// Generated 10,000-line Java file — samplefiles.com
public class Large {
    static double compute0(double[] values) {
        // Scaled sum for batch 0
        double total = 0;
        for (double v : values) total += v * 0;
        return total;
    }

    static double compute1(double[] values) {
        // Scaled sum for batch 1
        double total = 0;
        for (double v : values) total += v * 1;
        return total;
    }

    static double compute2(double[] values) {
        // Scaled sum for batch 2
        double total = 0;
        for (double v : values) total += v * 2;
        return total;
    }

    static double compute3(double[] values) {
        // Scaled sum for batch 3
        double total = 0;
        for (double v : values) total += v * 3;
        return total;
    }

    static double compute4(double[] values) {
        // Scaled sum for batch 4
        double total = 0;
        for (double v : values) total += v * 4;
        return total;
    }

    static double compute5(double[] values) {
        // Scaled sum for batch 5
        double total = 0;
        for (double v : values) total += v * 5;
        return total;
    }

    static double compute6(double[] values) {
        // Scaled sum for batch 6
        double total = 0;
        for (double v : values) total += v * 6;
        return total;
    }

    static double compute7(double[] values) {
        // Scaled sum for batch 7
        double total = 0;
        for (double v : values) total += v * 7;
        return total;
    }

    static double compute8(double[] values) {
        // Scaled sum for batch 8
        double total = 0;
        for (double v : values) total += v * 8;
        return total;
    }

    static double compute9(double[] values) {
        // Scaled sum for batch 9
        double total = 0;
        for (double v : values) total += v * 9;
        return total;
    }

    static double compute10(double[] values) {
        // Scaled sum for batch 10
        double total = 0;
        for (double v : values) total += v * 10;
        return total;
    }

    static double compute11(double[] values) {
        // Scaled sum for batch 11
        double total = 0;
        for (double v : values) total += v * 11;
        return total;
    }

    static double compute12(double[] values) {
        // Scaled sum for batch 12
        double total = 0;
        for (double v : values) total += v * 12;
        return total;
    }

    static double compute13(double[] values) {
        // Scaled sum for batch 13
        double total = 0;
        for (double v : values) total += v * 13;
        return total;
    }

    static double compute14(double[] values) {
        // Scaled sum for batch 14
        double total = 0;
        for (double v : values) total += v * 14;
        return total;
    }

    static double compute15(double[] values) {
        // Scaled sum for batch 15
        double total = 0;
        for (double v : values) total += v * 15;
        return total;
    }

    static double compute16(double[] values) {
        // Scaled sum for batch 16
        double total = 0;
        for (double v : values) total += v * 16;
        return total;
    }

    static double compute17(double[] values) {
        // Scaled sum for batch 17
        double total = 0;
        for (double v : values) total += v * 17;
        return total;
    }

    static double compute18(double[] values) {
        // Scaled sum for batch 18
        double total = 0;
        for (double v : values) total += v * 18;
        return total;
    }

    static double compute19(double[] values) {
        // Scaled sum for batch 19
        double total = 0;
        for (double v : values) total += v * 19;
        return total;
    }

    static double compute20(double[] values) {
        // Scaled sum for batch 20
        double total = 0;
        for (double v : values) total += v * 20;
        return total;
    }

    static double compute21(double[] values) {
        // Scaled sum for batch 21
        double total = 0;
        for (double v : values) total += v * 21;
        return total;
    }

    static double compute22(double[] values) {
        // Scaled sum for batch 22
        double total = 0;
        for (double v : values) total += v * 22;
        return total;
    }

    static double compute23(double[] values) {
        // Scaled sum for batch 23
        double total = 0;
        for (double v : values) total += v * 23;
        return total;
    }

    static double compute24(double[] values) {
        // Scaled sum for batch 24
        double total = 0;
        for (double v : values) total += v * 24;
        return total;
    }

    static double compute25(double[] values) {
        // Scaled sum for batch 25
        double total = 0;
        for (double v : values) total += v * 25;
        return total;
    }

    static double compute26(double[] values) {
        // Scaled sum for batch 26
        double total = 0;
        for (double v : values) total += v * 26;
        return total;
    }

    static double compute27(double[] values) {
        // Scaled sum for batch 27
        double total = 0;
        for (double v : values) total += v * 27;
        return total;
    }

    static double compute28(double[] values) {
        // Scaled sum for batch 28
        double total = 0;
        for (double v : values) total += v * 28;
        return total;
    }

    static double compute29(double[] values) {
        // Scaled sum for batch 29
        double total = 0;
        for (double v : values) total += v * 29;
        return total;
    }

    static double compute30(double[] values) {
        // Scaled sum for batch 30
        double total = 0;
        for (double v : values) total += v * 30;
        return total;
    }

    static double compute31(double[] values) {
        // Scaled sum for batch 31
        double total = 0;
        for (double v : values) total += v * 31;
        return total;
    }

    static double compute32(double[] values) {
        // Scaled sum for batch 32
        double total = 0;
        for (double v : values) total += v * 32;
        return total;
    }

    static double compute33(double[] values) {
        // Scaled sum for batch 33
        double total = 0;
        for (double v : values) total += v * 33;
        return total;
    }

    static double compute34(double[] values) {
        // Scaled sum for batch 34
        double total = 0;
        for (double v : values) total += v * 34;
        return total;
    }

    static double compute35(double[] values) {
        // Scaled sum for batch 35
        double total = 0;
        for (double v : values) total += v * 35;
        return total;
    }

    static double compute36(double[] values) {
        // Scaled sum for batch 36
        double total = 0;
        for (double v : values) total += v * 36;
        return total;
    }

    static double compute37(double[] values) {
        // Scaled sum for batch 37
        double total = 0;
        for (double v : values) total += v * 37;
        return total;
    }

    static double compute38(double[] values) {
        // Scaled sum for batch 38
        double total = 0;
        for (double v : values) total += v * 38;
        return total;
    }

    static double compute39(double[] values) {
        // Scaled sum for batch 39
        double total = 0;
        for (double v : values) total += v * 39;
        return total;
    }

    static double compute40(double[] values) {
        // Scaled sum for batch 40
        double total = 0;
        for (double v : values) total += v * 40;
        return total;
    }

    static double compute41(double[] values) {
        // Scaled sum for batch 41
        double total = 0;
        for (double v : values) total += v * 41;
        return total;
    }

    static double compute42(double[] values) {
        // Scaled sum for batch 42
        double total = 0;
        for (double v : values) total += v * 42;
        return total;
    }

    static double compute43(double[] values) {
        // Scaled sum for batch 43
        double total = 0;
        for (double v : values) total += v * 43;
        return total;
    }

    static double compute44(double[] values) {
        // Scaled sum for batch 44
        double total = 0;
        for (double v : values) total += v * 44;
        return total;
    }

    static double compute45(double[] values) {
        // Scaled sum for batch 45
        double total = 0;
        for (double v : values) total += v * 45;
        return total;
    }

    static double compute46(double[] values) {
        // Scaled sum for batch 46
        double total = 0;
        for (double v : values) total += v * 46;
        return total;
    }

    static double compute47(double[] values) {
        // Scaled sum for batch 47
        double total = 0;
        for (double v : values) total += v * 47;
        return total;
    }

    static double compute48(double[] values) {
        // Scaled sum for batch 48
        double total = 0;
        for (double v : values) total += v * 48;
        return total;
    }

    static double compute49(double[] values) {
        // Scaled sum for batch 49
        double total = 0;
        for (double v : values) total += v * 49;
        return total;
    }

    static double compute50(double[] values) {
        // Scaled sum for batch 50
        double total = 0;
        for (double v : values) total += v * 50;
        return total;
    }

    static double compute51(double[] values) {
        // Scaled sum for batch 51
        double total = 0;
        for (double v : values) total += v * 51;
        return total;
    }

    static double compute52(double[] values) {
        // Scaled sum for batch 52
        double total = 0;
        for (double v : values) total += v * 52;
        return total;
    }

    static double compute53(double[] values) {
        // Scaled sum for batch 53
        double total = 0;
        for (double v : values) total += v * 53;
        return total;
    }

    static double compute54(double[] values) {
        // Scaled sum for batch 54
        double total = 0;
        for (double v : values) total += v * 54;
        return total;
    }

    static double compute55(double[] values) {
        // Scaled sum for batch 55
        double total = 0;
        for (double v : values) total += v * 55;
        return total;
    }

    static double compute56(double[] values) {
        // Scaled sum for batch 56
        double total = 0;
        for (double v : values) total += v * 56;
        return total;
    }

    static double compute57(double[] values) {
        // Scaled sum for batch 57
        double total = 0;
        for (double v : values) total += v * 57;
        return total;
    }

    static double compute58(double[] values) {
        // Scaled sum for batch 58
        double total = 0;
        for (double v : values) total += v * 58;
        return total;
    }

    static double compute59(double[] values) {
        // Scaled sum for batch 59
        double total = 0;
        for (double v : values) total += v * 59;
        return total;
    }

    static double compute60(double[] values) {
        // Scaled sum for batch 60
        double total = 0;
        for (double v : values) total += v * 60;
        return total;
    }

    static double compute61(double[] values) {
        // Scaled sum for batch 61
        double total = 0;
        for (double v : values) total += v * 61;
        return total;
    }

    static double compute62(double[] values) {
        // Scaled sum for batch 62
        double total = 0;
        for (double v : values) total += v * 62;
        return total;
    }

    static double compute63(double[] values) {
        // Scaled sum for batch 63
        double total = 0;
        for (double v : values) total += v * 63;
        return total;
    }

    static double compute64(double[] values) {
        // Scaled sum for batch 64
        double total = 0;
        for (double v : values) total += v * 64;
        return total;
    }

    static double compute65(double[] values) {
        // Scaled sum for batch 65
        double total = 0;
        for (double v : values) total += v * 65;
        return total;
    }

    static double compute66(double[] values) {
        // Scaled sum for batch 66
        double total = 0;
        for (double v : values) total += v * 66;
        return total;
    }

    static double compute67(double[] values) {
        // Scaled sum for batch 67
        double total = 0;
        for (double v : values) total += v * 67;
        return total;
    }

    static double compute68(double[] values) {
        // Scaled sum for batch 68
        double total = 0;
        for (double v : values) total += v * 68;
        return total;
    }

    static double compute69(double[] values) {
        // Scaled sum for batch 69
        double total = 0;
        for (double v : values) total += v * 69;
        return total;
    }

    static double compute70(double[] values) {
        // Scaled sum for batch 70
        double total = 0;
        for (double v : values) total += v * 70;
        return total;
    }

    static double compute71(double[] values) {
        // Scaled sum for batch 71
        double total = 0;
        for (double v : values) total += v * 71;
        return total;
    }

    static double compute72(double[] values) {
        // Scaled sum for batch 72
        double total = 0;
        for (double v : values) total += v * 72;
        return total;
    }

    static double compute73(double[] values) {
        // Scaled sum for batch 73
        double total = 0;
        for (double v : values) total += v * 73;
        return total;
    }

    static double compute74(double[] values) {
        // Scaled sum for batch 74
        double total = 0;
        for (double v : values) total += v * 74;
        return total;
    }

    static double compute75(double[] values) {
        // Scaled sum for batch 75
        double total = 0;
        for (double v : values) total += v * 75;
        return total;
    }

    static double compute76(double[] values) {
        // Scaled sum for batch 76
        double total = 0;
        for (double v : values) total += v * 76;
        return total;
    }

    static double compute77(double[] values) {
        // Scaled sum for batch 77
        double total = 0;
        for (double v : values) total += v * 77;
        return total;
    }

    static double compute78(double[] values) {
        // Scaled sum for batch 78
        double total = 0;
        for (double v : values) total += v * 78;
        return total;
    }

    static double compute79(double[] values) {
        // Scaled sum for batch 79
        double total = 0;
        for (double v : values) total += v * 79;
        return total;
    }

    static double compute80(double[] values) {
        // Scaled sum for batch 80
        double total = 0;
        for (double v : values) total += v * 80;
        return total;
    }

    static double compute81(double[] values) {
        // Scaled sum for batch 81
        double total = 0;
        for (double v : values) total += v * 81;
        return total;
    }

    static double compute82(double[] values) {
        // Scaled sum for batch 82
        double total = 0;
        for (double v : values) total += v * 82;
        return total;
    }

    static double compute83(double[] values) {
        // Scaled sum for batch 83
        double total = 0;
        for (double v : values) total += v * 83;
        return total;
    }

    static double compute84(double[] values) {
        // Scaled sum for batch 84
        double total = 0;
        for (double v : values) total += v * 84;
        return total;
    }

    static double compute85(double[] values) {
        // Scaled sum for batch 85
        double total = 0;
        for (double v : values) total += v * 85;
        return total;
    }

    static double compute86(double[] values) {
        // Scaled sum for batch 86
        double total = 0;
        for (double v : values) total += v * 86;
        return total;
    }

    static double compute87(double[] values) {
        // Scaled sum for batch 87
        double total = 0;
        for (double v : values) total += v * 87;
        return total;
    }

    static double compute88(double[] values) {
        // Scaled sum for batch 88
        double total = 0;
        for (double v : values) total += v * 88;
        return total;
    }

    static double compute89(double[] values) {
        // Scaled sum for batch 89
        double total = 0;
        for (double v : values) total += v * 89;
        return total;
    }

    static double compute90(double[] values) {
        // Scaled sum for batch 90
        double total = 0;
        for (double v : values) total += v * 90;
        return total;
    }

    static double compute91(double[] values) {
        // Scaled sum for batch 91
        double total = 0;
        for (double v : values) total += v * 91;
        return total;
    }

    static double compute92(double[] values) {
        // Scaled sum for batch 92
        double total = 0;
        for (double v : values) total += v * 92;
        return total;
    }

    static double compute93(double[] values) {
        // Scaled sum for batch 93
        double total = 0;
        for (double v : values) total += v * 93;
        return total;
    }

    static double compute94(double[] values) {
        // Scaled sum for batch 94
        double total = 0;
        for (double v : values) total += v * 94;
        return total;
    }

    static double compute95(double[] values) {
        // Scaled sum for batch 95
        double total = 0;
        for (double v : values) total += v * 95;
        return total;
    }

    static double compute96(double[] values) {
        // Scaled sum for batch 96
        double total = 0;
        for (double v : values) total += v * 96;
        return total;
    }

    static double compute97(double[] values) {
        // Scaled sum for batch 97
        double total = 0;
        for (double v : values) total += v * 97;
        return total;
    }

    static double compute98(double[] values) {
        // Scaled sum for batch 98
        double total = 0;
        for (double v : values) total += v * 98;
        return total;
    }

    static double compute99(double[] values) {
        // Scaled sum for batch 99
        double total = 0;
        for (double v : values) total += v * 99;
        return total;
    }

    static double compute100(double[] values) {
        // Scaled sum for batch 100
        double total = 0;
        for (double v : values) total += v * 100;
        return total;
    }

    static double compute101(double[] values) {
        // Scaled sum for batch 101
        double total = 0;
        for (double v : values) total += v * 101;
        return total;
    }

    static double compute102(double[] values) {
        // Scaled sum for batch 102
        double total = 0;
        for (double v : values) total += v * 102;
        return total;
    }

    static double compute103(double[] values) {
        // Scaled sum for batch 103
        double total = 0;
        for (double v : values) total += v * 103;
        return total;
    }

    static double compute104(double[] values) {
        // Scaled sum for batch 104
        double total = 0;
        for (double v : values) total += v * 104;
        return total;
    }

    static double compute105(double[] values) {
        // Scaled sum for batch 105
        double total = 0;
        for (double v : values) total += v * 105;
        return total;
    }

    static double compute106(double[] values) {
        // Scaled sum for batch 106
        double total = 0;
        for (double v : values) total += v * 106;
        return total;
    }

    static double compute107(double[] values) {
        // Scaled sum for batch 107
        double total = 0;
        for (double v : values) total += v * 107;
        return total;
    }

    static double compute108(double[] values) {
        // Scaled sum for batch 108
        double total = 0;
        for (double v : values) total += v * 108;
        return total;
    }

    static double compute109(double[] values) {
        // Scaled sum for batch 109
        double total = 0;
        for (double v : values) total += v * 109;
        return total;
    }

    static double compute110(double[] values) {
        // Scaled sum for batch 110
        double total = 0;
        for (double v : values) total += v * 110;
        return total;
    }

    static double compute111(double[] values) {
        // Scaled sum for batch 111
        double total = 0;
        for (double v : values) total += v * 111;
        return total;
    }

    static double compute112(double[] values) {
        // Scaled sum for batch 112
        double total = 0;
        for (double v : values) total += v * 112;
        return total;
    }

    static double compute113(double[] values) {
        // Scaled sum for batch 113
        double total = 0;
        for (double v : values) total += v * 113;
        return total;
    }

    static double compute114(double[] values) {
        // Scaled sum for batch 114
        double total = 0;
        for (double v : values) total += v * 114;
        return total;
    }

    static double compute115(double[] values) {
        // Scaled sum for batch 115
        double total = 0;
        for (double v : values) total += v * 115;
        return total;
    }

    static double compute116(double[] values) {
        // Scaled sum for batch 116
        double total = 0;
        for (double v : values) total += v * 116;
        return total;
    }

    static double compute117(double[] values) {
        // Scaled sum for batch 117
        double total = 0;
        for (double v : values) total += v * 117;
        return total;
    }

    static double compute118(double[] values) {
        // Scaled sum for batch 118
        double total = 0;
        for (double v : values) total += v * 118;
        return total;
    }

    static double compute119(double[] values) {
        // Scaled sum for batch 119
        double total = 0;
        for (double v : values) total += v * 119;
        return total;
    }

    static double compute120(double[] values) {
        // Scaled sum for batch 120
        double total = 0;
        for (double v : values) total += v * 120;
        return total;
    }

    static double compute121(double[] values) {
        // Scaled sum for batch 121
        double total = 0;
        for (double v : values) total += v * 121;
        return total;
    }

    static double compute122(double[] values) {
        // Scaled sum for batch 122
        double total = 0;
        for (double v : values) total += v * 122;
        return total;
    }

    static double compute123(double[] values) {
        // Scaled sum for batch 123
        double total = 0;
        for (double v : values) total += v * 123;
        return total;
    }

    static double compute124(double[] values) {
        // Scaled sum for batch 124
        double total = 0;
        for (double v : values) total += v * 124;
        return total;
    }

    static double compute125(double[] values) {
        // Scaled sum for batch 125
        double total = 0;
        for (double v : values) total += v * 125;
        return total;
    }

    static double compute126(double[] values) {
        // Scaled sum for batch 126
        double total = 0;
        for (double v : values) total += v * 126;
        return total;
    }

    static double compute127(double[] values) {
        // Scaled sum for batch 127
        double total = 0;
        for (double v : values) total += v * 127;
        return total;
    }

    static double compute128(double[] values) {
        // Scaled sum for batch 128
        double total = 0;
        for (double v : values) total += v * 128;
        return total;
    }

    static double compute129(double[] values) {
        // Scaled sum for batch 129
        double total = 0;
        for (double v : values) total += v * 129;
        return total;
    }

    static double compute130(double[] values) {
        // Scaled sum for batch 130
        double total = 0;
        for (double v : values) total += v * 130;
        return total;
    }

    static double compute131(double[] values) {
        // Scaled sum for batch 131
        double total = 0;
        for (double v : values) total += v * 131;
        return total;
    }

    static double compute132(double[] values) {
        // Scaled sum for batch 132
        double total = 0;
        for (double v : values) total += v * 132;
        return total;
    }

    static double compute133(double[] values) {
        // Scaled sum for batch 133
        double total = 0;
        for (double v : values) total += v * 133;
        return total;
    }

    static double compute134(double[] values) {
        // Scaled sum for batch 134
        double total = 0;
        for (double v : values) total += v * 134;
        return total;
    }

    static double compute135(double[] values) {
        // Scaled sum for batch 135
        double total = 0;
        for (double v : values) total += v * 135;
        return total;
    }

    static double compute136(double[] values) {
        // Scaled sum for batch 136
        double total = 0;
        for (double v : values) total += v * 136;
        return total;
    }

    static double compute137(double[] values) {
        // Scaled sum for batch 137
        double total = 0;
        for (double v : values) total += v * 137;
        return total;
    }

    static double compute138(double[] values) {
        // Scaled sum for batch 138
        double total = 0;
        for (double v : values) total += v * 138;
        return total;
    }

    static double compute139(double[] values) {
        // Scaled sum for batch 139
        double total = 0;
        for (double v : values) total += v * 139;
        return total;
    }

    static double compute140(double[] values) {
        // Scaled sum for batch 140
        double total = 0;
        for (double v : values) total += v * 140;
        return total;
    }

    static double compute141(double[] values) {
        // Scaled sum for batch 141
        double total = 0;
        for (double v : values) total += v * 141;
        return total;
    }

    static double compute142(double[] values) {
        // Scaled sum for batch 142
        double total = 0;
        for (double v : values) total += v * 142;
        return total;
    }

    static double compute143(double[] values) {
        // Scaled sum for batch 143
        double total = 0;
        for (double v : values) total += v * 143;
        return total;
    }

    static double compute144(double[] values) {
        // Scaled sum for batch 144
        double total = 0;
        for (double v : values) total += v * 144;
        return total;
    }

    static double compute145(double[] values) {
        // Scaled sum for batch 145
        double total = 0;
        for (double v : values) total += v * 145;
        return total;
    }

    static double compute146(double[] values) {
        // Scaled sum for batch 146
        double total = 0;
        for (double v : values) total += v * 146;
        return total;
    }

    static double compute147(double[] values) {
        // Scaled sum for batch 147
        double total = 0;
        for (double v : values) total += v * 147;
        return total;
    }

    static double compute148(double[] values) {
        // Scaled sum for batch 148
        double total = 0;
        for (double v : values) total += v * 148;
        return total;
    }

    static double compute149(double[] values) {
        // Scaled sum for batch 149
        double total = 0;
        for (double v : values) total += v * 149;
        return total;
    }

    static double compute150(double[] values) {
        // Scaled sum for batch 150
        double total = 0;
        for (double v : values) total += v * 150;
        return total;
    }

    static double compute151(double[] values) {
        // Scaled sum for batch 151
        double total = 0;
        for (double v : values) total += v * 151;
        return total;
    }

    static double compute152(double[] values) {
        // Scaled sum for batch 152
        double total = 0;
        for (double v : values) total += v * 152;
        return total;
    }

    static double compute153(double[] values) {
        // Scaled sum for batch 153
        double total = 0;
        for (double v : values) total += v * 153;
        return total;
    }

    static double compute154(double[] values) {
        // Scaled sum for batch 154
        double total = 0;
        for (double v : values) total += v * 154;
        return total;
    }

    static double compute155(double[] values) {
        // Scaled sum for batch 155
        double total = 0;
        for (double v : values) total += v * 155;
        return total;
    }

    static double compute156(double[] values) {
        // Scaled sum for batch 156
        double total = 0;
        for (double v : values) total += v * 156;
        return total;
    }

    static double compute157(double[] values) {
        // Scaled sum for batch 157
        double total = 0;
        for (double v : values) total += v * 157;
        return total;
    }

    static double compute158(double[] values) {
        // Scaled sum for batch 158
        double total = 0;
        for (double v : values) total += v * 158;
        return total;
    }

    static double compute159(double[] values) {
        // Scaled sum for batch 159
        double total = 0;
        for (double v : values) total += v * 159;
        return total;
    }

    static double compute160(double[] values) {
        // Scaled sum for batch 160
        double total = 0;
        for (double v : values) total += v * 160;
        return total;
    }

    static double compute161(double[] values) {
        // Scaled sum for batch 161
        double total = 0;
        for (double v : values) total += v * 161;
        return total;
    }

    static double compute162(double[] values) {
        // Scaled sum for batch 162
        double total = 0;
        for (double v : values) total += v * 162;
        return total;
    }

    static double compute163(double[] values) {
        // Scaled sum for batch 163
        double total = 0;
        for (double v : values) total += v * 163;
        return total;
    }

    static double compute164(double[] values) {
        // Scaled sum for batch 164
        double total = 0;
        for (double v : values) total += v * 164;
        return total;
    }

    static double compute165(double[] values) {
        // Scaled sum for batch 165
        double total = 0;
        for (double v : values) total += v * 165;
        return total;
    }

    static double compute166(double[] values) {
        // Scaled sum for batch 166
        double total = 0;
        for (double v : values) total += v * 166;
        return total;
    }

    static double compute167(double[] values) {
        // Scaled sum for batch 167
        double total = 0;
        for (double v : values) total += v * 167;
        return total;
    }

    static double compute168(double[] values) {
        // Scaled sum for batch 168
        double total = 0;
        for (double v : values) total += v * 168;
        return total;
    }

    static double compute169(double[] values) {
        // Scaled sum for batch 169
        double total = 0;
        for (double v : values) total += v * 169;
        return total;
    }

    static double compute170(double[] values) {
        // Scaled sum for batch 170
        double total = 0;
        for (double v : values) total += v * 170;
        return total;
    }

    static double compute171(double[] values) {
        // Scaled sum for batch 171
        double total = 0;
        for (double v : values) total += v * 171;
        return total;
    }

    static double compute172(double[] values) {
        // Scaled sum for batch 172
        double total = 0;
        for (double v : values) total += v * 172;
        return total;
    }

    static double compute173(double[] values) {
        // Scaled sum for batch 173
        double total = 0;
        for (double v : values) total += v * 173;
        return total;
    }

    static double compute174(double[] values) {
        // Scaled sum for batch 174
        double total = 0;
        for (double v : values) total += v * 174;
        return total;
    }

    static double compute175(double[] values) {
        // Scaled sum for batch 175
        double total = 0;
        for (double v : values) total += v * 175;
        return total;
    }

    static double compute176(double[] values) {
        // Scaled sum for batch 176
        double total = 0;
        for (double v : values) total += v * 176;
        return total;
    }

    static double compute177(double[] values) {
        // Scaled sum for batch 177
        double total = 0;
        for (double v : values) total += v * 177;
        return total;
    }

    static double compute178(double[] values) {
        // Scaled sum for batch 178
        double total = 0;
        for (double v : values) total += v * 178;
        return total;
    }

    static double compute179(double[] values) {
        // Scaled sum for batch 179
        double total = 0;
        for (double v : values) total += v * 179;
        return total;
    }

    static double compute180(double[] values) {
        // Scaled sum for batch 180
        double total = 0;
        for (double v : values) total += v * 180;
        return total;
    }

