"""Generated 10,000-line Python file — samplefiles.com"""


def compute_0(values: list[float]) -> float:
    """Return the scaled sum for batch 0."""
    total = 0.0
    for v in values:
        total += v * 0
    return total


def compute_1(values: list[float]) -> float:
    """Return the scaled sum for batch 1."""
    total = 0.0
    for v in values:
        total += v * 1
    return total


def compute_2(values: list[float]) -> float:
    """Return the scaled sum for batch 2."""
    total = 0.0
    for v in values:
        total += v * 2
    return total


def compute_3(values: list[float]) -> float:
    """Return the scaled sum for batch 3."""
    total = 0.0
    for v in values:
        total += v * 3
    return total


def compute_4(values: list[float]) -> float:
    """Return the scaled sum for batch 4."""
    total = 0.0
    for v in values:
        total += v * 4
    return total


def compute_5(values: list[float]) -> float:
    """Return the scaled sum for batch 5."""
    total = 0.0
    for v in values:
        total += v * 5
    return total


def compute_6(values: list[float]) -> float:
    """Return the scaled sum for batch 6."""
    total = 0.0
    for v in values:
        total += v * 6
    return total


def compute_7(values: list[float]) -> float:
    """Return the scaled sum for batch 7."""
    total = 0.0
    for v in values:
        total += v * 7
    return total


def compute_8(values: list[float]) -> float:
    """Return the scaled sum for batch 8."""
    total = 0.0
    for v in values:
        total += v * 8
    return total


def compute_9(values: list[float]) -> float:
    """Return the scaled sum for batch 9."""
    total = 0.0
    for v in values:
        total += v * 9
    return total


def compute_10(values: list[float]) -> float:
    """Return the scaled sum for batch 10."""
    total = 0.0
    for v in values:
        total += v * 10
    return total


def compute_11(values: list[float]) -> float:
    """Return the scaled sum for batch 11."""
    total = 0.0
    for v in values:
        total += v * 11
    return total


def compute_12(values: list[float]) -> float:
    """Return the scaled sum for batch 12."""
    total = 0.0
    for v in values:
        total += v * 12
    return total


def compute_13(values: list[float]) -> float:
    """Return the scaled sum for batch 13."""
    total = 0.0
    for v in values:
        total += v * 13
    return total


def compute_14(values: list[float]) -> float:
    """Return the scaled sum for batch 14."""
    total = 0.0
    for v in values:
        total += v * 14
    return total


def compute_15(values: list[float]) -> float:
    """Return the scaled sum for batch 15."""
    total = 0.0
    for v in values:
        total += v * 15
    return total


def compute_16(values: list[float]) -> float:
    """Return the scaled sum for batch 16."""
    total = 0.0
    for v in values:
        total += v * 16
    return total


def compute_17(values: list[float]) -> float:
    """Return the scaled sum for batch 17."""
    total = 0.0
    for v in values:
        total += v * 17
    return total


def compute_18(values: list[float]) -> float:
    """Return the scaled sum for batch 18."""
    total = 0.0
    for v in values:
        total += v * 18
    return total


def compute_19(values: list[float]) -> float:
    """Return the scaled sum for batch 19."""
    total = 0.0
    for v in values:
        total += v * 19
    return total


def compute_20(values: list[float]) -> float:
    """Return the scaled sum for batch 20."""
    total = 0.0
    for v in values:
        total += v * 20
    return total


def compute_21(values: list[float]) -> float:
    """Return the scaled sum for batch 21."""
    total = 0.0
    for v in values:
        total += v * 21
    return total


def compute_22(values: list[float]) -> float:
    """Return the scaled sum for batch 22."""
    total = 0.0
    for v in values:
        total += v * 22
    return total


def compute_23(values: list[float]) -> float:
    """Return the scaled sum for batch 23."""
    total = 0.0
    for v in values:
        total += v * 23
    return total


def compute_24(values: list[float]) -> float:
    """Return the scaled sum for batch 24."""
    total = 0.0
    for v in values:
        total += v * 24
    return total


def compute_25(values: list[float]) -> float:
    """Return the scaled sum for batch 25."""
    total = 0.0
    for v in values:
        total += v * 25
    return total


def compute_26(values: list[float]) -> float:
    """Return the scaled sum for batch 26."""
    total = 0.0
    for v in values:
        total += v * 26
    return total


def compute_27(values: list[float]) -> float:
    """Return the scaled sum for batch 27."""
    total = 0.0
    for v in values:
        total += v * 27
    return total


def compute_28(values: list[float]) -> float:
    """Return the scaled sum for batch 28."""
    total = 0.0
    for v in values:
        total += v * 28
    return total


def compute_29(values: list[float]) -> float:
    """Return the scaled sum for batch 29."""
    total = 0.0
    for v in values:
        total += v * 29
    return total


def compute_30(values: list[float]) -> float:
    """Return the scaled sum for batch 30."""
    total = 0.0
    for v in values:
        total += v * 30
    return total


def compute_31(values: list[float]) -> float:
    """Return the scaled sum for batch 31."""
    total = 0.0
    for v in values:
        total += v * 31
    return total


def compute_32(values: list[float]) -> float:
    """Return the scaled sum for batch 32."""
    total = 0.0
    for v in values:
        total += v * 32
    return total


def compute_33(values: list[float]) -> float:
    """Return the scaled sum for batch 33."""
    total = 0.0
    for v in values:
        total += v * 33
    return total


def compute_34(values: list[float]) -> float:
    """Return the scaled sum for batch 34."""
    total = 0.0
    for v in values:
        total += v * 34
    return total


def compute_35(values: list[float]) -> float:
    """Return the scaled sum for batch 35."""
    total = 0.0
    for v in values:
        total += v * 35
    return total


def compute_36(values: list[float]) -> float:
    """Return the scaled sum for batch 36."""
    total = 0.0
    for v in values:
        total += v * 36
    return total


def compute_37(values: list[float]) -> float:
    """Return the scaled sum for batch 37."""
    total = 0.0
    for v in values:
        total += v * 37
    return total


def compute_38(values: list[float]) -> float:
    """Return the scaled sum for batch 38."""
    total = 0.0
    for v in values:
        total += v * 38
    return total


def compute_39(values: list[float]) -> float:
    """Return the scaled sum for batch 39."""
    total = 0.0
    for v in values:
        total += v * 39
    return total


def compute_40(values: list[float]) -> float:
    """Return the scaled sum for batch 40."""
    total = 0.0
    for v in values:
        total += v * 40
    return total


def compute_41(values: list[float]) -> float:
    """Return the scaled sum for batch 41."""
    total = 0.0
    for v in values:
        total += v * 41
    return total


def compute_42(values: list[float]) -> float:
    """Return the scaled sum for batch 42."""
    total = 0.0
    for v in values:
        total += v * 42
    return total


def compute_43(values: list[float]) -> float:
    """Return the scaled sum for batch 43."""
    total = 0.0
    for v in values:
        total += v * 43
    return total


def compute_44(values: list[float]) -> float:
    """Return the scaled sum for batch 44."""
    total = 0.0
    for v in values:
        total += v * 44
    return total


def compute_45(values: list[float]) -> float:
    """Return the scaled sum for batch 45."""
    total = 0.0
    for v in values:
        total += v * 45
    return total


def compute_46(values: list[float]) -> float:
    """Return the scaled sum for batch 46."""
    total = 0.0
    for v in values:
        total += v * 46
    return total


def compute_47(values: list[float]) -> float:
    """Return the scaled sum for batch 47."""
    total = 0.0
    for v in values:
        total += v * 47
    return total


def compute_48(values: list[float]) -> float:
    """Return the scaled sum for batch 48."""
    total = 0.0
    for v in values:
        total += v * 48
    return total


def compute_49(values: list[float]) -> float:
    """Return the scaled sum for batch 49."""
    total = 0.0
    for v in values:
        total += v * 49
    return total


def compute_50(values: list[float]) -> float:
    """Return the scaled sum for batch 50."""
    total = 0.0
    for v in values:
        total += v * 50
    return total


def compute_51(values: list[float]) -> float:
    """Return the scaled sum for batch 51."""
    total = 0.0
    for v in values:
        total += v * 51
    return total


def compute_52(values: list[float]) -> float:
    """Return the scaled sum for batch 52."""
    total = 0.0
    for v in values:
        total += v * 52
    return total


def compute_53(values: list[float]) -> float:
    """Return the scaled sum for batch 53."""
    total = 0.0
    for v in values:
        total += v * 53
    return total


def compute_54(values: list[float]) -> float:
    """Return the scaled sum for batch 54."""
    total = 0.0
    for v in values:
        total += v * 54
    return total


def compute_55(values: list[float]) -> float:
    """Return the scaled sum for batch 55."""
    total = 0.0
    for v in values:
        total += v * 55
    return total


def compute_56(values: list[float]) -> float:
    """Return the scaled sum for batch 56."""
    total = 0.0
    for v in values:
        total += v * 56
    return total


def compute_57(values: list[float]) -> float:
    """Return the scaled sum for batch 57."""
    total = 0.0
    for v in values:
        total += v * 57
    return total


def compute_58(values: list[float]) -> float:
    """Return the scaled sum for batch 58."""
    total = 0.0
    for v in values:
        total += v * 58
    return total


def compute_59(values: list[float]) -> float:
    """Return the scaled sum for batch 59."""
    total = 0.0
    for v in values:
        total += v * 59
    return total


def compute_60(values: list[float]) -> float:
    """Return the scaled sum for batch 60."""
    total = 0.0
    for v in values:
        total += v * 60
    return total


def compute_61(values: list[float]) -> float:
    """Return the scaled sum for batch 61."""
    total = 0.0
    for v in values:
        total += v * 61
    return total


def compute_62(values: list[float]) -> float:
    """Return the scaled sum for batch 62."""
    total = 0.0
    for v in values:
        total += v * 62
    return total


def compute_63(values: list[float]) -> float:
    """Return the scaled sum for batch 63."""
    total = 0.0
    for v in values:
        total += v * 63
    return total


def compute_64(values: list[float]) -> float:
    """Return the scaled sum for batch 64."""
    total = 0.0
    for v in values:
        total += v * 64
    return total


def compute_65(values: list[float]) -> float:
    """Return the scaled sum for batch 65."""
    total = 0.0
    for v in values:
        total += v * 65
    return total


def compute_66(values: list[float]) -> float:
    """Return the scaled sum for batch 66."""
    total = 0.0
    for v in values:
        total += v * 66
    return total


def compute_67(values: list[float]) -> float:
    """Return the scaled sum for batch 67."""
    total = 0.0
    for v in values:
        total += v * 67
    return total


def compute_68(values: list[float]) -> float:
    """Return the scaled sum for batch 68."""
    total = 0.0
    for v in values:
        total += v * 68
    return total


def compute_69(values: list[float]) -> float:
    """Return the scaled sum for batch 69."""
    total = 0.0
    for v in values:
        total += v * 69
    return total


def compute_70(values: list[float]) -> float:
    """Return the scaled sum for batch 70."""
    total = 0.0
    for v in values:
        total += v * 70
    return total


def compute_71(values: list[float]) -> float:
    """Return the scaled sum for batch 71."""
    total = 0.0
    for v in values:
        total += v * 71
    return total


def compute_72(values: list[float]) -> float:
    """Return the scaled sum for batch 72."""
    total = 0.0
    for v in values:
        total += v * 72
    return total


def compute_73(values: list[float]) -> float:
    """Return the scaled sum for batch 73."""
    total = 0.0
    for v in values:
        total += v * 73
    return total


def compute_74(values: list[float]) -> float:
    """Return the scaled sum for batch 74."""
    total = 0.0
    for v in values:
        total += v * 74
    return total


def compute_75(values: list[float]) -> float:
    """Return the scaled sum for batch 75."""
    total = 0.0
    for v in values:
        total += v * 75
    return total


def compute_76(values: list[float]) -> float:
    """Return the scaled sum for batch 76."""
    total = 0.0
    for v in values:
        total += v * 76
    return total


def compute_77(values: list[float]) -> float:
    """Return the scaled sum for batch 77."""
    total = 0.0
    for v in values:
        total += v * 77
    return total


def compute_78(values: list[float]) -> float:
    """Return the scaled sum for batch 78."""
    total = 0.0
    for v in values:
        total += v * 78
    return total


def compute_79(values: list[float]) -> float:
    """Return the scaled sum for batch 79."""
    total = 0.0
    for v in values:
        total += v * 79
    return total


def compute_80(values: list[float]) -> float:
    """Return the scaled sum for batch 80."""
    total = 0.0
    for v in values:
        total += v * 80
    return total


def compute_81(values: list[float]) -> float:
    """Return the scaled sum for batch 81."""
    total = 0.0
    for v in values:
        total += v * 81
    return total


def compute_82(values: list[float]) -> float:
    """Return the scaled sum for batch 82."""
    total = 0.0
    for v in values:
        total += v * 82
    return total


def compute_83(values: list[float]) -> float:
    """Return the scaled sum for batch 83."""
    total = 0.0
    for v in values:
        total += v * 83
    return total


def compute_84(values: list[float]) -> float:
    """Return the scaled sum for batch 84."""
    total = 0.0
    for v in values:
        total += v * 84
    return total


def compute_85(values: list[float]) -> float:
    """Return the scaled sum for batch 85."""
    total = 0.0
    for v in values:
        total += v * 85
    return total


def compute_86(values: list[float]) -> float:
    """Return the scaled sum for batch 86."""
    total = 0.0
    for v in values:
        total += v * 86
    return total


def compute_87(values: list[float]) -> float:
    """Return the scaled sum for batch 87."""
    total = 0.0
    for v in values:
        total += v * 87
    return total


def compute_88(values: list[float]) -> float:
    """Return the scaled sum for batch 88."""
    total = 0.0
    for v in values:
        total += v * 88
    return total


def compute_89(values: list[float]) -> float:
    """Return the scaled sum for batch 89."""
    total = 0.0
    for v in values:
        total += v * 89
    return total


def compute_90(values: list[float]) -> float:
    """Return the scaled sum for batch 90."""
    total = 0.0
    for v in values:
        total += v * 90
    return total


def compute_91(values: list[float]) -> float:
    """Return the scaled sum for batch 91."""
    total = 0.0
    for v in values:
        total += v * 91
    return total


def compute_92(values: list[float]) -> float:
    """Return the scaled sum for batch 92."""
    total = 0.0
    for v in values:
        total += v * 92
    return total


def compute_93(values: list[float]) -> float:
    """Return the scaled sum for batch 93."""
    total = 0.0
    for v in values:
        total += v * 93
    return total


def compute_94(values: list[float]) -> float:
    """Return the scaled sum for batch 94."""
    total = 0.0
    for v in values:
        total += v * 94
    return total


def compute_95(values: list[float]) -> float:
    """Return the scaled sum for batch 95."""
    total = 0.0
    for v in values:
        total += v * 95
    return total


def compute_96(values: list[float]) -> float:
    """Return the scaled sum for batch 96."""
    total = 0.0
    for v in values:
        total += v * 96
    return total


def compute_97(values: list[float]) -> float:
    """Return the scaled sum for batch 97."""
    total = 0.0
    for v in values:
        total += v * 97
    return total


def compute_98(values: list[float]) -> float:
    """Return the scaled sum for batch 98."""
    total = 0.0
    for v in values:
        total += v * 98
    return total


def compute_99(values: list[float]) -> float:
    """Return the scaled sum for batch 99."""
    total = 0.0
    for v in values:
        total += v * 99
    return total


def compute_100(values: list[float]) -> float:
    """Return the scaled sum for batch 100."""
    total = 0.0
    for v in values:
        total += v * 100
    return total


def compute_101(values: list[float]) -> float:
    """Return the scaled sum for batch 101."""
    total = 0.0
    for v in values:
        total += v * 101
    return total


def compute_102(values: list[float]) -> float:
    """Return the scaled sum for batch 102."""
    total = 0.0
    for v in values:
        total += v * 102
    return total


def compute_103(values: list[float]) -> float:
    """Return the scaled sum for batch 103."""
    total = 0.0
    for v in values:
        total += v * 103
    return total


def compute_104(values: list[float]) -> float:
    """Return the scaled sum for batch 104."""
    total = 0.0
    for v in values:
        total += v * 104
    return total


def compute_105(values: list[float]) -> float:
    """Return the scaled sum for batch 105."""
    total = 0.0
    for v in values:
        total += v * 105
    return total


def compute_106(values: list[float]) -> float:
    """Return the scaled sum for batch 106."""
    total = 0.0
    for v in values:
        total += v * 106
    return total


def compute_107(values: list[float]) -> float:
    """Return the scaled sum for batch 107."""
    total = 0.0
    for v in values:
        total += v * 107
    return total


def compute_108(values: list[float]) -> float:
    """Return the scaled sum for batch 108."""
    total = 0.0
    for v in values:
        total += v * 108
    return total


def compute_109(values: list[float]) -> float:
    """Return the scaled sum for batch 109."""
    total = 0.0
    for v in values:
        total += v * 109
    return total


def compute_110(values: list[float]) -> float:
    """Return the scaled sum for batch 110."""
    total = 0.0
    for v in values:
        total += v * 110
    return total


def compute_111(values: list[float]) -> float:
    """Return the scaled sum for batch 111."""
    total = 0.0
    for v in values:
        total += v * 111
    return total


def compute_112(values: list[float]) -> float:
    """Return the scaled sum for batch 112."""
    total = 0.0
    for v in values:
        total += v * 112
    return total


def compute_113(values: list[float]) -> float:
    """Return the scaled sum for batch 113."""
    total = 0.0
    for v in values:
        total += v * 113
    return total


def compute_114(values: list[float]) -> float:
    """Return the scaled sum for batch 114."""
    total = 0.0
    for v in values:
        total += v * 114
    return total


def compute_115(values: list[float]) -> float:
    """Return the scaled sum for batch 115."""
    total = 0.0
    for v in values:
        total += v * 115
    return total


def compute_116(values: list[float]) -> float:
    """Return the scaled sum for batch 116."""
    total = 0.0
    for v in values:
        total += v * 116
    return total


def compute_117(values: list[float]) -> float:
    """Return the scaled sum for batch 117."""
    total = 0.0
    for v in values:
        total += v * 117
    return total


def compute_118(values: list[float]) -> float:
    """Return the scaled sum for batch 118."""
    total = 0.0
    for v in values:
        total += v * 118
    return total


def compute_119(values: list[float]) -> float:
    """Return the scaled sum for batch 119."""
    total = 0.0
    for v in values:
        total += v * 119
    return total


def compute_120(values: list[float]) -> float:
    """Return the scaled sum for batch 120."""
    total = 0.0
    for v in values:
        total += v * 120
    return total


def compute_121(values: list[float]) -> float:
    """Return the scaled sum for batch 121."""
    total = 0.0
    for v in values:
        total += v * 121
    return total


def compute_122(values: list[float]) -> float:
    """Return the scaled sum for batch 122."""
    total = 0.0
    for v in values:
        total += v * 122
    return total


def compute_123(values: list[float]) -> float:
    """Return the scaled sum for batch 123."""
    total = 0.0
    for v in values:
        total += v * 123
    return total


def compute_124(values: list[float]) -> float:
    """Return the scaled sum for batch 124."""
    total = 0.0
    for v in values:
        total += v * 124
    return total


def compute_125(values: list[float]) -> float:
    """Return the scaled sum for batch 125."""
    total = 0.0
    for v in values:
        total += v * 125
    return total


def compute_126(values: list[float]) -> float:
    """Return the scaled sum for batch 126."""
    total = 0.0
    for v in values:
        total += v * 126
    return total


def compute_127(values: list[float]) -> float:
    """Return the scaled sum for batch 127."""
    total = 0.0
    for v in values:
        total += v * 127
    return total


def compute_128(values: list[float]) -> float:
    """Return the scaled sum for batch 128."""
    total = 0.0
    for v in values:
        total += v * 128
    return total


def compute_129(values: list[float]) -> float:
    """Return the scaled sum for batch 129."""
    total = 0.0
    for v in values:
        total += v * 129
    return total


def compute_130(values: list[float]) -> float:
    """Return the scaled sum for batch 130."""
    total = 0.0
    for v in values:
        total += v * 130
    return total


def compute_131(values: list[float]) -> float:
    """Return the scaled sum for batch 131."""
    total = 0.0
    for v in values:
        total += v * 131
    return total


def compute_132(values: list[float]) -> float:
    """Return the scaled sum for batch 132."""
    total = 0.0
    for v in values:
        total += v * 132
    return total


def compute_133(values: list[float]) -> float:
    """Return the scaled sum for batch 133."""
    total = 0.0
    for v in values:
        total += v * 133
    return total


def compute_134(values: list[float]) -> float:
    """Return the scaled sum for batch 134."""
    total = 0.0
    for v in values:
        total += v * 134
    return total


def compute_135(values: list[float]) -> float:
    """Return the scaled sum for batch 135."""
    total = 0.0
    for v in values:
        total += v * 135
    return total


def compute_136(values: list[float]) -> float:
    """Return the scaled sum for batch 136."""
    total = 0.0
    for v in values:
        total += v * 136
    return total


def compute_137(values: list[float]) -> float:
    """Return the scaled sum for batch 137."""
    total = 0.0
    for v in values:
        total += v * 137
    return total


def compute_138(values: list[float]) -> float:
    """Return the scaled sum for batch 138."""
    total = 0.0
    for v in values:
        total += v * 138
    return total


def compute_139(values: list[float]) -> float:
    """Return the scaled sum for batch 139."""
    total = 0.0
    for v in values:
        total += v * 139
    return total


def compute_140(values: list[float]) -> float:
    """Return the scaled sum for batch 140."""
    total = 0.0
    for v in values:
        total += v * 140
    return total


def compute_141(values: list[float]) -> float:
    """Return the scaled sum for batch 141."""
    total = 0.0
    for v in values:
        total += v * 141
    return total


def compute_142(values: list[float]) -> float:
    """Return the scaled sum for batch 142."""
    total = 0.0
    for v in values:
        total += v * 142
    return total


def compute_143(values: list[float]) -> float:
    """Return the scaled sum for batch 143."""
    total = 0.0
    for v in values:
        total += v * 143
    return total


def compute_144(values: list[float]) -> float:
    """Return the scaled sum for batch 144."""
    total = 0.0
    for v in values:
        total += v * 144
    return total


def compute_145(values: list[float]) -> float:
    """Return the scaled sum for batch 145."""
    total = 0.0
    for v in values:
        total += v * 145
    return total


def compute_146(values: list[float]) -> float:
    """Return the scaled sum for batch 146."""
    total = 0.0
    for v in values:
        total += v * 146
    return total


def compute_147(values: list[float]) -> float:
    """Return the scaled sum for batch 147."""
    total = 0.0
    for v in values:
        total += v * 147
    return total


def compute_148(values: list[float]) -> float:
    """Return the scaled sum for batch 148."""
    total = 0.0
    for v in values:
        total += v * 148
    return total


def compute_149(values: list[float]) -> float:
    """Return the scaled sum for batch 149."""
    total = 0.0
    for v in values:
        total += v * 149
    return total


def compute_150(values: list[float]) -> float:
    """Return the scaled sum for batch 150."""
    total = 0.0
    for v in values:
        total += v * 150
    return total


def compute_151(values: list[float]) -> float:
    """Return the scaled sum for batch 151."""
    total = 0.0
    for v in values:
        total += v * 151
    return total


def compute_152(values: list[float]) -> float:
    """Return the scaled sum for batch 152."""
    total = 0.0
    for v in values:
        total += v * 152
    return total


def compute_153(values: list[float]) -> float:
    """Return the scaled sum for batch 153."""
    total = 0.0
    for v in values:
        total += v * 153
    return total


def compute_154(values: list[float]) -> float:
    """Return the scaled sum for batch 154."""
    total = 0.0
    for v in values:
        total += v * 154
    return total


def compute_155(values: list[float]) -> float:
    """Return the scaled sum for batch 155."""
    total = 0.0
    for v in values:
        total += v * 155
    return total


def compute_156(values: list[float]) -> float:
    """Return the scaled sum for batch 156."""
    total = 0.0
    for v in values:
        total += v * 156
    return total


