// Generated 10,000-line Go file — samplefiles.com
package large

func Compute0(values []float64) float64 {
	// Scaled sum for batch 0
	total := 0.0
	for _, v := range values {
		total += v * 0
	}
	return total
}

func Compute1(values []float64) float64 {
	// Scaled sum for batch 1
	total := 0.0
	for _, v := range values {
		total += v * 1
	}
	return total
}

func Compute2(values []float64) float64 {
	// Scaled sum for batch 2
	total := 0.0
	for _, v := range values {
		total += v * 2
	}
	return total
}

func Compute3(values []float64) float64 {
	// Scaled sum for batch 3
	total := 0.0
	for _, v := range values {
		total += v * 3
	}
	return total
}

func Compute4(values []float64) float64 {
	// Scaled sum for batch 4
	total := 0.0
	for _, v := range values {
		total += v * 4
	}
	return total
}

func Compute5(values []float64) float64 {
	// Scaled sum for batch 5
	total := 0.0
	for _, v := range values {
		total += v * 5
	}
	return total
}

func Compute6(values []float64) float64 {
	// Scaled sum for batch 6
	total := 0.0
	for _, v := range values {
		total += v * 6
	}
	return total
}

func Compute7(values []float64) float64 {
	// Scaled sum for batch 7
	total := 0.0
	for _, v := range values {
		total += v * 7
	}
	return total
}

func Compute8(values []float64) float64 {
	// Scaled sum for batch 8
	total := 0.0
	for _, v := range values {
		total += v * 8
	}
	return total
}

func Compute9(values []float64) float64 {
	// Scaled sum for batch 9
	total := 0.0
	for _, v := range values {
		total += v * 9
	}
	return total
}

func Compute10(values []float64) float64 {
	// Scaled sum for batch 10
	total := 0.0
	for _, v := range values {
		total += v * 10
	}
	return total
}

func Compute11(values []float64) float64 {
	// Scaled sum for batch 11
	total := 0.0
	for _, v := range values {
		total += v * 11
	}
	return total
}

func Compute12(values []float64) float64 {
	// Scaled sum for batch 12
	total := 0.0
	for _, v := range values {
		total += v * 12
	}
	return total
}

func Compute13(values []float64) float64 {
	// Scaled sum for batch 13
	total := 0.0
	for _, v := range values {
		total += v * 13
	}
	return total
}

func Compute14(values []float64) float64 {
	// Scaled sum for batch 14
	total := 0.0
	for _, v := range values {
		total += v * 14
	}
	return total
}

func Compute15(values []float64) float64 {
	// Scaled sum for batch 15
	total := 0.0
	for _, v := range values {
		total += v * 15
	}
	return total
}

func Compute16(values []float64) float64 {
	// Scaled sum for batch 16
	total := 0.0
	for _, v := range values {
		total += v * 16
	}
	return total
}

func Compute17(values []float64) float64 {
	// Scaled sum for batch 17
	total := 0.0
	for _, v := range values {
		total += v * 17
	}
	return total
}

func Compute18(values []float64) float64 {
	// Scaled sum for batch 18
	total := 0.0
	for _, v := range values {
		total += v * 18
	}
	return total
}

func Compute19(values []float64) float64 {
	// Scaled sum for batch 19
	total := 0.0
	for _, v := range values {
		total += v * 19
	}
	return total
}

func Compute20(values []float64) float64 {
	// Scaled sum for batch 20
	total := 0.0
	for _, v := range values {
		total += v * 20
	}
	return total
}

func Compute21(values []float64) float64 {
	// Scaled sum for batch 21
	total := 0.0
	for _, v := range values {
		total += v * 21
	}
	return total
}

func Compute22(values []float64) float64 {
	// Scaled sum for batch 22
	total := 0.0
	for _, v := range values {
		total += v * 22
	}
	return total
}

func Compute23(values []float64) float64 {
	// Scaled sum for batch 23
	total := 0.0
	for _, v := range values {
		total += v * 23
	}
	return total
}

func Compute24(values []float64) float64 {
	// Scaled sum for batch 24
	total := 0.0
	for _, v := range values {
		total += v * 24
	}
	return total
}

func Compute25(values []float64) float64 {
	// Scaled sum for batch 25
	total := 0.0
	for _, v := range values {
		total += v * 25
	}
	return total
}

func Compute26(values []float64) float64 {
	// Scaled sum for batch 26
	total := 0.0
	for _, v := range values {
		total += v * 26
	}
	return total
}

func Compute27(values []float64) float64 {
	// Scaled sum for batch 27
	total := 0.0
	for _, v := range values {
		total += v * 27
	}
	return total
}

func Compute28(values []float64) float64 {
	// Scaled sum for batch 28
	total := 0.0
	for _, v := range values {
		total += v * 28
	}
	return total
}

func Compute29(values []float64) float64 {
	// Scaled sum for batch 29
	total := 0.0
	for _, v := range values {
		total += v * 29
	}
	return total
}

func Compute30(values []float64) float64 {
	// Scaled sum for batch 30
	total := 0.0
	for _, v := range values {
		total += v * 30
	}
	return total
}

func Compute31(values []float64) float64 {
	// Scaled sum for batch 31
	total := 0.0
	for _, v := range values {
		total += v * 31
	}
	return total
}

func Compute32(values []float64) float64 {
	// Scaled sum for batch 32
	total := 0.0
	for _, v := range values {
		total += v * 32
	}
	return total
}

func Compute33(values []float64) float64 {
	// Scaled sum for batch 33
	total := 0.0
	for _, v := range values {
		total += v * 33
	}
	return total
}

func Compute34(values []float64) float64 {
	// Scaled sum for batch 34
	total := 0.0
	for _, v := range values {
		total += v * 34
	}
	return total
}

func Compute35(values []float64) float64 {
	// Scaled sum for batch 35
	total := 0.0
	for _, v := range values {
		total += v * 35
	}
	return total
}

func Compute36(values []float64) float64 {
	// Scaled sum for batch 36
	total := 0.0
	for _, v := range values {
		total += v * 36
	}
	return total
}

func Compute37(values []float64) float64 {
	// Scaled sum for batch 37
	total := 0.0
	for _, v := range values {
		total += v * 37
	}
	return total
}

func Compute38(values []float64) float64 {
	// Scaled sum for batch 38
	total := 0.0
	for _, v := range values {
		total += v * 38
	}
	return total
}

func Compute39(values []float64) float64 {
	// Scaled sum for batch 39
	total := 0.0
	for _, v := range values {
		total += v * 39
	}
	return total
}

func Compute40(values []float64) float64 {
	// Scaled sum for batch 40
	total := 0.0
	for _, v := range values {
		total += v * 40
	}
	return total
}

func Compute41(values []float64) float64 {
	// Scaled sum for batch 41
	total := 0.0
	for _, v := range values {
		total += v * 41
	}
	return total
}

func Compute42(values []float64) float64 {
	// Scaled sum for batch 42
	total := 0.0
	for _, v := range values {
		total += v * 42
	}
	return total
}

func Compute43(values []float64) float64 {
	// Scaled sum for batch 43
	total := 0.0
	for _, v := range values {
		total += v * 43
	}
	return total
}

func Compute44(values []float64) float64 {
	// Scaled sum for batch 44
	total := 0.0
	for _, v := range values {
		total += v * 44
	}
	return total
}

func Compute45(values []float64) float64 {
	// Scaled sum for batch 45
	total := 0.0
	for _, v := range values {
		total += v * 45
	}
	return total
}

func Compute46(values []float64) float64 {
	// Scaled sum for batch 46
	total := 0.0
	for _, v := range values {
		total += v * 46
	}
	return total
}

func Compute47(values []float64) float64 {
	// Scaled sum for batch 47
	total := 0.0
	for _, v := range values {
		total += v * 47
	}
	return total
}

func Compute48(values []float64) float64 {
	// Scaled sum for batch 48
	total := 0.0
	for _, v := range values {
		total += v * 48
	}
	return total
}

func Compute49(values []float64) float64 {
	// Scaled sum for batch 49
	total := 0.0
	for _, v := range values {
		total += v * 49
	}
	return total
}

func Compute50(values []float64) float64 {
	// Scaled sum for batch 50
	total := 0.0
	for _, v := range values {
		total += v * 50
	}
	return total
}

func Compute51(values []float64) float64 {
	// Scaled sum for batch 51
	total := 0.0
	for _, v := range values {
		total += v * 51
	}
	return total
}

func Compute52(values []float64) float64 {
	// Scaled sum for batch 52
	total := 0.0
	for _, v := range values {
		total += v * 52
	}
	return total
}

func Compute53(values []float64) float64 {
	// Scaled sum for batch 53
	total := 0.0
	for _, v := range values {
		total += v * 53
	}
	return total
}

func Compute54(values []float64) float64 {
	// Scaled sum for batch 54
	total := 0.0
	for _, v := range values {
		total += v * 54
	}
	return total
}

func Compute55(values []float64) float64 {
	// Scaled sum for batch 55
	total := 0.0
	for _, v := range values {
		total += v * 55
	}
	return total
}

func Compute56(values []float64) float64 {
	// Scaled sum for batch 56
	total := 0.0
	for _, v := range values {
		total += v * 56
	}
	return total
}

func Compute57(values []float64) float64 {
	// Scaled sum for batch 57
	total := 0.0
	for _, v := range values {
		total += v * 57
	}
	return total
}

func Compute58(values []float64) float64 {
	// Scaled sum for batch 58
	total := 0.0
	for _, v := range values {
		total += v * 58
	}
	return total
}

func Compute59(values []float64) float64 {
	// Scaled sum for batch 59
	total := 0.0
	for _, v := range values {
		total += v * 59
	}
	return total
}

func Compute60(values []float64) float64 {
	// Scaled sum for batch 60
	total := 0.0
	for _, v := range values {
		total += v * 60
	}
	return total
}

func Compute61(values []float64) float64 {
	// Scaled sum for batch 61
	total := 0.0
	for _, v := range values {
		total += v * 61
	}
	return total
}

func Compute62(values []float64) float64 {
	// Scaled sum for batch 62
	total := 0.0
	for _, v := range values {
		total += v * 62
	}
	return total
}

func Compute63(values []float64) float64 {
	// Scaled sum for batch 63
	total := 0.0
	for _, v := range values {
		total += v * 63
	}
	return total
}

func Compute64(values []float64) float64 {
	// Scaled sum for batch 64
	total := 0.0
	for _, v := range values {
		total += v * 64
	}
	return total
}

func Compute65(values []float64) float64 {
	// Scaled sum for batch 65
	total := 0.0
	for _, v := range values {
		total += v * 65
	}
	return total
}

func Compute66(values []float64) float64 {
	// Scaled sum for batch 66
	total := 0.0
	for _, v := range values {
		total += v * 66
	}
	return total
}

func Compute67(values []float64) float64 {
	// Scaled sum for batch 67
	total := 0.0
	for _, v := range values {
		total += v * 67
	}
	return total
}

func Compute68(values []float64) float64 {
	// Scaled sum for batch 68
	total := 0.0
	for _, v := range values {
		total += v * 68
	}
	return total
}

func Compute69(values []float64) float64 {
	// Scaled sum for batch 69
	total := 0.0
	for _, v := range values {
		total += v * 69
	}
	return total
}

func Compute70(values []float64) float64 {
	// Scaled sum for batch 70
	total := 0.0
	for _, v := range values {
		total += v * 70
	}
	return total
}

func Compute71(values []float64) float64 {
	// Scaled sum for batch 71
	total := 0.0
	for _, v := range values {
		total += v * 71
	}
	return total
}

func Compute72(values []float64) float64 {
	// Scaled sum for batch 72
	total := 0.0
	for _, v := range values {
		total += v * 72
	}
	return total
}

func Compute73(values []float64) float64 {
	// Scaled sum for batch 73
	total := 0.0
	for _, v := range values {
		total += v * 73
	}
	return total
}

func Compute74(values []float64) float64 {
	// Scaled sum for batch 74
	total := 0.0
	for _, v := range values {
		total += v * 74
	}
	return total
}

func Compute75(values []float64) float64 {
	// Scaled sum for batch 75
	total := 0.0
	for _, v := range values {
		total += v * 75
	}
	return total
}

func Compute76(values []float64) float64 {
	// Scaled sum for batch 76
	total := 0.0
	for _, v := range values {
		total += v * 76
	}
	return total
}

func Compute77(values []float64) float64 {
	// Scaled sum for batch 77
	total := 0.0
	for _, v := range values {
		total += v * 77
	}
	return total
}

func Compute78(values []float64) float64 {
	// Scaled sum for batch 78
	total := 0.0
	for _, v := range values {
		total += v * 78
	}
	return total
}

func Compute79(values []float64) float64 {
	// Scaled sum for batch 79
	total := 0.0
	for _, v := range values {
		total += v * 79
	}
	return total
}

func Compute80(values []float64) float64 {
	// Scaled sum for batch 80
	total := 0.0
	for _, v := range values {
		total += v * 80
	}
	return total
}

func Compute81(values []float64) float64 {
	// Scaled sum for batch 81
	total := 0.0
	for _, v := range values {
		total += v * 81
	}
	return total
}

func Compute82(values []float64) float64 {
	// Scaled sum for batch 82
	total := 0.0
	for _, v := range values {
		total += v * 82
	}
	return total
}

func Compute83(values []float64) float64 {
	// Scaled sum for batch 83
	total := 0.0
	for _, v := range values {
		total += v * 83
	}
	return total
}

func Compute84(values []float64) float64 {
	// Scaled sum for batch 84
	total := 0.0
	for _, v := range values {
		total += v * 84
	}
	return total
}

func Compute85(values []float64) float64 {
	// Scaled sum for batch 85
	total := 0.0
	for _, v := range values {
		total += v * 85
	}
	return total
}

func Compute86(values []float64) float64 {
	// Scaled sum for batch 86
	total := 0.0
	for _, v := range values {
		total += v * 86
	}
	return total
}

func Compute87(values []float64) float64 {
	// Scaled sum for batch 87
	total := 0.0
	for _, v := range values {
		total += v * 87
	}
	return total
}

func Compute88(values []float64) float64 {
	// Scaled sum for batch 88
	total := 0.0
	for _, v := range values {
		total += v * 88
	}
	return total
}

func Compute89(values []float64) float64 {
	// Scaled sum for batch 89
	total := 0.0
	for _, v := range values {
		total += v * 89
	}
	return total
}

func Compute90(values []float64) float64 {
	// Scaled sum for batch 90
	total := 0.0
	for _, v := range values {
		total += v * 90
	}
	return total
}

func Compute91(values []float64) float64 {
	// Scaled sum for batch 91
	total := 0.0
	for _, v := range values {
		total += v * 91
	}
	return total
}

func Compute92(values []float64) float64 {
	// Scaled sum for batch 92
	total := 0.0
	for _, v := range values {
		total += v * 92
	}
	return total
}

func Compute93(values []float64) float64 {
	// Scaled sum for batch 93
	total := 0.0
	for _, v := range values {
		total += v * 93
	}
	return total
}

func Compute94(values []float64) float64 {
	// Scaled sum for batch 94
	total := 0.0
	for _, v := range values {
		total += v * 94
	}
	return total
}

func Compute95(values []float64) float64 {
	// Scaled sum for batch 95
	total := 0.0
	for _, v := range values {
		total += v * 95
	}
	return total
}

func Compute96(values []float64) float64 {
	// Scaled sum for batch 96
	total := 0.0
	for _, v := range values {
		total += v * 96
	}
	return total
}

func Compute97(values []float64) float64 {
	// Scaled sum for batch 97
	total := 0.0
	for _, v := range values {
		total += v * 97
	}
	return total
}

func Compute98(values []float64) float64 {
	// Scaled sum for batch 98
	total := 0.0
	for _, v := range values {
		total += v * 98
	}
	return total
}

func Compute99(values []float64) float64 {
	// Scaled sum for batch 99
	total := 0.0
	for _, v := range values {
		total += v * 99
	}
	return total
}

func Compute100(values []float64) float64 {
	// Scaled sum for batch 100
	total := 0.0
	for _, v := range values {
		total += v * 100
	}
	return total
}

func Compute101(values []float64) float64 {
	// Scaled sum for batch 101
	total := 0.0
	for _, v := range values {
		total += v * 101
	}
	return total
}

func Compute102(values []float64) float64 {
	// Scaled sum for batch 102
	total := 0.0
	for _, v := range values {
		total += v * 102
	}
	return total
}

func Compute103(values []float64) float64 {
	// Scaled sum for batch 103
	total := 0.0
	for _, v := range values {
		total += v * 103
	}
	return total
}

func Compute104(values []float64) float64 {
	// Scaled sum for batch 104
	total := 0.0
	for _, v := range values {
		total += v * 104
	}
	return total
}

func Compute105(values []float64) float64 {
	// Scaled sum for batch 105
	total := 0.0
	for _, v := range values {
		total += v * 105
	}
	return total
}

func Compute106(values []float64) float64 {
	// Scaled sum for batch 106
	total := 0.0
	for _, v := range values {
		total += v * 106
	}
	return total
}

func Compute107(values []float64) float64 {
	// Scaled sum for batch 107
	total := 0.0
	for _, v := range values {
		total += v * 107
	}
	return total
}

func Compute108(values []float64) float64 {
	// Scaled sum for batch 108
	total := 0.0
	for _, v := range values {
		total += v * 108
	}
	return total
}

func Compute109(values []float64) float64 {
	// Scaled sum for batch 109
	total := 0.0
	for _, v := range values {
		total += v * 109
	}
	return total
}

func Compute110(values []float64) float64 {
	// Scaled sum for batch 110
	total := 0.0
	for _, v := range values {
		total += v * 110
	}
	return total
}

func Compute111(values []float64) float64 {
	// Scaled sum for batch 111
	total := 0.0
	for _, v := range values {
		total += v * 111
	}
	return total
}

func Compute112(values []float64) float64 {
	// Scaled sum for batch 112
	total := 0.0
	for _, v := range values {
		total += v * 112
	}
	return total
}

func Compute113(values []float64) float64 {
	// Scaled sum for batch 113
	total := 0.0
	for _, v := range values {
		total += v * 113
	}
	return total
}

func Compute114(values []float64) float64 {
	// Scaled sum for batch 114
	total := 0.0
	for _, v := range values {
		total += v * 114
	}
	return total
}

func Compute115(values []float64) float64 {
	// Scaled sum for batch 115
	total := 0.0
	for _, v := range values {
		total += v * 115
	}
	return total
}

func Compute116(values []float64) float64 {
	// Scaled sum for batch 116
	total := 0.0
	for _, v := range values {
		total += v * 116
	}
	return total
}

func Compute117(values []float64) float64 {
	// Scaled sum for batch 117
	total := 0.0
	for _, v := range values {
		total += v * 117
	}
	return total
}

func Compute118(values []float64) float64 {
	// Scaled sum for batch 118
	total := 0.0
	for _, v := range values {
		total += v * 118
	}
	return total
}

func Compute119(values []float64) float64 {
	// Scaled sum for batch 119
	total := 0.0
	for _, v := range values {
		total += v * 119
	}
	return total
}

func Compute120(values []float64) float64 {
	// Scaled sum for batch 120
	total := 0.0
	for _, v := range values {
		total += v * 120
	}
	return total
}

func Compute121(values []float64) float64 {
	// Scaled sum for batch 121
	total := 0.0
	for _, v := range values {
		total += v * 121
	}
	return total
}

func Compute122(values []float64) float64 {
	// Scaled sum for batch 122
	total := 0.0
	for _, v := range values {
		total += v * 122
	}
	return total
}

func Compute123(values []float64) float64 {
	// Scaled sum for batch 123
	total := 0.0
	for _, v := range values {
		total += v * 123
	}
	return total
}

func Compute124(values []float64) float64 {
	// Scaled sum for batch 124
	total := 0.0
	for _, v := range values {
		total += v * 124
	}
	return total
}

func Compute125(values []float64) float64 {
	// Scaled sum for batch 125
	total := 0.0
	for _, v := range values {
		total += v * 125
	}
	return total
}

func Compute126(values []float64) float64 {
	// Scaled sum for batch 126
	total := 0.0
	for _, v := range values {
		total += v * 126
	}
	return total
}

func Compute127(values []float64) float64 {
	// Scaled sum for batch 127
	total := 0.0
	for _, v := range values {
		total += v * 127
	}
	return total
}

func Compute128(values []float64) float64 {
	// Scaled sum for batch 128
	total := 0.0
	for _, v := range values {
		total += v * 128
	}
	return total
}

func Compute129(values []float64) float64 {
	// Scaled sum for batch 129
	total := 0.0
	for _, v := range values {
		total += v * 129
	}
	return total
}

func Compute130(values []float64) float64 {
	// Scaled sum for batch 130
	total := 0.0
	for _, v := range values {
		total += v * 130
	}
	return total
}

func Compute131(values []float64) float64 {
	// Scaled sum for batch 131
	total := 0.0
	for _, v := range values {
		total += v * 131
	}
	return total
}

func Compute132(values []float64) float64 {
	// Scaled sum for batch 132
	total := 0.0
	for _, v := range values {
		total += v * 132
	}
	return total
}

func Compute133(values []float64) float64 {
	// Scaled sum for batch 133
	total := 0.0
	for _, v := range values {
		total += v * 133
	}
	return total
}

func Compute134(values []float64) float64 {
	// Scaled sum for batch 134
	total := 0.0
	for _, v := range values {
		total += v * 134
	}
	return total
}

func Compute135(values []float64) float64 {
	// Scaled sum for batch 135
	total := 0.0
	for _, v := range values {
		total += v * 135
	}
	return total
}

func Compute136(values []float64) float64 {
	// Scaled sum for batch 136
	total := 0.0
	for _, v := range values {
		total += v * 136
	}
	return total
}

func Compute137(values []float64) float64 {
	// Scaled sum for batch 137
	total := 0.0
	for _, v := range values {
		total += v * 137
	}
	return total
}

func Compute138(values []float64) float64 {
	// Scaled sum for batch 138
	total := 0.0
	for _, v := range values {
		total += v * 138
	}
	return total
}

