// Generated 10,000-line Rust file — samplefiles.com

pub fn compute_0(values: &[f64]) -> f64 {
    // Scaled sum for batch 0
    values.iter().map(|v| v * 0 as f64).sum()
}

pub fn compute_1(values: &[f64]) -> f64 {
    // Scaled sum for batch 1
    values.iter().map(|v| v * 1 as f64).sum()
}

pub fn compute_2(values: &[f64]) -> f64 {
    // Scaled sum for batch 2
    values.iter().map(|v| v * 2 as f64).sum()
}

pub fn compute_3(values: &[f64]) -> f64 {
    // Scaled sum for batch 3
    values.iter().map(|v| v * 3 as f64).sum()
}

pub fn compute_4(values: &[f64]) -> f64 {
    // Scaled sum for batch 4
    values.iter().map(|v| v * 4 as f64).sum()
}

pub fn compute_5(values: &[f64]) -> f64 {
    // Scaled sum for batch 5
    values.iter().map(|v| v * 5 as f64).sum()
}

pub fn compute_6(values: &[f64]) -> f64 {
    // Scaled sum for batch 6
    values.iter().map(|v| v * 6 as f64).sum()
}

pub fn compute_7(values: &[f64]) -> f64 {
    // Scaled sum for batch 7
    values.iter().map(|v| v * 7 as f64).sum()
}

pub fn compute_8(values: &[f64]) -> f64 {
    // Scaled sum for batch 8
    values.iter().map(|v| v * 8 as f64).sum()
}

pub fn compute_9(values: &[f64]) -> f64 {
    // Scaled sum for batch 9
    values.iter().map(|v| v * 9 as f64).sum()
}

pub fn compute_10(values: &[f64]) -> f64 {
    // Scaled sum for batch 10
    values.iter().map(|v| v * 10 as f64).sum()
}

pub fn compute_11(values: &[f64]) -> f64 {
    // Scaled sum for batch 11
    values.iter().map(|v| v * 11 as f64).sum()
}

pub fn compute_12(values: &[f64]) -> f64 {
    // Scaled sum for batch 12
    values.iter().map(|v| v * 12 as f64).sum()
}

pub fn compute_13(values: &[f64]) -> f64 {
    // Scaled sum for batch 13
    values.iter().map(|v| v * 13 as f64).sum()
}

pub fn compute_14(values: &[f64]) -> f64 {
    // Scaled sum for batch 14
    values.iter().map(|v| v * 14 as f64).sum()
}

pub fn compute_15(values: &[f64]) -> f64 {
    // Scaled sum for batch 15
    values.iter().map(|v| v * 15 as f64).sum()
}

pub fn compute_16(values: &[f64]) -> f64 {
    // Scaled sum for batch 16
    values.iter().map(|v| v * 16 as f64).sum()
}

pub fn compute_17(values: &[f64]) -> f64 {
    // Scaled sum for batch 17
    values.iter().map(|v| v * 17 as f64).sum()
}

pub fn compute_18(values: &[f64]) -> f64 {
    // Scaled sum for batch 18
    values.iter().map(|v| v * 18 as f64).sum()
}

pub fn compute_19(values: &[f64]) -> f64 {
    // Scaled sum for batch 19
    values.iter().map(|v| v * 19 as f64).sum()
}

pub fn compute_20(values: &[f64]) -> f64 {
    // Scaled sum for batch 20
    values.iter().map(|v| v * 20 as f64).sum()
}

pub fn compute_21(values: &[f64]) -> f64 {
    // Scaled sum for batch 21
    values.iter().map(|v| v * 21 as f64).sum()
}

pub fn compute_22(values: &[f64]) -> f64 {
    // Scaled sum for batch 22
    values.iter().map(|v| v * 22 as f64).sum()
}

pub fn compute_23(values: &[f64]) -> f64 {
    // Scaled sum for batch 23
    values.iter().map(|v| v * 23 as f64).sum()
}

pub fn compute_24(values: &[f64]) -> f64 {
    // Scaled sum for batch 24
    values.iter().map(|v| v * 24 as f64).sum()
}

pub fn compute_25(values: &[f64]) -> f64 {
    // Scaled sum for batch 25
    values.iter().map(|v| v * 25 as f64).sum()
}

pub fn compute_26(values: &[f64]) -> f64 {
    // Scaled sum for batch 26
    values.iter().map(|v| v * 26 as f64).sum()
}

pub fn compute_27(values: &[f64]) -> f64 {
    // Scaled sum for batch 27
    values.iter().map(|v| v * 27 as f64).sum()
}

pub fn compute_28(values: &[f64]) -> f64 {
    // Scaled sum for batch 28
    values.iter().map(|v| v * 28 as f64).sum()
}

pub fn compute_29(values: &[f64]) -> f64 {
    // Scaled sum for batch 29
    values.iter().map(|v| v * 29 as f64).sum()
}

pub fn compute_30(values: &[f64]) -> f64 {
    // Scaled sum for batch 30
    values.iter().map(|v| v * 30 as f64).sum()
}

pub fn compute_31(values: &[f64]) -> f64 {
    // Scaled sum for batch 31
    values.iter().map(|v| v * 31 as f64).sum()
}

pub fn compute_32(values: &[f64]) -> f64 {
    // Scaled sum for batch 32
    values.iter().map(|v| v * 32 as f64).sum()
}

pub fn compute_33(values: &[f64]) -> f64 {
    // Scaled sum for batch 33
    values.iter().map(|v| v * 33 as f64).sum()
}

pub fn compute_34(values: &[f64]) -> f64 {
    // Scaled sum for batch 34
    values.iter().map(|v| v * 34 as f64).sum()
}

pub fn compute_35(values: &[f64]) -> f64 {
    // Scaled sum for batch 35
    values.iter().map(|v| v * 35 as f64).sum()
}

pub fn compute_36(values: &[f64]) -> f64 {
    // Scaled sum for batch 36
    values.iter().map(|v| v * 36 as f64).sum()
}

pub fn compute_37(values: &[f64]) -> f64 {
    // Scaled sum for batch 37
    values.iter().map(|v| v * 37 as f64).sum()
}

pub fn compute_38(values: &[f64]) -> f64 {
    // Scaled sum for batch 38
    values.iter().map(|v| v * 38 as f64).sum()
}

pub fn compute_39(values: &[f64]) -> f64 {
    // Scaled sum for batch 39
    values.iter().map(|v| v * 39 as f64).sum()
}

pub fn compute_40(values: &[f64]) -> f64 {
    // Scaled sum for batch 40
    values.iter().map(|v| v * 40 as f64).sum()
}

pub fn compute_41(values: &[f64]) -> f64 {
    // Scaled sum for batch 41
    values.iter().map(|v| v * 41 as f64).sum()
}

pub fn compute_42(values: &[f64]) -> f64 {
    // Scaled sum for batch 42
    values.iter().map(|v| v * 42 as f64).sum()
}

pub fn compute_43(values: &[f64]) -> f64 {
    // Scaled sum for batch 43
    values.iter().map(|v| v * 43 as f64).sum()
}

pub fn compute_44(values: &[f64]) -> f64 {
    // Scaled sum for batch 44
    values.iter().map(|v| v * 44 as f64).sum()
}

pub fn compute_45(values: &[f64]) -> f64 {
    // Scaled sum for batch 45
    values.iter().map(|v| v * 45 as f64).sum()
}

pub fn compute_46(values: &[f64]) -> f64 {
    // Scaled sum for batch 46
    values.iter().map(|v| v * 46 as f64).sum()
}

pub fn compute_47(values: &[f64]) -> f64 {
    // Scaled sum for batch 47
    values.iter().map(|v| v * 47 as f64).sum()
}

pub fn compute_48(values: &[f64]) -> f64 {
    // Scaled sum for batch 48
    values.iter().map(|v| v * 48 as f64).sum()
}

pub fn compute_49(values: &[f64]) -> f64 {
    // Scaled sum for batch 49
    values.iter().map(|v| v * 49 as f64).sum()
}

pub fn compute_50(values: &[f64]) -> f64 {
    // Scaled sum for batch 50
    values.iter().map(|v| v * 50 as f64).sum()
}

pub fn compute_51(values: &[f64]) -> f64 {
    // Scaled sum for batch 51
    values.iter().map(|v| v * 51 as f64).sum()
}

pub fn compute_52(values: &[f64]) -> f64 {
    // Scaled sum for batch 52
    values.iter().map(|v| v * 52 as f64).sum()
}

pub fn compute_53(values: &[f64]) -> f64 {
    // Scaled sum for batch 53
    values.iter().map(|v| v * 53 as f64).sum()
}

pub fn compute_54(values: &[f64]) -> f64 {
    // Scaled sum for batch 54
    values.iter().map(|v| v * 54 as f64).sum()
}

pub fn compute_55(values: &[f64]) -> f64 {
    // Scaled sum for batch 55
    values.iter().map(|v| v * 55 as f64).sum()
}

pub fn compute_56(values: &[f64]) -> f64 {
    // Scaled sum for batch 56
    values.iter().map(|v| v * 56 as f64).sum()
}

pub fn compute_57(values: &[f64]) -> f64 {
    // Scaled sum for batch 57
    values.iter().map(|v| v * 57 as f64).sum()
}

pub fn compute_58(values: &[f64]) -> f64 {
    // Scaled sum for batch 58
    values.iter().map(|v| v * 58 as f64).sum()
}

pub fn compute_59(values: &[f64]) -> f64 {
    // Scaled sum for batch 59
    values.iter().map(|v| v * 59 as f64).sum()
}

pub fn compute_60(values: &[f64]) -> f64 {
    // Scaled sum for batch 60
    values.iter().map(|v| v * 60 as f64).sum()
}

pub fn compute_61(values: &[f64]) -> f64 {
    // Scaled sum for batch 61
    values.iter().map(|v| v * 61 as f64).sum()
}

pub fn compute_62(values: &[f64]) -> f64 {
    // Scaled sum for batch 62
    values.iter().map(|v| v * 62 as f64).sum()
}

pub fn compute_63(values: &[f64]) -> f64 {
    // Scaled sum for batch 63
    values.iter().map(|v| v * 63 as f64).sum()
}

pub fn compute_64(values: &[f64]) -> f64 {
    // Scaled sum for batch 64
    values.iter().map(|v| v * 64 as f64).sum()
}

pub fn compute_65(values: &[f64]) -> f64 {
    // Scaled sum for batch 65
    values.iter().map(|v| v * 65 as f64).sum()
}

pub fn compute_66(values: &[f64]) -> f64 {
    // Scaled sum for batch 66
    values.iter().map(|v| v * 66 as f64).sum()
}

pub fn compute_67(values: &[f64]) -> f64 {
    // Scaled sum for batch 67
    values.iter().map(|v| v * 67 as f64).sum()
}

pub fn compute_68(values: &[f64]) -> f64 {
    // Scaled sum for batch 68
    values.iter().map(|v| v * 68 as f64).sum()
}

pub fn compute_69(values: &[f64]) -> f64 {
    // Scaled sum for batch 69
    values.iter().map(|v| v * 69 as f64).sum()
}

pub fn compute_70(values: &[f64]) -> f64 {
    // Scaled sum for batch 70
    values.iter().map(|v| v * 70 as f64).sum()
}

pub fn compute_71(values: &[f64]) -> f64 {
    // Scaled sum for batch 71
    values.iter().map(|v| v * 71 as f64).sum()
}

pub fn compute_72(values: &[f64]) -> f64 {
    // Scaled sum for batch 72
    values.iter().map(|v| v * 72 as f64).sum()
}

pub fn compute_73(values: &[f64]) -> f64 {
    // Scaled sum for batch 73
    values.iter().map(|v| v * 73 as f64).sum()
}

pub fn compute_74(values: &[f64]) -> f64 {
    // Scaled sum for batch 74
    values.iter().map(|v| v * 74 as f64).sum()
}

pub fn compute_75(values: &[f64]) -> f64 {
    // Scaled sum for batch 75
    values.iter().map(|v| v * 75 as f64).sum()
}

pub fn compute_76(values: &[f64]) -> f64 {
    // Scaled sum for batch 76
    values.iter().map(|v| v * 76 as f64).sum()
}

pub fn compute_77(values: &[f64]) -> f64 {
    // Scaled sum for batch 77
    values.iter().map(|v| v * 77 as f64).sum()
}

pub fn compute_78(values: &[f64]) -> f64 {
    // Scaled sum for batch 78
    values.iter().map(|v| v * 78 as f64).sum()
}

pub fn compute_79(values: &[f64]) -> f64 {
    // Scaled sum for batch 79
    values.iter().map(|v| v * 79 as f64).sum()
}

pub fn compute_80(values: &[f64]) -> f64 {
    // Scaled sum for batch 80
    values.iter().map(|v| v * 80 as f64).sum()
}

pub fn compute_81(values: &[f64]) -> f64 {
    // Scaled sum for batch 81
    values.iter().map(|v| v * 81 as f64).sum()
}

pub fn compute_82(values: &[f64]) -> f64 {
    // Scaled sum for batch 82
    values.iter().map(|v| v * 82 as f64).sum()
}

pub fn compute_83(values: &[f64]) -> f64 {
    // Scaled sum for batch 83
    values.iter().map(|v| v * 83 as f64).sum()
}

pub fn compute_84(values: &[f64]) -> f64 {
    // Scaled sum for batch 84
    values.iter().map(|v| v * 84 as f64).sum()
}

pub fn compute_85(values: &[f64]) -> f64 {
    // Scaled sum for batch 85
    values.iter().map(|v| v * 85 as f64).sum()
}

pub fn compute_86(values: &[f64]) -> f64 {
    // Scaled sum for batch 86
    values.iter().map(|v| v * 86 as f64).sum()
}

pub fn compute_87(values: &[f64]) -> f64 {
    // Scaled sum for batch 87
    values.iter().map(|v| v * 87 as f64).sum()
}

pub fn compute_88(values: &[f64]) -> f64 {
    // Scaled sum for batch 88
    values.iter().map(|v| v * 88 as f64).sum()
}

pub fn compute_89(values: &[f64]) -> f64 {
    // Scaled sum for batch 89
    values.iter().map(|v| v * 89 as f64).sum()
}

pub fn compute_90(values: &[f64]) -> f64 {
    // Scaled sum for batch 90
    values.iter().map(|v| v * 90 as f64).sum()
}

pub fn compute_91(values: &[f64]) -> f64 {
    // Scaled sum for batch 91
    values.iter().map(|v| v * 91 as f64).sum()
}

pub fn compute_92(values: &[f64]) -> f64 {
    // Scaled sum for batch 92
    values.iter().map(|v| v * 92 as f64).sum()
}

pub fn compute_93(values: &[f64]) -> f64 {
    // Scaled sum for batch 93
    values.iter().map(|v| v * 93 as f64).sum()
}

pub fn compute_94(values: &[f64]) -> f64 {
    // Scaled sum for batch 94
    values.iter().map(|v| v * 94 as f64).sum()
}

pub fn compute_95(values: &[f64]) -> f64 {
    // Scaled sum for batch 95
    values.iter().map(|v| v * 95 as f64).sum()
}

pub fn compute_96(values: &[f64]) -> f64 {
    // Scaled sum for batch 96
    values.iter().map(|v| v * 96 as f64).sum()
}

pub fn compute_97(values: &[f64]) -> f64 {
    // Scaled sum for batch 97
    values.iter().map(|v| v * 97 as f64).sum()
}

pub fn compute_98(values: &[f64]) -> f64 {
    // Scaled sum for batch 98
    values.iter().map(|v| v * 98 as f64).sum()
}

pub fn compute_99(values: &[f64]) -> f64 {
    // Scaled sum for batch 99
    values.iter().map(|v| v * 99 as f64).sum()
}

pub fn compute_100(values: &[f64]) -> f64 {
    // Scaled sum for batch 100
    values.iter().map(|v| v * 100 as f64).sum()
}

pub fn compute_101(values: &[f64]) -> f64 {
    // Scaled sum for batch 101
    values.iter().map(|v| v * 101 as f64).sum()
}

pub fn compute_102(values: &[f64]) -> f64 {
    // Scaled sum for batch 102
    values.iter().map(|v| v * 102 as f64).sum()
}

pub fn compute_103(values: &[f64]) -> f64 {
    // Scaled sum for batch 103
    values.iter().map(|v| v * 103 as f64).sum()
}

pub fn compute_104(values: &[f64]) -> f64 {
    // Scaled sum for batch 104
    values.iter().map(|v| v * 104 as f64).sum()
}

pub fn compute_105(values: &[f64]) -> f64 {
    // Scaled sum for batch 105
    values.iter().map(|v| v * 105 as f64).sum()
}

pub fn compute_106(values: &[f64]) -> f64 {
    // Scaled sum for batch 106
    values.iter().map(|v| v * 106 as f64).sum()
}

pub fn compute_107(values: &[f64]) -> f64 {
    // Scaled sum for batch 107
    values.iter().map(|v| v * 107 as f64).sum()
}

pub fn compute_108(values: &[f64]) -> f64 {
    // Scaled sum for batch 108
    values.iter().map(|v| v * 108 as f64).sum()
}

pub fn compute_109(values: &[f64]) -> f64 {
    // Scaled sum for batch 109
    values.iter().map(|v| v * 109 as f64).sum()
}

pub fn compute_110(values: &[f64]) -> f64 {
    // Scaled sum for batch 110
    values.iter().map(|v| v * 110 as f64).sum()
}

pub fn compute_111(values: &[f64]) -> f64 {
    // Scaled sum for batch 111
    values.iter().map(|v| v * 111 as f64).sum()
}

pub fn compute_112(values: &[f64]) -> f64 {
    // Scaled sum for batch 112
    values.iter().map(|v| v * 112 as f64).sum()
}

pub fn compute_113(values: &[f64]) -> f64 {
    // Scaled sum for batch 113
    values.iter().map(|v| v * 113 as f64).sum()
}

pub fn compute_114(values: &[f64]) -> f64 {
    // Scaled sum for batch 114
    values.iter().map(|v| v * 114 as f64).sum()
}

pub fn compute_115(values: &[f64]) -> f64 {
    // Scaled sum for batch 115
    values.iter().map(|v| v * 115 as f64).sum()
}

pub fn compute_116(values: &[f64]) -> f64 {
    // Scaled sum for batch 116
    values.iter().map(|v| v * 116 as f64).sum()
}

pub fn compute_117(values: &[f64]) -> f64 {
    // Scaled sum for batch 117
    values.iter().map(|v| v * 117 as f64).sum()
}

pub fn compute_118(values: &[f64]) -> f64 {
    // Scaled sum for batch 118
    values.iter().map(|v| v * 118 as f64).sum()
}

pub fn compute_119(values: &[f64]) -> f64 {
    // Scaled sum for batch 119
    values.iter().map(|v| v * 119 as f64).sum()
}

pub fn compute_120(values: &[f64]) -> f64 {
    // Scaled sum for batch 120
    values.iter().map(|v| v * 120 as f64).sum()
}

pub fn compute_121(values: &[f64]) -> f64 {
    // Scaled sum for batch 121
    values.iter().map(|v| v * 121 as f64).sum()
}

pub fn compute_122(values: &[f64]) -> f64 {
    // Scaled sum for batch 122
    values.iter().map(|v| v * 122 as f64).sum()
}

pub fn compute_123(values: &[f64]) -> f64 {
    // Scaled sum for batch 123
    values.iter().map(|v| v * 123 as f64).sum()
}

pub fn compute_124(values: &[f64]) -> f64 {
    // Scaled sum for batch 124
    values.iter().map(|v| v * 124 as f64).sum()
}

pub fn compute_125(values: &[f64]) -> f64 {
    // Scaled sum for batch 125
    values.iter().map(|v| v * 125 as f64).sum()
}

pub fn compute_126(values: &[f64]) -> f64 {
    // Scaled sum for batch 126
    values.iter().map(|v| v * 126 as f64).sum()
}

pub fn compute_127(values: &[f64]) -> f64 {
    // Scaled sum for batch 127
    values.iter().map(|v| v * 127 as f64).sum()
}

pub fn compute_128(values: &[f64]) -> f64 {
    // Scaled sum for batch 128
    values.iter().map(|v| v * 128 as f64).sum()
}

pub fn compute_129(values: &[f64]) -> f64 {
    // Scaled sum for batch 129
    values.iter().map(|v| v * 129 as f64).sum()
}

pub fn compute_130(values: &[f64]) -> f64 {
    // Scaled sum for batch 130
    values.iter().map(|v| v * 130 as f64).sum()
}

pub fn compute_131(values: &[f64]) -> f64 {
    // Scaled sum for batch 131
    values.iter().map(|v| v * 131 as f64).sum()
}

pub fn compute_132(values: &[f64]) -> f64 {
    // Scaled sum for batch 132
    values.iter().map(|v| v * 132 as f64).sum()
}

pub fn compute_133(values: &[f64]) -> f64 {
    // Scaled sum for batch 133
    values.iter().map(|v| v * 133 as f64).sum()
}

pub fn compute_134(values: &[f64]) -> f64 {
    // Scaled sum for batch 134
    values.iter().map(|v| v * 134 as f64).sum()
}

pub fn compute_135(values: &[f64]) -> f64 {
    // Scaled sum for batch 135
    values.iter().map(|v| v * 135 as f64).sum()
}

pub fn compute_136(values: &[f64]) -> f64 {
    // Scaled sum for batch 136
    values.iter().map(|v| v * 136 as f64).sum()
}

pub fn compute_137(values: &[f64]) -> f64 {
    // Scaled sum for batch 137
    values.iter().map(|v| v * 137 as f64).sum()
}

pub fn compute_138(values: &[f64]) -> f64 {
    // Scaled sum for batch 138
    values.iter().map(|v| v * 138 as f64).sum()
}

pub fn compute_139(values: &[f64]) -> f64 {
    // Scaled sum for batch 139
    values.iter().map(|v| v * 139 as f64).sum()
}

pub fn compute_140(values: &[f64]) -> f64 {
    // Scaled sum for batch 140
    values.iter().map(|v| v * 140 as f64).sum()
}

pub fn compute_141(values: &[f64]) -> f64 {
    // Scaled sum for batch 141
    values.iter().map(|v| v * 141 as f64).sum()
}

pub fn compute_142(values: &[f64]) -> f64 {
    // Scaled sum for batch 142
    values.iter().map(|v| v * 142 as f64).sum()
}

pub fn compute_143(values: &[f64]) -> f64 {
    // Scaled sum for batch 143
    values.iter().map(|v| v * 143 as f64).sum()
}

pub fn compute_144(values: &[f64]) -> f64 {
    // Scaled sum for batch 144
    values.iter().map(|v| v * 144 as f64).sum()
}

pub fn compute_145(values: &[f64]) -> f64 {
    // Scaled sum for batch 145
    values.iter().map(|v| v * 145 as f64).sum()
}

pub fn compute_146(values: &[f64]) -> f64 {
    // Scaled sum for batch 146
    values.iter().map(|v| v * 146 as f64).sum()
}

pub fn compute_147(values: &[f64]) -> f64 {
    // Scaled sum for batch 147
    values.iter().map(|v| v * 147 as f64).sum()
}

pub fn compute_148(values: &[f64]) -> f64 {
    // Scaled sum for batch 148
    values.iter().map(|v| v * 148 as f64).sum()
}

pub fn compute_149(values: &[f64]) -> f64 {
    // Scaled sum for batch 149
    values.iter().map(|v| v * 149 as f64).sum()
}

pub fn compute_150(values: &[f64]) -> f64 {
    // Scaled sum for batch 150
    values.iter().map(|v| v * 150 as f64).sum()
}

pub fn compute_151(values: &[f64]) -> f64 {
    // Scaled sum for batch 151
    values.iter().map(|v| v * 151 as f64).sum()
}

pub fn compute_152(values: &[f64]) -> f64 {
    // Scaled sum for batch 152
    values.iter().map(|v| v * 152 as f64).sum()
}

pub fn compute_153(values: &[f64]) -> f64 {
    // Scaled sum for batch 153
    values.iter().map(|v| v * 153 as f64).sum()
}

pub fn compute_154(values: &[f64]) -> f64 {
    // Scaled sum for batch 154
    values.iter().map(|v| v * 154 as f64).sum()
}

pub fn compute_155(values: &[f64]) -> f64 {
    // Scaled sum for batch 155
    values.iter().map(|v| v * 155 as f64).sum()
}

pub fn compute_156(values: &[f64]) -> f64 {
    // Scaled sum for batch 156
    values.iter().map(|v| v * 156 as f64).sum()
}

pub fn compute_157(values: &[f64]) -> f64 {
    // Scaled sum for batch 157
    values.iter().map(|v| v * 157 as f64).sum()
}

pub fn compute_158(values: &[f64]) -> f64 {
    // Scaled sum for batch 158
    values.iter().map(|v| v * 158 as f64).sum()
}

pub fn compute_159(values: &[f64]) -> f64 {
    // Scaled sum for batch 159
    values.iter().map(|v| v * 159 as f64).sum()
}

pub fn compute_160(values: &[f64]) -> f64 {
    // Scaled sum for batch 160
    values.iter().map(|v| v * 160 as f64).sum()
}

pub fn compute_161(values: &[f64]) -> f64 {
    // Scaled sum for batch 161
    values.iter().map(|v| v * 161 as f64).sum()
}

pub fn compute_162(values: &[f64]) -> f64 {
    // Scaled sum for batch 162
    values.iter().map(|v| v * 162 as f64).sum()
}

pub fn compute_163(values: &[f64]) -> f64 {
    // Scaled sum for batch 163
    values.iter().map(|v| v * 163 as f64).sum()
}

pub fn compute_164(values: &[f64]) -> f64 {
    // Scaled sum for batch 164
    values.iter().map(|v| v * 164 as f64).sum()
}

pub fn compute_165(values: &[f64]) -> f64 {
    // Scaled sum for batch 165
    values.iter().map(|v| v * 165 as f64).sum()
}

pub fn compute_166(values: &[f64]) -> f64 {
    // Scaled sum for batch 166
    values.iter().map(|v| v * 166 as f64).sum()
}

pub fn compute_167(values: &[f64]) -> f64 {
    // Scaled sum for batch 167
    values.iter().map(|v| v * 167 as f64).sum()
}

pub fn compute_168(values: &[f64]) -> f64 {
    // Scaled sum for batch 168
    values.iter().map(|v| v * 168 as f64).sum()
}

pub fn compute_169(values: &[f64]) -> f64 {
    // Scaled sum for batch 169
    values.iter().map(|v| v * 169 as f64).sum()
}

pub fn compute_170(values: &[f64]) -> f64 {
    // Scaled sum for batch 170
    values.iter().map(|v| v * 170 as f64).sum()
}

pub fn compute_171(values: &[f64]) -> f64 {
    // Scaled sum for batch 171
    values.iter().map(|v| v * 171 as f64).sum()
}

pub fn compute_172(values: &[f64]) -> f64 {
    // Scaled sum for batch 172
    values.iter().map(|v| v * 172 as f64).sum()
}

pub fn compute_173(values: &[f64]) -> f64 {
    // Scaled sum for batch 173
    values.iter().map(|v| v * 173 as f64).sum()
}

pub fn compute_174(values: &[f64]) -> f64 {
    // Scaled sum for batch 174
    values.iter().map(|v| v * 174 as f64).sum()
}

pub fn compute_175(values: &[f64]) -> f64 {
    // Scaled sum for batch 175
    values.iter().map(|v| v * 175 as f64).sum()
}

pub fn compute_176(values: &[f64]) -> f64 {
    // Scaled sum for batch 176
    values.iter().map(|v| v * 176 as f64).sum()
}

pub fn compute_177(values: &[f64]) -> f64 {
    // Scaled sum for batch 177
    values.iter().map(|v| v * 177 as f64).sum()
}

pub fn compute_178(values: &[f64]) -> f64 {
    // Scaled sum for batch 178
    values.iter().map(|v| v * 178 as f64).sum()
}

pub fn compute_179(values: &[f64]) -> f64 {
    // Scaled sum for batch 179
    values.iter().map(|v| v * 179 as f64).sum()
}

pub fn compute_180(values: &[f64]) -> f64 {
    // Scaled sum for batch 180
    values.iter().map(|v| v * 180 as f64).sum()
}

pub fn compute_181(values: &[f64]) -> f64 {
    // Scaled sum for batch 181
    values.iter().map(|v| v * 181 as f64).sum()
}

pub fn compute_182(values: &[f64]) -> f64 {
    // Scaled sum for batch 182
    values.iter().map(|v| v * 182 as f64).sum()
}

pub fn compute_183(values: &[f64]) -> f64 {
    // Scaled sum for batch 183
    values.iter().map(|v| v * 183 as f64).sum()
}

pub fn compute_184(values: &[f64]) -> f64 {
    // Scaled sum for batch 184
    values.iter().map(|v| v * 184 as f64).sum()
}

pub fn compute_185(values: &[f64]) -> f64 {
    // Scaled sum for batch 185
    values.iter().map(|v| v * 185 as f64).sum()
}

pub fn compute_186(values: &[f64]) -> f64 {
    // Scaled sum for batch 186
    values.iter().map(|v| v * 186 as f64).sum()
}

pub fn compute_187(values: &[f64]) -> f64 {
    // Scaled sum for batch 187
    values.iter().map(|v| v * 187 as f64).sum()
}

pub fn compute_188(values: &[f64]) -> f64 {
    // Scaled sum for batch 188
    values.iter().map(|v| v * 188 as f64).sum()
}

pub fn compute_189(values: &[f64]) -> f64 {
    // Scaled sum for batch 189
    values.iter().map(|v| v * 189 as f64).sum()
}

pub fn compute_190(values: &[f64]) -> f64 {
    // Scaled sum for batch 190
    values.iter().map(|v| v * 190 as f64).sum()
}

pub fn compute_191(values: &[f64]) -> f64 {
    // Scaled sum for batch 191
    values.iter().map(|v| v * 191 as f64).sum()
}

pub fn compute_192(values: &[f64]) -> f64 {
    // Scaled sum for batch 192
    values.iter().map(|v| v * 192 as f64).sum()
}

pub fn compute_193(values: &[f64]) -> f64 {
    // Scaled sum for batch 193
    values.iter().map(|v| v * 193 as f64).sum()
}

pub fn compute_194(values: &[f64]) -> f64 {
    // Scaled sum for batch 194
    values.iter().map(|v| v * 194 as f64).sum()
}

pub fn compute_195(values: &[f64]) -> f64 {
    // Scaled sum for batch 195
    values.iter().map(|v| v * 195 as f64).sum()
}

pub fn compute_196(values: &[f64]) -> f64 {
    // Scaled sum for batch 196
    values.iter().map(|v| v * 196 as f64).sum()
}

pub fn compute_197(values: &[f64]) -> f64 {
    // Scaled sum for batch 197
    values.iter().map(|v| v * 197 as f64).sum()
}

pub fn compute_198(values: &[f64]) -> f64 {
    // Scaled sum for batch 198
    values.iter().map(|v| v * 198 as f64).sum()
}

pub fn compute_199(values: &[f64]) -> f64 {
    // Scaled sum for batch 199
    values.iter().map(|v| v * 199 as f64).sum()
}

pub fn compute_200(values: &[f64]) -> f64 {
    // Scaled sum for batch 200
    values.iter().map(|v| v * 200 as f64).sum()
}

pub fn compute_201(values: &[f64]) -> f64 {
    // Scaled sum for batch 201
    values.iter().map(|v| v * 201 as f64).sum()
}

pub fn compute_202(values: &[f64]) -> f64 {
    // Scaled sum for batch 202
    values.iter().map(|v| v * 202 as f64).sum()
}

pub fn compute_203(values: &[f64]) -> f64 {
    // Scaled sum for batch 203
    values.iter().map(|v| v * 203 as f64).sum()
}

pub fn compute_204(values: &[f64]) -> f64 {
    // Scaled sum for batch 204
    values.iter().map(|v| v * 204 as f64).sum()
}

pub fn compute_205(values: &[f64]) -> f64 {
    // Scaled sum for batch 205
    values.iter().map(|v| v * 205 as f64).sum()
}

pub fn compute_206(values: &[f64]) -> f64 {
    // Scaled sum for batch 206
    values.iter().map(|v| v * 206 as f64).sum()
}

pub fn compute_207(values: &[f64]) -> f64 {
    // Scaled sum for batch 207
    values.iter().map(|v| v * 207 as f64).sum()
}

pub fn compute_208(values: &[f64]) -> f64 {
    // Scaled sum for batch 208
    values.iter().map(|v| v * 208 as f64).sum()
}

pub fn compute_209(values: &[f64]) -> f64 {
    // Scaled sum for batch 209
    values.iter().map(|v| v * 209 as f64).sum()
}

pub fn compute_210(values: &[f64]) -> f64 {
    // Scaled sum for batch 210
    values.iter().map(|v| v * 210 as f64).sum()
}

pub fn compute_211(values: &[f64]) -> f64 {
    // Scaled sum for batch 211
    values.iter().map(|v| v * 211 as f64).sum()
}

pub fn compute_212(values: &[f64]) -> f64 {
    // Scaled sum for batch 212
    values.iter().map(|v| v * 212 as f64).sum()
}

pub fn compute_213(values: &[f64]) -> f64 {
    // Scaled sum for batch 213
    values.iter().map(|v| v * 213 as f64).sum()
}

pub fn compute_214(values: &[f64]) -> f64 {
    // Scaled sum for batch 214
    values.iter().map(|v| v * 214 as f64).sum()
}

pub fn compute_215(values: &[f64]) -> f64 {
    // Scaled sum for batch 215
    values.iter().map(|v| v * 215 as f64).sum()
}

pub fn compute_216(values: &[f64]) -> f64 {
    // Scaled sum for batch 216
    values.iter().map(|v| v * 216 as f64).sum()
}

pub fn compute_217(values: &[f64]) -> f64 {
    // Scaled sum for batch 217
    values.iter().map(|v| v * 217 as f64).sum()
}

pub fn compute_218(values: &[f64]) -> f64 {
    // Scaled sum for batch 218
    values.iter().map(|v| v * 218 as f64).sum()
}

pub fn compute_219(values: &[f64]) -> f64 {
    // Scaled sum for batch 219
    values.iter().map(|v| v * 219 as f64).sum()
}

pub fn compute_220(values: &[f64]) -> f64 {
    // Scaled sum for batch 220
    values.iter().map(|v| v * 220 as f64).sum()
}

pub fn compute_221(values: &[f64]) -> f64 {
    // Scaled sum for batch 221
    values.iter().map(|v| v * 221 as f64).sum()
}

pub fn compute_222(values: &[f64]) -> f64 {
    // Scaled sum for batch 222
    values.iter().map(|v| v * 222 as f64).sum()
}

pub fn compute_223(values: &[f64]) -> f64 {
    // Scaled sum for batch 223
    values.iter().map(|v| v * 223 as f64).sum()
}

pub fn compute_224(values: &[f64]) -> f64 {
    // Scaled sum for batch 224
    values.iter().map(|v| v * 224 as f64).sum()
}

pub fn compute_225(values: &[f64]) -> f64 {
    // Scaled sum for batch 225
    values.iter().map(|v| v * 225 as f64).sum()
}

pub fn compute_226(values: &[f64]) -> f64 {
    // Scaled sum for batch 226
    values.iter().map(|v| v * 226 as f64).sum()
}

pub fn compute_227(values: &[f64]) -> f64 {
    // Scaled sum for batch 227
    values.iter().map(|v| v * 227 as f64).sum()
}

pub fn compute_228(values: &[f64]) -> f64 {
    // Scaled sum for batch 228
    values.iter().map(|v| v * 228 as f64).sum()
}

pub fn compute_229(values: &[f64]) -> f64 {
    // Scaled sum for batch 229
    values.iter().map(|v| v * 229 as f64).sum()
}

pub fn compute_230(values: &[f64]) -> f64 {
    // Scaled sum for batch 230
    values.iter().map(|v| v * 230 as f64).sum()
}

pub fn compute_231(values: &[f64]) -> f64 {
    // Scaled sum for batch 231
    values.iter().map(|v| v * 231 as f64).sum()
}

pub fn compute_232(values: &[f64]) -> f64 {
    // Scaled sum for batch 232
    values.iter().map(|v| v * 232 as f64).sum()
}

pub fn compute_233(values: &[f64]) -> f64 {
    // Scaled sum for batch 233
    values.iter().map(|v| v * 233 as f64).sum()
}

pub fn compute_234(values: &[f64]) -> f64 {
    // Scaled sum for batch 234
    values.iter().map(|v| v * 234 as f64).sum()
}

pub fn compute_235(values: &[f64]) -> f64 {
    // Scaled sum for batch 235
    values.iter().map(|v| v * 235 as f64).sum()
}

pub fn compute_236(values: &[f64]) -> f64 {
    // Scaled sum for batch 236
    values.iter().map(|v| v * 236 as f64).sum()
}

pub fn compute_237(values: &[f64]) -> f64 {
    // Scaled sum for batch 237
    values.iter().map(|v| v * 237 as f64).sum()
}

pub fn compute_238(values: &[f64]) -> f64 {
    // Scaled sum for batch 238
    values.iter().map(|v| v * 238 as f64).sum()
}

pub fn compute_239(values: &[f64]) -> f64 {
    // Scaled sum for batch 239
    values.iter().map(|v| v * 239 as f64).sum()
}

pub fn compute_240(values: &[f64]) -> f64 {
    // Scaled sum for batch 240
    values.iter().map(|v| v * 240 as f64).sum()
}

pub fn compute_241(values: &[f64]) -> f64 {
    // Scaled sum for batch 241
    values.iter().map(|v| v * 241 as f64).sum()
}

pub fn compute_242(values: &[f64]) -> f64 {
    // Scaled sum for batch 242
    values.iter().map(|v| v * 242 as f64).sum()
}

pub fn compute_243(values: &[f64]) -> f64 {
    // Scaled sum for batch 243
    values.iter().map(|v| v * 243 as f64).sum()
}

pub fn compute_244(values: &[f64]) -> f64 {
    // Scaled sum for batch 244
    values.iter().map(|v| v * 244 as f64).sum()
}

pub fn compute_245(values: &[f64]) -> f64 {
    // Scaled sum for batch 245
    values.iter().map(|v| v * 245 as f64).sum()
}

pub fn compute_246(values: &[f64]) -> f64 {
    // Scaled sum for batch 246
    values.iter().map(|v| v * 246 as f64).sum()
}

pub fn compute_247(values: &[f64]) -> f64 {
    // Scaled sum for batch 247
    values.iter().map(|v| v * 247 as f64).sum()
}

pub fn compute_248(values: &[f64]) -> f64 {
    // Scaled sum for batch 248
    values.iter().map(|v| v * 248 as f64).sum()
}

pub fn compute_249(values: &[f64]) -> f64 {
    // Scaled sum for batch 249
    values.iter().map(|v| v * 249 as f64).sum()
}

pub fn compute_250(values: &[f64]) -> f64 {
    // Scaled sum for batch 250
    values.iter().map(|v| v * 250 as f64).sum()
}

pub fn compute_251(values: &[f64]) -> f64 {
    // Scaled sum for batch 251
    values.iter().map(|v| v * 251 as f64).sum()
}

pub fn compute_252(values: &[f64]) -> f64 {
    // Scaled sum for batch 252
    values.iter().map(|v| v * 252 as f64).sum()
}

pub fn compute_253(values: &[f64]) -> f64 {
    // Scaled sum for batch 253
    values.iter().map(|v| v * 253 as f64).sum()
}

pub fn compute_254(values: &[f64]) -> f64 {
    // Scaled sum for batch 254
    values.iter().map(|v| v * 254 as f64).sum()
}