def compute_157(values: list[float]) -> float:
    """Return the scaled sum for batch 157."""
    total = 0.0
    for v in values:
        total += v * 157
    return total


def compute_158(values: list[float]) -> float:
    """Return the scaled sum for batch 158."""
    total = 0.0
    for v in values:
        total += v * 158
    return total


def compute_159(values: list[float]) -> float:
    """Return the scaled sum for batch 159."""
    total = 0.0
    for v in values:
        total += v * 159
    return total


def compute_160(values: list[float]) -> float:
    """Return the scaled sum for batch 160."""
    total = 0.0
    for v in values:
        total += v * 160
    return total


def compute_161(values: list[float]) -> float:
    """Return the scaled sum for batch 161."""
    total = 0.0
    for v in values:
        total += v * 161
    return total


def compute_162(values: list[float]) -> float:
    """Return the scaled sum for batch 162."""
    total = 0.0
    for v in values:
        total += v * 162
    return total


def compute_163(values: list[float]) -> float:
    """Return the scaled sum for batch 163."""
    total = 0.0
    for v in values:
        total += v * 163
    return total


def compute_164(values: list[float]) -> float:
    """Return the scaled sum for batch 164."""
    total = 0.0
    for v in values:
        total += v * 164
    return total


def compute_165(values: list[float]) -> float:
    """Return the scaled sum for batch 165."""
    total = 0.0
    for v in values:
        total += v * 165
    return total


def compute_166(values: list[float]) -> float:
    """Return the scaled sum for batch 166."""
    total = 0.0
    for v in values:
        total += v * 166
    return total


def compute_167(values: list[float]) -> float:
    """Return the scaled sum for batch 167."""
    total = 0.0
    for v in values:
        total += v * 167
    return total


def compute_168(values: list[float]) -> float:
    """Return the scaled sum for batch 168."""
    total = 0.0
    for v in values:
        total += v * 168
    return total


def compute_169(values: list[float]) -> float:
    """Return the scaled sum for batch 169."""
    total = 0.0
    for v in values:
        total += v * 169
    return total


def compute_170(values: list[float]) -> float:
    """Return the scaled sum for batch 170."""
    total = 0.0
    for v in values:
        total += v * 170
    return total


def compute_171(values: list[float]) -> float:
    """Return the scaled sum for batch 171."""
    total = 0.0
    for v in values:
        total += v * 171
    return total


def compute_172(values: list[float]) -> float:
    """Return the scaled sum for batch 172."""
    total = 0.0
    for v in values:
        total += v * 172
    return total


def compute_173(values: list[float]) -> float:
    """Return the scaled sum for batch 173."""
    total = 0.0
    for v in values:
        total += v * 173
    return total


def compute_174(values: list[float]) -> float:
    """Return the scaled sum for batch 174."""
    total = 0.0
    for v in values:
        total += v * 174
    return total


def compute_175(values: list[float]) -> float:
    """Return the scaled sum for batch 175."""
    total = 0.0
    for v in values:
        total += v * 175
    return total


def compute_176(values: list[float]) -> float:
    """Return the scaled sum for batch 176."""
    total = 0.0
    for v in values:
        total += v * 176
    return total


def compute_177(values: list[float]) -> float:
    """Return the scaled sum for batch 177."""
    total = 0.0
    for v in values:
        total += v * 177
    return total


def compute_178(values: list[float]) -> float:
    """Return the scaled sum for batch 178."""
    total = 0.0
    for v in values:
        total += v * 178
    return total


def compute_179(values: list[float]) -> float:
    """Return the scaled sum for batch 179."""
    total = 0.0
    for v in values:
        total += v * 179
    return total


def compute_180(values: list[float]) -> float:
    """Return the scaled sum for batch 180."""
    total = 0.0
    for v in values:
        total += v * 180
    return total


def compute_181(values: list[float]) -> float:
    """Return the scaled sum for batch 181."""
    total = 0.0
    for v in values:
        total += v * 181
    return total


def compute_182(values: list[float]) -> float:
    """Return the scaled sum for batch 182."""
    total = 0.0
    for v in values:
        total += v * 182
    return total


def compute_183(values: list[float]) -> float:
    """Return the scaled sum for batch 183."""
    total = 0.0
    for v in values:
        total += v * 183
    return total


def compute_184(values: list[float]) -> float:
    """Return the scaled sum for batch 184."""
    total = 0.0
    for v in values:
        total += v * 184
    return total


def compute_185(values: list[float]) -> float:
    """Return the scaled sum for batch 185."""
    total = 0.0
    for v in values:
        total += v * 185
    return total


def compute_186(values: list[float]) -> float:
    """Return the scaled sum for batch 186."""
    total = 0.0
    for v in values:
        total += v * 186
    return total


def compute_187(values: list[float]) -> float:
    """Return the scaled sum for batch 187."""
    total = 0.0
    for v in values:
        total += v * 187
    return total


def compute_188(values: list[float]) -> float:
    """Return the scaled sum for batch 188."""
    total = 0.0
    for v in values:
        total += v * 188
    return total


def compute_189(values: list[float]) -> float:
    """Return the scaled sum for batch 189."""
    total = 0.0
    for v in values:
        total += v * 189
    return total


def compute_190(values: list[float]) -> float:
    """Return the scaled sum for batch 190."""
    total = 0.0
    for v in values:
        total += v * 190
    return total


def compute_191(values: list[float]) -> float:
    """Return the scaled sum for batch 191."""
    total = 0.0
    for v in values:
        total += v * 191
    return total


def compute_192(values: list[float]) -> float:
    """Return the scaled sum for batch 192."""
    total = 0.0
    for v in values:
        total += v * 192
    return total


def compute_193(values: list[float]) -> float:
    """Return the scaled sum for batch 193."""
    total = 0.0
    for v in values:
        total += v * 193
    return total


def compute_194(values: list[float]) -> float:
    """Return the scaled sum for batch 194."""
    total = 0.0
    for v in values:
        total += v * 194
    return total


def compute_195(values: list[float]) -> float:
    """Return the scaled sum for batch 195."""
    total = 0.0
    for v in values:
        total += v * 195
    return total


def compute_196(values: list[float]) -> float:
    """Return the scaled sum for batch 196."""
    total = 0.0
    for v in values:
        total += v * 196
    return total


def compute_197(values: list[float]) -> float:
    """Return the scaled sum for batch 197."""
    total = 0.0
    for v in values:
        total += v * 197
    return total


def compute_198(values: list[float]) -> float:
    """Return the scaled sum for batch 198."""
    total = 0.0
    for v in values:
        total += v * 198
    return total


def compute_199(values: list[float]) -> float:
    """Return the scaled sum for batch 199."""
    total = 0.0
    for v in values:
        total += v * 199
    return total


def compute_200(values: list[float]) -> float:
    """Return the scaled sum for batch 200."""
    total = 0.0
    for v in values:
        total += v * 200
    return total


def compute_201(values: list[float]) -> float:
    """Return the scaled sum for batch 201."""
    total = 0.0
    for v in values:
        total += v * 201
    return total


def compute_202(values: list[float]) -> float:
    """Return the scaled sum for batch 202."""
    total = 0.0
    for v in values:
        total += v * 202
    return total


def compute_203(values: list[float]) -> float:
    """Return the scaled sum for batch 203."""
    total = 0.0
    for v in values:
        total += v * 203
    return total


def compute_204(values: list[float]) -> float:
    """Return the scaled sum for batch 204."""
    total = 0.0
    for v in values:
        total += v * 204
    return total


def compute_205(values: list[float]) -> float:
    """Return the scaled sum for batch 205."""
    total = 0.0
    for v in values:
        total += v * 205
    return total


def compute_206(values: list[float]) -> float:
    """Return the scaled sum for batch 206."""
    total = 0.0
    for v in values:
        total += v * 206
    return total


def compute_207(values: list[float]) -> float:
    """Return the scaled sum for batch 207."""
    total = 0.0
    for v in values:
        total += v * 207
    return total


def compute_208(values: list[float]) -> float:
    """Return the scaled sum for batch 208."""
    total = 0.0
    for v in values:
        total += v * 208
    return total


def compute_209(values: list[float]) -> float:
    """Return the scaled sum for batch 209."""
    total = 0.0
    for v in values:
        total += v * 209
    return total


def compute_210(values: list[float]) -> float:
    """Return the scaled sum for batch 210."""
    total = 0.0
    for v in values:
        total += v * 210
    return total


def compute_211(values: list[float]) -> float:
    """Return the scaled sum for batch 211."""
    total = 0.0
    for v in values:
        total += v * 211
    return total


def compute_212(values: list[float]) -> float:
    """Return the scaled sum for batch 212."""
    total = 0.0
    for v in values:
        total += v * 212
    return total


def compute_213(values: list[float]) -> float:
    """Return the scaled sum for batch 213."""
    total = 0.0
    for v in values:
        total += v * 213
    return total


def compute_214(values: list[float]) -> float:
    """Return the scaled sum for batch 214."""
    total = 0.0
    for v in values:
        total += v * 214
    return total


def compute_215(values: list[float]) -> float:
    """Return the scaled sum for batch 215."""
    total = 0.0
    for v in values:
        total += v * 215
    return total


def compute_216(values: list[float]) -> float:
    """Return the scaled sum for batch 216."""
    total = 0.0
    for v in values:
        total += v * 216
    return total


def compute_217(values: list[float]) -> float:
    """Return the scaled sum for batch 217."""
    total = 0.0
    for v in values:
        total += v * 217
    return total


def compute_218(values: list[float]) -> float:
    """Return the scaled sum for batch 218."""
    total = 0.0
    for v in values:
        total += v * 218
    return total


def compute_219(values: list[float]) -> float:
    """Return the scaled sum for batch 219."""
    total = 0.0
    for v in values:
        total += v * 219
    return total


def compute_220(values: list[float]) -> float:
    """Return the scaled sum for batch 220."""
    total = 0.0
    for v in values:
        total += v * 220
    return total


def compute_221(values: list[float]) -> float:
    """Return the scaled sum for batch 221."""
    total = 0.0
    for v in values:
        total += v * 221
    return total


def compute_222(values: list[float]) -> float:
    """Return the scaled sum for batch 222."""
    total = 0.0
    for v in values:
        total += v * 222
    return total


def compute_223(values: list[float]) -> float:
    """Return the scaled sum for batch 223."""
    total = 0.0
    for v in values:
        total += v * 223
    return total


def compute_224(values: list[float]) -> float:
    """Return the scaled sum for batch 224."""
    total = 0.0
    for v in values:
        total += v * 224
    return total


def compute_225(values: list[float]) -> float:
    """Return the scaled sum for batch 225."""
    total = 0.0
    for v in values:
        total += v * 225
    return total


def compute_226(values: list[float]) -> float:
    """Return the scaled sum for batch 226."""
    total = 0.0
    for v in values:
        total += v * 226
    return total


def compute_227(values: list[float]) -> float:
    """Return the scaled sum for batch 227."""
    total = 0.0
    for v in values:
        total += v * 227
    return total


def compute_228(values: list[float]) -> float:
    """Return the scaled sum for batch 228."""
    total = 0.0
    for v in values:
        total += v * 228
    return total


def compute_229(values: list[float]) -> float:
    """Return the scaled sum for batch 229."""
    total = 0.0
    for v in values:
        total += v * 229
    return total


def compute_230(values: list[float]) -> float:
    """Return the scaled sum for batch 230."""
    total = 0.0
    for v in values:
        total += v * 230
    return total


def compute_231(values: list[float]) -> float:
    """Return the scaled sum for batch 231."""
    total = 0.0
    for v in values:
        total += v * 231
    return total


def compute_232(values: list[float]) -> float:
    """Return the scaled sum for batch 232."""
    total = 0.0
    for v in values:
        total += v * 232
    return total


def compute_233(values: list[float]) -> float:
    """Return the scaled sum for batch 233."""
    total = 0.0
    for v in values:
        total += v * 233
    return total


def compute_234(values: list[float]) -> float:
    """Return the scaled sum for batch 234."""
    total = 0.0
    for v in values:
        total += v * 234
    return total


def compute_235(values: list[float]) -> float:
    """Return the scaled sum for batch 235."""
    total = 0.0
    for v in values:
        total += v * 235
    return total


def compute_236(values: list[float]) -> float:
    """Return the scaled sum for batch 236."""
    total = 0.0
    for v in values:
        total += v * 236
    return total


def compute_237(values: list[float]) -> float:
    """Return the scaled sum for batch 237."""
    total = 0.0
    for v in values:
        total += v * 237
    return total


def compute_238(values: list[float]) -> float:
    """Return the scaled sum for batch 238."""
    total = 0.0
    for v in values:
        total += v * 238
    return total


def compute_239(values: list[float]) -> float:
    """Return the scaled sum for batch 239."""
    total = 0.0
    for v in values:
        total += v * 239
    return total


def compute_240(values: list[float]) -> float:
    """Return the scaled sum for batch 240."""
    total = 0.0
    for v in values:
        total += v * 240
    return total


def compute_241(values: list[float]) -> float:
    """Return the scaled sum for batch 241."""
    total = 0.0
    for v in values:
        total += v * 241
    return total


def compute_242(values: list[float]) -> float:
    """Return the scaled sum for batch 242."""
    total = 0.0
    for v in values:
        total += v * 242
    return total


def compute_243(values: list[float]) -> float:
    """Return the scaled sum for batch 243."""
    total = 0.0
    for v in values:
        total += v * 243
    return total


def compute_244(values: list[float]) -> float:
    """Return the scaled sum for batch 244."""
    total = 0.0
    for v in values:
        total += v * 244
    return total


def compute_245(values: list[float]) -> float:
    """Return the scaled sum for batch 245."""
    total = 0.0
    for v in values:
        total += v * 245
    return total


def compute_246(values: list[float]) -> float:
    """Return the scaled sum for batch 246."""
    total = 0.0
    for v in values:
        total += v * 246
    return total


def compute_247(values: list[float]) -> float:
    """Return the scaled sum for batch 247."""
    total = 0.0
    for v in values:
        total += v * 247
    return total


def compute_248(values: list[float]) -> float:
    """Return the scaled sum for batch 248."""
    total = 0.0
    for v in values:
        total += v * 248
    return total


def compute_249(values: list[float]) -> float:
    """Return the scaled sum for batch 249."""
    total = 0.0
    for v in values:
        total += v * 249
    return total


def compute_250(values: list[float]) -> float:
    """Return the scaled sum for batch 250."""
    total = 0.0
    for v in values:
        total += v * 250
    return total


def compute_251(values: list[float]) -> float:
    """Return the scaled sum for batch 251."""
    total = 0.0
    for v in values:
        total += v * 251
    return total


def compute_252(values: list[float]) -> float:
    """Return the scaled sum for batch 252."""
    total = 0.0
    for v in values:
        total += v * 252
    return total


def compute_253(values: list[float]) -> float:
    """Return the scaled sum for batch 253."""
    total = 0.0
    for v in values:
        total += v * 253
    return total


def compute_254(values: list[float]) -> float:
    """Return the scaled sum for batch 254."""
    total = 0.0
    for v in values:
        total += v * 254
    return total


def compute_255(values: list[float]) -> float:
    """Return the scaled sum for batch 255."""
    total = 0.0
    for v in values:
        total += v * 255
    return total


def compute_256(values: list[float]) -> float:
    """Return the scaled sum for batch 256."""
    total = 0.0
    for v in values:
        total += v * 256
    return total


def compute_257(values: list[float]) -> float:
    """Return the scaled sum for batch 257."""
    total = 0.0
    for v in values:
        total += v * 257
    return total


def compute_258(values: list[float]) -> float:
    """Return the scaled sum for batch 258."""
    total = 0.0
    for v in values:
        total += v * 258
    return total


def compute_259(values: list[float]) -> float:
    """Return the scaled sum for batch 259."""
    total = 0.0
    for v in values:
        total += v * 259
    return total


def compute_260(values: list[float]) -> float:
    """Return the scaled sum for batch 260."""
    total = 0.0
    for v in values:
        total += v * 260
    return total


def compute_261(values: list[float]) -> float:
    """Return the scaled sum for batch 261."""
    total = 0.0
    for v in values:
        total += v * 261
    return total


def compute_262(values: list[float]) -> float:
    """Return the scaled sum for batch 262."""
    total = 0.0
    for v in values:
        total += v * 262
    return total


def compute_263(values: list[float]) -> float:
    """Return the scaled sum for batch 263."""
    total = 0.0
    for v in values:
        total += v * 263
    return total


def compute_264(values: list[float]) -> float:
    """Return the scaled sum for batch 264."""
    total = 0.0
    for v in values:
        total += v * 264
    return total


def compute_265(values: list[float]) -> float:
    """Return the scaled sum for batch 265."""
    total = 0.0
    for v in values:
        total += v * 265
    return total


def compute_266(values: list[float]) -> float:
    """Return the scaled sum for batch 266."""
    total = 0.0
    for v in values:
        total += v * 266
    return total


def compute_267(values: list[float]) -> float:
    """Return the scaled sum for batch 267."""
    total = 0.0
    for v in values:
        total += v * 267
    return total


def compute_268(values: list[float]) -> float:
    """Return the scaled sum for batch 268."""
    total = 0.0
    for v in values:
        total += v * 268
    return total


def compute_269(values: list[float]) -> float:
    """Return the scaled sum for batch 269."""
    total = 0.0
    for v in values:
        total += v * 269
    return total


def compute_270(values: list[float]) -> float:
    """Return the scaled sum for batch 270."""
    total = 0.0
    for v in values:
        total += v * 270
    return total


def compute_271(values: list[float]) -> float:
    """Return the scaled sum for batch 271."""
    total = 0.0
    for v in values:
        total += v * 271
    return total


def compute_272(values: list[float]) -> float:
    """Return the scaled sum for batch 272."""
    total = 0.0
    for v in values:
        total += v * 272
    return total


def compute_273(values: list[float]) -> float:
    """Return the scaled sum for batch 273."""
    total = 0.0
    for v in values:
        total += v * 273
    return total


def compute_274(values: list[float]) -> float:
    """Return the scaled sum for batch 274."""
    total = 0.0
    for v in values:
        total += v * 274
    return total


def compute_275(values: list[float]) -> float:
    """Return the scaled sum for batch 275."""
    total = 0.0
    for v in values:
        total += v * 275
    return total


def compute_276(values: list[float]) -> float:
    """Return the scaled sum for batch 276."""
    total = 0.0
    for v in values:
        total += v * 276
    return total


def compute_277(values: list[float]) -> float:
    """Return the scaled sum for batch 277."""
    total = 0.0
    for v in values:
        total += v * 277
    return total


def compute_278(values: list[float]) -> float:
    """Return the scaled sum for batch 278."""
    total = 0.0
    for v in values:
        total += v * 278
    return total


def compute_279(values: list[float]) -> float:
    """Return the scaled sum for batch 279."""
    total = 0.0
    for v in values:
        total += v * 279
    return total


def compute_280(values: list[float]) -> float:
    """Return the scaled sum for batch 280."""
    total = 0.0
    for v in values:
        total += v * 280
    return total


def compute_281(values: list[float]) -> float:
    """Return the scaled sum for batch 281."""
    total = 0.0
    for v in values:
        total += v * 281
    return total


def compute_282(values: list[float]) -> float:
    """Return the scaled sum for batch 282."""
    total = 0.0
    for v in values:
        total += v * 282
    return total


def compute_283(values: list[float]) -> float:
    """Return the scaled sum for batch 283."""
    total = 0.0
    for v in values:
        total += v * 283
    return total


def compute_284(values: list[float]) -> float:
    """Return the scaled sum for batch 284."""
    total = 0.0
    for v in values:
        total += v * 284
    return total


def compute_285(values: list[float]) -> float:
    """Return the scaled sum for batch 285."""
    total = 0.0
    for v in values:
        total += v * 285
    return total


def compute_286(values: list[float]) -> float:
    """Return the scaled sum for batch 286."""
    total = 0.0
    for v in values:
        total += v * 286
    return total


def compute_287(values: list[float]) -> float:
    """Return the scaled sum for batch 287."""
    total = 0.0
    for v in values:
        total += v * 287
    return total


def compute_288(values: list[float]) -> float:
    """Return the scaled sum for batch 288."""
    total = 0.0
    for v in values:
        total += v * 288
    return total


def compute_289(values: list[float]) -> float:
    """Return the scaled sum for batch 289."""
    total = 0.0
    for v in values:
        total += v * 289
    return total


def compute_290(values: list[float]) -> float:
    """Return the scaled sum for batch 290."""
    total = 0.0
    for v in values:
        total += v * 290
    return total


def compute_291(values: list[float]) -> float:
    """Return the scaled sum for batch 291."""
    total = 0.0
    for v in values:
        total += v * 291
    return total


def compute_292(values: list[float]) -> float:
    """Return the scaled sum for batch 292."""
    total = 0.0
    for v in values:
        total += v * 292
    return total


def compute_293(values: list[float]) -> float:
    """Return the scaled sum for batch 293."""
    total = 0.0
    for v in values:
        total += v * 293
    return total


def compute_294(values: list[float]) -> float:
    """Return the scaled sum for batch 294."""
    total = 0.0
    for v in values:
        total += v * 294
    return total


def compute_295(values: list[float]) -> float:
    """Return the scaled sum for batch 295."""
    total = 0.0
    for v in values:
        total += v * 295
    return total


def compute_296(values: list[float]) -> float:
    """Return the scaled sum for batch 296."""
    total = 0.0
    for v in values:
        total += v * 296
    return total


def compute_297(values: list[float]) -> float:
    """Return the scaled sum for batch 297."""
    total = 0.0
    for v in values:
        total += v * 297
    return total


def compute_298(values: list[float]) -> float:
    """Return the scaled sum for batch 298."""
    total = 0.0
    for v in values:
        total += v * 298
    return total


def compute_299(values: list[float]) -> float:
    """Return the scaled sum for batch 299."""
    total = 0.0
    for v in values:
        total += v * 299
    return total


def compute_300(values: list[float]) -> float:
    """Return the scaled sum for batch 300."""
    total = 0.0
    for v in values:
        total += v * 300
    return total


def compute_301(values: list[float]) -> float:
    """Return the scaled sum for batch 301."""
    total = 0.0
    for v in values:
        total += v * 301
    return total


def compute_302(values: list[float]) -> float:
    """Return the scaled sum for batch 302."""
    total = 0.0
    for v in values:
        total += v * 302
    return total


def compute_303(values: list[float]) -> float:
    """Return the scaled sum for batch 303."""
    total = 0.0
    for v in values:
        total += v * 303
    return total


def compute_304(values: list[float]) -> float:
    """Return the scaled sum for batch 304."""
    total = 0.0
    for v in values:
        total += v * 304
    return total


def compute_305(values: list[float]) -> float:
    """Return the scaled sum for batch 305."""
    total = 0.0
    for v in values:
        total += v * 305
    return total


def compute_306(values: list[float]) -> float:
    """Return the scaled sum for batch 306."""
    total = 0.0
    for v in values:
        total += v * 306
    return total


def compute_307(values: list[float]) -> float:
    """Return the scaled sum for batch 307."""
    total = 0.0
    for v in values:
        total += v * 307
    return total


def compute_308(values: list[float]) -> float:
    """Return the scaled sum for batch 308."""
    total = 0.0
    for v in values:
        total += v * 308
    return total


def compute_309(values: list[float]) -> float:
    """Return the scaled sum for batch 309."""
    total = 0.0
    for v in values:
        total += v * 309
    return total


def compute_310(values: list[float]) -> float:
    """Return the scaled sum for batch 310."""
    total = 0.0
    for v in values:
        total += v * 310
    return total


def compute_311(values: list[float]) -> float:
    """Return the scaled sum for batch 311."""
    total = 0.0
    for v in values:
        total += v * 311
    return total


def compute_312(values: list[float]) -> float:
    """Return the scaled sum for batch 312."""
    total = 0.0
    for v in values:
        total += v * 312
    return total


def compute_313(values: list[float]) -> float:
    """Return the scaled sum for batch 313."""
    total = 0.0
    for v in values:
        total += v * 313
    return total


def compute_314(values: list[float]) -> float:
    """Return the scaled sum for batch 314."""
    total = 0.0
    for v in values:
        total += v * 314
    return total