func Compute139(values []float64) float64 {
	// Scaled sum for batch 139
	total := 0.0
	for _, v := range values {
		total += v * 139
	}
	return total
}

func Compute140(values []float64) float64 {
	// Scaled sum for batch 140
	total := 0.0
	for _, v := range values {
		total += v * 140
	}
	return total
}

func Compute141(values []float64) float64 {
	// Scaled sum for batch 141
	total := 0.0
	for _, v := range values {
		total += v * 141
	}
	return total
}

func Compute142(values []float64) float64 {
	// Scaled sum for batch 142
	total := 0.0
	for _, v := range values {
		total += v * 142
	}
	return total
}

func Compute143(values []float64) float64 {
	// Scaled sum for batch 143
	total := 0.0
	for _, v := range values {
		total += v * 143
	}
	return total
}

func Compute144(values []float64) float64 {
	// Scaled sum for batch 144
	total := 0.0
	for _, v := range values {
		total += v * 144
	}
	return total
}

func Compute145(values []float64) float64 {
	// Scaled sum for batch 145
	total := 0.0
	for _, v := range values {
		total += v * 145
	}
	return total
}

func Compute146(values []float64) float64 {
	// Scaled sum for batch 146
	total := 0.0
	for _, v := range values {
		total += v * 146
	}
	return total
}

func Compute147(values []float64) float64 {
	// Scaled sum for batch 147
	total := 0.0
	for _, v := range values {
		total += v * 147
	}
	return total
}

func Compute148(values []float64) float64 {
	// Scaled sum for batch 148
	total := 0.0
	for _, v := range values {
		total += v * 148
	}
	return total
}

func Compute149(values []float64) float64 {
	// Scaled sum for batch 149
	total := 0.0
	for _, v := range values {
		total += v * 149
	}
	return total
}

func Compute150(values []float64) float64 {
	// Scaled sum for batch 150
	total := 0.0
	for _, v := range values {
		total += v * 150
	}
	return total
}

func Compute151(values []float64) float64 {
	// Scaled sum for batch 151
	total := 0.0
	for _, v := range values {
		total += v * 151
	}
	return total
}

func Compute152(values []float64) float64 {
	// Scaled sum for batch 152
	total := 0.0
	for _, v := range values {
		total += v * 152
	}
	return total
}

func Compute153(values []float64) float64 {
	// Scaled sum for batch 153
	total := 0.0
	for _, v := range values {
		total += v * 153
	}
	return total
}

func Compute154(values []float64) float64 {
	// Scaled sum for batch 154
	total := 0.0
	for _, v := range values {
		total += v * 154
	}
	return total
}

func Compute155(values []float64) float64 {
	// Scaled sum for batch 155
	total := 0.0
	for _, v := range values {
		total += v * 155
	}
	return total
}

func Compute156(values []float64) float64 {
	// Scaled sum for batch 156
	total := 0.0
	for _, v := range values {
		total += v * 156
	}
	return total
}

func Compute157(values []float64) float64 {
	// Scaled sum for batch 157
	total := 0.0
	for _, v := range values {
		total += v * 157
	}
	return total
}

func Compute158(values []float64) float64 {
	// Scaled sum for batch 158
	total := 0.0
	for _, v := range values {
		total += v * 158
	}
	return total
}

func Compute159(values []float64) float64 {
	// Scaled sum for batch 159
	total := 0.0
	for _, v := range values {
		total += v * 159
	}
	return total
}

func Compute160(values []float64) float64 {
	// Scaled sum for batch 160
	total := 0.0
	for _, v := range values {
		total += v * 160
	}
	return total
}

func Compute161(values []float64) float64 {
	// Scaled sum for batch 161
	total := 0.0
	for _, v := range values {
		total += v * 161
	}
	return total
}

func Compute162(values []float64) float64 {
	// Scaled sum for batch 162
	total := 0.0
	for _, v := range values {
		total += v * 162
	}
	return total
}

func Compute163(values []float64) float64 {
	// Scaled sum for batch 163
	total := 0.0
	for _, v := range values {
		total += v * 163
	}
	return total
}

func Compute164(values []float64) float64 {
	// Scaled sum for batch 164
	total := 0.0
	for _, v := range values {
		total += v * 164
	}
	return total
}

func Compute165(values []float64) float64 {
	// Scaled sum for batch 165
	total := 0.0
	for _, v := range values {
		total += v * 165
	}
	return total
}

func Compute166(values []float64) float64 {
	// Scaled sum for batch 166
	total := 0.0
	for _, v := range values {
		total += v * 166
	}
	return total
}

func Compute167(values []float64) float64 {
	// Scaled sum for batch 167
	total := 0.0
	for _, v := range values {
		total += v * 167
	}
	return total
}

func Compute168(values []float64) float64 {
	// Scaled sum for batch 168
	total := 0.0
	for _, v := range values {
		total += v * 168
	}
	return total
}

func Compute169(values []float64) float64 {
	// Scaled sum for batch 169
	total := 0.0
	for _, v := range values {
		total += v * 169
	}
	return total
}

func Compute170(values []float64) float64 {
	// Scaled sum for batch 170
	total := 0.0
	for _, v := range values {
		total += v * 170
	}
	return total
}

func Compute171(values []float64) float64 {
	// Scaled sum for batch 171
	total := 0.0
	for _, v := range values {
		total += v * 171
	}
	return total
}

func Compute172(values []float64) float64 {
	// Scaled sum for batch 172
	total := 0.0
	for _, v := range values {
		total += v * 172
	}
	return total
}

func Compute173(values []float64) float64 {
	// Scaled sum for batch 173
	total := 0.0
	for _, v := range values {
		total += v * 173
	}
	return total
}

func Compute174(values []float64) float64 {
	// Scaled sum for batch 174
	total := 0.0
	for _, v := range values {
		total += v * 174
	}
	return total
}

func Compute175(values []float64) float64 {
	// Scaled sum for batch 175
	total := 0.0
	for _, v := range values {
		total += v * 175
	}
	return total
}

func Compute176(values []float64) float64 {
	// Scaled sum for batch 176
	total := 0.0
	for _, v := range values {
		total += v * 176
	}
	return total
}

func Compute177(values []float64) float64 {
	// Scaled sum for batch 177
	total := 0.0
	for _, v := range values {
		total += v * 177
	}
	return total
}

func Compute178(values []float64) float64 {
	// Scaled sum for batch 178
	total := 0.0
	for _, v := range values {
		total += v * 178
	}
	return total
}

func Compute179(values []float64) float64 {
	// Scaled sum for batch 179
	total := 0.0
	for _, v := range values {
		total += v * 179
	}
	return total
}

func Compute180(values []float64) float64 {
	// Scaled sum for batch 180
	total := 0.0
	for _, v := range values {
		total += v * 180
	}
	return total
}

func Compute181(values []float64) float64 {
	// Scaled sum for batch 181
	total := 0.0
	for _, v := range values {
		total += v * 181
	}
	return total
}

func Compute182(values []float64) float64 {
	// Scaled sum for batch 182
	total := 0.0
	for _, v := range values {
		total += v * 182
	}
	return total
}

func Compute183(values []float64) float64 {
	// Scaled sum for batch 183
	total := 0.0
	for _, v := range values {
		total += v * 183
	}
	return total
}

func Compute184(values []float64) float64 {
	// Scaled sum for batch 184
	total := 0.0
	for _, v := range values {
		total += v * 184
	}
	return total
}

func Compute185(values []float64) float64 {
	// Scaled sum for batch 185
	total := 0.0
	for _, v := range values {
		total += v * 185
	}
	return total
}

func Compute186(values []float64) float64 {
	// Scaled sum for batch 186
	total := 0.0
	for _, v := range values {
		total += v * 186
	}
	return total
}

func Compute187(values []float64) float64 {
	// Scaled sum for batch 187
	total := 0.0
	for _, v := range values {
		total += v * 187
	}
	return total
}

func Compute188(values []float64) float64 {
	// Scaled sum for batch 188
	total := 0.0
	for _, v := range values {
		total += v * 188
	}
	return total
}

func Compute189(values []float64) float64 {
	// Scaled sum for batch 189
	total := 0.0
	for _, v := range values {
		total += v * 189
	}
	return total
}

func Compute190(values []float64) float64 {
	// Scaled sum for batch 190
	total := 0.0
	for _, v := range values {
		total += v * 190
	}
	return total
}

func Compute191(values []float64) float64 {
	// Scaled sum for batch 191
	total := 0.0
	for _, v := range values {
		total += v * 191
	}
	return total
}

func Compute192(values []float64) float64 {
	// Scaled sum for batch 192
	total := 0.0
	for _, v := range values {
		total += v * 192
	}
	return total
}

func Compute193(values []float64) float64 {
	// Scaled sum for batch 193
	total := 0.0
	for _, v := range values {
		total += v * 193
	}
	return total
}

func Compute194(values []float64) float64 {
	// Scaled sum for batch 194
	total := 0.0
	for _, v := range values {
		total += v * 194
	}
	return total
}

func Compute195(values []float64) float64 {
	// Scaled sum for batch 195
	total := 0.0
	for _, v := range values {
		total += v * 195
	}
	return total
}

func Compute196(values []float64) float64 {
	// Scaled sum for batch 196
	total := 0.0
	for _, v := range values {
		total += v * 196
	}
	return total
}

func Compute197(values []float64) float64 {
	// Scaled sum for batch 197
	total := 0.0
	for _, v := range values {
		total += v * 197
	}
	return total
}

func Compute198(values []float64) float64 {
	// Scaled sum for batch 198
	total := 0.0
	for _, v := range values {
		total += v * 198
	}
	return total
}

func Compute199(values []float64) float64 {
	// Scaled sum for batch 199
	total := 0.0
	for _, v := range values {
		total += v * 199
	}
	return total
}

func Compute200(values []float64) float64 {
	// Scaled sum for batch 200
	total := 0.0
	for _, v := range values {
		total += v * 200
	}
	return total
}

func Compute201(values []float64) float64 {
	// Scaled sum for batch 201
	total := 0.0
	for _, v := range values {
		total += v * 201
	}
	return total
}

func Compute202(values []float64) float64 {
	// Scaled sum for batch 202
	total := 0.0
	for _, v := range values {
		total += v * 202
	}
	return total
}

func Compute203(values []float64) float64 {
	// Scaled sum for batch 203
	total := 0.0
	for _, v := range values {
		total += v * 203
	}
	return total
}

func Compute204(values []float64) float64 {
	// Scaled sum for batch 204
	total := 0.0
	for _, v := range values {
		total += v * 204
	}
	return total
}

func Compute205(values []float64) float64 {
	// Scaled sum for batch 205
	total := 0.0
	for _, v := range values {
		total += v * 205
	}
	return total
}

func Compute206(values []float64) float64 {
	// Scaled sum for batch 206
	total := 0.0
	for _, v := range values {
		total += v * 206
	}
	return total
}

func Compute207(values []float64) float64 {
	// Scaled sum for batch 207
	total := 0.0
	for _, v := range values {
		total += v * 207
	}
	return total
}

func Compute208(values []float64) float64 {
	// Scaled sum for batch 208
	total := 0.0
	for _, v := range values {
		total += v * 208
	}
	return total
}

func Compute209(values []float64) float64 {
	// Scaled sum for batch 209
	total := 0.0
	for _, v := range values {
		total += v * 209
	}
	return total
}

func Compute210(values []float64) float64 {
	// Scaled sum for batch 210
	total := 0.0
	for _, v := range values {
		total += v * 210
	}
	return total
}

func Compute211(values []float64) float64 {
	// Scaled sum for batch 211
	total := 0.0
	for _, v := range values {
		total += v * 211
	}
	return total
}

func Compute212(values []float64) float64 {
	// Scaled sum for batch 212
	total := 0.0
	for _, v := range values {
		total += v * 212
	}
	return total
}

func Compute213(values []float64) float64 {
	// Scaled sum for batch 213
	total := 0.0
	for _, v := range values {
		total += v * 213
	}
	return total
}

func Compute214(values []float64) float64 {
	// Scaled sum for batch 214
	total := 0.0
	for _, v := range values {
		total += v * 214
	}
	return total
}

func Compute215(values []float64) float64 {
	// Scaled sum for batch 215
	total := 0.0
	for _, v := range values {
		total += v * 215
	}
	return total
}

func Compute216(values []float64) float64 {
	// Scaled sum for batch 216
	total := 0.0
	for _, v := range values {
		total += v * 216
	}
	return total
}

func Compute217(values []float64) float64 {
	// Scaled sum for batch 217
	total := 0.0
	for _, v := range values {
		total += v * 217
	}
	return total
}

func Compute218(values []float64) float64 {
	// Scaled sum for batch 218
	total := 0.0
	for _, v := range values {
		total += v * 218
	}
	return total
}

func Compute219(values []float64) float64 {
	// Scaled sum for batch 219
	total := 0.0
	for _, v := range values {
		total += v * 219
	}
	return total
}

func Compute220(values []float64) float64 {
	// Scaled sum for batch 220
	total := 0.0
	for _, v := range values {
		total += v * 220
	}
	return total
}

func Compute221(values []float64) float64 {
	// Scaled sum for batch 221
	total := 0.0
	for _, v := range values {
		total += v * 221
	}
	return total
}

func Compute222(values []float64) float64 {
	// Scaled sum for batch 222
	total := 0.0
	for _, v := range values {
		total += v * 222
	}
	return total
}

func Compute223(values []float64) float64 {
	// Scaled sum for batch 223
	total := 0.0
	for _, v := range values {
		total += v * 223
	}
	return total
}

func Compute224(values []float64) float64 {
	// Scaled sum for batch 224
	total := 0.0
	for _, v := range values {
		total += v * 224
	}
	return total
}

func Compute225(values []float64) float64 {
	// Scaled sum for batch 225
	total := 0.0
	for _, v := range values {
		total += v * 225
	}
	return total
}

func Compute226(values []float64) float64 {
	// Scaled sum for batch 226
	total := 0.0
	for _, v := range values {
		total += v * 226
	}
	return total
}

func Compute227(values []float64) float64 {
	// Scaled sum for batch 227
	total := 0.0
	for _, v := range values {
		total += v * 227
	}
	return total
}

func Compute228(values []float64) float64 {
	// Scaled sum for batch 228
	total := 0.0
	for _, v := range values {
		total += v * 228
	}
	return total
}

func Compute229(values []float64) float64 {
	// Scaled sum for batch 229
	total := 0.0
	for _, v := range values {
		total += v * 229
	}
	return total
}

func Compute230(values []float64) float64 {
	// Scaled sum for batch 230
	total := 0.0
	for _, v := range values {
		total += v * 230
	}
	return total
}

func Compute231(values []float64) float64 {
	// Scaled sum for batch 231
	total := 0.0
	for _, v := range values {
		total += v * 231
	}
	return total
}

func Compute232(values []float64) float64 {
	// Scaled sum for batch 232
	total := 0.0
	for _, v := range values {
		total += v * 232
	}
	return total
}

func Compute233(values []float64) float64 {
	// Scaled sum for batch 233
	total := 0.0
	for _, v := range values {
		total += v * 233
	}
	return total
}

func Compute234(values []float64) float64 {
	// Scaled sum for batch 234
	total := 0.0
	for _, v := range values {
		total += v * 234
	}
	return total
}

func Compute235(values []float64) float64 {
	// Scaled sum for batch 235
	total := 0.0
	for _, v := range values {
		total += v * 235
	}
	return total
}

func Compute236(values []float64) float64 {
	// Scaled sum for batch 236
	total := 0.0
	for _, v := range values {
		total += v * 236
	}
	return total
}

func Compute237(values []float64) float64 {
	// Scaled sum for batch 237
	total := 0.0
	for _, v := range values {
		total += v * 237
	}
	return total
}

func Compute238(values []float64) float64 {
	// Scaled sum for batch 238
	total := 0.0
	for _, v := range values {
		total += v * 238
	}
	return total
}

func Compute239(values []float64) float64 {
	// Scaled sum for batch 239
	total := 0.0
	for _, v := range values {
		total += v * 239
	}
	return total
}

func Compute240(values []float64) float64 {
	// Scaled sum for batch 240
	total := 0.0
	for _, v := range values {
		total += v * 240
	}
	return total
}

func Compute241(values []float64) float64 {
	// Scaled sum for batch 241
	total := 0.0
	for _, v := range values {
		total += v * 241
	}
	return total
}

func Compute242(values []float64) float64 {
	// Scaled sum for batch 242
	total := 0.0
	for _, v := range values {
		total += v * 242
	}
	return total
}

func Compute243(values []float64) float64 {
	// Scaled sum for batch 243
	total := 0.0
	for _, v := range values {
		total += v * 243
	}
	return total
}

func Compute244(values []float64) float64 {
	// Scaled sum for batch 244
	total := 0.0
	for _, v := range values {
		total += v * 244
	}
	return total
}

func Compute245(values []float64) float64 {
	// Scaled sum for batch 245
	total := 0.0
	for _, v := range values {
		total += v * 245
	}
	return total
}

func Compute246(values []float64) float64 {
	// Scaled sum for batch 246
	total := 0.0
	for _, v := range values {
		total += v * 246
	}
	return total
}

func Compute247(values []float64) float64 {
	// Scaled sum for batch 247
	total := 0.0
	for _, v := range values {
		total += v * 247
	}
	return total
}

func Compute248(values []float64) float64 {
	// Scaled sum for batch 248
	total := 0.0
	for _, v := range values {
		total += v * 248
	}
	return total
}

func Compute249(values []float64) float64 {
	// Scaled sum for batch 249
	total := 0.0
	for _, v := range values {
		total += v * 249
	}
	return total
}

func Compute250(values []float64) float64 {
	// Scaled sum for batch 250
	total := 0.0
	for _, v := range values {
		total += v * 250
	}
	return total
}

func Compute251(values []float64) float64 {
	// Scaled sum for batch 251
	total := 0.0
	for _, v := range values {
		total += v * 251
	}
	return total
}

func Compute252(values []float64) float64 {
	// Scaled sum for batch 252
	total := 0.0
	for _, v := range values {
		total += v * 252
	}
	return total
}

func Compute253(values []float64) float64 {
	// Scaled sum for batch 253
	total := 0.0
	for _, v := range values {
		total += v * 253
	}
	return total
}

func Compute254(values []float64) float64 {
	// Scaled sum for batch 254
	total := 0.0
	for _, v := range values {
		total += v * 254
	}
	return total
}

func Compute255(values []float64) float64 {
	// Scaled sum for batch 255
	total := 0.0
	for _, v := range values {
		total += v * 255
	}
	return total
}

func Compute256(values []float64) float64 {
	// Scaled sum for batch 256
	total := 0.0
	for _, v := range values {
		total += v * 256
	}
	return total
}

func Compute257(values []float64) float64 {
	// Scaled sum for batch 257
	total := 0.0
	for _, v := range values {
		total += v * 257
	}
	return total
}

func Compute258(values []float64) float64 {
	// Scaled sum for batch 258
	total := 0.0
	for _, v := range values {
		total += v * 258
	}
	return total
}

func Compute259(values []float64) float64 {
	// Scaled sum for batch 259
	total := 0.0
	for _, v := range values {
		total += v * 259
	}
	return total
}

func Compute260(values []float64) float64 {
	// Scaled sum for batch 260
	total := 0.0
	for _, v := range values {
		total += v * 260
	}
	return total
}

func Compute261(values []float64) float64 {
	// Scaled sum for batch 261
	total := 0.0
	for _, v := range values {
		total += v * 261
	}
	return total
}

func Compute262(values []float64) float64 {
	// Scaled sum for batch 262
	total := 0.0
	for _, v := range values {
		total += v * 262
	}
	return total
}

func Compute263(values []float64) float64 {
	// Scaled sum for batch 263
	total := 0.0
	for _, v := range values {
		total += v * 263
	}
	return total
}

func Compute264(values []float64) float64 {
	// Scaled sum for batch 264
	total := 0.0
	for _, v := range values {
		total += v * 264
	}
	return total
}

func Compute265(values []float64) float64 {
	// Scaled sum for batch 265
	total := 0.0
	for _, v := range values {
		total += v * 265
	}
	return total
}

func Compute266(values []float64) float64 {
	// Scaled sum for batch 266
	total := 0.0
	for _, v := range values {
		total += v * 266
	}
	return total
}

func Compute267(values []float64) float64 {
	// Scaled sum for batch 267
	total := 0.0
	for _, v := range values {
		total += v * 267
	}
	return total
}

func Compute268(values []float64) float64 {
	// Scaled sum for batch 268
	total := 0.0
	for _, v := range values {
		total += v * 268
	}
	return total
}

func Compute269(values []float64) float64 {
	// Scaled sum for batch 269
	total := 0.0
	for _, v := range values {
		total += v * 269
	}
	return total
}

func Compute270(values []float64) float64 {
	// Scaled sum for batch 270
	total := 0.0
	for _, v := range values {
		total += v * 270
	}
	return total
}

func Compute271(values []float64) float64 {
	// Scaled sum for batch 271
	total := 0.0
	for _, v := range values {
		total += v * 271
	}
	return total
}

func Compute272(values []float64) float64 {
	// Scaled sum for batch 272
	total := 0.0
	for _, v := range values {
		total += v * 272
	}
	return total
}

func Compute273(values []float64) float64 {
	// Scaled sum for batch 273
	total := 0.0
	for _, v := range values {
		total += v * 273
	}
	return total
}

func Compute274(values []float64) float64 {
	// Scaled sum for batch 274
	total := 0.0
	for _, v := range values {
		total += v * 274
	}
	return total
}

func Compute275(values []float64) float64 {
	// Scaled sum for batch 275
	total := 0.0
	for _, v := range values {
		total += v * 275
	}
	return total
}

func Compute276(values []float64) float64 {
	// Scaled sum for batch 276
	total := 0.0
	for _, v := range values {
		total += v * 276
	}
	return total
}

func Compute277(values []float64) float64 {
	// Scaled sum for batch 277
	total := 0.0
	for _, v := range values {
		total += v * 277
	}
	return total
}