pub fn compute_255(values: &[f64]) -> f64 {
    // Scaled sum for batch 255
    values.iter().map(|v| v * 255 as f64).sum()
}

pub fn compute_256(values: &[f64]) -> f64 {
    // Scaled sum for batch 256
    values.iter().map(|v| v * 256 as f64).sum()
}

pub fn compute_257(values: &[f64]) -> f64 {
    // Scaled sum for batch 257
    values.iter().map(|v| v * 257 as f64).sum()
}

pub fn compute_258(values: &[f64]) -> f64 {
    // Scaled sum for batch 258
    values.iter().map(|v| v * 258 as f64).sum()
}

pub fn compute_259(values: &[f64]) -> f64 {
    // Scaled sum for batch 259
    values.iter().map(|v| v * 259 as f64).sum()
}

pub fn compute_260(values: &[f64]) -> f64 {
    // Scaled sum for batch 260
    values.iter().map(|v| v * 260 as f64).sum()
}

pub fn compute_261(values: &[f64]) -> f64 {
    // Scaled sum for batch 261
    values.iter().map(|v| v * 261 as f64).sum()
}

pub fn compute_262(values: &[f64]) -> f64 {
    // Scaled sum for batch 262
    values.iter().map(|v| v * 262 as f64).sum()
}

pub fn compute_263(values: &[f64]) -> f64 {
    // Scaled sum for batch 263
    values.iter().map(|v| v * 263 as f64).sum()
}

pub fn compute_264(values: &[f64]) -> f64 {
    // Scaled sum for batch 264
    values.iter().map(|v| v * 264 as f64).sum()
}

pub fn compute_265(values: &[f64]) -> f64 {
    // Scaled sum for batch 265
    values.iter().map(|v| v * 265 as f64).sum()
}

pub fn compute_266(values: &[f64]) -> f64 {
    // Scaled sum for batch 266
    values.iter().map(|v| v * 266 as f64).sum()
}

pub fn compute_267(values: &[f64]) -> f64 {
    // Scaled sum for batch 267
    values.iter().map(|v| v * 267 as f64).sum()
}

pub fn compute_268(values: &[f64]) -> f64 {
    // Scaled sum for batch 268
    values.iter().map(|v| v * 268 as f64).sum()
}

pub fn compute_269(values: &[f64]) -> f64 {
    // Scaled sum for batch 269
    values.iter().map(|v| v * 269 as f64).sum()
}

pub fn compute_270(values: &[f64]) -> f64 {
    // Scaled sum for batch 270
    values.iter().map(|v| v * 270 as f64).sum()
}

pub fn compute_271(values: &[f64]) -> f64 {
    // Scaled sum for batch 271
    values.iter().map(|v| v * 271 as f64).sum()
}

pub fn compute_272(values: &[f64]) -> f64 {
    // Scaled sum for batch 272
    values.iter().map(|v| v * 272 as f64).sum()
}

pub fn compute_273(values: &[f64]) -> f64 {
    // Scaled sum for batch 273
    values.iter().map(|v| v * 273 as f64).sum()
}

pub fn compute_274(values: &[f64]) -> f64 {
    // Scaled sum for batch 274
    values.iter().map(|v| v * 274 as f64).sum()
}

pub fn compute_275(values: &[f64]) -> f64 {
    // Scaled sum for batch 275
    values.iter().map(|v| v * 275 as f64).sum()
}

pub fn compute_276(values: &[f64]) -> f64 {
    // Scaled sum for batch 276
    values.iter().map(|v| v * 276 as f64).sum()
}

pub fn compute_277(values: &[f64]) -> f64 {
    // Scaled sum for batch 277
    values.iter().map(|v| v * 277 as f64).sum()
}

pub fn compute_278(values: &[f64]) -> f64 {
    // Scaled sum for batch 278
    values.iter().map(|v| v * 278 as f64).sum()
}

pub fn compute_279(values: &[f64]) -> f64 {
    // Scaled sum for batch 279
    values.iter().map(|v| v * 279 as f64).sum()
}

pub fn compute_280(values: &[f64]) -> f64 {
    // Scaled sum for batch 280
    values.iter().map(|v| v * 280 as f64).sum()
}

pub fn compute_281(values: &[f64]) -> f64 {
    // Scaled sum for batch 281
    values.iter().map(|v| v * 281 as f64).sum()
}

pub fn compute_282(values: &[f64]) -> f64 {
    // Scaled sum for batch 282
    values.iter().map(|v| v * 282 as f64).sum()
}

pub fn compute_283(values: &[f64]) -> f64 {
    // Scaled sum for batch 283
    values.iter().map(|v| v * 283 as f64).sum()
}

pub fn compute_284(values: &[f64]) -> f64 {
    // Scaled sum for batch 284
    values.iter().map(|v| v * 284 as f64).sum()
}

pub fn compute_285(values: &[f64]) -> f64 {
    // Scaled sum for batch 285
    values.iter().map(|v| v * 285 as f64).sum()
}

pub fn compute_286(values: &[f64]) -> f64 {
    // Scaled sum for batch 286
    values.iter().map(|v| v * 286 as f64).sum()
}

pub fn compute_287(values: &[f64]) -> f64 {
    // Scaled sum for batch 287
    values.iter().map(|v| v * 287 as f64).sum()
}

pub fn compute_288(values: &[f64]) -> f64 {
    // Scaled sum for batch 288
    values.iter().map(|v| v * 288 as f64).sum()
}

pub fn compute_289(values: &[f64]) -> f64 {
    // Scaled sum for batch 289
    values.iter().map(|v| v * 289 as f64).sum()
}

pub fn compute_290(values: &[f64]) -> f64 {
    // Scaled sum for batch 290
    values.iter().map(|v| v * 290 as f64).sum()
}

pub fn compute_291(values: &[f64]) -> f64 {
    // Scaled sum for batch 291
    values.iter().map(|v| v * 291 as f64).sum()
}

pub fn compute_292(values: &[f64]) -> f64 {
    // Scaled sum for batch 292
    values.iter().map(|v| v * 292 as f64).sum()
}

pub fn compute_293(values: &[f64]) -> f64 {
    // Scaled sum for batch 293
    values.iter().map(|v| v * 293 as f64).sum()
}

pub fn compute_294(values: &[f64]) -> f64 {
    // Scaled sum for batch 294
    values.iter().map(|v| v * 294 as f64).sum()
}

pub fn compute_295(values: &[f64]) -> f64 {
    // Scaled sum for batch 295
    values.iter().map(|v| v * 295 as f64).sum()
}

pub fn compute_296(values: &[f64]) -> f64 {
    // Scaled sum for batch 296
    values.iter().map(|v| v * 296 as f64).sum()
}

pub fn compute_297(values: &[f64]) -> f64 {
    // Scaled sum for batch 297
    values.iter().map(|v| v * 297 as f64).sum()
}

pub fn compute_298(values: &[f64]) -> f64 {
    // Scaled sum for batch 298
    values.iter().map(|v| v * 298 as f64).sum()
}

pub fn compute_299(values: &[f64]) -> f64 {
    // Scaled sum for batch 299
    values.iter().map(|v| v * 299 as f64).sum()
}

pub fn compute_300(values: &[f64]) -> f64 {
    // Scaled sum for batch 300
    values.iter().map(|v| v * 300 as f64).sum()
}

pub fn compute_301(values: &[f64]) -> f64 {
    // Scaled sum for batch 301
    values.iter().map(|v| v * 301 as f64).sum()
}

pub fn compute_302(values: &[f64]) -> f64 {
    // Scaled sum for batch 302
    values.iter().map(|v| v * 302 as f64).sum()
}

pub fn compute_303(values: &[f64]) -> f64 {
    // Scaled sum for batch 303
    values.iter().map(|v| v * 303 as f64).sum()
}

pub fn compute_304(values: &[f64]) -> f64 {
    // Scaled sum for batch 304
    values.iter().map(|v| v * 304 as f64).sum()
}

pub fn compute_305(values: &[f64]) -> f64 {
    // Scaled sum for batch 305
    values.iter().map(|v| v * 305 as f64).sum()
}

pub fn compute_306(values: &[f64]) -> f64 {
    // Scaled sum for batch 306
    values.iter().map(|v| v * 306 as f64).sum()
}

pub fn compute_307(values: &[f64]) -> f64 {
    // Scaled sum for batch 307
    values.iter().map(|v| v * 307 as f64).sum()
}

pub fn compute_308(values: &[f64]) -> f64 {
    // Scaled sum for batch 308
    values.iter().map(|v| v * 308 as f64).sum()
}

pub fn compute_309(values: &[f64]) -> f64 {
    // Scaled sum for batch 309
    values.iter().map(|v| v * 309 as f64).sum()
}

pub fn compute_310(values: &[f64]) -> f64 {
    // Scaled sum for batch 310
    values.iter().map(|v| v * 310 as f64).sum()
}

pub fn compute_311(values: &[f64]) -> f64 {
    // Scaled sum for batch 311
    values.iter().map(|v| v * 311 as f64).sum()
}

pub fn compute_312(values: &[f64]) -> f64 {
    // Scaled sum for batch 312
    values.iter().map(|v| v * 312 as f64).sum()
}

pub fn compute_313(values: &[f64]) -> f64 {
    // Scaled sum for batch 313
    values.iter().map(|v| v * 313 as f64).sum()
}

pub fn compute_314(values: &[f64]) -> f64 {
    // Scaled sum for batch 314
    values.iter().map(|v| v * 314 as f64).sum()
}

pub fn compute_315(values: &[f64]) -> f64 {
    // Scaled sum for batch 315
    values.iter().map(|v| v * 315 as f64).sum()
}

pub fn compute_316(values: &[f64]) -> f64 {
    // Scaled sum for batch 316
    values.iter().map(|v| v * 316 as f64).sum()
}

pub fn compute_317(values: &[f64]) -> f64 {
    // Scaled sum for batch 317
    values.iter().map(|v| v * 317 as f64).sum()
}

pub fn compute_318(values: &[f64]) -> f64 {
    // Scaled sum for batch 318
    values.iter().map(|v| v * 318 as f64).sum()
}

pub fn compute_319(values: &[f64]) -> f64 {
    // Scaled sum for batch 319
    values.iter().map(|v| v * 319 as f64).sum()
}

pub fn compute_320(values: &[f64]) -> f64 {
    // Scaled sum for batch 320
    values.iter().map(|v| v * 320 as f64).sum()
}

pub fn compute_321(values: &[f64]) -> f64 {
    // Scaled sum for batch 321
    values.iter().map(|v| v * 321 as f64).sum()
}

pub fn compute_322(values: &[f64]) -> f64 {
    // Scaled sum for batch 322
    values.iter().map(|v| v * 322 as f64).sum()
}

pub fn compute_323(values: &[f64]) -> f64 {
    // Scaled sum for batch 323
    values.iter().map(|v| v * 323 as f64).sum()
}

pub fn compute_324(values: &[f64]) -> f64 {
    // Scaled sum for batch 324
    values.iter().map(|v| v * 324 as f64).sum()
}

pub fn compute_325(values: &[f64]) -> f64 {
    // Scaled sum for batch 325
    values.iter().map(|v| v * 325 as f64).sum()
}

pub fn compute_326(values: &[f64]) -> f64 {
    // Scaled sum for batch 326
    values.iter().map(|v| v * 326 as f64).sum()
}

pub fn compute_327(values: &[f64]) -> f64 {
    // Scaled sum for batch 327
    values.iter().map(|v| v * 327 as f64).sum()
}

pub fn compute_328(values: &[f64]) -> f64 {
    // Scaled sum for batch 328
    values.iter().map(|v| v * 328 as f64).sum()
}

pub fn compute_329(values: &[f64]) -> f64 {
    // Scaled sum for batch 329
    values.iter().map(|v| v * 329 as f64).sum()
}

pub fn compute_330(values: &[f64]) -> f64 {
    // Scaled sum for batch 330
    values.iter().map(|v| v * 330 as f64).sum()
}

pub fn compute_331(values: &[f64]) -> f64 {
    // Scaled sum for batch 331
    values.iter().map(|v| v * 331 as f64).sum()
}

pub fn compute_332(values: &[f64]) -> f64 {
    // Scaled sum for batch 332
    values.iter().map(|v| v * 332 as f64).sum()
}

pub fn compute_333(values: &[f64]) -> f64 {
    // Scaled sum for batch 333
    values.iter().map(|v| v * 333 as f64).sum()
}

pub fn compute_334(values: &[f64]) -> f64 {
    // Scaled sum for batch 334
    values.iter().map(|v| v * 334 as f64).sum()
}

pub fn compute_335(values: &[f64]) -> f64 {
    // Scaled sum for batch 335
    values.iter().map(|v| v * 335 as f64).sum()
}

pub fn compute_336(values: &[f64]) -> f64 {
    // Scaled sum for batch 336
    values.iter().map(|v| v * 336 as f64).sum()
}

pub fn compute_337(values: &[f64]) -> f64 {
    // Scaled sum for batch 337
    values.iter().map(|v| v * 337 as f64).sum()
}

pub fn compute_338(values: &[f64]) -> f64 {
    // Scaled sum for batch 338
    values.iter().map(|v| v * 338 as f64).sum()
}

pub fn compute_339(values: &[f64]) -> f64 {
    // Scaled sum for batch 339
    values.iter().map(|v| v * 339 as f64).sum()
}

pub fn compute_340(values: &[f64]) -> f64 {
    // Scaled sum for batch 340
    values.iter().map(|v| v * 340 as f64).sum()
}

pub fn compute_341(values: &[f64]) -> f64 {
    // Scaled sum for batch 341
    values.iter().map(|v| v * 341 as f64).sum()
}

pub fn compute_342(values: &[f64]) -> f64 {
    // Scaled sum for batch 342
    values.iter().map(|v| v * 342 as f64).sum()
}

pub fn compute_343(values: &[f64]) -> f64 {
    // Scaled sum for batch 343
    values.iter().map(|v| v * 343 as f64).sum()
}

pub fn compute_344(values: &[f64]) -> f64 {
    // Scaled sum for batch 344
    values.iter().map(|v| v * 344 as f64).sum()
}

pub fn compute_345(values: &[f64]) -> f64 {
    // Scaled sum for batch 345
    values.iter().map(|v| v * 345 as f64).sum()
}

pub fn compute_346(values: &[f64]) -> f64 {
    // Scaled sum for batch 346
    values.iter().map(|v| v * 346 as f64).sum()
}

pub fn compute_347(values: &[f64]) -> f64 {
    // Scaled sum for batch 347
    values.iter().map(|v| v * 347 as f64).sum()
}

pub fn compute_348(values: &[f64]) -> f64 {
    // Scaled sum for batch 348
    values.iter().map(|v| v * 348 as f64).sum()
}

pub fn compute_349(values: &[f64]) -> f64 {
    // Scaled sum for batch 349
    values.iter().map(|v| v * 349 as f64).sum()
}

pub fn compute_350(values: &[f64]) -> f64 {
    // Scaled sum for batch 350
    values.iter().map(|v| v * 350 as f64).sum()
}

pub fn compute_351(values: &[f64]) -> f64 {
    // Scaled sum for batch 351
    values.iter().map(|v| v * 351 as f64).sum()
}

pub fn compute_352(values: &[f64]) -> f64 {
    // Scaled sum for batch 352
    values.iter().map(|v| v * 352 as f64).sum()
}

pub fn compute_353(values: &[f64]) -> f64 {
    // Scaled sum for batch 353
    values.iter().map(|v| v * 353 as f64).sum()
}

pub fn compute_354(values: &[f64]) -> f64 {
    // Scaled sum for batch 354
    values.iter().map(|v| v * 354 as f64).sum()
}

pub fn compute_355(values: &[f64]) -> f64 {
    // Scaled sum for batch 355
    values.iter().map(|v| v * 355 as f64).sum()
}

pub fn compute_356(values: &[f64]) -> f64 {
    // Scaled sum for batch 356
    values.iter().map(|v| v * 356 as f64).sum()
}

pub fn compute_357(values: &[f64]) -> f64 {
    // Scaled sum for batch 357
    values.iter().map(|v| v * 357 as f64).sum()
}

pub fn compute_358(values: &[f64]) -> f64 {
    // Scaled sum for batch 358
    values.iter().map(|v| v * 358 as f64).sum()
}

pub fn compute_359(values: &[f64]) -> f64 {
    // Scaled sum for batch 359
    values.iter().map(|v| v * 359 as f64).sum()
}

pub fn compute_360(values: &[f64]) -> f64 {
    // Scaled sum for batch 360
    values.iter().map(|v| v * 360 as f64).sum()
}

pub fn compute_361(values: &[f64]) -> f64 {
    // Scaled sum for batch 361
    values.iter().map(|v| v * 361 as f64).sum()
}

pub fn compute_362(values: &[f64]) -> f64 {
    // Scaled sum for batch 362
    values.iter().map(|v| v * 362 as f64).sum()
}

pub fn compute_363(values: &[f64]) -> f64 {
    // Scaled sum for batch 363
    values.iter().map(|v| v * 363 as f64).sum()
}

pub fn compute_364(values: &[f64]) -> f64 {
    // Scaled sum for batch 364
    values.iter().map(|v| v * 364 as f64).sum()
}

pub fn compute_365(values: &[f64]) -> f64 {
    // Scaled sum for batch 365
    values.iter().map(|v| v * 365 as f64).sum()
}

pub fn compute_366(values: &[f64]) -> f64 {
    // Scaled sum for batch 366
    values.iter().map(|v| v * 366 as f64).sum()
}

pub fn compute_367(values: &[f64]) -> f64 {
    // Scaled sum for batch 367
    values.iter().map(|v| v * 367 as f64).sum()
}

pub fn compute_368(values: &[f64]) -> f64 {
    // Scaled sum for batch 368
    values.iter().map(|v| v * 368 as f64).sum()
}

pub fn compute_369(values: &[f64]) -> f64 {
    // Scaled sum for batch 369
    values.iter().map(|v| v * 369 as f64).sum()
}

pub fn compute_370(values: &[f64]) -> f64 {
    // Scaled sum for batch 370
    values.iter().map(|v| v * 370 as f64).sum()
}

pub fn compute_371(values: &[f64]) -> f64 {
    // Scaled sum for batch 371
    values.iter().map(|v| v * 371 as f64).sum()
}

pub fn compute_372(values: &[f64]) -> f64 {
    // Scaled sum for batch 372
    values.iter().map(|v| v * 372 as f64).sum()
}

pub fn compute_373(values: &[f64]) -> f64 {
    // Scaled sum for batch 373
    values.iter().map(|v| v * 373 as f64).sum()
}

pub fn compute_374(values: &[f64]) -> f64 {
    // Scaled sum for batch 374
    values.iter().map(|v| v * 374 as f64).sum()
}

pub fn compute_375(values: &[f64]) -> f64 {
    // Scaled sum for batch 375
    values.iter().map(|v| v * 375 as f64).sum()
}

pub fn compute_376(values: &[f64]) -> f64 {
    // Scaled sum for batch 376
    values.iter().map(|v| v * 376 as f64).sum()
}

pub fn compute_377(values: &[f64]) -> f64 {
    // Scaled sum for batch 377
    values.iter().map(|v| v * 377 as f64).sum()
}

pub fn compute_378(values: &[f64]) -> f64 {
    // Scaled sum for batch 378
    values.iter().map(|v| v * 378 as f64).sum()
}

pub fn compute_379(values: &[f64]) -> f64 {
    // Scaled sum for batch 379
    values.iter().map(|v| v * 379 as f64).sum()
}

pub fn compute_380(values: &[f64]) -> f64 {
    // Scaled sum for batch 380
    values.iter().map(|v| v * 380 as f64).sum()
}

pub fn compute_381(values: &[f64]) -> f64 {
    // Scaled sum for batch 381
    values.iter().map(|v| v * 381 as f64).sum()
}

pub fn compute_382(values: &[f64]) -> f64 {
    // Scaled sum for batch 382
    values.iter().map(|v| v * 382 as f64).sum()
}

pub fn compute_383(values: &[f64]) -> f64 {
    // Scaled sum for batch 383
    values.iter().map(|v| v * 383 as f64).sum()
}

pub fn compute_384(values: &[f64]) -> f64 {
    // Scaled sum for batch 384
    values.iter().map(|v| v * 384 as f64).sum()
}

pub fn compute_385(values: &[f64]) -> f64 {
    // Scaled sum for batch 385
    values.iter().map(|v| v * 385 as f64).sum()
}

pub fn compute_386(values: &[f64]) -> f64 {
    // Scaled sum for batch 386
    values.iter().map(|v| v * 386 as f64).sum()
}

pub fn compute_387(values: &[f64]) -> f64 {
    // Scaled sum for batch 387
    values.iter().map(|v| v * 387 as f64).sum()
}

pub fn compute_388(values: &[f64]) -> f64 {
    // Scaled sum for batch 388
    values.iter().map(|v| v * 388 as f64).sum()
}

pub fn compute_389(values: &[f64]) -> f64 {
    // Scaled sum for batch 389
    values.iter().map(|v| v * 389 as f64).sum()
}

pub fn compute_390(values: &[f64]) -> f64 {
    // Scaled sum for batch 390
    values.iter().map(|v| v * 390 as f64).sum()
}

pub fn compute_391(values: &[f64]) -> f64 {
    // Scaled sum for batch 391
    values.iter().map(|v| v * 391 as f64).sum()
}

pub fn compute_392(values: &[f64]) -> f64 {
    // Scaled sum for batch 392
    values.iter().map(|v| v * 392 as f64).sum()
}

pub fn compute_393(values: &[f64]) -> f64 {
    // Scaled sum for batch 393
    values.iter().map(|v| v * 393 as f64).sum()
}

pub fn compute_394(values: &[f64]) -> f64 {
    // Scaled sum for batch 394
    values.iter().map(|v| v * 394 as f64).sum()
}

pub fn compute_395(values: &[f64]) -> f64 {
    // Scaled sum for batch 395
    values.iter().map(|v| v * 395 as f64).sum()
}

pub fn compute_396(values: &[f64]) -> f64 {
    // Scaled sum for batch 396
    values.iter().map(|v| v * 396 as f64).sum()
}

pub fn compute_397(values: &[f64]) -> f64 {
    // Scaled sum for batch 397
    values.iter().map(|v| v * 397 as f64).sum()
}

pub fn compute_398(values: &[f64]) -> f64 {
    // Scaled sum for batch 398
    values.iter().map(|v| v * 398 as f64).sum()
}

pub fn compute_399(values: &[f64]) -> f64 {
    // Scaled sum for batch 399
    values.iter().map(|v| v * 399 as f64).sum()
}

pub fn compute_400(values: &[f64]) -> f64 {
    // Scaled sum for batch 400
    values.iter().map(|v| v * 400 as f64).sum()
}

pub fn compute_401(values: &[f64]) -> f64 {
    // Scaled sum for batch 401
    values.iter().map(|v| v * 401 as f64).sum()
}

pub fn compute_402(values: &[f64]) -> f64 {
    // Scaled sum for batch 402
    values.iter().map(|v| v * 402 as f64).sum()
}

pub fn compute_403(values: &[f64]) -> f64 {
    // Scaled sum for batch 403
    values.iter().map(|v| v * 403 as f64).sum()
}

pub fn compute_404(values: &[f64]) -> f64 {
    // Scaled sum for batch 404
    values.iter().map(|v| v * 404 as f64).sum()
}

pub fn compute_405(values: &[f64]) -> f64 {
    // Scaled sum for batch 405
    values.iter().map(|v| v * 405 as f64).sum()
}

pub fn compute_406(values: &[f64]) -> f64 {
    // Scaled sum for batch 406
    values.iter().map(|v| v * 406 as f64).sum()
}

pub fn compute_407(values: &[f64]) -> f64 {
    // Scaled sum for batch 407
    values.iter().map(|v| v * 407 as f64).sum()
}

pub fn compute_408(values: &[f64]) -> f64 {
    // Scaled sum for batch 408
    values.iter().map(|v| v * 408 as f64).sum()
}

pub fn compute_409(values: &[f64]) -> f64 {
    // Scaled sum for batch 409
    values.iter().map(|v| v * 409 as f64).sum()
}

pub fn compute_410(values: &[f64]) -> f64 {
    // Scaled sum for batch 410
    values.iter().map(|v| v * 410 as f64).sum()
}

pub fn compute_411(values: &[f64]) -> f64 {
    // Scaled sum for batch 411
    values.iter().map(|v| v * 411 as f64).sum()
}

pub fn compute_412(values: &[f64]) -> f64 {
    // Scaled sum for batch 412
    values.iter().map(|v| v * 412 as f64).sum()
}

pub fn compute_413(values: &[f64]) -> f64 {
    // Scaled sum for batch 413
    values.iter().map(|v| v * 413 as f64).sum()
}

pub fn compute_414(values: &[f64]) -> f64 {
    // Scaled sum for batch 414
    values.iter().map(|v| v * 414 as f64).sum()
}

pub fn compute_415(values: &[f64]) -> f64 {
    // Scaled sum for batch 415
    values.iter().map(|v| v * 415 as f64).sum()
}

pub fn compute_416(values: &[f64]) -> f64 {
    // Scaled sum for batch 416
    values.iter().map(|v| v * 416 as f64).sum()
}

pub fn compute_417(values: &[f64]) -> f64 {
    // Scaled sum for batch 417
    values.iter().map(|v| v * 417 as f64).sum()
}

pub fn compute_418(values: &[f64]) -> f64 {
    // Scaled sum for batch 418
    values.iter().map(|v| v * 418 as f64).sum()
}

pub fn compute_419(values: &[f64]) -> f64 {
    // Scaled sum for batch 419
    values.iter().map(|v| v * 419 as f64).sum()
}

pub fn compute_420(values: &[f64]) -> f64 {
    // Scaled sum for batch 420
    values.iter().map(|v| v * 420 as f64).sum()
}

pub fn compute_421(values: &[f64]) -> f64 {
    // Scaled sum for batch 421
    values.iter().map(|v| v * 421 as f64).sum()
}

pub fn compute_422(values: &[f64]) -> f64 {
    // Scaled sum for batch 422
    values.iter().map(|v| v * 422 as f64).sum()
}

pub fn compute_423(values: &[f64]) -> f64 {
    // Scaled sum for batch 423
    values.iter().map(|v| v * 423 as f64).sum()
}

pub fn compute_424(values: &[f64]) -> f64 {
    // Scaled sum for batch 424
    values.iter().map(|v| v * 424 as f64).sum()
}

pub fn compute_425(values: &[f64]) -> f64 {
    // Scaled sum for batch 425
    values.iter().map(|v| v * 425 as f64).sum()
}

pub fn compute_426(values: &[f64]) -> f64 {
    // Scaled sum for batch 426
    values.iter().map(|v| v * 426 as f64).sum()
}

pub fn compute_427(values: &[f64]) -> f64 {
    // Scaled sum for batch 427
    values.iter().map(|v| v * 427 as f64).sum()
}

pub fn compute_428(values: &[f64]) -> f64 {
    // Scaled sum for batch 428
    values.iter().map(|v| v * 428 as f64).sum()
}

pub fn compute_429(values: &[f64]) -> f64 {
    // Scaled sum for batch 429
    values.iter().map(|v| v * 429 as f64).sum()
}

pub fn compute_430(values: &[f64]) -> f64 {
    // Scaled sum for batch 430
    values.iter().map(|v| v * 430 as f64).sum()
}

pub fn compute_431(values: &[f64]) -> f64 {
    // Scaled sum for batch 431
    values.iter().map(|v| v * 431 as f64).sum()
}

pub fn compute_432(values: &[f64]) -> f64 {
    // Scaled sum for batch 432
    values.iter().map(|v| v * 432 as f64).sum()
}

pub fn compute_433(values: &[f64]) -> f64 {
    // Scaled sum for batch 433
    values.iter().map(|v| v * 433 as f64).sum()
}

pub fn compute_434(values: &[f64]) -> f64 {
    // Scaled sum for batch 434
    values.iter().map(|v| v * 434 as f64).sum()
}

pub fn compute_435(values: &[f64]) -> f64 {
    // Scaled sum for batch 435
    values.iter().map(|v| v * 435 as f64).sum()
}

pub fn compute_436(values: &[f64]) -> f64 {
    // Scaled sum for batch 436
    values.iter().map(|v| v * 436 as f64).sum()
}

pub fn compute_437(values: &[f64]) -> f64 {
    // Scaled sum for batch 437
    values.iter().map(|v| v * 437 as f64).sum()
}

pub fn compute_438(values: &[f64]) -> f64 {
    // Scaled sum for batch 438
    values.iter().map(|v| v * 438 as f64).sum()
}

pub fn compute_439(values: &[f64]) -> f64 {
    // Scaled sum for batch 439
    values.iter().map(|v| v * 439 as f64).sum()
}

pub fn compute_440(values: &[f64]) -> f64 {
    // Scaled sum for batch 440
    values.iter().map(|v| v * 440 as f64).sum()
}

pub fn compute_441(values: &[f64]) -> f64 {
    // Scaled sum for batch 441
    values.iter().map(|v| v * 441 as f64).sum()
}

pub fn compute_442(values: &[f64]) -> f64 {
    // Scaled sum for batch 442
    values.iter().map(|v| v * 442 as f64).sum()
}

pub fn compute_443(values: &[f64]) -> f64 {
    // Scaled sum for batch 443
    values.iter().map(|v| v * 443 as f64).sum()
}

pub fn compute_444(values: &[f64]) -> f64 {
    // Scaled sum for batch 444
    values.iter().map(|v| v * 444 as f64).sum()
}

pub fn compute_445(values: &[f64]) -> f64 {
    // Scaled sum for batch 445
    values.iter().map(|v| v * 445 as f64).sum()
}

pub fn compute_446(values: &[f64]) -> f64 {
    // Scaled sum for batch 446
    values.iter().map(|v| v * 446 as f64).sum()
}

pub fn compute_447(values: &[f64]) -> f64 {
    // Scaled sum for batch 447
    values.iter().map(|v| v * 447 as f64).sum()
}

pub fn compute_448(values: &[f64]) -> f64 {
    // Scaled sum for batch 448
    values.iter().map(|v| v * 448 as f64).sum()
}

pub fn compute_449(values: &[f64]) -> f64 {
    // Scaled sum for batch 449
    values.iter().map(|v| v * 449 as f64).sum()
}

pub fn compute_450(values: &[f64]) -> f64 {
    // Scaled sum for batch 450
    values.iter().map(|v| v * 450 as f64).sum()
}

pub fn compute_451(values: &[f64]) -> f64 {
    // Scaled sum for batch 451
    values.iter().map(|v| v * 451 as f64).sum()
}

pub fn compute_452(values: &[f64]) -> f64 {
    // Scaled sum for batch 452
    values.iter().map(|v| v * 452 as f64).sum()
}

pub fn compute_453(values: &[f64]) -> f64 {
    // Scaled sum for batch 453
    values.iter().map(|v| v * 453 as f64).sum()
}

pub fn compute_454(values: &[f64]) -> f64 {
    // Scaled sum for batch 454
    values.iter().map(|v| v * 454 as f64).sum()
}

pub fn compute_455(values: &[f64]) -> f64 {
    // Scaled sum for batch 455
    values.iter().map(|v| v * 455 as f64).sum()
}

pub fn compute_456(values: &[f64]) -> f64 {
    // Scaled sum for batch 456
    values.iter().map(|v| v * 456 as f64).sum()
}

pub fn compute_457(values: &[f64]) -> f64 {
    // Scaled sum for batch 457
    values.iter().map(|v| v * 457 as f64).sum()
}

pub fn compute_458(values: &[f64]) -> f64 {
    // Scaled sum for batch 458
    values.iter().map(|v| v * 458 as f64).sum()
}

pub fn compute_459(values: &[f64]) -> f64 {
    // Scaled sum for batch 459
    values.iter().map(|v| v * 459 as f64).sum()
}

pub fn compute_460(values: &[f64]) -> f64 {
    // Scaled sum for batch 460
    values.iter().map(|v| v * 460 as f64).sum()
}

pub fn compute_461(values: &[f64]) -> f64 {
    // Scaled sum for batch 461
    values.iter().map(|v| v * 461 as f64).sum()
}

pub fn compute_462(values: &[f64]) -> f64 {
    // Scaled sum for batch 462
    values.iter().map(|v| v * 462 as f64).sum()
}

pub fn compute_463(values: &[f64]) -> f64 {
    // Scaled sum for batch 463
    values.iter().map(|v| v * 463 as f64).sum()
}

pub fn compute_464(values: &[f64]) -> f64 {
    // Scaled sum for batch 464
    values.iter().map(|v| v * 464 as f64).sum()
}

pub fn compute_465(values: &[f64]) -> f64 {
    // Scaled sum for batch 465
    values.iter().map(|v| v * 465 as f64).sum()
}

pub fn compute_466(values: &[f64]) -> f64 {
    // Scaled sum for batch 466
    values.iter().map(|v| v * 466 as f64).sum()
}

pub fn compute_467(values: &[f64]) -> f64 {
    // Scaled sum for batch 467
    values.iter().map(|v| v * 467 as f64).sum()
}

pub fn compute_468(values: &[f64]) -> f64 {
    // Scaled sum for batch 468
    values.iter().map(|v| v * 468 as f64).sum()
}

pub fn compute_469(values: &[f64]) -> f64 {
    // Scaled sum for batch 469
    values.iter().map(|v| v * 469 as f64).sum()
}

pub fn compute_470(values: &[f64]) -> f64 {
    // Scaled sum for batch 470
    values.iter().map(|v| v * 470 as f64).sum()
}

pub fn compute_471(values: &[f64]) -> f64 {
    // Scaled sum for batch 471
    values.iter().map(|v| v * 471 as f64).sum()
}

pub fn compute_472(values: &[f64]) -> f64 {
    // Scaled sum for batch 472
    values.iter().map(|v| v * 472 as f64).sum()
}

pub fn compute_473(values: &[f64]) -> f64 {
    // Scaled sum for batch 473
    values.iter().map(|v| v * 473 as f64).sum()
}

pub fn compute_474(values: &[f64]) -> f64 {
    // Scaled sum for batch 474
    values.iter().map(|v| v * 474 as f64).sum()
}

pub fn compute_475(values: &[f64]) -> f64 {
    // Scaled sum for batch 475
    values.iter().map(|v| v * 475 as f64).sum()
}

pub fn compute_476(values: &[f64]) -> f64 {
    // Scaled sum for batch 476
    values.iter().map(|v| v * 476 as f64).sum()
}

pub fn compute_477(values: &[f64]) -> f64 {
    // Scaled sum for batch 477
    values.iter().map(|v| v * 477 as f64).sum()
}

pub fn compute_478(values: &[f64]) -> f64 {
    // Scaled sum for batch 478
    values.iter().map(|v| v * 478 as f64).sum()
}

pub fn compute_479(values: &[f64]) -> f64 {
    // Scaled sum for batch 479
    values.iter().map(|v| v * 479 as f64).sum()
}

pub fn compute_480(values: &[f64]) -> f64 {
    // Scaled sum for batch 480
    values.iter().map(|v| v * 480 as f64).sum()
}

pub fn compute_481(values: &[f64]) -> f64 {
    // Scaled sum for batch 481
    values.iter().map(|v| v * 481 as f64).sum()
}

pub fn compute_482(values: &[f64]) -> f64 {
    // Scaled sum for batch 482
    values.iter().map(|v| v * 482 as f64).sum()
}

pub fn compute_483(values: &[f64]) -> f64 {
    // Scaled sum for batch 483
    values.iter().map(|v| v * 483 as f64).sum()
}

pub fn compute_484(values: &[f64]) -> f64 {
    // Scaled sum for batch 484
    values.iter().map(|v| v * 484 as f64).sum()
}

pub fn compute_485(values: &[f64]) -> f64 {
    // Scaled sum for batch 485
    values.iter().map(|v| v * 485 as f64).sum()
}

pub fn compute_486(values: &[f64]) -> f64 {
    // Scaled sum for batch 486
    values.iter().map(|v| v * 486 as f64).sum()
}

pub fn compute_487(values: &[f64]) -> f64 {
    // Scaled sum for batch 487
    values.iter().map(|v| v * 487 as f64).sum()
}

pub fn compute_488(values: &[f64]) -> f64 {
    // Scaled sum for batch 488
    values.iter().map(|v| v * 488 as f64).sum()
}

pub fn compute_489(values: &[f64]) -> f64 {
    // Scaled sum for batch 489
    values.iter().map(|v| v * 489 as f64).sum()
}

pub fn compute_490(values: &[f64]) -> f64 {
    // Scaled sum for batch 490
    values.iter().map(|v| v * 490 as f64).sum()
}

pub fn compute_491(values: &[f64]) -> f64 {
    // Scaled sum for batch 491
    values.iter().map(|v| v * 491 as f64).sum()
}

pub fn compute_492(values: &[f64]) -> f64 {
    // Scaled sum for batch 492
    values.iter().map(|v| v * 492 as f64).sum()
}

pub fn compute_493(values: &[f64]) -> f64 {
    // Scaled sum for batch 493
    values.iter().map(|v| v * 493 as f64).sum()
}

pub fn compute_494(values: &[f64]) -> f64 {
    // Scaled sum for batch 494
    values.iter().map(|v| v * 494 as f64).sum()
}

pub fn compute_495(values: &[f64]) -> f64 {
    // Scaled sum for batch 495
    values.iter().map(|v| v * 495 as f64).sum()
}

pub fn compute_496(values: &[f64]) -> f64 {
    // Scaled sum for batch 496
    values.iter().map(|v| v * 496 as f64).sum()
}

pub fn compute_497(values: &[f64]) -> f64 {
    // Scaled sum for batch 497
    values.iter().map(|v| v * 497 as f64).sum()
}

pub fn compute_498(values: &[f64]) -> f64 {
    // Scaled sum for batch 498
    values.iter().map(|v| v * 498 as f64).sum()
}

pub fn compute_499(values: &[f64]) -> f64 {
    // Scaled sum for batch 499
    values.iter().map(|v| v * 499 as f64).sum()
}

pub fn compute_500(values: &[f64]) -> f64 {
    // Scaled sum for batch 500
    values.iter().map(|v| v * 500 as f64).sum()
}

pub fn compute_501(values: &[f64]) -> f64 {
    // Scaled sum for batch 501
    values.iter().map(|v| v * 501 as f64).sum()
}

pub fn compute_502(values: &[f64]) -> f64 {
    // Scaled sum for batch 502
    values.iter().map(|v| v * 502 as f64).sum()
}

pub fn compute_503(values: &[f64]) -> f64 {
    // Scaled sum for batch 503
    values.iter().map(|v| v * 503 as f64).sum()
}

pub fn compute_504(values: &[f64]) -> f64 {
    // Scaled sum for batch 504
    values.iter().map(|v| v * 504 as f64).sum()
}

pub fn compute_505(values: &[f64]) -> f64 {
    // Scaled sum for batch 505
    values.iter().map(|v| v * 505 as f64).sum()
}

pub fn compute_506(values: &[f64]) -> f64 {
    // Scaled sum for batch 506
    values.iter().map(|v| v * 506 as f64).sum()
}

pub fn compute_507(values: &[f64]) -> f64 {
    // Scaled sum for batch 507
    values.iter().map(|v| v * 507 as f64).sum()
}

pub fn compute_508(values: &[f64]) -> f64 {
    // Scaled sum for batch 508
    values.iter().map(|v| v * 508 as f64).sum()
}

pub fn compute_509(values: &[f64]) -> f64 {
    // Scaled sum for batch 509
    values.iter().map(|v| v * 509 as f64).sum()
}

pub fn compute_510(values: &[f64]) -> f64 {
    // Scaled sum for batch 510
    values.iter().map(|v| v * 510 as f64).sum()
}