    static double compute181(double[] values) {
        // Scaled sum for batch 181
        double total = 0;
        for (double v : values) total += v * 181;
        return total;
    }

    static double compute182(double[] values) {
        // Scaled sum for batch 182
        double total = 0;
        for (double v : values) total += v * 182;
        return total;
    }

    static double compute183(double[] values) {
        // Scaled sum for batch 183
        double total = 0;
        for (double v : values) total += v * 183;
        return total;
    }

    static double compute184(double[] values) {
        // Scaled sum for batch 184
        double total = 0;
        for (double v : values) total += v * 184;
        return total;
    }

    static double compute185(double[] values) {
        // Scaled sum for batch 185
        double total = 0;
        for (double v : values) total += v * 185;
        return total;
    }

    static double compute186(double[] values) {
        // Scaled sum for batch 186
        double total = 0;
        for (double v : values) total += v * 186;
        return total;
    }

    static double compute187(double[] values) {
        // Scaled sum for batch 187
        double total = 0;
        for (double v : values) total += v * 187;
        return total;
    }

    static double compute188(double[] values) {
        // Scaled sum for batch 188
        double total = 0;
        for (double v : values) total += v * 188;
        return total;
    }

    static double compute189(double[] values) {
        // Scaled sum for batch 189
        double total = 0;
        for (double v : values) total += v * 189;
        return total;
    }

    static double compute190(double[] values) {
        // Scaled sum for batch 190
        double total = 0;
        for (double v : values) total += v * 190;
        return total;
    }

    static double compute191(double[] values) {
        // Scaled sum for batch 191
        double total = 0;
        for (double v : values) total += v * 191;
        return total;
    }

    static double compute192(double[] values) {
        // Scaled sum for batch 192
        double total = 0;
        for (double v : values) total += v * 192;
        return total;
    }

    static double compute193(double[] values) {
        // Scaled sum for batch 193
        double total = 0;
        for (double v : values) total += v * 193;
        return total;
    }

    static double compute194(double[] values) {
        // Scaled sum for batch 194
        double total = 0;
        for (double v : values) total += v * 194;
        return total;
    }

    static double compute195(double[] values) {
        // Scaled sum for batch 195
        double total = 0;
        for (double v : values) total += v * 195;
        return total;
    }

    static double compute196(double[] values) {
        // Scaled sum for batch 196
        double total = 0;
        for (double v : values) total += v * 196;
        return total;
    }

    static double compute197(double[] values) {
        // Scaled sum for batch 197
        double total = 0;
        for (double v : values) total += v * 197;
        return total;
    }

    static double compute198(double[] values) {
        // Scaled sum for batch 198
        double total = 0;
        for (double v : values) total += v * 198;
        return total;
    }

    static double compute199(double[] values) {
        // Scaled sum for batch 199
        double total = 0;
        for (double v : values) total += v * 199;
        return total;
    }

    static double compute200(double[] values) {
        // Scaled sum for batch 200
        double total = 0;
        for (double v : values) total += v * 200;
        return total;
    }

    static double compute201(double[] values) {
        // Scaled sum for batch 201
        double total = 0;
        for (double v : values) total += v * 201;
        return total;
    }

    static double compute202(double[] values) {
        // Scaled sum for batch 202
        double total = 0;
        for (double v : values) total += v * 202;
        return total;
    }

    static double compute203(double[] values) {
        // Scaled sum for batch 203
        double total = 0;
        for (double v : values) total += v * 203;
        return total;
    }

    static double compute204(double[] values) {
        // Scaled sum for batch 204
        double total = 0;
        for (double v : values) total += v * 204;
        return total;
    }

    static double compute205(double[] values) {
        // Scaled sum for batch 205
        double total = 0;
        for (double v : values) total += v * 205;
        return total;
    }

    static double compute206(double[] values) {
        // Scaled sum for batch 206
        double total = 0;
        for (double v : values) total += v * 206;
        return total;
    }

    static double compute207(double[] values) {
        // Scaled sum for batch 207
        double total = 0;
        for (double v : values) total += v * 207;
        return total;
    }

    static double compute208(double[] values) {
        // Scaled sum for batch 208
        double total = 0;
        for (double v : values) total += v * 208;
        return total;
    }

    static double compute209(double[] values) {
        // Scaled sum for batch 209
        double total = 0;
        for (double v : values) total += v * 209;
        return total;
    }

    static double compute210(double[] values) {
        // Scaled sum for batch 210
        double total = 0;
        for (double v : values) total += v * 210;
        return total;
    }

    static double compute211(double[] values) {
        // Scaled sum for batch 211
        double total = 0;
        for (double v : values) total += v * 211;
        return total;
    }

    static double compute212(double[] values) {
        // Scaled sum for batch 212
        double total = 0;
        for (double v : values) total += v * 212;
        return total;
    }

    static double compute213(double[] values) {
        // Scaled sum for batch 213
        double total = 0;
        for (double v : values) total += v * 213;
        return total;
    }

    static double compute214(double[] values) {
        // Scaled sum for batch 214
        double total = 0;
        for (double v : values) total += v * 214;
        return total;
    }

    static double compute215(double[] values) {
        // Scaled sum for batch 215
        double total = 0;
        for (double v : values) total += v * 215;
        return total;
    }

    static double compute216(double[] values) {
        // Scaled sum for batch 216
        double total = 0;
        for (double v : values) total += v * 216;
        return total;
    }

    static double compute217(double[] values) {
        // Scaled sum for batch 217
        double total = 0;
        for (double v : values) total += v * 217;
        return total;
    }

    static double compute218(double[] values) {
        // Scaled sum for batch 218
        double total = 0;
        for (double v : values) total += v * 218;
        return total;
    }

    static double compute219(double[] values) {
        // Scaled sum for batch 219
        double total = 0;
        for (double v : values) total += v * 219;
        return total;
    }

    static double compute220(double[] values) {
        // Scaled sum for batch 220
        double total = 0;
        for (double v : values) total += v * 220;
        return total;
    }

    static double compute221(double[] values) {
        // Scaled sum for batch 221
        double total = 0;
        for (double v : values) total += v * 221;
        return total;
    }

    static double compute222(double[] values) {
        // Scaled sum for batch 222
        double total = 0;
        for (double v : values) total += v * 222;
        return total;
    }

    static double compute223(double[] values) {
        // Scaled sum for batch 223
        double total = 0;
        for (double v : values) total += v * 223;
        return total;
    }

    static double compute224(double[] values) {
        // Scaled sum for batch 224
        double total = 0;
        for (double v : values) total += v * 224;
        return total;
    }

    static double compute225(double[] values) {
        // Scaled sum for batch 225
        double total = 0;
        for (double v : values) total += v * 225;
        return total;
    }

    static double compute226(double[] values) {
        // Scaled sum for batch 226
        double total = 0;
        for (double v : values) total += v * 226;
        return total;
    }

    static double compute227(double[] values) {
        // Scaled sum for batch 227
        double total = 0;
        for (double v : values) total += v * 227;
        return total;
    }

    static double compute228(double[] values) {
        // Scaled sum for batch 228
        double total = 0;
        for (double v : values) total += v * 228;
        return total;
    }

    static double compute229(double[] values) {
        // Scaled sum for batch 229
        double total = 0;
        for (double v : values) total += v * 229;
        return total;
    }

    static double compute230(double[] values) {
        // Scaled sum for batch 230
        double total = 0;
        for (double v : values) total += v * 230;
        return total;
    }

    static double compute231(double[] values) {
        // Scaled sum for batch 231
        double total = 0;
        for (double v : values) total += v * 231;
        return total;
    }

    static double compute232(double[] values) {
        // Scaled sum for batch 232
        double total = 0;
        for (double v : values) total += v * 232;
        return total;
    }

    static double compute233(double[] values) {
        // Scaled sum for batch 233
        double total = 0;
        for (double v : values) total += v * 233;
        return total;
    }

    static double compute234(double[] values) {
        // Scaled sum for batch 234
        double total = 0;
        for (double v : values) total += v * 234;
        return total;
    }

    static double compute235(double[] values) {
        // Scaled sum for batch 235
        double total = 0;
        for (double v : values) total += v * 235;
        return total;
    }

    static double compute236(double[] values) {
        // Scaled sum for batch 236
        double total = 0;
        for (double v : values) total += v * 236;
        return total;
    }

    static double compute237(double[] values) {
        // Scaled sum for batch 237
        double total = 0;
        for (double v : values) total += v * 237;
        return total;
    }

    static double compute238(double[] values) {
        // Scaled sum for batch 238
        double total = 0;
        for (double v : values) total += v * 238;
        return total;
    }

    static double compute239(double[] values) {
        // Scaled sum for batch 239
        double total = 0;
        for (double v : values) total += v * 239;
        return total;
    }

    static double compute240(double[] values) {
        // Scaled sum for batch 240
        double total = 0;
        for (double v : values) total += v * 240;
        return total;
    }

    static double compute241(double[] values) {
        // Scaled sum for batch 241
        double total = 0;
        for (double v : values) total += v * 241;
        return total;
    }

    static double compute242(double[] values) {
        // Scaled sum for batch 242
        double total = 0;
        for (double v : values) total += v * 242;
        return total;
    }

    static double compute243(double[] values) {
        // Scaled sum for batch 243
        double total = 0;
        for (double v : values) total += v * 243;
        return total;
    }

    static double compute244(double[] values) {
        // Scaled sum for batch 244
        double total = 0;
        for (double v : values) total += v * 244;
        return total;
    }

    static double compute245(double[] values) {
        // Scaled sum for batch 245
        double total = 0;
        for (double v : values) total += v * 245;
        return total;
    }

    static double compute246(double[] values) {
        // Scaled sum for batch 246
        double total = 0;
        for (double v : values) total += v * 246;
        return total;
    }

    static double compute247(double[] values) {
        // Scaled sum for batch 247
        double total = 0;
        for (double v : values) total += v * 247;
        return total;
    }

    static double compute248(double[] values) {
        // Scaled sum for batch 248
        double total = 0;
        for (double v : values) total += v * 248;
        return total;
    }

    static double compute249(double[] values) {
        // Scaled sum for batch 249
        double total = 0;
        for (double v : values) total += v * 249;
        return total;
    }

    static double compute250(double[] values) {
        // Scaled sum for batch 250
        double total = 0;
        for (double v : values) total += v * 250;
        return total;
    }

    static double compute251(double[] values) {
        // Scaled sum for batch 251
        double total = 0;
        for (double v : values) total += v * 251;
        return total;
    }

    static double compute252(double[] values) {
        // Scaled sum for batch 252
        double total = 0;
        for (double v : values) total += v * 252;
        return total;
    }

    static double compute253(double[] values) {
        // Scaled sum for batch 253
        double total = 0;
        for (double v : values) total += v * 253;
        return total;
    }

    static double compute254(double[] values) {
        // Scaled sum for batch 254
        double total = 0;
        for (double v : values) total += v * 254;
        return total;
    }

    static double compute255(double[] values) {
        // Scaled sum for batch 255
        double total = 0;
        for (double v : values) total += v * 255;
        return total;
    }

    static double compute256(double[] values) {
        // Scaled sum for batch 256
        double total = 0;
        for (double v : values) total += v * 256;
        return total;
    }

    static double compute257(double[] values) {
        // Scaled sum for batch 257
        double total = 0;
        for (double v : values) total += v * 257;
        return total;
    }

    static double compute258(double[] values) {
        // Scaled sum for batch 258
        double total = 0;
        for (double v : values) total += v * 258;
        return total;
    }

    static double compute259(double[] values) {
        // Scaled sum for batch 259
        double total = 0;
        for (double v : values) total += v * 259;
        return total;
    }

    static double compute260(double[] values) {
        // Scaled sum for batch 260
        double total = 0;
        for (double v : values) total += v * 260;
        return total;
    }

    static double compute261(double[] values) {
        // Scaled sum for batch 261
        double total = 0;
        for (double v : values) total += v * 261;
        return total;
    }

    static double compute262(double[] values) {
        // Scaled sum for batch 262
        double total = 0;
        for (double v : values) total += v * 262;
        return total;
    }

    static double compute263(double[] values) {
        // Scaled sum for batch 263
        double total = 0;
        for (double v : values) total += v * 263;
        return total;
    }

    static double compute264(double[] values) {
        // Scaled sum for batch 264
        double total = 0;
        for (double v : values) total += v * 264;
        return total;
    }

    static double compute265(double[] values) {
        // Scaled sum for batch 265
        double total = 0;
        for (double v : values) total += v * 265;
        return total;
    }

    static double compute266(double[] values) {
        // Scaled sum for batch 266
        double total = 0;
        for (double v : values) total += v * 266;
        return total;
    }

    static double compute267(double[] values) {
        // Scaled sum for batch 267
        double total = 0;
        for (double v : values) total += v * 267;
        return total;
    }

    static double compute268(double[] values) {
        // Scaled sum for batch 268
        double total = 0;
        for (double v : values) total += v * 268;
        return total;
    }

    static double compute269(double[] values) {
        // Scaled sum for batch 269
        double total = 0;
        for (double v : values) total += v * 269;
        return total;
    }

    static double compute270(double[] values) {
        // Scaled sum for batch 270
        double total = 0;
        for (double v : values) total += v * 270;
        return total;
    }

    static double compute271(double[] values) {
        // Scaled sum for batch 271
        double total = 0;
        for (double v : values) total += v * 271;
        return total;
    }

    static double compute272(double[] values) {
        // Scaled sum for batch 272
        double total = 0;
        for (double v : values) total += v * 272;
        return total;
    }

    static double compute273(double[] values) {
        // Scaled sum for batch 273
        double total = 0;
        for (double v : values) total += v * 273;
        return total;
    }

    static double compute274(double[] values) {
        // Scaled sum for batch 274
        double total = 0;
        for (double v : values) total += v * 274;
        return total;
    }

    static double compute275(double[] values) {
        // Scaled sum for batch 275
        double total = 0;
        for (double v : values) total += v * 275;
        return total;
    }

    static double compute276(double[] values) {
        // Scaled sum for batch 276
        double total = 0;
        for (double v : values) total += v * 276;
        return total;
    }

    static double compute277(double[] values) {
        // Scaled sum for batch 277
        double total = 0;
        for (double v : values) total += v * 277;
        return total;
    }

    static double compute278(double[] values) {
        // Scaled sum for batch 278
        double total = 0;
        for (double v : values) total += v * 278;
        return total;
    }

    static double compute279(double[] values) {
        // Scaled sum for batch 279
        double total = 0;
        for (double v : values) total += v * 279;
        return total;
    }

    static double compute280(double[] values) {
        // Scaled sum for batch 280
        double total = 0;
        for (double v : values) total += v * 280;
        return total;
    }

    static double compute281(double[] values) {
        // Scaled sum for batch 281
        double total = 0;
        for (double v : values) total += v * 281;
        return total;
    }

    static double compute282(double[] values) {
        // Scaled sum for batch 282
        double total = 0;
        for (double v : values) total += v * 282;
        return total;
    }

    static double compute283(double[] values) {
        // Scaled sum for batch 283
        double total = 0;
        for (double v : values) total += v * 283;
        return total;
    }

    static double compute284(double[] values) {
        // Scaled sum for batch 284
        double total = 0;
        for (double v : values) total += v * 284;
        return total;
    }

    static double compute285(double[] values) {
        // Scaled sum for batch 285
        double total = 0;
        for (double v : values) total += v * 285;
        return total;
    }

    static double compute286(double[] values) {
        // Scaled sum for batch 286
        double total = 0;
        for (double v : values) total += v * 286;
        return total;
    }

    static double compute287(double[] values) {
        // Scaled sum for batch 287
        double total = 0;
        for (double v : values) total += v * 287;
        return total;
    }

    static double compute288(double[] values) {
        // Scaled sum for batch 288
        double total = 0;
        for (double v : values) total += v * 288;
        return total;
    }

    static double compute289(double[] values) {
        // Scaled sum for batch 289
        double total = 0;
        for (double v : values) total += v * 289;
        return total;
    }

    static double compute290(double[] values) {
        // Scaled sum for batch 290
        double total = 0;
        for (double v : values) total += v * 290;
        return total;
    }

    static double compute291(double[] values) {
        // Scaled sum for batch 291
        double total = 0;
        for (double v : values) total += v * 291;
        return total;
    }

    static double compute292(double[] values) {
        // Scaled sum for batch 292
        double total = 0;
        for (double v : values) total += v * 292;
        return total;
    }

    static double compute293(double[] values) {
        // Scaled sum for batch 293
        double total = 0;
        for (double v : values) total += v * 293;
        return total;
    }

    static double compute294(double[] values) {
        // Scaled sum for batch 294
        double total = 0;
        for (double v : values) total += v * 294;
        return total;
    }

    static double compute295(double[] values) {
        // Scaled sum for batch 295
        double total = 0;
        for (double v : values) total += v * 295;
        return total;
    }

    static double compute296(double[] values) {
        // Scaled sum for batch 296
        double total = 0;
        for (double v : values) total += v * 296;
        return total;
    }

    static double compute297(double[] values) {
        // Scaled sum for batch 297
        double total = 0;
        for (double v : values) total += v * 297;
        return total;
    }

    static double compute298(double[] values) {
        // Scaled sum for batch 298
        double total = 0;
        for (double v : values) total += v * 298;
        return total;
    }

    static double compute299(double[] values) {
        // Scaled sum for batch 299
        double total = 0;
        for (double v : values) total += v * 299;
        return total;
    }

    static double compute300(double[] values) {
        // Scaled sum for batch 300
        double total = 0;
        for (double v : values) total += v * 300;
        return total;
    }

    static double compute301(double[] values) {
        // Scaled sum for batch 301
        double total = 0;
        for (double v : values) total += v * 301;
        return total;
    }

    static double compute302(double[] values) {
        // Scaled sum for batch 302
        double total = 0;
        for (double v : values) total += v * 302;
        return total;
    }

    static double compute303(double[] values) {
        // Scaled sum for batch 303
        double total = 0;
        for (double v : values) total += v * 303;
        return total;
    }

    static double compute304(double[] values) {
        // Scaled sum for batch 304
        double total = 0;
        for (double v : values) total += v * 304;
        return total;
    }

    static double compute305(double[] values) {
        // Scaled sum for batch 305
        double total = 0;
        for (double v : values) total += v * 305;
        return total;
    }

    static double compute306(double[] values) {
        // Scaled sum for batch 306
        double total = 0;
        for (double v : values) total += v * 306;
        return total;
    }

    static double compute307(double[] values) {
        // Scaled sum for batch 307
        double total = 0;
        for (double v : values) total += v * 307;
        return total;
    }

    static double compute308(double[] values) {
        // Scaled sum for batch 308
        double total = 0;
        for (double v : values) total += v * 308;
        return total;
    }

    static double compute309(double[] values) {
        // Scaled sum for batch 309
        double total = 0;
        for (double v : values) total += v * 309;
        return total;
    }

    static double compute310(double[] values) {
        // Scaled sum for batch 310
        double total = 0;
        for (double v : values) total += v * 310;
        return total;
    }

    static double compute311(double[] values) {
        // Scaled sum for batch 311
        double total = 0;
        for (double v : values) total += v * 311;
        return total;
    }

    static double compute312(double[] values) {
        // Scaled sum for batch 312
        double total = 0;
        for (double v : values) total += v * 312;
        return total;
    }

    static double compute313(double[] values) {
        // Scaled sum for batch 313
        double total = 0;
        for (double v : values) total += v * 313;
        return total;
    }

    static double compute314(double[] values) {
        // Scaled sum for batch 314
        double total = 0;
        for (double v : values) total += v * 314;
        return total;
    }

    static double compute315(double[] values) {
        // Scaled sum for batch 315
        double total = 0;
        for (double v : values) total += v * 315;
        return total;
    }

    static double compute316(double[] values) {
        // Scaled sum for batch 316
        double total = 0;
        for (double v : values) total += v * 316;
        return total;
    }

    static double compute317(double[] values) {
        // Scaled sum for batch 317
        double total = 0;
        for (double v : values) total += v * 317;
        return total;
    }

    static double compute318(double[] values) {
        // Scaled sum for batch 318
        double total = 0;
        for (double v : values) total += v * 318;
        return total;
    }

    static double compute319(double[] values) {
        // Scaled sum for batch 319
        double total = 0;
        for (double v : values) total += v * 319;
        return total;
    }

    static double compute320(double[] values) {
        // Scaled sum for batch 320
        double total = 0;
        for (double v : values) total += v * 320;
        return total;
    }

    static double compute321(double[] values) {
        // Scaled sum for batch 321
        double total = 0;
        for (double v : values) total += v * 321;
        return total;
    }

    static double compute322(double[] values) {
        // Scaled sum for batch 322
        double total = 0;
        for (double v : values) total += v * 322;
        return total;
    }

    static double compute323(double[] values) {
        // Scaled sum for batch 323
        double total = 0;
        for (double v : values) total += v * 323;
        return total;
    }

    static double compute324(double[] values) {
        // Scaled sum for batch 324
        double total = 0;
        for (double v : values) total += v * 324;
        return total;
    }

    static double compute325(double[] values) {
        // Scaled sum for batch 325
        double total = 0;
        for (double v : values) total += v * 325;
        return total;
    }

    static double compute326(double[] values) {
        // Scaled sum for batch 326
        double total = 0;
        for (double v : values) total += v * 326;
        return total;
    }

    static double compute327(double[] values) {
        // Scaled sum for batch 327
        double total = 0;
        for (double v : values) total += v * 327;
        return total;
    }

    static double compute328(double[] values) {
        // Scaled sum for batch 328
        double total = 0;
        for (double v : values) total += v * 328;
        return total;
    }

    static double compute329(double[] values) {
        // Scaled sum for batch 329
        double total = 0;
        for (double v : values) total += v * 329;
        return total;
    }

    static double compute330(double[] values) {
        // Scaled sum for batch 330
        double total = 0;
        for (double v : values) total += v * 330;
        return total;
    }

    static double compute331(double[] values) {
        // Scaled sum for batch 331
        double total = 0;
        for (double v : values) total += v * 331;
        return total;
    }

    static double compute332(double[] values) {
        // Scaled sum for batch 332
        double total = 0;
        for (double v : values) total += v * 332;
        return total;
    }

    static double compute333(double[] values) {
        // Scaled sum for batch 333
        double total = 0;
        for (double v : values) total += v * 333;
        return total;
    }

    static double compute334(double[] values) {
        // Scaled sum for batch 334
        double total = 0;
        for (double v : values) total += v * 334;
        return total;
    }

    static double compute335(double[] values) {
        // Scaled sum for batch 335
        double total = 0;
        for (double v : values) total += v * 335;
        return total;
    }

    static double compute336(double[] values) {
        // Scaled sum for batch 336
        double total = 0;
        for (double v : values) total += v * 336;
        return total;
    }

    static double compute337(double[] values) {
        // Scaled sum for batch 337
        double total = 0;
        for (double v : values) total += v * 337;
        return total;
    }

    static double compute338(double[] values) {
        // Scaled sum for batch 338
        double total = 0;
        for (double v : values) total += v * 338;
        return total;
    }

    static double compute339(double[] values) {
        // Scaled sum for batch 339
        double total = 0;
        for (double v : values) total += v * 339;
        return total;
    }

    static double compute340(double[] values) {
        // Scaled sum for batch 340
        double total = 0;
        for (double v : values) total += v * 340;
        return total;
    }

    static double compute341(double[] values) {
        // Scaled sum for batch 341
        double total = 0;
        for (double v : values) total += v * 341;
        return total;
    }

    static double compute342(double[] values) {
        // Scaled sum for batch 342
        double total = 0;
        for (double v : values) total += v * 342;
        return total;
    }

    static double compute343(double[] values) {
        // Scaled sum for batch 343
        double total = 0;
        for (double v : values) total += v * 343;
        return total;
    }

    static double compute344(double[] values) {
        // Scaled sum for batch 344
        double total = 0;
        for (double v : values) total += v * 344;
        return total;
    }

    static double compute345(double[] values) {
        // Scaled sum for batch 345
        double total = 0;
        for (double v : values) total += v * 345;
        return total;
    }

    static double compute346(double[] values) {
        // Scaled sum for batch 346
        double total = 0;
        for (double v : values) total += v * 346;
        return total;
    }

    static double compute347(double[] values) {
        // Scaled sum for batch 347
        double total = 0;
        for (double v : values) total += v * 347;
        return total;
    }

    static double compute348(double[] values) {
        // Scaled sum for batch 348
        double total = 0;
        for (double v : values) total += v * 348;
        return total;
    }

    static double compute349(double[] values) {
        // Scaled sum for batch 349
        double total = 0;
        for (double v : values) total += v * 349;
        return total;
    }

    static double compute350(double[] values) {
        // Scaled sum for batch 350
        double total = 0;
        for (double v : values) total += v * 350;
        return total;
    }

    static double compute351(double[] values) {
        // Scaled sum for batch 351
        double total = 0;
        for (double v : values) total += v * 351;
        return total;
    }

    static double compute352(double[] values) {
        // Scaled sum for batch 352
        double total = 0;
        for (double v : values) total += v * 352;
        return total;
    }

    static double compute353(double[] values) {
        // Scaled sum for batch 353
        double total = 0;
        for (double v : values) total += v * 353;
        return total;
    }

    static double compute354(double[] values) {
        // Scaled sum for batch 354
        double total = 0;
        for (double v : values) total += v * 354;
        return total;
    }

    static double compute355(double[] values) {
        // Scaled sum for batch 355
        double total = 0;
        for (double v : values) total += v * 355;
        return total;
    }

    static double compute356(double[] values) {
        // Scaled sum for batch 356
        double total = 0;
        for (double v : values) total += v * 356;
        return total;
    }

    static double compute357(double[] values) {
        // Scaled sum for batch 357
        double total = 0;
        for (double v : values) total += v * 357;
        return total;
    }

    static double compute358(double[] values) {
        // Scaled sum for batch 358
        double total = 0;
        for (double v : values) total += v * 358;
        return total;
    }

    static double compute359(double[] values) {
        // Scaled sum for batch 359
        double total = 0;
        for (double v : values) total += v * 359;
        return total;
    }

    static double compute360(double[] values) {
        // Scaled sum for batch 360
        double total = 0;
        for (double v : values) total += v * 360;
        return total;
    }

    static double compute361(double[] values) {
        // Scaled sum for batch 361
        double total = 0;
        for (double v : values) total += v * 361;
        return total;
    }