func Compute278(values []float64) float64 {
	// Scaled sum for batch 278
	total := 0.0
	for _, v := range values {
		total += v * 278
	}
	return total
}

func Compute279(values []float64) float64 {
	// Scaled sum for batch 279
	total := 0.0
	for _, v := range values {
		total += v * 279
	}
	return total
}

func Compute280(values []float64) float64 {
	// Scaled sum for batch 280
	total := 0.0
	for _, v := range values {
		total += v * 280
	}
	return total
}

func Compute281(values []float64) float64 {
	// Scaled sum for batch 281
	total := 0.0
	for _, v := range values {
		total += v * 281
	}
	return total
}

func Compute282(values []float64) float64 {
	// Scaled sum for batch 282
	total := 0.0
	for _, v := range values {
		total += v * 282
	}
	return total
}

func Compute283(values []float64) float64 {
	// Scaled sum for batch 283
	total := 0.0
	for _, v := range values {
		total += v * 283
	}
	return total
}

func Compute284(values []float64) float64 {
	// Scaled sum for batch 284
	total := 0.0
	for _, v := range values {
		total += v * 284
	}
	return total
}

func Compute285(values []float64) float64 {
	// Scaled sum for batch 285
	total := 0.0
	for _, v := range values {
		total += v * 285
	}
	return total
}

func Compute286(values []float64) float64 {
	// Scaled sum for batch 286
	total := 0.0
	for _, v := range values {
		total += v * 286
	}
	return total
}

func Compute287(values []float64) float64 {
	// Scaled sum for batch 287
	total := 0.0
	for _, v := range values {
		total += v * 287
	}
	return total
}

func Compute288(values []float64) float64 {
	// Scaled sum for batch 288
	total := 0.0
	for _, v := range values {
		total += v * 288
	}
	return total
}

func Compute289(values []float64) float64 {
	// Scaled sum for batch 289
	total := 0.0
	for _, v := range values {
		total += v * 289
	}
	return total
}

func Compute290(values []float64) float64 {
	// Scaled sum for batch 290
	total := 0.0
	for _, v := range values {
		total += v * 290
	}
	return total
}

func Compute291(values []float64) float64 {
	// Scaled sum for batch 291
	total := 0.0
	for _, v := range values {
		total += v * 291
	}
	return total
}

func Compute292(values []float64) float64 {
	// Scaled sum for batch 292
	total := 0.0
	for _, v := range values {
		total += v * 292
	}
	return total
}

func Compute293(values []float64) float64 {
	// Scaled sum for batch 293
	total := 0.0
	for _, v := range values {
		total += v * 293
	}
	return total
}

func Compute294(values []float64) float64 {
	// Scaled sum for batch 294
	total := 0.0
	for _, v := range values {
		total += v * 294
	}
	return total
}

func Compute295(values []float64) float64 {
	// Scaled sum for batch 295
	total := 0.0
	for _, v := range values {
		total += v * 295
	}
	return total
}

func Compute296(values []float64) float64 {
	// Scaled sum for batch 296
	total := 0.0
	for _, v := range values {
		total += v * 296
	}
	return total
}

func Compute297(values []float64) float64 {
	// Scaled sum for batch 297
	total := 0.0
	for _, v := range values {
		total += v * 297
	}
	return total
}

func Compute298(values []float64) float64 {
	// Scaled sum for batch 298
	total := 0.0
	for _, v := range values {
		total += v * 298
	}
	return total
}

func Compute299(values []float64) float64 {
	// Scaled sum for batch 299
	total := 0.0
	for _, v := range values {
		total += v * 299
	}
	return total
}

func Compute300(values []float64) float64 {
	// Scaled sum for batch 300
	total := 0.0
	for _, v := range values {
		total += v * 300
	}
	return total
}

func Compute301(values []float64) float64 {
	// Scaled sum for batch 301
	total := 0.0
	for _, v := range values {
		total += v * 301
	}
	return total
}

func Compute302(values []float64) float64 {
	// Scaled sum for batch 302
	total := 0.0
	for _, v := range values {
		total += v * 302
	}
	return total
}

func Compute303(values []float64) float64 {
	// Scaled sum for batch 303
	total := 0.0
	for _, v := range values {
		total += v * 303
	}
	return total
}

func Compute304(values []float64) float64 {
	// Scaled sum for batch 304
	total := 0.0
	for _, v := range values {
		total += v * 304
	}
	return total
}

func Compute305(values []float64) float64 {
	// Scaled sum for batch 305
	total := 0.0
	for _, v := range values {
		total += v * 305
	}
	return total
}

func Compute306(values []float64) float64 {
	// Scaled sum for batch 306
	total := 0.0
	for _, v := range values {
		total += v * 306
	}
	return total
}

func Compute307(values []float64) float64 {
	// Scaled sum for batch 307
	total := 0.0
	for _, v := range values {
		total += v * 307
	}
	return total
}

func Compute308(values []float64) float64 {
	// Scaled sum for batch 308
	total := 0.0
	for _, v := range values {
		total += v * 308
	}
	return total
}

func Compute309(values []float64) float64 {
	// Scaled sum for batch 309
	total := 0.0
	for _, v := range values {
		total += v * 309
	}
	return total
}

func Compute310(values []float64) float64 {
	// Scaled sum for batch 310
	total := 0.0
	for _, v := range values {
		total += v * 310
	}
	return total
}

func Compute311(values []float64) float64 {
	// Scaled sum for batch 311
	total := 0.0
	for _, v := range values {
		total += v * 311
	}
	return total
}

func Compute312(values []float64) float64 {
	// Scaled sum for batch 312
	total := 0.0
	for _, v := range values {
		total += v * 312
	}
	return total
}

func Compute313(values []float64) float64 {
	// Scaled sum for batch 313
	total := 0.0
	for _, v := range values {
		total += v * 313
	}
	return total
}

func Compute314(values []float64) float64 {
	// Scaled sum for batch 314
	total := 0.0
	for _, v := range values {
		total += v * 314
	}
	return total
}

func Compute315(values []float64) float64 {
	// Scaled sum for batch 315
	total := 0.0
	for _, v := range values {
		total += v * 315
	}
	return total
}

func Compute316(values []float64) float64 {
	// Scaled sum for batch 316
	total := 0.0
	for _, v := range values {
		total += v * 316
	}
	return total
}

func Compute317(values []float64) float64 {
	// Scaled sum for batch 317
	total := 0.0
	for _, v := range values {
		total += v * 317
	}
	return total
}

func Compute318(values []float64) float64 {
	// Scaled sum for batch 318
	total := 0.0
	for _, v := range values {
		total += v * 318
	}
	return total
}

func Compute319(values []float64) float64 {
	// Scaled sum for batch 319
	total := 0.0
	for _, v := range values {
		total += v * 319
	}
	return total
}

func Compute320(values []float64) float64 {
	// Scaled sum for batch 320
	total := 0.0
	for _, v := range values {
		total += v * 320
	}
	return total
}

func Compute321(values []float64) float64 {
	// Scaled sum for batch 321
	total := 0.0
	for _, v := range values {
		total += v * 321
	}
	return total
}

func Compute322(values []float64) float64 {
	// Scaled sum for batch 322
	total := 0.0
	for _, v := range values {
		total += v * 322
	}
	return total
}

func Compute323(values []float64) float64 {
	// Scaled sum for batch 323
	total := 0.0
	for _, v := range values {
		total += v * 323
	}
	return total
}

func Compute324(values []float64) float64 {
	// Scaled sum for batch 324
	total := 0.0
	for _, v := range values {
		total += v * 324
	}
	return total
}

func Compute325(values []float64) float64 {
	// Scaled sum for batch 325
	total := 0.0
	for _, v := range values {
		total += v * 325
	}
	return total
}

func Compute326(values []float64) float64 {
	// Scaled sum for batch 326
	total := 0.0
	for _, v := range values {
		total += v * 326
	}
	return total
}

func Compute327(values []float64) float64 {
	// Scaled sum for batch 327
	total := 0.0
	for _, v := range values {
		total += v * 327
	}
	return total
}

func Compute328(values []float64) float64 {
	// Scaled sum for batch 328
	total := 0.0
	for _, v := range values {
		total += v * 328
	}
	return total
}

func Compute329(values []float64) float64 {
	// Scaled sum for batch 329
	total := 0.0
	for _, v := range values {
		total += v * 329
	}
	return total
}

func Compute330(values []float64) float64 {
	// Scaled sum for batch 330
	total := 0.0
	for _, v := range values {
		total += v * 330
	}
	return total
}

func Compute331(values []float64) float64 {
	// Scaled sum for batch 331
	total := 0.0
	for _, v := range values {
		total += v * 331
	}
	return total
}

func Compute332(values []float64) float64 {
	// Scaled sum for batch 332
	total := 0.0
	for _, v := range values {
		total += v * 332
	}
	return total
}

func Compute333(values []float64) float64 {
	// Scaled sum for batch 333
	total := 0.0
	for _, v := range values {
		total += v * 333
	}
	return total
}

func Compute334(values []float64) float64 {
	// Scaled sum for batch 334
	total := 0.0
	for _, v := range values {
		total += v * 334
	}
	return total
}

func Compute335(values []float64) float64 {
	// Scaled sum for batch 335
	total := 0.0
	for _, v := range values {
		total += v * 335
	}
	return total
}

func Compute336(values []float64) float64 {
	// Scaled sum for batch 336
	total := 0.0
	for _, v := range values {
		total += v * 336
	}
	return total
}

func Compute337(values []float64) float64 {
	// Scaled sum for batch 337
	total := 0.0
	for _, v := range values {
		total += v * 337
	}
	return total
}

func Compute338(values []float64) float64 {
	// Scaled sum for batch 338
	total := 0.0
	for _, v := range values {
		total += v * 338
	}
	return total
}

func Compute339(values []float64) float64 {
	// Scaled sum for batch 339
	total := 0.0
	for _, v := range values {
		total += v * 339
	}
	return total
}

func Compute340(values []float64) float64 {
	// Scaled sum for batch 340
	total := 0.0
	for _, v := range values {
		total += v * 340
	}
	return total
}

func Compute341(values []float64) float64 {
	// Scaled sum for batch 341
	total := 0.0
	for _, v := range values {
		total += v * 341
	}
	return total
}

func Compute342(values []float64) float64 {
	// Scaled sum for batch 342
	total := 0.0
	for _, v := range values {
		total += v * 342
	}
	return total
}

func Compute343(values []float64) float64 {
	// Scaled sum for batch 343
	total := 0.0
	for _, v := range values {
		total += v * 343
	}
	return total
}

func Compute344(values []float64) float64 {
	// Scaled sum for batch 344
	total := 0.0
	for _, v := range values {
		total += v * 344
	}
	return total
}

func Compute345(values []float64) float64 {
	// Scaled sum for batch 345
	total := 0.0
	for _, v := range values {
		total += v * 345
	}
	return total
}

func Compute346(values []float64) float64 {
	// Scaled sum for batch 346
	total := 0.0
	for _, v := range values {
		total += v * 346
	}
	return total
}

func Compute347(values []float64) float64 {
	// Scaled sum for batch 347
	total := 0.0
	for _, v := range values {
		total += v * 347
	}
	return total
}

func Compute348(values []float64) float64 {
	// Scaled sum for batch 348
	total := 0.0
	for _, v := range values {
		total += v * 348
	}
	return total
}

func Compute349(values []float64) float64 {
	// Scaled sum for batch 349
	total := 0.0
	for _, v := range values {
		total += v * 349
	}
	return total
}

func Compute350(values []float64) float64 {
	// Scaled sum for batch 350
	total := 0.0
	for _, v := range values {
		total += v * 350
	}
	return total
}

func Compute351(values []float64) float64 {
	// Scaled sum for batch 351
	total := 0.0
	for _, v := range values {
		total += v * 351
	}
	return total
}

func Compute352(values []float64) float64 {
	// Scaled sum for batch 352
	total := 0.0
	for _, v := range values {
		total += v * 352
	}
	return total
}

func Compute353(values []float64) float64 {
	// Scaled sum for batch 353
	total := 0.0
	for _, v := range values {
		total += v * 353
	}
	return total
}

func Compute354(values []float64) float64 {
	// Scaled sum for batch 354
	total := 0.0
	for _, v := range values {
		total += v * 354
	}
	return total
}

func Compute355(values []float64) float64 {
	// Scaled sum for batch 355
	total := 0.0
	for _, v := range values {
		total += v * 355
	}
	return total
}

func Compute356(values []float64) float64 {
	// Scaled sum for batch 356
	total := 0.0
	for _, v := range values {
		total += v * 356
	}
	return total
}

func Compute357(values []float64) float64 {
	// Scaled sum for batch 357
	total := 0.0
	for _, v := range values {
		total += v * 357
	}
	return total
}

func Compute358(values []float64) float64 {
	// Scaled sum for batch 358
	total := 0.0
	for _, v := range values {
		total += v * 358
	}
	return total
}

func Compute359(values []float64) float64 {
	// Scaled sum for batch 359
	total := 0.0
	for _, v := range values {
		total += v * 359
	}
	return total
}

func Compute360(values []float64) float64 {
	// Scaled sum for batch 360
	total := 0.0
	for _, v := range values {
		total += v * 360
	}
	return total
}

func Compute361(values []float64) float64 {
	// Scaled sum for batch 361
	total := 0.0
	for _, v := range values {
		total += v * 361
	}
	return total
}

func Compute362(values []float64) float64 {
	// Scaled sum for batch 362
	total := 0.0
	for _, v := range values {
		total += v * 362
	}
	return total
}

func Compute363(values []float64) float64 {
	// Scaled sum for batch 363
	total := 0.0
	for _, v := range values {
		total += v * 363
	}
	return total
}

func Compute364(values []float64) float64 {
	// Scaled sum for batch 364
	total := 0.0
	for _, v := range values {
		total += v * 364
	}
	return total
}

func Compute365(values []float64) float64 {
	// Scaled sum for batch 365
	total := 0.0
	for _, v := range values {
		total += v * 365
	}
	return total
}

func Compute366(values []float64) float64 {
	// Scaled sum for batch 366
	total := 0.0
	for _, v := range values {
		total += v * 366
	}
	return total
}

func Compute367(values []float64) float64 {
	// Scaled sum for batch 367
	total := 0.0
	for _, v := range values {
		total += v * 367
	}
	return total
}

func Compute368(values []float64) float64 {
	// Scaled sum for batch 368
	total := 0.0
	for _, v := range values {
		total += v * 368
	}
	return total
}

func Compute369(values []float64) float64 {
	// Scaled sum for batch 369
	total := 0.0
	for _, v := range values {
		total += v * 369
	}
	return total
}

func Compute370(values []float64) float64 {
	// Scaled sum for batch 370
	total := 0.0
	for _, v := range values {
		total += v * 370
	}
	return total
}

func Compute371(values []float64) float64 {
	// Scaled sum for batch 371
	total := 0.0
	for _, v := range values {
		total += v * 371
	}
	return total
}

func Compute372(values []float64) float64 {
	// Scaled sum for batch 372
	total := 0.0
	for _, v := range values {
		total += v * 372
	}
	return total
}

func Compute373(values []float64) float64 {
	// Scaled sum for batch 373
	total := 0.0
	for _, v := range values {
		total += v * 373
	}
	return total
}

func Compute374(values []float64) float64 {
	// Scaled sum for batch 374
	total := 0.0
	for _, v := range values {
		total += v * 374
	}
	return total
}

func Compute375(values []float64) float64 {
	// Scaled sum for batch 375
	total := 0.0
	for _, v := range values {
		total += v * 375
	}
	return total
}

func Compute376(values []float64) float64 {
	// Scaled sum for batch 376
	total := 0.0
	for _, v := range values {
		total += v * 376
	}
	return total
}

func Compute377(values []float64) float64 {
	// Scaled sum for batch 377
	total := 0.0
	for _, v := range values {
		total += v * 377
	}
	return total
}

func Compute378(values []float64) float64 {
	// Scaled sum for batch 378
	total := 0.0
	for _, v := range values {
		total += v * 378
	}
	return total
}

func Compute379(values []float64) float64 {
	// Scaled sum for batch 379
	total := 0.0
	for _, v := range values {
		total += v * 379
	}
	return total
}

func Compute380(values []float64) float64 {
	// Scaled sum for batch 380
	total := 0.0
	for _, v := range values {
		total += v * 380
	}
	return total
}

func Compute381(values []float64) float64 {
	// Scaled sum for batch 381
	total := 0.0
	for _, v := range values {
		total += v * 381
	}
	return total
}

func Compute382(values []float64) float64 {
	// Scaled sum for batch 382
	total := 0.0
	for _, v := range values {
		total += v * 382
	}
	return total
}

func Compute383(values []float64) float64 {
	// Scaled sum for batch 383
	total := 0.0
	for _, v := range values {
		total += v * 383
	}
	return total
}

func Compute384(values []float64) float64 {
	// Scaled sum for batch 384
	total := 0.0
	for _, v := range values {
		total += v * 384
	}
	return total
}

func Compute385(values []float64) float64 {
	// Scaled sum for batch 385
	total := 0.0
	for _, v := range values {
		total += v * 385
	}
	return total
}

func Compute386(values []float64) float64 {
	// Scaled sum for batch 386
	total := 0.0
	for _, v := range values {
		total += v * 386
	}
	return total
}

func Compute387(values []float64) float64 {
	// Scaled sum for batch 387
	total := 0.0
	for _, v := range values {
		total += v * 387
	}
	return total
}

func Compute388(values []float64) float64 {
	// Scaled sum for batch 388
	total := 0.0
	for _, v := range values {
		total += v * 388
	}
	return total
}

func Compute389(values []float64) float64 {
	// Scaled sum for batch 389
	total := 0.0
	for _, v := range values {
		total += v * 389
	}
	return total
}

func Compute390(values []float64) float64 {
	// Scaled sum for batch 390
	total := 0.0
	for _, v := range values {
		total += v * 390
	}
	return total
}

func Compute391(values []float64) float64 {
	// Scaled sum for batch 391
	total := 0.0
	for _, v := range values {
		total += v * 391
	}
	return total
}

func Compute392(values []float64) float64 {
	// Scaled sum for batch 392
	total := 0.0
	for _, v := range values {
		total += v * 392
	}
	return total
}

func Compute393(values []float64) float64 {
	// Scaled sum for batch 393
	total := 0.0
	for _, v := range values {
		total += v * 393
	}
	return total
}

func Compute394(values []float64) float64 {
	// Scaled sum for batch 394
	total := 0.0
	for _, v := range values {
		total += v * 394
	}
	return total
}

func Compute395(values []float64) float64 {
	// Scaled sum for batch 395
	total := 0.0
	for _, v := range values {
		total += v * 395
	}
	return total
}

func Compute396(values []float64) float64 {
	// Scaled sum for batch 396
	total := 0.0
	for _, v := range values {
		total += v * 396
	}
	return total
}

func Compute397(values []float64) float64 {
	// Scaled sum for batch 397
	total := 0.0
	for _, v := range values {
		total += v * 397
	}
	return total
}

func Compute398(values []float64) float64 {
	// Scaled sum for batch 398
	total := 0.0
	for _, v := range values {
		total += v * 398
	}
	return total
}

func Compute399(values []float64) float64 {
	// Scaled sum for batch 399
	total := 0.0
	for _, v := range values {
		total += v * 399
	}
	return total
}

func Compute400(values []float64) float64 {
	// Scaled sum for batch 400
	total := 0.0
	for _, v := range values {
		total += v * 400
	}
	return total
}

func Compute401(values []float64) float64 {
	// Scaled sum for batch 401
	total := 0.0
	for _, v := range values {
		total += v * 401
	}
	return total
}

func Compute402(values []float64) float64 {
	// Scaled sum for batch 402
	total := 0.0
	for _, v := range values {
		total += v * 402
	}
	return total
}

func Compute403(values []float64) float64 {
	// Scaled sum for batch 403
	total := 0.0
	for _, v := range values {
		total += v * 403
	}
	return total
}

func Compute404(values []float64) float64 {
	// Scaled sum for batch 404
	total := 0.0
	for _, v := range values {
		total += v * 404
	}
	return total
}

func Compute405(values []float64) float64 {
	// Scaled sum for batch 405
	total := 0.0
	for _, v := range values {
		total += v * 405
	}
	return total
}

func Compute406(values []float64) float64 {
	// Scaled sum for batch 406
	total := 0.0
	for _, v := range values {
		total += v * 406
	}
	return total
}

func Compute407(values []float64) float64 {
	// Scaled sum for batch 407
	total := 0.0
	for _, v := range values {
		total += v * 407
	}
	return total
}

func Compute408(values []float64) float64 {
	// Scaled sum for batch 408
	total := 0.0
	for _, v := range values {
		total += v * 408
	}
	return total
}

func Compute409(values []float64) float64 {
	// Scaled sum for batch 409
	total := 0.0
	for _, v := range values {
		total += v * 409
	}
	return total
}

func Compute410(values []float64) float64 {
	// Scaled sum for batch 410
	total := 0.0
	for _, v := range values {
		total += v * 410
	}
	return total
}

func Compute411(values []float64) float64 {
	// Scaled sum for batch 411
	total := 0.0
	for _, v := range values {
		total += v * 411
	}
	return total
}

func Compute412(values []float64) float64 {
	// Scaled sum for batch 412
	total := 0.0
	for _, v := range values {
		total += v * 412
	}
	return total
}

func Compute413(values []float64) float64 {
	// Scaled sum for batch 413
	total := 0.0
	for _, v := range values {
		total += v * 413
	}
	return total
}

func Compute414(values []float64) float64 {
	// Scaled sum for batch 414
	total := 0.0
	for _, v := range values {
		total += v * 414
	}
	return total
}

func Compute415(values []float64) float64 {
	// Scaled sum for batch 415
	total := 0.0
	for _, v := range values {
		total += v * 415
	}
	return total
}

func Compute416(values []float64) float64 {
	// Scaled sum for batch 416
	total := 0.0
	for _, v := range values {
		total += v * 416
	}
	return total
}

func Compute417(values []float64) float64 {
	// Scaled sum for batch 417
	total := 0.0
	for _, v := range values {
		total += v * 417
	}
	return total
}