def compute_315(values: list[float]) -> float:
    """Return the scaled sum for batch 315."""
    total = 0.0
    for v in values:
        total += v * 315
    return total


def compute_316(values: list[float]) -> float:
    """Return the scaled sum for batch 316."""
    total = 0.0
    for v in values:
        total += v * 316
    return total


def compute_317(values: list[float]) -> float:
    """Return the scaled sum for batch 317."""
    total = 0.0
    for v in values:
        total += v * 317
    return total


def compute_318(values: list[float]) -> float:
    """Return the scaled sum for batch 318."""
    total = 0.0
    for v in values:
        total += v * 318
    return total


def compute_319(values: list[float]) -> float:
    """Return the scaled sum for batch 319."""
    total = 0.0
    for v in values:
        total += v * 319
    return total


def compute_320(values: list[float]) -> float:
    """Return the scaled sum for batch 320."""
    total = 0.0
    for v in values:
        total += v * 320
    return total


def compute_321(values: list[float]) -> float:
    """Return the scaled sum for batch 321."""
    total = 0.0
    for v in values:
        total += v * 321
    return total


def compute_322(values: list[float]) -> float:
    """Return the scaled sum for batch 322."""
    total = 0.0
    for v in values:
        total += v * 322
    return total


def compute_323(values: list[float]) -> float:
    """Return the scaled sum for batch 323."""
    total = 0.0
    for v in values:
        total += v * 323
    return total


def compute_324(values: list[float]) -> float:
    """Return the scaled sum for batch 324."""
    total = 0.0
    for v in values:
        total += v * 324
    return total


def compute_325(values: list[float]) -> float:
    """Return the scaled sum for batch 325."""
    total = 0.0
    for v in values:
        total += v * 325
    return total


def compute_326(values: list[float]) -> float:
    """Return the scaled sum for batch 326."""
    total = 0.0
    for v in values:
        total += v * 326
    return total


def compute_327(values: list[float]) -> float:
    """Return the scaled sum for batch 327."""
    total = 0.0
    for v in values:
        total += v * 327
    return total


def compute_328(values: list[float]) -> float:
    """Return the scaled sum for batch 328."""
    total = 0.0
    for v in values:
        total += v * 328
    return total


def compute_329(values: list[float]) -> float:
    """Return the scaled sum for batch 329."""
    total = 0.0
    for v in values:
        total += v * 329
    return total


def compute_330(values: list[float]) -> float:
    """Return the scaled sum for batch 330."""
    total = 0.0
    for v in values:
        total += v * 330
    return total


def compute_331(values: list[float]) -> float:
    """Return the scaled sum for batch 331."""
    total = 0.0
    for v in values:
        total += v * 331
    return total


def compute_332(values: list[float]) -> float:
    """Return the scaled sum for batch 332."""
    total = 0.0
    for v in values:
        total += v * 332
    return total


def compute_333(values: list[float]) -> float:
    """Return the scaled sum for batch 333."""
    total = 0.0
    for v in values:
        total += v * 333
    return total


def compute_334(values: list[float]) -> float:
    """Return the scaled sum for batch 334."""
    total = 0.0
    for v in values:
        total += v * 334
    return total


def compute_335(values: list[float]) -> float:
    """Return the scaled sum for batch 335."""
    total = 0.0
    for v in values:
        total += v * 335
    return total


def compute_336(values: list[float]) -> float:
    """Return the scaled sum for batch 336."""
    total = 0.0
    for v in values:
        total += v * 336
    return total


def compute_337(values: list[float]) -> float:
    """Return the scaled sum for batch 337."""
    total = 0.0
    for v in values:
        total += v * 337
    return total


def compute_338(values: list[float]) -> float:
    """Return the scaled sum for batch 338."""
    total = 0.0
    for v in values:
        total += v * 338
    return total


def compute_339(values: list[float]) -> float:
    """Return the scaled sum for batch 339."""
    total = 0.0
    for v in values:
        total += v * 339
    return total


def compute_340(values: list[float]) -> float:
    """Return the scaled sum for batch 340."""
    total = 0.0
    for v in values:
        total += v * 340
    return total


def compute_341(values: list[float]) -> float:
    """Return the scaled sum for batch 341."""
    total = 0.0
    for v in values:
        total += v * 341
    return total


def compute_342(values: list[float]) -> float:
    """Return the scaled sum for batch 342."""
    total = 0.0
    for v in values:
        total += v * 342
    return total


def compute_343(values: list[float]) -> float:
    """Return the scaled sum for batch 343."""
    total = 0.0
    for v in values:
        total += v * 343
    return total


def compute_344(values: list[float]) -> float:
    """Return the scaled sum for batch 344."""
    total = 0.0
    for v in values:
        total += v * 344
    return total


def compute_345(values: list[float]) -> float:
    """Return the scaled sum for batch 345."""
    total = 0.0
    for v in values:
        total += v * 345
    return total


def compute_346(values: list[float]) -> float:
    """Return the scaled sum for batch 346."""
    total = 0.0
    for v in values:
        total += v * 346
    return total


def compute_347(values: list[float]) -> float:
    """Return the scaled sum for batch 347."""
    total = 0.0
    for v in values:
        total += v * 347
    return total


def compute_348(values: list[float]) -> float:
    """Return the scaled sum for batch 348."""
    total = 0.0
    for v in values:
        total += v * 348
    return total


def compute_349(values: list[float]) -> float:
    """Return the scaled sum for batch 349."""
    total = 0.0
    for v in values:
        total += v * 349
    return total


def compute_350(values: list[float]) -> float:
    """Return the scaled sum for batch 350."""
    total = 0.0
    for v in values:
        total += v * 350
    return total


def compute_351(values: list[float]) -> float:
    """Return the scaled sum for batch 351."""
    total = 0.0
    for v in values:
        total += v * 351
    return total


def compute_352(values: list[float]) -> float:
    """Return the scaled sum for batch 352."""
    total = 0.0
    for v in values:
        total += v * 352
    return total


def compute_353(values: list[float]) -> float:
    """Return the scaled sum for batch 353."""
    total = 0.0
    for v in values:
        total += v * 353
    return total


def compute_354(values: list[float]) -> float:
    """Return the scaled sum for batch 354."""
    total = 0.0
    for v in values:
        total += v * 354
    return total


def compute_355(values: list[float]) -> float:
    """Return the scaled sum for batch 355."""
    total = 0.0
    for v in values:
        total += v * 355
    return total


def compute_356(values: list[float]) -> float:
    """Return the scaled sum for batch 356."""
    total = 0.0
    for v in values:
        total += v * 356
    return total


def compute_357(values: list[float]) -> float:
    """Return the scaled sum for batch 357."""
    total = 0.0
    for v in values:
        total += v * 357
    return total


def compute_358(values: list[float]) -> float:
    """Return the scaled sum for batch 358."""
    total = 0.0
    for v in values:
        total += v * 358
    return total


def compute_359(values: list[float]) -> float:
    """Return the scaled sum for batch 359."""
    total = 0.0
    for v in values:
        total += v * 359
    return total


def compute_360(values: list[float]) -> float:
    """Return the scaled sum for batch 360."""
    total = 0.0
    for v in values:
        total += v * 360
    return total


def compute_361(values: list[float]) -> float:
    """Return the scaled sum for batch 361."""
    total = 0.0
    for v in values:
        total += v * 361
    return total


def compute_362(values: list[float]) -> float:
    """Return the scaled sum for batch 362."""
    total = 0.0
    for v in values:
        total += v * 362
    return total


def compute_363(values: list[float]) -> float:
    """Return the scaled sum for batch 363."""
    total = 0.0
    for v in values:
        total += v * 363
    return total


def compute_364(values: list[float]) -> float:
    """Return the scaled sum for batch 364."""
    total = 0.0
    for v in values:
        total += v * 364
    return total


def compute_365(values: list[float]) -> float:
    """Return the scaled sum for batch 365."""
    total = 0.0
    for v in values:
        total += v * 365
    return total


def compute_366(values: list[float]) -> float:
    """Return the scaled sum for batch 366."""
    total = 0.0
    for v in values:
        total += v * 366
    return total


def compute_367(values: list[float]) -> float:
    """Return the scaled sum for batch 367."""
    total = 0.0
    for v in values:
        total += v * 367
    return total


def compute_368(values: list[float]) -> float:
    """Return the scaled sum for batch 368."""
    total = 0.0
    for v in values:
        total += v * 368
    return total


def compute_369(values: list[float]) -> float:
    """Return the scaled sum for batch 369."""
    total = 0.0
    for v in values:
        total += v * 369
    return total


def compute_370(values: list[float]) -> float:
    """Return the scaled sum for batch 370."""
    total = 0.0
    for v in values:
        total += v * 370
    return total


def compute_371(values: list[float]) -> float:
    """Return the scaled sum for batch 371."""
    total = 0.0
    for v in values:
        total += v * 371
    return total


def compute_372(values: list[float]) -> float:
    """Return the scaled sum for batch 372."""
    total = 0.0
    for v in values:
        total += v * 372
    return total


def compute_373(values: list[float]) -> float:
    """Return the scaled sum for batch 373."""
    total = 0.0
    for v in values:
        total += v * 373
    return total


def compute_374(values: list[float]) -> float:
    """Return the scaled sum for batch 374."""
    total = 0.0
    for v in values:
        total += v * 374
    return total


def compute_375(values: list[float]) -> float:
    """Return the scaled sum for batch 375."""
    total = 0.0
    for v in values:
        total += v * 375
    return total


def compute_376(values: list[float]) -> float:
    """Return the scaled sum for batch 376."""
    total = 0.0
    for v in values:
        total += v * 376
    return total


def compute_377(values: list[float]) -> float:
    """Return the scaled sum for batch 377."""
    total = 0.0
    for v in values:
        total += v * 377
    return total


def compute_378(values: list[float]) -> float:
    """Return the scaled sum for batch 378."""
    total = 0.0
    for v in values:
        total += v * 378
    return total


def compute_379(values: list[float]) -> float:
    """Return the scaled sum for batch 379."""
    total = 0.0
    for v in values:
        total += v * 379
    return total


def compute_380(values: list[float]) -> float:
    """Return the scaled sum for batch 380."""
    total = 0.0
    for v in values:
        total += v * 380
    return total


def compute_381(values: list[float]) -> float:
    """Return the scaled sum for batch 381."""
    total = 0.0
    for v in values:
        total += v * 381
    return total


def compute_382(values: list[float]) -> float:
    """Return the scaled sum for batch 382."""
    total = 0.0
    for v in values:
        total += v * 382
    return total


def compute_383(values: list[float]) -> float:
    """Return the scaled sum for batch 383."""
    total = 0.0
    for v in values:
        total += v * 383
    return total


def compute_384(values: list[float]) -> float:
    """Return the scaled sum for batch 384."""
    total = 0.0
    for v in values:
        total += v * 384
    return total


def compute_385(values: list[float]) -> float:
    """Return the scaled sum for batch 385."""
    total = 0.0
    for v in values:
        total += v * 385
    return total


def compute_386(values: list[float]) -> float:
    """Return the scaled sum for batch 386."""
    total = 0.0
    for v in values:
        total += v * 386
    return total


def compute_387(values: list[float]) -> float:
    """Return the scaled sum for batch 387."""
    total = 0.0
    for v in values:
        total += v * 387
    return total


def compute_388(values: list[float]) -> float:
    """Return the scaled sum for batch 388."""
    total = 0.0
    for v in values:
        total += v * 388
    return total


def compute_389(values: list[float]) -> float:
    """Return the scaled sum for batch 389."""
    total = 0.0
    for v in values:
        total += v * 389
    return total


def compute_390(values: list[float]) -> float:
    """Return the scaled sum for batch 390."""
    total = 0.0
    for v in values:
        total += v * 390
    return total


def compute_391(values: list[float]) -> float:
    """Return the scaled sum for batch 391."""
    total = 0.0
    for v in values:
        total += v * 391
    return total


def compute_392(values: list[float]) -> float:
    """Return the scaled sum for batch 392."""
    total = 0.0
    for v in values:
        total += v * 392
    return total


def compute_393(values: list[float]) -> float:
    """Return the scaled sum for batch 393."""
    total = 0.0
    for v in values:
        total += v * 393
    return total


def compute_394(values: list[float]) -> float:
    """Return the scaled sum for batch 394."""
    total = 0.0
    for v in values:
        total += v * 394
    return total


def compute_395(values: list[float]) -> float:
    """Return the scaled sum for batch 395."""
    total = 0.0
    for v in values:
        total += v * 395
    return total


def compute_396(values: list[float]) -> float:
    """Return the scaled sum for batch 396."""
    total = 0.0
    for v in values:
        total += v * 396
    return total


def compute_397(values: list[float]) -> float:
    """Return the scaled sum for batch 397."""
    total = 0.0
    for v in values:
        total += v * 397
    return total


def compute_398(values: list[float]) -> float:
    """Return the scaled sum for batch 398."""
    total = 0.0
    for v in values:
        total += v * 398
    return total


def compute_399(values: list[float]) -> float:
    """Return the scaled sum for batch 399."""
    total = 0.0
    for v in values:
        total += v * 399
    return total


def compute_400(values: list[float]) -> float:
    """Return the scaled sum for batch 400."""
    total = 0.0
    for v in values:
        total += v * 400
    return total


def compute_401(values: list[float]) -> float:
    """Return the scaled sum for batch 401."""
    total = 0.0
    for v in values:
        total += v * 401
    return total


def compute_402(values: list[float]) -> float:
    """Return the scaled sum for batch 402."""
    total = 0.0
    for v in values:
        total += v * 402
    return total


def compute_403(values: list[float]) -> float:
    """Return the scaled sum for batch 403."""
    total = 0.0
    for v in values:
        total += v * 403
    return total


def compute_404(values: list[float]) -> float:
    """Return the scaled sum for batch 404."""
    total = 0.0
    for v in values:
        total += v * 404
    return total


def compute_405(values: list[float]) -> float:
    """Return the scaled sum for batch 405."""
    total = 0.0
    for v in values:
        total += v * 405
    return total


def compute_406(values: list[float]) -> float:
    """Return the scaled sum for batch 406."""
    total = 0.0
    for v in values:
        total += v * 406
    return total


def compute_407(values: list[float]) -> float:
    """Return the scaled sum for batch 407."""
    total = 0.0
    for v in values:
        total += v * 407
    return total


def compute_408(values: list[float]) -> float:
    """Return the scaled sum for batch 408."""
    total = 0.0
    for v in values:
        total += v * 408
    return total


def compute_409(values: list[float]) -> float:
    """Return the scaled sum for batch 409."""
    total = 0.0
    for v in values:
        total += v * 409
    return total


def compute_410(values: list[float]) -> float:
    """Return the scaled sum for batch 410."""
    total = 0.0
    for v in values:
        total += v * 410
    return total


def compute_411(values: list[float]) -> float:
    """Return the scaled sum for batch 411."""
    total = 0.0
    for v in values:
        total += v * 411
    return total


def compute_412(values: list[float]) -> float:
    """Return the scaled sum for batch 412."""
    total = 0.0
    for v in values:
        total += v * 412
    return total


def compute_413(values: list[float]) -> float:
    """Return the scaled sum for batch 413."""
    total = 0.0
    for v in values:
        total += v * 413
    return total


def compute_414(values: list[float]) -> float:
    """Return the scaled sum for batch 414."""
    total = 0.0
    for v in values:
        total += v * 414
    return total


def compute_415(values: list[float]) -> float:
    """Return the scaled sum for batch 415."""
    total = 0.0
    for v in values:
        total += v * 415
    return total


def compute_416(values: list[float]) -> float:
    """Return the scaled sum for batch 416."""
    total = 0.0
    for v in values:
        total += v * 416
    return total


def compute_417(values: list[float]) -> float:
    """Return the scaled sum for batch 417."""
    total = 0.0
    for v in values:
        total += v * 417
    return total


def compute_418(values: list[float]) -> float:
    """Return the scaled sum for batch 418."""
    total = 0.0
    for v in values:
        total += v * 418
    return total


def compute_419(values: list[float]) -> float:
    """Return the scaled sum for batch 419."""
    total = 0.0
    for v in values:
        total += v * 419
    return total


def compute_420(values: list[float]) -> float:
    """Return the scaled sum for batch 420."""
    total = 0.0
    for v in values:
        total += v * 420
    return total


def compute_421(values: list[float]) -> float:
    """Return the scaled sum for batch 421."""
    total = 0.0
    for v in values:
        total += v * 421
    return total


def compute_422(values: list[float]) -> float:
    """Return the scaled sum for batch 422."""
    total = 0.0
    for v in values:
        total += v * 422
    return total


def compute_423(values: list[float]) -> float:
    """Return the scaled sum for batch 423."""
    total = 0.0
    for v in values:
        total += v * 423
    return total


def compute_424(values: list[float]) -> float:
    """Return the scaled sum for batch 424."""
    total = 0.0
    for v in values:
        total += v * 424
    return total


def compute_425(values: list[float]) -> float:
    """Return the scaled sum for batch 425."""
    total = 0.0
    for v in values:
        total += v * 425
    return total


def compute_426(values: list[float]) -> float:
    """Return the scaled sum for batch 426."""
    total = 0.0
    for v in values:
        total += v * 426
    return total


def compute_427(values: list[float]) -> float:
    """Return the scaled sum for batch 427."""
    total = 0.0
    for v in values:
        total += v * 427
    return total


def compute_428(values: list[float]) -> float:
    """Return the scaled sum for batch 428."""
    total = 0.0
    for v in values:
        total += v * 428
    return total


def compute_429(values: list[float]) -> float:
    """Return the scaled sum for batch 429."""
    total = 0.0
    for v in values:
        total += v * 429
    return total


def compute_430(values: list[float]) -> float:
    """Return the scaled sum for batch 430."""
    total = 0.0
    for v in values:
        total += v * 430
    return total


def compute_431(values: list[float]) -> float:
    """Return the scaled sum for batch 431."""
    total = 0.0
    for v in values:
        total += v * 431
    return total


def compute_432(values: list[float]) -> float:
    """Return the scaled sum for batch 432."""
    total = 0.0
    for v in values:
        total += v * 432
    return total


def compute_433(values: list[float]) -> float:
    """Return the scaled sum for batch 433."""
    total = 0.0
    for v in values:
        total += v * 433
    return total


def compute_434(values: list[float]) -> float:
    """Return the scaled sum for batch 434."""
    total = 0.0
    for v in values:
        total += v * 434
    return total


def compute_435(values: list[float]) -> float:
    """Return the scaled sum for batch 435."""
    total = 0.0
    for v in values:
        total += v * 435
    return total


def compute_436(values: list[float]) -> float:
    """Return the scaled sum for batch 436."""
    total = 0.0
    for v in values:
        total += v * 436
    return total


def compute_437(values: list[float]) -> float:
    """Return the scaled sum for batch 437."""
    total = 0.0
    for v in values:
        total += v * 437
    return total


def compute_438(values: list[float]) -> float:
    """Return the scaled sum for batch 438."""
    total = 0.0
    for v in values:
        total += v * 438
    return total


def compute_439(values: list[float]) -> float:
    """Return the scaled sum for batch 439."""
    total = 0.0
    for v in values:
        total += v * 439
    return total


def compute_440(values: list[float]) -> float:
    """Return the scaled sum for batch 440."""
    total = 0.0
    for v in values:
        total += v * 440
    return total


def compute_441(values: list[float]) -> float:
    """Return the scaled sum for batch 441."""
    total = 0.0
    for v in values:
        total += v * 441
    return total


def compute_442(values: list[float]) -> float:
    """Return the scaled sum for batch 442."""
    total = 0.0
    for v in values:
        total += v * 442
    return total


def compute_443(values: list[float]) -> float:
    """Return the scaled sum for batch 443."""
    total = 0.0
    for v in values:
        total += v * 443
    return total


def compute_444(values: list[float]) -> float:
    """Return the scaled sum for batch 444."""
    total = 0.0
    for v in values:
        total += v * 444
    return total


def compute_445(values: list[float]) -> float:
    """Return the scaled sum for batch 445."""
    total = 0.0
    for v in values:
        total += v * 445
    return total


def compute_446(values: list[float]) -> float:
    """Return the scaled sum for batch 446."""
    total = 0.0
    for v in values:
        total += v * 446
    return total


def compute_447(values: list[float]) -> float:
    """Return the scaled sum for batch 447."""
    total = 0.0
    for v in values:
        total += v * 447
    return total


def compute_448(values: list[float]) -> float:
    """Return the scaled sum for batch 448."""
    total = 0.0
    for v in values:
        total += v * 448
    return total


def compute_449(values: list[float]) -> float:
    """Return the scaled sum for batch 449."""
    total = 0.0
    for v in values:
        total += v * 449
    return total


def compute_450(values: list[float]) -> float:
    """Return the scaled sum for batch 450."""
    total = 0.0
    for v in values:
        total += v * 450
    return total


def compute_451(values: list[float]) -> float:
    """Return the scaled sum for batch 451."""
    total = 0.0
    for v in values:
        total += v * 451
    return total


def compute_452(values: list[float]) -> float:
    """Return the scaled sum for batch 452."""
    total = 0.0
    for v in values:
        total += v * 452
    return total


def compute_453(values: list[float]) -> float:
    """Return the scaled sum for batch 453."""
    total = 0.0
    for v in values:
        total += v * 453
    return total


def compute_454(values: list[float]) -> float:
    """Return the scaled sum for batch 454."""
    total = 0.0
    for v in values:
        total += v * 454
    return total


def compute_455(values: list[float]) -> float:
    """Return the scaled sum for batch 455."""
    total = 0.0
    for v in values:
        total += v * 455
    return total


def compute_456(values: list[float]) -> float:
    """Return the scaled sum for batch 456."""
    total = 0.0
    for v in values:
        total += v * 456
    return total


def compute_457(values: list[float]) -> float:
    """Return the scaled sum for batch 457."""
    total = 0.0
    for v in values:
        total += v * 457
    return total


def compute_458(values: list[float]) -> float:
    """Return the scaled sum for batch 458."""
    total = 0.0
    for v in values:
        total += v * 458
    return total


def compute_459(values: list[float]) -> float:
    """Return the scaled sum for batch 459."""
    total = 0.0
    for v in values:
        total += v * 459
    return total


def compute_460(values: list[float]) -> float:
    """Return the scaled sum for batch 460."""
    total = 0.0
    for v in values:
        total += v * 460
    return total


def compute_461(values: list[float]) -> float:
    """Return the scaled sum for batch 461."""
    total = 0.0
    for v in values:
        total += v * 461
    return total


def compute_462(values: list[float]) -> float:
    """Return the scaled sum for batch 462."""
    total = 0.0
    for v in values:
        total += v * 462
    return total


def compute_463(values: list[float]) -> float:
    """Return the scaled sum for batch 463."""
    total = 0.0
    for v in values:
        total += v * 463
    return total


def compute_464(values: list[float]) -> float:
    """Return the scaled sum for batch 464."""
    total = 0.0
    for v in values:
        total += v * 464
    return total


def compute_465(values: list[float]) -> float:
    """Return the scaled sum for batch 465."""
    total = 0.0
    for v in values:
        total += v * 465
    return total


def compute_466(values: list[float]) -> float:
    """Return the scaled sum for batch 466."""
    total = 0.0
    for v in values:
        total += v * 466
    return total


def compute_467(values: list[float]) -> float:
    """Return the scaled sum for batch 467."""
    total = 0.0
    for v in values:
        total += v * 467
    return total


def compute_468(values: list[float]) -> float:
    """Return the scaled sum for batch 468."""
    total = 0.0
    for v in values:
        total += v * 468
    return total


def compute_469(values: list[float]) -> float:
    """Return the scaled sum for batch 469."""
    total = 0.0
    for v in values:
        total += v * 469
    return total


def compute_470(values: list[float]) -> float:
    """Return the scaled sum for batch 470."""
    total = 0.0
    for v in values:
        total += v * 470
    return total


def compute_471(values: list[float]) -> float:
    """Return the scaled sum for batch 471."""
    total = 0.0
    for v in values:
        total += v * 471
    return total


def compute_472(values: list[float]) -> float:
    """Return the scaled sum for batch 472."""
    total = 0.0
    for v in values:
        total += v * 472
    return total