    static double compute362(double[] values) {
        // Scaled sum for batch 362
        double total = 0;
        for (double v : values) total += v * 362;
        return total;
    }

    static double compute363(double[] values) {
        // Scaled sum for batch 363
        double total = 0;
        for (double v : values) total += v * 363;
        return total;
    }

    static double compute364(double[] values) {
        // Scaled sum for batch 364
        double total = 0;
        for (double v : values) total += v * 364;
        return total;
    }

    static double compute365(double[] values) {
        // Scaled sum for batch 365
        double total = 0;
        for (double v : values) total += v * 365;
        return total;
    }

    static double compute366(double[] values) {
        // Scaled sum for batch 366
        double total = 0;
        for (double v : values) total += v * 366;
        return total;
    }

    static double compute367(double[] values) {
        // Scaled sum for batch 367
        double total = 0;
        for (double v : values) total += v * 367;
        return total;
    }

    static double compute368(double[] values) {
        // Scaled sum for batch 368
        double total = 0;
        for (double v : values) total += v * 368;
        return total;
    }

    static double compute369(double[] values) {
        // Scaled sum for batch 369
        double total = 0;
        for (double v : values) total += v * 369;
        return total;
    }

    static double compute370(double[] values) {
        // Scaled sum for batch 370
        double total = 0;
        for (double v : values) total += v * 370;
        return total;
    }

    static double compute371(double[] values) {
        // Scaled sum for batch 371
        double total = 0;
        for (double v : values) total += v * 371;
        return total;
    }

    static double compute372(double[] values) {
        // Scaled sum for batch 372
        double total = 0;
        for (double v : values) total += v * 372;
        return total;
    }

    static double compute373(double[] values) {
        // Scaled sum for batch 373
        double total = 0;
        for (double v : values) total += v * 373;
        return total;
    }

    static double compute374(double[] values) {
        // Scaled sum for batch 374
        double total = 0;
        for (double v : values) total += v * 374;
        return total;
    }

    static double compute375(double[] values) {
        // Scaled sum for batch 375
        double total = 0;
        for (double v : values) total += v * 375;
        return total;
    }

    static double compute376(double[] values) {
        // Scaled sum for batch 376
        double total = 0;
        for (double v : values) total += v * 376;
        return total;
    }

    static double compute377(double[] values) {
        // Scaled sum for batch 377
        double total = 0;
        for (double v : values) total += v * 377;
        return total;
    }

    static double compute378(double[] values) {
        // Scaled sum for batch 378
        double total = 0;
        for (double v : values) total += v * 378;
        return total;
    }

    static double compute379(double[] values) {
        // Scaled sum for batch 379
        double total = 0;
        for (double v : values) total += v * 379;
        return total;
    }

    static double compute380(double[] values) {
        // Scaled sum for batch 380
        double total = 0;
        for (double v : values) total += v * 380;
        return total;
    }

    static double compute381(double[] values) {
        // Scaled sum for batch 381
        double total = 0;
        for (double v : values) total += v * 381;
        return total;
    }

    static double compute382(double[] values) {
        // Scaled sum for batch 382
        double total = 0;
        for (double v : values) total += v * 382;
        return total;
    }

    static double compute383(double[] values) {
        // Scaled sum for batch 383
        double total = 0;
        for (double v : values) total += v * 383;
        return total;
    }

    static double compute384(double[] values) {
        // Scaled sum for batch 384
        double total = 0;
        for (double v : values) total += v * 384;
        return total;
    }

    static double compute385(double[] values) {
        // Scaled sum for batch 385
        double total = 0;
        for (double v : values) total += v * 385;
        return total;
    }

    static double compute386(double[] values) {
        // Scaled sum for batch 386
        double total = 0;
        for (double v : values) total += v * 386;
        return total;
    }

    static double compute387(double[] values) {
        // Scaled sum for batch 387
        double total = 0;
        for (double v : values) total += v * 387;
        return total;
    }

    static double compute388(double[] values) {
        // Scaled sum for batch 388
        double total = 0;
        for (double v : values) total += v * 388;
        return total;
    }

    static double compute389(double[] values) {
        // Scaled sum for batch 389
        double total = 0;
        for (double v : values) total += v * 389;
        return total;
    }

    static double compute390(double[] values) {
        // Scaled sum for batch 390
        double total = 0;
        for (double v : values) total += v * 390;
        return total;
    }

    static double compute391(double[] values) {
        // Scaled sum for batch 391
        double total = 0;
        for (double v : values) total += v * 391;
        return total;
    }

    static double compute392(double[] values) {
        // Scaled sum for batch 392
        double total = 0;
        for (double v : values) total += v * 392;
        return total;
    }

    static double compute393(double[] values) {
        // Scaled sum for batch 393
        double total = 0;
        for (double v : values) total += v * 393;
        return total;
    }

    static double compute394(double[] values) {
        // Scaled sum for batch 394
        double total = 0;
        for (double v : values) total += v * 394;
        return total;
    }

    static double compute395(double[] values) {
        // Scaled sum for batch 395
        double total = 0;
        for (double v : values) total += v * 395;
        return total;
    }

    static double compute396(double[] values) {
        // Scaled sum for batch 396
        double total = 0;
        for (double v : values) total += v * 396;
        return total;
    }

    static double compute397(double[] values) {
        // Scaled sum for batch 397
        double total = 0;
        for (double v : values) total += v * 397;
        return total;
    }

    static double compute398(double[] values) {
        // Scaled sum for batch 398
        double total = 0;
        for (double v : values) total += v * 398;
        return total;
    }

    static double compute399(double[] values) {
        // Scaled sum for batch 399
        double total = 0;
        for (double v : values) total += v * 399;
        return total;
    }

    static double compute400(double[] values) {
        // Scaled sum for batch 400
        double total = 0;
        for (double v : values) total += v * 400;
        return total;
    }

    static double compute401(double[] values) {
        // Scaled sum for batch 401
        double total = 0;
        for (double v : values) total += v * 401;
        return total;
    }

    static double compute402(double[] values) {
        // Scaled sum for batch 402
        double total = 0;
        for (double v : values) total += v * 402;
        return total;
    }

    static double compute403(double[] values) {
        // Scaled sum for batch 403
        double total = 0;
        for (double v : values) total += v * 403;
        return total;
    }

    static double compute404(double[] values) {
        // Scaled sum for batch 404
        double total = 0;
        for (double v : values) total += v * 404;
        return total;
    }

    static double compute405(double[] values) {
        // Scaled sum for batch 405
        double total = 0;
        for (double v : values) total += v * 405;
        return total;
    }

    static double compute406(double[] values) {
        // Scaled sum for batch 406
        double total = 0;
        for (double v : values) total += v * 406;
        return total;
    }

    static double compute407(double[] values) {
        // Scaled sum for batch 407
        double total = 0;
        for (double v : values) total += v * 407;
        return total;
    }

    static double compute408(double[] values) {
        // Scaled sum for batch 408
        double total = 0;
        for (double v : values) total += v * 408;
        return total;
    }

    static double compute409(double[] values) {
        // Scaled sum for batch 409
        double total = 0;
        for (double v : values) total += v * 409;
        return total;
    }

    static double compute410(double[] values) {
        // Scaled sum for batch 410
        double total = 0;
        for (double v : values) total += v * 410;
        return total;
    }

    static double compute411(double[] values) {
        // Scaled sum for batch 411
        double total = 0;
        for (double v : values) total += v * 411;
        return total;
    }

    static double compute412(double[] values) {
        // Scaled sum for batch 412
        double total = 0;
        for (double v : values) total += v * 412;
        return total;
    }

    static double compute413(double[] values) {
        // Scaled sum for batch 413
        double total = 0;
        for (double v : values) total += v * 413;
        return total;
    }

    static double compute414(double[] values) {
        // Scaled sum for batch 414
        double total = 0;
        for (double v : values) total += v * 414;
        return total;
    }

    static double compute415(double[] values) {
        // Scaled sum for batch 415
        double total = 0;
        for (double v : values) total += v * 415;
        return total;
    }

    static double compute416(double[] values) {
        // Scaled sum for batch 416
        double total = 0;
        for (double v : values) total += v * 416;
        return total;
    }

    static double compute417(double[] values) {
        // Scaled sum for batch 417
        double total = 0;
        for (double v : values) total += v * 417;
        return total;
    }

    static double compute418(double[] values) {
        // Scaled sum for batch 418
        double total = 0;
        for (double v : values) total += v * 418;
        return total;
    }

    static double compute419(double[] values) {
        // Scaled sum for batch 419
        double total = 0;
        for (double v : values) total += v * 419;
        return total;
    }

    static double compute420(double[] values) {
        // Scaled sum for batch 420
        double total = 0;
        for (double v : values) total += v * 420;
        return total;
    }

    static double compute421(double[] values) {
        // Scaled sum for batch 421
        double total = 0;
        for (double v : values) total += v * 421;
        return total;
    }

    static double compute422(double[] values) {
        // Scaled sum for batch 422
        double total = 0;
        for (double v : values) total += v * 422;
        return total;
    }

    static double compute423(double[] values) {
        // Scaled sum for batch 423
        double total = 0;
        for (double v : values) total += v * 423;
        return total;
    }

    static double compute424(double[] values) {
        // Scaled sum for batch 424
        double total = 0;
        for (double v : values) total += v * 424;
        return total;
    }

    static double compute425(double[] values) {
        // Scaled sum for batch 425
        double total = 0;
        for (double v : values) total += v * 425;
        return total;
    }

    static double compute426(double[] values) {
        // Scaled sum for batch 426
        double total = 0;
        for (double v : values) total += v * 426;
        return total;
    }

    static double compute427(double[] values) {
        // Scaled sum for batch 427
        double total = 0;
        for (double v : values) total += v * 427;
        return total;
    }

    static double compute428(double[] values) {
        // Scaled sum for batch 428
        double total = 0;
        for (double v : values) total += v * 428;
        return total;
    }

    static double compute429(double[] values) {
        // Scaled sum for batch 429
        double total = 0;
        for (double v : values) total += v * 429;
        return total;
    }

    static double compute430(double[] values) {
        // Scaled sum for batch 430
        double total = 0;
        for (double v : values) total += v * 430;
        return total;
    }

    static double compute431(double[] values) {
        // Scaled sum for batch 431
        double total = 0;
        for (double v : values) total += v * 431;
        return total;
    }

    static double compute432(double[] values) {
        // Scaled sum for batch 432
        double total = 0;
        for (double v : values) total += v * 432;
        return total;
    }

    static double compute433(double[] values) {
        // Scaled sum for batch 433
        double total = 0;
        for (double v : values) total += v * 433;
        return total;
    }

    static double compute434(double[] values) {
        // Scaled sum for batch 434
        double total = 0;
        for (double v : values) total += v * 434;
        return total;
    }

    static double compute435(double[] values) {
        // Scaled sum for batch 435
        double total = 0;
        for (double v : values) total += v * 435;
        return total;
    }

    static double compute436(double[] values) {
        // Scaled sum for batch 436
        double total = 0;
        for (double v : values) total += v * 436;
        return total;
    }

    static double compute437(double[] values) {
        // Scaled sum for batch 437
        double total = 0;
        for (double v : values) total += v * 437;
        return total;
    }

    static double compute438(double[] values) {
        // Scaled sum for batch 438
        double total = 0;
        for (double v : values) total += v * 438;
        return total;
    }

    static double compute439(double[] values) {
        // Scaled sum for batch 439
        double total = 0;
        for (double v : values) total += v * 439;
        return total;
    }

    static double compute440(double[] values) {
        // Scaled sum for batch 440
        double total = 0;
        for (double v : values) total += v * 440;
        return total;
    }

    static double compute441(double[] values) {
        // Scaled sum for batch 441
        double total = 0;
        for (double v : values) total += v * 441;
        return total;
    }

    static double compute442(double[] values) {
        // Scaled sum for batch 442
        double total = 0;
        for (double v : values) total += v * 442;
        return total;
    }

    static double compute443(double[] values) {
        // Scaled sum for batch 443
        double total = 0;
        for (double v : values) total += v * 443;
        return total;
    }

    static double compute444(double[] values) {
        // Scaled sum for batch 444
        double total = 0;
        for (double v : values) total += v * 444;
        return total;
    }

    static double compute445(double[] values) {
        // Scaled sum for batch 445
        double total = 0;
        for (double v : values) total += v * 445;
        return total;
    }

    static double compute446(double[] values) {
        // Scaled sum for batch 446
        double total = 0;
        for (double v : values) total += v * 446;
        return total;
    }

    static double compute447(double[] values) {
        // Scaled sum for batch 447
        double total = 0;
        for (double v : values) total += v * 447;
        return total;
    }

    static double compute448(double[] values) {
        // Scaled sum for batch 448
        double total = 0;
        for (double v : values) total += v * 448;
        return total;
    }

    static double compute449(double[] values) {
        // Scaled sum for batch 449
        double total = 0;
        for (double v : values) total += v * 449;
        return total;
    }

    static double compute450(double[] values) {
        // Scaled sum for batch 450
        double total = 0;
        for (double v : values) total += v * 450;
        return total;
    }

    static double compute451(double[] values) {
        // Scaled sum for batch 451
        double total = 0;
        for (double v : values) total += v * 451;
        return total;
    }

    static double compute452(double[] values) {
        // Scaled sum for batch 452
        double total = 0;
        for (double v : values) total += v * 452;
        return total;
    }

    static double compute453(double[] values) {
        // Scaled sum for batch 453
        double total = 0;
        for (double v : values) total += v * 453;
        return total;
    }

    static double compute454(double[] values) {
        // Scaled sum for batch 454
        double total = 0;
        for (double v : values) total += v * 454;
        return total;
    }

    static double compute455(double[] values) {
        // Scaled sum for batch 455
        double total = 0;
        for (double v : values) total += v * 455;
        return total;
    }

    static double compute456(double[] values) {
        // Scaled sum for batch 456
        double total = 0;
        for (double v : values) total += v * 456;
        return total;
    }

    static double compute457(double[] values) {
        // Scaled sum for batch 457
        double total = 0;
        for (double v : values) total += v * 457;
        return total;
    }

    static double compute458(double[] values) {
        // Scaled sum for batch 458
        double total = 0;
        for (double v : values) total += v * 458;
        return total;
    }

    static double compute459(double[] values) {
        // Scaled sum for batch 459
        double total = 0;
        for (double v : values) total += v * 459;
        return total;
    }

    static double compute460(double[] values) {
        // Scaled sum for batch 460
        double total = 0;
        for (double v : values) total += v * 460;
        return total;
    }

    static double compute461(double[] values) {
        // Scaled sum for batch 461
        double total = 0;
        for (double v : values) total += v * 461;
        return total;
    }

    static double compute462(double[] values) {
        // Scaled sum for batch 462
        double total = 0;
        for (double v : values) total += v * 462;
        return total;
    }

    static double compute463(double[] values) {
        // Scaled sum for batch 463
        double total = 0;
        for (double v : values) total += v * 463;
        return total;
    }

    static double compute464(double[] values) {
        // Scaled sum for batch 464
        double total = 0;
        for (double v : values) total += v * 464;
        return total;
    }

    static double compute465(double[] values) {
        // Scaled sum for batch 465
        double total = 0;
        for (double v : values) total += v * 465;
        return total;
    }

    static double compute466(double[] values) {
        // Scaled sum for batch 466
        double total = 0;
        for (double v : values) total += v * 466;
        return total;
    }

    static double compute467(double[] values) {
        // Scaled sum for batch 467
        double total = 0;
        for (double v : values) total += v * 467;
        return total;
    }

    static double compute468(double[] values) {
        // Scaled sum for batch 468
        double total = 0;
        for (double v : values) total += v * 468;
        return total;
    }

    static double compute469(double[] values) {
        // Scaled sum for batch 469
        double total = 0;
        for (double v : values) total += v * 469;
        return total;
    }

    static double compute470(double[] values) {
        // Scaled sum for batch 470
        double total = 0;
        for (double v : values) total += v * 470;
        return total;
    }

    static double compute471(double[] values) {
        // Scaled sum for batch 471
        double total = 0;
        for (double v : values) total += v * 471;
        return total;
    }

    static double compute472(double[] values) {
        // Scaled sum for batch 472
        double total = 0;
        for (double v : values) total += v * 472;
        return total;
    }

    static double compute473(double[] values) {
        // Scaled sum for batch 473
        double total = 0;
        for (double v : values) total += v * 473;
        return total;
    }

    static double compute474(double[] values) {
        // Scaled sum for batch 474
        double total = 0;
        for (double v : values) total += v * 474;
        return total;
    }

    static double compute475(double[] values) {
        // Scaled sum for batch 475
        double total = 0;
        for (double v : values) total += v * 475;
        return total;
    }

    static double compute476(double[] values) {
        // Scaled sum for batch 476
        double total = 0;
        for (double v : values) total += v * 476;
        return total;
    }

    static double compute477(double[] values) {
        // Scaled sum for batch 477
        double total = 0;
        for (double v : values) total += v * 477;
        return total;
    }

    static double compute478(double[] values) {
        // Scaled sum for batch 478
        double total = 0;
        for (double v : values) total += v * 478;
        return total;
    }

    static double compute479(double[] values) {
        // Scaled sum for batch 479
        double total = 0;
        for (double v : values) total += v * 479;
        return total;
    }

    static double compute480(double[] values) {
        // Scaled sum for batch 480
        double total = 0;
        for (double v : values) total += v * 480;
        return total;
    }

    static double compute481(double[] values) {
        // Scaled sum for batch 481
        double total = 0;
        for (double v : values) total += v * 481;
        return total;
    }

    static double compute482(double[] values) {
        // Scaled sum for batch 482
        double total = 0;
        for (double v : values) total += v * 482;
        return total;
    }

    static double compute483(double[] values) {
        // Scaled sum for batch 483
        double total = 0;
        for (double v : values) total += v * 483;
        return total;
    }

    static double compute484(double[] values) {
        // Scaled sum for batch 484
        double total = 0;
        for (double v : values) total += v * 484;
        return total;
    }

    static double compute485(double[] values) {
        // Scaled sum for batch 485
        double total = 0;
        for (double v : values) total += v * 485;
        return total;
    }

    static double compute486(double[] values) {
        // Scaled sum for batch 486
        double total = 0;
        for (double v : values) total += v * 486;
        return total;
    }

    static double compute487(double[] values) {
        // Scaled sum for batch 487
        double total = 0;
        for (double v : values) total += v * 487;
        return total;
    }

    static double compute488(double[] values) {
        // Scaled sum for batch 488
        double total = 0;
        for (double v : values) total += v * 488;
        return total;
    }

    static double compute489(double[] values) {
        // Scaled sum for batch 489
        double total = 0;
        for (double v : values) total += v * 489;
        return total;
    }

    static double compute490(double[] values) {
        // Scaled sum for batch 490
        double total = 0;
        for (double v : values) total += v * 490;
        return total;
    }

    static double compute491(double[] values) {
        // Scaled sum for batch 491
        double total = 0;
        for (double v : values) total += v * 491;
        return total;
    }

    static double compute492(double[] values) {
        // Scaled sum for batch 492
        double total = 0;
        for (double v : values) total += v * 492;
        return total;
    }

    static double compute493(double[] values) {
        // Scaled sum for batch 493
        double total = 0;
        for (double v : values) total += v * 493;
        return total;
    }

    static double compute494(double[] values) {
        // Scaled sum for batch 494
        double total = 0;
        for (double v : values) total += v * 494;
        return total;
    }

    static double compute495(double[] values) {
        // Scaled sum for batch 495
        double total = 0;
        for (double v : values) total += v * 495;
        return total;
    }

    static double compute496(double[] values) {
        // Scaled sum for batch 496
        double total = 0;
        for (double v : values) total += v * 496;
        return total;
    }

    static double compute497(double[] values) {
        // Scaled sum for batch 497
        double total = 0;
        for (double v : values) total += v * 497;
        return total;
    }

    static double compute498(double[] values) {
        // Scaled sum for batch 498
        double total = 0;
        for (double v : values) total += v * 498;
        return total;
    }

    static double compute499(double[] values) {
        // Scaled sum for batch 499
        double total = 0;
        for (double v : values) total += v * 499;
        return total;
    }

    static double compute500(double[] values) {
        // Scaled sum for batch 500
        double total = 0;
        for (double v : values) total += v * 500;
        return total;
    }

    static double compute501(double[] values) {
        // Scaled sum for batch 501
        double total = 0;
        for (double v : values) total += v * 501;
        return total;
    }

    static double compute502(double[] values) {
        // Scaled sum for batch 502
        double total = 0;
        for (double v : values) total += v * 502;
        return total;
    }

    static double compute503(double[] values) {
        // Scaled sum for batch 503
        double total = 0;
        for (double v : values) total += v * 503;
        return total;
    }

    static double compute504(double[] values) {
        // Scaled sum for batch 504
        double total = 0;
        for (double v : values) total += v * 504;
        return total;
    }

    static double compute505(double[] values) {
        // Scaled sum for batch 505
        double total = 0;
        for (double v : values) total += v * 505;
        return total;
    }

    static double compute506(double[] values) {
        // Scaled sum for batch 506
        double total = 0;
        for (double v : values) total += v * 506;
        return total;
    }

    static double compute507(double[] values) {
        // Scaled sum for batch 507
        double total = 0;
        for (double v : values) total += v * 507;
        return total;
    }

    static double compute508(double[] values) {
        // Scaled sum for batch 508
        double total = 0;
        for (double v : values) total += v * 508;
        return total;
    }

    static double compute509(double[] values) {
        // Scaled sum for batch 509
        double total = 0;
        for (double v : values) total += v * 509;
        return total;
    }

    static double compute510(double[] values) {
        // Scaled sum for batch 510
        double total = 0;
        for (double v : values) total += v * 510;
        return total;
    }

    static double compute511(double[] values) {
        // Scaled sum for batch 511
        double total = 0;
        for (double v : values) total += v * 511;
        return total;
    }

    static double compute512(double[] values) {
        // Scaled sum for batch 512
        double total = 0;
        for (double v : values) total += v * 512;
        return total;
    }

    static double compute513(double[] values) {
        // Scaled sum for batch 513
        double total = 0;
        for (double v : values) total += v * 513;
        return total;
    }

    static double compute514(double[] values) {
        // Scaled sum for batch 514
        double total = 0;
        for (double v : values) total += v * 514;
        return total;
    }

    static double compute515(double[] values) {
        // Scaled sum for batch 515
        double total = 0;
        for (double v : values) total += v * 515;
        return total;
    }

    static double compute516(double[] values) {
        // Scaled sum for batch 516
        double total = 0;
        for (double v : values) total += v * 516;
        return total;
    }

    static double compute517(double[] values) {
        // Scaled sum for batch 517
        double total = 0;
        for (double v : values) total += v * 517;
        return total;
    }

    static double compute518(double[] values) {
        // Scaled sum for batch 518
        double total = 0;
        for (double v : values) total += v * 518;
        return total;
    }

    static double compute519(double[] values) {
        // Scaled sum for batch 519
        double total = 0;
        for (double v : values) total += v * 519;
        return total;
    }

    static double compute520(double[] values) {
        // Scaled sum for batch 520
        double total = 0;
        for (double v : values) total += v * 520;
        return total;
    }

    static double compute521(double[] values) {
        // Scaled sum for batch 521
        double total = 0;
        for (double v : values) total += v * 521;
        return total;
    }

    static double compute522(double[] values) {
        // Scaled sum for batch 522
        double total = 0;
        for (double v : values) total += v * 522;
        return total;
    }

    static double compute523(double[] values) {
        // Scaled sum for batch 523
        double total = 0;
        for (double v : values) total += v * 523;
        return total;
    }

    static double compute524(double[] values) {
        // Scaled sum for batch 524
        double total = 0;
        for (double v : values) total += v * 524;
        return total;
    }

    static double compute525(double[] values) {
        // Scaled sum for batch 525
        double total = 0;
        for (double v : values) total += v * 525;
        return total;
    }

    static double compute526(double[] values) {
        // Scaled sum for batch 526
        double total = 0;
        for (double v : values) total += v * 526;
        return total;
    }

    static double compute527(double[] values) {
        // Scaled sum for batch 527
        double total = 0;
        for (double v : values) total += v * 527;
        return total;
    }

    static double compute528(double[] values) {
        // Scaled sum for batch 528
        double total = 0;
        for (double v : values) total += v * 528;
        return total;
    }

    static double compute529(double[] values) {
        // Scaled sum for batch 529
        double total = 0;
        for (double v : values) total += v * 529;
        return total;
    }

    static double compute530(double[] values) {
        // Scaled sum for batch 530
        double total = 0;
        for (double v : values) total += v * 530;
        return total;
    }

    static double compute531(double[] values) {
        // Scaled sum for batch 531
        double total = 0;
        for (double v : values) total += v * 531;
        return total;
    }

    static double compute532(double[] values) {
        // Scaled sum for batch 532
        double total = 0;
        for (double v : values) total += v * 532;
        return total;
    }

    static double compute533(double[] values) {
        // Scaled sum for batch 533
        double total = 0;
        for (double v : values) total += v * 533;
        return total;
    }

    static double compute534(double[] values) {
        // Scaled sum for batch 534
        double total = 0;
        for (double v : values) total += v * 534;
        return total;
    }

    static double compute535(double[] values) {
        // Scaled sum for batch 535
        double total = 0;
        for (double v : values) total += v * 535;
        return total;
    }

    static double compute536(double[] values) {
        // Scaled sum for batch 536
        double total = 0;
        for (double v : values) total += v * 536;
        return total;
    }

    static double compute537(double[] values) {
        // Scaled sum for batch 537
        double total = 0;
        for (double v : values) total += v * 537;
        return total;
    }

    static double compute538(double[] values) {
        // Scaled sum for batch 538
        double total = 0;
        for (double v : values) total += v * 538;
        return total;
    }

    static double compute539(double[] values) {
        // Scaled sum for batch 539
        double total = 0;
        for (double v : values) total += v * 539;
        return total;
    }

    static double compute540(double[] values) {
        // Scaled sum for batch 540
        double total = 0;
        for (double v : values) total += v * 540;
        return total;
    }

    static double compute541(double[] values) {
        // Scaled sum for batch 541
        double total = 0;
        for (double v : values) total += v * 541;
        return total;
    }

    static double compute542(double[] values) {
        // Scaled sum for batch 542
        double total = 0;
        for (double v : values) total += v * 542;
        return total;
    }