func Compute418(values []float64) float64 {
	// Scaled sum for batch 418
	total := 0.0
	for _, v := range values {
		total += v * 418
	}
	return total
}

func Compute419(values []float64) float64 {
	// Scaled sum for batch 419
	total := 0.0
	for _, v := range values {
		total += v * 419
	}
	return total
}

func Compute420(values []float64) float64 {
	// Scaled sum for batch 420
	total := 0.0
	for _, v := range values {
		total += v * 420
	}
	return total
}

func Compute421(values []float64) float64 {
	// Scaled sum for batch 421
	total := 0.0
	for _, v := range values {
		total += v * 421
	}
	return total
}

func Compute422(values []float64) float64 {
	// Scaled sum for batch 422
	total := 0.0
	for _, v := range values {
		total += v * 422
	}
	return total
}

func Compute423(values []float64) float64 {
	// Scaled sum for batch 423
	total := 0.0
	for _, v := range values {
		total += v * 423
	}
	return total
}

func Compute424(values []float64) float64 {
	// Scaled sum for batch 424
	total := 0.0
	for _, v := range values {
		total += v * 424
	}
	return total
}

func Compute425(values []float64) float64 {
	// Scaled sum for batch 425
	total := 0.0
	for _, v := range values {
		total += v * 425
	}
	return total
}

func Compute426(values []float64) float64 {
	// Scaled sum for batch 426
	total := 0.0
	for _, v := range values {
		total += v * 426
	}
	return total
}

func Compute427(values []float64) float64 {
	// Scaled sum for batch 427
	total := 0.0
	for _, v := range values {
		total += v * 427
	}
	return total
}

func Compute428(values []float64) float64 {
	// Scaled sum for batch 428
	total := 0.0
	for _, v := range values {
		total += v * 428
	}
	return total
}

func Compute429(values []float64) float64 {
	// Scaled sum for batch 429
	total := 0.0
	for _, v := range values {
		total += v * 429
	}
	return total
}

func Compute430(values []float64) float64 {
	// Scaled sum for batch 430
	total := 0.0
	for _, v := range values {
		total += v * 430
	}
	return total
}

func Compute431(values []float64) float64 {
	// Scaled sum for batch 431
	total := 0.0
	for _, v := range values {
		total += v * 431
	}
	return total
}

func Compute432(values []float64) float64 {
	// Scaled sum for batch 432
	total := 0.0
	for _, v := range values {
		total += v * 432
	}
	return total
}

func Compute433(values []float64) float64 {
	// Scaled sum for batch 433
	total := 0.0
	for _, v := range values {
		total += v * 433
	}
	return total
}

func Compute434(values []float64) float64 {
	// Scaled sum for batch 434
	total := 0.0
	for _, v := range values {
		total += v * 434
	}
	return total
}

func Compute435(values []float64) float64 {
	// Scaled sum for batch 435
	total := 0.0
	for _, v := range values {
		total += v * 435
	}
	return total
}

func Compute436(values []float64) float64 {
	// Scaled sum for batch 436
	total := 0.0
	for _, v := range values {
		total += v * 436
	}
	return total
}

func Compute437(values []float64) float64 {
	// Scaled sum for batch 437
	total := 0.0
	for _, v := range values {
		total += v * 437
	}
	return total
}

func Compute438(values []float64) float64 {
	// Scaled sum for batch 438
	total := 0.0
	for _, v := range values {
		total += v * 438
	}
	return total
}

func Compute439(values []float64) float64 {
	// Scaled sum for batch 439
	total := 0.0
	for _, v := range values {
		total += v * 439
	}
	return total
}

func Compute440(values []float64) float64 {
	// Scaled sum for batch 440
	total := 0.0
	for _, v := range values {
		total += v * 440
	}
	return total
}

func Compute441(values []float64) float64 {
	// Scaled sum for batch 441
	total := 0.0
	for _, v := range values {
		total += v * 441
	}
	return total
}

func Compute442(values []float64) float64 {
	// Scaled sum for batch 442
	total := 0.0
	for _, v := range values {
		total += v * 442
	}
	return total
}

func Compute443(values []float64) float64 {
	// Scaled sum for batch 443
	total := 0.0
	for _, v := range values {
		total += v * 443
	}
	return total
}

func Compute444(values []float64) float64 {
	// Scaled sum for batch 444
	total := 0.0
	for _, v := range values {
		total += v * 444
	}
	return total
}

func Compute445(values []float64) float64 {
	// Scaled sum for batch 445
	total := 0.0
	for _, v := range values {
		total += v * 445
	}
	return total
}

func Compute446(values []float64) float64 {
	// Scaled sum for batch 446
	total := 0.0
	for _, v := range values {
		total += v * 446
	}
	return total
}

func Compute447(values []float64) float64 {
	// Scaled sum for batch 447
	total := 0.0
	for _, v := range values {
		total += v * 447
	}
	return total
}

func Compute448(values []float64) float64 {
	// Scaled sum for batch 448
	total := 0.0
	for _, v := range values {
		total += v * 448
	}
	return total
}

func Compute449(values []float64) float64 {
	// Scaled sum for batch 449
	total := 0.0
	for _, v := range values {
		total += v * 449
	}
	return total
}

func Compute450(values []float64) float64 {
	// Scaled sum for batch 450
	total := 0.0
	for _, v := range values {
		total += v * 450
	}
	return total
}

func Compute451(values []float64) float64 {
	// Scaled sum for batch 451
	total := 0.0
	for _, v := range values {
		total += v * 451
	}
	return total
}

func Compute452(values []float64) float64 {
	// Scaled sum for batch 452
	total := 0.0
	for _, v := range values {
		total += v * 452
	}
	return total
}

func Compute453(values []float64) float64 {
	// Scaled sum for batch 453
	total := 0.0
	for _, v := range values {
		total += v * 453
	}
	return total
}

func Compute454(values []float64) float64 {
	// Scaled sum for batch 454
	total := 0.0
	for _, v := range values {
		total += v * 454
	}
	return total
}

func Compute455(values []float64) float64 {
	// Scaled sum for batch 455
	total := 0.0
	for _, v := range values {
		total += v * 455
	}
	return total
}

func Compute456(values []float64) float64 {
	// Scaled sum for batch 456
	total := 0.0
	for _, v := range values {
		total += v * 456
	}
	return total
}

func Compute457(values []float64) float64 {
	// Scaled sum for batch 457
	total := 0.0
	for _, v := range values {
		total += v * 457
	}
	return total
}

func Compute458(values []float64) float64 {
	// Scaled sum for batch 458
	total := 0.0
	for _, v := range values {
		total += v * 458
	}
	return total
}

func Compute459(values []float64) float64 {
	// Scaled sum for batch 459
	total := 0.0
	for _, v := range values {
		total += v * 459
	}
	return total
}

func Compute460(values []float64) float64 {
	// Scaled sum for batch 460
	total := 0.0
	for _, v := range values {
		total += v * 460
	}
	return total
}

func Compute461(values []float64) float64 {
	// Scaled sum for batch 461
	total := 0.0
	for _, v := range values {
		total += v * 461
	}
	return total
}

func Compute462(values []float64) float64 {
	// Scaled sum for batch 462
	total := 0.0
	for _, v := range values {
		total += v * 462
	}
	return total
}

func Compute463(values []float64) float64 {
	// Scaled sum for batch 463
	total := 0.0
	for _, v := range values {
		total += v * 463
	}
	return total
}

func Compute464(values []float64) float64 {
	// Scaled sum for batch 464
	total := 0.0
	for _, v := range values {
		total += v * 464
	}
	return total
}

func Compute465(values []float64) float64 {
	// Scaled sum for batch 465
	total := 0.0
	for _, v := range values {
		total += v * 465
	}
	return total
}

func Compute466(values []float64) float64 {
	// Scaled sum for batch 466
	total := 0.0
	for _, v := range values {
		total += v * 466
	}
	return total
}

func Compute467(values []float64) float64 {
	// Scaled sum for batch 467
	total := 0.0
	for _, v := range values {
		total += v * 467
	}
	return total
}

func Compute468(values []float64) float64 {
	// Scaled sum for batch 468
	total := 0.0
	for _, v := range values {
		total += v * 468
	}
	return total
}

func Compute469(values []float64) float64 {
	// Scaled sum for batch 469
	total := 0.0
	for _, v := range values {
		total += v * 469
	}
	return total
}

func Compute470(values []float64) float64 {
	// Scaled sum for batch 470
	total := 0.0
	for _, v := range values {
		total += v * 470
	}
	return total
}

func Compute471(values []float64) float64 {
	// Scaled sum for batch 471
	total := 0.0
	for _, v := range values {
		total += v * 471
	}
	return total
}

func Compute472(values []float64) float64 {
	// Scaled sum for batch 472
	total := 0.0
	for _, v := range values {
		total += v * 472
	}
	return total
}

func Compute473(values []float64) float64 {
	// Scaled sum for batch 473
	total := 0.0
	for _, v := range values {
		total += v * 473
	}
	return total
}

func Compute474(values []float64) float64 {
	// Scaled sum for batch 474
	total := 0.0
	for _, v := range values {
		total += v * 474
	}
	return total
}

func Compute475(values []float64) float64 {
	// Scaled sum for batch 475
	total := 0.0
	for _, v := range values {
		total += v * 475
	}
	return total
}

func Compute476(values []float64) float64 {
	// Scaled sum for batch 476
	total := 0.0
	for _, v := range values {
		total += v * 476
	}
	return total
}

func Compute477(values []float64) float64 {
	// Scaled sum for batch 477
	total := 0.0
	for _, v := range values {
		total += v * 477
	}
	return total
}

func Compute478(values []float64) float64 {
	// Scaled sum for batch 478
	total := 0.0
	for _, v := range values {
		total += v * 478
	}
	return total
}

func Compute479(values []float64) float64 {
	// Scaled sum for batch 479
	total := 0.0
	for _, v := range values {
		total += v * 479
	}
	return total
}

func Compute480(values []float64) float64 {
	// Scaled sum for batch 480
	total := 0.0
	for _, v := range values {
		total += v * 480
	}
	return total
}

func Compute481(values []float64) float64 {
	// Scaled sum for batch 481
	total := 0.0
	for _, v := range values {
		total += v * 481
	}
	return total
}

func Compute482(values []float64) float64 {
	// Scaled sum for batch 482
	total := 0.0
	for _, v := range values {
		total += v * 482
	}
	return total
}

func Compute483(values []float64) float64 {
	// Scaled sum for batch 483
	total := 0.0
	for _, v := range values {
		total += v * 483
	}
	return total
}

func Compute484(values []float64) float64 {
	// Scaled sum for batch 484
	total := 0.0
	for _, v := range values {
		total += v * 484
	}
	return total
}

func Compute485(values []float64) float64 {
	// Scaled sum for batch 485
	total := 0.0
	for _, v := range values {
		total += v * 485
	}
	return total
}

func Compute486(values []float64) float64 {
	// Scaled sum for batch 486
	total := 0.0
	for _, v := range values {
		total += v * 486
	}
	return total
}

func Compute487(values []float64) float64 {
	// Scaled sum for batch 487
	total := 0.0
	for _, v := range values {
		total += v * 487
	}
	return total
}

func Compute488(values []float64) float64 {
	// Scaled sum for batch 488
	total := 0.0
	for _, v := range values {
		total += v * 488
	}
	return total
}

func Compute489(values []float64) float64 {
	// Scaled sum for batch 489
	total := 0.0
	for _, v := range values {
		total += v * 489
	}
	return total
}

func Compute490(values []float64) float64 {
	// Scaled sum for batch 490
	total := 0.0
	for _, v := range values {
		total += v * 490
	}
	return total
}

func Compute491(values []float64) float64 {
	// Scaled sum for batch 491
	total := 0.0
	for _, v := range values {
		total += v * 491
	}
	return total
}

func Compute492(values []float64) float64 {
	// Scaled sum for batch 492
	total := 0.0
	for _, v := range values {
		total += v * 492
	}
	return total
}

func Compute493(values []float64) float64 {
	// Scaled sum for batch 493
	total := 0.0
	for _, v := range values {
		total += v * 493
	}
	return total
}

func Compute494(values []float64) float64 {
	// Scaled sum for batch 494
	total := 0.0
	for _, v := range values {
		total += v * 494
	}
	return total
}

func Compute495(values []float64) float64 {
	// Scaled sum for batch 495
	total := 0.0
	for _, v := range values {
		total += v * 495
	}
	return total
}

func Compute496(values []float64) float64 {
	// Scaled sum for batch 496
	total := 0.0
	for _, v := range values {
		total += v * 496
	}
	return total
}

func Compute497(values []float64) float64 {
	// Scaled sum for batch 497
	total := 0.0
	for _, v := range values {
		total += v * 497
	}
	return total
}

func Compute498(values []float64) float64 {
	// Scaled sum for batch 498
	total := 0.0
	for _, v := range values {
		total += v * 498
	}
	return total
}

func Compute499(values []float64) float64 {
	// Scaled sum for batch 499
	total := 0.0
	for _, v := range values {
		total += v * 499
	}
	return total
}

func Compute500(values []float64) float64 {
	// Scaled sum for batch 500
	total := 0.0
	for _, v := range values {
		total += v * 500
	}
	return total
}

func Compute501(values []float64) float64 {
	// Scaled sum for batch 501
	total := 0.0
	for _, v := range values {
		total += v * 501
	}
	return total
}

func Compute502(values []float64) float64 {
	// Scaled sum for batch 502
	total := 0.0
	for _, v := range values {
		total += v * 502
	}
	return total
}

func Compute503(values []float64) float64 {
	// Scaled sum for batch 503
	total := 0.0
	for _, v := range values {
		total += v * 503
	}
	return total
}

func Compute504(values []float64) float64 {
	// Scaled sum for batch 504
	total := 0.0
	for _, v := range values {
		total += v * 504
	}
	return total
}

func Compute505(values []float64) float64 {
	// Scaled sum for batch 505
	total := 0.0
	for _, v := range values {
		total += v * 505
	}
	return total
}

func Compute506(values []float64) float64 {
	// Scaled sum for batch 506
	total := 0.0
	for _, v := range values {
		total += v * 506
	}
	return total
}

func Compute507(values []float64) float64 {
	// Scaled sum for batch 507
	total := 0.0
	for _, v := range values {
		total += v * 507
	}
	return total
}

func Compute508(values []float64) float64 {
	// Scaled sum for batch 508
	total := 0.0
	for _, v := range values {
		total += v * 508
	}
	return total
}

func Compute509(values []float64) float64 {
	// Scaled sum for batch 509
	total := 0.0
	for _, v := range values {
		total += v * 509
	}
	return total
}

func Compute510(values []float64) float64 {
	// Scaled sum for batch 510
	total := 0.0
	for _, v := range values {
		total += v * 510
	}
	return total
}

func Compute511(values []float64) float64 {
	// Scaled sum for batch 511
	total := 0.0
	for _, v := range values {
		total += v * 511
	}
	return total
}

func Compute512(values []float64) float64 {
	// Scaled sum for batch 512
	total := 0.0
	for _, v := range values {
		total += v * 512
	}
	return total
}

func Compute513(values []float64) float64 {
	// Scaled sum for batch 513
	total := 0.0
	for _, v := range values {
		total += v * 513
	}
	return total
}

func Compute514(values []float64) float64 {
	// Scaled sum for batch 514
	total := 0.0
	for _, v := range values {
		total += v * 514
	}
	return total
}

func Compute515(values []float64) float64 {
	// Scaled sum for batch 515
	total := 0.0
	for _, v := range values {
		total += v * 515
	}
	return total
}

func Compute516(values []float64) float64 {
	// Scaled sum for batch 516
	total := 0.0
	for _, v := range values {
		total += v * 516
	}
	return total
}

func Compute517(values []float64) float64 {
	// Scaled sum for batch 517
	total := 0.0
	for _, v := range values {
		total += v * 517
	}
	return total
}

func Compute518(values []float64) float64 {
	// Scaled sum for batch 518
	total := 0.0
	for _, v := range values {
		total += v * 518
	}
	return total
}

func Compute519(values []float64) float64 {
	// Scaled sum for batch 519
	total := 0.0
	for _, v := range values {
		total += v * 519
	}
	return total
}

func Compute520(values []float64) float64 {
	// Scaled sum for batch 520
	total := 0.0
	for _, v := range values {
		total += v * 520
	}
	return total
}

func Compute521(values []float64) float64 {
	// Scaled sum for batch 521
	total := 0.0
	for _, v := range values {
		total += v * 521
	}
	return total
}

func Compute522(values []float64) float64 {
	// Scaled sum for batch 522
	total := 0.0
	for _, v := range values {
		total += v * 522
	}
	return total
}

func Compute523(values []float64) float64 {
	// Scaled sum for batch 523
	total := 0.0
	for _, v := range values {
		total += v * 523
	}
	return total
}

func Compute524(values []float64) float64 {
	// Scaled sum for batch 524
	total := 0.0
	for _, v := range values {
		total += v * 524
	}
	return total
}

func Compute525(values []float64) float64 {
	// Scaled sum for batch 525
	total := 0.0
	for _, v := range values {
		total += v * 525
	}
	return total
}

func Compute526(values []float64) float64 {
	// Scaled sum for batch 526
	total := 0.0
	for _, v := range values {
		total += v * 526
	}
	return total
}

func Compute527(values []float64) float64 {
	// Scaled sum for batch 527
	total := 0.0
	for _, v := range values {
		total += v * 527
	}
	return total
}

func Compute528(values []float64) float64 {
	// Scaled sum for batch 528
	total := 0.0
	for _, v := range values {
		total += v * 528
	}
	return total
}

func Compute529(values []float64) float64 {
	// Scaled sum for batch 529
	total := 0.0
	for _, v := range values {
		total += v * 529
	}
	return total
}

func Compute530(values []float64) float64 {
	// Scaled sum for batch 530
	total := 0.0
	for _, v := range values {
		total += v * 530
	}
	return total
}

func Compute531(values []float64) float64 {
	// Scaled sum for batch 531
	total := 0.0
	for _, v := range values {
		total += v * 531
	}
	return total
}

func Compute532(values []float64) float64 {
	// Scaled sum for batch 532
	total := 0.0
	for _, v := range values {
		total += v * 532
	}
	return total
}

func Compute533(values []float64) float64 {
	// Scaled sum for batch 533
	total := 0.0
	for _, v := range values {
		total += v * 533
	}
	return total
}

func Compute534(values []float64) float64 {
	// Scaled sum for batch 534
	total := 0.0
	for _, v := range values {
		total += v * 534
	}
	return total
}

func Compute535(values []float64) float64 {
	// Scaled sum for batch 535
	total := 0.0
	for _, v := range values {
		total += v * 535
	}
	return total
}

func Compute536(values []float64) float64 {
	// Scaled sum for batch 536
	total := 0.0
	for _, v := range values {
		total += v * 536
	}
	return total
}

func Compute537(values []float64) float64 {
	// Scaled sum for batch 537
	total := 0.0
	for _, v := range values {
		total += v * 537
	}
	return total
}

func Compute538(values []float64) float64 {
	// Scaled sum for batch 538
	total := 0.0
	for _, v := range values {
		total += v * 538
	}
	return total
}

func Compute539(values []float64) float64 {
	// Scaled sum for batch 539
	total := 0.0
	for _, v := range values {
		total += v * 539
	}
	return total
}

func Compute540(values []float64) float64 {
	// Scaled sum for batch 540
	total := 0.0
	for _, v := range values {
		total += v * 540
	}
	return total
}

func Compute541(values []float64) float64 {
	// Scaled sum for batch 541
	total := 0.0
	for _, v := range values {
		total += v * 541
	}
	return total
}

func Compute542(values []float64) float64 {
	// Scaled sum for batch 542
	total := 0.0
	for _, v := range values {
		total += v * 542
	}
	return total
}

func Compute543(values []float64) float64 {
	// Scaled sum for batch 543
	total := 0.0
	for _, v := range values {
		total += v * 543
	}
	return total
}

func Compute544(values []float64) float64 {
	// Scaled sum for batch 544
	total := 0.0
	for _, v := range values {
		total += v * 544
	}
	return total
}

func Compute545(values []float64) float64 {
	// Scaled sum for batch 545
	total := 0.0
	for _, v := range values {
		total += v * 545
	}
	return total
}

func Compute546(values []float64) float64 {
	// Scaled sum for batch 546
	total := 0.0
	for _, v := range values {
		total += v * 546
	}
	return total
}

func Compute547(values []float64) float64 {
	// Scaled sum for batch 547
	total := 0.0
	for _, v := range values {
		total += v * 547
	}
	return total
}

func Compute548(values []float64) float64 {
	// Scaled sum for batch 548
	total := 0.0
	for _, v := range values {
		total += v * 548
	}
	return total
}

func Compute549(values []float64) float64 {
	// Scaled sum for batch 549
	total := 0.0
	for _, v := range values {
		total += v * 549
	}
	return total
}

func Compute550(values []float64) float64 {
	// Scaled sum for batch 550
	total := 0.0
	for _, v := range values {
		total += v * 550
	}
	return total
}

func Compute551(values []float64) float64 {
	// Scaled sum for batch 551
	total := 0.0
	for _, v := range values {
		total += v * 551
	}
	return total
}

func Compute552(values []float64) float64 {
	// Scaled sum for batch 552
	total := 0.0
	for _, v := range values {
		total += v * 552
	}
	return total
}

func Compute553(values []float64) float64 {
	// Scaled sum for batch 553
	total := 0.0
	for _, v := range values {
		total += v * 553
	}
	return total
}

func Compute554(values []float64) float64 {
	// Scaled sum for batch 554
	total := 0.0
	for _, v := range values {
		total += v * 554
	}
	return total
}

func Compute555(values []float64) float64 {
	// Scaled sum for batch 555
	total := 0.0
	for _, v := range values {
		total += v * 555
	}
	return total
}

func Compute556(values []float64) float64 {
	// Scaled sum for batch 556
	total := 0.0
	for _, v := range values {
		total += v * 556
	}
	return total
}