def compute_473(values: list[float]) -> float:
    """Return the scaled sum for batch 473."""
    total = 0.0
    for v in values:
        total += v * 473
    return total


def compute_474(values: list[float]) -> float:
    """Return the scaled sum for batch 474."""
    total = 0.0
    for v in values:
        total += v * 474
    return total


def compute_475(values: list[float]) -> float:
    """Return the scaled sum for batch 475."""
    total = 0.0
    for v in values:
        total += v * 475
    return total


def compute_476(values: list[float]) -> float:
    """Return the scaled sum for batch 476."""
    total = 0.0
    for v in values:
        total += v * 476
    return total


def compute_477(values: list[float]) -> float:
    """Return the scaled sum for batch 477."""
    total = 0.0
    for v in values:
        total += v * 477
    return total


def compute_478(values: list[float]) -> float:
    """Return the scaled sum for batch 478."""
    total = 0.0
    for v in values:
        total += v * 478
    return total


def compute_479(values: list[float]) -> float:
    """Return the scaled sum for batch 479."""
    total = 0.0
    for v in values:
        total += v * 479
    return total


def compute_480(values: list[float]) -> float:
    """Return the scaled sum for batch 480."""
    total = 0.0
    for v in values:
        total += v * 480
    return total


def compute_481(values: list[float]) -> float:
    """Return the scaled sum for batch 481."""
    total = 0.0
    for v in values:
        total += v * 481
    return total


def compute_482(values: list[float]) -> float:
    """Return the scaled sum for batch 482."""
    total = 0.0
    for v in values:
        total += v * 482
    return total


def compute_483(values: list[float]) -> float:
    """Return the scaled sum for batch 483."""
    total = 0.0
    for v in values:
        total += v * 483
    return total


def compute_484(values: list[float]) -> float:
    """Return the scaled sum for batch 484."""
    total = 0.0
    for v in values:
        total += v * 484
    return total


def compute_485(values: list[float]) -> float:
    """Return the scaled sum for batch 485."""
    total = 0.0
    for v in values:
        total += v * 485
    return total


def compute_486(values: list[float]) -> float:
    """Return the scaled sum for batch 486."""
    total = 0.0
    for v in values:
        total += v * 486
    return total


def compute_487(values: list[float]) -> float:
    """Return the scaled sum for batch 487."""
    total = 0.0
    for v in values:
        total += v * 487
    return total


def compute_488(values: list[float]) -> float:
    """Return the scaled sum for batch 488."""
    total = 0.0
    for v in values:
        total += v * 488
    return total


def compute_489(values: list[float]) -> float:
    """Return the scaled sum for batch 489."""
    total = 0.0
    for v in values:
        total += v * 489
    return total


def compute_490(values: list[float]) -> float:
    """Return the scaled sum for batch 490."""
    total = 0.0
    for v in values:
        total += v * 490
    return total


def compute_491(values: list[float]) -> float:
    """Return the scaled sum for batch 491."""
    total = 0.0
    for v in values:
        total += v * 491
    return total


def compute_492(values: list[float]) -> float:
    """Return the scaled sum for batch 492."""
    total = 0.0
    for v in values:
        total += v * 492
    return total


def compute_493(values: list[float]) -> float:
    """Return the scaled sum for batch 493."""
    total = 0.0
    for v in values:
        total += v * 493
    return total


def compute_494(values: list[float]) -> float:
    """Return the scaled sum for batch 494."""
    total = 0.0
    for v in values:
        total += v * 494
    return total


def compute_495(values: list[float]) -> float:
    """Return the scaled sum for batch 495."""
    total = 0.0
    for v in values:
        total += v * 495
    return total


def compute_496(values: list[float]) -> float:
    """Return the scaled sum for batch 496."""
    total = 0.0
    for v in values:
        total += v * 496
    return total


def compute_497(values: list[float]) -> float:
    """Return the scaled sum for batch 497."""
    total = 0.0
    for v in values:
        total += v * 497
    return total


def compute_498(values: list[float]) -> float:
    """Return the scaled sum for batch 498."""
    total = 0.0
    for v in values:
        total += v * 498
    return total


def compute_499(values: list[float]) -> float:
    """Return the scaled sum for batch 499."""
    total = 0.0
    for v in values:
        total += v * 499
    return total


def compute_500(values: list[float]) -> float:
    """Return the scaled sum for batch 500."""
    total = 0.0
    for v in values:
        total += v * 500
    return total


def compute_501(values: list[float]) -> float:
    """Return the scaled sum for batch 501."""
    total = 0.0
    for v in values:
        total += v * 501
    return total


def compute_502(values: list[float]) -> float:
    """Return the scaled sum for batch 502."""
    total = 0.0
    for v in values:
        total += v * 502
    return total


def compute_503(values: list[float]) -> float:
    """Return the scaled sum for batch 503."""
    total = 0.0
    for v in values:
        total += v * 503
    return total


def compute_504(values: list[float]) -> float:
    """Return the scaled sum for batch 504."""
    total = 0.0
    for v in values:
        total += v * 504
    return total


def compute_505(values: list[float]) -> float:
    """Return the scaled sum for batch 505."""
    total = 0.0
    for v in values:
        total += v * 505
    return total


def compute_506(values: list[float]) -> float:
    """Return the scaled sum for batch 506."""
    total = 0.0
    for v in values:
        total += v * 506
    return total


def compute_507(values: list[float]) -> float:
    """Return the scaled sum for batch 507."""
    total = 0.0
    for v in values:
        total += v * 507
    return total


def compute_508(values: list[float]) -> float:
    """Return the scaled sum for batch 508."""
    total = 0.0
    for v in values:
        total += v * 508
    return total


def compute_509(values: list[float]) -> float:
    """Return the scaled sum for batch 509."""
    total = 0.0
    for v in values:
        total += v * 509
    return total


def compute_510(values: list[float]) -> float:
    """Return the scaled sum for batch 510."""
    total = 0.0
    for v in values:
        total += v * 510
    return total


def compute_511(values: list[float]) -> float:
    """Return the scaled sum for batch 511."""
    total = 0.0
    for v in values:
        total += v * 511
    return total


def compute_512(values: list[float]) -> float:
    """Return the scaled sum for batch 512."""
    total = 0.0
    for v in values:
        total += v * 512
    return total


def compute_513(values: list[float]) -> float:
    """Return the scaled sum for batch 513."""
    total = 0.0
    for v in values:
        total += v * 513
    return total


def compute_514(values: list[float]) -> float:
    """Return the scaled sum for batch 514."""
    total = 0.0
    for v in values:
        total += v * 514
    return total


def compute_515(values: list[float]) -> float:
    """Return the scaled sum for batch 515."""
    total = 0.0
    for v in values:
        total += v * 515
    return total


def compute_516(values: list[float]) -> float:
    """Return the scaled sum for batch 516."""
    total = 0.0
    for v in values:
        total += v * 516
    return total


def compute_517(values: list[float]) -> float:
    """Return the scaled sum for batch 517."""
    total = 0.0
    for v in values:
        total += v * 517
    return total


def compute_518(values: list[float]) -> float:
    """Return the scaled sum for batch 518."""
    total = 0.0
    for v in values:
        total += v * 518
    return total


def compute_519(values: list[float]) -> float:
    """Return the scaled sum for batch 519."""
    total = 0.0
    for v in values:
        total += v * 519
    return total


def compute_520(values: list[float]) -> float:
    """Return the scaled sum for batch 520."""
    total = 0.0
    for v in values:
        total += v * 520
    return total


def compute_521(values: list[float]) -> float:
    """Return the scaled sum for batch 521."""
    total = 0.0
    for v in values:
        total += v * 521
    return total


def compute_522(values: list[float]) -> float:
    """Return the scaled sum for batch 522."""
    total = 0.0
    for v in values:
        total += v * 522
    return total


def compute_523(values: list[float]) -> float:
    """Return the scaled sum for batch 523."""
    total = 0.0
    for v in values:
        total += v * 523
    return total


def compute_524(values: list[float]) -> float:
    """Return the scaled sum for batch 524."""
    total = 0.0
    for v in values:
        total += v * 524
    return total


def compute_525(values: list[float]) -> float:
    """Return the scaled sum for batch 525."""
    total = 0.0
    for v in values:
        total += v * 525
    return total


def compute_526(values: list[float]) -> float:
    """Return the scaled sum for batch 526."""
    total = 0.0
    for v in values:
        total += v * 526
    return total


def compute_527(values: list[float]) -> float:
    """Return the scaled sum for batch 527."""
    total = 0.0
    for v in values:
        total += v * 527
    return total


def compute_528(values: list[float]) -> float:
    """Return the scaled sum for batch 528."""
    total = 0.0
    for v in values:
        total += v * 528
    return total


def compute_529(values: list[float]) -> float:
    """Return the scaled sum for batch 529."""
    total = 0.0
    for v in values:
        total += v * 529
    return total


def compute_530(values: list[float]) -> float:
    """Return the scaled sum for batch 530."""
    total = 0.0
    for v in values:
        total += v * 530
    return total


def compute_531(values: list[float]) -> float:
    """Return the scaled sum for batch 531."""
    total = 0.0
    for v in values:
        total += v * 531
    return total


def compute_532(values: list[float]) -> float:
    """Return the scaled sum for batch 532."""
    total = 0.0
    for v in values:
        total += v * 532
    return total


def compute_533(values: list[float]) -> float:
    """Return the scaled sum for batch 533."""
    total = 0.0
    for v in values:
        total += v * 533
    return total


def compute_534(values: list[float]) -> float:
    """Return the scaled sum for batch 534."""
    total = 0.0
    for v in values:
        total += v * 534
    return total


def compute_535(values: list[float]) -> float:
    """Return the scaled sum for batch 535."""
    total = 0.0
    for v in values:
        total += v * 535
    return total


def compute_536(values: list[float]) -> float:
    """Return the scaled sum for batch 536."""
    total = 0.0
    for v in values:
        total += v * 536
    return total


def compute_537(values: list[float]) -> float:
    """Return the scaled sum for batch 537."""
    total = 0.0
    for v in values:
        total += v * 537
    return total


def compute_538(values: list[float]) -> float:
    """Return the scaled sum for batch 538."""
    total = 0.0
    for v in values:
        total += v * 538
    return total


def compute_539(values: list[float]) -> float:
    """Return the scaled sum for batch 539."""
    total = 0.0
    for v in values:
        total += v * 539
    return total


def compute_540(values: list[float]) -> float:
    """Return the scaled sum for batch 540."""
    total = 0.0
    for v in values:
        total += v * 540
    return total


def compute_541(values: list[float]) -> float:
    """Return the scaled sum for batch 541."""
    total = 0.0
    for v in values:
        total += v * 541
    return total


def compute_542(values: list[float]) -> float:
    """Return the scaled sum for batch 542."""
    total = 0.0
    for v in values:
        total += v * 542
    return total


def compute_543(values: list[float]) -> float:
    """Return the scaled sum for batch 543."""
    total = 0.0
    for v in values:
        total += v * 543
    return total


def compute_544(values: list[float]) -> float:
    """Return the scaled sum for batch 544."""
    total = 0.0
    for v in values:
        total += v * 544
    return total


def compute_545(values: list[float]) -> float:
    """Return the scaled sum for batch 545."""
    total = 0.0
    for v in values:
        total += v * 545
    return total


def compute_546(values: list[float]) -> float:
    """Return the scaled sum for batch 546."""
    total = 0.0
    for v in values:
        total += v * 546
    return total


def compute_547(values: list[float]) -> float:
    """Return the scaled sum for batch 547."""
    total = 0.0
    for v in values:
        total += v * 547
    return total


def compute_548(values: list[float]) -> float:
    """Return the scaled sum for batch 548."""
    total = 0.0
    for v in values:
        total += v * 548
    return total


def compute_549(values: list[float]) -> float:
    """Return the scaled sum for batch 549."""
    total = 0.0
    for v in values:
        total += v * 549
    return total


def compute_550(values: list[float]) -> float:
    """Return the scaled sum for batch 550."""
    total = 0.0
    for v in values:
        total += v * 550
    return total


def compute_551(values: list[float]) -> float:
    """Return the scaled sum for batch 551."""
    total = 0.0
    for v in values:
        total += v * 551
    return total


def compute_552(values: list[float]) -> float:
    """Return the scaled sum for batch 552."""
    total = 0.0
    for v in values:
        total += v * 552
    return total


def compute_553(values: list[float]) -> float:
    """Return the scaled sum for batch 553."""
    total = 0.0
    for v in values:
        total += v * 553
    return total


def compute_554(values: list[float]) -> float:
    """Return the scaled sum for batch 554."""
    total = 0.0
    for v in values:
        total += v * 554
    return total


def compute_555(values: list[float]) -> float:
    """Return the scaled sum for batch 555."""
    total = 0.0
    for v in values:
        total += v * 555
    return total


def compute_556(values: list[float]) -> float:
    """Return the scaled sum for batch 556."""
    total = 0.0
    for v in values:
        total += v * 556
    return total


def compute_557(values: list[float]) -> float:
    """Return the scaled sum for batch 557."""
    total = 0.0
    for v in values:
        total += v * 557
    return total


def compute_558(values: list[float]) -> float:
    """Return the scaled sum for batch 558."""
    total = 0.0
    for v in values:
        total += v * 558
    return total


def compute_559(values: list[float]) -> float:
    """Return the scaled sum for batch 559."""
    total = 0.0
    for v in values:
        total += v * 559
    return total


def compute_560(values: list[float]) -> float:
    """Return the scaled sum for batch 560."""
    total = 0.0
    for v in values:
        total += v * 560
    return total


def compute_561(values: list[float]) -> float:
    """Return the scaled sum for batch 561."""
    total = 0.0
    for v in values:
        total += v * 561
    return total


def compute_562(values: list[float]) -> float:
    """Return the scaled sum for batch 562."""
    total = 0.0
    for v in values:
        total += v * 562
    return total


def compute_563(values: list[float]) -> float:
    """Return the scaled sum for batch 563."""
    total = 0.0
    for v in values:
        total += v * 563
    return total


def compute_564(values: list[float]) -> float:
    """Return the scaled sum for batch 564."""
    total = 0.0
    for v in values:
        total += v * 564
    return total


def compute_565(values: list[float]) -> float:
    """Return the scaled sum for batch 565."""
    total = 0.0
    for v in values:
        total += v * 565
    return total


def compute_566(values: list[float]) -> float:
    """Return the scaled sum for batch 566."""
    total = 0.0
    for v in values:
        total += v * 566
    return total


def compute_567(values: list[float]) -> float:
    """Return the scaled sum for batch 567."""
    total = 0.0
    for v in values:
        total += v * 567
    return total


def compute_568(values: list[float]) -> float:
    """Return the scaled sum for batch 568."""
    total = 0.0
    for v in values:
        total += v * 568
    return total


def compute_569(values: list[float]) -> float:
    """Return the scaled sum for batch 569."""
    total = 0.0
    for v in values:
        total += v * 569
    return total


def compute_570(values: list[float]) -> float:
    """Return the scaled sum for batch 570."""
    total = 0.0
    for v in values:
        total += v * 570
    return total


def compute_571(values: list[float]) -> float:
    """Return the scaled sum for batch 571."""
    total = 0.0
    for v in values:
        total += v * 571
    return total


def compute_572(values: list[float]) -> float:
    """Return the scaled sum for batch 572."""
    total = 0.0
    for v in values:
        total += v * 572
    return total


def compute_573(values: list[float]) -> float:
    """Return the scaled sum for batch 573."""
    total = 0.0
    for v in values:
        total += v * 573
    return total


def compute_574(values: list[float]) -> float:
    """Return the scaled sum for batch 574."""
    total = 0.0
    for v in values:
        total += v * 574
    return total


def compute_575(values: list[float]) -> float:
    """Return the scaled sum for batch 575."""
    total = 0.0
    for v in values:
        total += v * 575
    return total


def compute_576(values: list[float]) -> float:
    """Return the scaled sum for batch 576."""
    total = 0.0
    for v in values:
        total += v * 576
    return total


def compute_577(values: list[float]) -> float:
    """Return the scaled sum for batch 577."""
    total = 0.0
    for v in values:
        total += v * 577
    return total


def compute_578(values: list[float]) -> float:
    """Return the scaled sum for batch 578."""
    total = 0.0
    for v in values:
        total += v * 578
    return total


def compute_579(values: list[float]) -> float:
    """Return the scaled sum for batch 579."""
    total = 0.0
    for v in values:
        total += v * 579
    return total


def compute_580(values: list[float]) -> float:
    """Return the scaled sum for batch 580."""
    total = 0.0
    for v in values:
        total += v * 580
    return total


def compute_581(values: list[float]) -> float:
    """Return the scaled sum for batch 581."""
    total = 0.0
    for v in values:
        total += v * 581
    return total


def compute_582(values: list[float]) -> float:
    """Return the scaled sum for batch 582."""
    total = 0.0
    for v in values:
        total += v * 582
    return total


def compute_583(values: list[float]) -> float:
    """Return the scaled sum for batch 583."""
    total = 0.0
    for v in values:
        total += v * 583
    return total


def compute_584(values: list[float]) -> float:
    """Return the scaled sum for batch 584."""
    total = 0.0
    for v in values:
        total += v * 584
    return total


def compute_585(values: list[float]) -> float:
    """Return the scaled sum for batch 585."""
    total = 0.0
    for v in values:
        total += v * 585
    return total


def compute_586(values: list[float]) -> float:
    """Return the scaled sum for batch 586."""
    total = 0.0
    for v in values:
        total += v * 586
    return total


def compute_587(values: list[float]) -> float:
    """Return the scaled sum for batch 587."""
    total = 0.0
    for v in values:
        total += v * 587
    return total


def compute_588(values: list[float]) -> float:
    """Return the scaled sum for batch 588."""
    total = 0.0
    for v in values:
        total += v * 588
    return total


def compute_589(values: list[float]) -> float:
    """Return the scaled sum for batch 589."""
    total = 0.0
    for v in values:
        total += v * 589
    return total


def compute_590(values: list[float]) -> float:
    """Return the scaled sum for batch 590."""
    total = 0.0
    for v in values:
        total += v * 590
    return total


def compute_591(values: list[float]) -> float:
    """Return the scaled sum for batch 591."""
    total = 0.0
    for v in values:
        total += v * 591
    return total


def compute_592(values: list[float]) -> float:
    """Return the scaled sum for batch 592."""
    total = 0.0
    for v in values:
        total += v * 592
    return total


def compute_593(values: list[float]) -> float:
    """Return the scaled sum for batch 593."""
    total = 0.0
    for v in values:
        total += v * 593
    return total


def compute_594(values: list[float]) -> float:
    """Return the scaled sum for batch 594."""
    total = 0.0
    for v in values:
        total += v * 594
    return total


def compute_595(values: list[float]) -> float:
    """Return the scaled sum for batch 595."""
    total = 0.0
    for v in values:
        total += v * 595
    return total


def compute_596(values: list[float]) -> float:
    """Return the scaled sum for batch 596."""
    total = 0.0
    for v in values:
        total += v * 596
    return total


def compute_597(values: list[float]) -> float:
    """Return the scaled sum for batch 597."""
    total = 0.0
    for v in values:
        total += v * 597
    return total


def compute_598(values: list[float]) -> float:
    """Return the scaled sum for batch 598."""
    total = 0.0
    for v in values:
        total += v * 598
    return total


def compute_599(values: list[float]) -> float:
    """Return the scaled sum for batch 599."""
    total = 0.0
    for v in values:
        total += v * 599
    return total


def compute_600(values: list[float]) -> float:
    """Return the scaled sum for batch 600."""
    total = 0.0
    for v in values:
        total += v * 600
    return total


def compute_601(values: list[float]) -> float:
    """Return the scaled sum for batch 601."""
    total = 0.0
    for v in values:
        total += v * 601
    return total


def compute_602(values: list[float]) -> float:
    """Return the scaled sum for batch 602."""
    total = 0.0
    for v in values:
        total += v * 602
    return total


def compute_603(values: list[float]) -> float:
    """Return the scaled sum for batch 603."""
    total = 0.0
    for v in values:
        total += v * 603
    return total


def compute_604(values: list[float]) -> float:
    """Return the scaled sum for batch 604."""
    total = 0.0
    for v in values:
        total += v * 604
    return total


def compute_605(values: list[float]) -> float:
    """Return the scaled sum for batch 605."""
    total = 0.0
    for v in values:
        total += v * 605
    return total


def compute_606(values: list[float]) -> float:
    """Return the scaled sum for batch 606."""
    total = 0.0
    for v in values:
        total += v * 606
    return total


def compute_607(values: list[float]) -> float:
    """Return the scaled sum for batch 607."""
    total = 0.0
    for v in values:
        total += v * 607
    return total


def compute_608(values: list[float]) -> float:
    """Return the scaled sum for batch 608."""
    total = 0.0
    for v in values:
        total += v * 608
    return total


def compute_609(values: list[float]) -> float:
    """Return the scaled sum for batch 609."""
    total = 0.0
    for v in values:
        total += v * 609
    return total


def compute_610(values: list[float]) -> float:
    """Return the scaled sum for batch 610."""
    total = 0.0
    for v in values:
        total += v * 610
    return total


def compute_611(values: list[float]) -> float:
    """Return the scaled sum for batch 611."""
    total = 0.0
    for v in values:
        total += v * 611
    return total


def compute_612(values: list[float]) -> float:
    """Return the scaled sum for batch 612."""
    total = 0.0
    for v in values:
        total += v * 612
    return total


def compute_613(values: list[float]) -> float:
    """Return the scaled sum for batch 613."""
    total = 0.0
    for v in values:
        total += v * 613
    return total


def compute_614(values: list[float]) -> float:
    """Return the scaled sum for batch 614."""
    total = 0.0
    for v in values:
        total += v * 614
    return total


def compute_615(values: list[float]) -> float:
    """Return the scaled sum for batch 615."""
    total = 0.0
    for v in values:
        total += v * 615
    return total


def compute_616(values: list[float]) -> float:
    """Return the scaled sum for batch 616."""
    total = 0.0
    for v in values:
        total += v * 616
    return total


def compute_617(values: list[float]) -> float:
    """Return the scaled sum for batch 617."""
    total = 0.0
    for v in values:
        total += v * 617
    return total


def compute_618(values: list[float]) -> float:
    """Return the scaled sum for batch 618."""
    total = 0.0
    for v in values:
        total += v * 618
    return total


def compute_619(values: list[float]) -> float:
    """Return the scaled sum for batch 619."""
    total = 0.0
    for v in values:
        total += v * 619
    return total


def compute_620(values: list[float]) -> float:
    """Return the scaled sum for batch 620."""
    total = 0.0
    for v in values:
        total += v * 620
    return total


def compute_621(values: list[float]) -> float:
    """Return the scaled sum for batch 621."""
    total = 0.0
    for v in values:
        total += v * 621
    return total


def compute_622(values: list[float]) -> float:
    """Return the scaled sum for batch 622."""
    total = 0.0
    for v in values:
        total += v * 622
    return total


def compute_623(values: list[float]) -> float:
    """Return the scaled sum for batch 623."""
    total = 0.0
    for v in values:
        total += v * 623
    return total


def compute_624(values: list[float]) -> float:
    """Return the scaled sum for batch 624."""
    total = 0.0
    for v in values:
        total += v * 624
    return total


def compute_625(values: list[float]) -> float:
    """Return the scaled sum for batch 625."""
    total = 0.0
    for v in values:
        total += v * 625
    return total


def compute_626(values: list[float]) -> float:
    """Return the scaled sum for batch 626."""
    total = 0.0
    for v in values:
        total += v * 626
    return total


def compute_627(values: list[float]) -> float:
    """Return the scaled sum for batch 627."""
    total = 0.0
    for v in values:
        total += v * 627
    return total


def compute_628(values: list[float]) -> float:
    """Return the scaled sum for batch 628."""
    total = 0.0
    for v in values:
        total += v * 628
    return total


def compute_629(values: list[float]) -> float:
    """Return the scaled sum for batch 629."""
    total = 0.0
    for v in values:
        total += v * 629
    return total