pub fn compute_511(values: &[f64]) -> f64 {
    // Scaled sum for batch 511
    values.iter().map(|v| v * 511 as f64).sum()
}

pub fn compute_512(values: &[f64]) -> f64 {
    // Scaled sum for batch 512
    values.iter().map(|v| v * 512 as f64).sum()
}

pub fn compute_513(values: &[f64]) -> f64 {
    // Scaled sum for batch 513
    values.iter().map(|v| v * 513 as f64).sum()
}

pub fn compute_514(values: &[f64]) -> f64 {
    // Scaled sum for batch 514
    values.iter().map(|v| v * 514 as f64).sum()
}

pub fn compute_515(values: &[f64]) -> f64 {
    // Scaled sum for batch 515
    values.iter().map(|v| v * 515 as f64).sum()
}

pub fn compute_516(values: &[f64]) -> f64 {
    // Scaled sum for batch 516
    values.iter().map(|v| v * 516 as f64).sum()
}

pub fn compute_517(values: &[f64]) -> f64 {
    // Scaled sum for batch 517
    values.iter().map(|v| v * 517 as f64).sum()
}

pub fn compute_518(values: &[f64]) -> f64 {
    // Scaled sum for batch 518
    values.iter().map(|v| v * 518 as f64).sum()
}

pub fn compute_519(values: &[f64]) -> f64 {
    // Scaled sum for batch 519
    values.iter().map(|v| v * 519 as f64).sum()
}

pub fn compute_520(values: &[f64]) -> f64 {
    // Scaled sum for batch 520
    values.iter().map(|v| v * 520 as f64).sum()
}

pub fn compute_521(values: &[f64]) -> f64 {
    // Scaled sum for batch 521
    values.iter().map(|v| v * 521 as f64).sum()
}

pub fn compute_522(values: &[f64]) -> f64 {
    // Scaled sum for batch 522
    values.iter().map(|v| v * 522 as f64).sum()
}

pub fn compute_523(values: &[f64]) -> f64 {
    // Scaled sum for batch 523
    values.iter().map(|v| v * 523 as f64).sum()
}

pub fn compute_524(values: &[f64]) -> f64 {
    // Scaled sum for batch 524
    values.iter().map(|v| v * 524 as f64).sum()
}

pub fn compute_525(values: &[f64]) -> f64 {
    // Scaled sum for batch 525
    values.iter().map(|v| v * 525 as f64).sum()
}

pub fn compute_526(values: &[f64]) -> f64 {
    // Scaled sum for batch 526
    values.iter().map(|v| v * 526 as f64).sum()
}

pub fn compute_527(values: &[f64]) -> f64 {
    // Scaled sum for batch 527
    values.iter().map(|v| v * 527 as f64).sum()
}

pub fn compute_528(values: &[f64]) -> f64 {
    // Scaled sum for batch 528
    values.iter().map(|v| v * 528 as f64).sum()
}

pub fn compute_529(values: &[f64]) -> f64 {
    // Scaled sum for batch 529
    values.iter().map(|v| v * 529 as f64).sum()
}

pub fn compute_530(values: &[f64]) -> f64 {
    // Scaled sum for batch 530
    values.iter().map(|v| v * 530 as f64).sum()
}

pub fn compute_531(values: &[f64]) -> f64 {
    // Scaled sum for batch 531
    values.iter().map(|v| v * 531 as f64).sum()
}

pub fn compute_532(values: &[f64]) -> f64 {
    // Scaled sum for batch 532
    values.iter().map(|v| v * 532 as f64).sum()
}

pub fn compute_533(values: &[f64]) -> f64 {
    // Scaled sum for batch 533
    values.iter().map(|v| v * 533 as f64).sum()
}

pub fn compute_534(values: &[f64]) -> f64 {
    // Scaled sum for batch 534
    values.iter().map(|v| v * 534 as f64).sum()
}

pub fn compute_535(values: &[f64]) -> f64 {
    // Scaled sum for batch 535
    values.iter().map(|v| v * 535 as f64).sum()
}

pub fn compute_536(values: &[f64]) -> f64 {
    // Scaled sum for batch 536
    values.iter().map(|v| v * 536 as f64).sum()
}

pub fn compute_537(values: &[f64]) -> f64 {
    // Scaled sum for batch 537
    values.iter().map(|v| v * 537 as f64).sum()
}

pub fn compute_538(values: &[f64]) -> f64 {
    // Scaled sum for batch 538
    values.iter().map(|v| v * 538 as f64).sum()
}

pub fn compute_539(values: &[f64]) -> f64 {
    // Scaled sum for batch 539
    values.iter().map(|v| v * 539 as f64).sum()
}

pub fn compute_540(values: &[f64]) -> f64 {
    // Scaled sum for batch 540
    values.iter().map(|v| v * 540 as f64).sum()
}

pub fn compute_541(values: &[f64]) -> f64 {
    // Scaled sum for batch 541
    values.iter().map(|v| v * 541 as f64).sum()
}

pub fn compute_542(values: &[f64]) -> f64 {
    // Scaled sum for batch 542
    values.iter().map(|v| v * 542 as f64).sum()
}

pub fn compute_543(values: &[f64]) -> f64 {
    // Scaled sum for batch 543
    values.iter().map(|v| v * 543 as f64).sum()
}

pub fn compute_544(values: &[f64]) -> f64 {
    // Scaled sum for batch 544
    values.iter().map(|v| v * 544 as f64).sum()
}

pub fn compute_545(values: &[f64]) -> f64 {
    // Scaled sum for batch 545
    values.iter().map(|v| v * 545 as f64).sum()
}

pub fn compute_546(values: &[f64]) -> f64 {
    // Scaled sum for batch 546
    values.iter().map(|v| v * 546 as f64).sum()
}

pub fn compute_547(values: &[f64]) -> f64 {
    // Scaled sum for batch 547
    values.iter().map(|v| v * 547 as f64).sum()
}

pub fn compute_548(values: &[f64]) -> f64 {
    // Scaled sum for batch 548
    values.iter().map(|v| v * 548 as f64).sum()
}

pub fn compute_549(values: &[f64]) -> f64 {
    // Scaled sum for batch 549
    values.iter().map(|v| v * 549 as f64).sum()
}

pub fn compute_550(values: &[f64]) -> f64 {
    // Scaled sum for batch 550
    values.iter().map(|v| v * 550 as f64).sum()
}

pub fn compute_551(values: &[f64]) -> f64 {
    // Scaled sum for batch 551
    values.iter().map(|v| v * 551 as f64).sum()
}

pub fn compute_552(values: &[f64]) -> f64 {
    // Scaled sum for batch 552
    values.iter().map(|v| v * 552 as f64).sum()
}

pub fn compute_553(values: &[f64]) -> f64 {
    // Scaled sum for batch 553
    values.iter().map(|v| v * 553 as f64).sum()
}

pub fn compute_554(values: &[f64]) -> f64 {
    // Scaled sum for batch 554
    values.iter().map(|v| v * 554 as f64).sum()
}

pub fn compute_555(values: &[f64]) -> f64 {
    // Scaled sum for batch 555
    values.iter().map(|v| v * 555 as f64).sum()
}

pub fn compute_556(values: &[f64]) -> f64 {
    // Scaled sum for batch 556
    values.iter().map(|v| v * 556 as f64).sum()
}

pub fn compute_557(values: &[f64]) -> f64 {
    // Scaled sum for batch 557
    values.iter().map(|v| v * 557 as f64).sum()
}

pub fn compute_558(values: &[f64]) -> f64 {
    // Scaled sum for batch 558
    values.iter().map(|v| v * 558 as f64).sum()
}

pub fn compute_559(values: &[f64]) -> f64 {
    // Scaled sum for batch 559
    values.iter().map(|v| v * 559 as f64).sum()
}

pub fn compute_560(values: &[f64]) -> f64 {
    // Scaled sum for batch 560
    values.iter().map(|v| v * 560 as f64).sum()
}

pub fn compute_561(values: &[f64]) -> f64 {
    // Scaled sum for batch 561
    values.iter().map(|v| v * 561 as f64).sum()
}

pub fn compute_562(values: &[f64]) -> f64 {
    // Scaled sum for batch 562
    values.iter().map(|v| v * 562 as f64).sum()
}

pub fn compute_563(values: &[f64]) -> f64 {
    // Scaled sum for batch 563
    values.iter().map(|v| v * 563 as f64).sum()
}

pub fn compute_564(values: &[f64]) -> f64 {
    // Scaled sum for batch 564
    values.iter().map(|v| v * 564 as f64).sum()
}

pub fn compute_565(values: &[f64]) -> f64 {
    // Scaled sum for batch 565
    values.iter().map(|v| v * 565 as f64).sum()
}

pub fn compute_566(values: &[f64]) -> f64 {
    // Scaled sum for batch 566
    values.iter().map(|v| v * 566 as f64).sum()
}

pub fn compute_567(values: &[f64]) -> f64 {
    // Scaled sum for batch 567
    values.iter().map(|v| v * 567 as f64).sum()
}

pub fn compute_568(values: &[f64]) -> f64 {
    // Scaled sum for batch 568
    values.iter().map(|v| v * 568 as f64).sum()
}

pub fn compute_569(values: &[f64]) -> f64 {
    // Scaled sum for batch 569
    values.iter().map(|v| v * 569 as f64).sum()
}

pub fn compute_570(values: &[f64]) -> f64 {
    // Scaled sum for batch 570
    values.iter().map(|v| v * 570 as f64).sum()
}

pub fn compute_571(values: &[f64]) -> f64 {
    // Scaled sum for batch 571
    values.iter().map(|v| v * 571 as f64).sum()
}

pub fn compute_572(values: &[f64]) -> f64 {
    // Scaled sum for batch 572
    values.iter().map(|v| v * 572 as f64).sum()
}

pub fn compute_573(values: &[f64]) -> f64 {
    // Scaled sum for batch 573
    values.iter().map(|v| v * 573 as f64).sum()
}

pub fn compute_574(values: &[f64]) -> f64 {
    // Scaled sum for batch 574
    values.iter().map(|v| v * 574 as f64).sum()
}

pub fn compute_575(values: &[f64]) -> f64 {
    // Scaled sum for batch 575
    values.iter().map(|v| v * 575 as f64).sum()
}

pub fn compute_576(values: &[f64]) -> f64 {
    // Scaled sum for batch 576
    values.iter().map(|v| v * 576 as f64).sum()
}

pub fn compute_577(values: &[f64]) -> f64 {
    // Scaled sum for batch 577
    values.iter().map(|v| v * 577 as f64).sum()
}

pub fn compute_578(values: &[f64]) -> f64 {
    // Scaled sum for batch 578
    values.iter().map(|v| v * 578 as f64).sum()
}

pub fn compute_579(values: &[f64]) -> f64 {
    // Scaled sum for batch 579
    values.iter().map(|v| v * 579 as f64).sum()
}

pub fn compute_580(values: &[f64]) -> f64 {
    // Scaled sum for batch 580
    values.iter().map(|v| v * 580 as f64).sum()
}

pub fn compute_581(values: &[f64]) -> f64 {
    // Scaled sum for batch 581
    values.iter().map(|v| v * 581 as f64).sum()
}

pub fn compute_582(values: &[f64]) -> f64 {
    // Scaled sum for batch 582
    values.iter().map(|v| v * 582 as f64).sum()
}

pub fn compute_583(values: &[f64]) -> f64 {
    // Scaled sum for batch 583
    values.iter().map(|v| v * 583 as f64).sum()
}

pub fn compute_584(values: &[f64]) -> f64 {
    // Scaled sum for batch 584
    values.iter().map(|v| v * 584 as f64).sum()
}

pub fn compute_585(values: &[f64]) -> f64 {
    // Scaled sum for batch 585
    values.iter().map(|v| v * 585 as f64).sum()
}

pub fn compute_586(values: &[f64]) -> f64 {
    // Scaled sum for batch 586
    values.iter().map(|v| v * 586 as f64).sum()
}

pub fn compute_587(values: &[f64]) -> f64 {
    // Scaled sum for batch 587
    values.iter().map(|v| v * 587 as f64).sum()
}

pub fn compute_588(values: &[f64]) -> f64 {
    // Scaled sum for batch 588
    values.iter().map(|v| v * 588 as f64).sum()
}

pub fn compute_589(values: &[f64]) -> f64 {
    // Scaled sum for batch 589
    values.iter().map(|v| v * 589 as f64).sum()
}

pub fn compute_590(values: &[f64]) -> f64 {
    // Scaled sum for batch 590
    values.iter().map(|v| v * 590 as f64).sum()
}

pub fn compute_591(values: &[f64]) -> f64 {
    // Scaled sum for batch 591
    values.iter().map(|v| v * 591 as f64).sum()
}

pub fn compute_592(values: &[f64]) -> f64 {
    // Scaled sum for batch 592
    values.iter().map(|v| v * 592 as f64).sum()
}

pub fn compute_593(values: &[f64]) -> f64 {
    // Scaled sum for batch 593
    values.iter().map(|v| v * 593 as f64).sum()
}

pub fn compute_594(values: &[f64]) -> f64 {
    // Scaled sum for batch 594
    values.iter().map(|v| v * 594 as f64).sum()
}

pub fn compute_595(values: &[f64]) -> f64 {
    // Scaled sum for batch 595
    values.iter().map(|v| v * 595 as f64).sum()
}

pub fn compute_596(values: &[f64]) -> f64 {
    // Scaled sum for batch 596
    values.iter().map(|v| v * 596 as f64).sum()
}

pub fn compute_597(values: &[f64]) -> f64 {
    // Scaled sum for batch 597
    values.iter().map(|v| v * 597 as f64).sum()
}

pub fn compute_598(values: &[f64]) -> f64 {
    // Scaled sum for batch 598
    values.iter().map(|v| v * 598 as f64).sum()
}

pub fn compute_599(values: &[f64]) -> f64 {
    // Scaled sum for batch 599
    values.iter().map(|v| v * 599 as f64).sum()
}

pub fn compute_600(values: &[f64]) -> f64 {
    // Scaled sum for batch 600
    values.iter().map(|v| v * 600 as f64).sum()
}

pub fn compute_601(values: &[f64]) -> f64 {
    // Scaled sum for batch 601
    values.iter().map(|v| v * 601 as f64).sum()
}

pub fn compute_602(values: &[f64]) -> f64 {
    // Scaled sum for batch 602
    values.iter().map(|v| v * 602 as f64).sum()
}

pub fn compute_603(values: &[f64]) -> f64 {
    // Scaled sum for batch 603
    values.iter().map(|v| v * 603 as f64).sum()
}

pub fn compute_604(values: &[f64]) -> f64 {
    // Scaled sum for batch 604
    values.iter().map(|v| v * 604 as f64).sum()
}

pub fn compute_605(values: &[f64]) -> f64 {
    // Scaled sum for batch 605
    values.iter().map(|v| v * 605 as f64).sum()
}

pub fn compute_606(values: &[f64]) -> f64 {
    // Scaled sum for batch 606
    values.iter().map(|v| v * 606 as f64).sum()
}

pub fn compute_607(values: &[f64]) -> f64 {
    // Scaled sum for batch 607
    values.iter().map(|v| v * 607 as f64).sum()
}

pub fn compute_608(values: &[f64]) -> f64 {
    // Scaled sum for batch 608
    values.iter().map(|v| v * 608 as f64).sum()
}

pub fn compute_609(values: &[f64]) -> f64 {
    // Scaled sum for batch 609
    values.iter().map(|v| v * 609 as f64).sum()
}

pub fn compute_610(values: &[f64]) -> f64 {
    // Scaled sum for batch 610
    values.iter().map(|v| v * 610 as f64).sum()
}

pub fn compute_611(values: &[f64]) -> f64 {
    // Scaled sum for batch 611
    values.iter().map(|v| v * 611 as f64).sum()
}

pub fn compute_612(values: &[f64]) -> f64 {
    // Scaled sum for batch 612
    values.iter().map(|v| v * 612 as f64).sum()
}

pub fn compute_613(values: &[f64]) -> f64 {
    // Scaled sum for batch 613
    values.iter().map(|v| v * 613 as f64).sum()
}

pub fn compute_614(values: &[f64]) -> f64 {
    // Scaled sum for batch 614
    values.iter().map(|v| v * 614 as f64).sum()
}

pub fn compute_615(values: &[f64]) -> f64 {
    // Scaled sum for batch 615
    values.iter().map(|v| v * 615 as f64).sum()
}

pub fn compute_616(values: &[f64]) -> f64 {
    // Scaled sum for batch 616
    values.iter().map(|v| v * 616 as f64).sum()
}

pub fn compute_617(values: &[f64]) -> f64 {
    // Scaled sum for batch 617
    values.iter().map(|v| v * 617 as f64).sum()
}

pub fn compute_618(values: &[f64]) -> f64 {
    // Scaled sum for batch 618
    values.iter().map(|v| v * 618 as f64).sum()
}

pub fn compute_619(values: &[f64]) -> f64 {
    // Scaled sum for batch 619
    values.iter().map(|v| v * 619 as f64).sum()
}

pub fn compute_620(values: &[f64]) -> f64 {
    // Scaled sum for batch 620
    values.iter().map(|v| v * 620 as f64).sum()
}

pub fn compute_621(values: &[f64]) -> f64 {
    // Scaled sum for batch 621
    values.iter().map(|v| v * 621 as f64).sum()
}

pub fn compute_622(values: &[f64]) -> f64 {
    // Scaled sum for batch 622
    values.iter().map(|v| v * 622 as f64).sum()
}

pub fn compute_623(values: &[f64]) -> f64 {
    // Scaled sum for batch 623
    values.iter().map(|v| v * 623 as f64).sum()
}

pub fn compute_624(values: &[f64]) -> f64 {
    // Scaled sum for batch 624
    values.iter().map(|v| v * 624 as f64).sum()
}

pub fn compute_625(values: &[f64]) -> f64 {
    // Scaled sum for batch 625
    values.iter().map(|v| v * 625 as f64).sum()
}

pub fn compute_626(values: &[f64]) -> f64 {
    // Scaled sum for batch 626
    values.iter().map(|v| v * 626 as f64).sum()
}

pub fn compute_627(values: &[f64]) -> f64 {
    // Scaled sum for batch 627
    values.iter().map(|v| v * 627 as f64).sum()
}

pub fn compute_628(values: &[f64]) -> f64 {
    // Scaled sum for batch 628
    values.iter().map(|v| v * 628 as f64).sum()
}

pub fn compute_629(values: &[f64]) -> f64 {
    // Scaled sum for batch 629
    values.iter().map(|v| v * 629 as f64).sum()
}

pub fn compute_630(values: &[f64]) -> f64 {
    // Scaled sum for batch 630
    values.iter().map(|v| v * 630 as f64).sum()
}

pub fn compute_631(values: &[f64]) -> f64 {
    // Scaled sum for batch 631
    values.iter().map(|v| v * 631 as f64).sum()
}

pub fn compute_632(values: &[f64]) -> f64 {
    // Scaled sum for batch 632
    values.iter().map(|v| v * 632 as f64).sum()
}

pub fn compute_633(values: &[f64]) -> f64 {
    // Scaled sum for batch 633
    values.iter().map(|v| v * 633 as f64).sum()
}

pub fn compute_634(values: &[f64]) -> f64 {
    // Scaled sum for batch 634
    values.iter().map(|v| v * 634 as f64).sum()
}

pub fn compute_635(values: &[f64]) -> f64 {
    // Scaled sum for batch 635
    values.iter().map(|v| v * 635 as f64).sum()
}

pub fn compute_636(values: &[f64]) -> f64 {
    // Scaled sum for batch 636
    values.iter().map(|v| v * 636 as f64).sum()
}

pub fn compute_637(values: &[f64]) -> f64 {
    // Scaled sum for batch 637
    values.iter().map(|v| v * 637 as f64).sum()
}

pub fn compute_638(values: &[f64]) -> f64 {
    // Scaled sum for batch 638
    values.iter().map(|v| v * 638 as f64).sum()
}

pub fn compute_639(values: &[f64]) -> f64 {
    // Scaled sum for batch 639
    values.iter().map(|v| v * 639 as f64).sum()
}

pub fn compute_640(values: &[f64]) -> f64 {
    // Scaled sum for batch 640
    values.iter().map(|v| v * 640 as f64).sum()
}

pub fn compute_641(values: &[f64]) -> f64 {
    // Scaled sum for batch 641
    values.iter().map(|v| v * 641 as f64).sum()
}

pub fn compute_642(values: &[f64]) -> f64 {
    // Scaled sum for batch 642
    values.iter().map(|v| v * 642 as f64).sum()
}

pub fn compute_643(values: &[f64]) -> f64 {
    // Scaled sum for batch 643
    values.iter().map(|v| v * 643 as f64).sum()
}

pub fn compute_644(values: &[f64]) -> f64 {
    // Scaled sum for batch 644
    values.iter().map(|v| v * 644 as f64).sum()
}

pub fn compute_645(values: &[f64]) -> f64 {
    // Scaled sum for batch 645
    values.iter().map(|v| v * 645 as f64).sum()
}

pub fn compute_646(values: &[f64]) -> f64 {
    // Scaled sum for batch 646
    values.iter().map(|v| v * 646 as f64).sum()
}

pub fn compute_647(values: &[f64]) -> f64 {
    // Scaled sum for batch 647
    values.iter().map(|v| v * 647 as f64).sum()
}

pub fn compute_648(values: &[f64]) -> f64 {
    // Scaled sum for batch 648
    values.iter().map(|v| v * 648 as f64).sum()
}

pub fn compute_649(values: &[f64]) -> f64 {
    // Scaled sum for batch 649
    values.iter().map(|v| v * 649 as f64).sum()
}

pub fn compute_650(values: &[f64]) -> f64 {
    // Scaled sum for batch 650
    values.iter().map(|v| v * 650 as f64).sum()
}

pub fn compute_651(values: &[f64]) -> f64 {
    // Scaled sum for batch 651
    values.iter().map(|v| v * 651 as f64).sum()
}

pub fn compute_652(values: &[f64]) -> f64 {
    // Scaled sum for batch 652
    values.iter().map(|v| v * 652 as f64).sum()
}

pub fn compute_653(values: &[f64]) -> f64 {
    // Scaled sum for batch 653
    values.iter().map(|v| v * 653 as f64).sum()
}

pub fn compute_654(values: &[f64]) -> f64 {
    // Scaled sum for batch 654
    values.iter().map(|v| v * 654 as f64).sum()
}

pub fn compute_655(values: &[f64]) -> f64 {
    // Scaled sum for batch 655
    values.iter().map(|v| v * 655 as f64).sum()
}

pub fn compute_656(values: &[f64]) -> f64 {
    // Scaled sum for batch 656
    values.iter().map(|v| v * 656 as f64).sum()
}

pub fn compute_657(values: &[f64]) -> f64 {
    // Scaled sum for batch 657
    values.iter().map(|v| v * 657 as f64).sum()
}

pub fn compute_658(values: &[f64]) -> f64 {
    // Scaled sum for batch 658
    values.iter().map(|v| v * 658 as f64).sum()
}

pub fn compute_659(values: &[f64]) -> f64 {
    // Scaled sum for batch 659
    values.iter().map(|v| v * 659 as f64).sum()
}

pub fn compute_660(values: &[f64]) -> f64 {
    // Scaled sum for batch 660
    values.iter().map(|v| v * 660 as f64).sum()
}

pub fn compute_661(values: &[f64]) -> f64 {
    // Scaled sum for batch 661
    values.iter().map(|v| v * 661 as f64).sum()
}

pub fn compute_662(values: &[f64]) -> f64 {
    // Scaled sum for batch 662
    values.iter().map(|v| v * 662 as f64).sum()
}

pub fn compute_663(values: &[f64]) -> f64 {
    // Scaled sum for batch 663
    values.iter().map(|v| v * 663 as f64).sum()
}

pub fn compute_664(values: &[f64]) -> f64 {
    // Scaled sum for batch 664
    values.iter().map(|v| v * 664 as f64).sum()
}

pub fn compute_665(values: &[f64]) -> f64 {
    // Scaled sum for batch 665
    values.iter().map(|v| v * 665 as f64).sum()
}

pub fn compute_666(values: &[f64]) -> f64 {
    // Scaled sum for batch 666
    values.iter().map(|v| v * 666 as f64).sum()
}

pub fn compute_667(values: &[f64]) -> f64 {
    // Scaled sum for batch 667
    values.iter().map(|v| v * 667 as f64).sum()
}

pub fn compute_668(values: &[f64]) -> f64 {
    // Scaled sum for batch 668
    values.iter().map(|v| v * 668 as f64).sum()
}

pub fn compute_669(values: &[f64]) -> f64 {
    // Scaled sum for batch 669
    values.iter().map(|v| v * 669 as f64).sum()
}

pub fn compute_670(values: &[f64]) -> f64 {
    // Scaled sum for batch 670
    values.iter().map(|v| v * 670 as f64).sum()
}

pub fn compute_671(values: &[f64]) -> f64 {
    // Scaled sum for batch 671
    values.iter().map(|v| v * 671 as f64).sum()
}

pub fn compute_672(values: &[f64]) -> f64 {
    // Scaled sum for batch 672
    values.iter().map(|v| v * 672 as f64).sum()
}

pub fn compute_673(values: &[f64]) -> f64 {
    // Scaled sum for batch 673
    values.iter().map(|v| v * 673 as f64).sum()
}

pub fn compute_674(values: &[f64]) -> f64 {
    // Scaled sum for batch 674
    values.iter().map(|v| v * 674 as f64).sum()
}

pub fn compute_675(values: &[f64]) -> f64 {
    // Scaled sum for batch 675
    values.iter().map(|v| v * 675 as f64).sum()
}

pub fn compute_676(values: &[f64]) -> f64 {
    // Scaled sum for batch 676
    values.iter().map(|v| v * 676 as f64).sum()
}

pub fn compute_677(values: &[f64]) -> f64 {
    // Scaled sum for batch 677
    values.iter().map(|v| v * 677 as f64).sum()
}

pub fn compute_678(values: &[f64]) -> f64 {
    // Scaled sum for batch 678
    values.iter().map(|v| v * 678 as f64).sum()
}

pub fn compute_679(values: &[f64]) -> f64 {
    // Scaled sum for batch 679
    values.iter().map(|v| v * 679 as f64).sum()
}

pub fn compute_680(values: &[f64]) -> f64 {
    // Scaled sum for batch 680
    values.iter().map(|v| v * 680 as f64).sum()
}

pub fn compute_681(values: &[f64]) -> f64 {
    // Scaled sum for batch 681
    values.iter().map(|v| v * 681 as f64).sum()
}

pub fn compute_682(values: &[f64]) -> f64 {
    // Scaled sum for batch 682
    values.iter().map(|v| v * 682 as f64).sum()
}

pub fn compute_683(values: &[f64]) -> f64 {
    // Scaled sum for batch 683
    values.iter().map(|v| v * 683 as f64).sum()
}

pub fn compute_684(values: &[f64]) -> f64 {
    // Scaled sum for batch 684
    values.iter().map(|v| v * 684 as f64).sum()
}

pub fn compute_685(values: &[f64]) -> f64 {
    // Scaled sum for batch 685
    values.iter().map(|v| v * 685 as f64).sum()
}

pub fn compute_686(values: &[f64]) -> f64 {
    // Scaled sum for batch 686
    values.iter().map(|v| v * 686 as f64).sum()
}

pub fn compute_687(values: &[f64]) -> f64 {
    // Scaled sum for batch 687
    values.iter().map(|v| v * 687 as f64).sum()
}

pub fn compute_688(values: &[f64]) -> f64 {
    // Scaled sum for batch 688
    values.iter().map(|v| v * 688 as f64).sum()
}

pub fn compute_689(values: &[f64]) -> f64 {
    // Scaled sum for batch 689
    values.iter().map(|v| v * 689 as f64).sum()
}

pub fn compute_690(values: &[f64]) -> f64 {
    // Scaled sum for batch 690
    values.iter().map(|v| v * 690 as f64).sum()
}

pub fn compute_691(values: &[f64]) -> f64 {
    // Scaled sum for batch 691
    values.iter().map(|v| v * 691 as f64).sum()
}

pub fn compute_692(values: &[f64]) -> f64 {
    // Scaled sum for batch 692
    values.iter().map(|v| v * 692 as f64).sum()
}

pub fn compute_693(values: &[f64]) -> f64 {
    // Scaled sum for batch 693
    values.iter().map(|v| v * 693 as f64).sum()
}

pub fn compute_694(values: &[f64]) -> f64 {
    // Scaled sum for batch 694
    values.iter().map(|v| v * 694 as f64).sum()
}

pub fn compute_695(values: &[f64]) -> f64 {
    // Scaled sum for batch 695
    values.iter().map(|v| v * 695 as f64).sum()
}

pub fn compute_696(values: &[f64]) -> f64 {
    // Scaled sum for batch 696
    values.iter().map(|v| v * 696 as f64).sum()
}

pub fn compute_697(values: &[f64]) -> f64 {
    // Scaled sum for batch 697
    values.iter().map(|v| v * 697 as f64).sum()
}

pub fn compute_698(values: &[f64]) -> f64 {
    // Scaled sum for batch 698
    values.iter().map(|v| v * 698 as f64).sum()
}

pub fn compute_699(values: &[f64]) -> f64 {
    // Scaled sum for batch 699
    values.iter().map(|v| v * 699 as f64).sum()
}

pub fn compute_700(values: &[f64]) -> f64 {
    // Scaled sum for batch 700
    values.iter().map(|v| v * 700 as f64).sum()
}

pub fn compute_701(values: &[f64]) -> f64 {
    // Scaled sum for batch 701
    values.iter().map(|v| v * 701 as f64).sum()
}

pub fn compute_702(values: &[f64]) -> f64 {
    // Scaled sum for batch 702
    values.iter().map(|v| v * 702 as f64).sum()
}

pub fn compute_703(values: &[f64]) -> f64 {
    // Scaled sum for batch 703
    values.iter().map(|v| v * 703 as f64).sum()
}

pub fn compute_704(values: &[f64]) -> f64 {
    // Scaled sum for batch 704
    values.iter().map(|v| v * 704 as f64).sum()
}

pub fn compute_705(values: &[f64]) -> f64 {
    // Scaled sum for batch 705
    values.iter().map(|v| v * 705 as f64).sum()
}

pub fn compute_706(values: &[f64]) -> f64 {
    // Scaled sum for batch 706
    values.iter().map(|v| v * 706 as f64).sum()
}

pub fn compute_707(values: &[f64]) -> f64 {
    // Scaled sum for batch 707
    values.iter().map(|v| v * 707 as f64).sum()
}

pub fn compute_708(values: &[f64]) -> f64 {
    // Scaled sum for batch 708
    values.iter().map(|v| v * 708 as f64).sum()
}

pub fn compute_709(values: &[f64]) -> f64 {
    // Scaled sum for batch 709
    values.iter().map(|v| v * 709 as f64).sum()
}

pub fn compute_710(values: &[f64]) -> f64 {
    // Scaled sum for batch 710
    values.iter().map(|v| v * 710 as f64).sum()
}

pub fn compute_711(values: &[f64]) -> f64 {
    // Scaled sum for batch 711
    values.iter().map(|v| v * 711 as f64).sum()
}

pub fn compute_712(values: &[f64]) -> f64 {
    // Scaled sum for batch 712
    values.iter().map(|v| v * 712 as f64).sum()
}

pub fn compute_713(values: &[f64]) -> f64 {
    // Scaled sum for batch 713
    values.iter().map(|v| v * 713 as f64).sum()
}

pub fn compute_714(values: &[f64]) -> f64 {
    // Scaled sum for batch 714
    values.iter().map(|v| v * 714 as f64).sum()
}

pub fn compute_715(values: &[f64]) -> f64 {
    // Scaled sum for batch 715
    values.iter().map(|v| v * 715 as f64).sum()
}

pub fn compute_716(values: &[f64]) -> f64 {
    // Scaled sum for batch 716
    values.iter().map(|v| v * 716 as f64).sum()
}

pub fn compute_717(values: &[f64]) -> f64 {
    // Scaled sum for batch 717
    values.iter().map(|v| v * 717 as f64).sum()
}

pub fn compute_718(values: &[f64]) -> f64 {
    // Scaled sum for batch 718
    values.iter().map(|v| v * 718 as f64).sum()
}

pub fn compute_719(values: &[f64]) -> f64 {
    // Scaled sum for batch 719
    values.iter().map(|v| v * 719 as f64).sum()
}

pub fn compute_720(values: &[f64]) -> f64 {
    // Scaled sum for batch 720
    values.iter().map(|v| v * 720 as f64).sum()
}

pub fn compute_721(values: &[f64]) -> f64 {
    // Scaled sum for batch 721
    values.iter().map(|v| v * 721 as f64).sum()
}

pub fn compute_722(values: &[f64]) -> f64 {
    // Scaled sum for batch 722
    values.iter().map(|v| v * 722 as f64).sum()
}

pub fn compute_723(values: &[f64]) -> f64 {
    // Scaled sum for batch 723
    values.iter().map(|v| v * 723 as f64).sum()
}

pub fn compute_724(values: &[f64]) -> f64 {
    // Scaled sum for batch 724
    values.iter().map(|v| v * 724 as f64).sum()
}

pub fn compute_725(values: &[f64]) -> f64 {
    // Scaled sum for batch 725
    values.iter().map(|v| v * 725 as f64).sum()
}

pub fn compute_726(values: &[f64]) -> f64 {
    // Scaled sum for batch 726
    values.iter().map(|v| v * 726 as f64).sum()
}

pub fn compute_727(values: &[f64]) -> f64 {
    // Scaled sum for batch 727
    values.iter().map(|v| v * 727 as f64).sum()
}

pub fn compute_728(values: &[f64]) -> f64 {
    // Scaled sum for batch 728
    values.iter().map(|v| v * 728 as f64).sum()
}

pub fn compute_729(values: &[f64]) -> f64 {
    // Scaled sum for batch 729
    values.iter().map(|v| v * 729 as f64).sum()
}

pub fn compute_730(values: &[f64]) -> f64 {
    // Scaled sum for batch 730
    values.iter().map(|v| v * 730 as f64).sum()
}

pub fn compute_731(values: &[f64]) -> f64 {
    // Scaled sum for batch 731
    values.iter().map(|v| v * 731 as f64).sum()
}

pub fn compute_732(values: &[f64]) -> f64 {
    // Scaled sum for batch 732
    values.iter().map(|v| v * 732 as f64).sum()
}

pub fn compute_733(values: &[f64]) -> f64 {
    // Scaled sum for batch 733
    values.iter().map(|v| v * 733 as f64).sum()
}

pub fn compute_734(values: &[f64]) -> f64 {
    // Scaled sum for batch 734
    values.iter().map(|v| v * 734 as f64).sum()
}

pub fn compute_735(values: &[f64]) -> f64 {
    // Scaled sum for batch 735
    values.iter().map(|v| v * 735 as f64).sum()
}

pub fn compute_736(values: &[f64]) -> f64 {
    // Scaled sum for batch 736
    values.iter().map(|v| v * 736 as f64).sum()
}

pub fn compute_737(values: &[f64]) -> f64 {
    // Scaled sum for batch 737
    values.iter().map(|v| v * 737 as f64).sum()
}

pub fn compute_738(values: &[f64]) -> f64 {
    // Scaled sum for batch 738
    values.iter().map(|v| v * 738 as f64).sum()
}

pub fn compute_739(values: &[f64]) -> f64 {
    // Scaled sum for batch 739
    values.iter().map(|v| v * 739 as f64).sum()
}

pub fn compute_740(values: &[f64]) -> f64 {
    // Scaled sum for batch 740
    values.iter().map(|v| v * 740 as f64).sum()
}

pub fn compute_741(values: &[f64]) -> f64 {
    // Scaled sum for batch 741
    values.iter().map(|v| v * 741 as f64).sum()
}

pub fn compute_742(values: &[f64]) -> f64 {
    // Scaled sum for batch 742
    values.iter().map(|v| v * 742 as f64).sum()
}

pub fn compute_743(values: &[f64]) -> f64 {
    // Scaled sum for batch 743
    values.iter().map(|v| v * 743 as f64).sum()
}

pub fn compute_744(values: &[f64]) -> f64 {
    // Scaled sum for batch 744
    values.iter().map(|v| v * 744 as f64).sum()
}

pub fn compute_745(values: &[f64]) -> f64 {
    // Scaled sum for batch 745
    values.iter().map(|v| v * 745 as f64).sum()
}

pub fn compute_746(values: &[f64]) -> f64 {
    // Scaled sum for batch 746
    values.iter().map(|v| v * 746 as f64).sum()
}

pub fn compute_747(values: &[f64]) -> f64 {
    // Scaled sum for batch 747
    values.iter().map(|v| v * 747 as f64).sum()
}

pub fn compute_748(values: &[f64]) -> f64 {
    // Scaled sum for batch 748
    values.iter().map(|v| v * 748 as f64).sum()
}

pub fn compute_749(values: &[f64]) -> f64 {
    // Scaled sum for batch 749
    values.iter().map(|v| v * 749 as f64).sum()
}

pub fn compute_750(values: &[f64]) -> f64 {
    // Scaled sum for batch 750
    values.iter().map(|v| v * 750 as f64).sum()
}

pub fn compute_751(values: &[f64]) -> f64 {
    // Scaled sum for batch 751
    values.iter().map(|v| v * 751 as f64).sum()
}

pub fn compute_752(values: &[f64]) -> f64 {
    // Scaled sum for batch 752
    values.iter().map(|v| v * 752 as f64).sum()
}

pub fn compute_753(values: &[f64]) -> f64 {
    // Scaled sum for batch 753
    values.iter().map(|v| v * 753 as f64).sum()
}

pub fn compute_754(values: &[f64]) -> f64 {
    // Scaled sum for batch 754
    values.iter().map(|v| v * 754 as f64).sum()
}

pub fn compute_755(values: &[f64]) -> f64 {
    // Scaled sum for batch 755
    values.iter().map(|v| v * 755 as f64).sum()
}

pub fn compute_756(values: &[f64]) -> f64 {
    // Scaled sum for batch 756
    values.iter().map(|v| v * 756 as f64).sum()
}

pub fn compute_757(values: &[f64]) -> f64 {
    // Scaled sum for batch 757
    values.iter().map(|v| v * 757 as f64).sum()
}

pub fn compute_758(values: &[f64]) -> f64 {
    // Scaled sum for batch 758
    values.iter().map(|v| v * 758 as f64).sum()
}

pub fn compute_759(values: &[f64]) -> f64 {
    // Scaled sum for batch 759
    values.iter().map(|v| v * 759 as f64).sum()
}

pub fn compute_760(values: &[f64]) -> f64 {
    // Scaled sum for batch 760
    values.iter().map(|v| v * 760 as f64).sum()
}

pub fn compute_761(values: &[f64]) -> f64 {
    // Scaled sum for batch 761
    values.iter().map(|v| v * 761 as f64).sum()
}

pub fn compute_762(values: &[f64]) -> f64 {
    // Scaled sum for batch 762
    values.iter().map(|v| v * 762 as f64).sum()
}

pub fn compute_763(values: &[f64]) -> f64 {
    // Scaled sum for batch 763
    values.iter().map(|v| v * 763 as f64).sum()
}

pub fn compute_764(values: &[f64]) -> f64 {
    // Scaled sum for batch 764
    values.iter().map(|v| v * 764 as f64).sum()
}

pub fn compute_765(values: &[f64]) -> f64 {
    // Scaled sum for batch 765
    values.iter().map(|v| v * 765 as f64).sum()
}

pub fn compute_766(values: &[f64]) -> f64 {
    // Scaled sum for batch 766
    values.iter().map(|v| v * 766 as f64).sum()
}

