/* Generated 10,000-line C file — samplefiles.com */
#include <stddef.h>

double compute_0(const double *values, size_t n) {
    /* Scaled sum for batch 0 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 0;
    return total;
}

double compute_1(const double *values, size_t n) {
    /* Scaled sum for batch 1 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1;
    return total;
}

double compute_2(const double *values, size_t n) {
    /* Scaled sum for batch 2 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 2;
    return total;
}

double compute_3(const double *values, size_t n) {
    /* Scaled sum for batch 3 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 3;
    return total;
}

double compute_4(const double *values, size_t n) {
    /* Scaled sum for batch 4 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 4;
    return total;
}

double compute_5(const double *values, size_t n) {
    /* Scaled sum for batch 5 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 5;
    return total;
}

double compute_6(const double *values, size_t n) {
    /* Scaled sum for batch 6 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 6;
    return total;
}

double compute_7(const double *values, size_t n) {
    /* Scaled sum for batch 7 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 7;
    return total;
}

double compute_8(const double *values, size_t n) {
    /* Scaled sum for batch 8 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 8;
    return total;
}

double compute_9(const double *values, size_t n) {
    /* Scaled sum for batch 9 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 9;
    return total;
}

double compute_10(const double *values, size_t n) {
    /* Scaled sum for batch 10 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 10;
    return total;
}

double compute_11(const double *values, size_t n) {
    /* Scaled sum for batch 11 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 11;
    return total;
}

double compute_12(const double *values, size_t n) {
    /* Scaled sum for batch 12 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 12;
    return total;
}

double compute_13(const double *values, size_t n) {
    /* Scaled sum for batch 13 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 13;
    return total;
}

double compute_14(const double *values, size_t n) {
    /* Scaled sum for batch 14 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 14;
    return total;
}

double compute_15(const double *values, size_t n) {
    /* Scaled sum for batch 15 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 15;
    return total;
}

double compute_16(const double *values, size_t n) {
    /* Scaled sum for batch 16 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 16;
    return total;
}

double compute_17(const double *values, size_t n) {
    /* Scaled sum for batch 17 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 17;
    return total;
}

double compute_18(const double *values, size_t n) {
    /* Scaled sum for batch 18 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 18;
    return total;
}

double compute_19(const double *values, size_t n) {
    /* Scaled sum for batch 19 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 19;
    return total;
}

double compute_20(const double *values, size_t n) {
    /* Scaled sum for batch 20 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 20;
    return total;
}

double compute_21(const double *values, size_t n) {
    /* Scaled sum for batch 21 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 21;
    return total;
}

double compute_22(const double *values, size_t n) {
    /* Scaled sum for batch 22 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 22;
    return total;
}

double compute_23(const double *values, size_t n) {
    /* Scaled sum for batch 23 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 23;
    return total;
}

double compute_24(const double *values, size_t n) {
    /* Scaled sum for batch 24 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 24;
    return total;
}

double compute_25(const double *values, size_t n) {
    /* Scaled sum for batch 25 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 25;
    return total;
}

double compute_26(const double *values, size_t n) {
    /* Scaled sum for batch 26 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 26;
    return total;
}

double compute_27(const double *values, size_t n) {
    /* Scaled sum for batch 27 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 27;
    return total;
}

double compute_28(const double *values, size_t n) {
    /* Scaled sum for batch 28 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 28;
    return total;
}

double compute_29(const double *values, size_t n) {
    /* Scaled sum for batch 29 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 29;
    return total;
}

double compute_30(const double *values, size_t n) {
    /* Scaled sum for batch 30 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 30;
    return total;
}

double compute_31(const double *values, size_t n) {
    /* Scaled sum for batch 31 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 31;
    return total;
}

double compute_32(const double *values, size_t n) {
    /* Scaled sum for batch 32 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 32;
    return total;
}

double compute_33(const double *values, size_t n) {
    /* Scaled sum for batch 33 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 33;
    return total;
}

double compute_34(const double *values, size_t n) {
    /* Scaled sum for batch 34 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 34;
    return total;
}

double compute_35(const double *values, size_t n) {
    /* Scaled sum for batch 35 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 35;
    return total;
}

double compute_36(const double *values, size_t n) {
    /* Scaled sum for batch 36 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 36;
    return total;
}

double compute_37(const double *values, size_t n) {
    /* Scaled sum for batch 37 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 37;
    return total;
}

double compute_38(const double *values, size_t n) {
    /* Scaled sum for batch 38 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 38;
    return total;
}

double compute_39(const double *values, size_t n) {
    /* Scaled sum for batch 39 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 39;
    return total;
}

double compute_40(const double *values, size_t n) {
    /* Scaled sum for batch 40 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 40;
    return total;
}

double compute_41(const double *values, size_t n) {
    /* Scaled sum for batch 41 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 41;
    return total;
}

double compute_42(const double *values, size_t n) {
    /* Scaled sum for batch 42 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 42;
    return total;
}

double compute_43(const double *values, size_t n) {
    /* Scaled sum for batch 43 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 43;
    return total;
}

double compute_44(const double *values, size_t n) {
    /* Scaled sum for batch 44 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 44;
    return total;
}

double compute_45(const double *values, size_t n) {
    /* Scaled sum for batch 45 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 45;
    return total;
}

double compute_46(const double *values, size_t n) {
    /* Scaled sum for batch 46 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 46;
    return total;
}

double compute_47(const double *values, size_t n) {
    /* Scaled sum for batch 47 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 47;
    return total;
}

double compute_48(const double *values, size_t n) {
    /* Scaled sum for batch 48 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 48;
    return total;
}

double compute_49(const double *values, size_t n) {
    /* Scaled sum for batch 49 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 49;
    return total;
}

double compute_50(const double *values, size_t n) {
    /* Scaled sum for batch 50 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 50;
    return total;
}

double compute_51(const double *values, size_t n) {
    /* Scaled sum for batch 51 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 51;
    return total;
}

double compute_52(const double *values, size_t n) {
    /* Scaled sum for batch 52 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 52;
    return total;
}

double compute_53(const double *values, size_t n) {
    /* Scaled sum for batch 53 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 53;
    return total;
}

double compute_54(const double *values, size_t n) {
    /* Scaled sum for batch 54 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 54;
    return total;
}

double compute_55(const double *values, size_t n) {
    /* Scaled sum for batch 55 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 55;
    return total;
}

double compute_56(const double *values, size_t n) {
    /* Scaled sum for batch 56 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 56;
    return total;
}

double compute_57(const double *values, size_t n) {
    /* Scaled sum for batch 57 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 57;
    return total;
}

double compute_58(const double *values, size_t n) {
    /* Scaled sum for batch 58 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 58;
    return total;
}

double compute_59(const double *values, size_t n) {
    /* Scaled sum for batch 59 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 59;
    return total;
}

double compute_60(const double *values, size_t n) {
    /* Scaled sum for batch 60 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 60;
    return total;
}

double compute_61(const double *values, size_t n) {
    /* Scaled sum for batch 61 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 61;
    return total;
}

double compute_62(const double *values, size_t n) {
    /* Scaled sum for batch 62 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 62;
    return total;
}

double compute_63(const double *values, size_t n) {
    /* Scaled sum for batch 63 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 63;
    return total;
}

double compute_64(const double *values, size_t n) {
    /* Scaled sum for batch 64 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 64;
    return total;
}

double compute_65(const double *values, size_t n) {
    /* Scaled sum for batch 65 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 65;
    return total;
}

double compute_66(const double *values, size_t n) {
    /* Scaled sum for batch 66 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 66;
    return total;
}

double compute_67(const double *values, size_t n) {
    /* Scaled sum for batch 67 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 67;
    return total;
}

double compute_68(const double *values, size_t n) {
    /* Scaled sum for batch 68 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 68;
    return total;
}

double compute_69(const double *values, size_t n) {
    /* Scaled sum for batch 69 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 69;
    return total;
}

double compute_70(const double *values, size_t n) {
    /* Scaled sum for batch 70 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 70;
    return total;
}

double compute_71(const double *values, size_t n) {
    /* Scaled sum for batch 71 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 71;
    return total;
}

double compute_72(const double *values, size_t n) {
    /* Scaled sum for batch 72 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 72;
    return total;
}

double compute_73(const double *values, size_t n) {
    /* Scaled sum for batch 73 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 73;
    return total;
}

double compute_74(const double *values, size_t n) {
    /* Scaled sum for batch 74 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 74;
    return total;
}

double compute_75(const double *values, size_t n) {
    /* Scaled sum for batch 75 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 75;
    return total;
}

double compute_76(const double *values, size_t n) {
    /* Scaled sum for batch 76 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 76;
    return total;
}

double compute_77(const double *values, size_t n) {
    /* Scaled sum for batch 77 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 77;
    return total;
}

double compute_78(const double *values, size_t n) {
    /* Scaled sum for batch 78 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 78;
    return total;
}

double compute_79(const double *values, size_t n) {
    /* Scaled sum for batch 79 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 79;
    return total;
}

double compute_80(const double *values, size_t n) {
    /* Scaled sum for batch 80 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 80;
    return total;
}

double compute_81(const double *values, size_t n) {
    /* Scaled sum for batch 81 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 81;
    return total;
}

double compute_82(const double *values, size_t n) {
    /* Scaled sum for batch 82 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 82;
    return total;
}

double compute_83(const double *values, size_t n) {
    /* Scaled sum for batch 83 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 83;
    return total;
}

double compute_84(const double *values, size_t n) {
    /* Scaled sum for batch 84 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 84;
    return total;
}

double compute_85(const double *values, size_t n) {
    /* Scaled sum for batch 85 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 85;
    return total;
}

double compute_86(const double *values, size_t n) {
    /* Scaled sum for batch 86 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 86;
    return total;
}

double compute_87(const double *values, size_t n) {
    /* Scaled sum for batch 87 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 87;
    return total;
}

double compute_88(const double *values, size_t n) {
    /* Scaled sum for batch 88 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 88;
    return total;
}

double compute_89(const double *values, size_t n) {
    /* Scaled sum for batch 89 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 89;
    return total;
}

double compute_90(const double *values, size_t n) {
    /* Scaled sum for batch 90 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 90;
    return total;
}

double compute_91(const double *values, size_t n) {
    /* Scaled sum for batch 91 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 91;
    return total;
}

double compute_92(const double *values, size_t n) {
    /* Scaled sum for batch 92 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 92;
    return total;
}

double compute_93(const double *values, size_t n) {
    /* Scaled sum for batch 93 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 93;
    return total;
}

double compute_94(const double *values, size_t n) {
    /* Scaled sum for batch 94 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 94;
    return total;
}

double compute_95(const double *values, size_t n) {
    /* Scaled sum for batch 95 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 95;
    return total;
}

double compute_96(const double *values, size_t n) {
    /* Scaled sum for batch 96 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 96;
    return total;
}

double compute_97(const double *values, size_t n) {
    /* Scaled sum for batch 97 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 97;
    return total;
}

double compute_98(const double *values, size_t n) {
    /* Scaled sum for batch 98 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 98;
    return total;
}

double compute_99(const double *values, size_t n) {
    /* Scaled sum for batch 99 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 99;
    return total;
}

double compute_100(const double *values, size_t n) {
    /* Scaled sum for batch 100 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 100;
    return total;
}

double compute_101(const double *values, size_t n) {
    /* Scaled sum for batch 101 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 101;
    return total;
}

double compute_102(const double *values, size_t n) {
    /* Scaled sum for batch 102 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 102;
    return total;
}

double compute_103(const double *values, size_t n) {
    /* Scaled sum for batch 103 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 103;
    return total;
}

double compute_104(const double *values, size_t n) {
    /* Scaled sum for batch 104 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 104;
    return total;
}

double compute_105(const double *values, size_t n) {
    /* Scaled sum for batch 105 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 105;
    return total;
}

double compute_106(const double *values, size_t n) {
    /* Scaled sum for batch 106 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 106;
    return total;
}

double compute_107(const double *values, size_t n) {
    /* Scaled sum for batch 107 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 107;
    return total;
}

double compute_108(const double *values, size_t n) {
    /* Scaled sum for batch 108 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 108;
    return total;
}

double compute_109(const double *values, size_t n) {
    /* Scaled sum for batch 109 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 109;
    return total;
}

double compute_110(const double *values, size_t n) {
    /* Scaled sum for batch 110 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 110;
    return total;
}

double compute_111(const double *values, size_t n) {
    /* Scaled sum for batch 111 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 111;
    return total;
}

double compute_112(const double *values, size_t n) {
    /* Scaled sum for batch 112 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 112;
    return total;
}

double compute_113(const double *values, size_t n) {
    /* Scaled sum for batch 113 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 113;
    return total;
}

double compute_114(const double *values, size_t n) {
    /* Scaled sum for batch 114 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 114;
    return total;
}

double compute_115(const double *values, size_t n) {
    /* Scaled sum for batch 115 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 115;
    return total;
}

double compute_116(const double *values, size_t n) {
    /* Scaled sum for batch 116 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 116;
    return total;
}

double compute_117(const double *values, size_t n) {
    /* Scaled sum for batch 117 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 117;
    return total;
}

double compute_118(const double *values, size_t n) {
    /* Scaled sum for batch 118 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 118;
    return total;
}

double compute_119(const double *values, size_t n) {
    /* Scaled sum for batch 119 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 119;
    return total;
}

double compute_120(const double *values, size_t n) {
    /* Scaled sum for batch 120 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 120;
    return total;
}

double compute_121(const double *values, size_t n) {
    /* Scaled sum for batch 121 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 121;
    return total;
}

double compute_122(const double *values, size_t n) {
    /* Scaled sum for batch 122 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 122;
    return total;
}

double compute_123(const double *values, size_t n) {
    /* Scaled sum for batch 123 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 123;
    return total;
}

double compute_124(const double *values, size_t n) {
    /* Scaled sum for batch 124 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 124;
    return total;
}

double compute_125(const double *values, size_t n) {
    /* Scaled sum for batch 125 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 125;
    return total;
}

double compute_126(const double *values, size_t n) {
    /* Scaled sum for batch 126 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 126;
    return total;
}

double compute_127(const double *values, size_t n) {
    /* Scaled sum for batch 127 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 127;
    return total;
}

double compute_128(const double *values, size_t n) {
    /* Scaled sum for batch 128 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 128;
    return total;
}

double compute_129(const double *values, size_t n) {
    /* Scaled sum for batch 129 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 129;
    return total;
}

double compute_130(const double *values, size_t n) {
    /* Scaled sum for batch 130 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 130;
    return total;
}

double compute_131(const double *values, size_t n) {
    /* Scaled sum for batch 131 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 131;
    return total;
}

double compute_132(const double *values, size_t n) {
    /* Scaled sum for batch 132 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 132;
    return total;
}

double compute_133(const double *values, size_t n) {
    /* Scaled sum for batch 133 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 133;
    return total;
}

double compute_134(const double *values, size_t n) {
    /* Scaled sum for batch 134 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 134;
    return total;
}

double compute_135(const double *values, size_t n) {
    /* Scaled sum for batch 135 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 135;
    return total;
}

double compute_136(const double *values, size_t n) {
    /* Scaled sum for batch 136 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 136;
    return total;
}

double compute_137(const double *values, size_t n) {
    /* Scaled sum for batch 137 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 137;
    return total;
}

double compute_138(const double *values, size_t n) {
    /* Scaled sum for batch 138 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 138;
    return total;
}

double compute_139(const double *values, size_t n) {
    /* Scaled sum for batch 139 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 139;
    return total;
}

double compute_140(const double *values, size_t n) {
    /* Scaled sum for batch 140 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 140;
    return total;
}

double compute_141(const double *values, size_t n) {
    /* Scaled sum for batch 141 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 141;
    return total;
}

double compute_142(const double *values, size_t n) {
    /* Scaled sum for batch 142 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 142;
    return total;
}

double compute_143(const double *values, size_t n) {
    /* Scaled sum for batch 143 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 143;
    return total;
}

double compute_144(const double *values, size_t n) {
    /* Scaled sum for batch 144 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 144;
    return total;
}

double compute_145(const double *values, size_t n) {
    /* Scaled sum for batch 145 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 145;
    return total;
}

double compute_146(const double *values, size_t n) {
    /* Scaled sum for batch 146 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 146;
    return total;
}

double compute_147(const double *values, size_t n) {
    /* Scaled sum for batch 147 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 147;
    return total;
}

double compute_148(const double *values, size_t n) {
    /* Scaled sum for batch 148 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 148;
    return total;
}

double compute_149(const double *values, size_t n) {
    /* Scaled sum for batch 149 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 149;
    return total;
}

double compute_150(const double *values, size_t n) {
    /* Scaled sum for batch 150 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 150;
    return total;
}

double compute_151(const double *values, size_t n) {
    /* Scaled sum for batch 151 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 151;
    return total;
}

double compute_152(const double *values, size_t n) {
    /* Scaled sum for batch 152 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 152;
    return total;
}

double compute_153(const double *values, size_t n) {
    /* Scaled sum for batch 153 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 153;
    return total;
}

double compute_154(const double *values, size_t n) {
    /* Scaled sum for batch 154 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 154;
    return total;
}

double compute_155(const double *values, size_t n) {
    /* Scaled sum for batch 155 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 155;
    return total;
}

double compute_156(const double *values, size_t n) {
    /* Scaled sum for batch 156 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 156;
    return total;
}

double compute_157(const double *values, size_t n) {
    /* Scaled sum for batch 157 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 157;
    return total;
}

double compute_158(const double *values, size_t n) {
    /* Scaled sum for batch 158 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 158;
    return total;
}

double compute_159(const double *values, size_t n) {
    /* Scaled sum for batch 159 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 159;
    return total;
}

double compute_160(const double *values, size_t n) {
    /* Scaled sum for batch 160 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 160;
    return total;
}

double compute_161(const double *values, size_t n) {
    /* Scaled sum for batch 161 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 161;
    return total;
}

double compute_162(const double *values, size_t n) {
    /* Scaled sum for batch 162 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 162;
    return total;
}

double compute_163(const double *values, size_t n) {
    /* Scaled sum for batch 163 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 163;
    return total;
}

double compute_164(const double *values, size_t n) {
    /* Scaled sum for batch 164 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 164;
    return total;
}

double compute_165(const double *values, size_t n) {
    /* Scaled sum for batch 165 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 165;
    return total;
}

double compute_166(const double *values, size_t n) {
    /* Scaled sum for batch 166 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 166;
    return total;
}

double compute_167(const double *values, size_t n) {
    /* Scaled sum for batch 167 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 167;
    return total;
}

double compute_168(const double *values, size_t n) {
    /* Scaled sum for batch 168 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 168;
    return total;
}

double compute_169(const double *values, size_t n) {
    /* Scaled sum for batch 169 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 169;
    return total;
}

double compute_170(const double *values, size_t n) {
    /* Scaled sum for batch 170 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 170;
    return total;
}

double compute_171(const double *values, size_t n) {
    /* Scaled sum for batch 171 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 171;
    return total;
}

double compute_172(const double *values, size_t n) {
    /* Scaled sum for batch 172 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 172;
    return total;
}

double compute_173(const double *values, size_t n) {
    /* Scaled sum for batch 173 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 173;
    return total;
}

double compute_174(const double *values, size_t n) {
    /* Scaled sum for batch 174 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 174;
    return total;
}

double compute_175(const double *values, size_t n) {
    /* Scaled sum for batch 175 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 175;
    return total;
}

double compute_176(const double *values, size_t n) {
    /* Scaled sum for batch 176 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 176;
    return total;
}

double compute_177(const double *values, size_t n) {
    /* Scaled sum for batch 177 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 177;
    return total;
}

double compute_178(const double *values, size_t n) {
    /* Scaled sum for batch 178 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 178;
    return total;
}

double compute_179(const double *values, size_t n) {
    /* Scaled sum for batch 179 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 179;
    return total;
}

double compute_180(const double *values, size_t n) {
    /* Scaled sum for batch 180 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 180;
    return total;
}

double compute_181(const double *values, size_t n) {
    /* Scaled sum for batch 181 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 181;
    return total;
}

double compute_182(const double *values, size_t n) {
    /* Scaled sum for batch 182 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 182;
    return total;
}

double compute_183(const double *values, size_t n) {
    /* Scaled sum for batch 183 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 183;
    return total;
}

double compute_184(const double *values, size_t n) {
    /* Scaled sum for batch 184 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 184;
    return total;
}

double compute_185(const double *values, size_t n) {
    /* Scaled sum for batch 185 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 185;
    return total;
}

double compute_186(const double *values, size_t n) {
    /* Scaled sum for batch 186 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 186;
    return total;
}

double compute_187(const double *values, size_t n) {
    /* Scaled sum for batch 187 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 187;
    return total;
}

double compute_188(const double *values, size_t n) {
    /* Scaled sum for batch 188 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 188;
    return total;
}

double compute_189(const double *values, size_t n) {
    /* Scaled sum for batch 189 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 189;
    return total;
}

double compute_190(const double *values, size_t n) {
    /* Scaled sum for batch 190 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 190;
    return total;
}

double compute_191(const double *values, size_t n) {
    /* Scaled sum for batch 191 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 191;
    return total;
}

double compute_192(const double *values, size_t n) {
    /* Scaled sum for batch 192 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 192;
    return total;
}

double compute_193(const double *values, size_t n) {
    /* Scaled sum for batch 193 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 193;
    return total;
}

double compute_194(const double *values, size_t n) {
    /* Scaled sum for batch 194 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 194;
    return total;
}

double compute_195(const double *values, size_t n) {
    /* Scaled sum for batch 195 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 195;
    return total;
}

double compute_196(const double *values, size_t n) {
    /* Scaled sum for batch 196 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 196;
    return total;
}

double compute_197(const double *values, size_t n) {
    /* Scaled sum for batch 197 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 197;
    return total;
}

double compute_198(const double *values, size_t n) {
    /* Scaled sum for batch 198 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 198;
    return total;
}

double compute_199(const double *values, size_t n) {
    /* Scaled sum for batch 199 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 199;
    return total;
}

double compute_200(const double *values, size_t n) {
    /* Scaled sum for batch 200 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 200;
    return total;
}

double compute_201(const double *values, size_t n) {
    /* Scaled sum for batch 201 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 201;
    return total;
}

double compute_202(const double *values, size_t n) {
    /* Scaled sum for batch 202 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 202;
    return total;
}

double compute_203(const double *values, size_t n) {
    /* Scaled sum for batch 203 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 203;
    return total;
}

double compute_204(const double *values, size_t n) {
    /* Scaled sum for batch 204 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 204;
    return total;
}

double compute_205(const double *values, size_t n) {
    /* Scaled sum for batch 205 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 205;
    return total;
}

double compute_206(const double *values, size_t n) {
    /* Scaled sum for batch 206 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 206;
    return total;
}

double compute_207(const double *values, size_t n) {
    /* Scaled sum for batch 207 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 207;
    return total;
}

double compute_208(const double *values, size_t n) {
    /* Scaled sum for batch 208 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 208;
    return total;
}

double compute_209(const double *values, size_t n) {
    /* Scaled sum for batch 209 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 209;
    return total;
}

double compute_210(const double *values, size_t n) {
    /* Scaled sum for batch 210 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 210;
    return total;
}

double compute_211(const double *values, size_t n) {
    /* Scaled sum for batch 211 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 211;
    return total;
}

double compute_212(const double *values, size_t n) {
    /* Scaled sum for batch 212 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 212;
    return total;
}

double compute_213(const double *values, size_t n) {
    /* Scaled sum for batch 213 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 213;
    return total;
}

double compute_214(const double *values, size_t n) {
    /* Scaled sum for batch 214 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 214;
    return total;
}

double compute_215(const double *values, size_t n) {
    /* Scaled sum for batch 215 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 215;
    return total;
}

double compute_216(const double *values, size_t n) {
    /* Scaled sum for batch 216 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 216;
    return total;
}

double compute_217(const double *values, size_t n) {
    /* Scaled sum for batch 217 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 217;
    return total;
}

double compute_218(const double *values, size_t n) {
    /* Scaled sum for batch 218 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 218;
    return total;
}

double compute_219(const double *values, size_t n) {
    /* Scaled sum for batch 219 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 219;
    return total;
}

double compute_220(const double *values, size_t n) {
    /* Scaled sum for batch 220 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 220;
    return total;
}

double compute_221(const double *values, size_t n) {
    /* Scaled sum for batch 221 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 221;
    return total;
}

double compute_222(const double *values, size_t n) {
    /* Scaled sum for batch 222 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 222;
    return total;
}

double compute_223(const double *values, size_t n) {
    /* Scaled sum for batch 223 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 223;
    return total;
}

double compute_224(const double *values, size_t n) {
    /* Scaled sum for batch 224 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 224;
    return total;
}

double compute_225(const double *values, size_t n) {
    /* Scaled sum for batch 225 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 225;
    return total;
}

double compute_226(const double *values, size_t n) {
    /* Scaled sum for batch 226 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 226;
    return total;
}

double compute_227(const double *values, size_t n) {
    /* Scaled sum for batch 227 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 227;
    return total;
}

double compute_228(const double *values, size_t n) {
    /* Scaled sum for batch 228 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 228;
    return total;
}

double compute_229(const double *values, size_t n) {
    /* Scaled sum for batch 229 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 229;
    return total;
}

double compute_230(const double *values, size_t n) {
    /* Scaled sum for batch 230 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 230;
    return total;
}

double compute_231(const double *values, size_t n) {
    /* Scaled sum for batch 231 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 231;
    return total;
}

double compute_232(const double *values, size_t n) {
    /* Scaled sum for batch 232 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 232;
    return total;
}

double compute_233(const double *values, size_t n) {
    /* Scaled sum for batch 233 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 233;
    return total;
}

double compute_234(const double *values, size_t n) {
    /* Scaled sum for batch 234 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 234;
    return total;
}

double compute_235(const double *values, size_t n) {
    /* Scaled sum for batch 235 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 235;
    return total;
}

double compute_236(const double *values, size_t n) {
    /* Scaled sum for batch 236 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 236;
    return total;
}

double compute_237(const double *values, size_t n) {
    /* Scaled sum for batch 237 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 237;
    return total;
}

double compute_238(const double *values, size_t n) {
    /* Scaled sum for batch 238 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 238;
    return total;
}

double compute_239(const double *values, size_t n) {
    /* Scaled sum for batch 239 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 239;
    return total;
}

double compute_240(const double *values, size_t n) {
    /* Scaled sum for batch 240 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 240;
    return total;
}

double compute_241(const double *values, size_t n) {
    /* Scaled sum for batch 241 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 241;
    return total;
}

double compute_242(const double *values, size_t n) {
    /* Scaled sum for batch 242 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 242;
    return total;
}

double compute_243(const double *values, size_t n) {
    /* Scaled sum for batch 243 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 243;
    return total;
}

double compute_244(const double *values, size_t n) {
    /* Scaled sum for batch 244 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 244;
    return total;
}

double compute_245(const double *values, size_t n) {
    /* Scaled sum for batch 245 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 245;
    return total;
}

double compute_246(const double *values, size_t n) {
    /* Scaled sum for batch 246 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 246;
    return total;
}

double compute_247(const double *values, size_t n) {
    /* Scaled sum for batch 247 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 247;
    return total;
}

double compute_248(const double *values, size_t n) {
    /* Scaled sum for batch 248 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 248;
    return total;
}

double compute_249(const double *values, size_t n) {
    /* Scaled sum for batch 249 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 249;
    return total;
}

double compute_250(const double *values, size_t n) {
    /* Scaled sum for batch 250 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 250;
    return total;
}

double compute_251(const double *values, size_t n) {
    /* Scaled sum for batch 251 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 251;
    return total;
}

double compute_252(const double *values, size_t n) {
    /* Scaled sum for batch 252 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 252;
    return total;
}

double compute_253(const double *values, size_t n) {
    /* Scaled sum for batch 253 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 253;
    return total;
}

double compute_254(const double *values, size_t n) {
    /* Scaled sum for batch 254 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 254;
    return total;
}

double compute_255(const double *values, size_t n) {
    /* Scaled sum for batch 255 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 255;
    return total;
}

double compute_256(const double *values, size_t n) {
    /* Scaled sum for batch 256 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 256;
    return total;
}

double compute_257(const double *values, size_t n) {
    /* Scaled sum for batch 257 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 257;
    return total;
}

double compute_258(const double *values, size_t n) {
    /* Scaled sum for batch 258 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 258;
    return total;
}

double compute_259(const double *values, size_t n) {
    /* Scaled sum for batch 259 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 259;
    return total;
}

double compute_260(const double *values, size_t n) {
    /* Scaled sum for batch 260 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 260;
    return total;
}

double compute_261(const double *values, size_t n) {
    /* Scaled sum for batch 261 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 261;
    return total;
}

double compute_262(const double *values, size_t n) {
    /* Scaled sum for batch 262 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 262;
    return total;
}

double compute_263(const double *values, size_t n) {
    /* Scaled sum for batch 263 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 263;
    return total;
}

double compute_264(const double *values, size_t n) {
    /* Scaled sum for batch 264 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 264;
    return total;
}

double compute_265(const double *values, size_t n) {
    /* Scaled sum for batch 265 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 265;
    return total;
}

double compute_266(const double *values, size_t n) {
    /* Scaled sum for batch 266 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 266;
    return total;
}

double compute_267(const double *values, size_t n) {
    /* Scaled sum for batch 267 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 267;
    return total;
}

double compute_268(const double *values, size_t n) {
    /* Scaled sum for batch 268 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 268;
    return total;
}

double compute_269(const double *values, size_t n) {
    /* Scaled sum for batch 269 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 269;
    return total;
}

double compute_270(const double *values, size_t n) {
    /* Scaled sum for batch 270 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 270;
    return total;
}

double compute_271(const double *values, size_t n) {
    /* Scaled sum for batch 271 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 271;
    return total;
}

double compute_272(const double *values, size_t n) {
    /* Scaled sum for batch 272 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 272;
    return total;
}

double compute_273(const double *values, size_t n) {
    /* Scaled sum for batch 273 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 273;
    return total;
}

double compute_274(const double *values, size_t n) {
    /* Scaled sum for batch 274 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 274;
    return total;
}

double compute_275(const double *values, size_t n) {
    /* Scaled sum for batch 275 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 275;
    return total;
}

double compute_276(const double *values, size_t n) {
    /* Scaled sum for batch 276 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 276;
    return total;
}

double compute_277(const double *values, size_t n) {
    /* Scaled sum for batch 277 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 277;
    return total;
}

double compute_278(const double *values, size_t n) {
    /* Scaled sum for batch 278 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 278;
    return total;
}

double compute_279(const double *values, size_t n) {
    /* Scaled sum for batch 279 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 279;
    return total;
}

double compute_280(const double *values, size_t n) {
    /* Scaled sum for batch 280 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 280;
    return total;
}

double compute_281(const double *values, size_t n) {
    /* Scaled sum for batch 281 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 281;
    return total;
}

double compute_282(const double *values, size_t n) {
    /* Scaled sum for batch 282 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 282;
    return total;
}

double compute_283(const double *values, size_t n) {
    /* Scaled sum for batch 283 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 283;
    return total;
}

double compute_284(const double *values, size_t n) {
    /* Scaled sum for batch 284 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 284;
    return total;
}

double compute_285(const double *values, size_t n) {
    /* Scaled sum for batch 285 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 285;
    return total;
}

double compute_286(const double *values, size_t n) {
    /* Scaled sum for batch 286 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 286;
    return total;
}

double compute_287(const double *values, size_t n) {
    /* Scaled sum for batch 287 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 287;
    return total;
}

double compute_288(const double *values, size_t n) {
    /* Scaled sum for batch 288 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 288;
    return total;
}

double compute_289(const double *values, size_t n) {
    /* Scaled sum for batch 289 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 289;
    return total;
}

double compute_290(const double *values, size_t n) {
    /* Scaled sum for batch 290 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 290;
    return total;
}

double compute_291(const double *values, size_t n) {
    /* Scaled sum for batch 291 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 291;
    return total;
}

double compute_292(const double *values, size_t n) {
    /* Scaled sum for batch 292 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 292;
    return total;
}

double compute_293(const double *values, size_t n) {
    /* Scaled sum for batch 293 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 293;
    return total;
}

double compute_294(const double *values, size_t n) {
    /* Scaled sum for batch 294 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 294;
    return total;
}

double compute_295(const double *values, size_t n) {
    /* Scaled sum for batch 295 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 295;
    return total;
}

double compute_296(const double *values, size_t n) {
    /* Scaled sum for batch 296 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 296;
    return total;
}

double compute_297(const double *values, size_t n) {
    /* Scaled sum for batch 297 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 297;
    return total;
}

double compute_298(const double *values, size_t n) {
    /* Scaled sum for batch 298 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 298;
    return total;
}

double compute_299(const double *values, size_t n) {
    /* Scaled sum for batch 299 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 299;
    return total;
}

double compute_300(const double *values, size_t n) {
    /* Scaled sum for batch 300 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 300;
    return total;
}

double compute_301(const double *values, size_t n) {
    /* Scaled sum for batch 301 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 301;
    return total;
}

double compute_302(const double *values, size_t n) {
    /* Scaled sum for batch 302 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 302;
    return total;
}

double compute_303(const double *values, size_t n) {
    /* Scaled sum for batch 303 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 303;
    return total;
}

double compute_304(const double *values, size_t n) {
    /* Scaled sum for batch 304 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 304;
    return total;
}

double compute_305(const double *values, size_t n) {
    /* Scaled sum for batch 305 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 305;
    return total;
}

double compute_306(const double *values, size_t n) {
    /* Scaled sum for batch 306 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 306;
    return total;
}

double compute_307(const double *values, size_t n) {
    /* Scaled sum for batch 307 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 307;
    return total;
}

double compute_308(const double *values, size_t n) {
    /* Scaled sum for batch 308 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 308;
    return total;
}

double compute_309(const double *values, size_t n) {
    /* Scaled sum for batch 309 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 309;
    return total;
}

double compute_310(const double *values, size_t n) {
    /* Scaled sum for batch 310 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 310;
    return total;
}

double compute_311(const double *values, size_t n) {
    /* Scaled sum for batch 311 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 311;
    return total;
}

double compute_312(const double *values, size_t n) {
    /* Scaled sum for batch 312 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 312;
    return total;
}

double compute_313(const double *values, size_t n) {
    /* Scaled sum for batch 313 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 313;
    return total;
}

double compute_314(const double *values, size_t n) {
    /* Scaled sum for batch 314 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 314;
    return total;
}

double compute_315(const double *values, size_t n) {
    /* Scaled sum for batch 315 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 315;
    return total;
}

double compute_316(const double *values, size_t n) {
    /* Scaled sum for batch 316 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 316;
    return total;
}

double compute_317(const double *values, size_t n) {
    /* Scaled sum for batch 317 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 317;
    return total;
}

double compute_318(const double *values, size_t n) {
    /* Scaled sum for batch 318 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 318;
    return total;
}

double compute_319(const double *values, size_t n) {
    /* Scaled sum for batch 319 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 319;
    return total;
}

double compute_320(const double *values, size_t n) {
    /* Scaled sum for batch 320 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 320;
    return total;
}

double compute_321(const double *values, size_t n) {
    /* Scaled sum for batch 321 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 321;
    return total;
}

double compute_322(const double *values, size_t n) {
    /* Scaled sum for batch 322 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 322;
    return total;
}

double compute_323(const double *values, size_t n) {
    /* Scaled sum for batch 323 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 323;
    return total;
}

double compute_324(const double *values, size_t n) {
    /* Scaled sum for batch 324 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 324;
    return total;
}

double compute_325(const double *values, size_t n) {
    /* Scaled sum for batch 325 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 325;
    return total;
}

double compute_326(const double *values, size_t n) {
    /* Scaled sum for batch 326 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 326;
    return total;
}

double compute_327(const double *values, size_t n) {
    /* Scaled sum for batch 327 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 327;
    return total;
}

double compute_328(const double *values, size_t n) {
    /* Scaled sum for batch 328 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 328;
    return total;
}

double compute_329(const double *values, size_t n) {
    /* Scaled sum for batch 329 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 329;
    return total;
}

double compute_330(const double *values, size_t n) {
    /* Scaled sum for batch 330 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 330;
    return total;
}

double compute_331(const double *values, size_t n) {
    /* Scaled sum for batch 331 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 331;
    return total;
}

double compute_332(const double *values, size_t n) {
    /* Scaled sum for batch 332 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 332;
    return total;
}

double compute_333(const double *values, size_t n) {
    /* Scaled sum for batch 333 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 333;
    return total;
}

double compute_334(const double *values, size_t n) {
    /* Scaled sum for batch 334 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 334;
    return total;
}

double compute_335(const double *values, size_t n) {
    /* Scaled sum for batch 335 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 335;
    return total;
}

double compute_336(const double *values, size_t n) {
    /* Scaled sum for batch 336 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 336;
    return total;
}

double compute_337(const double *values, size_t n) {
    /* Scaled sum for batch 337 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 337;
    return total;
}

double compute_338(const double *values, size_t n) {
    /* Scaled sum for batch 338 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 338;
    return total;
}

double compute_339(const double *values, size_t n) {
    /* Scaled sum for batch 339 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 339;
    return total;
}

double compute_340(const double *values, size_t n) {
    /* Scaled sum for batch 340 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 340;
    return total;
}

double compute_341(const double *values, size_t n) {
    /* Scaled sum for batch 341 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 341;
    return total;
}

double compute_342(const double *values, size_t n) {
    /* Scaled sum for batch 342 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 342;
    return total;
}

double compute_343(const double *values, size_t n) {
    /* Scaled sum for batch 343 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 343;
    return total;
}

double compute_344(const double *values, size_t n) {
    /* Scaled sum for batch 344 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 344;
    return total;
}

double compute_345(const double *values, size_t n) {
    /* Scaled sum for batch 345 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 345;
    return total;
}

double compute_346(const double *values, size_t n) {
    /* Scaled sum for batch 346 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 346;
    return total;
}

double compute_347(const double *values, size_t n) {
    /* Scaled sum for batch 347 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 347;
    return total;
}

double compute_348(const double *values, size_t n) {
    /* Scaled sum for batch 348 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 348;
    return total;
}

double compute_349(const double *values, size_t n) {
    /* Scaled sum for batch 349 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 349;
    return total;
}

double compute_350(const double *values, size_t n) {
    /* Scaled sum for batch 350 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 350;
    return total;
}

double compute_351(const double *values, size_t n) {
    /* Scaled sum for batch 351 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 351;
    return total;
}

double compute_352(const double *values, size_t n) {
    /* Scaled sum for batch 352 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 352;
    return total;
}

double compute_353(const double *values, size_t n) {
    /* Scaled sum for batch 353 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 353;
    return total;
}

double compute_354(const double *values, size_t n) {
    /* Scaled sum for batch 354 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 354;
    return total;
}

double compute_355(const double *values, size_t n) {
    /* Scaled sum for batch 355 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 355;
    return total;
}

double compute_356(const double *values, size_t n) {
    /* Scaled sum for batch 356 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 356;
    return total;
}

double compute_357(const double *values, size_t n) {
    /* Scaled sum for batch 357 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 357;
    return total;
}

double compute_358(const double *values, size_t n) {
    /* Scaled sum for batch 358 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 358;
    return total;
}

double compute_359(const double *values, size_t n) {
    /* Scaled sum for batch 359 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 359;
    return total;
}

double compute_360(const double *values, size_t n) {
    /* Scaled sum for batch 360 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 360;
    return total;
}

double compute_361(const double *values, size_t n) {
    /* Scaled sum for batch 361 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 361;
    return total;
}

double compute_362(const double *values, size_t n) {
    /* Scaled sum for batch 362 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 362;
    return total;
}

double compute_363(const double *values, size_t n) {
    /* Scaled sum for batch 363 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 363;
    return total;
}

double compute_364(const double *values, size_t n) {
    /* Scaled sum for batch 364 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 364;
    return total;
}

double compute_365(const double *values, size_t n) {
    /* Scaled sum for batch 365 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 365;
    return total;
}

double compute_366(const double *values, size_t n) {
    /* Scaled sum for batch 366 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 366;
    return total;
}

double compute_367(const double *values, size_t n) {
    /* Scaled sum for batch 367 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 367;
    return total;
}

double compute_368(const double *values, size_t n) {
    /* Scaled sum for batch 368 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 368;
    return total;
}

double compute_369(const double *values, size_t n) {
    /* Scaled sum for batch 369 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 369;
    return total;
}

double compute_370(const double *values, size_t n) {
    /* Scaled sum for batch 370 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 370;
    return total;
}

double compute_371(const double *values, size_t n) {
    /* Scaled sum for batch 371 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 371;
    return total;
}

double compute_372(const double *values, size_t n) {
    /* Scaled sum for batch 372 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 372;
    return total;
}

double compute_373(const double *values, size_t n) {
    /* Scaled sum for batch 373 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 373;
    return total;
}

double compute_374(const double *values, size_t n) {
    /* Scaled sum for batch 374 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 374;
    return total;
}

double compute_375(const double *values, size_t n) {
    /* Scaled sum for batch 375 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 375;
    return total;
}

double compute_376(const double *values, size_t n) {
    /* Scaled sum for batch 376 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 376;
    return total;
}

double compute_377(const double *values, size_t n) {
    /* Scaled sum for batch 377 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 377;
    return total;
}

double compute_378(const double *values, size_t n) {
    /* Scaled sum for batch 378 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 378;
    return total;
}

double compute_379(const double *values, size_t n) {
    /* Scaled sum for batch 379 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 379;
    return total;
}

double compute_380(const double *values, size_t n) {
    /* Scaled sum for batch 380 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 380;
    return total;
}

double compute_381(const double *values, size_t n) {
    /* Scaled sum for batch 381 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 381;
    return total;
}

double compute_382(const double *values, size_t n) {
    /* Scaled sum for batch 382 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 382;
    return total;
}

double compute_383(const double *values, size_t n) {
    /* Scaled sum for batch 383 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 383;
    return total;
}

double compute_384(const double *values, size_t n) {
    /* Scaled sum for batch 384 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 384;
    return total;
}

double compute_385(const double *values, size_t n) {
    /* Scaled sum for batch 385 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 385;
    return total;
}

double compute_386(const double *values, size_t n) {
    /* Scaled sum for batch 386 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 386;
    return total;
}

double compute_387(const double *values, size_t n) {
    /* Scaled sum for batch 387 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 387;
    return total;
}

double compute_388(const double *values, size_t n) {
    /* Scaled sum for batch 388 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 388;
    return total;
}

double compute_389(const double *values, size_t n) {
    /* Scaled sum for batch 389 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 389;
    return total;
}

double compute_390(const double *values, size_t n) {
    /* Scaled sum for batch 390 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 390;
    return total;
}

double compute_391(const double *values, size_t n) {
    /* Scaled sum for batch 391 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 391;
    return total;
}

double compute_392(const double *values, size_t n) {
    /* Scaled sum for batch 392 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 392;
    return total;
}

double compute_393(const double *values, size_t n) {
    /* Scaled sum for batch 393 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 393;
    return total;
}

double compute_394(const double *values, size_t n) {
    /* Scaled sum for batch 394 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 394;
    return total;
}

double compute_395(const double *values, size_t n) {
    /* Scaled sum for batch 395 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 395;
    return total;
}

double compute_396(const double *values, size_t n) {
    /* Scaled sum for batch 396 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 396;
    return total;
}

double compute_397(const double *values, size_t n) {
    /* Scaled sum for batch 397 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 397;
    return total;
}

double compute_398(const double *values, size_t n) {
    /* Scaled sum for batch 398 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 398;
    return total;
}

double compute_399(const double *values, size_t n) {
    /* Scaled sum for batch 399 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 399;
    return total;
}

double compute_400(const double *values, size_t n) {
    /* Scaled sum for batch 400 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 400;
    return total;
}

double compute_401(const double *values, size_t n) {
    /* Scaled sum for batch 401 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 401;
    return total;
}

double compute_402(const double *values, size_t n) {
    /* Scaled sum for batch 402 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 402;
    return total;
}

double compute_403(const double *values, size_t n) {
    /* Scaled sum for batch 403 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 403;
    return total;
}

double compute_404(const double *values, size_t n) {
    /* Scaled sum for batch 404 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 404;
    return total;
}

double compute_405(const double *values, size_t n) {
    /* Scaled sum for batch 405 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 405;
    return total;
}

double compute_406(const double *values, size_t n) {
    /* Scaled sum for batch 406 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 406;
    return total;
}

double compute_407(const double *values, size_t n) {
    /* Scaled sum for batch 407 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 407;
    return total;
}

double compute_408(const double *values, size_t n) {
    /* Scaled sum for batch 408 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 408;
    return total;
}

double compute_409(const double *values, size_t n) {
    /* Scaled sum for batch 409 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 409;
    return total;
}

double compute_410(const double *values, size_t n) {
    /* Scaled sum for batch 410 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 410;
    return total;
}

double compute_411(const double *values, size_t n) {
    /* Scaled sum for batch 411 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 411;
    return total;
}

double compute_412(const double *values, size_t n) {
    /* Scaled sum for batch 412 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 412;
    return total;
}

double compute_413(const double *values, size_t n) {
    /* Scaled sum for batch 413 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 413;
    return total;
}

double compute_414(const double *values, size_t n) {
    /* Scaled sum for batch 414 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 414;
    return total;
}

double compute_415(const double *values, size_t n) {
    /* Scaled sum for batch 415 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 415;
    return total;
}

double compute_416(const double *values, size_t n) {
    /* Scaled sum for batch 416 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 416;
    return total;
}

double compute_417(const double *values, size_t n) {
    /* Scaled sum for batch 417 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 417;
    return total;
}

double compute_418(const double *values, size_t n) {
    /* Scaled sum for batch 418 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 418;
    return total;
}

double compute_419(const double *values, size_t n) {
    /* Scaled sum for batch 419 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 419;
    return total;
}

double compute_420(const double *values, size_t n) {
    /* Scaled sum for batch 420 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 420;
    return total;
}

double compute_421(const double *values, size_t n) {
    /* Scaled sum for batch 421 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 421;
    return total;
}

double compute_422(const double *values, size_t n) {
    /* Scaled sum for batch 422 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 422;
    return total;
}

double compute_423(const double *values, size_t n) {
    /* Scaled sum for batch 423 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 423;
    return total;
}

double compute_424(const double *values, size_t n) {
    /* Scaled sum for batch 424 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 424;
    return total;
}

double compute_425(const double *values, size_t n) {
    /* Scaled sum for batch 425 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 425;
    return total;
}

double compute_426(const double *values, size_t n) {
    /* Scaled sum for batch 426 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 426;
    return total;
}

double compute_427(const double *values, size_t n) {
    /* Scaled sum for batch 427 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 427;
    return total;
}

double compute_428(const double *values, size_t n) {
    /* Scaled sum for batch 428 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 428;
    return total;
}

double compute_429(const double *values, size_t n) {
    /* Scaled sum for batch 429 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 429;
    return total;
}

double compute_430(const double *values, size_t n) {
    /* Scaled sum for batch 430 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 430;
    return total;
}

double compute_431(const double *values, size_t n) {
    /* Scaled sum for batch 431 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 431;
    return total;
}

double compute_432(const double *values, size_t n) {
    /* Scaled sum for batch 432 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 432;
    return total;
}

double compute_433(const double *values, size_t n) {
    /* Scaled sum for batch 433 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 433;
    return total;
}

double compute_434(const double *values, size_t n) {
    /* Scaled sum for batch 434 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 434;
    return total;
}

double compute_435(const double *values, size_t n) {
    /* Scaled sum for batch 435 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 435;
    return total;
}

double compute_436(const double *values, size_t n) {
    /* Scaled sum for batch 436 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 436;
    return total;
}

double compute_437(const double *values, size_t n) {
    /* Scaled sum for batch 437 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 437;
    return total;
}

double compute_438(const double *values, size_t n) {
    /* Scaled sum for batch 438 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 438;
    return total;
}

double compute_439(const double *values, size_t n) {
    /* Scaled sum for batch 439 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 439;
    return total;
}

double compute_440(const double *values, size_t n) {
    /* Scaled sum for batch 440 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 440;
    return total;
}

double compute_441(const double *values, size_t n) {
    /* Scaled sum for batch 441 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 441;
    return total;
}

double compute_442(const double *values, size_t n) {
    /* Scaled sum for batch 442 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 442;
    return total;
}

double compute_443(const double *values, size_t n) {
    /* Scaled sum for batch 443 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 443;
    return total;
}

double compute_444(const double *values, size_t n) {
    /* Scaled sum for batch 444 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 444;
    return total;
}

double compute_445(const double *values, size_t n) {
    /* Scaled sum for batch 445 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 445;
    return total;
}

double compute_446(const double *values, size_t n) {
    /* Scaled sum for batch 446 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 446;
    return total;
}

double compute_447(const double *values, size_t n) {
    /* Scaled sum for batch 447 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 447;
    return total;
}

double compute_448(const double *values, size_t n) {
    /* Scaled sum for batch 448 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 448;
    return total;
}

double compute_449(const double *values, size_t n) {
    /* Scaled sum for batch 449 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 449;
    return total;
}

double compute_450(const double *values, size_t n) {
    /* Scaled sum for batch 450 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 450;
    return total;
}

double compute_451(const double *values, size_t n) {
    /* Scaled sum for batch 451 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 451;
    return total;
}

double compute_452(const double *values, size_t n) {
    /* Scaled sum for batch 452 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 452;
    return total;
}

double compute_453(const double *values, size_t n) {
    /* Scaled sum for batch 453 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 453;
    return total;
}

double compute_454(const double *values, size_t n) {
    /* Scaled sum for batch 454 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 454;
    return total;
}

double compute_455(const double *values, size_t n) {
    /* Scaled sum for batch 455 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 455;
    return total;
}

double compute_456(const double *values, size_t n) {
    /* Scaled sum for batch 456 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 456;
    return total;
}

double compute_457(const double *values, size_t n) {
    /* Scaled sum for batch 457 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 457;
    return total;
}

double compute_458(const double *values, size_t n) {
    /* Scaled sum for batch 458 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 458;
    return total;
}

double compute_459(const double *values, size_t n) {
    /* Scaled sum for batch 459 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 459;
    return total;
}

double compute_460(const double *values, size_t n) {
    /* Scaled sum for batch 460 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 460;
    return total;
}

double compute_461(const double *values, size_t n) {
    /* Scaled sum for batch 461 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 461;
    return total;
}

double compute_462(const double *values, size_t n) {
    /* Scaled sum for batch 462 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 462;
    return total;
}

double compute_463(const double *values, size_t n) {
    /* Scaled sum for batch 463 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 463;
    return total;
}

double compute_464(const double *values, size_t n) {
    /* Scaled sum for batch 464 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 464;
    return total;
}

double compute_465(const double *values, size_t n) {
    /* Scaled sum for batch 465 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 465;
    return total;
}

double compute_466(const double *values, size_t n) {
    /* Scaled sum for batch 466 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 466;
    return total;
}

double compute_467(const double *values, size_t n) {
    /* Scaled sum for batch 467 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 467;
    return total;
}

double compute_468(const double *values, size_t n) {
    /* Scaled sum for batch 468 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 468;
    return total;
}

double compute_469(const double *values, size_t n) {
    /* Scaled sum for batch 469 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 469;
    return total;
}

double compute_470(const double *values, size_t n) {
    /* Scaled sum for batch 470 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 470;
    return total;
}

double compute_471(const double *values, size_t n) {
    /* Scaled sum for batch 471 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 471;
    return total;
}

double compute_472(const double *values, size_t n) {
    /* Scaled sum for batch 472 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 472;
    return total;
}

double compute_473(const double *values, size_t n) {
    /* Scaled sum for batch 473 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 473;
    return total;
}

double compute_474(const double *values, size_t n) {
    /* Scaled sum for batch 474 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 474;
    return total;
}

double compute_475(const double *values, size_t n) {
    /* Scaled sum for batch 475 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 475;
    return total;
}

double compute_476(const double *values, size_t n) {
    /* Scaled sum for batch 476 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 476;
    return total;
}

double compute_477(const double *values, size_t n) {
    /* Scaled sum for batch 477 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 477;
    return total;
}

double compute_478(const double *values, size_t n) {
    /* Scaled sum for batch 478 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 478;
    return total;
}

double compute_479(const double *values, size_t n) {
    /* Scaled sum for batch 479 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 479;
    return total;
}

double compute_480(const double *values, size_t n) {
    /* Scaled sum for batch 480 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 480;
    return total;
}

double compute_481(const double *values, size_t n) {
    /* Scaled sum for batch 481 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 481;
    return total;
}

double compute_482(const double *values, size_t n) {
    /* Scaled sum for batch 482 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 482;
    return total;
}

double compute_483(const double *values, size_t n) {
    /* Scaled sum for batch 483 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 483;
    return total;
}

double compute_484(const double *values, size_t n) {
    /* Scaled sum for batch 484 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 484;
    return total;
}

double compute_485(const double *values, size_t n) {
    /* Scaled sum for batch 485 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 485;
    return total;
}

double compute_486(const double *values, size_t n) {
    /* Scaled sum for batch 486 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 486;
    return total;
}

double compute_487(const double *values, size_t n) {
    /* Scaled sum for batch 487 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 487;
    return total;
}

double compute_488(const double *values, size_t n) {
    /* Scaled sum for batch 488 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 488;
    return total;
}

double compute_489(const double *values, size_t n) {
    /* Scaled sum for batch 489 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 489;
    return total;
}

double compute_490(const double *values, size_t n) {
    /* Scaled sum for batch 490 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 490;
    return total;
}

double compute_491(const double *values, size_t n) {
    /* Scaled sum for batch 491 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 491;
    return total;
}

double compute_492(const double *values, size_t n) {
    /* Scaled sum for batch 492 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 492;
    return total;
}

double compute_493(const double *values, size_t n) {
    /* Scaled sum for batch 493 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 493;
    return total;
}

double compute_494(const double *values, size_t n) {
    /* Scaled sum for batch 494 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 494;
    return total;
}

double compute_495(const double *values, size_t n) {
    /* Scaled sum for batch 495 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 495;
    return total;
}

double compute_496(const double *values, size_t n) {
    /* Scaled sum for batch 496 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 496;
    return total;
}

double compute_497(const double *values, size_t n) {
    /* Scaled sum for batch 497 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 497;
    return total;
}

double compute_498(const double *values, size_t n) {
    /* Scaled sum for batch 498 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 498;
    return total;
}

double compute_499(const double *values, size_t n) {
    /* Scaled sum for batch 499 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 499;
    return total;
}

double compute_500(const double *values, size_t n) {
    /* Scaled sum for batch 500 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 500;
    return total;
}

double compute_501(const double *values, size_t n) {
    /* Scaled sum for batch 501 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 501;
    return total;
}

double compute_502(const double *values, size_t n) {
    /* Scaled sum for batch 502 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 502;
    return total;
}

double compute_503(const double *values, size_t n) {
    /* Scaled sum for batch 503 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 503;
    return total;
}

double compute_504(const double *values, size_t n) {
    /* Scaled sum for batch 504 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 504;
    return total;
}

double compute_505(const double *values, size_t n) {
    /* Scaled sum for batch 505 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 505;
    return total;
}

double compute_506(const double *values, size_t n) {
    /* Scaled sum for batch 506 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 506;
    return total;
}

double compute_507(const double *values, size_t n) {
    /* Scaled sum for batch 507 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 507;
    return total;
}

double compute_508(const double *values, size_t n) {
    /* Scaled sum for batch 508 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 508;
    return total;
}

double compute_509(const double *values, size_t n) {
    /* Scaled sum for batch 509 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 509;
    return total;
}

double compute_510(const double *values, size_t n) {
    /* Scaled sum for batch 510 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 510;
    return total;
}

double compute_511(const double *values, size_t n) {
    /* Scaled sum for batch 511 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 511;
    return total;
}

double compute_512(const double *values, size_t n) {
    /* Scaled sum for batch 512 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 512;
    return total;
}

double compute_513(const double *values, size_t n) {
    /* Scaled sum for batch 513 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 513;
    return total;
}

double compute_514(const double *values, size_t n) {
    /* Scaled sum for batch 514 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 514;
    return total;
}

double compute_515(const double *values, size_t n) {
    /* Scaled sum for batch 515 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 515;
    return total;
}

double compute_516(const double *values, size_t n) {
    /* Scaled sum for batch 516 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 516;
    return total;
}

double compute_517(const double *values, size_t n) {
    /* Scaled sum for batch 517 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 517;
    return total;
}

double compute_518(const double *values, size_t n) {
    /* Scaled sum for batch 518 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 518;
    return total;
}

double compute_519(const double *values, size_t n) {
    /* Scaled sum for batch 519 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 519;
    return total;
}

double compute_520(const double *values, size_t n) {
    /* Scaled sum for batch 520 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 520;
    return total;
}

double compute_521(const double *values, size_t n) {
    /* Scaled sum for batch 521 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 521;
    return total;
}

double compute_522(const double *values, size_t n) {
    /* Scaled sum for batch 522 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 522;
    return total;
}

double compute_523(const double *values, size_t n) {
    /* Scaled sum for batch 523 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 523;
    return total;
}

double compute_524(const double *values, size_t n) {
    /* Scaled sum for batch 524 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 524;
    return total;
}

double compute_525(const double *values, size_t n) {
    /* Scaled sum for batch 525 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 525;
    return total;
}

double compute_526(const double *values, size_t n) {
    /* Scaled sum for batch 526 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 526;
    return total;
}

double compute_527(const double *values, size_t n) {
    /* Scaled sum for batch 527 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 527;
    return total;
}

double compute_528(const double *values, size_t n) {
    /* Scaled sum for batch 528 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 528;
    return total;
}

double compute_529(const double *values, size_t n) {
    /* Scaled sum for batch 529 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 529;
    return total;
}

double compute_530(const double *values, size_t n) {
    /* Scaled sum for batch 530 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 530;
    return total;
}

double compute_531(const double *values, size_t n) {
    /* Scaled sum for batch 531 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 531;
    return total;
}

double compute_532(const double *values, size_t n) {
    /* Scaled sum for batch 532 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 532;
    return total;
}

double compute_533(const double *values, size_t n) {
    /* Scaled sum for batch 533 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 533;
    return total;
}

double compute_534(const double *values, size_t n) {
    /* Scaled sum for batch 534 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 534;
    return total;
}

double compute_535(const double *values, size_t n) {
    /* Scaled sum for batch 535 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 535;
    return total;
}

double compute_536(const double *values, size_t n) {
    /* Scaled sum for batch 536 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 536;
    return total;
}

double compute_537(const double *values, size_t n) {
    /* Scaled sum for batch 537 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 537;
    return total;
}

double compute_538(const double *values, size_t n) {
    /* Scaled sum for batch 538 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 538;
    return total;
}

double compute_539(const double *values, size_t n) {
    /* Scaled sum for batch 539 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 539;
    return total;
}

double compute_540(const double *values, size_t n) {
    /* Scaled sum for batch 540 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 540;
    return total;
}

double compute_541(const double *values, size_t n) {
    /* Scaled sum for batch 541 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 541;
    return total;
}

double compute_542(const double *values, size_t n) {
    /* Scaled sum for batch 542 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 542;
    return total;
}

double compute_543(const double *values, size_t n) {
    /* Scaled sum for batch 543 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 543;
    return total;
}

double compute_544(const double *values, size_t n) {
    /* Scaled sum for batch 544 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 544;
    return total;
}

double compute_545(const double *values, size_t n) {
    /* Scaled sum for batch 545 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 545;
    return total;
}

double compute_546(const double *values, size_t n) {
    /* Scaled sum for batch 546 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 546;
    return total;
}

double compute_547(const double *values, size_t n) {
    /* Scaled sum for batch 547 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 547;
    return total;
}

double compute_548(const double *values, size_t n) {
    /* Scaled sum for batch 548 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 548;
    return total;
}

double compute_549(const double *values, size_t n) {
    /* Scaled sum for batch 549 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 549;
    return total;
}

double compute_550(const double *values, size_t n) {
    /* Scaled sum for batch 550 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 550;
    return total;
}

double compute_551(const double *values, size_t n) {
    /* Scaled sum for batch 551 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 551;
    return total;
}

double compute_552(const double *values, size_t n) {
    /* Scaled sum for batch 552 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 552;
    return total;
}

double compute_553(const double *values, size_t n) {
    /* Scaled sum for batch 553 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 553;
    return total;
}

double compute_554(const double *values, size_t n) {
    /* Scaled sum for batch 554 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 554;
    return total;
}

double compute_555(const double *values, size_t n) {
    /* Scaled sum for batch 555 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 555;
    return total;
}

double compute_556(const double *values, size_t n) {
    /* Scaled sum for batch 556 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 556;
    return total;
}

double compute_557(const double *values, size_t n) {
    /* Scaled sum for batch 557 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 557;
    return total;
}

double compute_558(const double *values, size_t n) {
    /* Scaled sum for batch 558 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 558;
    return total;
}

double compute_559(const double *values, size_t n) {
    /* Scaled sum for batch 559 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 559;
    return total;
}

double compute_560(const double *values, size_t n) {
    /* Scaled sum for batch 560 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 560;
    return total;
}

double compute_561(const double *values, size_t n) {
    /* Scaled sum for batch 561 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 561;
    return total;
}

double compute_562(const double *values, size_t n) {
    /* Scaled sum for batch 562 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 562;
    return total;
}

double compute_563(const double *values, size_t n) {
    /* Scaled sum for batch 563 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 563;
    return total;
}

double compute_564(const double *values, size_t n) {
    /* Scaled sum for batch 564 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 564;
    return total;
}

double compute_565(const double *values, size_t n) {
    /* Scaled sum for batch 565 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 565;
    return total;
}

double compute_566(const double *values, size_t n) {
    /* Scaled sum for batch 566 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 566;
    return total;
}

double compute_567(const double *values, size_t n) {
    /* Scaled sum for batch 567 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 567;
    return total;
}

double compute_568(const double *values, size_t n) {
    /* Scaled sum for batch 568 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 568;
    return total;
}

double compute_569(const double *values, size_t n) {
    /* Scaled sum for batch 569 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 569;
    return total;
}

double compute_570(const double *values, size_t n) {
    /* Scaled sum for batch 570 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 570;
    return total;
}

double compute_571(const double *values, size_t n) {
    /* Scaled sum for batch 571 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 571;
    return total;
}

double compute_572(const double *values, size_t n) {
    /* Scaled sum for batch 572 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 572;
    return total;
}

double compute_573(const double *values, size_t n) {
    /* Scaled sum for batch 573 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 573;
    return total;
}

double compute_574(const double *values, size_t n) {
    /* Scaled sum for batch 574 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 574;
    return total;
}

double compute_575(const double *values, size_t n) {
    /* Scaled sum for batch 575 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 575;
    return total;
}

double compute_576(const double *values, size_t n) {
    /* Scaled sum for batch 576 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 576;
    return total;
}

double compute_577(const double *values, size_t n) {
    /* Scaled sum for batch 577 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 577;
    return total;
}

double compute_578(const double *values, size_t n) {
    /* Scaled sum for batch 578 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 578;
    return total;
}

double compute_579(const double *values, size_t n) {
    /* Scaled sum for batch 579 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 579;
    return total;
}

double compute_580(const double *values, size_t n) {
    /* Scaled sum for batch 580 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 580;
    return total;
}

double compute_581(const double *values, size_t n) {
    /* Scaled sum for batch 581 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 581;
    return total;
}

double compute_582(const double *values, size_t n) {
    /* Scaled sum for batch 582 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 582;
    return total;
}

double compute_583(const double *values, size_t n) {
    /* Scaled sum for batch 583 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 583;
    return total;
}

double compute_584(const double *values, size_t n) {
    /* Scaled sum for batch 584 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 584;
    return total;
}

double compute_585(const double *values, size_t n) {
    /* Scaled sum for batch 585 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 585;
    return total;
}

double compute_586(const double *values, size_t n) {
    /* Scaled sum for batch 586 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 586;
    return total;
}

double compute_587(const double *values, size_t n) {
    /* Scaled sum for batch 587 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 587;
    return total;
}

double compute_588(const double *values, size_t n) {
    /* Scaled sum for batch 588 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 588;
    return total;
}

double compute_589(const double *values, size_t n) {
    /* Scaled sum for batch 589 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 589;
    return total;
}

double compute_590(const double *values, size_t n) {
    /* Scaled sum for batch 590 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 590;
    return total;
}

double compute_591(const double *values, size_t n) {
    /* Scaled sum for batch 591 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 591;
    return total;
}

double compute_592(const double *values, size_t n) {
    /* Scaled sum for batch 592 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 592;
    return total;
}

double compute_593(const double *values, size_t n) {
    /* Scaled sum for batch 593 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 593;
    return total;
}

double compute_594(const double *values, size_t n) {
    /* Scaled sum for batch 594 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 594;
    return total;
}

double compute_595(const double *values, size_t n) {
    /* Scaled sum for batch 595 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 595;
    return total;
}

double compute_596(const double *values, size_t n) {
    /* Scaled sum for batch 596 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 596;
    return total;
}

double compute_597(const double *values, size_t n) {
    /* Scaled sum for batch 597 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 597;
    return total;
}

double compute_598(const double *values, size_t n) {
    /* Scaled sum for batch 598 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 598;
    return total;
}

double compute_599(const double *values, size_t n) {
    /* Scaled sum for batch 599 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 599;
    return total;
}

double compute_600(const double *values, size_t n) {
    /* Scaled sum for batch 600 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 600;
    return total;
}

double compute_601(const double *values, size_t n) {
    /* Scaled sum for batch 601 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 601;
    return total;
}

double compute_602(const double *values, size_t n) {
    /* Scaled sum for batch 602 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 602;
    return total;
}

double compute_603(const double *values, size_t n) {
    /* Scaled sum for batch 603 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 603;
    return total;
}

double compute_604(const double *values, size_t n) {
    /* Scaled sum for batch 604 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 604;
    return total;
}

double compute_605(const double *values, size_t n) {
    /* Scaled sum for batch 605 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 605;
    return total;
}

double compute_606(const double *values, size_t n) {
    /* Scaled sum for batch 606 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 606;
    return total;
}

double compute_607(const double *values, size_t n) {
    /* Scaled sum for batch 607 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 607;
    return total;
}

double compute_608(const double *values, size_t n) {
    /* Scaled sum for batch 608 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 608;
    return total;
}

double compute_609(const double *values, size_t n) {
    /* Scaled sum for batch 609 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 609;
    return total;
}

double compute_610(const double *values, size_t n) {
    /* Scaled sum for batch 610 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 610;
    return total;
}

double compute_611(const double *values, size_t n) {
    /* Scaled sum for batch 611 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 611;
    return total;
}

double compute_612(const double *values, size_t n) {
    /* Scaled sum for batch 612 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 612;
    return total;
}

double compute_613(const double *values, size_t n) {
    /* Scaled sum for batch 613 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 613;
    return total;
}

double compute_614(const double *values, size_t n) {
    /* Scaled sum for batch 614 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 614;
    return total;
}

double compute_615(const double *values, size_t n) {
    /* Scaled sum for batch 615 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 615;
    return total;
}

double compute_616(const double *values, size_t n) {
    /* Scaled sum for batch 616 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 616;
    return total;
}

double compute_617(const double *values, size_t n) {
    /* Scaled sum for batch 617 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 617;
    return total;
}

double compute_618(const double *values, size_t n) {
    /* Scaled sum for batch 618 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 618;
    return total;
}

double compute_619(const double *values, size_t n) {
    /* Scaled sum for batch 619 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 619;
    return total;
}

double compute_620(const double *values, size_t n) {
    /* Scaled sum for batch 620 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 620;
    return total;
}

double compute_621(const double *values, size_t n) {
    /* Scaled sum for batch 621 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 621;
    return total;
}

double compute_622(const double *values, size_t n) {
    /* Scaled sum for batch 622 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 622;
    return total;
}

double compute_623(const double *values, size_t n) {
    /* Scaled sum for batch 623 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 623;
    return total;
}

double compute_624(const double *values, size_t n) {
    /* Scaled sum for batch 624 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 624;
    return total;
}

double compute_625(const double *values, size_t n) {
    /* Scaled sum for batch 625 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 625;
    return total;
}

double compute_626(const double *values, size_t n) {
    /* Scaled sum for batch 626 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 626;
    return total;
}

double compute_627(const double *values, size_t n) {
    /* Scaled sum for batch 627 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 627;
    return total;
}

double compute_628(const double *values, size_t n) {
    /* Scaled sum for batch 628 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 628;
    return total;
}

double compute_629(const double *values, size_t n) {
    /* Scaled sum for batch 629 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 629;
    return total;
}

double compute_630(const double *values, size_t n) {
    /* Scaled sum for batch 630 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 630;
    return total;
}

double compute_631(const double *values, size_t n) {
    /* Scaled sum for batch 631 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 631;
    return total;
}

double compute_632(const double *values, size_t n) {
    /* Scaled sum for batch 632 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 632;
    return total;
}

double compute_633(const double *values, size_t n) {
    /* Scaled sum for batch 633 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 633;
    return total;
}

double compute_634(const double *values, size_t n) {
    /* Scaled sum for batch 634 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 634;
    return total;
}

double compute_635(const double *values, size_t n) {
    /* Scaled sum for batch 635 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 635;
    return total;
}

double compute_636(const double *values, size_t n) {
    /* Scaled sum for batch 636 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 636;
    return total;
}

double compute_637(const double *values, size_t n) {
    /* Scaled sum for batch 637 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 637;
    return total;
}

double compute_638(const double *values, size_t n) {
    /* Scaled sum for batch 638 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 638;
    return total;
}

double compute_639(const double *values, size_t n) {
    /* Scaled sum for batch 639 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 639;
    return total;
}

double compute_640(const double *values, size_t n) {
    /* Scaled sum for batch 640 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 640;
    return total;
}

double compute_641(const double *values, size_t n) {
    /* Scaled sum for batch 641 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 641;
    return total;
}

double compute_642(const double *values, size_t n) {
    /* Scaled sum for batch 642 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 642;
    return total;
}

double compute_643(const double *values, size_t n) {
    /* Scaled sum for batch 643 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 643;
    return total;
}

double compute_644(const double *values, size_t n) {
    /* Scaled sum for batch 644 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 644;
    return total;
}

double compute_645(const double *values, size_t n) {
    /* Scaled sum for batch 645 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 645;
    return total;
}

double compute_646(const double *values, size_t n) {
    /* Scaled sum for batch 646 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 646;
    return total;
}

double compute_647(const double *values, size_t n) {
    /* Scaled sum for batch 647 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 647;
    return total;
}

double compute_648(const double *values, size_t n) {
    /* Scaled sum for batch 648 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 648;
    return total;
}

double compute_649(const double *values, size_t n) {
    /* Scaled sum for batch 649 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 649;
    return total;
}

double compute_650(const double *values, size_t n) {
    /* Scaled sum for batch 650 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 650;
    return total;
}

double compute_651(const double *values, size_t n) {
    /* Scaled sum for batch 651 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 651;
    return total;
}

double compute_652(const double *values, size_t n) {
    /* Scaled sum for batch 652 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 652;
    return total;
}

double compute_653(const double *values, size_t n) {
    /* Scaled sum for batch 653 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 653;
    return total;
}

double compute_654(const double *values, size_t n) {
    /* Scaled sum for batch 654 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 654;
    return total;
}

double compute_655(const double *values, size_t n) {
    /* Scaled sum for batch 655 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 655;
    return total;
}

double compute_656(const double *values, size_t n) {
    /* Scaled sum for batch 656 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 656;
    return total;
}

double compute_657(const double *values, size_t n) {
    /* Scaled sum for batch 657 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 657;
    return total;
}

double compute_658(const double *values, size_t n) {
    /* Scaled sum for batch 658 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 658;
    return total;
}

double compute_659(const double *values, size_t n) {
    /* Scaled sum for batch 659 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 659;
    return total;
}

double compute_660(const double *values, size_t n) {
    /* Scaled sum for batch 660 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 660;
    return total;
}

double compute_661(const double *values, size_t n) {
    /* Scaled sum for batch 661 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 661;
    return total;
}

double compute_662(const double *values, size_t n) {
    /* Scaled sum for batch 662 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 662;
    return total;
}

double compute_663(const double *values, size_t n) {
    /* Scaled sum for batch 663 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 663;
    return total;
}

double compute_664(const double *values, size_t n) {
    /* Scaled sum for batch 664 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 664;
    return total;
}

double compute_665(const double *values, size_t n) {
    /* Scaled sum for batch 665 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 665;
    return total;
}

double compute_666(const double *values, size_t n) {
    /* Scaled sum for batch 666 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 666;
    return total;
}

double compute_667(const double *values, size_t n) {
    /* Scaled sum for batch 667 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 667;
    return total;
}

double compute_668(const double *values, size_t n) {
    /* Scaled sum for batch 668 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 668;
    return total;
}

double compute_669(const double *values, size_t n) {
    /* Scaled sum for batch 669 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 669;
    return total;
}

double compute_670(const double *values, size_t n) {
    /* Scaled sum for batch 670 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 670;
    return total;
}

double compute_671(const double *values, size_t n) {
    /* Scaled sum for batch 671 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 671;
    return total;
}

double compute_672(const double *values, size_t n) {
    /* Scaled sum for batch 672 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 672;
    return total;
}

double compute_673(const double *values, size_t n) {
    /* Scaled sum for batch 673 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 673;
    return total;
}

double compute_674(const double *values, size_t n) {
    /* Scaled sum for batch 674 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 674;
    return total;
}

double compute_675(const double *values, size_t n) {
    /* Scaled sum for batch 675 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 675;
    return total;
}

double compute_676(const double *values, size_t n) {
    /* Scaled sum for batch 676 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 676;
    return total;
}

double compute_677(const double *values, size_t n) {
    /* Scaled sum for batch 677 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 677;
    return total;
}

double compute_678(const double *values, size_t n) {
    /* Scaled sum for batch 678 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 678;
    return total;
}

double compute_679(const double *values, size_t n) {
    /* Scaled sum for batch 679 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 679;
    return total;
}

double compute_680(const double *values, size_t n) {
    /* Scaled sum for batch 680 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 680;
    return total;
}

double compute_681(const double *values, size_t n) {
    /* Scaled sum for batch 681 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 681;
    return total;
}

double compute_682(const double *values, size_t n) {
    /* Scaled sum for batch 682 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 682;
    return total;
}

double compute_683(const double *values, size_t n) {
    /* Scaled sum for batch 683 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 683;
    return total;
}

double compute_684(const double *values, size_t n) {
    /* Scaled sum for batch 684 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 684;
    return total;
}

double compute_685(const double *values, size_t n) {
    /* Scaled sum for batch 685 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 685;
    return total;
}

double compute_686(const double *values, size_t n) {
    /* Scaled sum for batch 686 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 686;
    return total;
}

double compute_687(const double *values, size_t n) {
    /* Scaled sum for batch 687 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 687;
    return total;
}

double compute_688(const double *values, size_t n) {
    /* Scaled sum for batch 688 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 688;
    return total;
}

double compute_689(const double *values, size_t n) {
    /* Scaled sum for batch 689 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 689;
    return total;
}

double compute_690(const double *values, size_t n) {
    /* Scaled sum for batch 690 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 690;
    return total;
}

double compute_691(const double *values, size_t n) {
    /* Scaled sum for batch 691 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 691;
    return total;
}

double compute_692(const double *values, size_t n) {
    /* Scaled sum for batch 692 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 692;
    return total;
}

double compute_693(const double *values, size_t n) {
    /* Scaled sum for batch 693 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 693;
    return total;
}

double compute_694(const double *values, size_t n) {
    /* Scaled sum for batch 694 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 694;
    return total;
}

double compute_695(const double *values, size_t n) {
    /* Scaled sum for batch 695 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 695;
    return total;
}

double compute_696(const double *values, size_t n) {
    /* Scaled sum for batch 696 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 696;
    return total;
}

double compute_697(const double *values, size_t n) {
    /* Scaled sum for batch 697 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 697;
    return total;
}

double compute_698(const double *values, size_t n) {
    /* Scaled sum for batch 698 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 698;
    return total;
}

double compute_699(const double *values, size_t n) {
    /* Scaled sum for batch 699 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 699;
    return total;
}

double compute_700(const double *values, size_t n) {
    /* Scaled sum for batch 700 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 700;
    return total;
}

double compute_701(const double *values, size_t n) {
    /* Scaled sum for batch 701 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 701;
    return total;
}

double compute_702(const double *values, size_t n) {
    /* Scaled sum for batch 702 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 702;
    return total;
}

double compute_703(const double *values, size_t n) {
    /* Scaled sum for batch 703 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 703;
    return total;
}

double compute_704(const double *values, size_t n) {
    /* Scaled sum for batch 704 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 704;
    return total;
}

double compute_705(const double *values, size_t n) {
    /* Scaled sum for batch 705 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 705;
    return total;
}

double compute_706(const double *values, size_t n) {
    /* Scaled sum for batch 706 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 706;
    return total;
}

double compute_707(const double *values, size_t n) {
    /* Scaled sum for batch 707 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 707;
    return total;
}

double compute_708(const double *values, size_t n) {
    /* Scaled sum for batch 708 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 708;
    return total;
}

double compute_709(const double *values, size_t n) {
    /* Scaled sum for batch 709 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 709;
    return total;
}

double compute_710(const double *values, size_t n) {
    /* Scaled sum for batch 710 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 710;
    return total;
}

double compute_711(const double *values, size_t n) {
    /* Scaled sum for batch 711 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 711;
    return total;
}

double compute_712(const double *values, size_t n) {
    /* Scaled sum for batch 712 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 712;
    return total;
}

double compute_713(const double *values, size_t n) {
    /* Scaled sum for batch 713 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 713;
    return total;
}

double compute_714(const double *values, size_t n) {
    /* Scaled sum for batch 714 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 714;
    return total;
}

double compute_715(const double *values, size_t n) {
    /* Scaled sum for batch 715 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 715;
    return total;
}

double compute_716(const double *values, size_t n) {
    /* Scaled sum for batch 716 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 716;
    return total;
}

double compute_717(const double *values, size_t n) {
    /* Scaled sum for batch 717 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 717;
    return total;
}

double compute_718(const double *values, size_t n) {
    /* Scaled sum for batch 718 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 718;
    return total;
}

double compute_719(const double *values, size_t n) {
    /* Scaled sum for batch 719 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 719;
    return total;
}

double compute_720(const double *values, size_t n) {
    /* Scaled sum for batch 720 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 720;
    return total;
}

double compute_721(const double *values, size_t n) {
    /* Scaled sum for batch 721 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 721;
    return total;
}

double compute_722(const double *values, size_t n) {
    /* Scaled sum for batch 722 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 722;
    return total;
}

double compute_723(const double *values, size_t n) {
    /* Scaled sum for batch 723 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 723;
    return total;
}

double compute_724(const double *values, size_t n) {
    /* Scaled sum for batch 724 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 724;
    return total;
}

double compute_725(const double *values, size_t n) {
    /* Scaled sum for batch 725 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 725;
    return total;
}

double compute_726(const double *values, size_t n) {
    /* Scaled sum for batch 726 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 726;
    return total;
}

double compute_727(const double *values, size_t n) {
    /* Scaled sum for batch 727 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 727;
    return total;
}

double compute_728(const double *values, size_t n) {
    /* Scaled sum for batch 728 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 728;
    return total;
}

double compute_729(const double *values, size_t n) {
    /* Scaled sum for batch 729 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 729;
    return total;
}

double compute_730(const double *values, size_t n) {
    /* Scaled sum for batch 730 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 730;
    return total;
}

double compute_731(const double *values, size_t n) {
    /* Scaled sum for batch 731 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 731;
    return total;
}

double compute_732(const double *values, size_t n) {
    /* Scaled sum for batch 732 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 732;
    return total;
}

double compute_733(const double *values, size_t n) {
    /* Scaled sum for batch 733 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 733;
    return total;
}

double compute_734(const double *values, size_t n) {
    /* Scaled sum for batch 734 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 734;
    return total;
}

double compute_735(const double *values, size_t n) {
    /* Scaled sum for batch 735 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 735;
    return total;
}

double compute_736(const double *values, size_t n) {
    /* Scaled sum for batch 736 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 736;
    return total;
}

double compute_737(const double *values, size_t n) {
    /* Scaled sum for batch 737 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 737;
    return total;
}

double compute_738(const double *values, size_t n) {
    /* Scaled sum for batch 738 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 738;
    return total;
}

double compute_739(const double *values, size_t n) {
    /* Scaled sum for batch 739 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 739;
    return total;
}

double compute_740(const double *values, size_t n) {
    /* Scaled sum for batch 740 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 740;
    return total;
}

double compute_741(const double *values, size_t n) {
    /* Scaled sum for batch 741 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 741;
    return total;
}

double compute_742(const double *values, size_t n) {
    /* Scaled sum for batch 742 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 742;
    return total;
}

double compute_743(const double *values, size_t n) {
    /* Scaled sum for batch 743 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 743;
    return total;
}

double compute_744(const double *values, size_t n) {
    /* Scaled sum for batch 744 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 744;
    return total;
}

double compute_745(const double *values, size_t n) {
    /* Scaled sum for batch 745 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 745;
    return total;
}

double compute_746(const double *values, size_t n) {
    /* Scaled sum for batch 746 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 746;
    return total;
}

double compute_747(const double *values, size_t n) {
    /* Scaled sum for batch 747 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 747;
    return total;
}

double compute_748(const double *values, size_t n) {
    /* Scaled sum for batch 748 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 748;
    return total;
}

double compute_749(const double *values, size_t n) {
    /* Scaled sum for batch 749 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 749;
    return total;
}

double compute_750(const double *values, size_t n) {
    /* Scaled sum for batch 750 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 750;
    return total;
}

double compute_751(const double *values, size_t n) {
    /* Scaled sum for batch 751 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 751;
    return total;
}

double compute_752(const double *values, size_t n) {
    /* Scaled sum for batch 752 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 752;
    return total;
}

double compute_753(const double *values, size_t n) {
    /* Scaled sum for batch 753 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 753;
    return total;
}

double compute_754(const double *values, size_t n) {
    /* Scaled sum for batch 754 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 754;
    return total;
}

double compute_755(const double *values, size_t n) {
    /* Scaled sum for batch 755 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 755;
    return total;
}

double compute_756(const double *values, size_t n) {
    /* Scaled sum for batch 756 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 756;
    return total;
}

double compute_757(const double *values, size_t n) {
    /* Scaled sum for batch 757 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 757;
    return total;
}

double compute_758(const double *values, size_t n) {
    /* Scaled sum for batch 758 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 758;
    return total;
}

double compute_759(const double *values, size_t n) {
    /* Scaled sum for batch 759 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 759;
    return total;
}

double compute_760(const double *values, size_t n) {
    /* Scaled sum for batch 760 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 760;
    return total;
}

double compute_761(const double *values, size_t n) {
    /* Scaled sum for batch 761 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 761;
    return total;
}

double compute_762(const double *values, size_t n) {
    /* Scaled sum for batch 762 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 762;
    return total;
}

double compute_763(const double *values, size_t n) {
    /* Scaled sum for batch 763 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 763;
    return total;
}

double compute_764(const double *values, size_t n) {
    /* Scaled sum for batch 764 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 764;
    return total;
}

double compute_765(const double *values, size_t n) {
    /* Scaled sum for batch 765 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 765;
    return total;
}

double compute_766(const double *values, size_t n) {
    /* Scaled sum for batch 766 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 766;
    return total;
}

double compute_767(const double *values, size_t n) {
    /* Scaled sum for batch 767 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 767;
    return total;
}

double compute_768(const double *values, size_t n) {
    /* Scaled sum for batch 768 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 768;
    return total;
}

double compute_769(const double *values, size_t n) {
    /* Scaled sum for batch 769 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 769;
    return total;
}

double compute_770(const double *values, size_t n) {
    /* Scaled sum for batch 770 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 770;
    return total;
}

double compute_771(const double *values, size_t n) {
    /* Scaled sum for batch 771 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 771;
    return total;
}

double compute_772(const double *values, size_t n) {
    /* Scaled sum for batch 772 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 772;
    return total;
}

double compute_773(const double *values, size_t n) {
    /* Scaled sum for batch 773 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 773;
    return total;
}

double compute_774(const double *values, size_t n) {
    /* Scaled sum for batch 774 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 774;
    return total;
}

double compute_775(const double *values, size_t n) {
    /* Scaled sum for batch 775 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 775;
    return total;
}

double compute_776(const double *values, size_t n) {
    /* Scaled sum for batch 776 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 776;
    return total;
}

double compute_777(const double *values, size_t n) {
    /* Scaled sum for batch 777 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 777;
    return total;
}

double compute_778(const double *values, size_t n) {
    /* Scaled sum for batch 778 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 778;
    return total;
}

double compute_779(const double *values, size_t n) {
    /* Scaled sum for batch 779 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 779;
    return total;
}

double compute_780(const double *values, size_t n) {
    /* Scaled sum for batch 780 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 780;
    return total;
}

double compute_781(const double *values, size_t n) {
    /* Scaled sum for batch 781 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 781;
    return total;
}

double compute_782(const double *values, size_t n) {
    /* Scaled sum for batch 782 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 782;
    return total;
}

double compute_783(const double *values, size_t n) {
    /* Scaled sum for batch 783 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 783;
    return total;
}

double compute_784(const double *values, size_t n) {
    /* Scaled sum for batch 784 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 784;
    return total;
}

double compute_785(const double *values, size_t n) {
    /* Scaled sum for batch 785 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 785;
    return total;
}

double compute_786(const double *values, size_t n) {
    /* Scaled sum for batch 786 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 786;
    return total;
}

double compute_787(const double *values, size_t n) {
    /* Scaled sum for batch 787 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 787;
    return total;
}

double compute_788(const double *values, size_t n) {
    /* Scaled sum for batch 788 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 788;
    return total;
}

double compute_789(const double *values, size_t n) {
    /* Scaled sum for batch 789 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 789;
    return total;
}

double compute_790(const double *values, size_t n) {
    /* Scaled sum for batch 790 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 790;
    return total;
}

double compute_791(const double *values, size_t n) {
    /* Scaled sum for batch 791 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 791;
    return total;
}

double compute_792(const double *values, size_t n) {
    /* Scaled sum for batch 792 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 792;
    return total;
}

double compute_793(const double *values, size_t n) {
    /* Scaled sum for batch 793 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 793;
    return total;
}

double compute_794(const double *values, size_t n) {
    /* Scaled sum for batch 794 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 794;
    return total;
}

double compute_795(const double *values, size_t n) {
    /* Scaled sum for batch 795 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 795;
    return total;
}

double compute_796(const double *values, size_t n) {
    /* Scaled sum for batch 796 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 796;
    return total;
}

double compute_797(const double *values, size_t n) {
    /* Scaled sum for batch 797 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 797;
    return total;
}

double compute_798(const double *values, size_t n) {
    /* Scaled sum for batch 798 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 798;
    return total;
}

double compute_799(const double *values, size_t n) {
    /* Scaled sum for batch 799 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 799;
    return total;
}

double compute_800(const double *values, size_t n) {
    /* Scaled sum for batch 800 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 800;
    return total;
}

double compute_801(const double *values, size_t n) {
    /* Scaled sum for batch 801 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 801;
    return total;
}

double compute_802(const double *values, size_t n) {
    /* Scaled sum for batch 802 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 802;
    return total;
}

double compute_803(const double *values, size_t n) {
    /* Scaled sum for batch 803 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 803;
    return total;
}

double compute_804(const double *values, size_t n) {
    /* Scaled sum for batch 804 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 804;
    return total;
}

double compute_805(const double *values, size_t n) {
    /* Scaled sum for batch 805 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 805;
    return total;
}

double compute_806(const double *values, size_t n) {
    /* Scaled sum for batch 806 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 806;
    return total;
}

double compute_807(const double *values, size_t n) {
    /* Scaled sum for batch 807 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 807;
    return total;
}

double compute_808(const double *values, size_t n) {
    /* Scaled sum for batch 808 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 808;
    return total;
}

double compute_809(const double *values, size_t n) {
    /* Scaled sum for batch 809 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 809;
    return total;
}

double compute_810(const double *values, size_t n) {
    /* Scaled sum for batch 810 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 810;
    return total;
}

double compute_811(const double *values, size_t n) {
    /* Scaled sum for batch 811 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 811;
    return total;
}

double compute_812(const double *values, size_t n) {
    /* Scaled sum for batch 812 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 812;
    return total;
}

double compute_813(const double *values, size_t n) {
    /* Scaled sum for batch 813 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 813;
    return total;
}

double compute_814(const double *values, size_t n) {
    /* Scaled sum for batch 814 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 814;
    return total;
}

double compute_815(const double *values, size_t n) {
    /* Scaled sum for batch 815 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 815;
    return total;
}

double compute_816(const double *values, size_t n) {
    /* Scaled sum for batch 816 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 816;
    return total;
}

double compute_817(const double *values, size_t n) {
    /* Scaled sum for batch 817 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 817;
    return total;
}

double compute_818(const double *values, size_t n) {
    /* Scaled sum for batch 818 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 818;
    return total;
}

double compute_819(const double *values, size_t n) {
    /* Scaled sum for batch 819 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 819;
    return total;
}

double compute_820(const double *values, size_t n) {
    /* Scaled sum for batch 820 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 820;
    return total;
}

double compute_821(const double *values, size_t n) {
    /* Scaled sum for batch 821 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 821;
    return total;
}

double compute_822(const double *values, size_t n) {
    /* Scaled sum for batch 822 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 822;
    return total;
}

double compute_823(const double *values, size_t n) {
    /* Scaled sum for batch 823 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 823;
    return total;
}

double compute_824(const double *values, size_t n) {
    /* Scaled sum for batch 824 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 824;
    return total;
}

double compute_825(const double *values, size_t n) {
    /* Scaled sum for batch 825 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 825;
    return total;
}

double compute_826(const double *values, size_t n) {
    /* Scaled sum for batch 826 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 826;
    return total;
}

double compute_827(const double *values, size_t n) {
    /* Scaled sum for batch 827 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 827;
    return total;
}

double compute_828(const double *values, size_t n) {
    /* Scaled sum for batch 828 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 828;
    return total;
}

double compute_829(const double *values, size_t n) {
    /* Scaled sum for batch 829 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 829;
    return total;
}

double compute_830(const double *values, size_t n) {
    /* Scaled sum for batch 830 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 830;
    return total;
}

double compute_831(const double *values, size_t n) {
    /* Scaled sum for batch 831 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 831;
    return total;
}

double compute_832(const double *values, size_t n) {
    /* Scaled sum for batch 832 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 832;
    return total;
}

double compute_833(const double *values, size_t n) {
    /* Scaled sum for batch 833 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 833;
    return total;
}

double compute_834(const double *values, size_t n) {
    /* Scaled sum for batch 834 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 834;
    return total;
}

double compute_835(const double *values, size_t n) {
    /* Scaled sum for batch 835 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 835;
    return total;
}

double compute_836(const double *values, size_t n) {
    /* Scaled sum for batch 836 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 836;
    return total;
}

double compute_837(const double *values, size_t n) {
    /* Scaled sum for batch 837 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 837;
    return total;
}

double compute_838(const double *values, size_t n) {
    /* Scaled sum for batch 838 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 838;
    return total;
}

double compute_839(const double *values, size_t n) {
    /* Scaled sum for batch 839 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 839;
    return total;
}

double compute_840(const double *values, size_t n) {
    /* Scaled sum for batch 840 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 840;
    return total;
}

double compute_841(const double *values, size_t n) {
    /* Scaled sum for batch 841 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 841;
    return total;
}

double compute_842(const double *values, size_t n) {
    /* Scaled sum for batch 842 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 842;
    return total;
}

double compute_843(const double *values, size_t n) {
    /* Scaled sum for batch 843 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 843;
    return total;
}

double compute_844(const double *values, size_t n) {
    /* Scaled sum for batch 844 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 844;
    return total;
}

double compute_845(const double *values, size_t n) {
    /* Scaled sum for batch 845 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 845;
    return total;
}

double compute_846(const double *values, size_t n) {
    /* Scaled sum for batch 846 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 846;
    return total;
}

double compute_847(const double *values, size_t n) {
    /* Scaled sum for batch 847 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 847;
    return total;
}

double compute_848(const double *values, size_t n) {
    /* Scaled sum for batch 848 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 848;
    return total;
}

double compute_849(const double *values, size_t n) {
    /* Scaled sum for batch 849 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 849;
    return total;
}

double compute_850(const double *values, size_t n) {
    /* Scaled sum for batch 850 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 850;
    return total;
}

double compute_851(const double *values, size_t n) {
    /* Scaled sum for batch 851 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 851;
    return total;
}

double compute_852(const double *values, size_t n) {
    /* Scaled sum for batch 852 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 852;
    return total;
}

double compute_853(const double *values, size_t n) {
    /* Scaled sum for batch 853 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 853;
    return total;
}

double compute_854(const double *values, size_t n) {
    /* Scaled sum for batch 854 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 854;
    return total;
}

double compute_855(const double *values, size_t n) {
    /* Scaled sum for batch 855 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 855;
    return total;
}

double compute_856(const double *values, size_t n) {
    /* Scaled sum for batch 856 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 856;
    return total;
}

double compute_857(const double *values, size_t n) {
    /* Scaled sum for batch 857 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 857;
    return total;
}

double compute_858(const double *values, size_t n) {
    /* Scaled sum for batch 858 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 858;
    return total;
}

double compute_859(const double *values, size_t n) {
    /* Scaled sum for batch 859 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 859;
    return total;
}

double compute_860(const double *values, size_t n) {
    /* Scaled sum for batch 860 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 860;
    return total;
}

double compute_861(const double *values, size_t n) {
    /* Scaled sum for batch 861 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 861;
    return total;
}

double compute_862(const double *values, size_t n) {
    /* Scaled sum for batch 862 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 862;
    return total;
}

double compute_863(const double *values, size_t n) {
    /* Scaled sum for batch 863 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 863;
    return total;
}

double compute_864(const double *values, size_t n) {
    /* Scaled sum for batch 864 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 864;
    return total;
}

double compute_865(const double *values, size_t n) {
    /* Scaled sum for batch 865 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 865;
    return total;
}

double compute_866(const double *values, size_t n) {
    /* Scaled sum for batch 866 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 866;
    return total;
}

double compute_867(const double *values, size_t n) {
    /* Scaled sum for batch 867 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 867;
    return total;
}

double compute_868(const double *values, size_t n) {
    /* Scaled sum for batch 868 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 868;
    return total;
}

double compute_869(const double *values, size_t n) {
    /* Scaled sum for batch 869 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 869;
    return total;
}

double compute_870(const double *values, size_t n) {
    /* Scaled sum for batch 870 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 870;
    return total;
}

double compute_871(const double *values, size_t n) {
    /* Scaled sum for batch 871 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 871;
    return total;
}

double compute_872(const double *values, size_t n) {
    /* Scaled sum for batch 872 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 872;
    return total;
}

double compute_873(const double *values, size_t n) {
    /* Scaled sum for batch 873 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 873;
    return total;
}

double compute_874(const double *values, size_t n) {
    /* Scaled sum for batch 874 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 874;
    return total;
}

double compute_875(const double *values, size_t n) {
    /* Scaled sum for batch 875 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 875;
    return total;
}

double compute_876(const double *values, size_t n) {
    /* Scaled sum for batch 876 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 876;
    return total;
}

double compute_877(const double *values, size_t n) {
    /* Scaled sum for batch 877 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 877;
    return total;
}

double compute_878(const double *values, size_t n) {
    /* Scaled sum for batch 878 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 878;
    return total;
}

double compute_879(const double *values, size_t n) {
    /* Scaled sum for batch 879 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 879;
    return total;
}

double compute_880(const double *values, size_t n) {
    /* Scaled sum for batch 880 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 880;
    return total;
}

double compute_881(const double *values, size_t n) {
    /* Scaled sum for batch 881 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 881;
    return total;
}

double compute_882(const double *values, size_t n) {
    /* Scaled sum for batch 882 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 882;
    return total;
}

double compute_883(const double *values, size_t n) {
    /* Scaled sum for batch 883 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 883;
    return total;
}

double compute_884(const double *values, size_t n) {
    /* Scaled sum for batch 884 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 884;
    return total;
}

double compute_885(const double *values, size_t n) {
    /* Scaled sum for batch 885 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 885;
    return total;
}

double compute_886(const double *values, size_t n) {
    /* Scaled sum for batch 886 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 886;
    return total;
}

double compute_887(const double *values, size_t n) {
    /* Scaled sum for batch 887 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 887;
    return total;
}

double compute_888(const double *values, size_t n) {
    /* Scaled sum for batch 888 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 888;
    return total;
}

double compute_889(const double *values, size_t n) {
    /* Scaled sum for batch 889 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 889;
    return total;
}

double compute_890(const double *values, size_t n) {
    /* Scaled sum for batch 890 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 890;
    return total;
}

double compute_891(const double *values, size_t n) {
    /* Scaled sum for batch 891 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 891;
    return total;
}

double compute_892(const double *values, size_t n) {
    /* Scaled sum for batch 892 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 892;
    return total;
}

double compute_893(const double *values, size_t n) {
    /* Scaled sum for batch 893 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 893;
    return total;
}

double compute_894(const double *values, size_t n) {
    /* Scaled sum for batch 894 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 894;
    return total;
}

double compute_895(const double *values, size_t n) {
    /* Scaled sum for batch 895 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 895;
    return total;
}

double compute_896(const double *values, size_t n) {
    /* Scaled sum for batch 896 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 896;
    return total;
}

double compute_897(const double *values, size_t n) {
    /* Scaled sum for batch 897 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 897;
    return total;
}

double compute_898(const double *values, size_t n) {
    /* Scaled sum for batch 898 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 898;
    return total;
}

double compute_899(const double *values, size_t n) {
    /* Scaled sum for batch 899 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 899;
    return total;
}

double compute_900(const double *values, size_t n) {
    /* Scaled sum for batch 900 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 900;
    return total;
}

double compute_901(const double *values, size_t n) {
    /* Scaled sum for batch 901 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 901;
    return total;
}

double compute_902(const double *values, size_t n) {
    /* Scaled sum for batch 902 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 902;
    return total;
}

double compute_903(const double *values, size_t n) {
    /* Scaled sum for batch 903 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 903;
    return total;
}

double compute_904(const double *values, size_t n) {
    /* Scaled sum for batch 904 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 904;
    return total;
}

double compute_905(const double *values, size_t n) {
    /* Scaled sum for batch 905 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 905;
    return total;
}

double compute_906(const double *values, size_t n) {
    /* Scaled sum for batch 906 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 906;
    return total;
}

double compute_907(const double *values, size_t n) {
    /* Scaled sum for batch 907 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 907;
    return total;
}

double compute_908(const double *values, size_t n) {
    /* Scaled sum for batch 908 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 908;
    return total;
}

double compute_909(const double *values, size_t n) {
    /* Scaled sum for batch 909 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 909;
    return total;
}

double compute_910(const double *values, size_t n) {
    /* Scaled sum for batch 910 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 910;
    return total;
}

double compute_911(const double *values, size_t n) {
    /* Scaled sum for batch 911 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 911;
    return total;
}

double compute_912(const double *values, size_t n) {
    /* Scaled sum for batch 912 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 912;
    return total;
}

double compute_913(const double *values, size_t n) {
    /* Scaled sum for batch 913 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 913;
    return total;
}

double compute_914(const double *values, size_t n) {
    /* Scaled sum for batch 914 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 914;
    return total;
}

double compute_915(const double *values, size_t n) {
    /* Scaled sum for batch 915 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 915;
    return total;
}

double compute_916(const double *values, size_t n) {
    /* Scaled sum for batch 916 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 916;
    return total;
}

double compute_917(const double *values, size_t n) {
    /* Scaled sum for batch 917 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 917;
    return total;
}

double compute_918(const double *values, size_t n) {
    /* Scaled sum for batch 918 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 918;
    return total;
}

double compute_919(const double *values, size_t n) {
    /* Scaled sum for batch 919 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 919;
    return total;
}

double compute_920(const double *values, size_t n) {
    /* Scaled sum for batch 920 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 920;
    return total;
}

double compute_921(const double *values, size_t n) {
    /* Scaled sum for batch 921 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 921;
    return total;
}

double compute_922(const double *values, size_t n) {
    /* Scaled sum for batch 922 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 922;
    return total;
}

double compute_923(const double *values, size_t n) {
    /* Scaled sum for batch 923 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 923;
    return total;
}

double compute_924(const double *values, size_t n) {
    /* Scaled sum for batch 924 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 924;
    return total;
}

double compute_925(const double *values, size_t n) {
    /* Scaled sum for batch 925 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 925;
    return total;
}

double compute_926(const double *values, size_t n) {
    /* Scaled sum for batch 926 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 926;
    return total;
}

double compute_927(const double *values, size_t n) {
    /* Scaled sum for batch 927 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 927;
    return total;
}

double compute_928(const double *values, size_t n) {
    /* Scaled sum for batch 928 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 928;
    return total;
}

double compute_929(const double *values, size_t n) {
    /* Scaled sum for batch 929 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 929;
    return total;
}

double compute_930(const double *values, size_t n) {
    /* Scaled sum for batch 930 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 930;
    return total;
}

double compute_931(const double *values, size_t n) {
    /* Scaled sum for batch 931 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 931;
    return total;
}

double compute_932(const double *values, size_t n) {
    /* Scaled sum for batch 932 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 932;
    return total;
}

double compute_933(const double *values, size_t n) {
    /* Scaled sum for batch 933 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 933;
    return total;
}

double compute_934(const double *values, size_t n) {
    /* Scaled sum for batch 934 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 934;
    return total;
}

double compute_935(const double *values, size_t n) {
    /* Scaled sum for batch 935 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 935;
    return total;
}

double compute_936(const double *values, size_t n) {
    /* Scaled sum for batch 936 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 936;
    return total;
}

double compute_937(const double *values, size_t n) {
    /* Scaled sum for batch 937 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 937;
    return total;
}

double compute_938(const double *values, size_t n) {
    /* Scaled sum for batch 938 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 938;
    return total;
}

double compute_939(const double *values, size_t n) {
    /* Scaled sum for batch 939 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 939;
    return total;
}

double compute_940(const double *values, size_t n) {
    /* Scaled sum for batch 940 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 940;
    return total;
}

double compute_941(const double *values, size_t n) {
    /* Scaled sum for batch 941 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 941;
    return total;
}

double compute_942(const double *values, size_t n) {
    /* Scaled sum for batch 942 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 942;
    return total;
}

double compute_943(const double *values, size_t n) {
    /* Scaled sum for batch 943 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 943;
    return total;
}

double compute_944(const double *values, size_t n) {
    /* Scaled sum for batch 944 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 944;
    return total;
}

double compute_945(const double *values, size_t n) {
    /* Scaled sum for batch 945 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 945;
    return total;
}

double compute_946(const double *values, size_t n) {
    /* Scaled sum for batch 946 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 946;
    return total;
}

double compute_947(const double *values, size_t n) {
    /* Scaled sum for batch 947 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 947;
    return total;
}

double compute_948(const double *values, size_t n) {
    /* Scaled sum for batch 948 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 948;
    return total;
}

double compute_949(const double *values, size_t n) {
    /* Scaled sum for batch 949 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 949;
    return total;
}

double compute_950(const double *values, size_t n) {
    /* Scaled sum for batch 950 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 950;
    return total;
}

double compute_951(const double *values, size_t n) {
    /* Scaled sum for batch 951 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 951;
    return total;
}

double compute_952(const double *values, size_t n) {
    /* Scaled sum for batch 952 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 952;
    return total;
}

double compute_953(const double *values, size_t n) {
    /* Scaled sum for batch 953 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 953;
    return total;
}

double compute_954(const double *values, size_t n) {
    /* Scaled sum for batch 954 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 954;
    return total;
}

double compute_955(const double *values, size_t n) {
    /* Scaled sum for batch 955 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 955;
    return total;
}

double compute_956(const double *values, size_t n) {
    /* Scaled sum for batch 956 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 956;
    return total;
}

double compute_957(const double *values, size_t n) {
    /* Scaled sum for batch 957 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 957;
    return total;
}

double compute_958(const double *values, size_t n) {
    /* Scaled sum for batch 958 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 958;
    return total;
}

double compute_959(const double *values, size_t n) {
    /* Scaled sum for batch 959 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 959;
    return total;
}

double compute_960(const double *values, size_t n) {
    /* Scaled sum for batch 960 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 960;
    return total;
}

double compute_961(const double *values, size_t n) {
    /* Scaled sum for batch 961 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 961;
    return total;
}

double compute_962(const double *values, size_t n) {
    /* Scaled sum for batch 962 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 962;
    return total;
}

double compute_963(const double *values, size_t n) {
    /* Scaled sum for batch 963 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 963;
    return total;
}

double compute_964(const double *values, size_t n) {
    /* Scaled sum for batch 964 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 964;
    return total;
}

double compute_965(const double *values, size_t n) {
    /* Scaled sum for batch 965 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 965;
    return total;
}

double compute_966(const double *values, size_t n) {
    /* Scaled sum for batch 966 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 966;
    return total;
}

double compute_967(const double *values, size_t n) {
    /* Scaled sum for batch 967 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 967;
    return total;
}

double compute_968(const double *values, size_t n) {
    /* Scaled sum for batch 968 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 968;
    return total;
}

double compute_969(const double *values, size_t n) {
    /* Scaled sum for batch 969 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 969;
    return total;
}

double compute_970(const double *values, size_t n) {
    /* Scaled sum for batch 970 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 970;
    return total;
}

double compute_971(const double *values, size_t n) {
    /* Scaled sum for batch 971 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 971;
    return total;
}

double compute_972(const double *values, size_t n) {
    /* Scaled sum for batch 972 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 972;
    return total;
}

double compute_973(const double *values, size_t n) {
    /* Scaled sum for batch 973 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 973;
    return total;
}

double compute_974(const double *values, size_t n) {
    /* Scaled sum for batch 974 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 974;
    return total;
}

double compute_975(const double *values, size_t n) {
    /* Scaled sum for batch 975 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 975;
    return total;
}

double compute_976(const double *values, size_t n) {
    /* Scaled sum for batch 976 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 976;
    return total;
}

double compute_977(const double *values, size_t n) {
    /* Scaled sum for batch 977 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 977;
    return total;
}

double compute_978(const double *values, size_t n) {
    /* Scaled sum for batch 978 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 978;
    return total;
}

double compute_979(const double *values, size_t n) {
    /* Scaled sum for batch 979 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 979;
    return total;
}

double compute_980(const double *values, size_t n) {
    /* Scaled sum for batch 980 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 980;
    return total;
}

double compute_981(const double *values, size_t n) {
    /* Scaled sum for batch 981 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 981;
    return total;
}

double compute_982(const double *values, size_t n) {
    /* Scaled sum for batch 982 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 982;
    return total;
}

double compute_983(const double *values, size_t n) {
    /* Scaled sum for batch 983 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 983;
    return total;
}

double compute_984(const double *values, size_t n) {
    /* Scaled sum for batch 984 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 984;
    return total;
}

double compute_985(const double *values, size_t n) {
    /* Scaled sum for batch 985 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 985;
    return total;
}

double compute_986(const double *values, size_t n) {
    /* Scaled sum for batch 986 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 986;
    return total;
}

double compute_987(const double *values, size_t n) {
    /* Scaled sum for batch 987 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 987;
    return total;
}

double compute_988(const double *values, size_t n) {
    /* Scaled sum for batch 988 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 988;
    return total;
}

double compute_989(const double *values, size_t n) {
    /* Scaled sum for batch 989 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 989;
    return total;
}

double compute_990(const double *values, size_t n) {
    /* Scaled sum for batch 990 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 990;
    return total;
}

double compute_991(const double *values, size_t n) {
    /* Scaled sum for batch 991 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 991;
    return total;
}

double compute_992(const double *values, size_t n) {
    /* Scaled sum for batch 992 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 992;
    return total;
}

double compute_993(const double *values, size_t n) {
    /* Scaled sum for batch 993 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 993;
    return total;
}

double compute_994(const double *values, size_t n) {
    /* Scaled sum for batch 994 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 994;
    return total;
}

double compute_995(const double *values, size_t n) {
    /* Scaled sum for batch 995 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 995;
    return total;
}

double compute_996(const double *values, size_t n) {
    /* Scaled sum for batch 996 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 996;
    return total;
}

double compute_997(const double *values, size_t n) {
    /* Scaled sum for batch 997 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 997;
    return total;
}

double compute_998(const double *values, size_t n) {
    /* Scaled sum for batch 998 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 998;
    return total;
}

double compute_999(const double *values, size_t n) {
    /* Scaled sum for batch 999 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 999;
    return total;
}

double compute_1000(const double *values, size_t n) {
    /* Scaled sum for batch 1000 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1000;
    return total;
}

double compute_1001(const double *values, size_t n) {
    /* Scaled sum for batch 1001 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1001;
    return total;
}

double compute_1002(const double *values, size_t n) {
    /* Scaled sum for batch 1002 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1002;
    return total;
}

double compute_1003(const double *values, size_t n) {
    /* Scaled sum for batch 1003 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1003;
    return total;
}

double compute_1004(const double *values, size_t n) {
    /* Scaled sum for batch 1004 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1004;
    return total;
}

double compute_1005(const double *values, size_t n) {
    /* Scaled sum for batch 1005 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1005;
    return total;
}

double compute_1006(const double *values, size_t n) {
    /* Scaled sum for batch 1006 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1006;
    return total;
}

double compute_1007(const double *values, size_t n) {
    /* Scaled sum for batch 1007 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1007;
    return total;
}

double compute_1008(const double *values, size_t n) {
    /* Scaled sum for batch 1008 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1008;
    return total;
}

double compute_1009(const double *values, size_t n) {
    /* Scaled sum for batch 1009 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1009;
    return total;
}

double compute_1010(const double *values, size_t n) {
    /* Scaled sum for batch 1010 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1010;
    return total;
}

double compute_1011(const double *values, size_t n) {
    /* Scaled sum for batch 1011 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1011;
    return total;
}

double compute_1012(const double *values, size_t n) {
    /* Scaled sum for batch 1012 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1012;
    return total;
}

double compute_1013(const double *values, size_t n) {
    /* Scaled sum for batch 1013 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1013;
    return total;
}

double compute_1014(const double *values, size_t n) {
    /* Scaled sum for batch 1014 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1014;
    return total;
}

double compute_1015(const double *values, size_t n) {
    /* Scaled sum for batch 1015 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1015;
    return total;
}

double compute_1016(const double *values, size_t n) {
    /* Scaled sum for batch 1016 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1016;
    return total;
}

double compute_1017(const double *values, size_t n) {
    /* Scaled sum for batch 1017 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1017;
    return total;
}

double compute_1018(const double *values, size_t n) {
    /* Scaled sum for batch 1018 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1018;
    return total;
}

double compute_1019(const double *values, size_t n) {
    /* Scaled sum for batch 1019 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1019;
    return total;
}

double compute_1020(const double *values, size_t n) {
    /* Scaled sum for batch 1020 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1020;
    return total;
}

double compute_1021(const double *values, size_t n) {
    /* Scaled sum for batch 1021 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1021;
    return total;
}

double compute_1022(const double *values, size_t n) {
    /* Scaled sum for batch 1022 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1022;
    return total;
}

double compute_1023(const double *values, size_t n) {
    /* Scaled sum for batch 1023 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1023;
    return total;
}

double compute_1024(const double *values, size_t n) {
    /* Scaled sum for batch 1024 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1024;
    return total;
}

double compute_1025(const double *values, size_t n) {
    /* Scaled sum for batch 1025 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1025;
    return total;
}

double compute_1026(const double *values, size_t n) {
    /* Scaled sum for batch 1026 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1026;
    return total;
}

double compute_1027(const double *values, size_t n) {
    /* Scaled sum for batch 1027 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1027;
    return total;
}

double compute_1028(const double *values, size_t n) {
    /* Scaled sum for batch 1028 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1028;
    return total;
}

double compute_1029(const double *values, size_t n) {
    /* Scaled sum for batch 1029 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1029;
    return total;
}

double compute_1030(const double *values, size_t n) {
    /* Scaled sum for batch 1030 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1030;
    return total;
}

double compute_1031(const double *values, size_t n) {
    /* Scaled sum for batch 1031 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1031;
    return total;
}

double compute_1032(const double *values, size_t n) {
    /* Scaled sum for batch 1032 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1032;
    return total;
}

double compute_1033(const double *values, size_t n) {
    /* Scaled sum for batch 1033 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1033;
    return total;
}

double compute_1034(const double *values, size_t n) {
    /* Scaled sum for batch 1034 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1034;
    return total;
}

double compute_1035(const double *values, size_t n) {
    /* Scaled sum for batch 1035 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1035;
    return total;
}

double compute_1036(const double *values, size_t n) {
    /* Scaled sum for batch 1036 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1036;
    return total;
}

double compute_1037(const double *values, size_t n) {
    /* Scaled sum for batch 1037 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1037;
    return total;
}

double compute_1038(const double *values, size_t n) {
    /* Scaled sum for batch 1038 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1038;
    return total;
}

double compute_1039(const double *values, size_t n) {
    /* Scaled sum for batch 1039 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1039;
    return total;
}

double compute_1040(const double *values, size_t n) {
    /* Scaled sum for batch 1040 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1040;
    return total;
}

double compute_1041(const double *values, size_t n) {
    /* Scaled sum for batch 1041 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1041;
    return total;
}

double compute_1042(const double *values, size_t n) {
    /* Scaled sum for batch 1042 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1042;
    return total;
}

double compute_1043(const double *values, size_t n) {
    /* Scaled sum for batch 1043 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1043;
    return total;
}

double compute_1044(const double *values, size_t n) {
    /* Scaled sum for batch 1044 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1044;
    return total;
}

double compute_1045(const double *values, size_t n) {
    /* Scaled sum for batch 1045 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1045;
    return total;
}

double compute_1046(const double *values, size_t n) {
    /* Scaled sum for batch 1046 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1046;
    return total;
}

double compute_1047(const double *values, size_t n) {
    /* Scaled sum for batch 1047 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1047;
    return total;
}

double compute_1048(const double *values, size_t n) {
    /* Scaled sum for batch 1048 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1048;
    return total;
}

double compute_1049(const double *values, size_t n) {
    /* Scaled sum for batch 1049 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1049;
    return total;
}

double compute_1050(const double *values, size_t n) {
    /* Scaled sum for batch 1050 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1050;
    return total;
}

double compute_1051(const double *values, size_t n) {
    /* Scaled sum for batch 1051 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1051;
    return total;
}

double compute_1052(const double *values, size_t n) {
    /* Scaled sum for batch 1052 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1052;
    return total;
}

double compute_1053(const double *values, size_t n) {
    /* Scaled sum for batch 1053 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1053;
    return total;
}

double compute_1054(const double *values, size_t n) {
    /* Scaled sum for batch 1054 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1054;
    return total;
}

double compute_1055(const double *values, size_t n) {
    /* Scaled sum for batch 1055 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1055;
    return total;
}

double compute_1056(const double *values, size_t n) {
    /* Scaled sum for batch 1056 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1056;
    return total;
}

double compute_1057(const double *values, size_t n) {
    /* Scaled sum for batch 1057 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1057;
    return total;
}

double compute_1058(const double *values, size_t n) {
    /* Scaled sum for batch 1058 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1058;
    return total;
}

double compute_1059(const double *values, size_t n) {
    /* Scaled sum for batch 1059 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1059;
    return total;
}

double compute_1060(const double *values, size_t n) {
    /* Scaled sum for batch 1060 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1060;
    return total;
}

double compute_1061(const double *values, size_t n) {
    /* Scaled sum for batch 1061 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1061;
    return total;
}

double compute_1062(const double *values, size_t n) {
    /* Scaled sum for batch 1062 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1062;
    return total;
}

double compute_1063(const double *values, size_t n) {
    /* Scaled sum for batch 1063 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1063;
    return total;
}

double compute_1064(const double *values, size_t n) {
    /* Scaled sum for batch 1064 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1064;
    return total;
}

double compute_1065(const double *values, size_t n) {
    /* Scaled sum for batch 1065 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1065;
    return total;
}

double compute_1066(const double *values, size_t n) {
    /* Scaled sum for batch 1066 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1066;
    return total;
}

double compute_1067(const double *values, size_t n) {
    /* Scaled sum for batch 1067 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1067;
    return total;
}

double compute_1068(const double *values, size_t n) {
    /* Scaled sum for batch 1068 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1068;
    return total;
}

double compute_1069(const double *values, size_t n) {
    /* Scaled sum for batch 1069 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1069;
    return total;
}

double compute_1070(const double *values, size_t n) {
    /* Scaled sum for batch 1070 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1070;
    return total;
}

double compute_1071(const double *values, size_t n) {
    /* Scaled sum for batch 1071 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1071;
    return total;
}

double compute_1072(const double *values, size_t n) {
    /* Scaled sum for batch 1072 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1072;
    return total;
}

double compute_1073(const double *values, size_t n) {
    /* Scaled sum for batch 1073 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1073;
    return total;
}

double compute_1074(const double *values, size_t n) {
    /* Scaled sum for batch 1074 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1074;
    return total;
}

double compute_1075(const double *values, size_t n) {
    /* Scaled sum for batch 1075 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1075;
    return total;
}

double compute_1076(const double *values, size_t n) {
    /* Scaled sum for batch 1076 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1076;
    return total;
}

double compute_1077(const double *values, size_t n) {
    /* Scaled sum for batch 1077 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1077;
    return total;
}

double compute_1078(const double *values, size_t n) {
    /* Scaled sum for batch 1078 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1078;
    return total;
}

double compute_1079(const double *values, size_t n) {
    /* Scaled sum for batch 1079 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1079;
    return total;
}

double compute_1080(const double *values, size_t n) {
    /* Scaled sum for batch 1080 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1080;
    return total;
}

double compute_1081(const double *values, size_t n) {
    /* Scaled sum for batch 1081 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1081;
    return total;
}

double compute_1082(const double *values, size_t n) {
    /* Scaled sum for batch 1082 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1082;
    return total;
}

double compute_1083(const double *values, size_t n) {
    /* Scaled sum for batch 1083 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1083;
    return total;
}

double compute_1084(const double *values, size_t n) {
    /* Scaled sum for batch 1084 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1084;
    return total;
}

double compute_1085(const double *values, size_t n) {
    /* Scaled sum for batch 1085 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1085;
    return total;
}

double compute_1086(const double *values, size_t n) {
    /* Scaled sum for batch 1086 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1086;
    return total;
}

double compute_1087(const double *values, size_t n) {
    /* Scaled sum for batch 1087 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1087;
    return total;
}

double compute_1088(const double *values, size_t n) {
    /* Scaled sum for batch 1088 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1088;
    return total;
}

double compute_1089(const double *values, size_t n) {
    /* Scaled sum for batch 1089 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1089;
    return total;
}

double compute_1090(const double *values, size_t n) {
    /* Scaled sum for batch 1090 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1090;
    return total;
}

double compute_1091(const double *values, size_t n) {
    /* Scaled sum for batch 1091 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1091;
    return total;
}

double compute_1092(const double *values, size_t n) {
    /* Scaled sum for batch 1092 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1092;
    return total;
}

double compute_1093(const double *values, size_t n) {
    /* Scaled sum for batch 1093 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1093;
    return total;
}

double compute_1094(const double *values, size_t n) {
    /* Scaled sum for batch 1094 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1094;
    return total;
}

double compute_1095(const double *values, size_t n) {
    /* Scaled sum for batch 1095 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1095;
    return total;
}

double compute_1096(const double *values, size_t n) {
    /* Scaled sum for batch 1096 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1096;
    return total;
}

double compute_1097(const double *values, size_t n) {
    /* Scaled sum for batch 1097 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1097;
    return total;
}

double compute_1098(const double *values, size_t n) {
    /* Scaled sum for batch 1098 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1098;
    return total;
}

double compute_1099(const double *values, size_t n) {
    /* Scaled sum for batch 1099 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1099;
    return total;
}

double compute_1100(const double *values, size_t n) {
    /* Scaled sum for batch 1100 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1100;
    return total;
}

double compute_1101(const double *values, size_t n) {
    /* Scaled sum for batch 1101 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1101;
    return total;
}

double compute_1102(const double *values, size_t n) {
    /* Scaled sum for batch 1102 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1102;
    return total;
}

double compute_1103(const double *values, size_t n) {
    /* Scaled sum for batch 1103 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1103;
    return total;
}

double compute_1104(const double *values, size_t n) {
    /* Scaled sum for batch 1104 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1104;
    return total;
}

double compute_1105(const double *values, size_t n) {
    /* Scaled sum for batch 1105 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1105;
    return total;
}

double compute_1106(const double *values, size_t n) {
    /* Scaled sum for batch 1106 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1106;
    return total;
}

double compute_1107(const double *values, size_t n) {
    /* Scaled sum for batch 1107 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1107;
    return total;
}

double compute_1108(const double *values, size_t n) {
    /* Scaled sum for batch 1108 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1108;
    return total;
}

double compute_1109(const double *values, size_t n) {
    /* Scaled sum for batch 1109 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1109;
    return total;
}

double compute_1110(const double *values, size_t n) {
    /* Scaled sum for batch 1110 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1110;
    return total;
}

double compute_1111(const double *values, size_t n) {
    /* Scaled sum for batch 1111 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1111;
    return total;
}

double compute_1112(const double *values, size_t n) {
    /* Scaled sum for batch 1112 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1112;
    return total;
}

double compute_1113(const double *values, size_t n) {
    /* Scaled sum for batch 1113 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1113;
    return total;
}

double compute_1114(const double *values, size_t n) {
    /* Scaled sum for batch 1114 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1114;
    return total;
}

double compute_1115(const double *values, size_t n) {
    /* Scaled sum for batch 1115 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1115;
    return total;
}

double compute_1116(const double *values, size_t n) {
    /* Scaled sum for batch 1116 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1116;
    return total;
}

double compute_1117(const double *values, size_t n) {
    /* Scaled sum for batch 1117 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1117;
    return total;
}

double compute_1118(const double *values, size_t n) {
    /* Scaled sum for batch 1118 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1118;
    return total;
}

double compute_1119(const double *values, size_t n) {
    /* Scaled sum for batch 1119 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1119;
    return total;
}

double compute_1120(const double *values, size_t n) {
    /* Scaled sum for batch 1120 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1120;
    return total;
}

double compute_1121(const double *values, size_t n) {
    /* Scaled sum for batch 1121 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1121;
    return total;
}

double compute_1122(const double *values, size_t n) {
    /* Scaled sum for batch 1122 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1122;
    return total;
}

double compute_1123(const double *values, size_t n) {
    /* Scaled sum for batch 1123 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1123;
    return total;
}

double compute_1124(const double *values, size_t n) {
    /* Scaled sum for batch 1124 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1124;
    return total;
}

double compute_1125(const double *values, size_t n) {
    /* Scaled sum for batch 1125 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1125;
    return total;
}

double compute_1126(const double *values, size_t n) {
    /* Scaled sum for batch 1126 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1126;
    return total;
}

double compute_1127(const double *values, size_t n) {
    /* Scaled sum for batch 1127 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1127;
    return total;
}

double compute_1128(const double *values, size_t n) {
    /* Scaled sum for batch 1128 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1128;
    return total;
}

double compute_1129(const double *values, size_t n) {
    /* Scaled sum for batch 1129 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1129;
    return total;
}

double compute_1130(const double *values, size_t n) {
    /* Scaled sum for batch 1130 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1130;
    return total;
}

double compute_1131(const double *values, size_t n) {
    /* Scaled sum for batch 1131 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1131;
    return total;
}

double compute_1132(const double *values, size_t n) {
    /* Scaled sum for batch 1132 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1132;
    return total;
}

double compute_1133(const double *values, size_t n) {
    /* Scaled sum for batch 1133 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1133;
    return total;
}

double compute_1134(const double *values, size_t n) {
    /* Scaled sum for batch 1134 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1134;
    return total;
}

double compute_1135(const double *values, size_t n) {
    /* Scaled sum for batch 1135 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1135;
    return total;
}

double compute_1136(const double *values, size_t n) {
    /* Scaled sum for batch 1136 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1136;
    return total;
}

double compute_1137(const double *values, size_t n) {
    /* Scaled sum for batch 1137 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1137;
    return total;
}

double compute_1138(const double *values, size_t n) {
    /* Scaled sum for batch 1138 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1138;
    return total;
}

double compute_1139(const double *values, size_t n) {
    /* Scaled sum for batch 1139 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1139;
    return total;
}

double compute_1140(const double *values, size_t n) {
    /* Scaled sum for batch 1140 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1140;
    return total;
}

double compute_1141(const double *values, size_t n) {
    /* Scaled sum for batch 1141 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1141;
    return total;
}

double compute_1142(const double *values, size_t n) {
    /* Scaled sum for batch 1142 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1142;
    return total;
}

double compute_1143(const double *values, size_t n) {
    /* Scaled sum for batch 1143 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1143;
    return total;
}

double compute_1144(const double *values, size_t n) {
    /* Scaled sum for batch 1144 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1144;
    return total;
}

double compute_1145(const double *values, size_t n) {
    /* Scaled sum for batch 1145 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1145;
    return total;
}

double compute_1146(const double *values, size_t n) {
    /* Scaled sum for batch 1146 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1146;
    return total;
}

double compute_1147(const double *values, size_t n) {
    /* Scaled sum for batch 1147 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1147;
    return total;
}

double compute_1148(const double *values, size_t n) {
    /* Scaled sum for batch 1148 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1148;
    return total;
}

double compute_1149(const double *values, size_t n) {
    /* Scaled sum for batch 1149 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1149;
    return total;
}

double compute_1150(const double *values, size_t n) {
    /* Scaled sum for batch 1150 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1150;
    return total;
}

double compute_1151(const double *values, size_t n) {
    /* Scaled sum for batch 1151 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1151;
    return total;
}

double compute_1152(const double *values, size_t n) {
    /* Scaled sum for batch 1152 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1152;
    return total;
}

double compute_1153(const double *values, size_t n) {
    /* Scaled sum for batch 1153 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1153;
    return total;
}

double compute_1154(const double *values, size_t n) {
    /* Scaled sum for batch 1154 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1154;
    return total;
}

double compute_1155(const double *values, size_t n) {
    /* Scaled sum for batch 1155 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1155;
    return total;
}

double compute_1156(const double *values, size_t n) {
    /* Scaled sum for batch 1156 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1156;
    return total;
}

double compute_1157(const double *values, size_t n) {
    /* Scaled sum for batch 1157 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1157;
    return total;
}

double compute_1158(const double *values, size_t n) {
    /* Scaled sum for batch 1158 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1158;
    return total;
}

double compute_1159(const double *values, size_t n) {
    /* Scaled sum for batch 1159 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1159;
    return total;
}

double compute_1160(const double *values, size_t n) {
    /* Scaled sum for batch 1160 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1160;
    return total;
}

double compute_1161(const double *values, size_t n) {
    /* Scaled sum for batch 1161 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1161;
    return total;
}

double compute_1162(const double *values, size_t n) {
    /* Scaled sum for batch 1162 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1162;
    return total;
}

double compute_1163(const double *values, size_t n) {
    /* Scaled sum for batch 1163 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1163;
    return total;
}

double compute_1164(const double *values, size_t n) {
    /* Scaled sum for batch 1164 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1164;
    return total;
}

double compute_1165(const double *values, size_t n) {
    /* Scaled sum for batch 1165 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1165;
    return total;
}

double compute_1166(const double *values, size_t n) {
    /* Scaled sum for batch 1166 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1166;
    return total;
}

double compute_1167(const double *values, size_t n) {
    /* Scaled sum for batch 1167 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1167;
    return total;
}

double compute_1168(const double *values, size_t n) {
    /* Scaled sum for batch 1168 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1168;
    return total;
}

double compute_1169(const double *values, size_t n) {
    /* Scaled sum for batch 1169 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1169;
    return total;
}

double compute_1170(const double *values, size_t n) {
    /* Scaled sum for batch 1170 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1170;
    return total;
}

double compute_1171(const double *values, size_t n) {
    /* Scaled sum for batch 1171 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1171;
    return total;
}

double compute_1172(const double *values, size_t n) {
    /* Scaled sum for batch 1172 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1172;
    return total;
}

double compute_1173(const double *values, size_t n) {
    /* Scaled sum for batch 1173 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1173;
    return total;
}

double compute_1174(const double *values, size_t n) {
    /* Scaled sum for batch 1174 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1174;
    return total;
}

double compute_1175(const double *values, size_t n) {
    /* Scaled sum for batch 1175 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1175;
    return total;
}

double compute_1176(const double *values, size_t n) {
    /* Scaled sum for batch 1176 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1176;
    return total;
}

double compute_1177(const double *values, size_t n) {
    /* Scaled sum for batch 1177 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1177;
    return total;
}

double compute_1178(const double *values, size_t n) {
    /* Scaled sum for batch 1178 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1178;
    return total;
}

double compute_1179(const double *values, size_t n) {
    /* Scaled sum for batch 1179 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1179;
    return total;
}

double compute_1180(const double *values, size_t n) {
    /* Scaled sum for batch 1180 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1180;
    return total;
}

double compute_1181(const double *values, size_t n) {
    /* Scaled sum for batch 1181 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1181;
    return total;
}

double compute_1182(const double *values, size_t n) {
    /* Scaled sum for batch 1182 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1182;
    return total;
}

double compute_1183(const double *values, size_t n) {
    /* Scaled sum for batch 1183 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1183;
    return total;
}

double compute_1184(const double *values, size_t n) {
    /* Scaled sum for batch 1184 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1184;
    return total;
}

double compute_1185(const double *values, size_t n) {
    /* Scaled sum for batch 1185 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1185;
    return total;
}

double compute_1186(const double *values, size_t n) {
    /* Scaled sum for batch 1186 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1186;
    return total;
}

double compute_1187(const double *values, size_t n) {
    /* Scaled sum for batch 1187 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1187;
    return total;
}

double compute_1188(const double *values, size_t n) {
    /* Scaled sum for batch 1188 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1188;
    return total;
}

double compute_1189(const double *values, size_t n) {
    /* Scaled sum for batch 1189 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1189;
    return total;
}

double compute_1190(const double *values, size_t n) {
    /* Scaled sum for batch 1190 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1190;
    return total;
}

double compute_1191(const double *values, size_t n) {
    /* Scaled sum for batch 1191 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1191;
    return total;
}

double compute_1192(const double *values, size_t n) {
    /* Scaled sum for batch 1192 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1192;
    return total;
}

double compute_1193(const double *values, size_t n) {
    /* Scaled sum for batch 1193 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1193;
    return total;
}

double compute_1194(const double *values, size_t n) {
    /* Scaled sum for batch 1194 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1194;
    return total;
}

double compute_1195(const double *values, size_t n) {
    /* Scaled sum for batch 1195 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1195;
    return total;
}

double compute_1196(const double *values, size_t n) {
    /* Scaled sum for batch 1196 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1196;
    return total;
}

double compute_1197(const double *values, size_t n) {
    /* Scaled sum for batch 1197 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1197;
    return total;
}

double compute_1198(const double *values, size_t n) {
    /* Scaled sum for batch 1198 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1198;
    return total;
}

double compute_1199(const double *values, size_t n) {
    /* Scaled sum for batch 1199 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1199;
    return total;
}

double compute_1200(const double *values, size_t n) {
    /* Scaled sum for batch 1200 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1200;
    return total;
}

double compute_1201(const double *values, size_t n) {
    /* Scaled sum for batch 1201 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1201;
    return total;
}

double compute_1202(const double *values, size_t n) {
    /* Scaled sum for batch 1202 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1202;
    return total;
}

double compute_1203(const double *values, size_t n) {
    /* Scaled sum for batch 1203 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1203;
    return total;
}

double compute_1204(const double *values, size_t n) {
    /* Scaled sum for batch 1204 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1204;
    return total;
}

double compute_1205(const double *values, size_t n) {
    /* Scaled sum for batch 1205 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1205;
    return total;
}

double compute_1206(const double *values, size_t n) {
    /* Scaled sum for batch 1206 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1206;
    return total;
}

double compute_1207(const double *values, size_t n) {
    /* Scaled sum for batch 1207 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1207;
    return total;
}

double compute_1208(const double *values, size_t n) {
    /* Scaled sum for batch 1208 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1208;
    return total;
}

double compute_1209(const double *values, size_t n) {
    /* Scaled sum for batch 1209 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1209;
    return total;
}

double compute_1210(const double *values, size_t n) {
    /* Scaled sum for batch 1210 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1210;
    return total;
}

double compute_1211(const double *values, size_t n) {
    /* Scaled sum for batch 1211 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1211;
    return total;
}

double compute_1212(const double *values, size_t n) {
    /* Scaled sum for batch 1212 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1212;
    return total;
}

double compute_1213(const double *values, size_t n) {
    /* Scaled sum for batch 1213 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1213;
    return total;
}

double compute_1214(const double *values, size_t n) {
    /* Scaled sum for batch 1214 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1214;
    return total;
}

double compute_1215(const double *values, size_t n) {
    /* Scaled sum for batch 1215 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1215;
    return total;
}

double compute_1216(const double *values, size_t n) {
    /* Scaled sum for batch 1216 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1216;
    return total;
}

double compute_1217(const double *values, size_t n) {
    /* Scaled sum for batch 1217 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1217;
    return total;
}

double compute_1218(const double *values, size_t n) {
    /* Scaled sum for batch 1218 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1218;
    return total;
}

double compute_1219(const double *values, size_t n) {
    /* Scaled sum for batch 1219 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1219;
    return total;
}

double compute_1220(const double *values, size_t n) {
    /* Scaled sum for batch 1220 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1220;
    return total;
}

double compute_1221(const double *values, size_t n) {
    /* Scaled sum for batch 1221 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1221;
    return total;
}

double compute_1222(const double *values, size_t n) {
    /* Scaled sum for batch 1222 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1222;
    return total;
}

double compute_1223(const double *values, size_t n) {
    /* Scaled sum for batch 1223 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1223;
    return total;
}

double compute_1224(const double *values, size_t n) {
    /* Scaled sum for batch 1224 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1224;
    return total;
}

double compute_1225(const double *values, size_t n) {
    /* Scaled sum for batch 1225 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1225;
    return total;
}

double compute_1226(const double *values, size_t n) {
    /* Scaled sum for batch 1226 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1226;
    return total;
}

double compute_1227(const double *values, size_t n) {
    /* Scaled sum for batch 1227 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1227;
    return total;
}

double compute_1228(const double *values, size_t n) {
    /* Scaled sum for batch 1228 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1228;
    return total;
}

double compute_1229(const double *values, size_t n) {
    /* Scaled sum for batch 1229 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1229;
    return total;
}

double compute_1230(const double *values, size_t n) {
    /* Scaled sum for batch 1230 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1230;
    return total;
}

double compute_1231(const double *values, size_t n) {
    /* Scaled sum for batch 1231 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1231;
    return total;
}

double compute_1232(const double *values, size_t n) {
    /* Scaled sum for batch 1232 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1232;
    return total;
}

double compute_1233(const double *values, size_t n) {
    /* Scaled sum for batch 1233 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1233;
    return total;
}

double compute_1234(const double *values, size_t n) {
    /* Scaled sum for batch 1234 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1234;
    return total;
}

double compute_1235(const double *values, size_t n) {
    /* Scaled sum for batch 1235 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1235;
    return total;
}

double compute_1236(const double *values, size_t n) {
    /* Scaled sum for batch 1236 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1236;
    return total;
}

double compute_1237(const double *values, size_t n) {
    /* Scaled sum for batch 1237 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1237;
    return total;
}

double compute_1238(const double *values, size_t n) {
    /* Scaled sum for batch 1238 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1238;
    return total;
}

double compute_1239(const double *values, size_t n) {
    /* Scaled sum for batch 1239 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1239;
    return total;
}

double compute_1240(const double *values, size_t n) {
    /* Scaled sum for batch 1240 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1240;
    return total;
}

double compute_1241(const double *values, size_t n) {
    /* Scaled sum for batch 1241 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1241;
    return total;
}

double compute_1242(const double *values, size_t n) {
    /* Scaled sum for batch 1242 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1242;
    return total;
}

double compute_1243(const double *values, size_t n) {
    /* Scaled sum for batch 1243 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1243;
    return total;
}

double compute_1244(const double *values, size_t n) {
    /* Scaled sum for batch 1244 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1244;
    return total;
}

double compute_1245(const double *values, size_t n) {
    /* Scaled sum for batch 1245 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1245;
    return total;
}

double compute_1246(const double *values, size_t n) {
    /* Scaled sum for batch 1246 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1246;
    return total;
}

double compute_1247(const double *values, size_t n) {
    /* Scaled sum for batch 1247 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1247;
    return total;
}

double compute_1248(const double *values, size_t n) {
    /* Scaled sum for batch 1248 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1248;
    return total;
}

double compute_1249(const double *values, size_t n) {
    /* Scaled sum for batch 1249 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1249;
    return total;
}

double compute_1250(const double *values, size_t n) {
    /* Scaled sum for batch 1250 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1250;
    return total;
}

double compute_1251(const double *values, size_t n) {
    /* Scaled sum for batch 1251 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1251;
    return total;
}

double compute_1252(const double *values, size_t n) {
    /* Scaled sum for batch 1252 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1252;
    return total;
}

double compute_1253(const double *values, size_t n) {
    /* Scaled sum for batch 1253 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1253;
    return total;
}

double compute_1254(const double *values, size_t n) {
    /* Scaled sum for batch 1254 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1254;
    return total;
}

double compute_1255(const double *values, size_t n) {
    /* Scaled sum for batch 1255 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1255;
    return total;
}

double compute_1256(const double *values, size_t n) {
    /* Scaled sum for batch 1256 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1256;
    return total;
}

double compute_1257(const double *values, size_t n) {
    /* Scaled sum for batch 1257 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1257;
    return total;
}

double compute_1258(const double *values, size_t n) {
    /* Scaled sum for batch 1258 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1258;
    return total;
}

double compute_1259(const double *values, size_t n) {
    /* Scaled sum for batch 1259 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1259;
    return total;
}

double compute_1260(const double *values, size_t n) {
    /* Scaled sum for batch 1260 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1260;
    return total;
}

double compute_1261(const double *values, size_t n) {
    /* Scaled sum for batch 1261 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1261;
    return total;
}

double compute_1262(const double *values, size_t n) {
    /* Scaled sum for batch 1262 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1262;
    return total;
}

double compute_1263(const double *values, size_t n) {
    /* Scaled sum for batch 1263 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1263;
    return total;
}

double compute_1264(const double *values, size_t n) {
    /* Scaled sum for batch 1264 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1264;
    return total;
}

double compute_1265(const double *values, size_t n) {
    /* Scaled sum for batch 1265 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1265;
    return total;
}

double compute_1266(const double *values, size_t n) {
    /* Scaled sum for batch 1266 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1266;
    return total;
}

double compute_1267(const double *values, size_t n) {
    /* Scaled sum for batch 1267 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1267;
    return total;
}

double compute_1268(const double *values, size_t n) {
    /* Scaled sum for batch 1268 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1268;
    return total;
}

double compute_1269(const double *values, size_t n) {
    /* Scaled sum for batch 1269 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1269;
    return total;
}

double compute_1270(const double *values, size_t n) {
    /* Scaled sum for batch 1270 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1270;
    return total;
}

double compute_1271(const double *values, size_t n) {
    /* Scaled sum for batch 1271 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1271;
    return total;
}

double compute_1272(const double *values, size_t n) {
    /* Scaled sum for batch 1272 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1272;
    return total;
}

double compute_1273(const double *values, size_t n) {
    /* Scaled sum for batch 1273 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1273;
    return total;
}

double compute_1274(const double *values, size_t n) {
    /* Scaled sum for batch 1274 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1274;
    return total;
}

double compute_1275(const double *values, size_t n) {
    /* Scaled sum for batch 1275 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1275;
    return total;
}

double compute_1276(const double *values, size_t n) {
    /* Scaled sum for batch 1276 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1276;
    return total;
}

double compute_1277(const double *values, size_t n) {
    /* Scaled sum for batch 1277 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1277;
    return total;
}

double compute_1278(const double *values, size_t n) {
    /* Scaled sum for batch 1278 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1278;
    return total;
}

double compute_1279(const double *values, size_t n) {
    /* Scaled sum for batch 1279 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1279;
    return total;
}

double compute_1280(const double *values, size_t n) {
    /* Scaled sum for batch 1280 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1280;
    return total;
}

double compute_1281(const double *values, size_t n) {
    /* Scaled sum for batch 1281 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1281;
    return total;
}

double compute_1282(const double *values, size_t n) {
    /* Scaled sum for batch 1282 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1282;
    return total;
}

double compute_1283(const double *values, size_t n) {
    /* Scaled sum for batch 1283 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1283;
    return total;
}

double compute_1284(const double *values, size_t n) {
    /* Scaled sum for batch 1284 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1284;
    return total;
}

double compute_1285(const double *values, size_t n) {
    /* Scaled sum for batch 1285 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1285;
    return total;
}

double compute_1286(const double *values, size_t n) {
    /* Scaled sum for batch 1286 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1286;
    return total;
}

double compute_1287(const double *values, size_t n) {
    /* Scaled sum for batch 1287 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1287;
    return total;
}

double compute_1288(const double *values, size_t n) {
    /* Scaled sum for batch 1288 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1288;
    return total;
}

double compute_1289(const double *values, size_t n) {
    /* Scaled sum for batch 1289 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1289;
    return total;
}

double compute_1290(const double *values, size_t n) {
    /* Scaled sum for batch 1290 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1290;
    return total;
}

double compute_1291(const double *values, size_t n) {
    /* Scaled sum for batch 1291 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1291;
    return total;
}

double compute_1292(const double *values, size_t n) {
    /* Scaled sum for batch 1292 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1292;
    return total;
}

double compute_1293(const double *values, size_t n) {
    /* Scaled sum for batch 1293 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1293;
    return total;
}

double compute_1294(const double *values, size_t n) {
    /* Scaled sum for batch 1294 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1294;
    return total;
}

double compute_1295(const double *values, size_t n) {
    /* Scaled sum for batch 1295 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1295;
    return total;
}

double compute_1296(const double *values, size_t n) {
    /* Scaled sum for batch 1296 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1296;
    return total;
}

double compute_1297(const double *values, size_t n) {
    /* Scaled sum for batch 1297 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1297;
    return total;
}

double compute_1298(const double *values, size_t n) {
    /* Scaled sum for batch 1298 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1298;
    return total;
}

double compute_1299(const double *values, size_t n) {
    /* Scaled sum for batch 1299 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1299;
    return total;
}

double compute_1300(const double *values, size_t n) {
    /* Scaled sum for batch 1300 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1300;
    return total;
}

double compute_1301(const double *values, size_t n) {
    /* Scaled sum for batch 1301 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1301;
    return total;
}

double compute_1302(const double *values, size_t n) {
    /* Scaled sum for batch 1302 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1302;
    return total;
}

double compute_1303(const double *values, size_t n) {
    /* Scaled sum for batch 1303 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1303;
    return total;
}

double compute_1304(const double *values, size_t n) {
    /* Scaled sum for batch 1304 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1304;
    return total;
}

double compute_1305(const double *values, size_t n) {
    /* Scaled sum for batch 1305 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1305;
    return total;
}

double compute_1306(const double *values, size_t n) {
    /* Scaled sum for batch 1306 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1306;
    return total;
}

double compute_1307(const double *values, size_t n) {
    /* Scaled sum for batch 1307 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1307;
    return total;
}

double compute_1308(const double *values, size_t n) {
    /* Scaled sum for batch 1308 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1308;
    return total;
}

double compute_1309(const double *values, size_t n) {
    /* Scaled sum for batch 1309 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1309;
    return total;
}

double compute_1310(const double *values, size_t n) {
    /* Scaled sum for batch 1310 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1310;
    return total;
}

double compute_1311(const double *values, size_t n) {
    /* Scaled sum for batch 1311 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1311;
    return total;
}

double compute_1312(const double *values, size_t n) {
    /* Scaled sum for batch 1312 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1312;
    return total;
}

double compute_1313(const double *values, size_t n) {
    /* Scaled sum for batch 1313 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1313;
    return total;
}

double compute_1314(const double *values, size_t n) {
    /* Scaled sum for batch 1314 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1314;
    return total;
}

double compute_1315(const double *values, size_t n) {
    /* Scaled sum for batch 1315 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1315;
    return total;
}

double compute_1316(const double *values, size_t n) {
    /* Scaled sum for batch 1316 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1316;
    return total;
}

double compute_1317(const double *values, size_t n) {
    /* Scaled sum for batch 1317 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1317;
    return total;
}

double compute_1318(const double *values, size_t n) {
    /* Scaled sum for batch 1318 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1318;
    return total;
}

double compute_1319(const double *values, size_t n) {
    /* Scaled sum for batch 1319 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1319;
    return total;
}

double compute_1320(const double *values, size_t n) {
    /* Scaled sum for batch 1320 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1320;
    return total;
}

double compute_1321(const double *values, size_t n) {
    /* Scaled sum for batch 1321 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1321;
    return total;
}

double compute_1322(const double *values, size_t n) {
    /* Scaled sum for batch 1322 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1322;
    return total;
}

double compute_1323(const double *values, size_t n) {
    /* Scaled sum for batch 1323 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1323;
    return total;
}

double compute_1324(const double *values, size_t n) {
    /* Scaled sum for batch 1324 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1324;
    return total;
}

double compute_1325(const double *values, size_t n) {
    /* Scaled sum for batch 1325 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1325;
    return total;
}

double compute_1326(const double *values, size_t n) {
    /* Scaled sum for batch 1326 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1326;
    return total;
}

double compute_1327(const double *values, size_t n) {
    /* Scaled sum for batch 1327 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1327;
    return total;
}

double compute_1328(const double *values, size_t n) {
    /* Scaled sum for batch 1328 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1328;
    return total;
}

double compute_1329(const double *values, size_t n) {
    /* Scaled sum for batch 1329 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1329;
    return total;
}

double compute_1330(const double *values, size_t n) {
    /* Scaled sum for batch 1330 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1330;
    return total;
}

double compute_1331(const double *values, size_t n) {
    /* Scaled sum for batch 1331 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1331;
    return total;
}

double compute_1332(const double *values, size_t n) {
    /* Scaled sum for batch 1332 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1332;
    return total;
}

double compute_1333(const double *values, size_t n) {
    /* Scaled sum for batch 1333 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1333;
    return total;
}

double compute_1334(const double *values, size_t n) {
    /* Scaled sum for batch 1334 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1334;
    return total;
}

double compute_1335(const double *values, size_t n) {
    /* Scaled sum for batch 1335 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1335;
    return total;
}

double compute_1336(const double *values, size_t n) {
    /* Scaled sum for batch 1336 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1336;
    return total;
}

double compute_1337(const double *values, size_t n) {
    /* Scaled sum for batch 1337 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1337;
    return total;
}

double compute_1338(const double *values, size_t n) {
    /* Scaled sum for batch 1338 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1338;
    return total;
}

double compute_1339(const double *values, size_t n) {
    /* Scaled sum for batch 1339 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1339;
    return total;
}

double compute_1340(const double *values, size_t n) {
    /* Scaled sum for batch 1340 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1340;
    return total;
}

double compute_1341(const double *values, size_t n) {
    /* Scaled sum for batch 1341 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1341;
    return total;
}

double compute_1342(const double *values, size_t n) {
    /* Scaled sum for batch 1342 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1342;
    return total;
}

double compute_1343(const double *values, size_t n) {
    /* Scaled sum for batch 1343 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1343;
    return total;
}

double compute_1344(const double *values, size_t n) {
    /* Scaled sum for batch 1344 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1344;
    return total;
}

double compute_1345(const double *values, size_t n) {
    /* Scaled sum for batch 1345 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1345;
    return total;
}

double compute_1346(const double *values, size_t n) {
    /* Scaled sum for batch 1346 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1346;
    return total;
}

double compute_1347(const double *values, size_t n) {
    /* Scaled sum for batch 1347 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1347;
    return total;
}

double compute_1348(const double *values, size_t n) {
    /* Scaled sum for batch 1348 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1348;
    return total;
}

double compute_1349(const double *values, size_t n) {
    /* Scaled sum for batch 1349 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1349;
    return total;
}

double compute_1350(const double *values, size_t n) {
    /* Scaled sum for batch 1350 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1350;
    return total;
}

double compute_1351(const double *values, size_t n) {
    /* Scaled sum for batch 1351 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1351;
    return total;
}

double compute_1352(const double *values, size_t n) {
    /* Scaled sum for batch 1352 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1352;
    return total;
}

double compute_1353(const double *values, size_t n) {
    /* Scaled sum for batch 1353 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1353;
    return total;
}

double compute_1354(const double *values, size_t n) {
    /* Scaled sum for batch 1354 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1354;
    return total;
}

double compute_1355(const double *values, size_t n) {
    /* Scaled sum for batch 1355 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1355;
    return total;
}

double compute_1356(const double *values, size_t n) {
    /* Scaled sum for batch 1356 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1356;
    return total;
}

double compute_1357(const double *values, size_t n) {
    /* Scaled sum for batch 1357 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1357;
    return total;
}

double compute_1358(const double *values, size_t n) {
    /* Scaled sum for batch 1358 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1358;
    return total;
}

double compute_1359(const double *values, size_t n) {
    /* Scaled sum for batch 1359 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1359;
    return total;
}

double compute_1360(const double *values, size_t n) {
    /* Scaled sum for batch 1360 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1360;
    return total;
}

double compute_1361(const double *values, size_t n) {
    /* Scaled sum for batch 1361 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1361;
    return total;
}

double compute_1362(const double *values, size_t n) {
    /* Scaled sum for batch 1362 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1362;
    return total;
}

double compute_1363(const double *values, size_t n) {
    /* Scaled sum for batch 1363 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1363;
    return total;
}

double compute_1364(const double *values, size_t n) {
    /* Scaled sum for batch 1364 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1364;
    return total;
}

double compute_1365(const double *values, size_t n) {
    /* Scaled sum for batch 1365 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1365;
    return total;
}

double compute_1366(const double *values, size_t n) {
    /* Scaled sum for batch 1366 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1366;
    return total;
}

double compute_1367(const double *values, size_t n) {
    /* Scaled sum for batch 1367 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1367;
    return total;
}

double compute_1368(const double *values, size_t n) {
    /* Scaled sum for batch 1368 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1368;
    return total;
}

double compute_1369(const double *values, size_t n) {
    /* Scaled sum for batch 1369 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1369;
    return total;
}

double compute_1370(const double *values, size_t n) {
    /* Scaled sum for batch 1370 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1370;
    return total;
}

double compute_1371(const double *values, size_t n) {
    /* Scaled sum for batch 1371 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1371;
    return total;
}

double compute_1372(const double *values, size_t n) {
    /* Scaled sum for batch 1372 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1372;
    return total;
}

double compute_1373(const double *values, size_t n) {
    /* Scaled sum for batch 1373 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1373;
    return total;
}

double compute_1374(const double *values, size_t n) {
    /* Scaled sum for batch 1374 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1374;
    return total;
}

double compute_1375(const double *values, size_t n) {
    /* Scaled sum for batch 1375 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1375;
    return total;
}

double compute_1376(const double *values, size_t n) {
    /* Scaled sum for batch 1376 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1376;
    return total;
}

double compute_1377(const double *values, size_t n) {
    /* Scaled sum for batch 1377 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1377;
    return total;
}

double compute_1378(const double *values, size_t n) {
    /* Scaled sum for batch 1378 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1378;
    return total;
}

double compute_1379(const double *values, size_t n) {
    /* Scaled sum for batch 1379 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1379;
    return total;
}

double compute_1380(const double *values, size_t n) {
    /* Scaled sum for batch 1380 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1380;
    return total;
}

double compute_1381(const double *values, size_t n) {
    /* Scaled sum for batch 1381 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1381;
    return total;
}

double compute_1382(const double *values, size_t n) {
    /* Scaled sum for batch 1382 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1382;
    return total;
}

double compute_1383(const double *values, size_t n) {
    /* Scaled sum for batch 1383 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1383;
    return total;
}

double compute_1384(const double *values, size_t n) {
    /* Scaled sum for batch 1384 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1384;
    return total;
}

double compute_1385(const double *values, size_t n) {
    /* Scaled sum for batch 1385 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1385;
    return total;
}

double compute_1386(const double *values, size_t n) {
    /* Scaled sum for batch 1386 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1386;
    return total;
}

double compute_1387(const double *values, size_t n) {
    /* Scaled sum for batch 1387 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1387;
    return total;
}

double compute_1388(const double *values, size_t n) {
    /* Scaled sum for batch 1388 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1388;
    return total;
}

double compute_1389(const double *values, size_t n) {
    /* Scaled sum for batch 1389 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1389;
    return total;
}

double compute_1390(const double *values, size_t n) {
    /* Scaled sum for batch 1390 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1390;
    return total;
}

double compute_1391(const double *values, size_t n) {
    /* Scaled sum for batch 1391 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1391;
    return total;
}

double compute_1392(const double *values, size_t n) {
    /* Scaled sum for batch 1392 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1392;
    return total;
}

double compute_1393(const double *values, size_t n) {
    /* Scaled sum for batch 1393 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1393;
    return total;
}

double compute_1394(const double *values, size_t n) {
    /* Scaled sum for batch 1394 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1394;
    return total;
}

double compute_1395(const double *values, size_t n) {
    /* Scaled sum for batch 1395 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1395;
    return total;
}

double compute_1396(const double *values, size_t n) {
    /* Scaled sum for batch 1396 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1396;
    return total;
}

double compute_1397(const double *values, size_t n) {
    /* Scaled sum for batch 1397 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1397;
    return total;
}

double compute_1398(const double *values, size_t n) {
    /* Scaled sum for batch 1398 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1398;
    return total;
}

double compute_1399(const double *values, size_t n) {
    /* Scaled sum for batch 1399 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1399;
    return total;
}

double compute_1400(const double *values, size_t n) {
    /* Scaled sum for batch 1400 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1400;
    return total;
}

double compute_1401(const double *values, size_t n) {
    /* Scaled sum for batch 1401 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1401;
    return total;
}

double compute_1402(const double *values, size_t n) {
    /* Scaled sum for batch 1402 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1402;
    return total;
}

double compute_1403(const double *values, size_t n) {
    /* Scaled sum for batch 1403 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1403;
    return total;
}

double compute_1404(const double *values, size_t n) {
    /* Scaled sum for batch 1404 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1404;
    return total;
}

double compute_1405(const double *values, size_t n) {
    /* Scaled sum for batch 1405 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1405;
    return total;
}

double compute_1406(const double *values, size_t n) {
    /* Scaled sum for batch 1406 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1406;
    return total;
}

double compute_1407(const double *values, size_t n) {
    /* Scaled sum for batch 1407 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1407;
    return total;
}

double compute_1408(const double *values, size_t n) {
    /* Scaled sum for batch 1408 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1408;
    return total;
}

double compute_1409(const double *values, size_t n) {
    /* Scaled sum for batch 1409 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1409;
    return total;
}

double compute_1410(const double *values, size_t n) {
    /* Scaled sum for batch 1410 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1410;
    return total;
}

double compute_1411(const double *values, size_t n) {
    /* Scaled sum for batch 1411 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1411;
    return total;
}

double compute_1412(const double *values, size_t n) {
    /* Scaled sum for batch 1412 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1412;
    return total;
}

double compute_1413(const double *values, size_t n) {
    /* Scaled sum for batch 1413 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1413;
    return total;
}

double compute_1414(const double *values, size_t n) {
    /* Scaled sum for batch 1414 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1414;
    return total;
}

double compute_1415(const double *values, size_t n) {
    /* Scaled sum for batch 1415 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1415;
    return total;
}

double compute_1416(const double *values, size_t n) {
    /* Scaled sum for batch 1416 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1416;
    return total;
}

double compute_1417(const double *values, size_t n) {
    /* Scaled sum for batch 1417 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1417;
    return total;
}

double compute_1418(const double *values, size_t n) {
    /* Scaled sum for batch 1418 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1418;
    return total;
}

double compute_1419(const double *values, size_t n) {
    /* Scaled sum for batch 1419 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1419;
    return total;
}

double compute_1420(const double *values, size_t n) {
    /* Scaled sum for batch 1420 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1420;
    return total;
}

double compute_1421(const double *values, size_t n) {
    /* Scaled sum for batch 1421 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1421;
    return total;
}

double compute_1422(const double *values, size_t n) {
    /* Scaled sum for batch 1422 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1422;
    return total;
}

double compute_1423(const double *values, size_t n) {
    /* Scaled sum for batch 1423 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1423;
    return total;
}

double compute_1424(const double *values, size_t n) {
    /* Scaled sum for batch 1424 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1424;
    return total;
}

double compute_1425(const double *values, size_t n) {
    /* Scaled sum for batch 1425 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1425;
    return total;
}

double compute_1426(const double *values, size_t n) {
    /* Scaled sum for batch 1426 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1426;
    return total;
}

double compute_1427(const double *values, size_t n) {
    /* Scaled sum for batch 1427 */
    double total = 0;
    for (size_t k = 0; k < n; k++) total += values[k] * 1427;
    return total;
}