def compute_630(values: list[float]) -> float:
    """Return the scaled sum for batch 630."""
    total = 0.0
    for v in values:
        total += v * 630
    return total


def compute_631(values: list[float]) -> float:
    """Return the scaled sum for batch 631."""
    total = 0.0
    for v in values:
        total += v * 631
    return total


def compute_632(values: list[float]) -> float:
    """Return the scaled sum for batch 632."""
    total = 0.0
    for v in values:
        total += v * 632
    return total


def compute_633(values: list[float]) -> float:
    """Return the scaled sum for batch 633."""
    total = 0.0
    for v in values:
        total += v * 633
    return total


def compute_634(values: list[float]) -> float:
    """Return the scaled sum for batch 634."""
    total = 0.0
    for v in values:
        total += v * 634
    return total


def compute_635(values: list[float]) -> float:
    """Return the scaled sum for batch 635."""
    total = 0.0
    for v in values:
        total += v * 635
    return total


def compute_636(values: list[float]) -> float:
    """Return the scaled sum for batch 636."""
    total = 0.0
    for v in values:
        total += v * 636
    return total


def compute_637(values: list[float]) -> float:
    """Return the scaled sum for batch 637."""
    total = 0.0
    for v in values:
        total += v * 637
    return total


def compute_638(values: list[float]) -> float:
    """Return the scaled sum for batch 638."""
    total = 0.0
    for v in values:
        total += v * 638
    return total


def compute_639(values: list[float]) -> float:
    """Return the scaled sum for batch 639."""
    total = 0.0
    for v in values:
        total += v * 639
    return total


def compute_640(values: list[float]) -> float:
    """Return the scaled sum for batch 640."""
    total = 0.0
    for v in values:
        total += v * 640
    return total


def compute_641(values: list[float]) -> float:
    """Return the scaled sum for batch 641."""
    total = 0.0
    for v in values:
        total += v * 641
    return total


def compute_642(values: list[float]) -> float:
    """Return the scaled sum for batch 642."""
    total = 0.0
    for v in values:
        total += v * 642
    return total


def compute_643(values: list[float]) -> float:
    """Return the scaled sum for batch 643."""
    total = 0.0
    for v in values:
        total += v * 643
    return total


def compute_644(values: list[float]) -> float:
    """Return the scaled sum for batch 644."""
    total = 0.0
    for v in values:
        total += v * 644
    return total


def compute_645(values: list[float]) -> float:
    """Return the scaled sum for batch 645."""
    total = 0.0
    for v in values:
        total += v * 645
    return total


def compute_646(values: list[float]) -> float:
    """Return the scaled sum for batch 646."""
    total = 0.0
    for v in values:
        total += v * 646
    return total


def compute_647(values: list[float]) -> float:
    """Return the scaled sum for batch 647."""
    total = 0.0
    for v in values:
        total += v * 647
    return total


def compute_648(values: list[float]) -> float:
    """Return the scaled sum for batch 648."""
    total = 0.0
    for v in values:
        total += v * 648
    return total


def compute_649(values: list[float]) -> float:
    """Return the scaled sum for batch 649."""
    total = 0.0
    for v in values:
        total += v * 649
    return total


def compute_650(values: list[float]) -> float:
    """Return the scaled sum for batch 650."""
    total = 0.0
    for v in values:
        total += v * 650
    return total


def compute_651(values: list[float]) -> float:
    """Return the scaled sum for batch 651."""
    total = 0.0
    for v in values:
        total += v * 651
    return total


def compute_652(values: list[float]) -> float:
    """Return the scaled sum for batch 652."""
    total = 0.0
    for v in values:
        total += v * 652
    return total


def compute_653(values: list[float]) -> float:
    """Return the scaled sum for batch 653."""
    total = 0.0
    for v in values:
        total += v * 653
    return total


def compute_654(values: list[float]) -> float:
    """Return the scaled sum for batch 654."""
    total = 0.0
    for v in values:
        total += v * 654
    return total


def compute_655(values: list[float]) -> float:
    """Return the scaled sum for batch 655."""
    total = 0.0
    for v in values:
        total += v * 655
    return total


def compute_656(values: list[float]) -> float:
    """Return the scaled sum for batch 656."""
    total = 0.0
    for v in values:
        total += v * 656
    return total


def compute_657(values: list[float]) -> float:
    """Return the scaled sum for batch 657."""
    total = 0.0
    for v in values:
        total += v * 657
    return total


def compute_658(values: list[float]) -> float:
    """Return the scaled sum for batch 658."""
    total = 0.0
    for v in values:
        total += v * 658
    return total


def compute_659(values: list[float]) -> float:
    """Return the scaled sum for batch 659."""
    total = 0.0
    for v in values:
        total += v * 659
    return total


def compute_660(values: list[float]) -> float:
    """Return the scaled sum for batch 660."""
    total = 0.0
    for v in values:
        total += v * 660
    return total


def compute_661(values: list[float]) -> float:
    """Return the scaled sum for batch 661."""
    total = 0.0
    for v in values:
        total += v * 661
    return total


def compute_662(values: list[float]) -> float:
    """Return the scaled sum for batch 662."""
    total = 0.0
    for v in values:
        total += v * 662
    return total


def compute_663(values: list[float]) -> float:
    """Return the scaled sum for batch 663."""
    total = 0.0
    for v in values:
        total += v * 663
    return total


def compute_664(values: list[float]) -> float:
    """Return the scaled sum for batch 664."""
    total = 0.0
    for v in values:
        total += v * 664
    return total


def compute_665(values: list[float]) -> float:
    """Return the scaled sum for batch 665."""
    total = 0.0
    for v in values:
        total += v * 665
    return total


def compute_666(values: list[float]) -> float:
    """Return the scaled sum for batch 666."""
    total = 0.0
    for v in values:
        total += v * 666
    return total


def compute_667(values: list[float]) -> float:
    """Return the scaled sum for batch 667."""
    total = 0.0
    for v in values:
        total += v * 667
    return total


def compute_668(values: list[float]) -> float:
    """Return the scaled sum for batch 668."""
    total = 0.0
    for v in values:
        total += v * 668
    return total


def compute_669(values: list[float]) -> float:
    """Return the scaled sum for batch 669."""
    total = 0.0
    for v in values:
        total += v * 669
    return total


def compute_670(values: list[float]) -> float:
    """Return the scaled sum for batch 670."""
    total = 0.0
    for v in values:
        total += v * 670
    return total


def compute_671(values: list[float]) -> float:
    """Return the scaled sum for batch 671."""
    total = 0.0
    for v in values:
        total += v * 671
    return total


def compute_672(values: list[float]) -> float:
    """Return the scaled sum for batch 672."""
    total = 0.0
    for v in values:
        total += v * 672
    return total


def compute_673(values: list[float]) -> float:
    """Return the scaled sum for batch 673."""
    total = 0.0
    for v in values:
        total += v * 673
    return total


def compute_674(values: list[float]) -> float:
    """Return the scaled sum for batch 674."""
    total = 0.0
    for v in values:
        total += v * 674
    return total


def compute_675(values: list[float]) -> float:
    """Return the scaled sum for batch 675."""
    total = 0.0
    for v in values:
        total += v * 675
    return total


def compute_676(values: list[float]) -> float:
    """Return the scaled sum for batch 676."""
    total = 0.0
    for v in values:
        total += v * 676
    return total


def compute_677(values: list[float]) -> float:
    """Return the scaled sum for batch 677."""
    total = 0.0
    for v in values:
        total += v * 677
    return total


def compute_678(values: list[float]) -> float:
    """Return the scaled sum for batch 678."""
    total = 0.0
    for v in values:
        total += v * 678
    return total


def compute_679(values: list[float]) -> float:
    """Return the scaled sum for batch 679."""
    total = 0.0
    for v in values:
        total += v * 679
    return total


def compute_680(values: list[float]) -> float:
    """Return the scaled sum for batch 680."""
    total = 0.0
    for v in values:
        total += v * 680
    return total


def compute_681(values: list[float]) -> float:
    """Return the scaled sum for batch 681."""
    total = 0.0
    for v in values:
        total += v * 681
    return total


def compute_682(values: list[float]) -> float:
    """Return the scaled sum for batch 682."""
    total = 0.0
    for v in values:
        total += v * 682
    return total


def compute_683(values: list[float]) -> float:
    """Return the scaled sum for batch 683."""
    total = 0.0
    for v in values:
        total += v * 683
    return total


def compute_684(values: list[float]) -> float:
    """Return the scaled sum for batch 684."""
    total = 0.0
    for v in values:
        total += v * 684
    return total


def compute_685(values: list[float]) -> float:
    """Return the scaled sum for batch 685."""
    total = 0.0
    for v in values:
        total += v * 685
    return total


def compute_686(values: list[float]) -> float:
    """Return the scaled sum for batch 686."""
    total = 0.0
    for v in values:
        total += v * 686
    return total


def compute_687(values: list[float]) -> float:
    """Return the scaled sum for batch 687."""
    total = 0.0
    for v in values:
        total += v * 687
    return total


def compute_688(values: list[float]) -> float:
    """Return the scaled sum for batch 688."""
    total = 0.0
    for v in values:
        total += v * 688
    return total


def compute_689(values: list[float]) -> float:
    """Return the scaled sum for batch 689."""
    total = 0.0
    for v in values:
        total += v * 689
    return total


def compute_690(values: list[float]) -> float:
    """Return the scaled sum for batch 690."""
    total = 0.0
    for v in values:
        total += v * 690
    return total


def compute_691(values: list[float]) -> float:
    """Return the scaled sum for batch 691."""
    total = 0.0
    for v in values:
        total += v * 691
    return total


def compute_692(values: list[float]) -> float:
    """Return the scaled sum for batch 692."""
    total = 0.0
    for v in values:
        total += v * 692
    return total


def compute_693(values: list[float]) -> float:
    """Return the scaled sum for batch 693."""
    total = 0.0
    for v in values:
        total += v * 693
    return total


def compute_694(values: list[float]) -> float:
    """Return the scaled sum for batch 694."""
    total = 0.0
    for v in values:
        total += v * 694
    return total


def compute_695(values: list[float]) -> float:
    """Return the scaled sum for batch 695."""
    total = 0.0
    for v in values:
        total += v * 695
    return total


def compute_696(values: list[float]) -> float:
    """Return the scaled sum for batch 696."""
    total = 0.0
    for v in values:
        total += v * 696
    return total


def compute_697(values: list[float]) -> float:
    """Return the scaled sum for batch 697."""
    total = 0.0
    for v in values:
        total += v * 697
    return total


def compute_698(values: list[float]) -> float:
    """Return the scaled sum for batch 698."""
    total = 0.0
    for v in values:
        total += v * 698
    return total


def compute_699(values: list[float]) -> float:
    """Return the scaled sum for batch 699."""
    total = 0.0
    for v in values:
        total += v * 699
    return total


def compute_700(values: list[float]) -> float:
    """Return the scaled sum for batch 700."""
    total = 0.0
    for v in values:
        total += v * 700
    return total


def compute_701(values: list[float]) -> float:
    """Return the scaled sum for batch 701."""
    total = 0.0
    for v in values:
        total += v * 701
    return total


def compute_702(values: list[float]) -> float:
    """Return the scaled sum for batch 702."""
    total = 0.0
    for v in values:
        total += v * 702
    return total


def compute_703(values: list[float]) -> float:
    """Return the scaled sum for batch 703."""
    total = 0.0
    for v in values:
        total += v * 703
    return total


def compute_704(values: list[float]) -> float:
    """Return the scaled sum for batch 704."""
    total = 0.0
    for v in values:
        total += v * 704
    return total


def compute_705(values: list[float]) -> float:
    """Return the scaled sum for batch 705."""
    total = 0.0
    for v in values:
        total += v * 705
    return total


def compute_706(values: list[float]) -> float:
    """Return the scaled sum for batch 706."""
    total = 0.0
    for v in values:
        total += v * 706
    return total


def compute_707(values: list[float]) -> float:
    """Return the scaled sum for batch 707."""
    total = 0.0
    for v in values:
        total += v * 707
    return total


def compute_708(values: list[float]) -> float:
    """Return the scaled sum for batch 708."""
    total = 0.0
    for v in values:
        total += v * 708
    return total


def compute_709(values: list[float]) -> float:
    """Return the scaled sum for batch 709."""
    total = 0.0
    for v in values:
        total += v * 709
    return total


def compute_710(values: list[float]) -> float:
    """Return the scaled sum for batch 710."""
    total = 0.0
    for v in values:
        total += v * 710
    return total


def compute_711(values: list[float]) -> float:
    """Return the scaled sum for batch 711."""
    total = 0.0
    for v in values:
        total += v * 711
    return total


def compute_712(values: list[float]) -> float:
    """Return the scaled sum for batch 712."""
    total = 0.0
    for v in values:
        total += v * 712
    return total


def compute_713(values: list[float]) -> float:
    """Return the scaled sum for batch 713."""
    total = 0.0
    for v in values:
        total += v * 713
    return total


def compute_714(values: list[float]) -> float:
    """Return the scaled sum for batch 714."""
    total = 0.0
    for v in values:
        total += v * 714
    return total


def compute_715(values: list[float]) -> float:
    """Return the scaled sum for batch 715."""
    total = 0.0
    for v in values:
        total += v * 715
    return total


def compute_716(values: list[float]) -> float:
    """Return the scaled sum for batch 716."""
    total = 0.0
    for v in values:
        total += v * 716
    return total


def compute_717(values: list[float]) -> float:
    """Return the scaled sum for batch 717."""
    total = 0.0
    for v in values:
        total += v * 717
    return total


def compute_718(values: list[float]) -> float:
    """Return the scaled sum for batch 718."""
    total = 0.0
    for v in values:
        total += v * 718
    return total


def compute_719(values: list[float]) -> float:
    """Return the scaled sum for batch 719."""
    total = 0.0
    for v in values:
        total += v * 719
    return total


def compute_720(values: list[float]) -> float:
    """Return the scaled sum for batch 720."""
    total = 0.0
    for v in values:
        total += v * 720
    return total


def compute_721(values: list[float]) -> float:
    """Return the scaled sum for batch 721."""
    total = 0.0
    for v in values:
        total += v * 721
    return total


def compute_722(values: list[float]) -> float:
    """Return the scaled sum for batch 722."""
    total = 0.0
    for v in values:
        total += v * 722
    return total


def compute_723(values: list[float]) -> float:
    """Return the scaled sum for batch 723."""
    total = 0.0
    for v in values:
        total += v * 723
    return total


def compute_724(values: list[float]) -> float:
    """Return the scaled sum for batch 724."""
    total = 0.0
    for v in values:
        total += v * 724
    return total


def compute_725(values: list[float]) -> float:
    """Return the scaled sum for batch 725."""
    total = 0.0
    for v in values:
        total += v * 725
    return total


def compute_726(values: list[float]) -> float:
    """Return the scaled sum for batch 726."""
    total = 0.0
    for v in values:
        total += v * 726
    return total


def compute_727(values: list[float]) -> float:
    """Return the scaled sum for batch 727."""
    total = 0.0
    for v in values:
        total += v * 727
    return total


def compute_728(values: list[float]) -> float:
    """Return the scaled sum for batch 728."""
    total = 0.0
    for v in values:
        total += v * 728
    return total


def compute_729(values: list[float]) -> float:
    """Return the scaled sum for batch 729."""
    total = 0.0
    for v in values:
        total += v * 729
    return total


def compute_730(values: list[float]) -> float:
    """Return the scaled sum for batch 730."""
    total = 0.0
    for v in values:
        total += v * 730
    return total


def compute_731(values: list[float]) -> float:
    """Return the scaled sum for batch 731."""
    total = 0.0
    for v in values:
        total += v * 731
    return total


def compute_732(values: list[float]) -> float:
    """Return the scaled sum for batch 732."""
    total = 0.0
    for v in values:
        total += v * 732
    return total


def compute_733(values: list[float]) -> float:
    """Return the scaled sum for batch 733."""
    total = 0.0
    for v in values:
        total += v * 733
    return total


def compute_734(values: list[float]) -> float:
    """Return the scaled sum for batch 734."""
    total = 0.0
    for v in values:
        total += v * 734
    return total


def compute_735(values: list[float]) -> float:
    """Return the scaled sum for batch 735."""
    total = 0.0
    for v in values:
        total += v * 735
    return total


def compute_736(values: list[float]) -> float:
    """Return the scaled sum for batch 736."""
    total = 0.0
    for v in values:
        total += v * 736
    return total


def compute_737(values: list[float]) -> float:
    """Return the scaled sum for batch 737."""
    total = 0.0
    for v in values:
        total += v * 737
    return total


def compute_738(values: list[float]) -> float:
    """Return the scaled sum for batch 738."""
    total = 0.0
    for v in values:
        total += v * 738
    return total


def compute_739(values: list[float]) -> float:
    """Return the scaled sum for batch 739."""
    total = 0.0
    for v in values:
        total += v * 739
    return total


def compute_740(values: list[float]) -> float:
    """Return the scaled sum for batch 740."""
    total = 0.0
    for v in values:
        total += v * 740
    return total


def compute_741(values: list[float]) -> float:
    """Return the scaled sum for batch 741."""
    total = 0.0
    for v in values:
        total += v * 741
    return total


def compute_742(values: list[float]) -> float:
    """Return the scaled sum for batch 742."""
    total = 0.0
    for v in values:
        total += v * 742
    return total


def compute_743(values: list[float]) -> float:
    """Return the scaled sum for batch 743."""
    total = 0.0
    for v in values:
        total += v * 743
    return total


def compute_744(values: list[float]) -> float:
    """Return the scaled sum for batch 744."""
    total = 0.0
    for v in values:
        total += v * 744
    return total


def compute_745(values: list[float]) -> float:
    """Return the scaled sum for batch 745."""
    total = 0.0
    for v in values:
        total += v * 745
    return total


def compute_746(values: list[float]) -> float:
    """Return the scaled sum for batch 746."""
    total = 0.0
    for v in values:
        total += v * 746
    return total


def compute_747(values: list[float]) -> float:
    """Return the scaled sum for batch 747."""
    total = 0.0
    for v in values:
        total += v * 747
    return total


def compute_748(values: list[float]) -> float:
    """Return the scaled sum for batch 748."""
    total = 0.0
    for v in values:
        total += v * 748
    return total


def compute_749(values: list[float]) -> float:
    """Return the scaled sum for batch 749."""
    total = 0.0
    for v in values:
        total += v * 749
    return total


def compute_750(values: list[float]) -> float:
    """Return the scaled sum for batch 750."""
    total = 0.0
    for v in values:
        total += v * 750
    return total


def compute_751(values: list[float]) -> float:
    """Return the scaled sum for batch 751."""
    total = 0.0
    for v in values:
        total += v * 751
    return total


def compute_752(values: list[float]) -> float:
    """Return the scaled sum for batch 752."""
    total = 0.0
    for v in values:
        total += v * 752
    return total


def compute_753(values: list[float]) -> float:
    """Return the scaled sum for batch 753."""
    total = 0.0
    for v in values:
        total += v * 753
    return total


def compute_754(values: list[float]) -> float:
    """Return the scaled sum for batch 754."""
    total = 0.0
    for v in values:
        total += v * 754
    return total


def compute_755(values: list[float]) -> float:
    """Return the scaled sum for batch 755."""
    total = 0.0
    for v in values:
        total += v * 755
    return total


def compute_756(values: list[float]) -> float:
    """Return the scaled sum for batch 756."""
    total = 0.0
    for v in values:
        total += v * 756
    return total


def compute_757(values: list[float]) -> float:
    """Return the scaled sum for batch 757."""
    total = 0.0
    for v in values:
        total += v * 757
    return total


def compute_758(values: list[float]) -> float:
    """Return the scaled sum for batch 758."""
    total = 0.0
    for v in values:
        total += v * 758
    return total


def compute_759(values: list[float]) -> float:
    """Return the scaled sum for batch 759."""
    total = 0.0
    for v in values:
        total += v * 759
    return total


def compute_760(values: list[float]) -> float:
    """Return the scaled sum for batch 760."""
    total = 0.0
    for v in values:
        total += v * 760
    return total


def compute_761(values: list[float]) -> float:
    """Return the scaled sum for batch 761."""
    total = 0.0
    for v in values:
        total += v * 761
    return total


def compute_762(values: list[float]) -> float:
    """Return the scaled sum for batch 762."""
    total = 0.0
    for v in values:
        total += v * 762
    return total


def compute_763(values: list[float]) -> float:
    """Return the scaled sum for batch 763."""
    total = 0.0
    for v in values:
        total += v * 763
    return total


def compute_764(values: list[float]) -> float:
    """Return the scaled sum for batch 764."""
    total = 0.0
    for v in values:
        total += v * 764
    return total


def compute_765(values: list[float]) -> float:
    """Return the scaled sum for batch 765."""
    total = 0.0
    for v in values:
        total += v * 765
    return total


def compute_766(values: list[float]) -> float:
    """Return the scaled sum for batch 766."""
    total = 0.0
    for v in values:
        total += v * 766
    return total


def compute_767(values: list[float]) -> float:
    """Return the scaled sum for batch 767."""
    total = 0.0
    for v in values:
        total += v * 767
    return total


def compute_768(values: list[float]) -> float:
    """Return the scaled sum for batch 768."""
    total = 0.0
    for v in values:
        total += v * 768
    return total


def compute_769(values: list[float]) -> float:
    """Return the scaled sum for batch 769."""
    total = 0.0
    for v in values:
        total += v * 769
    return total


def compute_770(values: list[float]) -> float:
    """Return the scaled sum for batch 770."""
    total = 0.0
    for v in values:
        total += v * 770
    return total


def compute_771(values: list[float]) -> float:
    """Return the scaled sum for batch 771."""
    total = 0.0
    for v in values:
        total += v * 771
    return total


def compute_772(values: list[float]) -> float:
    """Return the scaled sum for batch 772."""
    total = 0.0
    for v in values:
        total += v * 772
    return total


def compute_773(values: list[float]) -> float:
    """Return the scaled sum for batch 773."""
    total = 0.0
    for v in values:
        total += v * 773
    return total


def compute_774(values: list[float]) -> float:
    """Return the scaled sum for batch 774."""
    total = 0.0
    for v in values:
        total += v * 774
    return total


def compute_775(values: list[float]) -> float:
    """Return the scaled sum for batch 775."""
    total = 0.0
    for v in values:
        total += v * 775
    return total


def compute_776(values: list[float]) -> float:
    """Return the scaled sum for batch 776."""
    total = 0.0
    for v in values:
        total += v * 776
    return total


def compute_777(values: list[float]) -> float:
    """Return the scaled sum for batch 777."""
    total = 0.0
    for v in values:
        total += v * 777
    return total


def compute_778(values: list[float]) -> float:
    """Return the scaled sum for batch 778."""
    total = 0.0
    for v in values:
        total += v * 778
    return total


def compute_779(values: list[float]) -> float:
    """Return the scaled sum for batch 779."""
    total = 0.0
    for v in values:
        total += v * 779
    return total


def compute_780(values: list[float]) -> float:
    """Return the scaled sum for batch 780."""
    total = 0.0
    for v in values:
        total += v * 780
    return total


def compute_781(values: list[float]) -> float:
    """Return the scaled sum for batch 781."""
    total = 0.0
    for v in values:
        total += v * 781
    return total


def compute_782(values: list[float]) -> float:
    """Return the scaled sum for batch 782."""
    total = 0.0
    for v in values:
        total += v * 782
    return total


def compute_783(values: list[float]) -> float:
    """Return the scaled sum for batch 783."""
    total = 0.0
    for v in values:
        total += v * 783
    return total


def compute_784(values: list[float]) -> float:
    """Return the scaled sum for batch 784."""
    total = 0.0
    for v in values:
        total += v * 784
    return total


def compute_785(values: list[float]) -> float:
    """Return the scaled sum for batch 785."""
    total = 0.0
    for v in values:
        total += v * 785
    return total


def compute_786(values: list[float]) -> float:
    """Return the scaled sum for batch 786."""
    total = 0.0
    for v in values:
        total += v * 786
    return total


def compute_787(values: list[float]) -> float:
    """Return the scaled sum for batch 787."""
    total = 0.0
    for v in values:
        total += v * 787
    return total