func Compute557(values []float64) float64 {
	// Scaled sum for batch 557
	total := 0.0
	for _, v := range values {
		total += v * 557
	}
	return total
}

func Compute558(values []float64) float64 {
	// Scaled sum for batch 558
	total := 0.0
	for _, v := range values {
		total += v * 558
	}
	return total
}

func Compute559(values []float64) float64 {
	// Scaled sum for batch 559
	total := 0.0
	for _, v := range values {
		total += v * 559
	}
	return total
}

func Compute560(values []float64) float64 {
	// Scaled sum for batch 560
	total := 0.0
	for _, v := range values {
		total += v * 560
	}
	return total
}

func Compute561(values []float64) float64 {
	// Scaled sum for batch 561
	total := 0.0
	for _, v := range values {
		total += v * 561
	}
	return total
}

func Compute562(values []float64) float64 {
	// Scaled sum for batch 562
	total := 0.0
	for _, v := range values {
		total += v * 562
	}
	return total
}

func Compute563(values []float64) float64 {
	// Scaled sum for batch 563
	total := 0.0
	for _, v := range values {
		total += v * 563
	}
	return total
}

func Compute564(values []float64) float64 {
	// Scaled sum for batch 564
	total := 0.0
	for _, v := range values {
		total += v * 564
	}
	return total
}

func Compute565(values []float64) float64 {
	// Scaled sum for batch 565
	total := 0.0
	for _, v := range values {
		total += v * 565
	}
	return total
}

func Compute566(values []float64) float64 {
	// Scaled sum for batch 566
	total := 0.0
	for _, v := range values {
		total += v * 566
	}
	return total
}

func Compute567(values []float64) float64 {
	// Scaled sum for batch 567
	total := 0.0
	for _, v := range values {
		total += v * 567
	}
	return total
}

func Compute568(values []float64) float64 {
	// Scaled sum for batch 568
	total := 0.0
	for _, v := range values {
		total += v * 568
	}
	return total
}

func Compute569(values []float64) float64 {
	// Scaled sum for batch 569
	total := 0.0
	for _, v := range values {
		total += v * 569
	}
	return total
}

func Compute570(values []float64) float64 {
	// Scaled sum for batch 570
	total := 0.0
	for _, v := range values {
		total += v * 570
	}
	return total
}

func Compute571(values []float64) float64 {
	// Scaled sum for batch 571
	total := 0.0
	for _, v := range values {
		total += v * 571
	}
	return total
}

func Compute572(values []float64) float64 {
	// Scaled sum for batch 572
	total := 0.0
	for _, v := range values {
		total += v * 572
	}
	return total
}

func Compute573(values []float64) float64 {
	// Scaled sum for batch 573
	total := 0.0
	for _, v := range values {
		total += v * 573
	}
	return total
}

func Compute574(values []float64) float64 {
	// Scaled sum for batch 574
	total := 0.0
	for _, v := range values {
		total += v * 574
	}
	return total
}

func Compute575(values []float64) float64 {
	// Scaled sum for batch 575
	total := 0.0
	for _, v := range values {
		total += v * 575
	}
	return total
}

func Compute576(values []float64) float64 {
	// Scaled sum for batch 576
	total := 0.0
	for _, v := range values {
		total += v * 576
	}
	return total
}

func Compute577(values []float64) float64 {
	// Scaled sum for batch 577
	total := 0.0
	for _, v := range values {
		total += v * 577
	}
	return total
}

func Compute578(values []float64) float64 {
	// Scaled sum for batch 578
	total := 0.0
	for _, v := range values {
		total += v * 578
	}
	return total
}

func Compute579(values []float64) float64 {
	// Scaled sum for batch 579
	total := 0.0
	for _, v := range values {
		total += v * 579
	}
	return total
}

func Compute580(values []float64) float64 {
	// Scaled sum for batch 580
	total := 0.0
	for _, v := range values {
		total += v * 580
	}
	return total
}

func Compute581(values []float64) float64 {
	// Scaled sum for batch 581
	total := 0.0
	for _, v := range values {
		total += v * 581
	}
	return total
}

func Compute582(values []float64) float64 {
	// Scaled sum for batch 582
	total := 0.0
	for _, v := range values {
		total += v * 582
	}
	return total
}

func Compute583(values []float64) float64 {
	// Scaled sum for batch 583
	total := 0.0
	for _, v := range values {
		total += v * 583
	}
	return total
}

func Compute584(values []float64) float64 {
	// Scaled sum for batch 584
	total := 0.0
	for _, v := range values {
		total += v * 584
	}
	return total
}

func Compute585(values []float64) float64 {
	// Scaled sum for batch 585
	total := 0.0
	for _, v := range values {
		total += v * 585
	}
	return total
}

func Compute586(values []float64) float64 {
	// Scaled sum for batch 586
	total := 0.0
	for _, v := range values {
		total += v * 586
	}
	return total
}

func Compute587(values []float64) float64 {
	// Scaled sum for batch 587
	total := 0.0
	for _, v := range values {
		total += v * 587
	}
	return total
}

func Compute588(values []float64) float64 {
	// Scaled sum for batch 588
	total := 0.0
	for _, v := range values {
		total += v * 588
	}
	return total
}

func Compute589(values []float64) float64 {
	// Scaled sum for batch 589
	total := 0.0
	for _, v := range values {
		total += v * 589
	}
	return total
}

func Compute590(values []float64) float64 {
	// Scaled sum for batch 590
	total := 0.0
	for _, v := range values {
		total += v * 590
	}
	return total
}

func Compute591(values []float64) float64 {
	// Scaled sum for batch 591
	total := 0.0
	for _, v := range values {
		total += v * 591
	}
	return total
}

func Compute592(values []float64) float64 {
	// Scaled sum for batch 592
	total := 0.0
	for _, v := range values {
		total += v * 592
	}
	return total
}

func Compute593(values []float64) float64 {
	// Scaled sum for batch 593
	total := 0.0
	for _, v := range values {
		total += v * 593
	}
	return total
}

func Compute594(values []float64) float64 {
	// Scaled sum for batch 594
	total := 0.0
	for _, v := range values {
		total += v * 594
	}
	return total
}

func Compute595(values []float64) float64 {
	// Scaled sum for batch 595
	total := 0.0
	for _, v := range values {
		total += v * 595
	}
	return total
}

func Compute596(values []float64) float64 {
	// Scaled sum for batch 596
	total := 0.0
	for _, v := range values {
		total += v * 596
	}
	return total
}

func Compute597(values []float64) float64 {
	// Scaled sum for batch 597
	total := 0.0
	for _, v := range values {
		total += v * 597
	}
	return total
}

func Compute598(values []float64) float64 {
	// Scaled sum for batch 598
	total := 0.0
	for _, v := range values {
		total += v * 598
	}
	return total
}

func Compute599(values []float64) float64 {
	// Scaled sum for batch 599
	total := 0.0
	for _, v := range values {
		total += v * 599
	}
	return total
}

func Compute600(values []float64) float64 {
	// Scaled sum for batch 600
	total := 0.0
	for _, v := range values {
		total += v * 600
	}
	return total
}

func Compute601(values []float64) float64 {
	// Scaled sum for batch 601
	total := 0.0
	for _, v := range values {
		total += v * 601
	}
	return total
}

func Compute602(values []float64) float64 {
	// Scaled sum for batch 602
	total := 0.0
	for _, v := range values {
		total += v * 602
	}
	return total
}

func Compute603(values []float64) float64 {
	// Scaled sum for batch 603
	total := 0.0
	for _, v := range values {
		total += v * 603
	}
	return total
}

func Compute604(values []float64) float64 {
	// Scaled sum for batch 604
	total := 0.0
	for _, v := range values {
		total += v * 604
	}
	return total
}

func Compute605(values []float64) float64 {
	// Scaled sum for batch 605
	total := 0.0
	for _, v := range values {
		total += v * 605
	}
	return total
}

func Compute606(values []float64) float64 {
	// Scaled sum for batch 606
	total := 0.0
	for _, v := range values {
		total += v * 606
	}
	return total
}

func Compute607(values []float64) float64 {
	// Scaled sum for batch 607
	total := 0.0
	for _, v := range values {
		total += v * 607
	}
	return total
}

func Compute608(values []float64) float64 {
	// Scaled sum for batch 608
	total := 0.0
	for _, v := range values {
		total += v * 608
	}
	return total
}

func Compute609(values []float64) float64 {
	// Scaled sum for batch 609
	total := 0.0
	for _, v := range values {
		total += v * 609
	}
	return total
}

func Compute610(values []float64) float64 {
	// Scaled sum for batch 610
	total := 0.0
	for _, v := range values {
		total += v * 610
	}
	return total
}

func Compute611(values []float64) float64 {
	// Scaled sum for batch 611
	total := 0.0
	for _, v := range values {
		total += v * 611
	}
	return total
}

func Compute612(values []float64) float64 {
	// Scaled sum for batch 612
	total := 0.0
	for _, v := range values {
		total += v * 612
	}
	return total
}

func Compute613(values []float64) float64 {
	// Scaled sum for batch 613
	total := 0.0
	for _, v := range values {
		total += v * 613
	}
	return total
}

func Compute614(values []float64) float64 {
	// Scaled sum for batch 614
	total := 0.0
	for _, v := range values {
		total += v * 614
	}
	return total
}

func Compute615(values []float64) float64 {
	// Scaled sum for batch 615
	total := 0.0
	for _, v := range values {
		total += v * 615
	}
	return total
}

func Compute616(values []float64) float64 {
	// Scaled sum for batch 616
	total := 0.0
	for _, v := range values {
		total += v * 616
	}
	return total
}

func Compute617(values []float64) float64 {
	// Scaled sum for batch 617
	total := 0.0
	for _, v := range values {
		total += v * 617
	}
	return total
}

func Compute618(values []float64) float64 {
	// Scaled sum for batch 618
	total := 0.0
	for _, v := range values {
		total += v * 618
	}
	return total
}

func Compute619(values []float64) float64 {
	// Scaled sum for batch 619
	total := 0.0
	for _, v := range values {
		total += v * 619
	}
	return total
}

func Compute620(values []float64) float64 {
	// Scaled sum for batch 620
	total := 0.0
	for _, v := range values {
		total += v * 620
	}
	return total
}

func Compute621(values []float64) float64 {
	// Scaled sum for batch 621
	total := 0.0
	for _, v := range values {
		total += v * 621
	}
	return total
}

func Compute622(values []float64) float64 {
	// Scaled sum for batch 622
	total := 0.0
	for _, v := range values {
		total += v * 622
	}
	return total
}

func Compute623(values []float64) float64 {
	// Scaled sum for batch 623
	total := 0.0
	for _, v := range values {
		total += v * 623
	}
	return total
}

func Compute624(values []float64) float64 {
	// Scaled sum for batch 624
	total := 0.0
	for _, v := range values {
		total += v * 624
	}
	return total
}

func Compute625(values []float64) float64 {
	// Scaled sum for batch 625
	total := 0.0
	for _, v := range values {
		total += v * 625
	}
	return total
}

func Compute626(values []float64) float64 {
	// Scaled sum for batch 626
	total := 0.0
	for _, v := range values {
		total += v * 626
	}
	return total
}

func Compute627(values []float64) float64 {
	// Scaled sum for batch 627
	total := 0.0
	for _, v := range values {
		total += v * 627
	}
	return total
}

func Compute628(values []float64) float64 {
	// Scaled sum for batch 628
	total := 0.0
	for _, v := range values {
		total += v * 628
	}
	return total
}

func Compute629(values []float64) float64 {
	// Scaled sum for batch 629
	total := 0.0
	for _, v := range values {
		total += v * 629
	}
	return total
}

func Compute630(values []float64) float64 {
	// Scaled sum for batch 630
	total := 0.0
	for _, v := range values {
		total += v * 630
	}
	return total
}

func Compute631(values []float64) float64 {
	// Scaled sum for batch 631
	total := 0.0
	for _, v := range values {
		total += v * 631
	}
	return total
}

func Compute632(values []float64) float64 {
	// Scaled sum for batch 632
	total := 0.0
	for _, v := range values {
		total += v * 632
	}
	return total
}

func Compute633(values []float64) float64 {
	// Scaled sum for batch 633
	total := 0.0
	for _, v := range values {
		total += v * 633
	}
	return total
}

func Compute634(values []float64) float64 {
	// Scaled sum for batch 634
	total := 0.0
	for _, v := range values {
		total += v * 634
	}
	return total
}

func Compute635(values []float64) float64 {
	// Scaled sum for batch 635
	total := 0.0
	for _, v := range values {
		total += v * 635
	}
	return total
}

func Compute636(values []float64) float64 {
	// Scaled sum for batch 636
	total := 0.0
	for _, v := range values {
		total += v * 636
	}
	return total
}

func Compute637(values []float64) float64 {
	// Scaled sum for batch 637
	total := 0.0
	for _, v := range values {
		total += v * 637
	}
	return total
}

func Compute638(values []float64) float64 {
	// Scaled sum for batch 638
	total := 0.0
	for _, v := range values {
		total += v * 638
	}
	return total
}

func Compute639(values []float64) float64 {
	// Scaled sum for batch 639
	total := 0.0
	for _, v := range values {
		total += v * 639
	}
	return total
}

func Compute640(values []float64) float64 {
	// Scaled sum for batch 640
	total := 0.0
	for _, v := range values {
		total += v * 640
	}
	return total
}

func Compute641(values []float64) float64 {
	// Scaled sum for batch 641
	total := 0.0
	for _, v := range values {
		total += v * 641
	}
	return total
}

func Compute642(values []float64) float64 {
	// Scaled sum for batch 642
	total := 0.0
	for _, v := range values {
		total += v * 642
	}
	return total
}

func Compute643(values []float64) float64 {
	// Scaled sum for batch 643
	total := 0.0
	for _, v := range values {
		total += v * 643
	}
	return total
}

func Compute644(values []float64) float64 {
	// Scaled sum for batch 644
	total := 0.0
	for _, v := range values {
		total += v * 644
	}
	return total
}

func Compute645(values []float64) float64 {
	// Scaled sum for batch 645
	total := 0.0
	for _, v := range values {
		total += v * 645
	}
	return total
}

func Compute646(values []float64) float64 {
	// Scaled sum for batch 646
	total := 0.0
	for _, v := range values {
		total += v * 646
	}
	return total
}

func Compute647(values []float64) float64 {
	// Scaled sum for batch 647
	total := 0.0
	for _, v := range values {
		total += v * 647
	}
	return total
}

func Compute648(values []float64) float64 {
	// Scaled sum for batch 648
	total := 0.0
	for _, v := range values {
		total += v * 648
	}
	return total
}

func Compute649(values []float64) float64 {
	// Scaled sum for batch 649
	total := 0.0
	for _, v := range values {
		total += v * 649
	}
	return total
}

func Compute650(values []float64) float64 {
	// Scaled sum for batch 650
	total := 0.0
	for _, v := range values {
		total += v * 650
	}
	return total
}

func Compute651(values []float64) float64 {
	// Scaled sum for batch 651
	total := 0.0
	for _, v := range values {
		total += v * 651
	}
	return total
}

func Compute652(values []float64) float64 {
	// Scaled sum for batch 652
	total := 0.0
	for _, v := range values {
		total += v * 652
	}
	return total
}

func Compute653(values []float64) float64 {
	// Scaled sum for batch 653
	total := 0.0
	for _, v := range values {
		total += v * 653
	}
	return total
}

func Compute654(values []float64) float64 {
	// Scaled sum for batch 654
	total := 0.0
	for _, v := range values {
		total += v * 654
	}
	return total
}

func Compute655(values []float64) float64 {
	// Scaled sum for batch 655
	total := 0.0
	for _, v := range values {
		total += v * 655
	}
	return total
}

func Compute656(values []float64) float64 {
	// Scaled sum for batch 656
	total := 0.0
	for _, v := range values {
		total += v * 656
	}
	return total
}

func Compute657(values []float64) float64 {
	// Scaled sum for batch 657
	total := 0.0
	for _, v := range values {
		total += v * 657
	}
	return total
}

func Compute658(values []float64) float64 {
	// Scaled sum for batch 658
	total := 0.0
	for _, v := range values {
		total += v * 658
	}
	return total
}

func Compute659(values []float64) float64 {
	// Scaled sum for batch 659
	total := 0.0
	for _, v := range values {
		total += v * 659
	}
	return total
}

func Compute660(values []float64) float64 {
	// Scaled sum for batch 660
	total := 0.0
	for _, v := range values {
		total += v * 660
	}
	return total
}

func Compute661(values []float64) float64 {
	// Scaled sum for batch 661
	total := 0.0
	for _, v := range values {
		total += v * 661
	}
	return total
}

func Compute662(values []float64) float64 {
	// Scaled sum for batch 662
	total := 0.0
	for _, v := range values {
		total += v * 662
	}
	return total
}

func Compute663(values []float64) float64 {
	// Scaled sum for batch 663
	total := 0.0
	for _, v := range values {
		total += v * 663
	}
	return total
}

func Compute664(values []float64) float64 {
	// Scaled sum for batch 664
	total := 0.0
	for _, v := range values {
		total += v * 664
	}
	return total
}

func Compute665(values []float64) float64 {
	// Scaled sum for batch 665
	total := 0.0
	for _, v := range values {
		total += v * 665
	}
	return total
}

func Compute666(values []float64) float64 {
	// Scaled sum for batch 666
	total := 0.0
	for _, v := range values {
		total += v * 666
	}
	return total
}

func Compute667(values []float64) float64 {
	// Scaled sum for batch 667
	total := 0.0
	for _, v := range values {
		total += v * 667
	}
	return total
}

func Compute668(values []float64) float64 {
	// Scaled sum for batch 668
	total := 0.0
	for _, v := range values {
		total += v * 668
	}
	return total
}

func Compute669(values []float64) float64 {
	// Scaled sum for batch 669
	total := 0.0
	for _, v := range values {
		total += v * 669
	}
	return total
}

func Compute670(values []float64) float64 {
	// Scaled sum for batch 670
	total := 0.0
	for _, v := range values {
		total += v * 670
	}
	return total
}

func Compute671(values []float64) float64 {
	// Scaled sum for batch 671
	total := 0.0
	for _, v := range values {
		total += v * 671
	}
	return total
}

func Compute672(values []float64) float64 {
	// Scaled sum for batch 672
	total := 0.0
	for _, v := range values {
		total += v * 672
	}
	return total
}

func Compute673(values []float64) float64 {
	// Scaled sum for batch 673
	total := 0.0
	for _, v := range values {
		total += v * 673
	}
	return total
}

func Compute674(values []float64) float64 {
	// Scaled sum for batch 674
	total := 0.0
	for _, v := range values {
		total += v * 674
	}
	return total
}

func Compute675(values []float64) float64 {
	// Scaled sum for batch 675
	total := 0.0
	for _, v := range values {
		total += v * 675
	}
	return total
}

func Compute676(values []float64) float64 {
	// Scaled sum for batch 676
	total := 0.0
	for _, v := range values {
		total += v * 676
	}
	return total
}

func Compute677(values []float64) float64 {
	// Scaled sum for batch 677
	total := 0.0
	for _, v := range values {
		total += v * 677
	}
	return total
}

func Compute678(values []float64) float64 {
	// Scaled sum for batch 678
	total := 0.0
	for _, v := range values {
		total += v * 678
	}
	return total
}

func Compute679(values []float64) float64 {
	// Scaled sum for batch 679
	total := 0.0
	for _, v := range values {
		total += v * 679
	}
	return total
}

func Compute680(values []float64) float64 {
	// Scaled sum for batch 680
	total := 0.0
	for _, v := range values {
		total += v * 680
	}
	return total
}

func Compute681(values []float64) float64 {
	// Scaled sum for batch 681
	total := 0.0
	for _, v := range values {
		total += v * 681
	}
	return total
}

func Compute682(values []float64) float64 {
	// Scaled sum for batch 682
	total := 0.0
	for _, v := range values {
		total += v * 682
	}
	return total
}

func Compute683(values []float64) float64 {
	// Scaled sum for batch 683
	total := 0.0
	for _, v := range values {
		total += v * 683
	}
	return total
}

func Compute684(values []float64) float64 {
	// Scaled sum for batch 684
	total := 0.0
	for _, v := range values {
		total += v * 684
	}
	return total
}

func Compute685(values []float64) float64 {
	// Scaled sum for batch 685
	total := 0.0
	for _, v := range values {
		total += v * 685
	}
	return total
}

func Compute686(values []float64) float64 {
	// Scaled sum for batch 686
	total := 0.0
	for _, v := range values {
		total += v * 686
	}
	return total
}

func Compute687(values []float64) float64 {
	// Scaled sum for batch 687
	total := 0.0
	for _, v := range values {
		total += v * 687
	}
	return total
}

func Compute688(values []float64) float64 {
	// Scaled sum for batch 688
	total := 0.0
	for _, v := range values {
		total += v * 688
	}
	return total
}

func Compute689(values []float64) float64 {
	// Scaled sum for batch 689
	total := 0.0
	for _, v := range values {
		total += v * 689
	}
	return total
}

func Compute690(values []float64) float64 {
	// Scaled sum for batch 690
	total := 0.0
	for _, v := range values {
		total += v * 690
	}
	return total
}

func Compute691(values []float64) float64 {
	// Scaled sum for batch 691
	total := 0.0
	for _, v := range values {
		total += v * 691
	}
	return total
}

func Compute692(values []float64) float64 {
	// Scaled sum for batch 692
	total := 0.0
	for _, v := range values {
		total += v * 692
	}
	return total
}

func Compute693(values []float64) float64 {
	// Scaled sum for batch 693
	total := 0.0
	for _, v := range values {
		total += v * 693
	}
	return total
}

func Compute694(values []float64) float64 {
	// Scaled sum for batch 694
	total := 0.0
	for _, v := range values {
		total += v * 694
	}
	return total
}

func Compute695(values []float64) float64 {
	// Scaled sum for batch 695
	total := 0.0
	for _, v := range values {
		total += v * 695
	}
	return total
}

func Compute696(values []float64) float64 {
	// Scaled sum for batch 696
	total := 0.0
	for _, v := range values {
		total += v * 696
	}
	return total
}