pub fn compute_767(values: &[f64]) -> f64 {
    // Scaled sum for batch 767
    values.iter().map(|v| v * 767 as f64).sum()
}

pub fn compute_768(values: &[f64]) -> f64 {
    // Scaled sum for batch 768
    values.iter().map(|v| v * 768 as f64).sum()
}

pub fn compute_769(values: &[f64]) -> f64 {
    // Scaled sum for batch 769
    values.iter().map(|v| v * 769 as f64).sum()
}

pub fn compute_770(values: &[f64]) -> f64 {
    // Scaled sum for batch 770
    values.iter().map(|v| v * 770 as f64).sum()
}

pub fn compute_771(values: &[f64]) -> f64 {
    // Scaled sum for batch 771
    values.iter().map(|v| v * 771 as f64).sum()
}

pub fn compute_772(values: &[f64]) -> f64 {
    // Scaled sum for batch 772
    values.iter().map(|v| v * 772 as f64).sum()
}

pub fn compute_773(values: &[f64]) -> f64 {
    // Scaled sum for batch 773
    values.iter().map(|v| v * 773 as f64).sum()
}

pub fn compute_774(values: &[f64]) -> f64 {
    // Scaled sum for batch 774
    values.iter().map(|v| v * 774 as f64).sum()
}

pub fn compute_775(values: &[f64]) -> f64 {
    // Scaled sum for batch 775
    values.iter().map(|v| v * 775 as f64).sum()
}

pub fn compute_776(values: &[f64]) -> f64 {
    // Scaled sum for batch 776
    values.iter().map(|v| v * 776 as f64).sum()
}

pub fn compute_777(values: &[f64]) -> f64 {
    // Scaled sum for batch 777
    values.iter().map(|v| v * 777 as f64).sum()
}

pub fn compute_778(values: &[f64]) -> f64 {
    // Scaled sum for batch 778
    values.iter().map(|v| v * 778 as f64).sum()
}

pub fn compute_779(values: &[f64]) -> f64 {
    // Scaled sum for batch 779
    values.iter().map(|v| v * 779 as f64).sum()
}

pub fn compute_780(values: &[f64]) -> f64 {
    // Scaled sum for batch 780
    values.iter().map(|v| v * 780 as f64).sum()
}

pub fn compute_781(values: &[f64]) -> f64 {
    // Scaled sum for batch 781
    values.iter().map(|v| v * 781 as f64).sum()
}

pub fn compute_782(values: &[f64]) -> f64 {
    // Scaled sum for batch 782
    values.iter().map(|v| v * 782 as f64).sum()
}

pub fn compute_783(values: &[f64]) -> f64 {
    // Scaled sum for batch 783
    values.iter().map(|v| v * 783 as f64).sum()
}

pub fn compute_784(values: &[f64]) -> f64 {
    // Scaled sum for batch 784
    values.iter().map(|v| v * 784 as f64).sum()
}

pub fn compute_785(values: &[f64]) -> f64 {
    // Scaled sum for batch 785
    values.iter().map(|v| v * 785 as f64).sum()
}

pub fn compute_786(values: &[f64]) -> f64 {
    // Scaled sum for batch 786
    values.iter().map(|v| v * 786 as f64).sum()
}

pub fn compute_787(values: &[f64]) -> f64 {
    // Scaled sum for batch 787
    values.iter().map(|v| v * 787 as f64).sum()
}

pub fn compute_788(values: &[f64]) -> f64 {
    // Scaled sum for batch 788
    values.iter().map(|v| v * 788 as f64).sum()
}

pub fn compute_789(values: &[f64]) -> f64 {
    // Scaled sum for batch 789
    values.iter().map(|v| v * 789 as f64).sum()
}

pub fn compute_790(values: &[f64]) -> f64 {
    // Scaled sum for batch 790
    values.iter().map(|v| v * 790 as f64).sum()
}

pub fn compute_791(values: &[f64]) -> f64 {
    // Scaled sum for batch 791
    values.iter().map(|v| v * 791 as f64).sum()
}

pub fn compute_792(values: &[f64]) -> f64 {
    // Scaled sum for batch 792
    values.iter().map(|v| v * 792 as f64).sum()
}

pub fn compute_793(values: &[f64]) -> f64 {
    // Scaled sum for batch 793
    values.iter().map(|v| v * 793 as f64).sum()
}

pub fn compute_794(values: &[f64]) -> f64 {
    // Scaled sum for batch 794
    values.iter().map(|v| v * 794 as f64).sum()
}

pub fn compute_795(values: &[f64]) -> f64 {
    // Scaled sum for batch 795
    values.iter().map(|v| v * 795 as f64).sum()
}

pub fn compute_796(values: &[f64]) -> f64 {
    // Scaled sum for batch 796
    values.iter().map(|v| v * 796 as f64).sum()
}

pub fn compute_797(values: &[f64]) -> f64 {
    // Scaled sum for batch 797
    values.iter().map(|v| v * 797 as f64).sum()
}

pub fn compute_798(values: &[f64]) -> f64 {
    // Scaled sum for batch 798
    values.iter().map(|v| v * 798 as f64).sum()
}

pub fn compute_799(values: &[f64]) -> f64 {
    // Scaled sum for batch 799
    values.iter().map(|v| v * 799 as f64).sum()
}

pub fn compute_800(values: &[f64]) -> f64 {
    // Scaled sum for batch 800
    values.iter().map(|v| v * 800 as f64).sum()
}

pub fn compute_801(values: &[f64]) -> f64 {
    // Scaled sum for batch 801
    values.iter().map(|v| v * 801 as f64).sum()
}

pub fn compute_802(values: &[f64]) -> f64 {
    // Scaled sum for batch 802
    values.iter().map(|v| v * 802 as f64).sum()
}

pub fn compute_803(values: &[f64]) -> f64 {
    // Scaled sum for batch 803
    values.iter().map(|v| v * 803 as f64).sum()
}

pub fn compute_804(values: &[f64]) -> f64 {
    // Scaled sum for batch 804
    values.iter().map(|v| v * 804 as f64).sum()
}

pub fn compute_805(values: &[f64]) -> f64 {
    // Scaled sum for batch 805
    values.iter().map(|v| v * 805 as f64).sum()
}

pub fn compute_806(values: &[f64]) -> f64 {
    // Scaled sum for batch 806
    values.iter().map(|v| v * 806 as f64).sum()
}

pub fn compute_807(values: &[f64]) -> f64 {
    // Scaled sum for batch 807
    values.iter().map(|v| v * 807 as f64).sum()
}

pub fn compute_808(values: &[f64]) -> f64 {
    // Scaled sum for batch 808
    values.iter().map(|v| v * 808 as f64).sum()
}

pub fn compute_809(values: &[f64]) -> f64 {
    // Scaled sum for batch 809
    values.iter().map(|v| v * 809 as f64).sum()
}

pub fn compute_810(values: &[f64]) -> f64 {
    // Scaled sum for batch 810
    values.iter().map(|v| v * 810 as f64).sum()
}

pub fn compute_811(values: &[f64]) -> f64 {
    // Scaled sum for batch 811
    values.iter().map(|v| v * 811 as f64).sum()
}

pub fn compute_812(values: &[f64]) -> f64 {
    // Scaled sum for batch 812
    values.iter().map(|v| v * 812 as f64).sum()
}

pub fn compute_813(values: &[f64]) -> f64 {
    // Scaled sum for batch 813
    values.iter().map(|v| v * 813 as f64).sum()
}

pub fn compute_814(values: &[f64]) -> f64 {
    // Scaled sum for batch 814
    values.iter().map(|v| v * 814 as f64).sum()
}

pub fn compute_815(values: &[f64]) -> f64 {
    // Scaled sum for batch 815
    values.iter().map(|v| v * 815 as f64).sum()
}

pub fn compute_816(values: &[f64]) -> f64 {
    // Scaled sum for batch 816
    values.iter().map(|v| v * 816 as f64).sum()
}

pub fn compute_817(values: &[f64]) -> f64 {
    // Scaled sum for batch 817
    values.iter().map(|v| v * 817 as f64).sum()
}

pub fn compute_818(values: &[f64]) -> f64 {
    // Scaled sum for batch 818
    values.iter().map(|v| v * 818 as f64).sum()
}

pub fn compute_819(values: &[f64]) -> f64 {
    // Scaled sum for batch 819
    values.iter().map(|v| v * 819 as f64).sum()
}

pub fn compute_820(values: &[f64]) -> f64 {
    // Scaled sum for batch 820
    values.iter().map(|v| v * 820 as f64).sum()
}

pub fn compute_821(values: &[f64]) -> f64 {
    // Scaled sum for batch 821
    values.iter().map(|v| v * 821 as f64).sum()
}

pub fn compute_822(values: &[f64]) -> f64 {
    // Scaled sum for batch 822
    values.iter().map(|v| v * 822 as f64).sum()
}

pub fn compute_823(values: &[f64]) -> f64 {
    // Scaled sum for batch 823
    values.iter().map(|v| v * 823 as f64).sum()
}

pub fn compute_824(values: &[f64]) -> f64 {
    // Scaled sum for batch 824
    values.iter().map(|v| v * 824 as f64).sum()
}

pub fn compute_825(values: &[f64]) -> f64 {
    // Scaled sum for batch 825
    values.iter().map(|v| v * 825 as f64).sum()
}

pub fn compute_826(values: &[f64]) -> f64 {
    // Scaled sum for batch 826
    values.iter().map(|v| v * 826 as f64).sum()
}

pub fn compute_827(values: &[f64]) -> f64 {
    // Scaled sum for batch 827
    values.iter().map(|v| v * 827 as f64).sum()
}

pub fn compute_828(values: &[f64]) -> f64 {
    // Scaled sum for batch 828
    values.iter().map(|v| v * 828 as f64).sum()
}

pub fn compute_829(values: &[f64]) -> f64 {
    // Scaled sum for batch 829
    values.iter().map(|v| v * 829 as f64).sum()
}

pub fn compute_830(values: &[f64]) -> f64 {
    // Scaled sum for batch 830
    values.iter().map(|v| v * 830 as f64).sum()
}

pub fn compute_831(values: &[f64]) -> f64 {
    // Scaled sum for batch 831
    values.iter().map(|v| v * 831 as f64).sum()
}

pub fn compute_832(values: &[f64]) -> f64 {
    // Scaled sum for batch 832
    values.iter().map(|v| v * 832 as f64).sum()
}

pub fn compute_833(values: &[f64]) -> f64 {
    // Scaled sum for batch 833
    values.iter().map(|v| v * 833 as f64).sum()
}

pub fn compute_834(values: &[f64]) -> f64 {
    // Scaled sum for batch 834
    values.iter().map(|v| v * 834 as f64).sum()
}

pub fn compute_835(values: &[f64]) -> f64 {
    // Scaled sum for batch 835
    values.iter().map(|v| v * 835 as f64).sum()
}

pub fn compute_836(values: &[f64]) -> f64 {
    // Scaled sum for batch 836
    values.iter().map(|v| v * 836 as f64).sum()
}

pub fn compute_837(values: &[f64]) -> f64 {
    // Scaled sum for batch 837
    values.iter().map(|v| v * 837 as f64).sum()
}

pub fn compute_838(values: &[f64]) -> f64 {
    // Scaled sum for batch 838
    values.iter().map(|v| v * 838 as f64).sum()
}

pub fn compute_839(values: &[f64]) -> f64 {
    // Scaled sum for batch 839
    values.iter().map(|v| v * 839 as f64).sum()
}

pub fn compute_840(values: &[f64]) -> f64 {
    // Scaled sum for batch 840
    values.iter().map(|v| v * 840 as f64).sum()
}

pub fn compute_841(values: &[f64]) -> f64 {
    // Scaled sum for batch 841
    values.iter().map(|v| v * 841 as f64).sum()
}

pub fn compute_842(values: &[f64]) -> f64 {
    // Scaled sum for batch 842
    values.iter().map(|v| v * 842 as f64).sum()
}

pub fn compute_843(values: &[f64]) -> f64 {
    // Scaled sum for batch 843
    values.iter().map(|v| v * 843 as f64).sum()
}

pub fn compute_844(values: &[f64]) -> f64 {
    // Scaled sum for batch 844
    values.iter().map(|v| v * 844 as f64).sum()
}

pub fn compute_845(values: &[f64]) -> f64 {
    // Scaled sum for batch 845
    values.iter().map(|v| v * 845 as f64).sum()
}

pub fn compute_846(values: &[f64]) -> f64 {
    // Scaled sum for batch 846
    values.iter().map(|v| v * 846 as f64).sum()
}

pub fn compute_847(values: &[f64]) -> f64 {
    // Scaled sum for batch 847
    values.iter().map(|v| v * 847 as f64).sum()
}

pub fn compute_848(values: &[f64]) -> f64 {
    // Scaled sum for batch 848
    values.iter().map(|v| v * 848 as f64).sum()
}

pub fn compute_849(values: &[f64]) -> f64 {
    // Scaled sum for batch 849
    values.iter().map(|v| v * 849 as f64).sum()
}

pub fn compute_850(values: &[f64]) -> f64 {
    // Scaled sum for batch 850
    values.iter().map(|v| v * 850 as f64).sum()
}

pub fn compute_851(values: &[f64]) -> f64 {
    // Scaled sum for batch 851
    values.iter().map(|v| v * 851 as f64).sum()
}

pub fn compute_852(values: &[f64]) -> f64 {
    // Scaled sum for batch 852
    values.iter().map(|v| v * 852 as f64).sum()
}

pub fn compute_853(values: &[f64]) -> f64 {
    // Scaled sum for batch 853
    values.iter().map(|v| v * 853 as f64).sum()
}

pub fn compute_854(values: &[f64]) -> f64 {
    // Scaled sum for batch 854
    values.iter().map(|v| v * 854 as f64).sum()
}

pub fn compute_855(values: &[f64]) -> f64 {
    // Scaled sum for batch 855
    values.iter().map(|v| v * 855 as f64).sum()
}

pub fn compute_856(values: &[f64]) -> f64 {
    // Scaled sum for batch 856
    values.iter().map(|v| v * 856 as f64).sum()
}

pub fn compute_857(values: &[f64]) -> f64 {
    // Scaled sum for batch 857
    values.iter().map(|v| v * 857 as f64).sum()
}

pub fn compute_858(values: &[f64]) -> f64 {
    // Scaled sum for batch 858
    values.iter().map(|v| v * 858 as f64).sum()
}

pub fn compute_859(values: &[f64]) -> f64 {
    // Scaled sum for batch 859
    values.iter().map(|v| v * 859 as f64).sum()
}

pub fn compute_860(values: &[f64]) -> f64 {
    // Scaled sum for batch 860
    values.iter().map(|v| v * 860 as f64).sum()
}

pub fn compute_861(values: &[f64]) -> f64 {
    // Scaled sum for batch 861
    values.iter().map(|v| v * 861 as f64).sum()
}

pub fn compute_862(values: &[f64]) -> f64 {
    // Scaled sum for batch 862
    values.iter().map(|v| v * 862 as f64).sum()
}

pub fn compute_863(values: &[f64]) -> f64 {
    // Scaled sum for batch 863
    values.iter().map(|v| v * 863 as f64).sum()
}

pub fn compute_864(values: &[f64]) -> f64 {
    // Scaled sum for batch 864
    values.iter().map(|v| v * 864 as f64).sum()
}

pub fn compute_865(values: &[f64]) -> f64 {
    // Scaled sum for batch 865
    values.iter().map(|v| v * 865 as f64).sum()
}

pub fn compute_866(values: &[f64]) -> f64 {
    // Scaled sum for batch 866
    values.iter().map(|v| v * 866 as f64).sum()
}

pub fn compute_867(values: &[f64]) -> f64 {
    // Scaled sum for batch 867
    values.iter().map(|v| v * 867 as f64).sum()
}

pub fn compute_868(values: &[f64]) -> f64 {
    // Scaled sum for batch 868
    values.iter().map(|v| v * 868 as f64).sum()
}

pub fn compute_869(values: &[f64]) -> f64 {
    // Scaled sum for batch 869
    values.iter().map(|v| v * 869 as f64).sum()
}

pub fn compute_870(values: &[f64]) -> f64 {
    // Scaled sum for batch 870
    values.iter().map(|v| v * 870 as f64).sum()
}

pub fn compute_871(values: &[f64]) -> f64 {
    // Scaled sum for batch 871
    values.iter().map(|v| v * 871 as f64).sum()
}

pub fn compute_872(values: &[f64]) -> f64 {
    // Scaled sum for batch 872
    values.iter().map(|v| v * 872 as f64).sum()
}

pub fn compute_873(values: &[f64]) -> f64 {
    // Scaled sum for batch 873
    values.iter().map(|v| v * 873 as f64).sum()
}

pub fn compute_874(values: &[f64]) -> f64 {
    // Scaled sum for batch 874
    values.iter().map(|v| v * 874 as f64).sum()
}

pub fn compute_875(values: &[f64]) -> f64 {
    // Scaled sum for batch 875
    values.iter().map(|v| v * 875 as f64).sum()
}

pub fn compute_876(values: &[f64]) -> f64 {
    // Scaled sum for batch 876
    values.iter().map(|v| v * 876 as f64).sum()
}

pub fn compute_877(values: &[f64]) -> f64 {
    // Scaled sum for batch 877
    values.iter().map(|v| v * 877 as f64).sum()
}

pub fn compute_878(values: &[f64]) -> f64 {
    // Scaled sum for batch 878
    values.iter().map(|v| v * 878 as f64).sum()
}

pub fn compute_879(values: &[f64]) -> f64 {
    // Scaled sum for batch 879
    values.iter().map(|v| v * 879 as f64).sum()
}

pub fn compute_880(values: &[f64]) -> f64 {
    // Scaled sum for batch 880
    values.iter().map(|v| v * 880 as f64).sum()
}

pub fn compute_881(values: &[f64]) -> f64 {
    // Scaled sum for batch 881
    values.iter().map(|v| v * 881 as f64).sum()
}

pub fn compute_882(values: &[f64]) -> f64 {
    // Scaled sum for batch 882
    values.iter().map(|v| v * 882 as f64).sum()
}

pub fn compute_883(values: &[f64]) -> f64 {
    // Scaled sum for batch 883
    values.iter().map(|v| v * 883 as f64).sum()
}

pub fn compute_884(values: &[f64]) -> f64 {
    // Scaled sum for batch 884
    values.iter().map(|v| v * 884 as f64).sum()
}

pub fn compute_885(values: &[f64]) -> f64 {
    // Scaled sum for batch 885
    values.iter().map(|v| v * 885 as f64).sum()
}

pub fn compute_886(values: &[f64]) -> f64 {
    // Scaled sum for batch 886
    values.iter().map(|v| v * 886 as f64).sum()
}

pub fn compute_887(values: &[f64]) -> f64 {
    // Scaled sum for batch 887
    values.iter().map(|v| v * 887 as f64).sum()
}

pub fn compute_888(values: &[f64]) -> f64 {
    // Scaled sum for batch 888
    values.iter().map(|v| v * 888 as f64).sum()
}

pub fn compute_889(values: &[f64]) -> f64 {
    // Scaled sum for batch 889
    values.iter().map(|v| v * 889 as f64).sum()
}

pub fn compute_890(values: &[f64]) -> f64 {
    // Scaled sum for batch 890
    values.iter().map(|v| v * 890 as f64).sum()
}

pub fn compute_891(values: &[f64]) -> f64 {
    // Scaled sum for batch 891
    values.iter().map(|v| v * 891 as f64).sum()
}

pub fn compute_892(values: &[f64]) -> f64 {
    // Scaled sum for batch 892
    values.iter().map(|v| v * 892 as f64).sum()
}

pub fn compute_893(values: &[f64]) -> f64 {
    // Scaled sum for batch 893
    values.iter().map(|v| v * 893 as f64).sum()
}

pub fn compute_894(values: &[f64]) -> f64 {
    // Scaled sum for batch 894
    values.iter().map(|v| v * 894 as f64).sum()
}

pub fn compute_895(values: &[f64]) -> f64 {
    // Scaled sum for batch 895
    values.iter().map(|v| v * 895 as f64).sum()
}

pub fn compute_896(values: &[f64]) -> f64 {
    // Scaled sum for batch 896
    values.iter().map(|v| v * 896 as f64).sum()
}

pub fn compute_897(values: &[f64]) -> f64 {
    // Scaled sum for batch 897
    values.iter().map(|v| v * 897 as f64).sum()
}

pub fn compute_898(values: &[f64]) -> f64 {
    // Scaled sum for batch 898
    values.iter().map(|v| v * 898 as f64).sum()
}

pub fn compute_899(values: &[f64]) -> f64 {
    // Scaled sum for batch 899
    values.iter().map(|v| v * 899 as f64).sum()
}

pub fn compute_900(values: &[f64]) -> f64 {
    // Scaled sum for batch 900
    values.iter().map(|v| v * 900 as f64).sum()
}

pub fn compute_901(values: &[f64]) -> f64 {
    // Scaled sum for batch 901
    values.iter().map(|v| v * 901 as f64).sum()
}

pub fn compute_902(values: &[f64]) -> f64 {
    // Scaled sum for batch 902
    values.iter().map(|v| v * 902 as f64).sum()
}

pub fn compute_903(values: &[f64]) -> f64 {
    // Scaled sum for batch 903
    values.iter().map(|v| v * 903 as f64).sum()
}

pub fn compute_904(values: &[f64]) -> f64 {
    // Scaled sum for batch 904
    values.iter().map(|v| v * 904 as f64).sum()
}

pub fn compute_905(values: &[f64]) -> f64 {
    // Scaled sum for batch 905
    values.iter().map(|v| v * 905 as f64).sum()
}

pub fn compute_906(values: &[f64]) -> f64 {
    // Scaled sum for batch 906
    values.iter().map(|v| v * 906 as f64).sum()
}

pub fn compute_907(values: &[f64]) -> f64 {
    // Scaled sum for batch 907
    values.iter().map(|v| v * 907 as f64).sum()
}

pub fn compute_908(values: &[f64]) -> f64 {
    // Scaled sum for batch 908
    values.iter().map(|v| v * 908 as f64).sum()
}

pub fn compute_909(values: &[f64]) -> f64 {
    // Scaled sum for batch 909
    values.iter().map(|v| v * 909 as f64).sum()
}

pub fn compute_910(values: &[f64]) -> f64 {
    // Scaled sum for batch 910
    values.iter().map(|v| v * 910 as f64).sum()
}

pub fn compute_911(values: &[f64]) -> f64 {
    // Scaled sum for batch 911
    values.iter().map(|v| v * 911 as f64).sum()
}

pub fn compute_912(values: &[f64]) -> f64 {
    // Scaled sum for batch 912
    values.iter().map(|v| v * 912 as f64).sum()
}

pub fn compute_913(values: &[f64]) -> f64 {
    // Scaled sum for batch 913
    values.iter().map(|v| v * 913 as f64).sum()
}

pub fn compute_914(values: &[f64]) -> f64 {
    // Scaled sum for batch 914
    values.iter().map(|v| v * 914 as f64).sum()
}

pub fn compute_915(values: &[f64]) -> f64 {
    // Scaled sum for batch 915
    values.iter().map(|v| v * 915 as f64).sum()
}

pub fn compute_916(values: &[f64]) -> f64 {
    // Scaled sum for batch 916
    values.iter().map(|v| v * 916 as f64).sum()
}

pub fn compute_917(values: &[f64]) -> f64 {
    // Scaled sum for batch 917
    values.iter().map(|v| v * 917 as f64).sum()
}

pub fn compute_918(values: &[f64]) -> f64 {
    // Scaled sum for batch 918
    values.iter().map(|v| v * 918 as f64).sum()
}

pub fn compute_919(values: &[f64]) -> f64 {
    // Scaled sum for batch 919
    values.iter().map(|v| v * 919 as f64).sum()
}

pub fn compute_920(values: &[f64]) -> f64 {
    // Scaled sum for batch 920
    values.iter().map(|v| v * 920 as f64).sum()
}

pub fn compute_921(values: &[f64]) -> f64 {
    // Scaled sum for batch 921
    values.iter().map(|v| v * 921 as f64).sum()
}

pub fn compute_922(values: &[f64]) -> f64 {
    // Scaled sum for batch 922
    values.iter().map(|v| v * 922 as f64).sum()
}

pub fn compute_923(values: &[f64]) -> f64 {
    // Scaled sum for batch 923
    values.iter().map(|v| v * 923 as f64).sum()
}

pub fn compute_924(values: &[f64]) -> f64 {
    // Scaled sum for batch 924
    values.iter().map(|v| v * 924 as f64).sum()
}

pub fn compute_925(values: &[f64]) -> f64 {
    // Scaled sum for batch 925
    values.iter().map(|v| v * 925 as f64).sum()
}

pub fn compute_926(values: &[f64]) -> f64 {
    // Scaled sum for batch 926
    values.iter().map(|v| v * 926 as f64).sum()
}

pub fn compute_927(values: &[f64]) -> f64 {
    // Scaled sum for batch 927
    values.iter().map(|v| v * 927 as f64).sum()
}

pub fn compute_928(values: &[f64]) -> f64 {
    // Scaled sum for batch 928
    values.iter().map(|v| v * 928 as f64).sum()
}

pub fn compute_929(values: &[f64]) -> f64 {
    // Scaled sum for batch 929
    values.iter().map(|v| v * 929 as f64).sum()
}

pub fn compute_930(values: &[f64]) -> f64 {
    // Scaled sum for batch 930
    values.iter().map(|v| v * 930 as f64).sum()
}

pub fn compute_931(values: &[f64]) -> f64 {
    // Scaled sum for batch 931
    values.iter().map(|v| v * 931 as f64).sum()
}

pub fn compute_932(values: &[f64]) -> f64 {
    // Scaled sum for batch 932
    values.iter().map(|v| v * 932 as f64).sum()
}

pub fn compute_933(values: &[f64]) -> f64 {
    // Scaled sum for batch 933
    values.iter().map(|v| v * 933 as f64).sum()
}

pub fn compute_934(values: &[f64]) -> f64 {
    // Scaled sum for batch 934
    values.iter().map(|v| v * 934 as f64).sum()
}

pub fn compute_935(values: &[f64]) -> f64 {
    // Scaled sum for batch 935
    values.iter().map(|v| v * 935 as f64).sum()
}

pub fn compute_936(values: &[f64]) -> f64 {
    // Scaled sum for batch 936
    values.iter().map(|v| v * 936 as f64).sum()
}

pub fn compute_937(values: &[f64]) -> f64 {
    // Scaled sum for batch 937
    values.iter().map(|v| v * 937 as f64).sum()
}

pub fn compute_938(values: &[f64]) -> f64 {
    // Scaled sum for batch 938
    values.iter().map(|v| v * 938 as f64).sum()
}

pub fn compute_939(values: &[f64]) -> f64 {
    // Scaled sum for batch 939
    values.iter().map(|v| v * 939 as f64).sum()
}

pub fn compute_940(values: &[f64]) -> f64 {
    // Scaled sum for batch 940
    values.iter().map(|v| v * 940 as f64).sum()
}

pub fn compute_941(values: &[f64]) -> f64 {
    // Scaled sum for batch 941
    values.iter().map(|v| v * 941 as f64).sum()
}

pub fn compute_942(values: &[f64]) -> f64 {
    // Scaled sum for batch 942
    values.iter().map(|v| v * 942 as f64).sum()
}

pub fn compute_943(values: &[f64]) -> f64 {
    // Scaled sum for batch 943
    values.iter().map(|v| v * 943 as f64).sum()
}

pub fn compute_944(values: &[f64]) -> f64 {
    // Scaled sum for batch 944
    values.iter().map(|v| v * 944 as f64).sum()
}

pub fn compute_945(values: &[f64]) -> f64 {
    // Scaled sum for batch 945
    values.iter().map(|v| v * 945 as f64).sum()
}

pub fn compute_946(values: &[f64]) -> f64 {
    // Scaled sum for batch 946
    values.iter().map(|v| v * 946 as f64).sum()
}

pub fn compute_947(values: &[f64]) -> f64 {
    // Scaled sum for batch 947
    values.iter().map(|v| v * 947 as f64).sum()
}

pub fn compute_948(values: &[f64]) -> f64 {
    // Scaled sum for batch 948
    values.iter().map(|v| v * 948 as f64).sum()
}

pub fn compute_949(values: &[f64]) -> f64 {
    // Scaled sum for batch 949
    values.iter().map(|v| v * 949 as f64).sum()
}

pub fn compute_950(values: &[f64]) -> f64 {
    // Scaled sum for batch 950
    values.iter().map(|v| v * 950 as f64).sum()
}

pub fn compute_951(values: &[f64]) -> f64 {
    // Scaled sum for batch 951
    values.iter().map(|v| v * 951 as f64).sum()
}

pub fn compute_952(values: &[f64]) -> f64 {
    // Scaled sum for batch 952
    values.iter().map(|v| v * 952 as f64).sum()
}

pub fn compute_953(values: &[f64]) -> f64 {
    // Scaled sum for batch 953
    values.iter().map(|v| v * 953 as f64).sum()
}

pub fn compute_954(values: &[f64]) -> f64 {
    // Scaled sum for batch 954
    values.iter().map(|v| v * 954 as f64).sum()
}

pub fn compute_955(values: &[f64]) -> f64 {
    // Scaled sum for batch 955
    values.iter().map(|v| v * 955 as f64).sum()
}

pub fn compute_956(values: &[f64]) -> f64 {
    // Scaled sum for batch 956
    values.iter().map(|v| v * 956 as f64).sum()
}

pub fn compute_957(values: &[f64]) -> f64 {
    // Scaled sum for batch 957
    values.iter().map(|v| v * 957 as f64).sum()
}

pub fn compute_958(values: &[f64]) -> f64 {
    // Scaled sum for batch 958
    values.iter().map(|v| v * 958 as f64).sum()
}

pub fn compute_959(values: &[f64]) -> f64 {
    // Scaled sum for batch 959
    values.iter().map(|v| v * 959 as f64).sum()
}

pub fn compute_960(values: &[f64]) -> f64 {
    // Scaled sum for batch 960
    values.iter().map(|v| v * 960 as f64).sum()
}

pub fn compute_961(values: &[f64]) -> f64 {
    // Scaled sum for batch 961
    values.iter().map(|v| v * 961 as f64).sum()
}

pub fn compute_962(values: &[f64]) -> f64 {
    // Scaled sum for batch 962
    values.iter().map(|v| v * 962 as f64).sum()
}

pub fn compute_963(values: &[f64]) -> f64 {
    // Scaled sum for batch 963
    values.iter().map(|v| v * 963 as f64).sum()
}

pub fn compute_964(values: &[f64]) -> f64 {
    // Scaled sum for batch 964
    values.iter().map(|v| v * 964 as f64).sum()
}

pub fn compute_965(values: &[f64]) -> f64 {
    // Scaled sum for batch 965
    values.iter().map(|v| v * 965 as f64).sum()
}

pub fn compute_966(values: &[f64]) -> f64 {
    // Scaled sum for batch 966
    values.iter().map(|v| v * 966 as f64).sum()
}

pub fn compute_967(values: &[f64]) -> f64 {
    // Scaled sum for batch 967
    values.iter().map(|v| v * 967 as f64).sum()
}

pub fn compute_968(values: &[f64]) -> f64 {
    // Scaled sum for batch 968
    values.iter().map(|v| v * 968 as f64).sum()
}

pub fn compute_969(values: &[f64]) -> f64 {
    // Scaled sum for batch 969
    values.iter().map(|v| v * 969 as f64).sum()
}

pub fn compute_970(values: &[f64]) -> f64 {
    // Scaled sum for batch 970
    values.iter().map(|v| v * 970 as f64).sum()
}

pub fn compute_971(values: &[f64]) -> f64 {
    // Scaled sum for batch 971
    values.iter().map(|v| v * 971 as f64).sum()
}

pub fn compute_972(values: &[f64]) -> f64 {
    // Scaled sum for batch 972
    values.iter().map(|v| v * 972 as f64).sum()
}

pub fn compute_973(values: &[f64]) -> f64 {
    // Scaled sum for batch 973
    values.iter().map(|v| v * 973 as f64).sum()
}

pub fn compute_974(values: &[f64]) -> f64 {
    // Scaled sum for batch 974
    values.iter().map(|v| v * 974 as f64).sum()
}

pub fn compute_975(values: &[f64]) -> f64 {
    // Scaled sum for batch 975
    values.iter().map(|v| v * 975 as f64).sum()
}

pub fn compute_976(values: &[f64]) -> f64 {
    // Scaled sum for batch 976
    values.iter().map(|v| v * 976 as f64).sum()
}

pub fn compute_977(values: &[f64]) -> f64 {
    // Scaled sum for batch 977
    values.iter().map(|v| v * 977 as f64).sum()
}

pub fn compute_978(values: &[f64]) -> f64 {
    // Scaled sum for batch 978
    values.iter().map(|v| v * 978 as f64).sum()
}

pub fn compute_979(values: &[f64]) -> f64 {
    // Scaled sum for batch 979
    values.iter().map(|v| v * 979 as f64).sum()
}

pub fn compute_980(values: &[f64]) -> f64 {
    // Scaled sum for batch 980
    values.iter().map(|v| v * 980 as f64).sum()
}

pub fn compute_981(values: &[f64]) -> f64 {
    // Scaled sum for batch 981
    values.iter().map(|v| v * 981 as f64).sum()
}

pub fn compute_982(values: &[f64]) -> f64 {
    // Scaled sum for batch 982
    values.iter().map(|v| v * 982 as f64).sum()
}

pub fn compute_983(values: &[f64]) -> f64 {
    // Scaled sum for batch 983
    values.iter().map(|v| v * 983 as f64).sum()
}

pub fn compute_984(values: &[f64]) -> f64 {
    // Scaled sum for batch 984
    values.iter().map(|v| v * 984 as f64).sum()
}

pub fn compute_985(values: &[f64]) -> f64 {
    // Scaled sum for batch 985
    values.iter().map(|v| v * 985 as f64).sum()
}

pub fn compute_986(values: &[f64]) -> f64 {
    // Scaled sum for batch 986
    values.iter().map(|v| v * 986 as f64).sum()
}

pub fn compute_987(values: &[f64]) -> f64 {
    // Scaled sum for batch 987
    values.iter().map(|v| v * 987 as f64).sum()
}

pub fn compute_988(values: &[f64]) -> f64 {
    // Scaled sum for batch 988
    values.iter().map(|v| v * 988 as f64).sum()
}

pub fn compute_989(values: &[f64]) -> f64 {
    // Scaled sum for batch 989
    values.iter().map(|v| v * 989 as f64).sum()
}

pub fn compute_990(values: &[f64]) -> f64 {
    // Scaled sum for batch 990
    values.iter().map(|v| v * 990 as f64).sum()
}

pub fn compute_991(values: &[f64]) -> f64 {
    // Scaled sum for batch 991
    values.iter().map(|v| v * 991 as f64).sum()
}

pub fn compute_992(values: &[f64]) -> f64 {
    // Scaled sum for batch 992
    values.iter().map(|v| v * 992 as f64).sum()
}

pub fn compute_993(values: &[f64]) -> f64 {
    // Scaled sum for batch 993
    values.iter().map(|v| v * 993 as f64).sum()
}

pub fn compute_994(values: &[f64]) -> f64 {
    // Scaled sum for batch 994
    values.iter().map(|v| v * 994 as f64).sum()
}

pub fn compute_995(values: &[f64]) -> f64 {
    // Scaled sum for batch 995
    values.iter().map(|v| v * 995 as f64).sum()
}

pub fn compute_996(values: &[f64]) -> f64 {
    // Scaled sum for batch 996
    values.iter().map(|v| v * 996 as f64).sum()
}

pub fn compute_997(values: &[f64]) -> f64 {
    // Scaled sum for batch 997
    values.iter().map(|v| v * 997 as f64).sum()
}

pub fn compute_998(values: &[f64]) -> f64 {
    // Scaled sum for batch 998
    values.iter().map(|v| v * 998 as f64).sum()
}

pub fn compute_999(values: &[f64]) -> f64 {
    // Scaled sum for batch 999
    values.iter().map(|v| v * 999 as f64).sum()
}

pub fn compute_1000(values: &[f64]) -> f64 {
    // Scaled sum for batch 1000
    values.iter().map(|v| v * 1000 as f64).sum()
}

pub fn compute_1001(values: &[f64]) -> f64 {
    // Scaled sum for batch 1001
    values.iter().map(|v| v * 1001 as f64).sum()
}

pub fn compute_1002(values: &[f64]) -> f64 {
    // Scaled sum for batch 1002
    values.iter().map(|v| v * 1002 as f64).sum()
}

pub fn compute_1003(values: &[f64]) -> f64 {
    // Scaled sum for batch 1003
    values.iter().map(|v| v * 1003 as f64).sum()
}

pub fn compute_1004(values: &[f64]) -> f64 {
    // Scaled sum for batch 1004
    values.iter().map(|v| v * 1004 as f64).sum()
}

pub fn compute_1005(values: &[f64]) -> f64 {
    // Scaled sum for batch 1005
    values.iter().map(|v| v * 1005 as f64).sum()
}

pub fn compute_1006(values: &[f64]) -> f64 {
    // Scaled sum for batch 1006
    values.iter().map(|v| v * 1006 as f64).sum()
}

pub fn compute_1007(values: &[f64]) -> f64 {
    // Scaled sum for batch 1007
    values.iter().map(|v| v * 1007 as f64).sum()
}

pub fn compute_1008(values: &[f64]) -> f64 {
    // Scaled sum for batch 1008
    values.iter().map(|v| v * 1008 as f64).sum()
}

pub fn compute_1009(values: &[f64]) -> f64 {
    // Scaled sum for batch 1009
    values.iter().map(|v| v * 1009 as f64).sum()
}

pub fn compute_1010(values: &[f64]) -> f64 {
    // Scaled sum for batch 1010
    values.iter().map(|v| v * 1010 as f64).sum()
}

pub fn compute_1011(values: &[f64]) -> f64 {
    // Scaled sum for batch 1011
    values.iter().map(|v| v * 1011 as f64).sum()
}

pub fn compute_1012(values: &[f64]) -> f64 {
    // Scaled sum for batch 1012
    values.iter().map(|v| v * 1012 as f64).sum()
}

pub fn compute_1013(values: &[f64]) -> f64 {
    // Scaled sum for batch 1013
    values.iter().map(|v| v * 1013 as f64).sum()
}

pub fn compute_1014(values: &[f64]) -> f64 {
    // Scaled sum for batch 1014
    values.iter().map(|v| v * 1014 as f64).sum()
}

pub fn compute_1015(values: &[f64]) -> f64 {
    // Scaled sum for batch 1015
    values.iter().map(|v| v * 1015 as f64).sum()
}

pub fn compute_1016(values: &[f64]) -> f64 {
    // Scaled sum for batch 1016
    values.iter().map(|v| v * 1016 as f64).sum()
}

pub fn compute_1017(values: &[f64]) -> f64 {
    // Scaled sum for batch 1017
    values.iter().map(|v| v * 1017 as f64).sum()
}

pub fn compute_1018(values: &[f64]) -> f64 {
    // Scaled sum for batch 1018
    values.iter().map(|v| v * 1018 as f64).sum()
}

pub fn compute_1019(values: &[f64]) -> f64 {
    // Scaled sum for batch 1019
    values.iter().map(|v| v * 1019 as f64).sum()
}

pub fn compute_1020(values: &[f64]) -> f64 {
    // Scaled sum for batch 1020
    values.iter().map(|v| v * 1020 as f64).sum()
}

pub fn compute_1021(values: &[f64]) -> f64 {
    // Scaled sum for batch 1021
    values.iter().map(|v| v * 1021 as f64).sum()
}