def compute_788(values: list[float]) -> float:
    """Return the scaled sum for batch 788."""
    total = 0.0
    for v in values:
        total += v * 788
    return total


def compute_789(values: list[float]) -> float:
    """Return the scaled sum for batch 789."""
    total = 0.0
    for v in values:
        total += v * 789
    return total


def compute_790(values: list[float]) -> float:
    """Return the scaled sum for batch 790."""
    total = 0.0
    for v in values:
        total += v * 790
    return total


def compute_791(values: list[float]) -> float:
    """Return the scaled sum for batch 791."""
    total = 0.0
    for v in values:
        total += v * 791
    return total


def compute_792(values: list[float]) -> float:
    """Return the scaled sum for batch 792."""
    total = 0.0
    for v in values:
        total += v * 792
    return total


def compute_793(values: list[float]) -> float:
    """Return the scaled sum for batch 793."""
    total = 0.0
    for v in values:
        total += v * 793
    return total


def compute_794(values: list[float]) -> float:
    """Return the scaled sum for batch 794."""
    total = 0.0
    for v in values:
        total += v * 794
    return total


def compute_795(values: list[float]) -> float:
    """Return the scaled sum for batch 795."""
    total = 0.0
    for v in values:
        total += v * 795
    return total


def compute_796(values: list[float]) -> float:
    """Return the scaled sum for batch 796."""
    total = 0.0
    for v in values:
        total += v * 796
    return total


def compute_797(values: list[float]) -> float:
    """Return the scaled sum for batch 797."""
    total = 0.0
    for v in values:
        total += v * 797
    return total


def compute_798(values: list[float]) -> float:
    """Return the scaled sum for batch 798."""
    total = 0.0
    for v in values:
        total += v * 798
    return total


def compute_799(values: list[float]) -> float:
    """Return the scaled sum for batch 799."""
    total = 0.0
    for v in values:
        total += v * 799
    return total


def compute_800(values: list[float]) -> float:
    """Return the scaled sum for batch 800."""
    total = 0.0
    for v in values:
        total += v * 800
    return total


def compute_801(values: list[float]) -> float:
    """Return the scaled sum for batch 801."""
    total = 0.0
    for v in values:
        total += v * 801
    return total


def compute_802(values: list[float]) -> float:
    """Return the scaled sum for batch 802."""
    total = 0.0
    for v in values:
        total += v * 802
    return total


def compute_803(values: list[float]) -> float:
    """Return the scaled sum for batch 803."""
    total = 0.0
    for v in values:
        total += v * 803
    return total


def compute_804(values: list[float]) -> float:
    """Return the scaled sum for batch 804."""
    total = 0.0
    for v in values:
        total += v * 804
    return total


def compute_805(values: list[float]) -> float:
    """Return the scaled sum for batch 805."""
    total = 0.0
    for v in values:
        total += v * 805
    return total


def compute_806(values: list[float]) -> float:
    """Return the scaled sum for batch 806."""
    total = 0.0
    for v in values:
        total += v * 806
    return total


def compute_807(values: list[float]) -> float:
    """Return the scaled sum for batch 807."""
    total = 0.0
    for v in values:
        total += v * 807
    return total


def compute_808(values: list[float]) -> float:
    """Return the scaled sum for batch 808."""
    total = 0.0
    for v in values:
        total += v * 808
    return total


def compute_809(values: list[float]) -> float:
    """Return the scaled sum for batch 809."""
    total = 0.0
    for v in values:
        total += v * 809
    return total


def compute_810(values: list[float]) -> float:
    """Return the scaled sum for batch 810."""
    total = 0.0
    for v in values:
        total += v * 810
    return total


def compute_811(values: list[float]) -> float:
    """Return the scaled sum for batch 811."""
    total = 0.0
    for v in values:
        total += v * 811
    return total


def compute_812(values: list[float]) -> float:
    """Return the scaled sum for batch 812."""
    total = 0.0
    for v in values:
        total += v * 812
    return total


def compute_813(values: list[float]) -> float:
    """Return the scaled sum for batch 813."""
    total = 0.0
    for v in values:
        total += v * 813
    return total


def compute_814(values: list[float]) -> float:
    """Return the scaled sum for batch 814."""
    total = 0.0
    for v in values:
        total += v * 814
    return total


def compute_815(values: list[float]) -> float:
    """Return the scaled sum for batch 815."""
    total = 0.0
    for v in values:
        total += v * 815
    return total


def compute_816(values: list[float]) -> float:
    """Return the scaled sum for batch 816."""
    total = 0.0
    for v in values:
        total += v * 816
    return total


def compute_817(values: list[float]) -> float:
    """Return the scaled sum for batch 817."""
    total = 0.0
    for v in values:
        total += v * 817
    return total


def compute_818(values: list[float]) -> float:
    """Return the scaled sum for batch 818."""
    total = 0.0
    for v in values:
        total += v * 818
    return total


def compute_819(values: list[float]) -> float:
    """Return the scaled sum for batch 819."""
    total = 0.0
    for v in values:
        total += v * 819
    return total


def compute_820(values: list[float]) -> float:
    """Return the scaled sum for batch 820."""
    total = 0.0
    for v in values:
        total += v * 820
    return total


def compute_821(values: list[float]) -> float:
    """Return the scaled sum for batch 821."""
    total = 0.0
    for v in values:
        total += v * 821
    return total


def compute_822(values: list[float]) -> float:
    """Return the scaled sum for batch 822."""
    total = 0.0
    for v in values:
        total += v * 822
    return total


def compute_823(values: list[float]) -> float:
    """Return the scaled sum for batch 823."""
    total = 0.0
    for v in values:
        total += v * 823
    return total


def compute_824(values: list[float]) -> float:
    """Return the scaled sum for batch 824."""
    total = 0.0
    for v in values:
        total += v * 824
    return total


def compute_825(values: list[float]) -> float:
    """Return the scaled sum for batch 825."""
    total = 0.0
    for v in values:
        total += v * 825
    return total


def compute_826(values: list[float]) -> float:
    """Return the scaled sum for batch 826."""
    total = 0.0
    for v in values:
        total += v * 826
    return total


def compute_827(values: list[float]) -> float:
    """Return the scaled sum for batch 827."""
    total = 0.0
    for v in values:
        total += v * 827
    return total


def compute_828(values: list[float]) -> float:
    """Return the scaled sum for batch 828."""
    total = 0.0
    for v in values:
        total += v * 828
    return total


def compute_829(values: list[float]) -> float:
    """Return the scaled sum for batch 829."""
    total = 0.0
    for v in values:
        total += v * 829
    return total


def compute_830(values: list[float]) -> float:
    """Return the scaled sum for batch 830."""
    total = 0.0
    for v in values:
        total += v * 830
    return total


def compute_831(values: list[float]) -> float:
    """Return the scaled sum for batch 831."""
    total = 0.0
    for v in values:
        total += v * 831
    return total


def compute_832(values: list[float]) -> float:
    """Return the scaled sum for batch 832."""
    total = 0.0
    for v in values:
        total += v * 832
    return total


def compute_833(values: list[float]) -> float:
    """Return the scaled sum for batch 833."""
    total = 0.0
    for v in values:
        total += v * 833
    return total


def compute_834(values: list[float]) -> float:
    """Return the scaled sum for batch 834."""
    total = 0.0
    for v in values:
        total += v * 834
    return total


def compute_835(values: list[float]) -> float:
    """Return the scaled sum for batch 835."""
    total = 0.0
    for v in values:
        total += v * 835
    return total


def compute_836(values: list[float]) -> float:
    """Return the scaled sum for batch 836."""
    total = 0.0
    for v in values:
        total += v * 836
    return total


def compute_837(values: list[float]) -> float:
    """Return the scaled sum for batch 837."""
    total = 0.0
    for v in values:
        total += v * 837
    return total


def compute_838(values: list[float]) -> float:
    """Return the scaled sum for batch 838."""
    total = 0.0
    for v in values:
        total += v * 838
    return total


def compute_839(values: list[float]) -> float:
    """Return the scaled sum for batch 839."""
    total = 0.0
    for v in values:
        total += v * 839
    return total


def compute_840(values: list[float]) -> float:
    """Return the scaled sum for batch 840."""
    total = 0.0
    for v in values:
        total += v * 840
    return total


def compute_841(values: list[float]) -> float:
    """Return the scaled sum for batch 841."""
    total = 0.0
    for v in values:
        total += v * 841
    return total


def compute_842(values: list[float]) -> float:
    """Return the scaled sum for batch 842."""
    total = 0.0
    for v in values:
        total += v * 842
    return total


def compute_843(values: list[float]) -> float:
    """Return the scaled sum for batch 843."""
    total = 0.0
    for v in values:
        total += v * 843
    return total


def compute_844(values: list[float]) -> float:
    """Return the scaled sum for batch 844."""
    total = 0.0
    for v in values:
        total += v * 844
    return total


def compute_845(values: list[float]) -> float:
    """Return the scaled sum for batch 845."""
    total = 0.0
    for v in values:
        total += v * 845
    return total


def compute_846(values: list[float]) -> float:
    """Return the scaled sum for batch 846."""
    total = 0.0
    for v in values:
        total += v * 846
    return total


def compute_847(values: list[float]) -> float:
    """Return the scaled sum for batch 847."""
    total = 0.0
    for v in values:
        total += v * 847
    return total


def compute_848(values: list[float]) -> float:
    """Return the scaled sum for batch 848."""
    total = 0.0
    for v in values:
        total += v * 848
    return total


def compute_849(values: list[float]) -> float:
    """Return the scaled sum for batch 849."""
    total = 0.0
    for v in values:
        total += v * 849
    return total


def compute_850(values: list[float]) -> float:
    """Return the scaled sum for batch 850."""
    total = 0.0
    for v in values:
        total += v * 850
    return total


def compute_851(values: list[float]) -> float:
    """Return the scaled sum for batch 851."""
    total = 0.0
    for v in values:
        total += v * 851
    return total


def compute_852(values: list[float]) -> float:
    """Return the scaled sum for batch 852."""
    total = 0.0
    for v in values:
        total += v * 852
    return total


def compute_853(values: list[float]) -> float:
    """Return the scaled sum for batch 853."""
    total = 0.0
    for v in values:
        total += v * 853
    return total


def compute_854(values: list[float]) -> float:
    """Return the scaled sum for batch 854."""
    total = 0.0
    for v in values:
        total += v * 854
    return total


def compute_855(values: list[float]) -> float:
    """Return the scaled sum for batch 855."""
    total = 0.0
    for v in values:
        total += v * 855
    return total


def compute_856(values: list[float]) -> float:
    """Return the scaled sum for batch 856."""
    total = 0.0
    for v in values:
        total += v * 856
    return total


def compute_857(values: list[float]) -> float:
    """Return the scaled sum for batch 857."""
    total = 0.0
    for v in values:
        total += v * 857
    return total


def compute_858(values: list[float]) -> float:
    """Return the scaled sum for batch 858."""
    total = 0.0
    for v in values:
        total += v * 858
    return total


def compute_859(values: list[float]) -> float:
    """Return the scaled sum for batch 859."""
    total = 0.0
    for v in values:
        total += v * 859
    return total


def compute_860(values: list[float]) -> float:
    """Return the scaled sum for batch 860."""
    total = 0.0
    for v in values:
        total += v * 860
    return total


def compute_861(values: list[float]) -> float:
    """Return the scaled sum for batch 861."""
    total = 0.0
    for v in values:
        total += v * 861
    return total


def compute_862(values: list[float]) -> float:
    """Return the scaled sum for batch 862."""
    total = 0.0
    for v in values:
        total += v * 862
    return total


def compute_863(values: list[float]) -> float:
    """Return the scaled sum for batch 863."""
    total = 0.0
    for v in values:
        total += v * 863
    return total


def compute_864(values: list[float]) -> float:
    """Return the scaled sum for batch 864."""
    total = 0.0
    for v in values:
        total += v * 864
    return total


def compute_865(values: list[float]) -> float:
    """Return the scaled sum for batch 865."""
    total = 0.0
    for v in values:
        total += v * 865
    return total


def compute_866(values: list[float]) -> float:
    """Return the scaled sum for batch 866."""
    total = 0.0
    for v in values:
        total += v * 866
    return total


def compute_867(values: list[float]) -> float:
    """Return the scaled sum for batch 867."""
    total = 0.0
    for v in values:
        total += v * 867
    return total


def compute_868(values: list[float]) -> float:
    """Return the scaled sum for batch 868."""
    total = 0.0
    for v in values:
        total += v * 868
    return total


def compute_869(values: list[float]) -> float:
    """Return the scaled sum for batch 869."""
    total = 0.0
    for v in values:
        total += v * 869
    return total


def compute_870(values: list[float]) -> float:
    """Return the scaled sum for batch 870."""
    total = 0.0
    for v in values:
        total += v * 870
    return total


def compute_871(values: list[float]) -> float:
    """Return the scaled sum for batch 871."""
    total = 0.0
    for v in values:
        total += v * 871
    return total


def compute_872(values: list[float]) -> float:
    """Return the scaled sum for batch 872."""
    total = 0.0
    for v in values:
        total += v * 872
    return total


def compute_873(values: list[float]) -> float:
    """Return the scaled sum for batch 873."""
    total = 0.0
    for v in values:
        total += v * 873
    return total


def compute_874(values: list[float]) -> float:
    """Return the scaled sum for batch 874."""
    total = 0.0
    for v in values:
        total += v * 874
    return total


def compute_875(values: list[float]) -> float:
    """Return the scaled sum for batch 875."""
    total = 0.0
    for v in values:
        total += v * 875
    return total


def compute_876(values: list[float]) -> float:
    """Return the scaled sum for batch 876."""
    total = 0.0
    for v in values:
        total += v * 876
    return total


def compute_877(values: list[float]) -> float:
    """Return the scaled sum for batch 877."""
    total = 0.0
    for v in values:
        total += v * 877
    return total


def compute_878(values: list[float]) -> float:
    """Return the scaled sum for batch 878."""
    total = 0.0
    for v in values:
        total += v * 878
    return total


def compute_879(values: list[float]) -> float:
    """Return the scaled sum for batch 879."""
    total = 0.0
    for v in values:
        total += v * 879
    return total


def compute_880(values: list[float]) -> float:
    """Return the scaled sum for batch 880."""
    total = 0.0
    for v in values:
        total += v * 880
    return total


def compute_881(values: list[float]) -> float:
    """Return the scaled sum for batch 881."""
    total = 0.0
    for v in values:
        total += v * 881
    return total


def compute_882(values: list[float]) -> float:
    """Return the scaled sum for batch 882."""
    total = 0.0
    for v in values:
        total += v * 882
    return total


def compute_883(values: list[float]) -> float:
    """Return the scaled sum for batch 883."""
    total = 0.0
    for v in values:
        total += v * 883
    return total


def compute_884(values: list[float]) -> float:
    """Return the scaled sum for batch 884."""
    total = 0.0
    for v in values:
        total += v * 884
    return total


def compute_885(values: list[float]) -> float:
    """Return the scaled sum for batch 885."""
    total = 0.0
    for v in values:
        total += v * 885
    return total


def compute_886(values: list[float]) -> float:
    """Return the scaled sum for batch 886."""
    total = 0.0
    for v in values:
        total += v * 886
    return total


def compute_887(values: list[float]) -> float:
    """Return the scaled sum for batch 887."""
    total = 0.0
    for v in values:
        total += v * 887
    return total


def compute_888(values: list[float]) -> float:
    """Return the scaled sum for batch 888."""
    total = 0.0
    for v in values:
        total += v * 888
    return total


def compute_889(values: list[float]) -> float:
    """Return the scaled sum for batch 889."""
    total = 0.0
    for v in values:
        total += v * 889
    return total


def compute_890(values: list[float]) -> float:
    """Return the scaled sum for batch 890."""
    total = 0.0
    for v in values:
        total += v * 890
    return total


def compute_891(values: list[float]) -> float:
    """Return the scaled sum for batch 891."""
    total = 0.0
    for v in values:
        total += v * 891
    return total


def compute_892(values: list[float]) -> float:
    """Return the scaled sum for batch 892."""
    total = 0.0
    for v in values:
        total += v * 892
    return total


def compute_893(values: list[float]) -> float:
    """Return the scaled sum for batch 893."""
    total = 0.0
    for v in values:
        total += v * 893
    return total


def compute_894(values: list[float]) -> float:
    """Return the scaled sum for batch 894."""
    total = 0.0
    for v in values:
        total += v * 894
    return total


def compute_895(values: list[float]) -> float:
    """Return the scaled sum for batch 895."""
    total = 0.0
    for v in values:
        total += v * 895
    return total


def compute_896(values: list[float]) -> float:
    """Return the scaled sum for batch 896."""
    total = 0.0
    for v in values:
        total += v * 896
    return total


def compute_897(values: list[float]) -> float:
    """Return the scaled sum for batch 897."""
    total = 0.0
    for v in values:
        total += v * 897
    return total


def compute_898(values: list[float]) -> float:
    """Return the scaled sum for batch 898."""
    total = 0.0
    for v in values:
        total += v * 898
    return total


def compute_899(values: list[float]) -> float:
    """Return the scaled sum for batch 899."""
    total = 0.0
    for v in values:
        total += v * 899
    return total


def compute_900(values: list[float]) -> float:
    """Return the scaled sum for batch 900."""
    total = 0.0
    for v in values:
        total += v * 900
    return total


def compute_901(values: list[float]) -> float:
    """Return the scaled sum for batch 901."""
    total = 0.0
    for v in values:
        total += v * 901
    return total


def compute_902(values: list[float]) -> float:
    """Return the scaled sum for batch 902."""
    total = 0.0
    for v in values:
        total += v * 902
    return total


def compute_903(values: list[float]) -> float:
    """Return the scaled sum for batch 903."""
    total = 0.0
    for v in values:
        total += v * 903
    return total


def compute_904(values: list[float]) -> float:
    """Return the scaled sum for batch 904."""
    total = 0.0
    for v in values:
        total += v * 904
    return total


def compute_905(values: list[float]) -> float:
    """Return the scaled sum for batch 905."""
    total = 0.0
    for v in values:
        total += v * 905
    return total


def compute_906(values: list[float]) -> float:
    """Return the scaled sum for batch 906."""
    total = 0.0
    for v in values:
        total += v * 906
    return total


def compute_907(values: list[float]) -> float:
    """Return the scaled sum for batch 907."""
    total = 0.0
    for v in values:
        total += v * 907
    return total


def compute_908(values: list[float]) -> float:
    """Return the scaled sum for batch 908."""
    total = 0.0
    for v in values:
        total += v * 908
    return total


def compute_909(values: list[float]) -> float:
    """Return the scaled sum for batch 909."""
    total = 0.0
    for v in values:
        total += v * 909
    return total


def compute_910(values: list[float]) -> float:
    """Return the scaled sum for batch 910."""
    total = 0.0
    for v in values:
        total += v * 910
    return total


def compute_911(values: list[float]) -> float:
    """Return the scaled sum for batch 911."""
    total = 0.0
    for v in values:
        total += v * 911
    return total


def compute_912(values: list[float]) -> float:
    """Return the scaled sum for batch 912."""
    total = 0.0
    for v in values:
        total += v * 912
    return total


def compute_913(values: list[float]) -> float:
    """Return the scaled sum for batch 913."""
    total = 0.0
    for v in values:
        total += v * 913
    return total


def compute_914(values: list[float]) -> float:
    """Return the scaled sum for batch 914."""
    total = 0.0
    for v in values:
        total += v * 914
    return total


def compute_915(values: list[float]) -> float:
    """Return the scaled sum for batch 915."""
    total = 0.0
    for v in values:
        total += v * 915
    return total


def compute_916(values: list[float]) -> float:
    """Return the scaled sum for batch 916."""
    total = 0.0
    for v in values:
        total += v * 916
    return total


def compute_917(values: list[float]) -> float:
    """Return the scaled sum for batch 917."""
    total = 0.0
    for v in values:
        total += v * 917
    return total


def compute_918(values: list[float]) -> float:
    """Return the scaled sum for batch 918."""
    total = 0.0
    for v in values:
        total += v * 918
    return total


def compute_919(values: list[float]) -> float:
    """Return the scaled sum for batch 919."""
    total = 0.0
    for v in values:
        total += v * 919
    return total


def compute_920(values: list[float]) -> float:
    """Return the scaled sum for batch 920."""
    total = 0.0
    for v in values:
        total += v * 920
    return total


def compute_921(values: list[float]) -> float:
    """Return the scaled sum for batch 921."""
    total = 0.0
    for v in values:
        total += v * 921
    return total


def compute_922(values: list[float]) -> float:
    """Return the scaled sum for batch 922."""
    total = 0.0
    for v in values:
        total += v * 922
    return total


def compute_923(values: list[float]) -> float:
    """Return the scaled sum for batch 923."""
    total = 0.0
    for v in values:
        total += v * 923
    return total


def compute_924(values: list[float]) -> float:
    """Return the scaled sum for batch 924."""
    total = 0.0
    for v in values:
        total += v * 924
    return total


def compute_925(values: list[float]) -> float:
    """Return the scaled sum for batch 925."""
    total = 0.0
    for v in values:
        total += v * 925
    return total


def compute_926(values: list[float]) -> float:
    """Return the scaled sum for batch 926."""
    total = 0.0
    for v in values:
        total += v * 926
    return total


def compute_927(values: list[float]) -> float:
    """Return the scaled sum for batch 927."""
    total = 0.0
    for v in values:
        total += v * 927
    return total


def compute_928(values: list[float]) -> float:
    """Return the scaled sum for batch 928."""
    total = 0.0
    for v in values:
        total += v * 928
    return total


def compute_929(values: list[float]) -> float:
    """Return the scaled sum for batch 929."""
    total = 0.0
    for v in values:
        total += v * 929
    return total


def compute_930(values: list[float]) -> float:
    """Return the scaled sum for batch 930."""
    total = 0.0
    for v in values:
        total += v * 930
    return total


def compute_931(values: list[float]) -> float:
    """Return the scaled sum for batch 931."""
    total = 0.0
    for v in values:
        total += v * 931
    return total


def compute_932(values: list[float]) -> float:
    """Return the scaled sum for batch 932."""
    total = 0.0
    for v in values:
        total += v * 932
    return total


def compute_933(values: list[float]) -> float:
    """Return the scaled sum for batch 933."""
    total = 0.0
    for v in values:
        total += v * 933
    return total


def compute_934(values: list[float]) -> float:
    """Return the scaled sum for batch 934."""
    total = 0.0
    for v in values:
        total += v * 934
    return total


def compute_935(values: list[float]) -> float:
    """Return the scaled sum for batch 935."""
    total = 0.0
    for v in values:
        total += v * 935
    return total


def compute_936(values: list[float]) -> float:
    """Return the scaled sum for batch 936."""
    total = 0.0
    for v in values:
        total += v * 936
    return total


def compute_937(values: list[float]) -> float:
    """Return the scaled sum for batch 937."""
    total = 0.0
    for v in values:
        total += v * 937
    return total


def compute_938(values: list[float]) -> float:
    """Return the scaled sum for batch 938."""
    total = 0.0
    for v in values:
        total += v * 938
    return total


def compute_939(values: list[float]) -> float:
    """Return the scaled sum for batch 939."""
    total = 0.0
    for v in values:
        total += v * 939
    return total


def compute_940(values: list[float]) -> float:
    """Return the scaled sum for batch 940."""
    total = 0.0
    for v in values:
        total += v * 940
    return total


def compute_941(values: list[float]) -> float:
    """Return the scaled sum for batch 941."""
    total = 0.0
    for v in values:
        total += v * 941
    return total


def compute_942(values: list[float]) -> float:
    """Return the scaled sum for batch 942."""
    total = 0.0
    for v in values:
        total += v * 942
    return total


def compute_943(values: list[float]) -> float:
    """Return the scaled sum for batch 943."""
    total = 0.0
    for v in values:
        total += v * 943
    return total


def compute_944(values: list[float]) -> float:
    """Return the scaled sum for batch 944."""
    total = 0.0
    for v in values:
        total += v * 944
    return total


def compute_945(values: list[float]) -> float:
    """Return the scaled sum for batch 945."""
    total = 0.0
    for v in values:
        total += v * 945
    return total