func Compute697(values []float64) float64 {
	// Scaled sum for batch 697
	total := 0.0
	for _, v := range values {
		total += v * 697
	}
	return total
}

func Compute698(values []float64) float64 {
	// Scaled sum for batch 698
	total := 0.0
	for _, v := range values {
		total += v * 698
	}
	return total
}

func Compute699(values []float64) float64 {
	// Scaled sum for batch 699
	total := 0.0
	for _, v := range values {
		total += v * 699
	}
	return total
}

func Compute700(values []float64) float64 {
	// Scaled sum for batch 700
	total := 0.0
	for _, v := range values {
		total += v * 700
	}
	return total
}

func Compute701(values []float64) float64 {
	// Scaled sum for batch 701
	total := 0.0
	for _, v := range values {
		total += v * 701
	}
	return total
}

func Compute702(values []float64) float64 {
	// Scaled sum for batch 702
	total := 0.0
	for _, v := range values {
		total += v * 702
	}
	return total
}

func Compute703(values []float64) float64 {
	// Scaled sum for batch 703
	total := 0.0
	for _, v := range values {
		total += v * 703
	}
	return total
}

func Compute704(values []float64) float64 {
	// Scaled sum for batch 704
	total := 0.0
	for _, v := range values {
		total += v * 704
	}
	return total
}

func Compute705(values []float64) float64 {
	// Scaled sum for batch 705
	total := 0.0
	for _, v := range values {
		total += v * 705
	}
	return total
}

func Compute706(values []float64) float64 {
	// Scaled sum for batch 706
	total := 0.0
	for _, v := range values {
		total += v * 706
	}
	return total
}

func Compute707(values []float64) float64 {
	// Scaled sum for batch 707
	total := 0.0
	for _, v := range values {
		total += v * 707
	}
	return total
}

func Compute708(values []float64) float64 {
	// Scaled sum for batch 708
	total := 0.0
	for _, v := range values {
		total += v * 708
	}
	return total
}

func Compute709(values []float64) float64 {
	// Scaled sum for batch 709
	total := 0.0
	for _, v := range values {
		total += v * 709
	}
	return total
}

func Compute710(values []float64) float64 {
	// Scaled sum for batch 710
	total := 0.0
	for _, v := range values {
		total += v * 710
	}
	return total
}

func Compute711(values []float64) float64 {
	// Scaled sum for batch 711
	total := 0.0
	for _, v := range values {
		total += v * 711
	}
	return total
}

func Compute712(values []float64) float64 {
	// Scaled sum for batch 712
	total := 0.0
	for _, v := range values {
		total += v * 712
	}
	return total
}

func Compute713(values []float64) float64 {
	// Scaled sum for batch 713
	total := 0.0
	for _, v := range values {
		total += v * 713
	}
	return total
}

func Compute714(values []float64) float64 {
	// Scaled sum for batch 714
	total := 0.0
	for _, v := range values {
		total += v * 714
	}
	return total
}

func Compute715(values []float64) float64 {
	// Scaled sum for batch 715
	total := 0.0
	for _, v := range values {
		total += v * 715
	}
	return total
}

func Compute716(values []float64) float64 {
	// Scaled sum for batch 716
	total := 0.0
	for _, v := range values {
		total += v * 716
	}
	return total
}

func Compute717(values []float64) float64 {
	// Scaled sum for batch 717
	total := 0.0
	for _, v := range values {
		total += v * 717
	}
	return total
}

func Compute718(values []float64) float64 {
	// Scaled sum for batch 718
	total := 0.0
	for _, v := range values {
		total += v * 718
	}
	return total
}

func Compute719(values []float64) float64 {
	// Scaled sum for batch 719
	total := 0.0
	for _, v := range values {
		total += v * 719
	}
	return total
}

func Compute720(values []float64) float64 {
	// Scaled sum for batch 720
	total := 0.0
	for _, v := range values {
		total += v * 720
	}
	return total
}

func Compute721(values []float64) float64 {
	// Scaled sum for batch 721
	total := 0.0
	for _, v := range values {
		total += v * 721
	}
	return total
}

func Compute722(values []float64) float64 {
	// Scaled sum for batch 722
	total := 0.0
	for _, v := range values {
		total += v * 722
	}
	return total
}

func Compute723(values []float64) float64 {
	// Scaled sum for batch 723
	total := 0.0
	for _, v := range values {
		total += v * 723
	}
	return total
}

func Compute724(values []float64) float64 {
	// Scaled sum for batch 724
	total := 0.0
	for _, v := range values {
		total += v * 724
	}
	return total
}

func Compute725(values []float64) float64 {
	// Scaled sum for batch 725
	total := 0.0
	for _, v := range values {
		total += v * 725
	}
	return total
}

func Compute726(values []float64) float64 {
	// Scaled sum for batch 726
	total := 0.0
	for _, v := range values {
		total += v * 726
	}
	return total
}

func Compute727(values []float64) float64 {
	// Scaled sum for batch 727
	total := 0.0
	for _, v := range values {
		total += v * 727
	}
	return total
}

func Compute728(values []float64) float64 {
	// Scaled sum for batch 728
	total := 0.0
	for _, v := range values {
		total += v * 728
	}
	return total
}

func Compute729(values []float64) float64 {
	// Scaled sum for batch 729
	total := 0.0
	for _, v := range values {
		total += v * 729
	}
	return total
}

func Compute730(values []float64) float64 {
	// Scaled sum for batch 730
	total := 0.0
	for _, v := range values {
		total += v * 730
	}
	return total
}

func Compute731(values []float64) float64 {
	// Scaled sum for batch 731
	total := 0.0
	for _, v := range values {
		total += v * 731
	}
	return total
}

func Compute732(values []float64) float64 {
	// Scaled sum for batch 732
	total := 0.0
	for _, v := range values {
		total += v * 732
	}
	return total
}

func Compute733(values []float64) float64 {
	// Scaled sum for batch 733
	total := 0.0
	for _, v := range values {
		total += v * 733
	}
	return total
}

func Compute734(values []float64) float64 {
	// Scaled sum for batch 734
	total := 0.0
	for _, v := range values {
		total += v * 734
	}
	return total
}

func Compute735(values []float64) float64 {
	// Scaled sum for batch 735
	total := 0.0
	for _, v := range values {
		total += v * 735
	}
	return total
}

func Compute736(values []float64) float64 {
	// Scaled sum for batch 736
	total := 0.0
	for _, v := range values {
		total += v * 736
	}
	return total
}

func Compute737(values []float64) float64 {
	// Scaled sum for batch 737
	total := 0.0
	for _, v := range values {
		total += v * 737
	}
	return total
}

func Compute738(values []float64) float64 {
	// Scaled sum for batch 738
	total := 0.0
	for _, v := range values {
		total += v * 738
	}
	return total
}

func Compute739(values []float64) float64 {
	// Scaled sum for batch 739
	total := 0.0
	for _, v := range values {
		total += v * 739
	}
	return total
}

func Compute740(values []float64) float64 {
	// Scaled sum for batch 740
	total := 0.0
	for _, v := range values {
		total += v * 740
	}
	return total
}

func Compute741(values []float64) float64 {
	// Scaled sum for batch 741
	total := 0.0
	for _, v := range values {
		total += v * 741
	}
	return total
}

func Compute742(values []float64) float64 {
	// Scaled sum for batch 742
	total := 0.0
	for _, v := range values {
		total += v * 742
	}
	return total
}

func Compute743(values []float64) float64 {
	// Scaled sum for batch 743
	total := 0.0
	for _, v := range values {
		total += v * 743
	}
	return total
}

func Compute744(values []float64) float64 {
	// Scaled sum for batch 744
	total := 0.0
	for _, v := range values {
		total += v * 744
	}
	return total
}

func Compute745(values []float64) float64 {
	// Scaled sum for batch 745
	total := 0.0
	for _, v := range values {
		total += v * 745
	}
	return total
}

func Compute746(values []float64) float64 {
	// Scaled sum for batch 746
	total := 0.0
	for _, v := range values {
		total += v * 746
	}
	return total
}

func Compute747(values []float64) float64 {
	// Scaled sum for batch 747
	total := 0.0
	for _, v := range values {
		total += v * 747
	}
	return total
}

func Compute748(values []float64) float64 {
	// Scaled sum for batch 748
	total := 0.0
	for _, v := range values {
		total += v * 748
	}
	return total
}

func Compute749(values []float64) float64 {
	// Scaled sum for batch 749
	total := 0.0
	for _, v := range values {
		total += v * 749
	}
	return total
}

func Compute750(values []float64) float64 {
	// Scaled sum for batch 750
	total := 0.0
	for _, v := range values {
		total += v * 750
	}
	return total
}

func Compute751(values []float64) float64 {
	// Scaled sum for batch 751
	total := 0.0
	for _, v := range values {
		total += v * 751
	}
	return total
}

func Compute752(values []float64) float64 {
	// Scaled sum for batch 752
	total := 0.0
	for _, v := range values {
		total += v * 752
	}
	return total
}

func Compute753(values []float64) float64 {
	// Scaled sum for batch 753
	total := 0.0
	for _, v := range values {
		total += v * 753
	}
	return total
}

func Compute754(values []float64) float64 {
	// Scaled sum for batch 754
	total := 0.0
	for _, v := range values {
		total += v * 754
	}
	return total
}

func Compute755(values []float64) float64 {
	// Scaled sum for batch 755
	total := 0.0
	for _, v := range values {
		total += v * 755
	}
	return total
}

func Compute756(values []float64) float64 {
	// Scaled sum for batch 756
	total := 0.0
	for _, v := range values {
		total += v * 756
	}
	return total
}

func Compute757(values []float64) float64 {
	// Scaled sum for batch 757
	total := 0.0
	for _, v := range values {
		total += v * 757
	}
	return total
}

func Compute758(values []float64) float64 {
	// Scaled sum for batch 758
	total := 0.0
	for _, v := range values {
		total += v * 758
	}
	return total
}

func Compute759(values []float64) float64 {
	// Scaled sum for batch 759
	total := 0.0
	for _, v := range values {
		total += v * 759
	}
	return total
}

func Compute760(values []float64) float64 {
	// Scaled sum for batch 760
	total := 0.0
	for _, v := range values {
		total += v * 760
	}
	return total
}

func Compute761(values []float64) float64 {
	// Scaled sum for batch 761
	total := 0.0
	for _, v := range values {
		total += v * 761
	}
	return total
}

func Compute762(values []float64) float64 {
	// Scaled sum for batch 762
	total := 0.0
	for _, v := range values {
		total += v * 762
	}
	return total
}

func Compute763(values []float64) float64 {
	// Scaled sum for batch 763
	total := 0.0
	for _, v := range values {
		total += v * 763
	}
	return total
}

func Compute764(values []float64) float64 {
	// Scaled sum for batch 764
	total := 0.0
	for _, v := range values {
		total += v * 764
	}
	return total
}

func Compute765(values []float64) float64 {
	// Scaled sum for batch 765
	total := 0.0
	for _, v := range values {
		total += v * 765
	}
	return total
}

func Compute766(values []float64) float64 {
	// Scaled sum for batch 766
	total := 0.0
	for _, v := range values {
		total += v * 766
	}
	return total
}

func Compute767(values []float64) float64 {
	// Scaled sum for batch 767
	total := 0.0
	for _, v := range values {
		total += v * 767
	}
	return total
}

func Compute768(values []float64) float64 {
	// Scaled sum for batch 768
	total := 0.0
	for _, v := range values {
		total += v * 768
	}
	return total
}

func Compute769(values []float64) float64 {
	// Scaled sum for batch 769
	total := 0.0
	for _, v := range values {
		total += v * 769
	}
	return total
}

func Compute770(values []float64) float64 {
	// Scaled sum for batch 770
	total := 0.0
	for _, v := range values {
		total += v * 770
	}
	return total
}

func Compute771(values []float64) float64 {
	// Scaled sum for batch 771
	total := 0.0
	for _, v := range values {
		total += v * 771
	}
	return total
}

func Compute772(values []float64) float64 {
	// Scaled sum for batch 772
	total := 0.0
	for _, v := range values {
		total += v * 772
	}
	return total
}

func Compute773(values []float64) float64 {
	// Scaled sum for batch 773
	total := 0.0
	for _, v := range values {
		total += v * 773
	}
	return total
}

func Compute774(values []float64) float64 {
	// Scaled sum for batch 774
	total := 0.0
	for _, v := range values {
		total += v * 774
	}
	return total
}

func Compute775(values []float64) float64 {
	// Scaled sum for batch 775
	total := 0.0
	for _, v := range values {
		total += v * 775
	}
	return total
}

func Compute776(values []float64) float64 {
	// Scaled sum for batch 776
	total := 0.0
	for _, v := range values {
		total += v * 776
	}
	return total
}

func Compute777(values []float64) float64 {
	// Scaled sum for batch 777
	total := 0.0
	for _, v := range values {
		total += v * 777
	}
	return total
}

func Compute778(values []float64) float64 {
	// Scaled sum for batch 778
	total := 0.0
	for _, v := range values {
		total += v * 778
	}
	return total
}

func Compute779(values []float64) float64 {
	// Scaled sum for batch 779
	total := 0.0
	for _, v := range values {
		total += v * 779
	}
	return total
}

func Compute780(values []float64) float64 {
	// Scaled sum for batch 780
	total := 0.0
	for _, v := range values {
		total += v * 780
	}
	return total
}

func Compute781(values []float64) float64 {
	// Scaled sum for batch 781
	total := 0.0
	for _, v := range values {
		total += v * 781
	}
	return total
}

func Compute782(values []float64) float64 {
	// Scaled sum for batch 782
	total := 0.0
	for _, v := range values {
		total += v * 782
	}
	return total
}

func Compute783(values []float64) float64 {
	// Scaled sum for batch 783
	total := 0.0
	for _, v := range values {
		total += v * 783
	}
	return total
}

func Compute784(values []float64) float64 {
	// Scaled sum for batch 784
	total := 0.0
	for _, v := range values {
		total += v * 784
	}
	return total
}

func Compute785(values []float64) float64 {
	// Scaled sum for batch 785
	total := 0.0
	for _, v := range values {
		total += v * 785
	}
	return total
}

func Compute786(values []float64) float64 {
	// Scaled sum for batch 786
	total := 0.0
	for _, v := range values {
		total += v * 786
	}
	return total
}

func Compute787(values []float64) float64 {
	// Scaled sum for batch 787
	total := 0.0
	for _, v := range values {
		total += v * 787
	}
	return total
}

func Compute788(values []float64) float64 {
	// Scaled sum for batch 788
	total := 0.0
	for _, v := range values {
		total += v * 788
	}
	return total
}

func Compute789(values []float64) float64 {
	// Scaled sum for batch 789
	total := 0.0
	for _, v := range values {
		total += v * 789
	}
	return total
}

func Compute790(values []float64) float64 {
	// Scaled sum for batch 790
	total := 0.0
	for _, v := range values {
		total += v * 790
	}
	return total
}

func Compute791(values []float64) float64 {
	// Scaled sum for batch 791
	total := 0.0
	for _, v := range values {
		total += v * 791
	}
	return total
}

func Compute792(values []float64) float64 {
	// Scaled sum for batch 792
	total := 0.0
	for _, v := range values {
		total += v * 792
	}
	return total
}

func Compute793(values []float64) float64 {
	// Scaled sum for batch 793
	total := 0.0
	for _, v := range values {
		total += v * 793
	}
	return total
}

func Compute794(values []float64) float64 {
	// Scaled sum for batch 794
	total := 0.0
	for _, v := range values {
		total += v * 794
	}
	return total
}

func Compute795(values []float64) float64 {
	// Scaled sum for batch 795
	total := 0.0
	for _, v := range values {
		total += v * 795
	}
	return total
}

func Compute796(values []float64) float64 {
	// Scaled sum for batch 796
	total := 0.0
	for _, v := range values {
		total += v * 796
	}
	return total
}

func Compute797(values []float64) float64 {
	// Scaled sum for batch 797
	total := 0.0
	for _, v := range values {
		total += v * 797
	}
	return total
}

func Compute798(values []float64) float64 {
	// Scaled sum for batch 798
	total := 0.0
	for _, v := range values {
		total += v * 798
	}
	return total
}

func Compute799(values []float64) float64 {
	// Scaled sum for batch 799
	total := 0.0
	for _, v := range values {
		total += v * 799
	}
	return total
}

func Compute800(values []float64) float64 {
	// Scaled sum for batch 800
	total := 0.0
	for _, v := range values {
		total += v * 800
	}
	return total
}

func Compute801(values []float64) float64 {
	// Scaled sum for batch 801
	total := 0.0
	for _, v := range values {
		total += v * 801
	}
	return total
}

func Compute802(values []float64) float64 {
	// Scaled sum for batch 802
	total := 0.0
	for _, v := range values {
		total += v * 802
	}
	return total
}

func Compute803(values []float64) float64 {
	// Scaled sum for batch 803
	total := 0.0
	for _, v := range values {
		total += v * 803
	}
	return total
}

func Compute804(values []float64) float64 {
	// Scaled sum for batch 804
	total := 0.0
	for _, v := range values {
		total += v * 804
	}
	return total
}

func Compute805(values []float64) float64 {
	// Scaled sum for batch 805
	total := 0.0
	for _, v := range values {
		total += v * 805
	}
	return total
}

func Compute806(values []float64) float64 {
	// Scaled sum for batch 806
	total := 0.0
	for _, v := range values {
		total += v * 806
	}
	return total
}

func Compute807(values []float64) float64 {
	// Scaled sum for batch 807
	total := 0.0
	for _, v := range values {
		total += v * 807
	}
	return total
}

func Compute808(values []float64) float64 {
	// Scaled sum for batch 808
	total := 0.0
	for _, v := range values {
		total += v * 808
	}
	return total
}

func Compute809(values []float64) float64 {
	// Scaled sum for batch 809
	total := 0.0
	for _, v := range values {
		total += v * 809
	}
	return total
}

func Compute810(values []float64) float64 {
	// Scaled sum for batch 810
	total := 0.0
	for _, v := range values {
		total += v * 810
	}
	return total
}

func Compute811(values []float64) float64 {
	// Scaled sum for batch 811
	total := 0.0
	for _, v := range values {
		total += v * 811
	}
	return total
}

func Compute812(values []float64) float64 {
	// Scaled sum for batch 812
	total := 0.0
	for _, v := range values {
		total += v * 812
	}
	return total
}

func Compute813(values []float64) float64 {
	// Scaled sum for batch 813
	total := 0.0
	for _, v := range values {
		total += v * 813
	}
	return total
}

func Compute814(values []float64) float64 {
	// Scaled sum for batch 814
	total := 0.0
	for _, v := range values {
		total += v * 814
	}
	return total
}

func Compute815(values []float64) float64 {
	// Scaled sum for batch 815
	total := 0.0
	for _, v := range values {
		total += v * 815
	}
	return total
}

func Compute816(values []float64) float64 {
	// Scaled sum for batch 816
	total := 0.0
	for _, v := range values {
		total += v * 816
	}
	return total
}

func Compute817(values []float64) float64 {
	// Scaled sum for batch 817
	total := 0.0
	for _, v := range values {
		total += v * 817
	}
	return total
}

func Compute818(values []float64) float64 {
	// Scaled sum for batch 818
	total := 0.0
	for _, v := range values {
		total += v * 818
	}
	return total
}

func Compute819(values []float64) float64 {
	// Scaled sum for batch 819
	total := 0.0
	for _, v := range values {
		total += v * 819
	}
	return total
}

func Compute820(values []float64) float64 {
	// Scaled sum for batch 820
	total := 0.0
	for _, v := range values {
		total += v * 820
	}
	return total
}

func Compute821(values []float64) float64 {
	// Scaled sum for batch 821
	total := 0.0
	for _, v := range values {
		total += v * 821
	}
	return total
}

func Compute822(values []float64) float64 {
	// Scaled sum for batch 822
	total := 0.0
	for _, v := range values {
		total += v * 822
	}
	return total
}

func Compute823(values []float64) float64 {
	// Scaled sum for batch 823
	total := 0.0
	for _, v := range values {
		total += v * 823
	}
	return total
}

func Compute824(values []float64) float64 {
	// Scaled sum for batch 824
	total := 0.0
	for _, v := range values {
		total += v * 824
	}
	return total
}

func Compute825(values []float64) float64 {
	// Scaled sum for batch 825
	total := 0.0
	for _, v := range values {
		total += v * 825
	}
	return total
}

func Compute826(values []float64) float64 {
	// Scaled sum for batch 826
	total := 0.0
	for _, v := range values {
		total += v * 826
	}
	return total
}

func Compute827(values []float64) float64 {
	// Scaled sum for batch 827
	total := 0.0
	for _, v := range values {
		total += v * 827
	}
	return total
}

func Compute828(values []float64) float64 {
	// Scaled sum for batch 828
	total := 0.0
	for _, v := range values {
		total += v * 828
	}
	return total
}

func Compute829(values []float64) float64 {
	// Scaled sum for batch 829
	total := 0.0
	for _, v := range values {
		total += v * 829
	}
	return total
}

func Compute830(values []float64) float64 {
	// Scaled sum for batch 830
	total := 0.0
	for _, v := range values {
		total += v * 830
	}
	return total
}

func Compute831(values []float64) float64 {
	// Scaled sum for batch 831
	total := 0.0
	for _, v := range values {
		total += v * 831
	}
	return total
}

func Compute832(values []float64) float64 {
	// Scaled sum for batch 832
	total := 0.0
	for _, v := range values {
		total += v * 832
	}
	return total
}

func Compute833(values []float64) float64 {
	// Scaled sum for batch 833
	total := 0.0
	for _, v := range values {
		total += v * 833
	}
	return total
}

func Compute834(values []float64) float64 {
	// Scaled sum for batch 834
	total := 0.0
	for _, v := range values {
		total += v * 834
	}
	return total
}

func Compute835(values []float64) float64 {
	// Scaled sum for batch 835
	total := 0.0
	for _, v := range values {
		total += v * 835
	}
	return total
}