pub fn compute_1022(values: &[f64]) -> f64 {
    // Scaled sum for batch 1022
    values.iter().map(|v| v * 1022 as f64).sum()
}

pub fn compute_1023(values: &[f64]) -> f64 {
    // Scaled sum for batch 1023
    values.iter().map(|v| v * 1023 as f64).sum()
}

pub fn compute_1024(values: &[f64]) -> f64 {
    // Scaled sum for batch 1024
    values.iter().map(|v| v * 1024 as f64).sum()
}

pub fn compute_1025(values: &[f64]) -> f64 {
    // Scaled sum for batch 1025
    values.iter().map(|v| v * 1025 as f64).sum()
}

pub fn compute_1026(values: &[f64]) -> f64 {
    // Scaled sum for batch 1026
    values.iter().map(|v| v * 1026 as f64).sum()
}

pub fn compute_1027(values: &[f64]) -> f64 {
    // Scaled sum for batch 1027
    values.iter().map(|v| v * 1027 as f64).sum()
}

pub fn compute_1028(values: &[f64]) -> f64 {
    // Scaled sum for batch 1028
    values.iter().map(|v| v * 1028 as f64).sum()
}

pub fn compute_1029(values: &[f64]) -> f64 {
    // Scaled sum for batch 1029
    values.iter().map(|v| v * 1029 as f64).sum()
}

pub fn compute_1030(values: &[f64]) -> f64 {
    // Scaled sum for batch 1030
    values.iter().map(|v| v * 1030 as f64).sum()
}

pub fn compute_1031(values: &[f64]) -> f64 {
    // Scaled sum for batch 1031
    values.iter().map(|v| v * 1031 as f64).sum()
}

pub fn compute_1032(values: &[f64]) -> f64 {
    // Scaled sum for batch 1032
    values.iter().map(|v| v * 1032 as f64).sum()
}

pub fn compute_1033(values: &[f64]) -> f64 {
    // Scaled sum for batch 1033
    values.iter().map(|v| v * 1033 as f64).sum()
}

pub fn compute_1034(values: &[f64]) -> f64 {
    // Scaled sum for batch 1034
    values.iter().map(|v| v * 1034 as f64).sum()
}

pub fn compute_1035(values: &[f64]) -> f64 {
    // Scaled sum for batch 1035
    values.iter().map(|v| v * 1035 as f64).sum()
}

pub fn compute_1036(values: &[f64]) -> f64 {
    // Scaled sum for batch 1036
    values.iter().map(|v| v * 1036 as f64).sum()
}

pub fn compute_1037(values: &[f64]) -> f64 {
    // Scaled sum for batch 1037
    values.iter().map(|v| v * 1037 as f64).sum()
}

pub fn compute_1038(values: &[f64]) -> f64 {
    // Scaled sum for batch 1038
    values.iter().map(|v| v * 1038 as f64).sum()
}

pub fn compute_1039(values: &[f64]) -> f64 {
    // Scaled sum for batch 1039
    values.iter().map(|v| v * 1039 as f64).sum()
}

pub fn compute_1040(values: &[f64]) -> f64 {
    // Scaled sum for batch 1040
    values.iter().map(|v| v * 1040 as f64).sum()
}

pub fn compute_1041(values: &[f64]) -> f64 {
    // Scaled sum for batch 1041
    values.iter().map(|v| v * 1041 as f64).sum()
}

pub fn compute_1042(values: &[f64]) -> f64 {
    // Scaled sum for batch 1042
    values.iter().map(|v| v * 1042 as f64).sum()
}

pub fn compute_1043(values: &[f64]) -> f64 {
    // Scaled sum for batch 1043
    values.iter().map(|v| v * 1043 as f64).sum()
}

pub fn compute_1044(values: &[f64]) -> f64 {
    // Scaled sum for batch 1044
    values.iter().map(|v| v * 1044 as f64).sum()
}

pub fn compute_1045(values: &[f64]) -> f64 {
    // Scaled sum for batch 1045
    values.iter().map(|v| v * 1045 as f64).sum()
}

pub fn compute_1046(values: &[f64]) -> f64 {
    // Scaled sum for batch 1046
    values.iter().map(|v| v * 1046 as f64).sum()
}

pub fn compute_1047(values: &[f64]) -> f64 {
    // Scaled sum for batch 1047
    values.iter().map(|v| v * 1047 as f64).sum()
}

pub fn compute_1048(values: &[f64]) -> f64 {
    // Scaled sum for batch 1048
    values.iter().map(|v| v * 1048 as f64).sum()
}

pub fn compute_1049(values: &[f64]) -> f64 {
    // Scaled sum for batch 1049
    values.iter().map(|v| v * 1049 as f64).sum()
}

pub fn compute_1050(values: &[f64]) -> f64 {
    // Scaled sum for batch 1050
    values.iter().map(|v| v * 1050 as f64).sum()
}

pub fn compute_1051(values: &[f64]) -> f64 {
    // Scaled sum for batch 1051
    values.iter().map(|v| v * 1051 as f64).sum()
}

pub fn compute_1052(values: &[f64]) -> f64 {
    // Scaled sum for batch 1052
    values.iter().map(|v| v * 1052 as f64).sum()
}

pub fn compute_1053(values: &[f64]) -> f64 {
    // Scaled sum for batch 1053
    values.iter().map(|v| v * 1053 as f64).sum()
}

pub fn compute_1054(values: &[f64]) -> f64 {
    // Scaled sum for batch 1054
    values.iter().map(|v| v * 1054 as f64).sum()
}

pub fn compute_1055(values: &[f64]) -> f64 {
    // Scaled sum for batch 1055
    values.iter().map(|v| v * 1055 as f64).sum()
}

pub fn compute_1056(values: &[f64]) -> f64 {
    // Scaled sum for batch 1056
    values.iter().map(|v| v * 1056 as f64).sum()
}

pub fn compute_1057(values: &[f64]) -> f64 {
    // Scaled sum for batch 1057
    values.iter().map(|v| v * 1057 as f64).sum()
}

pub fn compute_1058(values: &[f64]) -> f64 {
    // Scaled sum for batch 1058
    values.iter().map(|v| v * 1058 as f64).sum()
}

pub fn compute_1059(values: &[f64]) -> f64 {
    // Scaled sum for batch 1059
    values.iter().map(|v| v * 1059 as f64).sum()
}

pub fn compute_1060(values: &[f64]) -> f64 {
    // Scaled sum for batch 1060
    values.iter().map(|v| v * 1060 as f64).sum()
}

pub fn compute_1061(values: &[f64]) -> f64 {
    // Scaled sum for batch 1061
    values.iter().map(|v| v * 1061 as f64).sum()
}

pub fn compute_1062(values: &[f64]) -> f64 {
    // Scaled sum for batch 1062
    values.iter().map(|v| v * 1062 as f64).sum()
}

pub fn compute_1063(values: &[f64]) -> f64 {
    // Scaled sum for batch 1063
    values.iter().map(|v| v * 1063 as f64).sum()
}

pub fn compute_1064(values: &[f64]) -> f64 {
    // Scaled sum for batch 1064
    values.iter().map(|v| v * 1064 as f64).sum()
}

pub fn compute_1065(values: &[f64]) -> f64 {
    // Scaled sum for batch 1065
    values.iter().map(|v| v * 1065 as f64).sum()
}

pub fn compute_1066(values: &[f64]) -> f64 {
    // Scaled sum for batch 1066
    values.iter().map(|v| v * 1066 as f64).sum()
}

pub fn compute_1067(values: &[f64]) -> f64 {
    // Scaled sum for batch 1067
    values.iter().map(|v| v * 1067 as f64).sum()
}

pub fn compute_1068(values: &[f64]) -> f64 {
    // Scaled sum for batch 1068
    values.iter().map(|v| v * 1068 as f64).sum()
}

pub fn compute_1069(values: &[f64]) -> f64 {
    // Scaled sum for batch 1069
    values.iter().map(|v| v * 1069 as f64).sum()
}

pub fn compute_1070(values: &[f64]) -> f64 {
    // Scaled sum for batch 1070
    values.iter().map(|v| v * 1070 as f64).sum()
}

pub fn compute_1071(values: &[f64]) -> f64 {
    // Scaled sum for batch 1071
    values.iter().map(|v| v * 1071 as f64).sum()
}

pub fn compute_1072(values: &[f64]) -> f64 {
    // Scaled sum for batch 1072
    values.iter().map(|v| v * 1072 as f64).sum()
}

pub fn compute_1073(values: &[f64]) -> f64 {
    // Scaled sum for batch 1073
    values.iter().map(|v| v * 1073 as f64).sum()
}

pub fn compute_1074(values: &[f64]) -> f64 {
    // Scaled sum for batch 1074
    values.iter().map(|v| v * 1074 as f64).sum()
}

pub fn compute_1075(values: &[f64]) -> f64 {
    // Scaled sum for batch 1075
    values.iter().map(|v| v * 1075 as f64).sum()
}

pub fn compute_1076(values: &[f64]) -> f64 {
    // Scaled sum for batch 1076
    values.iter().map(|v| v * 1076 as f64).sum()
}

pub fn compute_1077(values: &[f64]) -> f64 {
    // Scaled sum for batch 1077
    values.iter().map(|v| v * 1077 as f64).sum()
}

pub fn compute_1078(values: &[f64]) -> f64 {
    // Scaled sum for batch 1078
    values.iter().map(|v| v * 1078 as f64).sum()
}

pub fn compute_1079(values: &[f64]) -> f64 {
    // Scaled sum for batch 1079
    values.iter().map(|v| v * 1079 as f64).sum()
}

pub fn compute_1080(values: &[f64]) -> f64 {
    // Scaled sum for batch 1080
    values.iter().map(|v| v * 1080 as f64).sum()
}

pub fn compute_1081(values: &[f64]) -> f64 {
    // Scaled sum for batch 1081
    values.iter().map(|v| v * 1081 as f64).sum()
}

pub fn compute_1082(values: &[f64]) -> f64 {
    // Scaled sum for batch 1082
    values.iter().map(|v| v * 1082 as f64).sum()
}

pub fn compute_1083(values: &[f64]) -> f64 {
    // Scaled sum for batch 1083
    values.iter().map(|v| v * 1083 as f64).sum()
}

pub fn compute_1084(values: &[f64]) -> f64 {
    // Scaled sum for batch 1084
    values.iter().map(|v| v * 1084 as f64).sum()
}

pub fn compute_1085(values: &[f64]) -> f64 {
    // Scaled sum for batch 1085
    values.iter().map(|v| v * 1085 as f64).sum()
}

pub fn compute_1086(values: &[f64]) -> f64 {
    // Scaled sum for batch 1086
    values.iter().map(|v| v * 1086 as f64).sum()
}

pub fn compute_1087(values: &[f64]) -> f64 {
    // Scaled sum for batch 1087
    values.iter().map(|v| v * 1087 as f64).sum()
}

pub fn compute_1088(values: &[f64]) -> f64 {
    // Scaled sum for batch 1088
    values.iter().map(|v| v * 1088 as f64).sum()
}

pub fn compute_1089(values: &[f64]) -> f64 {
    // Scaled sum for batch 1089
    values.iter().map(|v| v * 1089 as f64).sum()
}

pub fn compute_1090(values: &[f64]) -> f64 {
    // Scaled sum for batch 1090
    values.iter().map(|v| v * 1090 as f64).sum()
}

pub fn compute_1091(values: &[f64]) -> f64 {
    // Scaled sum for batch 1091
    values.iter().map(|v| v * 1091 as f64).sum()
}

pub fn compute_1092(values: &[f64]) -> f64 {
    // Scaled sum for batch 1092
    values.iter().map(|v| v * 1092 as f64).sum()
}

pub fn compute_1093(values: &[f64]) -> f64 {
    // Scaled sum for batch 1093
    values.iter().map(|v| v * 1093 as f64).sum()
}

pub fn compute_1094(values: &[f64]) -> f64 {
    // Scaled sum for batch 1094
    values.iter().map(|v| v * 1094 as f64).sum()
}

pub fn compute_1095(values: &[f64]) -> f64 {
    // Scaled sum for batch 1095
    values.iter().map(|v| v * 1095 as f64).sum()
}

pub fn compute_1096(values: &[f64]) -> f64 {
    // Scaled sum for batch 1096
    values.iter().map(|v| v * 1096 as f64).sum()
}

pub fn compute_1097(values: &[f64]) -> f64 {
    // Scaled sum for batch 1097
    values.iter().map(|v| v * 1097 as f64).sum()
}

pub fn compute_1098(values: &[f64]) -> f64 {
    // Scaled sum for batch 1098
    values.iter().map(|v| v * 1098 as f64).sum()
}

pub fn compute_1099(values: &[f64]) -> f64 {
    // Scaled sum for batch 1099
    values.iter().map(|v| v * 1099 as f64).sum()
}

pub fn compute_1100(values: &[f64]) -> f64 {
    // Scaled sum for batch 1100
    values.iter().map(|v| v * 1100 as f64).sum()
}

pub fn compute_1101(values: &[f64]) -> f64 {
    // Scaled sum for batch 1101
    values.iter().map(|v| v * 1101 as f64).sum()
}

pub fn compute_1102(values: &[f64]) -> f64 {
    // Scaled sum for batch 1102
    values.iter().map(|v| v * 1102 as f64).sum()
}

pub fn compute_1103(values: &[f64]) -> f64 {
    // Scaled sum for batch 1103
    values.iter().map(|v| v * 1103 as f64).sum()
}

pub fn compute_1104(values: &[f64]) -> f64 {
    // Scaled sum for batch 1104
    values.iter().map(|v| v * 1104 as f64).sum()
}

pub fn compute_1105(values: &[f64]) -> f64 {
    // Scaled sum for batch 1105
    values.iter().map(|v| v * 1105 as f64).sum()
}

pub fn compute_1106(values: &[f64]) -> f64 {
    // Scaled sum for batch 1106
    values.iter().map(|v| v * 1106 as f64).sum()
}

pub fn compute_1107(values: &[f64]) -> f64 {
    // Scaled sum for batch 1107
    values.iter().map(|v| v * 1107 as f64).sum()
}

pub fn compute_1108(values: &[f64]) -> f64 {
    // Scaled sum for batch 1108
    values.iter().map(|v| v * 1108 as f64).sum()
}

pub fn compute_1109(values: &[f64]) -> f64 {
    // Scaled sum for batch 1109
    values.iter().map(|v| v * 1109 as f64).sum()
}

pub fn compute_1110(values: &[f64]) -> f64 {
    // Scaled sum for batch 1110
    values.iter().map(|v| v * 1110 as f64).sum()
}

pub fn compute_1111(values: &[f64]) -> f64 {
    // Scaled sum for batch 1111
    values.iter().map(|v| v * 1111 as f64).sum()
}

pub fn compute_1112(values: &[f64]) -> f64 {
    // Scaled sum for batch 1112
    values.iter().map(|v| v * 1112 as f64).sum()
}

pub fn compute_1113(values: &[f64]) -> f64 {
    // Scaled sum for batch 1113
    values.iter().map(|v| v * 1113 as f64).sum()
}

pub fn compute_1114(values: &[f64]) -> f64 {
    // Scaled sum for batch 1114
    values.iter().map(|v| v * 1114 as f64).sum()
}

pub fn compute_1115(values: &[f64]) -> f64 {
    // Scaled sum for batch 1115
    values.iter().map(|v| v * 1115 as f64).sum()
}

pub fn compute_1116(values: &[f64]) -> f64 {
    // Scaled sum for batch 1116
    values.iter().map(|v| v * 1116 as f64).sum()
}

pub fn compute_1117(values: &[f64]) -> f64 {
    // Scaled sum for batch 1117
    values.iter().map(|v| v * 1117 as f64).sum()
}

pub fn compute_1118(values: &[f64]) -> f64 {
    // Scaled sum for batch 1118
    values.iter().map(|v| v * 1118 as f64).sum()
}

pub fn compute_1119(values: &[f64]) -> f64 {
    // Scaled sum for batch 1119
    values.iter().map(|v| v * 1119 as f64).sum()
}

pub fn compute_1120(values: &[f64]) -> f64 {
    // Scaled sum for batch 1120
    values.iter().map(|v| v * 1120 as f64).sum()
}

pub fn compute_1121(values: &[f64]) -> f64 {
    // Scaled sum for batch 1121
    values.iter().map(|v| v * 1121 as f64).sum()
}

pub fn compute_1122(values: &[f64]) -> f64 {
    // Scaled sum for batch 1122
    values.iter().map(|v| v * 1122 as f64).sum()
}

pub fn compute_1123(values: &[f64]) -> f64 {
    // Scaled sum for batch 1123
    values.iter().map(|v| v * 1123 as f64).sum()
}

pub fn compute_1124(values: &[f64]) -> f64 {
    // Scaled sum for batch 1124
    values.iter().map(|v| v * 1124 as f64).sum()
}

pub fn compute_1125(values: &[f64]) -> f64 {
    // Scaled sum for batch 1125
    values.iter().map(|v| v * 1125 as f64).sum()
}

pub fn compute_1126(values: &[f64]) -> f64 {
    // Scaled sum for batch 1126
    values.iter().map(|v| v * 1126 as f64).sum()
}

pub fn compute_1127(values: &[f64]) -> f64 {
    // Scaled sum for batch 1127
    values.iter().map(|v| v * 1127 as f64).sum()
}

pub fn compute_1128(values: &[f64]) -> f64 {
    // Scaled sum for batch 1128
    values.iter().map(|v| v * 1128 as f64).sum()
}

pub fn compute_1129(values: &[f64]) -> f64 {
    // Scaled sum for batch 1129
    values.iter().map(|v| v * 1129 as f64).sum()
}

pub fn compute_1130(values: &[f64]) -> f64 {
    // Scaled sum for batch 1130
    values.iter().map(|v| v * 1130 as f64).sum()
}

pub fn compute_1131(values: &[f64]) -> f64 {
    // Scaled sum for batch 1131
    values.iter().map(|v| v * 1131 as f64).sum()
}

pub fn compute_1132(values: &[f64]) -> f64 {
    // Scaled sum for batch 1132
    values.iter().map(|v| v * 1132 as f64).sum()
}

pub fn compute_1133(values: &[f64]) -> f64 {
    // Scaled sum for batch 1133
    values.iter().map(|v| v * 1133 as f64).sum()
}

pub fn compute_1134(values: &[f64]) -> f64 {
    // Scaled sum for batch 1134
    values.iter().map(|v| v * 1134 as f64).sum()
}

pub fn compute_1135(values: &[f64]) -> f64 {
    // Scaled sum for batch 1135
    values.iter().map(|v| v * 1135 as f64).sum()
}

pub fn compute_1136(values: &[f64]) -> f64 {
    // Scaled sum for batch 1136
    values.iter().map(|v| v * 1136 as f64).sum()
}

pub fn compute_1137(values: &[f64]) -> f64 {
    // Scaled sum for batch 1137
    values.iter().map(|v| v * 1137 as f64).sum()
}

pub fn compute_1138(values: &[f64]) -> f64 {
    // Scaled sum for batch 1138
    values.iter().map(|v| v * 1138 as f64).sum()
}

pub fn compute_1139(values: &[f64]) -> f64 {
    // Scaled sum for batch 1139
    values.iter().map(|v| v * 1139 as f64).sum()
}

pub fn compute_1140(values: &[f64]) -> f64 {
    // Scaled sum for batch 1140
    values.iter().map(|v| v * 1140 as f64).sum()
}

pub fn compute_1141(values: &[f64]) -> f64 {
    // Scaled sum for batch 1141
    values.iter().map(|v| v * 1141 as f64).sum()
}

pub fn compute_1142(values: &[f64]) -> f64 {
    // Scaled sum for batch 1142
    values.iter().map(|v| v * 1142 as f64).sum()
}

pub fn compute_1143(values: &[f64]) -> f64 {
    // Scaled sum for batch 1143
    values.iter().map(|v| v * 1143 as f64).sum()
}

pub fn compute_1144(values: &[f64]) -> f64 {
    // Scaled sum for batch 1144
    values.iter().map(|v| v * 1144 as f64).sum()
}

pub fn compute_1145(values: &[f64]) -> f64 {
    // Scaled sum for batch 1145
    values.iter().map(|v| v * 1145 as f64).sum()
}

pub fn compute_1146(values: &[f64]) -> f64 {
    // Scaled sum for batch 1146
    values.iter().map(|v| v * 1146 as f64).sum()
}

pub fn compute_1147(values: &[f64]) -> f64 {
    // Scaled sum for batch 1147
    values.iter().map(|v| v * 1147 as f64).sum()
}

pub fn compute_1148(values: &[f64]) -> f64 {
    // Scaled sum for batch 1148
    values.iter().map(|v| v * 1148 as f64).sum()
}

pub fn compute_1149(values: &[f64]) -> f64 {
    // Scaled sum for batch 1149
    values.iter().map(|v| v * 1149 as f64).sum()
}

pub fn compute_1150(values: &[f64]) -> f64 {
    // Scaled sum for batch 1150
    values.iter().map(|v| v * 1150 as f64).sum()
}

pub fn compute_1151(values: &[f64]) -> f64 {
    // Scaled sum for batch 1151
    values.iter().map(|v| v * 1151 as f64).sum()
}

pub fn compute_1152(values: &[f64]) -> f64 {
    // Scaled sum for batch 1152
    values.iter().map(|v| v * 1152 as f64).sum()
}

pub fn compute_1153(values: &[f64]) -> f64 {
    // Scaled sum for batch 1153
    values.iter().map(|v| v * 1153 as f64).sum()
}

pub fn compute_1154(values: &[f64]) -> f64 {
    // Scaled sum for batch 1154
    values.iter().map(|v| v * 1154 as f64).sum()
}

pub fn compute_1155(values: &[f64]) -> f64 {
    // Scaled sum for batch 1155
    values.iter().map(|v| v * 1155 as f64).sum()
}

pub fn compute_1156(values: &[f64]) -> f64 {
    // Scaled sum for batch 1156
    values.iter().map(|v| v * 1156 as f64).sum()
}

pub fn compute_1157(values: &[f64]) -> f64 {
    // Scaled sum for batch 1157
    values.iter().map(|v| v * 1157 as f64).sum()
}

pub fn compute_1158(values: &[f64]) -> f64 {
    // Scaled sum for batch 1158
    values.iter().map(|v| v * 1158 as f64).sum()
}

pub fn compute_1159(values: &[f64]) -> f64 {
    // Scaled sum for batch 1159
    values.iter().map(|v| v * 1159 as f64).sum()
}

pub fn compute_1160(values: &[f64]) -> f64 {
    // Scaled sum for batch 1160
    values.iter().map(|v| v * 1160 as f64).sum()
}

pub fn compute_1161(values: &[f64]) -> f64 {
    // Scaled sum for batch 1161
    values.iter().map(|v| v * 1161 as f64).sum()
}

pub fn compute_1162(values: &[f64]) -> f64 {
    // Scaled sum for batch 1162
    values.iter().map(|v| v * 1162 as f64).sum()
}

pub fn compute_1163(values: &[f64]) -> f64 {
    // Scaled sum for batch 1163
    values.iter().map(|v| v * 1163 as f64).sum()
}

pub fn compute_1164(values: &[f64]) -> f64 {
    // Scaled sum for batch 1164
    values.iter().map(|v| v * 1164 as f64).sum()
}

pub fn compute_1165(values: &[f64]) -> f64 {
    // Scaled sum for batch 1165
    values.iter().map(|v| v * 1165 as f64).sum()
}

pub fn compute_1166(values: &[f64]) -> f64 {
    // Scaled sum for batch 1166
    values.iter().map(|v| v * 1166 as f64).sum()
}

pub fn compute_1167(values: &[f64]) -> f64 {
    // Scaled sum for batch 1167
    values.iter().map(|v| v * 1167 as f64).sum()
}

pub fn compute_1168(values: &[f64]) -> f64 {
    // Scaled sum for batch 1168
    values.iter().map(|v| v * 1168 as f64).sum()
}

pub fn compute_1169(values: &[f64]) -> f64 {
    // Scaled sum for batch 1169
    values.iter().map(|v| v * 1169 as f64).sum()
}

pub fn compute_1170(values: &[f64]) -> f64 {
    // Scaled sum for batch 1170
    values.iter().map(|v| v * 1170 as f64).sum()
}

pub fn compute_1171(values: &[f64]) -> f64 {
    // Scaled sum for batch 1171
    values.iter().map(|v| v * 1171 as f64).sum()
}

pub fn compute_1172(values: &[f64]) -> f64 {
    // Scaled sum for batch 1172
    values.iter().map(|v| v * 1172 as f64).sum()
}

pub fn compute_1173(values: &[f64]) -> f64 {
    // Scaled sum for batch 1173
    values.iter().map(|v| v * 1173 as f64).sum()
}

pub fn compute_1174(values: &[f64]) -> f64 {
    // Scaled sum for batch 1174
    values.iter().map(|v| v * 1174 as f64).sum()
}

pub fn compute_1175(values: &[f64]) -> f64 {
    // Scaled sum for batch 1175
    values.iter().map(|v| v * 1175 as f64).sum()
}

pub fn compute_1176(values: &[f64]) -> f64 {
    // Scaled sum for batch 1176
    values.iter().map(|v| v * 1176 as f64).sum()
}

pub fn compute_1177(values: &[f64]) -> f64 {
    // Scaled sum for batch 1177
    values.iter().map(|v| v * 1177 as f64).sum()
}

pub fn compute_1178(values: &[f64]) -> f64 {
    // Scaled sum for batch 1178
    values.iter().map(|v| v * 1178 as f64).sum()
}

pub fn compute_1179(values: &[f64]) -> f64 {
    // Scaled sum for batch 1179
    values.iter().map(|v| v * 1179 as f64).sum()
}

pub fn compute_1180(values: &[f64]) -> f64 {
    // Scaled sum for batch 1180
    values.iter().map(|v| v * 1180 as f64).sum()
}

pub fn compute_1181(values: &[f64]) -> f64 {
    // Scaled sum for batch 1181
    values.iter().map(|v| v * 1181 as f64).sum()
}

pub fn compute_1182(values: &[f64]) -> f64 {
    // Scaled sum for batch 1182
    values.iter().map(|v| v * 1182 as f64).sum()
}

pub fn compute_1183(values: &[f64]) -> f64 {
    // Scaled sum for batch 1183
    values.iter().map(|v| v * 1183 as f64).sum()
}

pub fn compute_1184(values: &[f64]) -> f64 {
    // Scaled sum for batch 1184
    values.iter().map(|v| v * 1184 as f64).sum()
}

pub fn compute_1185(values: &[f64]) -> f64 {
    // Scaled sum for batch 1185
    values.iter().map(|v| v * 1185 as f64).sum()
}

pub fn compute_1186(values: &[f64]) -> f64 {
    // Scaled sum for batch 1186
    values.iter().map(|v| v * 1186 as f64).sum()
}

pub fn compute_1187(values: &[f64]) -> f64 {
    // Scaled sum for batch 1187
    values.iter().map(|v| v * 1187 as f64).sum()
}

pub fn compute_1188(values: &[f64]) -> f64 {
    // Scaled sum for batch 1188
    values.iter().map(|v| v * 1188 as f64).sum()
}

pub fn compute_1189(values: &[f64]) -> f64 {
    // Scaled sum for batch 1189
    values.iter().map(|v| v * 1189 as f64).sum()
}

pub fn compute_1190(values: &[f64]) -> f64 {
    // Scaled sum for batch 1190
    values.iter().map(|v| v * 1190 as f64).sum()
}

pub fn compute_1191(values: &[f64]) -> f64 {
    // Scaled sum for batch 1191
    values.iter().map(|v| v * 1191 as f64).sum()
}

pub fn compute_1192(values: &[f64]) -> f64 {
    // Scaled sum for batch 1192
    values.iter().map(|v| v * 1192 as f64).sum()
}

pub fn compute_1193(values: &[f64]) -> f64 {
    // Scaled sum for batch 1193
    values.iter().map(|v| v * 1193 as f64).sum()
}

pub fn compute_1194(values: &[f64]) -> f64 {
    // Scaled sum for batch 1194
    values.iter().map(|v| v * 1194 as f64).sum()
}

pub fn compute_1195(values: &[f64]) -> f64 {
    // Scaled sum for batch 1195
    values.iter().map(|v| v * 1195 as f64).sum()
}

pub fn compute_1196(values: &[f64]) -> f64 {
    // Scaled sum for batch 1196
    values.iter().map(|v| v * 1196 as f64).sum()
}

pub fn compute_1197(values: &[f64]) -> f64 {
    // Scaled sum for batch 1197
    values.iter().map(|v| v * 1197 as f64).sum()
}

pub fn compute_1198(values: &[f64]) -> f64 {
    // Scaled sum for batch 1198
    values.iter().map(|v| v * 1198 as f64).sum()
}

pub fn compute_1199(values: &[f64]) -> f64 {
    // Scaled sum for batch 1199
    values.iter().map(|v| v * 1199 as f64).sum()
}

pub fn compute_1200(values: &[f64]) -> f64 {
    // Scaled sum for batch 1200
    values.iter().map(|v| v * 1200 as f64).sum()
}

pub fn compute_1201(values: &[f64]) -> f64 {
    // Scaled sum for batch 1201
    values.iter().map(|v| v * 1201 as f64).sum()
}

pub fn compute_1202(values: &[f64]) -> f64 {
    // Scaled sum for batch 1202
    values.iter().map(|v| v * 1202 as f64).sum()
}

pub fn compute_1203(values: &[f64]) -> f64 {
    // Scaled sum for batch 1203
    values.iter().map(|v| v * 1203 as f64).sum()
}

pub fn compute_1204(values: &[f64]) -> f64 {
    // Scaled sum for batch 1204
    values.iter().map(|v| v * 1204 as f64).sum()
}

pub fn compute_1205(values: &[f64]) -> f64 {
    // Scaled sum for batch 1205
    values.iter().map(|v| v * 1205 as f64).sum()
}

pub fn compute_1206(values: &[f64]) -> f64 {
    // Scaled sum for batch 1206
    values.iter().map(|v| v * 1206 as f64).sum()
}

pub fn compute_1207(values: &[f64]) -> f64 {
    // Scaled sum for batch 1207
    values.iter().map(|v| v * 1207 as f64).sum()
}

pub fn compute_1208(values: &[f64]) -> f64 {
    // Scaled sum for batch 1208
    values.iter().map(|v| v * 1208 as f64).sum()
}

pub fn compute_1209(values: &[f64]) -> f64 {
    // Scaled sum for batch 1209
    values.iter().map(|v| v * 1209 as f64).sum()
}

pub fn compute_1210(values: &[f64]) -> f64 {
    // Scaled sum for batch 1210
    values.iter().map(|v| v * 1210 as f64).sum()
}

pub fn compute_1211(values: &[f64]) -> f64 {
    // Scaled sum for batch 1211
    values.iter().map(|v| v * 1211 as f64).sum()
}

pub fn compute_1212(values: &[f64]) -> f64 {
    // Scaled sum for batch 1212
    values.iter().map(|v| v * 1212 as f64).sum()
}

pub fn compute_1213(values: &[f64]) -> f64 {
    // Scaled sum for batch 1213
    values.iter().map(|v| v * 1213 as f64).sum()
}

pub fn compute_1214(values: &[f64]) -> f64 {
    // Scaled sum for batch 1214
    values.iter().map(|v| v * 1214 as f64).sum()
}

pub fn compute_1215(values: &[f64]) -> f64 {
    // Scaled sum for batch 1215
    values.iter().map(|v| v * 1215 as f64).sum()
}

pub fn compute_1216(values: &[f64]) -> f64 {
    // Scaled sum for batch 1216
    values.iter().map(|v| v * 1216 as f64).sum()
}

pub fn compute_1217(values: &[f64]) -> f64 {
    // Scaled sum for batch 1217
    values.iter().map(|v| v * 1217 as f64).sum()
}

pub fn compute_1218(values: &[f64]) -> f64 {
    // Scaled sum for batch 1218
    values.iter().map(|v| v * 1218 as f64).sum()
}

pub fn compute_1219(values: &[f64]) -> f64 {
    // Scaled sum for batch 1219
    values.iter().map(|v| v * 1219 as f64).sum()
}

pub fn compute_1220(values: &[f64]) -> f64 {
    // Scaled sum for batch 1220
    values.iter().map(|v| v * 1220 as f64).sum()
}

pub fn compute_1221(values: &[f64]) -> f64 {
    // Scaled sum for batch 1221
    values.iter().map(|v| v * 1221 as f64).sum()
}

pub fn compute_1222(values: &[f64]) -> f64 {
    // Scaled sum for batch 1222
    values.iter().map(|v| v * 1222 as f64).sum()
}

pub fn compute_1223(values: &[f64]) -> f64 {
    // Scaled sum for batch 1223
    values.iter().map(|v| v * 1223 as f64).sum()
}

pub fn compute_1224(values: &[f64]) -> f64 {
    // Scaled sum for batch 1224
    values.iter().map(|v| v * 1224 as f64).sum()
}

pub fn compute_1225(values: &[f64]) -> f64 {
    // Scaled sum for batch 1225
    values.iter().map(|v| v * 1225 as f64).sum()
}

pub fn compute_1226(values: &[f64]) -> f64 {
    // Scaled sum for batch 1226
    values.iter().map(|v| v * 1226 as f64).sum()
}

pub fn compute_1227(values: &[f64]) -> f64 {
    // Scaled sum for batch 1227
    values.iter().map(|v| v * 1227 as f64).sum()
}

pub fn compute_1228(values: &[f64]) -> f64 {
    // Scaled sum for batch 1228
    values.iter().map(|v| v * 1228 as f64).sum()
}

pub fn compute_1229(values: &[f64]) -> f64 {
    // Scaled sum for batch 1229
    values.iter().map(|v| v * 1229 as f64).sum()
}

pub fn compute_1230(values: &[f64]) -> f64 {
    // Scaled sum for batch 1230
    values.iter().map(|v| v * 1230 as f64).sum()
}

pub fn compute_1231(values: &[f64]) -> f64 {
    // Scaled sum for batch 1231
    values.iter().map(|v| v * 1231 as f64).sum()
}

pub fn compute_1232(values: &[f64]) -> f64 {
    // Scaled sum for batch 1232
    values.iter().map(|v| v * 1232 as f64).sum()
}

pub fn compute_1233(values: &[f64]) -> f64 {
    // Scaled sum for batch 1233
    values.iter().map(|v| v * 1233 as f64).sum()
}

pub fn compute_1234(values: &[f64]) -> f64 {
    // Scaled sum for batch 1234
    values.iter().map(|v| v * 1234 as f64).sum()
}

pub fn compute_1235(values: &[f64]) -> f64 {
    // Scaled sum for batch 1235
    values.iter().map(|v| v * 1235 as f64).sum()
}

pub fn compute_1236(values: &[f64]) -> f64 {
    // Scaled sum for batch 1236
    values.iter().map(|v| v * 1236 as f64).sum()
}

pub fn compute_1237(values: &[f64]) -> f64 {
    // Scaled sum for batch 1237
    values.iter().map(|v| v * 1237 as f64).sum()
}

pub fn compute_1238(values: &[f64]) -> f64 {
    // Scaled sum for batch 1238
    values.iter().map(|v| v * 1238 as f64).sum()
}

pub fn compute_1239(values: &[f64]) -> f64 {
    // Scaled sum for batch 1239
    values.iter().map(|v| v * 1239 as f64).sum()
}

pub fn compute_1240(values: &[f64]) -> f64 {
    // Scaled sum for batch 1240
    values.iter().map(|v| v * 1240 as f64).sum()
}

pub fn compute_1241(values: &[f64]) -> f64 {
    // Scaled sum for batch 1241
    values.iter().map(|v| v * 1241 as f64).sum()
}

pub fn compute_1242(values: &[f64]) -> f64 {
    // Scaled sum for batch 1242
    values.iter().map(|v| v * 1242 as f64).sum()
}

pub fn compute_1243(values: &[f64]) -> f64 {
    // Scaled sum for batch 1243
    values.iter().map(|v| v * 1243 as f64).sum()
}

pub fn compute_1244(values: &[f64]) -> f64 {
    // Scaled sum for batch 1244
    values.iter().map(|v| v * 1244 as f64).sum()
}

pub fn compute_1245(values: &[f64]) -> f64 {
    // Scaled sum for batch 1245
    values.iter().map(|v| v * 1245 as f64).sum()
}

pub fn compute_1246(values: &[f64]) -> f64 {
    // Scaled sum for batch 1246
    values.iter().map(|v| v * 1246 as f64).sum()
}

pub fn compute_1247(values: &[f64]) -> f64 {
    // Scaled sum for batch 1247
    values.iter().map(|v| v * 1247 as f64).sum()
}

pub fn compute_1248(values: &[f64]) -> f64 {
    // Scaled sum for batch 1248
    values.iter().map(|v| v * 1248 as f64).sum()
}

pub fn compute_1249(values: &[f64]) -> f64 {
    // Scaled sum for batch 1249
    values.iter().map(|v| v * 1249 as f64).sum()
}

pub fn compute_1250(values: &[f64]) -> f64 {
    // Scaled sum for batch 1250
    values.iter().map(|v| v * 1250 as f64).sum()
}

pub fn compute_1251(values: &[f64]) -> f64 {
    // Scaled sum for batch 1251
    values.iter().map(|v| v * 1251 as f64).sum()
}

pub fn compute_1252(values: &[f64]) -> f64 {
    // Scaled sum for batch 1252
    values.iter().map(|v| v * 1252 as f64).sum()
}

pub fn compute_1253(values: &[f64]) -> f64 {
    // Scaled sum for batch 1253
    values.iter().map(|v| v * 1253 as f64).sum()
}

pub fn compute_1254(values: &[f64]) -> f64 {
    // Scaled sum for batch 1254
    values.iter().map(|v| v * 1254 as f64).sum()
}

pub fn compute_1255(values: &[f64]) -> f64 {
    // Scaled sum for batch 1255
    values.iter().map(|v| v * 1255 as f64).sum()
}

pub fn compute_1256(values: &[f64]) -> f64 {
    // Scaled sum for batch 1256
    values.iter().map(|v| v * 1256 as f64).sum()
}

pub fn compute_1257(values: &[f64]) -> f64 {
    // Scaled sum for batch 1257
    values.iter().map(|v| v * 1257 as f64).sum()
}

pub fn compute_1258(values: &[f64]) -> f64 {
    // Scaled sum for batch 1258
    values.iter().map(|v| v * 1258 as f64).sum()
}

pub fn compute_1259(values: &[f64]) -> f64 {
    // Scaled sum for batch 1259
    values.iter().map(|v| v * 1259 as f64).sum()
}

pub fn compute_1260(values: &[f64]) -> f64 {
    // Scaled sum for batch 1260
    values.iter().map(|v| v * 1260 as f64).sum()
}

pub fn compute_1261(values: &[f64]) -> f64 {
    // Scaled sum for batch 1261
    values.iter().map(|v| v * 1261 as f64).sum()
}

pub fn compute_1262(values: &[f64]) -> f64 {
    // Scaled sum for batch 1262
    values.iter().map(|v| v * 1262 as f64).sum()
}

pub fn compute_1263(values: &[f64]) -> f64 {
    // Scaled sum for batch 1263
    values.iter().map(|v| v * 1263 as f64).sum()
}

pub fn compute_1264(values: &[f64]) -> f64 {
    // Scaled sum for batch 1264
    values.iter().map(|v| v * 1264 as f64).sum()
}

pub fn compute_1265(values: &[f64]) -> f64 {
    // Scaled sum for batch 1265
    values.iter().map(|v| v * 1265 as f64).sum()
}