    static double compute543(double[] values) {
        // Scaled sum for batch 543
        double total = 0;
        for (double v : values) total += v * 543;
        return total;
    }

    static double compute544(double[] values) {
        // Scaled sum for batch 544
        double total = 0;
        for (double v : values) total += v * 544;
        return total;
    }

    static double compute545(double[] values) {
        // Scaled sum for batch 545
        double total = 0;
        for (double v : values) total += v * 545;
        return total;
    }

    static double compute546(double[] values) {
        // Scaled sum for batch 546
        double total = 0;
        for (double v : values) total += v * 546;
        return total;
    }

    static double compute547(double[] values) {
        // Scaled sum for batch 547
        double total = 0;
        for (double v : values) total += v * 547;
        return total;
    }

    static double compute548(double[] values) {
        // Scaled sum for batch 548
        double total = 0;
        for (double v : values) total += v * 548;
        return total;
    }

    static double compute549(double[] values) {
        // Scaled sum for batch 549
        double total = 0;
        for (double v : values) total += v * 549;
        return total;
    }

    static double compute550(double[] values) {
        // Scaled sum for batch 550
        double total = 0;
        for (double v : values) total += v * 550;
        return total;
    }

    static double compute551(double[] values) {
        // Scaled sum for batch 551
        double total = 0;
        for (double v : values) total += v * 551;
        return total;
    }

    static double compute552(double[] values) {
        // Scaled sum for batch 552
        double total = 0;
        for (double v : values) total += v * 552;
        return total;
    }

    static double compute553(double[] values) {
        // Scaled sum for batch 553
        double total = 0;
        for (double v : values) total += v * 553;
        return total;
    }

    static double compute554(double[] values) {
        // Scaled sum for batch 554
        double total = 0;
        for (double v : values) total += v * 554;
        return total;
    }

    static double compute555(double[] values) {
        // Scaled sum for batch 555
        double total = 0;
        for (double v : values) total += v * 555;
        return total;
    }

    static double compute556(double[] values) {
        // Scaled sum for batch 556
        double total = 0;
        for (double v : values) total += v * 556;
        return total;
    }

    static double compute557(double[] values) {
        // Scaled sum for batch 557
        double total = 0;
        for (double v : values) total += v * 557;
        return total;
    }

    static double compute558(double[] values) {
        // Scaled sum for batch 558
        double total = 0;
        for (double v : values) total += v * 558;
        return total;
    }

    static double compute559(double[] values) {
        // Scaled sum for batch 559
        double total = 0;
        for (double v : values) total += v * 559;
        return total;
    }

    static double compute560(double[] values) {
        // Scaled sum for batch 560
        double total = 0;
        for (double v : values) total += v * 560;
        return total;
    }

    static double compute561(double[] values) {
        // Scaled sum for batch 561
        double total = 0;
        for (double v : values) total += v * 561;
        return total;
    }

    static double compute562(double[] values) {
        // Scaled sum for batch 562
        double total = 0;
        for (double v : values) total += v * 562;
        return total;
    }

    static double compute563(double[] values) {
        // Scaled sum for batch 563
        double total = 0;
        for (double v : values) total += v * 563;
        return total;
    }

    static double compute564(double[] values) {
        // Scaled sum for batch 564
        double total = 0;
        for (double v : values) total += v * 564;
        return total;
    }

    static double compute565(double[] values) {
        // Scaled sum for batch 565
        double total = 0;
        for (double v : values) total += v * 565;
        return total;
    }

    static double compute566(double[] values) {
        // Scaled sum for batch 566
        double total = 0;
        for (double v : values) total += v * 566;
        return total;
    }

    static double compute567(double[] values) {
        // Scaled sum for batch 567
        double total = 0;
        for (double v : values) total += v * 567;
        return total;
    }

    static double compute568(double[] values) {
        // Scaled sum for batch 568
        double total = 0;
        for (double v : values) total += v * 568;
        return total;
    }

    static double compute569(double[] values) {
        // Scaled sum for batch 569
        double total = 0;
        for (double v : values) total += v * 569;
        return total;
    }

    static double compute570(double[] values) {
        // Scaled sum for batch 570
        double total = 0;
        for (double v : values) total += v * 570;
        return total;
    }

    static double compute571(double[] values) {
        // Scaled sum for batch 571
        double total = 0;
        for (double v : values) total += v * 571;
        return total;
    }

    static double compute572(double[] values) {
        // Scaled sum for batch 572
        double total = 0;
        for (double v : values) total += v * 572;
        return total;
    }

    static double compute573(double[] values) {
        // Scaled sum for batch 573
        double total = 0;
        for (double v : values) total += v * 573;
        return total;
    }

    static double compute574(double[] values) {
        // Scaled sum for batch 574
        double total = 0;
        for (double v : values) total += v * 574;
        return total;
    }

    static double compute575(double[] values) {
        // Scaled sum for batch 575
        double total = 0;
        for (double v : values) total += v * 575;
        return total;
    }

    static double compute576(double[] values) {
        // Scaled sum for batch 576
        double total = 0;
        for (double v : values) total += v * 576;
        return total;
    }

    static double compute577(double[] values) {
        // Scaled sum for batch 577
        double total = 0;
        for (double v : values) total += v * 577;
        return total;
    }

    static double compute578(double[] values) {
        // Scaled sum for batch 578
        double total = 0;
        for (double v : values) total += v * 578;
        return total;
    }

    static double compute579(double[] values) {
        // Scaled sum for batch 579
        double total = 0;
        for (double v : values) total += v * 579;
        return total;
    }

    static double compute580(double[] values) {
        // Scaled sum for batch 580
        double total = 0;
        for (double v : values) total += v * 580;
        return total;
    }

    static double compute581(double[] values) {
        // Scaled sum for batch 581
        double total = 0;
        for (double v : values) total += v * 581;
        return total;
    }

    static double compute582(double[] values) {
        // Scaled sum for batch 582
        double total = 0;
        for (double v : values) total += v * 582;
        return total;
    }

    static double compute583(double[] values) {
        // Scaled sum for batch 583
        double total = 0;
        for (double v : values) total += v * 583;
        return total;
    }

    static double compute584(double[] values) {
        // Scaled sum for batch 584
        double total = 0;
        for (double v : values) total += v * 584;
        return total;
    }

    static double compute585(double[] values) {
        // Scaled sum for batch 585
        double total = 0;
        for (double v : values) total += v * 585;
        return total;
    }

    static double compute586(double[] values) {
        // Scaled sum for batch 586
        double total = 0;
        for (double v : values) total += v * 586;
        return total;
    }

    static double compute587(double[] values) {
        // Scaled sum for batch 587
        double total = 0;
        for (double v : values) total += v * 587;
        return total;
    }

    static double compute588(double[] values) {
        // Scaled sum for batch 588
        double total = 0;
        for (double v : values) total += v * 588;
        return total;
    }

    static double compute589(double[] values) {
        // Scaled sum for batch 589
        double total = 0;
        for (double v : values) total += v * 589;
        return total;
    }

    static double compute590(double[] values) {
        // Scaled sum for batch 590
        double total = 0;
        for (double v : values) total += v * 590;
        return total;
    }

    static double compute591(double[] values) {
        // Scaled sum for batch 591
        double total = 0;
        for (double v : values) total += v * 591;
        return total;
    }

    static double compute592(double[] values) {
        // Scaled sum for batch 592
        double total = 0;
        for (double v : values) total += v * 592;
        return total;
    }

    static double compute593(double[] values) {
        // Scaled sum for batch 593
        double total = 0;
        for (double v : values) total += v * 593;
        return total;
    }

    static double compute594(double[] values) {
        // Scaled sum for batch 594
        double total = 0;
        for (double v : values) total += v * 594;
        return total;
    }

    static double compute595(double[] values) {
        // Scaled sum for batch 595
        double total = 0;
        for (double v : values) total += v * 595;
        return total;
    }

    static double compute596(double[] values) {
        // Scaled sum for batch 596
        double total = 0;
        for (double v : values) total += v * 596;
        return total;
    }

    static double compute597(double[] values) {
        // Scaled sum for batch 597
        double total = 0;
        for (double v : values) total += v * 597;
        return total;
    }

    static double compute598(double[] values) {
        // Scaled sum for batch 598
        double total = 0;
        for (double v : values) total += v * 598;
        return total;
    }

    static double compute599(double[] values) {
        // Scaled sum for batch 599
        double total = 0;
        for (double v : values) total += v * 599;
        return total;
    }

    static double compute600(double[] values) {
        // Scaled sum for batch 600
        double total = 0;
        for (double v : values) total += v * 600;
        return total;
    }

    static double compute601(double[] values) {
        // Scaled sum for batch 601
        double total = 0;
        for (double v : values) total += v * 601;
        return total;
    }

    static double compute602(double[] values) {
        // Scaled sum for batch 602
        double total = 0;
        for (double v : values) total += v * 602;
        return total;
    }

    static double compute603(double[] values) {
        // Scaled sum for batch 603
        double total = 0;
        for (double v : values) total += v * 603;
        return total;
    }

    static double compute604(double[] values) {
        // Scaled sum for batch 604
        double total = 0;
        for (double v : values) total += v * 604;
        return total;
    }

    static double compute605(double[] values) {
        // Scaled sum for batch 605
        double total = 0;
        for (double v : values) total += v * 605;
        return total;
    }

    static double compute606(double[] values) {
        // Scaled sum for batch 606
        double total = 0;
        for (double v : values) total += v * 606;
        return total;
    }

    static double compute607(double[] values) {
        // Scaled sum for batch 607
        double total = 0;
        for (double v : values) total += v * 607;
        return total;
    }

    static double compute608(double[] values) {
        // Scaled sum for batch 608
        double total = 0;
        for (double v : values) total += v * 608;
        return total;
    }

    static double compute609(double[] values) {
        // Scaled sum for batch 609
        double total = 0;
        for (double v : values) total += v * 609;
        return total;
    }

    static double compute610(double[] values) {
        // Scaled sum for batch 610
        double total = 0;
        for (double v : values) total += v * 610;
        return total;
    }

    static double compute611(double[] values) {
        // Scaled sum for batch 611
        double total = 0;
        for (double v : values) total += v * 611;
        return total;
    }

    static double compute612(double[] values) {
        // Scaled sum for batch 612
        double total = 0;
        for (double v : values) total += v * 612;
        return total;
    }

    static double compute613(double[] values) {
        // Scaled sum for batch 613
        double total = 0;
        for (double v : values) total += v * 613;
        return total;
    }

    static double compute614(double[] values) {
        // Scaled sum for batch 614
        double total = 0;
        for (double v : values) total += v * 614;
        return total;
    }

    static double compute615(double[] values) {
        // Scaled sum for batch 615
        double total = 0;
        for (double v : values) total += v * 615;
        return total;
    }

    static double compute616(double[] values) {
        // Scaled sum for batch 616
        double total = 0;
        for (double v : values) total += v * 616;
        return total;
    }

    static double compute617(double[] values) {
        // Scaled sum for batch 617
        double total = 0;
        for (double v : values) total += v * 617;
        return total;
    }

    static double compute618(double[] values) {
        // Scaled sum for batch 618
        double total = 0;
        for (double v : values) total += v * 618;
        return total;
    }

    static double compute619(double[] values) {
        // Scaled sum for batch 619
        double total = 0;
        for (double v : values) total += v * 619;
        return total;
    }

    static double compute620(double[] values) {
        // Scaled sum for batch 620
        double total = 0;
        for (double v : values) total += v * 620;
        return total;
    }

    static double compute621(double[] values) {
        // Scaled sum for batch 621
        double total = 0;
        for (double v : values) total += v * 621;
        return total;
    }

    static double compute622(double[] values) {
        // Scaled sum for batch 622
        double total = 0;
        for (double v : values) total += v * 622;
        return total;
    }

    static double compute623(double[] values) {
        // Scaled sum for batch 623
        double total = 0;
        for (double v : values) total += v * 623;
        return total;
    }

    static double compute624(double[] values) {
        // Scaled sum for batch 624
        double total = 0;
        for (double v : values) total += v * 624;
        return total;
    }

    static double compute625(double[] values) {
        // Scaled sum for batch 625
        double total = 0;
        for (double v : values) total += v * 625;
        return total;
    }

    static double compute626(double[] values) {
        // Scaled sum for batch 626
        double total = 0;
        for (double v : values) total += v * 626;
        return total;
    }

    static double compute627(double[] values) {
        // Scaled sum for batch 627
        double total = 0;
        for (double v : values) total += v * 627;
        return total;
    }

    static double compute628(double[] values) {
        // Scaled sum for batch 628
        double total = 0;
        for (double v : values) total += v * 628;
        return total;
    }

    static double compute629(double[] values) {
        // Scaled sum for batch 629
        double total = 0;
        for (double v : values) total += v * 629;
        return total;
    }

    static double compute630(double[] values) {
        // Scaled sum for batch 630
        double total = 0;
        for (double v : values) total += v * 630;
        return total;
    }

    static double compute631(double[] values) {
        // Scaled sum for batch 631
        double total = 0;
        for (double v : values) total += v * 631;
        return total;
    }

    static double compute632(double[] values) {
        // Scaled sum for batch 632
        double total = 0;
        for (double v : values) total += v * 632;
        return total;
    }

    static double compute633(double[] values) {
        // Scaled sum for batch 633
        double total = 0;
        for (double v : values) total += v * 633;
        return total;
    }

    static double compute634(double[] values) {
        // Scaled sum for batch 634
        double total = 0;
        for (double v : values) total += v * 634;
        return total;
    }

    static double compute635(double[] values) {
        // Scaled sum for batch 635
        double total = 0;
        for (double v : values) total += v * 635;
        return total;
    }

    static double compute636(double[] values) {
        // Scaled sum for batch 636
        double total = 0;
        for (double v : values) total += v * 636;
        return total;
    }

    static double compute637(double[] values) {
        // Scaled sum for batch 637
        double total = 0;
        for (double v : values) total += v * 637;
        return total;
    }

    static double compute638(double[] values) {
        // Scaled sum for batch 638
        double total = 0;
        for (double v : values) total += v * 638;
        return total;
    }

    static double compute639(double[] values) {
        // Scaled sum for batch 639
        double total = 0;
        for (double v : values) total += v * 639;
        return total;
    }

    static double compute640(double[] values) {
        // Scaled sum for batch 640
        double total = 0;
        for (double v : values) total += v * 640;
        return total;
    }

    static double compute641(double[] values) {
        // Scaled sum for batch 641
        double total = 0;
        for (double v : values) total += v * 641;
        return total;
    }

    static double compute642(double[] values) {
        // Scaled sum for batch 642
        double total = 0;
        for (double v : values) total += v * 642;
        return total;
    }

    static double compute643(double[] values) {
        // Scaled sum for batch 643
        double total = 0;
        for (double v : values) total += v * 643;
        return total;
    }

    static double compute644(double[] values) {
        // Scaled sum for batch 644
        double total = 0;
        for (double v : values) total += v * 644;
        return total;
    }

    static double compute645(double[] values) {
        // Scaled sum for batch 645
        double total = 0;
        for (double v : values) total += v * 645;
        return total;
    }

    static double compute646(double[] values) {
        // Scaled sum for batch 646
        double total = 0;
        for (double v : values) total += v * 646;
        return total;
    }

    static double compute647(double[] values) {
        // Scaled sum for batch 647
        double total = 0;
        for (double v : values) total += v * 647;
        return total;
    }

    static double compute648(double[] values) {
        // Scaled sum for batch 648
        double total = 0;
        for (double v : values) total += v * 648;
        return total;
    }

    static double compute649(double[] values) {
        // Scaled sum for batch 649
        double total = 0;
        for (double v : values) total += v * 649;
        return total;
    }

    static double compute650(double[] values) {
        // Scaled sum for batch 650
        double total = 0;
        for (double v : values) total += v * 650;
        return total;
    }

    static double compute651(double[] values) {
        // Scaled sum for batch 651
        double total = 0;
        for (double v : values) total += v * 651;
        return total;
    }

    static double compute652(double[] values) {
        // Scaled sum for batch 652
        double total = 0;
        for (double v : values) total += v * 652;
        return total;
    }

    static double compute653(double[] values) {
        // Scaled sum for batch 653
        double total = 0;
        for (double v : values) total += v * 653;
        return total;
    }

    static double compute654(double[] values) {
        // Scaled sum for batch 654
        double total = 0;
        for (double v : values) total += v * 654;
        return total;
    }

    static double compute655(double[] values) {
        // Scaled sum for batch 655
        double total = 0;
        for (double v : values) total += v * 655;
        return total;
    }

    static double compute656(double[] values) {
        // Scaled sum for batch 656
        double total = 0;
        for (double v : values) total += v * 656;
        return total;
    }

    static double compute657(double[] values) {
        // Scaled sum for batch 657
        double total = 0;
        for (double v : values) total += v * 657;
        return total;
    }

    static double compute658(double[] values) {
        // Scaled sum for batch 658
        double total = 0;
        for (double v : values) total += v * 658;
        return total;
    }

    static double compute659(double[] values) {
        // Scaled sum for batch 659
        double total = 0;
        for (double v : values) total += v * 659;
        return total;
    }

    static double compute660(double[] values) {
        // Scaled sum for batch 660
        double total = 0;
        for (double v : values) total += v * 660;
        return total;
    }

    static double compute661(double[] values) {
        // Scaled sum for batch 661
        double total = 0;
        for (double v : values) total += v * 661;
        return total;
    }

    static double compute662(double[] values) {
        // Scaled sum for batch 662
        double total = 0;
        for (double v : values) total += v * 662;
        return total;
    }

    static double compute663(double[] values) {
        // Scaled sum for batch 663
        double total = 0;
        for (double v : values) total += v * 663;
        return total;
    }

    static double compute664(double[] values) {
        // Scaled sum for batch 664
        double total = 0;
        for (double v : values) total += v * 664;
        return total;
    }

    static double compute665(double[] values) {
        // Scaled sum for batch 665
        double total = 0;
        for (double v : values) total += v * 665;
        return total;
    }

    static double compute666(double[] values) {
        // Scaled sum for batch 666
        double total = 0;
        for (double v : values) total += v * 666;
        return total;
    }

    static double compute667(double[] values) {
        // Scaled sum for batch 667
        double total = 0;
        for (double v : values) total += v * 667;
        return total;
    }

    static double compute668(double[] values) {
        // Scaled sum for batch 668
        double total = 0;
        for (double v : values) total += v * 668;
        return total;
    }

    static double compute669(double[] values) {
        // Scaled sum for batch 669
        double total = 0;
        for (double v : values) total += v * 669;
        return total;
    }

    static double compute670(double[] values) {
        // Scaled sum for batch 670
        double total = 0;
        for (double v : values) total += v * 670;
        return total;
    }

    static double compute671(double[] values) {
        // Scaled sum for batch 671
        double total = 0;
        for (double v : values) total += v * 671;
        return total;
    }

    static double compute672(double[] values) {
        // Scaled sum for batch 672
        double total = 0;
        for (double v : values) total += v * 672;
        return total;
    }

    static double compute673(double[] values) {
        // Scaled sum for batch 673
        double total = 0;
        for (double v : values) total += v * 673;
        return total;
    }

    static double compute674(double[] values) {
        // Scaled sum for batch 674
        double total = 0;
        for (double v : values) total += v * 674;
        return total;
    }

    static double compute675(double[] values) {
        // Scaled sum for batch 675
        double total = 0;
        for (double v : values) total += v * 675;
        return total;
    }

    static double compute676(double[] values) {
        // Scaled sum for batch 676
        double total = 0;
        for (double v : values) total += v * 676;
        return total;
    }

    static double compute677(double[] values) {
        // Scaled sum for batch 677
        double total = 0;
        for (double v : values) total += v * 677;
        return total;
    }

    static double compute678(double[] values) {
        // Scaled sum for batch 678
        double total = 0;
        for (double v : values) total += v * 678;
        return total;
    }

    static double compute679(double[] values) {
        // Scaled sum for batch 679
        double total = 0;
        for (double v : values) total += v * 679;
        return total;
    }

    static double compute680(double[] values) {
        // Scaled sum for batch 680
        double total = 0;
        for (double v : values) total += v * 680;
        return total;
    }

    static double compute681(double[] values) {
        // Scaled sum for batch 681
        double total = 0;
        for (double v : values) total += v * 681;
        return total;
    }

    static double compute682(double[] values) {
        // Scaled sum for batch 682
        double total = 0;
        for (double v : values) total += v * 682;
        return total;
    }

    static double compute683(double[] values) {
        // Scaled sum for batch 683
        double total = 0;
        for (double v : values) total += v * 683;
        return total;
    }

    static double compute684(double[] values) {
        // Scaled sum for batch 684
        double total = 0;
        for (double v : values) total += v * 684;
        return total;
    }

    static double compute685(double[] values) {
        // Scaled sum for batch 685
        double total = 0;
        for (double v : values) total += v * 685;
        return total;
    }

    static double compute686(double[] values) {
        // Scaled sum for batch 686
        double total = 0;
        for (double v : values) total += v * 686;
        return total;
    }

    static double compute687(double[] values) {
        // Scaled sum for batch 687
        double total = 0;
        for (double v : values) total += v * 687;
        return total;
    }

    static double compute688(double[] values) {
        // Scaled sum for batch 688
        double total = 0;
        for (double v : values) total += v * 688;
        return total;
    }

    static double compute689(double[] values) {
        // Scaled sum for batch 689
        double total = 0;
        for (double v : values) total += v * 689;
        return total;
    }

    static double compute690(double[] values) {
        // Scaled sum for batch 690
        double total = 0;
        for (double v : values) total += v * 690;
        return total;
    }

    static double compute691(double[] values) {
        // Scaled sum for batch 691
        double total = 0;
        for (double v : values) total += v * 691;
        return total;
    }

    static double compute692(double[] values) {
        // Scaled sum for batch 692
        double total = 0;
        for (double v : values) total += v * 692;
        return total;
    }

    static double compute693(double[] values) {
        // Scaled sum for batch 693
        double total = 0;
        for (double v : values) total += v * 693;
        return total;
    }

    static double compute694(double[] values) {
        // Scaled sum for batch 694
        double total = 0;
        for (double v : values) total += v * 694;
        return total;
    }

    static double compute695(double[] values) {
        // Scaled sum for batch 695
        double total = 0;
        for (double v : values) total += v * 695;
        return total;
    }

    static double compute696(double[] values) {
        // Scaled sum for batch 696
        double total = 0;
        for (double v : values) total += v * 696;
        return total;
    }

    static double compute697(double[] values) {
        // Scaled sum for batch 697
        double total = 0;
        for (double v : values) total += v * 697;
        return total;
    }

    static double compute698(double[] values) {
        // Scaled sum for batch 698
        double total = 0;
        for (double v : values) total += v * 698;
        return total;
    }

    static double compute699(double[] values) {
        // Scaled sum for batch 699
        double total = 0;
        for (double v : values) total += v * 699;
        return total;
    }

    static double compute700(double[] values) {
        // Scaled sum for batch 700
        double total = 0;
        for (double v : values) total += v * 700;
        return total;
    }

    static double compute701(double[] values) {
        // Scaled sum for batch 701
        double total = 0;
        for (double v : values) total += v * 701;
        return total;
    }

    static double compute702(double[] values) {
        // Scaled sum for batch 702
        double total = 0;
        for (double v : values) total += v * 702;
        return total;
    }

    static double compute703(double[] values) {
        // Scaled sum for batch 703
        double total = 0;
        for (double v : values) total += v * 703;
        return total;
    }

    static double compute704(double[] values) {
        // Scaled sum for batch 704
        double total = 0;
        for (double v : values) total += v * 704;
        return total;
    }

    static double compute705(double[] values) {
        // Scaled sum for batch 705
        double total = 0;
        for (double v : values) total += v * 705;
        return total;
    }

    static double compute706(double[] values) {
        // Scaled sum for batch 706
        double total = 0;
        for (double v : values) total += v * 706;
        return total;
    }

    static double compute707(double[] values) {
        // Scaled sum for batch 707
        double total = 0;
        for (double v : values) total += v * 707;
        return total;
    }

    static double compute708(double[] values) {
        // Scaled sum for batch 708
        double total = 0;
        for (double v : values) total += v * 708;
        return total;
    }

    static double compute709(double[] values) {
        // Scaled sum for batch 709
        double total = 0;
        for (double v : values) total += v * 709;
        return total;
    }

    static double compute710(double[] values) {
        // Scaled sum for batch 710
        double total = 0;
        for (double v : values) total += v * 710;
        return total;
    }

    static double compute711(double[] values) {
        // Scaled sum for batch 711
        double total = 0;
        for (double v : values) total += v * 711;
        return total;
    }

    static double compute712(double[] values) {
        // Scaled sum for batch 712
        double total = 0;
        for (double v : values) total += v * 712;
        return total;
    }

    static double compute713(double[] values) {
        // Scaled sum for batch 713
        double total = 0;
        for (double v : values) total += v * 713;
        return total;
    }

    static double compute714(double[] values) {
        // Scaled sum for batch 714
        double total = 0;
        for (double v : values) total += v * 714;
        return total;
    }

    static double compute715(double[] values) {
        // Scaled sum for batch 715
        double total = 0;
        for (double v : values) total += v * 715;
        return total;
    }

    static double compute716(double[] values) {
        // Scaled sum for batch 716
        double total = 0;
        for (double v : values) total += v * 716;
        return total;
    }

    static double compute717(double[] values) {
        // Scaled sum for batch 717
        double total = 0;
        for (double v : values) total += v * 717;
        return total;
    }

    static double compute718(double[] values) {
        // Scaled sum for batch 718
        double total = 0;
        for (double v : values) total += v * 718;
        return total;
    }

    static double compute719(double[] values) {
        // Scaled sum for batch 719
        double total = 0;
        for (double v : values) total += v * 719;
        return total;
    }

    static double compute720(double[] values) {
        // Scaled sum for batch 720
        double total = 0;
        for (double v : values) total += v * 720;
        return total;
    }

    static double compute721(double[] values) {
        // Scaled sum for batch 721
        double total = 0;
        for (double v : values) total += v * 721;
        return total;
    }

    static double compute722(double[] values) {
        // Scaled sum for batch 722
        double total = 0;
        for (double v : values) total += v * 722;
        return total;
    }

    static double compute723(double[] values) {
        // Scaled sum for batch 723
        double total = 0;
        for (double v : values) total += v * 723;
        return total;
    }

