tx · 6ZUx4CxEdxGEKysKjPAAhaAWjcVtawSR398oJAV2c3VQ

3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY:  -0.01000000 Waves

2024.06.09 17:35 [3143325] smart account 3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY > SELF 0.00000000 Waves

{
    "type": 13,
    "id": "6ZUx4CxEdxGEKysKjPAAhaAWjcVtawSR398oJAV2c3VQ",
    "fee": 1000000,
    "feeAssetId": null,
    "timestamp": 1717943710648,
    "version": 2,
    "chainId": 84,
    "sender": "3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY",
    "senderPublicKey": "2AWdnJuBMzufXSjTvzVcawBQQhnhF1iXR6QNVgwn33oc",
    "proofs": [
        "2XLri11Smd7wQMhTFaYugX3iwCfeCjxMiDgAv6u9BMpRX8fwoa7zvfT9w52zVWihwoVwHf4qqNKFkdmPydJtpbGm"
    ],
    "script": "base64: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",
    "height": 3143325,
    "applicationStatus": "succeeded",
    "spentComplexity": 0
}

View: original | compacted
Prev: 6Ag2Dz5ACGV1QFSeWCTFFXeTntWPm7LJKXkHCEQgQxjE
Next: iLK3jGMDmDhi5uY8BqmpYMqtqM7TxFQTu1SRiWqQRvW

Diff: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-let weights_layer_1 = [[564, 1539, -23179, 855, 294, 992, 5476, 6462, 5706], [1917, -323, 1527, 663, 9898, -1842, -2539, -5642, -8671], [-6042, -3786, 10256, -3162, 10158, -3899, 9125, -4040, -7722], [-1352, -922, -1104, 509, -34, 490, 5265, -12258, 9412], [-6464, -4986, 8360, -4702, -6679, 8185, -7182, -4902, 6565], [2731, 2632, -1565, 2507, 4954, 1299, -21654, 2803, 2973], [-6119, -3811, -2055, -3351, 14558, 532, -673, 1631, 3778], [6040, -838, -2110, -3854, 5085, -7445, -5852, -2461, 2966], [-4305, -3403, -2766, -3236, -4289, -1690, -4486, 21035, -4907], [-2672, -2470, -3494, -4088, -3877, -3084, 19487, -2652, -3706], [2412, 1642, 1964, -18620, -1462, 1182, -3050, -1253, 670], [19242, -2063, -4350, -3449, -5421, -4376, -4500, -3187, -4753], [-423, -2939, 14505, 251, -3736, -2437, -801, -2938, -3626], [-3949, 2718, -4336, -616, 4477, -317, -3449, 2738, -3683], [222, -14478, 407, -266, -8125, 2276, -770, 7233, 2045], [-4305, -4933, -4848, 2460, -2529, 9859, 2373, 674, 4044], [-5309, 10785, -5094, -3997, 10031, -4763, -5325, 10792, -5739], [-21947, 2385, 1861, 1808, 663, 1519, 2530, 2931, 4297], [-806, -3733, -6338, 1896, -14255, -3034, 5184, 5033, 260], [5592, 2940, 506, 5670, 741, 3691, 3501, 1949, -21185], [-1364, 1321, 274, -8135, -818, 998, -35, 945, -1949], [-129, -755, 2327, -4149, -13780, -2145, 121, -4248, 1181], [8429, 9219, 7419, -3778, -8656, -4177, -8727, -6674, -8870], [-2176, -3671, -12291, 5772, 5707, 176, 5703, -6078, -4386], [-1839, 2272, -1238, 4154, -12551, 4606, -6216, 21, 1667], [358, -5103, -3725, 10010, -2287, -1696, -2364, -2487, -766], [-1863, 20045, -3277, -1732, -4059, -1788, -1120, -914, -1592], [1803, 4262, 1396, 4433, 3261, -22890, 2005, 4044, 3658], [-3681, 678, 1429, 4937, -7337, 4294, 7123, 1740, -6057], [4997, 4766, -744, 7316, 4186, 2866, 5265, -16537, 1584], [-2515, -1614, -3018, -2442, -5076, -3150, -5879, -333, 17206], [-2745, -1716, -2322, -4940, -4712, 21290, -3686, -4457, -4159], [-3365, -1416, -1958, -14770, 53, -2617, 5627, 6320, 7960], [5355, 1147, 1384, -915, 3172, -2462, 947, -13150, 2117], [7412, -19148, -65, 2697, 6621, 1645, 4059, 2603, 3924], [-6636, -2689, -3386, 9831, 8304, 10028, -4819, -3035, -6716]]
4+let weights_layer_1 = [[60049, 60073], [41419, 41425]]
55 
6-let biases_layer_1 = [-6632, -548, -12850, -4518, -9916, -4022, -668, -4817, -2828, -3640, -4752, -4800, 151, 7959, -5093, -564, -11437, -6961, -4759, -7890, 8094, -1435, -10481, -3502, -2916, 5716, -2811, -6803, -2598, -2480, -3309, -5554, -7707, -4774, -3217, -11177]
6+let biases_layer_1 = [-25905, -63563]
77 
8-let weights_layer_2 = [[-2096, -1305, 5422, 3073, 3504, 5502, -2672, 5596, 1887, 10049, -1150, 5652, -1567, 363, -2745, 2825, 6455, 6153, -1234, -3728, 953, -3504, 4523, -1796, 3711, -266, -2127, 12373, -137, -726, -365, 12859, 232, 2427, 1257, 6005], [-106, -2166, -4757, 110, -2887, -1229, 431, 1116, 10520, -3279, -4476, 5340, 6974, 5935, -5474, 2669, -3732, -1383, -2237, -6304, 8181, 3944, -3330, 1628, -770, 3266, -10111, 6225, -245, 5486, -3833, 9944, -4287, 3038, -5067, -4065], [2510, 1181, -2623, 5033, -4689, -7522, 982, -1767, 1762, 614, 629, 9461, 892, 1024, -448, -2775, -1788, -7064, -479, 1173, -394, 5090, -4726, 4378, -468, -417, 498, 784, -2916, 678, 4935, 1103, -3363, -2438, 470, 1189], [-2360, 3603, -596, 747, -1269, 4471, -11635, 913, -3798, -3722, -4302, -1479, 3493, -257, 1495, 3177, 393, 559, -1514, 332, -4115, -401, 740, -8928, 6055, 3887, -1232, -7560, 3886, 3661, -6356, 2298, -5153, -153, -1423, -1253], [418, -74, -194, -537, 664, -712, -321, -1606, -606, 1231, 1318, -492, -1264, -1238, -1042, -678, -1643, -1346, -1354, -1211, -813, -76, -1336, -1019, 219, -1526, -689, -954, 51, -158, -427, 687, -256, -1220, -1567, 368], [-173, 241, 1681, -3579, -397, -2941, 5489, 3201, 4842, -4938, 1533, -3574, -1694, -4417, 1214, -103, -6495, -1498, 6381, 1009, 2520, -2869, 827, 1633, 3153, 2898, 6345, 12259, 319, 6083, -1585, 15327, 1697, 5367, 1243, -2953], [107, 145, -2188, 403, -911, 1298, -2149, 2150, -2290, -2026, -3789, -6824, 203, 915, 2349, 2191, -2096, 5985, -2224, 3649, -14167, -5157, -1335, -1897, 7794, 19238, -848, 10763, 3764, 3190, -5095, -8904, -5128, -1621, -1361, 1856], [3341, -1613, -2545, -1826, 4012, 5400, -2311, 722, -916, -830, -563, -2565, 1867, 4541, 6163, -4621, -2253, -1077, -1949, -2230, 356, 560, -1588, -390, -596, -1143, 19868, -1873, -410, 4803, -2544, 239, 977, 168, 8759, 4005], [-9858, 3688, 4177, 290, 520, -2893, -3909, 2431, 4223, 2125, 6224, 428, 73, 153, -2108, -5298, -99, -2885, 201, 12336, -1906, 2079, 4876, -589, 2448, -1349, -379, 7642, -1544, -3603, 2004, 2510, -1904, 2209, -1215, -117], [2281, -1072, 3996, -2334, 4235, -5507, -5850, -1218, 1095, -2154, -642, -2979, 9930, -3455, 1385, -4333, 863, 9045, -201, 2592, 2021, 891, -640, -7210, 4180, 377, 210, 2567, -3675, 459, -1476, 985, 2661, 1220, 562, 2375], [4832, -1143, -237, 1941, -4376, -5830, -387, -4099, -756, 12251, -3078, -3504, -2443, 4335, -4996, 1416, 206, 505, -4118, -159, -155, 2033, -5753, 4897, -732, -721, -853, -847, 5195, -1607, -1054, -2430, -1948, -2840, 1089, -6073], [17104, 2700, 2898, 1350, -2431, 1451, 150, -4051, -4498, -5733, 206, 3039, -4419, -3286, -4724, 835, 3310, 4881, 4011, 1028, -2818, -4128, -4579, 4811, -1824, 3096, 834, -6460, -561, 1406, 1344, 3584, 3963, -7074, -10575, 1183], [2078, 1015, 5473, -3486, -2176, -7196, -3221, 2047, 235, -2161, 7465, 17932, 1139, 16, 555, -4492, 780, 16413, 118, -3092, 1895, -611, -4913, -3975, 1483, 1696, 673, 2002, 1675, -85, -2287, 4063, 5576, 4087, 4041, -1404], [-5883, -5918, -837, 2697, -40, 350, -2524, 3499, 6892, 917, 2915, 518, 2635, -10878, -2696, 1323, -2544, -2772, 11436, -1107, -192, 11603, 5059, -4973, 12019, -99, 4420, -4674, 4064, -1382, 837, 3351, -5541, 614, -6637, -475], [-2295, 3567, 2535, 3126, 3960, 2910, -3538, -679, -2642, 4519, -3754, 14892, 476, 2866, 4168, -3821, 4623, 10654, 6543, 7306, -1025, 3456, 688, 318, -4355, 1513, 3300, -1805, -4555, -2618, 4840, 2324, 432, -3001, 4289, 6549], [3931, -807, -1791, 970, 6028, 6852, 285, 651, 2335, 7948, -6, 3726, 6668, -268, -4170, -1777, 4997, 1468, -1039, -424, -35, -267, 1643, -2070, -1533, 1219, -949, -411, 3380, -2783, 982, -3889, -1680, 1290, -3117, 5231], [-1577, -3050, -2093, 1381, -783, 3137, 6044, -1401, 381, -871, -814, -4675, -610, -1684, -382, 1224, -2221, 10105, -4910, -3667, 527, -6593, -1908, 1695, -3573, -1310, 2604, 2930, -5818, 1367, 1013, -1488, 555, -1199, -348, -236], [3335, -3891, -4146, 662, -5076, -5571, -1160, -1221, -2333, 2318, -6249, -2111, 1009, 2932, 2470, 2442, -3146, -6213, 4366, 1164, -574, 1966, -7984, -1998, -716, 3432, 4135, 4532, 6444, -3933, -2834, -866, -3434, -2958, 5587, -1600], [-838, 253, -859, -1222, 4350, -92, 607, 4011, 2234, -387, 4093, -1213, 14403, -1620, -1193, -4969, -4509, 2447, -2574, -1982, 1761, 499, -649, -6015, 942, -2154, -1608, 2990, -3994, -1568, 56, -4305, -2286, 4976, 813, 1030], [3066, 5948, 4074, -1060, 5667, -4937, 5734, 423, -2048, 2584, 697, 420, -825, -3885, 4486, -1865, 7827, 3486, 9713, -5074, -1460, -186, 9088, -2956, 4742, 310, -1012, 3708, -733, -1804, 1802, 223, 4528, 67, 1969, 2272], [4582, -2931, -1982, -5158, -1475, 444, 1703, 2309, 18746, 1479, 745, -216, -5152, -3864, -728, -4970, 1313, -3858, 5493, 4351, -1562, 49, -54, 1383, 1103, -282, -751, 4091, 1670, -6141, -1063, -4440, 377, -6219, 2215, -2458], [10033, -3350, -908, 3179, 3946, 4611, 107, 125, -5169, -971, 2597, -3581, 6468, -1559, 2573, -1565, 5836, -7819, 4255, 559, 2011, -2218, 3906, 1816, -1021, 3104, 3707, 2128, 3470, 265, -1217, -1012, 5130, 1898, 9447, 1013], [658, -1685, -1712, -790, -2307, 705, 5439, 580, 1744, -373, -2189, 1641, 18, -252, -2386, 2081, -1499, 2503, 1551, -4418, -1009, 3080, -446, -335, 2319, -1773, 2688, 3668, -2440, 1957, 3894, 1961, -1972, -623, -3800, -365], [-1669, 10737, 672, 964, 3822, 1905, 11737, 1648, 275, -3024, -3696, -1608, -2571, 6669, 139, -1584, -913, -2322, -6145, 702, 1485, -8048, -1778, 7825, -8300, -3090, -3025, 4640, -5757, 4231, -1531, -2860, 1907, 5703, -723, -797], [-2633, -5119, 8627, 2168, -890, 3944, -2776, 3651, 5205, 1529, 3780, -3753, -1904, -904, 1457, 4857, -746, -2564, -8256, -3110, 3267, -4825, 1364, 824, 1032, -2630, 14493, 2457, -1367, 1206, 3163, 5313, 1431, 4222, 6849, 6444], [-4291, 1097, -844, 2177, 3425, 14896, 4484, 7910, 5684, 21400, 3932, -705, 2131, -1274, 548, 1000, -2338, -2291, -3747, -6956, 73, -1122, 1148, 3160, 3379, -1019, -185, -2722, 4599, 3741, 879, -1954, -3506, 2368, 1223, 2317], [-2185, 223, -4644, -1412, 630, -3031, 2708, -3382, -911, 3367, 13855, 3568, -1963, -1066, 1143, -335, 687, -7617, -1032, -785, 9567, 1614, -3619, 3592, -7180, -12214, 840, -5226, -4516, -2974, -1094, 4227, 9004, -402, -2994, -2658], [799, -3078, 3005, 11370, -4284, 3271, 2849, 3684, -2867, -2893, 568, -4617, 471, 1593, 974, -847, 1607, 286, -1218, 16983, 3677, 284, 1897, -4501, 1976, 349, -1392, 885, -1849, -3860, 19921, 3745, 2275, -1508, -2128, -606], [-185, 3390, 277, -695, 3227, 2887, 4299, -2136, -2134, -1883, 6438, -2668, -4444, 5344, 1075, 1191, 2022, 815, -4963, -4414, 7824, -5766, -1414, 103, -5981, -1158, 556, -3631, -2253, -4335, -4069, 1289, 5596, -94, 34, -3464], [1685, -4007, -1332, -856, -3036, -4039, -2013, -1274, -1556, 4618, -4698, 5203, -107, -4809, -1377, -2733, -2406, -6411, 3977, 4240, -5948, 1050, -1793, 2509, -1882, 3806, -357, 4023, 2805, 4061, -1415, -309, -4757, -254, 2470, 488], [-7290, -3075, -2002, 503, -5791, -3621, 630, -2569, 4729, -3445, -1732, 3170, -816, 5571, -1525, 1089, -10117, 497, -195, -3385, 7700, 4913, -10956, -243, -37, 3590, 8360, -7880, -4761, -1089, 2892, -8772, -3768, 810, 213, -7224], [-8266, 1528, -936, 2328, 8643, 830, 4138, -3567, 2847, -1492, 3043, -91, -3211, -3528, 5105, -910, -5218, 8871, -2732, -5464, 1250, 1456, 917, 525, 4296, 995, 1819, -6723, -2903, 2621, 683, 481, 615, 965, 2595, -1880], [2655, -2790, 12413, 7609, 2861, -217, 3780, 322, 15931, -932, 5160, 1737, 3562, -2485, -6777, -997, 5342, -626, -1949, 4562, -2205, -3122, 2830, -1207, -2284, 5697, 870, -4454, 4004, 14396, 5935, 228, 825, 7482, 3312, 8595], [-2393, 5001, -637, -3215, -1747, 2528, -2626, -1978, -1652, -1195, -2664, -211, -5308, -526, 1315, 1522, -1125, -3577, -966, 3713, 228, -317, -1283, -2120, 4743, 1380, 192, 2520, 404, -4582, -410, 7377, -774, -3070, -717, -1071], [1777, -1480, 1443, -1212, 1609, -1079, -427, 179, -1312, -463, 296, 1210, -1256, -1443, -1357, -972, -19, 1103, -1031, -1670, 2018, 793, -869, -1243, 1891, -1822, 3238, -1969, -381, -1679, -309, 1502, -534, -1169, -1331, -1924], [-5742, 2942, -166, -4927, 2651, 7606, -2251, 1903, -1186, -3071, 2323, -7556, 13648, -1901, 2113, -4962, -1996, 7644, 4242, 1634, 2084, 2424, -1206, -7340, -1060, -3872, 578, 2666, 1271, -985, -2562, 2440, 1036, 1219, 3700, 4020]]
8+let weights_layer_2 = [[83296, -89714]]
99 
10-let biases_layer_2 = [-1768, 8209, 1935, 6068, 1144, 945, 2821, 287, -1979, 456, 7230, -4163, 1676, -2168, -3095, -1961, -1625, 8204, -26, -7049, -1025, -6862, -1472, -7671, 1261, -3408, -7758, 2778, -2872, -5227, 21209, 343, -7070, -12, 336, -2278]
11-
12-let weights_layer_3 = [[-9317, 2910, 620, -228, 1610, 5421, 2761, 754, 2811, -2270, 4988, -6310, -21426, 2005, -16974, -4720, -4436, 7522, -111, -6940, -571, 1793, 150, -333, 4354, 2925, 2484, 4565, 4936, 388, 4070, -8381, -2501, 2472, -409, 6175], [1091, 14985, 5994, 7419, -1692, -7007, 1985, -17003, 3320, -5234, 2948, 3433, -2081, 4357, -5485, -37, 3740, -7076, 914, -4549, 487, -6295, 3202, -1999, -12831, 4826, 2047, 2865, 3341, -8123, 1152, -4427, -2360, 845, -3851, -1567], [3170, -3001, 16, 4114, 1448, 2750, 3644, -3529, 7086, -14054, 2580, -21113, -1151, 704, 1254, -6595, 2279, -2830, -18095, -2609, 1310, -10586, 457, -856, 4277, 2065, 1340, -2091, -2006, -7650, 9399, 9203, -5005, 6350, 1069, -16685], [31, 4815, 12845, -5516, 1626, 3480, -29237, 824, -584, -5454, 1714, 546, -5355, -1901, 3747, -1101, 8750, 6956, 1419, -6528, 846, -7768, 8701, -1002, 73, 168, -29198, -1835, 107, 4095, 4639, -3291, -5653, 4476, -728, 9307], [5863, 4945, 1281, 4748, 408, -6666, 1562, 468, -1625, 205, 3391, -915, 3150, -31536, -4780, -1298, -3063, 2241, 1305, -14830, 314, -3245, -3722, -28292, 8745, -828, 1695, 2445, -12087, -5147, 7734, -7306, 582, 2032, -553, -710], [-14743, -6340, 5274, 5173, 314, -14713, 5069, 1868, -2584, -2057, 4332, 3800, -4649, 2024, 2323, 3965, 5948, -3578, 4193, -4258, 6240, -3034, -882, 3563, -5152, 2657, 8463, -4486, -11621, -7521, 14395, 6833, -1, -3908, -424, 1679], [-9986, 2993, 2819, 5901, -498, 7336, 407, -1869, -764, 3495, -11816, 5097, 6429, -1581, -6180, -10516, 5264, 7540, 961, -475, -741, -6460, 800, 3218, -2338, -21638, -3159, 1523, 3848, -970, 7511, -532, 1004, -878, 1619, 1557], [69, -2163, 827, 8828, -385, -2432, 2613, 704, -907, -3341, 8018, 2854, -458, -2626, 4308, -1242, 3521, 8610, -3073, 964, -21911, 2565, 2032, 2134, -5156, -4150, 5429, 4212, 791, -6657, 4684, -6473, -19282, 8318, 3605, 4658], [536, 7804, -2112, 7804, -1536, 3409, -308, 6206, -16063, -2231, 4157, -1351, 5013, -931, -8226, 599, -8239, 898, -2716, -1701, 4741, -3679, 219, 3529, -3815, 2257, 5035, -22650, -2400, -7163, 3112, 1954, -8977, 966, -1432, 5029]]
13-
14-let biases_layer_3 = [11212, 2074, 7455, -585, 8587, 2132, 6372, 4342, 6426]
10+let biases_layer_2 = [-38117]
1511 
1612 func linear_forward_1 (input,weights,biases) = {
17-    let weighted_sum1 = (((if ((size(input) > 0))
18-        then (input[0] * weights[0][0])
19-        else (0 + (if ((size(input) > 1))
20-            then (input[1] * weights[0][1])
21-            else (0 + (if ((size(input) > 2))
22-                then (input[2] * weights[0][2])
23-                else (0 + (if ((size(input) > 3))
24-                    then (input[3] * weights[0][3])
25-                    else (0 + (if ((size(input) > 4))
26-                        then (input[4] * weights[0][4])
27-                        else (0 + (if ((size(input) > 5))
28-                            then (input[5] * weights[0][5])
29-                            else (0 + (if ((size(input) > 6))
30-                                then (input[6] * weights[0][6])
31-                                else (0 + (if ((size(input) > 7))
32-                                    then (input[7] * weights[0][7])
33-                                    else (0 + (if ((size(input) > 8))
34-                                        then (input[8] * weights[0][8])
35-                                        else 0))))))))))))))))) / 10000) + biases[0])
36-    let weighted_sum2 = (((if ((size(input) > 0))
37-        then (input[0] * weights[1][0])
38-        else (0 + (if ((size(input) > 1))
39-            then (input[1] * weights[1][1])
40-            else (0 + (if ((size(input) > 2))
41-                then (input[2] * weights[1][2])
42-                else (0 + (if ((size(input) > 3))
43-                    then (input[3] * weights[1][3])
44-                    else (0 + (if ((size(input) > 4))
45-                        then (input[4] * weights[1][4])
46-                        else (0 + (if ((size(input) > 5))
47-                            then (input[5] * weights[1][5])
48-                            else (0 + (if ((size(input) > 6))
49-                                then (input[6] * weights[1][6])
50-                                else (0 + (if ((size(input) > 7))
51-                                    then (input[7] * weights[1][7])
52-                                    else (0 + (if ((size(input) > 8))
53-                                        then (input[8] * weights[1][8])
54-                                        else 0))))))))))))))))) / 10000) + biases[1])
55-    let weighted_sum3 = (((if ((size(input) > 0))
56-        then (input[0] * weights[2][0])
57-        else (0 + (if ((size(input) > 1))
58-            then (input[1] * weights[2][1])
59-            else (0 + (if ((size(input) > 2))
60-                then (input[2] * weights[2][2])
61-                else (0 + (if ((size(input) > 3))
62-                    then (input[3] * weights[2][3])
63-                    else (0 + (if ((size(input) > 4))
64-                        then (input[4] * weights[2][4])
65-                        else (0 + (if ((size(input) > 5))
66-                            then (input[5] * weights[2][5])
67-                            else (0 + (if ((size(input) > 6))
68-                                then (input[6] * weights[2][6])
69-                                else (0 + (if ((size(input) > 7))
70-                                    then (input[7] * weights[2][7])
71-                                    else (0 + (if ((size(input) > 8))
72-                                        then (input[8] * weights[2][8])
73-                                        else 0))))))))))))))))) / 10000) + biases[2])
74-    let weighted_sum4 = (((if ((size(input) > 0))
75-        then (input[0] * weights[3][0])
76-        else (0 + (if ((size(input) > 1))
77-            then (input[1] * weights[3][1])
78-            else (0 + (if ((size(input) > 2))
79-                then (input[2] * weights[3][2])
80-                else (0 + (if ((size(input) > 3))
81-                    then (input[3] * weights[3][3])
82-                    else (0 + (if ((size(input) > 4))
83-                        then (input[4] * weights[3][4])
84-                        else (0 + (if ((size(input) > 5))
85-                            then (input[5] * weights[3][5])
86-                            else (0 + (if ((size(input) > 6))
87-                                then (input[6] * weights[3][6])
88-                                else (0 + (if ((size(input) > 7))
89-                                    then (input[7] * weights[3][7])
90-                                    else (0 + (if ((size(input) > 8))
91-                                        then (input[8] * weights[3][8])
92-                                        else 0))))))))))))))))) / 10000) + biases[3])
93-    let weighted_sum5 = (((if ((size(input) > 0))
94-        then (input[0] * weights[4][0])
95-        else (0 + (if ((size(input) > 1))
96-            then (input[1] * weights[4][1])
97-            else (0 + (if ((size(input) > 2))
98-                then (input[2] * weights[4][2])
99-                else (0 + (if ((size(input) > 3))
100-                    then (input[3] * weights[4][3])
101-                    else (0 + (if ((size(input) > 4))
102-                        then (input[4] * weights[4][4])
103-                        else (0 + (if ((size(input) > 5))
104-                            then (input[5] * weights[4][5])
105-                            else (0 + (if ((size(input) > 6))
106-                                then (input[6] * weights[4][6])
107-                                else (0 + (if ((size(input) > 7))
108-                                    then (input[7] * weights[4][7])
109-                                    else (0 + (if ((size(input) > 8))
110-                                        then (input[8] * weights[4][8])
111-                                        else 0))))))))))))))))) / 10000) + biases[4])
112-    let weighted_sum6 = (((if ((size(input) > 0))
113-        then (input[0] * weights[5][0])
114-        else (0 + (if ((size(input) > 1))
115-            then (input[1] * weights[5][1])
116-            else (0 + (if ((size(input) > 2))
117-                then (input[2] * weights[5][2])
118-                else (0 + (if ((size(input) > 3))
119-                    then (input[3] * weights[5][3])
120-                    else (0 + (if ((size(input) > 4))
121-                        then (input[4] * weights[5][4])
122-                        else (0 + (if ((size(input) > 5))
123-                            then (input[5] * weights[5][5])
124-                            else (0 + (if ((size(input) > 6))
125-                                then (input[6] * weights[5][6])
126-                                else (0 + (if ((size(input) > 7))
127-                                    then (input[7] * weights[5][7])
128-                                    else (0 + (if ((size(input) > 8))
129-                                        then (input[8] * weights[5][8])
130-                                        else 0))))))))))))))))) / 10000) + biases[5])
131-    let weighted_sum7 = (((if ((size(input) > 0))
132-        then (input[0] * weights[6][0])
133-        else (0 + (if ((size(input) > 1))
134-            then (input[1] * weights[6][1])
135-            else (0 + (if ((size(input) > 2))
136-                then (input[2] * weights[6][2])
137-                else (0 + (if ((size(input) > 3))
138-                    then (input[3] * weights[6][3])
139-                    else (0 + (if ((size(input) > 4))
140-                        then (input[4] * weights[6][4])
141-                        else (0 + (if ((size(input) > 5))
142-                            then (input[5] * weights[6][5])
143-                            else (0 + (if ((size(input) > 6))
144-                                then (input[6] * weights[6][6])
145-                                else (0 + (if ((size(input) > 7))
146-                                    then (input[7] * weights[6][7])
147-                                    else (0 + (if ((size(input) > 8))
148-                                        then (input[8] * weights[6][8])
149-                                        else 0))))))))))))))))) / 10000) + biases[6])
150-    let weighted_sum8 = (((if ((size(input) > 0))
151-        then (input[0] * weights[7][0])
152-        else (0 + (if ((size(input) > 1))
153-            then (input[1] * weights[7][1])
154-            else (0 + (if ((size(input) > 2))
155-                then (input[2] * weights[7][2])
156-                else (0 + (if ((size(input) > 3))
157-                    then (input[3] * weights[7][3])
158-                    else (0 + (if ((size(input) > 4))
159-                        then (input[4] * weights[7][4])
160-                        else (0 + (if ((size(input) > 5))
161-                            then (input[5] * weights[7][5])
162-                            else (0 + (if ((size(input) > 6))
163-                                then (input[6] * weights[7][6])
164-                                else (0 + (if ((size(input) > 7))
165-                                    then (input[7] * weights[7][7])
166-                                    else (0 + (if ((size(input) > 8))
167-                                        then (input[8] * weights[7][8])
168-                                        else 0))))))))))))))))) / 10000) + biases[7])
169-    let weighted_sum9 = (((if ((size(input) > 0))
170-        then (input[0] * weights[8][0])
171-        else (0 + (if ((size(input) > 1))
172-            then (input[1] * weights[8][1])
173-            else (0 + (if ((size(input) > 2))
174-                then (input[2] * weights[8][2])
175-                else (0 + (if ((size(input) > 3))
176-                    then (input[3] * weights[8][3])
177-                    else (0 + (if ((size(input) > 4))
178-                        then (input[4] * weights[8][4])
179-                        else (0 + (if ((size(input) > 5))
180-                            then (input[5] * weights[8][5])
181-                            else (0 + (if ((size(input) > 6))
182-                                then (input[6] * weights[8][6])
183-                                else (0 + (if ((size(input) > 7))
184-                                    then (input[7] * weights[8][7])
185-                                    else (0 + (if ((size(input) > 8))
186-                                        then (input[8] * weights[8][8])
187-                                        else 0))))))))))))))))) / 10000) + biases[8])
188-    let weighted_sum10 = (((if ((size(input) > 0))
189-        then (input[0] * weights[9][0])
190-        else (0 + (if ((size(input) > 1))
191-            then (input[1] * weights[9][1])
192-            else (0 + (if ((size(input) > 2))
193-                then (input[2] * weights[9][2])
194-                else (0 + (if ((size(input) > 3))
195-                    then (input[3] * weights[9][3])
196-                    else (0 + (if ((size(input) > 4))
197-                        then (input[4] * weights[9][4])
198-                        else (0 + (if ((size(input) > 5))
199-                            then (input[5] * weights[9][5])
200-                            else (0 + (if ((size(input) > 6))
201-                                then (input[6] * weights[9][6])
202-                                else (0 + (if ((size(input) > 7))
203-                                    then (input[7] * weights[9][7])
204-                                    else (0 + (if ((size(input) > 8))
205-                                        then (input[8] * weights[9][8])
206-                                        else 0))))))))))))))))) / 10000) + biases[9])
207-    let weighted_sum11 = (((if ((size(input) > 0))
208-        then (input[0] * weights[10][0])
209-        else (0 + (if ((size(input) > 1))
210-            then (input[1] * weights[10][1])
211-            else (0 + (if ((size(input) > 2))
212-                then (input[2] * weights[10][2])
213-                else (0 + (if ((size(input) > 3))
214-                    then (input[3] * weights[10][3])
215-                    else (0 + (if ((size(input) > 4))
216-                        then (input[4] * weights[10][4])
217-                        else (0 + (if ((size(input) > 5))
218-                            then (input[5] * weights[10][5])
219-                            else (0 + (if ((size(input) > 6))
220-                                then (input[6] * weights[10][6])
221-                                else (0 + (if ((size(input) > 7))
222-                                    then (input[7] * weights[10][7])
223-                                    else (0 + (if ((size(input) > 8))
224-                                        then (input[8] * weights[10][8])
225-                                        else 0))))))))))))))))) / 10000) + biases[10])
226-    let weighted_sum12 = (((if ((size(input) > 0))
227-        then (input[0] * weights[11][0])
228-        else (0 + (if ((size(input) > 1))
229-            then (input[1] * weights[11][1])
230-            else (0 + (if ((size(input) > 2))
231-                then (input[2] * weights[11][2])
232-                else (0 + (if ((size(input) > 3))
233-                    then (input[3] * weights[11][3])
234-                    else (0 + (if ((size(input) > 4))
235-                        then (input[4] * weights[11][4])
236-                        else (0 + (if ((size(input) > 5))
237-                            then (input[5] * weights[11][5])
238-                            else (0 + (if ((size(input) > 6))
239-                                then (input[6] * weights[11][6])
240-                                else (0 + (if ((size(input) > 7))
241-                                    then (input[7] * weights[11][7])
242-                                    else (0 + (if ((size(input) > 8))
243-                                        then (input[8] * weights[11][8])
244-                                        else 0))))))))))))))))) / 10000) + biases[11])
245-    let weighted_sum13 = (((if ((size(input) > 0))
246-        then (input[0] * weights[12][0])
247-        else (0 + (if ((size(input) > 1))
248-            then (input[1] * weights[12][1])
249-            else (0 + (if ((size(input) > 2))
250-                then (input[2] * weights[12][2])
251-                else (0 + (if ((size(input) > 3))
252-                    then (input[3] * weights[12][3])
253-                    else (0 + (if ((size(input) > 4))
254-                        then (input[4] * weights[12][4])
255-                        else (0 + (if ((size(input) > 5))
256-                            then (input[5] * weights[12][5])
257-                            else (0 + (if ((size(input) > 6))
258-                                then (input[6] * weights[12][6])
259-                                else (0 + (if ((size(input) > 7))
260-                                    then (input[7] * weights[12][7])
261-                                    else (0 + (if ((size(input) > 8))
262-                                        then (input[8] * weights[12][8])
263-                                        else 0))))))))))))))))) / 10000) + biases[12])
264-    let weighted_sum14 = (((if ((size(input) > 0))
265-        then (input[0] * weights[13][0])
266-        else (0 + (if ((size(input) > 1))
267-            then (input[1] * weights[13][1])
268-            else (0 + (if ((size(input) > 2))
269-                then (input[2] * weights[13][2])
270-                else (0 + (if ((size(input) > 3))
271-                    then (input[3] * weights[13][3])
272-                    else (0 + (if ((size(input) > 4))
273-                        then (input[4] * weights[13][4])
274-                        else (0 + (if ((size(input) > 5))
275-                            then (input[5] * weights[13][5])
276-                            else (0 + (if ((size(input) > 6))
277-                                then (input[6] * weights[13][6])
278-                                else (0 + (if ((size(input) > 7))
279-                                    then (input[7] * weights[13][7])
280-                                    else (0 + (if ((size(input) > 8))
281-                                        then (input[8] * weights[13][8])
282-                                        else 0))))))))))))))))) / 10000) + biases[13])
283-    let weighted_sum15 = (((if ((size(input) > 0))
284-        then (input[0] * weights[14][0])
285-        else (0 + (if ((size(input) > 1))
286-            then (input[1] * weights[14][1])
287-            else (0 + (if ((size(input) > 2))
288-                then (input[2] * weights[14][2])
289-                else (0 + (if ((size(input) > 3))
290-                    then (input[3] * weights[14][3])
291-                    else (0 + (if ((size(input) > 4))
292-                        then (input[4] * weights[14][4])
293-                        else (0 + (if ((size(input) > 5))
294-                            then (input[5] * weights[14][5])
295-                            else (0 + (if ((size(input) > 6))
296-                                then (input[6] * weights[14][6])
297-                                else (0 + (if ((size(input) > 7))
298-                                    then (input[7] * weights[14][7])
299-                                    else (0 + (if ((size(input) > 8))
300-                                        then (input[8] * weights[14][8])
301-                                        else 0))))))))))))))))) / 10000) + biases[14])
302-    let weighted_sum16 = (((if ((size(input) > 0))
303-        then (input[0] * weights[15][0])
304-        else (0 + (if ((size(input) > 1))
305-            then (input[1] * weights[15][1])
306-            else (0 + (if ((size(input) > 2))
307-                then (input[2] * weights[15][2])
308-                else (0 + (if ((size(input) > 3))
309-                    then (input[3] * weights[15][3])
310-                    else (0 + (if ((size(input) > 4))
311-                        then (input[4] * weights[15][4])
312-                        else (0 + (if ((size(input) > 5))
313-                            then (input[5] * weights[15][5])
314-                            else (0 + (if ((size(input) > 6))
315-                                then (input[6] * weights[15][6])
316-                                else (0 + (if ((size(input) > 7))
317-                                    then (input[7] * weights[15][7])
318-                                    else (0 + (if ((size(input) > 8))
319-                                        then (input[8] * weights[15][8])
320-                                        else 0))))))))))))))))) / 10000) + biases[15])
321-    let weighted_sum17 = (((if ((size(input) > 0))
322-        then (input[0] * weights[16][0])
323-        else (0 + (if ((size(input) > 1))
324-            then (input[1] * weights[16][1])
325-            else (0 + (if ((size(input) > 2))
326-                then (input[2] * weights[16][2])
327-                else (0 + (if ((size(input) > 3))
328-                    then (input[3] * weights[16][3])
329-                    else (0 + (if ((size(input) > 4))
330-                        then (input[4] * weights[16][4])
331-                        else (0 + (if ((size(input) > 5))
332-                            then (input[5] * weights[16][5])
333-                            else (0 + (if ((size(input) > 6))
334-                                then (input[6] * weights[16][6])
335-                                else (0 + (if ((size(input) > 7))
336-                                    then (input[7] * weights[16][7])
337-                                    else (0 + (if ((size(input) > 8))
338-                                        then (input[8] * weights[16][8])
339-                                        else 0))))))))))))))))) / 10000) + biases[16])
340-    let weighted_sum18 = (((if ((size(input) > 0))
341-        then (input[0] * weights[17][0])
342-        else (0 + (if ((size(input) > 1))
343-            then (input[1] * weights[17][1])
344-            else (0 + (if ((size(input) > 2))
345-                then (input[2] * weights[17][2])
346-                else (0 + (if ((size(input) > 3))
347-                    then (input[3] * weights[17][3])
348-                    else (0 + (if ((size(input) > 4))
349-                        then (input[4] * weights[17][4])
350-                        else (0 + (if ((size(input) > 5))
351-                            then (input[5] * weights[17][5])
352-                            else (0 + (if ((size(input) > 6))
353-                                then (input[6] * weights[17][6])
354-                                else (0 + (if ((size(input) > 7))
355-                                    then (input[7] * weights[17][7])
356-                                    else (0 + (if ((size(input) > 8))
357-                                        then (input[8] * weights[17][8])
358-                                        else 0))))))))))))))))) / 10000) + biases[17])
359-    let weighted_sum19 = (((if ((size(input) > 0))
360-        then (input[0] * weights[18][0])
361-        else (0 + (if ((size(input) > 1))
362-            then (input[1] * weights[18][1])
363-            else (0 + (if ((size(input) > 2))
364-                then (input[2] * weights[18][2])
365-                else (0 + (if ((size(input) > 3))
366-                    then (input[3] * weights[18][3])
367-                    else (0 + (if ((size(input) > 4))
368-                        then (input[4] * weights[18][4])
369-                        else (0 + (if ((size(input) > 5))
370-                            then (input[5] * weights[18][5])
371-                            else (0 + (if ((size(input) > 6))
372-                                then (input[6] * weights[18][6])
373-                                else (0 + (if ((size(input) > 7))
374-                                    then (input[7] * weights[18][7])
375-                                    else (0 + (if ((size(input) > 8))
376-                                        then (input[8] * weights[18][8])
377-                                        else 0))))))))))))))))) / 10000) + biases[18])
378-    let weighted_sum20 = (((if ((size(input) > 0))
379-        then (input[0] * weights[19][0])
380-        else (0 + (if ((size(input) > 1))
381-            then (input[1] * weights[19][1])
382-            else (0 + (if ((size(input) > 2))
383-                then (input[2] * weights[19][2])
384-                else (0 + (if ((size(input) > 3))
385-                    then (input[3] * weights[19][3])
386-                    else (0 + (if ((size(input) > 4))
387-                        then (input[4] * weights[19][4])
388-                        else (0 + (if ((size(input) > 5))
389-                            then (input[5] * weights[19][5])
390-                            else (0 + (if ((size(input) > 6))
391-                                then (input[6] * weights[19][6])
392-                                else (0 + (if ((size(input) > 7))
393-                                    then (input[7] * weights[19][7])
394-                                    else (0 + (if ((size(input) > 8))
395-                                        then (input[8] * weights[19][8])
396-                                        else 0))))))))))))))))) / 10000) + biases[19])
397-    let weighted_sum21 = (((if ((size(input) > 0))
398-        then (input[0] * weights[20][0])
399-        else (0 + (if ((size(input) > 1))
400-            then (input[1] * weights[20][1])
401-            else (0 + (if ((size(input) > 2))
402-                then (input[2] * weights[20][2])
403-                else (0 + (if ((size(input) > 3))
404-                    then (input[3] * weights[20][3])
405-                    else (0 + (if ((size(input) > 4))
406-                        then (input[4] * weights[20][4])
407-                        else (0 + (if ((size(input) > 5))
408-                            then (input[5] * weights[20][5])
409-                            else (0 + (if ((size(input) > 6))
410-                                then (input[6] * weights[20][6])
411-                                else (0 + (if ((size(input) > 7))
412-                                    then (input[7] * weights[20][7])
413-                                    else (0 + (if ((size(input) > 8))
414-                                        then (input[8] * weights[20][8])
415-                                        else 0))))))))))))))))) / 10000) + biases[20])
416-    let weighted_sum22 = (((if ((size(input) > 0))
417-        then (input[0] * weights[21][0])
418-        else (0 + (if ((size(input) > 1))
419-            then (input[1] * weights[21][1])
420-            else (0 + (if ((size(input) > 2))
421-                then (input[2] * weights[21][2])
422-                else (0 + (if ((size(input) > 3))
423-                    then (input[3] * weights[21][3])
424-                    else (0 + (if ((size(input) > 4))
425-                        then (input[4] * weights[21][4])
426-                        else (0 + (if ((size(input) > 5))
427-                            then (input[5] * weights[21][5])
428-                            else (0 + (if ((size(input) > 6))
429-                                then (input[6] * weights[21][6])
430-                                else (0 + (if ((size(input) > 7))
431-                                    then (input[7] * weights[21][7])
432-                                    else (0 + (if ((size(input) > 8))
433-                                        then (input[8] * weights[21][8])
434-                                        else 0))))))))))))))))) / 10000) + biases[21])
435-    let weighted_sum23 = (((if ((size(input) > 0))
436-        then (input[0] * weights[22][0])
437-        else (0 + (if ((size(input) > 1))
438-            then (input[1] * weights[22][1])
439-            else (0 + (if ((size(input) > 2))
440-                then (input[2] * weights[22][2])
441-                else (0 + (if ((size(input) > 3))
442-                    then (input[3] * weights[22][3])
443-                    else (0 + (if ((size(input) > 4))
444-                        then (input[4] * weights[22][4])
445-                        else (0 + (if ((size(input) > 5))
446-                            then (input[5] * weights[22][5])
447-                            else (0 + (if ((size(input) > 6))
448-                                then (input[6] * weights[22][6])
449-                                else (0 + (if ((size(input) > 7))
450-                                    then (input[7] * weights[22][7])
451-                                    else (0 + (if ((size(input) > 8))
452-                                        then (input[8] * weights[22][8])
453-                                        else 0))))))))))))))))) / 10000) + biases[22])
454-    let weighted_sum24 = (((if ((size(input) > 0))
455-        then (input[0] * weights[23][0])
456-        else (0 + (if ((size(input) > 1))
457-            then (input[1] * weights[23][1])
458-            else (0 + (if ((size(input) > 2))
459-                then (input[2] * weights[23][2])
460-                else (0 + (if ((size(input) > 3))
461-                    then (input[3] * weights[23][3])
462-                    else (0 + (if ((size(input) > 4))
463-                        then (input[4] * weights[23][4])
464-                        else (0 + (if ((size(input) > 5))
465-                            then (input[5] * weights[23][5])
466-                            else (0 + (if ((size(input) > 6))
467-                                then (input[6] * weights[23][6])
468-                                else (0 + (if ((size(input) > 7))
469-                                    then (input[7] * weights[23][7])
470-                                    else (0 + (if ((size(input) > 8))
471-                                        then (input[8] * weights[23][8])
472-                                        else 0))))))))))))))))) / 10000) + biases[23])
473-    let weighted_sum25 = (((if ((size(input) > 0))
474-        then (input[0] * weights[24][0])
475-        else (0 + (if ((size(input) > 1))
476-            then (input[1] * weights[24][1])
477-            else (0 + (if ((size(input) > 2))
478-                then (input[2] * weights[24][2])
479-                else (0 + (if ((size(input) > 3))
480-                    then (input[3] * weights[24][3])
481-                    else (0 + (if ((size(input) > 4))
482-                        then (input[4] * weights[24][4])
483-                        else (0 + (if ((size(input) > 5))
484-                            then (input[5] * weights[24][5])
485-                            else (0 + (if ((size(input) > 6))
486-                                then (input[6] * weights[24][6])
487-                                else (0 + (if ((size(input) > 7))
488-                                    then (input[7] * weights[24][7])
489-                                    else (0 + (if ((size(input) > 8))
490-                                        then (input[8] * weights[24][8])
491-                                        else 0))))))))))))))))) / 10000) + biases[24])
492-    let weighted_sum26 = (((if ((size(input) > 0))
493-        then (input[0] * weights[25][0])
494-        else (0 + (if ((size(input) > 1))
495-            then (input[1] * weights[25][1])
496-            else (0 + (if ((size(input) > 2))
497-                then (input[2] * weights[25][2])
498-                else (0 + (if ((size(input) > 3))
499-                    then (input[3] * weights[25][3])
500-                    else (0 + (if ((size(input) > 4))
501-                        then (input[4] * weights[25][4])
502-                        else (0 + (if ((size(input) > 5))
503-                            then (input[5] * weights[25][5])
504-                            else (0 + (if ((size(input) > 6))
505-                                then (input[6] * weights[25][6])
506-                                else (0 + (if ((size(input) > 7))
507-                                    then (input[7] * weights[25][7])
508-                                    else (0 + (if ((size(input) > 8))
509-                                        then (input[8] * weights[25][8])
510-                                        else 0))))))))))))))))) / 10000) + biases[25])
511-    let weighted_sum27 = (((if ((size(input) > 0))
512-        then (input[0] * weights[26][0])
513-        else (0 + (if ((size(input) > 1))
514-            then (input[1] * weights[26][1])
515-            else (0 + (if ((size(input) > 2))
516-                then (input[2] * weights[26][2])
517-                else (0 + (if ((size(input) > 3))
518-                    then (input[3] * weights[26][3])
519-                    else (0 + (if ((size(input) > 4))
520-                        then (input[4] * weights[26][4])
521-                        else (0 + (if ((size(input) > 5))
522-                            then (input[5] * weights[26][5])
523-                            else (0 + (if ((size(input) > 6))
524-                                then (input[6] * weights[26][6])
525-                                else (0 + (if ((size(input) > 7))
526-                                    then (input[7] * weights[26][7])
527-                                    else (0 + (if ((size(input) > 8))
528-                                        then (input[8] * weights[26][8])
529-                                        else 0))))))))))))))))) / 10000) + biases[26])
530-    let weighted_sum28 = (((if ((size(input) > 0))
531-        then (input[0] * weights[27][0])
532-        else (0 + (if ((size(input) > 1))
533-            then (input[1] * weights[27][1])
534-            else (0 + (if ((size(input) > 2))
535-                then (input[2] * weights[27][2])
536-                else (0 + (if ((size(input) > 3))
537-                    then (input[3] * weights[27][3])
538-                    else (0 + (if ((size(input) > 4))
539-                        then (input[4] * weights[27][4])
540-                        else (0 + (if ((size(input) > 5))
541-                            then (input[5] * weights[27][5])
542-                            else (0 + (if ((size(input) > 6))
543-                                then (input[6] * weights[27][6])
544-                                else (0 + (if ((size(input) > 7))
545-                                    then (input[7] * weights[27][7])
546-                                    else (0 + (if ((size(input) > 8))
547-                                        then (input[8] * weights[27][8])
548-                                        else 0))))))))))))))))) / 10000) + biases[27])
549-    let weighted_sum29 = (((if ((size(input) > 0))
550-        then (input[0] * weights[28][0])
551-        else (0 + (if ((size(input) > 1))
552-            then (input[1] * weights[28][1])
553-            else (0 + (if ((size(input) > 2))
554-                then (input[2] * weights[28][2])
555-                else (0 + (if ((size(input) > 3))
556-                    then (input[3] * weights[28][3])
557-                    else (0 + (if ((size(input) > 4))
558-                        then (input[4] * weights[28][4])
559-                        else (0 + (if ((size(input) > 5))
560-                            then (input[5] * weights[28][5])
561-                            else (0 + (if ((size(input) > 6))
562-                                then (input[6] * weights[28][6])
563-                                else (0 + (if ((size(input) > 7))
564-                                    then (input[7] * weights[28][7])
565-                                    else (0 + (if ((size(input) > 8))
566-                                        then (input[8] * weights[28][8])
567-                                        else 0))))))))))))))))) / 10000) + biases[28])
568-    let weighted_sum30 = (((if ((size(input) > 0))
569-        then (input[0] * weights[29][0])
570-        else (0 + (if ((size(input) > 1))
571-            then (input[1] * weights[29][1])
572-            else (0 + (if ((size(input) > 2))
573-                then (input[2] * weights[29][2])
574-                else (0 + (if ((size(input) > 3))
575-                    then (input[3] * weights[29][3])
576-                    else (0 + (if ((size(input) > 4))
577-                        then (input[4] * weights[29][4])
578-                        else (0 + (if ((size(input) > 5))
579-                            then (input[5] * weights[29][5])
580-                            else (0 + (if ((size(input) > 6))
581-                                then (input[6] * weights[29][6])
582-                                else (0 + (if ((size(input) > 7))
583-                                    then (input[7] * weights[29][7])
584-                                    else (0 + (if ((size(input) > 8))
585-                                        then (input[8] * weights[29][8])
586-                                        else 0))))))))))))))))) / 10000) + biases[29])
587-    let weighted_sum31 = (((if ((size(input) > 0))
588-        then (input[0] * weights[30][0])
589-        else (0 + (if ((size(input) > 1))
590-            then (input[1] * weights[30][1])
591-            else (0 + (if ((size(input) > 2))
592-                then (input[2] * weights[30][2])
593-                else (0 + (if ((size(input) > 3))
594-                    then (input[3] * weights[30][3])
595-                    else (0 + (if ((size(input) > 4))
596-                        then (input[4] * weights[30][4])
597-                        else (0 + (if ((size(input) > 5))
598-                            then (input[5] * weights[30][5])
599-                            else (0 + (if ((size(input) > 6))
600-                                then (input[6] * weights[30][6])
601-                                else (0 + (if ((size(input) > 7))
602-                                    then (input[7] * weights[30][7])
603-                                    else (0 + (if ((size(input) > 8))
604-                                        then (input[8] * weights[30][8])
605-                                        else 0))))))))))))))))) / 10000) + biases[30])
606-    let weighted_sum32 = (((if ((size(input) > 0))
607-        then (input[0] * weights[31][0])
608-        else (0 + (if ((size(input) > 1))
609-            then (input[1] * weights[31][1])
610-            else (0 + (if ((size(input) > 2))
611-                then (input[2] * weights[31][2])
612-                else (0 + (if ((size(input) > 3))
613-                    then (input[3] * weights[31][3])
614-                    else (0 + (if ((size(input) > 4))
615-                        then (input[4] * weights[31][4])
616-                        else (0 + (if ((size(input) > 5))
617-                            then (input[5] * weights[31][5])
618-                            else (0 + (if ((size(input) > 6))
619-                                then (input[6] * weights[31][6])
620-                                else (0 + (if ((size(input) > 7))
621-                                    then (input[7] * weights[31][7])
622-                                    else (0 + (if ((size(input) > 8))
623-                                        then (input[8] * weights[31][8])
624-                                        else 0))))))))))))))))) / 10000) + biases[31])
625-    let weighted_sum33 = (((if ((size(input) > 0))
626-        then (input[0] * weights[32][0])
627-        else (0 + (if ((size(input) > 1))
628-            then (input[1] * weights[32][1])
629-            else (0 + (if ((size(input) > 2))
630-                then (input[2] * weights[32][2])
631-                else (0 + (if ((size(input) > 3))
632-                    then (input[3] * weights[32][3])
633-                    else (0 + (if ((size(input) > 4))
634-                        then (input[4] * weights[32][4])
635-                        else (0 + (if ((size(input) > 5))
636-                            then (input[5] * weights[32][5])
637-                            else (0 + (if ((size(input) > 6))
638-                                then (input[6] * weights[32][6])
639-                                else (0 + (if ((size(input) > 7))
640-                                    then (input[7] * weights[32][7])
641-                                    else (0 + (if ((size(input) > 8))
642-                                        then (input[8] * weights[32][8])
643-                                        else 0))))))))))))))))) / 10000) + biases[32])
644-    let weighted_sum34 = (((if ((size(input) > 0))
645-        then (input[0] * weights[33][0])
646-        else (0 + (if ((size(input) > 1))
647-            then (input[1] * weights[33][1])
648-            else (0 + (if ((size(input) > 2))
649-                then (input[2] * weights[33][2])
650-                else (0 + (if ((size(input) > 3))
651-                    then (input[3] * weights[33][3])
652-                    else (0 + (if ((size(input) > 4))
653-                        then (input[4] * weights[33][4])
654-                        else (0 + (if ((size(input) > 5))
655-                            then (input[5] * weights[33][5])
656-                            else (0 + (if ((size(input) > 6))
657-                                then (input[6] * weights[33][6])
658-                                else (0 + (if ((size(input) > 7))
659-                                    then (input[7] * weights[33][7])
660-                                    else (0 + (if ((size(input) > 8))
661-                                        then (input[8] * weights[33][8])
662-                                        else 0))))))))))))))))) / 10000) + biases[33])
663-    let weighted_sum35 = (((if ((size(input) > 0))
664-        then (input[0] * weights[34][0])
665-        else (0 + (if ((size(input) > 1))
666-            then (input[1] * weights[34][1])
667-            else (0 + (if ((size(input) > 2))
668-                then (input[2] * weights[34][2])
669-                else (0 + (if ((size(input) > 3))
670-                    then (input[3] * weights[34][3])
671-                    else (0 + (if ((size(input) > 4))
672-                        then (input[4] * weights[34][4])
673-                        else (0 + (if ((size(input) > 5))
674-                            then (input[5] * weights[34][5])
675-                            else (0 + (if ((size(input) > 6))
676-                                then (input[6] * weights[34][6])
677-                                else (0 + (if ((size(input) > 7))
678-                                    then (input[7] * weights[34][7])
679-                                    else (0 + (if ((size(input) > 8))
680-                                        then (input[8] * weights[34][8])
681-                                        else 0))))))))))))))))) / 10000) + biases[34])
682-    let weighted_sum36 = (((if ((size(input) > 0))
683-        then (input[0] * weights[35][0])
684-        else (0 + (if ((size(input) > 1))
685-            then (input[1] * weights[35][1])
686-            else (0 + (if ((size(input) > 2))
687-                then (input[2] * weights[35][2])
688-                else (0 + (if ((size(input) > 3))
689-                    then (input[3] * weights[35][3])
690-                    else (0 + (if ((size(input) > 4))
691-                        then (input[4] * weights[35][4])
692-                        else (0 + (if ((size(input) > 5))
693-                            then (input[5] * weights[35][5])
694-                            else (0 + (if ((size(input) > 6))
695-                                then (input[6] * weights[35][6])
696-                                else (0 + (if ((size(input) > 7))
697-                                    then (input[7] * weights[35][7])
698-                                    else (0 + (if ((size(input) > 8))
699-                                        then (input[8] * weights[35][8])
700-                                        else 0))))))))))))))))) / 10000) + biases[35])
701-[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9, weighted_sum10, weighted_sum11, weighted_sum12, weighted_sum13, weighted_sum14, weighted_sum15, weighted_sum16, weighted_sum17, weighted_sum18, weighted_sum19, weighted_sum20, weighted_sum21, weighted_sum22, weighted_sum23, weighted_sum24, weighted_sum25, weighted_sum26, weighted_sum27, weighted_sum28, weighted_sum29, weighted_sum30, weighted_sum31, weighted_sum32, weighted_sum33, weighted_sum34, weighted_sum35, weighted_sum36]
13+    let weighted_sum1 = ((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) / 10000) + biases[0])
14+    let weighted_sum2 = ((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) / 10000) + biases[1])
15+[weighted_sum1, weighted_sum2]
70216     }
70317 
70418 
70519 func linear_forward_2 (input,weights,biases) = {
706-    let weighted_sum1 = (((if ((size(input) > 0))
707-        then (input[0] * weights[0][0])
708-        else (0 + (if ((size(input) > 1))
709-            then (input[1] * weights[0][1])
710-            else (0 + (if ((size(input) > 2))
711-                then (input[2] * weights[0][2])
712-                else (0 + (if ((size(input) > 3))
713-                    then (input[3] * weights[0][3])
714-                    else (0 + (if ((size(input) > 4))
715-                        then (input[4] * weights[0][4])
716-                        else (0 + (if ((size(input) > 5))
717-                            then (input[5] * weights[0][5])
718-                            else (0 + (if ((size(input) > 6))
719-                                then (input[6] * weights[0][6])
720-                                else (0 + (if ((size(input) > 7))
721-                                    then (input[7] * weights[0][7])
722-                                    else (0 + (if ((size(input) > 8))
723-                                        then (input[8] * weights[0][8])
724-                                        else (0 + (if ((size(input) > 9))
725-                                            then (input[9] * weights[0][9])
726-                                            else (0 + (if ((size(input) > 10))
727-                                                then (input[10] * weights[0][10])
728-                                                else (0 + (if ((size(input) > 11))
729-                                                    then (input[11] * weights[0][11])
730-                                                    else (0 + (if ((size(input) > 12))
731-                                                        then (input[12] * weights[0][12])
732-                                                        else (0 + (if ((size(input) > 13))
733-                                                            then (input[13] * weights[0][13])
734-                                                            else (0 + (if ((size(input) > 14))
735-                                                                then (input[14] * weights[0][14])
736-                                                                else (0 + (if ((size(input) > 15))
737-                                                                    then (input[15] * weights[0][15])
738-                                                                    else (0 + (if ((size(input) > 16))
739-                                                                        then (input[16] * weights[0][16])
740-                                                                        else (0 + (if ((size(input) > 17))
741-                                                                            then (input[17] * weights[0][17])
742-                                                                            else (0 + (if ((size(input) > 18))
743-                                                                                then (input[18] * weights[0][18])
744-                                                                                else (0 + (if ((size(input) > 19))
745-                                                                                    then (input[19] * weights[0][19])
746-                                                                                    else (0 + (if ((size(input) > 20))
747-                                                                                        then (input[20] * weights[0][20])
748-                                                                                        else (0 + (if ((size(input) > 21))
749-                                                                                            then (input[21] * weights[0][21])
750-                                                                                            else (0 + (if ((size(input) > 22))
751-                                                                                                then (input[22] * weights[0][22])
752-                                                                                                else (0 + (if ((size(input) > 23))
753-                                                                                                    then (input[23] * weights[0][23])
754-                                                                                                    else (0 + (if ((size(input) > 24))
755-                                                                                                        then (input[24] * weights[0][24])
756-                                                                                                        else (0 + (if ((size(input) > 25))
757-                                                                                                            then (input[25] * weights[0][25])
758-                                                                                                            else (0 + (if ((size(input) > 26))
759-                                                                                                                then (input[26] * weights[0][26])
760-                                                                                                                else (0 + (if ((size(input) > 27))
761-                                                                                                                    then (input[27] * weights[0][27])
762-                                                                                                                    else (0 + (if ((size(input) > 28))
763-                                                                                                                        then (input[28] * weights[0][28])
764-                                                                                                                        else (0 + (if ((size(input) > 29))
765-                                                                                                                            then (input[29] * weights[0][29])
766-                                                                                                                            else (0 + (if ((size(input) > 30))
767-                                                                                                                                then (input[30] * weights[0][30])
768-                                                                                                                                else (0 + (if ((size(input) > 31))
769-                                                                                                                                    then (input[31] * weights[0][31])
770-                                                                                                                                    else (0 + (if ((size(input) > 32))
771-                                                                                                                                        then (input[32] * weights[0][32])
772-                                                                                                                                        else (0 + (if ((size(input) > 33))
773-                                                                                                                                            then (input[33] * weights[0][33])
774-                                                                                                                                            else (0 + (if ((size(input) > 34))
775-                                                                                                                                                then (input[34] * weights[0][34])
776-                                                                                                                                                else (0 + (if ((size(input) > 35))
777-                                                                                                                                                    then (input[35] * weights[0][35])
778-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[0])
779-    let weighted_sum2 = (((if ((size(input) > 0))
780-        then (input[0] * weights[1][0])
781-        else (0 + (if ((size(input) > 1))
782-            then (input[1] * weights[1][1])
783-            else (0 + (if ((size(input) > 2))
784-                then (input[2] * weights[1][2])
785-                else (0 + (if ((size(input) > 3))
786-                    then (input[3] * weights[1][3])
787-                    else (0 + (if ((size(input) > 4))
788-                        then (input[4] * weights[1][4])
789-                        else (0 + (if ((size(input) > 5))
790-                            then (input[5] * weights[1][5])
791-                            else (0 + (if ((size(input) > 6))
792-                                then (input[6] * weights[1][6])
793-                                else (0 + (if ((size(input) > 7))
794-                                    then (input[7] * weights[1][7])
795-                                    else (0 + (if ((size(input) > 8))
796-                                        then (input[8] * weights[1][8])
797-                                        else (0 + (if ((size(input) > 9))
798-                                            then (input[9] * weights[1][9])
799-                                            else (0 + (if ((size(input) > 10))
800-                                                then (input[10] * weights[1][10])
801-                                                else (0 + (if ((size(input) > 11))
802-                                                    then (input[11] * weights[1][11])
803-                                                    else (0 + (if ((size(input) > 12))
804-                                                        then (input[12] * weights[1][12])
805-                                                        else (0 + (if ((size(input) > 13))
806-                                                            then (input[13] * weights[1][13])
807-                                                            else (0 + (if ((size(input) > 14))
808-                                                                then (input[14] * weights[1][14])
809-                                                                else (0 + (if ((size(input) > 15))
810-                                                                    then (input[15] * weights[1][15])
811-                                                                    else (0 + (if ((size(input) > 16))
812-                                                                        then (input[16] * weights[1][16])
813-                                                                        else (0 + (if ((size(input) > 17))
814-                                                                            then (input[17] * weights[1][17])
815-                                                                            else (0 + (if ((size(input) > 18))
816-                                                                                then (input[18] * weights[1][18])
817-                                                                                else (0 + (if ((size(input) > 19))
818-                                                                                    then (input[19] * weights[1][19])
819-                                                                                    else (0 + (if ((size(input) > 20))
820-                                                                                        then (input[20] * weights[1][20])
821-                                                                                        else (0 + (if ((size(input) > 21))
822-                                                                                            then (input[21] * weights[1][21])
823-                                                                                            else (0 + (if ((size(input) > 22))
824-                                                                                                then (input[22] * weights[1][22])
825-                                                                                                else (0 + (if ((size(input) > 23))
826-                                                                                                    then (input[23] * weights[1][23])
827-                                                                                                    else (0 + (if ((size(input) > 24))
828-                                                                                                        then (input[24] * weights[1][24])
829-                                                                                                        else (0 + (if ((size(input) > 25))
830-                                                                                                            then (input[25] * weights[1][25])
831-                                                                                                            else (0 + (if ((size(input) > 26))
832-                                                                                                                then (input[26] * weights[1][26])
833-                                                                                                                else (0 + (if ((size(input) > 27))
834-                                                                                                                    then (input[27] * weights[1][27])
835-                                                                                                                    else (0 + (if ((size(input) > 28))
836-                                                                                                                        then (input[28] * weights[1][28])
837-                                                                                                                        else (0 + (if ((size(input) > 29))
838-                                                                                                                            then (input[29] * weights[1][29])
839-                                                                                                                            else (0 + (if ((size(input) > 30))
840-                                                                                                                                then (input[30] * weights[1][30])
841-                                                                                                                                else (0 + (if ((size(input) > 31))
842-                                                                                                                                    then (input[31] * weights[1][31])
843-                                                                                                                                    else (0 + (if ((size(input) > 32))
844-                                                                                                                                        then (input[32] * weights[1][32])
845-                                                                                                                                        else (0 + (if ((size(input) > 33))
846-                                                                                                                                            then (input[33] * weights[1][33])
847-                                                                                                                                            else (0 + (if ((size(input) > 34))
848-                                                                                                                                                then (input[34] * weights[1][34])
849-                                                                                                                                                else (0 + (if ((size(input) > 35))
850-                                                                                                                                                    then (input[35] * weights[1][35])
851-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[1])
852-    let weighted_sum3 = (((if ((size(input) > 0))
853-        then (input[0] * weights[2][0])
854-        else (0 + (if ((size(input) > 1))
855-            then (input[1] * weights[2][1])
856-            else (0 + (if ((size(input) > 2))
857-                then (input[2] * weights[2][2])
858-                else (0 + (if ((size(input) > 3))
859-                    then (input[3] * weights[2][3])
860-                    else (0 + (if ((size(input) > 4))
861-                        then (input[4] * weights[2][4])
862-                        else (0 + (if ((size(input) > 5))
863-                            then (input[5] * weights[2][5])
864-                            else (0 + (if ((size(input) > 6))
865-                                then (input[6] * weights[2][6])
866-                                else (0 + (if ((size(input) > 7))
867-                                    then (input[7] * weights[2][7])
868-                                    else (0 + (if ((size(input) > 8))
869-                                        then (input[8] * weights[2][8])
870-                                        else (0 + (if ((size(input) > 9))
871-                                            then (input[9] * weights[2][9])
872-                                            else (0 + (if ((size(input) > 10))
873-                                                then (input[10] * weights[2][10])
874-                                                else (0 + (if ((size(input) > 11))
875-                                                    then (input[11] * weights[2][11])
876-                                                    else (0 + (if ((size(input) > 12))
877-                                                        then (input[12] * weights[2][12])
878-                                                        else (0 + (if ((size(input) > 13))
879-                                                            then (input[13] * weights[2][13])
880-                                                            else (0 + (if ((size(input) > 14))
881-                                                                then (input[14] * weights[2][14])
882-                                                                else (0 + (if ((size(input) > 15))
883-                                                                    then (input[15] * weights[2][15])
884-                                                                    else (0 + (if ((size(input) > 16))
885-                                                                        then (input[16] * weights[2][16])
886-                                                                        else (0 + (if ((size(input) > 17))
887-                                                                            then (input[17] * weights[2][17])
888-                                                                            else (0 + (if ((size(input) > 18))
889-                                                                                then (input[18] * weights[2][18])
890-                                                                                else (0 + (if ((size(input) > 19))
891-                                                                                    then (input[19] * weights[2][19])
892-                                                                                    else (0 + (if ((size(input) > 20))
893-                                                                                        then (input[20] * weights[2][20])
894-                                                                                        else (0 + (if ((size(input) > 21))
895-                                                                                            then (input[21] * weights[2][21])
896-                                                                                            else (0 + (if ((size(input) > 22))
897-                                                                                                then (input[22] * weights[2][22])
898-                                                                                                else (0 + (if ((size(input) > 23))
899-                                                                                                    then (input[23] * weights[2][23])
900-                                                                                                    else (0 + (if ((size(input) > 24))
901-                                                                                                        then (input[24] * weights[2][24])
902-                                                                                                        else (0 + (if ((size(input) > 25))
903-                                                                                                            then (input[25] * weights[2][25])
904-                                                                                                            else (0 + (if ((size(input) > 26))
905-                                                                                                                then (input[26] * weights[2][26])
906-                                                                                                                else (0 + (if ((size(input) > 27))
907-                                                                                                                    then (input[27] * weights[2][27])
908-                                                                                                                    else (0 + (if ((size(input) > 28))
909-                                                                                                                        then (input[28] * weights[2][28])
910-                                                                                                                        else (0 + (if ((size(input) > 29))
911-                                                                                                                            then (input[29] * weights[2][29])
912-                                                                                                                            else (0 + (if ((size(input) > 30))
913-                                                                                                                                then (input[30] * weights[2][30])
914-                                                                                                                                else (0 + (if ((size(input) > 31))
915-                                                                                                                                    then (input[31] * weights[2][31])
916-                                                                                                                                    else (0 + (if ((size(input) > 32))
917-                                                                                                                                        then (input[32] * weights[2][32])
918-                                                                                                                                        else (0 + (if ((size(input) > 33))
919-                                                                                                                                            then (input[33] * weights[2][33])
920-                                                                                                                                            else (0 + (if ((size(input) > 34))
921-                                                                                                                                                then (input[34] * weights[2][34])
922-                                                                                                                                                else (0 + (if ((size(input) > 35))
923-                                                                                                                                                    then (input[35] * weights[2][35])
924-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[2])
925-    let weighted_sum4 = (((if ((size(input) > 0))
926-        then (input[0] * weights[3][0])
927-        else (0 + (if ((size(input) > 1))
928-            then (input[1] * weights[3][1])
929-            else (0 + (if ((size(input) > 2))
930-                then (input[2] * weights[3][2])
931-                else (0 + (if ((size(input) > 3))
932-                    then (input[3] * weights[3][3])
933-                    else (0 + (if ((size(input) > 4))
934-                        then (input[4] * weights[3][4])
935-                        else (0 + (if ((size(input) > 5))
936-                            then (input[5] * weights[3][5])
937-                            else (0 + (if ((size(input) > 6))
938-                                then (input[6] * weights[3][6])
939-                                else (0 + (if ((size(input) > 7))
940-                                    then (input[7] * weights[3][7])
941-                                    else (0 + (if ((size(input) > 8))
942-                                        then (input[8] * weights[3][8])
943-                                        else (0 + (if ((size(input) > 9))
944-                                            then (input[9] * weights[3][9])
945-                                            else (0 + (if ((size(input) > 10))
946-                                                then (input[10] * weights[3][10])
947-                                                else (0 + (if ((size(input) > 11))
948-                                                    then (input[11] * weights[3][11])
949-                                                    else (0 + (if ((size(input) > 12))
950-                                                        then (input[12] * weights[3][12])
951-                                                        else (0 + (if ((size(input) > 13))
952-                                                            then (input[13] * weights[3][13])
953-                                                            else (0 + (if ((size(input) > 14))
954-                                                                then (input[14] * weights[3][14])
955-                                                                else (0 + (if ((size(input) > 15))
956-                                                                    then (input[15] * weights[3][15])
957-                                                                    else (0 + (if ((size(input) > 16))
958-                                                                        then (input[16] * weights[3][16])
959-                                                                        else (0 + (if ((size(input) > 17))
960-                                                                            then (input[17] * weights[3][17])
961-                                                                            else (0 + (if ((size(input) > 18))
962-                                                                                then (input[18] * weights[3][18])
963-                                                                                else (0 + (if ((size(input) > 19))
964-                                                                                    then (input[19] * weights[3][19])
965-                                                                                    else (0 + (if ((size(input) > 20))
966-                                                                                        then (input[20] * weights[3][20])
967-                                                                                        else (0 + (if ((size(input) > 21))
968-                                                                                            then (input[21] * weights[3][21])
969-                                                                                            else (0 + (if ((size(input) > 22))
970-                                                                                                then (input[22] * weights[3][22])
971-                                                                                                else (0 + (if ((size(input) > 23))
972-                                                                                                    then (input[23] * weights[3][23])
973-                                                                                                    else (0 + (if ((size(input) > 24))
974-                                                                                                        then (input[24] * weights[3][24])
975-                                                                                                        else (0 + (if ((size(input) > 25))
976-                                                                                                            then (input[25] * weights[3][25])
977-                                                                                                            else (0 + (if ((size(input) > 26))
978-                                                                                                                then (input[26] * weights[3][26])
979-                                                                                                                else (0 + (if ((size(input) > 27))
980-                                                                                                                    then (input[27] * weights[3][27])
981-                                                                                                                    else (0 + (if ((size(input) > 28))
982-                                                                                                                        then (input[28] * weights[3][28])
983-                                                                                                                        else (0 + (if ((size(input) > 29))
984-                                                                                                                            then (input[29] * weights[3][29])
985-                                                                                                                            else (0 + (if ((size(input) > 30))
986-                                                                                                                                then (input[30] * weights[3][30])
987-                                                                                                                                else (0 + (if ((size(input) > 31))
988-                                                                                                                                    then (input[31] * weights[3][31])
989-                                                                                                                                    else (0 + (if ((size(input) > 32))
990-                                                                                                                                        then (input[32] * weights[3][32])
991-                                                                                                                                        else (0 + (if ((size(input) > 33))
992-                                                                                                                                            then (input[33] * weights[3][33])
993-                                                                                                                                            else (0 + (if ((size(input) > 34))
994-                                                                                                                                                then (input[34] * weights[3][34])
995-                                                                                                                                                else (0 + (if ((size(input) > 35))
996-                                                                                                                                                    then (input[35] * weights[3][35])
997-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[3])
998-    let weighted_sum5 = (((if ((size(input) > 0))
999-        then (input[0] * weights[4][0])
1000-        else (0 + (if ((size(input) > 1))
1001-            then (input[1] * weights[4][1])
1002-            else (0 + (if ((size(input) > 2))
1003-                then (input[2] * weights[4][2])
1004-                else (0 + (if ((size(input) > 3))
1005-                    then (input[3] * weights[4][3])
1006-                    else (0 + (if ((size(input) > 4))
1007-                        then (input[4] * weights[4][4])
1008-                        else (0 + (if ((size(input) > 5))
1009-                            then (input[5] * weights[4][5])
1010-                            else (0 + (if ((size(input) > 6))
1011-                                then (input[6] * weights[4][6])
1012-                                else (0 + (if ((size(input) > 7))
1013-                                    then (input[7] * weights[4][7])
1014-                                    else (0 + (if ((size(input) > 8))
1015-                                        then (input[8] * weights[4][8])
1016-                                        else (0 + (if ((size(input) > 9))
1017-                                            then (input[9] * weights[4][9])
1018-                                            else (0 + (if ((size(input) > 10))
1019-                                                then (input[10] * weights[4][10])
1020-                                                else (0 + (if ((size(input) > 11))
1021-                                                    then (input[11] * weights[4][11])
1022-                                                    else (0 + (if ((size(input) > 12))
1023-                                                        then (input[12] * weights[4][12])
1024-                                                        else (0 + (if ((size(input) > 13))
1025-                                                            then (input[13] * weights[4][13])
1026-                                                            else (0 + (if ((size(input) > 14))
1027-                                                                then (input[14] * weights[4][14])
1028-                                                                else (0 + (if ((size(input) > 15))
1029-                                                                    then (input[15] * weights[4][15])
1030-                                                                    else (0 + (if ((size(input) > 16))
1031-                                                                        then (input[16] * weights[4][16])
1032-                                                                        else (0 + (if ((size(input) > 17))
1033-                                                                            then (input[17] * weights[4][17])
1034-                                                                            else (0 + (if ((size(input) > 18))
1035-                                                                                then (input[18] * weights[4][18])
1036-                                                                                else (0 + (if ((size(input) > 19))
1037-                                                                                    then (input[19] * weights[4][19])
1038-                                                                                    else (0 + (if ((size(input) > 20))
1039-                                                                                        then (input[20] * weights[4][20])
1040-                                                                                        else (0 + (if ((size(input) > 21))
1041-                                                                                            then (input[21] * weights[4][21])
1042-                                                                                            else (0 + (if ((size(input) > 22))
1043-                                                                                                then (input[22] * weights[4][22])
1044-                                                                                                else (0 + (if ((size(input) > 23))
1045-                                                                                                    then (input[23] * weights[4][23])
1046-                                                                                                    else (0 + (if ((size(input) > 24))
1047-                                                                                                        then (input[24] * weights[4][24])
1048-                                                                                                        else (0 + (if ((size(input) > 25))
1049-                                                                                                            then (input[25] * weights[4][25])
1050-                                                                                                            else (0 + (if ((size(input) > 26))
1051-                                                                                                                then (input[26] * weights[4][26])
1052-                                                                                                                else (0 + (if ((size(input) > 27))
1053-                                                                                                                    then (input[27] * weights[4][27])
1054-                                                                                                                    else (0 + (if ((size(input) > 28))
1055-                                                                                                                        then (input[28] * weights[4][28])
1056-                                                                                                                        else (0 + (if ((size(input) > 29))
1057-                                                                                                                            then (input[29] * weights[4][29])
1058-                                                                                                                            else (0 + (if ((size(input) > 30))
1059-                                                                                                                                then (input[30] * weights[4][30])
1060-                                                                                                                                else (0 + (if ((size(input) > 31))
1061-                                                                                                                                    then (input[31] * weights[4][31])
1062-                                                                                                                                    else (0 + (if ((size(input) > 32))
1063-                                                                                                                                        then (input[32] * weights[4][32])
1064-                                                                                                                                        else (0 + (if ((size(input) > 33))
1065-                                                                                                                                            then (input[33] * weights[4][33])
1066-                                                                                                                                            else (0 + (if ((size(input) > 34))
1067-                                                                                                                                                then (input[34] * weights[4][34])
1068-                                                                                                                                                else (0 + (if ((size(input) > 35))
1069-                                                                                                                                                    then (input[35] * weights[4][35])
1070-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[4])
1071-    let weighted_sum6 = (((if ((size(input) > 0))
1072-        then (input[0] * weights[5][0])
1073-        else (0 + (if ((size(input) > 1))
1074-            then (input[1] * weights[5][1])
1075-            else (0 + (if ((size(input) > 2))
1076-                then (input[2] * weights[5][2])
1077-                else (0 + (if ((size(input) > 3))
1078-                    then (input[3] * weights[5][3])
1079-                    else (0 + (if ((size(input) > 4))
1080-                        then (input[4] * weights[5][4])
1081-                        else (0 + (if ((size(input) > 5))
1082-                            then (input[5] * weights[5][5])
1083-                            else (0 + (if ((size(input) > 6))
1084-                                then (input[6] * weights[5][6])
1085-                                else (0 + (if ((size(input) > 7))
1086-                                    then (input[7] * weights[5][7])
1087-                                    else (0 + (if ((size(input) > 8))
1088-                                        then (input[8] * weights[5][8])
1089-                                        else (0 + (if ((size(input) > 9))
1090-                                            then (input[9] * weights[5][9])
1091-                                            else (0 + (if ((size(input) > 10))
1092-                                                then (input[10] * weights[5][10])
1093-                                                else (0 + (if ((size(input) > 11))
1094-                                                    then (input[11] * weights[5][11])
1095-                                                    else (0 + (if ((size(input) > 12))
1096-                                                        then (input[12] * weights[5][12])
1097-                                                        else (0 + (if ((size(input) > 13))
1098-                                                            then (input[13] * weights[5][13])
1099-                                                            else (0 + (if ((size(input) > 14))
1100-                                                                then (input[14] * weights[5][14])
1101-                                                                else (0 + (if ((size(input) > 15))
1102-                                                                    then (input[15] * weights[5][15])
1103-                                                                    else (0 + (if ((size(input) > 16))
1104-                                                                        then (input[16] * weights[5][16])
1105-                                                                        else (0 + (if ((size(input) > 17))
1106-                                                                            then (input[17] * weights[5][17])
1107-                                                                            else (0 + (if ((size(input) > 18))
1108-                                                                                then (input[18] * weights[5][18])
1109-                                                                                else (0 + (if ((size(input) > 19))
1110-                                                                                    then (input[19] * weights[5][19])
1111-                                                                                    else (0 + (if ((size(input) > 20))
1112-                                                                                        then (input[20] * weights[5][20])
1113-                                                                                        else (0 + (if ((size(input) > 21))
1114-                                                                                            then (input[21] * weights[5][21])
1115-                                                                                            else (0 + (if ((size(input) > 22))
1116-                                                                                                then (input[22] * weights[5][22])
1117-                                                                                                else (0 + (if ((size(input) > 23))
1118-                                                                                                    then (input[23] * weights[5][23])
1119-                                                                                                    else (0 + (if ((size(input) > 24))
1120-                                                                                                        then (input[24] * weights[5][24])
1121-                                                                                                        else (0 + (if ((size(input) > 25))
1122-                                                                                                            then (input[25] * weights[5][25])
1123-                                                                                                            else (0 + (if ((size(input) > 26))
1124-                                                                                                                then (input[26] * weights[5][26])
1125-                                                                                                                else (0 + (if ((size(input) > 27))
1126-                                                                                                                    then (input[27] * weights[5][27])
1127-                                                                                                                    else (0 + (if ((size(input) > 28))
1128-                                                                                                                        then (input[28] * weights[5][28])
1129-                                                                                                                        else (0 + (if ((size(input) > 29))
1130-                                                                                                                            then (input[29] * weights[5][29])
1131-                                                                                                                            else (0 + (if ((size(input) > 30))
1132-                                                                                                                                then (input[30] * weights[5][30])
1133-                                                                                                                                else (0 + (if ((size(input) > 31))
1134-                                                                                                                                    then (input[31] * weights[5][31])
1135-                                                                                                                                    else (0 + (if ((size(input) > 32))
1136-                                                                                                                                        then (input[32] * weights[5][32])
1137-                                                                                                                                        else (0 + (if ((size(input) > 33))
1138-                                                                                                                                            then (input[33] * weights[5][33])
1139-                                                                                                                                            else (0 + (if ((size(input) > 34))
1140-                                                                                                                                                then (input[34] * weights[5][34])
1141-                                                                                                                                                else (0 + (if ((size(input) > 35))
1142-                                                                                                                                                    then (input[35] * weights[5][35])
1143-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[5])
1144-    let weighted_sum7 = (((if ((size(input) > 0))
1145-        then (input[0] * weights[6][0])
1146-        else (0 + (if ((size(input) > 1))
1147-            then (input[1] * weights[6][1])
1148-            else (0 + (if ((size(input) > 2))
1149-                then (input[2] * weights[6][2])
1150-                else (0 + (if ((size(input) > 3))
1151-                    then (input[3] * weights[6][3])
1152-                    else (0 + (if ((size(input) > 4))
1153-                        then (input[4] * weights[6][4])
1154-                        else (0 + (if ((size(input) > 5))
1155-                            then (input[5] * weights[6][5])
1156-                            else (0 + (if ((size(input) > 6))
1157-                                then (input[6] * weights[6][6])
1158-                                else (0 + (if ((size(input) > 7))
1159-                                    then (input[7] * weights[6][7])
1160-                                    else (0 + (if ((size(input) > 8))
1161-                                        then (input[8] * weights[6][8])
1162-                                        else (0 + (if ((size(input) > 9))
1163-                                            then (input[9] * weights[6][9])
1164-                                            else (0 + (if ((size(input) > 10))
1165-                                                then (input[10] * weights[6][10])
1166-                                                else (0 + (if ((size(input) > 11))
1167-                                                    then (input[11] * weights[6][11])
1168-                                                    else (0 + (if ((size(input) > 12))
1169-                                                        then (input[12] * weights[6][12])
1170-                                                        else (0 + (if ((size(input) > 13))
1171-                                                            then (input[13] * weights[6][13])
1172-                                                            else (0 + (if ((size(input) > 14))
1173-                                                                then (input[14] * weights[6][14])
1174-                                                                else (0 + (if ((size(input) > 15))
1175-                                                                    then (input[15] * weights[6][15])
1176-                                                                    else (0 + (if ((size(input) > 16))
1177-                                                                        then (input[16] * weights[6][16])
1178-                                                                        else (0 + (if ((size(input) > 17))
1179-                                                                            then (input[17] * weights[6][17])
1180-                                                                            else (0 + (if ((size(input) > 18))
1181-                                                                                then (input[18] * weights[6][18])
1182-                                                                                else (0 + (if ((size(input) > 19))
1183-                                                                                    then (input[19] * weights[6][19])
1184-                                                                                    else (0 + (if ((size(input) > 20))
1185-                                                                                        then (input[20] * weights[6][20])
1186-                                                                                        else (0 + (if ((size(input) > 21))
1187-                                                                                            then (input[21] * weights[6][21])
1188-                                                                                            else (0 + (if ((size(input) > 22))
1189-                                                                                                then (input[22] * weights[6][22])
1190-                                                                                                else (0 + (if ((size(input) > 23))
1191-                                                                                                    then (input[23] * weights[6][23])
1192-                                                                                                    else (0 + (if ((size(input) > 24))
1193-                                                                                                        then (input[24] * weights[6][24])
1194-                                                                                                        else (0 + (if ((size(input) > 25))
1195-                                                                                                            then (input[25] * weights[6][25])
1196-                                                                                                            else (0 + (if ((size(input) > 26))
1197-                                                                                                                then (input[26] * weights[6][26])
1198-                                                                                                                else (0 + (if ((size(input) > 27))
1199-                                                                                                                    then (input[27] * weights[6][27])
1200-                                                                                                                    else (0 + (if ((size(input) > 28))
1201-                                                                                                                        then (input[28] * weights[6][28])
1202-                                                                                                                        else (0 + (if ((size(input) > 29))
1203-                                                                                                                            then (input[29] * weights[6][29])
1204-                                                                                                                            else (0 + (if ((size(input) > 30))
1205-                                                                                                                                then (input[30] * weights[6][30])
1206-                                                                                                                                else (0 + (if ((size(input) > 31))
1207-                                                                                                                                    then (input[31] * weights[6][31])
1208-                                                                                                                                    else (0 + (if ((size(input) > 32))
1209-                                                                                                                                        then (input[32] * weights[6][32])
1210-                                                                                                                                        else (0 + (if ((size(input) > 33))
1211-                                                                                                                                            then (input[33] * weights[6][33])
1212-                                                                                                                                            else (0 + (if ((size(input) > 34))
1213-                                                                                                                                                then (input[34] * weights[6][34])
1214-                                                                                                                                                else (0 + (if ((size(input) > 35))
1215-                                                                                                                                                    then (input[35] * weights[6][35])
1216-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[6])
1217-    let weighted_sum8 = (((if ((size(input) > 0))
1218-        then (input[0] * weights[7][0])
1219-        else (0 + (if ((size(input) > 1))
1220-            then (input[1] * weights[7][1])
1221-            else (0 + (if ((size(input) > 2))
1222-                then (input[2] * weights[7][2])
1223-                else (0 + (if ((size(input) > 3))
1224-                    then (input[3] * weights[7][3])
1225-                    else (0 + (if ((size(input) > 4))
1226-                        then (input[4] * weights[7][4])
1227-                        else (0 + (if ((size(input) > 5))
1228-                            then (input[5] * weights[7][5])
1229-                            else (0 + (if ((size(input) > 6))
1230-                                then (input[6] * weights[7][6])
1231-                                else (0 + (if ((size(input) > 7))
1232-                                    then (input[7] * weights[7][7])
1233-                                    else (0 + (if ((size(input) > 8))
1234-                                        then (input[8] * weights[7][8])
1235-                                        else (0 + (if ((size(input) > 9))
1236-                                            then (input[9] * weights[7][9])
1237-                                            else (0 + (if ((size(input) > 10))
1238-                                                then (input[10] * weights[7][10])
1239-                                                else (0 + (if ((size(input) > 11))
1240-                                                    then (input[11] * weights[7][11])
1241-                                                    else (0 + (if ((size(input) > 12))
1242-                                                        then (input[12] * weights[7][12])
1243-                                                        else (0 + (if ((size(input) > 13))
1244-                                                            then (input[13] * weights[7][13])
1245-                                                            else (0 + (if ((size(input) > 14))
1246-                                                                then (input[14] * weights[7][14])
1247-                                                                else (0 + (if ((size(input) > 15))
1248-                                                                    then (input[15] * weights[7][15])
1249-                                                                    else (0 + (if ((size(input) > 16))
1250-                                                                        then (input[16] * weights[7][16])
1251-                                                                        else (0 + (if ((size(input) > 17))
1252-                                                                            then (input[17] * weights[7][17])
1253-                                                                            else (0 + (if ((size(input) > 18))
1254-                                                                                then (input[18] * weights[7][18])
1255-                                                                                else (0 + (if ((size(input) > 19))
1256-                                                                                    then (input[19] * weights[7][19])
1257-                                                                                    else (0 + (if ((size(input) > 20))
1258-                                                                                        then (input[20] * weights[7][20])
1259-                                                                                        else (0 + (if ((size(input) > 21))
1260-                                                                                            then (input[21] * weights[7][21])
1261-                                                                                            else (0 + (if ((size(input) > 22))
1262-                                                                                                then (input[22] * weights[7][22])
1263-                                                                                                else (0 + (if ((size(input) > 23))
1264-                                                                                                    then (input[23] * weights[7][23])
1265-                                                                                                    else (0 + (if ((size(input) > 24))
1266-                                                                                                        then (input[24] * weights[7][24])
1267-                                                                                                        else (0 + (if ((size(input) > 25))
1268-                                                                                                            then (input[25] * weights[7][25])
1269-                                                                                                            else (0 + (if ((size(input) > 26))
1270-                                                                                                                then (input[26] * weights[7][26])
1271-                                                                                                                else (0 + (if ((size(input) > 27))
1272-                                                                                                                    then (input[27] * weights[7][27])
1273-                                                                                                                    else (0 + (if ((size(input) > 28))
1274-                                                                                                                        then (input[28] * weights[7][28])
1275-                                                                                                                        else (0 + (if ((size(input) > 29))
1276-                                                                                                                            then (input[29] * weights[7][29])
1277-                                                                                                                            else (0 + (if ((size(input) > 30))
1278-                                                                                                                                then (input[30] * weights[7][30])
1279-                                                                                                                                else (0 + (if ((size(input) > 31))
1280-                                                                                                                                    then (input[31] * weights[7][31])
1281-                                                                                                                                    else (0 + (if ((size(input) > 32))
1282-                                                                                                                                        then (input[32] * weights[7][32])
1283-                                                                                                                                        else (0 + (if ((size(input) > 33))
1284-                                                                                                                                            then (input[33] * weights[7][33])
1285-                                                                                                                                            else (0 + (if ((size(input) > 34))
1286-                                                                                                                                                then (input[34] * weights[7][34])
1287-                                                                                                                                                else (0 + (if ((size(input) > 35))
1288-                                                                                                                                                    then (input[35] * weights[7][35])
1289-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[7])
1290-    let weighted_sum9 = (((if ((size(input) > 0))
1291-        then (input[0] * weights[8][0])
1292-        else (0 + (if ((size(input) > 1))
1293-            then (input[1] * weights[8][1])
1294-            else (0 + (if ((size(input) > 2))
1295-                then (input[2] * weights[8][2])
1296-                else (0 + (if ((size(input) > 3))
1297-                    then (input[3] * weights[8][3])
1298-                    else (0 + (if ((size(input) > 4))
1299-                        then (input[4] * weights[8][4])
1300-                        else (0 + (if ((size(input) > 5))
1301-                            then (input[5] * weights[8][5])
1302-                            else (0 + (if ((size(input) > 6))
1303-                                then (input[6] * weights[8][6])
1304-                                else (0 + (if ((size(input) > 7))
1305-                                    then (input[7] * weights[8][7])
1306-                                    else (0 + (if ((size(input) > 8))
1307-                                        then (input[8] * weights[8][8])
1308-                                        else (0 + (if ((size(input) > 9))
1309-                                            then (input[9] * weights[8][9])
1310-                                            else (0 + (if ((size(input) > 10))
1311-                                                then (input[10] * weights[8][10])
1312-                                                else (0 + (if ((size(input) > 11))
1313-                                                    then (input[11] * weights[8][11])
1314-                                                    else (0 + (if ((size(input) > 12))
1315-                                                        then (input[12] * weights[8][12])
1316-                                                        else (0 + (if ((size(input) > 13))
1317-                                                            then (input[13] * weights[8][13])
1318-                                                            else (0 + (if ((size(input) > 14))
1319-                                                                then (input[14] * weights[8][14])
1320-                                                                else (0 + (if ((size(input) > 15))
1321-                                                                    then (input[15] * weights[8][15])
1322-                                                                    else (0 + (if ((size(input) > 16))
1323-                                                                        then (input[16] * weights[8][16])
1324-                                                                        else (0 + (if ((size(input) > 17))
1325-                                                                            then (input[17] * weights[8][17])
1326-                                                                            else (0 + (if ((size(input) > 18))
1327-                                                                                then (input[18] * weights[8][18])
1328-                                                                                else (0 + (if ((size(input) > 19))
1329-                                                                                    then (input[19] * weights[8][19])
1330-                                                                                    else (0 + (if ((size(input) > 20))
1331-                                                                                        then (input[20] * weights[8][20])
1332-                                                                                        else (0 + (if ((size(input) > 21))
1333-                                                                                            then (input[21] * weights[8][21])
1334-                                                                                            else (0 + (if ((size(input) > 22))
1335-                                                                                                then (input[22] * weights[8][22])
1336-                                                                                                else (0 + (if ((size(input) > 23))
1337-                                                                                                    then (input[23] * weights[8][23])
1338-                                                                                                    else (0 + (if ((size(input) > 24))
1339-                                                                                                        then (input[24] * weights[8][24])
1340-                                                                                                        else (0 + (if ((size(input) > 25))
1341-                                                                                                            then (input[25] * weights[8][25])
1342-                                                                                                            else (0 + (if ((size(input) > 26))
1343-                                                                                                                then (input[26] * weights[8][26])
1344-                                                                                                                else (0 + (if ((size(input) > 27))
1345-                                                                                                                    then (input[27] * weights[8][27])
1346-                                                                                                                    else (0 + (if ((size(input) > 28))
1347-                                                                                                                        then (input[28] * weights[8][28])
1348-                                                                                                                        else (0 + (if ((size(input) > 29))
1349-                                                                                                                            then (input[29] * weights[8][29])
1350-                                                                                                                            else (0 + (if ((size(input) > 30))
1351-                                                                                                                                then (input[30] * weights[8][30])
1352-                                                                                                                                else (0 + (if ((size(input) > 31))
1353-                                                                                                                                    then (input[31] * weights[8][31])
1354-                                                                                                                                    else (0 + (if ((size(input) > 32))
1355-                                                                                                                                        then (input[32] * weights[8][32])
1356-                                                                                                                                        else (0 + (if ((size(input) > 33))
1357-                                                                                                                                            then (input[33] * weights[8][33])
1358-                                                                                                                                            else (0 + (if ((size(input) > 34))
1359-                                                                                                                                                then (input[34] * weights[8][34])
1360-                                                                                                                                                else (0 + (if ((size(input) > 35))
1361-                                                                                                                                                    then (input[35] * weights[8][35])
1362-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[8])
1363-    let weighted_sum10 = (((if ((size(input) > 0))
1364-        then (input[0] * weights[9][0])
1365-        else (0 + (if ((size(input) > 1))
1366-            then (input[1] * weights[9][1])
1367-            else (0 + (if ((size(input) > 2))
1368-                then (input[2] * weights[9][2])
1369-                else (0 + (if ((size(input) > 3))
1370-                    then (input[3] * weights[9][3])
1371-                    else (0 + (if ((size(input) > 4))
1372-                        then (input[4] * weights[9][4])
1373-                        else (0 + (if ((size(input) > 5))
1374-                            then (input[5] * weights[9][5])
1375-                            else (0 + (if ((size(input) > 6))
1376-                                then (input[6] * weights[9][6])
1377-                                else (0 + (if ((size(input) > 7))
1378-                                    then (input[7] * weights[9][7])
1379-                                    else (0 + (if ((size(input) > 8))
1380-                                        then (input[8] * weights[9][8])
1381-                                        else (0 + (if ((size(input) > 9))
1382-                                            then (input[9] * weights[9][9])
1383-                                            else (0 + (if ((size(input) > 10))
1384-                                                then (input[10] * weights[9][10])
1385-                                                else (0 + (if ((size(input) > 11))
1386-                                                    then (input[11] * weights[9][11])
1387-                                                    else (0 + (if ((size(input) > 12))
1388-                                                        then (input[12] * weights[9][12])
1389-                                                        else (0 + (if ((size(input) > 13))
1390-                                                            then (input[13] * weights[9][13])
1391-                                                            else (0 + (if ((size(input) > 14))
1392-                                                                then (input[14] * weights[9][14])
1393-                                                                else (0 + (if ((size(input) > 15))
1394-                                                                    then (input[15] * weights[9][15])
1395-                                                                    else (0 + (if ((size(input) > 16))
1396-                                                                        then (input[16] * weights[9][16])
1397-                                                                        else (0 + (if ((size(input) > 17))
1398-                                                                            then (input[17] * weights[9][17])
1399-                                                                            else (0 + (if ((size(input) > 18))
1400-                                                                                then (input[18] * weights[9][18])
1401-                                                                                else (0 + (if ((size(input) > 19))
1402-                                                                                    then (input[19] * weights[9][19])
1403-                                                                                    else (0 + (if ((size(input) > 20))
1404-                                                                                        then (input[20] * weights[9][20])
1405-                                                                                        else (0 + (if ((size(input) > 21))
1406-                                                                                            then (input[21] * weights[9][21])
1407-                                                                                            else (0 + (if ((size(input) > 22))
1408-                                                                                                then (input[22] * weights[9][22])
1409-                                                                                                else (0 + (if ((size(input) > 23))
1410-                                                                                                    then (input[23] * weights[9][23])
1411-                                                                                                    else (0 + (if ((size(input) > 24))
1412-                                                                                                        then (input[24] * weights[9][24])
1413-                                                                                                        else (0 + (if ((size(input) > 25))
1414-                                                                                                            then (input[25] * weights[9][25])
1415-                                                                                                            else (0 + (if ((size(input) > 26))
1416-                                                                                                                then (input[26] * weights[9][26])
1417-                                                                                                                else (0 + (if ((size(input) > 27))
1418-                                                                                                                    then (input[27] * weights[9][27])
1419-                                                                                                                    else (0 + (if ((size(input) > 28))
1420-                                                                                                                        then (input[28] * weights[9][28])
1421-                                                                                                                        else (0 + (if ((size(input) > 29))
1422-                                                                                                                            then (input[29] * weights[9][29])
1423-                                                                                                                            else (0 + (if ((size(input) > 30))
1424-                                                                                                                                then (input[30] * weights[9][30])
1425-                                                                                                                                else (0 + (if ((size(input) > 31))
1426-                                                                                                                                    then (input[31] * weights[9][31])
1427-                                                                                                                                    else (0 + (if ((size(input) > 32))
1428-                                                                                                                                        then (input[32] * weights[9][32])
1429-                                                                                                                                        else (0 + (if ((size(input) > 33))
1430-                                                                                                                                            then (input[33] * weights[9][33])
1431-                                                                                                                                            else (0 + (if ((size(input) > 34))
1432-                                                                                                                                                then (input[34] * weights[9][34])
1433-                                                                                                                                                else (0 + (if ((size(input) > 35))
1434-                                                                                                                                                    then (input[35] * weights[9][35])
1435-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[9])
1436-    let weighted_sum11 = (((if ((size(input) > 0))
1437-        then (input[0] * weights[10][0])
1438-        else (0 + (if ((size(input) > 1))
1439-            then (input[1] * weights[10][1])
1440-            else (0 + (if ((size(input) > 2))
1441-                then (input[2] * weights[10][2])
1442-                else (0 + (if ((size(input) > 3))
1443-                    then (input[3] * weights[10][3])
1444-                    else (0 + (if ((size(input) > 4))
1445-                        then (input[4] * weights[10][4])
1446-                        else (0 + (if ((size(input) > 5))
1447-                            then (input[5] * weights[10][5])
1448-                            else (0 + (if ((size(input) > 6))
1449-                                then (input[6] * weights[10][6])
1450-                                else (0 + (if ((size(input) > 7))
1451-                                    then (input[7] * weights[10][7])
1452-                                    else (0 + (if ((size(input) > 8))
1453-                                        then (input[8] * weights[10][8])
1454-                                        else (0 + (if ((size(input) > 9))
1455-                                            then (input[9] * weights[10][9])
1456-                                            else (0 + (if ((size(input) > 10))
1457-                                                then (input[10] * weights[10][10])
1458-                                                else (0 + (if ((size(input) > 11))
1459-                                                    then (input[11] * weights[10][11])
1460-                                                    else (0 + (if ((size(input) > 12))
1461-                                                        then (input[12] * weights[10][12])
1462-                                                        else (0 + (if ((size(input) > 13))
1463-                                                            then (input[13] * weights[10][13])
1464-                                                            else (0 + (if ((size(input) > 14))
1465-                                                                then (input[14] * weights[10][14])
1466-                                                                else (0 + (if ((size(input) > 15))
1467-                                                                    then (input[15] * weights[10][15])
1468-                                                                    else (0 + (if ((size(input) > 16))
1469-                                                                        then (input[16] * weights[10][16])
1470-                                                                        else (0 + (if ((size(input) > 17))
1471-                                                                            then (input[17] * weights[10][17])
1472-                                                                            else (0 + (if ((size(input) > 18))
1473-                                                                                then (input[18] * weights[10][18])
1474-                                                                                else (0 + (if ((size(input) > 19))
1475-                                                                                    then (input[19] * weights[10][19])
1476-                                                                                    else (0 + (if ((size(input) > 20))
1477-                                                                                        then (input[20] * weights[10][20])
1478-                                                                                        else (0 + (if ((size(input) > 21))
1479-                                                                                            then (input[21] * weights[10][21])
1480-                                                                                            else (0 + (if ((size(input) > 22))
1481-                                                                                                then (input[22] * weights[10][22])
1482-                                                                                                else (0 + (if ((size(input) > 23))
1483-                                                                                                    then (input[23] * weights[10][23])
1484-                                                                                                    else (0 + (if ((size(input) > 24))
1485-                                                                                                        then (input[24] * weights[10][24])
1486-                                                                                                        else (0 + (if ((size(input) > 25))
1487-                                                                                                            then (input[25] * weights[10][25])
1488-                                                                                                            else (0 + (if ((size(input) > 26))
1489-                                                                                                                then (input[26] * weights[10][26])
1490-                                                                                                                else (0 + (if ((size(input) > 27))
1491-                                                                                                                    then (input[27] * weights[10][27])
1492-                                                                                                                    else (0 + (if ((size(input) > 28))
1493-                                                                                                                        then (input[28] * weights[10][28])
1494-                                                                                                                        else (0 + (if ((size(input) > 29))
1495-                                                                                                                            then (input[29] * weights[10][29])
1496-                                                                                                                            else (0 + (if ((size(input) > 30))
1497-                                                                                                                                then (input[30] * weights[10][30])
1498-                                                                                                                                else (0 + (if ((size(input) > 31))
1499-                                                                                                                                    then (input[31] * weights[10][31])
1500-                                                                                                                                    else (0 + (if ((size(input) > 32))
1501-                                                                                                                                        then (input[32] * weights[10][32])
1502-                                                                                                                                        else (0 + (if ((size(input) > 33))
1503-                                                                                                                                            then (input[33] * weights[10][33])
1504-                                                                                                                                            else (0 + (if ((size(input) > 34))
1505-                                                                                                                                                then (input[34] * weights[10][34])
1506-                                                                                                                                                else (0 + (if ((size(input) > 35))
1507-                                                                                                                                                    then (input[35] * weights[10][35])
1508-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[10])
1509-    let weighted_sum12 = (((if ((size(input) > 0))
1510-        then (input[0] * weights[11][0])
1511-        else (0 + (if ((size(input) > 1))
1512-            then (input[1] * weights[11][1])
1513-            else (0 + (if ((size(input) > 2))
1514-                then (input[2] * weights[11][2])
1515-                else (0 + (if ((size(input) > 3))
1516-                    then (input[3] * weights[11][3])
1517-                    else (0 + (if ((size(input) > 4))
1518-                        then (input[4] * weights[11][4])
1519-                        else (0 + (if ((size(input) > 5))
1520-                            then (input[5] * weights[11][5])
1521-                            else (0 + (if ((size(input) > 6))
1522-                                then (input[6] * weights[11][6])
1523-                                else (0 + (if ((size(input) > 7))
1524-                                    then (input[7] * weights[11][7])
1525-                                    else (0 + (if ((size(input) > 8))
1526-                                        then (input[8] * weights[11][8])
1527-                                        else (0 + (if ((size(input) > 9))
1528-                                            then (input[9] * weights[11][9])
1529-                                            else (0 + (if ((size(input) > 10))
1530-                                                then (input[10] * weights[11][10])
1531-                                                else (0 + (if ((size(input) > 11))
1532-                                                    then (input[11] * weights[11][11])
1533-                                                    else (0 + (if ((size(input) > 12))
1534-                                                        then (input[12] * weights[11][12])
1535-                                                        else (0 + (if ((size(input) > 13))
1536-                                                            then (input[13] * weights[11][13])
1537-                                                            else (0 + (if ((size(input) > 14))
1538-                                                                then (input[14] * weights[11][14])
1539-                                                                else (0 + (if ((size(input) > 15))
1540-                                                                    then (input[15] * weights[11][15])
1541-                                                                    else (0 + (if ((size(input) > 16))
1542-                                                                        then (input[16] * weights[11][16])
1543-                                                                        else (0 + (if ((size(input) > 17))
1544-                                                                            then (input[17] * weights[11][17])
1545-                                                                            else (0 + (if ((size(input) > 18))
1546-                                                                                then (input[18] * weights[11][18])
1547-                                                                                else (0 + (if ((size(input) > 19))
1548-                                                                                    then (input[19] * weights[11][19])
1549-                                                                                    else (0 + (if ((size(input) > 20))
1550-                                                                                        then (input[20] * weights[11][20])
1551-                                                                                        else (0 + (if ((size(input) > 21))
1552-                                                                                            then (input[21] * weights[11][21])
1553-                                                                                            else (0 + (if ((size(input) > 22))
1554-                                                                                                then (input[22] * weights[11][22])
1555-                                                                                                else (0 + (if ((size(input) > 23))
1556-                                                                                                    then (input[23] * weights[11][23])
1557-                                                                                                    else (0 + (if ((size(input) > 24))
1558-                                                                                                        then (input[24] * weights[11][24])
1559-                                                                                                        else (0 + (if ((size(input) > 25))
1560-                                                                                                            then (input[25] * weights[11][25])
1561-                                                                                                            else (0 + (if ((size(input) > 26))
1562-                                                                                                                then (input[26] * weights[11][26])
1563-                                                                                                                else (0 + (if ((size(input) > 27))
1564-                                                                                                                    then (input[27] * weights[11][27])
1565-                                                                                                                    else (0 + (if ((size(input) > 28))
1566-                                                                                                                        then (input[28] * weights[11][28])
1567-                                                                                                                        else (0 + (if ((size(input) > 29))
1568-                                                                                                                            then (input[29] * weights[11][29])
1569-                                                                                                                            else (0 + (if ((size(input) > 30))
1570-                                                                                                                                then (input[30] * weights[11][30])
1571-                                                                                                                                else (0 + (if ((size(input) > 31))
1572-                                                                                                                                    then (input[31] * weights[11][31])
1573-                                                                                                                                    else (0 + (if ((size(input) > 32))
1574-                                                                                                                                        then (input[32] * weights[11][32])
1575-                                                                                                                                        else (0 + (if ((size(input) > 33))
1576-                                                                                                                                            then (input[33] * weights[11][33])
1577-                                                                                                                                            else (0 + (if ((size(input) > 34))
1578-                                                                                                                                                then (input[34] * weights[11][34])
1579-                                                                                                                                                else (0 + (if ((size(input) > 35))
1580-                                                                                                                                                    then (input[35] * weights[11][35])
1581-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[11])
1582-    let weighted_sum13 = (((if ((size(input) > 0))
1583-        then (input[0] * weights[12][0])
1584-        else (0 + (if ((size(input) > 1))
1585-            then (input[1] * weights[12][1])
1586-            else (0 + (if ((size(input) > 2))
1587-                then (input[2] * weights[12][2])
1588-                else (0 + (if ((size(input) > 3))
1589-                    then (input[3] * weights[12][3])
1590-                    else (0 + (if ((size(input) > 4))
1591-                        then (input[4] * weights[12][4])
1592-                        else (0 + (if ((size(input) > 5))
1593-                            then (input[5] * weights[12][5])
1594-                            else (0 + (if ((size(input) > 6))
1595-                                then (input[6] * weights[12][6])
1596-                                else (0 + (if ((size(input) > 7))
1597-                                    then (input[7] * weights[12][7])
1598-                                    else (0 + (if ((size(input) > 8))
1599-                                        then (input[8] * weights[12][8])
1600-                                        else (0 + (if ((size(input) > 9))
1601-                                            then (input[9] * weights[12][9])
1602-                                            else (0 + (if ((size(input) > 10))
1603-                                                then (input[10] * weights[12][10])
1604-                                                else (0 + (if ((size(input) > 11))
1605-                                                    then (input[11] * weights[12][11])
1606-                                                    else (0 + (if ((size(input) > 12))
1607-                                                        then (input[12] * weights[12][12])
1608-                                                        else (0 + (if ((size(input) > 13))
1609-                                                            then (input[13] * weights[12][13])
1610-                                                            else (0 + (if ((size(input) > 14))
1611-                                                                then (input[14] * weights[12][14])
1612-                                                                else (0 + (if ((size(input) > 15))
1613-                                                                    then (input[15] * weights[12][15])
1614-                                                                    else (0 + (if ((size(input) > 16))
1615-                                                                        then (input[16] * weights[12][16])
1616-                                                                        else (0 + (if ((size(input) > 17))
1617-                                                                            then (input[17] * weights[12][17])
1618-                                                                            else (0 + (if ((size(input) > 18))
1619-                                                                                then (input[18] * weights[12][18])
1620-                                                                                else (0 + (if ((size(input) > 19))
1621-                                                                                    then (input[19] * weights[12][19])
1622-                                                                                    else (0 + (if ((size(input) > 20))
1623-                                                                                        then (input[20] * weights[12][20])
1624-                                                                                        else (0 + (if ((size(input) > 21))
1625-                                                                                            then (input[21] * weights[12][21])
1626-                                                                                            else (0 + (if ((size(input) > 22))
1627-                                                                                                then (input[22] * weights[12][22])
1628-                                                                                                else (0 + (if ((size(input) > 23))
1629-                                                                                                    then (input[23] * weights[12][23])
1630-                                                                                                    else (0 + (if ((size(input) > 24))
1631-                                                                                                        then (input[24] * weights[12][24])
1632-                                                                                                        else (0 + (if ((size(input) > 25))
1633-                                                                                                            then (input[25] * weights[12][25])
1634-                                                                                                            else (0 + (if ((size(input) > 26))
1635-                                                                                                                then (input[26] * weights[12][26])
1636-                                                                                                                else (0 + (if ((size(input) > 27))
1637-                                                                                                                    then (input[27] * weights[12][27])
1638-                                                                                                                    else (0 + (if ((size(input) > 28))
1639-                                                                                                                        then (input[28] * weights[12][28])
1640-                                                                                                                        else (0 + (if ((size(input) > 29))
1641-                                                                                                                            then (input[29] * weights[12][29])
1642-                                                                                                                            else (0 + (if ((size(input) > 30))
1643-                                                                                                                                then (input[30] * weights[12][30])
1644-                                                                                                                                else (0 + (if ((size(input) > 31))
1645-                                                                                                                                    then (input[31] * weights[12][31])
1646-                                                                                                                                    else (0 + (if ((size(input) > 32))
1647-                                                                                                                                        then (input[32] * weights[12][32])
1648-                                                                                                                                        else (0 + (if ((size(input) > 33))
1649-                                                                                                                                            then (input[33] * weights[12][33])
1650-                                                                                                                                            else (0 + (if ((size(input) > 34))
1651-                                                                                                                                                then (input[34] * weights[12][34])
1652-                                                                                                                                                else (0 + (if ((size(input) > 35))
1653-                                                                                                                                                    then (input[35] * weights[12][35])
1654-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[12])
1655-    let weighted_sum14 = (((if ((size(input) > 0))
1656-        then (input[0] * weights[13][0])
1657-        else (0 + (if ((size(input) > 1))
1658-            then (input[1] * weights[13][1])
1659-            else (0 + (if ((size(input) > 2))
1660-                then (input[2] * weights[13][2])
1661-                else (0 + (if ((size(input) > 3))
1662-                    then (input[3] * weights[13][3])
1663-                    else (0 + (if ((size(input) > 4))
1664-                        then (input[4] * weights[13][4])
1665-                        else (0 + (if ((size(input) > 5))
1666-                            then (input[5] * weights[13][5])
1667-                            else (0 + (if ((size(input) > 6))
1668-                                then (input[6] * weights[13][6])
1669-                                else (0 + (if ((size(input) > 7))
1670-                                    then (input[7] * weights[13][7])
1671-                                    else (0 + (if ((size(input) > 8))
1672-                                        then (input[8] * weights[13][8])
1673-                                        else (0 + (if ((size(input) > 9))
1674-                                            then (input[9] * weights[13][9])
1675-                                            else (0 + (if ((size(input) > 10))
1676-                                                then (input[10] * weights[13][10])
1677-                                                else (0 + (if ((size(input) > 11))
1678-                                                    then (input[11] * weights[13][11])
1679-                                                    else (0 + (if ((size(input) > 12))
1680-                                                        then (input[12] * weights[13][12])
1681-                                                        else (0 + (if ((size(input) > 13))
1682-                                                            then (input[13] * weights[13][13])
1683-                                                            else (0 + (if ((size(input) > 14))
1684-                                                                then (input[14] * weights[13][14])
1685-                                                                else (0 + (if ((size(input) > 15))
1686-                                                                    then (input[15] * weights[13][15])
1687-                                                                    else (0 + (if ((size(input) > 16))
1688-                                                                        then (input[16] * weights[13][16])
1689-                                                                        else (0 + (if ((size(input) > 17))
1690-                                                                            then (input[17] * weights[13][17])
1691-                                                                            else (0 + (if ((size(input) > 18))
1692-                                                                                then (input[18] * weights[13][18])
1693-                                                                                else (0 + (if ((size(input) > 19))
1694-                                                                                    then (input[19] * weights[13][19])
1695-                                                                                    else (0 + (if ((size(input) > 20))
1696-                                                                                        then (input[20] * weights[13][20])
1697-                                                                                        else (0 + (if ((size(input) > 21))
1698-                                                                                            then (input[21] * weights[13][21])
1699-                                                                                            else (0 + (if ((size(input) > 22))
1700-                                                                                                then (input[22] * weights[13][22])
1701-                                                                                                else (0 + (if ((size(input) > 23))
1702-                                                                                                    then (input[23] * weights[13][23])
1703-                                                                                                    else (0 + (if ((size(input) > 24))
1704-                                                                                                        then (input[24] * weights[13][24])
1705-                                                                                                        else (0 + (if ((size(input) > 25))
1706-                                                                                                            then (input[25] * weights[13][25])
1707-                                                                                                            else (0 + (if ((size(input) > 26))
1708-                                                                                                                then (input[26] * weights[13][26])
1709-                                                                                                                else (0 + (if ((size(input) > 27))
1710-                                                                                                                    then (input[27] * weights[13][27])
1711-                                                                                                                    else (0 + (if ((size(input) > 28))
1712-                                                                                                                        then (input[28] * weights[13][28])
1713-                                                                                                                        else (0 + (if ((size(input) > 29))
1714-                                                                                                                            then (input[29] * weights[13][29])
1715-                                                                                                                            else (0 + (if ((size(input) > 30))
1716-                                                                                                                                then (input[30] * weights[13][30])
1717-                                                                                                                                else (0 + (if ((size(input) > 31))
1718-                                                                                                                                    then (input[31] * weights[13][31])
1719-                                                                                                                                    else (0 + (if ((size(input) > 32))
1720-                                                                                                                                        then (input[32] * weights[13][32])
1721-                                                                                                                                        else (0 + (if ((size(input) > 33))
1722-                                                                                                                                            then (input[33] * weights[13][33])
1723-                                                                                                                                            else (0 + (if ((size(input) > 34))
1724-                                                                                                                                                then (input[34] * weights[13][34])
1725-                                                                                                                                                else (0 + (if ((size(input) > 35))
1726-                                                                                                                                                    then (input[35] * weights[13][35])
1727-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[13])
1728-    let weighted_sum15 = (((if ((size(input) > 0))
1729-        then (input[0] * weights[14][0])
1730-        else (0 + (if ((size(input) > 1))
1731-            then (input[1] * weights[14][1])
1732-            else (0 + (if ((size(input) > 2))
1733-                then (input[2] * weights[14][2])
1734-                else (0 + (if ((size(input) > 3))
1735-                    then (input[3] * weights[14][3])
1736-                    else (0 + (if ((size(input) > 4))
1737-                        then (input[4] * weights[14][4])
1738-                        else (0 + (if ((size(input) > 5))
1739-                            then (input[5] * weights[14][5])
1740-                            else (0 + (if ((size(input) > 6))
1741-                                then (input[6] * weights[14][6])
1742-                                else (0 + (if ((size(input) > 7))
1743-                                    then (input[7] * weights[14][7])
1744-                                    else (0 + (if ((size(input) > 8))
1745-                                        then (input[8] * weights[14][8])
1746-                                        else (0 + (if ((size(input) > 9))
1747-                                            then (input[9] * weights[14][9])
1748-                                            else (0 + (if ((size(input) > 10))
1749-                                                then (input[10] * weights[14][10])
1750-                                                else (0 + (if ((size(input) > 11))
1751-                                                    then (input[11] * weights[14][11])
1752-                                                    else (0 + (if ((size(input) > 12))
1753-                                                        then (input[12] * weights[14][12])
1754-                                                        else (0 + (if ((size(input) > 13))
1755-                                                            then (input[13] * weights[14][13])
1756-                                                            else (0 + (if ((size(input) > 14))
1757-                                                                then (input[14] * weights[14][14])
1758-                                                                else (0 + (if ((size(input) > 15))
1759-                                                                    then (input[15] * weights[14][15])
1760-                                                                    else (0 + (if ((size(input) > 16))
1761-                                                                        then (input[16] * weights[14][16])
1762-                                                                        else (0 + (if ((size(input) > 17))
1763-                                                                            then (input[17] * weights[14][17])
1764-                                                                            else (0 + (if ((size(input) > 18))
1765-                                                                                then (input[18] * weights[14][18])
1766-                                                                                else (0 + (if ((size(input) > 19))
1767-                                                                                    then (input[19] * weights[14][19])
1768-                                                                                    else (0 + (if ((size(input) > 20))
1769-                                                                                        then (input[20] * weights[14][20])
1770-                                                                                        else (0 + (if ((size(input) > 21))
1771-                                                                                            then (input[21] * weights[14][21])
1772-                                                                                            else (0 + (if ((size(input) > 22))
1773-                                                                                                then (input[22] * weights[14][22])
1774-                                                                                                else (0 + (if ((size(input) > 23))
1775-                                                                                                    then (input[23] * weights[14][23])
1776-                                                                                                    else (0 + (if ((size(input) > 24))
1777-                                                                                                        then (input[24] * weights[14][24])
1778-                                                                                                        else (0 + (if ((size(input) > 25))
1779-                                                                                                            then (input[25] * weights[14][25])
1780-                                                                                                            else (0 + (if ((size(input) > 26))
1781-                                                                                                                then (input[26] * weights[14][26])
1782-                                                                                                                else (0 + (if ((size(input) > 27))
1783-                                                                                                                    then (input[27] * weights[14][27])
1784-                                                                                                                    else (0 + (if ((size(input) > 28))
1785-                                                                                                                        then (input[28] * weights[14][28])
1786-                                                                                                                        else (0 + (if ((size(input) > 29))
1787-                                                                                                                            then (input[29] * weights[14][29])
1788-                                                                                                                            else (0 + (if ((size(input) > 30))
1789-                                                                                                                                then (input[30] * weights[14][30])
1790-                                                                                                                                else (0 + (if ((size(input) > 31))
1791-                                                                                                                                    then (input[31] * weights[14][31])
1792-                                                                                                                                    else (0 + (if ((size(input) > 32))
1793-                                                                                                                                        then (input[32] * weights[14][32])
1794-                                                                                                                                        else (0 + (if ((size(input) > 33))
1795-                                                                                                                                            then (input[33] * weights[14][33])
1796-                                                                                                                                            else (0 + (if ((size(input) > 34))
1797-                                                                                                                                                then (input[34] * weights[14][34])
1798-                                                                                                                                                else (0 + (if ((size(input) > 35))
1799-                                                                                                                                                    then (input[35] * weights[14][35])
1800-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[14])
1801-    let weighted_sum16 = (((if ((size(input) > 0))
1802-        then (input[0] * weights[15][0])
1803-        else (0 + (if ((size(input) > 1))
1804-            then (input[1] * weights[15][1])
1805-            else (0 + (if ((size(input) > 2))
1806-                then (input[2] * weights[15][2])
1807-                else (0 + (if ((size(input) > 3))
1808-                    then (input[3] * weights[15][3])
1809-                    else (0 + (if ((size(input) > 4))
1810-                        then (input[4] * weights[15][4])
1811-                        else (0 + (if ((size(input) > 5))
1812-                            then (input[5] * weights[15][5])
1813-                            else (0 + (if ((size(input) > 6))
1814-                                then (input[6] * weights[15][6])
1815-                                else (0 + (if ((size(input) > 7))
1816-                                    then (input[7] * weights[15][7])
1817-                                    else (0 + (if ((size(input) > 8))
1818-                                        then (input[8] * weights[15][8])
1819-                                        else (0 + (if ((size(input) > 9))
1820-                                            then (input[9] * weights[15][9])
1821-                                            else (0 + (if ((size(input) > 10))
1822-                                                then (input[10] * weights[15][10])
1823-                                                else (0 + (if ((size(input) > 11))
1824-                                                    then (input[11] * weights[15][11])
1825-                                                    else (0 + (if ((size(input) > 12))
1826-                                                        then (input[12] * weights[15][12])
1827-                                                        else (0 + (if ((size(input) > 13))
1828-                                                            then (input[13] * weights[15][13])
1829-                                                            else (0 + (if ((size(input) > 14))
1830-                                                                then (input[14] * weights[15][14])
1831-                                                                else (0 + (if ((size(input) > 15))
1832-                                                                    then (input[15] * weights[15][15])
1833-                                                                    else (0 + (if ((size(input) > 16))
1834-                                                                        then (input[16] * weights[15][16])
1835-                                                                        else (0 + (if ((size(input) > 17))
1836-                                                                            then (input[17] * weights[15][17])
1837-                                                                            else (0 + (if ((size(input) > 18))
1838-                                                                                then (input[18] * weights[15][18])
1839-                                                                                else (0 + (if ((size(input) > 19))
1840-                                                                                    then (input[19] * weights[15][19])
1841-                                                                                    else (0 + (if ((size(input) > 20))
1842-                                                                                        then (input[20] * weights[15][20])
1843-                                                                                        else (0 + (if ((size(input) > 21))
1844-                                                                                            then (input[21] * weights[15][21])
1845-                                                                                            else (0 + (if ((size(input) > 22))
1846-                                                                                                then (input[22] * weights[15][22])
1847-                                                                                                else (0 + (if ((size(input) > 23))
1848-                                                                                                    then (input[23] * weights[15][23])
1849-                                                                                                    else (0 + (if ((size(input) > 24))
1850-                                                                                                        then (input[24] * weights[15][24])
1851-                                                                                                        else (0 + (if ((size(input) > 25))
1852-                                                                                                            then (input[25] * weights[15][25])
1853-                                                                                                            else (0 + (if ((size(input) > 26))
1854-                                                                                                                then (input[26] * weights[15][26])
1855-                                                                                                                else (0 + (if ((size(input) > 27))
1856-                                                                                                                    then (input[27] * weights[15][27])
1857-                                                                                                                    else (0 + (if ((size(input) > 28))
1858-                                                                                                                        then (input[28] * weights[15][28])
1859-                                                                                                                        else (0 + (if ((size(input) > 29))
1860-                                                                                                                            then (input[29] * weights[15][29])
1861-                                                                                                                            else (0 + (if ((size(input) > 30))
1862-                                                                                                                                then (input[30] * weights[15][30])
1863-                                                                                                                                else (0 + (if ((size(input) > 31))
1864-                                                                                                                                    then (input[31] * weights[15][31])
1865-                                                                                                                                    else (0 + (if ((size(input) > 32))
1866-                                                                                                                                        then (input[32] * weights[15][32])
1867-                                                                                                                                        else (0 + (if ((size(input) > 33))
1868-                                                                                                                                            then (input[33] * weights[15][33])
1869-                                                                                                                                            else (0 + (if ((size(input) > 34))
1870-                                                                                                                                                then (input[34] * weights[15][34])
1871-                                                                                                                                                else (0 + (if ((size(input) > 35))
1872-                                                                                                                                                    then (input[35] * weights[15][35])
1873-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[15])
1874-    let weighted_sum17 = (((if ((size(input) > 0))
1875-        then (input[0] * weights[16][0])
1876-        else (0 + (if ((size(input) > 1))
1877-            then (input[1] * weights[16][1])
1878-            else (0 + (if ((size(input) > 2))
1879-                then (input[2] * weights[16][2])
1880-                else (0 + (if ((size(input) > 3))
1881-                    then (input[3] * weights[16][3])
1882-                    else (0 + (if ((size(input) > 4))
1883-                        then (input[4] * weights[16][4])
1884-                        else (0 + (if ((size(input) > 5))
1885-                            then (input[5] * weights[16][5])
1886-                            else (0 + (if ((size(input) > 6))
1887-                                then (input[6] * weights[16][6])
1888-                                else (0 + (if ((size(input) > 7))
1889-                                    then (input[7] * weights[16][7])
1890-                                    else (0 + (if ((size(input) > 8))
1891-                                        then (input[8] * weights[16][8])
1892-                                        else (0 + (if ((size(input) > 9))
1893-                                            then (input[9] * weights[16][9])
1894-                                            else (0 + (if ((size(input) > 10))
1895-                                                then (input[10] * weights[16][10])
1896-                                                else (0 + (if ((size(input) > 11))
1897-                                                    then (input[11] * weights[16][11])
1898-                                                    else (0 + (if ((size(input) > 12))
1899-                                                        then (input[12] * weights[16][12])
1900-                                                        else (0 + (if ((size(input) > 13))
1901-                                                            then (input[13] * weights[16][13])
1902-                                                            else (0 + (if ((size(input) > 14))
1903-                                                                then (input[14] * weights[16][14])
1904-                                                                else (0 + (if ((size(input) > 15))
1905-                                                                    then (input[15] * weights[16][15])
1906-                                                                    else (0 + (if ((size(input) > 16))
1907-                                                                        then (input[16] * weights[16][16])
1908-                                                                        else (0 + (if ((size(input) > 17))
1909-                                                                            then (input[17] * weights[16][17])
1910-                                                                            else (0 + (if ((size(input) > 18))
1911-                                                                                then (input[18] * weights[16][18])
1912-                                                                                else (0 + (if ((size(input) > 19))
1913-                                                                                    then (input[19] * weights[16][19])
1914-                                                                                    else (0 + (if ((size(input) > 20))
1915-                                                                                        then (input[20] * weights[16][20])
1916-                                                                                        else (0 + (if ((size(input) > 21))
1917-                                                                                            then (input[21] * weights[16][21])
1918-                                                                                            else (0 + (if ((size(input) > 22))
1919-                                                                                                then (input[22] * weights[16][22])
1920-                                                                                                else (0 + (if ((size(input) > 23))
1921-                                                                                                    then (input[23] * weights[16][23])
1922-                                                                                                    else (0 + (if ((size(input) > 24))
1923-                                                                                                        then (input[24] * weights[16][24])
1924-                                                                                                        else (0 + (if ((size(input) > 25))
1925-                                                                                                            then (input[25] * weights[16][25])
1926-                                                                                                            else (0 + (if ((size(input) > 26))
1927-                                                                                                                then (input[26] * weights[16][26])
1928-                                                                                                                else (0 + (if ((size(input) > 27))
1929-                                                                                                                    then (input[27] * weights[16][27])
1930-                                                                                                                    else (0 + (if ((size(input) > 28))
1931-                                                                                                                        then (input[28] * weights[16][28])
1932-                                                                                                                        else (0 + (if ((size(input) > 29))
1933-                                                                                                                            then (input[29] * weights[16][29])
1934-                                                                                                                            else (0 + (if ((size(input) > 30))
1935-                                                                                                                                then (input[30] * weights[16][30])
1936-                                                                                                                                else (0 + (if ((size(input) > 31))
1937-                                                                                                                                    then (input[31] * weights[16][31])
1938-                                                                                                                                    else (0 + (if ((size(input) > 32))
1939-                                                                                                                                        then (input[32] * weights[16][32])
1940-                                                                                                                                        else (0 + (if ((size(input) > 33))
1941-                                                                                                                                            then (input[33] * weights[16][33])
1942-                                                                                                                                            else (0 + (if ((size(input) > 34))
1943-                                                                                                                                                then (input[34] * weights[16][34])
1944-                                                                                                                                                else (0 + (if ((size(input) > 35))
1945-                                                                                                                                                    then (input[35] * weights[16][35])
1946-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[16])
1947-    let weighted_sum18 = (((if ((size(input) > 0))
1948-        then (input[0] * weights[17][0])
1949-        else (0 + (if ((size(input) > 1))
1950-            then (input[1] * weights[17][1])
1951-            else (0 + (if ((size(input) > 2))
1952-                then (input[2] * weights[17][2])
1953-                else (0 + (if ((size(input) > 3))
1954-                    then (input[3] * weights[17][3])
1955-                    else (0 + (if ((size(input) > 4))
1956-                        then (input[4] * weights[17][4])
1957-                        else (0 + (if ((size(input) > 5))
1958-                            then (input[5] * weights[17][5])
1959-                            else (0 + (if ((size(input) > 6))
1960-                                then (input[6] * weights[17][6])
1961-                                else (0 + (if ((size(input) > 7))
1962-                                    then (input[7] * weights[17][7])
1963-                                    else (0 + (if ((size(input) > 8))
1964-                                        then (input[8] * weights[17][8])
1965-                                        else (0 + (if ((size(input) > 9))
1966-                                            then (input[9] * weights[17][9])
1967-                                            else (0 + (if ((size(input) > 10))
1968-                                                then (input[10] * weights[17][10])
1969-                                                else (0 + (if ((size(input) > 11))
1970-                                                    then (input[11] * weights[17][11])
1971-                                                    else (0 + (if ((size(input) > 12))
1972-                                                        then (input[12] * weights[17][12])
1973-                                                        else (0 + (if ((size(input) > 13))
1974-                                                            then (input[13] * weights[17][13])
1975-                                                            else (0 + (if ((size(input) > 14))
1976-                                                                then (input[14] * weights[17][14])
1977-                                                                else (0 + (if ((size(input) > 15))
1978-                                                                    then (input[15] * weights[17][15])
1979-                                                                    else (0 + (if ((size(input) > 16))
1980-                                                                        then (input[16] * weights[17][16])
1981-                                                                        else (0 + (if ((size(input) > 17))
1982-                                                                            then (input[17] * weights[17][17])
1983-                                                                            else (0 + (if ((size(input) > 18))
1984-                                                                                then (input[18] * weights[17][18])
1985-                                                                                else (0 + (if ((size(input) > 19))
1986-                                                                                    then (input[19] * weights[17][19])
1987-                                                                                    else (0 + (if ((size(input) > 20))
1988-                                                                                        then (input[20] * weights[17][20])
1989-                                                                                        else (0 + (if ((size(input) > 21))
1990-                                                                                            then (input[21] * weights[17][21])
1991-                                                                                            else (0 + (if ((size(input) > 22))
1992-                                                                                                then (input[22] * weights[17][22])
1993-                                                                                                else (0 + (if ((size(input) > 23))
1994-                                                                                                    then (input[23] * weights[17][23])
1995-                                                                                                    else (0 + (if ((size(input) > 24))
1996-                                                                                                        then (input[24] * weights[17][24])
1997-                                                                                                        else (0 + (if ((size(input) > 25))
1998-                                                                                                            then (input[25] * weights[17][25])
1999-                                                                                                            else (0 + (if ((size(input) > 26))
2000-                                                                                                                then (input[26] * weights[17][26])
2001-                                                                                                                else (0 + (if ((size(input) > 27))
2002-                                                                                                                    then (input[27] * weights[17][27])
2003-                                                                                                                    else (0 + (if ((size(input) > 28))
2004-                                                                                                                        then (input[28] * weights[17][28])
2005-                                                                                                                        else (0 + (if ((size(input) > 29))
2006-                                                                                                                            then (input[29] * weights[17][29])
2007-                                                                                                                            else (0 + (if ((size(input) > 30))
2008-                                                                                                                                then (input[30] * weights[17][30])
2009-                                                                                                                                else (0 + (if ((size(input) > 31))
2010-                                                                                                                                    then (input[31] * weights[17][31])
2011-                                                                                                                                    else (0 + (if ((size(input) > 32))
2012-                                                                                                                                        then (input[32] * weights[17][32])
2013-                                                                                                                                        else (0 + (if ((size(input) > 33))
2014-                                                                                                                                            then (input[33] * weights[17][33])
2015-                                                                                                                                            else (0 + (if ((size(input) > 34))
2016-                                                                                                                                                then (input[34] * weights[17][34])
2017-                                                                                                                                                else (0 + (if ((size(input) > 35))
2018-                                                                                                                                                    then (input[35] * weights[17][35])
2019-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[17])
2020-    let weighted_sum19 = (((if ((size(input) > 0))
2021-        then (input[0] * weights[18][0])
2022-        else (0 + (if ((size(input) > 1))
2023-            then (input[1] * weights[18][1])
2024-            else (0 + (if ((size(input) > 2))
2025-                then (input[2] * weights[18][2])
2026-                else (0 + (if ((size(input) > 3))
2027-                    then (input[3] * weights[18][3])
2028-                    else (0 + (if ((size(input) > 4))
2029-                        then (input[4] * weights[18][4])
2030-                        else (0 + (if ((size(input) > 5))
2031-                            then (input[5] * weights[18][5])
2032-                            else (0 + (if ((size(input) > 6))
2033-                                then (input[6] * weights[18][6])
2034-                                else (0 + (if ((size(input) > 7))
2035-                                    then (input[7] * weights[18][7])
2036-                                    else (0 + (if ((size(input) > 8))
2037-                                        then (input[8] * weights[18][8])
2038-                                        else (0 + (if ((size(input) > 9))
2039-                                            then (input[9] * weights[18][9])
2040-                                            else (0 + (if ((size(input) > 10))
2041-                                                then (input[10] * weights[18][10])
2042-                                                else (0 + (if ((size(input) > 11))
2043-                                                    then (input[11] * weights[18][11])
2044-                                                    else (0 + (if ((size(input) > 12))
2045-                                                        then (input[12] * weights[18][12])
2046-                                                        else (0 + (if ((size(input) > 13))
2047-                                                            then (input[13] * weights[18][13])
2048-                                                            else (0 + (if ((size(input) > 14))
2049-                                                                then (input[14] * weights[18][14])
2050-                                                                else (0 + (if ((size(input) > 15))
2051-                                                                    then (input[15] * weights[18][15])
2052-                                                                    else (0 + (if ((size(input) > 16))
2053-                                                                        then (input[16] * weights[18][16])
2054-                                                                        else (0 + (if ((size(input) > 17))
2055-                                                                            then (input[17] * weights[18][17])
2056-                                                                            else (0 + (if ((size(input) > 18))
2057-                                                                                then (input[18] * weights[18][18])
2058-                                                                                else (0 + (if ((size(input) > 19))
2059-                                                                                    then (input[19] * weights[18][19])
2060-                                                                                    else (0 + (if ((size(input) > 20))
2061-                                                                                        then (input[20] * weights[18][20])
2062-                                                                                        else (0 + (if ((size(input) > 21))
2063-                                                                                            then (input[21] * weights[18][21])
2064-                                                                                            else (0 + (if ((size(input) > 22))
2065-                                                                                                then (input[22] * weights[18][22])
2066-                                                                                                else (0 + (if ((size(input) > 23))
2067-                                                                                                    then (input[23] * weights[18][23])
2068-                                                                                                    else (0 + (if ((size(input) > 24))
2069-                                                                                                        then (input[24] * weights[18][24])
2070-                                                                                                        else (0 + (if ((size(input) > 25))
2071-                                                                                                            then (input[25] * weights[18][25])
2072-                                                                                                            else (0 + (if ((size(input) > 26))
2073-                                                                                                                then (input[26] * weights[18][26])
2074-                                                                                                                else (0 + (if ((size(input) > 27))
2075-                                                                                                                    then (input[27] * weights[18][27])
2076-                                                                                                                    else (0 + (if ((size(input) > 28))
2077-                                                                                                                        then (input[28] * weights[18][28])
2078-                                                                                                                        else (0 + (if ((size(input) > 29))
2079-                                                                                                                            then (input[29] * weights[18][29])
2080-                                                                                                                            else (0 + (if ((size(input) > 30))
2081-                                                                                                                                then (input[30] * weights[18][30])
2082-                                                                                                                                else (0 + (if ((size(input) > 31))
2083-                                                                                                                                    then (input[31] * weights[18][31])
2084-                                                                                                                                    else (0 + (if ((size(input) > 32))
2085-                                                                                                                                        then (input[32] * weights[18][32])
2086-                                                                                                                                        else (0 + (if ((size(input) > 33))
2087-                                                                                                                                            then (input[33] * weights[18][33])
2088-                                                                                                                                            else (0 + (if ((size(input) > 34))
2089-                                                                                                                                                then (input[34] * weights[18][34])
2090-                                                                                                                                                else (0 + (if ((size(input) > 35))
2091-                                                                                                                                                    then (input[35] * weights[18][35])
2092-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[18])
2093-    let weighted_sum20 = (((if ((size(input) > 0))
2094-        then (input[0] * weights[19][0])
2095-        else (0 + (if ((size(input) > 1))
2096-            then (input[1] * weights[19][1])
2097-            else (0 + (if ((size(input) > 2))
2098-                then (input[2] * weights[19][2])
2099-                else (0 + (if ((size(input) > 3))
2100-                    then (input[3] * weights[19][3])
2101-                    else (0 + (if ((size(input) > 4))
2102-                        then (input[4] * weights[19][4])
2103-                        else (0 + (if ((size(input) > 5))
2104-                            then (input[5] * weights[19][5])
2105-                            else (0 + (if ((size(input) > 6))
2106-                                then (input[6] * weights[19][6])
2107-                                else (0 + (if ((size(input) > 7))
2108-                                    then (input[7] * weights[19][7])
2109-                                    else (0 + (if ((size(input) > 8))
2110-                                        then (input[8] * weights[19][8])
2111-                                        else (0 + (if ((size(input) > 9))
2112-                                            then (input[9] * weights[19][9])
2113-                                            else (0 + (if ((size(input) > 10))
2114-                                                then (input[10] * weights[19][10])
2115-                                                else (0 + (if ((size(input) > 11))
2116-                                                    then (input[11] * weights[19][11])
2117-                                                    else (0 + (if ((size(input) > 12))
2118-                                                        then (input[12] * weights[19][12])
2119-                                                        else (0 + (if ((size(input) > 13))
2120-                                                            then (input[13] * weights[19][13])
2121-                                                            else (0 + (if ((size(input) > 14))
2122-                                                                then (input[14] * weights[19][14])
2123-                                                                else (0 + (if ((size(input) > 15))
2124-                                                                    then (input[15] * weights[19][15])
2125-                                                                    else (0 + (if ((size(input) > 16))
2126-                                                                        then (input[16] * weights[19][16])
2127-                                                                        else (0 + (if ((size(input) > 17))
2128-                                                                            then (input[17] * weights[19][17])
2129-                                                                            else (0 + (if ((size(input) > 18))
2130-                                                                                then (input[18] * weights[19][18])
2131-                                                                                else (0 + (if ((size(input) > 19))
2132-                                                                                    then (input[19] * weights[19][19])
2133-                                                                                    else (0 + (if ((size(input) > 20))
2134-                                                                                        then (input[20] * weights[19][20])
2135-                                                                                        else (0 + (if ((size(input) > 21))
2136-                                                                                            then (input[21] * weights[19][21])
2137-                                                                                            else (0 + (if ((size(input) > 22))
2138-                                                                                                then (input[22] * weights[19][22])
2139-                                                                                                else (0 + (if ((size(input) > 23))
2140-                                                                                                    then (input[23] * weights[19][23])
2141-                                                                                                    else (0 + (if ((size(input) > 24))
2142-                                                                                                        then (input[24] * weights[19][24])
2143-                                                                                                        else (0 + (if ((size(input) > 25))
2144-                                                                                                            then (input[25] * weights[19][25])
2145-                                                                                                            else (0 + (if ((size(input) > 26))
2146-                                                                                                                then (input[26] * weights[19][26])
2147-                                                                                                                else (0 + (if ((size(input) > 27))
2148-                                                                                                                    then (input[27] * weights[19][27])
2149-                                                                                                                    else (0 + (if ((size(input) > 28))
2150-                                                                                                                        then (input[28] * weights[19][28])
2151-                                                                                                                        else (0 + (if ((size(input) > 29))
2152-                                                                                                                            then (input[29] * weights[19][29])
2153-                                                                                                                            else (0 + (if ((size(input) > 30))
2154-                                                                                                                                then (input[30] * weights[19][30])
2155-                                                                                                                                else (0 + (if ((size(input) > 31))
2156-                                                                                                                                    then (input[31] * weights[19][31])
2157-                                                                                                                                    else (0 + (if ((size(input) > 32))
2158-                                                                                                                                        then (input[32] * weights[19][32])
2159-                                                                                                                                        else (0 + (if ((size(input) > 33))
2160-                                                                                                                                            then (input[33] * weights[19][33])
2161-                                                                                                                                            else (0 + (if ((size(input) > 34))
2162-                                                                                                                                                then (input[34] * weights[19][34])
2163-                                                                                                                                                else (0 + (if ((size(input) > 35))
2164-                                                                                                                                                    then (input[35] * weights[19][35])
2165-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[19])
2166-    let weighted_sum21 = (((if ((size(input) > 0))
2167-        then (input[0] * weights[20][0])
2168-        else (0 + (if ((size(input) > 1))
2169-            then (input[1] * weights[20][1])
2170-            else (0 + (if ((size(input) > 2))
2171-                then (input[2] * weights[20][2])
2172-                else (0 + (if ((size(input) > 3))
2173-                    then (input[3] * weights[20][3])
2174-                    else (0 + (if ((size(input) > 4))
2175-                        then (input[4] * weights[20][4])
2176-                        else (0 + (if ((size(input) > 5))
2177-                            then (input[5] * weights[20][5])
2178-                            else (0 + (if ((size(input) > 6))
2179-                                then (input[6] * weights[20][6])
2180-                                else (0 + (if ((size(input) > 7))
2181-                                    then (input[7] * weights[20][7])
2182-                                    else (0 + (if ((size(input) > 8))
2183-                                        then (input[8] * weights[20][8])
2184-                                        else (0 + (if ((size(input) > 9))
2185-                                            then (input[9] * weights[20][9])
2186-                                            else (0 + (if ((size(input) > 10))
2187-                                                then (input[10] * weights[20][10])
2188-                                                else (0 + (if ((size(input) > 11))
2189-                                                    then (input[11] * weights[20][11])
2190-                                                    else (0 + (if ((size(input) > 12))
2191-                                                        then (input[12] * weights[20][12])
2192-                                                        else (0 + (if ((size(input) > 13))
2193-                                                            then (input[13] * weights[20][13])
2194-                                                            else (0 + (if ((size(input) > 14))
2195-                                                                then (input[14] * weights[20][14])
2196-                                                                else (0 + (if ((size(input) > 15))
2197-                                                                    then (input[15] * weights[20][15])
2198-                                                                    else (0 + (if ((size(input) > 16))
2199-                                                                        then (input[16] * weights[20][16])
2200-                                                                        else (0 + (if ((size(input) > 17))
2201-                                                                            then (input[17] * weights[20][17])
2202-                                                                            else (0 + (if ((size(input) > 18))
2203-                                                                                then (input[18] * weights[20][18])
2204-                                                                                else (0 + (if ((size(input) > 19))
2205-                                                                                    then (input[19] * weights[20][19])
2206-                                                                                    else (0 + (if ((size(input) > 20))
2207-                                                                                        then (input[20] * weights[20][20])
2208-                                                                                        else (0 + (if ((size(input) > 21))
2209-                                                                                            then (input[21] * weights[20][21])
2210-                                                                                            else (0 + (if ((size(input) > 22))
2211-                                                                                                then (input[22] * weights[20][22])
2212-                                                                                                else (0 + (if ((size(input) > 23))
2213-                                                                                                    then (input[23] * weights[20][23])
2214-                                                                                                    else (0 + (if ((size(input) > 24))
2215-                                                                                                        then (input[24] * weights[20][24])
2216-                                                                                                        else (0 + (if ((size(input) > 25))
2217-                                                                                                            then (input[25] * weights[20][25])
2218-                                                                                                            else (0 + (if ((size(input) > 26))
2219-                                                                                                                then (input[26] * weights[20][26])
2220-                                                                                                                else (0 + (if ((size(input) > 27))
2221-                                                                                                                    then (input[27] * weights[20][27])
2222-                                                                                                                    else (0 + (if ((size(input) > 28))
2223-                                                                                                                        then (input[28] * weights[20][28])
2224-                                                                                                                        else (0 + (if ((size(input) > 29))
2225-                                                                                                                            then (input[29] * weights[20][29])
2226-                                                                                                                            else (0 + (if ((size(input) > 30))
2227-                                                                                                                                then (input[30] * weights[20][30])
2228-                                                                                                                                else (0 + (if ((size(input) > 31))
2229-                                                                                                                                    then (input[31] * weights[20][31])
2230-                                                                                                                                    else (0 + (if ((size(input) > 32))
2231-                                                                                                                                        then (input[32] * weights[20][32])
2232-                                                                                                                                        else (0 + (if ((size(input) > 33))
2233-                                                                                                                                            then (input[33] * weights[20][33])
2234-                                                                                                                                            else (0 + (if ((size(input) > 34))
2235-                                                                                                                                                then (input[34] * weights[20][34])
2236-                                                                                                                                                else (0 + (if ((size(input) > 35))
2237-                                                                                                                                                    then (input[35] * weights[20][35])
2238-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[20])
2239-    let weighted_sum22 = (((if ((size(input) > 0))
2240-        then (input[0] * weights[21][0])
2241-        else (0 + (if ((size(input) > 1))
2242-            then (input[1] * weights[21][1])
2243-            else (0 + (if ((size(input) > 2))
2244-                then (input[2] * weights[21][2])
2245-                else (0 + (if ((size(input) > 3))
2246-                    then (input[3] * weights[21][3])
2247-                    else (0 + (if ((size(input) > 4))
2248-                        then (input[4] * weights[21][4])
2249-                        else (0 + (if ((size(input) > 5))
2250-                            then (input[5] * weights[21][5])
2251-                            else (0 + (if ((size(input) > 6))
2252-                                then (input[6] * weights[21][6])
2253-                                else (0 + (if ((size(input) > 7))
2254-                                    then (input[7] * weights[21][7])
2255-                                    else (0 + (if ((size(input) > 8))
2256-                                        then (input[8] * weights[21][8])
2257-                                        else (0 + (if ((size(input) > 9))
2258-                                            then (input[9] * weights[21][9])
2259-                                            else (0 + (if ((size(input) > 10))
2260-                                                then (input[10] * weights[21][10])
2261-                                                else (0 + (if ((size(input) > 11))
2262-                                                    then (input[11] * weights[21][11])
2263-                                                    else (0 + (if ((size(input) > 12))
2264-                                                        then (input[12] * weights[21][12])
2265-                                                        else (0 + (if ((size(input) > 13))
2266-                                                            then (input[13] * weights[21][13])
2267-                                                            else (0 + (if ((size(input) > 14))
2268-                                                                then (input[14] * weights[21][14])
2269-                                                                else (0 + (if ((size(input) > 15))
2270-                                                                    then (input[15] * weights[21][15])
2271-                                                                    else (0 + (if ((size(input) > 16))
2272-                                                                        then (input[16] * weights[21][16])
2273-                                                                        else (0 + (if ((size(input) > 17))
2274-                                                                            then (input[17] * weights[21][17])
2275-                                                                            else (0 + (if ((size(input) > 18))
2276-                                                                                then (input[18] * weights[21][18])
2277-                                                                                else (0 + (if ((size(input) > 19))
2278-                                                                                    then (input[19] * weights[21][19])
2279-                                                                                    else (0 + (if ((size(input) > 20))
2280-                                                                                        then (input[20] * weights[21][20])
2281-                                                                                        else (0 + (if ((size(input) > 21))
2282-                                                                                            then (input[21] * weights[21][21])
2283-                                                                                            else (0 + (if ((size(input) > 22))
2284-                                                                                                then (input[22] * weights[21][22])
2285-                                                                                                else (0 + (if ((size(input) > 23))
2286-                                                                                                    then (input[23] * weights[21][23])
2287-                                                                                                    else (0 + (if ((size(input) > 24))
2288-                                                                                                        then (input[24] * weights[21][24])
2289-                                                                                                        else (0 + (if ((size(input) > 25))
2290-                                                                                                            then (input[25] * weights[21][25])
2291-                                                                                                            else (0 + (if ((size(input) > 26))
2292-                                                                                                                then (input[26] * weights[21][26])
2293-                                                                                                                else (0 + (if ((size(input) > 27))
2294-                                                                                                                    then (input[27] * weights[21][27])
2295-                                                                                                                    else (0 + (if ((size(input) > 28))
2296-                                                                                                                        then (input[28] * weights[21][28])
2297-                                                                                                                        else (0 + (if ((size(input) > 29))
2298-                                                                                                                            then (input[29] * weights[21][29])
2299-                                                                                                                            else (0 + (if ((size(input) > 30))
2300-                                                                                                                                then (input[30] * weights[21][30])
2301-                                                                                                                                else (0 + (if ((size(input) > 31))
2302-                                                                                                                                    then (input[31] * weights[21][31])
2303-                                                                                                                                    else (0 + (if ((size(input) > 32))
2304-                                                                                                                                        then (input[32] * weights[21][32])
2305-                                                                                                                                        else (0 + (if ((size(input) > 33))
2306-                                                                                                                                            then (input[33] * weights[21][33])
2307-                                                                                                                                            else (0 + (if ((size(input) > 34))
2308-                                                                                                                                                then (input[34] * weights[21][34])
2309-                                                                                                                                                else (0 + (if ((size(input) > 35))
2310-                                                                                                                                                    then (input[35] * weights[21][35])
2311-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[21])
2312-    let weighted_sum23 = (((if ((size(input) > 0))
2313-        then (input[0] * weights[22][0])
2314-        else (0 + (if ((size(input) > 1))
2315-            then (input[1] * weights[22][1])
2316-            else (0 + (if ((size(input) > 2))
2317-                then (input[2] * weights[22][2])
2318-                else (0 + (if ((size(input) > 3))
2319-                    then (input[3] * weights[22][3])
2320-                    else (0 + (if ((size(input) > 4))
2321-                        then (input[4] * weights[22][4])
2322-                        else (0 + (if ((size(input) > 5))
2323-                            then (input[5] * weights[22][5])
2324-                            else (0 + (if ((size(input) > 6))
2325-                                then (input[6] * weights[22][6])
2326-                                else (0 + (if ((size(input) > 7))
2327-                                    then (input[7] * weights[22][7])
2328-                                    else (0 + (if ((size(input) > 8))
2329-                                        then (input[8] * weights[22][8])
2330-                                        else (0 + (if ((size(input) > 9))
2331-                                            then (input[9] * weights[22][9])
2332-                                            else (0 + (if ((size(input) > 10))
2333-                                                then (input[10] * weights[22][10])
2334-                                                else (0 + (if ((size(input) > 11))
2335-                                                    then (input[11] * weights[22][11])
2336-                                                    else (0 + (if ((size(input) > 12))
2337-                                                        then (input[12] * weights[22][12])
2338-                                                        else (0 + (if ((size(input) > 13))
2339-                                                            then (input[13] * weights[22][13])
2340-                                                            else (0 + (if ((size(input) > 14))
2341-                                                                then (input[14] * weights[22][14])
2342-                                                                else (0 + (if ((size(input) > 15))
2343-                                                                    then (input[15] * weights[22][15])
2344-                                                                    else (0 + (if ((size(input) > 16))
2345-                                                                        then (input[16] * weights[22][16])
2346-                                                                        else (0 + (if ((size(input) > 17))
2347-                                                                            then (input[17] * weights[22][17])
2348-                                                                            else (0 + (if ((size(input) > 18))
2349-                                                                                then (input[18] * weights[22][18])
2350-                                                                                else (0 + (if ((size(input) > 19))
2351-                                                                                    then (input[19] * weights[22][19])
2352-                                                                                    else (0 + (if ((size(input) > 20))
2353-                                                                                        then (input[20] * weights[22][20])
2354-                                                                                        else (0 + (if ((size(input) > 21))
2355-                                                                                            then (input[21] * weights[22][21])
2356-                                                                                            else (0 + (if ((size(input) > 22))
2357-                                                                                                then (input[22] * weights[22][22])
2358-                                                                                                else (0 + (if ((size(input) > 23))
2359-                                                                                                    then (input[23] * weights[22][23])
2360-                                                                                                    else (0 + (if ((size(input) > 24))
2361-                                                                                                        then (input[24] * weights[22][24])
2362-                                                                                                        else (0 + (if ((size(input) > 25))
2363-                                                                                                            then (input[25] * weights[22][25])
2364-                                                                                                            else (0 + (if ((size(input) > 26))
2365-                                                                                                                then (input[26] * weights[22][26])
2366-                                                                                                                else (0 + (if ((size(input) > 27))
2367-                                                                                                                    then (input[27] * weights[22][27])
2368-                                                                                                                    else (0 + (if ((size(input) > 28))
2369-                                                                                                                        then (input[28] * weights[22][28])
2370-                                                                                                                        else (0 + (if ((size(input) > 29))
2371-                                                                                                                            then (input[29] * weights[22][29])
2372-                                                                                                                            else (0 + (if ((size(input) > 30))
2373-                                                                                                                                then (input[30] * weights[22][30])
2374-                                                                                                                                else (0 + (if ((size(input) > 31))
2375-                                                                                                                                    then (input[31] * weights[22][31])
2376-                                                                                                                                    else (0 + (if ((size(input) > 32))
2377-                                                                                                                                        then (input[32] * weights[22][32])
2378-                                                                                                                                        else (0 + (if ((size(input) > 33))
2379-                                                                                                                                            then (input[33] * weights[22][33])
2380-                                                                                                                                            else (0 + (if ((size(input) > 34))
2381-                                                                                                                                                then (input[34] * weights[22][34])
2382-                                                                                                                                                else (0 + (if ((size(input) > 35))
2383-                                                                                                                                                    then (input[35] * weights[22][35])
2384-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[22])
2385-    let weighted_sum24 = (((if ((size(input) > 0))
2386-        then (input[0] * weights[23][0])
2387-        else (0 + (if ((size(input) > 1))
2388-            then (input[1] * weights[23][1])
2389-            else (0 + (if ((size(input) > 2))
2390-                then (input[2] * weights[23][2])
2391-                else (0 + (if ((size(input) > 3))
2392-                    then (input[3] * weights[23][3])
2393-                    else (0 + (if ((size(input) > 4))
2394-                        then (input[4] * weights[23][4])
2395-                        else (0 + (if ((size(input) > 5))
2396-                            then (input[5] * weights[23][5])
2397-                            else (0 + (if ((size(input) > 6))
2398-                                then (input[6] * weights[23][6])
2399-                                else (0 + (if ((size(input) > 7))
2400-                                    then (input[7] * weights[23][7])
2401-                                    else (0 + (if ((size(input) > 8))
2402-                                        then (input[8] * weights[23][8])
2403-                                        else (0 + (if ((size(input) > 9))
2404-                                            then (input[9] * weights[23][9])
2405-                                            else (0 + (if ((size(input) > 10))
2406-                                                then (input[10] * weights[23][10])
2407-                                                else (0 + (if ((size(input) > 11))
2408-                                                    then (input[11] * weights[23][11])
2409-                                                    else (0 + (if ((size(input) > 12))
2410-                                                        then (input[12] * weights[23][12])
2411-                                                        else (0 + (if ((size(input) > 13))
2412-                                                            then (input[13] * weights[23][13])
2413-                                                            else (0 + (if ((size(input) > 14))
2414-                                                                then (input[14] * weights[23][14])
2415-                                                                else (0 + (if ((size(input) > 15))
2416-                                                                    then (input[15] * weights[23][15])
2417-                                                                    else (0 + (if ((size(input) > 16))
2418-                                                                        then (input[16] * weights[23][16])
2419-                                                                        else (0 + (if ((size(input) > 17))
2420-                                                                            then (input[17] * weights[23][17])
2421-                                                                            else (0 + (if ((size(input) > 18))
2422-                                                                                then (input[18] * weights[23][18])
2423-                                                                                else (0 + (if ((size(input) > 19))
2424-                                                                                    then (input[19] * weights[23][19])
2425-                                                                                    else (0 + (if ((size(input) > 20))
2426-                                                                                        then (input[20] * weights[23][20])
2427-                                                                                        else (0 + (if ((size(input) > 21))
2428-                                                                                            then (input[21] * weights[23][21])
2429-                                                                                            else (0 + (if ((size(input) > 22))
2430-                                                                                                then (input[22] * weights[23][22])
2431-                                                                                                else (0 + (if ((size(input) > 23))
2432-                                                                                                    then (input[23] * weights[23][23])
2433-                                                                                                    else (0 + (if ((size(input) > 24))
2434-                                                                                                        then (input[24] * weights[23][24])
2435-                                                                                                        else (0 + (if ((size(input) > 25))
2436-                                                                                                            then (input[25] * weights[23][25])
2437-                                                                                                            else (0 + (if ((size(input) > 26))
2438-                                                                                                                then (input[26] * weights[23][26])
2439-                                                                                                                else (0 + (if ((size(input) > 27))
2440-                                                                                                                    then (input[27] * weights[23][27])
2441-                                                                                                                    else (0 + (if ((size(input) > 28))
2442-                                                                                                                        then (input[28] * weights[23][28])
2443-                                                                                                                        else (0 + (if ((size(input) > 29))
2444-                                                                                                                            then (input[29] * weights[23][29])
2445-                                                                                                                            else (0 + (if ((size(input) > 30))
2446-                                                                                                                                then (input[30] * weights[23][30])
2447-                                                                                                                                else (0 + (if ((size(input) > 31))
2448-                                                                                                                                    then (input[31] * weights[23][31])
2449-                                                                                                                                    else (0 + (if ((size(input) > 32))
2450-                                                                                                                                        then (input[32] * weights[23][32])
2451-                                                                                                                                        else (0 + (if ((size(input) > 33))
2452-                                                                                                                                            then (input[33] * weights[23][33])
2453-                                                                                                                                            else (0 + (if ((size(input) > 34))
2454-                                                                                                                                                then (input[34] * weights[23][34])
2455-                                                                                                                                                else (0 + (if ((size(input) > 35))
2456-                                                                                                                                                    then (input[35] * weights[23][35])
2457-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[23])
2458-    let weighted_sum25 = (((if ((size(input) > 0))
2459-        then (input[0] * weights[24][0])
2460-        else (0 + (if ((size(input) > 1))
2461-            then (input[1] * weights[24][1])
2462-            else (0 + (if ((size(input) > 2))
2463-                then (input[2] * weights[24][2])
2464-                else (0 + (if ((size(input) > 3))
2465-                    then (input[3] * weights[24][3])
2466-                    else (0 + (if ((size(input) > 4))
2467-                        then (input[4] * weights[24][4])
2468-                        else (0 + (if ((size(input) > 5))
2469-                            then (input[5] * weights[24][5])
2470-                            else (0 + (if ((size(input) > 6))
2471-                                then (input[6] * weights[24][6])
2472-                                else (0 + (if ((size(input) > 7))
2473-                                    then (input[7] * weights[24][7])
2474-                                    else (0 + (if ((size(input) > 8))
2475-                                        then (input[8] * weights[24][8])
2476-                                        else (0 + (if ((size(input) > 9))
2477-                                            then (input[9] * weights[24][9])
2478-                                            else (0 + (if ((size(input) > 10))
2479-                                                then (input[10] * weights[24][10])
2480-                                                else (0 + (if ((size(input) > 11))
2481-                                                    then (input[11] * weights[24][11])
2482-                                                    else (0 + (if ((size(input) > 12))
2483-                                                        then (input[12] * weights[24][12])
2484-                                                        else (0 + (if ((size(input) > 13))
2485-                                                            then (input[13] * weights[24][13])
2486-                                                            else (0 + (if ((size(input) > 14))
2487-                                                                then (input[14] * weights[24][14])
2488-                                                                else (0 + (if ((size(input) > 15))
2489-                                                                    then (input[15] * weights[24][15])
2490-                                                                    else (0 + (if ((size(input) > 16))
2491-                                                                        then (input[16] * weights[24][16])
2492-                                                                        else (0 + (if ((size(input) > 17))
2493-                                                                            then (input[17] * weights[24][17])
2494-                                                                            else (0 + (if ((size(input) > 18))
2495-                                                                                then (input[18] * weights[24][18])
2496-                                                                                else (0 + (if ((size(input) > 19))
2497-                                                                                    then (input[19] * weights[24][19])
2498-                                                                                    else (0 + (if ((size(input) > 20))
2499-                                                                                        then (input[20] * weights[24][20])
2500-                                                                                        else (0 + (if ((size(input) > 21))
2501-                                                                                            then (input[21] * weights[24][21])
2502-                                                                                            else (0 + (if ((size(input) > 22))
2503-                                                                                                then (input[22] * weights[24][22])
2504-                                                                                                else (0 + (if ((size(input) > 23))
2505-                                                                                                    then (input[23] * weights[24][23])
2506-                                                                                                    else (0 + (if ((size(input) > 24))
2507-                                                                                                        then (input[24] * weights[24][24])
2508-                                                                                                        else (0 + (if ((size(input) > 25))
2509-                                                                                                            then (input[25] * weights[24][25])
2510-                                                                                                            else (0 + (if ((size(input) > 26))
2511-                                                                                                                then (input[26] * weights[24][26])
2512-                                                                                                                else (0 + (if ((size(input) > 27))
2513-                                                                                                                    then (input[27] * weights[24][27])
2514-                                                                                                                    else (0 + (if ((size(input) > 28))
2515-                                                                                                                        then (input[28] * weights[24][28])
2516-                                                                                                                        else (0 + (if ((size(input) > 29))
2517-                                                                                                                            then (input[29] * weights[24][29])
2518-                                                                                                                            else (0 + (if ((size(input) > 30))
2519-                                                                                                                                then (input[30] * weights[24][30])
2520-                                                                                                                                else (0 + (if ((size(input) > 31))
2521-                                                                                                                                    then (input[31] * weights[24][31])
2522-                                                                                                                                    else (0 + (if ((size(input) > 32))
2523-                                                                                                                                        then (input[32] * weights[24][32])
2524-                                                                                                                                        else (0 + (if ((size(input) > 33))
2525-                                                                                                                                            then (input[33] * weights[24][33])
2526-                                                                                                                                            else (0 + (if ((size(input) > 34))
2527-                                                                                                                                                then (input[34] * weights[24][34])
2528-                                                                                                                                                else (0 + (if ((size(input) > 35))
2529-                                                                                                                                                    then (input[35] * weights[24][35])
2530-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[24])
2531-    let weighted_sum26 = (((if ((size(input) > 0))
2532-        then (input[0] * weights[25][0])
2533-        else (0 + (if ((size(input) > 1))
2534-            then (input[1] * weights[25][1])
2535-            else (0 + (if ((size(input) > 2))
2536-                then (input[2] * weights[25][2])
2537-                else (0 + (if ((size(input) > 3))
2538-                    then (input[3] * weights[25][3])
2539-                    else (0 + (if ((size(input) > 4))
2540-                        then (input[4] * weights[25][4])
2541-                        else (0 + (if ((size(input) > 5))
2542-                            then (input[5] * weights[25][5])
2543-                            else (0 + (if ((size(input) > 6))
2544-                                then (input[6] * weights[25][6])
2545-                                else (0 + (if ((size(input) > 7))
2546-                                    then (input[7] * weights[25][7])
2547-                                    else (0 + (if ((size(input) > 8))
2548-                                        then (input[8] * weights[25][8])
2549-                                        else (0 + (if ((size(input) > 9))
2550-                                            then (input[9] * weights[25][9])
2551-                                            else (0 + (if ((size(input) > 10))
2552-                                                then (input[10] * weights[25][10])
2553-                                                else (0 + (if ((size(input) > 11))
2554-                                                    then (input[11] * weights[25][11])
2555-                                                    else (0 + (if ((size(input) > 12))
2556-                                                        then (input[12] * weights[25][12])
2557-                                                        else (0 + (if ((size(input) > 13))
2558-                                                            then (input[13] * weights[25][13])
2559-                                                            else (0 + (if ((size(input) > 14))
2560-                                                                then (input[14] * weights[25][14])
2561-                                                                else (0 + (if ((size(input) > 15))
2562-                                                                    then (input[15] * weights[25][15])
2563-                                                                    else (0 + (if ((size(input) > 16))
2564-                                                                        then (input[16] * weights[25][16])
2565-                                                                        else (0 + (if ((size(input) > 17))
2566-                                                                            then (input[17] * weights[25][17])
2567-                                                                            else (0 + (if ((size(input) > 18))
2568-                                                                                then (input[18] * weights[25][18])
2569-                                                                                else (0 + (if ((size(input) > 19))
2570-                                                                                    then (input[19] * weights[25][19])
2571-                                                                                    else (0 + (if ((size(input) > 20))
2572-                                                                                        then (input[20] * weights[25][20])
2573-                                                                                        else (0 + (if ((size(input) > 21))
2574-                                                                                            then (input[21] * weights[25][21])
2575-                                                                                            else (0 + (if ((size(input) > 22))
2576-                                                                                                then (input[22] * weights[25][22])
2577-                                                                                                else (0 + (if ((size(input) > 23))
2578-                                                                                                    then (input[23] * weights[25][23])
2579-                                                                                                    else (0 + (if ((size(input) > 24))
2580-                                                                                                        then (input[24] * weights[25][24])
2581-                                                                                                        else (0 + (if ((size(input) > 25))
2582-                                                                                                            then (input[25] * weights[25][25])
2583-                                                                                                            else (0 + (if ((size(input) > 26))
2584-                                                                                                                then (input[26] * weights[25][26])
2585-                                                                                                                else (0 + (if ((size(input) > 27))
2586-                                                                                                                    then (input[27] * weights[25][27])
2587-                                                                                                                    else (0 + (if ((size(input) > 28))
2588-                                                                                                                        then (input[28] * weights[25][28])
2589-                                                                                                                        else (0 + (if ((size(input) > 29))
2590-                                                                                                                            then (input[29] * weights[25][29])
2591-                                                                                                                            else (0 + (if ((size(input) > 30))
2592-                                                                                                                                then (input[30] * weights[25][30])
2593-                                                                                                                                else (0 + (if ((size(input) > 31))
2594-                                                                                                                                    then (input[31] * weights[25][31])
2595-                                                                                                                                    else (0 + (if ((size(input) > 32))
2596-                                                                                                                                        then (input[32] * weights[25][32])
2597-                                                                                                                                        else (0 + (if ((size(input) > 33))
2598-                                                                                                                                            then (input[33] * weights[25][33])
2599-                                                                                                                                            else (0 + (if ((size(input) > 34))
2600-                                                                                                                                                then (input[34] * weights[25][34])
2601-                                                                                                                                                else (0 + (if ((size(input) > 35))
2602-                                                                                                                                                    then (input[35] * weights[25][35])
2603-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[25])
2604-    let weighted_sum27 = (((if ((size(input) > 0))
2605-        then (input[0] * weights[26][0])
2606-        else (0 + (if ((size(input) > 1))
2607-            then (input[1] * weights[26][1])
2608-            else (0 + (if ((size(input) > 2))
2609-                then (input[2] * weights[26][2])
2610-                else (0 + (if ((size(input) > 3))
2611-                    then (input[3] * weights[26][3])
2612-                    else (0 + (if ((size(input) > 4))
2613-                        then (input[4] * weights[26][4])
2614-                        else (0 + (if ((size(input) > 5))
2615-                            then (input[5] * weights[26][5])
2616-                            else (0 + (if ((size(input) > 6))
2617-                                then (input[6] * weights[26][6])
2618-                                else (0 + (if ((size(input) > 7))
2619-                                    then (input[7] * weights[26][7])
2620-                                    else (0 + (if ((size(input) > 8))
2621-                                        then (input[8] * weights[26][8])
2622-                                        else (0 + (if ((size(input) > 9))
2623-                                            then (input[9] * weights[26][9])
2624-                                            else (0 + (if ((size(input) > 10))
2625-                                                then (input[10] * weights[26][10])
2626-                                                else (0 + (if ((size(input) > 11))
2627-                                                    then (input[11] * weights[26][11])
2628-                                                    else (0 + (if ((size(input) > 12))
2629-                                                        then (input[12] * weights[26][12])
2630-                                                        else (0 + (if ((size(input) > 13))
2631-                                                            then (input[13] * weights[26][13])
2632-                                                            else (0 + (if ((size(input) > 14))
2633-                                                                then (input[14] * weights[26][14])
2634-                                                                else (0 + (if ((size(input) > 15))
2635-                                                                    then (input[15] * weights[26][15])
2636-                                                                    else (0 + (if ((size(input) > 16))
2637-                                                                        then (input[16] * weights[26][16])
2638-                                                                        else (0 + (if ((size(input) > 17))
2639-                                                                            then (input[17] * weights[26][17])
2640-                                                                            else (0 + (if ((size(input) > 18))
2641-                                                                                then (input[18] * weights[26][18])
2642-                                                                                else (0 + (if ((size(input) > 19))
2643-                                                                                    then (input[19] * weights[26][19])
2644-                                                                                    else (0 + (if ((size(input) > 20))
2645-                                                                                        then (input[20] * weights[26][20])
2646-                                                                                        else (0 + (if ((size(input) > 21))
2647-                                                                                            then (input[21] * weights[26][21])
2648-                                                                                            else (0 + (if ((size(input) > 22))
2649-                                                                                                then (input[22] * weights[26][22])
2650-                                                                                                else (0 + (if ((size(input) > 23))
2651-                                                                                                    then (input[23] * weights[26][23])
2652-                                                                                                    else (0 + (if ((size(input) > 24))
2653-                                                                                                        then (input[24] * weights[26][24])
2654-                                                                                                        else (0 + (if ((size(input) > 25))
2655-                                                                                                            then (input[25] * weights[26][25])
2656-                                                                                                            else (0 + (if ((size(input) > 26))
2657-                                                                                                                then (input[26] * weights[26][26])
2658-                                                                                                                else (0 + (if ((size(input) > 27))
2659-                                                                                                                    then (input[27] * weights[26][27])
2660-                                                                                                                    else (0 + (if ((size(input) > 28))
2661-                                                                                                                        then (input[28] * weights[26][28])
2662-                                                                                                                        else (0 + (if ((size(input) > 29))
2663-                                                                                                                            then (input[29] * weights[26][29])
2664-                                                                                                                            else (0 + (if ((size(input) > 30))
2665-                                                                                                                                then (input[30] * weights[26][30])
2666-                                                                                                                                else (0 + (if ((size(input) > 31))
2667-                                                                                                                                    then (input[31] * weights[26][31])
2668-                                                                                                                                    else (0 + (if ((size(input) > 32))
2669-                                                                                                                                        then (input[32] * weights[26][32])
2670-                                                                                                                                        else (0 + (if ((size(input) > 33))
2671-                                                                                                                                            then (input[33] * weights[26][33])
2672-                                                                                                                                            else (0 + (if ((size(input) > 34))
2673-                                                                                                                                                then (input[34] * weights[26][34])
2674-                                                                                                                                                else (0 + (if ((size(input) > 35))
2675-                                                                                                                                                    then (input[35] * weights[26][35])
2676-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[26])
2677-    let weighted_sum28 = (((if ((size(input) > 0))
2678-        then (input[0] * weights[27][0])
2679-        else (0 + (if ((size(input) > 1))
2680-            then (input[1] * weights[27][1])
2681-            else (0 + (if ((size(input) > 2))
2682-                then (input[2] * weights[27][2])
2683-                else (0 + (if ((size(input) > 3))
2684-                    then (input[3] * weights[27][3])
2685-                    else (0 + (if ((size(input) > 4))
2686-                        then (input[4] * weights[27][4])
2687-                        else (0 + (if ((size(input) > 5))
2688-                            then (input[5] * weights[27][5])
2689-                            else (0 + (if ((size(input) > 6))
2690-                                then (input[6] * weights[27][6])
2691-                                else (0 + (if ((size(input) > 7))
2692-                                    then (input[7] * weights[27][7])
2693-                                    else (0 + (if ((size(input) > 8))
2694-                                        then (input[8] * weights[27][8])
2695-                                        else (0 + (if ((size(input) > 9))
2696-                                            then (input[9] * weights[27][9])
2697-                                            else (0 + (if ((size(input) > 10))
2698-                                                then (input[10] * weights[27][10])
2699-                                                else (0 + (if ((size(input) > 11))
2700-                                                    then (input[11] * weights[27][11])
2701-                                                    else (0 + (if ((size(input) > 12))
2702-                                                        then (input[12] * weights[27][12])
2703-                                                        else (0 + (if ((size(input) > 13))
2704-                                                            then (input[13] * weights[27][13])
2705-                                                            else (0 + (if ((size(input) > 14))
2706-                                                                then (input[14] * weights[27][14])
2707-                                                                else (0 + (if ((size(input) > 15))
2708-                                                                    then (input[15] * weights[27][15])
2709-                                                                    else (0 + (if ((size(input) > 16))
2710-                                                                        then (input[16] * weights[27][16])
2711-                                                                        else (0 + (if ((size(input) > 17))
2712-                                                                            then (input[17] * weights[27][17])
2713-                                                                            else (0 + (if ((size(input) > 18))
2714-                                                                                then (input[18] * weights[27][18])
2715-                                                                                else (0 + (if ((size(input) > 19))
2716-                                                                                    then (input[19] * weights[27][19])
2717-                                                                                    else (0 + (if ((size(input) > 20))
2718-                                                                                        then (input[20] * weights[27][20])
2719-                                                                                        else (0 + (if ((size(input) > 21))
2720-                                                                                            then (input[21] * weights[27][21])
2721-                                                                                            else (0 + (if ((size(input) > 22))
2722-                                                                                                then (input[22] * weights[27][22])
2723-                                                                                                else (0 + (if ((size(input) > 23))
2724-                                                                                                    then (input[23] * weights[27][23])
2725-                                                                                                    else (0 + (if ((size(input) > 24))
2726-                                                                                                        then (input[24] * weights[27][24])
2727-                                                                                                        else (0 + (if ((size(input) > 25))
2728-                                                                                                            then (input[25] * weights[27][25])
2729-                                                                                                            else (0 + (if ((size(input) > 26))
2730-                                                                                                                then (input[26] * weights[27][26])
2731-                                                                                                                else (0 + (if ((size(input) > 27))
2732-                                                                                                                    then (input[27] * weights[27][27])
2733-                                                                                                                    else (0 + (if ((size(input) > 28))
2734-                                                                                                                        then (input[28] * weights[27][28])
2735-                                                                                                                        else (0 + (if ((size(input) > 29))
2736-                                                                                                                            then (input[29] * weights[27][29])
2737-                                                                                                                            else (0 + (if ((size(input) > 30))
2738-                                                                                                                                then (input[30] * weights[27][30])
2739-                                                                                                                                else (0 + (if ((size(input) > 31))
2740-                                                                                                                                    then (input[31] * weights[27][31])
2741-                                                                                                                                    else (0 + (if ((size(input) > 32))
2742-                                                                                                                                        then (input[32] * weights[27][32])
2743-                                                                                                                                        else (0 + (if ((size(input) > 33))
2744-                                                                                                                                            then (input[33] * weights[27][33])
2745-                                                                                                                                            else (0 + (if ((size(input) > 34))
2746-                                                                                                                                                then (input[34] * weights[27][34])
2747-                                                                                                                                                else (0 + (if ((size(input) > 35))
2748-                                                                                                                                                    then (input[35] * weights[27][35])
2749-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[27])
2750-    let weighted_sum29 = (((if ((size(input) > 0))
2751-        then (input[0] * weights[28][0])
2752-        else (0 + (if ((size(input) > 1))
2753-            then (input[1] * weights[28][1])
2754-            else (0 + (if ((size(input) > 2))
2755-                then (input[2] * weights[28][2])
2756-                else (0 + (if ((size(input) > 3))
2757-                    then (input[3] * weights[28][3])
2758-                    else (0 + (if ((size(input) > 4))
2759-                        then (input[4] * weights[28][4])
2760-                        else (0 + (if ((size(input) > 5))
2761-                            then (input[5] * weights[28][5])
2762-                            else (0 + (if ((size(input) > 6))
2763-                                then (input[6] * weights[28][6])
2764-                                else (0 + (if ((size(input) > 7))
2765-                                    then (input[7] * weights[28][7])
2766-                                    else (0 + (if ((size(input) > 8))
2767-                                        then (input[8] * weights[28][8])
2768-                                        else (0 + (if ((size(input) > 9))
2769-                                            then (input[9] * weights[28][9])
2770-                                            else (0 + (if ((size(input) > 10))
2771-                                                then (input[10] * weights[28][10])
2772-                                                else (0 + (if ((size(input) > 11))
2773-                                                    then (input[11] * weights[28][11])
2774-                                                    else (0 + (if ((size(input) > 12))
2775-                                                        then (input[12] * weights[28][12])
2776-                                                        else (0 + (if ((size(input) > 13))
2777-                                                            then (input[13] * weights[28][13])
2778-                                                            else (0 + (if ((size(input) > 14))
2779-                                                                then (input[14] * weights[28][14])
2780-                                                                else (0 + (if ((size(input) > 15))
2781-                                                                    then (input[15] * weights[28][15])
2782-                                                                    else (0 + (if ((size(input) > 16))
2783-                                                                        then (input[16] * weights[28][16])
2784-                                                                        else (0 + (if ((size(input) > 17))
2785-                                                                            then (input[17] * weights[28][17])
2786-                                                                            else (0 + (if ((size(input) > 18))
2787-                                                                                then (input[18] * weights[28][18])
2788-                                                                                else (0 + (if ((size(input) > 19))
2789-                                                                                    then (input[19] * weights[28][19])
2790-                                                                                    else (0 + (if ((size(input) > 20))
2791-                                                                                        then (input[20] * weights[28][20])
2792-                                                                                        else (0 + (if ((size(input) > 21))
2793-                                                                                            then (input[21] * weights[28][21])
2794-                                                                                            else (0 + (if ((size(input) > 22))
2795-                                                                                                then (input[22] * weights[28][22])
2796-                                                                                                else (0 + (if ((size(input) > 23))
2797-                                                                                                    then (input[23] * weights[28][23])
2798-                                                                                                    else (0 + (if ((size(input) > 24))
2799-                                                                                                        then (input[24] * weights[28][24])
2800-                                                                                                        else (0 + (if ((size(input) > 25))
2801-                                                                                                            then (input[25] * weights[28][25])
2802-                                                                                                            else (0 + (if ((size(input) > 26))
2803-                                                                                                                then (input[26] * weights[28][26])
2804-                                                                                                                else (0 + (if ((size(input) > 27))
2805-                                                                                                                    then (input[27] * weights[28][27])
2806-                                                                                                                    else (0 + (if ((size(input) > 28))
2807-                                                                                                                        then (input[28] * weights[28][28])
2808-                                                                                                                        else (0 + (if ((size(input) > 29))
2809-                                                                                                                            then (input[29] * weights[28][29])
2810-                                                                                                                            else (0 + (if ((size(input) > 30))
2811-                                                                                                                                then (input[30] * weights[28][30])
2812-                                                                                                                                else (0 + (if ((size(input) > 31))
2813-                                                                                                                                    then (input[31] * weights[28][31])
2814-                                                                                                                                    else (0 + (if ((size(input) > 32))
2815-                                                                                                                                        then (input[32] * weights[28][32])
2816-                                                                                                                                        else (0 + (if ((size(input) > 33))
2817-                                                                                                                                            then (input[33] * weights[28][33])
2818-                                                                                                                                            else (0 + (if ((size(input) > 34))
2819-                                                                                                                                                then (input[34] * weights[28][34])
2820-                                                                                                                                                else (0 + (if ((size(input) > 35))
2821-                                                                                                                                                    then (input[35] * weights[28][35])
2822-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[28])
2823-    let weighted_sum30 = (((if ((size(input) > 0))
2824-        then (input[0] * weights[29][0])
2825-        else (0 + (if ((size(input) > 1))
2826-            then (input[1] * weights[29][1])
2827-            else (0 + (if ((size(input) > 2))
2828-                then (input[2] * weights[29][2])
2829-                else (0 + (if ((size(input) > 3))
2830-                    then (input[3] * weights[29][3])
2831-                    else (0 + (if ((size(input) > 4))
2832-                        then (input[4] * weights[29][4])
2833-                        else (0 + (if ((size(input) > 5))
2834-                            then (input[5] * weights[29][5])
2835-                            else (0 + (if ((size(input) > 6))
2836-                                then (input[6] * weights[29][6])
2837-                                else (0 + (if ((size(input) > 7))
2838-                                    then (input[7] * weights[29][7])
2839-                                    else (0 + (if ((size(input) > 8))
2840-                                        then (input[8] * weights[29][8])
2841-                                        else (0 + (if ((size(input) > 9))
2842-                                            then (input[9] * weights[29][9])
2843-                                            else (0 + (if ((size(input) > 10))
2844-                                                then (input[10] * weights[29][10])
2845-                                                else (0 + (if ((size(input) > 11))
2846-                                                    then (input[11] * weights[29][11])
2847-                                                    else (0 + (if ((size(input) > 12))
2848-                                                        then (input[12] * weights[29][12])
2849-                                                        else (0 + (if ((size(input) > 13))
2850-                                                            then (input[13] * weights[29][13])
2851-                                                            else (0 + (if ((size(input) > 14))
2852-                                                                then (input[14] * weights[29][14])
2853-                                                                else (0 + (if ((size(input) > 15))
2854-                                                                    then (input[15] * weights[29][15])
2855-                                                                    else (0 + (if ((size(input) > 16))
2856-                                                                        then (input[16] * weights[29][16])
2857-                                                                        else (0 + (if ((size(input) > 17))
2858-                                                                            then (input[17] * weights[29][17])
2859-                                                                            else (0 + (if ((size(input) > 18))
2860-                                                                                then (input[18] * weights[29][18])
2861-                                                                                else (0 + (if ((size(input) > 19))
2862-                                                                                    then (input[19] * weights[29][19])
2863-                                                                                    else (0 + (if ((size(input) > 20))
2864-                                                                                        then (input[20] * weights[29][20])
2865-                                                                                        else (0 + (if ((size(input) > 21))
2866-                                                                                            then (input[21] * weights[29][21])
2867-                                                                                            else (0 + (if ((size(input) > 22))
2868-                                                                                                then (input[22] * weights[29][22])
2869-                                                                                                else (0 + (if ((size(input) > 23))
2870-                                                                                                    then (input[23] * weights[29][23])
2871-                                                                                                    else (0 + (if ((size(input) > 24))
2872-                                                                                                        then (input[24] * weights[29][24])
2873-                                                                                                        else (0 + (if ((size(input) > 25))
2874-                                                                                                            then (input[25] * weights[29][25])
2875-                                                                                                            else (0 + (if ((size(input) > 26))
2876-                                                                                                                then (input[26] * weights[29][26])
2877-                                                                                                                else (0 + (if ((size(input) > 27))
2878-                                                                                                                    then (input[27] * weights[29][27])
2879-                                                                                                                    else (0 + (if ((size(input) > 28))
2880-                                                                                                                        then (input[28] * weights[29][28])
2881-                                                                                                                        else (0 + (if ((size(input) > 29))
2882-                                                                                                                            then (input[29] * weights[29][29])
2883-                                                                                                                            else (0 + (if ((size(input) > 30))
2884-                                                                                                                                then (input[30] * weights[29][30])
2885-                                                                                                                                else (0 + (if ((size(input) > 31))
2886-                                                                                                                                    then (input[31] * weights[29][31])
2887-                                                                                                                                    else (0 + (if ((size(input) > 32))
2888-                                                                                                                                        then (input[32] * weights[29][32])
2889-                                                                                                                                        else (0 + (if ((size(input) > 33))
2890-                                                                                                                                            then (input[33] * weights[29][33])
2891-                                                                                                                                            else (0 + (if ((size(input) > 34))
2892-                                                                                                                                                then (input[34] * weights[29][34])
2893-                                                                                                                                                else (0 + (if ((size(input) > 35))
2894-                                                                                                                                                    then (input[35] * weights[29][35])
2895-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[29])
2896-    let weighted_sum31 = (((if ((size(input) > 0))
2897-        then (input[0] * weights[30][0])
2898-        else (0 + (if ((size(input) > 1))
2899-            then (input[1] * weights[30][1])
2900-            else (0 + (if ((size(input) > 2))
2901-                then (input[2] * weights[30][2])
2902-                else (0 + (if ((size(input) > 3))
2903-                    then (input[3] * weights[30][3])
2904-                    else (0 + (if ((size(input) > 4))
2905-                        then (input[4] * weights[30][4])
2906-                        else (0 + (if ((size(input) > 5))
2907-                            then (input[5] * weights[30][5])
2908-                            else (0 + (if ((size(input) > 6))
2909-                                then (input[6] * weights[30][6])
2910-                                else (0 + (if ((size(input) > 7))
2911-                                    then (input[7] * weights[30][7])
2912-                                    else (0 + (if ((size(input) > 8))
2913-                                        then (input[8] * weights[30][8])
2914-                                        else (0 + (if ((size(input) > 9))
2915-                                            then (input[9] * weights[30][9])
2916-                                            else (0 + (if ((size(input) > 10))
2917-                                                then (input[10] * weights[30][10])
2918-                                                else (0 + (if ((size(input) > 11))
2919-                                                    then (input[11] * weights[30][11])
2920-                                                    else (0 + (if ((size(input) > 12))
2921-                                                        then (input[12] * weights[30][12])
2922-                                                        else (0 + (if ((size(input) > 13))
2923-                                                            then (input[13] * weights[30][13])
2924-                                                            else (0 + (if ((size(input) > 14))
2925-                                                                then (input[14] * weights[30][14])
2926-                                                                else (0 + (if ((size(input) > 15))
2927-                                                                    then (input[15] * weights[30][15])
2928-                                                                    else (0 + (if ((size(input) > 16))
2929-                                                                        then (input[16] * weights[30][16])
2930-                                                                        else (0 + (if ((size(input) > 17))
2931-                                                                            then (input[17] * weights[30][17])
2932-                                                                            else (0 + (if ((size(input) > 18))
2933-                                                                                then (input[18] * weights[30][18])
2934-                                                                                else (0 + (if ((size(input) > 19))
2935-                                                                                    then (input[19] * weights[30][19])
2936-                                                                                    else (0 + (if ((size(input) > 20))
2937-                                                                                        then (input[20] * weights[30][20])
2938-                                                                                        else (0 + (if ((size(input) > 21))
2939-                                                                                            then (input[21] * weights[30][21])
2940-                                                                                            else (0 + (if ((size(input) > 22))
2941-                                                                                                then (input[22] * weights[30][22])
2942-                                                                                                else (0 + (if ((size(input) > 23))
2943-                                                                                                    then (input[23] * weights[30][23])
2944-                                                                                                    else (0 + (if ((size(input) > 24))
2945-                                                                                                        then (input[24] * weights[30][24])
2946-                                                                                                        else (0 + (if ((size(input) > 25))
2947-                                                                                                            then (input[25] * weights[30][25])
2948-                                                                                                            else (0 + (if ((size(input) > 26))
2949-                                                                                                                then (input[26] * weights[30][26])
2950-                                                                                                                else (0 + (if ((size(input) > 27))
2951-                                                                                                                    then (input[27] * weights[30][27])
2952-                                                                                                                    else (0 + (if ((size(input) > 28))
2953-                                                                                                                        then (input[28] * weights[30][28])
2954-                                                                                                                        else (0 + (if ((size(input) > 29))
2955-                                                                                                                            then (input[29] * weights[30][29])
2956-                                                                                                                            else (0 + (if ((size(input) > 30))
2957-                                                                                                                                then (input[30] * weights[30][30])
2958-                                                                                                                                else (0 + (if ((size(input) > 31))
2959-                                                                                                                                    then (input[31] * weights[30][31])
2960-                                                                                                                                    else (0 + (if ((size(input) > 32))
2961-                                                                                                                                        then (input[32] * weights[30][32])
2962-                                                                                                                                        else (0 + (if ((size(input) > 33))
2963-                                                                                                                                            then (input[33] * weights[30][33])
2964-                                                                                                                                            else (0 + (if ((size(input) > 34))
2965-                                                                                                                                                then (input[34] * weights[30][34])
2966-                                                                                                                                                else (0 + (if ((size(input) > 35))
2967-                                                                                                                                                    then (input[35] * weights[30][35])
2968-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[30])
2969-    let weighted_sum32 = (((if ((size(input) > 0))
2970-        then (input[0] * weights[31][0])
2971-        else (0 + (if ((size(input) > 1))
2972-            then (input[1] * weights[31][1])
2973-            else (0 + (if ((size(input) > 2))
2974-                then (input[2] * weights[31][2])
2975-                else (0 + (if ((size(input) > 3))
2976-                    then (input[3] * weights[31][3])
2977-                    else (0 + (if ((size(input) > 4))
2978-                        then (input[4] * weights[31][4])
2979-                        else (0 + (if ((size(input) > 5))
2980-                            then (input[5] * weights[31][5])
2981-                            else (0 + (if ((size(input) > 6))
2982-                                then (input[6] * weights[31][6])
2983-                                else (0 + (if ((size(input) > 7))
2984-                                    then (input[7] * weights[31][7])
2985-                                    else (0 + (if ((size(input) > 8))
2986-                                        then (input[8] * weights[31][8])
2987-                                        else (0 + (if ((size(input) > 9))
2988-                                            then (input[9] * weights[31][9])
2989-                                            else (0 + (if ((size(input) > 10))
2990-                                                then (input[10] * weights[31][10])
2991-                                                else (0 + (if ((size(input) > 11))
2992-                                                    then (input[11] * weights[31][11])
2993-                                                    else (0 + (if ((size(input) > 12))
2994-                                                        then (input[12] * weights[31][12])
2995-                                                        else (0 + (if ((size(input) > 13))
2996-                                                            then (input[13] * weights[31][13])
2997-                                                            else (0 + (if ((size(input) > 14))
2998-                                                                then (input[14] * weights[31][14])
2999-                                                                else (0 + (if ((size(input) > 15))
3000-                                                                    then (input[15] * weights[31][15])
3001-                                                                    else (0 + (if ((size(input) > 16))
3002-                                                                        then (input[16] * weights[31][16])
3003-                                                                        else (0 + (if ((size(input) > 17))
3004-                                                                            then (input[17] * weights[31][17])
3005-                                                                            else (0 + (if ((size(input) > 18))
3006-                                                                                then (input[18] * weights[31][18])
3007-                                                                                else (0 + (if ((size(input) > 19))
3008-                                                                                    then (input[19] * weights[31][19])
3009-                                                                                    else (0 + (if ((size(input) > 20))
3010-                                                                                        then (input[20] * weights[31][20])
3011-                                                                                        else (0 + (if ((size(input) > 21))
3012-                                                                                            then (input[21] * weights[31][21])
3013-                                                                                            else (0 + (if ((size(input) > 22))
3014-                                                                                                then (input[22] * weights[31][22])
3015-                                                                                                else (0 + (if ((size(input) > 23))
3016-                                                                                                    then (input[23] * weights[31][23])
3017-                                                                                                    else (0 + (if ((size(input) > 24))
3018-                                                                                                        then (input[24] * weights[31][24])
3019-                                                                                                        else (0 + (if ((size(input) > 25))
3020-                                                                                                            then (input[25] * weights[31][25])
3021-                                                                                                            else (0 + (if ((size(input) > 26))
3022-                                                                                                                then (input[26] * weights[31][26])
3023-                                                                                                                else (0 + (if ((size(input) > 27))
3024-                                                                                                                    then (input[27] * weights[31][27])
3025-                                                                                                                    else (0 + (if ((size(input) > 28))
3026-                                                                                                                        then (input[28] * weights[31][28])
3027-                                                                                                                        else (0 + (if ((size(input) > 29))
3028-                                                                                                                            then (input[29] * weights[31][29])
3029-                                                                                                                            else (0 + (if ((size(input) > 30))
3030-                                                                                                                                then (input[30] * weights[31][30])
3031-                                                                                                                                else (0 + (if ((size(input) > 31))
3032-                                                                                                                                    then (input[31] * weights[31][31])
3033-                                                                                                                                    else (0 + (if ((size(input) > 32))
3034-                                                                                                                                        then (input[32] * weights[31][32])
3035-                                                                                                                                        else (0 + (if ((size(input) > 33))
3036-                                                                                                                                            then (input[33] * weights[31][33])
3037-                                                                                                                                            else (0 + (if ((size(input) > 34))
3038-                                                                                                                                                then (input[34] * weights[31][34])
3039-                                                                                                                                                else (0 + (if ((size(input) > 35))
3040-                                                                                                                                                    then (input[35] * weights[31][35])
3041-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[31])
3042-    let weighted_sum33 = (((if ((size(input) > 0))
3043-        then (input[0] * weights[32][0])
3044-        else (0 + (if ((size(input) > 1))
3045-            then (input[1] * weights[32][1])
3046-            else (0 + (if ((size(input) > 2))
3047-                then (input[2] * weights[32][2])
3048-                else (0 + (if ((size(input) > 3))
3049-                    then (input[3] * weights[32][3])
3050-                    else (0 + (if ((size(input) > 4))
3051-                        then (input[4] * weights[32][4])
3052-                        else (0 + (if ((size(input) > 5))
3053-                            then (input[5] * weights[32][5])
3054-                            else (0 + (if ((size(input) > 6))
3055-                                then (input[6] * weights[32][6])
3056-                                else (0 + (if ((size(input) > 7))
3057-                                    then (input[7] * weights[32][7])
3058-                                    else (0 + (if ((size(input) > 8))
3059-                                        then (input[8] * weights[32][8])
3060-                                        else (0 + (if ((size(input) > 9))
3061-                                            then (input[9] * weights[32][9])
3062-                                            else (0 + (if ((size(input) > 10))
3063-                                                then (input[10] * weights[32][10])
3064-                                                else (0 + (if ((size(input) > 11))
3065-                                                    then (input[11] * weights[32][11])
3066-                                                    else (0 + (if ((size(input) > 12))
3067-                                                        then (input[12] * weights[32][12])
3068-                                                        else (0 + (if ((size(input) > 13))
3069-                                                            then (input[13] * weights[32][13])
3070-                                                            else (0 + (if ((size(input) > 14))
3071-                                                                then (input[14] * weights[32][14])
3072-                                                                else (0 + (if ((size(input) > 15))
3073-                                                                    then (input[15] * weights[32][15])
3074-                                                                    else (0 + (if ((size(input) > 16))
3075-                                                                        then (input[16] * weights[32][16])
3076-                                                                        else (0 + (if ((size(input) > 17))
3077-                                                                            then (input[17] * weights[32][17])
3078-                                                                            else (0 + (if ((size(input) > 18))
3079-                                                                                then (input[18] * weights[32][18])
3080-                                                                                else (0 + (if ((size(input) > 19))
3081-                                                                                    then (input[19] * weights[32][19])
3082-                                                                                    else (0 + (if ((size(input) > 20))
3083-                                                                                        then (input[20] * weights[32][20])
3084-                                                                                        else (0 + (if ((size(input) > 21))
3085-                                                                                            then (input[21] * weights[32][21])
3086-                                                                                            else (0 + (if ((size(input) > 22))
3087-                                                                                                then (input[22] * weights[32][22])
3088-                                                                                                else (0 + (if ((size(input) > 23))
3089-                                                                                                    then (input[23] * weights[32][23])
3090-                                                                                                    else (0 + (if ((size(input) > 24))
3091-                                                                                                        then (input[24] * weights[32][24])
3092-                                                                                                        else (0 + (if ((size(input) > 25))
3093-                                                                                                            then (input[25] * weights[32][25])
3094-                                                                                                            else (0 + (if ((size(input) > 26))
3095-                                                                                                                then (input[26] * weights[32][26])
3096-                                                                                                                else (0 + (if ((size(input) > 27))
3097-                                                                                                                    then (input[27] * weights[32][27])
3098-                                                                                                                    else (0 + (if ((size(input) > 28))
3099-                                                                                                                        then (input[28] * weights[32][28])
3100-                                                                                                                        else (0 + (if ((size(input) > 29))
3101-                                                                                                                            then (input[29] * weights[32][29])
3102-                                                                                                                            else (0 + (if ((size(input) > 30))
3103-                                                                                                                                then (input[30] * weights[32][30])
3104-                                                                                                                                else (0 + (if ((size(input) > 31))
3105-                                                                                                                                    then (input[31] * weights[32][31])
3106-                                                                                                                                    else (0 + (if ((size(input) > 32))
3107-                                                                                                                                        then (input[32] * weights[32][32])
3108-                                                                                                                                        else (0 + (if ((size(input) > 33))
3109-                                                                                                                                            then (input[33] * weights[32][33])
3110-                                                                                                                                            else (0 + (if ((size(input) > 34))
3111-                                                                                                                                                then (input[34] * weights[32][34])
3112-                                                                                                                                                else (0 + (if ((size(input) > 35))
3113-                                                                                                                                                    then (input[35] * weights[32][35])
3114-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[32])
3115-    let weighted_sum34 = (((if ((size(input) > 0))
3116-        then (input[0] * weights[33][0])
3117-        else (0 + (if ((size(input) > 1))
3118-            then (input[1] * weights[33][1])
3119-            else (0 + (if ((size(input) > 2))
3120-                then (input[2] * weights[33][2])
3121-                else (0 + (if ((size(input) > 3))
3122-                    then (input[3] * weights[33][3])
3123-                    else (0 + (if ((size(input) > 4))
3124-                        then (input[4] * weights[33][4])
3125-                        else (0 + (if ((size(input) > 5))
3126-                            then (input[5] * weights[33][5])
3127-                            else (0 + (if ((size(input) > 6))
3128-                                then (input[6] * weights[33][6])
3129-                                else (0 + (if ((size(input) > 7))
3130-                                    then (input[7] * weights[33][7])
3131-                                    else (0 + (if ((size(input) > 8))
3132-                                        then (input[8] * weights[33][8])
3133-                                        else (0 + (if ((size(input) > 9))
3134-                                            then (input[9] * weights[33][9])
3135-                                            else (0 + (if ((size(input) > 10))
3136-                                                then (input[10] * weights[33][10])
3137-                                                else (0 + (if ((size(input) > 11))
3138-                                                    then (input[11] * weights[33][11])
3139-                                                    else (0 + (if ((size(input) > 12))
3140-                                                        then (input[12] * weights[33][12])
3141-                                                        else (0 + (if ((size(input) > 13))
3142-                                                            then (input[13] * weights[33][13])
3143-                                                            else (0 + (if ((size(input) > 14))
3144-                                                                then (input[14] * weights[33][14])
3145-                                                                else (0 + (if ((size(input) > 15))
3146-                                                                    then (input[15] * weights[33][15])
3147-                                                                    else (0 + (if ((size(input) > 16))
3148-                                                                        then (input[16] * weights[33][16])
3149-                                                                        else (0 + (if ((size(input) > 17))
3150-                                                                            then (input[17] * weights[33][17])
3151-                                                                            else (0 + (if ((size(input) > 18))
3152-                                                                                then (input[18] * weights[33][18])
3153-                                                                                else (0 + (if ((size(input) > 19))
3154-                                                                                    then (input[19] * weights[33][19])
3155-                                                                                    else (0 + (if ((size(input) > 20))
3156-                                                                                        then (input[20] * weights[33][20])
3157-                                                                                        else (0 + (if ((size(input) > 21))
3158-                                                                                            then (input[21] * weights[33][21])
3159-                                                                                            else (0 + (if ((size(input) > 22))
3160-                                                                                                then (input[22] * weights[33][22])
3161-                                                                                                else (0 + (if ((size(input) > 23))
3162-                                                                                                    then (input[23] * weights[33][23])
3163-                                                                                                    else (0 + (if ((size(input) > 24))
3164-                                                                                                        then (input[24] * weights[33][24])
3165-                                                                                                        else (0 + (if ((size(input) > 25))
3166-                                                                                                            then (input[25] * weights[33][25])
3167-                                                                                                            else (0 + (if ((size(input) > 26))
3168-                                                                                                                then (input[26] * weights[33][26])
3169-                                                                                                                else (0 + (if ((size(input) > 27))
3170-                                                                                                                    then (input[27] * weights[33][27])
3171-                                                                                                                    else (0 + (if ((size(input) > 28))
3172-                                                                                                                        then (input[28] * weights[33][28])
3173-                                                                                                                        else (0 + (if ((size(input) > 29))
3174-                                                                                                                            then (input[29] * weights[33][29])
3175-                                                                                                                            else (0 + (if ((size(input) > 30))
3176-                                                                                                                                then (input[30] * weights[33][30])
3177-                                                                                                                                else (0 + (if ((size(input) > 31))
3178-                                                                                                                                    then (input[31] * weights[33][31])
3179-                                                                                                                                    else (0 + (if ((size(input) > 32))
3180-                                                                                                                                        then (input[32] * weights[33][32])
3181-                                                                                                                                        else (0 + (if ((size(input) > 33))
3182-                                                                                                                                            then (input[33] * weights[33][33])
3183-                                                                                                                                            else (0 + (if ((size(input) > 34))
3184-                                                                                                                                                then (input[34] * weights[33][34])
3185-                                                                                                                                                else (0 + (if ((size(input) > 35))
3186-                                                                                                                                                    then (input[35] * weights[33][35])
3187-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[33])
3188-    let weighted_sum35 = (((if ((size(input) > 0))
3189-        then (input[0] * weights[34][0])
3190-        else (0 + (if ((size(input) > 1))
3191-            then (input[1] * weights[34][1])
3192-            else (0 + (if ((size(input) > 2))
3193-                then (input[2] * weights[34][2])
3194-                else (0 + (if ((size(input) > 3))
3195-                    then (input[3] * weights[34][3])
3196-                    else (0 + (if ((size(input) > 4))
3197-                        then (input[4] * weights[34][4])
3198-                        else (0 + (if ((size(input) > 5))
3199-                            then (input[5] * weights[34][5])
3200-                            else (0 + (if ((size(input) > 6))
3201-                                then (input[6] * weights[34][6])
3202-                                else (0 + (if ((size(input) > 7))
3203-                                    then (input[7] * weights[34][7])
3204-                                    else (0 + (if ((size(input) > 8))
3205-                                        then (input[8] * weights[34][8])
3206-                                        else (0 + (if ((size(input) > 9))
3207-                                            then (input[9] * weights[34][9])
3208-                                            else (0 + (if ((size(input) > 10))
3209-                                                then (input[10] * weights[34][10])
3210-                                                else (0 + (if ((size(input) > 11))
3211-                                                    then (input[11] * weights[34][11])
3212-                                                    else (0 + (if ((size(input) > 12))
3213-                                                        then (input[12] * weights[34][12])
3214-                                                        else (0 + (if ((size(input) > 13))
3215-                                                            then (input[13] * weights[34][13])
3216-                                                            else (0 + (if ((size(input) > 14))
3217-                                                                then (input[14] * weights[34][14])
3218-                                                                else (0 + (if ((size(input) > 15))
3219-                                                                    then (input[15] * weights[34][15])
3220-                                                                    else (0 + (if ((size(input) > 16))
3221-                                                                        then (input[16] * weights[34][16])
3222-                                                                        else (0 + (if ((size(input) > 17))
3223-                                                                            then (input[17] * weights[34][17])
3224-                                                                            else (0 + (if ((size(input) > 18))
3225-                                                                                then (input[18] * weights[34][18])
3226-                                                                                else (0 + (if ((size(input) > 19))
3227-                                                                                    then (input[19] * weights[34][19])
3228-                                                                                    else (0 + (if ((size(input) > 20))
3229-                                                                                        then (input[20] * weights[34][20])
3230-                                                                                        else (0 + (if ((size(input) > 21))
3231-                                                                                            then (input[21] * weights[34][21])
3232-                                                                                            else (0 + (if ((size(input) > 22))
3233-                                                                                                then (input[22] * weights[34][22])
3234-                                                                                                else (0 + (if ((size(input) > 23))
3235-                                                                                                    then (input[23] * weights[34][23])
3236-                                                                                                    else (0 + (if ((size(input) > 24))
3237-                                                                                                        then (input[24] * weights[34][24])
3238-                                                                                                        else (0 + (if ((size(input) > 25))
3239-                                                                                                            then (input[25] * weights[34][25])
3240-                                                                                                            else (0 + (if ((size(input) > 26))
3241-                                                                                                                then (input[26] * weights[34][26])
3242-                                                                                                                else (0 + (if ((size(input) > 27))
3243-                                                                                                                    then (input[27] * weights[34][27])
3244-                                                                                                                    else (0 + (if ((size(input) > 28))
3245-                                                                                                                        then (input[28] * weights[34][28])
3246-                                                                                                                        else (0 + (if ((size(input) > 29))
3247-                                                                                                                            then (input[29] * weights[34][29])
3248-                                                                                                                            else (0 + (if ((size(input) > 30))
3249-                                                                                                                                then (input[30] * weights[34][30])
3250-                                                                                                                                else (0 + (if ((size(input) > 31))
3251-                                                                                                                                    then (input[31] * weights[34][31])
3252-                                                                                                                                    else (0 + (if ((size(input) > 32))
3253-                                                                                                                                        then (input[32] * weights[34][32])
3254-                                                                                                                                        else (0 + (if ((size(input) > 33))
3255-                                                                                                                                            then (input[33] * weights[34][33])
3256-                                                                                                                                            else (0 + (if ((size(input) > 34))
3257-                                                                                                                                                then (input[34] * weights[34][34])
3258-                                                                                                                                                else (0 + (if ((size(input) > 35))
3259-                                                                                                                                                    then (input[35] * weights[34][35])
3260-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[34])
3261-    let weighted_sum36 = (((if ((size(input) > 0))
3262-        then (input[0] * weights[35][0])
3263-        else (0 + (if ((size(input) > 1))
3264-            then (input[1] * weights[35][1])
3265-            else (0 + (if ((size(input) > 2))
3266-                then (input[2] * weights[35][2])
3267-                else (0 + (if ((size(input) > 3))
3268-                    then (input[3] * weights[35][3])
3269-                    else (0 + (if ((size(input) > 4))
3270-                        then (input[4] * weights[35][4])
3271-                        else (0 + (if ((size(input) > 5))
3272-                            then (input[5] * weights[35][5])
3273-                            else (0 + (if ((size(input) > 6))
3274-                                then (input[6] * weights[35][6])
3275-                                else (0 + (if ((size(input) > 7))
3276-                                    then (input[7] * weights[35][7])
3277-                                    else (0 + (if ((size(input) > 8))
3278-                                        then (input[8] * weights[35][8])
3279-                                        else (0 + (if ((size(input) > 9))
3280-                                            then (input[9] * weights[35][9])
3281-                                            else (0 + (if ((size(input) > 10))
3282-                                                then (input[10] * weights[35][10])
3283-                                                else (0 + (if ((size(input) > 11))
3284-                                                    then (input[11] * weights[35][11])
3285-                                                    else (0 + (if ((size(input) > 12))
3286-                                                        then (input[12] * weights[35][12])
3287-                                                        else (0 + (if ((size(input) > 13))
3288-                                                            then (input[13] * weights[35][13])
3289-                                                            else (0 + (if ((size(input) > 14))
3290-                                                                then (input[14] * weights[35][14])
3291-                                                                else (0 + (if ((size(input) > 15))
3292-                                                                    then (input[15] * weights[35][15])
3293-                                                                    else (0 + (if ((size(input) > 16))
3294-                                                                        then (input[16] * weights[35][16])
3295-                                                                        else (0 + (if ((size(input) > 17))
3296-                                                                            then (input[17] * weights[35][17])
3297-                                                                            else (0 + (if ((size(input) > 18))
3298-                                                                                then (input[18] * weights[35][18])
3299-                                                                                else (0 + (if ((size(input) > 19))
3300-                                                                                    then (input[19] * weights[35][19])
3301-                                                                                    else (0 + (if ((size(input) > 20))
3302-                                                                                        then (input[20] * weights[35][20])
3303-                                                                                        else (0 + (if ((size(input) > 21))
3304-                                                                                            then (input[21] * weights[35][21])
3305-                                                                                            else (0 + (if ((size(input) > 22))
3306-                                                                                                then (input[22] * weights[35][22])
3307-                                                                                                else (0 + (if ((size(input) > 23))
3308-                                                                                                    then (input[23] * weights[35][23])
3309-                                                                                                    else (0 + (if ((size(input) > 24))
3310-                                                                                                        then (input[24] * weights[35][24])
3311-                                                                                                        else (0 + (if ((size(input) > 25))
3312-                                                                                                            then (input[25] * weights[35][25])
3313-                                                                                                            else (0 + (if ((size(input) > 26))
3314-                                                                                                                then (input[26] * weights[35][26])
3315-                                                                                                                else (0 + (if ((size(input) > 27))
3316-                                                                                                                    then (input[27] * weights[35][27])
3317-                                                                                                                    else (0 + (if ((size(input) > 28))
3318-                                                                                                                        then (input[28] * weights[35][28])
3319-                                                                                                                        else (0 + (if ((size(input) > 29))
3320-                                                                                                                            then (input[29] * weights[35][29])
3321-                                                                                                                            else (0 + (if ((size(input) > 30))
3322-                                                                                                                                then (input[30] * weights[35][30])
3323-                                                                                                                                else (0 + (if ((size(input) > 31))
3324-                                                                                                                                    then (input[31] * weights[35][31])
3325-                                                                                                                                    else (0 + (if ((size(input) > 32))
3326-                                                                                                                                        then (input[32] * weights[35][32])
3327-                                                                                                                                        else (0 + (if ((size(input) > 33))
3328-                                                                                                                                            then (input[33] * weights[35][33])
3329-                                                                                                                                            else (0 + (if ((size(input) > 34))
3330-                                                                                                                                                then (input[34] * weights[35][34])
3331-                                                                                                                                                else (0 + (if ((size(input) > 35))
3332-                                                                                                                                                    then (input[35] * weights[35][35])
3333-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[35])
3334-[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9, weighted_sum10, weighted_sum11, weighted_sum12, weighted_sum13, weighted_sum14, weighted_sum15, weighted_sum16, weighted_sum17, weighted_sum18, weighted_sum19, weighted_sum20, weighted_sum21, weighted_sum22, weighted_sum23, weighted_sum24, weighted_sum25, weighted_sum26, weighted_sum27, weighted_sum28, weighted_sum29, weighted_sum30, weighted_sum31, weighted_sum32, weighted_sum33, weighted_sum34, weighted_sum35, weighted_sum36]
20+    let weighted_sum1 = ((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) / 10000) + biases[0])
21+[weighted_sum1]
333522     }
3336-
3337-
3338-func linear_forward_3 (input,weights,biases) = {
3339-    let weighted_sum1 = (((if ((size(input) > 0))
3340-        then (input[0] * weights[0][0])
3341-        else (0 + (if ((size(input) > 1))
3342-            then (input[1] * weights[0][1])
3343-            else (0 + (if ((size(input) > 2))
3344-                then (input[2] * weights[0][2])
3345-                else (0 + (if ((size(input) > 3))
3346-                    then (input[3] * weights[0][3])
3347-                    else (0 + (if ((size(input) > 4))
3348-                        then (input[4] * weights[0][4])
3349-                        else (0 + (if ((size(input) > 5))
3350-                            then (input[5] * weights[0][5])
3351-                            else (0 + (if ((size(input) > 6))
3352-                                then (input[6] * weights[0][6])
3353-                                else (0 + (if ((size(input) > 7))
3354-                                    then (input[7] * weights[0][7])
3355-                                    else (0 + (if ((size(input) > 8))
3356-                                        then (input[8] * weights[0][8])
3357-                                        else (0 + (if ((size(input) > 9))
3358-                                            then (input[9] * weights[0][9])
3359-                                            else (0 + (if ((size(input) > 10))
3360-                                                then (input[10] * weights[0][10])
3361-                                                else (0 + (if ((size(input) > 11))
3362-                                                    then (input[11] * weights[0][11])
3363-                                                    else (0 + (if ((size(input) > 12))
3364-                                                        then (input[12] * weights[0][12])
3365-                                                        else (0 + (if ((size(input) > 13))
3366-                                                            then (input[13] * weights[0][13])
3367-                                                            else (0 + (if ((size(input) > 14))
3368-                                                                then (input[14] * weights[0][14])
3369-                                                                else (0 + (if ((size(input) > 15))
3370-                                                                    then (input[15] * weights[0][15])
3371-                                                                    else (0 + (if ((size(input) > 16))
3372-                                                                        then (input[16] * weights[0][16])
3373-                                                                        else (0 + (if ((size(input) > 17))
3374-                                                                            then (input[17] * weights[0][17])
3375-                                                                            else (0 + (if ((size(input) > 18))
3376-                                                                                then (input[18] * weights[0][18])
3377-                                                                                else (0 + (if ((size(input) > 19))
3378-                                                                                    then (input[19] * weights[0][19])
3379-                                                                                    else (0 + (if ((size(input) > 20))
3380-                                                                                        then (input[20] * weights[0][20])
3381-                                                                                        else (0 + (if ((size(input) > 21))
3382-                                                                                            then (input[21] * weights[0][21])
3383-                                                                                            else (0 + (if ((size(input) > 22))
3384-                                                                                                then (input[22] * weights[0][22])
3385-                                                                                                else (0 + (if ((size(input) > 23))
3386-                                                                                                    then (input[23] * weights[0][23])
3387-                                                                                                    else (0 + (if ((size(input) > 24))
3388-                                                                                                        then (input[24] * weights[0][24])
3389-                                                                                                        else (0 + (if ((size(input) > 25))
3390-                                                                                                            then (input[25] * weights[0][25])
3391-                                                                                                            else (0 + (if ((size(input) > 26))
3392-                                                                                                                then (input[26] * weights[0][26])
3393-                                                                                                                else (0 + (if ((size(input) > 27))
3394-                                                                                                                    then (input[27] * weights[0][27])
3395-                                                                                                                    else (0 + (if ((size(input) > 28))
3396-                                                                                                                        then (input[28] * weights[0][28])
3397-                                                                                                                        else (0 + (if ((size(input) > 29))
3398-                                                                                                                            then (input[29] * weights[0][29])
3399-                                                                                                                            else (0 + (if ((size(input) > 30))
3400-                                                                                                                                then (input[30] * weights[0][30])
3401-                                                                                                                                else (0 + (if ((size(input) > 31))
3402-                                                                                                                                    then (input[31] * weights[0][31])
3403-                                                                                                                                    else (0 + (if ((size(input) > 32))
3404-                                                                                                                                        then (input[32] * weights[0][32])
3405-                                                                                                                                        else (0 + (if ((size(input) > 33))
3406-                                                                                                                                            then (input[33] * weights[0][33])
3407-                                                                                                                                            else (0 + (if ((size(input) > 34))
3408-                                                                                                                                                then (input[34] * weights[0][34])
3409-                                                                                                                                                else (0 + (if ((size(input) > 35))
3410-                                                                                                                                                    then (input[35] * weights[0][35])
3411-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[0])
3412-    let weighted_sum2 = (((if ((size(input) > 0))
3413-        then (input[0] * weights[1][0])
3414-        else (0 + (if ((size(input) > 1))
3415-            then (input[1] * weights[1][1])
3416-            else (0 + (if ((size(input) > 2))
3417-                then (input[2] * weights[1][2])
3418-                else (0 + (if ((size(input) > 3))
3419-                    then (input[3] * weights[1][3])
3420-                    else (0 + (if ((size(input) > 4))
3421-                        then (input[4] * weights[1][4])
3422-                        else (0 + (if ((size(input) > 5))
3423-                            then (input[5] * weights[1][5])
3424-                            else (0 + (if ((size(input) > 6))
3425-                                then (input[6] * weights[1][6])
3426-                                else (0 + (if ((size(input) > 7))
3427-                                    then (input[7] * weights[1][7])
3428-                                    else (0 + (if ((size(input) > 8))
3429-                                        then (input[8] * weights[1][8])
3430-                                        else (0 + (if ((size(input) > 9))
3431-                                            then (input[9] * weights[1][9])
3432-                                            else (0 + (if ((size(input) > 10))
3433-                                                then (input[10] * weights[1][10])
3434-                                                else (0 + (if ((size(input) > 11))
3435-                                                    then (input[11] * weights[1][11])
3436-                                                    else (0 + (if ((size(input) > 12))
3437-                                                        then (input[12] * weights[1][12])
3438-                                                        else (0 + (if ((size(input) > 13))
3439-                                                            then (input[13] * weights[1][13])
3440-                                                            else (0 + (if ((size(input) > 14))
3441-                                                                then (input[14] * weights[1][14])
3442-                                                                else (0 + (if ((size(input) > 15))
3443-                                                                    then (input[15] * weights[1][15])
3444-                                                                    else (0 + (if ((size(input) > 16))
3445-                                                                        then (input[16] * weights[1][16])
3446-                                                                        else (0 + (if ((size(input) > 17))
3447-                                                                            then (input[17] * weights[1][17])
3448-                                                                            else (0 + (if ((size(input) > 18))
3449-                                                                                then (input[18] * weights[1][18])
3450-                                                                                else (0 + (if ((size(input) > 19))
3451-                                                                                    then (input[19] * weights[1][19])
3452-                                                                                    else (0 + (if ((size(input) > 20))
3453-                                                                                        then (input[20] * weights[1][20])
3454-                                                                                        else (0 + (if ((size(input) > 21))
3455-                                                                                            then (input[21] * weights[1][21])
3456-                                                                                            else (0 + (if ((size(input) > 22))
3457-                                                                                                then (input[22] * weights[1][22])
3458-                                                                                                else (0 + (if ((size(input) > 23))
3459-                                                                                                    then (input[23] * weights[1][23])
3460-                                                                                                    else (0 + (if ((size(input) > 24))
3461-                                                                                                        then (input[24] * weights[1][24])
3462-                                                                                                        else (0 + (if ((size(input) > 25))
3463-                                                                                                            then (input[25] * weights[1][25])
3464-                                                                                                            else (0 + (if ((size(input) > 26))
3465-                                                                                                                then (input[26] * weights[1][26])
3466-                                                                                                                else (0 + (if ((size(input) > 27))
3467-                                                                                                                    then (input[27] * weights[1][27])
3468-                                                                                                                    else (0 + (if ((size(input) > 28))
3469-                                                                                                                        then (input[28] * weights[1][28])
3470-                                                                                                                        else (0 + (if ((size(input) > 29))
3471-                                                                                                                            then (input[29] * weights[1][29])
3472-                                                                                                                            else (0 + (if ((size(input) > 30))
3473-                                                                                                                                then (input[30] * weights[1][30])
3474-                                                                                                                                else (0 + (if ((size(input) > 31))
3475-                                                                                                                                    then (input[31] * weights[1][31])
3476-                                                                                                                                    else (0 + (if ((size(input) > 32))
3477-                                                                                                                                        then (input[32] * weights[1][32])
3478-                                                                                                                                        else (0 + (if ((size(input) > 33))
3479-                                                                                                                                            then (input[33] * weights[1][33])
3480-                                                                                                                                            else (0 + (if ((size(input) > 34))
3481-                                                                                                                                                then (input[34] * weights[1][34])
3482-                                                                                                                                                else (0 + (if ((size(input) > 35))
3483-                                                                                                                                                    then (input[35] * weights[1][35])
3484-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[1])
3485-    let weighted_sum3 = (((if ((size(input) > 0))
3486-        then (input[0] * weights[2][0])
3487-        else (0 + (if ((size(input) > 1))
3488-            then (input[1] * weights[2][1])
3489-            else (0 + (if ((size(input) > 2))
3490-                then (input[2] * weights[2][2])
3491-                else (0 + (if ((size(input) > 3))
3492-                    then (input[3] * weights[2][3])
3493-                    else (0 + (if ((size(input) > 4))
3494-                        then (input[4] * weights[2][4])
3495-                        else (0 + (if ((size(input) > 5))
3496-                            then (input[5] * weights[2][5])
3497-                            else (0 + (if ((size(input) > 6))
3498-                                then (input[6] * weights[2][6])
3499-                                else (0 + (if ((size(input) > 7))
3500-                                    then (input[7] * weights[2][7])
3501-                                    else (0 + (if ((size(input) > 8))
3502-                                        then (input[8] * weights[2][8])
3503-                                        else (0 + (if ((size(input) > 9))
3504-                                            then (input[9] * weights[2][9])
3505-                                            else (0 + (if ((size(input) > 10))
3506-                                                then (input[10] * weights[2][10])
3507-                                                else (0 + (if ((size(input) > 11))
3508-                                                    then (input[11] * weights[2][11])
3509-                                                    else (0 + (if ((size(input) > 12))
3510-                                                        then (input[12] * weights[2][12])
3511-                                                        else (0 + (if ((size(input) > 13))
3512-                                                            then (input[13] * weights[2][13])
3513-                                                            else (0 + (if ((size(input) > 14))
3514-                                                                then (input[14] * weights[2][14])
3515-                                                                else (0 + (if ((size(input) > 15))
3516-                                                                    then (input[15] * weights[2][15])
3517-                                                                    else (0 + (if ((size(input) > 16))
3518-                                                                        then (input[16] * weights[2][16])
3519-                                                                        else (0 + (if ((size(input) > 17))
3520-                                                                            then (input[17] * weights[2][17])
3521-                                                                            else (0 + (if ((size(input) > 18))
3522-                                                                                then (input[18] * weights[2][18])
3523-                                                                                else (0 + (if ((size(input) > 19))
3524-                                                                                    then (input[19] * weights[2][19])
3525-                                                                                    else (0 + (if ((size(input) > 20))
3526-                                                                                        then (input[20] * weights[2][20])
3527-                                                                                        else (0 + (if ((size(input) > 21))
3528-                                                                                            then (input[21] * weights[2][21])
3529-                                                                                            else (0 + (if ((size(input) > 22))
3530-                                                                                                then (input[22] * weights[2][22])
3531-                                                                                                else (0 + (if ((size(input) > 23))
3532-                                                                                                    then (input[23] * weights[2][23])
3533-                                                                                                    else (0 + (if ((size(input) > 24))
3534-                                                                                                        then (input[24] * weights[2][24])
3535-                                                                                                        else (0 + (if ((size(input) > 25))
3536-                                                                                                            then (input[25] * weights[2][25])
3537-                                                                                                            else (0 + (if ((size(input) > 26))
3538-                                                                                                                then (input[26] * weights[2][26])
3539-                                                                                                                else (0 + (if ((size(input) > 27))
3540-                                                                                                                    then (input[27] * weights[2][27])
3541-                                                                                                                    else (0 + (if ((size(input) > 28))
3542-                                                                                                                        then (input[28] * weights[2][28])
3543-                                                                                                                        else (0 + (if ((size(input) > 29))
3544-                                                                                                                            then (input[29] * weights[2][29])
3545-                                                                                                                            else (0 + (if ((size(input) > 30))
3546-                                                                                                                                then (input[30] * weights[2][30])
3547-                                                                                                                                else (0 + (if ((size(input) > 31))
3548-                                                                                                                                    then (input[31] * weights[2][31])
3549-                                                                                                                                    else (0 + (if ((size(input) > 32))
3550-                                                                                                                                        then (input[32] * weights[2][32])
3551-                                                                                                                                        else (0 + (if ((size(input) > 33))
3552-                                                                                                                                            then (input[33] * weights[2][33])
3553-                                                                                                                                            else (0 + (if ((size(input) > 34))
3554-                                                                                                                                                then (input[34] * weights[2][34])
3555-                                                                                                                                                else (0 + (if ((size(input) > 35))
3556-                                                                                                                                                    then (input[35] * weights[2][35])
3557-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[2])
3558-    let weighted_sum4 = (((if ((size(input) > 0))
3559-        then (input[0] * weights[3][0])
3560-        else (0 + (if ((size(input) > 1))
3561-            then (input[1] * weights[3][1])
3562-            else (0 + (if ((size(input) > 2))
3563-                then (input[2] * weights[3][2])
3564-                else (0 + (if ((size(input) > 3))
3565-                    then (input[3] * weights[3][3])
3566-                    else (0 + (if ((size(input) > 4))
3567-                        then (input[4] * weights[3][4])
3568-                        else (0 + (if ((size(input) > 5))
3569-                            then (input[5] * weights[3][5])
3570-                            else (0 + (if ((size(input) > 6))
3571-                                then (input[6] * weights[3][6])
3572-                                else (0 + (if ((size(input) > 7))
3573-                                    then (input[7] * weights[3][7])
3574-                                    else (0 + (if ((size(input) > 8))
3575-                                        then (input[8] * weights[3][8])
3576-                                        else (0 + (if ((size(input) > 9))
3577-                                            then (input[9] * weights[3][9])
3578-                                            else (0 + (if ((size(input) > 10))
3579-                                                then (input[10] * weights[3][10])
3580-                                                else (0 + (if ((size(input) > 11))
3581-                                                    then (input[11] * weights[3][11])
3582-                                                    else (0 + (if ((size(input) > 12))
3583-                                                        then (input[12] * weights[3][12])
3584-                                                        else (0 + (if ((size(input) > 13))
3585-                                                            then (input[13] * weights[3][13])
3586-                                                            else (0 + (if ((size(input) > 14))
3587-                                                                then (input[14] * weights[3][14])
3588-                                                                else (0 + (if ((size(input) > 15))
3589-                                                                    then (input[15] * weights[3][15])
3590-                                                                    else (0 + (if ((size(input) > 16))
3591-                                                                        then (input[16] * weights[3][16])
3592-                                                                        else (0 + (if ((size(input) > 17))
3593-                                                                            then (input[17] * weights[3][17])
3594-                                                                            else (0 + (if ((size(input) > 18))
3595-                                                                                then (input[18] * weights[3][18])
3596-                                                                                else (0 + (if ((size(input) > 19))
3597-                                                                                    then (input[19] * weights[3][19])
3598-                                                                                    else (0 + (if ((size(input) > 20))
3599-                                                                                        then (input[20] * weights[3][20])
3600-                                                                                        else (0 + (if ((size(input) > 21))
3601-                                                                                            then (input[21] * weights[3][21])
3602-                                                                                            else (0 + (if ((size(input) > 22))
3603-                                                                                                then (input[22] * weights[3][22])
3604-                                                                                                else (0 + (if ((size(input) > 23))
3605-                                                                                                    then (input[23] * weights[3][23])
3606-                                                                                                    else (0 + (if ((size(input) > 24))
3607-                                                                                                        then (input[24] * weights[3][24])
3608-                                                                                                        else (0 + (if ((size(input) > 25))
3609-                                                                                                            then (input[25] * weights[3][25])
3610-                                                                                                            else (0 + (if ((size(input) > 26))
3611-                                                                                                                then (input[26] * weights[3][26])
3612-                                                                                                                else (0 + (if ((size(input) > 27))
3613-                                                                                                                    then (input[27] * weights[3][27])
3614-                                                                                                                    else (0 + (if ((size(input) > 28))
3615-                                                                                                                        then (input[28] * weights[3][28])
3616-                                                                                                                        else (0 + (if ((size(input) > 29))
3617-                                                                                                                            then (input[29] * weights[3][29])
3618-                                                                                                                            else (0 + (if ((size(input) > 30))
3619-                                                                                                                                then (input[30] * weights[3][30])
3620-                                                                                                                                else (0 + (if ((size(input) > 31))
3621-                                                                                                                                    then (input[31] * weights[3][31])
3622-                                                                                                                                    else (0 + (if ((size(input) > 32))
3623-                                                                                                                                        then (input[32] * weights[3][32])
3624-                                                                                                                                        else (0 + (if ((size(input) > 33))
3625-                                                                                                                                            then (input[33] * weights[3][33])
3626-                                                                                                                                            else (0 + (if ((size(input) > 34))
3627-                                                                                                                                                then (input[34] * weights[3][34])
3628-                                                                                                                                                else (0 + (if ((size(input) > 35))
3629-                                                                                                                                                    then (input[35] * weights[3][35])
3630-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[3])
3631-    let weighted_sum5 = (((if ((size(input) > 0))
3632-        then (input[0] * weights[4][0])
3633-        else (0 + (if ((size(input) > 1))
3634-            then (input[1] * weights[4][1])
3635-            else (0 + (if ((size(input) > 2))
3636-                then (input[2] * weights[4][2])
3637-                else (0 + (if ((size(input) > 3))
3638-                    then (input[3] * weights[4][3])
3639-                    else (0 + (if ((size(input) > 4))
3640-                        then (input[4] * weights[4][4])
3641-                        else (0 + (if ((size(input) > 5))
3642-                            then (input[5] * weights[4][5])
3643-                            else (0 + (if ((size(input) > 6))
3644-                                then (input[6] * weights[4][6])
3645-                                else (0 + (if ((size(input) > 7))
3646-                                    then (input[7] * weights[4][7])
3647-                                    else (0 + (if ((size(input) > 8))
3648-                                        then (input[8] * weights[4][8])
3649-                                        else (0 + (if ((size(input) > 9))
3650-                                            then (input[9] * weights[4][9])
3651-                                            else (0 + (if ((size(input) > 10))
3652-                                                then (input[10] * weights[4][10])
3653-                                                else (0 + (if ((size(input) > 11))
3654-                                                    then (input[11] * weights[4][11])
3655-                                                    else (0 + (if ((size(input) > 12))
3656-                                                        then (input[12] * weights[4][12])
3657-                                                        else (0 + (if ((size(input) > 13))
3658-                                                            then (input[13] * weights[4][13])
3659-                                                            else (0 + (if ((size(input) > 14))
3660-                                                                then (input[14] * weights[4][14])
3661-                                                                else (0 + (if ((size(input) > 15))
3662-                                                                    then (input[15] * weights[4][15])
3663-                                                                    else (0 + (if ((size(input) > 16))
3664-                                                                        then (input[16] * weights[4][16])
3665-                                                                        else (0 + (if ((size(input) > 17))
3666-                                                                            then (input[17] * weights[4][17])
3667-                                                                            else (0 + (if ((size(input) > 18))
3668-                                                                                then (input[18] * weights[4][18])
3669-                                                                                else (0 + (if ((size(input) > 19))
3670-                                                                                    then (input[19] * weights[4][19])
3671-                                                                                    else (0 + (if ((size(input) > 20))
3672-                                                                                        then (input[20] * weights[4][20])
3673-                                                                                        else (0 + (if ((size(input) > 21))
3674-                                                                                            then (input[21] * weights[4][21])
3675-                                                                                            else (0 + (if ((size(input) > 22))
3676-                                                                                                then (input[22] * weights[4][22])
3677-                                                                                                else (0 + (if ((size(input) > 23))
3678-                                                                                                    then (input[23] * weights[4][23])
3679-                                                                                                    else (0 + (if ((size(input) > 24))
3680-                                                                                                        then (input[24] * weights[4][24])
3681-                                                                                                        else (0 + (if ((size(input) > 25))
3682-                                                                                                            then (input[25] * weights[4][25])
3683-                                                                                                            else (0 + (if ((size(input) > 26))
3684-                                                                                                                then (input[26] * weights[4][26])
3685-                                                                                                                else (0 + (if ((size(input) > 27))
3686-                                                                                                                    then (input[27] * weights[4][27])
3687-                                                                                                                    else (0 + (if ((size(input) > 28))
3688-                                                                                                                        then (input[28] * weights[4][28])
3689-                                                                                                                        else (0 + (if ((size(input) > 29))
3690-                                                                                                                            then (input[29] * weights[4][29])
3691-                                                                                                                            else (0 + (if ((size(input) > 30))
3692-                                                                                                                                then (input[30] * weights[4][30])
3693-                                                                                                                                else (0 + (if ((size(input) > 31))
3694-                                                                                                                                    then (input[31] * weights[4][31])
3695-                                                                                                                                    else (0 + (if ((size(input) > 32))
3696-                                                                                                                                        then (input[32] * weights[4][32])
3697-                                                                                                                                        else (0 + (if ((size(input) > 33))
3698-                                                                                                                                            then (input[33] * weights[4][33])
3699-                                                                                                                                            else (0 + (if ((size(input) > 34))
3700-                                                                                                                                                then (input[34] * weights[4][34])
3701-                                                                                                                                                else (0 + (if ((size(input) > 35))
3702-                                                                                                                                                    then (input[35] * weights[4][35])
3703-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[4])
3704-    let weighted_sum6 = (((if ((size(input) > 0))
3705-        then (input[0] * weights[5][0])
3706-        else (0 + (if ((size(input) > 1))
3707-            then (input[1] * weights[5][1])
3708-            else (0 + (if ((size(input) > 2))
3709-                then (input[2] * weights[5][2])
3710-                else (0 + (if ((size(input) > 3))
3711-                    then (input[3] * weights[5][3])
3712-                    else (0 + (if ((size(input) > 4))
3713-                        then (input[4] * weights[5][4])
3714-                        else (0 + (if ((size(input) > 5))
3715-                            then (input[5] * weights[5][5])
3716-                            else (0 + (if ((size(input) > 6))
3717-                                then (input[6] * weights[5][6])
3718-                                else (0 + (if ((size(input) > 7))
3719-                                    then (input[7] * weights[5][7])
3720-                                    else (0 + (if ((size(input) > 8))
3721-                                        then (input[8] * weights[5][8])
3722-                                        else (0 + (if ((size(input) > 9))
3723-                                            then (input[9] * weights[5][9])
3724-                                            else (0 + (if ((size(input) > 10))
3725-                                                then (input[10] * weights[5][10])
3726-                                                else (0 + (if ((size(input) > 11))
3727-                                                    then (input[11] * weights[5][11])
3728-                                                    else (0 + (if ((size(input) > 12))
3729-                                                        then (input[12] * weights[5][12])
3730-                                                        else (0 + (if ((size(input) > 13))
3731-                                                            then (input[13] * weights[5][13])
3732-                                                            else (0 + (if ((size(input) > 14))
3733-                                                                then (input[14] * weights[5][14])
3734-                                                                else (0 + (if ((size(input) > 15))
3735-                                                                    then (input[15] * weights[5][15])
3736-                                                                    else (0 + (if ((size(input) > 16))
3737-                                                                        then (input[16] * weights[5][16])
3738-                                                                        else (0 + (if ((size(input) > 17))
3739-                                                                            then (input[17] * weights[5][17])
3740-                                                                            else (0 + (if ((size(input) > 18))
3741-                                                                                then (input[18] * weights[5][18])
3742-                                                                                else (0 + (if ((size(input) > 19))
3743-                                                                                    then (input[19] * weights[5][19])
3744-                                                                                    else (0 + (if ((size(input) > 20))
3745-                                                                                        then (input[20] * weights[5][20])
3746-                                                                                        else (0 + (if ((size(input) > 21))
3747-                                                                                            then (input[21] * weights[5][21])
3748-                                                                                            else (0 + (if ((size(input) > 22))
3749-                                                                                                then (input[22] * weights[5][22])
3750-                                                                                                else (0 + (if ((size(input) > 23))
3751-                                                                                                    then (input[23] * weights[5][23])
3752-                                                                                                    else (0 + (if ((size(input) > 24))
3753-                                                                                                        then (input[24] * weights[5][24])
3754-                                                                                                        else (0 + (if ((size(input) > 25))
3755-                                                                                                            then (input[25] * weights[5][25])
3756-                                                                                                            else (0 + (if ((size(input) > 26))
3757-                                                                                                                then (input[26] * weights[5][26])
3758-                                                                                                                else (0 + (if ((size(input) > 27))
3759-                                                                                                                    then (input[27] * weights[5][27])
3760-                                                                                                                    else (0 + (if ((size(input) > 28))
3761-                                                                                                                        then (input[28] * weights[5][28])
3762-                                                                                                                        else (0 + (if ((size(input) > 29))
3763-                                                                                                                            then (input[29] * weights[5][29])
3764-                                                                                                                            else (0 + (if ((size(input) > 30))
3765-                                                                                                                                then (input[30] * weights[5][30])
3766-                                                                                                                                else (0 + (if ((size(input) > 31))
3767-                                                                                                                                    then (input[31] * weights[5][31])
3768-                                                                                                                                    else (0 + (if ((size(input) > 32))
3769-                                                                                                                                        then (input[32] * weights[5][32])
3770-                                                                                                                                        else (0 + (if ((size(input) > 33))
3771-                                                                                                                                            then (input[33] * weights[5][33])
3772-                                                                                                                                            else (0 + (if ((size(input) > 34))
3773-                                                                                                                                                then (input[34] * weights[5][34])
3774-                                                                                                                                                else (0 + (if ((size(input) > 35))
3775-                                                                                                                                                    then (input[35] * weights[5][35])
3776-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[5])
3777-    let weighted_sum7 = (((if ((size(input) > 0))
3778-        then (input[0] * weights[6][0])
3779-        else (0 + (if ((size(input) > 1))
3780-            then (input[1] * weights[6][1])
3781-            else (0 + (if ((size(input) > 2))
3782-                then (input[2] * weights[6][2])
3783-                else (0 + (if ((size(input) > 3))
3784-                    then (input[3] * weights[6][3])
3785-                    else (0 + (if ((size(input) > 4))
3786-                        then (input[4] * weights[6][4])
3787-                        else (0 + (if ((size(input) > 5))
3788-                            then (input[5] * weights[6][5])
3789-                            else (0 + (if ((size(input) > 6))
3790-                                then (input[6] * weights[6][6])
3791-                                else (0 + (if ((size(input) > 7))
3792-                                    then (input[7] * weights[6][7])
3793-                                    else (0 + (if ((size(input) > 8))
3794-                                        then (input[8] * weights[6][8])
3795-                                        else (0 + (if ((size(input) > 9))
3796-                                            then (input[9] * weights[6][9])
3797-                                            else (0 + (if ((size(input) > 10))
3798-                                                then (input[10] * weights[6][10])
3799-                                                else (0 + (if ((size(input) > 11))
3800-                                                    then (input[11] * weights[6][11])
3801-                                                    else (0 + (if ((size(input) > 12))
3802-                                                        then (input[12] * weights[6][12])
3803-                                                        else (0 + (if ((size(input) > 13))
3804-                                                            then (input[13] * weights[6][13])
3805-                                                            else (0 + (if ((size(input) > 14))
3806-                                                                then (input[14] * weights[6][14])
3807-                                                                else (0 + (if ((size(input) > 15))
3808-                                                                    then (input[15] * weights[6][15])
3809-                                                                    else (0 + (if ((size(input) > 16))
3810-                                                                        then (input[16] * weights[6][16])
3811-                                                                        else (0 + (if ((size(input) > 17))
3812-                                                                            then (input[17] * weights[6][17])
3813-                                                                            else (0 + (if ((size(input) > 18))
3814-                                                                                then (input[18] * weights[6][18])
3815-                                                                                else (0 + (if ((size(input) > 19))
3816-                                                                                    then (input[19] * weights[6][19])
3817-                                                                                    else (0 + (if ((size(input) > 20))
3818-                                                                                        then (input[20] * weights[6][20])
3819-                                                                                        else (0 + (if ((size(input) > 21))
3820-                                                                                            then (input[21] * weights[6][21])
3821-                                                                                            else (0 + (if ((size(input) > 22))
3822-                                                                                                then (input[22] * weights[6][22])
3823-                                                                                                else (0 + (if ((size(input) > 23))
3824-                                                                                                    then (input[23] * weights[6][23])
3825-                                                                                                    else (0 + (if ((size(input) > 24))
3826-                                                                                                        then (input[24] * weights[6][24])
3827-                                                                                                        else (0 + (if ((size(input) > 25))
3828-                                                                                                            then (input[25] * weights[6][25])
3829-                                                                                                            else (0 + (if ((size(input) > 26))
3830-                                                                                                                then (input[26] * weights[6][26])
3831-                                                                                                                else (0 + (if ((size(input) > 27))
3832-                                                                                                                    then (input[27] * weights[6][27])
3833-                                                                                                                    else (0 + (if ((size(input) > 28))
3834-                                                                                                                        then (input[28] * weights[6][28])
3835-                                                                                                                        else (0 + (if ((size(input) > 29))
3836-                                                                                                                            then (input[29] * weights[6][29])
3837-                                                                                                                            else (0 + (if ((size(input) > 30))
3838-                                                                                                                                then (input[30] * weights[6][30])
3839-                                                                                                                                else (0 + (if ((size(input) > 31))
3840-                                                                                                                                    then (input[31] * weights[6][31])
3841-                                                                                                                                    else (0 + (if ((size(input) > 32))
3842-                                                                                                                                        then (input[32] * weights[6][32])
3843-                                                                                                                                        else (0 + (if ((size(input) > 33))
3844-                                                                                                                                            then (input[33] * weights[6][33])
3845-                                                                                                                                            else (0 + (if ((size(input) > 34))
3846-                                                                                                                                                then (input[34] * weights[6][34])
3847-                                                                                                                                                else (0 + (if ((size(input) > 35))
3848-                                                                                                                                                    then (input[35] * weights[6][35])
3849-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[6])
3850-    let weighted_sum8 = (((if ((size(input) > 0))
3851-        then (input[0] * weights[7][0])
3852-        else (0 + (if ((size(input) > 1))
3853-            then (input[1] * weights[7][1])
3854-            else (0 + (if ((size(input) > 2))
3855-                then (input[2] * weights[7][2])
3856-                else (0 + (if ((size(input) > 3))
3857-                    then (input[3] * weights[7][3])
3858-                    else (0 + (if ((size(input) > 4))
3859-                        then (input[4] * weights[7][4])
3860-                        else (0 + (if ((size(input) > 5))
3861-                            then (input[5] * weights[7][5])
3862-                            else (0 + (if ((size(input) > 6))
3863-                                then (input[6] * weights[7][6])
3864-                                else (0 + (if ((size(input) > 7))
3865-                                    then (input[7] * weights[7][7])
3866-                                    else (0 + (if ((size(input) > 8))
3867-                                        then (input[8] * weights[7][8])
3868-                                        else (0 + (if ((size(input) > 9))
3869-                                            then (input[9] * weights[7][9])
3870-                                            else (0 + (if ((size(input) > 10))
3871-                                                then (input[10] * weights[7][10])
3872-                                                else (0 + (if ((size(input) > 11))
3873-                                                    then (input[11] * weights[7][11])
3874-                                                    else (0 + (if ((size(input) > 12))
3875-                                                        then (input[12] * weights[7][12])
3876-                                                        else (0 + (if ((size(input) > 13))
3877-                                                            then (input[13] * weights[7][13])
3878-                                                            else (0 + (if ((size(input) > 14))
3879-                                                                then (input[14] * weights[7][14])
3880-                                                                else (0 + (if ((size(input) > 15))
3881-                                                                    then (input[15] * weights[7][15])
3882-                                                                    else (0 + (if ((size(input) > 16))
3883-                                                                        then (input[16] * weights[7][16])
3884-                                                                        else (0 + (if ((size(input) > 17))
3885-                                                                            then (input[17] * weights[7][17])
3886-                                                                            else (0 + (if ((size(input) > 18))
3887-                                                                                then (input[18] * weights[7][18])
3888-                                                                                else (0 + (if ((size(input) > 19))
3889-                                                                                    then (input[19] * weights[7][19])
3890-                                                                                    else (0 + (if ((size(input) > 20))
3891-                                                                                        then (input[20] * weights[7][20])
3892-                                                                                        else (0 + (if ((size(input) > 21))
3893-                                                                                            then (input[21] * weights[7][21])
3894-                                                                                            else (0 + (if ((size(input) > 22))
3895-                                                                                                then (input[22] * weights[7][22])
3896-                                                                                                else (0 + (if ((size(input) > 23))
3897-                                                                                                    then (input[23] * weights[7][23])
3898-                                                                                                    else (0 + (if ((size(input) > 24))
3899-                                                                                                        then (input[24] * weights[7][24])
3900-                                                                                                        else (0 + (if ((size(input) > 25))
3901-                                                                                                            then (input[25] * weights[7][25])
3902-                                                                                                            else (0 + (if ((size(input) > 26))
3903-                                                                                                                then (input[26] * weights[7][26])
3904-                                                                                                                else (0 + (if ((size(input) > 27))
3905-                                                                                                                    then (input[27] * weights[7][27])
3906-                                                                                                                    else (0 + (if ((size(input) > 28))
3907-                                                                                                                        then (input[28] * weights[7][28])
3908-                                                                                                                        else (0 + (if ((size(input) > 29))
3909-                                                                                                                            then (input[29] * weights[7][29])
3910-                                                                                                                            else (0 + (if ((size(input) > 30))
3911-                                                                                                                                then (input[30] * weights[7][30])
3912-                                                                                                                                else (0 + (if ((size(input) > 31))
3913-                                                                                                                                    then (input[31] * weights[7][31])
3914-                                                                                                                                    else (0 + (if ((size(input) > 32))
3915-                                                                                                                                        then (input[32] * weights[7][32])
3916-                                                                                                                                        else (0 + (if ((size(input) > 33))
3917-                                                                                                                                            then (input[33] * weights[7][33])
3918-                                                                                                                                            else (0 + (if ((size(input) > 34))
3919-                                                                                                                                                then (input[34] * weights[7][34])
3920-                                                                                                                                                else (0 + (if ((size(input) > 35))
3921-                                                                                                                                                    then (input[35] * weights[7][35])
3922-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[7])
3923-    let weighted_sum9 = (((if ((size(input) > 0))
3924-        then (input[0] * weights[8][0])
3925-        else (0 + (if ((size(input) > 1))
3926-            then (input[1] * weights[8][1])
3927-            else (0 + (if ((size(input) > 2))
3928-                then (input[2] * weights[8][2])
3929-                else (0 + (if ((size(input) > 3))
3930-                    then (input[3] * weights[8][3])
3931-                    else (0 + (if ((size(input) > 4))
3932-                        then (input[4] * weights[8][4])
3933-                        else (0 + (if ((size(input) > 5))
3934-                            then (input[5] * weights[8][5])
3935-                            else (0 + (if ((size(input) > 6))
3936-                                then (input[6] * weights[8][6])
3937-                                else (0 + (if ((size(input) > 7))
3938-                                    then (input[7] * weights[8][7])
3939-                                    else (0 + (if ((size(input) > 8))
3940-                                        then (input[8] * weights[8][8])
3941-                                        else (0 + (if ((size(input) > 9))
3942-                                            then (input[9] * weights[8][9])
3943-                                            else (0 + (if ((size(input) > 10))
3944-                                                then (input[10] * weights[8][10])
3945-                                                else (0 + (if ((size(input) > 11))
3946-                                                    then (input[11] * weights[8][11])
3947-                                                    else (0 + (if ((size(input) > 12))
3948-                                                        then (input[12] * weights[8][12])
3949-                                                        else (0 + (if ((size(input) > 13))
3950-                                                            then (input[13] * weights[8][13])
3951-                                                            else (0 + (if ((size(input) > 14))
3952-                                                                then (input[14] * weights[8][14])
3953-                                                                else (0 + (if ((size(input) > 15))
3954-                                                                    then (input[15] * weights[8][15])
3955-                                                                    else (0 + (if ((size(input) > 16))
3956-                                                                        then (input[16] * weights[8][16])
3957-                                                                        else (0 + (if ((size(input) > 17))
3958-                                                                            then (input[17] * weights[8][17])
3959-                                                                            else (0 + (if ((size(input) > 18))
3960-                                                                                then (input[18] * weights[8][18])
3961-                                                                                else (0 + (if ((size(input) > 19))
3962-                                                                                    then (input[19] * weights[8][19])
3963-                                                                                    else (0 + (if ((size(input) > 20))
3964-                                                                                        then (input[20] * weights[8][20])
3965-                                                                                        else (0 + (if ((size(input) > 21))
3966-                                                                                            then (input[21] * weights[8][21])
3967-                                                                                            else (0 + (if ((size(input) > 22))
3968-                                                                                                then (input[22] * weights[8][22])
3969-                                                                                                else (0 + (if ((size(input) > 23))
3970-                                                                                                    then (input[23] * weights[8][23])
3971-                                                                                                    else (0 + (if ((size(input) > 24))
3972-                                                                                                        then (input[24] * weights[8][24])
3973-                                                                                                        else (0 + (if ((size(input) > 25))
3974-                                                                                                            then (input[25] * weights[8][25])
3975-                                                                                                            else (0 + (if ((size(input) > 26))
3976-                                                                                                                then (input[26] * weights[8][26])
3977-                                                                                                                else (0 + (if ((size(input) > 27))
3978-                                                                                                                    then (input[27] * weights[8][27])
3979-                                                                                                                    else (0 + (if ((size(input) > 28))
3980-                                                                                                                        then (input[28] * weights[8][28])
3981-                                                                                                                        else (0 + (if ((size(input) > 29))
3982-                                                                                                                            then (input[29] * weights[8][29])
3983-                                                                                                                            else (0 + (if ((size(input) > 30))
3984-                                                                                                                                then (input[30] * weights[8][30])
3985-                                                                                                                                else (0 + (if ((size(input) > 31))
3986-                                                                                                                                    then (input[31] * weights[8][31])
3987-                                                                                                                                    else (0 + (if ((size(input) > 32))
3988-                                                                                                                                        then (input[32] * weights[8][32])
3989-                                                                                                                                        else (0 + (if ((size(input) > 33))
3990-                                                                                                                                            then (input[33] * weights[8][33])
3991-                                                                                                                                            else (0 + (if ((size(input) > 34))
3992-                                                                                                                                                then (input[34] * weights[8][34])
3993-                                                                                                                                                else (0 + (if ((size(input) > 35))
3994-                                                                                                                                                    then (input[35] * weights[8][35])
3995-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[8])
3996-[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9]
3997-    }
3998-
3999-
4000-func relu (input) = if ((0 > input))
4001-    then 0
4002-    else input
4003-
4004-
4005-func relu_activation (inputs,num_outputs) = [relu(if ((size(inputs) > 0))
4006-    then inputs[0]
4007-    else 0), relu(if ((size(inputs) > 1))
4008-    then inputs[1]
4009-    else 0), relu(if ((size(inputs) > 2))
4010-    then inputs[2]
4011-    else 0), relu(if ((size(inputs) > 3))
4012-    then inputs[3]
4013-    else 0), relu(if ((size(inputs) > 4))
4014-    then inputs[4]
4015-    else 0), relu(if ((size(inputs) > 5))
4016-    then inputs[5]
4017-    else 0), relu(if ((size(inputs) > 6))
4018-    then inputs[6]
4019-    else 0), relu(if ((size(inputs) > 7))
4020-    then inputs[7]
4021-    else 0), relu(if ((size(inputs) > 8))
4022-    then inputs[8]
4023-    else 0), relu(if ((size(inputs) > 9))
4024-    then inputs[9]
4025-    else 0), relu(if ((size(inputs) > 10))
4026-    then inputs[10]
4027-    else 0), relu(if ((size(inputs) > 11))
4028-    then inputs[11]
4029-    else 0), relu(if ((size(inputs) > 12))
4030-    then inputs[12]
4031-    else 0), relu(if ((size(inputs) > 13))
4032-    then inputs[13]
4033-    else 0), relu(if ((size(inputs) > 14))
4034-    then inputs[14]
4035-    else 0), relu(if ((size(inputs) > 15))
4036-    then inputs[15]
4037-    else 0), relu(if ((size(inputs) > 16))
4038-    then inputs[16]
4039-    else 0), relu(if ((size(inputs) > 17))
4040-    then inputs[17]
4041-    else 0), relu(if ((size(inputs) > 18))
4042-    then inputs[18]
4043-    else 0), relu(if ((size(inputs) > 19))
4044-    then inputs[19]
4045-    else 0), relu(if ((size(inputs) > 20))
4046-    then inputs[20]
4047-    else 0), relu(if ((size(inputs) > 21))
4048-    then inputs[21]
4049-    else 0), relu(if ((size(inputs) > 22))
4050-    then inputs[22]
4051-    else 0), relu(if ((size(inputs) > 23))
4052-    then inputs[23]
4053-    else 0), relu(if ((size(inputs) > 24))
4054-    then inputs[24]
4055-    else 0), relu(if ((size(inputs) > 25))
4056-    then inputs[25]
4057-    else 0), relu(if ((size(inputs) > 26))
4058-    then inputs[26]
4059-    else 0), relu(if ((size(inputs) > 27))
4060-    then inputs[27]
4061-    else 0), relu(if ((size(inputs) > 28))
4062-    then inputs[28]
4063-    else 0), relu(if ((size(inputs) > 29))
4064-    then inputs[29]
4065-    else 0), relu(if ((size(inputs) > 30))
4066-    then inputs[30]
4067-    else 0), relu(if ((size(inputs) > 31))
4068-    then inputs[31]
4069-    else 0), relu(if ((size(inputs) > 32))
4070-    then inputs[32]
4071-    else 0), relu(if ((size(inputs) > 33))
4072-    then inputs[33]
4073-    else 0), relu(if ((size(inputs) > 34))
4074-    then inputs[34]
4075-    else 0), relu(if ((size(inputs) > 35))
4076-    then inputs[35]
4077-    else 0)]
407823 
407924 
408025 func sigmoid (input) = if ((-80000 > input))
409843                                     else 10000
409944 
410045 
4101-func sigmoid_activation (inputs,num_outputs) = [sigmoid(if ((size(inputs) > 0))
4102-    then inputs[0]
4103-    else 0), sigmoid(if ((size(inputs) > 1))
4104-    then inputs[1]
4105-    else 0), sigmoid(if ((size(inputs) > 2))
4106-    then inputs[2]
4107-    else 0), sigmoid(if ((size(inputs) > 3))
4108-    then inputs[3]
4109-    else 0), sigmoid(if ((size(inputs) > 4))
4110-    then inputs[4]
4111-    else 0), sigmoid(if ((size(inputs) > 5))
4112-    then inputs[5]
4113-    else 0), sigmoid(if ((size(inputs) > 6))
4114-    then inputs[6]
4115-    else 0), sigmoid(if ((size(inputs) > 7))
4116-    then inputs[7]
4117-    else 0), sigmoid(if ((size(inputs) > 8))
4118-    then inputs[8]
4119-    else 0)]
46+func sigmoid_activation (inputs,num_outputs) = [sigmoid(inputs[0]), sigmoid(inputs[1])]
412047 
412148 
412249 @Callable(i)
4123-func predict (x1,x2,x3,x4,x5,x6,x7,x8,x9) = {
4124-    let x1_scaled = (x1 * 10000)
4125-    let x2_scaled = (x2 * 10000)
4126-    let x3_scaled = (x3 * 10000)
4127-    let x4_scaled = (x4 * 10000)
4128-    let x5_scaled = (x5 * 10000)
4129-    let x6_scaled = (x6 * 10000)
4130-    let x7_scaled = (x7 * 10000)
4131-    let x8_scaled = (x8 * 10000)
4132-    let x9_scaled = (x9 * 10000)
4133-    let inputs = [x1_scaled, x2_scaled, x3_scaled, x4_scaled, x5_scaled, x6_scaled, x7_scaled, x8_scaled, x9_scaled]
4134-    let z1 = linear_forward_1(inputs, weights_layer_1, biases_layer_1)
4135-    let a1 = relu_activation(z1, 36)
50+func predict (inputs) = {
51+    let x1_scaled = (inputs[0] * 10000)
52+    let x2_scaled = (inputs[1] * 10000)
53+    let scaled_inputs = [x1_scaled, x2_scaled]
54+    let z1 = linear_forward_1(scaled_inputs, weights_layer_1, biases_layer_1)
55+    let a1 = sigmoid_activation(z1, 2)
413656     let z2 = linear_forward_2(a1, weights_layer_2, biases_layer_2)
4137-    let a2 = relu_activation(z2, 36)
4138-    let z3 = linear_forward_3(a2, weights_layer_3, biases_layer_3)
4139-    let a3 = sigmoid_activation(z3, 9)
4140-    let result0 = if ((size(a3) > 0))
4141-        then a3[0]
4142-        else 0
4143-    let result1 = if ((size(a3) > 1))
4144-        then a3[1]
4145-        else 0
4146-    let result2 = if ((size(a3) > 2))
4147-        then a3[2]
4148-        else 0
4149-    let result3 = if ((size(a3) > 3))
4150-        then a3[3]
4151-        else 0
4152-    let result4 = if ((size(a3) > 4))
4153-        then a3[4]
4154-        else 0
4155-    let result5 = if ((size(a3) > 5))
4156-        then a3[5]
4157-        else 0
4158-    let result6 = if ((size(a3) > 6))
4159-        then a3[6]
4160-        else 0
4161-    let result7 = if ((size(a3) > 7))
4162-        then a3[7]
4163-        else 0
4164-    let result8 = if ((size(a3) > 8))
4165-        then a3[8]
4166-        else 0
57+    let a2 = sigmoid_activation(z2, 1)
58+    let result0 = a2[0]
416759     let debug_outputs = nil
4168-    ([IntegerEntry("move_prediction_0", result0), IntegerEntry("move_prediction_1", result1), IntegerEntry("move_prediction_2", result2), IntegerEntry("move_prediction_3", result3), IntegerEntry("move_prediction_4", result4), IntegerEntry("move_prediction_5", result5), IntegerEntry("move_prediction_6", result6), IntegerEntry("move_prediction_7", result7), IntegerEntry("move_prediction_8", result8)] ++ debug_outputs)
60+    ([IntegerEntry("move_prediction_0", result0)] ++ debug_outputs)
416961     }
417062 
417163 

Full: 

OldNewDifferences
11 {-# STDLIB_VERSION 7 #-}
22 {-# SCRIPT_TYPE ACCOUNT #-}
33 {-# CONTENT_TYPE DAPP #-}
4-let weights_layer_1 = [[564, 1539, -23179, 855, 294, 992, 5476, 6462, 5706], [1917, -323, 1527, 663, 9898, -1842, -2539, -5642, -8671], [-6042, -3786, 10256, -3162, 10158, -3899, 9125, -4040, -7722], [-1352, -922, -1104, 509, -34, 490, 5265, -12258, 9412], [-6464, -4986, 8360, -4702, -6679, 8185, -7182, -4902, 6565], [2731, 2632, -1565, 2507, 4954, 1299, -21654, 2803, 2973], [-6119, -3811, -2055, -3351, 14558, 532, -673, 1631, 3778], [6040, -838, -2110, -3854, 5085, -7445, -5852, -2461, 2966], [-4305, -3403, -2766, -3236, -4289, -1690, -4486, 21035, -4907], [-2672, -2470, -3494, -4088, -3877, -3084, 19487, -2652, -3706], [2412, 1642, 1964, -18620, -1462, 1182, -3050, -1253, 670], [19242, -2063, -4350, -3449, -5421, -4376, -4500, -3187, -4753], [-423, -2939, 14505, 251, -3736, -2437, -801, -2938, -3626], [-3949, 2718, -4336, -616, 4477, -317, -3449, 2738, -3683], [222, -14478, 407, -266, -8125, 2276, -770, 7233, 2045], [-4305, -4933, -4848, 2460, -2529, 9859, 2373, 674, 4044], [-5309, 10785, -5094, -3997, 10031, -4763, -5325, 10792, -5739], [-21947, 2385, 1861, 1808, 663, 1519, 2530, 2931, 4297], [-806, -3733, -6338, 1896, -14255, -3034, 5184, 5033, 260], [5592, 2940, 506, 5670, 741, 3691, 3501, 1949, -21185], [-1364, 1321, 274, -8135, -818, 998, -35, 945, -1949], [-129, -755, 2327, -4149, -13780, -2145, 121, -4248, 1181], [8429, 9219, 7419, -3778, -8656, -4177, -8727, -6674, -8870], [-2176, -3671, -12291, 5772, 5707, 176, 5703, -6078, -4386], [-1839, 2272, -1238, 4154, -12551, 4606, -6216, 21, 1667], [358, -5103, -3725, 10010, -2287, -1696, -2364, -2487, -766], [-1863, 20045, -3277, -1732, -4059, -1788, -1120, -914, -1592], [1803, 4262, 1396, 4433, 3261, -22890, 2005, 4044, 3658], [-3681, 678, 1429, 4937, -7337, 4294, 7123, 1740, -6057], [4997, 4766, -744, 7316, 4186, 2866, 5265, -16537, 1584], [-2515, -1614, -3018, -2442, -5076, -3150, -5879, -333, 17206], [-2745, -1716, -2322, -4940, -4712, 21290, -3686, -4457, -4159], [-3365, -1416, -1958, -14770, 53, -2617, 5627, 6320, 7960], [5355, 1147, 1384, -915, 3172, -2462, 947, -13150, 2117], [7412, -19148, -65, 2697, 6621, 1645, 4059, 2603, 3924], [-6636, -2689, -3386, 9831, 8304, 10028, -4819, -3035, -6716]]
4+let weights_layer_1 = [[60049, 60073], [41419, 41425]]
55 
6-let biases_layer_1 = [-6632, -548, -12850, -4518, -9916, -4022, -668, -4817, -2828, -3640, -4752, -4800, 151, 7959, -5093, -564, -11437, -6961, -4759, -7890, 8094, -1435, -10481, -3502, -2916, 5716, -2811, -6803, -2598, -2480, -3309, -5554, -7707, -4774, -3217, -11177]
6+let biases_layer_1 = [-25905, -63563]
77 
8-let weights_layer_2 = [[-2096, -1305, 5422, 3073, 3504, 5502, -2672, 5596, 1887, 10049, -1150, 5652, -1567, 363, -2745, 2825, 6455, 6153, -1234, -3728, 953, -3504, 4523, -1796, 3711, -266, -2127, 12373, -137, -726, -365, 12859, 232, 2427, 1257, 6005], [-106, -2166, -4757, 110, -2887, -1229, 431, 1116, 10520, -3279, -4476, 5340, 6974, 5935, -5474, 2669, -3732, -1383, -2237, -6304, 8181, 3944, -3330, 1628, -770, 3266, -10111, 6225, -245, 5486, -3833, 9944, -4287, 3038, -5067, -4065], [2510, 1181, -2623, 5033, -4689, -7522, 982, -1767, 1762, 614, 629, 9461, 892, 1024, -448, -2775, -1788, -7064, -479, 1173, -394, 5090, -4726, 4378, -468, -417, 498, 784, -2916, 678, 4935, 1103, -3363, -2438, 470, 1189], [-2360, 3603, -596, 747, -1269, 4471, -11635, 913, -3798, -3722, -4302, -1479, 3493, -257, 1495, 3177, 393, 559, -1514, 332, -4115, -401, 740, -8928, 6055, 3887, -1232, -7560, 3886, 3661, -6356, 2298, -5153, -153, -1423, -1253], [418, -74, -194, -537, 664, -712, -321, -1606, -606, 1231, 1318, -492, -1264, -1238, -1042, -678, -1643, -1346, -1354, -1211, -813, -76, -1336, -1019, 219, -1526, -689, -954, 51, -158, -427, 687, -256, -1220, -1567, 368], [-173, 241, 1681, -3579, -397, -2941, 5489, 3201, 4842, -4938, 1533, -3574, -1694, -4417, 1214, -103, -6495, -1498, 6381, 1009, 2520, -2869, 827, 1633, 3153, 2898, 6345, 12259, 319, 6083, -1585, 15327, 1697, 5367, 1243, -2953], [107, 145, -2188, 403, -911, 1298, -2149, 2150, -2290, -2026, -3789, -6824, 203, 915, 2349, 2191, -2096, 5985, -2224, 3649, -14167, -5157, -1335, -1897, 7794, 19238, -848, 10763, 3764, 3190, -5095, -8904, -5128, -1621, -1361, 1856], [3341, -1613, -2545, -1826, 4012, 5400, -2311, 722, -916, -830, -563, -2565, 1867, 4541, 6163, -4621, -2253, -1077, -1949, -2230, 356, 560, -1588, -390, -596, -1143, 19868, -1873, -410, 4803, -2544, 239, 977, 168, 8759, 4005], [-9858, 3688, 4177, 290, 520, -2893, -3909, 2431, 4223, 2125, 6224, 428, 73, 153, -2108, -5298, -99, -2885, 201, 12336, -1906, 2079, 4876, -589, 2448, -1349, -379, 7642, -1544, -3603, 2004, 2510, -1904, 2209, -1215, -117], [2281, -1072, 3996, -2334, 4235, -5507, -5850, -1218, 1095, -2154, -642, -2979, 9930, -3455, 1385, -4333, 863, 9045, -201, 2592, 2021, 891, -640, -7210, 4180, 377, 210, 2567, -3675, 459, -1476, 985, 2661, 1220, 562, 2375], [4832, -1143, -237, 1941, -4376, -5830, -387, -4099, -756, 12251, -3078, -3504, -2443, 4335, -4996, 1416, 206, 505, -4118, -159, -155, 2033, -5753, 4897, -732, -721, -853, -847, 5195, -1607, -1054, -2430, -1948, -2840, 1089, -6073], [17104, 2700, 2898, 1350, -2431, 1451, 150, -4051, -4498, -5733, 206, 3039, -4419, -3286, -4724, 835, 3310, 4881, 4011, 1028, -2818, -4128, -4579, 4811, -1824, 3096, 834, -6460, -561, 1406, 1344, 3584, 3963, -7074, -10575, 1183], [2078, 1015, 5473, -3486, -2176, -7196, -3221, 2047, 235, -2161, 7465, 17932, 1139, 16, 555, -4492, 780, 16413, 118, -3092, 1895, -611, -4913, -3975, 1483, 1696, 673, 2002, 1675, -85, -2287, 4063, 5576, 4087, 4041, -1404], [-5883, -5918, -837, 2697, -40, 350, -2524, 3499, 6892, 917, 2915, 518, 2635, -10878, -2696, 1323, -2544, -2772, 11436, -1107, -192, 11603, 5059, -4973, 12019, -99, 4420, -4674, 4064, -1382, 837, 3351, -5541, 614, -6637, -475], [-2295, 3567, 2535, 3126, 3960, 2910, -3538, -679, -2642, 4519, -3754, 14892, 476, 2866, 4168, -3821, 4623, 10654, 6543, 7306, -1025, 3456, 688, 318, -4355, 1513, 3300, -1805, -4555, -2618, 4840, 2324, 432, -3001, 4289, 6549], [3931, -807, -1791, 970, 6028, 6852, 285, 651, 2335, 7948, -6, 3726, 6668, -268, -4170, -1777, 4997, 1468, -1039, -424, -35, -267, 1643, -2070, -1533, 1219, -949, -411, 3380, -2783, 982, -3889, -1680, 1290, -3117, 5231], [-1577, -3050, -2093, 1381, -783, 3137, 6044, -1401, 381, -871, -814, -4675, -610, -1684, -382, 1224, -2221, 10105, -4910, -3667, 527, -6593, -1908, 1695, -3573, -1310, 2604, 2930, -5818, 1367, 1013, -1488, 555, -1199, -348, -236], [3335, -3891, -4146, 662, -5076, -5571, -1160, -1221, -2333, 2318, -6249, -2111, 1009, 2932, 2470, 2442, -3146, -6213, 4366, 1164, -574, 1966, -7984, -1998, -716, 3432, 4135, 4532, 6444, -3933, -2834, -866, -3434, -2958, 5587, -1600], [-838, 253, -859, -1222, 4350, -92, 607, 4011, 2234, -387, 4093, -1213, 14403, -1620, -1193, -4969, -4509, 2447, -2574, -1982, 1761, 499, -649, -6015, 942, -2154, -1608, 2990, -3994, -1568, 56, -4305, -2286, 4976, 813, 1030], [3066, 5948, 4074, -1060, 5667, -4937, 5734, 423, -2048, 2584, 697, 420, -825, -3885, 4486, -1865, 7827, 3486, 9713, -5074, -1460, -186, 9088, -2956, 4742, 310, -1012, 3708, -733, -1804, 1802, 223, 4528, 67, 1969, 2272], [4582, -2931, -1982, -5158, -1475, 444, 1703, 2309, 18746, 1479, 745, -216, -5152, -3864, -728, -4970, 1313, -3858, 5493, 4351, -1562, 49, -54, 1383, 1103, -282, -751, 4091, 1670, -6141, -1063, -4440, 377, -6219, 2215, -2458], [10033, -3350, -908, 3179, 3946, 4611, 107, 125, -5169, -971, 2597, -3581, 6468, -1559, 2573, -1565, 5836, -7819, 4255, 559, 2011, -2218, 3906, 1816, -1021, 3104, 3707, 2128, 3470, 265, -1217, -1012, 5130, 1898, 9447, 1013], [658, -1685, -1712, -790, -2307, 705, 5439, 580, 1744, -373, -2189, 1641, 18, -252, -2386, 2081, -1499, 2503, 1551, -4418, -1009, 3080, -446, -335, 2319, -1773, 2688, 3668, -2440, 1957, 3894, 1961, -1972, -623, -3800, -365], [-1669, 10737, 672, 964, 3822, 1905, 11737, 1648, 275, -3024, -3696, -1608, -2571, 6669, 139, -1584, -913, -2322, -6145, 702, 1485, -8048, -1778, 7825, -8300, -3090, -3025, 4640, -5757, 4231, -1531, -2860, 1907, 5703, -723, -797], [-2633, -5119, 8627, 2168, -890, 3944, -2776, 3651, 5205, 1529, 3780, -3753, -1904, -904, 1457, 4857, -746, -2564, -8256, -3110, 3267, -4825, 1364, 824, 1032, -2630, 14493, 2457, -1367, 1206, 3163, 5313, 1431, 4222, 6849, 6444], [-4291, 1097, -844, 2177, 3425, 14896, 4484, 7910, 5684, 21400, 3932, -705, 2131, -1274, 548, 1000, -2338, -2291, -3747, -6956, 73, -1122, 1148, 3160, 3379, -1019, -185, -2722, 4599, 3741, 879, -1954, -3506, 2368, 1223, 2317], [-2185, 223, -4644, -1412, 630, -3031, 2708, -3382, -911, 3367, 13855, 3568, -1963, -1066, 1143, -335, 687, -7617, -1032, -785, 9567, 1614, -3619, 3592, -7180, -12214, 840, -5226, -4516, -2974, -1094, 4227, 9004, -402, -2994, -2658], [799, -3078, 3005, 11370, -4284, 3271, 2849, 3684, -2867, -2893, 568, -4617, 471, 1593, 974, -847, 1607, 286, -1218, 16983, 3677, 284, 1897, -4501, 1976, 349, -1392, 885, -1849, -3860, 19921, 3745, 2275, -1508, -2128, -606], [-185, 3390, 277, -695, 3227, 2887, 4299, -2136, -2134, -1883, 6438, -2668, -4444, 5344, 1075, 1191, 2022, 815, -4963, -4414, 7824, -5766, -1414, 103, -5981, -1158, 556, -3631, -2253, -4335, -4069, 1289, 5596, -94, 34, -3464], [1685, -4007, -1332, -856, -3036, -4039, -2013, -1274, -1556, 4618, -4698, 5203, -107, -4809, -1377, -2733, -2406, -6411, 3977, 4240, -5948, 1050, -1793, 2509, -1882, 3806, -357, 4023, 2805, 4061, -1415, -309, -4757, -254, 2470, 488], [-7290, -3075, -2002, 503, -5791, -3621, 630, -2569, 4729, -3445, -1732, 3170, -816, 5571, -1525, 1089, -10117, 497, -195, -3385, 7700, 4913, -10956, -243, -37, 3590, 8360, -7880, -4761, -1089, 2892, -8772, -3768, 810, 213, -7224], [-8266, 1528, -936, 2328, 8643, 830, 4138, -3567, 2847, -1492, 3043, -91, -3211, -3528, 5105, -910, -5218, 8871, -2732, -5464, 1250, 1456, 917, 525, 4296, 995, 1819, -6723, -2903, 2621, 683, 481, 615, 965, 2595, -1880], [2655, -2790, 12413, 7609, 2861, -217, 3780, 322, 15931, -932, 5160, 1737, 3562, -2485, -6777, -997, 5342, -626, -1949, 4562, -2205, -3122, 2830, -1207, -2284, 5697, 870, -4454, 4004, 14396, 5935, 228, 825, 7482, 3312, 8595], [-2393, 5001, -637, -3215, -1747, 2528, -2626, -1978, -1652, -1195, -2664, -211, -5308, -526, 1315, 1522, -1125, -3577, -966, 3713, 228, -317, -1283, -2120, 4743, 1380, 192, 2520, 404, -4582, -410, 7377, -774, -3070, -717, -1071], [1777, -1480, 1443, -1212, 1609, -1079, -427, 179, -1312, -463, 296, 1210, -1256, -1443, -1357, -972, -19, 1103, -1031, -1670, 2018, 793, -869, -1243, 1891, -1822, 3238, -1969, -381, -1679, -309, 1502, -534, -1169, -1331, -1924], [-5742, 2942, -166, -4927, 2651, 7606, -2251, 1903, -1186, -3071, 2323, -7556, 13648, -1901, 2113, -4962, -1996, 7644, 4242, 1634, 2084, 2424, -1206, -7340, -1060, -3872, 578, 2666, 1271, -985, -2562, 2440, 1036, 1219, 3700, 4020]]
8+let weights_layer_2 = [[83296, -89714]]
99 
10-let biases_layer_2 = [-1768, 8209, 1935, 6068, 1144, 945, 2821, 287, -1979, 456, 7230, -4163, 1676, -2168, -3095, -1961, -1625, 8204, -26, -7049, -1025, -6862, -1472, -7671, 1261, -3408, -7758, 2778, -2872, -5227, 21209, 343, -7070, -12, 336, -2278]
11-
12-let weights_layer_3 = [[-9317, 2910, 620, -228, 1610, 5421, 2761, 754, 2811, -2270, 4988, -6310, -21426, 2005, -16974, -4720, -4436, 7522, -111, -6940, -571, 1793, 150, -333, 4354, 2925, 2484, 4565, 4936, 388, 4070, -8381, -2501, 2472, -409, 6175], [1091, 14985, 5994, 7419, -1692, -7007, 1985, -17003, 3320, -5234, 2948, 3433, -2081, 4357, -5485, -37, 3740, -7076, 914, -4549, 487, -6295, 3202, -1999, -12831, 4826, 2047, 2865, 3341, -8123, 1152, -4427, -2360, 845, -3851, -1567], [3170, -3001, 16, 4114, 1448, 2750, 3644, -3529, 7086, -14054, 2580, -21113, -1151, 704, 1254, -6595, 2279, -2830, -18095, -2609, 1310, -10586, 457, -856, 4277, 2065, 1340, -2091, -2006, -7650, 9399, 9203, -5005, 6350, 1069, -16685], [31, 4815, 12845, -5516, 1626, 3480, -29237, 824, -584, -5454, 1714, 546, -5355, -1901, 3747, -1101, 8750, 6956, 1419, -6528, 846, -7768, 8701, -1002, 73, 168, -29198, -1835, 107, 4095, 4639, -3291, -5653, 4476, -728, 9307], [5863, 4945, 1281, 4748, 408, -6666, 1562, 468, -1625, 205, 3391, -915, 3150, -31536, -4780, -1298, -3063, 2241, 1305, -14830, 314, -3245, -3722, -28292, 8745, -828, 1695, 2445, -12087, -5147, 7734, -7306, 582, 2032, -553, -710], [-14743, -6340, 5274, 5173, 314, -14713, 5069, 1868, -2584, -2057, 4332, 3800, -4649, 2024, 2323, 3965, 5948, -3578, 4193, -4258, 6240, -3034, -882, 3563, -5152, 2657, 8463, -4486, -11621, -7521, 14395, 6833, -1, -3908, -424, 1679], [-9986, 2993, 2819, 5901, -498, 7336, 407, -1869, -764, 3495, -11816, 5097, 6429, -1581, -6180, -10516, 5264, 7540, 961, -475, -741, -6460, 800, 3218, -2338, -21638, -3159, 1523, 3848, -970, 7511, -532, 1004, -878, 1619, 1557], [69, -2163, 827, 8828, -385, -2432, 2613, 704, -907, -3341, 8018, 2854, -458, -2626, 4308, -1242, 3521, 8610, -3073, 964, -21911, 2565, 2032, 2134, -5156, -4150, 5429, 4212, 791, -6657, 4684, -6473, -19282, 8318, 3605, 4658], [536, 7804, -2112, 7804, -1536, 3409, -308, 6206, -16063, -2231, 4157, -1351, 5013, -931, -8226, 599, -8239, 898, -2716, -1701, 4741, -3679, 219, 3529, -3815, 2257, 5035, -22650, -2400, -7163, 3112, 1954, -8977, 966, -1432, 5029]]
13-
14-let biases_layer_3 = [11212, 2074, 7455, -585, 8587, 2132, 6372, 4342, 6426]
10+let biases_layer_2 = [-38117]
1511 
1612 func linear_forward_1 (input,weights,biases) = {
17-    let weighted_sum1 = (((if ((size(input) > 0))
18-        then (input[0] * weights[0][0])
19-        else (0 + (if ((size(input) > 1))
20-            then (input[1] * weights[0][1])
21-            else (0 + (if ((size(input) > 2))
22-                then (input[2] * weights[0][2])
23-                else (0 + (if ((size(input) > 3))
24-                    then (input[3] * weights[0][3])
25-                    else (0 + (if ((size(input) > 4))
26-                        then (input[4] * weights[0][4])
27-                        else (0 + (if ((size(input) > 5))
28-                            then (input[5] * weights[0][5])
29-                            else (0 + (if ((size(input) > 6))
30-                                then (input[6] * weights[0][6])
31-                                else (0 + (if ((size(input) > 7))
32-                                    then (input[7] * weights[0][7])
33-                                    else (0 + (if ((size(input) > 8))
34-                                        then (input[8] * weights[0][8])
35-                                        else 0))))))))))))))))) / 10000) + biases[0])
36-    let weighted_sum2 = (((if ((size(input) > 0))
37-        then (input[0] * weights[1][0])
38-        else (0 + (if ((size(input) > 1))
39-            then (input[1] * weights[1][1])
40-            else (0 + (if ((size(input) > 2))
41-                then (input[2] * weights[1][2])
42-                else (0 + (if ((size(input) > 3))
43-                    then (input[3] * weights[1][3])
44-                    else (0 + (if ((size(input) > 4))
45-                        then (input[4] * weights[1][4])
46-                        else (0 + (if ((size(input) > 5))
47-                            then (input[5] * weights[1][5])
48-                            else (0 + (if ((size(input) > 6))
49-                                then (input[6] * weights[1][6])
50-                                else (0 + (if ((size(input) > 7))
51-                                    then (input[7] * weights[1][7])
52-                                    else (0 + (if ((size(input) > 8))
53-                                        then (input[8] * weights[1][8])
54-                                        else 0))))))))))))))))) / 10000) + biases[1])
55-    let weighted_sum3 = (((if ((size(input) > 0))
56-        then (input[0] * weights[2][0])
57-        else (0 + (if ((size(input) > 1))
58-            then (input[1] * weights[2][1])
59-            else (0 + (if ((size(input) > 2))
60-                then (input[2] * weights[2][2])
61-                else (0 + (if ((size(input) > 3))
62-                    then (input[3] * weights[2][3])
63-                    else (0 + (if ((size(input) > 4))
64-                        then (input[4] * weights[2][4])
65-                        else (0 + (if ((size(input) > 5))
66-                            then (input[5] * weights[2][5])
67-                            else (0 + (if ((size(input) > 6))
68-                                then (input[6] * weights[2][6])
69-                                else (0 + (if ((size(input) > 7))
70-                                    then (input[7] * weights[2][7])
71-                                    else (0 + (if ((size(input) > 8))
72-                                        then (input[8] * weights[2][8])
73-                                        else 0))))))))))))))))) / 10000) + biases[2])
74-    let weighted_sum4 = (((if ((size(input) > 0))
75-        then (input[0] * weights[3][0])
76-        else (0 + (if ((size(input) > 1))
77-            then (input[1] * weights[3][1])
78-            else (0 + (if ((size(input) > 2))
79-                then (input[2] * weights[3][2])
80-                else (0 + (if ((size(input) > 3))
81-                    then (input[3] * weights[3][3])
82-                    else (0 + (if ((size(input) > 4))
83-                        then (input[4] * weights[3][4])
84-                        else (0 + (if ((size(input) > 5))
85-                            then (input[5] * weights[3][5])
86-                            else (0 + (if ((size(input) > 6))
87-                                then (input[6] * weights[3][6])
88-                                else (0 + (if ((size(input) > 7))
89-                                    then (input[7] * weights[3][7])
90-                                    else (0 + (if ((size(input) > 8))
91-                                        then (input[8] * weights[3][8])
92-                                        else 0))))))))))))))))) / 10000) + biases[3])
93-    let weighted_sum5 = (((if ((size(input) > 0))
94-        then (input[0] * weights[4][0])
95-        else (0 + (if ((size(input) > 1))
96-            then (input[1] * weights[4][1])
97-            else (0 + (if ((size(input) > 2))
98-                then (input[2] * weights[4][2])
99-                else (0 + (if ((size(input) > 3))
100-                    then (input[3] * weights[4][3])
101-                    else (0 + (if ((size(input) > 4))
102-                        then (input[4] * weights[4][4])
103-                        else (0 + (if ((size(input) > 5))
104-                            then (input[5] * weights[4][5])
105-                            else (0 + (if ((size(input) > 6))
106-                                then (input[6] * weights[4][6])
107-                                else (0 + (if ((size(input) > 7))
108-                                    then (input[7] * weights[4][7])
109-                                    else (0 + (if ((size(input) > 8))
110-                                        then (input[8] * weights[4][8])
111-                                        else 0))))))))))))))))) / 10000) + biases[4])
112-    let weighted_sum6 = (((if ((size(input) > 0))
113-        then (input[0] * weights[5][0])
114-        else (0 + (if ((size(input) > 1))
115-            then (input[1] * weights[5][1])
116-            else (0 + (if ((size(input) > 2))
117-                then (input[2] * weights[5][2])
118-                else (0 + (if ((size(input) > 3))
119-                    then (input[3] * weights[5][3])
120-                    else (0 + (if ((size(input) > 4))
121-                        then (input[4] * weights[5][4])
122-                        else (0 + (if ((size(input) > 5))
123-                            then (input[5] * weights[5][5])
124-                            else (0 + (if ((size(input) > 6))
125-                                then (input[6] * weights[5][6])
126-                                else (0 + (if ((size(input) > 7))
127-                                    then (input[7] * weights[5][7])
128-                                    else (0 + (if ((size(input) > 8))
129-                                        then (input[8] * weights[5][8])
130-                                        else 0))))))))))))))))) / 10000) + biases[5])
131-    let weighted_sum7 = (((if ((size(input) > 0))
132-        then (input[0] * weights[6][0])
133-        else (0 + (if ((size(input) > 1))
134-            then (input[1] * weights[6][1])
135-            else (0 + (if ((size(input) > 2))
136-                then (input[2] * weights[6][2])
137-                else (0 + (if ((size(input) > 3))
138-                    then (input[3] * weights[6][3])
139-                    else (0 + (if ((size(input) > 4))
140-                        then (input[4] * weights[6][4])
141-                        else (0 + (if ((size(input) > 5))
142-                            then (input[5] * weights[6][5])
143-                            else (0 + (if ((size(input) > 6))
144-                                then (input[6] * weights[6][6])
145-                                else (0 + (if ((size(input) > 7))
146-                                    then (input[7] * weights[6][7])
147-                                    else (0 + (if ((size(input) > 8))
148-                                        then (input[8] * weights[6][8])
149-                                        else 0))))))))))))))))) / 10000) + biases[6])
150-    let weighted_sum8 = (((if ((size(input) > 0))
151-        then (input[0] * weights[7][0])
152-        else (0 + (if ((size(input) > 1))
153-            then (input[1] * weights[7][1])
154-            else (0 + (if ((size(input) > 2))
155-                then (input[2] * weights[7][2])
156-                else (0 + (if ((size(input) > 3))
157-                    then (input[3] * weights[7][3])
158-                    else (0 + (if ((size(input) > 4))
159-                        then (input[4] * weights[7][4])
160-                        else (0 + (if ((size(input) > 5))
161-                            then (input[5] * weights[7][5])
162-                            else (0 + (if ((size(input) > 6))
163-                                then (input[6] * weights[7][6])
164-                                else (0 + (if ((size(input) > 7))
165-                                    then (input[7] * weights[7][7])
166-                                    else (0 + (if ((size(input) > 8))
167-                                        then (input[8] * weights[7][8])
168-                                        else 0))))))))))))))))) / 10000) + biases[7])
169-    let weighted_sum9 = (((if ((size(input) > 0))
170-        then (input[0] * weights[8][0])
171-        else (0 + (if ((size(input) > 1))
172-            then (input[1] * weights[8][1])
173-            else (0 + (if ((size(input) > 2))
174-                then (input[2] * weights[8][2])
175-                else (0 + (if ((size(input) > 3))
176-                    then (input[3] * weights[8][3])
177-                    else (0 + (if ((size(input) > 4))
178-                        then (input[4] * weights[8][4])
179-                        else (0 + (if ((size(input) > 5))
180-                            then (input[5] * weights[8][5])
181-                            else (0 + (if ((size(input) > 6))
182-                                then (input[6] * weights[8][6])
183-                                else (0 + (if ((size(input) > 7))
184-                                    then (input[7] * weights[8][7])
185-                                    else (0 + (if ((size(input) > 8))
186-                                        then (input[8] * weights[8][8])
187-                                        else 0))))))))))))))))) / 10000) + biases[8])
188-    let weighted_sum10 = (((if ((size(input) > 0))
189-        then (input[0] * weights[9][0])
190-        else (0 + (if ((size(input) > 1))
191-            then (input[1] * weights[9][1])
192-            else (0 + (if ((size(input) > 2))
193-                then (input[2] * weights[9][2])
194-                else (0 + (if ((size(input) > 3))
195-                    then (input[3] * weights[9][3])
196-                    else (0 + (if ((size(input) > 4))
197-                        then (input[4] * weights[9][4])
198-                        else (0 + (if ((size(input) > 5))
199-                            then (input[5] * weights[9][5])
200-                            else (0 + (if ((size(input) > 6))
201-                                then (input[6] * weights[9][6])
202-                                else (0 + (if ((size(input) > 7))
203-                                    then (input[7] * weights[9][7])
204-                                    else (0 + (if ((size(input) > 8))
205-                                        then (input[8] * weights[9][8])
206-                                        else 0))))))))))))))))) / 10000) + biases[9])
207-    let weighted_sum11 = (((if ((size(input) > 0))
208-        then (input[0] * weights[10][0])
209-        else (0 + (if ((size(input) > 1))
210-            then (input[1] * weights[10][1])
211-            else (0 + (if ((size(input) > 2))
212-                then (input[2] * weights[10][2])
213-                else (0 + (if ((size(input) > 3))
214-                    then (input[3] * weights[10][3])
215-                    else (0 + (if ((size(input) > 4))
216-                        then (input[4] * weights[10][4])
217-                        else (0 + (if ((size(input) > 5))
218-                            then (input[5] * weights[10][5])
219-                            else (0 + (if ((size(input) > 6))
220-                                then (input[6] * weights[10][6])
221-                                else (0 + (if ((size(input) > 7))
222-                                    then (input[7] * weights[10][7])
223-                                    else (0 + (if ((size(input) > 8))
224-                                        then (input[8] * weights[10][8])
225-                                        else 0))))))))))))))))) / 10000) + biases[10])
226-    let weighted_sum12 = (((if ((size(input) > 0))
227-        then (input[0] * weights[11][0])
228-        else (0 + (if ((size(input) > 1))
229-            then (input[1] * weights[11][1])
230-            else (0 + (if ((size(input) > 2))
231-                then (input[2] * weights[11][2])
232-                else (0 + (if ((size(input) > 3))
233-                    then (input[3] * weights[11][3])
234-                    else (0 + (if ((size(input) > 4))
235-                        then (input[4] * weights[11][4])
236-                        else (0 + (if ((size(input) > 5))
237-                            then (input[5] * weights[11][5])
238-                            else (0 + (if ((size(input) > 6))
239-                                then (input[6] * weights[11][6])
240-                                else (0 + (if ((size(input) > 7))
241-                                    then (input[7] * weights[11][7])
242-                                    else (0 + (if ((size(input) > 8))
243-                                        then (input[8] * weights[11][8])
244-                                        else 0))))))))))))))))) / 10000) + biases[11])
245-    let weighted_sum13 = (((if ((size(input) > 0))
246-        then (input[0] * weights[12][0])
247-        else (0 + (if ((size(input) > 1))
248-            then (input[1] * weights[12][1])
249-            else (0 + (if ((size(input) > 2))
250-                then (input[2] * weights[12][2])
251-                else (0 + (if ((size(input) > 3))
252-                    then (input[3] * weights[12][3])
253-                    else (0 + (if ((size(input) > 4))
254-                        then (input[4] * weights[12][4])
255-                        else (0 + (if ((size(input) > 5))
256-                            then (input[5] * weights[12][5])
257-                            else (0 + (if ((size(input) > 6))
258-                                then (input[6] * weights[12][6])
259-                                else (0 + (if ((size(input) > 7))
260-                                    then (input[7] * weights[12][7])
261-                                    else (0 + (if ((size(input) > 8))
262-                                        then (input[8] * weights[12][8])
263-                                        else 0))))))))))))))))) / 10000) + biases[12])
264-    let weighted_sum14 = (((if ((size(input) > 0))
265-        then (input[0] * weights[13][0])
266-        else (0 + (if ((size(input) > 1))
267-            then (input[1] * weights[13][1])
268-            else (0 + (if ((size(input) > 2))
269-                then (input[2] * weights[13][2])
270-                else (0 + (if ((size(input) > 3))
271-                    then (input[3] * weights[13][3])
272-                    else (0 + (if ((size(input) > 4))
273-                        then (input[4] * weights[13][4])
274-                        else (0 + (if ((size(input) > 5))
275-                            then (input[5] * weights[13][5])
276-                            else (0 + (if ((size(input) > 6))
277-                                then (input[6] * weights[13][6])
278-                                else (0 + (if ((size(input) > 7))
279-                                    then (input[7] * weights[13][7])
280-                                    else (0 + (if ((size(input) > 8))
281-                                        then (input[8] * weights[13][8])
282-                                        else 0))))))))))))))))) / 10000) + biases[13])
283-    let weighted_sum15 = (((if ((size(input) > 0))
284-        then (input[0] * weights[14][0])
285-        else (0 + (if ((size(input) > 1))
286-            then (input[1] * weights[14][1])
287-            else (0 + (if ((size(input) > 2))
288-                then (input[2] * weights[14][2])
289-                else (0 + (if ((size(input) > 3))
290-                    then (input[3] * weights[14][3])
291-                    else (0 + (if ((size(input) > 4))
292-                        then (input[4] * weights[14][4])
293-                        else (0 + (if ((size(input) > 5))
294-                            then (input[5] * weights[14][5])
295-                            else (0 + (if ((size(input) > 6))
296-                                then (input[6] * weights[14][6])
297-                                else (0 + (if ((size(input) > 7))
298-                                    then (input[7] * weights[14][7])
299-                                    else (0 + (if ((size(input) > 8))
300-                                        then (input[8] * weights[14][8])
301-                                        else 0))))))))))))))))) / 10000) + biases[14])
302-    let weighted_sum16 = (((if ((size(input) > 0))
303-        then (input[0] * weights[15][0])
304-        else (0 + (if ((size(input) > 1))
305-            then (input[1] * weights[15][1])
306-            else (0 + (if ((size(input) > 2))
307-                then (input[2] * weights[15][2])
308-                else (0 + (if ((size(input) > 3))
309-                    then (input[3] * weights[15][3])
310-                    else (0 + (if ((size(input) > 4))
311-                        then (input[4] * weights[15][4])
312-                        else (0 + (if ((size(input) > 5))
313-                            then (input[5] * weights[15][5])
314-                            else (0 + (if ((size(input) > 6))
315-                                then (input[6] * weights[15][6])
316-                                else (0 + (if ((size(input) > 7))
317-                                    then (input[7] * weights[15][7])
318-                                    else (0 + (if ((size(input) > 8))
319-                                        then (input[8] * weights[15][8])
320-                                        else 0))))))))))))))))) / 10000) + biases[15])
321-    let weighted_sum17 = (((if ((size(input) > 0))
322-        then (input[0] * weights[16][0])
323-        else (0 + (if ((size(input) > 1))
324-            then (input[1] * weights[16][1])
325-            else (0 + (if ((size(input) > 2))
326-                then (input[2] * weights[16][2])
327-                else (0 + (if ((size(input) > 3))
328-                    then (input[3] * weights[16][3])
329-                    else (0 + (if ((size(input) > 4))
330-                        then (input[4] * weights[16][4])
331-                        else (0 + (if ((size(input) > 5))
332-                            then (input[5] * weights[16][5])
333-                            else (0 + (if ((size(input) > 6))
334-                                then (input[6] * weights[16][6])
335-                                else (0 + (if ((size(input) > 7))
336-                                    then (input[7] * weights[16][7])
337-                                    else (0 + (if ((size(input) > 8))
338-                                        then (input[8] * weights[16][8])
339-                                        else 0))))))))))))))))) / 10000) + biases[16])
340-    let weighted_sum18 = (((if ((size(input) > 0))
341-        then (input[0] * weights[17][0])
342-        else (0 + (if ((size(input) > 1))
343-            then (input[1] * weights[17][1])
344-            else (0 + (if ((size(input) > 2))
345-                then (input[2] * weights[17][2])
346-                else (0 + (if ((size(input) > 3))
347-                    then (input[3] * weights[17][3])
348-                    else (0 + (if ((size(input) > 4))
349-                        then (input[4] * weights[17][4])
350-                        else (0 + (if ((size(input) > 5))
351-                            then (input[5] * weights[17][5])
352-                            else (0 + (if ((size(input) > 6))
353-                                then (input[6] * weights[17][6])
354-                                else (0 + (if ((size(input) > 7))
355-                                    then (input[7] * weights[17][7])
356-                                    else (0 + (if ((size(input) > 8))
357-                                        then (input[8] * weights[17][8])
358-                                        else 0))))))))))))))))) / 10000) + biases[17])
359-    let weighted_sum19 = (((if ((size(input) > 0))
360-        then (input[0] * weights[18][0])
361-        else (0 + (if ((size(input) > 1))
362-            then (input[1] * weights[18][1])
363-            else (0 + (if ((size(input) > 2))
364-                then (input[2] * weights[18][2])
365-                else (0 + (if ((size(input) > 3))
366-                    then (input[3] * weights[18][3])
367-                    else (0 + (if ((size(input) > 4))
368-                        then (input[4] * weights[18][4])
369-                        else (0 + (if ((size(input) > 5))
370-                            then (input[5] * weights[18][5])
371-                            else (0 + (if ((size(input) > 6))
372-                                then (input[6] * weights[18][6])
373-                                else (0 + (if ((size(input) > 7))
374-                                    then (input[7] * weights[18][7])
375-                                    else (0 + (if ((size(input) > 8))
376-                                        then (input[8] * weights[18][8])
377-                                        else 0))))))))))))))))) / 10000) + biases[18])
378-    let weighted_sum20 = (((if ((size(input) > 0))
379-        then (input[0] * weights[19][0])
380-        else (0 + (if ((size(input) > 1))
381-            then (input[1] * weights[19][1])
382-            else (0 + (if ((size(input) > 2))
383-                then (input[2] * weights[19][2])
384-                else (0 + (if ((size(input) > 3))
385-                    then (input[3] * weights[19][3])
386-                    else (0 + (if ((size(input) > 4))
387-                        then (input[4] * weights[19][4])
388-                        else (0 + (if ((size(input) > 5))
389-                            then (input[5] * weights[19][5])
390-                            else (0 + (if ((size(input) > 6))
391-                                then (input[6] * weights[19][6])
392-                                else (0 + (if ((size(input) > 7))
393-                                    then (input[7] * weights[19][7])
394-                                    else (0 + (if ((size(input) > 8))
395-                                        then (input[8] * weights[19][8])
396-                                        else 0))))))))))))))))) / 10000) + biases[19])
397-    let weighted_sum21 = (((if ((size(input) > 0))
398-        then (input[0] * weights[20][0])
399-        else (0 + (if ((size(input) > 1))
400-            then (input[1] * weights[20][1])
401-            else (0 + (if ((size(input) > 2))
402-                then (input[2] * weights[20][2])
403-                else (0 + (if ((size(input) > 3))
404-                    then (input[3] * weights[20][3])
405-                    else (0 + (if ((size(input) > 4))
406-                        then (input[4] * weights[20][4])
407-                        else (0 + (if ((size(input) > 5))
408-                            then (input[5] * weights[20][5])
409-                            else (0 + (if ((size(input) > 6))
410-                                then (input[6] * weights[20][6])
411-                                else (0 + (if ((size(input) > 7))
412-                                    then (input[7] * weights[20][7])
413-                                    else (0 + (if ((size(input) > 8))
414-                                        then (input[8] * weights[20][8])
415-                                        else 0))))))))))))))))) / 10000) + biases[20])
416-    let weighted_sum22 = (((if ((size(input) > 0))
417-        then (input[0] * weights[21][0])
418-        else (0 + (if ((size(input) > 1))
419-            then (input[1] * weights[21][1])
420-            else (0 + (if ((size(input) > 2))
421-                then (input[2] * weights[21][2])
422-                else (0 + (if ((size(input) > 3))
423-                    then (input[3] * weights[21][3])
424-                    else (0 + (if ((size(input) > 4))
425-                        then (input[4] * weights[21][4])
426-                        else (0 + (if ((size(input) > 5))
427-                            then (input[5] * weights[21][5])
428-                            else (0 + (if ((size(input) > 6))
429-                                then (input[6] * weights[21][6])
430-                                else (0 + (if ((size(input) > 7))
431-                                    then (input[7] * weights[21][7])
432-                                    else (0 + (if ((size(input) > 8))
433-                                        then (input[8] * weights[21][8])
434-                                        else 0))))))))))))))))) / 10000) + biases[21])
435-    let weighted_sum23 = (((if ((size(input) > 0))
436-        then (input[0] * weights[22][0])
437-        else (0 + (if ((size(input) > 1))
438-            then (input[1] * weights[22][1])
439-            else (0 + (if ((size(input) > 2))
440-                then (input[2] * weights[22][2])
441-                else (0 + (if ((size(input) > 3))
442-                    then (input[3] * weights[22][3])
443-                    else (0 + (if ((size(input) > 4))
444-                        then (input[4] * weights[22][4])
445-                        else (0 + (if ((size(input) > 5))
446-                            then (input[5] * weights[22][5])
447-                            else (0 + (if ((size(input) > 6))
448-                                then (input[6] * weights[22][6])
449-                                else (0 + (if ((size(input) > 7))
450-                                    then (input[7] * weights[22][7])
451-                                    else (0 + (if ((size(input) > 8))
452-                                        then (input[8] * weights[22][8])
453-                                        else 0))))))))))))))))) / 10000) + biases[22])
454-    let weighted_sum24 = (((if ((size(input) > 0))
455-        then (input[0] * weights[23][0])
456-        else (0 + (if ((size(input) > 1))
457-            then (input[1] * weights[23][1])
458-            else (0 + (if ((size(input) > 2))
459-                then (input[2] * weights[23][2])
460-                else (0 + (if ((size(input) > 3))
461-                    then (input[3] * weights[23][3])
462-                    else (0 + (if ((size(input) > 4))
463-                        then (input[4] * weights[23][4])
464-                        else (0 + (if ((size(input) > 5))
465-                            then (input[5] * weights[23][5])
466-                            else (0 + (if ((size(input) > 6))
467-                                then (input[6] * weights[23][6])
468-                                else (0 + (if ((size(input) > 7))
469-                                    then (input[7] * weights[23][7])
470-                                    else (0 + (if ((size(input) > 8))
471-                                        then (input[8] * weights[23][8])
472-                                        else 0))))))))))))))))) / 10000) + biases[23])
473-    let weighted_sum25 = (((if ((size(input) > 0))
474-        then (input[0] * weights[24][0])
475-        else (0 + (if ((size(input) > 1))
476-            then (input[1] * weights[24][1])
477-            else (0 + (if ((size(input) > 2))
478-                then (input[2] * weights[24][2])
479-                else (0 + (if ((size(input) > 3))
480-                    then (input[3] * weights[24][3])
481-                    else (0 + (if ((size(input) > 4))
482-                        then (input[4] * weights[24][4])
483-                        else (0 + (if ((size(input) > 5))
484-                            then (input[5] * weights[24][5])
485-                            else (0 + (if ((size(input) > 6))
486-                                then (input[6] * weights[24][6])
487-                                else (0 + (if ((size(input) > 7))
488-                                    then (input[7] * weights[24][7])
489-                                    else (0 + (if ((size(input) > 8))
490-                                        then (input[8] * weights[24][8])
491-                                        else 0))))))))))))))))) / 10000) + biases[24])
492-    let weighted_sum26 = (((if ((size(input) > 0))
493-        then (input[0] * weights[25][0])
494-        else (0 + (if ((size(input) > 1))
495-            then (input[1] * weights[25][1])
496-            else (0 + (if ((size(input) > 2))
497-                then (input[2] * weights[25][2])
498-                else (0 + (if ((size(input) > 3))
499-                    then (input[3] * weights[25][3])
500-                    else (0 + (if ((size(input) > 4))
501-                        then (input[4] * weights[25][4])
502-                        else (0 + (if ((size(input) > 5))
503-                            then (input[5] * weights[25][5])
504-                            else (0 + (if ((size(input) > 6))
505-                                then (input[6] * weights[25][6])
506-                                else (0 + (if ((size(input) > 7))
507-                                    then (input[7] * weights[25][7])
508-                                    else (0 + (if ((size(input) > 8))
509-                                        then (input[8] * weights[25][8])
510-                                        else 0))))))))))))))))) / 10000) + biases[25])
511-    let weighted_sum27 = (((if ((size(input) > 0))
512-        then (input[0] * weights[26][0])
513-        else (0 + (if ((size(input) > 1))
514-            then (input[1] * weights[26][1])
515-            else (0 + (if ((size(input) > 2))
516-                then (input[2] * weights[26][2])
517-                else (0 + (if ((size(input) > 3))
518-                    then (input[3] * weights[26][3])
519-                    else (0 + (if ((size(input) > 4))
520-                        then (input[4] * weights[26][4])
521-                        else (0 + (if ((size(input) > 5))
522-                            then (input[5] * weights[26][5])
523-                            else (0 + (if ((size(input) > 6))
524-                                then (input[6] * weights[26][6])
525-                                else (0 + (if ((size(input) > 7))
526-                                    then (input[7] * weights[26][7])
527-                                    else (0 + (if ((size(input) > 8))
528-                                        then (input[8] * weights[26][8])
529-                                        else 0))))))))))))))))) / 10000) + biases[26])
530-    let weighted_sum28 = (((if ((size(input) > 0))
531-        then (input[0] * weights[27][0])
532-        else (0 + (if ((size(input) > 1))
533-            then (input[1] * weights[27][1])
534-            else (0 + (if ((size(input) > 2))
535-                then (input[2] * weights[27][2])
536-                else (0 + (if ((size(input) > 3))
537-                    then (input[3] * weights[27][3])
538-                    else (0 + (if ((size(input) > 4))
539-                        then (input[4] * weights[27][4])
540-                        else (0 + (if ((size(input) > 5))
541-                            then (input[5] * weights[27][5])
542-                            else (0 + (if ((size(input) > 6))
543-                                then (input[6] * weights[27][6])
544-                                else (0 + (if ((size(input) > 7))
545-                                    then (input[7] * weights[27][7])
546-                                    else (0 + (if ((size(input) > 8))
547-                                        then (input[8] * weights[27][8])
548-                                        else 0))))))))))))))))) / 10000) + biases[27])
549-    let weighted_sum29 = (((if ((size(input) > 0))
550-        then (input[0] * weights[28][0])
551-        else (0 + (if ((size(input) > 1))
552-            then (input[1] * weights[28][1])
553-            else (0 + (if ((size(input) > 2))
554-                then (input[2] * weights[28][2])
555-                else (0 + (if ((size(input) > 3))
556-                    then (input[3] * weights[28][3])
557-                    else (0 + (if ((size(input) > 4))
558-                        then (input[4] * weights[28][4])
559-                        else (0 + (if ((size(input) > 5))
560-                            then (input[5] * weights[28][5])
561-                            else (0 + (if ((size(input) > 6))
562-                                then (input[6] * weights[28][6])
563-                                else (0 + (if ((size(input) > 7))
564-                                    then (input[7] * weights[28][7])
565-                                    else (0 + (if ((size(input) > 8))
566-                                        then (input[8] * weights[28][8])
567-                                        else 0))))))))))))))))) / 10000) + biases[28])
568-    let weighted_sum30 = (((if ((size(input) > 0))
569-        then (input[0] * weights[29][0])
570-        else (0 + (if ((size(input) > 1))
571-            then (input[1] * weights[29][1])
572-            else (0 + (if ((size(input) > 2))
573-                then (input[2] * weights[29][2])
574-                else (0 + (if ((size(input) > 3))
575-                    then (input[3] * weights[29][3])
576-                    else (0 + (if ((size(input) > 4))
577-                        then (input[4] * weights[29][4])
578-                        else (0 + (if ((size(input) > 5))
579-                            then (input[5] * weights[29][5])
580-                            else (0 + (if ((size(input) > 6))
581-                                then (input[6] * weights[29][6])
582-                                else (0 + (if ((size(input) > 7))
583-                                    then (input[7] * weights[29][7])
584-                                    else (0 + (if ((size(input) > 8))
585-                                        then (input[8] * weights[29][8])
586-                                        else 0))))))))))))))))) / 10000) + biases[29])
587-    let weighted_sum31 = (((if ((size(input) > 0))
588-        then (input[0] * weights[30][0])
589-        else (0 + (if ((size(input) > 1))
590-            then (input[1] * weights[30][1])
591-            else (0 + (if ((size(input) > 2))
592-                then (input[2] * weights[30][2])
593-                else (0 + (if ((size(input) > 3))
594-                    then (input[3] * weights[30][3])
595-                    else (0 + (if ((size(input) > 4))
596-                        then (input[4] * weights[30][4])
597-                        else (0 + (if ((size(input) > 5))
598-                            then (input[5] * weights[30][5])
599-                            else (0 + (if ((size(input) > 6))
600-                                then (input[6] * weights[30][6])
601-                                else (0 + (if ((size(input) > 7))
602-                                    then (input[7] * weights[30][7])
603-                                    else (0 + (if ((size(input) > 8))
604-                                        then (input[8] * weights[30][8])
605-                                        else 0))))))))))))))))) / 10000) + biases[30])
606-    let weighted_sum32 = (((if ((size(input) > 0))
607-        then (input[0] * weights[31][0])
608-        else (0 + (if ((size(input) > 1))
609-            then (input[1] * weights[31][1])
610-            else (0 + (if ((size(input) > 2))
611-                then (input[2] * weights[31][2])
612-                else (0 + (if ((size(input) > 3))
613-                    then (input[3] * weights[31][3])
614-                    else (0 + (if ((size(input) > 4))
615-                        then (input[4] * weights[31][4])
616-                        else (0 + (if ((size(input) > 5))
617-                            then (input[5] * weights[31][5])
618-                            else (0 + (if ((size(input) > 6))
619-                                then (input[6] * weights[31][6])
620-                                else (0 + (if ((size(input) > 7))
621-                                    then (input[7] * weights[31][7])
622-                                    else (0 + (if ((size(input) > 8))
623-                                        then (input[8] * weights[31][8])
624-                                        else 0))))))))))))))))) / 10000) + biases[31])
625-    let weighted_sum33 = (((if ((size(input) > 0))
626-        then (input[0] * weights[32][0])
627-        else (0 + (if ((size(input) > 1))
628-            then (input[1] * weights[32][1])
629-            else (0 + (if ((size(input) > 2))
630-                then (input[2] * weights[32][2])
631-                else (0 + (if ((size(input) > 3))
632-                    then (input[3] * weights[32][3])
633-                    else (0 + (if ((size(input) > 4))
634-                        then (input[4] * weights[32][4])
635-                        else (0 + (if ((size(input) > 5))
636-                            then (input[5] * weights[32][5])
637-                            else (0 + (if ((size(input) > 6))
638-                                then (input[6] * weights[32][6])
639-                                else (0 + (if ((size(input) > 7))
640-                                    then (input[7] * weights[32][7])
641-                                    else (0 + (if ((size(input) > 8))
642-                                        then (input[8] * weights[32][8])
643-                                        else 0))))))))))))))))) / 10000) + biases[32])
644-    let weighted_sum34 = (((if ((size(input) > 0))
645-        then (input[0] * weights[33][0])
646-        else (0 + (if ((size(input) > 1))
647-            then (input[1] * weights[33][1])
648-            else (0 + (if ((size(input) > 2))
649-                then (input[2] * weights[33][2])
650-                else (0 + (if ((size(input) > 3))
651-                    then (input[3] * weights[33][3])
652-                    else (0 + (if ((size(input) > 4))
653-                        then (input[4] * weights[33][4])
654-                        else (0 + (if ((size(input) > 5))
655-                            then (input[5] * weights[33][5])
656-                            else (0 + (if ((size(input) > 6))
657-                                then (input[6] * weights[33][6])
658-                                else (0 + (if ((size(input) > 7))
659-                                    then (input[7] * weights[33][7])
660-                                    else (0 + (if ((size(input) > 8))
661-                                        then (input[8] * weights[33][8])
662-                                        else 0))))))))))))))))) / 10000) + biases[33])
663-    let weighted_sum35 = (((if ((size(input) > 0))
664-        then (input[0] * weights[34][0])
665-        else (0 + (if ((size(input) > 1))
666-            then (input[1] * weights[34][1])
667-            else (0 + (if ((size(input) > 2))
668-                then (input[2] * weights[34][2])
669-                else (0 + (if ((size(input) > 3))
670-                    then (input[3] * weights[34][3])
671-                    else (0 + (if ((size(input) > 4))
672-                        then (input[4] * weights[34][4])
673-                        else (0 + (if ((size(input) > 5))
674-                            then (input[5] * weights[34][5])
675-                            else (0 + (if ((size(input) > 6))
676-                                then (input[6] * weights[34][6])
677-                                else (0 + (if ((size(input) > 7))
678-                                    then (input[7] * weights[34][7])
679-                                    else (0 + (if ((size(input) > 8))
680-                                        then (input[8] * weights[34][8])
681-                                        else 0))))))))))))))))) / 10000) + biases[34])
682-    let weighted_sum36 = (((if ((size(input) > 0))
683-        then (input[0] * weights[35][0])
684-        else (0 + (if ((size(input) > 1))
685-            then (input[1] * weights[35][1])
686-            else (0 + (if ((size(input) > 2))
687-                then (input[2] * weights[35][2])
688-                else (0 + (if ((size(input) > 3))
689-                    then (input[3] * weights[35][3])
690-                    else (0 + (if ((size(input) > 4))
691-                        then (input[4] * weights[35][4])
692-                        else (0 + (if ((size(input) > 5))
693-                            then (input[5] * weights[35][5])
694-                            else (0 + (if ((size(input) > 6))
695-                                then (input[6] * weights[35][6])
696-                                else (0 + (if ((size(input) > 7))
697-                                    then (input[7] * weights[35][7])
698-                                    else (0 + (if ((size(input) > 8))
699-                                        then (input[8] * weights[35][8])
700-                                        else 0))))))))))))))))) / 10000) + biases[35])
701-[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9, weighted_sum10, weighted_sum11, weighted_sum12, weighted_sum13, weighted_sum14, weighted_sum15, weighted_sum16, weighted_sum17, weighted_sum18, weighted_sum19, weighted_sum20, weighted_sum21, weighted_sum22, weighted_sum23, weighted_sum24, weighted_sum25, weighted_sum26, weighted_sum27, weighted_sum28, weighted_sum29, weighted_sum30, weighted_sum31, weighted_sum32, weighted_sum33, weighted_sum34, weighted_sum35, weighted_sum36]
13+    let weighted_sum1 = ((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) / 10000) + biases[0])
14+    let weighted_sum2 = ((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) / 10000) + biases[1])
15+[weighted_sum1, weighted_sum2]
70216     }
70317 
70418 
70519 func linear_forward_2 (input,weights,biases) = {
706-    let weighted_sum1 = (((if ((size(input) > 0))
707-        then (input[0] * weights[0][0])
708-        else (0 + (if ((size(input) > 1))
709-            then (input[1] * weights[0][1])
710-            else (0 + (if ((size(input) > 2))
711-                then (input[2] * weights[0][2])
712-                else (0 + (if ((size(input) > 3))
713-                    then (input[3] * weights[0][3])
714-                    else (0 + (if ((size(input) > 4))
715-                        then (input[4] * weights[0][4])
716-                        else (0 + (if ((size(input) > 5))
717-                            then (input[5] * weights[0][5])
718-                            else (0 + (if ((size(input) > 6))
719-                                then (input[6] * weights[0][6])
720-                                else (0 + (if ((size(input) > 7))
721-                                    then (input[7] * weights[0][7])
722-                                    else (0 + (if ((size(input) > 8))
723-                                        then (input[8] * weights[0][8])
724-                                        else (0 + (if ((size(input) > 9))
725-                                            then (input[9] * weights[0][9])
726-                                            else (0 + (if ((size(input) > 10))
727-                                                then (input[10] * weights[0][10])
728-                                                else (0 + (if ((size(input) > 11))
729-                                                    then (input[11] * weights[0][11])
730-                                                    else (0 + (if ((size(input) > 12))
731-                                                        then (input[12] * weights[0][12])
732-                                                        else (0 + (if ((size(input) > 13))
733-                                                            then (input[13] * weights[0][13])
734-                                                            else (0 + (if ((size(input) > 14))
735-                                                                then (input[14] * weights[0][14])
736-                                                                else (0 + (if ((size(input) > 15))
737-                                                                    then (input[15] * weights[0][15])
738-                                                                    else (0 + (if ((size(input) > 16))
739-                                                                        then (input[16] * weights[0][16])
740-                                                                        else (0 + (if ((size(input) > 17))
741-                                                                            then (input[17] * weights[0][17])
742-                                                                            else (0 + (if ((size(input) > 18))
743-                                                                                then (input[18] * weights[0][18])
744-                                                                                else (0 + (if ((size(input) > 19))
745-                                                                                    then (input[19] * weights[0][19])
746-                                                                                    else (0 + (if ((size(input) > 20))
747-                                                                                        then (input[20] * weights[0][20])
748-                                                                                        else (0 + (if ((size(input) > 21))
749-                                                                                            then (input[21] * weights[0][21])
750-                                                                                            else (0 + (if ((size(input) > 22))
751-                                                                                                then (input[22] * weights[0][22])
752-                                                                                                else (0 + (if ((size(input) > 23))
753-                                                                                                    then (input[23] * weights[0][23])
754-                                                                                                    else (0 + (if ((size(input) > 24))
755-                                                                                                        then (input[24] * weights[0][24])
756-                                                                                                        else (0 + (if ((size(input) > 25))
757-                                                                                                            then (input[25] * weights[0][25])
758-                                                                                                            else (0 + (if ((size(input) > 26))
759-                                                                                                                then (input[26] * weights[0][26])
760-                                                                                                                else (0 + (if ((size(input) > 27))
761-                                                                                                                    then (input[27] * weights[0][27])
762-                                                                                                                    else (0 + (if ((size(input) > 28))
763-                                                                                                                        then (input[28] * weights[0][28])
764-                                                                                                                        else (0 + (if ((size(input) > 29))
765-                                                                                                                            then (input[29] * weights[0][29])
766-                                                                                                                            else (0 + (if ((size(input) > 30))
767-                                                                                                                                then (input[30] * weights[0][30])
768-                                                                                                                                else (0 + (if ((size(input) > 31))
769-                                                                                                                                    then (input[31] * weights[0][31])
770-                                                                                                                                    else (0 + (if ((size(input) > 32))
771-                                                                                                                                        then (input[32] * weights[0][32])
772-                                                                                                                                        else (0 + (if ((size(input) > 33))
773-                                                                                                                                            then (input[33] * weights[0][33])
774-                                                                                                                                            else (0 + (if ((size(input) > 34))
775-                                                                                                                                                then (input[34] * weights[0][34])
776-                                                                                                                                                else (0 + (if ((size(input) > 35))
777-                                                                                                                                                    then (input[35] * weights[0][35])
778-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[0])
779-    let weighted_sum2 = (((if ((size(input) > 0))
780-        then (input[0] * weights[1][0])
781-        else (0 + (if ((size(input) > 1))
782-            then (input[1] * weights[1][1])
783-            else (0 + (if ((size(input) > 2))
784-                then (input[2] * weights[1][2])
785-                else (0 + (if ((size(input) > 3))
786-                    then (input[3] * weights[1][3])
787-                    else (0 + (if ((size(input) > 4))
788-                        then (input[4] * weights[1][4])
789-                        else (0 + (if ((size(input) > 5))
790-                            then (input[5] * weights[1][5])
791-                            else (0 + (if ((size(input) > 6))
792-                                then (input[6] * weights[1][6])
793-                                else (0 + (if ((size(input) > 7))
794-                                    then (input[7] * weights[1][7])
795-                                    else (0 + (if ((size(input) > 8))
796-                                        then (input[8] * weights[1][8])
797-                                        else (0 + (if ((size(input) > 9))
798-                                            then (input[9] * weights[1][9])
799-                                            else (0 + (if ((size(input) > 10))
800-                                                then (input[10] * weights[1][10])
801-                                                else (0 + (if ((size(input) > 11))
802-                                                    then (input[11] * weights[1][11])
803-                                                    else (0 + (if ((size(input) > 12))
804-                                                        then (input[12] * weights[1][12])
805-                                                        else (0 + (if ((size(input) > 13))
806-                                                            then (input[13] * weights[1][13])
807-                                                            else (0 + (if ((size(input) > 14))
808-                                                                then (input[14] * weights[1][14])
809-                                                                else (0 + (if ((size(input) > 15))
810-                                                                    then (input[15] * weights[1][15])
811-                                                                    else (0 + (if ((size(input) > 16))
812-                                                                        then (input[16] * weights[1][16])
813-                                                                        else (0 + (if ((size(input) > 17))
814-                                                                            then (input[17] * weights[1][17])
815-                                                                            else (0 + (if ((size(input) > 18))
816-                                                                                then (input[18] * weights[1][18])
817-                                                                                else (0 + (if ((size(input) > 19))
818-                                                                                    then (input[19] * weights[1][19])
819-                                                                                    else (0 + (if ((size(input) > 20))
820-                                                                                        then (input[20] * weights[1][20])
821-                                                                                        else (0 + (if ((size(input) > 21))
822-                                                                                            then (input[21] * weights[1][21])
823-                                                                                            else (0 + (if ((size(input) > 22))
824-                                                                                                then (input[22] * weights[1][22])
825-                                                                                                else (0 + (if ((size(input) > 23))
826-                                                                                                    then (input[23] * weights[1][23])
827-                                                                                                    else (0 + (if ((size(input) > 24))
828-                                                                                                        then (input[24] * weights[1][24])
829-                                                                                                        else (0 + (if ((size(input) > 25))
830-                                                                                                            then (input[25] * weights[1][25])
831-                                                                                                            else (0 + (if ((size(input) > 26))
832-                                                                                                                then (input[26] * weights[1][26])
833-                                                                                                                else (0 + (if ((size(input) > 27))
834-                                                                                                                    then (input[27] * weights[1][27])
835-                                                                                                                    else (0 + (if ((size(input) > 28))
836-                                                                                                                        then (input[28] * weights[1][28])
837-                                                                                                                        else (0 + (if ((size(input) > 29))
838-                                                                                                                            then (input[29] * weights[1][29])
839-                                                                                                                            else (0 + (if ((size(input) > 30))
840-                                                                                                                                then (input[30] * weights[1][30])
841-                                                                                                                                else (0 + (if ((size(input) > 31))
842-                                                                                                                                    then (input[31] * weights[1][31])
843-                                                                                                                                    else (0 + (if ((size(input) > 32))
844-                                                                                                                                        then (input[32] * weights[1][32])
845-                                                                                                                                        else (0 + (if ((size(input) > 33))
846-                                                                                                                                            then (input[33] * weights[1][33])
847-                                                                                                                                            else (0 + (if ((size(input) > 34))
848-                                                                                                                                                then (input[34] * weights[1][34])
849-                                                                                                                                                else (0 + (if ((size(input) > 35))
850-                                                                                                                                                    then (input[35] * weights[1][35])
851-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[1])
852-    let weighted_sum3 = (((if ((size(input) > 0))
853-        then (input[0] * weights[2][0])
854-        else (0 + (if ((size(input) > 1))
855-            then (input[1] * weights[2][1])
856-            else (0 + (if ((size(input) > 2))
857-                then (input[2] * weights[2][2])
858-                else (0 + (if ((size(input) > 3))
859-                    then (input[3] * weights[2][3])
860-                    else (0 + (if ((size(input) > 4))
861-                        then (input[4] * weights[2][4])
862-                        else (0 + (if ((size(input) > 5))
863-                            then (input[5] * weights[2][5])
864-                            else (0 + (if ((size(input) > 6))
865-                                then (input[6] * weights[2][6])
866-                                else (0 + (if ((size(input) > 7))
867-                                    then (input[7] * weights[2][7])
868-                                    else (0 + (if ((size(input) > 8))
869-                                        then (input[8] * weights[2][8])
870-                                        else (0 + (if ((size(input) > 9))
871-                                            then (input[9] * weights[2][9])
872-                                            else (0 + (if ((size(input) > 10))
873-                                                then (input[10] * weights[2][10])
874-                                                else (0 + (if ((size(input) > 11))
875-                                                    then (input[11] * weights[2][11])
876-                                                    else (0 + (if ((size(input) > 12))
877-                                                        then (input[12] * weights[2][12])
878-                                                        else (0 + (if ((size(input) > 13))
879-                                                            then (input[13] * weights[2][13])
880-                                                            else (0 + (if ((size(input) > 14))
881-                                                                then (input[14] * weights[2][14])
882-                                                                else (0 + (if ((size(input) > 15))
883-                                                                    then (input[15] * weights[2][15])
884-                                                                    else (0 + (if ((size(input) > 16))
885-                                                                        then (input[16] * weights[2][16])
886-                                                                        else (0 + (if ((size(input) > 17))
887-                                                                            then (input[17] * weights[2][17])
888-                                                                            else (0 + (if ((size(input) > 18))
889-                                                                                then (input[18] * weights[2][18])
890-                                                                                else (0 + (if ((size(input) > 19))
891-                                                                                    then (input[19] * weights[2][19])
892-                                                                                    else (0 + (if ((size(input) > 20))
893-                                                                                        then (input[20] * weights[2][20])
894-                                                                                        else (0 + (if ((size(input) > 21))
895-                                                                                            then (input[21] * weights[2][21])
896-                                                                                            else (0 + (if ((size(input) > 22))
897-                                                                                                then (input[22] * weights[2][22])
898-                                                                                                else (0 + (if ((size(input) > 23))
899-                                                                                                    then (input[23] * weights[2][23])
900-                                                                                                    else (0 + (if ((size(input) > 24))
901-                                                                                                        then (input[24] * weights[2][24])
902-                                                                                                        else (0 + (if ((size(input) > 25))
903-                                                                                                            then (input[25] * weights[2][25])
904-                                                                                                            else (0 + (if ((size(input) > 26))
905-                                                                                                                then (input[26] * weights[2][26])
906-                                                                                                                else (0 + (if ((size(input) > 27))
907-                                                                                                                    then (input[27] * weights[2][27])
908-                                                                                                                    else (0 + (if ((size(input) > 28))
909-                                                                                                                        then (input[28] * weights[2][28])
910-                                                                                                                        else (0 + (if ((size(input) > 29))
911-                                                                                                                            then (input[29] * weights[2][29])
912-                                                                                                                            else (0 + (if ((size(input) > 30))
913-                                                                                                                                then (input[30] * weights[2][30])
914-                                                                                                                                else (0 + (if ((size(input) > 31))
915-                                                                                                                                    then (input[31] * weights[2][31])
916-                                                                                                                                    else (0 + (if ((size(input) > 32))
917-                                                                                                                                        then (input[32] * weights[2][32])
918-                                                                                                                                        else (0 + (if ((size(input) > 33))
919-                                                                                                                                            then (input[33] * weights[2][33])
920-                                                                                                                                            else (0 + (if ((size(input) > 34))
921-                                                                                                                                                then (input[34] * weights[2][34])
922-                                                                                                                                                else (0 + (if ((size(input) > 35))
923-                                                                                                                                                    then (input[35] * weights[2][35])
924-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[2])
925-    let weighted_sum4 = (((if ((size(input) > 0))
926-        then (input[0] * weights[3][0])
927-        else (0 + (if ((size(input) > 1))
928-            then (input[1] * weights[3][1])
929-            else (0 + (if ((size(input) > 2))
930-                then (input[2] * weights[3][2])
931-                else (0 + (if ((size(input) > 3))
932-                    then (input[3] * weights[3][3])
933-                    else (0 + (if ((size(input) > 4))
934-                        then (input[4] * weights[3][4])
935-                        else (0 + (if ((size(input) > 5))
936-                            then (input[5] * weights[3][5])
937-                            else (0 + (if ((size(input) > 6))
938-                                then (input[6] * weights[3][6])
939-                                else (0 + (if ((size(input) > 7))
940-                                    then (input[7] * weights[3][7])
941-                                    else (0 + (if ((size(input) > 8))
942-                                        then (input[8] * weights[3][8])
943-                                        else (0 + (if ((size(input) > 9))
944-                                            then (input[9] * weights[3][9])
945-                                            else (0 + (if ((size(input) > 10))
946-                                                then (input[10] * weights[3][10])
947-                                                else (0 + (if ((size(input) > 11))
948-                                                    then (input[11] * weights[3][11])
949-                                                    else (0 + (if ((size(input) > 12))
950-                                                        then (input[12] * weights[3][12])
951-                                                        else (0 + (if ((size(input) > 13))
952-                                                            then (input[13] * weights[3][13])
953-                                                            else (0 + (if ((size(input) > 14))
954-                                                                then (input[14] * weights[3][14])
955-                                                                else (0 + (if ((size(input) > 15))
956-                                                                    then (input[15] * weights[3][15])
957-                                                                    else (0 + (if ((size(input) > 16))
958-                                                                        then (input[16] * weights[3][16])
959-                                                                        else (0 + (if ((size(input) > 17))
960-                                                                            then (input[17] * weights[3][17])
961-                                                                            else (0 + (if ((size(input) > 18))
962-                                                                                then (input[18] * weights[3][18])
963-                                                                                else (0 + (if ((size(input) > 19))
964-                                                                                    then (input[19] * weights[3][19])
965-                                                                                    else (0 + (if ((size(input) > 20))
966-                                                                                        then (input[20] * weights[3][20])
967-                                                                                        else (0 + (if ((size(input) > 21))
968-                                                                                            then (input[21] * weights[3][21])
969-                                                                                            else (0 + (if ((size(input) > 22))
970-                                                                                                then (input[22] * weights[3][22])
971-                                                                                                else (0 + (if ((size(input) > 23))
972-                                                                                                    then (input[23] * weights[3][23])
973-                                                                                                    else (0 + (if ((size(input) > 24))
974-                                                                                                        then (input[24] * weights[3][24])
975-                                                                                                        else (0 + (if ((size(input) > 25))
976-                                                                                                            then (input[25] * weights[3][25])
977-                                                                                                            else (0 + (if ((size(input) > 26))
978-                                                                                                                then (input[26] * weights[3][26])
979-                                                                                                                else (0 + (if ((size(input) > 27))
980-                                                                                                                    then (input[27] * weights[3][27])
981-                                                                                                                    else (0 + (if ((size(input) > 28))
982-                                                                                                                        then (input[28] * weights[3][28])
983-                                                                                                                        else (0 + (if ((size(input) > 29))
984-                                                                                                                            then (input[29] * weights[3][29])
985-                                                                                                                            else (0 + (if ((size(input) > 30))
986-                                                                                                                                then (input[30] * weights[3][30])
987-                                                                                                                                else (0 + (if ((size(input) > 31))
988-                                                                                                                                    then (input[31] * weights[3][31])
989-                                                                                                                                    else (0 + (if ((size(input) > 32))
990-                                                                                                                                        then (input[32] * weights[3][32])
991-                                                                                                                                        else (0 + (if ((size(input) > 33))
992-                                                                                                                                            then (input[33] * weights[3][33])
993-                                                                                                                                            else (0 + (if ((size(input) > 34))
994-                                                                                                                                                then (input[34] * weights[3][34])
995-                                                                                                                                                else (0 + (if ((size(input) > 35))
996-                                                                                                                                                    then (input[35] * weights[3][35])
997-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[3])
998-    let weighted_sum5 = (((if ((size(input) > 0))
999-        then (input[0] * weights[4][0])
1000-        else (0 + (if ((size(input) > 1))
1001-            then (input[1] * weights[4][1])
1002-            else (0 + (if ((size(input) > 2))
1003-                then (input[2] * weights[4][2])
1004-                else (0 + (if ((size(input) > 3))
1005-                    then (input[3] * weights[4][3])
1006-                    else (0 + (if ((size(input) > 4))
1007-                        then (input[4] * weights[4][4])
1008-                        else (0 + (if ((size(input) > 5))
1009-                            then (input[5] * weights[4][5])
1010-                            else (0 + (if ((size(input) > 6))
1011-                                then (input[6] * weights[4][6])
1012-                                else (0 + (if ((size(input) > 7))
1013-                                    then (input[7] * weights[4][7])
1014-                                    else (0 + (if ((size(input) > 8))
1015-                                        then (input[8] * weights[4][8])
1016-                                        else (0 + (if ((size(input) > 9))
1017-                                            then (input[9] * weights[4][9])
1018-                                            else (0 + (if ((size(input) > 10))
1019-                                                then (input[10] * weights[4][10])
1020-                                                else (0 + (if ((size(input) > 11))
1021-                                                    then (input[11] * weights[4][11])
1022-                                                    else (0 + (if ((size(input) > 12))
1023-                                                        then (input[12] * weights[4][12])
1024-                                                        else (0 + (if ((size(input) > 13))
1025-                                                            then (input[13] * weights[4][13])
1026-                                                            else (0 + (if ((size(input) > 14))
1027-                                                                then (input[14] * weights[4][14])
1028-                                                                else (0 + (if ((size(input) > 15))
1029-                                                                    then (input[15] * weights[4][15])
1030-                                                                    else (0 + (if ((size(input) > 16))
1031-                                                                        then (input[16] * weights[4][16])
1032-                                                                        else (0 + (if ((size(input) > 17))
1033-                                                                            then (input[17] * weights[4][17])
1034-                                                                            else (0 + (if ((size(input) > 18))
1035-                                                                                then (input[18] * weights[4][18])
1036-                                                                                else (0 + (if ((size(input) > 19))
1037-                                                                                    then (input[19] * weights[4][19])
1038-                                                                                    else (0 + (if ((size(input) > 20))
1039-                                                                                        then (input[20] * weights[4][20])
1040-                                                                                        else (0 + (if ((size(input) > 21))
1041-                                                                                            then (input[21] * weights[4][21])
1042-                                                                                            else (0 + (if ((size(input) > 22))
1043-                                                                                                then (input[22] * weights[4][22])
1044-                                                                                                else (0 + (if ((size(input) > 23))
1045-                                                                                                    then (input[23] * weights[4][23])
1046-                                                                                                    else (0 + (if ((size(input) > 24))
1047-                                                                                                        then (input[24] * weights[4][24])
1048-                                                                                                        else (0 + (if ((size(input) > 25))
1049-                                                                                                            then (input[25] * weights[4][25])
1050-                                                                                                            else (0 + (if ((size(input) > 26))
1051-                                                                                                                then (input[26] * weights[4][26])
1052-                                                                                                                else (0 + (if ((size(input) > 27))
1053-                                                                                                                    then (input[27] * weights[4][27])
1054-                                                                                                                    else (0 + (if ((size(input) > 28))
1055-                                                                                                                        then (input[28] * weights[4][28])
1056-                                                                                                                        else (0 + (if ((size(input) > 29))
1057-                                                                                                                            then (input[29] * weights[4][29])
1058-                                                                                                                            else (0 + (if ((size(input) > 30))
1059-                                                                                                                                then (input[30] * weights[4][30])
1060-                                                                                                                                else (0 + (if ((size(input) > 31))
1061-                                                                                                                                    then (input[31] * weights[4][31])
1062-                                                                                                                                    else (0 + (if ((size(input) > 32))
1063-                                                                                                                                        then (input[32] * weights[4][32])
1064-                                                                                                                                        else (0 + (if ((size(input) > 33))
1065-                                                                                                                                            then (input[33] * weights[4][33])
1066-                                                                                                                                            else (0 + (if ((size(input) > 34))
1067-                                                                                                                                                then (input[34] * weights[4][34])
1068-                                                                                                                                                else (0 + (if ((size(input) > 35))
1069-                                                                                                                                                    then (input[35] * weights[4][35])
1070-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[4])
1071-    let weighted_sum6 = (((if ((size(input) > 0))
1072-        then (input[0] * weights[5][0])
1073-        else (0 + (if ((size(input) > 1))
1074-            then (input[1] * weights[5][1])
1075-            else (0 + (if ((size(input) > 2))
1076-                then (input[2] * weights[5][2])
1077-                else (0 + (if ((size(input) > 3))
1078-                    then (input[3] * weights[5][3])
1079-                    else (0 + (if ((size(input) > 4))
1080-                        then (input[4] * weights[5][4])
1081-                        else (0 + (if ((size(input) > 5))
1082-                            then (input[5] * weights[5][5])
1083-                            else (0 + (if ((size(input) > 6))
1084-                                then (input[6] * weights[5][6])
1085-                                else (0 + (if ((size(input) > 7))
1086-                                    then (input[7] * weights[5][7])
1087-                                    else (0 + (if ((size(input) > 8))
1088-                                        then (input[8] * weights[5][8])
1089-                                        else (0 + (if ((size(input) > 9))
1090-                                            then (input[9] * weights[5][9])
1091-                                            else (0 + (if ((size(input) > 10))
1092-                                                then (input[10] * weights[5][10])
1093-                                                else (0 + (if ((size(input) > 11))
1094-                                                    then (input[11] * weights[5][11])
1095-                                                    else (0 + (if ((size(input) > 12))
1096-                                                        then (input[12] * weights[5][12])
1097-                                                        else (0 + (if ((size(input) > 13))
1098-                                                            then (input[13] * weights[5][13])
1099-                                                            else (0 + (if ((size(input) > 14))
1100-                                                                then (input[14] * weights[5][14])
1101-                                                                else (0 + (if ((size(input) > 15))
1102-                                                                    then (input[15] * weights[5][15])
1103-                                                                    else (0 + (if ((size(input) > 16))
1104-                                                                        then (input[16] * weights[5][16])
1105-                                                                        else (0 + (if ((size(input) > 17))
1106-                                                                            then (input[17] * weights[5][17])
1107-                                                                            else (0 + (if ((size(input) > 18))
1108-                                                                                then (input[18] * weights[5][18])
1109-                                                                                else (0 + (if ((size(input) > 19))
1110-                                                                                    then (input[19] * weights[5][19])
1111-                                                                                    else (0 + (if ((size(input) > 20))
1112-                                                                                        then (input[20] * weights[5][20])
1113-                                                                                        else (0 + (if ((size(input) > 21))
1114-                                                                                            then (input[21] * weights[5][21])
1115-                                                                                            else (0 + (if ((size(input) > 22))
1116-                                                                                                then (input[22] * weights[5][22])
1117-                                                                                                else (0 + (if ((size(input) > 23))
1118-                                                                                                    then (input[23] * weights[5][23])
1119-                                                                                                    else (0 + (if ((size(input) > 24))
1120-                                                                                                        then (input[24] * weights[5][24])
1121-                                                                                                        else (0 + (if ((size(input) > 25))
1122-                                                                                                            then (input[25] * weights[5][25])
1123-                                                                                                            else (0 + (if ((size(input) > 26))
1124-                                                                                                                then (input[26] * weights[5][26])
1125-                                                                                                                else (0 + (if ((size(input) > 27))
1126-                                                                                                                    then (input[27] * weights[5][27])
1127-                                                                                                                    else (0 + (if ((size(input) > 28))
1128-                                                                                                                        then (input[28] * weights[5][28])
1129-                                                                                                                        else (0 + (if ((size(input) > 29))
1130-                                                                                                                            then (input[29] * weights[5][29])
1131-                                                                                                                            else (0 + (if ((size(input) > 30))
1132-                                                                                                                                then (input[30] * weights[5][30])
1133-                                                                                                                                else (0 + (if ((size(input) > 31))
1134-                                                                                                                                    then (input[31] * weights[5][31])
1135-                                                                                                                                    else (0 + (if ((size(input) > 32))
1136-                                                                                                                                        then (input[32] * weights[5][32])
1137-                                                                                                                                        else (0 + (if ((size(input) > 33))
1138-                                                                                                                                            then (input[33] * weights[5][33])
1139-                                                                                                                                            else (0 + (if ((size(input) > 34))
1140-                                                                                                                                                then (input[34] * weights[5][34])
1141-                                                                                                                                                else (0 + (if ((size(input) > 35))
1142-                                                                                                                                                    then (input[35] * weights[5][35])
1143-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[5])
1144-    let weighted_sum7 = (((if ((size(input) > 0))
1145-        then (input[0] * weights[6][0])
1146-        else (0 + (if ((size(input) > 1))
1147-            then (input[1] * weights[6][1])
1148-            else (0 + (if ((size(input) > 2))
1149-                then (input[2] * weights[6][2])
1150-                else (0 + (if ((size(input) > 3))
1151-                    then (input[3] * weights[6][3])
1152-                    else (0 + (if ((size(input) > 4))
1153-                        then (input[4] * weights[6][4])
1154-                        else (0 + (if ((size(input) > 5))
1155-                            then (input[5] * weights[6][5])
1156-                            else (0 + (if ((size(input) > 6))
1157-                                then (input[6] * weights[6][6])
1158-                                else (0 + (if ((size(input) > 7))
1159-                                    then (input[7] * weights[6][7])
1160-                                    else (0 + (if ((size(input) > 8))
1161-                                        then (input[8] * weights[6][8])
1162-                                        else (0 + (if ((size(input) > 9))
1163-                                            then (input[9] * weights[6][9])
1164-                                            else (0 + (if ((size(input) > 10))
1165-                                                then (input[10] * weights[6][10])
1166-                                                else (0 + (if ((size(input) > 11))
1167-                                                    then (input[11] * weights[6][11])
1168-                                                    else (0 + (if ((size(input) > 12))
1169-                                                        then (input[12] * weights[6][12])
1170-                                                        else (0 + (if ((size(input) > 13))
1171-                                                            then (input[13] * weights[6][13])
1172-                                                            else (0 + (if ((size(input) > 14))
1173-                                                                then (input[14] * weights[6][14])
1174-                                                                else (0 + (if ((size(input) > 15))
1175-                                                                    then (input[15] * weights[6][15])
1176-                                                                    else (0 + (if ((size(input) > 16))
1177-                                                                        then (input[16] * weights[6][16])
1178-                                                                        else (0 + (if ((size(input) > 17))
1179-                                                                            then (input[17] * weights[6][17])
1180-                                                                            else (0 + (if ((size(input) > 18))
1181-                                                                                then (input[18] * weights[6][18])
1182-                                                                                else (0 + (if ((size(input) > 19))
1183-                                                                                    then (input[19] * weights[6][19])
1184-                                                                                    else (0 + (if ((size(input) > 20))
1185-                                                                                        then (input[20] * weights[6][20])
1186-                                                                                        else (0 + (if ((size(input) > 21))
1187-                                                                                            then (input[21] * weights[6][21])
1188-                                                                                            else (0 + (if ((size(input) > 22))
1189-                                                                                                then (input[22] * weights[6][22])
1190-                                                                                                else (0 + (if ((size(input) > 23))
1191-                                                                                                    then (input[23] * weights[6][23])
1192-                                                                                                    else (0 + (if ((size(input) > 24))
1193-                                                                                                        then (input[24] * weights[6][24])
1194-                                                                                                        else (0 + (if ((size(input) > 25))
1195-                                                                                                            then (input[25] * weights[6][25])
1196-                                                                                                            else (0 + (if ((size(input) > 26))
1197-                                                                                                                then (input[26] * weights[6][26])
1198-                                                                                                                else (0 + (if ((size(input) > 27))
1199-                                                                                                                    then (input[27] * weights[6][27])
1200-                                                                                                                    else (0 + (if ((size(input) > 28))
1201-                                                                                                                        then (input[28] * weights[6][28])
1202-                                                                                                                        else (0 + (if ((size(input) > 29))
1203-                                                                                                                            then (input[29] * weights[6][29])
1204-                                                                                                                            else (0 + (if ((size(input) > 30))
1205-                                                                                                                                then (input[30] * weights[6][30])
1206-                                                                                                                                else (0 + (if ((size(input) > 31))
1207-                                                                                                                                    then (input[31] * weights[6][31])
1208-                                                                                                                                    else (0 + (if ((size(input) > 32))
1209-                                                                                                                                        then (input[32] * weights[6][32])
1210-                                                                                                                                        else (0 + (if ((size(input) > 33))
1211-                                                                                                                                            then (input[33] * weights[6][33])
1212-                                                                                                                                            else (0 + (if ((size(input) > 34))
1213-                                                                                                                                                then (input[34] * weights[6][34])
1214-                                                                                                                                                else (0 + (if ((size(input) > 35))
1215-                                                                                                                                                    then (input[35] * weights[6][35])
1216-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[6])
1217-    let weighted_sum8 = (((if ((size(input) > 0))
1218-        then (input[0] * weights[7][0])
1219-        else (0 + (if ((size(input) > 1))
1220-            then (input[1] * weights[7][1])
1221-            else (0 + (if ((size(input) > 2))
1222-                then (input[2] * weights[7][2])
1223-                else (0 + (if ((size(input) > 3))
1224-                    then (input[3] * weights[7][3])
1225-                    else (0 + (if ((size(input) > 4))
1226-                        then (input[4] * weights[7][4])
1227-                        else (0 + (if ((size(input) > 5))
1228-                            then (input[5] * weights[7][5])
1229-                            else (0 + (if ((size(input) > 6))
1230-                                then (input[6] * weights[7][6])
1231-                                else (0 + (if ((size(input) > 7))
1232-                                    then (input[7] * weights[7][7])
1233-                                    else (0 + (if ((size(input) > 8))
1234-                                        then (input[8] * weights[7][8])
1235-                                        else (0 + (if ((size(input) > 9))
1236-                                            then (input[9] * weights[7][9])
1237-                                            else (0 + (if ((size(input) > 10))
1238-                                                then (input[10] * weights[7][10])
1239-                                                else (0 + (if ((size(input) > 11))
1240-                                                    then (input[11] * weights[7][11])
1241-                                                    else (0 + (if ((size(input) > 12))
1242-                                                        then (input[12] * weights[7][12])
1243-                                                        else (0 + (if ((size(input) > 13))
1244-                                                            then (input[13] * weights[7][13])
1245-                                                            else (0 + (if ((size(input) > 14))
1246-                                                                then (input[14] * weights[7][14])
1247-                                                                else (0 + (if ((size(input) > 15))
1248-                                                                    then (input[15] * weights[7][15])
1249-                                                                    else (0 + (if ((size(input) > 16))
1250-                                                                        then (input[16] * weights[7][16])
1251-                                                                        else (0 + (if ((size(input) > 17))
1252-                                                                            then (input[17] * weights[7][17])
1253-                                                                            else (0 + (if ((size(input) > 18))
1254-                                                                                then (input[18] * weights[7][18])
1255-                                                                                else (0 + (if ((size(input) > 19))
1256-                                                                                    then (input[19] * weights[7][19])
1257-                                                                                    else (0 + (if ((size(input) > 20))
1258-                                                                                        then (input[20] * weights[7][20])
1259-                                                                                        else (0 + (if ((size(input) > 21))
1260-                                                                                            then (input[21] * weights[7][21])
1261-                                                                                            else (0 + (if ((size(input) > 22))
1262-                                                                                                then (input[22] * weights[7][22])
1263-                                                                                                else (0 + (if ((size(input) > 23))
1264-                                                                                                    then (input[23] * weights[7][23])
1265-                                                                                                    else (0 + (if ((size(input) > 24))
1266-                                                                                                        then (input[24] * weights[7][24])
1267-                                                                                                        else (0 + (if ((size(input) > 25))
1268-                                                                                                            then (input[25] * weights[7][25])
1269-                                                                                                            else (0 + (if ((size(input) > 26))
1270-                                                                                                                then (input[26] * weights[7][26])
1271-                                                                                                                else (0 + (if ((size(input) > 27))
1272-                                                                                                                    then (input[27] * weights[7][27])
1273-                                                                                                                    else (0 + (if ((size(input) > 28))
1274-                                                                                                                        then (input[28] * weights[7][28])
1275-                                                                                                                        else (0 + (if ((size(input) > 29))
1276-                                                                                                                            then (input[29] * weights[7][29])
1277-                                                                                                                            else (0 + (if ((size(input) > 30))
1278-                                                                                                                                then (input[30] * weights[7][30])
1279-                                                                                                                                else (0 + (if ((size(input) > 31))
1280-                                                                                                                                    then (input[31] * weights[7][31])
1281-                                                                                                                                    else (0 + (if ((size(input) > 32))
1282-                                                                                                                                        then (input[32] * weights[7][32])
1283-                                                                                                                                        else (0 + (if ((size(input) > 33))
1284-                                                                                                                                            then (input[33] * weights[7][33])
1285-                                                                                                                                            else (0 + (if ((size(input) > 34))
1286-                                                                                                                                                then (input[34] * weights[7][34])
1287-                                                                                                                                                else (0 + (if ((size(input) > 35))
1288-                                                                                                                                                    then (input[35] * weights[7][35])
1289-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[7])
1290-    let weighted_sum9 = (((if ((size(input) > 0))
1291-        then (input[0] * weights[8][0])
1292-        else (0 + (if ((size(input) > 1))
1293-            then (input[1] * weights[8][1])
1294-            else (0 + (if ((size(input) > 2))
1295-                then (input[2] * weights[8][2])
1296-                else (0 + (if ((size(input) > 3))
1297-                    then (input[3] * weights[8][3])
1298-                    else (0 + (if ((size(input) > 4))
1299-                        then (input[4] * weights[8][4])
1300-                        else (0 + (if ((size(input) > 5))
1301-                            then (input[5] * weights[8][5])
1302-                            else (0 + (if ((size(input) > 6))
1303-                                then (input[6] * weights[8][6])
1304-                                else (0 + (if ((size(input) > 7))
1305-                                    then (input[7] * weights[8][7])
1306-                                    else (0 + (if ((size(input) > 8))
1307-                                        then (input[8] * weights[8][8])
1308-                                        else (0 + (if ((size(input) > 9))
1309-                                            then (input[9] * weights[8][9])
1310-                                            else (0 + (if ((size(input) > 10))
1311-                                                then (input[10] * weights[8][10])
1312-                                                else (0 + (if ((size(input) > 11))
1313-                                                    then (input[11] * weights[8][11])
1314-                                                    else (0 + (if ((size(input) > 12))
1315-                                                        then (input[12] * weights[8][12])
1316-                                                        else (0 + (if ((size(input) > 13))
1317-                                                            then (input[13] * weights[8][13])
1318-                                                            else (0 + (if ((size(input) > 14))
1319-                                                                then (input[14] * weights[8][14])
1320-                                                                else (0 + (if ((size(input) > 15))
1321-                                                                    then (input[15] * weights[8][15])
1322-                                                                    else (0 + (if ((size(input) > 16))
1323-                                                                        then (input[16] * weights[8][16])
1324-                                                                        else (0 + (if ((size(input) > 17))
1325-                                                                            then (input[17] * weights[8][17])
1326-                                                                            else (0 + (if ((size(input) > 18))
1327-                                                                                then (input[18] * weights[8][18])
1328-                                                                                else (0 + (if ((size(input) > 19))
1329-                                                                                    then (input[19] * weights[8][19])
1330-                                                                                    else (0 + (if ((size(input) > 20))
1331-                                                                                        then (input[20] * weights[8][20])
1332-                                                                                        else (0 + (if ((size(input) > 21))
1333-                                                                                            then (input[21] * weights[8][21])
1334-                                                                                            else (0 + (if ((size(input) > 22))
1335-                                                                                                then (input[22] * weights[8][22])
1336-                                                                                                else (0 + (if ((size(input) > 23))
1337-                                                                                                    then (input[23] * weights[8][23])
1338-                                                                                                    else (0 + (if ((size(input) > 24))
1339-                                                                                                        then (input[24] * weights[8][24])
1340-                                                                                                        else (0 + (if ((size(input) > 25))
1341-                                                                                                            then (input[25] * weights[8][25])
1342-                                                                                                            else (0 + (if ((size(input) > 26))
1343-                                                                                                                then (input[26] * weights[8][26])
1344-                                                                                                                else (0 + (if ((size(input) > 27))
1345-                                                                                                                    then (input[27] * weights[8][27])
1346-                                                                                                                    else (0 + (if ((size(input) > 28))
1347-                                                                                                                        then (input[28] * weights[8][28])
1348-                                                                                                                        else (0 + (if ((size(input) > 29))
1349-                                                                                                                            then (input[29] * weights[8][29])
1350-                                                                                                                            else (0 + (if ((size(input) > 30))
1351-                                                                                                                                then (input[30] * weights[8][30])
1352-                                                                                                                                else (0 + (if ((size(input) > 31))
1353-                                                                                                                                    then (input[31] * weights[8][31])
1354-                                                                                                                                    else (0 + (if ((size(input) > 32))
1355-                                                                                                                                        then (input[32] * weights[8][32])
1356-                                                                                                                                        else (0 + (if ((size(input) > 33))
1357-                                                                                                                                            then (input[33] * weights[8][33])
1358-                                                                                                                                            else (0 + (if ((size(input) > 34))
1359-                                                                                                                                                then (input[34] * weights[8][34])
1360-                                                                                                                                                else (0 + (if ((size(input) > 35))
1361-                                                                                                                                                    then (input[35] * weights[8][35])
1362-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[8])
1363-    let weighted_sum10 = (((if ((size(input) > 0))
1364-        then (input[0] * weights[9][0])
1365-        else (0 + (if ((size(input) > 1))
1366-            then (input[1] * weights[9][1])
1367-            else (0 + (if ((size(input) > 2))
1368-                then (input[2] * weights[9][2])
1369-                else (0 + (if ((size(input) > 3))
1370-                    then (input[3] * weights[9][3])
1371-                    else (0 + (if ((size(input) > 4))
1372-                        then (input[4] * weights[9][4])
1373-                        else (0 + (if ((size(input) > 5))
1374-                            then (input[5] * weights[9][5])
1375-                            else (0 + (if ((size(input) > 6))
1376-                                then (input[6] * weights[9][6])
1377-                                else (0 + (if ((size(input) > 7))
1378-                                    then (input[7] * weights[9][7])
1379-                                    else (0 + (if ((size(input) > 8))
1380-                                        then (input[8] * weights[9][8])
1381-                                        else (0 + (if ((size(input) > 9))
1382-                                            then (input[9] * weights[9][9])
1383-                                            else (0 + (if ((size(input) > 10))
1384-                                                then (input[10] * weights[9][10])
1385-                                                else (0 + (if ((size(input) > 11))
1386-                                                    then (input[11] * weights[9][11])
1387-                                                    else (0 + (if ((size(input) > 12))
1388-                                                        then (input[12] * weights[9][12])
1389-                                                        else (0 + (if ((size(input) > 13))
1390-                                                            then (input[13] * weights[9][13])
1391-                                                            else (0 + (if ((size(input) > 14))
1392-                                                                then (input[14] * weights[9][14])
1393-                                                                else (0 + (if ((size(input) > 15))
1394-                                                                    then (input[15] * weights[9][15])
1395-                                                                    else (0 + (if ((size(input) > 16))
1396-                                                                        then (input[16] * weights[9][16])
1397-                                                                        else (0 + (if ((size(input) > 17))
1398-                                                                            then (input[17] * weights[9][17])
1399-                                                                            else (0 + (if ((size(input) > 18))
1400-                                                                                then (input[18] * weights[9][18])
1401-                                                                                else (0 + (if ((size(input) > 19))
1402-                                                                                    then (input[19] * weights[9][19])
1403-                                                                                    else (0 + (if ((size(input) > 20))
1404-                                                                                        then (input[20] * weights[9][20])
1405-                                                                                        else (0 + (if ((size(input) > 21))
1406-                                                                                            then (input[21] * weights[9][21])
1407-                                                                                            else (0 + (if ((size(input) > 22))
1408-                                                                                                then (input[22] * weights[9][22])
1409-                                                                                                else (0 + (if ((size(input) > 23))
1410-                                                                                                    then (input[23] * weights[9][23])
1411-                                                                                                    else (0 + (if ((size(input) > 24))
1412-                                                                                                        then (input[24] * weights[9][24])
1413-                                                                                                        else (0 + (if ((size(input) > 25))
1414-                                                                                                            then (input[25] * weights[9][25])
1415-                                                                                                            else (0 + (if ((size(input) > 26))
1416-                                                                                                                then (input[26] * weights[9][26])
1417-                                                                                                                else (0 + (if ((size(input) > 27))
1418-                                                                                                                    then (input[27] * weights[9][27])
1419-                                                                                                                    else (0 + (if ((size(input) > 28))
1420-                                                                                                                        then (input[28] * weights[9][28])
1421-                                                                                                                        else (0 + (if ((size(input) > 29))
1422-                                                                                                                            then (input[29] * weights[9][29])
1423-                                                                                                                            else (0 + (if ((size(input) > 30))
1424-                                                                                                                                then (input[30] * weights[9][30])
1425-                                                                                                                                else (0 + (if ((size(input) > 31))
1426-                                                                                                                                    then (input[31] * weights[9][31])
1427-                                                                                                                                    else (0 + (if ((size(input) > 32))
1428-                                                                                                                                        then (input[32] * weights[9][32])
1429-                                                                                                                                        else (0 + (if ((size(input) > 33))
1430-                                                                                                                                            then (input[33] * weights[9][33])
1431-                                                                                                                                            else (0 + (if ((size(input) > 34))
1432-                                                                                                                                                then (input[34] * weights[9][34])
1433-                                                                                                                                                else (0 + (if ((size(input) > 35))
1434-                                                                                                                                                    then (input[35] * weights[9][35])
1435-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[9])
1436-    let weighted_sum11 = (((if ((size(input) > 0))
1437-        then (input[0] * weights[10][0])
1438-        else (0 + (if ((size(input) > 1))
1439-            then (input[1] * weights[10][1])
1440-            else (0 + (if ((size(input) > 2))
1441-                then (input[2] * weights[10][2])
1442-                else (0 + (if ((size(input) > 3))
1443-                    then (input[3] * weights[10][3])
1444-                    else (0 + (if ((size(input) > 4))
1445-                        then (input[4] * weights[10][4])
1446-                        else (0 + (if ((size(input) > 5))
1447-                            then (input[5] * weights[10][5])
1448-                            else (0 + (if ((size(input) > 6))
1449-                                then (input[6] * weights[10][6])
1450-                                else (0 + (if ((size(input) > 7))
1451-                                    then (input[7] * weights[10][7])
1452-                                    else (0 + (if ((size(input) > 8))
1453-                                        then (input[8] * weights[10][8])
1454-                                        else (0 + (if ((size(input) > 9))
1455-                                            then (input[9] * weights[10][9])
1456-                                            else (0 + (if ((size(input) > 10))
1457-                                                then (input[10] * weights[10][10])
1458-                                                else (0 + (if ((size(input) > 11))
1459-                                                    then (input[11] * weights[10][11])
1460-                                                    else (0 + (if ((size(input) > 12))
1461-                                                        then (input[12] * weights[10][12])
1462-                                                        else (0 + (if ((size(input) > 13))
1463-                                                            then (input[13] * weights[10][13])
1464-                                                            else (0 + (if ((size(input) > 14))
1465-                                                                then (input[14] * weights[10][14])
1466-                                                                else (0 + (if ((size(input) > 15))
1467-                                                                    then (input[15] * weights[10][15])
1468-                                                                    else (0 + (if ((size(input) > 16))
1469-                                                                        then (input[16] * weights[10][16])
1470-                                                                        else (0 + (if ((size(input) > 17))
1471-                                                                            then (input[17] * weights[10][17])
1472-                                                                            else (0 + (if ((size(input) > 18))
1473-                                                                                then (input[18] * weights[10][18])
1474-                                                                                else (0 + (if ((size(input) > 19))
1475-                                                                                    then (input[19] * weights[10][19])
1476-                                                                                    else (0 + (if ((size(input) > 20))
1477-                                                                                        then (input[20] * weights[10][20])
1478-                                                                                        else (0 + (if ((size(input) > 21))
1479-                                                                                            then (input[21] * weights[10][21])
1480-                                                                                            else (0 + (if ((size(input) > 22))
1481-                                                                                                then (input[22] * weights[10][22])
1482-                                                                                                else (0 + (if ((size(input) > 23))
1483-                                                                                                    then (input[23] * weights[10][23])
1484-                                                                                                    else (0 + (if ((size(input) > 24))
1485-                                                                                                        then (input[24] * weights[10][24])
1486-                                                                                                        else (0 + (if ((size(input) > 25))
1487-                                                                                                            then (input[25] * weights[10][25])
1488-                                                                                                            else (0 + (if ((size(input) > 26))
1489-                                                                                                                then (input[26] * weights[10][26])
1490-                                                                                                                else (0 + (if ((size(input) > 27))
1491-                                                                                                                    then (input[27] * weights[10][27])
1492-                                                                                                                    else (0 + (if ((size(input) > 28))
1493-                                                                                                                        then (input[28] * weights[10][28])
1494-                                                                                                                        else (0 + (if ((size(input) > 29))
1495-                                                                                                                            then (input[29] * weights[10][29])
1496-                                                                                                                            else (0 + (if ((size(input) > 30))
1497-                                                                                                                                then (input[30] * weights[10][30])
1498-                                                                                                                                else (0 + (if ((size(input) > 31))
1499-                                                                                                                                    then (input[31] * weights[10][31])
1500-                                                                                                                                    else (0 + (if ((size(input) > 32))
1501-                                                                                                                                        then (input[32] * weights[10][32])
1502-                                                                                                                                        else (0 + (if ((size(input) > 33))
1503-                                                                                                                                            then (input[33] * weights[10][33])
1504-                                                                                                                                            else (0 + (if ((size(input) > 34))
1505-                                                                                                                                                then (input[34] * weights[10][34])
1506-                                                                                                                                                else (0 + (if ((size(input) > 35))
1507-                                                                                                                                                    then (input[35] * weights[10][35])
1508-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[10])
1509-    let weighted_sum12 = (((if ((size(input) > 0))
1510-        then (input[0] * weights[11][0])
1511-        else (0 + (if ((size(input) > 1))
1512-            then (input[1] * weights[11][1])
1513-            else (0 + (if ((size(input) > 2))
1514-                then (input[2] * weights[11][2])
1515-                else (0 + (if ((size(input) > 3))
1516-                    then (input[3] * weights[11][3])
1517-                    else (0 + (if ((size(input) > 4))
1518-                        then (input[4] * weights[11][4])
1519-                        else (0 + (if ((size(input) > 5))
1520-                            then (input[5] * weights[11][5])
1521-                            else (0 + (if ((size(input) > 6))
1522-                                then (input[6] * weights[11][6])
1523-                                else (0 + (if ((size(input) > 7))
1524-                                    then (input[7] * weights[11][7])
1525-                                    else (0 + (if ((size(input) > 8))
1526-                                        then (input[8] * weights[11][8])
1527-                                        else (0 + (if ((size(input) > 9))
1528-                                            then (input[9] * weights[11][9])
1529-                                            else (0 + (if ((size(input) > 10))
1530-                                                then (input[10] * weights[11][10])
1531-                                                else (0 + (if ((size(input) > 11))
1532-                                                    then (input[11] * weights[11][11])
1533-                                                    else (0 + (if ((size(input) > 12))
1534-                                                        then (input[12] * weights[11][12])
1535-                                                        else (0 + (if ((size(input) > 13))
1536-                                                            then (input[13] * weights[11][13])
1537-                                                            else (0 + (if ((size(input) > 14))
1538-                                                                then (input[14] * weights[11][14])
1539-                                                                else (0 + (if ((size(input) > 15))
1540-                                                                    then (input[15] * weights[11][15])
1541-                                                                    else (0 + (if ((size(input) > 16))
1542-                                                                        then (input[16] * weights[11][16])
1543-                                                                        else (0 + (if ((size(input) > 17))
1544-                                                                            then (input[17] * weights[11][17])
1545-                                                                            else (0 + (if ((size(input) > 18))
1546-                                                                                then (input[18] * weights[11][18])
1547-                                                                                else (0 + (if ((size(input) > 19))
1548-                                                                                    then (input[19] * weights[11][19])
1549-                                                                                    else (0 + (if ((size(input) > 20))
1550-                                                                                        then (input[20] * weights[11][20])
1551-                                                                                        else (0 + (if ((size(input) > 21))
1552-                                                                                            then (input[21] * weights[11][21])
1553-                                                                                            else (0 + (if ((size(input) > 22))
1554-                                                                                                then (input[22] * weights[11][22])
1555-                                                                                                else (0 + (if ((size(input) > 23))
1556-                                                                                                    then (input[23] * weights[11][23])
1557-                                                                                                    else (0 + (if ((size(input) > 24))
1558-                                                                                                        then (input[24] * weights[11][24])
1559-                                                                                                        else (0 + (if ((size(input) > 25))
1560-                                                                                                            then (input[25] * weights[11][25])
1561-                                                                                                            else (0 + (if ((size(input) > 26))
1562-                                                                                                                then (input[26] * weights[11][26])
1563-                                                                                                                else (0 + (if ((size(input) > 27))
1564-                                                                                                                    then (input[27] * weights[11][27])
1565-                                                                                                                    else (0 + (if ((size(input) > 28))
1566-                                                                                                                        then (input[28] * weights[11][28])
1567-                                                                                                                        else (0 + (if ((size(input) > 29))
1568-                                                                                                                            then (input[29] * weights[11][29])
1569-                                                                                                                            else (0 + (if ((size(input) > 30))
1570-                                                                                                                                then (input[30] * weights[11][30])
1571-                                                                                                                                else (0 + (if ((size(input) > 31))
1572-                                                                                                                                    then (input[31] * weights[11][31])
1573-                                                                                                                                    else (0 + (if ((size(input) > 32))
1574-                                                                                                                                        then (input[32] * weights[11][32])
1575-                                                                                                                                        else (0 + (if ((size(input) > 33))
1576-                                                                                                                                            then (input[33] * weights[11][33])
1577-                                                                                                                                            else (0 + (if ((size(input) > 34))
1578-                                                                                                                                                then (input[34] * weights[11][34])
1579-                                                                                                                                                else (0 + (if ((size(input) > 35))
1580-                                                                                                                                                    then (input[35] * weights[11][35])
1581-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[11])
1582-    let weighted_sum13 = (((if ((size(input) > 0))
1583-        then (input[0] * weights[12][0])
1584-        else (0 + (if ((size(input) > 1))
1585-            then (input[1] * weights[12][1])
1586-            else (0 + (if ((size(input) > 2))
1587-                then (input[2] * weights[12][2])
1588-                else (0 + (if ((size(input) > 3))
1589-                    then (input[3] * weights[12][3])
1590-                    else (0 + (if ((size(input) > 4))
1591-                        then (input[4] * weights[12][4])
1592-                        else (0 + (if ((size(input) > 5))
1593-                            then (input[5] * weights[12][5])
1594-                            else (0 + (if ((size(input) > 6))
1595-                                then (input[6] * weights[12][6])
1596-                                else (0 + (if ((size(input) > 7))
1597-                                    then (input[7] * weights[12][7])
1598-                                    else (0 + (if ((size(input) > 8))
1599-                                        then (input[8] * weights[12][8])
1600-                                        else (0 + (if ((size(input) > 9))
1601-                                            then (input[9] * weights[12][9])
1602-                                            else (0 + (if ((size(input) > 10))
1603-                                                then (input[10] * weights[12][10])
1604-                                                else (0 + (if ((size(input) > 11))
1605-                                                    then (input[11] * weights[12][11])
1606-                                                    else (0 + (if ((size(input) > 12))
1607-                                                        then (input[12] * weights[12][12])
1608-                                                        else (0 + (if ((size(input) > 13))
1609-                                                            then (input[13] * weights[12][13])
1610-                                                            else (0 + (if ((size(input) > 14))
1611-                                                                then (input[14] * weights[12][14])
1612-                                                                else (0 + (if ((size(input) > 15))
1613-                                                                    then (input[15] * weights[12][15])
1614-                                                                    else (0 + (if ((size(input) > 16))
1615-                                                                        then (input[16] * weights[12][16])
1616-                                                                        else (0 + (if ((size(input) > 17))
1617-                                                                            then (input[17] * weights[12][17])
1618-                                                                            else (0 + (if ((size(input) > 18))
1619-                                                                                then (input[18] * weights[12][18])
1620-                                                                                else (0 + (if ((size(input) > 19))
1621-                                                                                    then (input[19] * weights[12][19])
1622-                                                                                    else (0 + (if ((size(input) > 20))
1623-                                                                                        then (input[20] * weights[12][20])
1624-                                                                                        else (0 + (if ((size(input) > 21))
1625-                                                                                            then (input[21] * weights[12][21])
1626-                                                                                            else (0 + (if ((size(input) > 22))
1627-                                                                                                then (input[22] * weights[12][22])
1628-                                                                                                else (0 + (if ((size(input) > 23))
1629-                                                                                                    then (input[23] * weights[12][23])
1630-                                                                                                    else (0 + (if ((size(input) > 24))
1631-                                                                                                        then (input[24] * weights[12][24])
1632-                                                                                                        else (0 + (if ((size(input) > 25))
1633-                                                                                                            then (input[25] * weights[12][25])
1634-                                                                                                            else (0 + (if ((size(input) > 26))
1635-                                                                                                                then (input[26] * weights[12][26])
1636-                                                                                                                else (0 + (if ((size(input) > 27))
1637-                                                                                                                    then (input[27] * weights[12][27])
1638-                                                                                                                    else (0 + (if ((size(input) > 28))
1639-                                                                                                                        then (input[28] * weights[12][28])
1640-                                                                                                                        else (0 + (if ((size(input) > 29))
1641-                                                                                                                            then (input[29] * weights[12][29])
1642-                                                                                                                            else (0 + (if ((size(input) > 30))
1643-                                                                                                                                then (input[30] * weights[12][30])
1644-                                                                                                                                else (0 + (if ((size(input) > 31))
1645-                                                                                                                                    then (input[31] * weights[12][31])
1646-                                                                                                                                    else (0 + (if ((size(input) > 32))
1647-                                                                                                                                        then (input[32] * weights[12][32])
1648-                                                                                                                                        else (0 + (if ((size(input) > 33))
1649-                                                                                                                                            then (input[33] * weights[12][33])
1650-                                                                                                                                            else (0 + (if ((size(input) > 34))
1651-                                                                                                                                                then (input[34] * weights[12][34])
1652-                                                                                                                                                else (0 + (if ((size(input) > 35))
1653-                                                                                                                                                    then (input[35] * weights[12][35])
1654-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[12])
1655-    let weighted_sum14 = (((if ((size(input) > 0))
1656-        then (input[0] * weights[13][0])
1657-        else (0 + (if ((size(input) > 1))
1658-            then (input[1] * weights[13][1])
1659-            else (0 + (if ((size(input) > 2))
1660-                then (input[2] * weights[13][2])
1661-                else (0 + (if ((size(input) > 3))
1662-                    then (input[3] * weights[13][3])
1663-                    else (0 + (if ((size(input) > 4))
1664-                        then (input[4] * weights[13][4])
1665-                        else (0 + (if ((size(input) > 5))
1666-                            then (input[5] * weights[13][5])
1667-                            else (0 + (if ((size(input) > 6))
1668-                                then (input[6] * weights[13][6])
1669-                                else (0 + (if ((size(input) > 7))
1670-                                    then (input[7] * weights[13][7])
1671-                                    else (0 + (if ((size(input) > 8))
1672-                                        then (input[8] * weights[13][8])
1673-                                        else (0 + (if ((size(input) > 9))
1674-                                            then (input[9] * weights[13][9])
1675-                                            else (0 + (if ((size(input) > 10))
1676-                                                then (input[10] * weights[13][10])
1677-                                                else (0 + (if ((size(input) > 11))
1678-                                                    then (input[11] * weights[13][11])
1679-                                                    else (0 + (if ((size(input) > 12))
1680-                                                        then (input[12] * weights[13][12])
1681-                                                        else (0 + (if ((size(input) > 13))
1682-                                                            then (input[13] * weights[13][13])
1683-                                                            else (0 + (if ((size(input) > 14))
1684-                                                                then (input[14] * weights[13][14])
1685-                                                                else (0 + (if ((size(input) > 15))
1686-                                                                    then (input[15] * weights[13][15])
1687-                                                                    else (0 + (if ((size(input) > 16))
1688-                                                                        then (input[16] * weights[13][16])
1689-                                                                        else (0 + (if ((size(input) > 17))
1690-                                                                            then (input[17] * weights[13][17])
1691-                                                                            else (0 + (if ((size(input) > 18))
1692-                                                                                then (input[18] * weights[13][18])
1693-                                                                                else (0 + (if ((size(input) > 19))
1694-                                                                                    then (input[19] * weights[13][19])
1695-                                                                                    else (0 + (if ((size(input) > 20))
1696-                                                                                        then (input[20] * weights[13][20])
1697-                                                                                        else (0 + (if ((size(input) > 21))
1698-                                                                                            then (input[21] * weights[13][21])
1699-                                                                                            else (0 + (if ((size(input) > 22))
1700-                                                                                                then (input[22] * weights[13][22])
1701-                                                                                                else (0 + (if ((size(input) > 23))
1702-                                                                                                    then (input[23] * weights[13][23])
1703-                                                                                                    else (0 + (if ((size(input) > 24))
1704-                                                                                                        then (input[24] * weights[13][24])
1705-                                                                                                        else (0 + (if ((size(input) > 25))
1706-                                                                                                            then (input[25] * weights[13][25])
1707-                                                                                                            else (0 + (if ((size(input) > 26))
1708-                                                                                                                then (input[26] * weights[13][26])
1709-                                                                                                                else (0 + (if ((size(input) > 27))
1710-                                                                                                                    then (input[27] * weights[13][27])
1711-                                                                                                                    else (0 + (if ((size(input) > 28))
1712-                                                                                                                        then (input[28] * weights[13][28])
1713-                                                                                                                        else (0 + (if ((size(input) > 29))
1714-                                                                                                                            then (input[29] * weights[13][29])
1715-                                                                                                                            else (0 + (if ((size(input) > 30))
1716-                                                                                                                                then (input[30] * weights[13][30])
1717-                                                                                                                                else (0 + (if ((size(input) > 31))
1718-                                                                                                                                    then (input[31] * weights[13][31])
1719-                                                                                                                                    else (0 + (if ((size(input) > 32))
1720-                                                                                                                                        then (input[32] * weights[13][32])
1721-                                                                                                                                        else (0 + (if ((size(input) > 33))
1722-                                                                                                                                            then (input[33] * weights[13][33])
1723-                                                                                                                                            else (0 + (if ((size(input) > 34))
1724-                                                                                                                                                then (input[34] * weights[13][34])
1725-                                                                                                                                                else (0 + (if ((size(input) > 35))
1726-                                                                                                                                                    then (input[35] * weights[13][35])
1727-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[13])
1728-    let weighted_sum15 = (((if ((size(input) > 0))
1729-        then (input[0] * weights[14][0])
1730-        else (0 + (if ((size(input) > 1))
1731-            then (input[1] * weights[14][1])
1732-            else (0 + (if ((size(input) > 2))
1733-                then (input[2] * weights[14][2])
1734-                else (0 + (if ((size(input) > 3))
1735-                    then (input[3] * weights[14][3])
1736-                    else (0 + (if ((size(input) > 4))
1737-                        then (input[4] * weights[14][4])
1738-                        else (0 + (if ((size(input) > 5))
1739-                            then (input[5] * weights[14][5])
1740-                            else (0 + (if ((size(input) > 6))
1741-                                then (input[6] * weights[14][6])
1742-                                else (0 + (if ((size(input) > 7))
1743-                                    then (input[7] * weights[14][7])
1744-                                    else (0 + (if ((size(input) > 8))
1745-                                        then (input[8] * weights[14][8])
1746-                                        else (0 + (if ((size(input) > 9))
1747-                                            then (input[9] * weights[14][9])
1748-                                            else (0 + (if ((size(input) > 10))
1749-                                                then (input[10] * weights[14][10])
1750-                                                else (0 + (if ((size(input) > 11))
1751-                                                    then (input[11] * weights[14][11])
1752-                                                    else (0 + (if ((size(input) > 12))
1753-                                                        then (input[12] * weights[14][12])
1754-                                                        else (0 + (if ((size(input) > 13))
1755-                                                            then (input[13] * weights[14][13])
1756-                                                            else (0 + (if ((size(input) > 14))
1757-                                                                then (input[14] * weights[14][14])
1758-                                                                else (0 + (if ((size(input) > 15))
1759-                                                                    then (input[15] * weights[14][15])
1760-                                                                    else (0 + (if ((size(input) > 16))
1761-                                                                        then (input[16] * weights[14][16])
1762-                                                                        else (0 + (if ((size(input) > 17))
1763-                                                                            then (input[17] * weights[14][17])
1764-                                                                            else (0 + (if ((size(input) > 18))
1765-                                                                                then (input[18] * weights[14][18])
1766-                                                                                else (0 + (if ((size(input) > 19))
1767-                                                                                    then (input[19] * weights[14][19])
1768-                                                                                    else (0 + (if ((size(input) > 20))
1769-                                                                                        then (input[20] * weights[14][20])
1770-                                                                                        else (0 + (if ((size(input) > 21))
1771-                                                                                            then (input[21] * weights[14][21])
1772-                                                                                            else (0 + (if ((size(input) > 22))
1773-                                                                                                then (input[22] * weights[14][22])
1774-                                                                                                else (0 + (if ((size(input) > 23))
1775-                                                                                                    then (input[23] * weights[14][23])
1776-                                                                                                    else (0 + (if ((size(input) > 24))
1777-                                                                                                        then (input[24] * weights[14][24])
1778-                                                                                                        else (0 + (if ((size(input) > 25))
1779-                                                                                                            then (input[25] * weights[14][25])
1780-                                                                                                            else (0 + (if ((size(input) > 26))
1781-                                                                                                                then (input[26] * weights[14][26])
1782-                                                                                                                else (0 + (if ((size(input) > 27))
1783-                                                                                                                    then (input[27] * weights[14][27])
1784-                                                                                                                    else (0 + (if ((size(input) > 28))
1785-                                                                                                                        then (input[28] * weights[14][28])
1786-                                                                                                                        else (0 + (if ((size(input) > 29))
1787-                                                                                                                            then (input[29] * weights[14][29])
1788-                                                                                                                            else (0 + (if ((size(input) > 30))
1789-                                                                                                                                then (input[30] * weights[14][30])
1790-                                                                                                                                else (0 + (if ((size(input) > 31))
1791-                                                                                                                                    then (input[31] * weights[14][31])
1792-                                                                                                                                    else (0 + (if ((size(input) > 32))
1793-                                                                                                                                        then (input[32] * weights[14][32])
1794-                                                                                                                                        else (0 + (if ((size(input) > 33))
1795-                                                                                                                                            then (input[33] * weights[14][33])
1796-                                                                                                                                            else (0 + (if ((size(input) > 34))
1797-                                                                                                                                                then (input[34] * weights[14][34])
1798-                                                                                                                                                else (0 + (if ((size(input) > 35))
1799-                                                                                                                                                    then (input[35] * weights[14][35])
1800-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[14])
1801-    let weighted_sum16 = (((if ((size(input) > 0))
1802-        then (input[0] * weights[15][0])
1803-        else (0 + (if ((size(input) > 1))
1804-            then (input[1] * weights[15][1])
1805-            else (0 + (if ((size(input) > 2))
1806-                then (input[2] * weights[15][2])
1807-                else (0 + (if ((size(input) > 3))
1808-                    then (input[3] * weights[15][3])
1809-                    else (0 + (if ((size(input) > 4))
1810-                        then (input[4] * weights[15][4])
1811-                        else (0 + (if ((size(input) > 5))
1812-                            then (input[5] * weights[15][5])
1813-                            else (0 + (if ((size(input) > 6))
1814-                                then (input[6] * weights[15][6])
1815-                                else (0 + (if ((size(input) > 7))
1816-                                    then (input[7] * weights[15][7])
1817-                                    else (0 + (if ((size(input) > 8))
1818-                                        then (input[8] * weights[15][8])
1819-                                        else (0 + (if ((size(input) > 9))
1820-                                            then (input[9] * weights[15][9])
1821-                                            else (0 + (if ((size(input) > 10))
1822-                                                then (input[10] * weights[15][10])
1823-                                                else (0 + (if ((size(input) > 11))
1824-                                                    then (input[11] * weights[15][11])
1825-                                                    else (0 + (if ((size(input) > 12))
1826-                                                        then (input[12] * weights[15][12])
1827-                                                        else (0 + (if ((size(input) > 13))
1828-                                                            then (input[13] * weights[15][13])
1829-                                                            else (0 + (if ((size(input) > 14))
1830-                                                                then (input[14] * weights[15][14])
1831-                                                                else (0 + (if ((size(input) > 15))
1832-                                                                    then (input[15] * weights[15][15])
1833-                                                                    else (0 + (if ((size(input) > 16))
1834-                                                                        then (input[16] * weights[15][16])
1835-                                                                        else (0 + (if ((size(input) > 17))
1836-                                                                            then (input[17] * weights[15][17])
1837-                                                                            else (0 + (if ((size(input) > 18))
1838-                                                                                then (input[18] * weights[15][18])
1839-                                                                                else (0 + (if ((size(input) > 19))
1840-                                                                                    then (input[19] * weights[15][19])
1841-                                                                                    else (0 + (if ((size(input) > 20))
1842-                                                                                        then (input[20] * weights[15][20])
1843-                                                                                        else (0 + (if ((size(input) > 21))
1844-                                                                                            then (input[21] * weights[15][21])
1845-                                                                                            else (0 + (if ((size(input) > 22))
1846-                                                                                                then (input[22] * weights[15][22])
1847-                                                                                                else (0 + (if ((size(input) > 23))
1848-                                                                                                    then (input[23] * weights[15][23])
1849-                                                                                                    else (0 + (if ((size(input) > 24))
1850-                                                                                                        then (input[24] * weights[15][24])
1851-                                                                                                        else (0 + (if ((size(input) > 25))
1852-                                                                                                            then (input[25] * weights[15][25])
1853-                                                                                                            else (0 + (if ((size(input) > 26))
1854-                                                                                                                then (input[26] * weights[15][26])
1855-                                                                                                                else (0 + (if ((size(input) > 27))
1856-                                                                                                                    then (input[27] * weights[15][27])
1857-                                                                                                                    else (0 + (if ((size(input) > 28))
1858-                                                                                                                        then (input[28] * weights[15][28])
1859-                                                                                                                        else (0 + (if ((size(input) > 29))
1860-                                                                                                                            then (input[29] * weights[15][29])
1861-                                                                                                                            else (0 + (if ((size(input) > 30))
1862-                                                                                                                                then (input[30] * weights[15][30])
1863-                                                                                                                                else (0 + (if ((size(input) > 31))
1864-                                                                                                                                    then (input[31] * weights[15][31])
1865-                                                                                                                                    else (0 + (if ((size(input) > 32))
1866-                                                                                                                                        then (input[32] * weights[15][32])
1867-                                                                                                                                        else (0 + (if ((size(input) > 33))
1868-                                                                                                                                            then (input[33] * weights[15][33])
1869-                                                                                                                                            else (0 + (if ((size(input) > 34))
1870-                                                                                                                                                then (input[34] * weights[15][34])
1871-                                                                                                                                                else (0 + (if ((size(input) > 35))
1872-                                                                                                                                                    then (input[35] * weights[15][35])
1873-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[15])
1874-    let weighted_sum17 = (((if ((size(input) > 0))
1875-        then (input[0] * weights[16][0])
1876-        else (0 + (if ((size(input) > 1))
1877-            then (input[1] * weights[16][1])
1878-            else (0 + (if ((size(input) > 2))
1879-                then (input[2] * weights[16][2])
1880-                else (0 + (if ((size(input) > 3))
1881-                    then (input[3] * weights[16][3])
1882-                    else (0 + (if ((size(input) > 4))
1883-                        then (input[4] * weights[16][4])
1884-                        else (0 + (if ((size(input) > 5))
1885-                            then (input[5] * weights[16][5])
1886-                            else (0 + (if ((size(input) > 6))
1887-                                then (input[6] * weights[16][6])
1888-                                else (0 + (if ((size(input) > 7))
1889-                                    then (input[7] * weights[16][7])
1890-                                    else (0 + (if ((size(input) > 8))
1891-                                        then (input[8] * weights[16][8])
1892-                                        else (0 + (if ((size(input) > 9))
1893-                                            then (input[9] * weights[16][9])
1894-                                            else (0 + (if ((size(input) > 10))
1895-                                                then (input[10] * weights[16][10])
1896-                                                else (0 + (if ((size(input) > 11))
1897-                                                    then (input[11] * weights[16][11])
1898-                                                    else (0 + (if ((size(input) > 12))
1899-                                                        then (input[12] * weights[16][12])
1900-                                                        else (0 + (if ((size(input) > 13))
1901-                                                            then (input[13] * weights[16][13])
1902-                                                            else (0 + (if ((size(input) > 14))
1903-                                                                then (input[14] * weights[16][14])
1904-                                                                else (0 + (if ((size(input) > 15))
1905-                                                                    then (input[15] * weights[16][15])
1906-                                                                    else (0 + (if ((size(input) > 16))
1907-                                                                        then (input[16] * weights[16][16])
1908-                                                                        else (0 + (if ((size(input) > 17))
1909-                                                                            then (input[17] * weights[16][17])
1910-                                                                            else (0 + (if ((size(input) > 18))
1911-                                                                                then (input[18] * weights[16][18])
1912-                                                                                else (0 + (if ((size(input) > 19))
1913-                                                                                    then (input[19] * weights[16][19])
1914-                                                                                    else (0 + (if ((size(input) > 20))
1915-                                                                                        then (input[20] * weights[16][20])
1916-                                                                                        else (0 + (if ((size(input) > 21))
1917-                                                                                            then (input[21] * weights[16][21])
1918-                                                                                            else (0 + (if ((size(input) > 22))
1919-                                                                                                then (input[22] * weights[16][22])
1920-                                                                                                else (0 + (if ((size(input) > 23))
1921-                                                                                                    then (input[23] * weights[16][23])
1922-                                                                                                    else (0 + (if ((size(input) > 24))
1923-                                                                                                        then (input[24] * weights[16][24])
1924-                                                                                                        else (0 + (if ((size(input) > 25))
1925-                                                                                                            then (input[25] * weights[16][25])
1926-                                                                                                            else (0 + (if ((size(input) > 26))
1927-                                                                                                                then (input[26] * weights[16][26])
1928-                                                                                                                else (0 + (if ((size(input) > 27))
1929-                                                                                                                    then (input[27] * weights[16][27])
1930-                                                                                                                    else (0 + (if ((size(input) > 28))
1931-                                                                                                                        then (input[28] * weights[16][28])
1932-                                                                                                                        else (0 + (if ((size(input) > 29))
1933-                                                                                                                            then (input[29] * weights[16][29])
1934-                                                                                                                            else (0 + (if ((size(input) > 30))
1935-                                                                                                                                then (input[30] * weights[16][30])
1936-                                                                                                                                else (0 + (if ((size(input) > 31))
1937-                                                                                                                                    then (input[31] * weights[16][31])
1938-                                                                                                                                    else (0 + (if ((size(input) > 32))
1939-                                                                                                                                        then (input[32] * weights[16][32])
1940-                                                                                                                                        else (0 + (if ((size(input) > 33))
1941-                                                                                                                                            then (input[33] * weights[16][33])
1942-                                                                                                                                            else (0 + (if ((size(input) > 34))
1943-                                                                                                                                                then (input[34] * weights[16][34])
1944-                                                                                                                                                else (0 + (if ((size(input) > 35))
1945-                                                                                                                                                    then (input[35] * weights[16][35])
1946-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[16])
1947-    let weighted_sum18 = (((if ((size(input) > 0))
1948-        then (input[0] * weights[17][0])
1949-        else (0 + (if ((size(input) > 1))
1950-            then (input[1] * weights[17][1])
1951-            else (0 + (if ((size(input) > 2))
1952-                then (input[2] * weights[17][2])
1953-                else (0 + (if ((size(input) > 3))
1954-                    then (input[3] * weights[17][3])
1955-                    else (0 + (if ((size(input) > 4))
1956-                        then (input[4] * weights[17][4])
1957-                        else (0 + (if ((size(input) > 5))
1958-                            then (input[5] * weights[17][5])
1959-                            else (0 + (if ((size(input) > 6))
1960-                                then (input[6] * weights[17][6])
1961-                                else (0 + (if ((size(input) > 7))
1962-                                    then (input[7] * weights[17][7])
1963-                                    else (0 + (if ((size(input) > 8))
1964-                                        then (input[8] * weights[17][8])
1965-                                        else (0 + (if ((size(input) > 9))
1966-                                            then (input[9] * weights[17][9])
1967-                                            else (0 + (if ((size(input) > 10))
1968-                                                then (input[10] * weights[17][10])
1969-                                                else (0 + (if ((size(input) > 11))
1970-                                                    then (input[11] * weights[17][11])
1971-                                                    else (0 + (if ((size(input) > 12))
1972-                                                        then (input[12] * weights[17][12])
1973-                                                        else (0 + (if ((size(input) > 13))
1974-                                                            then (input[13] * weights[17][13])
1975-                                                            else (0 + (if ((size(input) > 14))
1976-                                                                then (input[14] * weights[17][14])
1977-                                                                else (0 + (if ((size(input) > 15))
1978-                                                                    then (input[15] * weights[17][15])
1979-                                                                    else (0 + (if ((size(input) > 16))
1980-                                                                        then (input[16] * weights[17][16])
1981-                                                                        else (0 + (if ((size(input) > 17))
1982-                                                                            then (input[17] * weights[17][17])
1983-                                                                            else (0 + (if ((size(input) > 18))
1984-                                                                                then (input[18] * weights[17][18])
1985-                                                                                else (0 + (if ((size(input) > 19))
1986-                                                                                    then (input[19] * weights[17][19])
1987-                                                                                    else (0 + (if ((size(input) > 20))
1988-                                                                                        then (input[20] * weights[17][20])
1989-                                                                                        else (0 + (if ((size(input) > 21))
1990-                                                                                            then (input[21] * weights[17][21])
1991-                                                                                            else (0 + (if ((size(input) > 22))
1992-                                                                                                then (input[22] * weights[17][22])
1993-                                                                                                else (0 + (if ((size(input) > 23))
1994-                                                                                                    then (input[23] * weights[17][23])
1995-                                                                                                    else (0 + (if ((size(input) > 24))
1996-                                                                                                        then (input[24] * weights[17][24])
1997-                                                                                                        else (0 + (if ((size(input) > 25))
1998-                                                                                                            then (input[25] * weights[17][25])
1999-                                                                                                            else (0 + (if ((size(input) > 26))
2000-                                                                                                                then (input[26] * weights[17][26])
2001-                                                                                                                else (0 + (if ((size(input) > 27))
2002-                                                                                                                    then (input[27] * weights[17][27])
2003-                                                                                                                    else (0 + (if ((size(input) > 28))
2004-                                                                                                                        then (input[28] * weights[17][28])
2005-                                                                                                                        else (0 + (if ((size(input) > 29))
2006-                                                                                                                            then (input[29] * weights[17][29])
2007-                                                                                                                            else (0 + (if ((size(input) > 30))
2008-                                                                                                                                then (input[30] * weights[17][30])
2009-                                                                                                                                else (0 + (if ((size(input) > 31))
2010-                                                                                                                                    then (input[31] * weights[17][31])
2011-                                                                                                                                    else (0 + (if ((size(input) > 32))
2012-                                                                                                                                        then (input[32] * weights[17][32])
2013-                                                                                                                                        else (0 + (if ((size(input) > 33))
2014-                                                                                                                                            then (input[33] * weights[17][33])
2015-                                                                                                                                            else (0 + (if ((size(input) > 34))
2016-                                                                                                                                                then (input[34] * weights[17][34])
2017-                                                                                                                                                else (0 + (if ((size(input) > 35))
2018-                                                                                                                                                    then (input[35] * weights[17][35])
2019-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[17])
2020-    let weighted_sum19 = (((if ((size(input) > 0))
2021-        then (input[0] * weights[18][0])
2022-        else (0 + (if ((size(input) > 1))
2023-            then (input[1] * weights[18][1])
2024-            else (0 + (if ((size(input) > 2))
2025-                then (input[2] * weights[18][2])
2026-                else (0 + (if ((size(input) > 3))
2027-                    then (input[3] * weights[18][3])
2028-                    else (0 + (if ((size(input) > 4))
2029-                        then (input[4] * weights[18][4])
2030-                        else (0 + (if ((size(input) > 5))
2031-                            then (input[5] * weights[18][5])
2032-                            else (0 + (if ((size(input) > 6))
2033-                                then (input[6] * weights[18][6])
2034-                                else (0 + (if ((size(input) > 7))
2035-                                    then (input[7] * weights[18][7])
2036-                                    else (0 + (if ((size(input) > 8))
2037-                                        then (input[8] * weights[18][8])
2038-                                        else (0 + (if ((size(input) > 9))
2039-                                            then (input[9] * weights[18][9])
2040-                                            else (0 + (if ((size(input) > 10))
2041-                                                then (input[10] * weights[18][10])
2042-                                                else (0 + (if ((size(input) > 11))
2043-                                                    then (input[11] * weights[18][11])
2044-                                                    else (0 + (if ((size(input) > 12))
2045-                                                        then (input[12] * weights[18][12])
2046-                                                        else (0 + (if ((size(input) > 13))
2047-                                                            then (input[13] * weights[18][13])
2048-                                                            else (0 + (if ((size(input) > 14))
2049-                                                                then (input[14] * weights[18][14])
2050-                                                                else (0 + (if ((size(input) > 15))
2051-                                                                    then (input[15] * weights[18][15])
2052-                                                                    else (0 + (if ((size(input) > 16))
2053-                                                                        then (input[16] * weights[18][16])
2054-                                                                        else (0 + (if ((size(input) > 17))
2055-                                                                            then (input[17] * weights[18][17])
2056-                                                                            else (0 + (if ((size(input) > 18))
2057-                                                                                then (input[18] * weights[18][18])
2058-                                                                                else (0 + (if ((size(input) > 19))
2059-                                                                                    then (input[19] * weights[18][19])
2060-                                                                                    else (0 + (if ((size(input) > 20))
2061-                                                                                        then (input[20] * weights[18][20])
2062-                                                                                        else (0 + (if ((size(input) > 21))
2063-                                                                                            then (input[21] * weights[18][21])
2064-                                                                                            else (0 + (if ((size(input) > 22))
2065-                                                                                                then (input[22] * weights[18][22])
2066-                                                                                                else (0 + (if ((size(input) > 23))
2067-                                                                                                    then (input[23] * weights[18][23])
2068-                                                                                                    else (0 + (if ((size(input) > 24))
2069-                                                                                                        then (input[24] * weights[18][24])
2070-                                                                                                        else (0 + (if ((size(input) > 25))
2071-                                                                                                            then (input[25] * weights[18][25])
2072-                                                                                                            else (0 + (if ((size(input) > 26))
2073-                                                                                                                then (input[26] * weights[18][26])
2074-                                                                                                                else (0 + (if ((size(input) > 27))
2075-                                                                                                                    then (input[27] * weights[18][27])
2076-                                                                                                                    else (0 + (if ((size(input) > 28))
2077-                                                                                                                        then (input[28] * weights[18][28])
2078-                                                                                                                        else (0 + (if ((size(input) > 29))
2079-                                                                                                                            then (input[29] * weights[18][29])
2080-                                                                                                                            else (0 + (if ((size(input) > 30))
2081-                                                                                                                                then (input[30] * weights[18][30])
2082-                                                                                                                                else (0 + (if ((size(input) > 31))
2083-                                                                                                                                    then (input[31] * weights[18][31])
2084-                                                                                                                                    else (0 + (if ((size(input) > 32))
2085-                                                                                                                                        then (input[32] * weights[18][32])
2086-                                                                                                                                        else (0 + (if ((size(input) > 33))
2087-                                                                                                                                            then (input[33] * weights[18][33])
2088-                                                                                                                                            else (0 + (if ((size(input) > 34))
2089-                                                                                                                                                then (input[34] * weights[18][34])
2090-                                                                                                                                                else (0 + (if ((size(input) > 35))
2091-                                                                                                                                                    then (input[35] * weights[18][35])
2092-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[18])
2093-    let weighted_sum20 = (((if ((size(input) > 0))
2094-        then (input[0] * weights[19][0])
2095-        else (0 + (if ((size(input) > 1))
2096-            then (input[1] * weights[19][1])
2097-            else (0 + (if ((size(input) > 2))
2098-                then (input[2] * weights[19][2])
2099-                else (0 + (if ((size(input) > 3))
2100-                    then (input[3] * weights[19][3])
2101-                    else (0 + (if ((size(input) > 4))
2102-                        then (input[4] * weights[19][4])
2103-                        else (0 + (if ((size(input) > 5))
2104-                            then (input[5] * weights[19][5])
2105-                            else (0 + (if ((size(input) > 6))
2106-                                then (input[6] * weights[19][6])
2107-                                else (0 + (if ((size(input) > 7))
2108-                                    then (input[7] * weights[19][7])
2109-                                    else (0 + (if ((size(input) > 8))
2110-                                        then (input[8] * weights[19][8])
2111-                                        else (0 + (if ((size(input) > 9))
2112-                                            then (input[9] * weights[19][9])
2113-                                            else (0 + (if ((size(input) > 10))
2114-                                                then (input[10] * weights[19][10])
2115-                                                else (0 + (if ((size(input) > 11))
2116-                                                    then (input[11] * weights[19][11])
2117-                                                    else (0 + (if ((size(input) > 12))
2118-                                                        then (input[12] * weights[19][12])
2119-                                                        else (0 + (if ((size(input) > 13))
2120-                                                            then (input[13] * weights[19][13])
2121-                                                            else (0 + (if ((size(input) > 14))
2122-                                                                then (input[14] * weights[19][14])
2123-                                                                else (0 + (if ((size(input) > 15))
2124-                                                                    then (input[15] * weights[19][15])
2125-                                                                    else (0 + (if ((size(input) > 16))
2126-                                                                        then (input[16] * weights[19][16])
2127-                                                                        else (0 + (if ((size(input) > 17))
2128-                                                                            then (input[17] * weights[19][17])
2129-                                                                            else (0 + (if ((size(input) > 18))
2130-                                                                                then (input[18] * weights[19][18])
2131-                                                                                else (0 + (if ((size(input) > 19))
2132-                                                                                    then (input[19] * weights[19][19])
2133-                                                                                    else (0 + (if ((size(input) > 20))
2134-                                                                                        then (input[20] * weights[19][20])
2135-                                                                                        else (0 + (if ((size(input) > 21))
2136-                                                                                            then (input[21] * weights[19][21])
2137-                                                                                            else (0 + (if ((size(input) > 22))
2138-                                                                                                then (input[22] * weights[19][22])
2139-                                                                                                else (0 + (if ((size(input) > 23))
2140-                                                                                                    then (input[23] * weights[19][23])
2141-                                                                                                    else (0 + (if ((size(input) > 24))
2142-                                                                                                        then (input[24] * weights[19][24])
2143-                                                                                                        else (0 + (if ((size(input) > 25))
2144-                                                                                                            then (input[25] * weights[19][25])
2145-                                                                                                            else (0 + (if ((size(input) > 26))
2146-                                                                                                                then (input[26] * weights[19][26])
2147-                                                                                                                else (0 + (if ((size(input) > 27))
2148-                                                                                                                    then (input[27] * weights[19][27])
2149-                                                                                                                    else (0 + (if ((size(input) > 28))
2150-                                                                                                                        then (input[28] * weights[19][28])
2151-                                                                                                                        else (0 + (if ((size(input) > 29))
2152-                                                                                                                            then (input[29] * weights[19][29])
2153-                                                                                                                            else (0 + (if ((size(input) > 30))
2154-                                                                                                                                then (input[30] * weights[19][30])
2155-                                                                                                                                else (0 + (if ((size(input) > 31))
2156-                                                                                                                                    then (input[31] * weights[19][31])
2157-                                                                                                                                    else (0 + (if ((size(input) > 32))
2158-                                                                                                                                        then (input[32] * weights[19][32])
2159-                                                                                                                                        else (0 + (if ((size(input) > 33))
2160-                                                                                                                                            then (input[33] * weights[19][33])
2161-                                                                                                                                            else (0 + (if ((size(input) > 34))
2162-                                                                                                                                                then (input[34] * weights[19][34])
2163-                                                                                                                                                else (0 + (if ((size(input) > 35))
2164-                                                                                                                                                    then (input[35] * weights[19][35])
2165-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[19])
2166-    let weighted_sum21 = (((if ((size(input) > 0))
2167-        then (input[0] * weights[20][0])
2168-        else (0 + (if ((size(input) > 1))
2169-            then (input[1] * weights[20][1])
2170-            else (0 + (if ((size(input) > 2))
2171-                then (input[2] * weights[20][2])
2172-                else (0 + (if ((size(input) > 3))
2173-                    then (input[3] * weights[20][3])
2174-                    else (0 + (if ((size(input) > 4))
2175-                        then (input[4] * weights[20][4])
2176-                        else (0 + (if ((size(input) > 5))
2177-                            then (input[5] * weights[20][5])
2178-                            else (0 + (if ((size(input) > 6))
2179-                                then (input[6] * weights[20][6])
2180-                                else (0 + (if ((size(input) > 7))
2181-                                    then (input[7] * weights[20][7])
2182-                                    else (0 + (if ((size(input) > 8))
2183-                                        then (input[8] * weights[20][8])
2184-                                        else (0 + (if ((size(input) > 9))
2185-                                            then (input[9] * weights[20][9])
2186-                                            else (0 + (if ((size(input) > 10))
2187-                                                then (input[10] * weights[20][10])
2188-                                                else (0 + (if ((size(input) > 11))
2189-                                                    then (input[11] * weights[20][11])
2190-                                                    else (0 + (if ((size(input) > 12))
2191-                                                        then (input[12] * weights[20][12])
2192-                                                        else (0 + (if ((size(input) > 13))
2193-                                                            then (input[13] * weights[20][13])
2194-                                                            else (0 + (if ((size(input) > 14))
2195-                                                                then (input[14] * weights[20][14])
2196-                                                                else (0 + (if ((size(input) > 15))
2197-                                                                    then (input[15] * weights[20][15])
2198-                                                                    else (0 + (if ((size(input) > 16))
2199-                                                                        then (input[16] * weights[20][16])
2200-                                                                        else (0 + (if ((size(input) > 17))
2201-                                                                            then (input[17] * weights[20][17])
2202-                                                                            else (0 + (if ((size(input) > 18))
2203-                                                                                then (input[18] * weights[20][18])
2204-                                                                                else (0 + (if ((size(input) > 19))
2205-                                                                                    then (input[19] * weights[20][19])
2206-                                                                                    else (0 + (if ((size(input) > 20))
2207-                                                                                        then (input[20] * weights[20][20])
2208-                                                                                        else (0 + (if ((size(input) > 21))
2209-                                                                                            then (input[21] * weights[20][21])
2210-                                                                                            else (0 + (if ((size(input) > 22))
2211-                                                                                                then (input[22] * weights[20][22])
2212-                                                                                                else (0 + (if ((size(input) > 23))
2213-                                                                                                    then (input[23] * weights[20][23])
2214-                                                                                                    else (0 + (if ((size(input) > 24))
2215-                                                                                                        then (input[24] * weights[20][24])
2216-                                                                                                        else (0 + (if ((size(input) > 25))
2217-                                                                                                            then (input[25] * weights[20][25])
2218-                                                                                                            else (0 + (if ((size(input) > 26))
2219-                                                                                                                then (input[26] * weights[20][26])
2220-                                                                                                                else (0 + (if ((size(input) > 27))
2221-                                                                                                                    then (input[27] * weights[20][27])
2222-                                                                                                                    else (0 + (if ((size(input) > 28))
2223-                                                                                                                        then (input[28] * weights[20][28])
2224-                                                                                                                        else (0 + (if ((size(input) > 29))
2225-                                                                                                                            then (input[29] * weights[20][29])
2226-                                                                                                                            else (0 + (if ((size(input) > 30))
2227-                                                                                                                                then (input[30] * weights[20][30])
2228-                                                                                                                                else (0 + (if ((size(input) > 31))
2229-                                                                                                                                    then (input[31] * weights[20][31])
2230-                                                                                                                                    else (0 + (if ((size(input) > 32))
2231-                                                                                                                                        then (input[32] * weights[20][32])
2232-                                                                                                                                        else (0 + (if ((size(input) > 33))
2233-                                                                                                                                            then (input[33] * weights[20][33])
2234-                                                                                                                                            else (0 + (if ((size(input) > 34))
2235-                                                                                                                                                then (input[34] * weights[20][34])
2236-                                                                                                                                                else (0 + (if ((size(input) > 35))
2237-                                                                                                                                                    then (input[35] * weights[20][35])
2238-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[20])
2239-    let weighted_sum22 = (((if ((size(input) > 0))
2240-        then (input[0] * weights[21][0])
2241-        else (0 + (if ((size(input) > 1))
2242-            then (input[1] * weights[21][1])
2243-            else (0 + (if ((size(input) > 2))
2244-                then (input[2] * weights[21][2])
2245-                else (0 + (if ((size(input) > 3))
2246-                    then (input[3] * weights[21][3])
2247-                    else (0 + (if ((size(input) > 4))
2248-                        then (input[4] * weights[21][4])
2249-                        else (0 + (if ((size(input) > 5))
2250-                            then (input[5] * weights[21][5])
2251-                            else (0 + (if ((size(input) > 6))
2252-                                then (input[6] * weights[21][6])
2253-                                else (0 + (if ((size(input) > 7))
2254-                                    then (input[7] * weights[21][7])
2255-                                    else (0 + (if ((size(input) > 8))
2256-                                        then (input[8] * weights[21][8])
2257-                                        else (0 + (if ((size(input) > 9))
2258-                                            then (input[9] * weights[21][9])
2259-                                            else (0 + (if ((size(input) > 10))
2260-                                                then (input[10] * weights[21][10])
2261-                                                else (0 + (if ((size(input) > 11))
2262-                                                    then (input[11] * weights[21][11])
2263-                                                    else (0 + (if ((size(input) > 12))
2264-                                                        then (input[12] * weights[21][12])
2265-                                                        else (0 + (if ((size(input) > 13))
2266-                                                            then (input[13] * weights[21][13])
2267-                                                            else (0 + (if ((size(input) > 14))
2268-                                                                then (input[14] * weights[21][14])
2269-                                                                else (0 + (if ((size(input) > 15))
2270-                                                                    then (input[15] * weights[21][15])
2271-                                                                    else (0 + (if ((size(input) > 16))
2272-                                                                        then (input[16] * weights[21][16])
2273-                                                                        else (0 + (if ((size(input) > 17))
2274-                                                                            then (input[17] * weights[21][17])
2275-                                                                            else (0 + (if ((size(input) > 18))
2276-                                                                                then (input[18] * weights[21][18])
2277-                                                                                else (0 + (if ((size(input) > 19))
2278-                                                                                    then (input[19] * weights[21][19])
2279-                                                                                    else (0 + (if ((size(input) > 20))
2280-                                                                                        then (input[20] * weights[21][20])
2281-                                                                                        else (0 + (if ((size(input) > 21))
2282-                                                                                            then (input[21] * weights[21][21])
2283-                                                                                            else (0 + (if ((size(input) > 22))
2284-                                                                                                then (input[22] * weights[21][22])
2285-                                                                                                else (0 + (if ((size(input) > 23))
2286-                                                                                                    then (input[23] * weights[21][23])
2287-                                                                                                    else (0 + (if ((size(input) > 24))
2288-                                                                                                        then (input[24] * weights[21][24])
2289-                                                                                                        else (0 + (if ((size(input) > 25))
2290-                                                                                                            then (input[25] * weights[21][25])
2291-                                                                                                            else (0 + (if ((size(input) > 26))
2292-                                                                                                                then (input[26] * weights[21][26])
2293-                                                                                                                else (0 + (if ((size(input) > 27))
2294-                                                                                                                    then (input[27] * weights[21][27])
2295-                                                                                                                    else (0 + (if ((size(input) > 28))
2296-                                                                                                                        then (input[28] * weights[21][28])
2297-                                                                                                                        else (0 + (if ((size(input) > 29))
2298-                                                                                                                            then (input[29] * weights[21][29])
2299-                                                                                                                            else (0 + (if ((size(input) > 30))
2300-                                                                                                                                then (input[30] * weights[21][30])
2301-                                                                                                                                else (0 + (if ((size(input) > 31))
2302-                                                                                                                                    then (input[31] * weights[21][31])
2303-                                                                                                                                    else (0 + (if ((size(input) > 32))
2304-                                                                                                                                        then (input[32] * weights[21][32])
2305-                                                                                                                                        else (0 + (if ((size(input) > 33))
2306-                                                                                                                                            then (input[33] * weights[21][33])
2307-                                                                                                                                            else (0 + (if ((size(input) > 34))
2308-                                                                                                                                                then (input[34] * weights[21][34])
2309-                                                                                                                                                else (0 + (if ((size(input) > 35))
2310-                                                                                                                                                    then (input[35] * weights[21][35])
2311-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[21])
2312-    let weighted_sum23 = (((if ((size(input) > 0))
2313-        then (input[0] * weights[22][0])
2314-        else (0 + (if ((size(input) > 1))
2315-            then (input[1] * weights[22][1])
2316-            else (0 + (if ((size(input) > 2))
2317-                then (input[2] * weights[22][2])
2318-                else (0 + (if ((size(input) > 3))
2319-                    then (input[3] * weights[22][3])
2320-                    else (0 + (if ((size(input) > 4))
2321-                        then (input[4] * weights[22][4])
2322-                        else (0 + (if ((size(input) > 5))
2323-                            then (input[5] * weights[22][5])
2324-                            else (0 + (if ((size(input) > 6))
2325-                                then (input[6] * weights[22][6])
2326-                                else (0 + (if ((size(input) > 7))
2327-                                    then (input[7] * weights[22][7])
2328-                                    else (0 + (if ((size(input) > 8))
2329-                                        then (input[8] * weights[22][8])
2330-                                        else (0 + (if ((size(input) > 9))
2331-                                            then (input[9] * weights[22][9])
2332-                                            else (0 + (if ((size(input) > 10))
2333-                                                then (input[10] * weights[22][10])
2334-                                                else (0 + (if ((size(input) > 11))
2335-                                                    then (input[11] * weights[22][11])
2336-                                                    else (0 + (if ((size(input) > 12))
2337-                                                        then (input[12] * weights[22][12])
2338-                                                        else (0 + (if ((size(input) > 13))
2339-                                                            then (input[13] * weights[22][13])
2340-                                                            else (0 + (if ((size(input) > 14))
2341-                                                                then (input[14] * weights[22][14])
2342-                                                                else (0 + (if ((size(input) > 15))
2343-                                                                    then (input[15] * weights[22][15])
2344-                                                                    else (0 + (if ((size(input) > 16))
2345-                                                                        then (input[16] * weights[22][16])
2346-                                                                        else (0 + (if ((size(input) > 17))
2347-                                                                            then (input[17] * weights[22][17])
2348-                                                                            else (0 + (if ((size(input) > 18))
2349-                                                                                then (input[18] * weights[22][18])
2350-                                                                                else (0 + (if ((size(input) > 19))
2351-                                                                                    then (input[19] * weights[22][19])
2352-                                                                                    else (0 + (if ((size(input) > 20))
2353-                                                                                        then (input[20] * weights[22][20])
2354-                                                                                        else (0 + (if ((size(input) > 21))
2355-                                                                                            then (input[21] * weights[22][21])
2356-                                                                                            else (0 + (if ((size(input) > 22))
2357-                                                                                                then (input[22] * weights[22][22])
2358-                                                                                                else (0 + (if ((size(input) > 23))
2359-                                                                                                    then (input[23] * weights[22][23])
2360-                                                                                                    else (0 + (if ((size(input) > 24))
2361-                                                                                                        then (input[24] * weights[22][24])
2362-                                                                                                        else (0 + (if ((size(input) > 25))
2363-                                                                                                            then (input[25] * weights[22][25])
2364-                                                                                                            else (0 + (if ((size(input) > 26))
2365-                                                                                                                then (input[26] * weights[22][26])
2366-                                                                                                                else (0 + (if ((size(input) > 27))
2367-                                                                                                                    then (input[27] * weights[22][27])
2368-                                                                                                                    else (0 + (if ((size(input) > 28))
2369-                                                                                                                        then (input[28] * weights[22][28])
2370-                                                                                                                        else (0 + (if ((size(input) > 29))
2371-                                                                                                                            then (input[29] * weights[22][29])
2372-                                                                                                                            else (0 + (if ((size(input) > 30))
2373-                                                                                                                                then (input[30] * weights[22][30])
2374-                                                                                                                                else (0 + (if ((size(input) > 31))
2375-                                                                                                                                    then (input[31] * weights[22][31])
2376-                                                                                                                                    else (0 + (if ((size(input) > 32))
2377-                                                                                                                                        then (input[32] * weights[22][32])
2378-                                                                                                                                        else (0 + (if ((size(input) > 33))
2379-                                                                                                                                            then (input[33] * weights[22][33])
2380-                                                                                                                                            else (0 + (if ((size(input) > 34))
2381-                                                                                                                                                then (input[34] * weights[22][34])
2382-                                                                                                                                                else (0 + (if ((size(input) > 35))
2383-                                                                                                                                                    then (input[35] * weights[22][35])
2384-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[22])
2385-    let weighted_sum24 = (((if ((size(input) > 0))
2386-        then (input[0] * weights[23][0])
2387-        else (0 + (if ((size(input) > 1))
2388-            then (input[1] * weights[23][1])
2389-            else (0 + (if ((size(input) > 2))
2390-                then (input[2] * weights[23][2])
2391-                else (0 + (if ((size(input) > 3))
2392-                    then (input[3] * weights[23][3])
2393-                    else (0 + (if ((size(input) > 4))
2394-                        then (input[4] * weights[23][4])
2395-                        else (0 + (if ((size(input) > 5))
2396-                            then (input[5] * weights[23][5])
2397-                            else (0 + (if ((size(input) > 6))
2398-                                then (input[6] * weights[23][6])
2399-                                else (0 + (if ((size(input) > 7))
2400-                                    then (input[7] * weights[23][7])
2401-                                    else (0 + (if ((size(input) > 8))
2402-                                        then (input[8] * weights[23][8])
2403-                                        else (0 + (if ((size(input) > 9))
2404-                                            then (input[9] * weights[23][9])
2405-                                            else (0 + (if ((size(input) > 10))
2406-                                                then (input[10] * weights[23][10])
2407-                                                else (0 + (if ((size(input) > 11))
2408-                                                    then (input[11] * weights[23][11])
2409-                                                    else (0 + (if ((size(input) > 12))
2410-                                                        then (input[12] * weights[23][12])
2411-                                                        else (0 + (if ((size(input) > 13))
2412-                                                            then (input[13] * weights[23][13])
2413-                                                            else (0 + (if ((size(input) > 14))
2414-                                                                then (input[14] * weights[23][14])
2415-                                                                else (0 + (if ((size(input) > 15))
2416-                                                                    then (input[15] * weights[23][15])
2417-                                                                    else (0 + (if ((size(input) > 16))
2418-                                                                        then (input[16] * weights[23][16])
2419-                                                                        else (0 + (if ((size(input) > 17))
2420-                                                                            then (input[17] * weights[23][17])
2421-                                                                            else (0 + (if ((size(input) > 18))
2422-                                                                                then (input[18] * weights[23][18])
2423-                                                                                else (0 + (if ((size(input) > 19))
2424-                                                                                    then (input[19] * weights[23][19])
2425-                                                                                    else (0 + (if ((size(input) > 20))
2426-                                                                                        then (input[20] * weights[23][20])
2427-                                                                                        else (0 + (if ((size(input) > 21))
2428-                                                                                            then (input[21] * weights[23][21])
2429-                                                                                            else (0 + (if ((size(input) > 22))
2430-                                                                                                then (input[22] * weights[23][22])
2431-                                                                                                else (0 + (if ((size(input) > 23))
2432-                                                                                                    then (input[23] * weights[23][23])
2433-                                                                                                    else (0 + (if ((size(input) > 24))
2434-                                                                                                        then (input[24] * weights[23][24])
2435-                                                                                                        else (0 + (if ((size(input) > 25))
2436-                                                                                                            then (input[25] * weights[23][25])
2437-                                                                                                            else (0 + (if ((size(input) > 26))
2438-                                                                                                                then (input[26] * weights[23][26])
2439-                                                                                                                else (0 + (if ((size(input) > 27))
2440-                                                                                                                    then (input[27] * weights[23][27])
2441-                                                                                                                    else (0 + (if ((size(input) > 28))
2442-                                                                                                                        then (input[28] * weights[23][28])
2443-                                                                                                                        else (0 + (if ((size(input) > 29))
2444-                                                                                                                            then (input[29] * weights[23][29])
2445-                                                                                                                            else (0 + (if ((size(input) > 30))
2446-                                                                                                                                then (input[30] * weights[23][30])
2447-                                                                                                                                else (0 + (if ((size(input) > 31))
2448-                                                                                                                                    then (input[31] * weights[23][31])
2449-                                                                                                                                    else (0 + (if ((size(input) > 32))
2450-                                                                                                                                        then (input[32] * weights[23][32])
2451-                                                                                                                                        else (0 + (if ((size(input) > 33))
2452-                                                                                                                                            then (input[33] * weights[23][33])
2453-                                                                                                                                            else (0 + (if ((size(input) > 34))
2454-                                                                                                                                                then (input[34] * weights[23][34])
2455-                                                                                                                                                else (0 + (if ((size(input) > 35))
2456-                                                                                                                                                    then (input[35] * weights[23][35])
2457-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[23])
2458-    let weighted_sum25 = (((if ((size(input) > 0))
2459-        then (input[0] * weights[24][0])
2460-        else (0 + (if ((size(input) > 1))
2461-            then (input[1] * weights[24][1])
2462-            else (0 + (if ((size(input) > 2))
2463-                then (input[2] * weights[24][2])
2464-                else (0 + (if ((size(input) > 3))
2465-                    then (input[3] * weights[24][3])
2466-                    else (0 + (if ((size(input) > 4))
2467-                        then (input[4] * weights[24][4])
2468-                        else (0 + (if ((size(input) > 5))
2469-                            then (input[5] * weights[24][5])
2470-                            else (0 + (if ((size(input) > 6))
2471-                                then (input[6] * weights[24][6])
2472-                                else (0 + (if ((size(input) > 7))
2473-                                    then (input[7] * weights[24][7])
2474-                                    else (0 + (if ((size(input) > 8))
2475-                                        then (input[8] * weights[24][8])
2476-                                        else (0 + (if ((size(input) > 9))
2477-                                            then (input[9] * weights[24][9])
2478-                                            else (0 + (if ((size(input) > 10))
2479-                                                then (input[10] * weights[24][10])
2480-                                                else (0 + (if ((size(input) > 11))
2481-                                                    then (input[11] * weights[24][11])
2482-                                                    else (0 + (if ((size(input) > 12))
2483-                                                        then (input[12] * weights[24][12])
2484-                                                        else (0 + (if ((size(input) > 13))
2485-                                                            then (input[13] * weights[24][13])
2486-                                                            else (0 + (if ((size(input) > 14))
2487-                                                                then (input[14] * weights[24][14])
2488-                                                                else (0 + (if ((size(input) > 15))
2489-                                                                    then (input[15] * weights[24][15])
2490-                                                                    else (0 + (if ((size(input) > 16))
2491-                                                                        then (input[16] * weights[24][16])
2492-                                                                        else (0 + (if ((size(input) > 17))
2493-                                                                            then (input[17] * weights[24][17])
2494-                                                                            else (0 + (if ((size(input) > 18))
2495-                                                                                then (input[18] * weights[24][18])
2496-                                                                                else (0 + (if ((size(input) > 19))
2497-                                                                                    then (input[19] * weights[24][19])
2498-                                                                                    else (0 + (if ((size(input) > 20))
2499-                                                                                        then (input[20] * weights[24][20])
2500-                                                                                        else (0 + (if ((size(input) > 21))
2501-                                                                                            then (input[21] * weights[24][21])
2502-                                                                                            else (0 + (if ((size(input) > 22))
2503-                                                                                                then (input[22] * weights[24][22])
2504-                                                                                                else (0 + (if ((size(input) > 23))
2505-                                                                                                    then (input[23] * weights[24][23])
2506-                                                                                                    else (0 + (if ((size(input) > 24))
2507-                                                                                                        then (input[24] * weights[24][24])
2508-                                                                                                        else (0 + (if ((size(input) > 25))
2509-                                                                                                            then (input[25] * weights[24][25])
2510-                                                                                                            else (0 + (if ((size(input) > 26))
2511-                                                                                                                then (input[26] * weights[24][26])
2512-                                                                                                                else (0 + (if ((size(input) > 27))
2513-                                                                                                                    then (input[27] * weights[24][27])
2514-                                                                                                                    else (0 + (if ((size(input) > 28))
2515-                                                                                                                        then (input[28] * weights[24][28])
2516-                                                                                                                        else (0 + (if ((size(input) > 29))
2517-                                                                                                                            then (input[29] * weights[24][29])
2518-                                                                                                                            else (0 + (if ((size(input) > 30))
2519-                                                                                                                                then (input[30] * weights[24][30])
2520-                                                                                                                                else (0 + (if ((size(input) > 31))
2521-                                                                                                                                    then (input[31] * weights[24][31])
2522-                                                                                                                                    else (0 + (if ((size(input) > 32))
2523-                                                                                                                                        then (input[32] * weights[24][32])
2524-                                                                                                                                        else (0 + (if ((size(input) > 33))
2525-                                                                                                                                            then (input[33] * weights[24][33])
2526-                                                                                                                                            else (0 + (if ((size(input) > 34))
2527-                                                                                                                                                then (input[34] * weights[24][34])
2528-                                                                                                                                                else (0 + (if ((size(input) > 35))
2529-                                                                                                                                                    then (input[35] * weights[24][35])
2530-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[24])
2531-    let weighted_sum26 = (((if ((size(input) > 0))
2532-        then (input[0] * weights[25][0])
2533-        else (0 + (if ((size(input) > 1))
2534-            then (input[1] * weights[25][1])
2535-            else (0 + (if ((size(input) > 2))
2536-                then (input[2] * weights[25][2])
2537-                else (0 + (if ((size(input) > 3))
2538-                    then (input[3] * weights[25][3])
2539-                    else (0 + (if ((size(input) > 4))
2540-                        then (input[4] * weights[25][4])
2541-                        else (0 + (if ((size(input) > 5))
2542-                            then (input[5] * weights[25][5])
2543-                            else (0 + (if ((size(input) > 6))
2544-                                then (input[6] * weights[25][6])
2545-                                else (0 + (if ((size(input) > 7))
2546-                                    then (input[7] * weights[25][7])
2547-                                    else (0 + (if ((size(input) > 8))
2548-                                        then (input[8] * weights[25][8])
2549-                                        else (0 + (if ((size(input) > 9))
2550-                                            then (input[9] * weights[25][9])
2551-                                            else (0 + (if ((size(input) > 10))
2552-                                                then (input[10] * weights[25][10])
2553-                                                else (0 + (if ((size(input) > 11))
2554-                                                    then (input[11] * weights[25][11])
2555-                                                    else (0 + (if ((size(input) > 12))
2556-                                                        then (input[12] * weights[25][12])
2557-                                                        else (0 + (if ((size(input) > 13))
2558-                                                            then (input[13] * weights[25][13])
2559-                                                            else (0 + (if ((size(input) > 14))
2560-                                                                then (input[14] * weights[25][14])
2561-                                                                else (0 + (if ((size(input) > 15))
2562-                                                                    then (input[15] * weights[25][15])
2563-                                                                    else (0 + (if ((size(input) > 16))
2564-                                                                        then (input[16] * weights[25][16])
2565-                                                                        else (0 + (if ((size(input) > 17))
2566-                                                                            then (input[17] * weights[25][17])
2567-                                                                            else (0 + (if ((size(input) > 18))
2568-                                                                                then (input[18] * weights[25][18])
2569-                                                                                else (0 + (if ((size(input) > 19))
2570-                                                                                    then (input[19] * weights[25][19])
2571-                                                                                    else (0 + (if ((size(input) > 20))
2572-                                                                                        then (input[20] * weights[25][20])
2573-                                                                                        else (0 + (if ((size(input) > 21))
2574-                                                                                            then (input[21] * weights[25][21])
2575-                                                                                            else (0 + (if ((size(input) > 22))
2576-                                                                                                then (input[22] * weights[25][22])
2577-                                                                                                else (0 + (if ((size(input) > 23))
2578-                                                                                                    then (input[23] * weights[25][23])
2579-                                                                                                    else (0 + (if ((size(input) > 24))
2580-                                                                                                        then (input[24] * weights[25][24])
2581-                                                                                                        else (0 + (if ((size(input) > 25))
2582-                                                                                                            then (input[25] * weights[25][25])
2583-                                                                                                            else (0 + (if ((size(input) > 26))
2584-                                                                                                                then (input[26] * weights[25][26])
2585-                                                                                                                else (0 + (if ((size(input) > 27))
2586-                                                                                                                    then (input[27] * weights[25][27])
2587-                                                                                                                    else (0 + (if ((size(input) > 28))
2588-                                                                                                                        then (input[28] * weights[25][28])
2589-                                                                                                                        else (0 + (if ((size(input) > 29))
2590-                                                                                                                            then (input[29] * weights[25][29])
2591-                                                                                                                            else (0 + (if ((size(input) > 30))
2592-                                                                                                                                then (input[30] * weights[25][30])
2593-                                                                                                                                else (0 + (if ((size(input) > 31))
2594-                                                                                                                                    then (input[31] * weights[25][31])
2595-                                                                                                                                    else (0 + (if ((size(input) > 32))
2596-                                                                                                                                        then (input[32] * weights[25][32])
2597-                                                                                                                                        else (0 + (if ((size(input) > 33))
2598-                                                                                                                                            then (input[33] * weights[25][33])
2599-                                                                                                                                            else (0 + (if ((size(input) > 34))
2600-                                                                                                                                                then (input[34] * weights[25][34])
2601-                                                                                                                                                else (0 + (if ((size(input) > 35))
2602-                                                                                                                                                    then (input[35] * weights[25][35])
2603-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[25])
2604-    let weighted_sum27 = (((if ((size(input) > 0))
2605-        then (input[0] * weights[26][0])
2606-        else (0 + (if ((size(input) > 1))
2607-            then (input[1] * weights[26][1])
2608-            else (0 + (if ((size(input) > 2))
2609-                then (input[2] * weights[26][2])
2610-                else (0 + (if ((size(input) > 3))
2611-                    then (input[3] * weights[26][3])
2612-                    else (0 + (if ((size(input) > 4))
2613-                        then (input[4] * weights[26][4])
2614-                        else (0 + (if ((size(input) > 5))
2615-                            then (input[5] * weights[26][5])
2616-                            else (0 + (if ((size(input) > 6))
2617-                                then (input[6] * weights[26][6])
2618-                                else (0 + (if ((size(input) > 7))
2619-                                    then (input[7] * weights[26][7])
2620-                                    else (0 + (if ((size(input) > 8))
2621-                                        then (input[8] * weights[26][8])
2622-                                        else (0 + (if ((size(input) > 9))
2623-                                            then (input[9] * weights[26][9])
2624-                                            else (0 + (if ((size(input) > 10))
2625-                                                then (input[10] * weights[26][10])
2626-                                                else (0 + (if ((size(input) > 11))
2627-                                                    then (input[11] * weights[26][11])
2628-                                                    else (0 + (if ((size(input) > 12))
2629-                                                        then (input[12] * weights[26][12])
2630-                                                        else (0 + (if ((size(input) > 13))
2631-                                                            then (input[13] * weights[26][13])
2632-                                                            else (0 + (if ((size(input) > 14))
2633-                                                                then (input[14] * weights[26][14])
2634-                                                                else (0 + (if ((size(input) > 15))
2635-                                                                    then (input[15] * weights[26][15])
2636-                                                                    else (0 + (if ((size(input) > 16))
2637-                                                                        then (input[16] * weights[26][16])
2638-                                                                        else (0 + (if ((size(input) > 17))
2639-                                                                            then (input[17] * weights[26][17])
2640-                                                                            else (0 + (if ((size(input) > 18))
2641-                                                                                then (input[18] * weights[26][18])
2642-                                                                                else (0 + (if ((size(input) > 19))
2643-                                                                                    then (input[19] * weights[26][19])
2644-                                                                                    else (0 + (if ((size(input) > 20))
2645-                                                                                        then (input[20] * weights[26][20])
2646-                                                                                        else (0 + (if ((size(input) > 21))
2647-                                                                                            then (input[21] * weights[26][21])
2648-                                                                                            else (0 + (if ((size(input) > 22))
2649-                                                                                                then (input[22] * weights[26][22])
2650-                                                                                                else (0 + (if ((size(input) > 23))
2651-                                                                                                    then (input[23] * weights[26][23])
2652-                                                                                                    else (0 + (if ((size(input) > 24))
2653-                                                                                                        then (input[24] * weights[26][24])
2654-                                                                                                        else (0 + (if ((size(input) > 25))
2655-                                                                                                            then (input[25] * weights[26][25])
2656-                                                                                                            else (0 + (if ((size(input) > 26))
2657-                                                                                                                then (input[26] * weights[26][26])
2658-                                                                                                                else (0 + (if ((size(input) > 27))
2659-                                                                                                                    then (input[27] * weights[26][27])
2660-                                                                                                                    else (0 + (if ((size(input) > 28))
2661-                                                                                                                        then (input[28] * weights[26][28])
2662-                                                                                                                        else (0 + (if ((size(input) > 29))
2663-                                                                                                                            then (input[29] * weights[26][29])
2664-                                                                                                                            else (0 + (if ((size(input) > 30))
2665-                                                                                                                                then (input[30] * weights[26][30])
2666-                                                                                                                                else (0 + (if ((size(input) > 31))
2667-                                                                                                                                    then (input[31] * weights[26][31])
2668-                                                                                                                                    else (0 + (if ((size(input) > 32))
2669-                                                                                                                                        then (input[32] * weights[26][32])
2670-                                                                                                                                        else (0 + (if ((size(input) > 33))
2671-                                                                                                                                            then (input[33] * weights[26][33])
2672-                                                                                                                                            else (0 + (if ((size(input) > 34))
2673-                                                                                                                                                then (input[34] * weights[26][34])
2674-                                                                                                                                                else (0 + (if ((size(input) > 35))
2675-                                                                                                                                                    then (input[35] * weights[26][35])
2676-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[26])
2677-    let weighted_sum28 = (((if ((size(input) > 0))
2678-        then (input[0] * weights[27][0])
2679-        else (0 + (if ((size(input) > 1))
2680-            then (input[1] * weights[27][1])
2681-            else (0 + (if ((size(input) > 2))
2682-                then (input[2] * weights[27][2])
2683-                else (0 + (if ((size(input) > 3))
2684-                    then (input[3] * weights[27][3])
2685-                    else (0 + (if ((size(input) > 4))
2686-                        then (input[4] * weights[27][4])
2687-                        else (0 + (if ((size(input) > 5))
2688-                            then (input[5] * weights[27][5])
2689-                            else (0 + (if ((size(input) > 6))
2690-                                then (input[6] * weights[27][6])
2691-                                else (0 + (if ((size(input) > 7))
2692-                                    then (input[7] * weights[27][7])
2693-                                    else (0 + (if ((size(input) > 8))
2694-                                        then (input[8] * weights[27][8])
2695-                                        else (0 + (if ((size(input) > 9))
2696-                                            then (input[9] * weights[27][9])
2697-                                            else (0 + (if ((size(input) > 10))
2698-                                                then (input[10] * weights[27][10])
2699-                                                else (0 + (if ((size(input) > 11))
2700-                                                    then (input[11] * weights[27][11])
2701-                                                    else (0 + (if ((size(input) > 12))
2702-                                                        then (input[12] * weights[27][12])
2703-                                                        else (0 + (if ((size(input) > 13))
2704-                                                            then (input[13] * weights[27][13])
2705-                                                            else (0 + (if ((size(input) > 14))
2706-                                                                then (input[14] * weights[27][14])
2707-                                                                else (0 + (if ((size(input) > 15))
2708-                                                                    then (input[15] * weights[27][15])
2709-                                                                    else (0 + (if ((size(input) > 16))
2710-                                                                        then (input[16] * weights[27][16])
2711-                                                                        else (0 + (if ((size(input) > 17))
2712-                                                                            then (input[17] * weights[27][17])
2713-                                                                            else (0 + (if ((size(input) > 18))
2714-                                                                                then (input[18] * weights[27][18])
2715-                                                                                else (0 + (if ((size(input) > 19))
2716-                                                                                    then (input[19] * weights[27][19])
2717-                                                                                    else (0 + (if ((size(input) > 20))
2718-                                                                                        then (input[20] * weights[27][20])
2719-                                                                                        else (0 + (if ((size(input) > 21))
2720-                                                                                            then (input[21] * weights[27][21])
2721-                                                                                            else (0 + (if ((size(input) > 22))
2722-                                                                                                then (input[22] * weights[27][22])
2723-                                                                                                else (0 + (if ((size(input) > 23))
2724-                                                                                                    then (input[23] * weights[27][23])
2725-                                                                                                    else (0 + (if ((size(input) > 24))
2726-                                                                                                        then (input[24] * weights[27][24])
2727-                                                                                                        else (0 + (if ((size(input) > 25))
2728-                                                                                                            then (input[25] * weights[27][25])
2729-                                                                                                            else (0 + (if ((size(input) > 26))
2730-                                                                                                                then (input[26] * weights[27][26])
2731-                                                                                                                else (0 + (if ((size(input) > 27))
2732-                                                                                                                    then (input[27] * weights[27][27])
2733-                                                                                                                    else (0 + (if ((size(input) > 28))
2734-                                                                                                                        then (input[28] * weights[27][28])
2735-                                                                                                                        else (0 + (if ((size(input) > 29))
2736-                                                                                                                            then (input[29] * weights[27][29])
2737-                                                                                                                            else (0 + (if ((size(input) > 30))
2738-                                                                                                                                then (input[30] * weights[27][30])
2739-                                                                                                                                else (0 + (if ((size(input) > 31))
2740-                                                                                                                                    then (input[31] * weights[27][31])
2741-                                                                                                                                    else (0 + (if ((size(input) > 32))
2742-                                                                                                                                        then (input[32] * weights[27][32])
2743-                                                                                                                                        else (0 + (if ((size(input) > 33))
2744-                                                                                                                                            then (input[33] * weights[27][33])
2745-                                                                                                                                            else (0 + (if ((size(input) > 34))
2746-                                                                                                                                                then (input[34] * weights[27][34])
2747-                                                                                                                                                else (0 + (if ((size(input) > 35))
2748-                                                                                                                                                    then (input[35] * weights[27][35])
2749-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[27])
2750-    let weighted_sum29 = (((if ((size(input) > 0))
2751-        then (input[0] * weights[28][0])
2752-        else (0 + (if ((size(input) > 1))
2753-            then (input[1] * weights[28][1])
2754-            else (0 + (if ((size(input) > 2))
2755-                then (input[2] * weights[28][2])
2756-                else (0 + (if ((size(input) > 3))
2757-                    then (input[3] * weights[28][3])
2758-                    else (0 + (if ((size(input) > 4))
2759-                        then (input[4] * weights[28][4])
2760-                        else (0 + (if ((size(input) > 5))
2761-                            then (input[5] * weights[28][5])
2762-                            else (0 + (if ((size(input) > 6))
2763-                                then (input[6] * weights[28][6])
2764-                                else (0 + (if ((size(input) > 7))
2765-                                    then (input[7] * weights[28][7])
2766-                                    else (0 + (if ((size(input) > 8))
2767-                                        then (input[8] * weights[28][8])
2768-                                        else (0 + (if ((size(input) > 9))
2769-                                            then (input[9] * weights[28][9])
2770-                                            else (0 + (if ((size(input) > 10))
2771-                                                then (input[10] * weights[28][10])
2772-                                                else (0 + (if ((size(input) > 11))
2773-                                                    then (input[11] * weights[28][11])
2774-                                                    else (0 + (if ((size(input) > 12))
2775-                                                        then (input[12] * weights[28][12])
2776-                                                        else (0 + (if ((size(input) > 13))
2777-                                                            then (input[13] * weights[28][13])
2778-                                                            else (0 + (if ((size(input) > 14))
2779-                                                                then (input[14] * weights[28][14])
2780-                                                                else (0 + (if ((size(input) > 15))
2781-                                                                    then (input[15] * weights[28][15])
2782-                                                                    else (0 + (if ((size(input) > 16))
2783-                                                                        then (input[16] * weights[28][16])
2784-                                                                        else (0 + (if ((size(input) > 17))
2785-                                                                            then (input[17] * weights[28][17])
2786-                                                                            else (0 + (if ((size(input) > 18))
2787-                                                                                then (input[18] * weights[28][18])
2788-                                                                                else (0 + (if ((size(input) > 19))
2789-                                                                                    then (input[19] * weights[28][19])
2790-                                                                                    else (0 + (if ((size(input) > 20))
2791-                                                                                        then (input[20] * weights[28][20])
2792-                                                                                        else (0 + (if ((size(input) > 21))
2793-                                                                                            then (input[21] * weights[28][21])
2794-                                                                                            else (0 + (if ((size(input) > 22))
2795-                                                                                                then (input[22] * weights[28][22])
2796-                                                                                                else (0 + (if ((size(input) > 23))
2797-                                                                                                    then (input[23] * weights[28][23])
2798-                                                                                                    else (0 + (if ((size(input) > 24))
2799-                                                                                                        then (input[24] * weights[28][24])
2800-                                                                                                        else (0 + (if ((size(input) > 25))
2801-                                                                                                            then (input[25] * weights[28][25])
2802-                                                                                                            else (0 + (if ((size(input) > 26))
2803-                                                                                                                then (input[26] * weights[28][26])
2804-                                                                                                                else (0 + (if ((size(input) > 27))
2805-                                                                                                                    then (input[27] * weights[28][27])
2806-                                                                                                                    else (0 + (if ((size(input) > 28))
2807-                                                                                                                        then (input[28] * weights[28][28])
2808-                                                                                                                        else (0 + (if ((size(input) > 29))
2809-                                                                                                                            then (input[29] * weights[28][29])
2810-                                                                                                                            else (0 + (if ((size(input) > 30))
2811-                                                                                                                                then (input[30] * weights[28][30])
2812-                                                                                                                                else (0 + (if ((size(input) > 31))
2813-                                                                                                                                    then (input[31] * weights[28][31])
2814-                                                                                                                                    else (0 + (if ((size(input) > 32))
2815-                                                                                                                                        then (input[32] * weights[28][32])
2816-                                                                                                                                        else (0 + (if ((size(input) > 33))
2817-                                                                                                                                            then (input[33] * weights[28][33])
2818-                                                                                                                                            else (0 + (if ((size(input) > 34))
2819-                                                                                                                                                then (input[34] * weights[28][34])
2820-                                                                                                                                                else (0 + (if ((size(input) > 35))
2821-                                                                                                                                                    then (input[35] * weights[28][35])
2822-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[28])
2823-    let weighted_sum30 = (((if ((size(input) > 0))
2824-        then (input[0] * weights[29][0])
2825-        else (0 + (if ((size(input) > 1))
2826-            then (input[1] * weights[29][1])
2827-            else (0 + (if ((size(input) > 2))
2828-                then (input[2] * weights[29][2])
2829-                else (0 + (if ((size(input) > 3))
2830-                    then (input[3] * weights[29][3])
2831-                    else (0 + (if ((size(input) > 4))
2832-                        then (input[4] * weights[29][4])
2833-                        else (0 + (if ((size(input) > 5))
2834-                            then (input[5] * weights[29][5])
2835-                            else (0 + (if ((size(input) > 6))
2836-                                then (input[6] * weights[29][6])
2837-                                else (0 + (if ((size(input) > 7))
2838-                                    then (input[7] * weights[29][7])
2839-                                    else (0 + (if ((size(input) > 8))
2840-                                        then (input[8] * weights[29][8])
2841-                                        else (0 + (if ((size(input) > 9))
2842-                                            then (input[9] * weights[29][9])
2843-                                            else (0 + (if ((size(input) > 10))
2844-                                                then (input[10] * weights[29][10])
2845-                                                else (0 + (if ((size(input) > 11))
2846-                                                    then (input[11] * weights[29][11])
2847-                                                    else (0 + (if ((size(input) > 12))
2848-                                                        then (input[12] * weights[29][12])
2849-                                                        else (0 + (if ((size(input) > 13))
2850-                                                            then (input[13] * weights[29][13])
2851-                                                            else (0 + (if ((size(input) > 14))
2852-                                                                then (input[14] * weights[29][14])
2853-                                                                else (0 + (if ((size(input) > 15))
2854-                                                                    then (input[15] * weights[29][15])
2855-                                                                    else (0 + (if ((size(input) > 16))
2856-                                                                        then (input[16] * weights[29][16])
2857-                                                                        else (0 + (if ((size(input) > 17))
2858-                                                                            then (input[17] * weights[29][17])
2859-                                                                            else (0 + (if ((size(input) > 18))
2860-                                                                                then (input[18] * weights[29][18])
2861-                                                                                else (0 + (if ((size(input) > 19))
2862-                                                                                    then (input[19] * weights[29][19])
2863-                                                                                    else (0 + (if ((size(input) > 20))
2864-                                                                                        then (input[20] * weights[29][20])
2865-                                                                                        else (0 + (if ((size(input) > 21))
2866-                                                                                            then (input[21] * weights[29][21])
2867-                                                                                            else (0 + (if ((size(input) > 22))
2868-                                                                                                then (input[22] * weights[29][22])
2869-                                                                                                else (0 + (if ((size(input) > 23))
2870-                                                                                                    then (input[23] * weights[29][23])
2871-                                                                                                    else (0 + (if ((size(input) > 24))
2872-                                                                                                        then (input[24] * weights[29][24])
2873-                                                                                                        else (0 + (if ((size(input) > 25))
2874-                                                                                                            then (input[25] * weights[29][25])
2875-                                                                                                            else (0 + (if ((size(input) > 26))
2876-                                                                                                                then (input[26] * weights[29][26])
2877-                                                                                                                else (0 + (if ((size(input) > 27))
2878-                                                                                                                    then (input[27] * weights[29][27])
2879-                                                                                                                    else (0 + (if ((size(input) > 28))
2880-                                                                                                                        then (input[28] * weights[29][28])
2881-                                                                                                                        else (0 + (if ((size(input) > 29))
2882-                                                                                                                            then (input[29] * weights[29][29])
2883-                                                                                                                            else (0 + (if ((size(input) > 30))
2884-                                                                                                                                then (input[30] * weights[29][30])
2885-                                                                                                                                else (0 + (if ((size(input) > 31))
2886-                                                                                                                                    then (input[31] * weights[29][31])
2887-                                                                                                                                    else (0 + (if ((size(input) > 32))
2888-                                                                                                                                        then (input[32] * weights[29][32])
2889-                                                                                                                                        else (0 + (if ((size(input) > 33))
2890-                                                                                                                                            then (input[33] * weights[29][33])
2891-                                                                                                                                            else (0 + (if ((size(input) > 34))
2892-                                                                                                                                                then (input[34] * weights[29][34])
2893-                                                                                                                                                else (0 + (if ((size(input) > 35))
2894-                                                                                                                                                    then (input[35] * weights[29][35])
2895-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[29])
2896-    let weighted_sum31 = (((if ((size(input) > 0))
2897-        then (input[0] * weights[30][0])
2898-        else (0 + (if ((size(input) > 1))
2899-            then (input[1] * weights[30][1])
2900-            else (0 + (if ((size(input) > 2))
2901-                then (input[2] * weights[30][2])
2902-                else (0 + (if ((size(input) > 3))
2903-                    then (input[3] * weights[30][3])
2904-                    else (0 + (if ((size(input) > 4))
2905-                        then (input[4] * weights[30][4])
2906-                        else (0 + (if ((size(input) > 5))
2907-                            then (input[5] * weights[30][5])
2908-                            else (0 + (if ((size(input) > 6))
2909-                                then (input[6] * weights[30][6])
2910-                                else (0 + (if ((size(input) > 7))
2911-                                    then (input[7] * weights[30][7])
2912-                                    else (0 + (if ((size(input) > 8))
2913-                                        then (input[8] * weights[30][8])
2914-                                        else (0 + (if ((size(input) > 9))
2915-                                            then (input[9] * weights[30][9])
2916-                                            else (0 + (if ((size(input) > 10))
2917-                                                then (input[10] * weights[30][10])
2918-                                                else (0 + (if ((size(input) > 11))
2919-                                                    then (input[11] * weights[30][11])
2920-                                                    else (0 + (if ((size(input) > 12))
2921-                                                        then (input[12] * weights[30][12])
2922-                                                        else (0 + (if ((size(input) > 13))
2923-                                                            then (input[13] * weights[30][13])
2924-                                                            else (0 + (if ((size(input) > 14))
2925-                                                                then (input[14] * weights[30][14])
2926-                                                                else (0 + (if ((size(input) > 15))
2927-                                                                    then (input[15] * weights[30][15])
2928-                                                                    else (0 + (if ((size(input) > 16))
2929-                                                                        then (input[16] * weights[30][16])
2930-                                                                        else (0 + (if ((size(input) > 17))
2931-                                                                            then (input[17] * weights[30][17])
2932-                                                                            else (0 + (if ((size(input) > 18))
2933-                                                                                then (input[18] * weights[30][18])
2934-                                                                                else (0 + (if ((size(input) > 19))
2935-                                                                                    then (input[19] * weights[30][19])
2936-                                                                                    else (0 + (if ((size(input) > 20))
2937-                                                                                        then (input[20] * weights[30][20])
2938-                                                                                        else (0 + (if ((size(input) > 21))
2939-                                                                                            then (input[21] * weights[30][21])
2940-                                                                                            else (0 + (if ((size(input) > 22))
2941-                                                                                                then (input[22] * weights[30][22])
2942-                                                                                                else (0 + (if ((size(input) > 23))
2943-                                                                                                    then (input[23] * weights[30][23])
2944-                                                                                                    else (0 + (if ((size(input) > 24))
2945-                                                                                                        then (input[24] * weights[30][24])
2946-                                                                                                        else (0 + (if ((size(input) > 25))
2947-                                                                                                            then (input[25] * weights[30][25])
2948-                                                                                                            else (0 + (if ((size(input) > 26))
2949-                                                                                                                then (input[26] * weights[30][26])
2950-                                                                                                                else (0 + (if ((size(input) > 27))
2951-                                                                                                                    then (input[27] * weights[30][27])
2952-                                                                                                                    else (0 + (if ((size(input) > 28))
2953-                                                                                                                        then (input[28] * weights[30][28])
2954-                                                                                                                        else (0 + (if ((size(input) > 29))
2955-                                                                                                                            then (input[29] * weights[30][29])
2956-                                                                                                                            else (0 + (if ((size(input) > 30))
2957-                                                                                                                                then (input[30] * weights[30][30])
2958-                                                                                                                                else (0 + (if ((size(input) > 31))
2959-                                                                                                                                    then (input[31] * weights[30][31])
2960-                                                                                                                                    else (0 + (if ((size(input) > 32))
2961-                                                                                                                                        then (input[32] * weights[30][32])
2962-                                                                                                                                        else (0 + (if ((size(input) > 33))
2963-                                                                                                                                            then (input[33] * weights[30][33])
2964-                                                                                                                                            else (0 + (if ((size(input) > 34))
2965-                                                                                                                                                then (input[34] * weights[30][34])
2966-                                                                                                                                                else (0 + (if ((size(input) > 35))
2967-                                                                                                                                                    then (input[35] * weights[30][35])
2968-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[30])
2969-    let weighted_sum32 = (((if ((size(input) > 0))
2970-        then (input[0] * weights[31][0])
2971-        else (0 + (if ((size(input) > 1))
2972-            then (input[1] * weights[31][1])
2973-            else (0 + (if ((size(input) > 2))
2974-                then (input[2] * weights[31][2])
2975-                else (0 + (if ((size(input) > 3))
2976-                    then (input[3] * weights[31][3])
2977-                    else (0 + (if ((size(input) > 4))
2978-                        then (input[4] * weights[31][4])
2979-                        else (0 + (if ((size(input) > 5))
2980-                            then (input[5] * weights[31][5])
2981-                            else (0 + (if ((size(input) > 6))
2982-                                then (input[6] * weights[31][6])
2983-                                else (0 + (if ((size(input) > 7))
2984-                                    then (input[7] * weights[31][7])
2985-                                    else (0 + (if ((size(input) > 8))
2986-                                        then (input[8] * weights[31][8])
2987-                                        else (0 + (if ((size(input) > 9))
2988-                                            then (input[9] * weights[31][9])
2989-                                            else (0 + (if ((size(input) > 10))
2990-                                                then (input[10] * weights[31][10])
2991-                                                else (0 + (if ((size(input) > 11))
2992-                                                    then (input[11] * weights[31][11])
2993-                                                    else (0 + (if ((size(input) > 12))
2994-                                                        then (input[12] * weights[31][12])
2995-                                                        else (0 + (if ((size(input) > 13))
2996-                                                            then (input[13] * weights[31][13])
2997-                                                            else (0 + (if ((size(input) > 14))
2998-                                                                then (input[14] * weights[31][14])
2999-                                                                else (0 + (if ((size(input) > 15))
3000-                                                                    then (input[15] * weights[31][15])
3001-                                                                    else (0 + (if ((size(input) > 16))
3002-                                                                        then (input[16] * weights[31][16])
3003-                                                                        else (0 + (if ((size(input) > 17))
3004-                                                                            then (input[17] * weights[31][17])
3005-                                                                            else (0 + (if ((size(input) > 18))
3006-                                                                                then (input[18] * weights[31][18])
3007-                                                                                else (0 + (if ((size(input) > 19))
3008-                                                                                    then (input[19] * weights[31][19])
3009-                                                                                    else (0 + (if ((size(input) > 20))
3010-                                                                                        then (input[20] * weights[31][20])
3011-                                                                                        else (0 + (if ((size(input) > 21))
3012-                                                                                            then (input[21] * weights[31][21])
3013-                                                                                            else (0 + (if ((size(input) > 22))
3014-                                                                                                then (input[22] * weights[31][22])
3015-                                                                                                else (0 + (if ((size(input) > 23))
3016-                                                                                                    then (input[23] * weights[31][23])
3017-                                                                                                    else (0 + (if ((size(input) > 24))
3018-                                                                                                        then (input[24] * weights[31][24])
3019-                                                                                                        else (0 + (if ((size(input) > 25))
3020-                                                                                                            then (input[25] * weights[31][25])
3021-                                                                                                            else (0 + (if ((size(input) > 26))
3022-                                                                                                                then (input[26] * weights[31][26])
3023-                                                                                                                else (0 + (if ((size(input) > 27))
3024-                                                                                                                    then (input[27] * weights[31][27])
3025-                                                                                                                    else (0 + (if ((size(input) > 28))
3026-                                                                                                                        then (input[28] * weights[31][28])
3027-                                                                                                                        else (0 + (if ((size(input) > 29))
3028-                                                                                                                            then (input[29] * weights[31][29])
3029-                                                                                                                            else (0 + (if ((size(input) > 30))
3030-                                                                                                                                then (input[30] * weights[31][30])
3031-                                                                                                                                else (0 + (if ((size(input) > 31))
3032-                                                                                                                                    then (input[31] * weights[31][31])
3033-                                                                                                                                    else (0 + (if ((size(input) > 32))
3034-                                                                                                                                        then (input[32] * weights[31][32])
3035-                                                                                                                                        else (0 + (if ((size(input) > 33))
3036-                                                                                                                                            then (input[33] * weights[31][33])
3037-                                                                                                                                            else (0 + (if ((size(input) > 34))
3038-                                                                                                                                                then (input[34] * weights[31][34])
3039-                                                                                                                                                else (0 + (if ((size(input) > 35))
3040-                                                                                                                                                    then (input[35] * weights[31][35])
3041-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[31])
3042-    let weighted_sum33 = (((if ((size(input) > 0))
3043-        then (input[0] * weights[32][0])
3044-        else (0 + (if ((size(input) > 1))
3045-            then (input[1] * weights[32][1])
3046-            else (0 + (if ((size(input) > 2))
3047-                then (input[2] * weights[32][2])
3048-                else (0 + (if ((size(input) > 3))
3049-                    then (input[3] * weights[32][3])
3050-                    else (0 + (if ((size(input) > 4))
3051-                        then (input[4] * weights[32][4])
3052-                        else (0 + (if ((size(input) > 5))
3053-                            then (input[5] * weights[32][5])
3054-                            else (0 + (if ((size(input) > 6))
3055-                                then (input[6] * weights[32][6])
3056-                                else (0 + (if ((size(input) > 7))
3057-                                    then (input[7] * weights[32][7])
3058-                                    else (0 + (if ((size(input) > 8))
3059-                                        then (input[8] * weights[32][8])
3060-                                        else (0 + (if ((size(input) > 9))
3061-                                            then (input[9] * weights[32][9])
3062-                                            else (0 + (if ((size(input) > 10))
3063-                                                then (input[10] * weights[32][10])
3064-                                                else (0 + (if ((size(input) > 11))
3065-                                                    then (input[11] * weights[32][11])
3066-                                                    else (0 + (if ((size(input) > 12))
3067-                                                        then (input[12] * weights[32][12])
3068-                                                        else (0 + (if ((size(input) > 13))
3069-                                                            then (input[13] * weights[32][13])
3070-                                                            else (0 + (if ((size(input) > 14))
3071-                                                                then (input[14] * weights[32][14])
3072-                                                                else (0 + (if ((size(input) > 15))
3073-                                                                    then (input[15] * weights[32][15])
3074-                                                                    else (0 + (if ((size(input) > 16))
3075-                                                                        then (input[16] * weights[32][16])
3076-                                                                        else (0 + (if ((size(input) > 17))
3077-                                                                            then (input[17] * weights[32][17])
3078-                                                                            else (0 + (if ((size(input) > 18))
3079-                                                                                then (input[18] * weights[32][18])
3080-                                                                                else (0 + (if ((size(input) > 19))
3081-                                                                                    then (input[19] * weights[32][19])
3082-                                                                                    else (0 + (if ((size(input) > 20))
3083-                                                                                        then (input[20] * weights[32][20])
3084-                                                                                        else (0 + (if ((size(input) > 21))
3085-                                                                                            then (input[21] * weights[32][21])
3086-                                                                                            else (0 + (if ((size(input) > 22))
3087-                                                                                                then (input[22] * weights[32][22])
3088-                                                                                                else (0 + (if ((size(input) > 23))
3089-                                                                                                    then (input[23] * weights[32][23])
3090-                                                                                                    else (0 + (if ((size(input) > 24))
3091-                                                                                                        then (input[24] * weights[32][24])
3092-                                                                                                        else (0 + (if ((size(input) > 25))
3093-                                                                                                            then (input[25] * weights[32][25])
3094-                                                                                                            else (0 + (if ((size(input) > 26))
3095-                                                                                                                then (input[26] * weights[32][26])
3096-                                                                                                                else (0 + (if ((size(input) > 27))
3097-                                                                                                                    then (input[27] * weights[32][27])
3098-                                                                                                                    else (0 + (if ((size(input) > 28))
3099-                                                                                                                        then (input[28] * weights[32][28])
3100-                                                                                                                        else (0 + (if ((size(input) > 29))
3101-                                                                                                                            then (input[29] * weights[32][29])
3102-                                                                                                                            else (0 + (if ((size(input) > 30))
3103-                                                                                                                                then (input[30] * weights[32][30])
3104-                                                                                                                                else (0 + (if ((size(input) > 31))
3105-                                                                                                                                    then (input[31] * weights[32][31])
3106-                                                                                                                                    else (0 + (if ((size(input) > 32))
3107-                                                                                                                                        then (input[32] * weights[32][32])
3108-                                                                                                                                        else (0 + (if ((size(input) > 33))
3109-                                                                                                                                            then (input[33] * weights[32][33])
3110-                                                                                                                                            else (0 + (if ((size(input) > 34))
3111-                                                                                                                                                then (input[34] * weights[32][34])
3112-                                                                                                                                                else (0 + (if ((size(input) > 35))
3113-                                                                                                                                                    then (input[35] * weights[32][35])
3114-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[32])
3115-    let weighted_sum34 = (((if ((size(input) > 0))
3116-        then (input[0] * weights[33][0])
3117-        else (0 + (if ((size(input) > 1))
3118-            then (input[1] * weights[33][1])
3119-            else (0 + (if ((size(input) > 2))
3120-                then (input[2] * weights[33][2])
3121-                else (0 + (if ((size(input) > 3))
3122-                    then (input[3] * weights[33][3])
3123-                    else (0 + (if ((size(input) > 4))
3124-                        then (input[4] * weights[33][4])
3125-                        else (0 + (if ((size(input) > 5))
3126-                            then (input[5] * weights[33][5])
3127-                            else (0 + (if ((size(input) > 6))
3128-                                then (input[6] * weights[33][6])
3129-                                else (0 + (if ((size(input) > 7))
3130-                                    then (input[7] * weights[33][7])
3131-                                    else (0 + (if ((size(input) > 8))
3132-                                        then (input[8] * weights[33][8])
3133-                                        else (0 + (if ((size(input) > 9))
3134-                                            then (input[9] * weights[33][9])
3135-                                            else (0 + (if ((size(input) > 10))
3136-                                                then (input[10] * weights[33][10])
3137-                                                else (0 + (if ((size(input) > 11))
3138-                                                    then (input[11] * weights[33][11])
3139-                                                    else (0 + (if ((size(input) > 12))
3140-                                                        then (input[12] * weights[33][12])
3141-                                                        else (0 + (if ((size(input) > 13))
3142-                                                            then (input[13] * weights[33][13])
3143-                                                            else (0 + (if ((size(input) > 14))
3144-                                                                then (input[14] * weights[33][14])
3145-                                                                else (0 + (if ((size(input) > 15))
3146-                                                                    then (input[15] * weights[33][15])
3147-                                                                    else (0 + (if ((size(input) > 16))
3148-                                                                        then (input[16] * weights[33][16])
3149-                                                                        else (0 + (if ((size(input) > 17))
3150-                                                                            then (input[17] * weights[33][17])
3151-                                                                            else (0 + (if ((size(input) > 18))
3152-                                                                                then (input[18] * weights[33][18])
3153-                                                                                else (0 + (if ((size(input) > 19))
3154-                                                                                    then (input[19] * weights[33][19])
3155-                                                                                    else (0 + (if ((size(input) > 20))
3156-                                                                                        then (input[20] * weights[33][20])
3157-                                                                                        else (0 + (if ((size(input) > 21))
3158-                                                                                            then (input[21] * weights[33][21])
3159-                                                                                            else (0 + (if ((size(input) > 22))
3160-                                                                                                then (input[22] * weights[33][22])
3161-                                                                                                else (0 + (if ((size(input) > 23))
3162-                                                                                                    then (input[23] * weights[33][23])
3163-                                                                                                    else (0 + (if ((size(input) > 24))
3164-                                                                                                        then (input[24] * weights[33][24])
3165-                                                                                                        else (0 + (if ((size(input) > 25))
3166-                                                                                                            then (input[25] * weights[33][25])
3167-                                                                                                            else (0 + (if ((size(input) > 26))
3168-                                                                                                                then (input[26] * weights[33][26])
3169-                                                                                                                else (0 + (if ((size(input) > 27))
3170-                                                                                                                    then (input[27] * weights[33][27])
3171-                                                                                                                    else (0 + (if ((size(input) > 28))
3172-                                                                                                                        then (input[28] * weights[33][28])
3173-                                                                                                                        else (0 + (if ((size(input) > 29))
3174-                                                                                                                            then (input[29] * weights[33][29])
3175-                                                                                                                            else (0 + (if ((size(input) > 30))
3176-                                                                                                                                then (input[30] * weights[33][30])
3177-                                                                                                                                else (0 + (if ((size(input) > 31))
3178-                                                                                                                                    then (input[31] * weights[33][31])
3179-                                                                                                                                    else (0 + (if ((size(input) > 32))
3180-                                                                                                                                        then (input[32] * weights[33][32])
3181-                                                                                                                                        else (0 + (if ((size(input) > 33))
3182-                                                                                                                                            then (input[33] * weights[33][33])
3183-                                                                                                                                            else (0 + (if ((size(input) > 34))
3184-                                                                                                                                                then (input[34] * weights[33][34])
3185-                                                                                                                                                else (0 + (if ((size(input) > 35))
3186-                                                                                                                                                    then (input[35] * weights[33][35])
3187-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[33])
3188-    let weighted_sum35 = (((if ((size(input) > 0))
3189-        then (input[0] * weights[34][0])
3190-        else (0 + (if ((size(input) > 1))
3191-            then (input[1] * weights[34][1])
3192-            else (0 + (if ((size(input) > 2))
3193-                then (input[2] * weights[34][2])
3194-                else (0 + (if ((size(input) > 3))
3195-                    then (input[3] * weights[34][3])
3196-                    else (0 + (if ((size(input) > 4))
3197-                        then (input[4] * weights[34][4])
3198-                        else (0 + (if ((size(input) > 5))
3199-                            then (input[5] * weights[34][5])
3200-                            else (0 + (if ((size(input) > 6))
3201-                                then (input[6] * weights[34][6])
3202-                                else (0 + (if ((size(input) > 7))
3203-                                    then (input[7] * weights[34][7])
3204-                                    else (0 + (if ((size(input) > 8))
3205-                                        then (input[8] * weights[34][8])
3206-                                        else (0 + (if ((size(input) > 9))
3207-                                            then (input[9] * weights[34][9])
3208-                                            else (0 + (if ((size(input) > 10))
3209-                                                then (input[10] * weights[34][10])
3210-                                                else (0 + (if ((size(input) > 11))
3211-                                                    then (input[11] * weights[34][11])
3212-                                                    else (0 + (if ((size(input) > 12))
3213-                                                        then (input[12] * weights[34][12])
3214-                                                        else (0 + (if ((size(input) > 13))
3215-                                                            then (input[13] * weights[34][13])
3216-                                                            else (0 + (if ((size(input) > 14))
3217-                                                                then (input[14] * weights[34][14])
3218-                                                                else (0 + (if ((size(input) > 15))
3219-                                                                    then (input[15] * weights[34][15])
3220-                                                                    else (0 + (if ((size(input) > 16))
3221-                                                                        then (input[16] * weights[34][16])
3222-                                                                        else (0 + (if ((size(input) > 17))
3223-                                                                            then (input[17] * weights[34][17])
3224-                                                                            else (0 + (if ((size(input) > 18))
3225-                                                                                then (input[18] * weights[34][18])
3226-                                                                                else (0 + (if ((size(input) > 19))
3227-                                                                                    then (input[19] * weights[34][19])
3228-                                                                                    else (0 + (if ((size(input) > 20))
3229-                                                                                        then (input[20] * weights[34][20])
3230-                                                                                        else (0 + (if ((size(input) > 21))
3231-                                                                                            then (input[21] * weights[34][21])
3232-                                                                                            else (0 + (if ((size(input) > 22))
3233-                                                                                                then (input[22] * weights[34][22])
3234-                                                                                                else (0 + (if ((size(input) > 23))
3235-                                                                                                    then (input[23] * weights[34][23])
3236-                                                                                                    else (0 + (if ((size(input) > 24))
3237-                                                                                                        then (input[24] * weights[34][24])
3238-                                                                                                        else (0 + (if ((size(input) > 25))
3239-                                                                                                            then (input[25] * weights[34][25])
3240-                                                                                                            else (0 + (if ((size(input) > 26))
3241-                                                                                                                then (input[26] * weights[34][26])
3242-                                                                                                                else (0 + (if ((size(input) > 27))
3243-                                                                                                                    then (input[27] * weights[34][27])
3244-                                                                                                                    else (0 + (if ((size(input) > 28))
3245-                                                                                                                        then (input[28] * weights[34][28])
3246-                                                                                                                        else (0 + (if ((size(input) > 29))
3247-                                                                                                                            then (input[29] * weights[34][29])
3248-                                                                                                                            else (0 + (if ((size(input) > 30))
3249-                                                                                                                                then (input[30] * weights[34][30])
3250-                                                                                                                                else (0 + (if ((size(input) > 31))
3251-                                                                                                                                    then (input[31] * weights[34][31])
3252-                                                                                                                                    else (0 + (if ((size(input) > 32))
3253-                                                                                                                                        then (input[32] * weights[34][32])
3254-                                                                                                                                        else (0 + (if ((size(input) > 33))
3255-                                                                                                                                            then (input[33] * weights[34][33])
3256-                                                                                                                                            else (0 + (if ((size(input) > 34))
3257-                                                                                                                                                then (input[34] * weights[34][34])
3258-                                                                                                                                                else (0 + (if ((size(input) > 35))
3259-                                                                                                                                                    then (input[35] * weights[34][35])
3260-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[34])
3261-    let weighted_sum36 = (((if ((size(input) > 0))
3262-        then (input[0] * weights[35][0])
3263-        else (0 + (if ((size(input) > 1))
3264-            then (input[1] * weights[35][1])
3265-            else (0 + (if ((size(input) > 2))
3266-                then (input[2] * weights[35][2])
3267-                else (0 + (if ((size(input) > 3))
3268-                    then (input[3] * weights[35][3])
3269-                    else (0 + (if ((size(input) > 4))
3270-                        then (input[4] * weights[35][4])
3271-                        else (0 + (if ((size(input) > 5))
3272-                            then (input[5] * weights[35][5])
3273-                            else (0 + (if ((size(input) > 6))
3274-                                then (input[6] * weights[35][6])
3275-                                else (0 + (if ((size(input) > 7))
3276-                                    then (input[7] * weights[35][7])
3277-                                    else (0 + (if ((size(input) > 8))
3278-                                        then (input[8] * weights[35][8])
3279-                                        else (0 + (if ((size(input) > 9))
3280-                                            then (input[9] * weights[35][9])
3281-                                            else (0 + (if ((size(input) > 10))
3282-                                                then (input[10] * weights[35][10])
3283-                                                else (0 + (if ((size(input) > 11))
3284-                                                    then (input[11] * weights[35][11])
3285-                                                    else (0 + (if ((size(input) > 12))
3286-                                                        then (input[12] * weights[35][12])
3287-                                                        else (0 + (if ((size(input) > 13))
3288-                                                            then (input[13] * weights[35][13])
3289-                                                            else (0 + (if ((size(input) > 14))
3290-                                                                then (input[14] * weights[35][14])
3291-                                                                else (0 + (if ((size(input) > 15))
3292-                                                                    then (input[15] * weights[35][15])
3293-                                                                    else (0 + (if ((size(input) > 16))
3294-                                                                        then (input[16] * weights[35][16])
3295-                                                                        else (0 + (if ((size(input) > 17))
3296-                                                                            then (input[17] * weights[35][17])
3297-                                                                            else (0 + (if ((size(input) > 18))
3298-                                                                                then (input[18] * weights[35][18])
3299-                                                                                else (0 + (if ((size(input) > 19))
3300-                                                                                    then (input[19] * weights[35][19])
3301-                                                                                    else (0 + (if ((size(input) > 20))
3302-                                                                                        then (input[20] * weights[35][20])
3303-                                                                                        else (0 + (if ((size(input) > 21))
3304-                                                                                            then (input[21] * weights[35][21])
3305-                                                                                            else (0 + (if ((size(input) > 22))
3306-                                                                                                then (input[22] * weights[35][22])
3307-                                                                                                else (0 + (if ((size(input) > 23))
3308-                                                                                                    then (input[23] * weights[35][23])
3309-                                                                                                    else (0 + (if ((size(input) > 24))
3310-                                                                                                        then (input[24] * weights[35][24])
3311-                                                                                                        else (0 + (if ((size(input) > 25))
3312-                                                                                                            then (input[25] * weights[35][25])
3313-                                                                                                            else (0 + (if ((size(input) > 26))
3314-                                                                                                                then (input[26] * weights[35][26])
3315-                                                                                                                else (0 + (if ((size(input) > 27))
3316-                                                                                                                    then (input[27] * weights[35][27])
3317-                                                                                                                    else (0 + (if ((size(input) > 28))
3318-                                                                                                                        then (input[28] * weights[35][28])
3319-                                                                                                                        else (0 + (if ((size(input) > 29))
3320-                                                                                                                            then (input[29] * weights[35][29])
3321-                                                                                                                            else (0 + (if ((size(input) > 30))
3322-                                                                                                                                then (input[30] * weights[35][30])
3323-                                                                                                                                else (0 + (if ((size(input) > 31))
3324-                                                                                                                                    then (input[31] * weights[35][31])
3325-                                                                                                                                    else (0 + (if ((size(input) > 32))
3326-                                                                                                                                        then (input[32] * weights[35][32])
3327-                                                                                                                                        else (0 + (if ((size(input) > 33))
3328-                                                                                                                                            then (input[33] * weights[35][33])
3329-                                                                                                                                            else (0 + (if ((size(input) > 34))
3330-                                                                                                                                                then (input[34] * weights[35][34])
3331-                                                                                                                                                else (0 + (if ((size(input) > 35))
3332-                                                                                                                                                    then (input[35] * weights[35][35])
3333-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[35])
3334-[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9, weighted_sum10, weighted_sum11, weighted_sum12, weighted_sum13, weighted_sum14, weighted_sum15, weighted_sum16, weighted_sum17, weighted_sum18, weighted_sum19, weighted_sum20, weighted_sum21, weighted_sum22, weighted_sum23, weighted_sum24, weighted_sum25, weighted_sum26, weighted_sum27, weighted_sum28, weighted_sum29, weighted_sum30, weighted_sum31, weighted_sum32, weighted_sum33, weighted_sum34, weighted_sum35, weighted_sum36]
20+    let weighted_sum1 = ((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) / 10000) + biases[0])
21+[weighted_sum1]
333522     }
3336-
3337-
3338-func linear_forward_3 (input,weights,biases) = {
3339-    let weighted_sum1 = (((if ((size(input) > 0))
3340-        then (input[0] * weights[0][0])
3341-        else (0 + (if ((size(input) > 1))
3342-            then (input[1] * weights[0][1])
3343-            else (0 + (if ((size(input) > 2))
3344-                then (input[2] * weights[0][2])
3345-                else (0 + (if ((size(input) > 3))
3346-                    then (input[3] * weights[0][3])
3347-                    else (0 + (if ((size(input) > 4))
3348-                        then (input[4] * weights[0][4])
3349-                        else (0 + (if ((size(input) > 5))
3350-                            then (input[5] * weights[0][5])
3351-                            else (0 + (if ((size(input) > 6))
3352-                                then (input[6] * weights[0][6])
3353-                                else (0 + (if ((size(input) > 7))
3354-                                    then (input[7] * weights[0][7])
3355-                                    else (0 + (if ((size(input) > 8))
3356-                                        then (input[8] * weights[0][8])
3357-                                        else (0 + (if ((size(input) > 9))
3358-                                            then (input[9] * weights[0][9])
3359-                                            else (0 + (if ((size(input) > 10))
3360-                                                then (input[10] * weights[0][10])
3361-                                                else (0 + (if ((size(input) > 11))
3362-                                                    then (input[11] * weights[0][11])
3363-                                                    else (0 + (if ((size(input) > 12))
3364-                                                        then (input[12] * weights[0][12])
3365-                                                        else (0 + (if ((size(input) > 13))
3366-                                                            then (input[13] * weights[0][13])
3367-                                                            else (0 + (if ((size(input) > 14))
3368-                                                                then (input[14] * weights[0][14])
3369-                                                                else (0 + (if ((size(input) > 15))
3370-                                                                    then (input[15] * weights[0][15])
3371-                                                                    else (0 + (if ((size(input) > 16))
3372-                                                                        then (input[16] * weights[0][16])
3373-                                                                        else (0 + (if ((size(input) > 17))
3374-                                                                            then (input[17] * weights[0][17])
3375-                                                                            else (0 + (if ((size(input) > 18))
3376-                                                                                then (input[18] * weights[0][18])
3377-                                                                                else (0 + (if ((size(input) > 19))
3378-                                                                                    then (input[19] * weights[0][19])
3379-                                                                                    else (0 + (if ((size(input) > 20))
3380-                                                                                        then (input[20] * weights[0][20])
3381-                                                                                        else (0 + (if ((size(input) > 21))
3382-                                                                                            then (input[21] * weights[0][21])
3383-                                                                                            else (0 + (if ((size(input) > 22))
3384-                                                                                                then (input[22] * weights[0][22])
3385-                                                                                                else (0 + (if ((size(input) > 23))
3386-                                                                                                    then (input[23] * weights[0][23])
3387-                                                                                                    else (0 + (if ((size(input) > 24))
3388-                                                                                                        then (input[24] * weights[0][24])
3389-                                                                                                        else (0 + (if ((size(input) > 25))
3390-                                                                                                            then (input[25] * weights[0][25])
3391-                                                                                                            else (0 + (if ((size(input) > 26))
3392-                                                                                                                then (input[26] * weights[0][26])
3393-                                                                                                                else (0 + (if ((size(input) > 27))
3394-                                                                                                                    then (input[27] * weights[0][27])
3395-                                                                                                                    else (0 + (if ((size(input) > 28))
3396-                                                                                                                        then (input[28] * weights[0][28])
3397-                                                                                                                        else (0 + (if ((size(input) > 29))
3398-                                                                                                                            then (input[29] * weights[0][29])
3399-                                                                                                                            else (0 + (if ((size(input) > 30))
3400-                                                                                                                                then (input[30] * weights[0][30])
3401-                                                                                                                                else (0 + (if ((size(input) > 31))
3402-                                                                                                                                    then (input[31] * weights[0][31])
3403-                                                                                                                                    else (0 + (if ((size(input) > 32))
3404-                                                                                                                                        then (input[32] * weights[0][32])
3405-                                                                                                                                        else (0 + (if ((size(input) > 33))
3406-                                                                                                                                            then (input[33] * weights[0][33])
3407-                                                                                                                                            else (0 + (if ((size(input) > 34))
3408-                                                                                                                                                then (input[34] * weights[0][34])
3409-                                                                                                                                                else (0 + (if ((size(input) > 35))
3410-                                                                                                                                                    then (input[35] * weights[0][35])
3411-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[0])
3412-    let weighted_sum2 = (((if ((size(input) > 0))
3413-        then (input[0] * weights[1][0])
3414-        else (0 + (if ((size(input) > 1))
3415-            then (input[1] * weights[1][1])
3416-            else (0 + (if ((size(input) > 2))
3417-                then (input[2] * weights[1][2])
3418-                else (0 + (if ((size(input) > 3))
3419-                    then (input[3] * weights[1][3])
3420-                    else (0 + (if ((size(input) > 4))
3421-                        then (input[4] * weights[1][4])
3422-                        else (0 + (if ((size(input) > 5))
3423-                            then (input[5] * weights[1][5])
3424-                            else (0 + (if ((size(input) > 6))
3425-                                then (input[6] * weights[1][6])
3426-                                else (0 + (if ((size(input) > 7))
3427-                                    then (input[7] * weights[1][7])
3428-                                    else (0 + (if ((size(input) > 8))
3429-                                        then (input[8] * weights[1][8])
3430-                                        else (0 + (if ((size(input) > 9))
3431-                                            then (input[9] * weights[1][9])
3432-                                            else (0 + (if ((size(input) > 10))
3433-                                                then (input[10] * weights[1][10])
3434-                                                else (0 + (if ((size(input) > 11))
3435-                                                    then (input[11] * weights[1][11])
3436-                                                    else (0 + (if ((size(input) > 12))
3437-                                                        then (input[12] * weights[1][12])
3438-                                                        else (0 + (if ((size(input) > 13))
3439-                                                            then (input[13] * weights[1][13])
3440-                                                            else (0 + (if ((size(input) > 14))
3441-                                                                then (input[14] * weights[1][14])
3442-                                                                else (0 + (if ((size(input) > 15))
3443-                                                                    then (input[15] * weights[1][15])
3444-                                                                    else (0 + (if ((size(input) > 16))
3445-                                                                        then (input[16] * weights[1][16])
3446-                                                                        else (0 + (if ((size(input) > 17))
3447-                                                                            then (input[17] * weights[1][17])
3448-                                                                            else (0 + (if ((size(input) > 18))
3449-                                                                                then (input[18] * weights[1][18])
3450-                                                                                else (0 + (if ((size(input) > 19))
3451-                                                                                    then (input[19] * weights[1][19])
3452-                                                                                    else (0 + (if ((size(input) > 20))
3453-                                                                                        then (input[20] * weights[1][20])
3454-                                                                                        else (0 + (if ((size(input) > 21))
3455-                                                                                            then (input[21] * weights[1][21])
3456-                                                                                            else (0 + (if ((size(input) > 22))
3457-                                                                                                then (input[22] * weights[1][22])
3458-                                                                                                else (0 + (if ((size(input) > 23))
3459-                                                                                                    then (input[23] * weights[1][23])
3460-                                                                                                    else (0 + (if ((size(input) > 24))
3461-                                                                                                        then (input[24] * weights[1][24])
3462-                                                                                                        else (0 + (if ((size(input) > 25))
3463-                                                                                                            then (input[25] * weights[1][25])
3464-                                                                                                            else (0 + (if ((size(input) > 26))
3465-                                                                                                                then (input[26] * weights[1][26])
3466-                                                                                                                else (0 + (if ((size(input) > 27))
3467-                                                                                                                    then (input[27] * weights[1][27])
3468-                                                                                                                    else (0 + (if ((size(input) > 28))
3469-                                                                                                                        then (input[28] * weights[1][28])
3470-                                                                                                                        else (0 + (if ((size(input) > 29))
3471-                                                                                                                            then (input[29] * weights[1][29])
3472-                                                                                                                            else (0 + (if ((size(input) > 30))
3473-                                                                                                                                then (input[30] * weights[1][30])
3474-                                                                                                                                else (0 + (if ((size(input) > 31))
3475-                                                                                                                                    then (input[31] * weights[1][31])
3476-                                                                                                                                    else (0 + (if ((size(input) > 32))
3477-                                                                                                                                        then (input[32] * weights[1][32])
3478-                                                                                                                                        else (0 + (if ((size(input) > 33))
3479-                                                                                                                                            then (input[33] * weights[1][33])
3480-                                                                                                                                            else (0 + (if ((size(input) > 34))
3481-                                                                                                                                                then (input[34] * weights[1][34])
3482-                                                                                                                                                else (0 + (if ((size(input) > 35))
3483-                                                                                                                                                    then (input[35] * weights[1][35])
3484-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[1])
3485-    let weighted_sum3 = (((if ((size(input) > 0))
3486-        then (input[0] * weights[2][0])
3487-        else (0 + (if ((size(input) > 1))
3488-            then (input[1] * weights[2][1])
3489-            else (0 + (if ((size(input) > 2))
3490-                then (input[2] * weights[2][2])
3491-                else (0 + (if ((size(input) > 3))
3492-                    then (input[3] * weights[2][3])
3493-                    else (0 + (if ((size(input) > 4))
3494-                        then (input[4] * weights[2][4])
3495-                        else (0 + (if ((size(input) > 5))
3496-                            then (input[5] * weights[2][5])
3497-                            else (0 + (if ((size(input) > 6))
3498-                                then (input[6] * weights[2][6])
3499-                                else (0 + (if ((size(input) > 7))
3500-                                    then (input[7] * weights[2][7])
3501-                                    else (0 + (if ((size(input) > 8))
3502-                                        then (input[8] * weights[2][8])
3503-                                        else (0 + (if ((size(input) > 9))
3504-                                            then (input[9] * weights[2][9])
3505-                                            else (0 + (if ((size(input) > 10))
3506-                                                then (input[10] * weights[2][10])
3507-                                                else (0 + (if ((size(input) > 11))
3508-                                                    then (input[11] * weights[2][11])
3509-                                                    else (0 + (if ((size(input) > 12))
3510-                                                        then (input[12] * weights[2][12])
3511-                                                        else (0 + (if ((size(input) > 13))
3512-                                                            then (input[13] * weights[2][13])
3513-                                                            else (0 + (if ((size(input) > 14))
3514-                                                                then (input[14] * weights[2][14])
3515-                                                                else (0 + (if ((size(input) > 15))
3516-                                                                    then (input[15] * weights[2][15])
3517-                                                                    else (0 + (if ((size(input) > 16))
3518-                                                                        then (input[16] * weights[2][16])
3519-                                                                        else (0 + (if ((size(input) > 17))
3520-                                                                            then (input[17] * weights[2][17])
3521-                                                                            else (0 + (if ((size(input) > 18))
3522-                                                                                then (input[18] * weights[2][18])
3523-                                                                                else (0 + (if ((size(input) > 19))
3524-                                                                                    then (input[19] * weights[2][19])
3525-                                                                                    else (0 + (if ((size(input) > 20))
3526-                                                                                        then (input[20] * weights[2][20])
3527-                                                                                        else (0 + (if ((size(input) > 21))
3528-                                                                                            then (input[21] * weights[2][21])
3529-                                                                                            else (0 + (if ((size(input) > 22))
3530-                                                                                                then (input[22] * weights[2][22])
3531-                                                                                                else (0 + (if ((size(input) > 23))
3532-                                                                                                    then (input[23] * weights[2][23])
3533-                                                                                                    else (0 + (if ((size(input) > 24))
3534-                                                                                                        then (input[24] * weights[2][24])
3535-                                                                                                        else (0 + (if ((size(input) > 25))
3536-                                                                                                            then (input[25] * weights[2][25])
3537-                                                                                                            else (0 + (if ((size(input) > 26))
3538-                                                                                                                then (input[26] * weights[2][26])
3539-                                                                                                                else (0 + (if ((size(input) > 27))
3540-                                                                                                                    then (input[27] * weights[2][27])
3541-                                                                                                                    else (0 + (if ((size(input) > 28))
3542-                                                                                                                        then (input[28] * weights[2][28])
3543-                                                                                                                        else (0 + (if ((size(input) > 29))
3544-                                                                                                                            then (input[29] * weights[2][29])
3545-                                                                                                                            else (0 + (if ((size(input) > 30))
3546-                                                                                                                                then (input[30] * weights[2][30])
3547-                                                                                                                                else (0 + (if ((size(input) > 31))
3548-                                                                                                                                    then (input[31] * weights[2][31])
3549-                                                                                                                                    else (0 + (if ((size(input) > 32))
3550-                                                                                                                                        then (input[32] * weights[2][32])
3551-                                                                                                                                        else (0 + (if ((size(input) > 33))
3552-                                                                                                                                            then (input[33] * weights[2][33])
3553-                                                                                                                                            else (0 + (if ((size(input) > 34))
3554-                                                                                                                                                then (input[34] * weights[2][34])
3555-                                                                                                                                                else (0 + (if ((size(input) > 35))
3556-                                                                                                                                                    then (input[35] * weights[2][35])
3557-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[2])
3558-    let weighted_sum4 = (((if ((size(input) > 0))
3559-        then (input[0] * weights[3][0])
3560-        else (0 + (if ((size(input) > 1))
3561-            then (input[1] * weights[3][1])
3562-            else (0 + (if ((size(input) > 2))
3563-                then (input[2] * weights[3][2])
3564-                else (0 + (if ((size(input) > 3))
3565-                    then (input[3] * weights[3][3])
3566-                    else (0 + (if ((size(input) > 4))
3567-                        then (input[4] * weights[3][4])
3568-                        else (0 + (if ((size(input) > 5))
3569-                            then (input[5] * weights[3][5])
3570-                            else (0 + (if ((size(input) > 6))
3571-                                then (input[6] * weights[3][6])
3572-                                else (0 + (if ((size(input) > 7))
3573-                                    then (input[7] * weights[3][7])
3574-                                    else (0 + (if ((size(input) > 8))
3575-                                        then (input[8] * weights[3][8])
3576-                                        else (0 + (if ((size(input) > 9))
3577-                                            then (input[9] * weights[3][9])
3578-                                            else (0 + (if ((size(input) > 10))
3579-                                                then (input[10] * weights[3][10])
3580-                                                else (0 + (if ((size(input) > 11))
3581-                                                    then (input[11] * weights[3][11])
3582-                                                    else (0 + (if ((size(input) > 12))
3583-                                                        then (input[12] * weights[3][12])
3584-                                                        else (0 + (if ((size(input) > 13))
3585-                                                            then (input[13] * weights[3][13])
3586-                                                            else (0 + (if ((size(input) > 14))
3587-                                                                then (input[14] * weights[3][14])
3588-                                                                else (0 + (if ((size(input) > 15))
3589-                                                                    then (input[15] * weights[3][15])
3590-                                                                    else (0 + (if ((size(input) > 16))
3591-                                                                        then (input[16] * weights[3][16])
3592-                                                                        else (0 + (if ((size(input) > 17))
3593-                                                                            then (input[17] * weights[3][17])
3594-                                                                            else (0 + (if ((size(input) > 18))
3595-                                                                                then (input[18] * weights[3][18])
3596-                                                                                else (0 + (if ((size(input) > 19))
3597-                                                                                    then (input[19] * weights[3][19])
3598-                                                                                    else (0 + (if ((size(input) > 20))
3599-                                                                                        then (input[20] * weights[3][20])
3600-                                                                                        else (0 + (if ((size(input) > 21))
3601-                                                                                            then (input[21] * weights[3][21])
3602-                                                                                            else (0 + (if ((size(input) > 22))
3603-                                                                                                then (input[22] * weights[3][22])
3604-                                                                                                else (0 + (if ((size(input) > 23))
3605-                                                                                                    then (input[23] * weights[3][23])
3606-                                                                                                    else (0 + (if ((size(input) > 24))
3607-                                                                                                        then (input[24] * weights[3][24])
3608-                                                                                                        else (0 + (if ((size(input) > 25))
3609-                                                                                                            then (input[25] * weights[3][25])
3610-                                                                                                            else (0 + (if ((size(input) > 26))
3611-                                                                                                                then (input[26] * weights[3][26])
3612-                                                                                                                else (0 + (if ((size(input) > 27))
3613-                                                                                                                    then (input[27] * weights[3][27])
3614-                                                                                                                    else (0 + (if ((size(input) > 28))
3615-                                                                                                                        then (input[28] * weights[3][28])
3616-                                                                                                                        else (0 + (if ((size(input) > 29))
3617-                                                                                                                            then (input[29] * weights[3][29])
3618-                                                                                                                            else (0 + (if ((size(input) > 30))
3619-                                                                                                                                then (input[30] * weights[3][30])
3620-                                                                                                                                else (0 + (if ((size(input) > 31))
3621-                                                                                                                                    then (input[31] * weights[3][31])
3622-                                                                                                                                    else (0 + (if ((size(input) > 32))
3623-                                                                                                                                        then (input[32] * weights[3][32])
3624-                                                                                                                                        else (0 + (if ((size(input) > 33))
3625-                                                                                                                                            then (input[33] * weights[3][33])
3626-                                                                                                                                            else (0 + (if ((size(input) > 34))
3627-                                                                                                                                                then (input[34] * weights[3][34])
3628-                                                                                                                                                else (0 + (if ((size(input) > 35))
3629-                                                                                                                                                    then (input[35] * weights[3][35])
3630-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[3])
3631-    let weighted_sum5 = (((if ((size(input) > 0))
3632-        then (input[0] * weights[4][0])
3633-        else (0 + (if ((size(input) > 1))
3634-            then (input[1] * weights[4][1])
3635-            else (0 + (if ((size(input) > 2))
3636-                then (input[2] * weights[4][2])
3637-                else (0 + (if ((size(input) > 3))
3638-                    then (input[3] * weights[4][3])
3639-                    else (0 + (if ((size(input) > 4))
3640-                        then (input[4] * weights[4][4])
3641-                        else (0 + (if ((size(input) > 5))
3642-                            then (input[5] * weights[4][5])
3643-                            else (0 + (if ((size(input) > 6))
3644-                                then (input[6] * weights[4][6])
3645-                                else (0 + (if ((size(input) > 7))
3646-                                    then (input[7] * weights[4][7])
3647-                                    else (0 + (if ((size(input) > 8))
3648-                                        then (input[8] * weights[4][8])
3649-                                        else (0 + (if ((size(input) > 9))
3650-                                            then (input[9] * weights[4][9])
3651-                                            else (0 + (if ((size(input) > 10))
3652-                                                then (input[10] * weights[4][10])
3653-                                                else (0 + (if ((size(input) > 11))
3654-                                                    then (input[11] * weights[4][11])
3655-                                                    else (0 + (if ((size(input) > 12))
3656-                                                        then (input[12] * weights[4][12])
3657-                                                        else (0 + (if ((size(input) > 13))
3658-                                                            then (input[13] * weights[4][13])
3659-                                                            else (0 + (if ((size(input) > 14))
3660-                                                                then (input[14] * weights[4][14])
3661-                                                                else (0 + (if ((size(input) > 15))
3662-                                                                    then (input[15] * weights[4][15])
3663-                                                                    else (0 + (if ((size(input) > 16))
3664-                                                                        then (input[16] * weights[4][16])
3665-                                                                        else (0 + (if ((size(input) > 17))
3666-                                                                            then (input[17] * weights[4][17])
3667-                                                                            else (0 + (if ((size(input) > 18))
3668-                                                                                then (input[18] * weights[4][18])
3669-                                                                                else (0 + (if ((size(input) > 19))
3670-                                                                                    then (input[19] * weights[4][19])
3671-                                                                                    else (0 + (if ((size(input) > 20))
3672-                                                                                        then (input[20] * weights[4][20])
3673-                                                                                        else (0 + (if ((size(input) > 21))
3674-                                                                                            then (input[21] * weights[4][21])
3675-                                                                                            else (0 + (if ((size(input) > 22))
3676-                                                                                                then (input[22] * weights[4][22])
3677-                                                                                                else (0 + (if ((size(input) > 23))
3678-                                                                                                    then (input[23] * weights[4][23])
3679-                                                                                                    else (0 + (if ((size(input) > 24))
3680-                                                                                                        then (input[24] * weights[4][24])
3681-                                                                                                        else (0 + (if ((size(input) > 25))
3682-                                                                                                            then (input[25] * weights[4][25])
3683-                                                                                                            else (0 + (if ((size(input) > 26))
3684-                                                                                                                then (input[26] * weights[4][26])
3685-                                                                                                                else (0 + (if ((size(input) > 27))
3686-                                                                                                                    then (input[27] * weights[4][27])
3687-                                                                                                                    else (0 + (if ((size(input) > 28))
3688-                                                                                                                        then (input[28] * weights[4][28])
3689-                                                                                                                        else (0 + (if ((size(input) > 29))
3690-                                                                                                                            then (input[29] * weights[4][29])
3691-                                                                                                                            else (0 + (if ((size(input) > 30))
3692-                                                                                                                                then (input[30] * weights[4][30])
3693-                                                                                                                                else (0 + (if ((size(input) > 31))
3694-                                                                                                                                    then (input[31] * weights[4][31])
3695-                                                                                                                                    else (0 + (if ((size(input) > 32))
3696-                                                                                                                                        then (input[32] * weights[4][32])
3697-                                                                                                                                        else (0 + (if ((size(input) > 33))
3698-                                                                                                                                            then (input[33] * weights[4][33])
3699-                                                                                                                                            else (0 + (if ((size(input) > 34))
3700-                                                                                                                                                then (input[34] * weights[4][34])
3701-                                                                                                                                                else (0 + (if ((size(input) > 35))
3702-                                                                                                                                                    then (input[35] * weights[4][35])
3703-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[4])
3704-    let weighted_sum6 = (((if ((size(input) > 0))
3705-        then (input[0] * weights[5][0])
3706-        else (0 + (if ((size(input) > 1))
3707-            then (input[1] * weights[5][1])
3708-            else (0 + (if ((size(input) > 2))
3709-                then (input[2] * weights[5][2])
3710-                else (0 + (if ((size(input) > 3))
3711-                    then (input[3] * weights[5][3])
3712-                    else (0 + (if ((size(input) > 4))
3713-                        then (input[4] * weights[5][4])
3714-                        else (0 + (if ((size(input) > 5))
3715-                            then (input[5] * weights[5][5])
3716-                            else (0 + (if ((size(input) > 6))
3717-                                then (input[6] * weights[5][6])
3718-                                else (0 + (if ((size(input) > 7))
3719-                                    then (input[7] * weights[5][7])
3720-                                    else (0 + (if ((size(input) > 8))
3721-                                        then (input[8] * weights[5][8])
3722-                                        else (0 + (if ((size(input) > 9))
3723-                                            then (input[9] * weights[5][9])
3724-                                            else (0 + (if ((size(input) > 10))
3725-                                                then (input[10] * weights[5][10])
3726-                                                else (0 + (if ((size(input) > 11))
3727-                                                    then (input[11] * weights[5][11])
3728-                                                    else (0 + (if ((size(input) > 12))
3729-                                                        then (input[12] * weights[5][12])
3730-                                                        else (0 + (if ((size(input) > 13))
3731-                                                            then (input[13] * weights[5][13])
3732-                                                            else (0 + (if ((size(input) > 14))
3733-                                                                then (input[14] * weights[5][14])
3734-                                                                else (0 + (if ((size(input) > 15))
3735-                                                                    then (input[15] * weights[5][15])
3736-                                                                    else (0 + (if ((size(input) > 16))
3737-                                                                        then (input[16] * weights[5][16])
3738-                                                                        else (0 + (if ((size(input) > 17))
3739-                                                                            then (input[17] * weights[5][17])
3740-                                                                            else (0 + (if ((size(input) > 18))
3741-                                                                                then (input[18] * weights[5][18])
3742-                                                                                else (0 + (if ((size(input) > 19))
3743-                                                                                    then (input[19] * weights[5][19])
3744-                                                                                    else (0 + (if ((size(input) > 20))
3745-                                                                                        then (input[20] * weights[5][20])
3746-                                                                                        else (0 + (if ((size(input) > 21))
3747-                                                                                            then (input[21] * weights[5][21])
3748-                                                                                            else (0 + (if ((size(input) > 22))
3749-                                                                                                then (input[22] * weights[5][22])
3750-                                                                                                else (0 + (if ((size(input) > 23))
3751-                                                                                                    then (input[23] * weights[5][23])
3752-                                                                                                    else (0 + (if ((size(input) > 24))
3753-                                                                                                        then (input[24] * weights[5][24])
3754-                                                                                                        else (0 + (if ((size(input) > 25))
3755-                                                                                                            then (input[25] * weights[5][25])
3756-                                                                                                            else (0 + (if ((size(input) > 26))
3757-                                                                                                                then (input[26] * weights[5][26])
3758-                                                                                                                else (0 + (if ((size(input) > 27))
3759-                                                                                                                    then (input[27] * weights[5][27])
3760-                                                                                                                    else (0 + (if ((size(input) > 28))
3761-                                                                                                                        then (input[28] * weights[5][28])
3762-                                                                                                                        else (0 + (if ((size(input) > 29))
3763-                                                                                                                            then (input[29] * weights[5][29])
3764-                                                                                                                            else (0 + (if ((size(input) > 30))
3765-                                                                                                                                then (input[30] * weights[5][30])
3766-                                                                                                                                else (0 + (if ((size(input) > 31))
3767-                                                                                                                                    then (input[31] * weights[5][31])
3768-                                                                                                                                    else (0 + (if ((size(input) > 32))
3769-                                                                                                                                        then (input[32] * weights[5][32])
3770-                                                                                                                                        else (0 + (if ((size(input) > 33))
3771-                                                                                                                                            then (input[33] * weights[5][33])
3772-                                                                                                                                            else (0 + (if ((size(input) > 34))
3773-                                                                                                                                                then (input[34] * weights[5][34])
3774-                                                                                                                                                else (0 + (if ((size(input) > 35))
3775-                                                                                                                                                    then (input[35] * weights[5][35])
3776-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[5])
3777-    let weighted_sum7 = (((if ((size(input) > 0))
3778-        then (input[0] * weights[6][0])
3779-        else (0 + (if ((size(input) > 1))
3780-            then (input[1] * weights[6][1])
3781-            else (0 + (if ((size(input) > 2))
3782-                then (input[2] * weights[6][2])
3783-                else (0 + (if ((size(input) > 3))
3784-                    then (input[3] * weights[6][3])
3785-                    else (0 + (if ((size(input) > 4))
3786-                        then (input[4] * weights[6][4])
3787-                        else (0 + (if ((size(input) > 5))
3788-                            then (input[5] * weights[6][5])
3789-                            else (0 + (if ((size(input) > 6))
3790-                                then (input[6] * weights[6][6])
3791-                                else (0 + (if ((size(input) > 7))
3792-                                    then (input[7] * weights[6][7])
3793-                                    else (0 + (if ((size(input) > 8))
3794-                                        then (input[8] * weights[6][8])
3795-                                        else (0 + (if ((size(input) > 9))
3796-                                            then (input[9] * weights[6][9])
3797-                                            else (0 + (if ((size(input) > 10))
3798-                                                then (input[10] * weights[6][10])
3799-                                                else (0 + (if ((size(input) > 11))
3800-                                                    then (input[11] * weights[6][11])
3801-                                                    else (0 + (if ((size(input) > 12))
3802-                                                        then (input[12] * weights[6][12])
3803-                                                        else (0 + (if ((size(input) > 13))
3804-                                                            then (input[13] * weights[6][13])
3805-                                                            else (0 + (if ((size(input) > 14))
3806-                                                                then (input[14] * weights[6][14])
3807-                                                                else (0 + (if ((size(input) > 15))
3808-                                                                    then (input[15] * weights[6][15])
3809-                                                                    else (0 + (if ((size(input) > 16))
3810-                                                                        then (input[16] * weights[6][16])
3811-                                                                        else (0 + (if ((size(input) > 17))
3812-                                                                            then (input[17] * weights[6][17])
3813-                                                                            else (0 + (if ((size(input) > 18))
3814-                                                                                then (input[18] * weights[6][18])
3815-                                                                                else (0 + (if ((size(input) > 19))
3816-                                                                                    then (input[19] * weights[6][19])
3817-                                                                                    else (0 + (if ((size(input) > 20))
3818-                                                                                        then (input[20] * weights[6][20])
3819-                                                                                        else (0 + (if ((size(input) > 21))
3820-                                                                                            then (input[21] * weights[6][21])
3821-                                                                                            else (0 + (if ((size(input) > 22))
3822-                                                                                                then (input[22] * weights[6][22])
3823-                                                                                                else (0 + (if ((size(input) > 23))
3824-                                                                                                    then (input[23] * weights[6][23])
3825-                                                                                                    else (0 + (if ((size(input) > 24))
3826-                                                                                                        then (input[24] * weights[6][24])
3827-                                                                                                        else (0 + (if ((size(input) > 25))
3828-                                                                                                            then (input[25] * weights[6][25])
3829-                                                                                                            else (0 + (if ((size(input) > 26))
3830-                                                                                                                then (input[26] * weights[6][26])
3831-                                                                                                                else (0 + (if ((size(input) > 27))
3832-                                                                                                                    then (input[27] * weights[6][27])
3833-                                                                                                                    else (0 + (if ((size(input) > 28))
3834-                                                                                                                        then (input[28] * weights[6][28])
3835-                                                                                                                        else (0 + (if ((size(input) > 29))
3836-                                                                                                                            then (input[29] * weights[6][29])
3837-                                                                                                                            else (0 + (if ((size(input) > 30))
3838-                                                                                                                                then (input[30] * weights[6][30])
3839-                                                                                                                                else (0 + (if ((size(input) > 31))
3840-                                                                                                                                    then (input[31] * weights[6][31])
3841-                                                                                                                                    else (0 + (if ((size(input) > 32))
3842-                                                                                                                                        then (input[32] * weights[6][32])
3843-                                                                                                                                        else (0 + (if ((size(input) > 33))
3844-                                                                                                                                            then (input[33] * weights[6][33])
3845-                                                                                                                                            else (0 + (if ((size(input) > 34))
3846-                                                                                                                                                then (input[34] * weights[6][34])
3847-                                                                                                                                                else (0 + (if ((size(input) > 35))
3848-                                                                                                                                                    then (input[35] * weights[6][35])
3849-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[6])
3850-    let weighted_sum8 = (((if ((size(input) > 0))
3851-        then (input[0] * weights[7][0])
3852-        else (0 + (if ((size(input) > 1))
3853-            then (input[1] * weights[7][1])
3854-            else (0 + (if ((size(input) > 2))
3855-                then (input[2] * weights[7][2])
3856-                else (0 + (if ((size(input) > 3))
3857-                    then (input[3] * weights[7][3])
3858-                    else (0 + (if ((size(input) > 4))
3859-                        then (input[4] * weights[7][4])
3860-                        else (0 + (if ((size(input) > 5))
3861-                            then (input[5] * weights[7][5])
3862-                            else (0 + (if ((size(input) > 6))
3863-                                then (input[6] * weights[7][6])
3864-                                else (0 + (if ((size(input) > 7))
3865-                                    then (input[7] * weights[7][7])
3866-                                    else (0 + (if ((size(input) > 8))
3867-                                        then (input[8] * weights[7][8])
3868-                                        else (0 + (if ((size(input) > 9))
3869-                                            then (input[9] * weights[7][9])
3870-                                            else (0 + (if ((size(input) > 10))
3871-                                                then (input[10] * weights[7][10])
3872-                                                else (0 + (if ((size(input) > 11))
3873-                                                    then (input[11] * weights[7][11])
3874-                                                    else (0 + (if ((size(input) > 12))
3875-                                                        then (input[12] * weights[7][12])
3876-                                                        else (0 + (if ((size(input) > 13))
3877-                                                            then (input[13] * weights[7][13])
3878-                                                            else (0 + (if ((size(input) > 14))
3879-                                                                then (input[14] * weights[7][14])
3880-                                                                else (0 + (if ((size(input) > 15))
3881-                                                                    then (input[15] * weights[7][15])
3882-                                                                    else (0 + (if ((size(input) > 16))
3883-                                                                        then (input[16] * weights[7][16])
3884-                                                                        else (0 + (if ((size(input) > 17))
3885-                                                                            then (input[17] * weights[7][17])
3886-                                                                            else (0 + (if ((size(input) > 18))
3887-                                                                                then (input[18] * weights[7][18])
3888-                                                                                else (0 + (if ((size(input) > 19))
3889-                                                                                    then (input[19] * weights[7][19])
3890-                                                                                    else (0 + (if ((size(input) > 20))
3891-                                                                                        then (input[20] * weights[7][20])
3892-                                                                                        else (0 + (if ((size(input) > 21))
3893-                                                                                            then (input[21] * weights[7][21])
3894-                                                                                            else (0 + (if ((size(input) > 22))
3895-                                                                                                then (input[22] * weights[7][22])
3896-                                                                                                else (0 + (if ((size(input) > 23))
3897-                                                                                                    then (input[23] * weights[7][23])
3898-                                                                                                    else (0 + (if ((size(input) > 24))
3899-                                                                                                        then (input[24] * weights[7][24])
3900-                                                                                                        else (0 + (if ((size(input) > 25))
3901-                                                                                                            then (input[25] * weights[7][25])
3902-                                                                                                            else (0 + (if ((size(input) > 26))
3903-                                                                                                                then (input[26] * weights[7][26])
3904-                                                                                                                else (0 + (if ((size(input) > 27))
3905-                                                                                                                    then (input[27] * weights[7][27])
3906-                                                                                                                    else (0 + (if ((size(input) > 28))
3907-                                                                                                                        then (input[28] * weights[7][28])
3908-                                                                                                                        else (0 + (if ((size(input) > 29))
3909-                                                                                                                            then (input[29] * weights[7][29])
3910-                                                                                                                            else (0 + (if ((size(input) > 30))
3911-                                                                                                                                then (input[30] * weights[7][30])
3912-                                                                                                                                else (0 + (if ((size(input) > 31))
3913-                                                                                                                                    then (input[31] * weights[7][31])
3914-                                                                                                                                    else (0 + (if ((size(input) > 32))
3915-                                                                                                                                        then (input[32] * weights[7][32])
3916-                                                                                                                                        else (0 + (if ((size(input) > 33))
3917-                                                                                                                                            then (input[33] * weights[7][33])
3918-                                                                                                                                            else (0 + (if ((size(input) > 34))
3919-                                                                                                                                                then (input[34] * weights[7][34])
3920-                                                                                                                                                else (0 + (if ((size(input) > 35))
3921-                                                                                                                                                    then (input[35] * weights[7][35])
3922-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[7])
3923-    let weighted_sum9 = (((if ((size(input) > 0))
3924-        then (input[0] * weights[8][0])
3925-        else (0 + (if ((size(input) > 1))
3926-            then (input[1] * weights[8][1])
3927-            else (0 + (if ((size(input) > 2))
3928-                then (input[2] * weights[8][2])
3929-                else (0 + (if ((size(input) > 3))
3930-                    then (input[3] * weights[8][3])
3931-                    else (0 + (if ((size(input) > 4))
3932-                        then (input[4] * weights[8][4])
3933-                        else (0 + (if ((size(input) > 5))
3934-                            then (input[5] * weights[8][5])
3935-                            else (0 + (if ((size(input) > 6))
3936-                                then (input[6] * weights[8][6])
3937-                                else (0 + (if ((size(input) > 7))
3938-                                    then (input[7] * weights[8][7])
3939-                                    else (0 + (if ((size(input) > 8))
3940-                                        then (input[8] * weights[8][8])
3941-                                        else (0 + (if ((size(input) > 9))
3942-                                            then (input[9] * weights[8][9])
3943-                                            else (0 + (if ((size(input) > 10))
3944-                                                then (input[10] * weights[8][10])
3945-                                                else (0 + (if ((size(input) > 11))
3946-                                                    then (input[11] * weights[8][11])
3947-                                                    else (0 + (if ((size(input) > 12))
3948-                                                        then (input[12] * weights[8][12])
3949-                                                        else (0 + (if ((size(input) > 13))
3950-                                                            then (input[13] * weights[8][13])
3951-                                                            else (0 + (if ((size(input) > 14))
3952-                                                                then (input[14] * weights[8][14])
3953-                                                                else (0 + (if ((size(input) > 15))
3954-                                                                    then (input[15] * weights[8][15])
3955-                                                                    else (0 + (if ((size(input) > 16))
3956-                                                                        then (input[16] * weights[8][16])
3957-                                                                        else (0 + (if ((size(input) > 17))
3958-                                                                            then (input[17] * weights[8][17])
3959-                                                                            else (0 + (if ((size(input) > 18))
3960-                                                                                then (input[18] * weights[8][18])
3961-                                                                                else (0 + (if ((size(input) > 19))
3962-                                                                                    then (input[19] * weights[8][19])
3963-                                                                                    else (0 + (if ((size(input) > 20))
3964-                                                                                        then (input[20] * weights[8][20])
3965-                                                                                        else (0 + (if ((size(input) > 21))
3966-                                                                                            then (input[21] * weights[8][21])
3967-                                                                                            else (0 + (if ((size(input) > 22))
3968-                                                                                                then (input[22] * weights[8][22])
3969-                                                                                                else (0 + (if ((size(input) > 23))
3970-                                                                                                    then (input[23] * weights[8][23])
3971-                                                                                                    else (0 + (if ((size(input) > 24))
3972-                                                                                                        then (input[24] * weights[8][24])
3973-                                                                                                        else (0 + (if ((size(input) > 25))
3974-                                                                                                            then (input[25] * weights[8][25])
3975-                                                                                                            else (0 + (if ((size(input) > 26))
3976-                                                                                                                then (input[26] * weights[8][26])
3977-                                                                                                                else (0 + (if ((size(input) > 27))
3978-                                                                                                                    then (input[27] * weights[8][27])
3979-                                                                                                                    else (0 + (if ((size(input) > 28))
3980-                                                                                                                        then (input[28] * weights[8][28])
3981-                                                                                                                        else (0 + (if ((size(input) > 29))
3982-                                                                                                                            then (input[29] * weights[8][29])
3983-                                                                                                                            else (0 + (if ((size(input) > 30))
3984-                                                                                                                                then (input[30] * weights[8][30])
3985-                                                                                                                                else (0 + (if ((size(input) > 31))
3986-                                                                                                                                    then (input[31] * weights[8][31])
3987-                                                                                                                                    else (0 + (if ((size(input) > 32))
3988-                                                                                                                                        then (input[32] * weights[8][32])
3989-                                                                                                                                        else (0 + (if ((size(input) > 33))
3990-                                                                                                                                            then (input[33] * weights[8][33])
3991-                                                                                                                                            else (0 + (if ((size(input) > 34))
3992-                                                                                                                                                then (input[34] * weights[8][34])
3993-                                                                                                                                                else (0 + (if ((size(input) > 35))
3994-                                                                                                                                                    then (input[35] * weights[8][35])
3995-                                                                                                                                                    else 0))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))) / 10000) + biases[8])
3996-[weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9]
3997-    }
3998-
3999-
4000-func relu (input) = if ((0 > input))
4001-    then 0
4002-    else input
4003-
4004-
4005-func relu_activation (inputs,num_outputs) = [relu(if ((size(inputs) > 0))
4006-    then inputs[0]
4007-    else 0), relu(if ((size(inputs) > 1))
4008-    then inputs[1]
4009-    else 0), relu(if ((size(inputs) > 2))
4010-    then inputs[2]
4011-    else 0), relu(if ((size(inputs) > 3))
4012-    then inputs[3]
4013-    else 0), relu(if ((size(inputs) > 4))
4014-    then inputs[4]
4015-    else 0), relu(if ((size(inputs) > 5))
4016-    then inputs[5]
4017-    else 0), relu(if ((size(inputs) > 6))
4018-    then inputs[6]
4019-    else 0), relu(if ((size(inputs) > 7))
4020-    then inputs[7]
4021-    else 0), relu(if ((size(inputs) > 8))
4022-    then inputs[8]
4023-    else 0), relu(if ((size(inputs) > 9))
4024-    then inputs[9]
4025-    else 0), relu(if ((size(inputs) > 10))
4026-    then inputs[10]
4027-    else 0), relu(if ((size(inputs) > 11))
4028-    then inputs[11]
4029-    else 0), relu(if ((size(inputs) > 12))
4030-    then inputs[12]
4031-    else 0), relu(if ((size(inputs) > 13))
4032-    then inputs[13]
4033-    else 0), relu(if ((size(inputs) > 14))
4034-    then inputs[14]
4035-    else 0), relu(if ((size(inputs) > 15))
4036-    then inputs[15]
4037-    else 0), relu(if ((size(inputs) > 16))
4038-    then inputs[16]
4039-    else 0), relu(if ((size(inputs) > 17))
4040-    then inputs[17]
4041-    else 0), relu(if ((size(inputs) > 18))
4042-    then inputs[18]
4043-    else 0), relu(if ((size(inputs) > 19))
4044-    then inputs[19]
4045-    else 0), relu(if ((size(inputs) > 20))
4046-    then inputs[20]
4047-    else 0), relu(if ((size(inputs) > 21))
4048-    then inputs[21]
4049-    else 0), relu(if ((size(inputs) > 22))
4050-    then inputs[22]
4051-    else 0), relu(if ((size(inputs) > 23))
4052-    then inputs[23]
4053-    else 0), relu(if ((size(inputs) > 24))
4054-    then inputs[24]
4055-    else 0), relu(if ((size(inputs) > 25))
4056-    then inputs[25]
4057-    else 0), relu(if ((size(inputs) > 26))
4058-    then inputs[26]
4059-    else 0), relu(if ((size(inputs) > 27))
4060-    then inputs[27]
4061-    else 0), relu(if ((size(inputs) > 28))
4062-    then inputs[28]
4063-    else 0), relu(if ((size(inputs) > 29))
4064-    then inputs[29]
4065-    else 0), relu(if ((size(inputs) > 30))
4066-    then inputs[30]
4067-    else 0), relu(if ((size(inputs) > 31))
4068-    then inputs[31]
4069-    else 0), relu(if ((size(inputs) > 32))
4070-    then inputs[32]
4071-    else 0), relu(if ((size(inputs) > 33))
4072-    then inputs[33]
4073-    else 0), relu(if ((size(inputs) > 34))
4074-    then inputs[34]
4075-    else 0), relu(if ((size(inputs) > 35))
4076-    then inputs[35]
4077-    else 0)]
407823 
407924 
408025 func sigmoid (input) = if ((-80000 > input))
408126     then 0
408227     else if ((-60000 > input))
408328         then fraction((input + 80000), 125, 10000)
408429         else if ((-40000 > input))
408530             then fraction((input + 60000), 100, 10000)
408631             else if ((-20000 > input))
408732                 then fraction((input + 40000), 75, 10000)
408833                 else if ((0 > input))
408934                     then fraction((input + 20000), 50, 10000)
409035                     else if ((20000 > input))
409136                         then (fraction(input, 50, 10000) + 5000)
409237                         else if ((40000 > input))
409338                             then (fraction((input - 20000), 75, 10000) + 7500)
409439                             else if ((60000 > input))
409540                                 then (fraction((input - 40000), 100, 10000) + 8750)
409641                                 else if ((80000 > input))
409742                                     then (fraction((input - 60000), 125, 10000) + 9375)
409843                                     else 10000
409944 
410045 
4101-func sigmoid_activation (inputs,num_outputs) = [sigmoid(if ((size(inputs) > 0))
4102-    then inputs[0]
4103-    else 0), sigmoid(if ((size(inputs) > 1))
4104-    then inputs[1]
4105-    else 0), sigmoid(if ((size(inputs) > 2))
4106-    then inputs[2]
4107-    else 0), sigmoid(if ((size(inputs) > 3))
4108-    then inputs[3]
4109-    else 0), sigmoid(if ((size(inputs) > 4))
4110-    then inputs[4]
4111-    else 0), sigmoid(if ((size(inputs) > 5))
4112-    then inputs[5]
4113-    else 0), sigmoid(if ((size(inputs) > 6))
4114-    then inputs[6]
4115-    else 0), sigmoid(if ((size(inputs) > 7))
4116-    then inputs[7]
4117-    else 0), sigmoid(if ((size(inputs) > 8))
4118-    then inputs[8]
4119-    else 0)]
46+func sigmoid_activation (inputs,num_outputs) = [sigmoid(inputs[0]), sigmoid(inputs[1])]
412047 
412148 
412249 @Callable(i)
4123-func predict (x1,x2,x3,x4,x5,x6,x7,x8,x9) = {
4124-    let x1_scaled = (x1 * 10000)
4125-    let x2_scaled = (x2 * 10000)
4126-    let x3_scaled = (x3 * 10000)
4127-    let x4_scaled = (x4 * 10000)
4128-    let x5_scaled = (x5 * 10000)
4129-    let x6_scaled = (x6 * 10000)
4130-    let x7_scaled = (x7 * 10000)
4131-    let x8_scaled = (x8 * 10000)
4132-    let x9_scaled = (x9 * 10000)
4133-    let inputs = [x1_scaled, x2_scaled, x3_scaled, x4_scaled, x5_scaled, x6_scaled, x7_scaled, x8_scaled, x9_scaled]
4134-    let z1 = linear_forward_1(inputs, weights_layer_1, biases_layer_1)
4135-    let a1 = relu_activation(z1, 36)
50+func predict (inputs) = {
51+    let x1_scaled = (inputs[0] * 10000)
52+    let x2_scaled = (inputs[1] * 10000)
53+    let scaled_inputs = [x1_scaled, x2_scaled]
54+    let z1 = linear_forward_1(scaled_inputs, weights_layer_1, biases_layer_1)
55+    let a1 = sigmoid_activation(z1, 2)
413656     let z2 = linear_forward_2(a1, weights_layer_2, biases_layer_2)
4137-    let a2 = relu_activation(z2, 36)
4138-    let z3 = linear_forward_3(a2, weights_layer_3, biases_layer_3)
4139-    let a3 = sigmoid_activation(z3, 9)
4140-    let result0 = if ((size(a3) > 0))
4141-        then a3[0]
4142-        else 0
4143-    let result1 = if ((size(a3) > 1))
4144-        then a3[1]
4145-        else 0
4146-    let result2 = if ((size(a3) > 2))
4147-        then a3[2]
4148-        else 0
4149-    let result3 = if ((size(a3) > 3))
4150-        then a3[3]
4151-        else 0
4152-    let result4 = if ((size(a3) > 4))
4153-        then a3[4]
4154-        else 0
4155-    let result5 = if ((size(a3) > 5))
4156-        then a3[5]
4157-        else 0
4158-    let result6 = if ((size(a3) > 6))
4159-        then a3[6]
4160-        else 0
4161-    let result7 = if ((size(a3) > 7))
4162-        then a3[7]
4163-        else 0
4164-    let result8 = if ((size(a3) > 8))
4165-        then a3[8]
4166-        else 0
57+    let a2 = sigmoid_activation(z2, 1)
58+    let result0 = a2[0]
416759     let debug_outputs = nil
4168-    ([IntegerEntry("move_prediction_0", result0), IntegerEntry("move_prediction_1", result1), IntegerEntry("move_prediction_2", result2), IntegerEntry("move_prediction_3", result3), IntegerEntry("move_prediction_4", result4), IntegerEntry("move_prediction_5", result5), IntegerEntry("move_prediction_6", result6), IntegerEntry("move_prediction_7", result7), IntegerEntry("move_prediction_8", result8)] ++ debug_outputs)
60+    ([IntegerEntry("move_prediction_0", result0)] ++ debug_outputs)
416961     }
417062 
417163 
github/deemru/w8io/169f3d6 
606.85 ms ◑