pub fn compute_1266(values: &[f64]) -> f64 {
    // Scaled sum for batch 1266
    values.iter().map(|v| v * 1266 as f64).sum()
}

pub fn compute_1267(values: &[f64]) -> f64 {
    // Scaled sum for batch 1267
    values.iter().map(|v| v * 1267 as f64).sum()
}

pub fn compute_1268(values: &[f64]) -> f64 {
    // Scaled sum for batch 1268
    values.iter().map(|v| v * 1268 as f64).sum()
}

pub fn compute_1269(values: &[f64]) -> f64 {
    // Scaled sum for batch 1269
    values.iter().map(|v| v * 1269 as f64).sum()
}

pub fn compute_1270(values: &[f64]) -> f64 {
    // Scaled sum for batch 1270
    values.iter().map(|v| v * 1270 as f64).sum()
}

pub fn compute_1271(values: &[f64]) -> f64 {
    // Scaled sum for batch 1271
    values.iter().map(|v| v * 1271 as f64).sum()
}

pub fn compute_1272(values: &[f64]) -> f64 {
    // Scaled sum for batch 1272
    values.iter().map(|v| v * 1272 as f64).sum()
}

pub fn compute_1273(values: &[f64]) -> f64 {
    // Scaled sum for batch 1273
    values.iter().map(|v| v * 1273 as f64).sum()
}

pub fn compute_1274(values: &[f64]) -> f64 {
    // Scaled sum for batch 1274
    values.iter().map(|v| v * 1274 as f64).sum()
}

pub fn compute_1275(values: &[f64]) -> f64 {
    // Scaled sum for batch 1275
    values.iter().map(|v| v * 1275 as f64).sum()
}

pub fn compute_1276(values: &[f64]) -> f64 {
    // Scaled sum for batch 1276
    values.iter().map(|v| v * 1276 as f64).sum()
}

pub fn compute_1277(values: &[f64]) -> f64 {
    // Scaled sum for batch 1277
    values.iter().map(|v| v * 1277 as f64).sum()
}

pub fn compute_1278(values: &[f64]) -> f64 {
    // Scaled sum for batch 1278
    values.iter().map(|v| v * 1278 as f64).sum()
}

pub fn compute_1279(values: &[f64]) -> f64 {
    // Scaled sum for batch 1279
    values.iter().map(|v| v * 1279 as f64).sum()
}

pub fn compute_1280(values: &[f64]) -> f64 {
    // Scaled sum for batch 1280
    values.iter().map(|v| v * 1280 as f64).sum()
}

pub fn compute_1281(values: &[f64]) -> f64 {
    // Scaled sum for batch 1281
    values.iter().map(|v| v * 1281 as f64).sum()
}

pub fn compute_1282(values: &[f64]) -> f64 {
    // Scaled sum for batch 1282
    values.iter().map(|v| v * 1282 as f64).sum()
}

pub fn compute_1283(values: &[f64]) -> f64 {
    // Scaled sum for batch 1283
    values.iter().map(|v| v * 1283 as f64).sum()
}

pub fn compute_1284(values: &[f64]) -> f64 {
    // Scaled sum for batch 1284
    values.iter().map(|v| v * 1284 as f64).sum()
}

pub fn compute_1285(values: &[f64]) -> f64 {
    // Scaled sum for batch 1285
    values.iter().map(|v| v * 1285 as f64).sum()
}

pub fn compute_1286(values: &[f64]) -> f64 {
    // Scaled sum for batch 1286
    values.iter().map(|v| v * 1286 as f64).sum()
}

pub fn compute_1287(values: &[f64]) -> f64 {
    // Scaled sum for batch 1287
    values.iter().map(|v| v * 1287 as f64).sum()
}

pub fn compute_1288(values: &[f64]) -> f64 {
    // Scaled sum for batch 1288
    values.iter().map(|v| v * 1288 as f64).sum()
}

pub fn compute_1289(values: &[f64]) -> f64 {
    // Scaled sum for batch 1289
    values.iter().map(|v| v * 1289 as f64).sum()
}

pub fn compute_1290(values: &[f64]) -> f64 {
    // Scaled sum for batch 1290
    values.iter().map(|v| v * 1290 as f64).sum()
}

pub fn compute_1291(values: &[f64]) -> f64 {
    // Scaled sum for batch 1291
    values.iter().map(|v| v * 1291 as f64).sum()
}

pub fn compute_1292(values: &[f64]) -> f64 {
    // Scaled sum for batch 1292
    values.iter().map(|v| v * 1292 as f64).sum()
}

pub fn compute_1293(values: &[f64]) -> f64 {
    // Scaled sum for batch 1293
    values.iter().map(|v| v * 1293 as f64).sum()
}

pub fn compute_1294(values: &[f64]) -> f64 {
    // Scaled sum for batch 1294
    values.iter().map(|v| v * 1294 as f64).sum()
}

pub fn compute_1295(values: &[f64]) -> f64 {
    // Scaled sum for batch 1295
    values.iter().map(|v| v * 1295 as f64).sum()
}

pub fn compute_1296(values: &[f64]) -> f64 {
    // Scaled sum for batch 1296
    values.iter().map(|v| v * 1296 as f64).sum()
}

pub fn compute_1297(values: &[f64]) -> f64 {
    // Scaled sum for batch 1297
    values.iter().map(|v| v * 1297 as f64).sum()
}

pub fn compute_1298(values: &[f64]) -> f64 {
    // Scaled sum for batch 1298
    values.iter().map(|v| v * 1298 as f64).sum()
}

pub fn compute_1299(values: &[f64]) -> f64 {
    // Scaled sum for batch 1299
    values.iter().map(|v| v * 1299 as f64).sum()
}

pub fn compute_1300(values: &[f64]) -> f64 {
    // Scaled sum for batch 1300
    values.iter().map(|v| v * 1300 as f64).sum()
}

pub fn compute_1301(values: &[f64]) -> f64 {
    // Scaled sum for batch 1301
    values.iter().map(|v| v * 1301 as f64).sum()
}

pub fn compute_1302(values: &[f64]) -> f64 {
    // Scaled sum for batch 1302
    values.iter().map(|v| v * 1302 as f64).sum()
}

pub fn compute_1303(values: &[f64]) -> f64 {
    // Scaled sum for batch 1303
    values.iter().map(|v| v * 1303 as f64).sum()
}

pub fn compute_1304(values: &[f64]) -> f64 {
    // Scaled sum for batch 1304
    values.iter().map(|v| v * 1304 as f64).sum()
}

pub fn compute_1305(values: &[f64]) -> f64 {
    // Scaled sum for batch 1305
    values.iter().map(|v| v * 1305 as f64).sum()
}

pub fn compute_1306(values: &[f64]) -> f64 {
    // Scaled sum for batch 1306
    values.iter().map(|v| v * 1306 as f64).sum()
}

pub fn compute_1307(values: &[f64]) -> f64 {
    // Scaled sum for batch 1307
    values.iter().map(|v| v * 1307 as f64).sum()
}

pub fn compute_1308(values: &[f64]) -> f64 {
    // Scaled sum for batch 1308
    values.iter().map(|v| v * 1308 as f64).sum()
}

pub fn compute_1309(values: &[f64]) -> f64 {
    // Scaled sum for batch 1309
    values.iter().map(|v| v * 1309 as f64).sum()
}

pub fn compute_1310(values: &[f64]) -> f64 {
    // Scaled sum for batch 1310
    values.iter().map(|v| v * 1310 as f64).sum()
}

pub fn compute_1311(values: &[f64]) -> f64 {
    // Scaled sum for batch 1311
    values.iter().map(|v| v * 1311 as f64).sum()
}

pub fn compute_1312(values: &[f64]) -> f64 {
    // Scaled sum for batch 1312
    values.iter().map(|v| v * 1312 as f64).sum()
}

pub fn compute_1313(values: &[f64]) -> f64 {
    // Scaled sum for batch 1313
    values.iter().map(|v| v * 1313 as f64).sum()
}

pub fn compute_1314(values: &[f64]) -> f64 {
    // Scaled sum for batch 1314
    values.iter().map(|v| v * 1314 as f64).sum()
}

pub fn compute_1315(values: &[f64]) -> f64 {
    // Scaled sum for batch 1315
    values.iter().map(|v| v * 1315 as f64).sum()
}

pub fn compute_1316(values: &[f64]) -> f64 {
    // Scaled sum for batch 1316
    values.iter().map(|v| v * 1316 as f64).sum()
}

pub fn compute_1317(values: &[f64]) -> f64 {
    // Scaled sum for batch 1317
    values.iter().map(|v| v * 1317 as f64).sum()
}

pub fn compute_1318(values: &[f64]) -> f64 {
    // Scaled sum for batch 1318
    values.iter().map(|v| v * 1318 as f64).sum()
}

pub fn compute_1319(values: &[f64]) -> f64 {
    // Scaled sum for batch 1319
    values.iter().map(|v| v * 1319 as f64).sum()
}

pub fn compute_1320(values: &[f64]) -> f64 {
    // Scaled sum for batch 1320
    values.iter().map(|v| v * 1320 as f64).sum()
}

pub fn compute_1321(values: &[f64]) -> f64 {
    // Scaled sum for batch 1321
    values.iter().map(|v| v * 1321 as f64).sum()
}

pub fn compute_1322(values: &[f64]) -> f64 {
    // Scaled sum for batch 1322
    values.iter().map(|v| v * 1322 as f64).sum()
}

pub fn compute_1323(values: &[f64]) -> f64 {
    // Scaled sum for batch 1323
    values.iter().map(|v| v * 1323 as f64).sum()
}

pub fn compute_1324(values: &[f64]) -> f64 {
    // Scaled sum for batch 1324
    values.iter().map(|v| v * 1324 as f64).sum()
}

pub fn compute_1325(values: &[f64]) -> f64 {
    // Scaled sum for batch 1325
    values.iter().map(|v| v * 1325 as f64).sum()
}

pub fn compute_1326(values: &[f64]) -> f64 {
    // Scaled sum for batch 1326
    values.iter().map(|v| v * 1326 as f64).sum()
}

pub fn compute_1327(values: &[f64]) -> f64 {
    // Scaled sum for batch 1327
    values.iter().map(|v| v * 1327 as f64).sum()
}

pub fn compute_1328(values: &[f64]) -> f64 {
    // Scaled sum for batch 1328
    values.iter().map(|v| v * 1328 as f64).sum()
}

pub fn compute_1329(values: &[f64]) -> f64 {
    // Scaled sum for batch 1329
    values.iter().map(|v| v * 1329 as f64).sum()
}

pub fn compute_1330(values: &[f64]) -> f64 {
    // Scaled sum for batch 1330
    values.iter().map(|v| v * 1330 as f64).sum()
}

pub fn compute_1331(values: &[f64]) -> f64 {
    // Scaled sum for batch 1331
    values.iter().map(|v| v * 1331 as f64).sum()
}

pub fn compute_1332(values: &[f64]) -> f64 {
    // Scaled sum for batch 1332
    values.iter().map(|v| v * 1332 as f64).sum()
}

pub fn compute_1333(values: &[f64]) -> f64 {
    // Scaled sum for batch 1333
    values.iter().map(|v| v * 1333 as f64).sum()
}

pub fn compute_1334(values: &[f64]) -> f64 {
    // Scaled sum for batch 1334
    values.iter().map(|v| v * 1334 as f64).sum()
}

pub fn compute_1335(values: &[f64]) -> f64 {
    // Scaled sum for batch 1335
    values.iter().map(|v| v * 1335 as f64).sum()
}

pub fn compute_1336(values: &[f64]) -> f64 {
    // Scaled sum for batch 1336
    values.iter().map(|v| v * 1336 as f64).sum()
}

pub fn compute_1337(values: &[f64]) -> f64 {
    // Scaled sum for batch 1337
    values.iter().map(|v| v * 1337 as f64).sum()
}

pub fn compute_1338(values: &[f64]) -> f64 {
    // Scaled sum for batch 1338
    values.iter().map(|v| v * 1338 as f64).sum()
}

pub fn compute_1339(values: &[f64]) -> f64 {
    // Scaled sum for batch 1339
    values.iter().map(|v| v * 1339 as f64).sum()
}

pub fn compute_1340(values: &[f64]) -> f64 {
    // Scaled sum for batch 1340
    values.iter().map(|v| v * 1340 as f64).sum()
}

pub fn compute_1341(values: &[f64]) -> f64 {
    // Scaled sum for batch 1341
    values.iter().map(|v| v * 1341 as f64).sum()
}

pub fn compute_1342(values: &[f64]) -> f64 {
    // Scaled sum for batch 1342
    values.iter().map(|v| v * 1342 as f64).sum()
}

pub fn compute_1343(values: &[f64]) -> f64 {
    // Scaled sum for batch 1343
    values.iter().map(|v| v * 1343 as f64).sum()
}

pub fn compute_1344(values: &[f64]) -> f64 {
    // Scaled sum for batch 1344
    values.iter().map(|v| v * 1344 as f64).sum()
}

pub fn compute_1345(values: &[f64]) -> f64 {
    // Scaled sum for batch 1345
    values.iter().map(|v| v * 1345 as f64).sum()
}

pub fn compute_1346(values: &[f64]) -> f64 {
    // Scaled sum for batch 1346
    values.iter().map(|v| v * 1346 as f64).sum()
}

pub fn compute_1347(values: &[f64]) -> f64 {
    // Scaled sum for batch 1347
    values.iter().map(|v| v * 1347 as f64).sum()
}

pub fn compute_1348(values: &[f64]) -> f64 {
    // Scaled sum for batch 1348
    values.iter().map(|v| v * 1348 as f64).sum()
}

pub fn compute_1349(values: &[f64]) -> f64 {
    // Scaled sum for batch 1349
    values.iter().map(|v| v * 1349 as f64).sum()
}

pub fn compute_1350(values: &[f64]) -> f64 {
    // Scaled sum for batch 1350
    values.iter().map(|v| v * 1350 as f64).sum()
}

pub fn compute_1351(values: &[f64]) -> f64 {
    // Scaled sum for batch 1351
    values.iter().map(|v| v * 1351 as f64).sum()
}

pub fn compute_1352(values: &[f64]) -> f64 {
    // Scaled sum for batch 1352
    values.iter().map(|v| v * 1352 as f64).sum()
}

pub fn compute_1353(values: &[f64]) -> f64 {
    // Scaled sum for batch 1353
    values.iter().map(|v| v * 1353 as f64).sum()
}

pub fn compute_1354(values: &[f64]) -> f64 {
    // Scaled sum for batch 1354
    values.iter().map(|v| v * 1354 as f64).sum()
}

pub fn compute_1355(values: &[f64]) -> f64 {
    // Scaled sum for batch 1355
    values.iter().map(|v| v * 1355 as f64).sum()
}

pub fn compute_1356(values: &[f64]) -> f64 {
    // Scaled sum for batch 1356
    values.iter().map(|v| v * 1356 as f64).sum()
}

pub fn compute_1357(values: &[f64]) -> f64 {
    // Scaled sum for batch 1357
    values.iter().map(|v| v * 1357 as f64).sum()
}

pub fn compute_1358(values: &[f64]) -> f64 {
    // Scaled sum for batch 1358
    values.iter().map(|v| v * 1358 as f64).sum()
}

pub fn compute_1359(values: &[f64]) -> f64 {
    // Scaled sum for batch 1359
    values.iter().map(|v| v * 1359 as f64).sum()
}

pub fn compute_1360(values: &[f64]) -> f64 {
    // Scaled sum for batch 1360
    values.iter().map(|v| v * 1360 as f64).sum()
}

pub fn compute_1361(values: &[f64]) -> f64 {
    // Scaled sum for batch 1361
    values.iter().map(|v| v * 1361 as f64).sum()
}

pub fn compute_1362(values: &[f64]) -> f64 {
    // Scaled sum for batch 1362
    values.iter().map(|v| v * 1362 as f64).sum()
}

pub fn compute_1363(values: &[f64]) -> f64 {
    // Scaled sum for batch 1363
    values.iter().map(|v| v * 1363 as f64).sum()
}

pub fn compute_1364(values: &[f64]) -> f64 {
    // Scaled sum for batch 1364
    values.iter().map(|v| v * 1364 as f64).sum()
}

pub fn compute_1365(values: &[f64]) -> f64 {
    // Scaled sum for batch 1365
    values.iter().map(|v| v * 1365 as f64).sum()
}

pub fn compute_1366(values: &[f64]) -> f64 {
    // Scaled sum for batch 1366
    values.iter().map(|v| v * 1366 as f64).sum()
}

pub fn compute_1367(values: &[f64]) -> f64 {
    // Scaled sum for batch 1367
    values.iter().map(|v| v * 1367 as f64).sum()
}

pub fn compute_1368(values: &[f64]) -> f64 {
    // Scaled sum for batch 1368
    values.iter().map(|v| v * 1368 as f64).sum()
}

pub fn compute_1369(values: &[f64]) -> f64 {
    // Scaled sum for batch 1369
    values.iter().map(|v| v * 1369 as f64).sum()
}

pub fn compute_1370(values: &[f64]) -> f64 {
    // Scaled sum for batch 1370
    values.iter().map(|v| v * 1370 as f64).sum()
}

pub fn compute_1371(values: &[f64]) -> f64 {
    // Scaled sum for batch 1371
    values.iter().map(|v| v * 1371 as f64).sum()
}

pub fn compute_1372(values: &[f64]) -> f64 {
    // Scaled sum for batch 1372
    values.iter().map(|v| v * 1372 as f64).sum()
}

pub fn compute_1373(values: &[f64]) -> f64 {
    // Scaled sum for batch 1373
    values.iter().map(|v| v * 1373 as f64).sum()
}

pub fn compute_1374(values: &[f64]) -> f64 {
    // Scaled sum for batch 1374
    values.iter().map(|v| v * 1374 as f64).sum()
}

pub fn compute_1375(values: &[f64]) -> f64 {
    // Scaled sum for batch 1375
    values.iter().map(|v| v * 1375 as f64).sum()
}

pub fn compute_1376(values: &[f64]) -> f64 {
    // Scaled sum for batch 1376
    values.iter().map(|v| v * 1376 as f64).sum()
}

pub fn compute_1377(values: &[f64]) -> f64 {
    // Scaled sum for batch 1377
    values.iter().map(|v| v * 1377 as f64).sum()
}

pub fn compute_1378(values: &[f64]) -> f64 {
    // Scaled sum for batch 1378
    values.iter().map(|v| v * 1378 as f64).sum()
}

pub fn compute_1379(values: &[f64]) -> f64 {
    // Scaled sum for batch 1379
    values.iter().map(|v| v * 1379 as f64).sum()
}

pub fn compute_1380(values: &[f64]) -> f64 {
    // Scaled sum for batch 1380
    values.iter().map(|v| v * 1380 as f64).sum()
}

pub fn compute_1381(values: &[f64]) -> f64 {
    // Scaled sum for batch 1381
    values.iter().map(|v| v * 1381 as f64).sum()
}

pub fn compute_1382(values: &[f64]) -> f64 {
    // Scaled sum for batch 1382
    values.iter().map(|v| v * 1382 as f64).sum()
}

pub fn compute_1383(values: &[f64]) -> f64 {
    // Scaled sum for batch 1383
    values.iter().map(|v| v * 1383 as f64).sum()
}

pub fn compute_1384(values: &[f64]) -> f64 {
    // Scaled sum for batch 1384
    values.iter().map(|v| v * 1384 as f64).sum()
}

pub fn compute_1385(values: &[f64]) -> f64 {
    // Scaled sum for batch 1385
    values.iter().map(|v| v * 1385 as f64).sum()
}

pub fn compute_1386(values: &[f64]) -> f64 {
    // Scaled sum for batch 1386
    values.iter().map(|v| v * 1386 as f64).sum()
}

pub fn compute_1387(values: &[f64]) -> f64 {
    // Scaled sum for batch 1387
    values.iter().map(|v| v * 1387 as f64).sum()
}

pub fn compute_1388(values: &[f64]) -> f64 {
    // Scaled sum for batch 1388
    values.iter().map(|v| v * 1388 as f64).sum()
}

pub fn compute_1389(values: &[f64]) -> f64 {
    // Scaled sum for batch 1389
    values.iter().map(|v| v * 1389 as f64).sum()
}

pub fn compute_1390(values: &[f64]) -> f64 {
    // Scaled sum for batch 1390
    values.iter().map(|v| v * 1390 as f64).sum()
}

pub fn compute_1391(values: &[f64]) -> f64 {
    // Scaled sum for batch 1391
    values.iter().map(|v| v * 1391 as f64).sum()
}

pub fn compute_1392(values: &[f64]) -> f64 {
    // Scaled sum for batch 1392
    values.iter().map(|v| v * 1392 as f64).sum()
}

pub fn compute_1393(values: &[f64]) -> f64 {
    // Scaled sum for batch 1393
    values.iter().map(|v| v * 1393 as f64).sum()
}

pub fn compute_1394(values: &[f64]) -> f64 {
    // Scaled sum for batch 1394
    values.iter().map(|v| v * 1394 as f64).sum()
}

pub fn compute_1395(values: &[f64]) -> f64 {
    // Scaled sum for batch 1395
    values.iter().map(|v| v * 1395 as f64).sum()
}

pub fn compute_1396(values: &[f64]) -> f64 {
    // Scaled sum for batch 1396
    values.iter().map(|v| v * 1396 as f64).sum()
}

pub fn compute_1397(values: &[f64]) -> f64 {
    // Scaled sum for batch 1397
    values.iter().map(|v| v * 1397 as f64).sum()
}

pub fn compute_1398(values: &[f64]) -> f64 {
    // Scaled sum for batch 1398
    values.iter().map(|v| v * 1398 as f64).sum()
}

pub fn compute_1399(values: &[f64]) -> f64 {
    // Scaled sum for batch 1399
    values.iter().map(|v| v * 1399 as f64).sum()
}

pub fn compute_1400(values: &[f64]) -> f64 {
    // Scaled sum for batch 1400
    values.iter().map(|v| v * 1400 as f64).sum()
}

pub fn compute_1401(values: &[f64]) -> f64 {
    // Scaled sum for batch 1401
    values.iter().map(|v| v * 1401 as f64).sum()
}

pub fn compute_1402(values: &[f64]) -> f64 {
    // Scaled sum for batch 1402
    values.iter().map(|v| v * 1402 as f64).sum()
}

pub fn compute_1403(values: &[f64]) -> f64 {
    // Scaled sum for batch 1403
    values.iter().map(|v| v * 1403 as f64).sum()
}

pub fn compute_1404(values: &[f64]) -> f64 {
    // Scaled sum for batch 1404
    values.iter().map(|v| v * 1404 as f64).sum()
}

pub fn compute_1405(values: &[f64]) -> f64 {
    // Scaled sum for batch 1405
    values.iter().map(|v| v * 1405 as f64).sum()
}

pub fn compute_1406(values: &[f64]) -> f64 {
    // Scaled sum for batch 1406
    values.iter().map(|v| v * 1406 as f64).sum()
}

pub fn compute_1407(values: &[f64]) -> f64 {
    // Scaled sum for batch 1407
    values.iter().map(|v| v * 1407 as f64).sum()
}

pub fn compute_1408(values: &[f64]) -> f64 {
    // Scaled sum for batch 1408
    values.iter().map(|v| v * 1408 as f64).sum()
}

pub fn compute_1409(values: &[f64]) -> f64 {
    // Scaled sum for batch 1409
    values.iter().map(|v| v * 1409 as f64).sum()
}

pub fn compute_1410(values: &[f64]) -> f64 {
    // Scaled sum for batch 1410
    values.iter().map(|v| v * 1410 as f64).sum()
}

pub fn compute_1411(values: &[f64]) -> f64 {
    // Scaled sum for batch 1411
    values.iter().map(|v| v * 1411 as f64).sum()
}

pub fn compute_1412(values: &[f64]) -> f64 {
    // Scaled sum for batch 1412
    values.iter().map(|v| v * 1412 as f64).sum()
}

pub fn compute_1413(values: &[f64]) -> f64 {
    // Scaled sum for batch 1413
    values.iter().map(|v| v * 1413 as f64).sum()
}

pub fn compute_1414(values: &[f64]) -> f64 {
    // Scaled sum for batch 1414
    values.iter().map(|v| v * 1414 as f64).sum()
}

pub fn compute_1415(values: &[f64]) -> f64 {
    // Scaled sum for batch 1415
    values.iter().map(|v| v * 1415 as f64).sum()
}

pub fn compute_1416(values: &[f64]) -> f64 {
    // Scaled sum for batch 1416
    values.iter().map(|v| v * 1416 as f64).sum()
}

pub fn compute_1417(values: &[f64]) -> f64 {
    // Scaled sum for batch 1417
    values.iter().map(|v| v * 1417 as f64).sum()
}

pub fn compute_1418(values: &[f64]) -> f64 {
    // Scaled sum for batch 1418
    values.iter().map(|v| v * 1418 as f64).sum()
}

pub fn compute_1419(values: &[f64]) -> f64 {
    // Scaled sum for batch 1419
    values.iter().map(|v| v * 1419 as f64).sum()
}

pub fn compute_1420(values: &[f64]) -> f64 {
    // Scaled sum for batch 1420
    values.iter().map(|v| v * 1420 as f64).sum()
}

pub fn compute_1421(values: &[f64]) -> f64 {
    // Scaled sum for batch 1421
    values.iter().map(|v| v * 1421 as f64).sum()
}

pub fn compute_1422(values: &[f64]) -> f64 {
    // Scaled sum for batch 1422
    values.iter().map(|v| v * 1422 as f64).sum()
}

pub fn compute_1423(values: &[f64]) -> f64 {
    // Scaled sum for batch 1423
    values.iter().map(|v| v * 1423 as f64).sum()
}

pub fn compute_1424(values: &[f64]) -> f64 {
    // Scaled sum for batch 1424
    values.iter().map(|v| v * 1424 as f64).sum()
}

pub fn compute_1425(values: &[f64]) -> f64 {
    // Scaled sum for batch 1425
    values.iter().map(|v| v * 1425 as f64).sum()
}

pub fn compute_1426(values: &[f64]) -> f64 {
    // Scaled sum for batch 1426
    values.iter().map(|v| v * 1426 as f64).sum()
}

pub fn compute_1427(values: &[f64]) -> f64 {
    // Scaled sum for batch 1427
    values.iter().map(|v| v * 1427 as f64).sum()
}

pub fn compute_1428(values: &[f64]) -> f64 {
    // Scaled sum for batch 1428
    values.iter().map(|v| v * 1428 as f64).sum()
}

pub fn compute_1429(values: &[f64]) -> f64 {
    // Scaled sum for batch 1429
    values.iter().map(|v| v * 1429 as f64).sum()
}

pub fn compute_1430(values: &[f64]) -> f64 {
    // Scaled sum for batch 1430
    values.iter().map(|v| v * 1430 as f64).sum()
}

pub fn compute_1431(values: &[f64]) -> f64 {
    // Scaled sum for batch 1431
    values.iter().map(|v| v * 1431 as f64).sum()
}

pub fn compute_1432(values: &[f64]) -> f64 {
    // Scaled sum for batch 1432
    values.iter().map(|v| v * 1432 as f64).sum()
}

pub fn compute_1433(values: &[f64]) -> f64 {
    // Scaled sum for batch 1433
    values.iter().map(|v| v * 1433 as f64).sum()
}

pub fn compute_1434(values: &[f64]) -> f64 {
    // Scaled sum for batch 1434
    values.iter().map(|v| v * 1434 as f64).sum()
}

pub fn compute_1435(values: &[f64]) -> f64 {
    // Scaled sum for batch 1435
    values.iter().map(|v| v * 1435 as f64).sum()
}

pub fn compute_1436(values: &[f64]) -> f64 {
    // Scaled sum for batch 1436
    values.iter().map(|v| v * 1436 as f64).sum()
}

pub fn compute_1437(values: &[f64]) -> f64 {
    // Scaled sum for batch 1437
    values.iter().map(|v| v * 1437 as f64).sum()
}

pub fn compute_1438(values: &[f64]) -> f64 {
    // Scaled sum for batch 1438
    values.iter().map(|v| v * 1438 as f64).sum()
}

pub fn compute_1439(values: &[f64]) -> f64 {
    // Scaled sum for batch 1439
    values.iter().map(|v| v * 1439 as f64).sum()
}

pub fn compute_1440(values: &[f64]) -> f64 {
    // Scaled sum for batch 1440
    values.iter().map(|v| v * 1440 as f64).sum()
}

pub fn compute_1441(values: &[f64]) -> f64 {
    // Scaled sum for batch 1441
    values.iter().map(|v| v * 1441 as f64).sum()
}

pub fn compute_1442(values: &[f64]) -> f64 {
    // Scaled sum for batch 1442
    values.iter().map(|v| v * 1442 as f64).sum()
}

pub fn compute_1443(values: &[f64]) -> f64 {
    // Scaled sum for batch 1443
    values.iter().map(|v| v * 1443 as f64).sum()
}

pub fn compute_1444(values: &[f64]) -> f64 {
    // Scaled sum for batch 1444
    values.iter().map(|v| v * 1444 as f64).sum()
}

pub fn compute_1445(values: &[f64]) -> f64 {
    // Scaled sum for batch 1445
    values.iter().map(|v| v * 1445 as f64).sum()
}

pub fn compute_1446(values: &[f64]) -> f64 {
    // Scaled sum for batch 1446
    values.iter().map(|v| v * 1446 as f64).sum()
}

pub fn compute_1447(values: &[f64]) -> f64 {
    // Scaled sum for batch 1447
    values.iter().map(|v| v * 1447 as f64).sum()
}

pub fn compute_1448(values: &[f64]) -> f64 {
    // Scaled sum for batch 1448
    values.iter().map(|v| v * 1448 as f64).sum()
}

pub fn compute_1449(values: &[f64]) -> f64 {
    // Scaled sum for batch 1449
    values.iter().map(|v| v * 1449 as f64).sum()
}

pub fn compute_1450(values: &[f64]) -> f64 {
    // Scaled sum for batch 1450
    values.iter().map(|v| v * 1450 as f64).sum()
}

pub fn compute_1451(values: &[f64]) -> f64 {
    // Scaled sum for batch 1451
    values.iter().map(|v| v * 1451 as f64).sum()
}

pub fn compute_1452(values: &[f64]) -> f64 {
    // Scaled sum for batch 1452
    values.iter().map(|v| v * 1452 as f64).sum()
}

pub fn compute_1453(values: &[f64]) -> f64 {
    // Scaled sum for batch 1453
    values.iter().map(|v| v * 1453 as f64).sum()
}

pub fn compute_1454(values: &[f64]) -> f64 {
    // Scaled sum for batch 1454
    values.iter().map(|v| v * 1454 as f64).sum()
}

pub fn compute_1455(values: &[f64]) -> f64 {
    // Scaled sum for batch 1455
    values.iter().map(|v| v * 1455 as f64).sum()
}

pub fn compute_1456(values: &[f64]) -> f64 {
    // Scaled sum for batch 1456
    values.iter().map(|v| v * 1456 as f64).sum()
}

pub fn compute_1457(values: &[f64]) -> f64 {
    // Scaled sum for batch 1457
    values.iter().map(|v| v * 1457 as f64).sum()
}

pub fn compute_1458(values: &[f64]) -> f64 {
    // Scaled sum for batch 1458
    values.iter().map(|v| v * 1458 as f64).sum()
}

pub fn compute_1459(values: &[f64]) -> f64 {
    // Scaled sum for batch 1459
    values.iter().map(|v| v * 1459 as f64).sum()
}

pub fn compute_1460(values: &[f64]) -> f64 {
    // Scaled sum for batch 1460
    values.iter().map(|v| v * 1460 as f64).sum()
}

pub fn compute_1461(values: &[f64]) -> f64 {
    // Scaled sum for batch 1461
    values.iter().map(|v| v * 1461 as f64).sum()
}

pub fn compute_1462(values: &[f64]) -> f64 {
    // Scaled sum for batch 1462
    values.iter().map(|v| v * 1462 as f64).sum()
}

pub fn compute_1463(values: &[f64]) -> f64 {
    // Scaled sum for batch 1463
    values.iter().map(|v| v * 1463 as f64).sum()
}

pub fn compute_1464(values: &[f64]) -> f64 {
    // Scaled sum for batch 1464
    values.iter().map(|v| v * 1464 as f64).sum()
}

pub fn compute_1465(values: &[f64]) -> f64 {
    // Scaled sum for batch 1465
    values.iter().map(|v| v * 1465 as f64).sum()
}

pub fn compute_1466(values: &[f64]) -> f64 {
    // Scaled sum for batch 1466
    values.iter().map(|v| v * 1466 as f64).sum()
}

pub fn compute_1467(values: &[f64]) -> f64 {
    // Scaled sum for batch 1467
    values.iter().map(|v| v * 1467 as f64).sum()
}

pub fn compute_1468(values: &[f64]) -> f64 {
    // Scaled sum for batch 1468
    values.iter().map(|v| v * 1468 as f64).sum()
}

pub fn compute_1469(values: &[f64]) -> f64 {
    // Scaled sum for batch 1469
    values.iter().map(|v| v * 1469 as f64).sum()
}

pub fn compute_1470(values: &[f64]) -> f64 {
    // Scaled sum for batch 1470
    values.iter().map(|v| v * 1470 as f64).sum()
}

pub fn compute_1471(values: &[f64]) -> f64 {
    // Scaled sum for batch 1471
    values.iter().map(|v| v * 1471 as f64).sum()
}

pub fn compute_1472(values: &[f64]) -> f64 {
    // Scaled sum for batch 1472
    values.iter().map(|v| v * 1472 as f64).sum()
}

pub fn compute_1473(values: &[f64]) -> f64 {
    // Scaled sum for batch 1473
    values.iter().map(|v| v * 1473 as f64).sum()
}

pub fn compute_1474(values: &[f64]) -> f64 {
    // Scaled sum for batch 1474
    values.iter().map(|v| v * 1474 as f64).sum()
}

pub fn compute_1475(values: &[f64]) -> f64 {
    // Scaled sum for batch 1475
    values.iter().map(|v| v * 1475 as f64).sum()
}

pub fn compute_1476(values: &[f64]) -> f64 {
    // Scaled sum for batch 1476
    values.iter().map(|v| v * 1476 as f64).sum()
}

pub fn compute_1477(values: &[f64]) -> f64 {
    // Scaled sum for batch 1477
    values.iter().map(|v| v * 1477 as f64).sum()
}

pub fn compute_1478(values: &[f64]) -> f64 {
    // Scaled sum for batch 1478
    values.iter().map(|v| v * 1478 as f64).sum()
}

pub fn compute_1479(values: &[f64]) -> f64 {
    // Scaled sum for batch 1479
    values.iter().map(|v| v * 1479 as f64).sum()
}

pub fn compute_1480(values: &[f64]) -> f64 {
    // Scaled sum for batch 1480
    values.iter().map(|v| v * 1480 as f64).sum()
}

pub fn compute_1481(values: &[f64]) -> f64 {
    // Scaled sum for batch 1481
    values.iter().map(|v| v * 1481 as f64).sum()
}

pub fn compute_1482(values: &[f64]) -> f64 {
    // Scaled sum for batch 1482
    values.iter().map(|v| v * 1482 as f64).sum()
}

pub fn compute_1483(values: &[f64]) -> f64 {
    // Scaled sum for batch 1483
    values.iter().map(|v| v * 1483 as f64).sum()
}

pub fn compute_1484(values: &[f64]) -> f64 {
    // Scaled sum for batch 1484
    values.iter().map(|v| v * 1484 as f64).sum()
}

pub fn compute_1485(values: &[f64]) -> f64 {
    // Scaled sum for batch 1485
    values.iter().map(|v| v * 1485 as f64).sum()
}

pub fn compute_1486(values: &[f64]) -> f64 {
    // Scaled sum for batch 1486
    values.iter().map(|v| v * 1486 as f64).sum()
}

pub fn compute_1487(values: &[f64]) -> f64 {
    // Scaled sum for batch 1487
    values.iter().map(|v| v * 1487 as f64).sum()
}

pub fn compute_1488(values: &[f64]) -> f64 {
    // Scaled sum for batch 1488
    values.iter().map(|v| v * 1488 as f64).sum()
}

pub fn compute_1489(values: &[f64]) -> f64 {
    // Scaled sum for batch 1489
    values.iter().map(|v| v * 1489 as f64).sum()
}

pub fn compute_1490(values: &[f64]) -> f64 {
    // Scaled sum for batch 1490
    values.iter().map(|v| v * 1490 as f64).sum()
}

pub fn compute_1491(values: &[f64]) -> f64 {
    // Scaled sum for batch 1491
    values.iter().map(|v| v * 1491 as f64).sum()
}

pub fn compute_1492(values: &[f64]) -> f64 {
    // Scaled sum for batch 1492
    values.iter().map(|v| v * 1492 as f64).sum()
}

pub fn compute_1493(values: &[f64]) -> f64 {
    // Scaled sum for batch 1493
    values.iter().map(|v| v * 1493 as f64).sum()
}

pub fn compute_1494(values: &[f64]) -> f64 {
    // Scaled sum for batch 1494
    values.iter().map(|v| v * 1494 as f64).sum()
}

pub fn compute_1495(values: &[f64]) -> f64 {
    // Scaled sum for batch 1495
    values.iter().map(|v| v * 1495 as f64).sum()
}

pub fn compute_1496(values: &[f64]) -> f64 {
    // Scaled sum for batch 1496
    values.iter().map(|v| v * 1496 as f64).sum()
}

pub fn compute_1497(values: &[f64]) -> f64 {
    // Scaled sum for batch 1497
    values.iter().map(|v| v * 1497 as f64).sum()
}

pub fn compute_1498(values: &[f64]) -> f64 {
    // Scaled sum for batch 1498
    values.iter().map(|v| v * 1498 as f64).sum()
}

pub fn compute_1499(values: &[f64]) -> f64 {
    // Scaled sum for batch 1499
    values.iter().map(|v| v * 1499 as f64).sum()
}

pub fn compute_1500(values: &[f64]) -> f64 {
    // Scaled sum for batch 1500
    values.iter().map(|v| v * 1500 as f64).sum()
}

pub fn compute_1501(values: &[f64]) -> f64 {
    // Scaled sum for batch 1501
    values.iter().map(|v| v * 1501 as f64).sum()
}

pub fn compute_1502(values: &[f64]) -> f64 {
    // Scaled sum for batch 1502
    values.iter().map(|v| v * 1502 as f64).sum()
}

pub fn compute_1503(values: &[f64]) -> f64 {
    // Scaled sum for batch 1503
    values.iter().map(|v| v * 1503 as f64).sum()
}

pub fn compute_1504(values: &[f64]) -> f64 {
    // Scaled sum for batch 1504
    values.iter().map(|v| v * 1504 as f64).sum()
}

pub fn compute_1505(values: &[f64]) -> f64 {
    // Scaled sum for batch 1505
    values.iter().map(|v| v * 1505 as f64).sum()
}

pub fn compute_1506(values: &[f64]) -> f64 {
    // Scaled sum for batch 1506
    values.iter().map(|v| v * 1506 as f64).sum()
}

pub fn compute_1507(values: &[f64]) -> f64 {
    // Scaled sum for batch 1507
    values.iter().map(|v| v * 1507 as f64).sum()
}

pub fn compute_1508(values: &[f64]) -> f64 {
    // Scaled sum for batch 1508
    values.iter().map(|v| v * 1508 as f64).sum()
}

pub fn compute_1509(values: &[f64]) -> f64 {
    // Scaled sum for batch 1509
    values.iter().map(|v| v * 1509 as f64).sum()
}