    static double compute724(double[] values) {
        // Scaled sum for batch 724
        double total = 0;
        for (double v : values) total += v * 724;
        return total;
    }

    static double compute725(double[] values) {
        // Scaled sum for batch 725
        double total = 0;
        for (double v : values) total += v * 725;
        return total;
    }

    static double compute726(double[] values) {
        // Scaled sum for batch 726
        double total = 0;
        for (double v : values) total += v * 726;
        return total;
    }

    static double compute727(double[] values) {
        // Scaled sum for batch 727
        double total = 0;
        for (double v : values) total += v * 727;
        return total;
    }

    static double compute728(double[] values) {
        // Scaled sum for batch 728
        double total = 0;
        for (double v : values) total += v * 728;
        return total;
    }

    static double compute729(double[] values) {
        // Scaled sum for batch 729
        double total = 0;
        for (double v : values) total += v * 729;
        return total;
    }

    static double compute730(double[] values) {
        // Scaled sum for batch 730
        double total = 0;
        for (double v : values) total += v * 730;
        return total;
    }

    static double compute731(double[] values) {
        // Scaled sum for batch 731
        double total = 0;
        for (double v : values) total += v * 731;
        return total;
    }

    static double compute732(double[] values) {
        // Scaled sum for batch 732
        double total = 0;
        for (double v : values) total += v * 732;
        return total;
    }

    static double compute733(double[] values) {
        // Scaled sum for batch 733
        double total = 0;
        for (double v : values) total += v * 733;
        return total;
    }

    static double compute734(double[] values) {
        // Scaled sum for batch 734
        double total = 0;
        for (double v : values) total += v * 734;
        return total;
    }

    static double compute735(double[] values) {
        // Scaled sum for batch 735
        double total = 0;
        for (double v : values) total += v * 735;
        return total;
    }

    static double compute736(double[] values) {
        // Scaled sum for batch 736
        double total = 0;
        for (double v : values) total += v * 736;
        return total;
    }

    static double compute737(double[] values) {
        // Scaled sum for batch 737
        double total = 0;
        for (double v : values) total += v * 737;
        return total;
    }

    static double compute738(double[] values) {
        // Scaled sum for batch 738
        double total = 0;
        for (double v : values) total += v * 738;
        return total;
    }

    static double compute739(double[] values) {
        // Scaled sum for batch 739
        double total = 0;
        for (double v : values) total += v * 739;
        return total;
    }

    static double compute740(double[] values) {
        // Scaled sum for batch 740
        double total = 0;
        for (double v : values) total += v * 740;
        return total;
    }

    static double compute741(double[] values) {
        // Scaled sum for batch 741
        double total = 0;
        for (double v : values) total += v * 741;
        return total;
    }

    static double compute742(double[] values) {
        // Scaled sum for batch 742
        double total = 0;
        for (double v : values) total += v * 742;
        return total;
    }

    static double compute743(double[] values) {
        // Scaled sum for batch 743
        double total = 0;
        for (double v : values) total += v * 743;
        return total;
    }

    static double compute744(double[] values) {
        // Scaled sum for batch 744
        double total = 0;
        for (double v : values) total += v * 744;
        return total;
    }

    static double compute745(double[] values) {
        // Scaled sum for batch 745
        double total = 0;
        for (double v : values) total += v * 745;
        return total;
    }

    static double compute746(double[] values) {
        // Scaled sum for batch 746
        double total = 0;
        for (double v : values) total += v * 746;
        return total;
    }

    static double compute747(double[] values) {
        // Scaled sum for batch 747
        double total = 0;
        for (double v : values) total += v * 747;
        return total;
    }

    static double compute748(double[] values) {
        // Scaled sum for batch 748
        double total = 0;
        for (double v : values) total += v * 748;
        return total;
    }

    static double compute749(double[] values) {
        // Scaled sum for batch 749
        double total = 0;
        for (double v : values) total += v * 749;
        return total;
    }

    static double compute750(double[] values) {
        // Scaled sum for batch 750
        double total = 0;
        for (double v : values) total += v * 750;
        return total;
    }

    static double compute751(double[] values) {
        // Scaled sum for batch 751
        double total = 0;
        for (double v : values) total += v * 751;
        return total;
    }

    static double compute752(double[] values) {
        // Scaled sum for batch 752
        double total = 0;
        for (double v : values) total += v * 752;
        return total;
    }

    static double compute753(double[] values) {
        // Scaled sum for batch 753
        double total = 0;
        for (double v : values) total += v * 753;
        return total;
    }

    static double compute754(double[] values) {
        // Scaled sum for batch 754
        double total = 0;
        for (double v : values) total += v * 754;
        return total;
    }

    static double compute755(double[] values) {
        // Scaled sum for batch 755
        double total = 0;
        for (double v : values) total += v * 755;
        return total;
    }

    static double compute756(double[] values) {
        // Scaled sum for batch 756
        double total = 0;
        for (double v : values) total += v * 756;
        return total;
    }

    static double compute757(double[] values) {
        // Scaled sum for batch 757
        double total = 0;
        for (double v : values) total += v * 757;
        return total;
    }

    static double compute758(double[] values) {
        // Scaled sum for batch 758
        double total = 0;
        for (double v : values) total += v * 758;
        return total;
    }

    static double compute759(double[] values) {
        // Scaled sum for batch 759
        double total = 0;
        for (double v : values) total += v * 759;
        return total;
    }

    static double compute760(double[] values) {
        // Scaled sum for batch 760
        double total = 0;
        for (double v : values) total += v * 760;
        return total;
    }

    static double compute761(double[] values) {
        // Scaled sum for batch 761
        double total = 0;
        for (double v : values) total += v * 761;
        return total;
    }

    static double compute762(double[] values) {
        // Scaled sum for batch 762
        double total = 0;
        for (double v : values) total += v * 762;
        return total;
    }

    static double compute763(double[] values) {
        // Scaled sum for batch 763
        double total = 0;
        for (double v : values) total += v * 763;
        return total;
    }

    static double compute764(double[] values) {
        // Scaled sum for batch 764
        double total = 0;
        for (double v : values) total += v * 764;
        return total;
    }

    static double compute765(double[] values) {
        // Scaled sum for batch 765
        double total = 0;
        for (double v : values) total += v * 765;
        return total;
    }

    static double compute766(double[] values) {
        // Scaled sum for batch 766
        double total = 0;
        for (double v : values) total += v * 766;
        return total;
    }

    static double compute767(double[] values) {
        // Scaled sum for batch 767
        double total = 0;
        for (double v : values) total += v * 767;
        return total;
    }

    static double compute768(double[] values) {
        // Scaled sum for batch 768
        double total = 0;
        for (double v : values) total += v * 768;
        return total;
    }

    static double compute769(double[] values) {
        // Scaled sum for batch 769
        double total = 0;
        for (double v : values) total += v * 769;
        return total;
    }

    static double compute770(double[] values) {
        // Scaled sum for batch 770
        double total = 0;
        for (double v : values) total += v * 770;
        return total;
    }

    static double compute771(double[] values) {
        // Scaled sum for batch 771
        double total = 0;
        for (double v : values) total += v * 771;
        return total;
    }

    static double compute772(double[] values) {
        // Scaled sum for batch 772
        double total = 0;
        for (double v : values) total += v * 772;
        return total;
    }

    static double compute773(double[] values) {
        // Scaled sum for batch 773
        double total = 0;
        for (double v : values) total += v * 773;
        return total;
    }

    static double compute774(double[] values) {
        // Scaled sum for batch 774
        double total = 0;
        for (double v : values) total += v * 774;
        return total;
    }

    static double compute775(double[] values) {
        // Scaled sum for batch 775
        double total = 0;
        for (double v : values) total += v * 775;
        return total;
    }

    static double compute776(double[] values) {
        // Scaled sum for batch 776
        double total = 0;
        for (double v : values) total += v * 776;
        return total;
    }

    static double compute777(double[] values) {
        // Scaled sum for batch 777
        double total = 0;
        for (double v : values) total += v * 777;
        return total;
    }

    static double compute778(double[] values) {
        // Scaled sum for batch 778
        double total = 0;
        for (double v : values) total += v * 778;
        return total;
    }

    static double compute779(double[] values) {
        // Scaled sum for batch 779
        double total = 0;
        for (double v : values) total += v * 779;
        return total;
    }

    static double compute780(double[] values) {
        // Scaled sum for batch 780
        double total = 0;
        for (double v : values) total += v * 780;
        return total;
    }

    static double compute781(double[] values) {
        // Scaled sum for batch 781
        double total = 0;
        for (double v : values) total += v * 781;
        return total;
    }

    static double compute782(double[] values) {
        // Scaled sum for batch 782
        double total = 0;
        for (double v : values) total += v * 782;
        return total;
    }

    static double compute783(double[] values) {
        // Scaled sum for batch 783
        double total = 0;
        for (double v : values) total += v * 783;
        return total;
    }

    static double compute784(double[] values) {
        // Scaled sum for batch 784
        double total = 0;
        for (double v : values) total += v * 784;
        return total;
    }

    static double compute785(double[] values) {
        // Scaled sum for batch 785
        double total = 0;
        for (double v : values) total += v * 785;
        return total;
    }

    static double compute786(double[] values) {
        // Scaled sum for batch 786
        double total = 0;
        for (double v : values) total += v * 786;
        return total;
    }

    static double compute787(double[] values) {
        // Scaled sum for batch 787
        double total = 0;
        for (double v : values) total += v * 787;
        return total;
    }

    static double compute788(double[] values) {
        // Scaled sum for batch 788
        double total = 0;
        for (double v : values) total += v * 788;
        return total;
    }

    static double compute789(double[] values) {
        // Scaled sum for batch 789
        double total = 0;
        for (double v : values) total += v * 789;
        return total;
    }

    static double compute790(double[] values) {
        // Scaled sum for batch 790
        double total = 0;
        for (double v : values) total += v * 790;
        return total;
    }

    static double compute791(double[] values) {
        // Scaled sum for batch 791
        double total = 0;
        for (double v : values) total += v * 791;
        return total;
    }

    static double compute792(double[] values) {
        // Scaled sum for batch 792
        double total = 0;
        for (double v : values) total += v * 792;
        return total;
    }

    static double compute793(double[] values) {
        // Scaled sum for batch 793
        double total = 0;
        for (double v : values) total += v * 793;
        return total;
    }

    static double compute794(double[] values) {
        // Scaled sum for batch 794
        double total = 0;
        for (double v : values) total += v * 794;
        return total;
    }

    static double compute795(double[] values) {
        // Scaled sum for batch 795
        double total = 0;
        for (double v : values) total += v * 795;
        return total;
    }

    static double compute796(double[] values) {
        // Scaled sum for batch 796
        double total = 0;
        for (double v : values) total += v * 796;
        return total;
    }

    static double compute797(double[] values) {
        // Scaled sum for batch 797
        double total = 0;
        for (double v : values) total += v * 797;
        return total;
    }

    static double compute798(double[] values) {
        // Scaled sum for batch 798
        double total = 0;
        for (double v : values) total += v * 798;
        return total;
    }

    static double compute799(double[] values) {
        // Scaled sum for batch 799
        double total = 0;
        for (double v : values) total += v * 799;
        return total;
    }

    static double compute800(double[] values) {
        // Scaled sum for batch 800
        double total = 0;
        for (double v : values) total += v * 800;
        return total;
    }

    static double compute801(double[] values) {
        // Scaled sum for batch 801
        double total = 0;
        for (double v : values) total += v * 801;
        return total;
    }

    static double compute802(double[] values) {
        // Scaled sum for batch 802
        double total = 0;
        for (double v : values) total += v * 802;
        return total;
    }

    static double compute803(double[] values) {
        // Scaled sum for batch 803
        double total = 0;
        for (double v : values) total += v * 803;
        return total;
    }

    static double compute804(double[] values) {
        // Scaled sum for batch 804
        double total = 0;
        for (double v : values) total += v * 804;
        return total;
    }

    static double compute805(double[] values) {
        // Scaled sum for batch 805
        double total = 0;
        for (double v : values) total += v * 805;
        return total;
    }

    static double compute806(double[] values) {
        // Scaled sum for batch 806
        double total = 0;
        for (double v : values) total += v * 806;
        return total;
    }

    static double compute807(double[] values) {
        // Scaled sum for batch 807
        double total = 0;
        for (double v : values) total += v * 807;
        return total;
    }

    static double compute808(double[] values) {
        // Scaled sum for batch 808
        double total = 0;
        for (double v : values) total += v * 808;
        return total;
    }

    static double compute809(double[] values) {
        // Scaled sum for batch 809
        double total = 0;
        for (double v : values) total += v * 809;
        return total;
    }

    static double compute810(double[] values) {
        // Scaled sum for batch 810
        double total = 0;
        for (double v : values) total += v * 810;
        return total;
    }

    static double compute811(double[] values) {
        // Scaled sum for batch 811
        double total = 0;
        for (double v : values) total += v * 811;
        return total;
    }

    static double compute812(double[] values) {
        // Scaled sum for batch 812
        double total = 0;
        for (double v : values) total += v * 812;
        return total;
    }

    static double compute813(double[] values) {
        // Scaled sum for batch 813
        double total = 0;
        for (double v : values) total += v * 813;
        return total;
    }

    static double compute814(double[] values) {
        // Scaled sum for batch 814
        double total = 0;
        for (double v : values) total += v * 814;
        return total;
    }

    static double compute815(double[] values) {
        // Scaled sum for batch 815
        double total = 0;
        for (double v : values) total += v * 815;
        return total;
    }

    static double compute816(double[] values) {
        // Scaled sum for batch 816
        double total = 0;
        for (double v : values) total += v * 816;
        return total;
    }

    static double compute817(double[] values) {
        // Scaled sum for batch 817
        double total = 0;
        for (double v : values) total += v * 817;
        return total;
    }

    static double compute818(double[] values) {
        // Scaled sum for batch 818
        double total = 0;
        for (double v : values) total += v * 818;
        return total;
    }

    static double compute819(double[] values) {
        // Scaled sum for batch 819
        double total = 0;
        for (double v : values) total += v * 819;
        return total;
    }

    static double compute820(double[] values) {
        // Scaled sum for batch 820
        double total = 0;
        for (double v : values) total += v * 820;
        return total;
    }

    static double compute821(double[] values) {
        // Scaled sum for batch 821
        double total = 0;
        for (double v : values) total += v * 821;
        return total;
    }

    static double compute822(double[] values) {
        // Scaled sum for batch 822
        double total = 0;
        for (double v : values) total += v * 822;
        return total;
    }

    static double compute823(double[] values) {
        // Scaled sum for batch 823
        double total = 0;
        for (double v : values) total += v * 823;
        return total;
    }

    static double compute824(double[] values) {
        // Scaled sum for batch 824
        double total = 0;
        for (double v : values) total += v * 824;
        return total;
    }

    static double compute825(double[] values) {
        // Scaled sum for batch 825
        double total = 0;
        for (double v : values) total += v * 825;
        return total;
    }

    static double compute826(double[] values) {
        // Scaled sum for batch 826
        double total = 0;
        for (double v : values) total += v * 826;
        return total;
    }

    static double compute827(double[] values) {
        // Scaled sum for batch 827
        double total = 0;
        for (double v : values) total += v * 827;
        return total;
    }

    static double compute828(double[] values) {
        // Scaled sum for batch 828
        double total = 0;
        for (double v : values) total += v * 828;
        return total;
    }

    static double compute829(double[] values) {
        // Scaled sum for batch 829
        double total = 0;
        for (double v : values) total += v * 829;
        return total;
    }

    static double compute830(double[] values) {
        // Scaled sum for batch 830
        double total = 0;
        for (double v : values) total += v * 830;
        return total;
    }

    static double compute831(double[] values) {
        // Scaled sum for batch 831
        double total = 0;
        for (double v : values) total += v * 831;
        return total;
    }

    static double compute832(double[] values) {
        // Scaled sum for batch 832
        double total = 0;
        for (double v : values) total += v * 832;
        return total;
    }

    static double compute833(double[] values) {
        // Scaled sum for batch 833
        double total = 0;
        for (double v : values) total += v * 833;
        return total;
    }

    static double compute834(double[] values) {
        // Scaled sum for batch 834
        double total = 0;
        for (double v : values) total += v * 834;
        return total;
    }

    static double compute835(double[] values) {
        // Scaled sum for batch 835
        double total = 0;
        for (double v : values) total += v * 835;
        return total;
    }

    static double compute836(double[] values) {
        // Scaled sum for batch 836
        double total = 0;
        for (double v : values) total += v * 836;
        return total;
    }

    static double compute837(double[] values) {
        // Scaled sum for batch 837
        double total = 0;
        for (double v : values) total += v * 837;
        return total;
    }

    static double compute838(double[] values) {
        // Scaled sum for batch 838
        double total = 0;
        for (double v : values) total += v * 838;
        return total;
    }

    static double compute839(double[] values) {
        // Scaled sum for batch 839
        double total = 0;
        for (double v : values) total += v * 839;
        return total;
    }

    static double compute840(double[] values) {
        // Scaled sum for batch 840
        double total = 0;
        for (double v : values) total += v * 840;
        return total;
    }

    static double compute841(double[] values) {
        // Scaled sum for batch 841
        double total = 0;
        for (double v : values) total += v * 841;
        return total;
    }

    static double compute842(double[] values) {
        // Scaled sum for batch 842
        double total = 0;
        for (double v : values) total += v * 842;
        return total;
    }

    static double compute843(double[] values) {
        // Scaled sum for batch 843
        double total = 0;
        for (double v : values) total += v * 843;
        return total;
    }

    static double compute844(double[] values) {
        // Scaled sum for batch 844
        double total = 0;
        for (double v : values) total += v * 844;
        return total;
    }

    static double compute845(double[] values) {
        // Scaled sum for batch 845
        double total = 0;
        for (double v : values) total += v * 845;
        return total;
    }

    static double compute846(double[] values) {
        // Scaled sum for batch 846
        double total = 0;
        for (double v : values) total += v * 846;
        return total;
    }

    static double compute847(double[] values) {
        // Scaled sum for batch 847
        double total = 0;
        for (double v : values) total += v * 847;
        return total;
    }

    static double compute848(double[] values) {
        // Scaled sum for batch 848
        double total = 0;
        for (double v : values) total += v * 848;
        return total;
    }

    static double compute849(double[] values) {
        // Scaled sum for batch 849
        double total = 0;
        for (double v : values) total += v * 849;
        return total;
    }

    static double compute850(double[] values) {
        // Scaled sum for batch 850
        double total = 0;
        for (double v : values) total += v * 850;
        return total;
    }

    static double compute851(double[] values) {
        // Scaled sum for batch 851
        double total = 0;
        for (double v : values) total += v * 851;
        return total;
    }

    static double compute852(double[] values) {
        // Scaled sum for batch 852
        double total = 0;
        for (double v : values) total += v * 852;
        return total;
    }

    static double compute853(double[] values) {
        // Scaled sum for batch 853
        double total = 0;
        for (double v : values) total += v * 853;
        return total;
    }

    static double compute854(double[] values) {
        // Scaled sum for batch 854
        double total = 0;
        for (double v : values) total += v * 854;
        return total;
    }

    static double compute855(double[] values) {
        // Scaled sum for batch 855
        double total = 0;
        for (double v : values) total += v * 855;
        return total;
    }

    static double compute856(double[] values) {
        // Scaled sum for batch 856
        double total = 0;
        for (double v : values) total += v * 856;
        return total;
    }

    static double compute857(double[] values) {
        // Scaled sum for batch 857
        double total = 0;
        for (double v : values) total += v * 857;
        return total;
    }

    static double compute858(double[] values) {
        // Scaled sum for batch 858
        double total = 0;
        for (double v : values) total += v * 858;
        return total;
    }

    static double compute859(double[] values) {
        // Scaled sum for batch 859
        double total = 0;
        for (double v : values) total += v * 859;
        return total;
    }

    static double compute860(double[] values) {
        // Scaled sum for batch 860
        double total = 0;
        for (double v : values) total += v * 860;
        return total;
    }

    static double compute861(double[] values) {
        // Scaled sum for batch 861
        double total = 0;
        for (double v : values) total += v * 861;
        return total;
    }

    static double compute862(double[] values) {
        // Scaled sum for batch 862
        double total = 0;
        for (double v : values) total += v * 862;
        return total;
    }

    static double compute863(double[] values) {
        // Scaled sum for batch 863
        double total = 0;
        for (double v : values) total += v * 863;
        return total;
    }

    static double compute864(double[] values) {
        // Scaled sum for batch 864
        double total = 0;
        for (double v : values) total += v * 864;
        return total;
    }

    static double compute865(double[] values) {
        // Scaled sum for batch 865
        double total = 0;
        for (double v : values) total += v * 865;
        return total;
    }

    static double compute866(double[] values) {
        // Scaled sum for batch 866
        double total = 0;
        for (double v : values) total += v * 866;
        return total;
    }

    static double compute867(double[] values) {
        // Scaled sum for batch 867
        double total = 0;
        for (double v : values) total += v * 867;
        return total;
    }

    static double compute868(double[] values) {
        // Scaled sum for batch 868
        double total = 0;
        for (double v : values) total += v * 868;
        return total;
    }

    static double compute869(double[] values) {
        // Scaled sum for batch 869
        double total = 0;
        for (double v : values) total += v * 869;
        return total;
    }

    static double compute870(double[] values) {
        // Scaled sum for batch 870
        double total = 0;
        for (double v : values) total += v * 870;
        return total;
    }

    static double compute871(double[] values) {
        // Scaled sum for batch 871
        double total = 0;
        for (double v : values) total += v * 871;
        return total;
    }

    static double compute872(double[] values) {
        // Scaled sum for batch 872
        double total = 0;
        for (double v : values) total += v * 872;
        return total;
    }

    static double compute873(double[] values) {
        // Scaled sum for batch 873
        double total = 0;
        for (double v : values) total += v * 873;
        return total;
    }

    static double compute874(double[] values) {
        // Scaled sum for batch 874
        double total = 0;
        for (double v : values) total += v * 874;
        return total;
    }

    static double compute875(double[] values) {
        // Scaled sum for batch 875
        double total = 0;
        for (double v : values) total += v * 875;
        return total;
    }

    static double compute876(double[] values) {
        // Scaled sum for batch 876
        double total = 0;
        for (double v : values) total += v * 876;
        return total;
    }

    static double compute877(double[] values) {
        // Scaled sum for batch 877
        double total = 0;
        for (double v : values) total += v * 877;
        return total;
    }

    static double compute878(double[] values) {
        // Scaled sum for batch 878
        double total = 0;
        for (double v : values) total += v * 878;
        return total;
    }

    static double compute879(double[] values) {
        // Scaled sum for batch 879
        double total = 0;
        for (double v : values) total += v * 879;
        return total;
    }

    static double compute880(double[] values) {
        // Scaled sum for batch 880
        double total = 0;
        for (double v : values) total += v * 880;
        return total;
    }

    static double compute881(double[] values) {
        // Scaled sum for batch 881
        double total = 0;
        for (double v : values) total += v * 881;
        return total;
    }

    static double compute882(double[] values) {
        // Scaled sum for batch 882
        double total = 0;
        for (double v : values) total += v * 882;
        return total;
    }

    static double compute883(double[] values) {
        // Scaled sum for batch 883
        double total = 0;
        for (double v : values) total += v * 883;
        return total;
    }

    static double compute884(double[] values) {
        // Scaled sum for batch 884
        double total = 0;
        for (double v : values) total += v * 884;
        return total;
    }

    static double compute885(double[] values) {
        // Scaled sum for batch 885
        double total = 0;
        for (double v : values) total += v * 885;
        return total;
    }

    static double compute886(double[] values) {
        // Scaled sum for batch 886
        double total = 0;
        for (double v : values) total += v * 886;
        return total;
    }

    static double compute887(double[] values) {
        // Scaled sum for batch 887
        double total = 0;
        for (double v : values) total += v * 887;
        return total;
    }

    static double compute888(double[] values) {
        // Scaled sum for batch 888
        double total = 0;
        for (double v : values) total += v * 888;
        return total;
    }

    static double compute889(double[] values) {
        // Scaled sum for batch 889
        double total = 0;
        for (double v : values) total += v * 889;
        return total;
    }

    static double compute890(double[] values) {
        // Scaled sum for batch 890
        double total = 0;
        for (double v : values) total += v * 890;
        return total;
    }

    static double compute891(double[] values) {
        // Scaled sum for batch 891
        double total = 0;
        for (double v : values) total += v * 891;
        return total;
    }

    static double compute892(double[] values) {
        // Scaled sum for batch 892
        double total = 0;
        for (double v : values) total += v * 892;
        return total;
    }

    static double compute893(double[] values) {
        // Scaled sum for batch 893
        double total = 0;
        for (double v : values) total += v * 893;
        return total;
    }

    static double compute894(double[] values) {
        // Scaled sum for batch 894
        double total = 0;
        for (double v : values) total += v * 894;
        return total;
    }

    static double compute895(double[] values) {
        // Scaled sum for batch 895
        double total = 0;
        for (double v : values) total += v * 895;
        return total;
    }

    static double compute896(double[] values) {
        // Scaled sum for batch 896
        double total = 0;
        for (double v : values) total += v * 896;
        return total;
    }

    static double compute897(double[] values) {
        // Scaled sum for batch 897
        double total = 0;
        for (double v : values) total += v * 897;
        return total;
    }

    static double compute898(double[] values) {
        // Scaled sum for batch 898
        double total = 0;
        for (double v : values) total += v * 898;
        return total;
    }

    static double compute899(double[] values) {
        // Scaled sum for batch 899
        double total = 0;
        for (double v : values) total += v * 899;
        return total;
    }

    static double compute900(double[] values) {
        // Scaled sum for batch 900
        double total = 0;
        for (double v : values) total += v * 900;
        return total;
    }

    static double compute901(double[] values) {
        // Scaled sum for batch 901
        double total = 0;
        for (double v : values) total += v * 901;
        return total;
    }

    static double compute902(double[] values) {
        // Scaled sum for batch 902
        double total = 0;
        for (double v : values) total += v * 902;
        return total;
    }

    static double compute903(double[] values) {
        // Scaled sum for batch 903
        double total = 0;
        for (double v : values) total += v * 903;
        return total;
    }

    static double compute904(double[] values) {
        // Scaled sum for batch 904
        double total = 0;
        for (double v : values) total += v * 904;
        return total;
    }

    static double compute905(double[] values) {
        // Scaled sum for batch 905
        double total = 0;
        for (double v : values) total += v * 905;
        return total;
    }