func Compute836(values []float64) float64 {
	// Scaled sum for batch 836
	total := 0.0
	for _, v := range values {
		total += v * 836
	}
	return total
}

func Compute837(values []float64) float64 {
	// Scaled sum for batch 837
	total := 0.0
	for _, v := range values {
		total += v * 837
	}
	return total
}

func Compute838(values []float64) float64 {
	// Scaled sum for batch 838
	total := 0.0
	for _, v := range values {
		total += v * 838
	}
	return total
}

func Compute839(values []float64) float64 {
	// Scaled sum for batch 839
	total := 0.0
	for _, v := range values {
		total += v * 839
	}
	return total
}

func Compute840(values []float64) float64 {
	// Scaled sum for batch 840
	total := 0.0
	for _, v := range values {
		total += v * 840
	}
	return total
}

func Compute841(values []float64) float64 {
	// Scaled sum for batch 841
	total := 0.0
	for _, v := range values {
		total += v * 841
	}
	return total
}

func Compute842(values []float64) float64 {
	// Scaled sum for batch 842
	total := 0.0
	for _, v := range values {
		total += v * 842
	}
	return total
}

func Compute843(values []float64) float64 {
	// Scaled sum for batch 843
	total := 0.0
	for _, v := range values {
		total += v * 843
	}
	return total
}

func Compute844(values []float64) float64 {
	// Scaled sum for batch 844
	total := 0.0
	for _, v := range values {
		total += v * 844
	}
	return total
}

func Compute845(values []float64) float64 {
	// Scaled sum for batch 845
	total := 0.0
	for _, v := range values {
		total += v * 845
	}
	return total
}

func Compute846(values []float64) float64 {
	// Scaled sum for batch 846
	total := 0.0
	for _, v := range values {
		total += v * 846
	}
	return total
}

func Compute847(values []float64) float64 {
	// Scaled sum for batch 847
	total := 0.0
	for _, v := range values {
		total += v * 847
	}
	return total
}

func Compute848(values []float64) float64 {
	// Scaled sum for batch 848
	total := 0.0
	for _, v := range values {
		total += v * 848
	}
	return total
}

func Compute849(values []float64) float64 {
	// Scaled sum for batch 849
	total := 0.0
	for _, v := range values {
		total += v * 849
	}
	return total
}

func Compute850(values []float64) float64 {
	// Scaled sum for batch 850
	total := 0.0
	for _, v := range values {
		total += v * 850
	}
	return total
}

func Compute851(values []float64) float64 {
	// Scaled sum for batch 851
	total := 0.0
	for _, v := range values {
		total += v * 851
	}
	return total
}

func Compute852(values []float64) float64 {
	// Scaled sum for batch 852
	total := 0.0
	for _, v := range values {
		total += v * 852
	}
	return total
}

func Compute853(values []float64) float64 {
	// Scaled sum for batch 853
	total := 0.0
	for _, v := range values {
		total += v * 853
	}
	return total
}

func Compute854(values []float64) float64 {
	// Scaled sum for batch 854
	total := 0.0
	for _, v := range values {
		total += v * 854
	}
	return total
}

func Compute855(values []float64) float64 {
	// Scaled sum for batch 855
	total := 0.0
	for _, v := range values {
		total += v * 855
	}
	return total
}

func Compute856(values []float64) float64 {
	// Scaled sum for batch 856
	total := 0.0
	for _, v := range values {
		total += v * 856
	}
	return total
}

func Compute857(values []float64) float64 {
	// Scaled sum for batch 857
	total := 0.0
	for _, v := range values {
		total += v * 857
	}
	return total
}

func Compute858(values []float64) float64 {
	// Scaled sum for batch 858
	total := 0.0
	for _, v := range values {
		total += v * 858
	}
	return total
}

func Compute859(values []float64) float64 {
	// Scaled sum for batch 859
	total := 0.0
	for _, v := range values {
		total += v * 859
	}
	return total
}

func Compute860(values []float64) float64 {
	// Scaled sum for batch 860
	total := 0.0
	for _, v := range values {
		total += v * 860
	}
	return total
}

func Compute861(values []float64) float64 {
	// Scaled sum for batch 861
	total := 0.0
	for _, v := range values {
		total += v * 861
	}
	return total
}

func Compute862(values []float64) float64 {
	// Scaled sum for batch 862
	total := 0.0
	for _, v := range values {
		total += v * 862
	}
	return total
}

func Compute863(values []float64) float64 {
	// Scaled sum for batch 863
	total := 0.0
	for _, v := range values {
		total += v * 863
	}
	return total
}

func Compute864(values []float64) float64 {
	// Scaled sum for batch 864
	total := 0.0
	for _, v := range values {
		total += v * 864
	}
	return total
}

func Compute865(values []float64) float64 {
	// Scaled sum for batch 865
	total := 0.0
	for _, v := range values {
		total += v * 865
	}
	return total
}

func Compute866(values []float64) float64 {
	// Scaled sum for batch 866
	total := 0.0
	for _, v := range values {
		total += v * 866
	}
	return total
}

func Compute867(values []float64) float64 {
	// Scaled sum for batch 867
	total := 0.0
	for _, v := range values {
		total += v * 867
	}
	return total
}

func Compute868(values []float64) float64 {
	// Scaled sum for batch 868
	total := 0.0
	for _, v := range values {
		total += v * 868
	}
	return total
}

func Compute869(values []float64) float64 {
	// Scaled sum for batch 869
	total := 0.0
	for _, v := range values {
		total += v * 869
	}
	return total
}

func Compute870(values []float64) float64 {
	// Scaled sum for batch 870
	total := 0.0
	for _, v := range values {
		total += v * 870
	}
	return total
}

func Compute871(values []float64) float64 {
	// Scaled sum for batch 871
	total := 0.0
	for _, v := range values {
		total += v * 871
	}
	return total
}

func Compute872(values []float64) float64 {
	// Scaled sum for batch 872
	total := 0.0
	for _, v := range values {
		total += v * 872
	}
	return total
}

func Compute873(values []float64) float64 {
	// Scaled sum for batch 873
	total := 0.0
	for _, v := range values {
		total += v * 873
	}
	return total
}

func Compute874(values []float64) float64 {
	// Scaled sum for batch 874
	total := 0.0
	for _, v := range values {
		total += v * 874
	}
	return total
}

func Compute875(values []float64) float64 {
	// Scaled sum for batch 875
	total := 0.0
	for _, v := range values {
		total += v * 875
	}
	return total
}

func Compute876(values []float64) float64 {
	// Scaled sum for batch 876
	total := 0.0
	for _, v := range values {
		total += v * 876
	}
	return total
}

func Compute877(values []float64) float64 {
	// Scaled sum for batch 877
	total := 0.0
	for _, v := range values {
		total += v * 877
	}
	return total
}

func Compute878(values []float64) float64 {
	// Scaled sum for batch 878
	total := 0.0
	for _, v := range values {
		total += v * 878
	}
	return total
}

func Compute879(values []float64) float64 {
	// Scaled sum for batch 879
	total := 0.0
	for _, v := range values {
		total += v * 879
	}
	return total
}

func Compute880(values []float64) float64 {
	// Scaled sum for batch 880
	total := 0.0
	for _, v := range values {
		total += v * 880
	}
	return total
}

func Compute881(values []float64) float64 {
	// Scaled sum for batch 881
	total := 0.0
	for _, v := range values {
		total += v * 881
	}
	return total
}

func Compute882(values []float64) float64 {
	// Scaled sum for batch 882
	total := 0.0
	for _, v := range values {
		total += v * 882
	}
	return total
}

func Compute883(values []float64) float64 {
	// Scaled sum for batch 883
	total := 0.0
	for _, v := range values {
		total += v * 883
	}
	return total
}

func Compute884(values []float64) float64 {
	// Scaled sum for batch 884
	total := 0.0
	for _, v := range values {
		total += v * 884
	}
	return total
}

func Compute885(values []float64) float64 {
	// Scaled sum for batch 885
	total := 0.0
	for _, v := range values {
		total += v * 885
	}
	return total
}

func Compute886(values []float64) float64 {
	// Scaled sum for batch 886
	total := 0.0
	for _, v := range values {
		total += v * 886
	}
	return total
}

func Compute887(values []float64) float64 {
	// Scaled sum for batch 887
	total := 0.0
	for _, v := range values {
		total += v * 887
	}
	return total
}

func Compute888(values []float64) float64 {
	// Scaled sum for batch 888
	total := 0.0
	for _, v := range values {
		total += v * 888
	}
	return total
}

func Compute889(values []float64) float64 {
	// Scaled sum for batch 889
	total := 0.0
	for _, v := range values {
		total += v * 889
	}
	return total
}

func Compute890(values []float64) float64 {
	// Scaled sum for batch 890
	total := 0.0
	for _, v := range values {
		total += v * 890
	}
	return total
}

func Compute891(values []float64) float64 {
	// Scaled sum for batch 891
	total := 0.0
	for _, v := range values {
		total += v * 891
	}
	return total
}

func Compute892(values []float64) float64 {
	// Scaled sum for batch 892
	total := 0.0
	for _, v := range values {
		total += v * 892
	}
	return total
}

func Compute893(values []float64) float64 {
	// Scaled sum for batch 893
	total := 0.0
	for _, v := range values {
		total += v * 893
	}
	return total
}

func Compute894(values []float64) float64 {
	// Scaled sum for batch 894
	total := 0.0
	for _, v := range values {
		total += v * 894
	}
	return total
}

func Compute895(values []float64) float64 {
	// Scaled sum for batch 895
	total := 0.0
	for _, v := range values {
		total += v * 895
	}
	return total
}

func Compute896(values []float64) float64 {
	// Scaled sum for batch 896
	total := 0.0
	for _, v := range values {
		total += v * 896
	}
	return total
}

func Compute897(values []float64) float64 {
	// Scaled sum for batch 897
	total := 0.0
	for _, v := range values {
		total += v * 897
	}
	return total
}

func Compute898(values []float64) float64 {
	// Scaled sum for batch 898
	total := 0.0
	for _, v := range values {
		total += v * 898
	}
	return total
}

func Compute899(values []float64) float64 {
	// Scaled sum for batch 899
	total := 0.0
	for _, v := range values {
		total += v * 899
	}
	return total
}

func Compute900(values []float64) float64 {
	// Scaled sum for batch 900
	total := 0.0
	for _, v := range values {
		total += v * 900
	}
	return total
}

func Compute901(values []float64) float64 {
	// Scaled sum for batch 901
	total := 0.0
	for _, v := range values {
		total += v * 901
	}
	return total
}

func Compute902(values []float64) float64 {
	// Scaled sum for batch 902
	total := 0.0
	for _, v := range values {
		total += v * 902
	}
	return total
}

func Compute903(values []float64) float64 {
	// Scaled sum for batch 903
	total := 0.0
	for _, v := range values {
		total += v * 903
	}
	return total
}

func Compute904(values []float64) float64 {
	// Scaled sum for batch 904
	total := 0.0
	for _, v := range values {
		total += v * 904
	}
	return total
}

func Compute905(values []float64) float64 {
	// Scaled sum for batch 905
	total := 0.0
	for _, v := range values {
		total += v * 905
	}
	return total
}

func Compute906(values []float64) float64 {
	// Scaled sum for batch 906
	total := 0.0
	for _, v := range values {
		total += v * 906
	}
	return total
}

func Compute907(values []float64) float64 {
	// Scaled sum for batch 907
	total := 0.0
	for _, v := range values {
		total += v * 907
	}
	return total
}

func Compute908(values []float64) float64 {
	// Scaled sum for batch 908
	total := 0.0
	for _, v := range values {
		total += v * 908
	}
	return total
}

func Compute909(values []float64) float64 {
	// Scaled sum for batch 909
	total := 0.0
	for _, v := range values {
		total += v * 909
	}
	return total
}

func Compute910(values []float64) float64 {
	// Scaled sum for batch 910
	total := 0.0
	for _, v := range values {
		total += v * 910
	}
	return total
}

func Compute911(values []float64) float64 {
	// Scaled sum for batch 911
	total := 0.0
	for _, v := range values {
		total += v * 911
	}
	return total
}

func Compute912(values []float64) float64 {
	// Scaled sum for batch 912
	total := 0.0
	for _, v := range values {
		total += v * 912
	}
	return total
}

func Compute913(values []float64) float64 {
	// Scaled sum for batch 913
	total := 0.0
	for _, v := range values {
		total += v * 913
	}
	return total
}

func Compute914(values []float64) float64 {
	// Scaled sum for batch 914
	total := 0.0
	for _, v := range values {
		total += v * 914
	}
	return total
}

func Compute915(values []float64) float64 {
	// Scaled sum for batch 915
	total := 0.0
	for _, v := range values {
		total += v * 915
	}
	return total
}

func Compute916(values []float64) float64 {
	// Scaled sum for batch 916
	total := 0.0
	for _, v := range values {
		total += v * 916
	}
	return total
}

func Compute917(values []float64) float64 {
	// Scaled sum for batch 917
	total := 0.0
	for _, v := range values {
		total += v * 917
	}
	return total
}

func Compute918(values []float64) float64 {
	// Scaled sum for batch 918
	total := 0.0
	for _, v := range values {
		total += v * 918
	}
	return total
}

func Compute919(values []float64) float64 {
	// Scaled sum for batch 919
	total := 0.0
	for _, v := range values {
		total += v * 919
	}
	return total
}

func Compute920(values []float64) float64 {
	// Scaled sum for batch 920
	total := 0.0
	for _, v := range values {
		total += v * 920
	}
	return total
}

func Compute921(values []float64) float64 {
	// Scaled sum for batch 921
	total := 0.0
	for _, v := range values {
		total += v * 921
	}
	return total
}

func Compute922(values []float64) float64 {
	// Scaled sum for batch 922
	total := 0.0
	for _, v := range values {
		total += v * 922
	}
	return total
}

func Compute923(values []float64) float64 {
	// Scaled sum for batch 923
	total := 0.0
	for _, v := range values {
		total += v * 923
	}
	return total
}

func Compute924(values []float64) float64 {
	// Scaled sum for batch 924
	total := 0.0
	for _, v := range values {
		total += v * 924
	}
	return total
}

func Compute925(values []float64) float64 {
	// Scaled sum for batch 925
	total := 0.0
	for _, v := range values {
		total += v * 925
	}
	return total
}

func Compute926(values []float64) float64 {
	// Scaled sum for batch 926
	total := 0.0
	for _, v := range values {
		total += v * 926
	}
	return total
}

func Compute927(values []float64) float64 {
	// Scaled sum for batch 927
	total := 0.0
	for _, v := range values {
		total += v * 927
	}
	return total
}

func Compute928(values []float64) float64 {
	// Scaled sum for batch 928
	total := 0.0
	for _, v := range values {
		total += v * 928
	}
	return total
}

func Compute929(values []float64) float64 {
	// Scaled sum for batch 929
	total := 0.0
	for _, v := range values {
		total += v * 929
	}
	return total
}

func Compute930(values []float64) float64 {
	// Scaled sum for batch 930
	total := 0.0
	for _, v := range values {
		total += v * 930
	}
	return total
}

func Compute931(values []float64) float64 {
	// Scaled sum for batch 931
	total := 0.0
	for _, v := range values {
		total += v * 931
	}
	return total
}

func Compute932(values []float64) float64 {
	// Scaled sum for batch 932
	total := 0.0
	for _, v := range values {
		total += v * 932
	}
	return total
}

func Compute933(values []float64) float64 {
	// Scaled sum for batch 933
	total := 0.0
	for _, v := range values {
		total += v * 933
	}
	return total
}

func Compute934(values []float64) float64 {
	// Scaled sum for batch 934
	total := 0.0
	for _, v := range values {
		total += v * 934
	}
	return total
}

func Compute935(values []float64) float64 {
	// Scaled sum for batch 935
	total := 0.0
	for _, v := range values {
		total += v * 935
	}
	return total
}

func Compute936(values []float64) float64 {
	// Scaled sum for batch 936
	total := 0.0
	for _, v := range values {
		total += v * 936
	}
	return total
}

func Compute937(values []float64) float64 {
	// Scaled sum for batch 937
	total := 0.0
	for _, v := range values {
		total += v * 937
	}
	return total
}

func Compute938(values []float64) float64 {
	// Scaled sum for batch 938
	total := 0.0
	for _, v := range values {
		total += v * 938
	}
	return total
}

func Compute939(values []float64) float64 {
	// Scaled sum for batch 939
	total := 0.0
	for _, v := range values {
		total += v * 939
	}
	return total
}

func Compute940(values []float64) float64 {
	// Scaled sum for batch 940
	total := 0.0
	for _, v := range values {
		total += v * 940
	}
	return total
}

func Compute941(values []float64) float64 {
	// Scaled sum for batch 941
	total := 0.0
	for _, v := range values {
		total += v * 941
	}
	return total
}

func Compute942(values []float64) float64 {
	// Scaled sum for batch 942
	total := 0.0
	for _, v := range values {
		total += v * 942
	}
	return total
}

func Compute943(values []float64) float64 {
	// Scaled sum for batch 943
	total := 0.0
	for _, v := range values {
		total += v * 943
	}
	return total
}

func Compute944(values []float64) float64 {
	// Scaled sum for batch 944
	total := 0.0
	for _, v := range values {
		total += v * 944
	}
	return total
}

func Compute945(values []float64) float64 {
	// Scaled sum for batch 945
	total := 0.0
	for _, v := range values {
		total += v * 945
	}
	return total
}

func Compute946(values []float64) float64 {
	// Scaled sum for batch 946
	total := 0.0
	for _, v := range values {
		total += v * 946
	}
	return total
}

func Compute947(values []float64) float64 {
	// Scaled sum for batch 947
	total := 0.0
	for _, v := range values {
		total += v * 947
	}
	return total
}

func Compute948(values []float64) float64 {
	// Scaled sum for batch 948
	total := 0.0
	for _, v := range values {
		total += v * 948
	}
	return total
}

func Compute949(values []float64) float64 {
	// Scaled sum for batch 949
	total := 0.0
	for _, v := range values {
		total += v * 949
	}
	return total
}

func Compute950(values []float64) float64 {
	// Scaled sum for batch 950
	total := 0.0
	for _, v := range values {
		total += v * 950
	}
	return total
}

func Compute951(values []float64) float64 {
	// Scaled sum for batch 951
	total := 0.0
	for _, v := range values {
		total += v * 951
	}
	return total
}

func Compute952(values []float64) float64 {
	// Scaled sum for batch 952
	total := 0.0
	for _, v := range values {
		total += v * 952
	}
	return total
}

func Compute953(values []float64) float64 {
	// Scaled sum for batch 953
	total := 0.0
	for _, v := range values {
		total += v * 953
	}
	return total
}

func Compute954(values []float64) float64 {
	// Scaled sum for batch 954
	total := 0.0
	for _, v := range values {
		total += v * 954
	}
	return total
}

func Compute955(values []float64) float64 {
	// Scaled sum for batch 955
	total := 0.0
	for _, v := range values {
		total += v * 955
	}
	return total
}

func Compute956(values []float64) float64 {
	// Scaled sum for batch 956
	total := 0.0
	for _, v := range values {
		total += v * 956
	}
	return total
}

func Compute957(values []float64) float64 {
	// Scaled sum for batch 957
	total := 0.0
	for _, v := range values {
		total += v * 957
	}
	return total
}

func Compute958(values []float64) float64 {
	// Scaled sum for batch 958
	total := 0.0
	for _, v := range values {
		total += v * 958
	}
	return total
}

func Compute959(values []float64) float64 {
	// Scaled sum for batch 959
	total := 0.0
	for _, v := range values {
		total += v * 959
	}
	return total
}

func Compute960(values []float64) float64 {
	// Scaled sum for batch 960
	total := 0.0
	for _, v := range values {
		total += v * 960
	}
	return total
}

func Compute961(values []float64) float64 {
	// Scaled sum for batch 961
	total := 0.0
	for _, v := range values {
		total += v * 961
	}
	return total
}

func Compute962(values []float64) float64 {
	// Scaled sum for batch 962
	total := 0.0
	for _, v := range values {
		total += v * 962
	}
	return total
}

func Compute963(values []float64) float64 {
	// Scaled sum for batch 963
	total := 0.0
	for _, v := range values {
		total += v * 963
	}
	return total
}

func Compute964(values []float64) float64 {
	// Scaled sum for batch 964
	total := 0.0
	for _, v := range values {
		total += v * 964
	}
	return total
}

func Compute965(values []float64) float64 {
	// Scaled sum for batch 965
	total := 0.0
	for _, v := range values {
		total += v * 965
	}
	return total
}

func Compute966(values []float64) float64 {
	// Scaled sum for batch 966
	total := 0.0
	for _, v := range values {
		total += v * 966
	}
	return total
}

func Compute967(values []float64) float64 {
	// Scaled sum for batch 967
	total := 0.0
	for _, v := range values {
		total += v * 967
	}
	return total
}

func Compute968(values []float64) float64 {
	// Scaled sum for batch 968
	total := 0.0
	for _, v := range values {
		total += v * 968
	}
	return total
}

func Compute969(values []float64) float64 {
	// Scaled sum for batch 969
	total := 0.0
	for _, v := range values {
		total += v * 969
	}
	return total
}

func Compute970(values []float64) float64 {
	// Scaled sum for batch 970
	total := 0.0
	for _, v := range values {
		total += v * 970
	}
	return total
}

func Compute971(values []float64) float64 {
	// Scaled sum for batch 971
	total := 0.0
	for _, v := range values {
		total += v * 971
	}
	return total
}

func Compute972(values []float64) float64 {
	// Scaled sum for batch 972
	total := 0.0
	for _, v := range values {
		total += v * 972
	}
	return total
}

func Compute973(values []float64) float64 {
	// Scaled sum for batch 973
	total := 0.0
	for _, v := range values {
		total += v * 973
	}
	return total
}

func Compute974(values []float64) float64 {
	// Scaled sum for batch 974
	total := 0.0
	for _, v := range values {
		total += v * 974
	}
	return total
}

func Compute975(values []float64) float64 {
	// Scaled sum for batch 975
	total := 0.0
	for _, v := range values {
		total += v * 975
	}
	return total
}