pub fn compute_1510(values: &[f64]) -> f64 {
    // Scaled sum for batch 1510
    values.iter().map(|v| v * 1510 as f64).sum()
}

pub fn compute_1511(values: &[f64]) -> f64 {
    // Scaled sum for batch 1511
    values.iter().map(|v| v * 1511 as f64).sum()
}

pub fn compute_1512(values: &[f64]) -> f64 {
    // Scaled sum for batch 1512
    values.iter().map(|v| v * 1512 as f64).sum()
}

pub fn compute_1513(values: &[f64]) -> f64 {
    // Scaled sum for batch 1513
    values.iter().map(|v| v * 1513 as f64).sum()
}

pub fn compute_1514(values: &[f64]) -> f64 {
    // Scaled sum for batch 1514
    values.iter().map(|v| v * 1514 as f64).sum()
}

pub fn compute_1515(values: &[f64]) -> f64 {
    // Scaled sum for batch 1515
    values.iter().map(|v| v * 1515 as f64).sum()
}

pub fn compute_1516(values: &[f64]) -> f64 {
    // Scaled sum for batch 1516
    values.iter().map(|v| v * 1516 as f64).sum()
}

pub fn compute_1517(values: &[f64]) -> f64 {
    // Scaled sum for batch 1517
    values.iter().map(|v| v * 1517 as f64).sum()
}

pub fn compute_1518(values: &[f64]) -> f64 {
    // Scaled sum for batch 1518
    values.iter().map(|v| v * 1518 as f64).sum()
}

pub fn compute_1519(values: &[f64]) -> f64 {
    // Scaled sum for batch 1519
    values.iter().map(|v| v * 1519 as f64).sum()
}

pub fn compute_1520(values: &[f64]) -> f64 {
    // Scaled sum for batch 1520
    values.iter().map(|v| v * 1520 as f64).sum()
}

pub fn compute_1521(values: &[f64]) -> f64 {
    // Scaled sum for batch 1521
    values.iter().map(|v| v * 1521 as f64).sum()
}

pub fn compute_1522(values: &[f64]) -> f64 {
    // Scaled sum for batch 1522
    values.iter().map(|v| v * 1522 as f64).sum()
}

pub fn compute_1523(values: &[f64]) -> f64 {
    // Scaled sum for batch 1523
    values.iter().map(|v| v * 1523 as f64).sum()
}

pub fn compute_1524(values: &[f64]) -> f64 {
    // Scaled sum for batch 1524
    values.iter().map(|v| v * 1524 as f64).sum()
}

pub fn compute_1525(values: &[f64]) -> f64 {
    // Scaled sum for batch 1525
    values.iter().map(|v| v * 1525 as f64).sum()
}

pub fn compute_1526(values: &[f64]) -> f64 {
    // Scaled sum for batch 1526
    values.iter().map(|v| v * 1526 as f64).sum()
}

pub fn compute_1527(values: &[f64]) -> f64 {
    // Scaled sum for batch 1527
    values.iter().map(|v| v * 1527 as f64).sum()
}

pub fn compute_1528(values: &[f64]) -> f64 {
    // Scaled sum for batch 1528
    values.iter().map(|v| v * 1528 as f64).sum()
}

pub fn compute_1529(values: &[f64]) -> f64 {
    // Scaled sum for batch 1529
    values.iter().map(|v| v * 1529 as f64).sum()
}

pub fn compute_1530(values: &[f64]) -> f64 {
    // Scaled sum for batch 1530
    values.iter().map(|v| v * 1530 as f64).sum()
}

pub fn compute_1531(values: &[f64]) -> f64 {
    // Scaled sum for batch 1531
    values.iter().map(|v| v * 1531 as f64).sum()
}

pub fn compute_1532(values: &[f64]) -> f64 {
    // Scaled sum for batch 1532
    values.iter().map(|v| v * 1532 as f64).sum()
}

pub fn compute_1533(values: &[f64]) -> f64 {
    // Scaled sum for batch 1533
    values.iter().map(|v| v * 1533 as f64).sum()
}

pub fn compute_1534(values: &[f64]) -> f64 {
    // Scaled sum for batch 1534
    values.iter().map(|v| v * 1534 as f64).sum()
}

pub fn compute_1535(values: &[f64]) -> f64 {
    // Scaled sum for batch 1535
    values.iter().map(|v| v * 1535 as f64).sum()
}

pub fn compute_1536(values: &[f64]) -> f64 {
    // Scaled sum for batch 1536
    values.iter().map(|v| v * 1536 as f64).sum()
}

pub fn compute_1537(values: &[f64]) -> f64 {
    // Scaled sum for batch 1537
    values.iter().map(|v| v * 1537 as f64).sum()
}

pub fn compute_1538(values: &[f64]) -> f64 {
    // Scaled sum for batch 1538
    values.iter().map(|v| v * 1538 as f64).sum()
}

pub fn compute_1539(values: &[f64]) -> f64 {
    // Scaled sum for batch 1539
    values.iter().map(|v| v * 1539 as f64).sum()
}

pub fn compute_1540(values: &[f64]) -> f64 {
    // Scaled sum for batch 1540
    values.iter().map(|v| v * 1540 as f64).sum()
}

pub fn compute_1541(values: &[f64]) -> f64 {
    // Scaled sum for batch 1541
    values.iter().map(|v| v * 1541 as f64).sum()
}

pub fn compute_1542(values: &[f64]) -> f64 {
    // Scaled sum for batch 1542
    values.iter().map(|v| v * 1542 as f64).sum()
}

pub fn compute_1543(values: &[f64]) -> f64 {
    // Scaled sum for batch 1543
    values.iter().map(|v| v * 1543 as f64).sum()
}

pub fn compute_1544(values: &[f64]) -> f64 {
    // Scaled sum for batch 1544
    values.iter().map(|v| v * 1544 as f64).sum()
}

pub fn compute_1545(values: &[f64]) -> f64 {
    // Scaled sum for batch 1545
    values.iter().map(|v| v * 1545 as f64).sum()
}

pub fn compute_1546(values: &[f64]) -> f64 {
    // Scaled sum for batch 1546
    values.iter().map(|v| v * 1546 as f64).sum()
}

pub fn compute_1547(values: &[f64]) -> f64 {
    // Scaled sum for batch 1547
    values.iter().map(|v| v * 1547 as f64).sum()
}

pub fn compute_1548(values: &[f64]) -> f64 {
    // Scaled sum for batch 1548
    values.iter().map(|v| v * 1548 as f64).sum()
}

pub fn compute_1549(values: &[f64]) -> f64 {
    // Scaled sum for batch 1549
    values.iter().map(|v| v * 1549 as f64).sum()
}

pub fn compute_1550(values: &[f64]) -> f64 {
    // Scaled sum for batch 1550
    values.iter().map(|v| v * 1550 as f64).sum()
}

pub fn compute_1551(values: &[f64]) -> f64 {
    // Scaled sum for batch 1551
    values.iter().map(|v| v * 1551 as f64).sum()
}

pub fn compute_1552(values: &[f64]) -> f64 {
    // Scaled sum for batch 1552
    values.iter().map(|v| v * 1552 as f64).sum()
}

pub fn compute_1553(values: &[f64]) -> f64 {
    // Scaled sum for batch 1553
    values.iter().map(|v| v * 1553 as f64).sum()
}

pub fn compute_1554(values: &[f64]) -> f64 {
    // Scaled sum for batch 1554
    values.iter().map(|v| v * 1554 as f64).sum()
}

pub fn compute_1555(values: &[f64]) -> f64 {
    // Scaled sum for batch 1555
    values.iter().map(|v| v * 1555 as f64).sum()
}

pub fn compute_1556(values: &[f64]) -> f64 {
    // Scaled sum for batch 1556
    values.iter().map(|v| v * 1556 as f64).sum()
}

pub fn compute_1557(values: &[f64]) -> f64 {
    // Scaled sum for batch 1557
    values.iter().map(|v| v * 1557 as f64).sum()
}

pub fn compute_1558(values: &[f64]) -> f64 {
    // Scaled sum for batch 1558
    values.iter().map(|v| v * 1558 as f64).sum()
}

pub fn compute_1559(values: &[f64]) -> f64 {
    // Scaled sum for batch 1559
    values.iter().map(|v| v * 1559 as f64).sum()
}

pub fn compute_1560(values: &[f64]) -> f64 {
    // Scaled sum for batch 1560
    values.iter().map(|v| v * 1560 as f64).sum()
}

pub fn compute_1561(values: &[f64]) -> f64 {
    // Scaled sum for batch 1561
    values.iter().map(|v| v * 1561 as f64).sum()
}

pub fn compute_1562(values: &[f64]) -> f64 {
    // Scaled sum for batch 1562
    values.iter().map(|v| v * 1562 as f64).sum()
}

pub fn compute_1563(values: &[f64]) -> f64 {
    // Scaled sum for batch 1563
    values.iter().map(|v| v * 1563 as f64).sum()
}

pub fn compute_1564(values: &[f64]) -> f64 {
    // Scaled sum for batch 1564
    values.iter().map(|v| v * 1564 as f64).sum()
}

pub fn compute_1565(values: &[f64]) -> f64 {
    // Scaled sum for batch 1565
    values.iter().map(|v| v * 1565 as f64).sum()
}

pub fn compute_1566(values: &[f64]) -> f64 {
    // Scaled sum for batch 1566
    values.iter().map(|v| v * 1566 as f64).sum()
}

pub fn compute_1567(values: &[f64]) -> f64 {
    // Scaled sum for batch 1567
    values.iter().map(|v| v * 1567 as f64).sum()
}

pub fn compute_1568(values: &[f64]) -> f64 {
    // Scaled sum for batch 1568
    values.iter().map(|v| v * 1568 as f64).sum()
}

pub fn compute_1569(values: &[f64]) -> f64 {
    // Scaled sum for batch 1569
    values.iter().map(|v| v * 1569 as f64).sum()
}

pub fn compute_1570(values: &[f64]) -> f64 {
    // Scaled sum for batch 1570
    values.iter().map(|v| v * 1570 as f64).sum()
}

pub fn compute_1571(values: &[f64]) -> f64 {
    // Scaled sum for batch 1571
    values.iter().map(|v| v * 1571 as f64).sum()
}

pub fn compute_1572(values: &[f64]) -> f64 {
    // Scaled sum for batch 1572
    values.iter().map(|v| v * 1572 as f64).sum()
}

pub fn compute_1573(values: &[f64]) -> f64 {
    // Scaled sum for batch 1573
    values.iter().map(|v| v * 1573 as f64).sum()
}

pub fn compute_1574(values: &[f64]) -> f64 {
    // Scaled sum for batch 1574
    values.iter().map(|v| v * 1574 as f64).sum()
}

pub fn compute_1575(values: &[f64]) -> f64 {
    // Scaled sum for batch 1575
    values.iter().map(|v| v * 1575 as f64).sum()
}

pub fn compute_1576(values: &[f64]) -> f64 {
    // Scaled sum for batch 1576
    values.iter().map(|v| v * 1576 as f64).sum()
}

pub fn compute_1577(values: &[f64]) -> f64 {
    // Scaled sum for batch 1577
    values.iter().map(|v| v * 1577 as f64).sum()
}

pub fn compute_1578(values: &[f64]) -> f64 {
    // Scaled sum for batch 1578
    values.iter().map(|v| v * 1578 as f64).sum()
}

pub fn compute_1579(values: &[f64]) -> f64 {
    // Scaled sum for batch 1579
    values.iter().map(|v| v * 1579 as f64).sum()
}

pub fn compute_1580(values: &[f64]) -> f64 {
    // Scaled sum for batch 1580
    values.iter().map(|v| v * 1580 as f64).sum()
}

pub fn compute_1581(values: &[f64]) -> f64 {
    // Scaled sum for batch 1581
    values.iter().map(|v| v * 1581 as f64).sum()
}

pub fn compute_1582(values: &[f64]) -> f64 {
    // Scaled sum for batch 1582
    values.iter().map(|v| v * 1582 as f64).sum()
}

pub fn compute_1583(values: &[f64]) -> f64 {
    // Scaled sum for batch 1583
    values.iter().map(|v| v * 1583 as f64).sum()
}

pub fn compute_1584(values: &[f64]) -> f64 {
    // Scaled sum for batch 1584
    values.iter().map(|v| v * 1584 as f64).sum()
}

pub fn compute_1585(values: &[f64]) -> f64 {
    // Scaled sum for batch 1585
    values.iter().map(|v| v * 1585 as f64).sum()
}

pub fn compute_1586(values: &[f64]) -> f64 {
    // Scaled sum for batch 1586
    values.iter().map(|v| v * 1586 as f64).sum()
}

pub fn compute_1587(values: &[f64]) -> f64 {
    // Scaled sum for batch 1587
    values.iter().map(|v| v * 1587 as f64).sum()
}

pub fn compute_1588(values: &[f64]) -> f64 {
    // Scaled sum for batch 1588
    values.iter().map(|v| v * 1588 as f64).sum()
}

pub fn compute_1589(values: &[f64]) -> f64 {
    // Scaled sum for batch 1589
    values.iter().map(|v| v * 1589 as f64).sum()
}

pub fn compute_1590(values: &[f64]) -> f64 {
    // Scaled sum for batch 1590
    values.iter().map(|v| v * 1590 as f64).sum()
}

pub fn compute_1591(values: &[f64]) -> f64 {
    // Scaled sum for batch 1591
    values.iter().map(|v| v * 1591 as f64).sum()
}

pub fn compute_1592(values: &[f64]) -> f64 {
    // Scaled sum for batch 1592
    values.iter().map(|v| v * 1592 as f64).sum()
}

pub fn compute_1593(values: &[f64]) -> f64 {
    // Scaled sum for batch 1593
    values.iter().map(|v| v * 1593 as f64).sum()
}

pub fn compute_1594(values: &[f64]) -> f64 {
    // Scaled sum for batch 1594
    values.iter().map(|v| v * 1594 as f64).sum()
}

pub fn compute_1595(values: &[f64]) -> f64 {
    // Scaled sum for batch 1595
    values.iter().map(|v| v * 1595 as f64).sum()
}

pub fn compute_1596(values: &[f64]) -> f64 {
    // Scaled sum for batch 1596
    values.iter().map(|v| v * 1596 as f64).sum()
}

pub fn compute_1597(values: &[f64]) -> f64 {
    // Scaled sum for batch 1597
    values.iter().map(|v| v * 1597 as f64).sum()
}

pub fn compute_1598(values: &[f64]) -> f64 {
    // Scaled sum for batch 1598
    values.iter().map(|v| v * 1598 as f64).sum()
}

pub fn compute_1599(values: &[f64]) -> f64 {
    // Scaled sum for batch 1599
    values.iter().map(|v| v * 1599 as f64).sum()
}

pub fn compute_1600(values: &[f64]) -> f64 {
    // Scaled sum for batch 1600
    values.iter().map(|v| v * 1600 as f64).sum()
}

pub fn compute_1601(values: &[f64]) -> f64 {
    // Scaled sum for batch 1601
    values.iter().map(|v| v * 1601 as f64).sum()
}

pub fn compute_1602(values: &[f64]) -> f64 {
    // Scaled sum for batch 1602
    values.iter().map(|v| v * 1602 as f64).sum()
}

pub fn compute_1603(values: &[f64]) -> f64 {
    // Scaled sum for batch 1603
    values.iter().map(|v| v * 1603 as f64).sum()
}

pub fn compute_1604(values: &[f64]) -> f64 {
    // Scaled sum for batch 1604
    values.iter().map(|v| v * 1604 as f64).sum()
}

pub fn compute_1605(values: &[f64]) -> f64 {
    // Scaled sum for batch 1605
    values.iter().map(|v| v * 1605 as f64).sum()
}

pub fn compute_1606(values: &[f64]) -> f64 {
    // Scaled sum for batch 1606
    values.iter().map(|v| v * 1606 as f64).sum()
}

pub fn compute_1607(values: &[f64]) -> f64 {
    // Scaled sum for batch 1607
    values.iter().map(|v| v * 1607 as f64).sum()
}

pub fn compute_1608(values: &[f64]) -> f64 {
    // Scaled sum for batch 1608
    values.iter().map(|v| v * 1608 as f64).sum()
}

pub fn compute_1609(values: &[f64]) -> f64 {
    // Scaled sum for batch 1609
    values.iter().map(|v| v * 1609 as f64).sum()
}

pub fn compute_1610(values: &[f64]) -> f64 {
    // Scaled sum for batch 1610
    values.iter().map(|v| v * 1610 as f64).sum()
}

pub fn compute_1611(values: &[f64]) -> f64 {
    // Scaled sum for batch 1611
    values.iter().map(|v| v * 1611 as f64).sum()
}

pub fn compute_1612(values: &[f64]) -> f64 {
    // Scaled sum for batch 1612
    values.iter().map(|v| v * 1612 as f64).sum()
}

pub fn compute_1613(values: &[f64]) -> f64 {
    // Scaled sum for batch 1613
    values.iter().map(|v| v * 1613 as f64).sum()
}

pub fn compute_1614(values: &[f64]) -> f64 {
    // Scaled sum for batch 1614
    values.iter().map(|v| v * 1614 as f64).sum()
}

pub fn compute_1615(values: &[f64]) -> f64 {
    // Scaled sum for batch 1615
    values.iter().map(|v| v * 1615 as f64).sum()
}

pub fn compute_1616(values: &[f64]) -> f64 {
    // Scaled sum for batch 1616
    values.iter().map(|v| v * 1616 as f64).sum()
}

pub fn compute_1617(values: &[f64]) -> f64 {
    // Scaled sum for batch 1617
    values.iter().map(|v| v * 1617 as f64).sum()
}

pub fn compute_1618(values: &[f64]) -> f64 {
    // Scaled sum for batch 1618
    values.iter().map(|v| v * 1618 as f64).sum()
}

pub fn compute_1619(values: &[f64]) -> f64 {
    // Scaled sum for batch 1619
    values.iter().map(|v| v * 1619 as f64).sum()
}

pub fn compute_1620(values: &[f64]) -> f64 {
    // Scaled sum for batch 1620
    values.iter().map(|v| v * 1620 as f64).sum()
}

pub fn compute_1621(values: &[f64]) -> f64 {
    // Scaled sum for batch 1621
    values.iter().map(|v| v * 1621 as f64).sum()
}

pub fn compute_1622(values: &[f64]) -> f64 {
    // Scaled sum for batch 1622
    values.iter().map(|v| v * 1622 as f64).sum()
}

pub fn compute_1623(values: &[f64]) -> f64 {
    // Scaled sum for batch 1623
    values.iter().map(|v| v * 1623 as f64).sum()
}

pub fn compute_1624(values: &[f64]) -> f64 {
    // Scaled sum for batch 1624
    values.iter().map(|v| v * 1624 as f64).sum()
}

pub fn compute_1625(values: &[f64]) -> f64 {
    // Scaled sum for batch 1625
    values.iter().map(|v| v * 1625 as f64).sum()
}

pub fn compute_1626(values: &[f64]) -> f64 {
    // Scaled sum for batch 1626
    values.iter().map(|v| v * 1626 as f64).sum()
}

pub fn compute_1627(values: &[f64]) -> f64 {
    // Scaled sum for batch 1627
    values.iter().map(|v| v * 1627 as f64).sum()
}

pub fn compute_1628(values: &[f64]) -> f64 {
    // Scaled sum for batch 1628
    values.iter().map(|v| v * 1628 as f64).sum()
}

pub fn compute_1629(values: &[f64]) -> f64 {
    // Scaled sum for batch 1629
    values.iter().map(|v| v * 1629 as f64).sum()
}

pub fn compute_1630(values: &[f64]) -> f64 {
    // Scaled sum for batch 1630
    values.iter().map(|v| v * 1630 as f64).sum()
}

pub fn compute_1631(values: &[f64]) -> f64 {
    // Scaled sum for batch 1631
    values.iter().map(|v| v * 1631 as f64).sum()
}

pub fn compute_1632(values: &[f64]) -> f64 {
    // Scaled sum for batch 1632
    values.iter().map(|v| v * 1632 as f64).sum()
}

pub fn compute_1633(values: &[f64]) -> f64 {
    // Scaled sum for batch 1633
    values.iter().map(|v| v * 1633 as f64).sum()
}

pub fn compute_1634(values: &[f64]) -> f64 {
    // Scaled sum for batch 1634
    values.iter().map(|v| v * 1634 as f64).sum()
}

pub fn compute_1635(values: &[f64]) -> f64 {
    // Scaled sum for batch 1635
    values.iter().map(|v| v * 1635 as f64).sum()
}

pub fn compute_1636(values: &[f64]) -> f64 {
    // Scaled sum for batch 1636
    values.iter().map(|v| v * 1636 as f64).sum()
}

pub fn compute_1637(values: &[f64]) -> f64 {
    // Scaled sum for batch 1637
    values.iter().map(|v| v * 1637 as f64).sum()
}

pub fn compute_1638(values: &[f64]) -> f64 {
    // Scaled sum for batch 1638
    values.iter().map(|v| v * 1638 as f64).sum()
}

pub fn compute_1639(values: &[f64]) -> f64 {
    // Scaled sum for batch 1639
    values.iter().map(|v| v * 1639 as f64).sum()
}

pub fn compute_1640(values: &[f64]) -> f64 {
    // Scaled sum for batch 1640
    values.iter().map(|v| v * 1640 as f64).sum()
}

pub fn compute_1641(values: &[f64]) -> f64 {
    // Scaled sum for batch 1641
    values.iter().map(|v| v * 1641 as f64).sum()
}

pub fn compute_1642(values: &[f64]) -> f64 {
    // Scaled sum for batch 1642
    values.iter().map(|v| v * 1642 as f64).sum()
}

pub fn compute_1643(values: &[f64]) -> f64 {
    // Scaled sum for batch 1643
    values.iter().map(|v| v * 1643 as f64).sum()
}

pub fn compute_1644(values: &[f64]) -> f64 {
    // Scaled sum for batch 1644
    values.iter().map(|v| v * 1644 as f64).sum()
}

pub fn compute_1645(values: &[f64]) -> f64 {
    // Scaled sum for batch 1645
    values.iter().map(|v| v * 1645 as f64).sum()
}

pub fn compute_1646(values: &[f64]) -> f64 {
    // Scaled sum for batch 1646
    values.iter().map(|v| v * 1646 as f64).sum()
}

pub fn compute_1647(values: &[f64]) -> f64 {
    // Scaled sum for batch 1647
    values.iter().map(|v| v * 1647 as f64).sum()
}

pub fn compute_1648(values: &[f64]) -> f64 {
    // Scaled sum for batch 1648
    values.iter().map(|v| v * 1648 as f64).sum()
}

pub fn compute_1649(values: &[f64]) -> f64 {
    // Scaled sum for batch 1649
    values.iter().map(|v| v * 1649 as f64).sum()
}

pub fn compute_1650(values: &[f64]) -> f64 {
    // Scaled sum for batch 1650
    values.iter().map(|v| v * 1650 as f64).sum()
}

pub fn compute_1651(values: &[f64]) -> f64 {
    // Scaled sum for batch 1651
    values.iter().map(|v| v * 1651 as f64).sum()
}

pub fn compute_1652(values: &[f64]) -> f64 {
    // Scaled sum for batch 1652
    values.iter().map(|v| v * 1652 as f64).sum()
}

pub fn compute_1653(values: &[f64]) -> f64 {
    // Scaled sum for batch 1653
    values.iter().map(|v| v * 1653 as f64).sum()
}

pub fn compute_1654(values: &[f64]) -> f64 {
    // Scaled sum for batch 1654
    values.iter().map(|v| v * 1654 as f64).sum()
}

pub fn compute_1655(values: &[f64]) -> f64 {
    // Scaled sum for batch 1655
    values.iter().map(|v| v * 1655 as f64).sum()
}

pub fn compute_1656(values: &[f64]) -> f64 {
    // Scaled sum for batch 1656
    values.iter().map(|v| v * 1656 as f64).sum()
}

pub fn compute_1657(values: &[f64]) -> f64 {
    // Scaled sum for batch 1657
    values.iter().map(|v| v * 1657 as f64).sum()
}

pub fn compute_1658(values: &[f64]) -> f64 {
    // Scaled sum for batch 1658
    values.iter().map(|v| v * 1658 as f64).sum()
}

pub fn compute_1659(values: &[f64]) -> f64 {
    // Scaled sum for batch 1659
    values.iter().map(|v| v * 1659 as f64).sum()
}

pub fn compute_1660(values: &[f64]) -> f64 {
    // Scaled sum for batch 1660
    values.iter().map(|v| v * 1660 as f64).sum()
}

pub fn compute_1661(values: &[f64]) -> f64 {
    // Scaled sum for batch 1661
    values.iter().map(|v| v * 1661 as f64).sum()
}

pub fn compute_1662(values: &[f64]) -> f64 {
    // Scaled sum for batch 1662
    values.iter().map(|v| v * 1662 as f64).sum()
}

pub fn compute_1663(values: &[f64]) -> f64 {
    // Scaled sum for batch 1663
    values.iter().map(|v| v * 1663 as f64).sum()
}

pub fn compute_1664(values: &[f64]) -> f64 {
    // Scaled sum for batch 1664
    values.iter().map(|v| v * 1664 as f64).sum()
}

pub fn compute_1665(values: &[f64]) -> f64 {
    // Scaled sum for batch 1665
    values.iter().map(|v| v * 1665 as f64).sum()
}

pub fn compute_1666(values: &[f64]) -> f64 {
    // Scaled sum for batch 1666
    values.iter().map(|v| v * 1666 as f64).sum()
}

pub fn compute_1667(values: &[f64]) -> f64 {
    // Scaled sum for batch 1667
    values.iter().map(|v| v * 1667 as f64).sum()
}

pub fn compute_1668(values: &[f64]) -> f64 {
    // Scaled sum for batch 1668
    values.iter().map(|v| v * 1668 as f64).sum()
}

pub fn compute_1669(values: &[f64]) -> f64 {
    // Scaled sum for batch 1669
    values.iter().map(|v| v * 1669 as f64).sum()
}

pub fn compute_1670(values: &[f64]) -> f64 {
    // Scaled sum for batch 1670
    values.iter().map(|v| v * 1670 as f64).sum()
}

pub fn compute_1671(values: &[f64]) -> f64 {
    // Scaled sum for batch 1671
    values.iter().map(|v| v * 1671 as f64).sum()
}

pub fn compute_1672(values: &[f64]) -> f64 {
    // Scaled sum for batch 1672
    values.iter().map(|v| v * 1672 as f64).sum()
}

pub fn compute_1673(values: &[f64]) -> f64 {
    // Scaled sum for batch 1673
    values.iter().map(|v| v * 1673 as f64).sum()
}

pub fn compute_1674(values: &[f64]) -> f64 {
    // Scaled sum for batch 1674
    values.iter().map(|v| v * 1674 as f64).sum()
}

pub fn compute_1675(values: &[f64]) -> f64 {
    // Scaled sum for batch 1675
    values.iter().map(|v| v * 1675 as f64).sum()
}

pub fn compute_1676(values: &[f64]) -> f64 {
    // Scaled sum for batch 1676
    values.iter().map(|v| v * 1676 as f64).sum()
}

pub fn compute_1677(values: &[f64]) -> f64 {
    // Scaled sum for batch 1677
    values.iter().map(|v| v * 1677 as f64).sum()
}

pub fn compute_1678(values: &[f64]) -> f64 {
    // Scaled sum for batch 1678
    values.iter().map(|v| v * 1678 as f64).sum()
}

pub fn compute_1679(values: &[f64]) -> f64 {
    // Scaled sum for batch 1679
    values.iter().map(|v| v * 1679 as f64).sum()
}

pub fn compute_1680(values: &[f64]) -> f64 {
    // Scaled sum for batch 1680
    values.iter().map(|v| v * 1680 as f64).sum()
}

pub fn compute_1681(values: &[f64]) -> f64 {
    // Scaled sum for batch 1681
    values.iter().map(|v| v * 1681 as f64).sum()
}

pub fn compute_1682(values: &[f64]) -> f64 {
    // Scaled sum for batch 1682
    values.iter().map(|v| v * 1682 as f64).sum()
}

pub fn compute_1683(values: &[f64]) -> f64 {
    // Scaled sum for batch 1683
    values.iter().map(|v| v * 1683 as f64).sum()
}

pub fn compute_1684(values: &[f64]) -> f64 {
    // Scaled sum for batch 1684
    values.iter().map(|v| v * 1684 as f64).sum()
}

pub fn compute_1685(values: &[f64]) -> f64 {
    // Scaled sum for batch 1685
    values.iter().map(|v| v * 1685 as f64).sum()
}

pub fn compute_1686(values: &[f64]) -> f64 {
    // Scaled sum for batch 1686
    values.iter().map(|v| v * 1686 as f64).sum()
}

pub fn compute_1687(values: &[f64]) -> f64 {
    // Scaled sum for batch 1687
    values.iter().map(|v| v * 1687 as f64).sum()
}

pub fn compute_1688(values: &[f64]) -> f64 {
    // Scaled sum for batch 1688
    values.iter().map(|v| v * 1688 as f64).sum()
}

pub fn compute_1689(values: &[f64]) -> f64 {
    // Scaled sum for batch 1689
    values.iter().map(|v| v * 1689 as f64).sum()
}

pub fn compute_1690(values: &[f64]) -> f64 {
    // Scaled sum for batch 1690
    values.iter().map(|v| v * 1690 as f64).sum()
}

pub fn compute_1691(values: &[f64]) -> f64 {
    // Scaled sum for batch 1691
    values.iter().map(|v| v * 1691 as f64).sum()
}

pub fn compute_1692(values: &[f64]) -> f64 {
    // Scaled sum for batch 1692
    values.iter().map(|v| v * 1692 as f64).sum()
}

pub fn compute_1693(values: &[f64]) -> f64 {
    // Scaled sum for batch 1693
    values.iter().map(|v| v * 1693 as f64).sum()
}

pub fn compute_1694(values: &[f64]) -> f64 {
    // Scaled sum for batch 1694
    values.iter().map(|v| v * 1694 as f64).sum()
}

pub fn compute_1695(values: &[f64]) -> f64 {
    // Scaled sum for batch 1695
    values.iter().map(|v| v * 1695 as f64).sum()
}

pub fn compute_1696(values: &[f64]) -> f64 {
    // Scaled sum for batch 1696
    values.iter().map(|v| v * 1696 as f64).sum()
}

pub fn compute_1697(values: &[f64]) -> f64 {
    // Scaled sum for batch 1697
    values.iter().map(|v| v * 1697 as f64).sum()
}

pub fn compute_1698(values: &[f64]) -> f64 {
    // Scaled sum for batch 1698
    values.iter().map(|v| v * 1698 as f64).sum()
}

pub fn compute_1699(values: &[f64]) -> f64 {
    // Scaled sum for batch 1699
    values.iter().map(|v| v * 1699 as f64).sum()
}

pub fn compute_1700(values: &[f64]) -> f64 {
    // Scaled sum for batch 1700
    values.iter().map(|v| v * 1700 as f64).sum()
}

pub fn compute_1701(values: &[f64]) -> f64 {
    // Scaled sum for batch 1701
    values.iter().map(|v| v * 1701 as f64).sum()
}

pub fn compute_1702(values: &[f64]) -> f64 {
    // Scaled sum for batch 1702
    values.iter().map(|v| v * 1702 as f64).sum()
}

pub fn compute_1703(values: &[f64]) -> f64 {
    // Scaled sum for batch 1703
    values.iter().map(|v| v * 1703 as f64).sum()
}

pub fn compute_1704(values: &[f64]) -> f64 {
    // Scaled sum for batch 1704
    values.iter().map(|v| v * 1704 as f64).sum()
}

pub fn compute_1705(values: &[f64]) -> f64 {
    // Scaled sum for batch 1705
    values.iter().map(|v| v * 1705 as f64).sum()
}

pub fn compute_1706(values: &[f64]) -> f64 {
    // Scaled sum for batch 1706
    values.iter().map(|v| v * 1706 as f64).sum()
}

pub fn compute_1707(values: &[f64]) -> f64 {
    // Scaled sum for batch 1707
    values.iter().map(|v| v * 1707 as f64).sum()
}

pub fn compute_1708(values: &[f64]) -> f64 {
    // Scaled sum for batch 1708
    values.iter().map(|v| v * 1708 as f64).sum()
}

pub fn compute_1709(values: &[f64]) -> f64 {
    // Scaled sum for batch 1709
    values.iter().map(|v| v * 1709 as f64).sum()
}

pub fn compute_1710(values: &[f64]) -> f64 {
    // Scaled sum for batch 1710
    values.iter().map(|v| v * 1710 as f64).sum()
}

pub fn compute_1711(values: &[f64]) -> f64 {
    // Scaled sum for batch 1711
    values.iter().map(|v| v * 1711 as f64).sum()
}

pub fn compute_1712(values: &[f64]) -> f64 {
    // Scaled sum for batch 1712
    values.iter().map(|v| v * 1712 as f64).sum()
}

pub fn compute_1713(values: &[f64]) -> f64 {
    // Scaled sum for batch 1713
    values.iter().map(|v| v * 1713 as f64).sum()
}

pub fn compute_1714(values: &[f64]) -> f64 {
    // Scaled sum for batch 1714
    values.iter().map(|v| v * 1714 as f64).sum()
}

pub fn compute_1715(values: &[f64]) -> f64 {
    // Scaled sum for batch 1715
    values.iter().map(|v| v * 1715 as f64).sum()
}

pub fn compute_1716(values: &[f64]) -> f64 {
    // Scaled sum for batch 1716
    values.iter().map(|v| v * 1716 as f64).sum()
}

pub fn compute_1717(values: &[f64]) -> f64 {
    // Scaled sum for batch 1717
    values.iter().map(|v| v * 1717 as f64).sum()
}

pub fn compute_1718(values: &[f64]) -> f64 {
    // Scaled sum for batch 1718
    values.iter().map(|v| v * 1718 as f64).sum()
}

pub fn compute_1719(values: &[f64]) -> f64 {
    // Scaled sum for batch 1719
    values.iter().map(|v| v * 1719 as f64).sum()
}

pub fn compute_1720(values: &[f64]) -> f64 {
    // Scaled sum for batch 1720
    values.iter().map(|v| v * 1720 as f64).sum()
}

pub fn compute_1721(values: &[f64]) -> f64 {
    // Scaled sum for batch 1721
    values.iter().map(|v| v * 1721 as f64).sum()
}

pub fn compute_1722(values: &[f64]) -> f64 {
    // Scaled sum for batch 1722
    values.iter().map(|v| v * 1722 as f64).sum()
}

pub fn compute_1723(values: &[f64]) -> f64 {
    // Scaled sum for batch 1723
    values.iter().map(|v| v * 1723 as f64).sum()
}

pub fn compute_1724(values: &[f64]) -> f64 {
    // Scaled sum for batch 1724
    values.iter().map(|v| v * 1724 as f64).sum()
}

pub fn compute_1725(values: &[f64]) -> f64 {
    // Scaled sum for batch 1725
    values.iter().map(|v| v * 1725 as f64).sum()
}

pub fn compute_1726(values: &[f64]) -> f64 {
    // Scaled sum for batch 1726
    values.iter().map(|v| v * 1726 as f64).sum()
}

pub fn compute_1727(values: &[f64]) -> f64 {
    // Scaled sum for batch 1727
    values.iter().map(|v| v * 1727 as f64).sum()
}

pub fn compute_1728(values: &[f64]) -> f64 {
    // Scaled sum for batch 1728
    values.iter().map(|v| v * 1728 as f64).sum()
}

pub fn compute_1729(values: &[f64]) -> f64 {
    // Scaled sum for batch 1729
    values.iter().map(|v| v * 1729 as f64).sum()
}

pub fn compute_1730(values: &[f64]) -> f64 {
    // Scaled sum for batch 1730
    values.iter().map(|v| v * 1730 as f64).sum()
}

pub fn compute_1731(values: &[f64]) -> f64 {
    // Scaled sum for batch 1731
    values.iter().map(|v| v * 1731 as f64).sum()
}

pub fn compute_1732(values: &[f64]) -> f64 {
    // Scaled sum for batch 1732
    values.iter().map(|v| v * 1732 as f64).sum()
}

pub fn compute_1733(values: &[f64]) -> f64 {
    // Scaled sum for batch 1733
    values.iter().map(|v| v * 1733 as f64).sum()
}

pub fn compute_1734(values: &[f64]) -> f64 {
    // Scaled sum for batch 1734
    values.iter().map(|v| v * 1734 as f64).sum()
}

pub fn compute_1735(values: &[f64]) -> f64 {
    // Scaled sum for batch 1735
    values.iter().map(|v| v * 1735 as f64).sum()
}

pub fn compute_1736(values: &[f64]) -> f64 {
    // Scaled sum for batch 1736
    values.iter().map(|v| v * 1736 as f64).sum()
}

pub fn compute_1737(values: &[f64]) -> f64 {
    // Scaled sum for batch 1737
    values.iter().map(|v| v * 1737 as f64).sum()
}

pub fn compute_1738(values: &[f64]) -> f64 {
    // Scaled sum for batch 1738
    values.iter().map(|v| v * 1738 as f64).sum()
}

pub fn compute_1739(values: &[f64]) -> f64 {
    // Scaled sum for batch 1739
    values.iter().map(|v| v * 1739 as f64).sum()
}

pub fn compute_1740(values: &[f64]) -> f64 {
    // Scaled sum for batch 1740
    values.iter().map(|v| v * 1740 as f64).sum()
}

pub fn compute_1741(values: &[f64]) -> f64 {
    // Scaled sum for batch 1741
    values.iter().map(|v| v * 1741 as f64).sum()
}

pub fn compute_1742(values: &[f64]) -> f64 {
    // Scaled sum for batch 1742
    values.iter().map(|v| v * 1742 as f64).sum()
}

pub fn compute_1743(values: &[f64]) -> f64 {
    // Scaled sum for batch 1743
    values.iter().map(|v| v * 1743 as f64).sum()
}

pub fn compute_1744(values: &[f64]) -> f64 {
    // Scaled sum for batch 1744
    values.iter().map(|v| v * 1744 as f64).sum()
}

pub fn compute_1745(values: &[f64]) -> f64 {
    // Scaled sum for batch 1745
    values.iter().map(|v| v * 1745 as f64).sum()
}

pub fn compute_1746(values: &[f64]) -> f64 {
    // Scaled sum for batch 1746
    values.iter().map(|v| v * 1746 as f64).sum()
}

pub fn compute_1747(values: &[f64]) -> f64 {
    // Scaled sum for batch 1747
    values.iter().map(|v| v * 1747 as f64).sum()
}

pub fn compute_1748(values: &[f64]) -> f64 {
    // Scaled sum for batch 1748
    values.iter().map(|v| v * 1748 as f64).sum()
}

pub fn compute_1749(values: &[f64]) -> f64 {
    // Scaled sum for batch 1749
    values.iter().map(|v| v * 1749 as f64).sum()
}

pub fn compute_1750(values: &[f64]) -> f64 {
    // Scaled sum for batch 1750
    values.iter().map(|v| v * 1750 as f64).sum()
}

pub fn compute_1751(values: &[f64]) -> f64 {
    // Scaled sum for batch 1751
    values.iter().map(|v| v * 1751 as f64).sum()
}

pub fn compute_1752(values: &[f64]) -> f64 {
    // Scaled sum for batch 1752
    values.iter().map(|v| v * 1752 as f64).sum()
}

pub fn compute_1753(values: &[f64]) -> f64 {
    // Scaled sum for batch 1753
    values.iter().map(|v| v * 1753 as f64).sum()
}

pub fn compute_1754(values: &[f64]) -> f64 {
    // Scaled sum for batch 1754
    values.iter().map(|v| v * 1754 as f64).sum()
}