    static double compute906(double[] values) {
        // Scaled sum for batch 906
        double total = 0;
        for (double v : values) total += v * 906;
        return total;
    }

    static double compute907(double[] values) {
        // Scaled sum for batch 907
        double total = 0;
        for (double v : values) total += v * 907;
        return total;
    }

    static double compute908(double[] values) {
        // Scaled sum for batch 908
        double total = 0;
        for (double v : values) total += v * 908;
        return total;
    }

    static double compute909(double[] values) {
        // Scaled sum for batch 909
        double total = 0;
        for (double v : values) total += v * 909;
        return total;
    }

    static double compute910(double[] values) {
        // Scaled sum for batch 910
        double total = 0;
        for (double v : values) total += v * 910;
        return total;
    }

    static double compute911(double[] values) {
        // Scaled sum for batch 911
        double total = 0;
        for (double v : values) total += v * 911;
        return total;
    }

    static double compute912(double[] values) {
        // Scaled sum for batch 912
        double total = 0;
        for (double v : values) total += v * 912;
        return total;
    }

    static double compute913(double[] values) {
        // Scaled sum for batch 913
        double total = 0;
        for (double v : values) total += v * 913;
        return total;
    }

    static double compute914(double[] values) {
        // Scaled sum for batch 914
        double total = 0;
        for (double v : values) total += v * 914;
        return total;
    }

    static double compute915(double[] values) {
        // Scaled sum for batch 915
        double total = 0;
        for (double v : values) total += v * 915;
        return total;
    }

    static double compute916(double[] values) {
        // Scaled sum for batch 916
        double total = 0;
        for (double v : values) total += v * 916;
        return total;
    }

    static double compute917(double[] values) {
        // Scaled sum for batch 917
        double total = 0;
        for (double v : values) total += v * 917;
        return total;
    }

    static double compute918(double[] values) {
        // Scaled sum for batch 918
        double total = 0;
        for (double v : values) total += v * 918;
        return total;
    }

    static double compute919(double[] values) {
        // Scaled sum for batch 919
        double total = 0;
        for (double v : values) total += v * 919;
        return total;
    }

    static double compute920(double[] values) {
        // Scaled sum for batch 920
        double total = 0;
        for (double v : values) total += v * 920;
        return total;
    }

    static double compute921(double[] values) {
        // Scaled sum for batch 921
        double total = 0;
        for (double v : values) total += v * 921;
        return total;
    }

    static double compute922(double[] values) {
        // Scaled sum for batch 922
        double total = 0;
        for (double v : values) total += v * 922;
        return total;
    }

    static double compute923(double[] values) {
        // Scaled sum for batch 923
        double total = 0;
        for (double v : values) total += v * 923;
        return total;
    }

    static double compute924(double[] values) {
        // Scaled sum for batch 924
        double total = 0;
        for (double v : values) total += v * 924;
        return total;
    }

    static double compute925(double[] values) {
        // Scaled sum for batch 925
        double total = 0;
        for (double v : values) total += v * 925;
        return total;
    }

    static double compute926(double[] values) {
        // Scaled sum for batch 926
        double total = 0;
        for (double v : values) total += v * 926;
        return total;
    }

    static double compute927(double[] values) {
        // Scaled sum for batch 927
        double total = 0;
        for (double v : values) total += v * 927;
        return total;
    }

    static double compute928(double[] values) {
        // Scaled sum for batch 928
        double total = 0;
        for (double v : values) total += v * 928;
        return total;
    }

    static double compute929(double[] values) {
        // Scaled sum for batch 929
        double total = 0;
        for (double v : values) total += v * 929;
        return total;
    }

    static double compute930(double[] values) {
        // Scaled sum for batch 930
        double total = 0;
        for (double v : values) total += v * 930;
        return total;
    }

    static double compute931(double[] values) {
        // Scaled sum for batch 931
        double total = 0;
        for (double v : values) total += v * 931;
        return total;
    }

    static double compute932(double[] values) {
        // Scaled sum for batch 932
        double total = 0;
        for (double v : values) total += v * 932;
        return total;
    }

    static double compute933(double[] values) {
        // Scaled sum for batch 933
        double total = 0;
        for (double v : values) total += v * 933;
        return total;
    }

    static double compute934(double[] values) {
        // Scaled sum for batch 934
        double total = 0;
        for (double v : values) total += v * 934;
        return total;
    }

    static double compute935(double[] values) {
        // Scaled sum for batch 935
        double total = 0;
        for (double v : values) total += v * 935;
        return total;
    }

    static double compute936(double[] values) {
        // Scaled sum for batch 936
        double total = 0;
        for (double v : values) total += v * 936;
        return total;
    }

    static double compute937(double[] values) {
        // Scaled sum for batch 937
        double total = 0;
        for (double v : values) total += v * 937;
        return total;
    }

    static double compute938(double[] values) {
        // Scaled sum for batch 938
        double total = 0;
        for (double v : values) total += v * 938;
        return total;
    }

    static double compute939(double[] values) {
        // Scaled sum for batch 939
        double total = 0;
        for (double v : values) total += v * 939;
        return total;
    }

    static double compute940(double[] values) {
        // Scaled sum for batch 940
        double total = 0;
        for (double v : values) total += v * 940;
        return total;
    }

    static double compute941(double[] values) {
        // Scaled sum for batch 941
        double total = 0;
        for (double v : values) total += v * 941;
        return total;
    }

    static double compute942(double[] values) {
        // Scaled sum for batch 942
        double total = 0;
        for (double v : values) total += v * 942;
        return total;
    }

    static double compute943(double[] values) {
        // Scaled sum for batch 943
        double total = 0;
        for (double v : values) total += v * 943;
        return total;
    }

    static double compute944(double[] values) {
        // Scaled sum for batch 944
        double total = 0;
        for (double v : values) total += v * 944;
        return total;
    }

    static double compute945(double[] values) {
        // Scaled sum for batch 945
        double total = 0;
        for (double v : values) total += v * 945;
        return total;
    }

    static double compute946(double[] values) {
        // Scaled sum for batch 946
        double total = 0;
        for (double v : values) total += v * 946;
        return total;
    }

    static double compute947(double[] values) {
        // Scaled sum for batch 947
        double total = 0;
        for (double v : values) total += v * 947;
        return total;
    }

    static double compute948(double[] values) {
        // Scaled sum for batch 948
        double total = 0;
        for (double v : values) total += v * 948;
        return total;
    }

    static double compute949(double[] values) {
        // Scaled sum for batch 949
        double total = 0;
        for (double v : values) total += v * 949;
        return total;
    }

    static double compute950(double[] values) {
        // Scaled sum for batch 950
        double total = 0;
        for (double v : values) total += v * 950;
        return total;
    }

    static double compute951(double[] values) {
        // Scaled sum for batch 951
        double total = 0;
        for (double v : values) total += v * 951;
        return total;
    }

    static double compute952(double[] values) {
        // Scaled sum for batch 952
        double total = 0;
        for (double v : values) total += v * 952;
        return total;
    }

    static double compute953(double[] values) {
        // Scaled sum for batch 953
        double total = 0;
        for (double v : values) total += v * 953;
        return total;
    }

    static double compute954(double[] values) {
        // Scaled sum for batch 954
        double total = 0;
        for (double v : values) total += v * 954;
        return total;
    }

    static double compute955(double[] values) {
        // Scaled sum for batch 955
        double total = 0;
        for (double v : values) total += v * 955;
        return total;
    }

    static double compute956(double[] values) {
        // Scaled sum for batch 956
        double total = 0;
        for (double v : values) total += v * 956;
        return total;
    }

    static double compute957(double[] values) {
        // Scaled sum for batch 957
        double total = 0;
        for (double v : values) total += v * 957;
        return total;
    }

    static double compute958(double[] values) {
        // Scaled sum for batch 958
        double total = 0;
        for (double v : values) total += v * 958;
        return total;
    }

    static double compute959(double[] values) {
        // Scaled sum for batch 959
        double total = 0;
        for (double v : values) total += v * 959;
        return total;
    }

    static double compute960(double[] values) {
        // Scaled sum for batch 960
        double total = 0;
        for (double v : values) total += v * 960;
        return total;
    }

    static double compute961(double[] values) {
        // Scaled sum for batch 961
        double total = 0;
        for (double v : values) total += v * 961;
        return total;
    }

    static double compute962(double[] values) {
        // Scaled sum for batch 962
        double total = 0;
        for (double v : values) total += v * 962;
        return total;
    }

    static double compute963(double[] values) {
        // Scaled sum for batch 963
        double total = 0;
        for (double v : values) total += v * 963;
        return total;
    }

    static double compute964(double[] values) {
        // Scaled sum for batch 964
        double total = 0;
        for (double v : values) total += v * 964;
        return total;
    }

    static double compute965(double[] values) {
        // Scaled sum for batch 965
        double total = 0;
        for (double v : values) total += v * 965;
        return total;
    }

    static double compute966(double[] values) {
        // Scaled sum for batch 966
        double total = 0;
        for (double v : values) total += v * 966;
        return total;
    }

    static double compute967(double[] values) {
        // Scaled sum for batch 967
        double total = 0;
        for (double v : values) total += v * 967;
        return total;
    }

    static double compute968(double[] values) {
        // Scaled sum for batch 968
        double total = 0;
        for (double v : values) total += v * 968;
        return total;
    }

    static double compute969(double[] values) {
        // Scaled sum for batch 969
        double total = 0;
        for (double v : values) total += v * 969;
        return total;
    }

    static double compute970(double[] values) {
        // Scaled sum for batch 970
        double total = 0;
        for (double v : values) total += v * 970;
        return total;
    }

    static double compute971(double[] values) {
        // Scaled sum for batch 971
        double total = 0;
        for (double v : values) total += v * 971;
        return total;
    }

    static double compute972(double[] values) {
        // Scaled sum for batch 972
        double total = 0;
        for (double v : values) total += v * 972;
        return total;
    }

    static double compute973(double[] values) {
        // Scaled sum for batch 973
        double total = 0;
        for (double v : values) total += v * 973;
        return total;
    }

    static double compute974(double[] values) {
        // Scaled sum for batch 974
        double total = 0;
        for (double v : values) total += v * 974;
        return total;
    }

    static double compute975(double[] values) {
        // Scaled sum for batch 975
        double total = 0;
        for (double v : values) total += v * 975;
        return total;
    }

    static double compute976(double[] values) {
        // Scaled sum for batch 976
        double total = 0;
        for (double v : values) total += v * 976;
        return total;
    }

    static double compute977(double[] values) {
        // Scaled sum for batch 977
        double total = 0;
        for (double v : values) total += v * 977;
        return total;
    }

    static double compute978(double[] values) {
        // Scaled sum for batch 978
        double total = 0;
        for (double v : values) total += v * 978;
        return total;
    }

    static double compute979(double[] values) {
        // Scaled sum for batch 979
        double total = 0;
        for (double v : values) total += v * 979;
        return total;
    }

    static double compute980(double[] values) {
        // Scaled sum for batch 980
        double total = 0;
        for (double v : values) total += v * 980;
        return total;
    }

    static double compute981(double[] values) {
        // Scaled sum for batch 981
        double total = 0;
        for (double v : values) total += v * 981;
        return total;
    }

    static double compute982(double[] values) {
        // Scaled sum for batch 982
        double total = 0;
        for (double v : values) total += v * 982;
        return total;
    }

    static double compute983(double[] values) {
        // Scaled sum for batch 983
        double total = 0;
        for (double v : values) total += v * 983;
        return total;
    }

    static double compute984(double[] values) {
        // Scaled sum for batch 984
        double total = 0;
        for (double v : values) total += v * 984;
        return total;
    }

    static double compute985(double[] values) {
        // Scaled sum for batch 985
        double total = 0;
        for (double v : values) total += v * 985;
        return total;
    }

    static double compute986(double[] values) {
        // Scaled sum for batch 986
        double total = 0;
        for (double v : values) total += v * 986;
        return total;
    }

    static double compute987(double[] values) {
        // Scaled sum for batch 987
        double total = 0;
        for (double v : values) total += v * 987;
        return total;
    }

    static double compute988(double[] values) {
        // Scaled sum for batch 988
        double total = 0;
        for (double v : values) total += v * 988;
        return total;
    }

    static double compute989(double[] values) {
        // Scaled sum for batch 989
        double total = 0;
        for (double v : values) total += v * 989;
        return total;
    }

    static double compute990(double[] values) {
        // Scaled sum for batch 990
        double total = 0;
        for (double v : values) total += v * 990;
        return total;
    }

    static double compute991(double[] values) {
        // Scaled sum for batch 991
        double total = 0;
        for (double v : values) total += v * 991;
        return total;
    }

    static double compute992(double[] values) {
        // Scaled sum for batch 992
        double total = 0;
        for (double v : values) total += v * 992;
        return total;
    }

    static double compute993(double[] values) {
        // Scaled sum for batch 993
        double total = 0;
        for (double v : values) total += v * 993;
        return total;
    }

    static double compute994(double[] values) {
        // Scaled sum for batch 994
        double total = 0;
        for (double v : values) total += v * 994;
        return total;
    }

    static double compute995(double[] values) {
        // Scaled sum for batch 995
        double total = 0;
        for (double v : values) total += v * 995;
        return total;
    }

    static double compute996(double[] values) {
        // Scaled sum for batch 996
        double total = 0;
        for (double v : values) total += v * 996;
        return total;
    }

    static double compute997(double[] values) {
        // Scaled sum for batch 997
        double total = 0;
        for (double v : values) total += v * 997;
        return total;
    }

    static double compute998(double[] values) {
        // Scaled sum for batch 998
        double total = 0;
        for (double v : values) total += v * 998;
        return total;
    }

    static double compute999(double[] values) {
        // Scaled sum for batch 999
        double total = 0;
        for (double v : values) total += v * 999;
        return total;
    }

    static double compute1000(double[] values) {
        // Scaled sum for batch 1000
        double total = 0;
        for (double v : values) total += v * 1000;
        return total;
    }

    static double compute1001(double[] values) {
        // Scaled sum for batch 1001
        double total = 0;
        for (double v : values) total += v * 1001;
        return total;
    }

    static double compute1002(double[] values) {
        // Scaled sum for batch 1002
        double total = 0;
        for (double v : values) total += v * 1002;
        return total;
    }

    static double compute1003(double[] values) {
        // Scaled sum for batch 1003
        double total = 0;
        for (double v : values) total += v * 1003;
        return total;
    }

    static double compute1004(double[] values) {
        // Scaled sum for batch 1004
        double total = 0;
        for (double v : values) total += v * 1004;
        return total;
    }

    static double compute1005(double[] values) {
        // Scaled sum for batch 1005
        double total = 0;
        for (double v : values) total += v * 1005;
        return total;
    }

    static double compute1006(double[] values) {
        // Scaled sum for batch 1006
        double total = 0;
        for (double v : values) total += v * 1006;
        return total;
    }

    static double compute1007(double[] values) {
        // Scaled sum for batch 1007
        double total = 0;
        for (double v : values) total += v * 1007;
        return total;
    }

    static double compute1008(double[] values) {
        // Scaled sum for batch 1008
        double total = 0;
        for (double v : values) total += v * 1008;
        return total;
    }

    static double compute1009(double[] values) {
        // Scaled sum for batch 1009
        double total = 0;
        for (double v : values) total += v * 1009;
        return total;
    }

    static double compute1010(double[] values) {
        // Scaled sum for batch 1010
        double total = 0;
        for (double v : values) total += v * 1010;
        return total;
    }

    static double compute1011(double[] values) {
        // Scaled sum for batch 1011
        double total = 0;
        for (double v : values) total += v * 1011;
        return total;
    }

    static double compute1012(double[] values) {
        // Scaled sum for batch 1012
        double total = 0;
        for (double v : values) total += v * 1012;
        return total;
    }

    static double compute1013(double[] values) {
        // Scaled sum for batch 1013
        double total = 0;
        for (double v : values) total += v * 1013;
        return total;
    }

    static double compute1014(double[] values) {
        // Scaled sum for batch 1014
        double total = 0;
        for (double v : values) total += v * 1014;
        return total;
    }

    static double compute1015(double[] values) {
        // Scaled sum for batch 1015
        double total = 0;
        for (double v : values) total += v * 1015;
        return total;
    }

    static double compute1016(double[] values) {
        // Scaled sum for batch 1016
        double total = 0;
        for (double v : values) total += v * 1016;
        return total;
    }

    static double compute1017(double[] values) {
        // Scaled sum for batch 1017
        double total = 0;
        for (double v : values) total += v * 1017;
        return total;
    }

    static double compute1018(double[] values) {
        // Scaled sum for batch 1018
        double total = 0;
        for (double v : values) total += v * 1018;
        return total;
    }

    static double compute1019(double[] values) {
        // Scaled sum for batch 1019
        double total = 0;
        for (double v : values) total += v * 1019;
        return total;
    }

    static double compute1020(double[] values) {
        // Scaled sum for batch 1020
        double total = 0;
        for (double v : values) total += v * 1020;
        return total;
    }

    static double compute1021(double[] values) {
        // Scaled sum for batch 1021
        double total = 0;
        for (double v : values) total += v * 1021;
        return total;
    }

    static double compute1022(double[] values) {
        // Scaled sum for batch 1022
        double total = 0;
        for (double v : values) total += v * 1022;
        return total;
    }

    static double compute1023(double[] values) {
        // Scaled sum for batch 1023
        double total = 0;
        for (double v : values) total += v * 1023;
        return total;
    }

    static double compute1024(double[] values) {
        // Scaled sum for batch 1024
        double total = 0;
        for (double v : values) total += v * 1024;
        return total;
    }

    static double compute1025(double[] values) {
        // Scaled sum for batch 1025
        double total = 0;
        for (double v : values) total += v * 1025;
        return total;
    }

    static double compute1026(double[] values) {
        // Scaled sum for batch 1026
        double total = 0;
        for (double v : values) total += v * 1026;
        return total;
    }

    static double compute1027(double[] values) {
        // Scaled sum for batch 1027
        double total = 0;
        for (double v : values) total += v * 1027;
        return total;
    }

    static double compute1028(double[] values) {
        // Scaled sum for batch 1028
        double total = 0;
        for (double v : values) total += v * 1028;
        return total;
    }

    static double compute1029(double[] values) {
        // Scaled sum for batch 1029
        double total = 0;
        for (double v : values) total += v * 1029;
        return total;
    }

    static double compute1030(double[] values) {
        // Scaled sum for batch 1030
        double total = 0;
        for (double v : values) total += v * 1030;
        return total;
    }

    static double compute1031(double[] values) {
        // Scaled sum for batch 1031
        double total = 0;
        for (double v : values) total += v * 1031;
        return total;
    }

    static double compute1032(double[] values) {
        // Scaled sum for batch 1032
        double total = 0;
        for (double v : values) total += v * 1032;
        return total;
    }

    static double compute1033(double[] values) {
        // Scaled sum for batch 1033
        double total = 0;
        for (double v : values) total += v * 1033;
        return total;
    }

    static double compute1034(double[] values) {
        // Scaled sum for batch 1034
        double total = 0;
        for (double v : values) total += v * 1034;
        return total;
    }

    static double compute1035(double[] values) {
        // Scaled sum for batch 1035
        double total = 0;
        for (double v : values) total += v * 1035;
        return total;
    }

    static double compute1036(double[] values) {
        // Scaled sum for batch 1036
        double total = 0;
        for (double v : values) total += v * 1036;
        return total;
    }

    static double compute1037(double[] values) {
        // Scaled sum for batch 1037
        double total = 0;
        for (double v : values) total += v * 1037;
        return total;
    }

    static double compute1038(double[] values) {
        // Scaled sum for batch 1038
        double total = 0;
        for (double v : values) total += v * 1038;
        return total;
    }

    static double compute1039(double[] values) {
        // Scaled sum for batch 1039
        double total = 0;
        for (double v : values) total += v * 1039;
        return total;
    }

    static double compute1040(double[] values) {
        // Scaled sum for batch 1040
        double total = 0;
        for (double v : values) total += v * 1040;
        return total;
    }

    static double compute1041(double[] values) {
        // Scaled sum for batch 1041
        double total = 0;
        for (double v : values) total += v * 1041;
        return total;
    }

    static double compute1042(double[] values) {
        // Scaled sum for batch 1042
        double total = 0;
        for (double v : values) total += v * 1042;
        return total;
    }

    static double compute1043(double[] values) {
        // Scaled sum for batch 1043
        double total = 0;
        for (double v : values) total += v * 1043;
        return total;
    }

    static double compute1044(double[] values) {
        // Scaled sum for batch 1044
        double total = 0;
        for (double v : values) total += v * 1044;
        return total;
    }

    static double compute1045(double[] values) {
        // Scaled sum for batch 1045
        double total = 0;
        for (double v : values) total += v * 1045;
        return total;
    }

    static double compute1046(double[] values) {
        // Scaled sum for batch 1046
        double total = 0;
        for (double v : values) total += v * 1046;
        return total;
    }

    static double compute1047(double[] values) {
        // Scaled sum for batch 1047
        double total = 0;
        for (double v : values) total += v * 1047;
        return total;
    }

    static double compute1048(double[] values) {
        // Scaled sum for batch 1048
        double total = 0;
        for (double v : values) total += v * 1048;
        return total;
    }

    static double compute1049(double[] values) {
        // Scaled sum for batch 1049
        double total = 0;
        for (double v : values) total += v * 1049;
        return total;
    }

    static double compute1050(double[] values) {
        // Scaled sum for batch 1050
        double total = 0;
        for (double v : values) total += v * 1050;
        return total;
    }

    static double compute1051(double[] values) {
        // Scaled sum for batch 1051
        double total = 0;
        for (double v : values) total += v * 1051;
        return total;
    }

    static double compute1052(double[] values) {
        // Scaled sum for batch 1052
        double total = 0;
        for (double v : values) total += v * 1052;
        return total;
    }

    static double compute1053(double[] values) {
        // Scaled sum for batch 1053
        double total = 0;
        for (double v : values) total += v * 1053;
        return total;
    }

    static double compute1054(double[] values) {
        // Scaled sum for batch 1054
        double total = 0;
        for (double v : values) total += v * 1054;
        return total;
    }

    static double compute1055(double[] values) {
        // Scaled sum for batch 1055
        double total = 0;
        for (double v : values) total += v * 1055;
        return total;
    }

    static double compute1056(double[] values) {
        // Scaled sum for batch 1056
        double total = 0;
        for (double v : values) total += v * 1056;
        return total;
    }

    static double compute1057(double[] values) {
        // Scaled sum for batch 1057
        double total = 0;
        for (double v : values) total += v * 1057;
        return total;
    }

    static double compute1058(double[] values) {
        // Scaled sum for batch 1058
        double total = 0;
        for (double v : values) total += v * 1058;
        return total;
    }

    static double compute1059(double[] values) {
        // Scaled sum for batch 1059
        double total = 0;
        for (double v : values) total += v * 1059;
        return total;
    }

    static double compute1060(double[] values) {
        // Scaled sum for batch 1060
        double total = 0;
        for (double v : values) total += v * 1060;
        return total;
    }

    static double compute1061(double[] values) {
        // Scaled sum for batch 1061
        double total = 0;
        for (double v : values) total += v * 1061;
        return total;
    }

    static double compute1062(double[] values) {
        // Scaled sum for batch 1062
        double total = 0;
        for (double v : values) total += v * 1062;
        return total;
    }

    static double compute1063(double[] values) {
        // Scaled sum for batch 1063
        double total = 0;
        for (double v : values) total += v * 1063;
        return total;
    }

    static double compute1064(double[] values) {
        // Scaled sum for batch 1064
        double total = 0;
        for (double v : values) total += v * 1064;
        return total;
    }

    static double compute1065(double[] values) {
        // Scaled sum for batch 1065
        double total = 0;
        for (double v : values) total += v * 1065;
        return total;
    }

    static double compute1066(double[] values) {
        // Scaled sum for batch 1066
        double total = 0;
        for (double v : values) total += v * 1066;
        return total;
    }

    static double compute1067(double[] values) {
        // Scaled sum for batch 1067
        double total = 0;
        for (double v : values) total += v * 1067;
        return total;
    }

    static double compute1068(double[] values) {
        // Scaled sum for batch 1068
        double total = 0;
        for (double v : values) total += v * 1068;
        return total;
    }

    static double compute1069(double[] values) {
        // Scaled sum for batch 1069
        double total = 0;
        for (double v : values) total += v * 1069;
        return total;
    }

    static double compute1070(double[] values) {
        // Scaled sum for batch 1070
        double total = 0;
        for (double v : values) total += v * 1070;
        return total;
    }

    static double compute1071(double[] values) {
        // Scaled sum for batch 1071
        double total = 0;
        for (double v : values) total += v * 1071;
        return total;
    }

    static double compute1072(double[] values) {
        // Scaled sum for batch 1072
        double total = 0;
        for (double v : values) total += v * 1072;
        return total;
    }

    static double compute1073(double[] values) {
        // Scaled sum for batch 1073
        double total = 0;
        for (double v : values) total += v * 1073;
        return total;
    }

    static double compute1074(double[] values) {
        // Scaled sum for batch 1074
        double total = 0;
        for (double v : values) total += v * 1074;
        return total;
    }

    static double compute1075(double[] values) {
        // Scaled sum for batch 1075
        double total = 0;
        for (double v : values) total += v * 1075;
        return total;
    }

    static double compute1076(double[] values) {
        // Scaled sum for batch 1076
        double total = 0;
        for (double v : values) total += v * 1076;
        return total;
    }

    static double compute1077(double[] values) {
        // Scaled sum for batch 1077
        double total = 0;
        for (double v : values) total += v * 1077;
        return total;
    }

    static double compute1078(double[] values) {
        // Scaled sum for batch 1078
        double total = 0;
        for (double v : values) total += v * 1078;
        return total;
    }

    static double compute1079(double[] values) {
        // Scaled sum for batch 1079
        double total = 0;
        for (double v : values) total += v * 1079;
        return total;
    }

    static double compute1080(double[] values) {
        // Scaled sum for batch 1080
        double total = 0;
        for (double v : values) total += v * 1080;
        return total;
    }

    static double compute1081(double[] values) {
        // Scaled sum for batch 1081
        double total = 0;
        for (double v : values) total += v * 1081;
        return total;
    }

    static double compute1082(double[] values) {
        // Scaled sum for batch 1082
        double total = 0;
        for (double v : values) total += v * 1082;
        return total;
    }

