github/deemru/w8io/c3f4982 178.99 ms ◑
tx · 8DLJpLx8NfRS2MqFEbYqsi5zVS4CNWwfxb8z8wBKsRPS 3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY: -0.01000000 Waves 2024.06.01 15:25 [3131624] smart account 3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY > SELF 0.00000000 Waves
{ "type": 13, "id": "8DLJpLx8NfRS2MqFEbYqsi5zVS4CNWwfxb8z8wBKsRPS", "fee": 1000000, "feeAssetId": null, "timestamp": 1717244774857, "version": 2, "chainId": 84, "sender": "3N3n75UqB8G1GKmXFr4zPhKCjGcqJPRSuJY", "senderPublicKey": "2AWdnJuBMzufXSjTvzVcawBQQhnhF1iXR6QNVgwn33oc", "proofs": [ "2P4GJckjj9nWuMz7s7mP8XPevtK3GoWJJnHVjZbeG4AF41GpEgY1RGhrSsNRuXHCzwZaMqNrq81yTtJfj2FcL2FE" ], "script": "base64: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", "height": 3131624, "applicationStatus": "succeeded", "spentComplexity": 0 } View: original | compacted Prev: By5s2Ep32mxx4dxfuLaF3R53XiheQjPbjYooM3vd1ou6 Next: Hv9h4RHHWAKLP6LMA99tehzrvZXUkvLkodFdaMPd9nDH Full:
| Old | New | Differences | |
|---|---|---|---|
| 1 | 1 | {-# STDLIB_VERSION 7 #-} | |
| 2 | 2 | {-# SCRIPT_TYPE ACCOUNT #-} | |
| 3 | 3 | {-# CONTENT_TYPE DAPP #-} | |
| 4 | - | let weights_layer_1 = [[ | |
| 4 | + | let weights_layer_1 = [[60049, 60073], [41419, 41425]] | |
| 5 | 5 | ||
| 6 | - | let biases_layer_1 = [- | |
| 6 | + | let biases_layer_1 = [-25905, -63563] | |
| 7 | 7 | ||
| 8 | - | let weights_layer_2 = [[ | |
| 8 | + | let weights_layer_2 = [[83296, -89714]] | |
| 9 | 9 | ||
| 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] | |
| 15 | 11 | ||
| 16 | 12 | func linear_forward_1 (input,weights,biases) = { | |
| 17 | - | let weighted_sum1 = (((((((((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) + (input[2] * weights[0][2])) + (input[3] * weights[0][3])) + (input[4] * weights[0][4])) + (input[5] * weights[0][5])) + (input[6] * weights[0][6])) + (input[7] * weights[0][7])) + (input[8] * weights[0][8])) / 10000) + biases[0]) | |
| 18 | - | let weighted_sum2 = (((((((((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) + (input[2] * weights[1][2])) + (input[3] * weights[1][3])) + (input[4] * weights[1][4])) + (input[5] * weights[1][5])) + (input[6] * weights[1][6])) + (input[7] * weights[1][7])) + (input[8] * weights[1][8])) / 10000) + biases[1]) | |
| 19 | - | let weighted_sum3 = (((((((((((input[0] * weights[2][0]) + (input[1] * weights[2][1])) + (input[2] * weights[2][2])) + (input[3] * weights[2][3])) + (input[4] * weights[2][4])) + (input[5] * weights[2][5])) + (input[6] * weights[2][6])) + (input[7] * weights[2][7])) + (input[8] * weights[2][8])) / 10000) + biases[2]) | |
| 20 | - | let weighted_sum4 = (((((((((((input[0] * weights[3][0]) + (input[1] * weights[3][1])) + (input[2] * weights[3][2])) + (input[3] * weights[3][3])) + (input[4] * weights[3][4])) + (input[5] * weights[3][5])) + (input[6] * weights[3][6])) + (input[7] * weights[3][7])) + (input[8] * weights[3][8])) / 10000) + biases[3]) | |
| 21 | - | let weighted_sum5 = (((((((((((input[0] * weights[4][0]) + (input[1] * weights[4][1])) + (input[2] * weights[4][2])) + (input[3] * weights[4][3])) + (input[4] * weights[4][4])) + (input[5] * weights[4][5])) + (input[6] * weights[4][6])) + (input[7] * weights[4][7])) + (input[8] * weights[4][8])) / 10000) + biases[4]) | |
| 22 | - | let weighted_sum6 = (((((((((((input[0] * weights[5][0]) + (input[1] * weights[5][1])) + (input[2] * weights[5][2])) + (input[3] * weights[5][3])) + (input[4] * weights[5][4])) + (input[5] * weights[5][5])) + (input[6] * weights[5][6])) + (input[7] * weights[5][7])) + (input[8] * weights[5][8])) / 10000) + biases[5]) | |
| 23 | - | let weighted_sum7 = (((((((((((input[0] * weights[6][0]) + (input[1] * weights[6][1])) + (input[2] * weights[6][2])) + (input[3] * weights[6][3])) + (input[4] * weights[6][4])) + (input[5] * weights[6][5])) + (input[6] * weights[6][6])) + (input[7] * weights[6][7])) + (input[8] * weights[6][8])) / 10000) + biases[6]) | |
| 24 | - | let weighted_sum8 = (((((((((((input[0] * weights[7][0]) + (input[1] * weights[7][1])) + (input[2] * weights[7][2])) + (input[3] * weights[7][3])) + (input[4] * weights[7][4])) + (input[5] * weights[7][5])) + (input[6] * weights[7][6])) + (input[7] * weights[7][7])) + (input[8] * weights[7][8])) / 10000) + biases[7]) | |
| 25 | - | let weighted_sum9 = (((((((((((input[0] * weights[8][0]) + (input[1] * weights[8][1])) + (input[2] * weights[8][2])) + (input[3] * weights[8][3])) + (input[4] * weights[8][4])) + (input[5] * weights[8][5])) + (input[6] * weights[8][6])) + (input[7] * weights[8][7])) + (input[8] * weights[8][8])) / 10000) + biases[8]) | |
| 26 | - | let weighted_sum10 = (((((((((((input[0] * weights[9][0]) + (input[1] * weights[9][1])) + (input[2] * weights[9][2])) + (input[3] * weights[9][3])) + (input[4] * weights[9][4])) + (input[5] * weights[9][5])) + (input[6] * weights[9][6])) + (input[7] * weights[9][7])) + (input[8] * weights[9][8])) / 10000) + biases[9]) | |
| 27 | - | let weighted_sum11 = (((((((((((input[0] * weights[10][0]) + (input[1] * weights[10][1])) + (input[2] * weights[10][2])) + (input[3] * weights[10][3])) + (input[4] * weights[10][4])) + (input[5] * weights[10][5])) + (input[6] * weights[10][6])) + (input[7] * weights[10][7])) + (input[8] * weights[10][8])) / 10000) + biases[10]) | |
| 28 | - | let weighted_sum12 = (((((((((((input[0] * weights[11][0]) + (input[1] * weights[11][1])) + (input[2] * weights[11][2])) + (input[3] * weights[11][3])) + (input[4] * weights[11][4])) + (input[5] * weights[11][5])) + (input[6] * weights[11][6])) + (input[7] * weights[11][7])) + (input[8] * weights[11][8])) / 10000) + biases[11]) | |
| 29 | - | let weighted_sum13 = (((((((((((input[0] * weights[12][0]) + (input[1] * weights[12][1])) + (input[2] * weights[12][2])) + (input[3] * weights[12][3])) + (input[4] * weights[12][4])) + (input[5] * weights[12][5])) + (input[6] * weights[12][6])) + (input[7] * weights[12][7])) + (input[8] * weights[12][8])) / 10000) + biases[12]) | |
| 30 | - | let weighted_sum14 = (((((((((((input[0] * weights[13][0]) + (input[1] * weights[13][1])) + (input[2] * weights[13][2])) + (input[3] * weights[13][3])) + (input[4] * weights[13][4])) + (input[5] * weights[13][5])) + (input[6] * weights[13][6])) + (input[7] * weights[13][7])) + (input[8] * weights[13][8])) / 10000) + biases[13]) | |
| 31 | - | let weighted_sum15 = (((((((((((input[0] * weights[14][0]) + (input[1] * weights[14][1])) + (input[2] * weights[14][2])) + (input[3] * weights[14][3])) + (input[4] * weights[14][4])) + (input[5] * weights[14][5])) + (input[6] * weights[14][6])) + (input[7] * weights[14][7])) + (input[8] * weights[14][8])) / 10000) + biases[14]) | |
| 32 | - | let weighted_sum16 = (((((((((((input[0] * weights[15][0]) + (input[1] * weights[15][1])) + (input[2] * weights[15][2])) + (input[3] * weights[15][3])) + (input[4] * weights[15][4])) + (input[5] * weights[15][5])) + (input[6] * weights[15][6])) + (input[7] * weights[15][7])) + (input[8] * weights[15][8])) / 10000) + biases[15]) | |
| 33 | - | let weighted_sum17 = (((((((((((input[0] * weights[16][0]) + (input[1] * weights[16][1])) + (input[2] * weights[16][2])) + (input[3] * weights[16][3])) + (input[4] * weights[16][4])) + (input[5] * weights[16][5])) + (input[6] * weights[16][6])) + (input[7] * weights[16][7])) + (input[8] * weights[16][8])) / 10000) + biases[16]) | |
| 34 | - | let weighted_sum18 = (((((((((((input[0] * weights[17][0]) + (input[1] * weights[17][1])) + (input[2] * weights[17][2])) + (input[3] * weights[17][3])) + (input[4] * weights[17][4])) + (input[5] * weights[17][5])) + (input[6] * weights[17][6])) + (input[7] * weights[17][7])) + (input[8] * weights[17][8])) / 10000) + biases[17]) | |
| 35 | - | let weighted_sum19 = (((((((((((input[0] * weights[18][0]) + (input[1] * weights[18][1])) + (input[2] * weights[18][2])) + (input[3] * weights[18][3])) + (input[4] * weights[18][4])) + (input[5] * weights[18][5])) + (input[6] * weights[18][6])) + (input[7] * weights[18][7])) + (input[8] * weights[18][8])) / 10000) + biases[18]) | |
| 36 | - | let weighted_sum20 = (((((((((((input[0] * weights[19][0]) + (input[1] * weights[19][1])) + (input[2] * weights[19][2])) + (input[3] * weights[19][3])) + (input[4] * weights[19][4])) + (input[5] * weights[19][5])) + (input[6] * weights[19][6])) + (input[7] * weights[19][7])) + (input[8] * weights[19][8])) / 10000) + biases[19]) | |
| 37 | - | let weighted_sum21 = (((((((((((input[0] * weights[20][0]) + (input[1] * weights[20][1])) + (input[2] * weights[20][2])) + (input[3] * weights[20][3])) + (input[4] * weights[20][4])) + (input[5] * weights[20][5])) + (input[6] * weights[20][6])) + (input[7] * weights[20][7])) + (input[8] * weights[20][8])) / 10000) + biases[20]) | |
| 38 | - | let weighted_sum22 = (((((((((((input[0] * weights[21][0]) + (input[1] * weights[21][1])) + (input[2] * weights[21][2])) + (input[3] * weights[21][3])) + (input[4] * weights[21][4])) + (input[5] * weights[21][5])) + (input[6] * weights[21][6])) + (input[7] * weights[21][7])) + (input[8] * weights[21][8])) / 10000) + biases[21]) | |
| 39 | - | let weighted_sum23 = (((((((((((input[0] * weights[22][0]) + (input[1] * weights[22][1])) + (input[2] * weights[22][2])) + (input[3] * weights[22][3])) + (input[4] * weights[22][4])) + (input[5] * weights[22][5])) + (input[6] * weights[22][6])) + (input[7] * weights[22][7])) + (input[8] * weights[22][8])) / 10000) + biases[22]) | |
| 40 | - | let weighted_sum24 = (((((((((((input[0] * weights[23][0]) + (input[1] * weights[23][1])) + (input[2] * weights[23][2])) + (input[3] * weights[23][3])) + (input[4] * weights[23][4])) + (input[5] * weights[23][5])) + (input[6] * weights[23][6])) + (input[7] * weights[23][7])) + (input[8] * weights[23][8])) / 10000) + biases[23]) | |
| 41 | - | let weighted_sum25 = (((((((((((input[0] * weights[24][0]) + (input[1] * weights[24][1])) + (input[2] * weights[24][2])) + (input[3] * weights[24][3])) + (input[4] * weights[24][4])) + (input[5] * weights[24][5])) + (input[6] * weights[24][6])) + (input[7] * weights[24][7])) + (input[8] * weights[24][8])) / 10000) + biases[24]) | |
| 42 | - | let weighted_sum26 = (((((((((((input[0] * weights[25][0]) + (input[1] * weights[25][1])) + (input[2] * weights[25][2])) + (input[3] * weights[25][3])) + (input[4] * weights[25][4])) + (input[5] * weights[25][5])) + (input[6] * weights[25][6])) + (input[7] * weights[25][7])) + (input[8] * weights[25][8])) / 10000) + biases[25]) | |
| 43 | - | let weighted_sum27 = (((((((((((input[0] * weights[26][0]) + (input[1] * weights[26][1])) + (input[2] * weights[26][2])) + (input[3] * weights[26][3])) + (input[4] * weights[26][4])) + (input[5] * weights[26][5])) + (input[6] * weights[26][6])) + (input[7] * weights[26][7])) + (input[8] * weights[26][8])) / 10000) + biases[26]) | |
| 44 | - | let weighted_sum28 = (((((((((((input[0] * weights[27][0]) + (input[1] * weights[27][1])) + (input[2] * weights[27][2])) + (input[3] * weights[27][3])) + (input[4] * weights[27][4])) + (input[5] * weights[27][5])) + (input[6] * weights[27][6])) + (input[7] * weights[27][7])) + (input[8] * weights[27][8])) / 10000) + biases[27]) | |
| 45 | - | let weighted_sum29 = (((((((((((input[0] * weights[28][0]) + (input[1] * weights[28][1])) + (input[2] * weights[28][2])) + (input[3] * weights[28][3])) + (input[4] * weights[28][4])) + (input[5] * weights[28][5])) + (input[6] * weights[28][6])) + (input[7] * weights[28][7])) + (input[8] * weights[28][8])) / 10000) + biases[28]) | |
| 46 | - | let weighted_sum30 = (((((((((((input[0] * weights[29][0]) + (input[1] * weights[29][1])) + (input[2] * weights[29][2])) + (input[3] * weights[29][3])) + (input[4] * weights[29][4])) + (input[5] * weights[29][5])) + (input[6] * weights[29][6])) + (input[7] * weights[29][7])) + (input[8] * weights[29][8])) / 10000) + biases[29]) | |
| 47 | - | let weighted_sum31 = (((((((((((input[0] * weights[30][0]) + (input[1] * weights[30][1])) + (input[2] * weights[30][2])) + (input[3] * weights[30][3])) + (input[4] * weights[30][4])) + (input[5] * weights[30][5])) + (input[6] * weights[30][6])) + (input[7] * weights[30][7])) + (input[8] * weights[30][8])) / 10000) + biases[30]) | |
| 48 | - | let weighted_sum32 = (((((((((((input[0] * weights[31][0]) + (input[1] * weights[31][1])) + (input[2] * weights[31][2])) + (input[3] * weights[31][3])) + (input[4] * weights[31][4])) + (input[5] * weights[31][5])) + (input[6] * weights[31][6])) + (input[7] * weights[31][7])) + (input[8] * weights[31][8])) / 10000) + biases[31]) | |
| 49 | - | let weighted_sum33 = (((((((((((input[0] * weights[32][0]) + (input[1] * weights[32][1])) + (input[2] * weights[32][2])) + (input[3] * weights[32][3])) + (input[4] * weights[32][4])) + (input[5] * weights[32][5])) + (input[6] * weights[32][6])) + (input[7] * weights[32][7])) + (input[8] * weights[32][8])) / 10000) + biases[32]) | |
| 50 | - | let weighted_sum34 = (((((((((((input[0] * weights[33][0]) + (input[1] * weights[33][1])) + (input[2] * weights[33][2])) + (input[3] * weights[33][3])) + (input[4] * weights[33][4])) + (input[5] * weights[33][5])) + (input[6] * weights[33][6])) + (input[7] * weights[33][7])) + (input[8] * weights[33][8])) / 10000) + biases[33]) | |
| 51 | - | let weighted_sum35 = (((((((((((input[0] * weights[34][0]) + (input[1] * weights[34][1])) + (input[2] * weights[34][2])) + (input[3] * weights[34][3])) + (input[4] * weights[34][4])) + (input[5] * weights[34][5])) + (input[6] * weights[34][6])) + (input[7] * weights[34][7])) + (input[8] * weights[34][8])) / 10000) + biases[34]) | |
| 52 | - | let weighted_sum36 = (((((((((((input[0] * weights[35][0]) + (input[1] * weights[35][1])) + (input[2] * weights[35][2])) + (input[3] * weights[35][3])) + (input[4] * weights[35][4])) + (input[5] * weights[35][5])) + (input[6] * weights[35][6])) + (input[7] * weights[35][7])) + (input[8] * weights[35][8])) / 10000) + biases[35]) | |
| 53 | - | [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] | |
| 54 | 16 | } | |
| 55 | 17 | ||
| 56 | 18 | ||
| 57 | 19 | func linear_forward_2 (input,weights,biases) = { | |
| 58 | - | let weighted_sum1 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) + (input[2] * weights[0][2])) + (input[3] * weights[0][3])) + (input[4] * weights[0][4])) + (input[5] * weights[0][5])) + (input[6] * weights[0][6])) + (input[7] * weights[0][7])) + (input[8] * weights[0][8])) + (input[9] * weights[0][9])) + (input[10] * weights[0][10])) + (input[11] * weights[0][11])) + (input[12] * weights[0][12])) + (input[13] * weights[0][13])) + (input[14] * weights[0][14])) + (input[15] * weights[0][15])) + (input[16] * weights[0][16])) + (input[17] * weights[0][17])) + (input[18] * weights[0][18])) + (input[19] * weights[0][19])) + (input[20] * weights[0][20])) + (input[21] * weights[0][21])) + (input[22] * weights[0][22])) + (input[23] * weights[0][23])) + (input[24] * weights[0][24])) + (input[25] * weights[0][25])) + (input[26] * weights[0][26])) + (input[27] * weights[0][27])) + (input[28] * weights[0][28])) + (input[29] * weights[0][29])) + (input[30] * weights[0][30])) + (input[31] * weights[0][31])) + (input[32] * weights[0][32])) + (input[33] * weights[0][33])) + (input[34] * weights[0][34])) + (input[35] * weights[0][35])) / 10000) + biases[0]) | |
| 59 | - | let weighted_sum2 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) + (input[2] * weights[1][2])) + (input[3] * weights[1][3])) + (input[4] * weights[1][4])) + (input[5] * weights[1][5])) + (input[6] * weights[1][6])) + (input[7] * weights[1][7])) + (input[8] * weights[1][8])) + (input[9] * weights[1][9])) + (input[10] * weights[1][10])) + (input[11] * weights[1][11])) + (input[12] * weights[1][12])) + (input[13] * weights[1][13])) + (input[14] * weights[1][14])) + (input[15] * weights[1][15])) + (input[16] * weights[1][16])) + (input[17] * weights[1][17])) + (input[18] * weights[1][18])) + (input[19] * weights[1][19])) + (input[20] * weights[1][20])) + (input[21] * weights[1][21])) + (input[22] * weights[1][22])) + (input[23] * weights[1][23])) + (input[24] * weights[1][24])) + (input[25] * weights[1][25])) + (input[26] * weights[1][26])) + (input[27] * weights[1][27])) + (input[28] * weights[1][28])) + (input[29] * weights[1][29])) + (input[30] * weights[1][30])) + (input[31] * weights[1][31])) + (input[32] * weights[1][32])) + (input[33] * weights[1][33])) + (input[34] * weights[1][34])) + (input[35] * weights[1][35])) / 10000) + biases[1]) | |
| 60 | - | let weighted_sum3 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[2][0]) + (input[1] * weights[2][1])) + (input[2] * weights[2][2])) + (input[3] * weights[2][3])) + (input[4] * weights[2][4])) + (input[5] * weights[2][5])) + (input[6] * weights[2][6])) + (input[7] * weights[2][7])) + (input[8] * weights[2][8])) + (input[9] * weights[2][9])) + (input[10] * weights[2][10])) + (input[11] * weights[2][11])) + (input[12] * weights[2][12])) + (input[13] * weights[2][13])) + (input[14] * weights[2][14])) + (input[15] * weights[2][15])) + (input[16] * weights[2][16])) + (input[17] * weights[2][17])) + (input[18] * weights[2][18])) + (input[19] * weights[2][19])) + (input[20] * weights[2][20])) + (input[21] * weights[2][21])) + (input[22] * weights[2][22])) + (input[23] * weights[2][23])) + (input[24] * weights[2][24])) + (input[25] * weights[2][25])) + (input[26] * weights[2][26])) + (input[27] * weights[2][27])) + (input[28] * weights[2][28])) + (input[29] * weights[2][29])) + (input[30] * weights[2][30])) + (input[31] * weights[2][31])) + (input[32] * weights[2][32])) + (input[33] * weights[2][33])) + (input[34] * weights[2][34])) + (input[35] * weights[2][35])) / 10000) + biases[2]) | |
| 61 | - | let weighted_sum4 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[3][0]) + (input[1] * weights[3][1])) + (input[2] * weights[3][2])) + (input[3] * weights[3][3])) + (input[4] * weights[3][4])) + (input[5] * weights[3][5])) + (input[6] * weights[3][6])) + (input[7] * weights[3][7])) + (input[8] * weights[3][8])) + (input[9] * weights[3][9])) + (input[10] * weights[3][10])) + (input[11] * weights[3][11])) + (input[12] * weights[3][12])) + (input[13] * weights[3][13])) + (input[14] * weights[3][14])) + (input[15] * weights[3][15])) + (input[16] * weights[3][16])) + (input[17] * weights[3][17])) + (input[18] * weights[3][18])) + (input[19] * weights[3][19])) + (input[20] * weights[3][20])) + (input[21] * weights[3][21])) + (input[22] * weights[3][22])) + (input[23] * weights[3][23])) + (input[24] * weights[3][24])) + (input[25] * weights[3][25])) + (input[26] * weights[3][26])) + (input[27] * weights[3][27])) + (input[28] * weights[3][28])) + (input[29] * weights[3][29])) + (input[30] * weights[3][30])) + (input[31] * weights[3][31])) + (input[32] * weights[3][32])) + (input[33] * weights[3][33])) + (input[34] * weights[3][34])) + (input[35] * weights[3][35])) / 10000) + biases[3]) | |
| 62 | - | let weighted_sum5 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[4][0]) + (input[1] * weights[4][1])) + (input[2] * weights[4][2])) + (input[3] * weights[4][3])) + (input[4] * weights[4][4])) + (input[5] * weights[4][5])) + (input[6] * weights[4][6])) + (input[7] * weights[4][7])) + (input[8] * weights[4][8])) + (input[9] * weights[4][9])) + (input[10] * weights[4][10])) + (input[11] * weights[4][11])) + (input[12] * weights[4][12])) + (input[13] * weights[4][13])) + (input[14] * weights[4][14])) + (input[15] * weights[4][15])) + (input[16] * weights[4][16])) + (input[17] * weights[4][17])) + (input[18] * weights[4][18])) + (input[19] * weights[4][19])) + (input[20] * weights[4][20])) + (input[21] * weights[4][21])) + (input[22] * weights[4][22])) + (input[23] * weights[4][23])) + (input[24] * weights[4][24])) + (input[25] * weights[4][25])) + (input[26] * weights[4][26])) + (input[27] * weights[4][27])) + (input[28] * weights[4][28])) + (input[29] * weights[4][29])) + (input[30] * weights[4][30])) + (input[31] * weights[4][31])) + (input[32] * weights[4][32])) + (input[33] * weights[4][33])) + (input[34] * weights[4][34])) + (input[35] * weights[4][35])) / 10000) + biases[4]) | |
| 63 | - | let weighted_sum6 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[5][0]) + (input[1] * weights[5][1])) + (input[2] * weights[5][2])) + (input[3] * weights[5][3])) + (input[4] * weights[5][4])) + (input[5] * weights[5][5])) + (input[6] * weights[5][6])) + (input[7] * weights[5][7])) + (input[8] * weights[5][8])) + (input[9] * weights[5][9])) + (input[10] * weights[5][10])) + (input[11] * weights[5][11])) + (input[12] * weights[5][12])) + (input[13] * weights[5][13])) + (input[14] * weights[5][14])) + (input[15] * weights[5][15])) + (input[16] * weights[5][16])) + (input[17] * weights[5][17])) + (input[18] * weights[5][18])) + (input[19] * weights[5][19])) + (input[20] * weights[5][20])) + (input[21] * weights[5][21])) + (input[22] * weights[5][22])) + (input[23] * weights[5][23])) + (input[24] * weights[5][24])) + (input[25] * weights[5][25])) + (input[26] * weights[5][26])) + (input[27] * weights[5][27])) + (input[28] * weights[5][28])) + (input[29] * weights[5][29])) + (input[30] * weights[5][30])) + (input[31] * weights[5][31])) + (input[32] * weights[5][32])) + (input[33] * weights[5][33])) + (input[34] * weights[5][34])) + (input[35] * weights[5][35])) / 10000) + biases[5]) | |
| 64 | - | let weighted_sum7 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[6][0]) + (input[1] * weights[6][1])) + (input[2] * weights[6][2])) + (input[3] * weights[6][3])) + (input[4] * weights[6][4])) + (input[5] * weights[6][5])) + (input[6] * weights[6][6])) + (input[7] * weights[6][7])) + (input[8] * weights[6][8])) + (input[9] * weights[6][9])) + (input[10] * weights[6][10])) + (input[11] * weights[6][11])) + (input[12] * weights[6][12])) + (input[13] * weights[6][13])) + (input[14] * weights[6][14])) + (input[15] * weights[6][15])) + (input[16] * weights[6][16])) + (input[17] * weights[6][17])) + (input[18] * weights[6][18])) + (input[19] * weights[6][19])) + (input[20] * weights[6][20])) + (input[21] * weights[6][21])) + (input[22] * weights[6][22])) + (input[23] * weights[6][23])) + (input[24] * weights[6][24])) + (input[25] * weights[6][25])) + (input[26] * weights[6][26])) + (input[27] * weights[6][27])) + (input[28] * weights[6][28])) + (input[29] * weights[6][29])) + (input[30] * weights[6][30])) + (input[31] * weights[6][31])) + (input[32] * weights[6][32])) + (input[33] * weights[6][33])) + (input[34] * weights[6][34])) + (input[35] * weights[6][35])) / 10000) + biases[6]) | |
| 65 | - | let weighted_sum8 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[7][0]) + (input[1] * weights[7][1])) + (input[2] * weights[7][2])) + (input[3] * weights[7][3])) + (input[4] * weights[7][4])) + (input[5] * weights[7][5])) + (input[6] * weights[7][6])) + (input[7] * weights[7][7])) + (input[8] * weights[7][8])) + (input[9] * weights[7][9])) + (input[10] * weights[7][10])) + (input[11] * weights[7][11])) + (input[12] * weights[7][12])) + (input[13] * weights[7][13])) + (input[14] * weights[7][14])) + (input[15] * weights[7][15])) + (input[16] * weights[7][16])) + (input[17] * weights[7][17])) + (input[18] * weights[7][18])) + (input[19] * weights[7][19])) + (input[20] * weights[7][20])) + (input[21] * weights[7][21])) + (input[22] * weights[7][22])) + (input[23] * weights[7][23])) + (input[24] * weights[7][24])) + (input[25] * weights[7][25])) + (input[26] * weights[7][26])) + (input[27] * weights[7][27])) + (input[28] * weights[7][28])) + (input[29] * weights[7][29])) + (input[30] * weights[7][30])) + (input[31] * weights[7][31])) + (input[32] * weights[7][32])) + (input[33] * weights[7][33])) + (input[34] * weights[7][34])) + (input[35] * weights[7][35])) / 10000) + biases[7]) | |
| 66 | - | let weighted_sum9 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[8][0]) + (input[1] * weights[8][1])) + (input[2] * weights[8][2])) + (input[3] * weights[8][3])) + (input[4] * weights[8][4])) + (input[5] * weights[8][5])) + (input[6] * weights[8][6])) + (input[7] * weights[8][7])) + (input[8] * weights[8][8])) + (input[9] * weights[8][9])) + (input[10] * weights[8][10])) + (input[11] * weights[8][11])) + (input[12] * weights[8][12])) + (input[13] * weights[8][13])) + (input[14] * weights[8][14])) + (input[15] * weights[8][15])) + (input[16] * weights[8][16])) + (input[17] * weights[8][17])) + (input[18] * weights[8][18])) + (input[19] * weights[8][19])) + (input[20] * weights[8][20])) + (input[21] * weights[8][21])) + (input[22] * weights[8][22])) + (input[23] * weights[8][23])) + (input[24] * weights[8][24])) + (input[25] * weights[8][25])) + (input[26] * weights[8][26])) + (input[27] * weights[8][27])) + (input[28] * weights[8][28])) + (input[29] * weights[8][29])) + (input[30] * weights[8][30])) + (input[31] * weights[8][31])) + (input[32] * weights[8][32])) + (input[33] * weights[8][33])) + (input[34] * weights[8][34])) + (input[35] * weights[8][35])) / 10000) + biases[8]) | |
| 67 | - | let weighted_sum10 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[9][0]) + (input[1] * weights[9][1])) + (input[2] * weights[9][2])) + (input[3] * weights[9][3])) + (input[4] * weights[9][4])) + (input[5] * weights[9][5])) + (input[6] * weights[9][6])) + (input[7] * weights[9][7])) + (input[8] * weights[9][8])) + (input[9] * weights[9][9])) + (input[10] * weights[9][10])) + (input[11] * weights[9][11])) + (input[12] * weights[9][12])) + (input[13] * weights[9][13])) + (input[14] * weights[9][14])) + (input[15] * weights[9][15])) + (input[16] * weights[9][16])) + (input[17] * weights[9][17])) + (input[18] * weights[9][18])) + (input[19] * weights[9][19])) + (input[20] * weights[9][20])) + (input[21] * weights[9][21])) + (input[22] * weights[9][22])) + (input[23] * weights[9][23])) + (input[24] * weights[9][24])) + (input[25] * weights[9][25])) + (input[26] * weights[9][26])) + (input[27] * weights[9][27])) + (input[28] * weights[9][28])) + (input[29] * weights[9][29])) + (input[30] * weights[9][30])) + (input[31] * weights[9][31])) + (input[32] * weights[9][32])) + (input[33] * weights[9][33])) + (input[34] * weights[9][34])) + (input[35] * weights[9][35])) / 10000) + biases[9]) | |
| 68 | - | let weighted_sum11 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[10][0]) + (input[1] * weights[10][1])) + (input[2] * weights[10][2])) + (input[3] * weights[10][3])) + (input[4] * weights[10][4])) + (input[5] * weights[10][5])) + (input[6] * weights[10][6])) + (input[7] * weights[10][7])) + (input[8] * weights[10][8])) + (input[9] * weights[10][9])) + (input[10] * weights[10][10])) + (input[11] * weights[10][11])) + (input[12] * weights[10][12])) + (input[13] * weights[10][13])) + (input[14] * weights[10][14])) + (input[15] * weights[10][15])) + (input[16] * weights[10][16])) + (input[17] * weights[10][17])) + (input[18] * weights[10][18])) + (input[19] * weights[10][19])) + (input[20] * weights[10][20])) + (input[21] * weights[10][21])) + (input[22] * weights[10][22])) + (input[23] * weights[10][23])) + (input[24] * weights[10][24])) + (input[25] * weights[10][25])) + (input[26] * weights[10][26])) + (input[27] * weights[10][27])) + (input[28] * weights[10][28])) + (input[29] * weights[10][29])) + (input[30] * weights[10][30])) + (input[31] * weights[10][31])) + (input[32] * weights[10][32])) + (input[33] * weights[10][33])) + (input[34] * weights[10][34])) + (input[35] * weights[10][35])) / 10000) + biases[10]) | |
| 69 | - | let weighted_sum12 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[11][0]) + (input[1] * weights[11][1])) + (input[2] * weights[11][2])) + (input[3] * weights[11][3])) + (input[4] * weights[11][4])) + (input[5] * weights[11][5])) + (input[6] * weights[11][6])) + (input[7] * weights[11][7])) + (input[8] * weights[11][8])) + (input[9] * weights[11][9])) + (input[10] * weights[11][10])) + (input[11] * weights[11][11])) + (input[12] * weights[11][12])) + (input[13] * weights[11][13])) + (input[14] * weights[11][14])) + (input[15] * weights[11][15])) + (input[16] * weights[11][16])) + (input[17] * weights[11][17])) + (input[18] * weights[11][18])) + (input[19] * weights[11][19])) + (input[20] * weights[11][20])) + (input[21] * weights[11][21])) + (input[22] * weights[11][22])) + (input[23] * weights[11][23])) + (input[24] * weights[11][24])) + (input[25] * weights[11][25])) + (input[26] * weights[11][26])) + (input[27] * weights[11][27])) + (input[28] * weights[11][28])) + (input[29] * weights[11][29])) + (input[30] * weights[11][30])) + (input[31] * weights[11][31])) + (input[32] * weights[11][32])) + (input[33] * weights[11][33])) + (input[34] * weights[11][34])) + (input[35] * weights[11][35])) / 10000) + biases[11]) | |
| 70 | - | let weighted_sum13 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[12][0]) + (input[1] * weights[12][1])) + (input[2] * weights[12][2])) + (input[3] * weights[12][3])) + (input[4] * weights[12][4])) + (input[5] * weights[12][5])) + (input[6] * weights[12][6])) + (input[7] * weights[12][7])) + (input[8] * weights[12][8])) + (input[9] * weights[12][9])) + (input[10] * weights[12][10])) + (input[11] * weights[12][11])) + (input[12] * weights[12][12])) + (input[13] * weights[12][13])) + (input[14] * weights[12][14])) + (input[15] * weights[12][15])) + (input[16] * weights[12][16])) + (input[17] * weights[12][17])) + (input[18] * weights[12][18])) + (input[19] * weights[12][19])) + (input[20] * weights[12][20])) + (input[21] * weights[12][21])) + (input[22] * weights[12][22])) + (input[23] * weights[12][23])) + (input[24] * weights[12][24])) + (input[25] * weights[12][25])) + (input[26] * weights[12][26])) + (input[27] * weights[12][27])) + (input[28] * weights[12][28])) + (input[29] * weights[12][29])) + (input[30] * weights[12][30])) + (input[31] * weights[12][31])) + (input[32] * weights[12][32])) + (input[33] * weights[12][33])) + (input[34] * weights[12][34])) + (input[35] * weights[12][35])) / 10000) + biases[12]) | |
| 71 | - | let weighted_sum14 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[13][0]) + (input[1] * weights[13][1])) + (input[2] * weights[13][2])) + (input[3] * weights[13][3])) + (input[4] * weights[13][4])) + (input[5] * weights[13][5])) + (input[6] * weights[13][6])) + (input[7] * weights[13][7])) + (input[8] * weights[13][8])) + (input[9] * weights[13][9])) + (input[10] * weights[13][10])) + (input[11] * weights[13][11])) + (input[12] * weights[13][12])) + (input[13] * weights[13][13])) + (input[14] * weights[13][14])) + (input[15] * weights[13][15])) + (input[16] * weights[13][16])) + (input[17] * weights[13][17])) + (input[18] * weights[13][18])) + (input[19] * weights[13][19])) + (input[20] * weights[13][20])) + (input[21] * weights[13][21])) + (input[22] * weights[13][22])) + (input[23] * weights[13][23])) + (input[24] * weights[13][24])) + (input[25] * weights[13][25])) + (input[26] * weights[13][26])) + (input[27] * weights[13][27])) + (input[28] * weights[13][28])) + (input[29] * weights[13][29])) + (input[30] * weights[13][30])) + (input[31] * weights[13][31])) + (input[32] * weights[13][32])) + (input[33] * weights[13][33])) + (input[34] * weights[13][34])) + (input[35] * weights[13][35])) / 10000) + biases[13]) | |
| 72 | - | let weighted_sum15 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[14][0]) + (input[1] * weights[14][1])) + (input[2] * weights[14][2])) + (input[3] * weights[14][3])) + (input[4] * weights[14][4])) + (input[5] * weights[14][5])) + (input[6] * weights[14][6])) + (input[7] * weights[14][7])) + (input[8] * weights[14][8])) + (input[9] * weights[14][9])) + (input[10] * weights[14][10])) + (input[11] * weights[14][11])) + (input[12] * weights[14][12])) + (input[13] * weights[14][13])) + (input[14] * weights[14][14])) + (input[15] * weights[14][15])) + (input[16] * weights[14][16])) + (input[17] * weights[14][17])) + (input[18] * weights[14][18])) + (input[19] * weights[14][19])) + (input[20] * weights[14][20])) + (input[21] * weights[14][21])) + (input[22] * weights[14][22])) + (input[23] * weights[14][23])) + (input[24] * weights[14][24])) + (input[25] * weights[14][25])) + (input[26] * weights[14][26])) + (input[27] * weights[14][27])) + (input[28] * weights[14][28])) + (input[29] * weights[14][29])) + (input[30] * weights[14][30])) + (input[31] * weights[14][31])) + (input[32] * weights[14][32])) + (input[33] * weights[14][33])) + (input[34] * weights[14][34])) + (input[35] * weights[14][35])) / 10000) + biases[14]) | |
| 73 | - | let weighted_sum16 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[15][0]) + (input[1] * weights[15][1])) + (input[2] * weights[15][2])) + (input[3] * weights[15][3])) + (input[4] * weights[15][4])) + (input[5] * weights[15][5])) + (input[6] * weights[15][6])) + (input[7] * weights[15][7])) + (input[8] * weights[15][8])) + (input[9] * weights[15][9])) + (input[10] * weights[15][10])) + (input[11] * weights[15][11])) + (input[12] * weights[15][12])) + (input[13] * weights[15][13])) + (input[14] * weights[15][14])) + (input[15] * weights[15][15])) + (input[16] * weights[15][16])) + (input[17] * weights[15][17])) + (input[18] * weights[15][18])) + (input[19] * weights[15][19])) + (input[20] * weights[15][20])) + (input[21] * weights[15][21])) + (input[22] * weights[15][22])) + (input[23] * weights[15][23])) + (input[24] * weights[15][24])) + (input[25] * weights[15][25])) + (input[26] * weights[15][26])) + (input[27] * weights[15][27])) + (input[28] * weights[15][28])) + (input[29] * weights[15][29])) + (input[30] * weights[15][30])) + (input[31] * weights[15][31])) + (input[32] * weights[15][32])) + (input[33] * weights[15][33])) + (input[34] * weights[15][34])) + (input[35] * weights[15][35])) / 10000) + biases[15]) | |
| 74 | - | let weighted_sum17 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[16][0]) + (input[1] * weights[16][1])) + (input[2] * weights[16][2])) + (input[3] * weights[16][3])) + (input[4] * weights[16][4])) + (input[5] * weights[16][5])) + (input[6] * weights[16][6])) + (input[7] * weights[16][7])) + (input[8] * weights[16][8])) + (input[9] * weights[16][9])) + (input[10] * weights[16][10])) + (input[11] * weights[16][11])) + (input[12] * weights[16][12])) + (input[13] * weights[16][13])) + (input[14] * weights[16][14])) + (input[15] * weights[16][15])) + (input[16] * weights[16][16])) + (input[17] * weights[16][17])) + (input[18] * weights[16][18])) + (input[19] * weights[16][19])) + (input[20] * weights[16][20])) + (input[21] * weights[16][21])) + (input[22] * weights[16][22])) + (input[23] * weights[16][23])) + (input[24] * weights[16][24])) + (input[25] * weights[16][25])) + (input[26] * weights[16][26])) + (input[27] * weights[16][27])) + (input[28] * weights[16][28])) + (input[29] * weights[16][29])) + (input[30] * weights[16][30])) + (input[31] * weights[16][31])) + (input[32] * weights[16][32])) + (input[33] * weights[16][33])) + (input[34] * weights[16][34])) + (input[35] * weights[16][35])) / 10000) + biases[16]) | |
| 75 | - | let weighted_sum18 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[17][0]) + (input[1] * weights[17][1])) + (input[2] * weights[17][2])) + (input[3] * weights[17][3])) + (input[4] * weights[17][4])) + (input[5] * weights[17][5])) + (input[6] * weights[17][6])) + (input[7] * weights[17][7])) + (input[8] * weights[17][8])) + (input[9] * weights[17][9])) + (input[10] * weights[17][10])) + (input[11] * weights[17][11])) + (input[12] * weights[17][12])) + (input[13] * weights[17][13])) + (input[14] * weights[17][14])) + (input[15] * weights[17][15])) + (input[16] * weights[17][16])) + (input[17] * weights[17][17])) + (input[18] * weights[17][18])) + (input[19] * weights[17][19])) + (input[20] * weights[17][20])) + (input[21] * weights[17][21])) + (input[22] * weights[17][22])) + (input[23] * weights[17][23])) + (input[24] * weights[17][24])) + (input[25] * weights[17][25])) + (input[26] * weights[17][26])) + (input[27] * weights[17][27])) + (input[28] * weights[17][28])) + (input[29] * weights[17][29])) + (input[30] * weights[17][30])) + (input[31] * weights[17][31])) + (input[32] * weights[17][32])) + (input[33] * weights[17][33])) + (input[34] * weights[17][34])) + (input[35] * weights[17][35])) / 10000) + biases[17]) | |
| 76 | - | let weighted_sum19 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[18][0]) + (input[1] * weights[18][1])) + (input[2] * weights[18][2])) + (input[3] * weights[18][3])) + (input[4] * weights[18][4])) + (input[5] * weights[18][5])) + (input[6] * weights[18][6])) + (input[7] * weights[18][7])) + (input[8] * weights[18][8])) + (input[9] * weights[18][9])) + (input[10] * weights[18][10])) + (input[11] * weights[18][11])) + (input[12] * weights[18][12])) + (input[13] * weights[18][13])) + (input[14] * weights[18][14])) + (input[15] * weights[18][15])) + (input[16] * weights[18][16])) + (input[17] * weights[18][17])) + (input[18] * weights[18][18])) + (input[19] * weights[18][19])) + (input[20] * weights[18][20])) + (input[21] * weights[18][21])) + (input[22] * weights[18][22])) + (input[23] * weights[18][23])) + (input[24] * weights[18][24])) + (input[25] * weights[18][25])) + (input[26] * weights[18][26])) + (input[27] * weights[18][27])) + (input[28] * weights[18][28])) + (input[29] * weights[18][29])) + (input[30] * weights[18][30])) + (input[31] * weights[18][31])) + (input[32] * weights[18][32])) + (input[33] * weights[18][33])) + (input[34] * weights[18][34])) + (input[35] * weights[18][35])) / 10000) + biases[18]) | |
| 77 | - | let weighted_sum20 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[19][0]) + (input[1] * weights[19][1])) + (input[2] * weights[19][2])) + (input[3] * weights[19][3])) + (input[4] * weights[19][4])) + (input[5] * weights[19][5])) + (input[6] * weights[19][6])) + (input[7] * weights[19][7])) + (input[8] * weights[19][8])) + (input[9] * weights[19][9])) + (input[10] * weights[19][10])) + (input[11] * weights[19][11])) + (input[12] * weights[19][12])) + (input[13] * weights[19][13])) + (input[14] * weights[19][14])) + (input[15] * weights[19][15])) + (input[16] * weights[19][16])) + (input[17] * weights[19][17])) + (input[18] * weights[19][18])) + (input[19] * weights[19][19])) + (input[20] * weights[19][20])) + (input[21] * weights[19][21])) + (input[22] * weights[19][22])) + (input[23] * weights[19][23])) + (input[24] * weights[19][24])) + (input[25] * weights[19][25])) + (input[26] * weights[19][26])) + (input[27] * weights[19][27])) + (input[28] * weights[19][28])) + (input[29] * weights[19][29])) + (input[30] * weights[19][30])) + (input[31] * weights[19][31])) + (input[32] * weights[19][32])) + (input[33] * weights[19][33])) + (input[34] * weights[19][34])) + (input[35] * weights[19][35])) / 10000) + biases[19]) | |
| 78 | - | let weighted_sum21 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[20][0]) + (input[1] * weights[20][1])) + (input[2] * weights[20][2])) + (input[3] * weights[20][3])) + (input[4] * weights[20][4])) + (input[5] * weights[20][5])) + (input[6] * weights[20][6])) + (input[7] * weights[20][7])) + (input[8] * weights[20][8])) + (input[9] * weights[20][9])) + (input[10] * weights[20][10])) + (input[11] * weights[20][11])) + (input[12] * weights[20][12])) + (input[13] * weights[20][13])) + (input[14] * weights[20][14])) + (input[15] * weights[20][15])) + (input[16] * weights[20][16])) + (input[17] * weights[20][17])) + (input[18] * weights[20][18])) + (input[19] * weights[20][19])) + (input[20] * weights[20][20])) + (input[21] * weights[20][21])) + (input[22] * weights[20][22])) + (input[23] * weights[20][23])) + (input[24] * weights[20][24])) + (input[25] * weights[20][25])) + (input[26] * weights[20][26])) + (input[27] * weights[20][27])) + (input[28] * weights[20][28])) + (input[29] * weights[20][29])) + (input[30] * weights[20][30])) + (input[31] * weights[20][31])) + (input[32] * weights[20][32])) + (input[33] * weights[20][33])) + (input[34] * weights[20][34])) + (input[35] * weights[20][35])) / 10000) + biases[20]) | |
| 79 | - | let weighted_sum22 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[21][0]) + (input[1] * weights[21][1])) + (input[2] * weights[21][2])) + (input[3] * weights[21][3])) + (input[4] * weights[21][4])) + (input[5] * weights[21][5])) + (input[6] * weights[21][6])) + (input[7] * weights[21][7])) + (input[8] * weights[21][8])) + (input[9] * weights[21][9])) + (input[10] * weights[21][10])) + (input[11] * weights[21][11])) + (input[12] * weights[21][12])) + (input[13] * weights[21][13])) + (input[14] * weights[21][14])) + (input[15] * weights[21][15])) + (input[16] * weights[21][16])) + (input[17] * weights[21][17])) + (input[18] * weights[21][18])) + (input[19] * weights[21][19])) + (input[20] * weights[21][20])) + (input[21] * weights[21][21])) + (input[22] * weights[21][22])) + (input[23] * weights[21][23])) + (input[24] * weights[21][24])) + (input[25] * weights[21][25])) + (input[26] * weights[21][26])) + (input[27] * weights[21][27])) + (input[28] * weights[21][28])) + (input[29] * weights[21][29])) + (input[30] * weights[21][30])) + (input[31] * weights[21][31])) + (input[32] * weights[21][32])) + (input[33] * weights[21][33])) + (input[34] * weights[21][34])) + (input[35] * weights[21][35])) / 10000) + biases[21]) | |
| 80 | - | let weighted_sum23 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[22][0]) + (input[1] * weights[22][1])) + (input[2] * weights[22][2])) + (input[3] * weights[22][3])) + (input[4] * weights[22][4])) + (input[5] * weights[22][5])) + (input[6] * weights[22][6])) + (input[7] * weights[22][7])) + (input[8] * weights[22][8])) + (input[9] * weights[22][9])) + (input[10] * weights[22][10])) + (input[11] * weights[22][11])) + (input[12] * weights[22][12])) + (input[13] * weights[22][13])) + (input[14] * weights[22][14])) + (input[15] * weights[22][15])) + (input[16] * weights[22][16])) + (input[17] * weights[22][17])) + (input[18] * weights[22][18])) + (input[19] * weights[22][19])) + (input[20] * weights[22][20])) + (input[21] * weights[22][21])) + (input[22] * weights[22][22])) + (input[23] * weights[22][23])) + (input[24] * weights[22][24])) + (input[25] * weights[22][25])) + (input[26] * weights[22][26])) + (input[27] * weights[22][27])) + (input[28] * weights[22][28])) + (input[29] * weights[22][29])) + (input[30] * weights[22][30])) + (input[31] * weights[22][31])) + (input[32] * weights[22][32])) + (input[33] * weights[22][33])) + (input[34] * weights[22][34])) + (input[35] * weights[22][35])) / 10000) + biases[22]) | |
| 81 | - | let weighted_sum24 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[23][0]) + (input[1] * weights[23][1])) + (input[2] * weights[23][2])) + (input[3] * weights[23][3])) + (input[4] * weights[23][4])) + (input[5] * weights[23][5])) + (input[6] * weights[23][6])) + (input[7] * weights[23][7])) + (input[8] * weights[23][8])) + (input[9] * weights[23][9])) + (input[10] * weights[23][10])) + (input[11] * weights[23][11])) + (input[12] * weights[23][12])) + (input[13] * weights[23][13])) + (input[14] * weights[23][14])) + (input[15] * weights[23][15])) + (input[16] * weights[23][16])) + (input[17] * weights[23][17])) + (input[18] * weights[23][18])) + (input[19] * weights[23][19])) + (input[20] * weights[23][20])) + (input[21] * weights[23][21])) + (input[22] * weights[23][22])) + (input[23] * weights[23][23])) + (input[24] * weights[23][24])) + (input[25] * weights[23][25])) + (input[26] * weights[23][26])) + (input[27] * weights[23][27])) + (input[28] * weights[23][28])) + (input[29] * weights[23][29])) + (input[30] * weights[23][30])) + (input[31] * weights[23][31])) + (input[32] * weights[23][32])) + (input[33] * weights[23][33])) + (input[34] * weights[23][34])) + (input[35] * weights[23][35])) / 10000) + biases[23]) | |
| 82 | - | let weighted_sum25 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[24][0]) + (input[1] * weights[24][1])) + (input[2] * weights[24][2])) + (input[3] * weights[24][3])) + (input[4] * weights[24][4])) + (input[5] * weights[24][5])) + (input[6] * weights[24][6])) + (input[7] * weights[24][7])) + (input[8] * weights[24][8])) + (input[9] * weights[24][9])) + (input[10] * weights[24][10])) + (input[11] * weights[24][11])) + (input[12] * weights[24][12])) + (input[13] * weights[24][13])) + (input[14] * weights[24][14])) + (input[15] * weights[24][15])) + (input[16] * weights[24][16])) + (input[17] * weights[24][17])) + (input[18] * weights[24][18])) + (input[19] * weights[24][19])) + (input[20] * weights[24][20])) + (input[21] * weights[24][21])) + (input[22] * weights[24][22])) + (input[23] * weights[24][23])) + (input[24] * weights[24][24])) + (input[25] * weights[24][25])) + (input[26] * weights[24][26])) + (input[27] * weights[24][27])) + (input[28] * weights[24][28])) + (input[29] * weights[24][29])) + (input[30] * weights[24][30])) + (input[31] * weights[24][31])) + (input[32] * weights[24][32])) + (input[33] * weights[24][33])) + (input[34] * weights[24][34])) + (input[35] * weights[24][35])) / 10000) + biases[24]) | |
| 83 | - | let weighted_sum26 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[25][0]) + (input[1] * weights[25][1])) + (input[2] * weights[25][2])) + (input[3] * weights[25][3])) + (input[4] * weights[25][4])) + (input[5] * weights[25][5])) + (input[6] * weights[25][6])) + (input[7] * weights[25][7])) + (input[8] * weights[25][8])) + (input[9] * weights[25][9])) + (input[10] * weights[25][10])) + (input[11] * weights[25][11])) + (input[12] * weights[25][12])) + (input[13] * weights[25][13])) + (input[14] * weights[25][14])) + (input[15] * weights[25][15])) + (input[16] * weights[25][16])) + (input[17] * weights[25][17])) + (input[18] * weights[25][18])) + (input[19] * weights[25][19])) + (input[20] * weights[25][20])) + (input[21] * weights[25][21])) + (input[22] * weights[25][22])) + (input[23] * weights[25][23])) + (input[24] * weights[25][24])) + (input[25] * weights[25][25])) + (input[26] * weights[25][26])) + (input[27] * weights[25][27])) + (input[28] * weights[25][28])) + (input[29] * weights[25][29])) + (input[30] * weights[25][30])) + (input[31] * weights[25][31])) + (input[32] * weights[25][32])) + (input[33] * weights[25][33])) + (input[34] * weights[25][34])) + (input[35] * weights[25][35])) / 10000) + biases[25]) | |
| 84 | - | let weighted_sum27 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[26][0]) + (input[1] * weights[26][1])) + (input[2] * weights[26][2])) + (input[3] * weights[26][3])) + (input[4] * weights[26][4])) + (input[5] * weights[26][5])) + (input[6] * weights[26][6])) + (input[7] * weights[26][7])) + (input[8] * weights[26][8])) + (input[9] * weights[26][9])) + (input[10] * weights[26][10])) + (input[11] * weights[26][11])) + (input[12] * weights[26][12])) + (input[13] * weights[26][13])) + (input[14] * weights[26][14])) + (input[15] * weights[26][15])) + (input[16] * weights[26][16])) + (input[17] * weights[26][17])) + (input[18] * weights[26][18])) + (input[19] * weights[26][19])) + (input[20] * weights[26][20])) + (input[21] * weights[26][21])) + (input[22] * weights[26][22])) + (input[23] * weights[26][23])) + (input[24] * weights[26][24])) + (input[25] * weights[26][25])) + (input[26] * weights[26][26])) + (input[27] * weights[26][27])) + (input[28] * weights[26][28])) + (input[29] * weights[26][29])) + (input[30] * weights[26][30])) + (input[31] * weights[26][31])) + (input[32] * weights[26][32])) + (input[33] * weights[26][33])) + (input[34] * weights[26][34])) + (input[35] * weights[26][35])) / 10000) + biases[26]) | |
| 85 | - | let weighted_sum28 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[27][0]) + (input[1] * weights[27][1])) + (input[2] * weights[27][2])) + (input[3] * weights[27][3])) + (input[4] * weights[27][4])) + (input[5] * weights[27][5])) + (input[6] * weights[27][6])) + (input[7] * weights[27][7])) + (input[8] * weights[27][8])) + (input[9] * weights[27][9])) + (input[10] * weights[27][10])) + (input[11] * weights[27][11])) + (input[12] * weights[27][12])) + (input[13] * weights[27][13])) + (input[14] * weights[27][14])) + (input[15] * weights[27][15])) + (input[16] * weights[27][16])) + (input[17] * weights[27][17])) + (input[18] * weights[27][18])) + (input[19] * weights[27][19])) + (input[20] * weights[27][20])) + (input[21] * weights[27][21])) + (input[22] * weights[27][22])) + (input[23] * weights[27][23])) + (input[24] * weights[27][24])) + (input[25] * weights[27][25])) + (input[26] * weights[27][26])) + (input[27] * weights[27][27])) + (input[28] * weights[27][28])) + (input[29] * weights[27][29])) + (input[30] * weights[27][30])) + (input[31] * weights[27][31])) + (input[32] * weights[27][32])) + (input[33] * weights[27][33])) + (input[34] * weights[27][34])) + (input[35] * weights[27][35])) / 10000) + biases[27]) | |
| 86 | - | let weighted_sum29 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[28][0]) + (input[1] * weights[28][1])) + (input[2] * weights[28][2])) + (input[3] * weights[28][3])) + (input[4] * weights[28][4])) + (input[5] * weights[28][5])) + (input[6] * weights[28][6])) + (input[7] * weights[28][7])) + (input[8] * weights[28][8])) + (input[9] * weights[28][9])) + (input[10] * weights[28][10])) + (input[11] * weights[28][11])) + (input[12] * weights[28][12])) + (input[13] * weights[28][13])) + (input[14] * weights[28][14])) + (input[15] * weights[28][15])) + (input[16] * weights[28][16])) + (input[17] * weights[28][17])) + (input[18] * weights[28][18])) + (input[19] * weights[28][19])) + (input[20] * weights[28][20])) + (input[21] * weights[28][21])) + (input[22] * weights[28][22])) + (input[23] * weights[28][23])) + (input[24] * weights[28][24])) + (input[25] * weights[28][25])) + (input[26] * weights[28][26])) + (input[27] * weights[28][27])) + (input[28] * weights[28][28])) + (input[29] * weights[28][29])) + (input[30] * weights[28][30])) + (input[31] * weights[28][31])) + (input[32] * weights[28][32])) + (input[33] * weights[28][33])) + (input[34] * weights[28][34])) + (input[35] * weights[28][35])) / 10000) + biases[28]) | |
| 87 | - | let weighted_sum30 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[29][0]) + (input[1] * weights[29][1])) + (input[2] * weights[29][2])) + (input[3] * weights[29][3])) + (input[4] * weights[29][4])) + (input[5] * weights[29][5])) + (input[6] * weights[29][6])) + (input[7] * weights[29][7])) + (input[8] * weights[29][8])) + (input[9] * weights[29][9])) + (input[10] * weights[29][10])) + (input[11] * weights[29][11])) + (input[12] * weights[29][12])) + (input[13] * weights[29][13])) + (input[14] * weights[29][14])) + (input[15] * weights[29][15])) + (input[16] * weights[29][16])) + (input[17] * weights[29][17])) + (input[18] * weights[29][18])) + (input[19] * weights[29][19])) + (input[20] * weights[29][20])) + (input[21] * weights[29][21])) + (input[22] * weights[29][22])) + (input[23] * weights[29][23])) + (input[24] * weights[29][24])) + (input[25] * weights[29][25])) + (input[26] * weights[29][26])) + (input[27] * weights[29][27])) + (input[28] * weights[29][28])) + (input[29] * weights[29][29])) + (input[30] * weights[29][30])) + (input[31] * weights[29][31])) + (input[32] * weights[29][32])) + (input[33] * weights[29][33])) + (input[34] * weights[29][34])) + (input[35] * weights[29][35])) / 10000) + biases[29]) | |
| 88 | - | let weighted_sum31 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[30][0]) + (input[1] * weights[30][1])) + (input[2] * weights[30][2])) + (input[3] * weights[30][3])) + (input[4] * weights[30][4])) + (input[5] * weights[30][5])) + (input[6] * weights[30][6])) + (input[7] * weights[30][7])) + (input[8] * weights[30][8])) + (input[9] * weights[30][9])) + (input[10] * weights[30][10])) + (input[11] * weights[30][11])) + (input[12] * weights[30][12])) + (input[13] * weights[30][13])) + (input[14] * weights[30][14])) + (input[15] * weights[30][15])) + (input[16] * weights[30][16])) + (input[17] * weights[30][17])) + (input[18] * weights[30][18])) + (input[19] * weights[30][19])) + (input[20] * weights[30][20])) + (input[21] * weights[30][21])) + (input[22] * weights[30][22])) + (input[23] * weights[30][23])) + (input[24] * weights[30][24])) + (input[25] * weights[30][25])) + (input[26] * weights[30][26])) + (input[27] * weights[30][27])) + (input[28] * weights[30][28])) + (input[29] * weights[30][29])) + (input[30] * weights[30][30])) + (input[31] * weights[30][31])) + (input[32] * weights[30][32])) + (input[33] * weights[30][33])) + (input[34] * weights[30][34])) + (input[35] * weights[30][35])) / 10000) + biases[30]) | |
| 89 | - | let weighted_sum32 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[31][0]) + (input[1] * weights[31][1])) + (input[2] * weights[31][2])) + (input[3] * weights[31][3])) + (input[4] * weights[31][4])) + (input[5] * weights[31][5])) + (input[6] * weights[31][6])) + (input[7] * weights[31][7])) + (input[8] * weights[31][8])) + (input[9] * weights[31][9])) + (input[10] * weights[31][10])) + (input[11] * weights[31][11])) + (input[12] * weights[31][12])) + (input[13] * weights[31][13])) + (input[14] * weights[31][14])) + (input[15] * weights[31][15])) + (input[16] * weights[31][16])) + (input[17] * weights[31][17])) + (input[18] * weights[31][18])) + (input[19] * weights[31][19])) + (input[20] * weights[31][20])) + (input[21] * weights[31][21])) + (input[22] * weights[31][22])) + (input[23] * weights[31][23])) + (input[24] * weights[31][24])) + (input[25] * weights[31][25])) + (input[26] * weights[31][26])) + (input[27] * weights[31][27])) + (input[28] * weights[31][28])) + (input[29] * weights[31][29])) + (input[30] * weights[31][30])) + (input[31] * weights[31][31])) + (input[32] * weights[31][32])) + (input[33] * weights[31][33])) + (input[34] * weights[31][34])) + (input[35] * weights[31][35])) / 10000) + biases[31]) | |
| 90 | - | let weighted_sum33 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[32][0]) + (input[1] * weights[32][1])) + (input[2] * weights[32][2])) + (input[3] * weights[32][3])) + (input[4] * weights[32][4])) + (input[5] * weights[32][5])) + (input[6] * weights[32][6])) + (input[7] * weights[32][7])) + (input[8] * weights[32][8])) + (input[9] * weights[32][9])) + (input[10] * weights[32][10])) + (input[11] * weights[32][11])) + (input[12] * weights[32][12])) + (input[13] * weights[32][13])) + (input[14] * weights[32][14])) + (input[15] * weights[32][15])) + (input[16] * weights[32][16])) + (input[17] * weights[32][17])) + (input[18] * weights[32][18])) + (input[19] * weights[32][19])) + (input[20] * weights[32][20])) + (input[21] * weights[32][21])) + (input[22] * weights[32][22])) + (input[23] * weights[32][23])) + (input[24] * weights[32][24])) + (input[25] * weights[32][25])) + (input[26] * weights[32][26])) + (input[27] * weights[32][27])) + (input[28] * weights[32][28])) + (input[29] * weights[32][29])) + (input[30] * weights[32][30])) + (input[31] * weights[32][31])) + (input[32] * weights[32][32])) + (input[33] * weights[32][33])) + (input[34] * weights[32][34])) + (input[35] * weights[32][35])) / 10000) + biases[32]) | |
| 91 | - | let weighted_sum34 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[33][0]) + (input[1] * weights[33][1])) + (input[2] * weights[33][2])) + (input[3] * weights[33][3])) + (input[4] * weights[33][4])) + (input[5] * weights[33][5])) + (input[6] * weights[33][6])) + (input[7] * weights[33][7])) + (input[8] * weights[33][8])) + (input[9] * weights[33][9])) + (input[10] * weights[33][10])) + (input[11] * weights[33][11])) + (input[12] * weights[33][12])) + (input[13] * weights[33][13])) + (input[14] * weights[33][14])) + (input[15] * weights[33][15])) + (input[16] * weights[33][16])) + (input[17] * weights[33][17])) + (input[18] * weights[33][18])) + (input[19] * weights[33][19])) + (input[20] * weights[33][20])) + (input[21] * weights[33][21])) + (input[22] * weights[33][22])) + (input[23] * weights[33][23])) + (input[24] * weights[33][24])) + (input[25] * weights[33][25])) + (input[26] * weights[33][26])) + (input[27] * weights[33][27])) + (input[28] * weights[33][28])) + (input[29] * weights[33][29])) + (input[30] * weights[33][30])) + (input[31] * weights[33][31])) + (input[32] * weights[33][32])) + (input[33] * weights[33][33])) + (input[34] * weights[33][34])) + (input[35] * weights[33][35])) / 10000) + biases[33]) | |
| 92 | - | let weighted_sum35 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[34][0]) + (input[1] * weights[34][1])) + (input[2] * weights[34][2])) + (input[3] * weights[34][3])) + (input[4] * weights[34][4])) + (input[5] * weights[34][5])) + (input[6] * weights[34][6])) + (input[7] * weights[34][7])) + (input[8] * weights[34][8])) + (input[9] * weights[34][9])) + (input[10] * weights[34][10])) + (input[11] * weights[34][11])) + (input[12] * weights[34][12])) + (input[13] * weights[34][13])) + (input[14] * weights[34][14])) + (input[15] * weights[34][15])) + (input[16] * weights[34][16])) + (input[17] * weights[34][17])) + (input[18] * weights[34][18])) + (input[19] * weights[34][19])) + (input[20] * weights[34][20])) + (input[21] * weights[34][21])) + (input[22] * weights[34][22])) + (input[23] * weights[34][23])) + (input[24] * weights[34][24])) + (input[25] * weights[34][25])) + (input[26] * weights[34][26])) + (input[27] * weights[34][27])) + (input[28] * weights[34][28])) + (input[29] * weights[34][29])) + (input[30] * weights[34][30])) + (input[31] * weights[34][31])) + (input[32] * weights[34][32])) + (input[33] * weights[34][33])) + (input[34] * weights[34][34])) + (input[35] * weights[34][35])) / 10000) + biases[34]) | |
| 93 | - | let weighted_sum36 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[35][0]) + (input[1] * weights[35][1])) + (input[2] * weights[35][2])) + (input[3] * weights[35][3])) + (input[4] * weights[35][4])) + (input[5] * weights[35][5])) + (input[6] * weights[35][6])) + (input[7] * weights[35][7])) + (input[8] * weights[35][8])) + (input[9] * weights[35][9])) + (input[10] * weights[35][10])) + (input[11] * weights[35][11])) + (input[12] * weights[35][12])) + (input[13] * weights[35][13])) + (input[14] * weights[35][14])) + (input[15] * weights[35][15])) + (input[16] * weights[35][16])) + (input[17] * weights[35][17])) + (input[18] * weights[35][18])) + (input[19] * weights[35][19])) + (input[20] * weights[35][20])) + (input[21] * weights[35][21])) + (input[22] * weights[35][22])) + (input[23] * weights[35][23])) + (input[24] * weights[35][24])) + (input[25] * weights[35][25])) + (input[26] * weights[35][26])) + (input[27] * weights[35][27])) + (input[28] * weights[35][28])) + (input[29] * weights[35][29])) + (input[30] * weights[35][30])) + (input[31] * weights[35][31])) + (input[32] * weights[35][32])) + (input[33] * weights[35][33])) + (input[34] * weights[35][34])) + (input[35] * weights[35][35])) / 10000) + biases[35]) | |
| 94 | - | [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] | |
| 95 | 22 | } | |
| 96 | 23 | ||
| 97 | 24 | ||
| 98 | - | func linear_forward_3 (input,weights,biases) = { | |
| 99 | - | let weighted_sum1 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[0][0]) + (input[1] * weights[0][1])) + (input[2] * weights[0][2])) + (input[3] * weights[0][3])) + (input[4] * weights[0][4])) + (input[5] * weights[0][5])) + (input[6] * weights[0][6])) + (input[7] * weights[0][7])) + (input[8] * weights[0][8])) + (input[9] * weights[0][9])) + (input[10] * weights[0][10])) + (input[11] * weights[0][11])) + (input[12] * weights[0][12])) + (input[13] * weights[0][13])) + (input[14] * weights[0][14])) + (input[15] * weights[0][15])) + (input[16] * weights[0][16])) + (input[17] * weights[0][17])) + (input[18] * weights[0][18])) + (input[19] * weights[0][19])) + (input[20] * weights[0][20])) + (input[21] * weights[0][21])) + (input[22] * weights[0][22])) + (input[23] * weights[0][23])) + (input[24] * weights[0][24])) + (input[25] * weights[0][25])) + (input[26] * weights[0][26])) + (input[27] * weights[0][27])) + (input[28] * weights[0][28])) + (input[29] * weights[0][29])) + (input[30] * weights[0][30])) + (input[31] * weights[0][31])) + (input[32] * weights[0][32])) + (input[33] * weights[0][33])) + (input[34] * weights[0][34])) + (input[35] * weights[0][35])) / 10000) + biases[0]) | |
| 100 | - | let weighted_sum2 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[1][0]) + (input[1] * weights[1][1])) + (input[2] * weights[1][2])) + (input[3] * weights[1][3])) + (input[4] * weights[1][4])) + (input[5] * weights[1][5])) + (input[6] * weights[1][6])) + (input[7] * weights[1][7])) + (input[8] * weights[1][8])) + (input[9] * weights[1][9])) + (input[10] * weights[1][10])) + (input[11] * weights[1][11])) + (input[12] * weights[1][12])) + (input[13] * weights[1][13])) + (input[14] * weights[1][14])) + (input[15] * weights[1][15])) + (input[16] * weights[1][16])) + (input[17] * weights[1][17])) + (input[18] * weights[1][18])) + (input[19] * weights[1][19])) + (input[20] * weights[1][20])) + (input[21] * weights[1][21])) + (input[22] * weights[1][22])) + (input[23] * weights[1][23])) + (input[24] * weights[1][24])) + (input[25] * weights[1][25])) + (input[26] * weights[1][26])) + (input[27] * weights[1][27])) + (input[28] * weights[1][28])) + (input[29] * weights[1][29])) + (input[30] * weights[1][30])) + (input[31] * weights[1][31])) + (input[32] * weights[1][32])) + (input[33] * weights[1][33])) + (input[34] * weights[1][34])) + (input[35] * weights[1][35])) / 10000) + biases[1]) | |
| 101 | - | let weighted_sum3 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[2][0]) + (input[1] * weights[2][1])) + (input[2] * weights[2][2])) + (input[3] * weights[2][3])) + (input[4] * weights[2][4])) + (input[5] * weights[2][5])) + (input[6] * weights[2][6])) + (input[7] * weights[2][7])) + (input[8] * weights[2][8])) + (input[9] * weights[2][9])) + (input[10] * weights[2][10])) + (input[11] * weights[2][11])) + (input[12] * weights[2][12])) + (input[13] * weights[2][13])) + (input[14] * weights[2][14])) + (input[15] * weights[2][15])) + (input[16] * weights[2][16])) + (input[17] * weights[2][17])) + (input[18] * weights[2][18])) + (input[19] * weights[2][19])) + (input[20] * weights[2][20])) + (input[21] * weights[2][21])) + (input[22] * weights[2][22])) + (input[23] * weights[2][23])) + (input[24] * weights[2][24])) + (input[25] * weights[2][25])) + (input[26] * weights[2][26])) + (input[27] * weights[2][27])) + (input[28] * weights[2][28])) + (input[29] * weights[2][29])) + (input[30] * weights[2][30])) + (input[31] * weights[2][31])) + (input[32] * weights[2][32])) + (input[33] * weights[2][33])) + (input[34] * weights[2][34])) + (input[35] * weights[2][35])) / 10000) + biases[2]) | |
| 102 | - | let weighted_sum4 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[3][0]) + (input[1] * weights[3][1])) + (input[2] * weights[3][2])) + (input[3] * weights[3][3])) + (input[4] * weights[3][4])) + (input[5] * weights[3][5])) + (input[6] * weights[3][6])) + (input[7] * weights[3][7])) + (input[8] * weights[3][8])) + (input[9] * weights[3][9])) + (input[10] * weights[3][10])) + (input[11] * weights[3][11])) + (input[12] * weights[3][12])) + (input[13] * weights[3][13])) + (input[14] * weights[3][14])) + (input[15] * weights[3][15])) + (input[16] * weights[3][16])) + (input[17] * weights[3][17])) + (input[18] * weights[3][18])) + (input[19] * weights[3][19])) + (input[20] * weights[3][20])) + (input[21] * weights[3][21])) + (input[22] * weights[3][22])) + (input[23] * weights[3][23])) + (input[24] * weights[3][24])) + (input[25] * weights[3][25])) + (input[26] * weights[3][26])) + (input[27] * weights[3][27])) + (input[28] * weights[3][28])) + (input[29] * weights[3][29])) + (input[30] * weights[3][30])) + (input[31] * weights[3][31])) + (input[32] * weights[3][32])) + (input[33] * weights[3][33])) + (input[34] * weights[3][34])) + (input[35] * weights[3][35])) / 10000) + biases[3]) | |
| 103 | - | let weighted_sum5 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[4][0]) + (input[1] * weights[4][1])) + (input[2] * weights[4][2])) + (input[3] * weights[4][3])) + (input[4] * weights[4][4])) + (input[5] * weights[4][5])) + (input[6] * weights[4][6])) + (input[7] * weights[4][7])) + (input[8] * weights[4][8])) + (input[9] * weights[4][9])) + (input[10] * weights[4][10])) + (input[11] * weights[4][11])) + (input[12] * weights[4][12])) + (input[13] * weights[4][13])) + (input[14] * weights[4][14])) + (input[15] * weights[4][15])) + (input[16] * weights[4][16])) + (input[17] * weights[4][17])) + (input[18] * weights[4][18])) + (input[19] * weights[4][19])) + (input[20] * weights[4][20])) + (input[21] * weights[4][21])) + (input[22] * weights[4][22])) + (input[23] * weights[4][23])) + (input[24] * weights[4][24])) + (input[25] * weights[4][25])) + (input[26] * weights[4][26])) + (input[27] * weights[4][27])) + (input[28] * weights[4][28])) + (input[29] * weights[4][29])) + (input[30] * weights[4][30])) + (input[31] * weights[4][31])) + (input[32] * weights[4][32])) + (input[33] * weights[4][33])) + (input[34] * weights[4][34])) + (input[35] * weights[4][35])) / 10000) + biases[4]) | |
| 104 | - | let weighted_sum6 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[5][0]) + (input[1] * weights[5][1])) + (input[2] * weights[5][2])) + (input[3] * weights[5][3])) + (input[4] * weights[5][4])) + (input[5] * weights[5][5])) + (input[6] * weights[5][6])) + (input[7] * weights[5][7])) + (input[8] * weights[5][8])) + (input[9] * weights[5][9])) + (input[10] * weights[5][10])) + (input[11] * weights[5][11])) + (input[12] * weights[5][12])) + (input[13] * weights[5][13])) + (input[14] * weights[5][14])) + (input[15] * weights[5][15])) + (input[16] * weights[5][16])) + (input[17] * weights[5][17])) + (input[18] * weights[5][18])) + (input[19] * weights[5][19])) + (input[20] * weights[5][20])) + (input[21] * weights[5][21])) + (input[22] * weights[5][22])) + (input[23] * weights[5][23])) + (input[24] * weights[5][24])) + (input[25] * weights[5][25])) + (input[26] * weights[5][26])) + (input[27] * weights[5][27])) + (input[28] * weights[5][28])) + (input[29] * weights[5][29])) + (input[30] * weights[5][30])) + (input[31] * weights[5][31])) + (input[32] * weights[5][32])) + (input[33] * weights[5][33])) + (input[34] * weights[5][34])) + (input[35] * weights[5][35])) / 10000) + biases[5]) | |
| 105 | - | let weighted_sum7 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[6][0]) + (input[1] * weights[6][1])) + (input[2] * weights[6][2])) + (input[3] * weights[6][3])) + (input[4] * weights[6][4])) + (input[5] * weights[6][5])) + (input[6] * weights[6][6])) + (input[7] * weights[6][7])) + (input[8] * weights[6][8])) + (input[9] * weights[6][9])) + (input[10] * weights[6][10])) + (input[11] * weights[6][11])) + (input[12] * weights[6][12])) + (input[13] * weights[6][13])) + (input[14] * weights[6][14])) + (input[15] * weights[6][15])) + (input[16] * weights[6][16])) + (input[17] * weights[6][17])) + (input[18] * weights[6][18])) + (input[19] * weights[6][19])) + (input[20] * weights[6][20])) + (input[21] * weights[6][21])) + (input[22] * weights[6][22])) + (input[23] * weights[6][23])) + (input[24] * weights[6][24])) + (input[25] * weights[6][25])) + (input[26] * weights[6][26])) + (input[27] * weights[6][27])) + (input[28] * weights[6][28])) + (input[29] * weights[6][29])) + (input[30] * weights[6][30])) + (input[31] * weights[6][31])) + (input[32] * weights[6][32])) + (input[33] * weights[6][33])) + (input[34] * weights[6][34])) + (input[35] * weights[6][35])) / 10000) + biases[6]) | |
| 106 | - | let weighted_sum8 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[7][0]) + (input[1] * weights[7][1])) + (input[2] * weights[7][2])) + (input[3] * weights[7][3])) + (input[4] * weights[7][4])) + (input[5] * weights[7][5])) + (input[6] * weights[7][6])) + (input[7] * weights[7][7])) + (input[8] * weights[7][8])) + (input[9] * weights[7][9])) + (input[10] * weights[7][10])) + (input[11] * weights[7][11])) + (input[12] * weights[7][12])) + (input[13] * weights[7][13])) + (input[14] * weights[7][14])) + (input[15] * weights[7][15])) + (input[16] * weights[7][16])) + (input[17] * weights[7][17])) + (input[18] * weights[7][18])) + (input[19] * weights[7][19])) + (input[20] * weights[7][20])) + (input[21] * weights[7][21])) + (input[22] * weights[7][22])) + (input[23] * weights[7][23])) + (input[24] * weights[7][24])) + (input[25] * weights[7][25])) + (input[26] * weights[7][26])) + (input[27] * weights[7][27])) + (input[28] * weights[7][28])) + (input[29] * weights[7][29])) + (input[30] * weights[7][30])) + (input[31] * weights[7][31])) + (input[32] * weights[7][32])) + (input[33] * weights[7][33])) + (input[34] * weights[7][34])) + (input[35] * weights[7][35])) / 10000) + biases[7]) | |
| 107 | - | let weighted_sum9 = ((((((((((((((((((((((((((((((((((((((input[0] * weights[8][0]) + (input[1] * weights[8][1])) + (input[2] * weights[8][2])) + (input[3] * weights[8][3])) + (input[4] * weights[8][4])) + (input[5] * weights[8][5])) + (input[6] * weights[8][6])) + (input[7] * weights[8][7])) + (input[8] * weights[8][8])) + (input[9] * weights[8][9])) + (input[10] * weights[8][10])) + (input[11] * weights[8][11])) + (input[12] * weights[8][12])) + (input[13] * weights[8][13])) + (input[14] * weights[8][14])) + (input[15] * weights[8][15])) + (input[16] * weights[8][16])) + (input[17] * weights[8][17])) + (input[18] * weights[8][18])) + (input[19] * weights[8][19])) + (input[20] * weights[8][20])) + (input[21] * weights[8][21])) + (input[22] * weights[8][22])) + (input[23] * weights[8][23])) + (input[24] * weights[8][24])) + (input[25] * weights[8][25])) + (input[26] * weights[8][26])) + (input[27] * weights[8][27])) + (input[28] * weights[8][28])) + (input[29] * weights[8][29])) + (input[30] * weights[8][30])) + (input[31] * weights[8][31])) + (input[32] * weights[8][32])) + (input[33] * weights[8][33])) + (input[34] * weights[8][34])) + (input[35] * weights[8][35])) / 10000) + biases[8]) | |
| 108 | - | [weighted_sum1, weighted_sum2, weighted_sum3, weighted_sum4, weighted_sum5, weighted_sum6, weighted_sum7, weighted_sum8, weighted_sum9] | |
| 109 | - | } | |
| 25 | + | func sigmoid (input) = if ((-80000 > input)) | |
| 26 | + | then 0 | |
| 27 | + | else if ((-60000 > input)) | |
| 28 | + | then fraction((input + 80000), 125, 10000) | |
| 29 | + | else if ((-40000 > input)) | |
| 30 | + | then fraction((input + 60000), 100, 10000) | |
| 31 | + | else if ((-20000 > input)) | |
| 32 | + | then fraction((input + 40000), 75, 10000) | |
| 33 | + | else if ((0 > input)) | |
| 34 | + | then fraction((input + 20000), 50, 10000) | |
| 35 | + | else if ((20000 > input)) | |
| 36 | + | then (fraction(input, 50, 10000) + 5000) | |
| 37 | + | else if ((40000 > input)) | |
| 38 | + | then (fraction((input - 20000), 75, 10000) + 7500) | |
| 39 | + | else if ((60000 > input)) | |
| 40 | + | then (fraction((input - 40000), 100, 10000) + 8750) | |
| 41 | + | else if ((80000 > input)) | |
| 42 | + | then (fraction((input - 60000), 125, 10000) + 9375) | |
| 43 | + | else 10000 | |
| 110 | 44 | ||
| 111 | 45 | ||
| 112 | - | func relu (input) = if ((0 > input)) | |
| 113 | - | then 0 | |
| 114 | - | else input | |
| 115 | - | ||
| 116 | - | ||
| 117 | - | func relu_activation (inputs,num_outputs) = [relu(inputs[0]), relu(inputs[1]), relu(inputs[2]), relu(inputs[3]), relu(inputs[4]), relu(inputs[5]), relu(inputs[6]), relu(inputs[7]), relu(inputs[8]), relu(inputs[9]), relu(inputs[10]), relu(inputs[11]), relu(inputs[12]), relu(inputs[13]), relu(inputs[14]), relu(inputs[15]), relu(inputs[16]), relu(inputs[17]), relu(inputs[18]), relu(inputs[19]), relu(inputs[20]), relu(inputs[21]), relu(inputs[22]), relu(inputs[23]), relu(inputs[24]), relu(inputs[25]), relu(inputs[26]), relu(inputs[27]), relu(inputs[28]), relu(inputs[29]), relu(inputs[30]), relu(inputs[31]), relu(inputs[32]), relu(inputs[33]), relu(inputs[34]), relu(inputs[35])] | |
| 118 | - | ||
| 119 | - | ||
| 120 | - | func sigmoid (input) = if ((-100000 > input)) | |
| 121 | - | then 0 | |
| 122 | - | else if ((-80000 > input)) | |
| 123 | - | then fraction((input + 100000), 125, 10000) | |
| 124 | - | else if ((-60000 > input)) | |
| 125 | - | then fraction((input + 80000), 100, 10000) | |
| 126 | - | else if ((-40000 > input)) | |
| 127 | - | then fraction((input + 60000), 75, 10000) | |
| 128 | - | else if ((-20000 > input)) | |
| 129 | - | then fraction((input + 40000), 50, 10000) | |
| 130 | - | else if ((0 > input)) | |
| 131 | - | then fraction((input + 20000), 40, 10000) | |
| 132 | - | else if ((20000 > input)) | |
| 133 | - | then (fraction(input, 40, 10000) + 5000) | |
| 134 | - | else if ((40000 > input)) | |
| 135 | - | then (fraction((input - 20000), 50, 10000) + 7500) | |
| 136 | - | else if ((60000 > input)) | |
| 137 | - | then (fraction((input - 40000), 75, 10000) + 8750) | |
| 138 | - | else if ((80000 > input)) | |
| 139 | - | then (fraction((input - 60000), 100, 10000) + 9375) | |
| 140 | - | else if ((100000 > input)) | |
| 141 | - | then (fraction((input - 80000), 125, 10000) + 9687) | |
| 142 | - | else 10000 | |
| 143 | - | ||
| 144 | - | ||
| 145 | - | func sigmoid_activation (inputs,num_outputs) = [sigmoid(inputs[0]), sigmoid(inputs[1]), sigmoid(inputs[2]), sigmoid(inputs[3]), sigmoid(inputs[4]), sigmoid(inputs[5]), sigmoid(inputs[6]), sigmoid(inputs[7]), sigmoid(inputs[8])] | |
| 46 | + | func sigmoid_activation (inputs,num_outputs) = [sigmoid(inputs[0]), sigmoid(inputs[1])] | |
| 146 | 47 | ||
| 147 | 48 | ||
| 148 | 49 | @Callable(i) | |
| 149 | - | func predict (x1,x2,x3,x4,x5,x6,x7,x8,x9) = { | |
| 150 | - | let x1_scaled = (x1 * 10000) | |
| 151 | - | let x2_scaled = (x2 * 10000) | |
| 152 | - | let x3_scaled = (x3 * 10000) | |
| 153 | - | let x4_scaled = (x4 * 10000) | |
| 154 | - | let x5_scaled = (x5 * 10000) | |
| 155 | - | let x6_scaled = (x6 * 10000) | |
| 156 | - | let x7_scaled = (x7 * 10000) | |
| 157 | - | let x8_scaled = (x8 * 10000) | |
| 158 | - | let x9_scaled = (x9 * 10000) | |
| 159 | - | let inputs = [x1_scaled, x2_scaled, x3_scaled, x4_scaled, x5_scaled, x6_scaled, x7_scaled, x8_scaled, x9_scaled] | |
| 160 | - | let z1 = linear_forward_1(inputs, weights_layer_1, biases_layer_1) | |
| 161 | - | let a1 = relu_activation(z1, 36) | |
| 50 | + | func predict (inputs) = { | |
| 51 | + | let inputs_scaled = [(inputs[0] * 10000), (inputs[1] * 10000)] | |
| 52 | + | let z1 = linear_forward_1(inputs_scaled, weights_layer_1, biases_layer_1) | |
| 53 | + | let a1 = sigmoid_activation(z1, 2) | |
| 162 | 54 | let z2 = linear_forward_2(a1, weights_layer_2, biases_layer_2) | |
| 163 | - | let a2 = relu_activation(z2, 36) | |
| 164 | - | let z3 = linear_forward_3(a2, weights_layer_3, biases_layer_3) | |
| 165 | - | let a3 = sigmoid_activation(z3, 9) | |
| 166 | - | let result0 = a3[0] | |
| 167 | - | let result1 = a3[1] | |
| 168 | - | let result2 = a3[2] | |
| 169 | - | let result3 = a3[3] | |
| 170 | - | let result4 = a3[4] | |
| 171 | - | let result5 = a3[5] | |
| 172 | - | let result6 = a3[6] | |
| 173 | - | let result7 = a3[7] | |
| 174 | - | let result8 = a3[8] | |
| 55 | + | let a2 = sigmoid_activation(z2, 1) | |
| 56 | + | let result0 = a2[0] | |
| 175 | 57 | let debug_outputs = nil | |
| 176 | - | ([IntegerEntry("move_prediction_0", result0) | |
| 58 | + | ([IntegerEntry("move_prediction_0", result0)] ++ debug_outputs) | |
| 177 | 59 | } | |
| 178 | 60 | ||
| 179 | 61 |
github/deemru/w8io/c3f4982 178.99 ms ◑