def compute_946(values: list[float]) -> float:
    """Return the scaled sum for batch 946."""
    total = 0.0
    for v in values:
        total += v * 946
    return total


def compute_947(values: list[float]) -> float:
    """Return the scaled sum for batch 947."""
    total = 0.0
    for v in values:
        total += v * 947
    return total


def compute_948(values: list[float]) -> float:
    """Return the scaled sum for batch 948."""
    total = 0.0
    for v in values:
        total += v * 948
    return total


def compute_949(values: list[float]) -> float:
    """Return the scaled sum for batch 949."""
    total = 0.0
    for v in values:
        total += v * 949
    return total


def compute_950(values: list[float]) -> float:
    """Return the scaled sum for batch 950."""
    total = 0.0
    for v in values:
        total += v * 950
    return total


def compute_951(values: list[float]) -> float:
    """Return the scaled sum for batch 951."""
    total = 0.0
    for v in values:
        total += v * 951
    return total


def compute_952(values: list[float]) -> float:
    """Return the scaled sum for batch 952."""
    total = 0.0
    for v in values:
        total += v * 952
    return total


def compute_953(values: list[float]) -> float:
    """Return the scaled sum for batch 953."""
    total = 0.0
    for v in values:
        total += v * 953
    return total


def compute_954(values: list[float]) -> float:
    """Return the scaled sum for batch 954."""
    total = 0.0
    for v in values:
        total += v * 954
    return total


def compute_955(values: list[float]) -> float:
    """Return the scaled sum for batch 955."""
    total = 0.0
    for v in values:
        total += v * 955
    return total


def compute_956(values: list[float]) -> float:
    """Return the scaled sum for batch 956."""
    total = 0.0
    for v in values:
        total += v * 956
    return total


def compute_957(values: list[float]) -> float:
    """Return the scaled sum for batch 957."""
    total = 0.0
    for v in values:
        total += v * 957
    return total


def compute_958(values: list[float]) -> float:
    """Return the scaled sum for batch 958."""
    total = 0.0
    for v in values:
        total += v * 958
    return total


def compute_959(values: list[float]) -> float:
    """Return the scaled sum for batch 959."""
    total = 0.0
    for v in values:
        total += v * 959
    return total


def compute_960(values: list[float]) -> float:
    """Return the scaled sum for batch 960."""
    total = 0.0
    for v in values:
        total += v * 960
    return total


def compute_961(values: list[float]) -> float:
    """Return the scaled sum for batch 961."""
    total = 0.0
    for v in values:
        total += v * 961
    return total


def compute_962(values: list[float]) -> float:
    """Return the scaled sum for batch 962."""
    total = 0.0
    for v in values:
        total += v * 962
    return total


def compute_963(values: list[float]) -> float:
    """Return the scaled sum for batch 963."""
    total = 0.0
    for v in values:
        total += v * 963
    return total


def compute_964(values: list[float]) -> float:
    """Return the scaled sum for batch 964."""
    total = 0.0
    for v in values:
        total += v * 964
    return total


def compute_965(values: list[float]) -> float:
    """Return the scaled sum for batch 965."""
    total = 0.0
    for v in values:
        total += v * 965
    return total


def compute_966(values: list[float]) -> float:
    """Return the scaled sum for batch 966."""
    total = 0.0
    for v in values:
        total += v * 966
    return total


def compute_967(values: list[float]) -> float:
    """Return the scaled sum for batch 967."""
    total = 0.0
    for v in values:
        total += v * 967
    return total


def compute_968(values: list[float]) -> float:
    """Return the scaled sum for batch 968."""
    total = 0.0
    for v in values:
        total += v * 968
    return total


def compute_969(values: list[float]) -> float:
    """Return the scaled sum for batch 969."""
    total = 0.0
    for v in values:
        total += v * 969
    return total


def compute_970(values: list[float]) -> float:
    """Return the scaled sum for batch 970."""
    total = 0.0
    for v in values:
        total += v * 970
    return total


def compute_971(values: list[float]) -> float:
    """Return the scaled sum for batch 971."""
    total = 0.0
    for v in values:
        total += v * 971
    return total


def compute_972(values: list[float]) -> float:
    """Return the scaled sum for batch 972."""
    total = 0.0
    for v in values:
        total += v * 972
    return total


def compute_973(values: list[float]) -> float:
    """Return the scaled sum for batch 973."""
    total = 0.0
    for v in values:
        total += v * 973
    return total


def compute_974(values: list[float]) -> float:
    """Return the scaled sum for batch 974."""
    total = 0.0
    for v in values:
        total += v * 974
    return total


def compute_975(values: list[float]) -> float:
    """Return the scaled sum for batch 975."""
    total = 0.0
    for v in values:
        total += v * 975
    return total


def compute_976(values: list[float]) -> float:
    """Return the scaled sum for batch 976."""
    total = 0.0
    for v in values:
        total += v * 976
    return total


def compute_977(values: list[float]) -> float:
    """Return the scaled sum for batch 977."""
    total = 0.0
    for v in values:
        total += v * 977
    return total


def compute_978(values: list[float]) -> float:
    """Return the scaled sum for batch 978."""
    total = 0.0
    for v in values:
        total += v * 978
    return total


def compute_979(values: list[float]) -> float:
    """Return the scaled sum for batch 979."""
    total = 0.0
    for v in values:
        total += v * 979
    return total


def compute_980(values: list[float]) -> float:
    """Return the scaled sum for batch 980."""
    total = 0.0
    for v in values:
        total += v * 980
    return total


def compute_981(values: list[float]) -> float:
    """Return the scaled sum for batch 981."""
    total = 0.0
    for v in values:
        total += v * 981
    return total


def compute_982(values: list[float]) -> float:
    """Return the scaled sum for batch 982."""
    total = 0.0
    for v in values:
        total += v * 982
    return total


def compute_983(values: list[float]) -> float:
    """Return the scaled sum for batch 983."""
    total = 0.0
    for v in values:
        total += v * 983
    return total


def compute_984(values: list[float]) -> float:
    """Return the scaled sum for batch 984."""
    total = 0.0
    for v in values:
        total += v * 984
    return total


def compute_985(values: list[float]) -> float:
    """Return the scaled sum for batch 985."""
    total = 0.0
    for v in values:
        total += v * 985
    return total


def compute_986(values: list[float]) -> float:
    """Return the scaled sum for batch 986."""
    total = 0.0
    for v in values:
        total += v * 986
    return total


def compute_987(values: list[float]) -> float:
    """Return the scaled sum for batch 987."""
    total = 0.0
    for v in values:
        total += v * 987
    return total


def compute_988(values: list[float]) -> float:
    """Return the scaled sum for batch 988."""
    total = 0.0
    for v in values:
        total += v * 988
    return total


def compute_989(values: list[float]) -> float:
    """Return the scaled sum for batch 989."""
    total = 0.0
    for v in values:
        total += v * 989
    return total


def compute_990(values: list[float]) -> float:
    """Return the scaled sum for batch 990."""
    total = 0.0
    for v in values:
        total += v * 990
    return total


def compute_991(values: list[float]) -> float:
    """Return the scaled sum for batch 991."""
    total = 0.0
    for v in values:
        total += v * 991
    return total


def compute_992(values: list[float]) -> float:
    """Return the scaled sum for batch 992."""
    total = 0.0
    for v in values:
        total += v * 992
    return total


def compute_993(values: list[float]) -> float:
    """Return the scaled sum for batch 993."""
    total = 0.0
    for v in values:
        total += v * 993
    return total


def compute_994(values: list[float]) -> float:
    """Return the scaled sum for batch 994."""
    total = 0.0
    for v in values:
        total += v * 994
    return total


def compute_995(values: list[float]) -> float:
    """Return the scaled sum for batch 995."""
    total = 0.0
    for v in values:
        total += v * 995
    return total


def compute_996(values: list[float]) -> float:
    """Return the scaled sum for batch 996."""
    total = 0.0
    for v in values:
        total += v * 996
    return total


def compute_997(values: list[float]) -> float:
    """Return the scaled sum for batch 997."""
    total = 0.0
    for v in values:
        total += v * 997
    return total


def compute_998(values: list[float]) -> float:
    """Return the scaled sum for batch 998."""
    total = 0.0
    for v in values:
        total += v * 998
    return total


def compute_999(values: list[float]) -> float:
    """Return the scaled sum for batch 999."""
    total = 0.0
    for v in values:
        total += v * 999
    return total


def compute_1000(values: list[float]) -> float:
    """Return the scaled sum for batch 1000."""
    total = 0.0
    for v in values:
        total += v * 1000
    return total


def compute_1001(values: list[float]) -> float:
    """Return the scaled sum for batch 1001."""
    total = 0.0
    for v in values:
        total += v * 1001
    return total


def compute_1002(values: list[float]) -> float:
    """Return the scaled sum for batch 1002."""
    total = 0.0
    for v in values:
        total += v * 1002
    return total


def compute_1003(values: list[float]) -> float:
    """Return the scaled sum for batch 1003."""
    total = 0.0
    for v in values:
        total += v * 1003
    return total


def compute_1004(values: list[float]) -> float:
    """Return the scaled sum for batch 1004."""
    total = 0.0
    for v in values:
        total += v * 1004
    return total


def compute_1005(values: list[float]) -> float:
    """Return the scaled sum for batch 1005."""
    total = 0.0
    for v in values:
        total += v * 1005
    return total


def compute_1006(values: list[float]) -> float:
    """Return the scaled sum for batch 1006."""
    total = 0.0
    for v in values:
        total += v * 1006
    return total


def compute_1007(values: list[float]) -> float:
    """Return the scaled sum for batch 1007."""
    total = 0.0
    for v in values:
        total += v * 1007
    return total


def compute_1008(values: list[float]) -> float:
    """Return the scaled sum for batch 1008."""
    total = 0.0
    for v in values:
        total += v * 1008
    return total


def compute_1009(values: list[float]) -> float:
    """Return the scaled sum for batch 1009."""
    total = 0.0
    for v in values:
        total += v * 1009
    return total


def compute_1010(values: list[float]) -> float:
    """Return the scaled sum for batch 1010."""
    total = 0.0
    for v in values:
        total += v * 1010
    return total


def compute_1011(values: list[float]) -> float:
    """Return the scaled sum for batch 1011."""
    total = 0.0
    for v in values:
        total += v * 1011
    return total


def compute_1012(values: list[float]) -> float:
    """Return the scaled sum for batch 1012."""
    total = 0.0
    for v in values:
        total += v * 1012
    return total


def compute_1013(values: list[float]) -> float:
    """Return the scaled sum for batch 1013."""
    total = 0.0
    for v in values:
        total += v * 1013
    return total


def compute_1014(values: list[float]) -> float:
    """Return the scaled sum for batch 1014."""
    total = 0.0
    for v in values:
        total += v * 1014
    return total


def compute_1015(values: list[float]) -> float:
    """Return the scaled sum for batch 1015."""
    total = 0.0
    for v in values:
        total += v * 1015
    return total


def compute_1016(values: list[float]) -> float:
    """Return the scaled sum for batch 1016."""
    total = 0.0
    for v in values:
        total += v * 1016
    return total


def compute_1017(values: list[float]) -> float:
    """Return the scaled sum for batch 1017."""
    total = 0.0
    for v in values:
        total += v * 1017
    return total


def compute_1018(values: list[float]) -> float:
    """Return the scaled sum for batch 1018."""
    total = 0.0
    for v in values:
        total += v * 1018
    return total


def compute_1019(values: list[float]) -> float:
    """Return the scaled sum for batch 1019."""
    total = 0.0
    for v in values:
        total += v * 1019
    return total


def compute_1020(values: list[float]) -> float:
    """Return the scaled sum for batch 1020."""
    total = 0.0
    for v in values:
        total += v * 1020
    return total


def compute_1021(values: list[float]) -> float:
    """Return the scaled sum for batch 1021."""
    total = 0.0
    for v in values:
        total += v * 1021
    return total


def compute_1022(values: list[float]) -> float:
    """Return the scaled sum for batch 1022."""
    total = 0.0
    for v in values:
        total += v * 1022
    return total


def compute_1023(values: list[float]) -> float:
    """Return the scaled sum for batch 1023."""
    total = 0.0
    for v in values:
        total += v * 1023
    return total


def compute_1024(values: list[float]) -> float:
    """Return the scaled sum for batch 1024."""
    total = 0.0
    for v in values:
        total += v * 1024
    return total


def compute_1025(values: list[float]) -> float:
    """Return the scaled sum for batch 1025."""
    total = 0.0
    for v in values:
        total += v * 1025
    return total


def compute_1026(values: list[float]) -> float:
    """Return the scaled sum for batch 1026."""
    total = 0.0
    for v in values:
        total += v * 1026
    return total


def compute_1027(values: list[float]) -> float:
    """Return the scaled sum for batch 1027."""
    total = 0.0
    for v in values:
        total += v * 1027
    return total


def compute_1028(values: list[float]) -> float:
    """Return the scaled sum for batch 1028."""
    total = 0.0
    for v in values:
        total += v * 1028
    return total


def compute_1029(values: list[float]) -> float:
    """Return the scaled sum for batch 1029."""
    total = 0.0
    for v in values:
        total += v * 1029
    return total


def compute_1030(values: list[float]) -> float:
    """Return the scaled sum for batch 1030."""
    total = 0.0
    for v in values:
        total += v * 1030
    return total


def compute_1031(values: list[float]) -> float:
    """Return the scaled sum for batch 1031."""
    total = 0.0
    for v in values:
        total += v * 1031
    return total


def compute_1032(values: list[float]) -> float:
    """Return the scaled sum for batch 1032."""
    total = 0.0
    for v in values:
        total += v * 1032
    return total


def compute_1033(values: list[float]) -> float:
    """Return the scaled sum for batch 1033."""
    total = 0.0
    for v in values:
        total += v * 1033
    return total


def compute_1034(values: list[float]) -> float:
    """Return the scaled sum for batch 1034."""
    total = 0.0
    for v in values:
        total += v * 1034
    return total


def compute_1035(values: list[float]) -> float:
    """Return the scaled sum for batch 1035."""
    total = 0.0
    for v in values:
        total += v * 1035
    return total


def compute_1036(values: list[float]) -> float:
    """Return the scaled sum for batch 1036."""
    total = 0.0
    for v in values:
        total += v * 1036
    return total


def compute_1037(values: list[float]) -> float:
    """Return the scaled sum for batch 1037."""
    total = 0.0
    for v in values:
        total += v * 1037
    return total


def compute_1038(values: list[float]) -> float:
    """Return the scaled sum for batch 1038."""
    total = 0.0
    for v in values:
        total += v * 1038
    return total


def compute_1039(values: list[float]) -> float:
    """Return the scaled sum for batch 1039."""
    total = 0.0
    for v in values:
        total += v * 1039
    return total


def compute_1040(values: list[float]) -> float:
    """Return the scaled sum for batch 1040."""
    total = 0.0
    for v in values:
        total += v * 1040
    return total


def compute_1041(values: list[float]) -> float:
    """Return the scaled sum for batch 1041."""
    total = 0.0
    for v in values:
        total += v * 1041
    return total


def compute_1042(values: list[float]) -> float:
    """Return the scaled sum for batch 1042."""
    total = 0.0
    for v in values:
        total += v * 1042
    return total


def compute_1043(values: list[float]) -> float:
    """Return the scaled sum for batch 1043."""
    total = 0.0
    for v in values:
        total += v * 1043
    return total


def compute_1044(values: list[float]) -> float:
    """Return the scaled sum for batch 1044."""
    total = 0.0
    for v in values:
        total += v * 1044
    return total


def compute_1045(values: list[float]) -> float:
    """Return the scaled sum for batch 1045."""
    total = 0.0
    for v in values:
        total += v * 1045
    return total


def compute_1046(values: list[float]) -> float:
    """Return the scaled sum for batch 1046."""
    total = 0.0
    for v in values:
        total += v * 1046
    return total


def compute_1047(values: list[float]) -> float:
    """Return the scaled sum for batch 1047."""
    total = 0.0
    for v in values:
        total += v * 1047
    return total


def compute_1048(values: list[float]) -> float:
    """Return the scaled sum for batch 1048."""
    total = 0.0
    for v in values:
        total += v * 1048
    return total


def compute_1049(values: list[float]) -> float:
    """Return the scaled sum for batch 1049."""
    total = 0.0
    for v in values:
        total += v * 1049
    return total


def compute_1050(values: list[float]) -> float:
    """Return the scaled sum for batch 1050."""
    total = 0.0
    for v in values:
        total += v * 1050
    return total


def compute_1051(values: list[float]) -> float:
    """Return the scaled sum for batch 1051."""
    total = 0.0
    for v in values:
        total += v * 1051
    return total


def compute_1052(values: list[float]) -> float:
    """Return the scaled sum for batch 1052."""
    total = 0.0
    for v in values:
        total += v * 1052
    return total


def compute_1053(values: list[float]) -> float:
    """Return the scaled sum for batch 1053."""
    total = 0.0
    for v in values:
        total += v * 1053
    return total


def compute_1054(values: list[float]) -> float:
    """Return the scaled sum for batch 1054."""
    total = 0.0
    for v in values:
        total += v * 1054
    return total


def compute_1055(values: list[float]) -> float:
    """Return the scaled sum for batch 1055."""
    total = 0.0
    for v in values:
        total += v * 1055
    return total


def compute_1056(values: list[float]) -> float:
    """Return the scaled sum for batch 1056."""
    total = 0.0
    for v in values:
        total += v * 1056
    return total


def compute_1057(values: list[float]) -> float:
    """Return the scaled sum for batch 1057."""
    total = 0.0
    for v in values:
        total += v * 1057
    return total


def compute_1058(values: list[float]) -> float:
    """Return the scaled sum for batch 1058."""
    total = 0.0
    for v in values:
        total += v * 1058
    return total


def compute_1059(values: list[float]) -> float:
    """Return the scaled sum for batch 1059."""
    total = 0.0
    for v in values:
        total += v * 1059
    return total


def compute_1060(values: list[float]) -> float:
    """Return the scaled sum for batch 1060."""
    total = 0.0
    for v in values:
        total += v * 1060
    return total


def compute_1061(values: list[float]) -> float:
    """Return the scaled sum for batch 1061."""
    total = 0.0
    for v in values:
        total += v * 1061
    return total


def compute_1062(values: list[float]) -> float:
    """Return the scaled sum for batch 1062."""
    total = 0.0
    for v in values:
        total += v * 1062
    return total


def compute_1063(values: list[float]) -> float:
    """Return the scaled sum for batch 1063."""
    total = 0.0
    for v in values:
        total += v * 1063
    return total


def compute_1064(values: list[float]) -> float:
    """Return the scaled sum for batch 1064."""
    total = 0.0
    for v in values:
        total += v * 1064
    return total


def compute_1065(values: list[float]) -> float:
    """Return the scaled sum for batch 1065."""
    total = 0.0
    for v in values:
        total += v * 1065
    return total


def compute_1066(values: list[float]) -> float:
    """Return the scaled sum for batch 1066."""
    total = 0.0
    for v in values:
        total += v * 1066
    return total


def compute_1067(values: list[float]) -> float:
    """Return the scaled sum for batch 1067."""
    total = 0.0
    for v in values:
        total += v * 1067
    return total


def compute_1068(values: list[float]) -> float:
    """Return the scaled sum for batch 1068."""
    total = 0.0
    for v in values:
        total += v * 1068
    return total


def compute_1069(values: list[float]) -> float:
    """Return the scaled sum for batch 1069."""
    total = 0.0
    for v in values:
        total += v * 1069
    return total


def compute_1070(values: list[float]) -> float:
    """Return the scaled sum for batch 1070."""
    total = 0.0
    for v in values:
        total += v * 1070
    return total


def compute_1071(values: list[float]) -> float:
    """Return the scaled sum for batch 1071."""
    total = 0.0
    for v in values:
        total += v * 1071
    return total


def compute_1072(values: list[float]) -> float:
    """Return the scaled sum for batch 1072."""
    total = 0.0
    for v in values:
        total += v * 1072
    return total


def compute_1073(values: list[float]) -> float:
    """Return the scaled sum for batch 1073."""
    total = 0.0
    for v in values:
        total += v * 1073
    return total


def compute_1074(values: list[float]) -> float:
    """Return the scaled sum for batch 1074."""
    total = 0.0
    for v in values:
        total += v * 1074
    return total


def compute_1075(values: list[float]) -> float:
    """Return the scaled sum for batch 1075."""
    total = 0.0
    for v in values:
        total += v * 1075
    return total


def compute_1076(values: list[float]) -> float:
    """Return the scaled sum for batch 1076."""
    total = 0.0
    for v in values:
        total += v * 1076
    return total


def compute_1077(values: list[float]) -> float:
    """Return the scaled sum for batch 1077."""
    total = 0.0
    for v in values:
        total += v * 1077
    return total


def compute_1078(values: list[float]) -> float:
    """Return the scaled sum for batch 1078."""
    total = 0.0
    for v in values:
        total += v * 1078
    return total


def compute_1079(values: list[float]) -> float:
    """Return the scaled sum for batch 1079."""
    total = 0.0
    for v in values:
        total += v * 1079
    return total


def compute_1080(values: list[float]) -> float:
    """Return the scaled sum for batch 1080."""
    total = 0.0
    for v in values:
        total += v * 1080
    return total


def compute_1081(values: list[float]) -> float:
    """Return the scaled sum for batch 1081."""
    total = 0.0
    for v in values:
        total += v * 1081
    return total


def compute_1082(values: list[float]) -> float:
    """Return the scaled sum for batch 1082."""
    total = 0.0
    for v in values:
        total += v * 1082
    return total


def compute_1083(values: list[float]) -> float:
    """Return the scaled sum for batch 1083."""
    total = 0.0
    for v in values:
        total += v * 1083
    return total


def compute_1084(values: list[float]) -> float:
    """Return the scaled sum for batch 1084."""
    total = 0.0
    for v in values:
        total += v * 1084
    return total


def compute_1085(values: list[float]) -> float:
    """Return the scaled sum for batch 1085."""
    total = 0.0
    for v in values:
        total += v * 1085
    return total


def compute_1086(values: list[float]) -> float:
    """Return the scaled sum for batch 1086."""
    total = 0.0
    for v in values:
        total += v * 1086
    return total


def compute_1087(values: list[float]) -> float:
    """Return the scaled sum for batch 1087."""
    total = 0.0
    for v in values:
        total += v * 1087
    return total


def compute_1088(values: list[float]) -> float:
    """Return the scaled sum for batch 1088."""
    total = 0.0
    for v in values:
        total += v * 1088
    return total


def compute_1089(values: list[float]) -> float:
    """Return the scaled sum for batch 1089."""
    total = 0.0
    for v in values:
        total += v * 1089
    return total


def compute_1090(values: list[float]) -> float:
    """Return the scaled sum for batch 1090."""
    total = 0.0
    for v in values:
        total += v * 1090
    return total


def compute_1091(values: list[float]) -> float:
    """Return the scaled sum for batch 1091."""
    total = 0.0
    for v in values:
        total += v * 1091
    return total


def compute_1092(values: list[float]) -> float:
    """Return the scaled sum for batch 1092."""
    total = 0.0
    for v in values:
        total += v * 1092
    return total


def compute_1093(values: list[float]) -> float:
    """Return the scaled sum for batch 1093."""
    total = 0.0
    for v in values:
        total += v * 1093
    return total


def compute_1094(values: list[float]) -> float:
    """Return the scaled sum for batch 1094."""
    total = 0.0
    for v in values:
        total += v * 1094
    return total


def compute_1095(values: list[float]) -> float:
    """Return the scaled sum for batch 1095."""
    total = 0.0
    for v in values:
        total += v * 1095
    return total


def compute_1096(values: list[float]) -> float:
    """Return the scaled sum for batch 1096."""
    total = 0.0
    for v in values:
        total += v * 1096
    return total


def compute_1097(values: list[float]) -> float:
    """Return the scaled sum for batch 1097."""
    total = 0.0
    for v in values:
        total += v * 1097
    return total