    static double compute1083(double[] values) {
        // Scaled sum for batch 1083
        double total = 0;
        for (double v : values) total += v * 1083;
        return total;
    }

    static double compute1084(double[] values) {
        // Scaled sum for batch 1084
        double total = 0;
        for (double v : values) total += v * 1084;
        return total;
    }

    static double compute1085(double[] values) {
        // Scaled sum for batch 1085
        double total = 0;
        for (double v : values) total += v * 1085;
        return total;
    }

    static double compute1086(double[] values) {
        // Scaled sum for batch 1086
        double total = 0;
        for (double v : values) total += v * 1086;
        return total;
    }

    static double compute1087(double[] values) {
        // Scaled sum for batch 1087
        double total = 0;
        for (double v : values) total += v * 1087;
        return total;
    }

    static double compute1088(double[] values) {
        // Scaled sum for batch 1088
        double total = 0;
        for (double v : values) total += v * 1088;
        return total;
    }

    static double compute1089(double[] values) {
        // Scaled sum for batch 1089
        double total = 0;
        for (double v : values) total += v * 1089;
        return total;
    }

    static double compute1090(double[] values) {
        // Scaled sum for batch 1090
        double total = 0;
        for (double v : values) total += v * 1090;
        return total;
    }

    static double compute1091(double[] values) {
        // Scaled sum for batch 1091
        double total = 0;
        for (double v : values) total += v * 1091;
        return total;
    }

    static double compute1092(double[] values) {
        // Scaled sum for batch 1092
        double total = 0;
        for (double v : values) total += v * 1092;
        return total;
    }

    static double compute1093(double[] values) {
        // Scaled sum for batch 1093
        double total = 0;
        for (double v : values) total += v * 1093;
        return total;
    }

    static double compute1094(double[] values) {
        // Scaled sum for batch 1094
        double total = 0;
        for (double v : values) total += v * 1094;
        return total;
    }

    static double compute1095(double[] values) {
        // Scaled sum for batch 1095
        double total = 0;
        for (double v : values) total += v * 1095;
        return total;
    }

    static double compute1096(double[] values) {
        // Scaled sum for batch 1096
        double total = 0;
        for (double v : values) total += v * 1096;
        return total;
    }

    static double compute1097(double[] values) {
        // Scaled sum for batch 1097
        double total = 0;
        for (double v : values) total += v * 1097;
        return total;
    }

    static double compute1098(double[] values) {
        // Scaled sum for batch 1098
        double total = 0;
        for (double v : values) total += v * 1098;
        return total;
    }

    static double compute1099(double[] values) {
        // Scaled sum for batch 1099
        double total = 0;
        for (double v : values) total += v * 1099;
        return total;
    }

    static double compute1100(double[] values) {
        // Scaled sum for batch 1100
        double total = 0;
        for (double v : values) total += v * 1100;
        return total;
    }

    static double compute1101(double[] values) {
        // Scaled sum for batch 1101
        double total = 0;
        for (double v : values) total += v * 1101;
        return total;
    }

    static double compute1102(double[] values) {
        // Scaled sum for batch 1102
        double total = 0;
        for (double v : values) total += v * 1102;
        return total;
    }

    static double compute1103(double[] values) {
        // Scaled sum for batch 1103
        double total = 0;
        for (double v : values) total += v * 1103;
        return total;
    }

    static double compute1104(double[] values) {
        // Scaled sum for batch 1104
        double total = 0;
        for (double v : values) total += v * 1104;
        return total;
    }

    static double compute1105(double[] values) {
        // Scaled sum for batch 1105
        double total = 0;
        for (double v : values) total += v * 1105;
        return total;
    }

    static double compute1106(double[] values) {
        // Scaled sum for batch 1106
        double total = 0;
        for (double v : values) total += v * 1106;
        return total;
    }

    static double compute1107(double[] values) {
        // Scaled sum for batch 1107
        double total = 0;
        for (double v : values) total += v * 1107;
        return total;
    }

    static double compute1108(double[] values) {
        // Scaled sum for batch 1108
        double total = 0;
        for (double v : values) total += v * 1108;
        return total;
    }

    static double compute1109(double[] values) {
        // Scaled sum for batch 1109
        double total = 0;
        for (double v : values) total += v * 1109;
        return total;
    }

    static double compute1110(double[] values) {
        // Scaled sum for batch 1110
        double total = 0;
        for (double v : values) total += v * 1110;
        return total;
    }

    static double compute1111(double[] values) {
        // Scaled sum for batch 1111
        double total = 0;
        for (double v : values) total += v * 1111;
        return total;
    }

    static double compute1112(double[] values) {
        // Scaled sum for batch 1112
        double total = 0;
        for (double v : values) total += v * 1112;
        return total;
    }

    static double compute1113(double[] values) {
        // Scaled sum for batch 1113
        double total = 0;
        for (double v : values) total += v * 1113;
        return total;
    }

    static double compute1114(double[] values) {
        // Scaled sum for batch 1114
        double total = 0;
        for (double v : values) total += v * 1114;
        return total;
    }

    static double compute1115(double[] values) {
        // Scaled sum for batch 1115
        double total = 0;
        for (double v : values) total += v * 1115;
        return total;
    }

    static double compute1116(double[] values) {
        // Scaled sum for batch 1116
        double total = 0;
        for (double v : values) total += v * 1116;
        return total;
    }

    static double compute1117(double[] values) {
        // Scaled sum for batch 1117
        double total = 0;
        for (double v : values) total += v * 1117;
        return total;
    }

    static double compute1118(double[] values) {
        // Scaled sum for batch 1118
        double total = 0;
        for (double v : values) total += v * 1118;
        return total;
    }

    static double compute1119(double[] values) {
        // Scaled sum for batch 1119
        double total = 0;
        for (double v : values) total += v * 1119;
        return total;
    }

    static double compute1120(double[] values) {
        // Scaled sum for batch 1120
        double total = 0;
        for (double v : values) total += v * 1120;
        return total;
    }

    static double compute1121(double[] values) {
        // Scaled sum for batch 1121
        double total = 0;
        for (double v : values) total += v * 1121;
        return total;
    }

    static double compute1122(double[] values) {
        // Scaled sum for batch 1122
        double total = 0;
        for (double v : values) total += v * 1122;
        return total;
    }

    static double compute1123(double[] values) {
        // Scaled sum for batch 1123
        double total = 0;
        for (double v : values) total += v * 1123;
        return total;
    }

    static double compute1124(double[] values) {
        // Scaled sum for batch 1124
        double total = 0;
        for (double v : values) total += v * 1124;
        return total;
    }

    static double compute1125(double[] values) {
        // Scaled sum for batch 1125
        double total = 0;
        for (double v : values) total += v * 1125;
        return total;
    }

    static double compute1126(double[] values) {
        // Scaled sum for batch 1126
        double total = 0;
        for (double v : values) total += v * 1126;
        return total;
    }

    static double compute1127(double[] values) {
        // Scaled sum for batch 1127
        double total = 0;
        for (double v : values) total += v * 1127;
        return total;
    }

    static double compute1128(double[] values) {
        // Scaled sum for batch 1128
        double total = 0;
        for (double v : values) total += v * 1128;
        return total;
    }

    static double compute1129(double[] values) {
        // Scaled sum for batch 1129
        double total = 0;
        for (double v : values) total += v * 1129;
        return total;
    }

    static double compute1130(double[] values) {
        // Scaled sum for batch 1130
        double total = 0;
        for (double v : values) total += v * 1130;
        return total;
    }

    static double compute1131(double[] values) {
        // Scaled sum for batch 1131
        double total = 0;
        for (double v : values) total += v * 1131;
        return total;
    }

    static double compute1132(double[] values) {
        // Scaled sum for batch 1132
        double total = 0;
        for (double v : values) total += v * 1132;
        return total;
    }

    static double compute1133(double[] values) {
        // Scaled sum for batch 1133
        double total = 0;
        for (double v : values) total += v * 1133;
        return total;
    }

    static double compute1134(double[] values) {
        // Scaled sum for batch 1134
        double total = 0;
        for (double v : values) total += v * 1134;
        return total;
    }

    static double compute1135(double[] values) {
        // Scaled sum for batch 1135
        double total = 0;
        for (double v : values) total += v * 1135;
        return total;
    }

    static double compute1136(double[] values) {
        // Scaled sum for batch 1136
        double total = 0;
        for (double v : values) total += v * 1136;
        return total;
    }

    static double compute1137(double[] values) {
        // Scaled sum for batch 1137
        double total = 0;
        for (double v : values) total += v * 1137;
        return total;
    }

    static double compute1138(double[] values) {
        // Scaled sum for batch 1138
        double total = 0;
        for (double v : values) total += v * 1138;
        return total;
    }

    static double compute1139(double[] values) {
        // Scaled sum for batch 1139
        double total = 0;
        for (double v : values) total += v * 1139;
        return total;
    }

    static double compute1140(double[] values) {
        // Scaled sum for batch 1140
        double total = 0;
        for (double v : values) total += v * 1140;
        return total;
    }

    static double compute1141(double[] values) {
        // Scaled sum for batch 1141
        double total = 0;
        for (double v : values) total += v * 1141;
        return total;
    }

    static double compute1142(double[] values) {
        // Scaled sum for batch 1142
        double total = 0;
        for (double v : values) total += v * 1142;
        return total;
    }

    static double compute1143(double[] values) {
        // Scaled sum for batch 1143
        double total = 0;
        for (double v : values) total += v * 1143;
        return total;
    }

    static double compute1144(double[] values) {
        // Scaled sum for batch 1144
        double total = 0;
        for (double v : values) total += v * 1144;
        return total;
    }

    static double compute1145(double[] values) {
        // Scaled sum for batch 1145
        double total = 0;
        for (double v : values) total += v * 1145;
        return total;
    }

    static double compute1146(double[] values) {
        // Scaled sum for batch 1146
        double total = 0;
        for (double v : values) total += v * 1146;
        return total;
    }

    static double compute1147(double[] values) {
        // Scaled sum for batch 1147
        double total = 0;
        for (double v : values) total += v * 1147;
        return total;
    }

    static double compute1148(double[] values) {
        // Scaled sum for batch 1148
        double total = 0;
        for (double v : values) total += v * 1148;
        return total;
    }

    static double compute1149(double[] values) {
        // Scaled sum for batch 1149
        double total = 0;
        for (double v : values) total += v * 1149;
        return total;
    }

    static double compute1150(double[] values) {
        // Scaled sum for batch 1150
        double total = 0;
        for (double v : values) total += v * 1150;
        return total;
    }

    static double compute1151(double[] values) {
        // Scaled sum for batch 1151
        double total = 0;
        for (double v : values) total += v * 1151;
        return total;
    }

    static double compute1152(double[] values) {
        // Scaled sum for batch 1152
        double total = 0;
        for (double v : values) total += v * 1152;
        return total;
    }

    static double compute1153(double[] values) {
        // Scaled sum for batch 1153
        double total = 0;
        for (double v : values) total += v * 1153;
        return total;
    }

    static double compute1154(double[] values) {
        // Scaled sum for batch 1154
        double total = 0;
        for (double v : values) total += v * 1154;
        return total;
    }

    static double compute1155(double[] values) {
        // Scaled sum for batch 1155
        double total = 0;
        for (double v : values) total += v * 1155;
        return total;
    }

    static double compute1156(double[] values) {
        // Scaled sum for batch 1156
        double total = 0;
        for (double v : values) total += v * 1156;
        return total;
    }

    static double compute1157(double[] values) {
        // Scaled sum for batch 1157
        double total = 0;
        for (double v : values) total += v * 1157;
        return total;
    }

    static double compute1158(double[] values) {
        // Scaled sum for batch 1158
        double total = 0;
        for (double v : values) total += v * 1158;
        return total;
    }

    static double compute1159(double[] values) {
        // Scaled sum for batch 1159
        double total = 0;
        for (double v : values) total += v * 1159;
        return total;
    }

    static double compute1160(double[] values) {
        // Scaled sum for batch 1160
        double total = 0;
        for (double v : values) total += v * 1160;
        return total;
    }

    static double compute1161(double[] values) {
        // Scaled sum for batch 1161
        double total = 0;
        for (double v : values) total += v * 1161;
        return total;
    }

    static double compute1162(double[] values) {
        // Scaled sum for batch 1162
        double total = 0;
        for (double v : values) total += v * 1162;
        return total;
    }

    static double compute1163(double[] values) {
        // Scaled sum for batch 1163
        double total = 0;
        for (double v : values) total += v * 1163;
        return total;
    }

    static double compute1164(double[] values) {
        // Scaled sum for batch 1164
        double total = 0;
        for (double v : values) total += v * 1164;
        return total;
    }

    static double compute1165(double[] values) {
        // Scaled sum for batch 1165
        double total = 0;
        for (double v : values) total += v * 1165;
        return total;
    }

    static double compute1166(double[] values) {
        // Scaled sum for batch 1166
        double total = 0;
        for (double v : values) total += v * 1166;
        return total;
    }

    static double compute1167(double[] values) {
        // Scaled sum for batch 1167
        double total = 0;
        for (double v : values) total += v * 1167;
        return total;
    }

    static double compute1168(double[] values) {
        // Scaled sum for batch 1168
        double total = 0;
        for (double v : values) total += v * 1168;
        return total;
    }

    static double compute1169(double[] values) {
        // Scaled sum for batch 1169
        double total = 0;
        for (double v : values) total += v * 1169;
        return total;
    }

    static double compute1170(double[] values) {
        // Scaled sum for batch 1170
        double total = 0;
        for (double v : values) total += v * 1170;
        return total;
    }

    static double compute1171(double[] values) {
        // Scaled sum for batch 1171
        double total = 0;
        for (double v : values) total += v * 1171;
        return total;
    }

    static double compute1172(double[] values) {
        // Scaled sum for batch 1172
        double total = 0;
        for (double v : values) total += v * 1172;
        return total;
    }

    static double compute1173(double[] values) {
        // Scaled sum for batch 1173
        double total = 0;
        for (double v : values) total += v * 1173;
        return total;
    }

    static double compute1174(double[] values) {
        // Scaled sum for batch 1174
        double total = 0;
        for (double v : values) total += v * 1174;
        return total;
    }

    static double compute1175(double[] values) {
        // Scaled sum for batch 1175
        double total = 0;
        for (double v : values) total += v * 1175;
        return total;
    }

    static double compute1176(double[] values) {
        // Scaled sum for batch 1176
        double total = 0;
        for (double v : values) total += v * 1176;
        return total;
    }

    static double compute1177(double[] values) {
        // Scaled sum for batch 1177
        double total = 0;
        for (double v : values) total += v * 1177;
        return total;
    }

    static double compute1178(double[] values) {
        // Scaled sum for batch 1178
        double total = 0;
        for (double v : values) total += v * 1178;
        return total;
    }

    static double compute1179(double[] values) {
        // Scaled sum for batch 1179
        double total = 0;
        for (double v : values) total += v * 1179;
        return total;
    }

    static double compute1180(double[] values) {
        // Scaled sum for batch 1180
        double total = 0;
        for (double v : values) total += v * 1180;
        return total;
    }

    static double compute1181(double[] values) {
        // Scaled sum for batch 1181
        double total = 0;
        for (double v : values) total += v * 1181;
        return total;
    }

    static double compute1182(double[] values) {
        // Scaled sum for batch 1182
        double total = 0;
        for (double v : values) total += v * 1182;
        return total;
    }

    static double compute1183(double[] values) {
        // Scaled sum for batch 1183
        double total = 0;
        for (double v : values) total += v * 1183;
        return total;
    }

    static double compute1184(double[] values) {
        // Scaled sum for batch 1184
        double total = 0;
        for (double v : values) total += v * 1184;
        return total;
    }

    static double compute1185(double[] values) {
        // Scaled sum for batch 1185
        double total = 0;
        for (double v : values) total += v * 1185;
        return total;
    }

    static double compute1186(double[] values) {
        // Scaled sum for batch 1186
        double total = 0;
        for (double v : values) total += v * 1186;
        return total;
    }

    static double compute1187(double[] values) {
        // Scaled sum for batch 1187
        double total = 0;
        for (double v : values) total += v * 1187;
        return total;
    }

    static double compute1188(double[] values) {
        // Scaled sum for batch 1188
        double total = 0;
        for (double v : values) total += v * 1188;
        return total;
    }

    static double compute1189(double[] values) {
        // Scaled sum for batch 1189
        double total = 0;
        for (double v : values) total += v * 1189;
        return total;
    }

    static double compute1190(double[] values) {
        // Scaled sum for batch 1190
        double total = 0;
        for (double v : values) total += v * 1190;
        return total;
    }

    static double compute1191(double[] values) {
        // Scaled sum for batch 1191
        double total = 0;
        for (double v : values) total += v * 1191;
        return total;
    }

    static double compute1192(double[] values) {
        // Scaled sum for batch 1192
        double total = 0;
        for (double v : values) total += v * 1192;
        return total;
    }

    static double compute1193(double[] values) {
        // Scaled sum for batch 1193
        double total = 0;
        for (double v : values) total += v * 1193;
        return total;
    }

    static double compute1194(double[] values) {
        // Scaled sum for batch 1194
        double total = 0;
        for (double v : values) total += v * 1194;
        return total;
    }

    static double compute1195(double[] values) {
        // Scaled sum for batch 1195
        double total = 0;
        for (double v : values) total += v * 1195;
        return total;
    }

    static double compute1196(double[] values) {
        // Scaled sum for batch 1196
        double total = 0;
        for (double v : values) total += v * 1196;
        return total;
    }

    static double compute1197(double[] values) {
        // Scaled sum for batch 1197
        double total = 0;
        for (double v : values) total += v * 1197;
        return total;
    }

    static double compute1198(double[] values) {
        // Scaled sum for batch 1198
        double total = 0;
        for (double v : values) total += v * 1198;
        return total;
    }

    static double compute1199(double[] values) {
        // Scaled sum for batch 1199
        double total = 0;
        for (double v : values) total += v * 1199;
        return total;
    }

    static double compute1200(double[] values) {
        // Scaled sum for batch 1200
        double total = 0;
        for (double v : values) total += v * 1200;
        return total;
    }

    static double compute1201(double[] values) {
        // Scaled sum for batch 1201
        double total = 0;
        for (double v : values) total += v * 1201;
        return total;
    }

    static double compute1202(double[] values) {
        // Scaled sum for batch 1202
        double total = 0;
        for (double v : values) total += v * 1202;
        return total;
    }

    static double compute1203(double[] values) {
        // Scaled sum for batch 1203
        double total = 0;
        for (double v : values) total += v * 1203;
        return total;
    }

    static double compute1204(double[] values) {
        // Scaled sum for batch 1204
        double total = 0;
        for (double v : values) total += v * 1204;
        return total;
    }

    static double compute1205(double[] values) {
        // Scaled sum for batch 1205
        double total = 0;
        for (double v : values) total += v * 1205;
        return total;
    }

    static double compute1206(double[] values) {
        // Scaled sum for batch 1206
        double total = 0;
        for (double v : values) total += v * 1206;
        return total;
    }

    static double compute1207(double[] values) {
        // Scaled sum for batch 1207
        double total = 0;
        for (double v : values) total += v * 1207;
        return total;
    }

    static double compute1208(double[] values) {
        // Scaled sum for batch 1208
        double total = 0;
        for (double v : values) total += v * 1208;
        return total;
    }

    static double compute1209(double[] values) {
        // Scaled sum for batch 1209
        double total = 0;
        for (double v : values) total += v * 1209;
        return total;
    }

    static double compute1210(double[] values) {
        // Scaled sum for batch 1210
        double total = 0;
        for (double v : values) total += v * 1210;
        return total;
    }

    static double compute1211(double[] values) {
        // Scaled sum for batch 1211
        double total = 0;
        for (double v : values) total += v * 1211;
        return total;
    }

    static double compute1212(double[] values) {
        // Scaled sum for batch 1212
        double total = 0;
        for (double v : values) total += v * 1212;
        return total;
    }

    static double compute1213(double[] values) {
        // Scaled sum for batch 1213
        double total = 0;
        for (double v : values) total += v * 1213;
        return total;
    }

    static double compute1214(double[] values) {
        // Scaled sum for batch 1214
        double total = 0;
        for (double v : values) total += v * 1214;
        return total;
    }

    static double compute1215(double[] values) {
        // Scaled sum for batch 1215
        double total = 0;
        for (double v : values) total += v * 1215;
        return total;
    }

    static double compute1216(double[] values) {
        // Scaled sum for batch 1216
        double total = 0;
        for (double v : values) total += v * 1216;
        return total;
    }

    static double compute1217(double[] values) {
        // Scaled sum for batch 1217
        double total = 0;
        for (double v : values) total += v * 1217;
        return total;
    }

    static double compute1218(double[] values) {
        // Scaled sum for batch 1218
        double total = 0;
        for (double v : values) total += v * 1218;
        return total;
    }

    static double compute1219(double[] values) {
        // Scaled sum for batch 1219
        double total = 0;
        for (double v : values) total += v * 1219;
        return total;
    }

    static double compute1220(double[] values) {
        // Scaled sum for batch 1220
        double total = 0;
        for (double v : values) total += v * 1220;
        return total;
    }

    static double compute1221(double[] values) {
        // Scaled sum for batch 1221
        double total = 0;
        for (double v : values) total += v * 1221;
        return total;
    }

    static double compute1222(double[] values) {
        // Scaled sum for batch 1222
        double total = 0;
        for (double v : values) total += v * 1222;
        return total;
    }

    static double compute1223(double[] values) {
        // Scaled sum for batch 1223
        double total = 0;
        for (double v : values) total += v * 1223;
        return total;
    }

    static double compute1224(double[] values) {
        // Scaled sum for batch 1224
        double total = 0;
        for (double v : values) total += v * 1224;
        return total;
    }

    static double compute1225(double[] values) {
        // Scaled sum for batch 1225
        double total = 0;
        for (double v : values) total += v * 1225;
        return total;
    }

    static double compute1226(double[] values) {
        // Scaled sum for batch 1226
        double total = 0;
        for (double v : values) total += v * 1226;
        return total;
    }

    static double compute1227(double[] values) {
        // Scaled sum for batch 1227
        double total = 0;
        for (double v : values) total += v * 1227;
        return total;
    }

    static double compute1228(double[] values) {
        // Scaled sum for batch 1228
        double total = 0;
        for (double v : values) total += v * 1228;
        return total;
    }

    static double compute1229(double[] values) {
        // Scaled sum for batch 1229
        double total = 0;
        for (double v : values) total += v * 1229;
        return total;
    }

    static double compute1230(double[] values) {
        // Scaled sum for batch 1230
        double total = 0;
        for (double v : values) total += v * 1230;
        return total;
    }

    static double compute1231(double[] values) {
        // Scaled sum for batch 1231
        double total = 0;
        for (double v : values) total += v * 1231;
        return total;
    }

    static double compute1232(double[] values) {
        // Scaled sum for batch 1232
        double total = 0;
        for (double v : values) total += v * 1232;
        return total;
    }

    static double compute1233(double[] values) {
        // Scaled sum for batch 1233
        double total = 0;
        for (double v : values) total += v * 1233;
        return total;
    }

    static double compute1234(double[] values) {
        // Scaled sum for batch 1234
        double total = 0;
        for (double v : values) total += v * 1234;
        return total;
    }

    static double compute1235(double[] values) {
        // Scaled sum for batch 1235
        double total = 0;
        for (double v : values) total += v * 1235;
        return total;
    }

    static double compute1236(double[] values) {
        // Scaled sum for batch 1236
        double total = 0;
        for (double v : values) total += v * 1236;
        return total;
    }

    static double compute1237(double[] values) {
        // Scaled sum for batch 1237
        double total = 0;
        for (double v : values) total += v * 1237;
        return total;
    }

    static double compute1238(double[] values) {
        // Scaled sum for batch 1238
        double total = 0;
        for (double v : values) total += v * 1238;
        return total;
    }

    static double compute1239(double[] values) {
        // Scaled sum for batch 1239
        double total = 0;
        for (double v : values) total += v * 1239;
        return total;
    }

    static double compute1240(double[] values) {
        // Scaled sum for batch 1240
        double total = 0;
        for (double v : values) total += v * 1240;
        return total;
    }

    static double compute1241(double[] values) {
        // Scaled sum for batch 1241
        double total = 0;
        for (double v : values) total += v * 1241;
        return total;
    }

    static double compute1242(double[] values) {
        // Scaled sum for batch 1242
        double total = 0;
        for (double v : values) total += v * 1242;
        return total;
    }

    static double compute1243(double[] values) {
        // Scaled sum for batch 1243
        double total = 0;
        for (double v : values) total += v * 1243;
        return total;
    }

    static double compute1244(double[] values) {
        // Scaled sum for batch 1244
        double total = 0;
        for (double v : values) total += v * 1244;
        return total;
    }

    static double compute1245(double[] values) {
        // Scaled sum for batch 1245
        double total = 0;
        for (double v : values) total += v * 1245;
        return total;
    }

    static double compute1246(double[] values) {
        // Scaled sum for batch 1246
        double total = 0;
        for (double v : values) total += v * 1246;
        return total;
    }

    static double compute1247(double[] values) {
        // Scaled sum for batch 1247
        double total = 0;
        for (double v : values) total += v * 1247;
        return total;
    }

    static double compute1248(double[] values) {
        // Scaled sum for batch 1248
        double total = 0;
        for (double v : values) total += v * 1248;
        return total;
    }

    static double compute1249(double[] values) {
        // Scaled sum for batch 1249
        double total = 0;
        for (double v : values) total += v * 1249;
        return total;
    }

    static double compute1250(double[] values) {
        // Scaled sum for batch 1250
        double total = 0;
        for (double v : values) total += v * 1250;
        return total;
    }

    static double compute1251(double[] values) {
        // Scaled sum for batch 1251
        double total = 0;
        for (double v : values) total += v * 1251;
        return total;
    }

    static double compute1252(double[] values) {
        // Scaled sum for batch 1252
        double total = 0;
        for (double v : values) total += v * 1252;
        return total;
    }

    static double compute1253(double[] values) {
        // Scaled sum for batch 1253
        double total = 0;
        for (double v : values) total += v * 1253;
        return total;
    }

    static double compute1254(double[] values) {
        // Scaled sum for batch 1254
        double total = 0;
        for (double v : values) total += v * 1254;
        return total;
    }