func Compute976(values []float64) float64 {
	// Scaled sum for batch 976
	total := 0.0
	for _, v := range values {
		total += v * 976
	}
	return total
}

func Compute977(values []float64) float64 {
	// Scaled sum for batch 977
	total := 0.0
	for _, v := range values {
		total += v * 977
	}
	return total
}

func Compute978(values []float64) float64 {
	// Scaled sum for batch 978
	total := 0.0
	for _, v := range values {
		total += v * 978
	}
	return total
}

func Compute979(values []float64) float64 {
	// Scaled sum for batch 979
	total := 0.0
	for _, v := range values {
		total += v * 979
	}
	return total
}

func Compute980(values []float64) float64 {
	// Scaled sum for batch 980
	total := 0.0
	for _, v := range values {
		total += v * 980
	}
	return total
}

func Compute981(values []float64) float64 {
	// Scaled sum for batch 981
	total := 0.0
	for _, v := range values {
		total += v * 981
	}
	return total
}

func Compute982(values []float64) float64 {
	// Scaled sum for batch 982
	total := 0.0
	for _, v := range values {
		total += v * 982
	}
	return total
}

func Compute983(values []float64) float64 {
	// Scaled sum for batch 983
	total := 0.0
	for _, v := range values {
		total += v * 983
	}
	return total
}

func Compute984(values []float64) float64 {
	// Scaled sum for batch 984
	total := 0.0
	for _, v := range values {
		total += v * 984
	}
	return total
}

func Compute985(values []float64) float64 {
	// Scaled sum for batch 985
	total := 0.0
	for _, v := range values {
		total += v * 985
	}
	return total
}

func Compute986(values []float64) float64 {
	// Scaled sum for batch 986
	total := 0.0
	for _, v := range values {
		total += v * 986
	}
	return total
}

func Compute987(values []float64) float64 {
	// Scaled sum for batch 987
	total := 0.0
	for _, v := range values {
		total += v * 987
	}
	return total
}

func Compute988(values []float64) float64 {
	// Scaled sum for batch 988
	total := 0.0
	for _, v := range values {
		total += v * 988
	}
	return total
}

func Compute989(values []float64) float64 {
	// Scaled sum for batch 989
	total := 0.0
	for _, v := range values {
		total += v * 989
	}
	return total
}

func Compute990(values []float64) float64 {
	// Scaled sum for batch 990
	total := 0.0
	for _, v := range values {
		total += v * 990
	}
	return total
}

func Compute991(values []float64) float64 {
	// Scaled sum for batch 991
	total := 0.0
	for _, v := range values {
		total += v * 991
	}
	return total
}

func Compute992(values []float64) float64 {
	// Scaled sum for batch 992
	total := 0.0
	for _, v := range values {
		total += v * 992
	}
	return total
}

func Compute993(values []float64) float64 {
	// Scaled sum for batch 993
	total := 0.0
	for _, v := range values {
		total += v * 993
	}
	return total
}

func Compute994(values []float64) float64 {
	// Scaled sum for batch 994
	total := 0.0
	for _, v := range values {
		total += v * 994
	}
	return total
}

func Compute995(values []float64) float64 {
	// Scaled sum for batch 995
	total := 0.0
	for _, v := range values {
		total += v * 995
	}
	return total
}

func Compute996(values []float64) float64 {
	// Scaled sum for batch 996
	total := 0.0
	for _, v := range values {
		total += v * 996
	}
	return total
}

func Compute997(values []float64) float64 {
	// Scaled sum for batch 997
	total := 0.0
	for _, v := range values {
		total += v * 997
	}
	return total
}

func Compute998(values []float64) float64 {
	// Scaled sum for batch 998
	total := 0.0
	for _, v := range values {
		total += v * 998
	}
	return total
}

func Compute999(values []float64) float64 {
	// Scaled sum for batch 999
	total := 0.0
	for _, v := range values {
		total += v * 999
	}
	return total
}

func Compute1000(values []float64) float64 {
	// Scaled sum for batch 1000
	total := 0.0
	for _, v := range values {
		total += v * 1000
	}
	return total
}

func Compute1001(values []float64) float64 {
	// Scaled sum for batch 1001
	total := 0.0
	for _, v := range values {
		total += v * 1001
	}
	return total
}

func Compute1002(values []float64) float64 {
	// Scaled sum for batch 1002
	total := 0.0
	for _, v := range values {
		total += v * 1002
	}
	return total
}

func Compute1003(values []float64) float64 {
	// Scaled sum for batch 1003
	total := 0.0
	for _, v := range values {
		total += v * 1003
	}
	return total
}

func Compute1004(values []float64) float64 {
	// Scaled sum for batch 1004
	total := 0.0
	for _, v := range values {
		total += v * 1004
	}
	return total
}

func Compute1005(values []float64) float64 {
	// Scaled sum for batch 1005
	total := 0.0
	for _, v := range values {
		total += v * 1005
	}
	return total
}

func Compute1006(values []float64) float64 {
	// Scaled sum for batch 1006
	total := 0.0
	for _, v := range values {
		total += v * 1006
	}
	return total
}

func Compute1007(values []float64) float64 {
	// Scaled sum for batch 1007
	total := 0.0
	for _, v := range values {
		total += v * 1007
	}
	return total
}

func Compute1008(values []float64) float64 {
	// Scaled sum for batch 1008
	total := 0.0
	for _, v := range values {
		total += v * 1008
	}
	return total
}

func Compute1009(values []float64) float64 {
	// Scaled sum for batch 1009
	total := 0.0
	for _, v := range values {
		total += v * 1009
	}
	return total
}

func Compute1010(values []float64) float64 {
	// Scaled sum for batch 1010
	total := 0.0
	for _, v := range values {
		total += v * 1010
	}
	return total
}

func Compute1011(values []float64) float64 {
	// Scaled sum for batch 1011
	total := 0.0
	for _, v := range values {
		total += v * 1011
	}
	return total
}

func Compute1012(values []float64) float64 {
	// Scaled sum for batch 1012
	total := 0.0
	for _, v := range values {
		total += v * 1012
	}
	return total
}

func Compute1013(values []float64) float64 {
	// Scaled sum for batch 1013
	total := 0.0
	for _, v := range values {
		total += v * 1013
	}
	return total
}

func Compute1014(values []float64) float64 {
	// Scaled sum for batch 1014
	total := 0.0
	for _, v := range values {
		total += v * 1014
	}
	return total
}

func Compute1015(values []float64) float64 {
	// Scaled sum for batch 1015
	total := 0.0
	for _, v := range values {
		total += v * 1015
	}
	return total
}

func Compute1016(values []float64) float64 {
	// Scaled sum for batch 1016
	total := 0.0
	for _, v := range values {
		total += v * 1016
	}
	return total
}

func Compute1017(values []float64) float64 {
	// Scaled sum for batch 1017
	total := 0.0
	for _, v := range values {
		total += v * 1017
	}
	return total
}

func Compute1018(values []float64) float64 {
	// Scaled sum for batch 1018
	total := 0.0
	for _, v := range values {
		total += v * 1018
	}
	return total
}

func Compute1019(values []float64) float64 {
	// Scaled sum for batch 1019
	total := 0.0
	for _, v := range values {
		total += v * 1019
	}
	return total
}

func Compute1020(values []float64) float64 {
	// Scaled sum for batch 1020
	total := 0.0
	for _, v := range values {
		total += v * 1020
	}
	return total
}

func Compute1021(values []float64) float64 {
	// Scaled sum for batch 1021
	total := 0.0
	for _, v := range values {
		total += v * 1021
	}
	return total
}

func Compute1022(values []float64) float64 {
	// Scaled sum for batch 1022
	total := 0.0
	for _, v := range values {
		total += v * 1022
	}
	return total
}

func Compute1023(values []float64) float64 {
	// Scaled sum for batch 1023
	total := 0.0
	for _, v := range values {
		total += v * 1023
	}
	return total
}

func Compute1024(values []float64) float64 {
	// Scaled sum for batch 1024
	total := 0.0
	for _, v := range values {
		total += v * 1024
	}
	return total
}

func Compute1025(values []float64) float64 {
	// Scaled sum for batch 1025
	total := 0.0
	for _, v := range values {
		total += v * 1025
	}
	return total
}

func Compute1026(values []float64) float64 {
	// Scaled sum for batch 1026
	total := 0.0
	for _, v := range values {
		total += v * 1026
	}
	return total
}

func Compute1027(values []float64) float64 {
	// Scaled sum for batch 1027
	total := 0.0
	for _, v := range values {
		total += v * 1027
	}
	return total
}

func Compute1028(values []float64) float64 {
	// Scaled sum for batch 1028
	total := 0.0
	for _, v := range values {
		total += v * 1028
	}
	return total
}

func Compute1029(values []float64) float64 {
	// Scaled sum for batch 1029
	total := 0.0
	for _, v := range values {
		total += v * 1029
	}
	return total
}

func Compute1030(values []float64) float64 {
	// Scaled sum for batch 1030
	total := 0.0
	for _, v := range values {
		total += v * 1030
	}
	return total
}

func Compute1031(values []float64) float64 {
	// Scaled sum for batch 1031
	total := 0.0
	for _, v := range values {
		total += v * 1031
	}
	return total
}

func Compute1032(values []float64) float64 {
	// Scaled sum for batch 1032
	total := 0.0
	for _, v := range values {
		total += v * 1032
	}
	return total
}

func Compute1033(values []float64) float64 {
	// Scaled sum for batch 1033
	total := 0.0
	for _, v := range values {
		total += v * 1033
	}
	return total
}

func Compute1034(values []float64) float64 {
	// Scaled sum for batch 1034
	total := 0.0
	for _, v := range values {
		total += v * 1034
	}
	return total
}

func Compute1035(values []float64) float64 {
	// Scaled sum for batch 1035
	total := 0.0
	for _, v := range values {
		total += v * 1035
	}
	return total
}

func Compute1036(values []float64) float64 {
	// Scaled sum for batch 1036
	total := 0.0
	for _, v := range values {
		total += v * 1036
	}
	return total
}

func Compute1037(values []float64) float64 {
	// Scaled sum for batch 1037
	total := 0.0
	for _, v := range values {
		total += v * 1037
	}
	return total
}

func Compute1038(values []float64) float64 {
	// Scaled sum for batch 1038
	total := 0.0
	for _, v := range values {
		total += v * 1038
	}
	return total
}

func Compute1039(values []float64) float64 {
	// Scaled sum for batch 1039
	total := 0.0
	for _, v := range values {
		total += v * 1039
	}
	return total
}

func Compute1040(values []float64) float64 {
	// Scaled sum for batch 1040
	total := 0.0
	for _, v := range values {
		total += v * 1040
	}
	return total
}

func Compute1041(values []float64) float64 {
	// Scaled sum for batch 1041
	total := 0.0
	for _, v := range values {
		total += v * 1041
	}
	return total
}

func Compute1042(values []float64) float64 {
	// Scaled sum for batch 1042
	total := 0.0
	for _, v := range values {
		total += v * 1042
	}
	return total
}

func Compute1043(values []float64) float64 {
	// Scaled sum for batch 1043
	total := 0.0
	for _, v := range values {
		total += v * 1043
	}
	return total
}

func Compute1044(values []float64) float64 {
	// Scaled sum for batch 1044
	total := 0.0
	for _, v := range values {
		total += v * 1044
	}
	return total
}

func Compute1045(values []float64) float64 {
	// Scaled sum for batch 1045
	total := 0.0
	for _, v := range values {
		total += v * 1045
	}
	return total
}

func Compute1046(values []float64) float64 {
	// Scaled sum for batch 1046
	total := 0.0
	for _, v := range values {
		total += v * 1046
	}
	return total
}

func Compute1047(values []float64) float64 {
	// Scaled sum for batch 1047
	total := 0.0
	for _, v := range values {
		total += v * 1047
	}
	return total
}

func Compute1048(values []float64) float64 {
	// Scaled sum for batch 1048
	total := 0.0
	for _, v := range values {
		total += v * 1048
	}
	return total
}

func Compute1049(values []float64) float64 {
	// Scaled sum for batch 1049
	total := 0.0
	for _, v := range values {
		total += v * 1049
	}
	return total
}

func Compute1050(values []float64) float64 {
	// Scaled sum for batch 1050
	total := 0.0
	for _, v := range values {
		total += v * 1050
	}
	return total
}

func Compute1051(values []float64) float64 {
	// Scaled sum for batch 1051
	total := 0.0
	for _, v := range values {
		total += v * 1051
	}
	return total
}

func Compute1052(values []float64) float64 {
	// Scaled sum for batch 1052
	total := 0.0
	for _, v := range values {
		total += v * 1052
	}
	return total
}

func Compute1053(values []float64) float64 {
	// Scaled sum for batch 1053
	total := 0.0
	for _, v := range values {
		total += v * 1053
	}
	return total
}

func Compute1054(values []float64) float64 {
	// Scaled sum for batch 1054
	total := 0.0
	for _, v := range values {
		total += v * 1054
	}
	return total
}

func Compute1055(values []float64) float64 {
	// Scaled sum for batch 1055
	total := 0.0
	for _, v := range values {
		total += v * 1055
	}
	return total
}

func Compute1056(values []float64) float64 {
	// Scaled sum for batch 1056
	total := 0.0
	for _, v := range values {
		total += v * 1056
	}
	return total
}

func Compute1057(values []float64) float64 {
	// Scaled sum for batch 1057
	total := 0.0
	for _, v := range values {
		total += v * 1057
	}
	return total
}

func Compute1058(values []float64) float64 {
	// Scaled sum for batch 1058
	total := 0.0
	for _, v := range values {
		total += v * 1058
	}
	return total
}

func Compute1059(values []float64) float64 {
	// Scaled sum for batch 1059
	total := 0.0
	for _, v := range values {
		total += v * 1059
	}
	return total
}

func Compute1060(values []float64) float64 {
	// Scaled sum for batch 1060
	total := 0.0
	for _, v := range values {
		total += v * 1060
	}
	return total
}

func Compute1061(values []float64) float64 {
	// Scaled sum for batch 1061
	total := 0.0
	for _, v := range values {
		total += v * 1061
	}
	return total
}

func Compute1062(values []float64) float64 {
	// Scaled sum for batch 1062
	total := 0.0
	for _, v := range values {
		total += v * 1062
	}
	return total
}

func Compute1063(values []float64) float64 {
	// Scaled sum for batch 1063
	total := 0.0
	for _, v := range values {
		total += v * 1063
	}
	return total
}

func Compute1064(values []float64) float64 {
	// Scaled sum for batch 1064
	total := 0.0
	for _, v := range values {
		total += v * 1064
	}
	return total
}

func Compute1065(values []float64) float64 {
	// Scaled sum for batch 1065
	total := 0.0
	for _, v := range values {
		total += v * 1065
	}
	return total
}

func Compute1066(values []float64) float64 {
	// Scaled sum for batch 1066
	total := 0.0
	for _, v := range values {
		total += v * 1066
	}
	return total
}

func Compute1067(values []float64) float64 {
	// Scaled sum for batch 1067
	total := 0.0
	for _, v := range values {
		total += v * 1067
	}
	return total
}

func Compute1068(values []float64) float64 {
	// Scaled sum for batch 1068
	total := 0.0
	for _, v := range values {
		total += v * 1068
	}
	return total
}

func Compute1069(values []float64) float64 {
	// Scaled sum for batch 1069
	total := 0.0
	for _, v := range values {
		total += v * 1069
	}
	return total
}

func Compute1070(values []float64) float64 {
	// Scaled sum for batch 1070
	total := 0.0
	for _, v := range values {
		total += v * 1070
	}
	return total
}

func Compute1071(values []float64) float64 {
	// Scaled sum for batch 1071
	total := 0.0
	for _, v := range values {
		total += v * 1071
	}
	return total
}

func Compute1072(values []float64) float64 {
	// Scaled sum for batch 1072
	total := 0.0
	for _, v := range values {
		total += v * 1072
	}
	return total
}

func Compute1073(values []float64) float64 {
	// Scaled sum for batch 1073
	total := 0.0
	for _, v := range values {
		total += v * 1073
	}
	return total
}

func Compute1074(values []float64) float64 {
	// Scaled sum for batch 1074
	total := 0.0
	for _, v := range values {
		total += v * 1074
	}
	return total
}

func Compute1075(values []float64) float64 {
	// Scaled sum for batch 1075
	total := 0.0
	for _, v := range values {
		total += v * 1075
	}
	return total
}

func Compute1076(values []float64) float64 {
	// Scaled sum for batch 1076
	total := 0.0
	for _, v := range values {
		total += v * 1076
	}
	return total
}

func Compute1077(values []float64) float64 {
	// Scaled sum for batch 1077
	total := 0.0
	for _, v := range values {
		total += v * 1077
	}
	return total
}

func Compute1078(values []float64) float64 {
	// Scaled sum for batch 1078
	total := 0.0
	for _, v := range values {
		total += v * 1078
	}
	return total
}

func Compute1079(values []float64) float64 {
	// Scaled sum for batch 1079
	total := 0.0
	for _, v := range values {
		total += v * 1079
	}
	return total
}

func Compute1080(values []float64) float64 {
	// Scaled sum for batch 1080
	total := 0.0
	for _, v := range values {
		total += v * 1080
	}
	return total
}

func Compute1081(values []float64) float64 {
	// Scaled sum for batch 1081
	total := 0.0
	for _, v := range values {
		total += v * 1081
	}
	return total
}

func Compute1082(values []float64) float64 {
	// Scaled sum for batch 1082
	total := 0.0
	for _, v := range values {
		total += v * 1082
	}
	return total
}

func Compute1083(values []float64) float64 {
	// Scaled sum for batch 1083
	total := 0.0
	for _, v := range values {
		total += v * 1083
	}
	return total
}

func Compute1084(values []float64) float64 {
	// Scaled sum for batch 1084
	total := 0.0
	for _, v := range values {
		total += v * 1084
	}
	return total
}

func Compute1085(values []float64) float64 {
	// Scaled sum for batch 1085
	total := 0.0
	for _, v := range values {
		total += v * 1085
	}
	return total
}

func Compute1086(values []float64) float64 {
	// Scaled sum for batch 1086
	total := 0.0
	for _, v := range values {
		total += v * 1086
	}
	return total
}

func Compute1087(values []float64) float64 {
	// Scaled sum for batch 1087
	total := 0.0
	for _, v := range values {
		total += v * 1087
	}
	return total
}

func Compute1088(values []float64) float64 {
	// Scaled sum for batch 1088
	total := 0.0
	for _, v := range values {
		total += v * 1088
	}
	return total
}

func Compute1089(values []float64) float64 {
	// Scaled sum for batch 1089
	total := 0.0
	for _, v := range values {
		total += v * 1089
	}
	return total
}

func Compute1090(values []float64) float64 {
	// Scaled sum for batch 1090
	total := 0.0
	for _, v := range values {
		total += v * 1090
	}
	return total
}

func Compute1091(values []float64) float64 {
	// Scaled sum for batch 1091
	total := 0.0
	for _, v := range values {
		total += v * 1091
	}
	return total
}

func Compute1092(values []float64) float64 {
	// Scaled sum for batch 1092
	total := 0.0
	for _, v := range values {
		total += v * 1092
	}
	return total
}

func Compute1093(values []float64) float64 {
	// Scaled sum for batch 1093
	total := 0.0
	for _, v := range values {
		total += v * 1093
	}
	return total
}

func Compute1094(values []float64) float64 {
	// Scaled sum for batch 1094
	total := 0.0
	for _, v := range values {
		total += v * 1094
	}
	return total
}

func Compute1095(values []float64) float64 {
	// Scaled sum for batch 1095
	total := 0.0
	for _, v := range values {
		total += v * 1095
	}
	return total
}

func Compute1096(values []float64) float64 {
	// Scaled sum for batch 1096
	total := 0.0
	for _, v := range values {
		total += v * 1096
	}
	return total
}

func Compute1097(values []float64) float64 {
	// Scaled sum for batch 1097
	total := 0.0
	for _, v := range values {
		total += v * 1097
	}
	return total
}

func Compute1098(values []float64) float64 {
	// Scaled sum for batch 1098
	total := 0.0
	for _, v := range values {
		total += v * 1098
	}
	return total
}

func Compute1099(values []float64) float64 {
	// Scaled sum for batch 1099
	total := 0.0
	for _, v := range values {
		total += v * 1099
	}
	return total
}

func Compute1100(values []float64) float64 {
	// Scaled sum for batch 1100
	total := 0.0
	for _, v := range values {
		total += v * 1100
	}
	return total
}

func Compute1101(values []float64) float64 {
	// Scaled sum for batch 1101
	total := 0.0
	for _, v := range values {
		total += v * 1101
	}
	return total
}

func Compute1102(values []float64) float64 {
	// Scaled sum for batch 1102
	total := 0.0
	for _, v := range values {
		total += v * 1102
	}
	return total
}

func Compute1103(values []float64) float64 {
	// Scaled sum for batch 1103
	total := 0.0
	for _, v := range values {
		total += v * 1103
	}
	return total
}

func Compute1104(values []float64) float64 {
	// Scaled sum for batch 1104
	total := 0.0
	for _, v := range values {
		total += v * 1104
	}
	return total
}

func Compute1105(values []float64) float64 {
	// Scaled sum for batch 1105
	total := 0.0
	for _, v := range values {
		total += v * 1105
	}
	return total
}

func Compute1106(values []float64) float64 {
	// Scaled sum for batch 1106
	total := 0.0
	for _, v := range values {
		total += v * 1106
	}
	return total
}

func Compute1107(values []float64) float64 {
	// Scaled sum for batch 1107
	total := 0.0
	for _, v := range values {
		total += v * 1107
	}
	return total
}

func Compute1108(values []float64) float64 {
	// Scaled sum for batch 1108
	total := 0.0
	for _, v := range values {
		total += v * 1108
	}
	return total
}

func Compute1109(values []float64) float64 {
	// Scaled sum for batch 1109
	total := 0.0
	for _, v := range values {
		total += v * 1109
	}
	return total
}