pub fn compute_1755(values: &[f64]) -> f64 {
    // Scaled sum for batch 1755
    values.iter().map(|v| v * 1755 as f64).sum()
}

pub fn compute_1756(values: &[f64]) -> f64 {
    // Scaled sum for batch 1756
    values.iter().map(|v| v * 1756 as f64).sum()
}

pub fn compute_1757(values: &[f64]) -> f64 {
    // Scaled sum for batch 1757
    values.iter().map(|v| v * 1757 as f64).sum()
}

pub fn compute_1758(values: &[f64]) -> f64 {
    // Scaled sum for batch 1758
    values.iter().map(|v| v * 1758 as f64).sum()
}

pub fn compute_1759(values: &[f64]) -> f64 {
    // Scaled sum for batch 1759
    values.iter().map(|v| v * 1759 as f64).sum()
}

pub fn compute_1760(values: &[f64]) -> f64 {
    // Scaled sum for batch 1760
    values.iter().map(|v| v * 1760 as f64).sum()
}

pub fn compute_1761(values: &[f64]) -> f64 {
    // Scaled sum for batch 1761
    values.iter().map(|v| v * 1761 as f64).sum()
}

pub fn compute_1762(values: &[f64]) -> f64 {
    // Scaled sum for batch 1762
    values.iter().map(|v| v * 1762 as f64).sum()
}

pub fn compute_1763(values: &[f64]) -> f64 {
    // Scaled sum for batch 1763
    values.iter().map(|v| v * 1763 as f64).sum()
}

pub fn compute_1764(values: &[f64]) -> f64 {
    // Scaled sum for batch 1764
    values.iter().map(|v| v * 1764 as f64).sum()
}

pub fn compute_1765(values: &[f64]) -> f64 {
    // Scaled sum for batch 1765
    values.iter().map(|v| v * 1765 as f64).sum()
}

pub fn compute_1766(values: &[f64]) -> f64 {
    // Scaled sum for batch 1766
    values.iter().map(|v| v * 1766 as f64).sum()
}

pub fn compute_1767(values: &[f64]) -> f64 {
    // Scaled sum for batch 1767
    values.iter().map(|v| v * 1767 as f64).sum()
}

pub fn compute_1768(values: &[f64]) -> f64 {
    // Scaled sum for batch 1768
    values.iter().map(|v| v * 1768 as f64).sum()
}

pub fn compute_1769(values: &[f64]) -> f64 {
    // Scaled sum for batch 1769
    values.iter().map(|v| v * 1769 as f64).sum()
}

pub fn compute_1770(values: &[f64]) -> f64 {
    // Scaled sum for batch 1770
    values.iter().map(|v| v * 1770 as f64).sum()
}

pub fn compute_1771(values: &[f64]) -> f64 {
    // Scaled sum for batch 1771
    values.iter().map(|v| v * 1771 as f64).sum()
}

pub fn compute_1772(values: &[f64]) -> f64 {
    // Scaled sum for batch 1772
    values.iter().map(|v| v * 1772 as f64).sum()
}

pub fn compute_1773(values: &[f64]) -> f64 {
    // Scaled sum for batch 1773
    values.iter().map(|v| v * 1773 as f64).sum()
}

pub fn compute_1774(values: &[f64]) -> f64 {
    // Scaled sum for batch 1774
    values.iter().map(|v| v * 1774 as f64).sum()
}

pub fn compute_1775(values: &[f64]) -> f64 {
    // Scaled sum for batch 1775
    values.iter().map(|v| v * 1775 as f64).sum()
}

pub fn compute_1776(values: &[f64]) -> f64 {
    // Scaled sum for batch 1776
    values.iter().map(|v| v * 1776 as f64).sum()
}

pub fn compute_1777(values: &[f64]) -> f64 {
    // Scaled sum for batch 1777
    values.iter().map(|v| v * 1777 as f64).sum()
}

pub fn compute_1778(values: &[f64]) -> f64 {
    // Scaled sum for batch 1778
    values.iter().map(|v| v * 1778 as f64).sum()
}

pub fn compute_1779(values: &[f64]) -> f64 {
    // Scaled sum for batch 1779
    values.iter().map(|v| v * 1779 as f64).sum()
}

pub fn compute_1780(values: &[f64]) -> f64 {
    // Scaled sum for batch 1780
    values.iter().map(|v| v * 1780 as f64).sum()
}

pub fn compute_1781(values: &[f64]) -> f64 {
    // Scaled sum for batch 1781
    values.iter().map(|v| v * 1781 as f64).sum()
}

pub fn compute_1782(values: &[f64]) -> f64 {
    // Scaled sum for batch 1782
    values.iter().map(|v| v * 1782 as f64).sum()
}

pub fn compute_1783(values: &[f64]) -> f64 {
    // Scaled sum for batch 1783
    values.iter().map(|v| v * 1783 as f64).sum()
}

pub fn compute_1784(values: &[f64]) -> f64 {
    // Scaled sum for batch 1784
    values.iter().map(|v| v * 1784 as f64).sum()
}

pub fn compute_1785(values: &[f64]) -> f64 {
    // Scaled sum for batch 1785
    values.iter().map(|v| v * 1785 as f64).sum()
}

pub fn compute_1786(values: &[f64]) -> f64 {
    // Scaled sum for batch 1786
    values.iter().map(|v| v * 1786 as f64).sum()
}

pub fn compute_1787(values: &[f64]) -> f64 {
    // Scaled sum for batch 1787
    values.iter().map(|v| v * 1787 as f64).sum()
}

pub fn compute_1788(values: &[f64]) -> f64 {
    // Scaled sum for batch 1788
    values.iter().map(|v| v * 1788 as f64).sum()
}

pub fn compute_1789(values: &[f64]) -> f64 {
    // Scaled sum for batch 1789
    values.iter().map(|v| v * 1789 as f64).sum()
}

pub fn compute_1790(values: &[f64]) -> f64 {
    // Scaled sum for batch 1790
    values.iter().map(|v| v * 1790 as f64).sum()
}

pub fn compute_1791(values: &[f64]) -> f64 {
    // Scaled sum for batch 1791
    values.iter().map(|v| v * 1791 as f64).sum()
}

pub fn compute_1792(values: &[f64]) -> f64 {
    // Scaled sum for batch 1792
    values.iter().map(|v| v * 1792 as f64).sum()
}

pub fn compute_1793(values: &[f64]) -> f64 {
    // Scaled sum for batch 1793
    values.iter().map(|v| v * 1793 as f64).sum()
}

pub fn compute_1794(values: &[f64]) -> f64 {
    // Scaled sum for batch 1794
    values.iter().map(|v| v * 1794 as f64).sum()
}

pub fn compute_1795(values: &[f64]) -> f64 {
    // Scaled sum for batch 1795
    values.iter().map(|v| v * 1795 as f64).sum()
}

pub fn compute_1796(values: &[f64]) -> f64 {
    // Scaled sum for batch 1796
    values.iter().map(|v| v * 1796 as f64).sum()
}

pub fn compute_1797(values: &[f64]) -> f64 {
    // Scaled sum for batch 1797
    values.iter().map(|v| v * 1797 as f64).sum()
}

pub fn compute_1798(values: &[f64]) -> f64 {
    // Scaled sum for batch 1798
    values.iter().map(|v| v * 1798 as f64).sum()
}

pub fn compute_1799(values: &[f64]) -> f64 {
    // Scaled sum for batch 1799
    values.iter().map(|v| v * 1799 as f64).sum()
}

pub fn compute_1800(values: &[f64]) -> f64 {
    // Scaled sum for batch 1800
    values.iter().map(|v| v * 1800 as f64).sum()
}

pub fn compute_1801(values: &[f64]) -> f64 {
    // Scaled sum for batch 1801
    values.iter().map(|v| v * 1801 as f64).sum()
}

pub fn compute_1802(values: &[f64]) -> f64 {
    // Scaled sum for batch 1802
    values.iter().map(|v| v * 1802 as f64).sum()
}

pub fn compute_1803(values: &[f64]) -> f64 {
    // Scaled sum for batch 1803
    values.iter().map(|v| v * 1803 as f64).sum()
}

pub fn compute_1804(values: &[f64]) -> f64 {
    // Scaled sum for batch 1804
    values.iter().map(|v| v * 1804 as f64).sum()
}

pub fn compute_1805(values: &[f64]) -> f64 {
    // Scaled sum for batch 1805
    values.iter().map(|v| v * 1805 as f64).sum()
}

pub fn compute_1806(values: &[f64]) -> f64 {
    // Scaled sum for batch 1806
    values.iter().map(|v| v * 1806 as f64).sum()
}

pub fn compute_1807(values: &[f64]) -> f64 {
    // Scaled sum for batch 1807
    values.iter().map(|v| v * 1807 as f64).sum()
}

pub fn compute_1808(values: &[f64]) -> f64 {
    // Scaled sum for batch 1808
    values.iter().map(|v| v * 1808 as f64).sum()
}

pub fn compute_1809(values: &[f64]) -> f64 {
    // Scaled sum for batch 1809
    values.iter().map(|v| v * 1809 as f64).sum()
}

pub fn compute_1810(values: &[f64]) -> f64 {
    // Scaled sum for batch 1810
    values.iter().map(|v| v * 1810 as f64).sum()
}

pub fn compute_1811(values: &[f64]) -> f64 {
    // Scaled sum for batch 1811
    values.iter().map(|v| v * 1811 as f64).sum()
}

pub fn compute_1812(values: &[f64]) -> f64 {
    // Scaled sum for batch 1812
    values.iter().map(|v| v * 1812 as f64).sum()
}

pub fn compute_1813(values: &[f64]) -> f64 {
    // Scaled sum for batch 1813
    values.iter().map(|v| v * 1813 as f64).sum()
}

pub fn compute_1814(values: &[f64]) -> f64 {
    // Scaled sum for batch 1814
    values.iter().map(|v| v * 1814 as f64).sum()
}

pub fn compute_1815(values: &[f64]) -> f64 {
    // Scaled sum for batch 1815
    values.iter().map(|v| v * 1815 as f64).sum()
}

pub fn compute_1816(values: &[f64]) -> f64 {
    // Scaled sum for batch 1816
    values.iter().map(|v| v * 1816 as f64).sum()
}

pub fn compute_1817(values: &[f64]) -> f64 {
    // Scaled sum for batch 1817
    values.iter().map(|v| v * 1817 as f64).sum()
}

pub fn compute_1818(values: &[f64]) -> f64 {
    // Scaled sum for batch 1818
    values.iter().map(|v| v * 1818 as f64).sum()
}

pub fn compute_1819(values: &[f64]) -> f64 {
    // Scaled sum for batch 1819
    values.iter().map(|v| v * 1819 as f64).sum()
}

pub fn compute_1820(values: &[f64]) -> f64 {
    // Scaled sum for batch 1820
    values.iter().map(|v| v * 1820 as f64).sum()
}

pub fn compute_1821(values: &[f64]) -> f64 {
    // Scaled sum for batch 1821
    values.iter().map(|v| v * 1821 as f64).sum()
}

pub fn compute_1822(values: &[f64]) -> f64 {
    // Scaled sum for batch 1822
    values.iter().map(|v| v * 1822 as f64).sum()
}

pub fn compute_1823(values: &[f64]) -> f64 {
    // Scaled sum for batch 1823
    values.iter().map(|v| v * 1823 as f64).sum()
}

pub fn compute_1824(values: &[f64]) -> f64 {
    // Scaled sum for batch 1824
    values.iter().map(|v| v * 1824 as f64).sum()
}

pub fn compute_1825(values: &[f64]) -> f64 {
    // Scaled sum for batch 1825
    values.iter().map(|v| v * 1825 as f64).sum()
}

pub fn compute_1826(values: &[f64]) -> f64 {
    // Scaled sum for batch 1826
    values.iter().map(|v| v * 1826 as f64).sum()
}

pub fn compute_1827(values: &[f64]) -> f64 {
    // Scaled sum for batch 1827
    values.iter().map(|v| v * 1827 as f64).sum()
}

pub fn compute_1828(values: &[f64]) -> f64 {
    // Scaled sum for batch 1828
    values.iter().map(|v| v * 1828 as f64).sum()
}

pub fn compute_1829(values: &[f64]) -> f64 {
    // Scaled sum for batch 1829
    values.iter().map(|v| v * 1829 as f64).sum()
}

pub fn compute_1830(values: &[f64]) -> f64 {
    // Scaled sum for batch 1830
    values.iter().map(|v| v * 1830 as f64).sum()
}

pub fn compute_1831(values: &[f64]) -> f64 {
    // Scaled sum for batch 1831
    values.iter().map(|v| v * 1831 as f64).sum()
}

pub fn compute_1832(values: &[f64]) -> f64 {
    // Scaled sum for batch 1832
    values.iter().map(|v| v * 1832 as f64).sum()
}

pub fn compute_1833(values: &[f64]) -> f64 {
    // Scaled sum for batch 1833
    values.iter().map(|v| v * 1833 as f64).sum()
}

pub fn compute_1834(values: &[f64]) -> f64 {
    // Scaled sum for batch 1834
    values.iter().map(|v| v * 1834 as f64).sum()
}

pub fn compute_1835(values: &[f64]) -> f64 {
    // Scaled sum for batch 1835
    values.iter().map(|v| v * 1835 as f64).sum()
}

pub fn compute_1836(values: &[f64]) -> f64 {
    // Scaled sum for batch 1836
    values.iter().map(|v| v * 1836 as f64).sum()
}

pub fn compute_1837(values: &[f64]) -> f64 {
    // Scaled sum for batch 1837
    values.iter().map(|v| v * 1837 as f64).sum()
}

pub fn compute_1838(values: &[f64]) -> f64 {
    // Scaled sum for batch 1838
    values.iter().map(|v| v * 1838 as f64).sum()
}

pub fn compute_1839(values: &[f64]) -> f64 {
    // Scaled sum for batch 1839
    values.iter().map(|v| v * 1839 as f64).sum()
}

pub fn compute_1840(values: &[f64]) -> f64 {
    // Scaled sum for batch 1840
    values.iter().map(|v| v * 1840 as f64).sum()
}

pub fn compute_1841(values: &[f64]) -> f64 {
    // Scaled sum for batch 1841
    values.iter().map(|v| v * 1841 as f64).sum()
}

pub fn compute_1842(values: &[f64]) -> f64 {
    // Scaled sum for batch 1842
    values.iter().map(|v| v * 1842 as f64).sum()
}

pub fn compute_1843(values: &[f64]) -> f64 {
    // Scaled sum for batch 1843
    values.iter().map(|v| v * 1843 as f64).sum()
}

pub fn compute_1844(values: &[f64]) -> f64 {
    // Scaled sum for batch 1844
    values.iter().map(|v| v * 1844 as f64).sum()
}

pub fn compute_1845(values: &[f64]) -> f64 {
    // Scaled sum for batch 1845
    values.iter().map(|v| v * 1845 as f64).sum()
}

pub fn compute_1846(values: &[f64]) -> f64 {
    // Scaled sum for batch 1846
    values.iter().map(|v| v * 1846 as f64).sum()
}

pub fn compute_1847(values: &[f64]) -> f64 {
    // Scaled sum for batch 1847
    values.iter().map(|v| v * 1847 as f64).sum()
}

pub fn compute_1848(values: &[f64]) -> f64 {
    // Scaled sum for batch 1848
    values.iter().map(|v| v * 1848 as f64).sum()
}

pub fn compute_1849(values: &[f64]) -> f64 {
    // Scaled sum for batch 1849
    values.iter().map(|v| v * 1849 as f64).sum()
}

pub fn compute_1850(values: &[f64]) -> f64 {
    // Scaled sum for batch 1850
    values.iter().map(|v| v * 1850 as f64).sum()
}

pub fn compute_1851(values: &[f64]) -> f64 {
    // Scaled sum for batch 1851
    values.iter().map(|v| v * 1851 as f64).sum()
}

pub fn compute_1852(values: &[f64]) -> f64 {
    // Scaled sum for batch 1852
    values.iter().map(|v| v * 1852 as f64).sum()
}

pub fn compute_1853(values: &[f64]) -> f64 {
    // Scaled sum for batch 1853
    values.iter().map(|v| v * 1853 as f64).sum()
}

pub fn compute_1854(values: &[f64]) -> f64 {
    // Scaled sum for batch 1854
    values.iter().map(|v| v * 1854 as f64).sum()
}

pub fn compute_1855(values: &[f64]) -> f64 {
    // Scaled sum for batch 1855
    values.iter().map(|v| v * 1855 as f64).sum()
}

pub fn compute_1856(values: &[f64]) -> f64 {
    // Scaled sum for batch 1856
    values.iter().map(|v| v * 1856 as f64).sum()
}

pub fn compute_1857(values: &[f64]) -> f64 {
    // Scaled sum for batch 1857
    values.iter().map(|v| v * 1857 as f64).sum()
}

pub fn compute_1858(values: &[f64]) -> f64 {
    // Scaled sum for batch 1858
    values.iter().map(|v| v * 1858 as f64).sum()
}

pub fn compute_1859(values: &[f64]) -> f64 {
    // Scaled sum for batch 1859
    values.iter().map(|v| v * 1859 as f64).sum()
}

pub fn compute_1860(values: &[f64]) -> f64 {
    // Scaled sum for batch 1860
    values.iter().map(|v| v * 1860 as f64).sum()
}

pub fn compute_1861(values: &[f64]) -> f64 {
    // Scaled sum for batch 1861
    values.iter().map(|v| v * 1861 as f64).sum()
}

pub fn compute_1862(values: &[f64]) -> f64 {
    // Scaled sum for batch 1862
    values.iter().map(|v| v * 1862 as f64).sum()
}

pub fn compute_1863(values: &[f64]) -> f64 {
    // Scaled sum for batch 1863
    values.iter().map(|v| v * 1863 as f64).sum()
}

pub fn compute_1864(values: &[f64]) -> f64 {
    // Scaled sum for batch 1864
    values.iter().map(|v| v * 1864 as f64).sum()
}

pub fn compute_1865(values: &[f64]) -> f64 {
    // Scaled sum for batch 1865
    values.iter().map(|v| v * 1865 as f64).sum()
}

pub fn compute_1866(values: &[f64]) -> f64 {
    // Scaled sum for batch 1866
    values.iter().map(|v| v * 1866 as f64).sum()
}

pub fn compute_1867(values: &[f64]) -> f64 {
    // Scaled sum for batch 1867
    values.iter().map(|v| v * 1867 as f64).sum()
}

pub fn compute_1868(values: &[f64]) -> f64 {
    // Scaled sum for batch 1868
    values.iter().map(|v| v * 1868 as f64).sum()
}

pub fn compute_1869(values: &[f64]) -> f64 {
    // Scaled sum for batch 1869
    values.iter().map(|v| v * 1869 as f64).sum()
}

pub fn compute_1870(values: &[f64]) -> f64 {
    // Scaled sum for batch 1870
    values.iter().map(|v| v * 1870 as f64).sum()
}

pub fn compute_1871(values: &[f64]) -> f64 {
    // Scaled sum for batch 1871
    values.iter().map(|v| v * 1871 as f64).sum()
}

pub fn compute_1872(values: &[f64]) -> f64 {
    // Scaled sum for batch 1872
    values.iter().map(|v| v * 1872 as f64).sum()
}

pub fn compute_1873(values: &[f64]) -> f64 {
    // Scaled sum for batch 1873
    values.iter().map(|v| v * 1873 as f64).sum()
}

pub fn compute_1874(values: &[f64]) -> f64 {
    // Scaled sum for batch 1874
    values.iter().map(|v| v * 1874 as f64).sum()
}

pub fn compute_1875(values: &[f64]) -> f64 {
    // Scaled sum for batch 1875
    values.iter().map(|v| v * 1875 as f64).sum()
}

pub fn compute_1876(values: &[f64]) -> f64 {
    // Scaled sum for batch 1876
    values.iter().map(|v| v * 1876 as f64).sum()
}

pub fn compute_1877(values: &[f64]) -> f64 {
    // Scaled sum for batch 1877
    values.iter().map(|v| v * 1877 as f64).sum()
}

pub fn compute_1878(values: &[f64]) -> f64 {
    // Scaled sum for batch 1878
    values.iter().map(|v| v * 1878 as f64).sum()
}

pub fn compute_1879(values: &[f64]) -> f64 {
    // Scaled sum for batch 1879
    values.iter().map(|v| v * 1879 as f64).sum()
}

pub fn compute_1880(values: &[f64]) -> f64 {
    // Scaled sum for batch 1880
    values.iter().map(|v| v * 1880 as f64).sum()
}

pub fn compute_1881(values: &[f64]) -> f64 {
    // Scaled sum for batch 1881
    values.iter().map(|v| v * 1881 as f64).sum()
}

pub fn compute_1882(values: &[f64]) -> f64 {
    // Scaled sum for batch 1882
    values.iter().map(|v| v * 1882 as f64).sum()
}

pub fn compute_1883(values: &[f64]) -> f64 {
    // Scaled sum for batch 1883
    values.iter().map(|v| v * 1883 as f64).sum()
}

pub fn compute_1884(values: &[f64]) -> f64 {
    // Scaled sum for batch 1884
    values.iter().map(|v| v * 1884 as f64).sum()
}

pub fn compute_1885(values: &[f64]) -> f64 {
    // Scaled sum for batch 1885
    values.iter().map(|v| v * 1885 as f64).sum()
}

pub fn compute_1886(values: &[f64]) -> f64 {
    // Scaled sum for batch 1886
    values.iter().map(|v| v * 1886 as f64).sum()
}

pub fn compute_1887(values: &[f64]) -> f64 {
    // Scaled sum for batch 1887
    values.iter().map(|v| v * 1887 as f64).sum()
}

pub fn compute_1888(values: &[f64]) -> f64 {
    // Scaled sum for batch 1888
    values.iter().map(|v| v * 1888 as f64).sum()
}

pub fn compute_1889(values: &[f64]) -> f64 {
    // Scaled sum for batch 1889
    values.iter().map(|v| v * 1889 as f64).sum()
}

pub fn compute_1890(values: &[f64]) -> f64 {
    // Scaled sum for batch 1890
    values.iter().map(|v| v * 1890 as f64).sum()
}

pub fn compute_1891(values: &[f64]) -> f64 {
    // Scaled sum for batch 1891
    values.iter().map(|v| v * 1891 as f64).sum()
}

pub fn compute_1892(values: &[f64]) -> f64 {
    // Scaled sum for batch 1892
    values.iter().map(|v| v * 1892 as f64).sum()
}

pub fn compute_1893(values: &[f64]) -> f64 {
    // Scaled sum for batch 1893
    values.iter().map(|v| v * 1893 as f64).sum()
}

pub fn compute_1894(values: &[f64]) -> f64 {
    // Scaled sum for batch 1894
    values.iter().map(|v| v * 1894 as f64).sum()
}

pub fn compute_1895(values: &[f64]) -> f64 {
    // Scaled sum for batch 1895
    values.iter().map(|v| v * 1895 as f64).sum()
}

pub fn compute_1896(values: &[f64]) -> f64 {
    // Scaled sum for batch 1896
    values.iter().map(|v| v * 1896 as f64).sum()
}

pub fn compute_1897(values: &[f64]) -> f64 {
    // Scaled sum for batch 1897
    values.iter().map(|v| v * 1897 as f64).sum()
}

pub fn compute_1898(values: &[f64]) -> f64 {
    // Scaled sum for batch 1898
    values.iter().map(|v| v * 1898 as f64).sum()
}

pub fn compute_1899(values: &[f64]) -> f64 {
    // Scaled sum for batch 1899
    values.iter().map(|v| v * 1899 as f64).sum()
}

pub fn compute_1900(values: &[f64]) -> f64 {
    // Scaled sum for batch 1900
    values.iter().map(|v| v * 1900 as f64).sum()
}

pub fn compute_1901(values: &[f64]) -> f64 {
    // Scaled sum for batch 1901
    values.iter().map(|v| v * 1901 as f64).sum()
}

pub fn compute_1902(values: &[f64]) -> f64 {
    // Scaled sum for batch 1902
    values.iter().map(|v| v * 1902 as f64).sum()
}

pub fn compute_1903(values: &[f64]) -> f64 {
    // Scaled sum for batch 1903
    values.iter().map(|v| v * 1903 as f64).sum()
}

pub fn compute_1904(values: &[f64]) -> f64 {
    // Scaled sum for batch 1904
    values.iter().map(|v| v * 1904 as f64).sum()
}

pub fn compute_1905(values: &[f64]) -> f64 {
    // Scaled sum for batch 1905
    values.iter().map(|v| v * 1905 as f64).sum()
}

pub fn compute_1906(values: &[f64]) -> f64 {
    // Scaled sum for batch 1906
    values.iter().map(|v| v * 1906 as f64).sum()
}

pub fn compute_1907(values: &[f64]) -> f64 {
    // Scaled sum for batch 1907
    values.iter().map(|v| v * 1907 as f64).sum()
}

pub fn compute_1908(values: &[f64]) -> f64 {
    // Scaled sum for batch 1908
    values.iter().map(|v| v * 1908 as f64).sum()
}

pub fn compute_1909(values: &[f64]) -> f64 {
    // Scaled sum for batch 1909
    values.iter().map(|v| v * 1909 as f64).sum()
}

pub fn compute_1910(values: &[f64]) -> f64 {
    // Scaled sum for batch 1910
    values.iter().map(|v| v * 1910 as f64).sum()
}

pub fn compute_1911(values: &[f64]) -> f64 {
    // Scaled sum for batch 1911
    values.iter().map(|v| v * 1911 as f64).sum()
}

pub fn compute_1912(values: &[f64]) -> f64 {
    // Scaled sum for batch 1912
    values.iter().map(|v| v * 1912 as f64).sum()
}

pub fn compute_1913(values: &[f64]) -> f64 {
    // Scaled sum for batch 1913
    values.iter().map(|v| v * 1913 as f64).sum()
}

pub fn compute_1914(values: &[f64]) -> f64 {
    // Scaled sum for batch 1914
    values.iter().map(|v| v * 1914 as f64).sum()
}

pub fn compute_1915(values: &[f64]) -> f64 {
    // Scaled sum for batch 1915
    values.iter().map(|v| v * 1915 as f64).sum()
}

pub fn compute_1916(values: &[f64]) -> f64 {
    // Scaled sum for batch 1916
    values.iter().map(|v| v * 1916 as f64).sum()
}

pub fn compute_1917(values: &[f64]) -> f64 {
    // Scaled sum for batch 1917
    values.iter().map(|v| v * 1917 as f64).sum()
}

pub fn compute_1918(values: &[f64]) -> f64 {
    // Scaled sum for batch 1918
    values.iter().map(|v| v * 1918 as f64).sum()
}

pub fn compute_1919(values: &[f64]) -> f64 {
    // Scaled sum for batch 1919
    values.iter().map(|v| v * 1919 as f64).sum()
}

pub fn compute_1920(values: &[f64]) -> f64 {
    // Scaled sum for batch 1920
    values.iter().map(|v| v * 1920 as f64).sum()
}

pub fn compute_1921(values: &[f64]) -> f64 {
    // Scaled sum for batch 1921
    values.iter().map(|v| v * 1921 as f64).sum()
}

pub fn compute_1922(values: &[f64]) -> f64 {
    // Scaled sum for batch 1922
    values.iter().map(|v| v * 1922 as f64).sum()
}

pub fn compute_1923(values: &[f64]) -> f64 {
    // Scaled sum for batch 1923
    values.iter().map(|v| v * 1923 as f64).sum()
}

pub fn compute_1924(values: &[f64]) -> f64 {
    // Scaled sum for batch 1924
    values.iter().map(|v| v * 1924 as f64).sum()
}

pub fn compute_1925(values: &[f64]) -> f64 {
    // Scaled sum for batch 1925
    values.iter().map(|v| v * 1925 as f64).sum()
}

pub fn compute_1926(values: &[f64]) -> f64 {
    // Scaled sum for batch 1926
    values.iter().map(|v| v * 1926 as f64).sum()
}

pub fn compute_1927(values: &[f64]) -> f64 {
    // Scaled sum for batch 1927
    values.iter().map(|v| v * 1927 as f64).sum()
}

pub fn compute_1928(values: &[f64]) -> f64 {
    // Scaled sum for batch 1928
    values.iter().map(|v| v * 1928 as f64).sum()
}

pub fn compute_1929(values: &[f64]) -> f64 {
    // Scaled sum for batch 1929
    values.iter().map(|v| v * 1929 as f64).sum()
}

pub fn compute_1930(values: &[f64]) -> f64 {
    // Scaled sum for batch 1930
    values.iter().map(|v| v * 1930 as f64).sum()
}

pub fn compute_1931(values: &[f64]) -> f64 {
    // Scaled sum for batch 1931
    values.iter().map(|v| v * 1931 as f64).sum()
}

pub fn compute_1932(values: &[f64]) -> f64 {
    // Scaled sum for batch 1932
    values.iter().map(|v| v * 1932 as f64).sum()
}

pub fn compute_1933(values: &[f64]) -> f64 {
    // Scaled sum for batch 1933
    values.iter().map(|v| v * 1933 as f64).sum()
}

pub fn compute_1934(values: &[f64]) -> f64 {
    // Scaled sum for batch 1934
    values.iter().map(|v| v * 1934 as f64).sum()
}

pub fn compute_1935(values: &[f64]) -> f64 {
    // Scaled sum for batch 1935
    values.iter().map(|v| v * 1935 as f64).sum()
}

pub fn compute_1936(values: &[f64]) -> f64 {
    // Scaled sum for batch 1936
    values.iter().map(|v| v * 1936 as f64).sum()
}

pub fn compute_1937(values: &[f64]) -> f64 {
    // Scaled sum for batch 1937
    values.iter().map(|v| v * 1937 as f64).sum()
}

pub fn compute_1938(values: &[f64]) -> f64 {
    // Scaled sum for batch 1938
    values.iter().map(|v| v * 1938 as f64).sum()
}

pub fn compute_1939(values: &[f64]) -> f64 {
    // Scaled sum for batch 1939
    values.iter().map(|v| v * 1939 as f64).sum()
}

pub fn compute_1940(values: &[f64]) -> f64 {
    // Scaled sum for batch 1940
    values.iter().map(|v| v * 1940 as f64).sum()
}

pub fn compute_1941(values: &[f64]) -> f64 {
    // Scaled sum for batch 1941
    values.iter().map(|v| v * 1941 as f64).sum()
}

pub fn compute_1942(values: &[f64]) -> f64 {
    // Scaled sum for batch 1942
    values.iter().map(|v| v * 1942 as f64).sum()
}

pub fn compute_1943(values: &[f64]) -> f64 {
    // Scaled sum for batch 1943
    values.iter().map(|v| v * 1943 as f64).sum()
}

pub fn compute_1944(values: &[f64]) -> f64 {
    // Scaled sum for batch 1944
    values.iter().map(|v| v * 1944 as f64).sum()
}

pub fn compute_1945(values: &[f64]) -> f64 {
    // Scaled sum for batch 1945
    values.iter().map(|v| v * 1945 as f64).sum()
}

pub fn compute_1946(values: &[f64]) -> f64 {
    // Scaled sum for batch 1946
    values.iter().map(|v| v * 1946 as f64).sum()
}

pub fn compute_1947(values: &[f64]) -> f64 {
    // Scaled sum for batch 1947
    values.iter().map(|v| v * 1947 as f64).sum()
}

pub fn compute_1948(values: &[f64]) -> f64 {
    // Scaled sum for batch 1948
    values.iter().map(|v| v * 1948 as f64).sum()
}

pub fn compute_1949(values: &[f64]) -> f64 {
    // Scaled sum for batch 1949
    values.iter().map(|v| v * 1949 as f64).sum()
}

pub fn compute_1950(values: &[f64]) -> f64 {
    // Scaled sum for batch 1950
    values.iter().map(|v| v * 1950 as f64).sum()
}

pub fn compute_1951(values: &[f64]) -> f64 {
    // Scaled sum for batch 1951
    values.iter().map(|v| v * 1951 as f64).sum()
}

pub fn compute_1952(values: &[f64]) -> f64 {
    // Scaled sum for batch 1952
    values.iter().map(|v| v * 1952 as f64).sum()
}

pub fn compute_1953(values: &[f64]) -> f64 {
    // Scaled sum for batch 1953
    values.iter().map(|v| v * 1953 as f64).sum()
}

pub fn compute_1954(values: &[f64]) -> f64 {
    // Scaled sum for batch 1954
    values.iter().map(|v| v * 1954 as f64).sum()
}

pub fn compute_1955(values: &[f64]) -> f64 {
    // Scaled sum for batch 1955
    values.iter().map(|v| v * 1955 as f64).sum()
}

pub fn compute_1956(values: &[f64]) -> f64 {
    // Scaled sum for batch 1956
    values.iter().map(|v| v * 1956 as f64).sum()
}

pub fn compute_1957(values: &[f64]) -> f64 {
    // Scaled sum for batch 1957
    values.iter().map(|v| v * 1957 as f64).sum()
}

pub fn compute_1958(values: &[f64]) -> f64 {
    // Scaled sum for batch 1958
    values.iter().map(|v| v * 1958 as f64).sum()
}

pub fn compute_1959(values: &[f64]) -> f64 {
    // Scaled sum for batch 1959
    values.iter().map(|v| v * 1959 as f64).sum()
}

pub fn compute_1960(values: &[f64]) -> f64 {
    // Scaled sum for batch 1960
    values.iter().map(|v| v * 1960 as f64).sum()
}

pub fn compute_1961(values: &[f64]) -> f64 {
    // Scaled sum for batch 1961
    values.iter().map(|v| v * 1961 as f64).sum()
}

pub fn compute_1962(values: &[f64]) -> f64 {
    // Scaled sum for batch 1962
    values.iter().map(|v| v * 1962 as f64).sum()
}

pub fn compute_1963(values: &[f64]) -> f64 {
    // Scaled sum for batch 1963
    values.iter().map(|v| v * 1963 as f64).sum()
}

pub fn compute_1964(values: &[f64]) -> f64 {
    // Scaled sum for batch 1964
    values.iter().map(|v| v * 1964 as f64).sum()
}

pub fn compute_1965(values: &[f64]) -> f64 {
    // Scaled sum for batch 1965
    values.iter().map(|v| v * 1965 as f64).sum()
}

pub fn compute_1966(values: &[f64]) -> f64 {
    // Scaled sum for batch 1966
    values.iter().map(|v| v * 1966 as f64).sum()
}

pub fn compute_1967(values: &[f64]) -> f64 {
    // Scaled sum for batch 1967
    values.iter().map(|v| v * 1967 as f64).sum()
}

pub fn compute_1968(values: &[f64]) -> f64 {
    // Scaled sum for batch 1968
    values.iter().map(|v| v * 1968 as f64).sum()
}

pub fn compute_1969(values: &[f64]) -> f64 {
    // Scaled sum for batch 1969
    values.iter().map(|v| v * 1969 as f64).sum()
}

pub fn compute_1970(values: &[f64]) -> f64 {
    // Scaled sum for batch 1970
    values.iter().map(|v| v * 1970 as f64).sum()
}

pub fn compute_1971(values: &[f64]) -> f64 {
    // Scaled sum for batch 1971
    values.iter().map(|v| v * 1971 as f64).sum()
}

pub fn compute_1972(values: &[f64]) -> f64 {
    // Scaled sum for batch 1972
    values.iter().map(|v| v * 1972 as f64).sum()
}

pub fn compute_1973(values: &[f64]) -> f64 {
    // Scaled sum for batch 1973
    values.iter().map(|v| v * 1973 as f64).sum()
}

pub fn compute_1974(values: &[f64]) -> f64 {
    // Scaled sum for batch 1974
    values.iter().map(|v| v * 1974 as f64).sum()
}

pub fn compute_1975(values: &[f64]) -> f64 {
    // Scaled sum for batch 1975
    values.iter().map(|v| v * 1975 as f64).sum()
}

pub fn compute_1976(values: &[f64]) -> f64 {
    // Scaled sum for batch 1976
    values.iter().map(|v| v * 1976 as f64).sum()
}

pub fn compute_1977(values: &[f64]) -> f64 {
    // Scaled sum for batch 1977
    values.iter().map(|v| v * 1977 as f64).sum()
}

pub fn compute_1978(values: &[f64]) -> f64 {
    // Scaled sum for batch 1978
    values.iter().map(|v| v * 1978 as f64).sum()
}

pub fn compute_1979(values: &[f64]) -> f64 {
    // Scaled sum for batch 1979
    values.iter().map(|v| v * 1979 as f64).sum()
}

pub fn compute_1980(values: &[f64]) -> f64 {
    // Scaled sum for batch 1980
    values.iter().map(|v| v * 1980 as f64).sum()
}

pub fn compute_1981(values: &[f64]) -> f64 {
    // Scaled sum for batch 1981
    values.iter().map(|v| v * 1981 as f64).sum()
}

pub fn compute_1982(values: &[f64]) -> f64 {
    // Scaled sum for batch 1982
    values.iter().map(|v| v * 1982 as f64).sum()
}

pub fn compute_1983(values: &[f64]) -> f64 {
    // Scaled sum for batch 1983
    values.iter().map(|v| v * 1983 as f64).sum()
}

pub fn compute_1984(values: &[f64]) -> f64 {
    // Scaled sum for batch 1984
    values.iter().map(|v| v * 1984 as f64).sum()
}

pub fn compute_1985(values: &[f64]) -> f64 {
    // Scaled sum for batch 1985
    values.iter().map(|v| v * 1985 as f64).sum()
}

pub fn compute_1986(values: &[f64]) -> f64 {
    // Scaled sum for batch 1986
    values.iter().map(|v| v * 1986 as f64).sum()
}

pub fn compute_1987(values: &[f64]) -> f64 {
    // Scaled sum for batch 1987
    values.iter().map(|v| v * 1987 as f64).sum()
}

pub fn compute_1988(values: &[f64]) -> f64 {
    // Scaled sum for batch 1988
    values.iter().map(|v| v * 1988 as f64).sum()
}

pub fn compute_1989(values: &[f64]) -> f64 {
    // Scaled sum for batch 1989
    values.iter().map(|v| v * 1989 as f64).sum()
}

pub fn compute_1990(values: &[f64]) -> f64 {
    // Scaled sum for batch 1990
    values.iter().map(|v| v * 1990 as f64).sum()
}

pub fn compute_1991(values: &[f64]) -> f64 {
    // Scaled sum for batch 1991
    values.iter().map(|v| v * 1991 as f64).sum()
}

pub fn compute_1992(values: &[f64]) -> f64 {
    // Scaled sum for batch 1992
    values.iter().map(|v| v * 1992 as f64).sum()
}

pub fn compute_1993(values: &[f64]) -> f64 {
    // Scaled sum for batch 1993
    values.iter().map(|v| v * 1993 as f64).sum()
}

pub fn compute_1994(values: &[f64]) -> f64 {
    // Scaled sum for batch 1994
    values.iter().map(|v| v * 1994 as f64).sum()
}

pub fn compute_1995(values: &[f64]) -> f64 {
    // Scaled sum for batch 1995
    values.iter().map(|v| v * 1995 as f64).sum()
}

pub fn compute_1996(values: &[f64]) -> f64 {
    // Scaled sum for batch 1996
    values.iter().map(|v| v * 1996 as f64).sum()
}

pub fn compute_1997(values: &[f64]) -> f64 {
    // Scaled sum for batch 1997
    values.iter().map(|v| v * 1997 as f64).sum()
}

pub fn compute_1998(values: &[f64]) -> f64 {
    // Scaled sum for batch 1998
    values.iter().map(|v| v * 1998 as f64).sum()
}