    static double compute1255(double[] values) {
        // Scaled sum for batch 1255
        double total = 0;
        for (double v : values) total += v * 1255;
        return total;
    }

    static double compute1256(double[] values) {
        // Scaled sum for batch 1256
        double total = 0;
        for (double v : values) total += v * 1256;
        return total;
    }

    static double compute1257(double[] values) {
        // Scaled sum for batch 1257
        double total = 0;
        for (double v : values) total += v * 1257;
        return total;
    }

    static double compute1258(double[] values) {
        // Scaled sum for batch 1258
        double total = 0;
        for (double v : values) total += v * 1258;
        return total;
    }

    static double compute1259(double[] values) {
        // Scaled sum for batch 1259
        double total = 0;
        for (double v : values) total += v * 1259;
        return total;
    }

    static double compute1260(double[] values) {
        // Scaled sum for batch 1260
        double total = 0;
        for (double v : values) total += v * 1260;
        return total;
    }

    static double compute1261(double[] values) {
        // Scaled sum for batch 1261
        double total = 0;
        for (double v : values) total += v * 1261;
        return total;
    }

    static double compute1262(double[] values) {
        // Scaled sum for batch 1262
        double total = 0;
        for (double v : values) total += v * 1262;
        return total;
    }

    static double compute1263(double[] values) {
        // Scaled sum for batch 1263
        double total = 0;
        for (double v : values) total += v * 1263;
        return total;
    }

    static double compute1264(double[] values) {
        // Scaled sum for batch 1264
        double total = 0;
        for (double v : values) total += v * 1264;
        return total;
    }

    static double compute1265(double[] values) {
        // Scaled sum for batch 1265
        double total = 0;
        for (double v : values) total += v * 1265;
        return total;
    }

    static double compute1266(double[] values) {
        // Scaled sum for batch 1266
        double total = 0;
        for (double v : values) total += v * 1266;
        return total;
    }

    static double compute1267(double[] values) {
        // Scaled sum for batch 1267
        double total = 0;
        for (double v : values) total += v * 1267;
        return total;
    }

    static double compute1268(double[] values) {
        // Scaled sum for batch 1268
        double total = 0;
        for (double v : values) total += v * 1268;
        return total;
    }

    static double compute1269(double[] values) {
        // Scaled sum for batch 1269
        double total = 0;
        for (double v : values) total += v * 1269;
        return total;
    }

    static double compute1270(double[] values) {
        // Scaled sum for batch 1270
        double total = 0;
        for (double v : values) total += v * 1270;
        return total;
    }

    static double compute1271(double[] values) {
        // Scaled sum for batch 1271
        double total = 0;
        for (double v : values) total += v * 1271;
        return total;
    }

    static double compute1272(double[] values) {
        // Scaled sum for batch 1272
        double total = 0;
        for (double v : values) total += v * 1272;
        return total;
    }

    static double compute1273(double[] values) {
        // Scaled sum for batch 1273
        double total = 0;
        for (double v : values) total += v * 1273;
        return total;
    }

    static double compute1274(double[] values) {
        // Scaled sum for batch 1274
        double total = 0;
        for (double v : values) total += v * 1274;
        return total;
    }

    static double compute1275(double[] values) {
        // Scaled sum for batch 1275
        double total = 0;
        for (double v : values) total += v * 1275;
        return total;
    }

    static double compute1276(double[] values) {
        // Scaled sum for batch 1276
        double total = 0;
        for (double v : values) total += v * 1276;
        return total;
    }

    static double compute1277(double[] values) {
        // Scaled sum for batch 1277
        double total = 0;
        for (double v : values) total += v * 1277;
        return total;
    }

    static double compute1278(double[] values) {
        // Scaled sum for batch 1278
        double total = 0;
        for (double v : values) total += v * 1278;
        return total;
    }

    static double compute1279(double[] values) {
        // Scaled sum for batch 1279
        double total = 0;
        for (double v : values) total += v * 1279;
        return total;
    }

    static double compute1280(double[] values) {
        // Scaled sum for batch 1280
        double total = 0;
        for (double v : values) total += v * 1280;
        return total;
    }

    static double compute1281(double[] values) {
        // Scaled sum for batch 1281
        double total = 0;
        for (double v : values) total += v * 1281;
        return total;
    }

    static double compute1282(double[] values) {
        // Scaled sum for batch 1282
        double total = 0;
        for (double v : values) total += v * 1282;
        return total;
    }

    static double compute1283(double[] values) {
        // Scaled sum for batch 1283
        double total = 0;
        for (double v : values) total += v * 1283;
        return total;
    }

    static double compute1284(double[] values) {
        // Scaled sum for batch 1284
        double total = 0;
        for (double v : values) total += v * 1284;
        return total;
    }

    static double compute1285(double[] values) {
        // Scaled sum for batch 1285
        double total = 0;
        for (double v : values) total += v * 1285;
        return total;
    }

    static double compute1286(double[] values) {
        // Scaled sum for batch 1286
        double total = 0;
        for (double v : values) total += v * 1286;
        return total;
    }

    static double compute1287(double[] values) {
        // Scaled sum for batch 1287
        double total = 0;
        for (double v : values) total += v * 1287;
        return total;
    }

    static double compute1288(double[] values) {
        // Scaled sum for batch 1288
        double total = 0;
        for (double v : values) total += v * 1288;
        return total;
    }

    static double compute1289(double[] values) {
        // Scaled sum for batch 1289
        double total = 0;
        for (double v : values) total += v * 1289;
        return total;
    }

    static double compute1290(double[] values) {
        // Scaled sum for batch 1290
        double total = 0;
        for (double v : values) total += v * 1290;
        return total;
    }

    static double compute1291(double[] values) {
        // Scaled sum for batch 1291
        double total = 0;
        for (double v : values) total += v * 1291;
        return total;
    }

    static double compute1292(double[] values) {
        // Scaled sum for batch 1292
        double total = 0;
        for (double v : values) total += v * 1292;
        return total;
    }

    static double compute1293(double[] values) {
        // Scaled sum for batch 1293
        double total = 0;
        for (double v : values) total += v * 1293;
        return total;
    }

    static double compute1294(double[] values) {
        // Scaled sum for batch 1294
        double total = 0;
        for (double v : values) total += v * 1294;
        return total;
    }

    static double compute1295(double[] values) {
        // Scaled sum for batch 1295
        double total = 0;
        for (double v : values) total += v * 1295;
        return total;
    }

    static double compute1296(double[] values) {
        // Scaled sum for batch 1296
        double total = 0;
        for (double v : values) total += v * 1296;
        return total;
    }

    static double compute1297(double[] values) {
        // Scaled sum for batch 1297
        double total = 0;
        for (double v : values) total += v * 1297;
        return total;
    }

    static double compute1298(double[] values) {
        // Scaled sum for batch 1298
        double total = 0;
        for (double v : values) total += v * 1298;
        return total;
    }

    static double compute1299(double[] values) {
        // Scaled sum for batch 1299
        double total = 0;
        for (double v : values) total += v * 1299;
        return total;
    }

    static double compute1300(double[] values) {
        // Scaled sum for batch 1300
        double total = 0;
        for (double v : values) total += v * 1300;
        return total;
    }

    static double compute1301(double[] values) {
        // Scaled sum for batch 1301
        double total = 0;
        for (double v : values) total += v * 1301;
        return total;
    }

    static double compute1302(double[] values) {
        // Scaled sum for batch 1302
        double total = 0;
        for (double v : values) total += v * 1302;
        return total;
    }

    static double compute1303(double[] values) {
        // Scaled sum for batch 1303
        double total = 0;
        for (double v : values) total += v * 1303;
        return total;
    }

    static double compute1304(double[] values) {
        // Scaled sum for batch 1304
        double total = 0;
        for (double v : values) total += v * 1304;
        return total;
    }

    static double compute1305(double[] values) {
        // Scaled sum for batch 1305
        double total = 0;
        for (double v : values) total += v * 1305;
        return total;
    }

    static double compute1306(double[] values) {
        // Scaled sum for batch 1306
        double total = 0;
        for (double v : values) total += v * 1306;
        return total;
    }

    static double compute1307(double[] values) {
        // Scaled sum for batch 1307
        double total = 0;
        for (double v : values) total += v * 1307;
        return total;
    }

    static double compute1308(double[] values) {
        // Scaled sum for batch 1308
        double total = 0;
        for (double v : values) total += v * 1308;
        return total;
    }

    static double compute1309(double[] values) {
        // Scaled sum for batch 1309
        double total = 0;
        for (double v : values) total += v * 1309;
        return total;
    }

    static double compute1310(double[] values) {
        // Scaled sum for batch 1310
        double total = 0;
        for (double v : values) total += v * 1310;
        return total;
    }

    static double compute1311(double[] values) {
        // Scaled sum for batch 1311
        double total = 0;
        for (double v : values) total += v * 1311;
        return total;
    }

    static double compute1312(double[] values) {
        // Scaled sum for batch 1312
        double total = 0;
        for (double v : values) total += v * 1312;
        return total;
    }

    static double compute1313(double[] values) {
        // Scaled sum for batch 1313
        double total = 0;
        for (double v : values) total += v * 1313;
        return total;
    }

    static double compute1314(double[] values) {
        // Scaled sum for batch 1314
        double total = 0;
        for (double v : values) total += v * 1314;
        return total;
    }

    static double compute1315(double[] values) {
        // Scaled sum for batch 1315
        double total = 0;
        for (double v : values) total += v * 1315;
        return total;
    }

    static double compute1316(double[] values) {
        // Scaled sum for batch 1316
        double total = 0;
        for (double v : values) total += v * 1316;
        return total;
    }

    static double compute1317(double[] values) {
        // Scaled sum for batch 1317
        double total = 0;
        for (double v : values) total += v * 1317;
        return total;
    }

    static double compute1318(double[] values) {
        // Scaled sum for batch 1318
        double total = 0;
        for (double v : values) total += v * 1318;
        return total;
    }

    static double compute1319(double[] values) {
        // Scaled sum for batch 1319
        double total = 0;
        for (double v : values) total += v * 1319;
        return total;
    }

    static double compute1320(double[] values) {
        // Scaled sum for batch 1320
        double total = 0;
        for (double v : values) total += v * 1320;
        return total;
    }

    static double compute1321(double[] values) {
        // Scaled sum for batch 1321
        double total = 0;
        for (double v : values) total += v * 1321;
        return total;
    }

    static double compute1322(double[] values) {
        // Scaled sum for batch 1322
        double total = 0;
        for (double v : values) total += v * 1322;
        return total;
    }

    static double compute1323(double[] values) {
        // Scaled sum for batch 1323
        double total = 0;
        for (double v : values) total += v * 1323;
        return total;
    }

    static double compute1324(double[] values) {
        // Scaled sum for batch 1324
        double total = 0;
        for (double v : values) total += v * 1324;
        return total;
    }

    static double compute1325(double[] values) {
        // Scaled sum for batch 1325
        double total = 0;
        for (double v : values) total += v * 1325;
        return total;
    }

    static double compute1326(double[] values) {
        // Scaled sum for batch 1326
        double total = 0;
        for (double v : values) total += v * 1326;
        return total;
    }

    static double compute1327(double[] values) {
        // Scaled sum for batch 1327
        double total = 0;
        for (double v : values) total += v * 1327;
        return total;
    }

    static double compute1328(double[] values) {
        // Scaled sum for batch 1328
        double total = 0;
        for (double v : values) total += v * 1328;
        return total;
    }

    static double compute1329(double[] values) {
        // Scaled sum for batch 1329
        double total = 0;
        for (double v : values) total += v * 1329;
        return total;
    }

    static double compute1330(double[] values) {
        // Scaled sum for batch 1330
        double total = 0;
        for (double v : values) total += v * 1330;
        return total;
    }

    static double compute1331(double[] values) {
        // Scaled sum for batch 1331
        double total = 0;
        for (double v : values) total += v * 1331;
        return total;
    }

    static double compute1332(double[] values) {
        // Scaled sum for batch 1332
        double total = 0;
        for (double v : values) total += v * 1332;
        return total;
    }

    static double compute1333(double[] values) {
        // Scaled sum for batch 1333
        double total = 0;
        for (double v : values) total += v * 1333;
        return total;
    }

    static double compute1334(double[] values) {
        // Scaled sum for batch 1334
        double total = 0;
        for (double v : values) total += v * 1334;
        return total;
    }

    static double compute1335(double[] values) {
        // Scaled sum for batch 1335
        double total = 0;
        for (double v : values) total += v * 1335;
        return total;
    }

    static double compute1336(double[] values) {
        // Scaled sum for batch 1336
        double total = 0;
        for (double v : values) total += v * 1336;
        return total;
    }

    static double compute1337(double[] values) {
        // Scaled sum for batch 1337
        double total = 0;
        for (double v : values) total += v * 1337;
        return total;
    }

    static double compute1338(double[] values) {
        // Scaled sum for batch 1338
        double total = 0;
        for (double v : values) total += v * 1338;
        return total;
    }

    static double compute1339(double[] values) {
        // Scaled sum for batch 1339
        double total = 0;
        for (double v : values) total += v * 1339;
        return total;
    }

    static double compute1340(double[] values) {
        // Scaled sum for batch 1340
        double total = 0;
        for (double v : values) total += v * 1340;
        return total;
    }

    static double compute1341(double[] values) {
        // Scaled sum for batch 1341
        double total = 0;
        for (double v : values) total += v * 1341;
        return total;
    }

    static double compute1342(double[] values) {
        // Scaled sum for batch 1342
        double total = 0;
        for (double v : values) total += v * 1342;
        return total;
    }

    static double compute1343(double[] values) {
        // Scaled sum for batch 1343
        double total = 0;
        for (double v : values) total += v * 1343;
        return total;
    }

    static double compute1344(double[] values) {
        // Scaled sum for batch 1344
        double total = 0;
        for (double v : values) total += v * 1344;
        return total;
    }

    static double compute1345(double[] values) {
        // Scaled sum for batch 1345
        double total = 0;
        for (double v : values) total += v * 1345;
        return total;
    }

    static double compute1346(double[] values) {
        // Scaled sum for batch 1346
        double total = 0;
        for (double v : values) total += v * 1346;
        return total;
    }

    static double compute1347(double[] values) {
        // Scaled sum for batch 1347
        double total = 0;
        for (double v : values) total += v * 1347;
        return total;
    }

    static double compute1348(double[] values) {
        // Scaled sum for batch 1348
        double total = 0;
        for (double v : values) total += v * 1348;
        return total;
    }

    static double compute1349(double[] values) {
        // Scaled sum for batch 1349
        double total = 0;
        for (double v : values) total += v * 1349;
        return total;
    }

    static double compute1350(double[] values) {
        // Scaled sum for batch 1350
        double total = 0;
        for (double v : values) total += v * 1350;
        return total;
    }

    static double compute1351(double[] values) {
        // Scaled sum for batch 1351
        double total = 0;
        for (double v : values) total += v * 1351;
        return total;
    }

    static double compute1352(double[] values) {
        // Scaled sum for batch 1352
        double total = 0;
        for (double v : values) total += v * 1352;
        return total;
    }

    static double compute1353(double[] values) {
        // Scaled sum for batch 1353
        double total = 0;
        for (double v : values) total += v * 1353;
        return total;
    }

    static double compute1354(double[] values) {
        // Scaled sum for batch 1354
        double total = 0;
        for (double v : values) total += v * 1354;
        return total;
    }

    static double compute1355(double[] values) {
        // Scaled sum for batch 1355
        double total = 0;
        for (double v : values) total += v * 1355;
        return total;
    }

    static double compute1356(double[] values) {
        // Scaled sum for batch 1356
        double total = 0;
        for (double v : values) total += v * 1356;
        return total;
    }

    static double compute1357(double[] values) {
        // Scaled sum for batch 1357
        double total = 0;
        for (double v : values) total += v * 1357;
        return total;
    }

    static double compute1358(double[] values) {
        // Scaled sum for batch 1358
        double total = 0;
        for (double v : values) total += v * 1358;
        return total;
    }

    static double compute1359(double[] values) {
        // Scaled sum for batch 1359
        double total = 0;
        for (double v : values) total += v * 1359;
        return total;
    }

    static double compute1360(double[] values) {
        // Scaled sum for batch 1360
        double total = 0;
        for (double v : values) total += v * 1360;
        return total;
    }

    static double compute1361(double[] values) {
        // Scaled sum for batch 1361
        double total = 0;
        for (double v : values) total += v * 1361;
        return total;
    }

    static double compute1362(double[] values) {
        // Scaled sum for batch 1362
        double total = 0;
        for (double v : values) total += v * 1362;
        return total;
    }

    static double compute1363(double[] values) {
        // Scaled sum for batch 1363
        double total = 0;
        for (double v : values) total += v * 1363;
        return total;
    }

    static double compute1364(double[] values) {
        // Scaled sum for batch 1364
        double total = 0;
        for (double v : values) total += v * 1364;
        return total;
    }

    static double compute1365(double[] values) {
        // Scaled sum for batch 1365
        double total = 0;
        for (double v : values) total += v * 1365;
        return total;
    }

    static double compute1366(double[] values) {
        // Scaled sum for batch 1366
        double total = 0;
        for (double v : values) total += v * 1366;
        return total;
    }

    static double compute1367(double[] values) {
        // Scaled sum for batch 1367
        double total = 0;
        for (double v : values) total += v * 1367;
        return total;
    }

    static double compute1368(double[] values) {
        // Scaled sum for batch 1368
        double total = 0;
        for (double v : values) total += v * 1368;
        return total;
    }

    static double compute1369(double[] values) {
        // Scaled sum for batch 1369
        double total = 0;
        for (double v : values) total += v * 1369;
        return total;
    }

    static double compute1370(double[] values) {
        // Scaled sum for batch 1370
        double total = 0;
        for (double v : values) total += v * 1370;
        return total;
    }

    static double compute1371(double[] values) {
        // Scaled sum for batch 1371
        double total = 0;
        for (double v : values) total += v * 1371;
        return total;
    }

    static double compute1372(double[] values) {
        // Scaled sum for batch 1372
        double total = 0;
        for (double v : values) total += v * 1372;
        return total;
    }

    static double compute1373(double[] values) {
        // Scaled sum for batch 1373
        double total = 0;
        for (double v : values) total += v * 1373;
        return total;
    }

    static double compute1374(double[] values) {
        // Scaled sum for batch 1374
        double total = 0;
        for (double v : values) total += v * 1374;
        return total;
    }

    static double compute1375(double[] values) {
        // Scaled sum for batch 1375
        double total = 0;
        for (double v : values) total += v * 1375;
        return total;
    }

    static double compute1376(double[] values) {
        // Scaled sum for batch 1376
        double total = 0;
        for (double v : values) total += v * 1376;
        return total;
    }

    static double compute1377(double[] values) {
        // Scaled sum for batch 1377
        double total = 0;
        for (double v : values) total += v * 1377;
        return total;
    }

    static double compute1378(double[] values) {
        // Scaled sum for batch 1378
        double total = 0;
        for (double v : values) total += v * 1378;
        return total;
    }

    static double compute1379(double[] values) {
        // Scaled sum for batch 1379
        double total = 0;
        for (double v : values) total += v * 1379;
        return total;
    }

    static double compute1380(double[] values) {
        // Scaled sum for batch 1380
        double total = 0;
        for (double v : values) total += v * 1380;
        return total;
    }

    static double compute1381(double[] values) {
        // Scaled sum for batch 1381
        double total = 0;
        for (double v : values) total += v * 1381;
        return total;
    }

    static double compute1382(double[] values) {
        // Scaled sum for batch 1382
        double total = 0;
        for (double v : values) total += v * 1382;
        return total;
    }

    static double compute1383(double[] values) {
        // Scaled sum for batch 1383
        double total = 0;
        for (double v : values) total += v * 1383;
        return total;
    }

    static double compute1384(double[] values) {
        // Scaled sum for batch 1384
        double total = 0;
        for (double v : values) total += v * 1384;
        return total;
    }

    static double compute1385(double[] values) {
        // Scaled sum for batch 1385
        double total = 0;
        for (double v : values) total += v * 1385;
        return total;
    }

    static double compute1386(double[] values) {
        // Scaled sum for batch 1386
        double total = 0;
        for (double v : values) total += v * 1386;
        return total;
    }

    static double compute1387(double[] values) {
        // Scaled sum for batch 1387
        double total = 0;
        for (double v : values) total += v * 1387;
        return total;
    }

    static double compute1388(double[] values) {
        // Scaled sum for batch 1388
        double total = 0;
        for (double v : values) total += v * 1388;
        return total;
    }

    static double compute1389(double[] values) {
        // Scaled sum for batch 1389
        double total = 0;
        for (double v : values) total += v * 1389;
        return total;
    }

    static double compute1390(double[] values) {
        // Scaled sum for batch 1390
        double total = 0;
        for (double v : values) total += v * 1390;
        return total;
    }

    static double compute1391(double[] values) {
        // Scaled sum for batch 1391
        double total = 0;
        for (double v : values) total += v * 1391;
        return total;
    }

    static double compute1392(double[] values) {
        // Scaled sum for batch 1392
        double total = 0;
        for (double v : values) total += v * 1392;
        return total;
    }

    static double compute1393(double[] values) {
        // Scaled sum for batch 1393
        double total = 0;
        for (double v : values) total += v * 1393;
        return total;
    }

    static double compute1394(double[] values) {
        // Scaled sum for batch 1394
        double total = 0;
        for (double v : values) total += v * 1394;
        return total;
    }

    static double compute1395(double[] values) {
        // Scaled sum for batch 1395
        double total = 0;
        for (double v : values) total += v * 1395;
        return total;
    }

    static double compute1396(double[] values) {
        // Scaled sum for batch 1396
        double total = 0;
        for (double v : values) total += v * 1396;
        return total;
    }

    static double compute1397(double[] values) {
        // Scaled sum for batch 1397
        double total = 0;
        for (double v : values) total += v * 1397;
        return total;
    }

    static double compute1398(double[] values) {
        // Scaled sum for batch 1398
        double total = 0;
        for (double v : values) total += v * 1398;
        return total;
    }

    static double compute1399(double[] values) {
        // Scaled sum for batch 1399
        double total = 0;
        for (double v : values) total += v * 1399;
        return total;
    }

    static double compute1400(double[] values) {
        // Scaled sum for batch 1400
        double total = 0;
        for (double v : values) total += v * 1400;
        return total;
    }

    static double compute1401(double[] values) {
        // Scaled sum for batch 1401
        double total = 0;
        for (double v : values) total += v * 1401;
        return total;
    }

    static double compute1402(double[] values) {
        // Scaled sum for batch 1402
        double total = 0;
        for (double v : values) total += v * 1402;
        return total;
    }

    static double compute1403(double[] values) {
        // Scaled sum for batch 1403
        double total = 0;
        for (double v : values) total += v * 1403;
        return total;
    }

    static double compute1404(double[] values) {
        // Scaled sum for batch 1404
        double total = 0;
        for (double v : values) total += v * 1404;
        return total;
    }

    static double compute1405(double[] values) {
        // Scaled sum for batch 1405
        double total = 0;
        for (double v : values) total += v * 1405;
        return total;
    }

    static double compute1406(double[] values) {
        // Scaled sum for batch 1406
        double total = 0;
        for (double v : values) total += v * 1406;
        return total;
    }

    static double compute1407(double[] values) {
        // Scaled sum for batch 1407
        double total = 0;
        for (double v : values) total += v * 1407;
        return total;
    }

    static double compute1408(double[] values) {
        // Scaled sum for batch 1408
        double total = 0;
        for (double v : values) total += v * 1408;
        return total;
    }

    static double compute1409(double[] values) {
        // Scaled sum for batch 1409
        double total = 0;
        for (double v : values) total += v * 1409;
        return total;
    }

    static double compute1410(double[] values) {
        // Scaled sum for batch 1410
        double total = 0;
        for (double v : values) total += v * 1410;
        return total;
    }

    static double compute1411(double[] values) {
        // Scaled sum for batch 1411
        double total = 0;
        for (double v : values) total += v * 1411;
        return total;
    }

    static double compute1412(double[] values) {
        // Scaled sum for batch 1412
        double total = 0;
        for (double v : values) total += v * 1412;
        return total;
    }

    static double compute1413(double[] values) {
        // Scaled sum for batch 1413
        double total = 0;
        for (double v : values) total += v * 1413;
        return total;
    }

    static double compute1414(double[] values) {
        // Scaled sum for batch 1414
        double total = 0;
        for (double v : values) total += v * 1414;
        return total;
    }

    static double compute1415(double[] values) {
        // Scaled sum for batch 1415
        double total = 0;
        for (double v : values) total += v * 1415;
        return total;
    }

    static double compute1416(double[] values) {
        // Scaled sum for batch 1416
        double total = 0;
        for (double v : values) total += v * 1416;
        return total;
    }

    static double compute1417(double[] values) {
        // Scaled sum for batch 1417
        double total = 0;
        for (double v : values) total += v * 1417;
        return total;
    }

    static double compute1418(double[] values) {
        // Scaled sum for batch 1418
        double total = 0;
        for (double v : values) total += v * 1418;
        return total;
    }

    static double compute1419(double[] values) {
        // Scaled sum for batch 1419
        double total = 0;
        for (double v : values) total += v * 1419;
        return total;
    }

    static double compute1420(double[] values) {
        // Scaled sum for batch 1420
        double total = 0;
        for (double v : values) total += v * 1420;
        return total;
    }

    static double compute1421(double[] values) {
        // Scaled sum for batch 1421
        double total = 0;
        for (double v : values) total += v * 1421;
        return total;
    }

    static double compute1422(double[] values) {
        // Scaled sum for batch 1422
        double total = 0;
        for (double v : values) total += v * 1422;
        return total;
    }

    static double compute1423(double[] values) {
        // Scaled sum for batch 1423
        double total = 0;
        for (double v : values) total += v * 1423;
        return total;
    }

    static double compute1424(double[] values) {
        // Scaled sum for batch 1424
        double total = 0;
        for (double v : values) total += v * 1424;
        return total;
    }

    static double compute1425(double[] values) {
        // Scaled sum for batch 1425
        double total = 0;
        for (double v : values) total += v * 1425;
        return total;
    }

    static double compute1426(double[] values) {
        // Scaled sum for batch 1426
        double total = 0;
        for (double v : values) total += v * 1426;
        return total;
    }

    static double compute1427(double[] values) {
        // Scaled sum for batch 1427
        double total = 0;
        for (double v : values) total += v * 1427;
        return total;
    }

}