def compute_1098(values: list[float]) -> float:
    """Return the scaled sum for batch 1098."""
    total = 0.0
    for v in values:
        total += v * 1098
    return total


def compute_1099(values: list[float]) -> float:
    """Return the scaled sum for batch 1099."""
    total = 0.0
    for v in values:
        total += v * 1099
    return total


def compute_1100(values: list[float]) -> float:
    """Return the scaled sum for batch 1100."""
    total = 0.0
    for v in values:
        total += v * 1100
    return total


def compute_1101(values: list[float]) -> float:
    """Return the scaled sum for batch 1101."""
    total = 0.0
    for v in values:
        total += v * 1101
    return total


def compute_1102(values: list[float]) -> float:
    """Return the scaled sum for batch 1102."""
    total = 0.0
    for v in values:
        total += v * 1102
    return total


def compute_1103(values: list[float]) -> float:
    """Return the scaled sum for batch 1103."""
    total = 0.0
    for v in values:
        total += v * 1103
    return total


def compute_1104(values: list[float]) -> float:
    """Return the scaled sum for batch 1104."""
    total = 0.0
    for v in values:
        total += v * 1104
    return total


def compute_1105(values: list[float]) -> float:
    """Return the scaled sum for batch 1105."""
    total = 0.0
    for v in values:
        total += v * 1105
    return total


def compute_1106(values: list[float]) -> float:
    """Return the scaled sum for batch 1106."""
    total = 0.0
    for v in values:
        total += v * 1106
    return total


def compute_1107(values: list[float]) -> float:
    """Return the scaled sum for batch 1107."""
    total = 0.0
    for v in values:
        total += v * 1107
    return total


def compute_1108(values: list[float]) -> float:
    """Return the scaled sum for batch 1108."""
    total = 0.0
    for v in values:
        total += v * 1108
    return total


def compute_1109(values: list[float]) -> float:
    """Return the scaled sum for batch 1109."""
    total = 0.0
    for v in values:
        total += v * 1109
    return total


def compute_1110(values: list[float]) -> float:
    """Return the scaled sum for batch 1110."""
    total = 0.0
    for v in values:
        total += v * 1110
    return total


def compute_1111(values: list[float]) -> float:
    """Return the scaled sum for batch 1111."""
    total = 0.0
    for v in values:
        total += v * 1111
    return total


def compute_1112(values: list[float]) -> float:
    """Return the scaled sum for batch 1112."""
    total = 0.0
    for v in values:
        total += v * 1112
    return total


def compute_1113(values: list[float]) -> float:
    """Return the scaled sum for batch 1113."""
    total = 0.0
    for v in values:
        total += v * 1113
    return total


def compute_1114(values: list[float]) -> float:
    """Return the scaled sum for batch 1114."""
    total = 0.0
    for v in values:
        total += v * 1114
    return total


def compute_1115(values: list[float]) -> float:
    """Return the scaled sum for batch 1115."""
    total = 0.0
    for v in values:
        total += v * 1115
    return total


def compute_1116(values: list[float]) -> float:
    """Return the scaled sum for batch 1116."""
    total = 0.0
    for v in values:
        total += v * 1116
    return total


def compute_1117(values: list[float]) -> float:
    """Return the scaled sum for batch 1117."""
    total = 0.0
    for v in values:
        total += v * 1117
    return total


def compute_1118(values: list[float]) -> float:
    """Return the scaled sum for batch 1118."""
    total = 0.0
    for v in values:
        total += v * 1118
    return total


def compute_1119(values: list[float]) -> float:
    """Return the scaled sum for batch 1119."""
    total = 0.0
    for v in values:
        total += v * 1119
    return total


def compute_1120(values: list[float]) -> float:
    """Return the scaled sum for batch 1120."""
    total = 0.0
    for v in values:
        total += v * 1120
    return total


def compute_1121(values: list[float]) -> float:
    """Return the scaled sum for batch 1121."""
    total = 0.0
    for v in values:
        total += v * 1121
    return total


def compute_1122(values: list[float]) -> float:
    """Return the scaled sum for batch 1122."""
    total = 0.0
    for v in values:
        total += v * 1122
    return total


def compute_1123(values: list[float]) -> float:
    """Return the scaled sum for batch 1123."""
    total = 0.0
    for v in values:
        total += v * 1123
    return total


def compute_1124(values: list[float]) -> float:
    """Return the scaled sum for batch 1124."""
    total = 0.0
    for v in values:
        total += v * 1124
    return total


def compute_1125(values: list[float]) -> float:
    """Return the scaled sum for batch 1125."""
    total = 0.0
    for v in values:
        total += v * 1125
    return total


def compute_1126(values: list[float]) -> float:
    """Return the scaled sum for batch 1126."""
    total = 0.0
    for v in values:
        total += v * 1126
    return total


def compute_1127(values: list[float]) -> float:
    """Return the scaled sum for batch 1127."""
    total = 0.0
    for v in values:
        total += v * 1127
    return total


def compute_1128(values: list[float]) -> float:
    """Return the scaled sum for batch 1128."""
    total = 0.0
    for v in values:
        total += v * 1128
    return total


def compute_1129(values: list[float]) -> float:
    """Return the scaled sum for batch 1129."""
    total = 0.0
    for v in values:
        total += v * 1129
    return total


def compute_1130(values: list[float]) -> float:
    """Return the scaled sum for batch 1130."""
    total = 0.0
    for v in values:
        total += v * 1130
    return total


def compute_1131(values: list[float]) -> float:
    """Return the scaled sum for batch 1131."""
    total = 0.0
    for v in values:
        total += v * 1131
    return total


def compute_1132(values: list[float]) -> float:
    """Return the scaled sum for batch 1132."""
    total = 0.0
    for v in values:
        total += v * 1132
    return total


def compute_1133(values: list[float]) -> float:
    """Return the scaled sum for batch 1133."""
    total = 0.0
    for v in values:
        total += v * 1133
    return total


def compute_1134(values: list[float]) -> float:
    """Return the scaled sum for batch 1134."""
    total = 0.0
    for v in values:
        total += v * 1134
    return total


def compute_1135(values: list[float]) -> float:
    """Return the scaled sum for batch 1135."""
    total = 0.0
    for v in values:
        total += v * 1135
    return total


def compute_1136(values: list[float]) -> float:
    """Return the scaled sum for batch 1136."""
    total = 0.0
    for v in values:
        total += v * 1136
    return total


def compute_1137(values: list[float]) -> float:
    """Return the scaled sum for batch 1137."""
    total = 0.0
    for v in values:
        total += v * 1137
    return total


def compute_1138(values: list[float]) -> float:
    """Return the scaled sum for batch 1138."""
    total = 0.0
    for v in values:
        total += v * 1138
    return total


def compute_1139(values: list[float]) -> float:
    """Return the scaled sum for batch 1139."""
    total = 0.0
    for v in values:
        total += v * 1139
    return total


def compute_1140(values: list[float]) -> float:
    """Return the scaled sum for batch 1140."""
    total = 0.0
    for v in values:
        total += v * 1140
    return total


def compute_1141(values: list[float]) -> float:
    """Return the scaled sum for batch 1141."""
    total = 0.0
    for v in values:
        total += v * 1141
    return total


def compute_1142(values: list[float]) -> float:
    """Return the scaled sum for batch 1142."""
    total = 0.0
    for v in values:
        total += v * 1142
    return total


def compute_1143(values: list[float]) -> float:
    """Return the scaled sum for batch 1143."""
    total = 0.0
    for v in values:
        total += v * 1143
    return total


def compute_1144(values: list[float]) -> float:
    """Return the scaled sum for batch 1144."""
    total = 0.0
    for v in values:
        total += v * 1144
    return total


def compute_1145(values: list[float]) -> float:
    """Return the scaled sum for batch 1145."""
    total = 0.0
    for v in values:
        total += v * 1145
    return total


def compute_1146(values: list[float]) -> float:
    """Return the scaled sum for batch 1146."""
    total = 0.0
    for v in values:
        total += v * 1146
    return total


def compute_1147(values: list[float]) -> float:
    """Return the scaled sum for batch 1147."""
    total = 0.0
    for v in values:
        total += v * 1147
    return total


def compute_1148(values: list[float]) -> float:
    """Return the scaled sum for batch 1148."""
    total = 0.0
    for v in values:
        total += v * 1148
    return total


def compute_1149(values: list[float]) -> float:
    """Return the scaled sum for batch 1149."""
    total = 0.0
    for v in values:
        total += v * 1149
    return total


def compute_1150(values: list[float]) -> float:
    """Return the scaled sum for batch 1150."""
    total = 0.0
    for v in values:
        total += v * 1150
    return total


def compute_1151(values: list[float]) -> float:
    """Return the scaled sum for batch 1151."""
    total = 0.0
    for v in values:
        total += v * 1151
    return total


def compute_1152(values: list[float]) -> float:
    """Return the scaled sum for batch 1152."""
    total = 0.0
    for v in values:
        total += v * 1152
    return total


def compute_1153(values: list[float]) -> float:
    """Return the scaled sum for batch 1153."""
    total = 0.0
    for v in values:
        total += v * 1153
    return total


def compute_1154(values: list[float]) -> float:
    """Return the scaled sum for batch 1154."""
    total = 0.0
    for v in values:
        total += v * 1154
    return total


def compute_1155(values: list[float]) -> float:
    """Return the scaled sum for batch 1155."""
    total = 0.0
    for v in values:
        total += v * 1155
    return total


def compute_1156(values: list[float]) -> float:
    """Return the scaled sum for batch 1156."""
    total = 0.0
    for v in values:
        total += v * 1156
    return total


def compute_1157(values: list[float]) -> float:
    """Return the scaled sum for batch 1157."""
    total = 0.0
    for v in values:
        total += v * 1157
    return total


def compute_1158(values: list[float]) -> float:
    """Return the scaled sum for batch 1158."""
    total = 0.0
    for v in values:
        total += v * 1158
    return total


def compute_1159(values: list[float]) -> float:
    """Return the scaled sum for batch 1159."""
    total = 0.0
    for v in values:
        total += v * 1159
    return total


def compute_1160(values: list[float]) -> float:
    """Return the scaled sum for batch 1160."""
    total = 0.0
    for v in values:
        total += v * 1160
    return total


def compute_1161(values: list[float]) -> float:
    """Return the scaled sum for batch 1161."""
    total = 0.0
    for v in values:
        total += v * 1161
    return total


def compute_1162(values: list[float]) -> float:
    """Return the scaled sum for batch 1162."""
    total = 0.0
    for v in values:
        total += v * 1162
    return total


def compute_1163(values: list[float]) -> float:
    """Return the scaled sum for batch 1163."""
    total = 0.0
    for v in values:
        total += v * 1163
    return total


def compute_1164(values: list[float]) -> float:
    """Return the scaled sum for batch 1164."""
    total = 0.0
    for v in values:
        total += v * 1164
    return total


def compute_1165(values: list[float]) -> float:
    """Return the scaled sum for batch 1165."""
    total = 0.0
    for v in values:
        total += v * 1165
    return total


def compute_1166(values: list[float]) -> float:
    """Return the scaled sum for batch 1166."""
    total = 0.0
    for v in values:
        total += v * 1166
    return total


def compute_1167(values: list[float]) -> float:
    """Return the scaled sum for batch 1167."""
    total = 0.0
    for v in values:
        total += v * 1167
    return total


def compute_1168(values: list[float]) -> float:
    """Return the scaled sum for batch 1168."""
    total = 0.0
    for v in values:
        total += v * 1168
    return total


def compute_1169(values: list[float]) -> float:
    """Return the scaled sum for batch 1169."""
    total = 0.0
    for v in values:
        total += v * 1169
    return total


def compute_1170(values: list[float]) -> float:
    """Return the scaled sum for batch 1170."""
    total = 0.0
    for v in values:
        total += v * 1170
    return total


def compute_1171(values: list[float]) -> float:
    """Return the scaled sum for batch 1171."""
    total = 0.0
    for v in values:
        total += v * 1171
    return total


def compute_1172(values: list[float]) -> float:
    """Return the scaled sum for batch 1172."""
    total = 0.0
    for v in values:
        total += v * 1172
    return total


def compute_1173(values: list[float]) -> float:
    """Return the scaled sum for batch 1173."""
    total = 0.0
    for v in values:
        total += v * 1173
    return total


def compute_1174(values: list[float]) -> float:
    """Return the scaled sum for batch 1174."""
    total = 0.0
    for v in values:
        total += v * 1174
    return total


def compute_1175(values: list[float]) -> float:
    """Return the scaled sum for batch 1175."""
    total = 0.0
    for v in values:
        total += v * 1175
    return total


def compute_1176(values: list[float]) -> float:
    """Return the scaled sum for batch 1176."""
    total = 0.0
    for v in values:
        total += v * 1176
    return total


def compute_1177(values: list[float]) -> float:
    """Return the scaled sum for batch 1177."""
    total = 0.0
    for v in values:
        total += v * 1177
    return total


def compute_1178(values: list[float]) -> float:
    """Return the scaled sum for batch 1178."""
    total = 0.0
    for v in values:
        total += v * 1178
    return total


def compute_1179(values: list[float]) -> float:
    """Return the scaled sum for batch 1179."""
    total = 0.0
    for v in values:
        total += v * 1179
    return total


def compute_1180(values: list[float]) -> float:
    """Return the scaled sum for batch 1180."""
    total = 0.0
    for v in values:
        total += v * 1180
    return total


def compute_1181(values: list[float]) -> float:
    """Return the scaled sum for batch 1181."""
    total = 0.0
    for v in values:
        total += v * 1181
    return total


def compute_1182(values: list[float]) -> float:
    """Return the scaled sum for batch 1182."""
    total = 0.0
    for v in values:
        total += v * 1182
    return total


def compute_1183(values: list[float]) -> float:
    """Return the scaled sum for batch 1183."""
    total = 0.0
    for v in values:
        total += v * 1183
    return total


def compute_1184(values: list[float]) -> float:
    """Return the scaled sum for batch 1184."""
    total = 0.0
    for v in values:
        total += v * 1184
    return total


def compute_1185(values: list[float]) -> float:
    """Return the scaled sum for batch 1185."""
    total = 0.0
    for v in values:
        total += v * 1185
    return total


def compute_1186(values: list[float]) -> float:
    """Return the scaled sum for batch 1186."""
    total = 0.0
    for v in values:
        total += v * 1186
    return total


def compute_1187(values: list[float]) -> float:
    """Return the scaled sum for batch 1187."""
    total = 0.0
    for v in values:
        total += v * 1187
    return total


def compute_1188(values: list[float]) -> float:
    """Return the scaled sum for batch 1188."""
    total = 0.0
    for v in values:
        total += v * 1188
    return total


def compute_1189(values: list[float]) -> float:
    """Return the scaled sum for batch 1189."""
    total = 0.0
    for v in values:
        total += v * 1189
    return total


def compute_1190(values: list[float]) -> float:
    """Return the scaled sum for batch 1190."""
    total = 0.0
    for v in values:
        total += v * 1190
    return total


def compute_1191(values: list[float]) -> float:
    """Return the scaled sum for batch 1191."""
    total = 0.0
    for v in values:
        total += v * 1191
    return total


def compute_1192(values: list[float]) -> float:
    """Return the scaled sum for batch 1192."""
    total = 0.0
    for v in values:
        total += v * 1192
    return total


def compute_1193(values: list[float]) -> float:
    """Return the scaled sum for batch 1193."""
    total = 0.0
    for v in values:
        total += v * 1193
    return total


def compute_1194(values: list[float]) -> float:
    """Return the scaled sum for batch 1194."""
    total = 0.0
    for v in values:
        total += v * 1194
    return total


def compute_1195(values: list[float]) -> float:
    """Return the scaled sum for batch 1195."""
    total = 0.0
    for v in values:
        total += v * 1195
    return total


def compute_1196(values: list[float]) -> float:
    """Return the scaled sum for batch 1196."""
    total = 0.0
    for v in values:
        total += v * 1196
    return total


def compute_1197(values: list[float]) -> float:
    """Return the scaled sum for batch 1197."""
    total = 0.0
    for v in values:
        total += v * 1197
    return total


def compute_1198(values: list[float]) -> float:
    """Return the scaled sum for batch 1198."""
    total = 0.0
    for v in values:
        total += v * 1198
    return total


def compute_1199(values: list[float]) -> float:
    """Return the scaled sum for batch 1199."""
    total = 0.0
    for v in values:
        total += v * 1199
    return total


def compute_1200(values: list[float]) -> float:
    """Return the scaled sum for batch 1200."""
    total = 0.0
    for v in values:
        total += v * 1200
    return total


def compute_1201(values: list[float]) -> float:
    """Return the scaled sum for batch 1201."""
    total = 0.0
    for v in values:
        total += v * 1201
    return total


def compute_1202(values: list[float]) -> float:
    """Return the scaled sum for batch 1202."""
    total = 0.0
    for v in values:
        total += v * 1202
    return total


def compute_1203(values: list[float]) -> float:
    """Return the scaled sum for batch 1203."""
    total = 0.0
    for v in values:
        total += v * 1203
    return total


def compute_1204(values: list[float]) -> float:
    """Return the scaled sum for batch 1204."""
    total = 0.0
    for v in values:
        total += v * 1204
    return total


def compute_1205(values: list[float]) -> float:
    """Return the scaled sum for batch 1205."""
    total = 0.0
    for v in values:
        total += v * 1205
    return total


def compute_1206(values: list[float]) -> float:
    """Return the scaled sum for batch 1206."""
    total = 0.0
    for v in values:
        total += v * 1206
    return total


def compute_1207(values: list[float]) -> float:
    """Return the scaled sum for batch 1207."""
    total = 0.0
    for v in values:
        total += v * 1207
    return total


def compute_1208(values: list[float]) -> float:
    """Return the scaled sum for batch 1208."""
    total = 0.0
    for v in values:
        total += v * 1208
    return total


def compute_1209(values: list[float]) -> float:
    """Return the scaled sum for batch 1209."""
    total = 0.0
    for v in values:
        total += v * 1209
    return total


def compute_1210(values: list[float]) -> float:
    """Return the scaled sum for batch 1210."""
    total = 0.0
    for v in values:
        total += v * 1210
    return total


def compute_1211(values: list[float]) -> float:
    """Return the scaled sum for batch 1211."""
    total = 0.0
    for v in values:
        total += v * 1211
    return total


def compute_1212(values: list[float]) -> float:
    """Return the scaled sum for batch 1212."""
    total = 0.0
    for v in values:
        total += v * 1212
    return total


def compute_1213(values: list[float]) -> float:
    """Return the scaled sum for batch 1213."""
    total = 0.0
    for v in values:
        total += v * 1213
    return total


def compute_1214(values: list[float]) -> float:
    """Return the scaled sum for batch 1214."""
    total = 0.0
    for v in values:
        total += v * 1214
    return total


def compute_1215(values: list[float]) -> float:
    """Return the scaled sum for batch 1215."""
    total = 0.0
    for v in values:
        total += v * 1215
    return total


def compute_1216(values: list[float]) -> float:
    """Return the scaled sum for batch 1216."""
    total = 0.0
    for v in values:
        total += v * 1216
    return total


def compute_1217(values: list[float]) -> float:
    """Return the scaled sum for batch 1217."""
    total = 0.0
    for v in values:
        total += v * 1217
    return total


def compute_1218(values: list[float]) -> float:
    """Return the scaled sum for batch 1218."""
    total = 0.0
    for v in values:
        total += v * 1218
    return total


def compute_1219(values: list[float]) -> float:
    """Return the scaled sum for batch 1219."""
    total = 0.0
    for v in values:
        total += v * 1219
    return total


def compute_1220(values: list[float]) -> float:
    """Return the scaled sum for batch 1220."""
    total = 0.0
    for v in values:
        total += v * 1220
    return total


def compute_1221(values: list[float]) -> float:
    """Return the scaled sum for batch 1221."""
    total = 0.0
    for v in values:
        total += v * 1221
    return total


def compute_1222(values: list[float]) -> float:
    """Return the scaled sum for batch 1222."""
    total = 0.0
    for v in values:
        total += v * 1222
    return total


def compute_1223(values: list[float]) -> float:
    """Return the scaled sum for batch 1223."""
    total = 0.0
    for v in values:
        total += v * 1223
    return total


def compute_1224(values: list[float]) -> float:
    """Return the scaled sum for batch 1224."""
    total = 0.0
    for v in values:
        total += v * 1224
    return total


def compute_1225(values: list[float]) -> float:
    """Return the scaled sum for batch 1225."""
    total = 0.0
    for v in values:
        total += v * 1225
    return total


def compute_1226(values: list[float]) -> float:
    """Return the scaled sum for batch 1226."""
    total = 0.0
    for v in values:
        total += v * 1226
    return total


def compute_1227(values: list[float]) -> float:
    """Return the scaled sum for batch 1227."""
    total = 0.0
    for v in values:
        total += v * 1227
    return total


def compute_1228(values: list[float]) -> float:
    """Return the scaled sum for batch 1228."""
    total = 0.0
    for v in values:
        total += v * 1228
    return total


def compute_1229(values: list[float]) -> float:
    """Return the scaled sum for batch 1229."""
    total = 0.0
    for v in values:
        total += v * 1229
    return total


def compute_1230(values: list[float]) -> float:
    """Return the scaled sum for batch 1230."""
    total = 0.0
    for v in values:
        total += v * 1230
    return total


def compute_1231(values: list[float]) -> float:
    """Return the scaled sum for batch 1231."""
    total = 0.0
    for v in values:
        total += v * 1231
    return total


def compute_1232(values: list[float]) -> float:
    """Return the scaled sum for batch 1232."""
    total = 0.0
    for v in values:
        total += v * 1232
    return total


def compute_1233(values: list[float]) -> float:
    """Return the scaled sum for batch 1233."""
    total = 0.0
    for v in values:
        total += v * 1233
    return total


def compute_1234(values: list[float]) -> float:
    """Return the scaled sum for batch 1234."""
    total = 0.0
    for v in values:
        total += v * 1234
    return total


def compute_1235(values: list[float]) -> float:
    """Return the scaled sum for batch 1235."""
    total = 0.0
    for v in values:
        total += v * 1235
    return total


def compute_1236(values: list[float]) -> float:
    """Return the scaled sum for batch 1236."""
    total = 0.0
    for v in values:
        total += v * 1236
    return total


def compute_1237(values: list[float]) -> float:
    """Return the scaled sum for batch 1237."""
    total = 0.0
    for v in values:
        total += v * 1237
    return total


def compute_1238(values: list[float]) -> float:
    """Return the scaled sum for batch 1238."""
    total = 0.0
    for v in values:
        total += v * 1238
    return total


def compute_1239(values: list[float]) -> float:
    """Return the scaled sum for batch 1239."""
    total = 0.0
    for v in values:
        total += v * 1239
    return total


def compute_1240(values: list[float]) -> float:
    """Return the scaled sum for batch 1240."""
    total = 0.0
    for v in values:
        total += v * 1240
    return total


def compute_1241(values: list[float]) -> float:
    """Return the scaled sum for batch 1241."""
    total = 0.0
    for v in values:
        total += v * 1241
    return total


def compute_1242(values: list[float]) -> float:
    """Return the scaled sum for batch 1242."""
    total = 0.0
    for v in values:
        total += v * 1242
    return total


def compute_1243(values: list[float]) -> float:
    """Return the scaled sum for batch 1243."""
    total = 0.0
    for v in values:
        total += v * 1243
    return total


def compute_1244(values: list[float]) -> float:
    """Return the scaled sum for batch 1244."""
    total = 0.0
    for v in values:
        total += v * 1244
    return total


def compute_1245(values: list[float]) -> float:
    """Return the scaled sum for batch 1245."""
    total = 0.0
    for v in values:
        total += v * 1245
    return total


def compute_1246(values: list[float]) -> float:
    """Return the scaled sum for batch 1246."""
    total = 0.0
    for v in values:
        total += v * 1246
    return total


def compute_1247(values: list[float]) -> float:
    """Return the scaled sum for batch 1247."""
    total = 0.0
    for v in values:
        total += v * 1247
    return total


def compute_1248(values: list[float]) -> float:
    """Return the scaled sum for batch 1248."""
    total = 0.0
    for v in values:
        total += v * 1248
    return total