exported_model.py

import math
import time

def relu(x):
    return max(0.0, x)

def softmax(x_list):
    if not x_list:
        return []
    m = max(x_list)
    exps = [math.exp(i - m) for i in x_list]
    s = sum(exps)
    if s == 0:
        return [1.0 / len(x_list)] * len(x_list)
    return [e / s for e in exps]

def neuron_0(inputs):
    return relu(0.41948306*inputs[0] + 0.13081274*inputs[1] + 0.20155070*inputs[2] + -0.14924237*inputs[3] + -0.01651083*inputs[4] + -0.45635546*inputs[5] + 0.76163591*inputs[6] + -0.12222538*inputs[7] + 0.64307232*inputs[8] + 0.21719413*inputs[9] + -0.10417907*inputs[10] + -0.14590349*inputs[11] + -0.10776069*inputs[12] + -0.02259848*inputs[13] + -0.17919899*inputs[14] + 0.32479935*inputs[15] + -0.04870858*inputs[16] + 0.03447852*inputs[17] + 0.20881076*inputs[18] + 0.18368160*inputs[19] + -0.60960350*inputs[20] + 0.09451720*inputs[21] + 0.18635853*inputs[22] + -0.19214314*inputs[23] + 0.09386260*inputs[24] + 0.23148885*inputs[25] + -0.01464167*inputs[26] + 0.10320259*inputs[27] + 0.14134098*inputs[28] + -0.00922694*inputs[29] + 0.05660935*inputs[30] + -0.02554113*inputs[31] + -0.19435722*inputs[32] + 0.34086217*inputs[33] + -0.20398206*inputs[34] + 0.63617500*inputs[35] + -0.08847886*inputs[36] + -0.08709808*inputs[37] + 0.23337493*inputs[38] + 0.41898014*inputs[39] + -0.29848663*inputs[40] + 0.60211757*inputs[41] + -0.34964384*inputs[42] + 1.04577516*inputs[43] + 0.89635447*inputs[44] + 0.10795583*inputs[45] + -0.29558240*inputs[46] + 0.16986610*inputs[47] + 0.68009980*inputs[48] + -0.11408999*inputs[49] + -0.13875843*inputs[50] + -0.11929138*inputs[51] + 0.32096438*inputs[52] + -0.11415236*inputs[53] + 0.96631573*inputs[54] + 0.45675884*inputs[55] + -0.04169060*inputs[56] + 0.15122634*inputs[57] + -0.04286146*inputs[58] + -0.34742785*inputs[59] + 1.44500416*inputs[60] + 0.12702003*inputs[61] + 0.15253972*inputs[62] + -0.07615039*inputs[63] + 1.87867205)

def neuron_1(inputs):
    return relu(0.21139046*inputs[0] + 0.27389612*inputs[1] + 1.08254070*inputs[2] + 0.39374460*inputs[3] + 0.11136982*inputs[4] + -0.21598576*inputs[5] + -0.16547468*inputs[6] + 0.06098899*inputs[7] + 0.19687091*inputs[8] + -0.11915731*inputs[9] + 0.32361193*inputs[10] + 0.24199308*inputs[11] + 0.23844488*inputs[12] + -0.13501921*inputs[13] + -0.54224338*inputs[14] + -0.11955857*inputs[15] + 1.89788332*inputs[16] + -0.11503565*inputs[17] + -0.40089712*inputs[18] + 0.37461847*inputs[19] + -0.28837420*inputs[20] + -0.07814604*inputs[21] + 0.21841119*inputs[22] + 0.25211899*inputs[23] + 0.16952698*inputs[24] + -0.25989111*inputs[25] + 0.11812256*inputs[26] + -0.16767870*inputs[27] + 0.18585367*inputs[28] + -0.27984586*inputs[29] + 0.75856852*inputs[30] + -0.19468204*inputs[31] + 0.55345285*inputs[32] + -0.20044089*inputs[33] + -0.01702985*inputs[34] + 0.00127312*inputs[35] + -0.20129072*inputs[36] + 0.02491476*inputs[37] + 0.18213653*inputs[38] + 0.00001521*inputs[39] + 0.07916465*inputs[40] + 0.03828374*inputs[41] + -0.23662493*inputs[42] + 0.20028526*inputs[43] + -0.34569243*inputs[44] + -0.21936307*inputs[45] + -0.21871037*inputs[46] + -0.38201506*inputs[47] + 0.28231961*inputs[48] + -0.03242607*inputs[49] + -0.15276043*inputs[50] + -0.22149866*inputs[51] + -0.07858260*inputs[52] + -0.37545997*inputs[53] + 0.65224538*inputs[54] + 0.75756802*inputs[55] + 0.34472957*inputs[56] + 0.31923743*inputs[57] + 0.42549610*inputs[58] + 0.63391685*inputs[59] + 1.36205186*inputs[60] + 0.23899548*inputs[61] + -0.19103286*inputs[62] + -0.23949056*inputs[63] + 1.79191195)

def neuron_2(inputs):
    return relu(-0.12641090*inputs[0] + 0.06380141*inputs[1] + -0.11027689*inputs[2] + -0.04135416*inputs[3] + -0.11165066*inputs[4] + 0.08129042*inputs[5] + 0.03340575*inputs[6] + 0.27824901*inputs[7] + 0.03618834*inputs[8] + 0.18724900*inputs[9] + 0.21919244*inputs[10] + 0.22840102*inputs[11] + -0.14376133*inputs[12] + 0.07374869*inputs[13] + 0.13332817*inputs[14] + 0.12448197*inputs[15] + -0.51269902*inputs[16] + 0.14363288*inputs[17] + 0.50433140*inputs[18] + -0.34121036*inputs[19] + -0.07152814*inputs[20] + 0.61652457*inputs[21] + -0.04332111*inputs[22] + 0.05592501*inputs[23] + -0.18253820*inputs[24] + 0.07481686*inputs[25] + 0.30378064*inputs[26] + -0.09057421*inputs[27] + -0.20658633*inputs[28] + 0.46691170*inputs[29] + -0.11260351*inputs[30] + 0.33425374*inputs[31] + -0.05528583*inputs[32] + -0.15192972*inputs[33] + -0.14693536*inputs[34] + 0.47775489*inputs[35] + 0.47031039*inputs[36] + 0.28139298*inputs[37] + 0.24923237*inputs[38] + 0.36541666*inputs[39] + 0.26246858*inputs[40] + 0.30103908*inputs[41] + -0.37355871*inputs[42] + 0.54514279*inputs[43] + 0.23879805*inputs[44] + -0.11256509*inputs[45] + 0.21323837*inputs[46] + -0.32160516*inputs[47] + 0.43882249*inputs[48] + 0.16833162*inputs[49] + -0.05013913*inputs[50] + -0.16901855*inputs[51] + -0.03980127*inputs[52] + 0.11624863*inputs[53] + -0.06856158*inputs[54] + -0.27801301*inputs[55] + 0.23179649*inputs[56] + 0.50153726*inputs[57] + -0.15673880*inputs[58] + -0.09274408*inputs[59] + -0.53881102*inputs[60] + 0.06198033*inputs[61] + -0.27498812*inputs[62] + 0.15753582*inputs[63] + 1.00466770)

def neuron_3(inputs):
    return relu(-0.03214550*inputs[0] + -0.43523681*inputs[1] + -0.44995584*inputs[2] + -0.23111185*inputs[3] + 0.10387856*inputs[4] + -0.02823431*inputs[5] + -0.28649724*inputs[6] + 0.36297177*inputs[7] + 0.48273249*inputs[8] + 0.04621140*inputs[9] + -0.33820781*inputs[10] + -0.07338874*inputs[11] + -0.68014436*inputs[12] + 0.11786784*inputs[13] + 0.34823274*inputs[14] + 0.65819033*inputs[15] + 1.07834850*inputs[16] + -0.08368965*inputs[17] + 0.26090510*inputs[18] + -0.01859786*inputs[19] + -0.32576213*inputs[20] + 0.15753000*inputs[21] + -0.08317560*inputs[22] + 0.38394546*inputs[23] + 0.17029409*inputs[24] + 0.17143471*inputs[25] + -0.18024548*inputs[26] + -0.02796511*inputs[27] + -0.11690137*inputs[28] + 0.39988255*inputs[29] + -0.21333832*inputs[30] + 0.16997755*inputs[31] + 0.38937098*inputs[32] + 0.01708268*inputs[33] + 0.18161749*inputs[34] + -0.23689325*inputs[35] + -0.23323482*inputs[36] + -0.38021397*inputs[37] + -0.04744673*inputs[38] + 0.47961142*inputs[39] + -0.22050827*inputs[40] + 0.59800964*inputs[41] + 0.27370499*inputs[42] + -0.33115114*inputs[43] + 0.35935611*inputs[44] + 0.05965379*inputs[45] + 0.02166617*inputs[46] + -0.16507679*inputs[47] + 0.27411029*inputs[48] + 0.31247781*inputs[49] + 0.14277504*inputs[50] + 0.00741280*inputs[51] + 0.64988620*inputs[52] + -0.20015080*inputs[53] + -0.31708198*inputs[54] + -0.30079538*inputs[55] + -0.00106168*inputs[56] + 0.35567266*inputs[57] + 0.14665556*inputs[58] + -0.06862217*inputs[59] + -0.33120130*inputs[60] + -0.01923099*inputs[61] + 0.05266471*inputs[62] + 0.28555374*inputs[63] + 0.67494213)

def neuron_4(inputs):
    return relu(0.21621907*inputs[0] + 0.05019406*inputs[1] + -0.02724461*inputs[2] + -0.16104093*inputs[3] + 0.38766946*inputs[4] + -0.05579317*inputs[5] + 1.30397357*inputs[6] + 0.01322242*inputs[7] + -0.34160679*inputs[8] + -0.41480562*inputs[9] + 0.53531684*inputs[10] + 0.14841767*inputs[11] + -0.49497187*inputs[12] + 0.44863133*inputs[13] + 0.15674652*inputs[14] + 0.06935582*inputs[15] + -0.61058173*inputs[16] + 0.16616688*inputs[17] + 0.55389205*inputs[18] + 0.09248579*inputs[19] + 0.24116153*inputs[20] + 0.11048458*inputs[21] + 0.64046428*inputs[22] + -0.06388702*inputs[23] + 0.25888006*inputs[24] + 0.44604355*inputs[25] + 0.25020133*inputs[26] + 0.22361049*inputs[27] + 0.47088571*inputs[28] + -0.05248490*inputs[29] + -0.06426583*inputs[30] + -0.35071155*inputs[31] + 0.55648830*inputs[32] + 0.40442104*inputs[33] + -0.31667163*inputs[34] + 0.21778166*inputs[35] + -0.23105686*inputs[36] + -0.23080260*inputs[37] + 0.00475917*inputs[38] + 0.06396826*inputs[39] + 0.19783278*inputs[40] + 0.40263508*inputs[41] + -0.42710904*inputs[42] + 0.40048157*inputs[43] + -0.00908750*inputs[44] + 0.34356530*inputs[45] + 0.23444858*inputs[46] + 0.14211924*inputs[47] + -0.14922847*inputs[48] + 0.29483210*inputs[49] + -0.16584608*inputs[50] + -0.09613136*inputs[51] + -0.29044860*inputs[52] + -0.10356796*inputs[53] + -0.08299006*inputs[54] + -0.37856492*inputs[55] + 0.13079525*inputs[56] + -0.33313124*inputs[57] + 0.03911342*inputs[58] + -0.04204061*inputs[59] + -0.76171171*inputs[60] + 0.32436505*inputs[61] + 0.47308625*inputs[62] + 0.04187565*inputs[63] + 1.00333310)

def neuron_5(inputs):
    return relu(1.45166411*inputs[0] + -0.45832866*inputs[1] + 0.33159017*inputs[2] + -0.09773084*inputs[3] + 0.51612184*inputs[4] + 0.07821550*inputs[5] + 0.31507474*inputs[6] + -0.14596801*inputs[7] + -0.17630180*inputs[8] + 0.06111040*inputs[9] + 0.08073771*inputs[10] + -0.33535724*inputs[11] + -0.18527812*inputs[12] + -0.16224218*inputs[13] + 0.20943201*inputs[14] + 0.35570178*inputs[15] + 0.03824178*inputs[16] + 0.30761471*inputs[17] + -0.00359030*inputs[18] + 0.57660198*inputs[19] + -0.20139637*inputs[20] + -0.30018263*inputs[21] + -0.16919988*inputs[22] + -0.32101200*inputs[23] + -0.08753281*inputs[24] + 0.26662731*inputs[25] + -0.24076982*inputs[26] + -0.02449353*inputs[27] + 0.99507995*inputs[28] + -0.30861568*inputs[29] + -0.01470240*inputs[30] + 0.36147423*inputs[31] + -0.27316213*inputs[32] + 0.07238118*inputs[33] + 0.09048697*inputs[34] + -0.29912592*inputs[35] + -0.55442988*inputs[36] + -0.46521977*inputs[37] + -0.33651015*inputs[38] + 0.13418751*inputs[39] + -0.49046130*inputs[40] + -0.28457807*inputs[41] + -0.15382483*inputs[42] + 0.28862282*inputs[43] + -0.17534578*inputs[44] + -0.49533884*inputs[45] + 0.24432646*inputs[46] + -0.13527940*inputs[47] + 0.22062692*inputs[48] + -0.06899793*inputs[49] + 0.48895331*inputs[50] + 0.25185551*inputs[51] + 0.40231154*inputs[52] + 0.20572844*inputs[53] + 0.39512758*inputs[54] + 1.83692699*inputs[55] + 0.78054417*inputs[56] + -0.29908197*inputs[57] + 0.14543453*inputs[58] + 0.28977279*inputs[59] + 1.47748873*inputs[60] + -0.07790776*inputs[61] + 0.14881769*inputs[62] + 0.10493382*inputs[63] + 1.68282060)

def neuron_6(inputs):
    return relu(0.67216727*inputs[0] + -0.46417036*inputs[1] + -0.29826183*inputs[2] + 0.66750024*inputs[3] + 0.09761509*inputs[4] + -0.18808480*inputs[5] + 0.97309397*inputs[6] + -0.05221205*inputs[7] + -0.59068574*inputs[8] + 0.62033102*inputs[9] + 0.13976092*inputs[10] + 0.63285099*inputs[11] + 0.41284715*inputs[12] + -0.14317272*inputs[13] + 0.32287916*inputs[14] + -0.60779365*inputs[15] + -0.53538198*inputs[16] + -0.43667326*inputs[17] + 0.17069285*inputs[18] + -0.21118015*inputs[19] + 0.38567034*inputs[20] + 0.20619272*inputs[21] + 0.45565432*inputs[22] + -0.15193981*inputs[23] + -0.20143644*inputs[24] + -0.05774613*inputs[25] + 0.31925837*inputs[26] + 0.02112158*inputs[27] + -0.53883378*inputs[28] + -0.20378377*inputs[29] + 0.16093883*inputs[30] + -0.45968712*inputs[31] + 0.59055586*inputs[32] + 0.89072730*inputs[33] + -0.29636094*inputs[34] + 0.37396057*inputs[35] + 0.66290308*inputs[36] + 0.57441535*inputs[37] + 0.24400803*inputs[38] + 0.31415565*inputs[39] + -0.12668253*inputs[40] + 0.32504714*inputs[41] + 0.19941003*inputs[42] + 0.55484497*inputs[43] + -0.55074842*inputs[44] + 0.60815389*inputs[45] + -0.20715739*inputs[46] + -0.03468679*inputs[47] + -0.17684744*inputs[48] + 0.39341684*inputs[49] + 0.09507945*inputs[50] + -0.75726225*inputs[51] + -0.22137750*inputs[52] + -0.36398448*inputs[53] + 0.02585476*inputs[54] + 0.58460802*inputs[55] + -0.39136029*inputs[56] + 0.28308343*inputs[57] + 0.13574245*inputs[58] + 1.19218778*inputs[59] + 0.19324913*inputs[60] + 0.57733444*inputs[61] + 0.05939113*inputs[62] + -0.16911534*inputs[63] + 1.65016800)

def neuron_7(inputs):
    return relu(-0.77322673*inputs[0] + 0.14880524*inputs[1] + 0.11382665*inputs[2] + 0.02704503*inputs[3] + -0.07779972*inputs[4] + 0.64988555*inputs[5] + 0.25182299*inputs[6] + -0.03275097*inputs[7] + -0.17352641*inputs[8] + 0.04719062*inputs[9] + -0.15869264*inputs[10] + 0.33636288*inputs[11] + -0.11940098*inputs[12] + 0.30516247*inputs[13] + 0.08245742*inputs[14] + 0.30336448*inputs[15] + -0.11236729*inputs[16] + 0.08993923*inputs[17] + -0.18554776*inputs[18] + -0.04991825*inputs[19] + 0.48595014*inputs[20] + -0.19677666*inputs[21] + 0.37314071*inputs[22] + 0.97291095*inputs[23] + 0.01864144*inputs[24] + -0.00517827*inputs[25] + 0.53008506*inputs[26] + 0.00270155*inputs[27] + -0.28179023*inputs[28] + 0.57032377*inputs[29] + -0.12108328*inputs[30] + -0.06041677*inputs[31] + -0.01873187*inputs[32] + 0.42883256*inputs[33] + 0.00483285*inputs[34] + -0.15308920*inputs[35] + 0.01158303*inputs[36] + -0.10384006*inputs[37] + -0.09829809*inputs[38] + 0.00325249*inputs[39] + 0.19540068*inputs[40] + -0.12672162*inputs[41] + -0.12699071*inputs[42] + -0.12951478*inputs[43] + -0.11168987*inputs[44] + -0.17715281*inputs[45] + -0.15393515*inputs[46] + -0.11799197*inputs[47] + -0.27898077*inputs[48] + -0.10034164*inputs[49] + -0.12125057*inputs[50] + -0.17602806*inputs[51] + -0.31876760*inputs[52] + 0.12352131*inputs[53] + -0.32426017*inputs[54] + -0.51194000*inputs[55] + -0.14776611*inputs[56] + -0.19086467*inputs[57] + 0.10080001*inputs[58] + -0.12489552*inputs[59] + 1.04365862*inputs[60] + -0.21613037*inputs[61] + 1.05589702*inputs[62] + 0.14093470*inputs[63] + 0.56492257)

def neuron_8(inputs):
    return relu(0.51132742*inputs[0] + 0.19384570*inputs[1] + 0.28487024*inputs[2] + 0.82667269*inputs[3] + 0.41025713*inputs[4] + 0.19300205*inputs[5] + 0.78804504*inputs[6] + 0.53040370*inputs[7] + 0.62637219*inputs[8] + -0.04580331*inputs[9] + 0.34143702*inputs[10] + 0.86162423*inputs[11] + 0.64327906*inputs[12] + -0.45973086*inputs[13] + -0.56874837*inputs[14] + -0.16111276*inputs[15] + 0.36434655*inputs[16] + -0.21282822*inputs[17] + -0.41568281*inputs[18] + 0.13439532*inputs[19] + -0.51412520*inputs[20] + 0.62789445*inputs[21] + 0.51291513*inputs[22] + 0.41791461*inputs[23] + 0.02236928*inputs[24] + -0.26185115*inputs[25] + 0.51593897*inputs[26] + 0.15856704*inputs[27] + -0.48914910*inputs[28] + 0.40435102*inputs[29] + 0.15665054*inputs[30] + -0.33128136*inputs[31] + 0.18870503*inputs[32] + -0.02541317*inputs[33] + -0.23323077*inputs[34] + -0.11447306*inputs[35] + 0.33250054*inputs[36] + 0.33502559*inputs[37] + 0.11248976*inputs[38] + -0.27463785*inputs[39] + -0.50907139*inputs[40] + 0.05593657*inputs[41] + -0.07315797*inputs[42] + 0.03204524*inputs[43] + 0.11150194*inputs[44] + 0.27083398*inputs[45] + 0.17694483*inputs[46] + -0.03230435*inputs[47] + 0.16459092*inputs[48] + -0.29386137*inputs[49] + -0.06197685*inputs[50] + -0.18445927*inputs[51] + 0.31408853*inputs[52] + -0.12838659*inputs[53] + 1.87575840*inputs[54] + 0.89394924*inputs[55] + -0.08037814*inputs[56] + -0.15026160*inputs[57] + -0.09555396*inputs[58] + -0.01174863*inputs[59] + 1.60221328*inputs[60] + 0.57286775*inputs[61] + -0.05289582*inputs[62] + -0.12242674*inputs[63] + 2.63849079)

def neuron_9(inputs):
    return relu(0.58959461*inputs[0] + -0.01327554*inputs[1] + 0.12439145*inputs[2] + 0.21214662*inputs[3] + 0.04611828*inputs[4] + 0.49438578*inputs[5] + 1.09179966*inputs[6] + -0.07444842*inputs[7] + -0.13021719*inputs[8] + -0.24913884*inputs[9] + -0.32297096*inputs[10] + -0.23757798*inputs[11] + 1.62723694*inputs[12] + -0.25895815*inputs[13] + -0.59083930*inputs[14] + 0.44900980*inputs[15] + -0.09806208*inputs[16] + 0.23253443*inputs[17] + -0.46133221*inputs[18] + 0.09827898*inputs[19] + -0.03266010*inputs[20] + 0.65625843*inputs[21] + 0.11981774*inputs[22] + -0.57679017*inputs[23] + 0.33808697*inputs[24] + -0.11324574*inputs[25] + -0.12654935*inputs[26] + 0.13354554*inputs[27] + 0.24241290*inputs[28] + -0.26187081*inputs[29] + 0.19463421*inputs[30] + -0.56066572*inputs[31] + -0.37969599*inputs[32] + 0.57479862*inputs[33] + 0.55861109*inputs[34] + -0.28736123*inputs[35] + -0.28844618*inputs[36] + -0.37357199*inputs[37] + 0.44200814*inputs[38] + 0.14854413*inputs[39] + -0.16466925*inputs[40] + 0.04840912*inputs[41] + -0.03595479*inputs[42] + -0.11961846*inputs[43] + -0.20106698*inputs[44] + 1.07425376*inputs[45] + 0.06967852*inputs[46] + 0.23810716*inputs[47] + 0.20617926*inputs[48] + -0.11203353*inputs[49] + 0.09859053*inputs[50] + 0.04202003*inputs[51] + 0.19954894*inputs[52] + -0.14500062*inputs[53] + 0.95579142*inputs[54] + 0.90264720*inputs[55] + -0.00670663*inputs[56] + -0.30909735*inputs[57] + 0.80626038*inputs[58] + 0.23719524*inputs[59] + 1.99242114*inputs[60] + 0.19593669*inputs[61] + 0.07077648*inputs[62] + 0.44111030*inputs[63] + 2.19717665)

def neuron_10(inputs):
    return relu(-0.28192741*inputs[0] + -0.04574611*inputs[1] + -0.24631876*inputs[2] + -0.12962074*inputs[3] + -0.53879932*inputs[4] + 0.74395240*inputs[5] + 0.93158593*inputs[6] + 0.29218349*inputs[7] + 0.03832933*inputs[8] + -0.03470904*inputs[9] + -0.05145773*inputs[10] + 0.14906781*inputs[11] + 0.82687178*inputs[12] + 0.58414741*inputs[13] + 0.67319023*inputs[14] + -0.10248139*inputs[15] + -0.75461736*inputs[16] + -0.52544511*inputs[17] + 0.05652015*inputs[18] + -0.14632078*inputs[19] + -0.34154832*inputs[20] + 0.23783751*inputs[21] + 1.52081062*inputs[22] + -0.06156637*inputs[23] + 0.41122056*inputs[24] + 0.11585586*inputs[25] + 0.09169912*inputs[26] + -0.28887659*inputs[27] + -0.78453110*inputs[28] + 0.11175364*inputs[29] + -0.08888065*inputs[30] + 0.24577239*inputs[31] + 0.36371821*inputs[32] + 0.66878897*inputs[33] + 0.49091431*inputs[34] + -0.12164509*inputs[35] + 0.01586928*inputs[36] + 0.00160087*inputs[37] + -0.23519753*inputs[38] + -0.15791660*inputs[39] + 0.77579027*inputs[40] + 0.43235520*inputs[41] + 0.08075001*inputs[42] + -0.43264210*inputs[43] + 0.18048186*inputs[44] + 0.69718385*inputs[45] + 0.41184582*inputs[46] + 0.04679503*inputs[47] + 0.23534295*inputs[48] + 0.22354357*inputs[49] + 0.39430803*inputs[50] + 0.37945609*inputs[51] + -0.23328918*inputs[52] + 0.10080125*inputs[53] + 0.20694571*inputs[54] + 0.58121411*inputs[55] + 0.14743748*inputs[56] + 0.56706914*inputs[57] + -0.15454385*inputs[58] + -0.14247000*inputs[59] + 0.40360198*inputs[60] + -0.69421539*inputs[61] + 0.01555373*inputs[62] + 0.06969564*inputs[63] + 1.92207858)

def neuron_11(inputs):
    return relu(0.97681658*inputs[0] + -0.10314159*inputs[1] + -0.17397284*inputs[2] + 0.06935998*inputs[3] + 0.06364771*inputs[4] + -0.18512704*inputs[5] + 0.19906936*inputs[6] + -0.11423541*inputs[7] + 0.49825054*inputs[8] + -0.17494565*inputs[9] + 0.02726699*inputs[10] + -0.27379864*inputs[11] + -0.05244997*inputs[12] + 0.54925616*inputs[13] + 0.52225616*inputs[14] + -0.07486734*inputs[15] + 0.60895442*inputs[16] + -0.01924057*inputs[17] + -0.11117010*inputs[18] + 0.18549393*inputs[19] + 0.03199433*inputs[20] + -0.21807962*inputs[21] + 0.18049681*inputs[22] + 0.04946687*inputs[23] + 0.05310342*inputs[24] + 0.02115661*inputs[25] + -0.26123184*inputs[26] + -0.10608739*inputs[27] + 0.14854879*inputs[28] + -0.11115432*inputs[29] + -0.04141552*inputs[30] + -0.26418064*inputs[31] + -0.12147558*inputs[32] + 0.25996979*inputs[33] + 0.23022675*inputs[34] + -0.04106341*inputs[35] + -0.05105727*inputs[36] + -0.19948828*inputs[37] + 0.11138982*inputs[38] + -0.04787906*inputs[39] + 0.41335085*inputs[40] + 0.18452581*inputs[41] + -0.23228148*inputs[42] + -0.08209616*inputs[43] + 0.76351260*inputs[44] + -0.15496538*inputs[45] + -0.15179417*inputs[46] + -0.13151066*inputs[47] + -0.07291225*inputs[48] + -0.37128530*inputs[49] + -0.11231080*inputs[50] + 0.24436715*inputs[51] + -0.14771587*inputs[52] + -0.03494339*inputs[53] + 0.82327395*inputs[54] + 1.29815185*inputs[55] + 0.25645729*inputs[56] + 0.04214187*inputs[57] + -0.23875454*inputs[58] + 0.04578086*inputs[59] + 1.89043516*inputs[60] + 0.24346868*inputs[61] + -0.14620927*inputs[62] + -0.01559017*inputs[63] + 1.72011936)

def neuron_12(inputs):
    return relu(0.09127757*inputs[0] + 0.43864574*inputs[1] + 0.20417673*inputs[2] + -0.06355767*inputs[3] + 0.35029824*inputs[4] + 0.31218418*inputs[5] + 0.27088933*inputs[6] + -0.25128719*inputs[7] + -0.48366600*inputs[8] + -0.21062513*inputs[9] + 0.00732534*inputs[10] + -0.17502550*inputs[11] + 1.13515212*inputs[12] + 0.13625875*inputs[13] + -0.79510782*inputs[14] + 0.11870960*inputs[15] + -0.28243102*inputs[16] + -0.12497721*inputs[17] + 0.17723752*inputs[18] + 0.30656195*inputs[19] + 0.55735165*inputs[20] + -0.23327977*inputs[21] + -0.21784193*inputs[22] + -0.10601694*inputs[23] + 0.58689006*inputs[24] + -0.04375909*inputs[25] + 0.01222765*inputs[26] + 0.18762584*inputs[27] + 0.11775439*inputs[28] + -0.07247446*inputs[29] + -0.37684111*inputs[30] + 0.57461471*inputs[31] + -0.27573004*inputs[32] + -0.00415041*inputs[33] + -0.30136983*inputs[34] + -0.03829071*inputs[35] + -0.13932104*inputs[36] + -0.08438103*inputs[37] + 0.37279218*inputs[38] + 0.52252967*inputs[39] + 0.05699135*inputs[40] + 0.12106036*inputs[41] + -0.09059526*inputs[42] + 0.41195621*inputs[43] + -0.40996963*inputs[44] + 0.52526581*inputs[45] + -0.03693602*inputs[46] + 0.41054361*inputs[47] + 0.53493462*inputs[48] + 0.17970481*inputs[49] + -0.24575248*inputs[50] + 0.01687121*inputs[51] + -0.32583820*inputs[52] + -0.00567512*inputs[53] + 0.87440481*inputs[54] + 0.21418697*inputs[55] + -0.00620333*inputs[56] + 0.40413585*inputs[57] + -0.24210091*inputs[58] + -0.18310907*inputs[59] + 1.13204528*inputs[60] + 0.14270604*inputs[61] + 0.43388965*inputs[62] + 0.16393625*inputs[63] + 1.45373781)

def neuron_13(inputs):
    return relu(0.16425345*inputs[0] + -0.20136004*inputs[1] + -0.16666039*inputs[2] + -0.64311223*inputs[3] + -0.51365467*inputs[4] + -0.71472389*inputs[5] + -0.35534379*inputs[6] + 0.57704094*inputs[7] + 0.49289091*inputs[8] + 0.37669799*inputs[9] + 0.03943302*inputs[10] + 0.00845348*inputs[11] + 0.44176090*inputs[12] + 0.08433431*inputs[13] + 0.35229801*inputs[14] + 0.48101895*inputs[15] + -0.17705851*inputs[16] + -0.37167339*inputs[17] + -0.27843173*inputs[18] + 0.23239451*inputs[19] + -0.09133486*inputs[20] + 0.57608143*inputs[21] + -0.53246313*inputs[22] + -0.02898856*inputs[23] + -0.16806502*inputs[24] + 0.82205966*inputs[25] + -0.53391843*inputs[26] + 0.14127206*inputs[27] + -0.13312469*inputs[28] + 0.08764881*inputs[29] + 0.43875266*inputs[30] + 0.35679959*inputs[31] + 0.06146256*inputs[32] + 0.13891310*inputs[33] + 0.56757898*inputs[34] + -0.22791985*inputs[35] + -0.20005416*inputs[36] + -0.16436894*inputs[37] + 0.25940024*inputs[38] + 0.32723854*inputs[39] + -0.07883572*inputs[40] + -0.25718633*inputs[41] + 0.18072682*inputs[42] + 0.41863764*inputs[43] + 0.45913381*inputs[44] + 0.68125570*inputs[45] + -0.42008572*inputs[46] + -0.37752058*inputs[47] + 0.36485768*inputs[48] + -0.29425043*inputs[49] + -0.02950950*inputs[50] + -0.35374352*inputs[51] + -0.29719795*inputs[52] + 0.15245541*inputs[53] + 0.75460962*inputs[54] + 1.43261202*inputs[55] + 0.08353602*inputs[56] + 0.48282877*inputs[57] + -0.49463599*inputs[58] + 0.57705453*inputs[59] + 1.02994014*inputs[60] + 0.10766434*inputs[61] + -0.53867250*inputs[62] + 0.39041240*inputs[63] + 1.45619468)

def neuron_14(inputs):
    return relu(0.94053708*inputs[0] + -0.28868811*inputs[1] + -0.24668338*inputs[2] + 0.15169797*inputs[3] + 0.84534675*inputs[4] + 0.44518617*inputs[5] + 0.18348325*inputs[6] + -0.31789456*inputs[7] + 0.03356311*inputs[8] + 0.42567329*inputs[9] + -0.00436205*inputs[10] + -0.22035430*inputs[11] + 0.89976284*inputs[12] + -0.14729805*inputs[13] + -0.43435265*inputs[14] + 0.01053642*inputs[15] + -0.49692316*inputs[16] + -0.36659364*inputs[17] + -0.28017639*inputs[18] + 0.07041335*inputs[19] + -0.19927537*inputs[20] + -0.04775390*inputs[21] + 1.05875679*inputs[22] + 0.10101115*inputs[23] + -0.09054539*inputs[24] + -0.22748136*inputs[25] + 0.45629434*inputs[26] + 0.09673713*inputs[27] + 0.50572384*inputs[28] + 0.22549889*inputs[29] + -0.53264087*inputs[30] + -0.35849249*inputs[31] + 0.15071453*inputs[32] + 0.74304601*inputs[33] + 0.12518537*inputs[34] + -0.30868795*inputs[35] + 0.33099330*inputs[36] + 0.40499192*inputs[37] + 0.31340766*inputs[38] + 0.34301614*inputs[39] + -0.15481530*inputs[40] + -0.28359590*inputs[41] + 0.34505952*inputs[42] + -0.14134823*inputs[43] + -0.44724974*inputs[44] + 0.47687773*inputs[45] + -0.06158090*inputs[46] + 0.36704431*inputs[47] + 0.34557764*inputs[48] + 0.19800013*inputs[49] + -0.30134003*inputs[50] + -0.20239497*inputs[51] + -0.23092100*inputs[52] + -0.21730600*inputs[53] + 0.54587084*inputs[54] + -0.18119533*inputs[55] + -0.24630404*inputs[56] + 0.20287577*inputs[57] + -0.07091649*inputs[58] + 1.04256946*inputs[59] + -0.23454010*inputs[60] + 0.72906236*inputs[61] + 0.46490694*inputs[62] + 0.30274567*inputs[63] + 1.54016651)

def neuron_15(inputs):
    return relu(0.00003028*inputs[0] + -0.37435435*inputs[1] + 0.12894803*inputs[2] + -0.07556712*inputs[3] + -0.09423453*inputs[4] + -0.04308542*inputs[5] + 0.75833460*inputs[6] + -0.16917741*inputs[7] + -0.28142170*inputs[8] + -0.05522543*inputs[9] + -0.12697155*inputs[10] + -0.13698774*inputs[11] + 0.12625277*inputs[12] + 0.01114052*inputs[13] + 0.26010047*inputs[14] + 0.02744216*inputs[15] + -0.31788703*inputs[16] + 0.22278453*inputs[17] + 0.40207683*inputs[18] + -0.01832675*inputs[19] + -0.11926729*inputs[20] + -0.03658053*inputs[21] + 0.74958649*inputs[22] + 0.10176918*inputs[23] + -0.02132374*inputs[24] + -0.10632366*inputs[25] + -0.07071124*inputs[26] + 0.06847396*inputs[27] + -0.18344370*inputs[28] + 0.13372191*inputs[29] + 0.00747325*inputs[30] + -0.16799860*inputs[31] + 0.00804913*inputs[32] + 0.77554626*inputs[33] + 0.03746917*inputs[34] + -0.00107809*inputs[35] + 0.06102677*inputs[36] + 0.01091542*inputs[37] + -0.12699349*inputs[38] + -0.07667109*inputs[39] + -0.12826748*inputs[40] + -0.19003758*inputs[41] + -0.10150431*inputs[42] + 0.11679750*inputs[43] + 0.01057205*inputs[44] + 0.30082394*inputs[45] + 0.30485206*inputs[46] + -0.32565764*inputs[47] + -0.09715781*inputs[48] + 0.07147466*inputs[49] + 0.85001935*inputs[50] + 0.04386087*inputs[51] + 0.48803914*inputs[52] + 0.33458262*inputs[53] + -0.00057955*inputs[54] + -0.07372561*inputs[55] + 0.41601213*inputs[56] + -0.00226729*inputs[57] + 0.47603343*inputs[58] + -0.14973177*inputs[59] + 0.80273888*inputs[60] + 0.11023767*inputs[61] + -0.05299885*inputs[62] + -0.02920801*inputs[63] + 1.16788184)

def neuron_16(inputs):
    return relu(-0.18821267*inputs[0] + 0.44971589*inputs[1] + 0.05975057*inputs[2] + -0.04873256*inputs[3] + -0.15156715*inputs[4] + -0.11066632*inputs[5] + -0.07362658*inputs[6] + 0.05830186*inputs[7] + -0.19690154*inputs[8] + 0.06627509*inputs[9] + -0.02135413*inputs[10] + -0.09666940*inputs[11] + 0.04795776*inputs[12] + 0.31699239*inputs[13] + -0.20306930*inputs[14] + -0.19766879*inputs[15] + -0.02771744*inputs[16] + 0.01318471*inputs[17] + 0.14092385*inputs[18] + -0.00210269*inputs[19] + 0.37660640*inputs[20] + 0.16580326*inputs[21] + -0.12411820*inputs[22] + -0.23408519*inputs[23] + 0.03617469*inputs[24] + -0.03782014*inputs[25] + -0.01902210*inputs[26] + -0.04773467*inputs[27] + -0.05230891*inputs[28] + -0.18047991*inputs[29] + 0.38854665*inputs[30] + 0.38400482*inputs[31] + 0.02499204*inputs[32] + -0.06976553*inputs[33] + -0.01749825*inputs[34] + 0.30114624*inputs[35] + -0.10625630*inputs[36] + -0.12639180*inputs[37] + -0.04001496*inputs[38] + 0.33300874*inputs[39] + 0.15619868*inputs[40] + -0.20130810*inputs[41] + -0.24527453*inputs[42] + 0.17775000*inputs[43] + 0.01791212*inputs[44] + -0.26443731*inputs[45] + -0.05265974*inputs[46] + -0.15027364*inputs[47] + 0.43233932*inputs[48] + 0.30890784*inputs[49] + -0.11767263*inputs[50] + -0.02125741*inputs[51] + -0.27553779*inputs[52] + 0.31361621*inputs[53] + -0.12883391*inputs[54] + 0.02270641*inputs[55] + 0.07430062*inputs[56] + 0.73699038*inputs[57] + -0.03916388*inputs[58] + 0.00989893*inputs[59] + -0.15359318*inputs[60] + -0.03614109*inputs[61] + -0.12797969*inputs[62] + 0.17848476*inputs[63] + 0.41898909)

def neuron_17(inputs):
    return relu(1.15410734*inputs[0] + -0.07779309*inputs[1] + -0.10145474*inputs[2] + 0.29176618*inputs[3] + 0.14000833*inputs[4] + 1.02105038*inputs[5] + 0.18533577*inputs[6] + -0.20802311*inputs[7] + -0.20838183*inputs[8] + 0.45723805*inputs[9] + 0.15912888*inputs[10] + 0.02110274*inputs[11] + 0.01115851*inputs[12] + 0.19118023*inputs[13] + 0.34757879*inputs[14] + 0.10032001*inputs[15] + -0.37878768*inputs[16] + 0.45701832*inputs[17] + 0.01658179*inputs[18] + 0.18396233*inputs[19] + 0.31696589*inputs[20] + 0.03541876*inputs[21] + 0.65540229*inputs[22] + -0.05831605*inputs[23] + -0.26719060*inputs[24] + -0.10361077*inputs[25] + 0.05411419*inputs[26] + 0.04690108*inputs[27] + 0.26968926*inputs[28] + 0.00303721*inputs[29] + -0.11958850*inputs[30] + -0.15770674*inputs[31] + -0.06062145*inputs[32] + 0.88667037*inputs[33] + -0.28507595*inputs[34] + -0.03300085*inputs[35] + -0.14586611*inputs[36] + -0.19743376*inputs[37] + 0.00534713*inputs[38] + -0.02935539*inputs[39] + -0.14067317*inputs[40] + -0.20063016*inputs[41] + -0.04962329*inputs[42] + -0.03514703*inputs[43] + 0.10101430*inputs[44] + 0.20819020*inputs[45] + 0.49406004*inputs[46] + 0.35124279*inputs[47] + -0.28320703*inputs[48] + -0.24928146*inputs[49] + 0.18147024*inputs[50] + 0.32059608*inputs[51] + 0.03141202*inputs[52] + 0.05758862*inputs[53] + 1.13581985*inputs[54] + 1.25516432*inputs[55] + -0.36151835*inputs[56] + -0.16492110*inputs[57] + 0.32867698*inputs[58] + 0.41708420*inputs[59] + 1.25366820*inputs[60] + -0.05319340*inputs[61] + 0.21152328*inputs[62] + -0.36689061*inputs[63] + 2.19383306)

def neuron_18(inputs):
    return relu(1.07542449*inputs[0] + -0.09598688*inputs[1] + -0.16896853*inputs[2] + 0.63537311*inputs[3] + 0.14668881*inputs[4] + 0.10676660*inputs[5] + 0.07791621*inputs[6] + -0.04899442*inputs[7] + -0.26039165*inputs[8] + 0.06394278*inputs[9] + -0.45535056*inputs[10] + 0.17677881*inputs[11] + 0.20176259*inputs[12] + 0.22133819*inputs[13] + 0.06932788*inputs[14] + -0.07570140*inputs[15] + 0.91451541*inputs[16] + -0.24960971*inputs[17] + -0.17948013*inputs[18] + -0.17272442*inputs[19] + -0.13397749*inputs[20] + -0.11326547*inputs[21] + -0.01665686*inputs[22] + 0.05946684*inputs[23] + -0.19745859*inputs[24] + -0.34499178*inputs[25] + -0.19764187*inputs[26] + -0.01371926*inputs[27] + 0.02589543*inputs[28] + -0.14432634*inputs[29] + -0.11243105*inputs[30] + -0.12180943*inputs[31] + -0.34038062*inputs[32] + 1.01203416*inputs[33] + -0.10573225*inputs[34] + -0.14001702*inputs[35] + 0.29744929*inputs[36] + 0.29247279*inputs[37] + 0.07163590*inputs[38] + 0.19115289*inputs[39] + 0.11379880*inputs[40] + -0.13012154*inputs[41] + 0.06899129*inputs[42] + 0.32792945*inputs[43] + -0.21401178*inputs[44] + 0.58752785*inputs[45] + 0.30930654*inputs[46] + 0.06250926*inputs[47] + 0.13825894*inputs[48] + -0.27213177*inputs[49] + -0.23439028*inputs[50] + -0.13137228*inputs[51] + -0.13114333*inputs[52] + 0.00796540*inputs[53] + -0.16034098*inputs[54] + -0.34504365*inputs[55] + 0.04527774*inputs[56] + 0.24913566*inputs[57] + -0.09732895*inputs[58] + 0.91796100*inputs[59] + 1.30554163*inputs[60] + 0.70014599*inputs[61] + -0.28894717*inputs[62] + -0.35862780*inputs[63] + 1.00511579)

def neuron_19(inputs):
    return relu(-0.82124953*inputs[0] + -0.16425864*inputs[1] + -0.00766579*inputs[2] + 0.40955863*inputs[3] + 0.30159580*inputs[4] + -0.11441899*inputs[5] + 1.57959188*inputs[6] + 0.06879495*inputs[7] + -0.05411950*inputs[8] + 0.60054786*inputs[9] + -0.27238173*inputs[10] + 0.16737159*inputs[11] + -0.18566032*inputs[12] + 0.04655647*inputs[13] + -0.26895799*inputs[14] + -0.11043931*inputs[15] + -0.32794098*inputs[16] + -0.04512031*inputs[17] + 0.03331857*inputs[18] + -0.10743710*inputs[19] + -0.24717827*inputs[20] + -0.27816530*inputs[21] + 1.81245341*inputs[22] + 0.24729417*inputs[23] + 0.09462956*inputs[24] + 0.46716704*inputs[25] + 0.03549733*inputs[26] + 0.00336461*inputs[27] + 0.28655797*inputs[28] + 0.01979321*inputs[29] + -0.32128901*inputs[30] + 0.03935347*inputs[31] + -0.36971423*inputs[32] + 0.51146535*inputs[33] + -0.16434019*inputs[34] + 0.26911650*inputs[35] + -0.26719844*inputs[36] + -0.39446060*inputs[37] + 0.17770672*inputs[38] + 0.31755846*inputs[39] + 0.03966287*inputs[40] + 0.33990276*inputs[41] + 0.03726157*inputs[42] + 0.46442896*inputs[43] + 0.16044332*inputs[44] + -0.17496584*inputs[45] + -0.00634792*inputs[46] + 0.07659496*inputs[47] + 0.49638592*inputs[48] + -0.07322373*inputs[49] + 0.10588059*inputs[50] + -0.35768205*inputs[51] + 0.00753220*inputs[52] + -0.65600766*inputs[53] + 0.31746226*inputs[54] + 0.05117397*inputs[55] + -0.08690674*inputs[56] + 0.29198024*inputs[57] + -0.28563362*inputs[58] + 0.79581636*inputs[59] + 1.54317877*inputs[60] + -0.27976295*inputs[61] + -0.32934102*inputs[62] + -0.09030430*inputs[63] + 1.27302891)

def neuron_20(inputs):
    return relu(0.35241100*inputs[0] + 0.25584982*inputs[1] + -0.28470301*inputs[2] + 0.18323061*inputs[3] + -0.18649750*inputs[4] + 0.41807466*inputs[5] + 1.00842802*inputs[6] + 0.81304934*inputs[7] + -0.13335499*inputs[8] + 0.09796282*inputs[9] + 0.31698865*inputs[10] + 0.60939466*inputs[11] + 0.42431806*inputs[12] + -0.35784975*inputs[13] + -0.01164997*inputs[14] + -0.37805598*inputs[15] + 0.10271777*inputs[16] + 0.75297431*inputs[17] + -0.37955831*inputs[18] + -0.06601534*inputs[19] + 0.15433582*inputs[20] + 0.43712253*inputs[21] + 1.07269054*inputs[22] + 0.12969232*inputs[23] + -0.64500529*inputs[24] + 0.45014392*inputs[25] + -0.11786633*inputs[26] + -0.32404153*inputs[27] + -0.32548243*inputs[28] + 0.33828103*inputs[29] + 0.00731737*inputs[30] + -0.39548509*inputs[31] + -0.44707682*inputs[32] + 0.36625504*inputs[33] + 0.14931031*inputs[34] + -0.08453963*inputs[35] + 0.36096248*inputs[36] + 0.26810445*inputs[37] + 0.21912315*inputs[38] + -0.14747914*inputs[39] + -0.10571005*inputs[40] + 0.04912882*inputs[41] + 0.01175530*inputs[42] + -0.21084457*inputs[43] + -0.22213366*inputs[44] + 0.31180250*inputs[45] + -0.02906538*inputs[46] + -0.02573359*inputs[47] + 0.21154946*inputs[48] + -0.30690170*inputs[49] + 0.01966300*inputs[50] + 0.24348424*inputs[51] + 0.01751635*inputs[52] + -0.11676141*inputs[53] + -0.12938913*inputs[54] + 1.70500449*inputs[55] + -0.06707273*inputs[56] + 0.22025250*inputs[57] + 0.62002850*inputs[58] + -0.29734835*inputs[59] + 0.76261110*inputs[60] + -0.20843738*inputs[61] + -0.29030537*inputs[62] + -0.33034733*inputs[63] + 1.67900623)

def neuron_21(inputs):
    return relu(-0.25988854*inputs[0] + -0.18515525*inputs[1] + 0.04949605*inputs[2] + -0.17451086*inputs[3] + 0.09012635*inputs[4] + -0.21034515*inputs[5] + 0.86546107*inputs[6] + -0.14341640*inputs[7] + -0.46053655*inputs[8] + -0.12819894*inputs[9] + -0.15173679*inputs[10] + 0.24296721*inputs[11] + 0.54006216*inputs[12] + 0.79055678*inputs[13] + 0.73469025*inputs[14] + 0.57425261*inputs[15] + 0.19274407*inputs[16] + -0.07261973*inputs[17] + 0.17045387*inputs[18] + 0.22306244*inputs[19] + -0.29722476*inputs[20] + -0.30741439*inputs[21] + 0.49765485*inputs[22] + -0.27607215*inputs[23] + 0.21103656*inputs[24] + 0.15662599*inputs[25] + 0.24673351*inputs[26] + 0.16038831*inputs[27] + -0.48063376*inputs[28] + -0.55768353*inputs[29] + 0.27557313*inputs[30] + 0.13371683*inputs[31] + 0.57070335*inputs[32] + 1.11512148*inputs[33] + 0.51307433*inputs[34] + -0.40297802*inputs[35] + 0.37784102*inputs[36] + 0.36515133*inputs[37] + -0.20121041*inputs[38] + -0.01635300*inputs[39] + 0.27987386*inputs[40] + 0.03478123*inputs[41] + -0.17731671*inputs[42] + -0.23139346*inputs[43] + -0.51857990*inputs[44] + 0.38207523*inputs[45] + 0.52876571*inputs[46] + 0.31522890*inputs[47] + -0.31563229*inputs[48] + 0.14624207*inputs[49] + -0.13242484*inputs[50] + 0.20384063*inputs[51] + 0.58763677*inputs[52] + -0.15996895*inputs[53] + 0.66597043*inputs[54] + -0.43790991*inputs[55] + 0.25956622*inputs[56] + -0.60477802*inputs[57] + -0.64814799*inputs[58] + 0.94428612*inputs[59] + 0.80806806*inputs[60] + 0.40013774*inputs[61] + -0.73798300*inputs[62] + 0.43085723*inputs[63] + 1.83361096)

def neuron_22(inputs):
    return relu(0.51601889*inputs[0] + 0.51316723*inputs[1] + 0.30657240*inputs[2] + 0.02022042*inputs[3] + -0.49888139*inputs[4] + -0.35815285*inputs[5] + -0.08238931*inputs[6] + -0.15977018*inputs[7] + 0.12071455*inputs[8] + -0.32066346*inputs[9] + 0.43393769*inputs[10] + 0.07375077*inputs[11] + 1.02398560*inputs[12] + 0.27494713*inputs[13] + 0.68373545*inputs[14] + -0.06652824*inputs[15] + -0.54881932*inputs[16] + 0.37884865*inputs[17] + 0.16596498*inputs[18] + -0.14487568*inputs[19] + 0.62393769*inputs[20] + 0.21583217*inputs[21] + 0.92970618*inputs[22] + 0.05672650*inputs[23] + -0.44870168*inputs[24] + 0.20069652*inputs[25] + 0.11203099*inputs[26] + -0.04116120*inputs[27] + -0.53783044*inputs[28] + -0.47681029*inputs[29] + 0.54142130*inputs[30] + 0.00258181*inputs[31] + -0.10236683*inputs[32] + -0.23976838*inputs[33] + 0.48075251*inputs[34] + 0.32667846*inputs[35] + -0.04778267*inputs[36] + -0.15573618*inputs[37] + 0.15635471*inputs[38] + -0.16604550*inputs[39] + 0.46456573*inputs[40] + 0.18172217*inputs[41] + -0.17239066*inputs[42] + -0.16713629*inputs[43] + 0.20084607*inputs[44] + 0.23402642*inputs[45] + -0.00653457*inputs[46] + -0.26384026*inputs[47] + -0.09594702*inputs[48] + 0.44600921*inputs[49] + 0.01988351*inputs[50] + 0.15284107*inputs[51] + -0.56642408*inputs[52] + 0.37352617*inputs[53] + 1.35934754*inputs[54] + 1.38604931*inputs[55] + 0.68066198*inputs[56] + 0.00603451*inputs[57] + 0.13669339*inputs[58] + 0.40778670*inputs[59] + 1.90323581*inputs[60] + -0.47637688*inputs[61] + 0.34088916*inputs[62] + 0.50334753*inputs[63] + 2.52142938)

def neuron_23(inputs):
    return relu(-0.80710909*inputs[0] + -0.04805249*inputs[1] + 0.56585599*inputs[2] + 0.25874200*inputs[3] + -0.05800531*inputs[4] + -0.09807319*inputs[5] + -0.30754830*inputs[6] + -0.39568898*inputs[7] + 0.17398508*inputs[8] + 0.44434747*inputs[9] + -0.05035965*inputs[10] + -0.15595956*inputs[11] + -0.03518204*inputs[12] + 0.09136455*inputs[13] + 0.12190741*inputs[14] + 0.16634695*inputs[15] + 0.36123373*inputs[16] + -0.20325861*inputs[17] + -0.06838788*inputs[18] + 0.50368026*inputs[19] + 0.41327281*inputs[20] + -0.69689722*inputs[21] + -0.35006581*inputs[22] + 0.37760401*inputs[23] + 0.47692877*inputs[24] + -0.24167851*inputs[25] + 0.22591366*inputs[26] + 0.01475411*inputs[27] + 0.30963430*inputs[28] + -0.27622771*inputs[29] + 0.44403072*inputs[30] + 0.37059122*inputs[31] + 0.41347136*inputs[32] + -0.51062355*inputs[33] + 0.05241466*inputs[34] + -0.18123427*inputs[35] + 0.31910694*inputs[36] + 0.52311565*inputs[37] + -0.20876146*inputs[38] + 0.26887388*inputs[39] + 0.18644871*inputs[40] + -0.05926489*inputs[41] + 0.31127307*inputs[42] + 0.08936662*inputs[43] + -0.26848856*inputs[44] + 0.05737175*inputs[45] + 0.10233513*inputs[46] + -0.27673801*inputs[47] + 0.18572347*inputs[48] + 0.20413727*inputs[49] + 0.36302525*inputs[50] + 0.14704187*inputs[51] + 0.05350416*inputs[52] + -0.35068199*inputs[53] + -0.12676516*inputs[54] + 0.62051692*inputs[55] + 0.30785732*inputs[56] + 0.39847643*inputs[57] + 0.57506707*inputs[58] + 0.32657648*inputs[59] + -0.70436619*inputs[60] + 0.61602554*inputs[61] + 0.06930018*inputs[62] + 0.05715450*inputs[63] + 1.00826625)

def neuron_24(inputs):
    return relu(1.97346177*inputs[0] + -0.32675732*inputs[1] + 0.02324436*inputs[2] + 0.08678730*inputs[3] + 0.86214633*inputs[4] + -0.01639453*inputs[5] + 0.52895072*inputs[6] + -0.39582164*inputs[7] + -0.41782587*inputs[8] + -0.12755308*inputs[9] + -0.31854017*inputs[10] + 0.45591493*inputs[11] + 0.69118268*inputs[12] + -0.33652656*inputs[13] + -0.24167955*inputs[14] + 0.23532622*inputs[15] + 0.68594541*inputs[16] + -0.18111360*inputs[17] + -0.08432926*inputs[18] + -0.58565582*inputs[19] + 0.00925738*inputs[20] + 0.28249689*inputs[21] + 0.50964082*inputs[22] + -0.37115980*inputs[23] + -0.06334975*inputs[24] + -0.47744103*inputs[25] + 0.58477019*inputs[26] + 0.04664588*inputs[27] + 0.13816789*inputs[28] + 0.13625404*inputs[29] + -0.38295505*inputs[30] + -0.29954350*inputs[31] + 0.44903662*inputs[32] + 0.78808129*inputs[33] + 0.16702774*inputs[34] + -0.45705417*inputs[35] + 0.43270730*inputs[36] + 0.26239346*inputs[37] + 0.23008371*inputs[38] + -0.06449209*inputs[39] + 0.49764193*inputs[40] + -0.37679926*inputs[41] + 0.40044366*inputs[42] + -0.06861575*inputs[43] + 0.11441453*inputs[44] + 0.71839703*inputs[45] + 0.04444808*inputs[46] + 0.23937518*inputs[47] + -0.14459508*inputs[48] + -0.17638053*inputs[49] + -0.08378870*inputs[50] + 0.40168480*inputs[51] + -0.52050275*inputs[52] + 0.18634763*inputs[53] + 0.10352961*inputs[54] + -1.40669241*inputs[55] + -0.01551852*inputs[56] + -0.12450449*inputs[57] + -0.05794617*inputs[58] + -0.91039932*inputs[59] + 0.41404555*inputs[60] + 0.88367861*inputs[61] + 0.49411564*inputs[62] + 0.22291094*inputs[63] + 1.25853557)

def neuron_25(inputs):
    return relu(0.06141015*inputs[0] + -0.30892191*inputs[1] + 0.17169039*inputs[2] + 0.26124502*inputs[3] + 0.24667361*inputs[4] + 1.12928357*inputs[5] + -0.01042613*inputs[6] + -0.09643851*inputs[7] + -0.15460153*inputs[8] + 0.19706594*inputs[9] + 0.25105262*inputs[10] + 0.45705947*inputs[11] + 0.36915970*inputs[12] + -0.23627188*inputs[13] + 0.05407880*inputs[14] + 0.16741130*inputs[15] + -0.52692975*inputs[16] + -0.06219759*inputs[17] + 0.43355369*inputs[18] + 0.09261353*inputs[19] + -0.02482776*inputs[20] + 0.21277176*inputs[21] + 0.53607067*inputs[22] + -0.10249862*inputs[23] + -0.15899726*inputs[24] + -0.01128337*inputs[25] + 0.13118254*inputs[26] + -0.15227895*inputs[27] + 0.33319158*inputs[28] + -0.11478696*inputs[29] + 0.14884023*inputs[30] + -0.47595241*inputs[31] + 0.29714699*inputs[32] + -0.22558369*inputs[33] + -0.26128274*inputs[34] + 0.34480839*inputs[35] + -0.09074284*inputs[36] + -0.03971802*inputs[37] + -0.04096753*inputs[38] + -0.03511061*inputs[39] + -0.13216320*inputs[40] + 0.14290318*inputs[41] + -0.09251621*inputs[42] + -0.45377684*inputs[43] + 0.29904662*inputs[44] + -0.28685603*inputs[45] + 0.79246632*inputs[46] + 0.25871501*inputs[47] + -0.01224481*inputs[48] + 0.40920705*inputs[49] + -0.10276945*inputs[50] + 0.69013209*inputs[51] + -0.23091707*inputs[52] + -0.00252230*inputs[53] + 0.44405225*inputs[54] + -0.21545250*inputs[55] + 0.19545928*inputs[56] + -0.07218537*inputs[57] + 0.31899031*inputs[58] + -0.14378222*inputs[59] + -1.24338635*inputs[60] + 0.21426236*inputs[61] + -0.31583539*inputs[62] + 0.12367492*inputs[63] + 0.93868651)

def neuron_26(inputs):
    return relu(0.31092817*inputs[0] + -0.26701382*inputs[1] + 0.61395681*inputs[2] + -0.53599183*inputs[3] + 0.26459598*inputs[4] + -0.19891832*inputs[5] + 0.38385598*inputs[6] + 0.06690135*inputs[7] + 0.00675202*inputs[8] + 0.49914728*inputs[9] + 0.39955864*inputs[10] + 0.60696184*inputs[11] + -0.25820916*inputs[12] + -0.38059376*inputs[13] + 0.34335641*inputs[14] + 0.01483439*inputs[15] + 0.75757372*inputs[16] + 0.03328107*inputs[17] + 0.36026174*inputs[18] + -0.11285215*inputs[19] + 0.11348247*inputs[20] + -0.03767381*inputs[21] + 1.14867258*inputs[22] + -0.13165414*inputs[23] + -0.57212742*inputs[24] + 0.17871067*inputs[25] + 0.40704868*inputs[26] + -0.23451077*inputs[27] + 0.51360731*inputs[28] + -0.21468706*inputs[29] + 0.59557574*inputs[30] + -0.12243558*inputs[31] + 0.71468122*inputs[32] + -0.05240887*inputs[33] + 0.12428664*inputs[34] + 0.07936574*inputs[35] + -0.45499861*inputs[36] + -0.17846820*inputs[37] + 0.01816792*inputs[38] + -0.15901895*inputs[39] + -0.10000488*inputs[40] + 0.10412955*inputs[41] + 0.52628920*inputs[42] + -0.05865780*inputs[43] + 0.30100888*inputs[44] + 0.19686029*inputs[45] + -0.13865623*inputs[46] + -0.12133798*inputs[47] + -0.27967093*inputs[48] + 0.28771906*inputs[49] + 0.04846221*inputs[50] + -0.04821701*inputs[51] + 0.22042648*inputs[52] + 0.49587062*inputs[53] + -0.72965549*inputs[54] + -0.10709594*inputs[55] + -0.06824622*inputs[56] + 0.08587597*inputs[57] + 0.07465455*inputs[58] + -0.72606202*inputs[59] + -0.24787593*inputs[60] + -0.15492598*inputs[61] + -0.69264860*inputs[62] + -0.26722790*inputs[63] + 0.69407862)

def neuron_27(inputs):
    return relu(-0.62758180*inputs[0] + 0.41830995*inputs[1] + 0.16452204*inputs[2] + 0.02487940*inputs[3] + 0.20237157*inputs[4] + 0.02027316*inputs[5] + 1.23164589*inputs[6] + 0.73142381*inputs[7] + -0.67214979*inputs[8] + -0.25240471*inputs[9] + -0.19501924*inputs[10] + 0.52420162*inputs[11] + 0.52544281*inputs[12] + -0.15713975*inputs[13] + 0.25586638*inputs[14] + 0.13352835*inputs[15] + 1.14698714*inputs[16] + 0.61999034*inputs[17] + 0.23481977*inputs[18] + 0.06287487*inputs[19] + -0.02530494*inputs[20] + 0.09610990*inputs[21] + 0.93046299*inputs[22] + 0.22284605*inputs[23] + -0.34966073*inputs[24] + 0.27239748*inputs[25] + 0.33069372*inputs[26] + 0.17596974*inputs[27] + -0.55607927*inputs[28] + 0.45319573*inputs[29] + -0.02712203*inputs[30] + 0.09582383*inputs[31] + -0.01251785*inputs[32] + 0.46864953*inputs[33] + 0.08767882*inputs[34] + -0.14838396*inputs[35] + 0.22619238*inputs[36] + 0.31317365*inputs[37] + 0.27889343*inputs[38] + -0.17815298*inputs[39] + -0.16159929*inputs[40] + -0.31588176*inputs[41] + 0.06274938*inputs[42] + -0.12060187*inputs[43] + -0.08671253*inputs[44] + 0.32671207*inputs[45] + 0.03622401*inputs[46] + 0.25505423*inputs[47] + 0.12638193*inputs[48] + -0.17304793*inputs[49] + -0.22543850*inputs[50] + 0.17488980*inputs[51] + 0.32901087*inputs[52] + -0.00952327*inputs[53] + 0.11667166*inputs[54] + -0.40916312*inputs[55] + -0.30836697*inputs[56] + -0.38554948*inputs[57] + -0.15152814*inputs[58] + -0.26131448*inputs[59] + -0.42232517*inputs[60] + 0.58275042*inputs[61] + -0.31069407*inputs[62] + 0.11723782*inputs[63] + 1.33083893)

def neuron_28(inputs):
    return relu(0.76579074*inputs[0] + 1.07213330*inputs[1] + -0.35788762*inputs[2] + 0.39487414*inputs[3] + -0.07106883*inputs[4] + -0.14966425*inputs[5] + 0.57593417*inputs[6] + -0.26216921*inputs[7] + -0.05104041*inputs[8] + 0.07763490*inputs[9] + -0.40076784*inputs[10] + -0.07383174*inputs[11] + -0.25067968*inputs[12] + 0.62144711*inputs[13] + 0.29274791*inputs[14] + 0.28947999*inputs[15] + 0.90025013*inputs[16] + -0.14740460*inputs[17] + 0.21763559*inputs[18] + -0.44136208*inputs[19] + 0.23702487*inputs[20] + 0.17750017*inputs[21] + 0.86907026*inputs[22] + -0.02253449*inputs[23] + 0.50758425*inputs[24] + -0.34335706*inputs[25] + -0.39729969*inputs[26] + -0.13866862*inputs[27] + 0.29571666*inputs[28] + 0.03078768*inputs[29] + -0.00133681*inputs[30] + 1.00156862*inputs[31] + -0.54239297*inputs[32] + 1.50397836*inputs[33] + 0.25877905*inputs[34] + 0.08482402*inputs[35] + 0.18347082*inputs[36] + 0.18639614*inputs[37] + -0.52434108*inputs[38] + -0.49558848*inputs[39] + 0.15527384*inputs[40] + -0.54649977*inputs[41] + -0.18082555*inputs[42] + 0.15148382*inputs[43] + -0.53911107*inputs[44] + 0.32716802*inputs[45] + -0.12367890*inputs[46] + -0.22188446*inputs[47] + -0.15988001*inputs[48] + 0.18751297*inputs[49] + -0.43359303*inputs[50] + 0.00322548*inputs[51] + 0.07354892*inputs[52] + 0.67309471*inputs[53] + -0.85754466*inputs[54] + 0.45059287*inputs[55] + -0.43865039*inputs[56] + 0.17387114*inputs[57] + -0.55557398*inputs[58] + 0.15973764*inputs[59] + 0.62610694*inputs[60] + 0.13600044*inputs[61] + 0.20427225*inputs[62] + -0.09953405*inputs[63] + 1.17338410)

def neuron_29(inputs):
    return relu(0.16262656*inputs[0] + -0.01388308*inputs[1] + -0.18757411*inputs[2] + -0.32745642*inputs[3] + 0.01131002*inputs[4] + 0.31233177*inputs[5] + 0.00460051*inputs[6] + 0.71602622*inputs[7] + 0.61603281*inputs[8] + -0.18218495*inputs[9] + -0.13976307*inputs[10] + -0.02776540*inputs[11] + 0.09889212*inputs[12] + 0.15890511*inputs[13] + -0.25927090*inputs[14] + -0.02786659*inputs[15] + 0.65472896*inputs[16] + 0.08787013*inputs[17] + 0.25609280*inputs[18] + -0.19749449*inputs[19] + -0.22054450*inputs[20] + 0.17389400*inputs[21] + -0.14561036*inputs[22] + 0.16315332*inputs[23] + 0.51922582*inputs[24] + 0.22416406*inputs[25] + -0.04515969*inputs[26] + -0.09431147*inputs[27] + -0.25985772*inputs[28] + 0.00690208*inputs[29] + 0.27094000*inputs[30] + -0.19244236*inputs[31] + -0.30107848*inputs[32] + -0.06468492*inputs[33] + -0.05018775*inputs[34] + 0.22947734*inputs[35] + -0.14788337*inputs[36] + -0.21923260*inputs[37] + 0.16357392*inputs[38] + -0.08605468*inputs[39] + -0.09796674*inputs[40] + 0.53344358*inputs[41] + -0.25131521*inputs[42] + -0.16463200*inputs[43] + 0.28674458*inputs[44] + -0.45490272*inputs[45] + 0.41898161*inputs[46] + 0.18375749*inputs[47] + 0.27816135*inputs[48] + 0.04522456*inputs[49] + 0.36239743*inputs[50] + 0.33128718*inputs[51] + 0.38108612*inputs[52] + -0.25110257*inputs[53] + -0.05196624*inputs[54] + -0.48116657*inputs[55] + 0.01243061*inputs[56] + 0.12300135*inputs[57] + 0.55830938*inputs[58] + -0.08689326*inputs[59] + -0.48043810*inputs[60] + -0.13286880*inputs[61] + -0.47868727*inputs[62] + 0.09917927*inputs[63] + 0.67299756)

def neuron_30(inputs):
    return relu(-0.60714970*inputs[0] + -0.20485468*inputs[1] + -0.05288954*inputs[2] + -0.08372582*inputs[3] + 0.50941620*inputs[4] + -0.17736244*inputs[5] + 0.97015828*inputs[6] + 0.42433757*inputs[7] + -0.58813388*inputs[8] + -0.06298411*inputs[9] + -0.00216684*inputs[10] + 0.05861600*inputs[11] + 0.88565363*inputs[12] + 0.03724591*inputs[13] + -0.49725383*inputs[14] + -0.06006708*inputs[15] + 0.06955324*inputs[16] + -0.01023813*inputs[17] + -0.37831361*inputs[18] + 0.20816203*inputs[19] + -0.23217403*inputs[20] + -0.03265778*inputs[21] + 1.87281520*inputs[22] + 0.17221561*inputs[23] + 0.51465443*inputs[24] + -0.10475421*inputs[25] + 0.23700868*inputs[26] + 0.19820592*inputs[27] + 0.34255680*inputs[28] + 0.75745207*inputs[29] + -0.34952348*inputs[30] + -0.32506122*inputs[31] + -0.02128623*inputs[32] + 1.30038819*inputs[33] + 0.08744361*inputs[34] + 0.02642072*inputs[35] + 0.43749029*inputs[36] + 0.54428325*inputs[37] + 0.06491792*inputs[38] + -0.08343441*inputs[39] + 0.21476707*inputs[40] + -0.05704801*inputs[41] + -0.04163307*inputs[42] + -0.20232825*inputs[43] + -0.26703027*inputs[44] + 1.55685945*inputs[45] + -0.26592002*inputs[46] + -0.18871981*inputs[47] + 0.15082295*inputs[48] + -0.38365506*inputs[49] + 0.48496382*inputs[50] + -0.44828280*inputs[51] + 0.33282573*inputs[52] + -0.20323415*inputs[53] + -0.12131382*inputs[54] + -0.62226552*inputs[55] + -0.15768696*inputs[56] + -0.20921168*inputs[57] + 0.63276194*inputs[58] + 0.50028916*inputs[59] + -0.15085722*inputs[60] + 0.03516442*inputs[61] + -0.10490563*inputs[62] + -0.22098842*inputs[63] + 1.49655569)

def neuron_31(inputs):
    return relu(-0.31046722*inputs[0] + 0.16359850*inputs[1] + -0.30979301*inputs[2] + -0.27989082*inputs[3] + -0.27757754*inputs[4] + -0.03128934*inputs[5] + 1.02784239*inputs[6] + 0.08388782*inputs[7] + -0.10595057*inputs[8] + 0.02424103*inputs[9] + 0.72198627*inputs[10] + 0.14595284*inputs[11] + 0.38996844*inputs[12] + 0.33546717*inputs[13] + -0.08391883*inputs[14] + -0.23134692*inputs[15] + -0.54093080*inputs[16] + 0.34439727*inputs[17] + 0.11551880*inputs[18] + 0.15934647*inputs[19] + 0.04354016*inputs[20] + 0.37937838*inputs[21] + 1.59786503*inputs[22] + -0.21127094*inputs[23] + 0.14892332*inputs[24] + 0.33346452*inputs[25] + -0.08752883*inputs[26] + 0.01636426*inputs[27] + 0.37263532*inputs[28] + -0.26263139*inputs[29] + 0.63894885*inputs[30] + -0.10063451*inputs[31] + 0.18239450*inputs[32] + 1.29278486*inputs[33] + -0.07422777*inputs[34] + 0.33388831*inputs[35] + 0.13609401*inputs[36] + 0.15785765*inputs[37] + -0.08296833*inputs[38] + -0.32091498*inputs[39] + 0.39303837*inputs[40] + 0.50848771*inputs[41] + 0.16191758*inputs[42] + -0.25777044*inputs[43] + 0.64514711*inputs[44] + 1.33314926*inputs[45] + 0.02785624*inputs[46] + -0.03302943*inputs[47] + -0.27694005*inputs[48] + -0.80379050*inputs[49] + 0.21564923*inputs[50] + -0.04611074*inputs[51] + 0.01357233*inputs[52] + -0.26727513*inputs[53] + -0.43511641*inputs[54] + -0.98961975*inputs[55] + -0.01889993*inputs[56] + -0.07297331*inputs[57] + 0.24819379*inputs[58] + 0.41294035*inputs[59] + 0.22758700*inputs[60] + -0.02203956*inputs[61] + 0.01354418*inputs[62] + -0.46817389*inputs[63] + 1.49967802)

def neuron_32(inputs):
    return relu(0.19043019*inputs[0] + 1.04586127*inputs[1] + -0.19490669*inputs[2] + 0.01957094*inputs[3] + -0.14885915*inputs[4] + 0.30515741*inputs[5] + 0.47239034*inputs[6] + -0.15904940*inputs[7] + -0.16443943*inputs[8] + -0.42867479*inputs[9] + 0.25290992*inputs[10] + -0.38430945*inputs[11] + -0.00874662*inputs[12] + -0.28139646*inputs[13] + -0.10792287*inputs[14] + -0.26637577*inputs[15] + 0.04367333*inputs[16] + 0.56174105*inputs[17] + -0.20147932*inputs[18] + 0.15321464*inputs[19] + 0.66579384*inputs[20] + -0.11288933*inputs[21] + 0.61519568*inputs[22] + 0.08459008*inputs[23] + -0.02465513*inputs[24] + 0.06939235*inputs[25] + -0.14606931*inputs[26] + -0.05148713*inputs[27] + 0.38650018*inputs[28] + -0.00754419*inputs[29] + 0.10362252*inputs[30] + 0.28620638*inputs[31] + 0.15993307*inputs[32] + 0.46035547*inputs[33] + 0.09060715*inputs[34] + -0.13883117*inputs[35] + 0.23521917*inputs[36] + 0.29782113*inputs[37] + 0.01598046*inputs[38] + -0.41933828*inputs[39] + -0.07007834*inputs[40] + -0.03429533*inputs[41] + -0.22355810*inputs[42] + -0.24213565*inputs[43] + -0.05541891*inputs[44] + -0.13302417*inputs[45] + -0.25311912*inputs[46] + -0.12383980*inputs[47] + -0.19081418*inputs[48] + 0.11562333*inputs[49] + -0.18549834*inputs[50] + -0.22728222*inputs[51] + 0.01367394*inputs[52] + -0.12689681*inputs[53] + -0.03670571*inputs[54] + 0.67703865*inputs[55] + -0.01145447*inputs[56] + 0.03183467*inputs[57] + 0.29497746*inputs[58] + 0.21942645*inputs[59] + 0.57129429*inputs[60] + -0.05016819*inputs[61] + -0.12926557*inputs[62] + -0.16981223*inputs[63] + 0.70363866)

def neuron_33(inputs):
    return relu(2.24265779*inputs[0] + -0.26248419*inputs[1] + -0.49205347*inputs[2] + -0.35142919*inputs[3] + 0.19698198*inputs[4] + -0.15445203*inputs[5] + 0.23176197*inputs[6] + 0.16384063*inputs[7] + 0.05070283*inputs[8] + -0.19755742*inputs[9] + -0.21840974*inputs[10] + -0.07450732*inputs[11] + 0.46155373*inputs[12] + 0.05836356*inputs[13] + -0.19872336*inputs[14] + 0.46600486*inputs[15] + -0.20426632*inputs[16] + 0.23509144*inputs[17] + -0.19872241*inputs[18] + -0.30417640*inputs[19] + -0.22496488*inputs[20] + 0.59750277*inputs[21] + -0.11228886*inputs[22] + -0.47025334*inputs[23] + -0.28108137*inputs[24] + 0.83244461*inputs[25] + -0.46193522*inputs[26] + 0.37114945*inputs[27] + 0.22298968*inputs[28] + -0.23304157*inputs[29] + 0.04007940*inputs[30] + 0.01608476*inputs[31] + 0.02965783*inputs[32] + 0.58938558*inputs[33] + 0.09554082*inputs[34] + -0.12261201*inputs[35] + -0.22469737*inputs[36] + -0.20269769*inputs[37] + 0.02724257*inputs[38] + 0.41026113*inputs[39] + -0.14491198*inputs[40] + -0.32606028*inputs[41] + -0.19163818*inputs[42] + 0.69633697*inputs[43] + -0.13292174*inputs[44] + 0.22029124*inputs[45] + 0.34809678*inputs[46] + 0.34832978*inputs[47] + 0.01729824*inputs[48] + 0.32856869*inputs[49] + -0.20743055*inputs[50] + 0.00243549*inputs[51] + 0.16736287*inputs[52] + 0.47524602*inputs[53] + 1.09907632*inputs[54] + 0.51413369*inputs[55] + 0.13413762*inputs[56] + -0.42826153*inputs[57] + -0.24929727*inputs[58] + -0.11961528*inputs[59] + 0.62638315*inputs[60] + 0.01523377*inputs[61] + 0.10813661*inputs[62] + 0.72273415*inputs[63] + 1.70631166)

def neuron_34(inputs):
    return relu(1.42808757*inputs[0] + 0.03782492*inputs[1] + -0.19193028*inputs[2] + -0.08338813*inputs[3] + 0.05047049*inputs[4] + 0.32538808*inputs[5] + 0.87402670*inputs[6] + 0.01800276*inputs[7] + 0.12434297*inputs[8] + -0.08419248*inputs[9] + 0.11886782*inputs[10] + -0.21782832*inputs[11] + 0.27512160*inputs[12] + -0.15711069*inputs[13] + -0.23581293*inputs[14] + 0.14196966*inputs[15] + -0.10914074*inputs[16] + -0.05041252*inputs[17] + 0.04468205*inputs[18] + 0.22984642*inputs[19] + -0.25852566*inputs[20] + -0.04687946*inputs[21] + -0.33166542*inputs[22] + -0.21310140*inputs[23] + 0.10918961*inputs[24] + 0.55118072*inputs[25] + -0.21292082*inputs[26] + 0.23646131*inputs[27] + 0.43979007*inputs[28] + -0.22450699*inputs[29] + 0.14927571*inputs[30] + -0.17466662*inputs[31] + -0.31036129*inputs[32] + 0.18807259*inputs[33] + -0.29977897*inputs[34] + 0.34709028*inputs[35] + -0.26146236*inputs[36] + -0.28037319*inputs[37] + 0.32148666*inputs[38] + 0.07865297*inputs[39] + 0.01707350*inputs[40] + -0.02564434*inputs[41] + -0.13819032*inputs[42] + 0.26476663*inputs[43] + -0.19357078*inputs[44] + 0.25514538*inputs[45] + -0.00465611*inputs[46] + 0.13694469*inputs[47] + 0.18368531*inputs[48] + -0.08749274*inputs[49] + -0.08844557*inputs[50] + -0.19961316*inputs[51] + -0.11990631*inputs[52] + 0.12884747*inputs[53] + 2.09421683*inputs[54] + 1.29979965*inputs[55] + -0.00235648*inputs[56] + -0.04223427*inputs[57] + 0.04665506*inputs[58] + -0.25784453*inputs[59] + 1.75199436*inputs[60] + 0.01959168*inputs[61] + -0.18443946*inputs[62] + 0.00083116*inputs[63] + 1.81179596)

def neuron_35(inputs):
    return relu(0.57428958*inputs[0] + 0.21649614*inputs[1] + 0.55069634*inputs[2] + 0.19318410*inputs[3] + 0.09726763*inputs[4] + 0.28846745*inputs[5] + 0.68840283*inputs[6] + -0.13498136*inputs[7] + -0.44306030*inputs[8] + -0.00747628*inputs[9] + 0.31499282*inputs[10] + 0.01836484*inputs[11] + 0.18795386*inputs[12] + -0.32387055*inputs[13] + 0.76855024*inputs[14] + -0.10515077*inputs[15] + 0.12149985*inputs[16] + -0.13316257*inputs[17] + 0.43142101*inputs[18] + 0.08908125*inputs[19] + -0.33841156*inputs[20] + -0.80395570*inputs[21] + 1.13258634*inputs[22] + 0.47697826*inputs[23] + -0.32202243*inputs[24] + -0.35615066*inputs[25] + 0.35652396*inputs[26] + -0.28692249*inputs[27] + 0.18753399*inputs[28] + -0.16736312*inputs[29] + -0.02698584*inputs[30] + 0.28805726*inputs[31] + -0.21952887*inputs[32] + 0.31611921*inputs[33] + 0.79797901*inputs[34] + -0.35611585*inputs[35] + 0.30263231*inputs[36] + 0.44821276*inputs[37] + -0.19029340*inputs[38] + -0.37165416*inputs[39] + 0.27015697*inputs[40] + -0.12849305*inputs[41] + 0.22433659*inputs[42] + -0.65408087*inputs[43] + -0.09096220*inputs[44] + 0.33624872*inputs[45] + 0.60879784*inputs[46] + -0.32074678*inputs[47] + -0.11232643*inputs[48] + -0.01950046*inputs[49] + -0.09987473*inputs[50] + 0.55505166*inputs[51] + -0.38372152*inputs[52] + 0.42796565*inputs[53] + -0.55143400*inputs[54] + 1.22465125*inputs[55] + 0.61842245*inputs[56] + -0.10271805*inputs[57] + -0.37142252*inputs[58] + 0.20003588*inputs[59] + 0.40612522*inputs[60] + -0.49863258*inputs[61] + -0.27867153*inputs[62] + -0.18753187*inputs[63] + 1.18050969)

def neuron_36(inputs):
    return relu(1.02408329*inputs[0] + -0.35906358*inputs[1] + 0.54554408*inputs[2] + -0.66972641*inputs[3] + 0.03041832*inputs[4] + -0.06989733*inputs[5] + -0.57912781*inputs[6] + 0.21457332*inputs[7] + 0.07802762*inputs[8] + 0.28944025*inputs[9] + 0.28072789*inputs[10] + -0.13913725*inputs[11] + -0.19637864*inputs[12] + -0.50995863*inputs[13] + -0.41246824*inputs[14] + -0.35306091*inputs[15] + 1.22301771*inputs[16] + 0.09151813*inputs[17] + -0.15440998*inputs[18] + -0.08542078*inputs[19] + -0.11585230*inputs[20] + 0.38623103*inputs[21] + 1.12225589*inputs[22] + 0.26592049*inputs[23] + -0.18322551*inputs[24] + -0.19114618*inputs[25] + -0.02709111*inputs[26] + -0.13636947*inputs[27] + 0.58136189*inputs[28] + 0.46165274*inputs[29] + 0.22228743*inputs[30] + 0.22798195*inputs[31] + 0.00653691*inputs[32] + 0.75769465*inputs[33] + 0.09005956*inputs[34] + -0.28040969*inputs[35] + -0.11059148*inputs[36] + -0.09550126*inputs[37] + -0.38267365*inputs[38] + 0.07736366*inputs[39] + -0.51464275*inputs[40] + -0.21582304*inputs[41] + 0.59278454*inputs[42] + -0.31230986*inputs[43] + -0.10826927*inputs[44] + 0.38116063*inputs[45] + -0.35301459*inputs[46] + 0.00487677*inputs[47] + -0.11919435*inputs[48] + -0.07948396*inputs[49] + -0.03899497*inputs[50] + 0.03920913*inputs[51] + 0.04538226*inputs[52] + 0.01640024*inputs[53] + -0.19761312*inputs[54] + 0.05671838*inputs[55] + -0.09773522*inputs[56] + -0.15332669*inputs[57] + -0.00148570*inputs[58] + 0.09138723*inputs[59] + 0.99214098*inputs[60] + 0.00800508*inputs[61] + 0.81656693*inputs[62] + -0.08028777*inputs[63] + 0.89121649)

def neuron_37(inputs):
    return relu(-0.16047415*inputs[0] + 0.07280387*inputs[1] + -0.13871022*inputs[2] + 0.47057956*inputs[3] + -0.06329655*inputs[4] + -0.17878916*inputs[5] + 1.00551893*inputs[6] + 0.57148812*inputs[7] + -0.21411958*inputs[8] + -0.38449514*inputs[9] + 0.80176299*inputs[10] + 1.17816387*inputs[11] + -0.22571136*inputs[12] + -0.08835488*inputs[13] + -0.05044177*inputs[14] + 0.02291478*inputs[15] + -0.17927582*inputs[16] + -0.45855952*inputs[17] + 0.02510531*inputs[18] + 0.02330661*inputs[19] + 0.29805905*inputs[20] + 0.87092347*inputs[21] + 0.66472745*inputs[22] + -0.42092402*inputs[23] + 0.43608519*inputs[24] + 0.51958216*inputs[25] + -0.33260211*inputs[26] + -0.11387691*inputs[27] + 0.41882178*inputs[28] + -0.04293983*inputs[29] + 0.52266121*inputs[30] + 0.05520609*inputs[31] + 0.39186718*inputs[32] + 0.08627969*inputs[33] + 0.27710548*inputs[34] + -0.17020850*inputs[35] + -0.18402234*inputs[36] + -0.21782248*inputs[37] + -0.09542345*inputs[38] + -0.22676945*inputs[39] + -0.08897945*inputs[40] + -0.37284922*inputs[41] + -0.29214468*inputs[42] + -0.27566123*inputs[43] + -0.33245365*inputs[44] + -0.08022427*inputs[45] + -0.05290464*inputs[46] + -0.31656441*inputs[47] + 0.03922756*inputs[48] + 0.31775423*inputs[49] + 0.30159913*inputs[50] + -0.07203585*inputs[51] + -0.28924243*inputs[52] + 0.41219812*inputs[53] + -0.77215907*inputs[54] + -0.02035531*inputs[55] + 0.38956012*inputs[56] + 0.20274030*inputs[57] + 0.38811361*inputs[58] + -0.41641581*inputs[59] + 0.09130407*inputs[60] + -0.00989529*inputs[61] + -0.15371623*inputs[62] + -0.00727197*inputs[63] + 0.85431663)

def neuron_38(inputs):
    return relu(0.54975192*inputs[0] + 0.46992072*inputs[1] + -0.17838215*inputs[2] + -0.21315239*inputs[3] + 0.44137687*inputs[4] + -0.53213519*inputs[5] + -0.73095989*inputs[6] + -0.45128379*inputs[7] + 0.13922910*inputs[8] + 1.00020687*inputs[9] + 0.08231208*inputs[10] + -0.00941843*inputs[11] + 0.17146520*inputs[12] + -0.30286923*inputs[13] + 0.30212179*inputs[14] + 0.55761344*inputs[15] + -0.85324624*inputs[16] + 0.16272101*inputs[17] + 0.04376507*inputs[18] + 0.33591058*inputs[19] + -0.40057707*inputs[20] + 0.03647746*inputs[21] + 0.10557727*inputs[22] + 0.07905721*inputs[23] + 0.10147921*inputs[24] + -0.25580846*inputs[25] + 0.33747298*inputs[26] + 0.29817380*inputs[27] + 0.24866515*inputs[28] + 0.42279734*inputs[29] + -0.37788271*inputs[30] + -0.66658043*inputs[31] + 0.44389784*inputs[32] + 0.84210864*inputs[33] + -0.45893461*inputs[34] + -0.02779926*inputs[35] + 0.19132474*inputs[36] + 0.18787756*inputs[37] + 0.39472339*inputs[38] + -0.16525990*inputs[39] + 0.39107547*inputs[40] + 0.02906314*inputs[41] + 1.00435780*inputs[42] + 0.71854081*inputs[43] + -0.26536036*inputs[44] + 0.22321516*inputs[45] + -0.09885300*inputs[46] + 0.20439983*inputs[47] + 0.14190548*inputs[48] + 0.14957169*inputs[49] + -0.61558113*inputs[50] + -0.19053361*inputs[51] + 0.00243493*inputs[52] + -0.34015582*inputs[53] + 1.17857912*inputs[54] + -1.07994588*inputs[55] + 0.16351832*inputs[56] + -0.78689882*inputs[57] + 0.22931969*inputs[58] + 1.08278500*inputs[59] + 0.70315329*inputs[60] + 0.85774126*inputs[61] + 0.77481958*inputs[62] + 0.60843793*inputs[63] + 1.95961306)

def neuron_39(inputs):
    return relu(-0.19062437*inputs[0] + 0.10740385*inputs[1] + 0.31393391*inputs[2] + -0.20484525*inputs[3] + -0.19328697*inputs[4] + 0.57438575*inputs[5] + 0.88632851*inputs[6] + -0.06074913*inputs[7] + -0.18312808*inputs[8] + -0.09162058*inputs[9] + -0.21553869*inputs[10] + -0.03254591*inputs[11] + 0.44764638*inputs[12] + -0.20094915*inputs[13] + -0.04598207*inputs[14] + 0.13723322*inputs[15] + -0.56849769*inputs[16] + 0.51594125*inputs[17] + 0.33695351*inputs[18] + -0.05352708*inputs[19] + 0.51856564*inputs[20] + -0.18383741*inputs[21] + 0.73441103*inputs[22] + 0.09536492*inputs[23] + 0.21227273*inputs[24] + -0.26811630*inputs[25] + 0.28431833*inputs[26] + -0.02514219*inputs[27] + -0.37131730*inputs[28] + 0.06754845*inputs[29] + -0.16190345*inputs[30] + 0.45158392*inputs[31] + 0.63095126*inputs[32] + 0.17020391*inputs[33] + -0.03423508*inputs[34] + 0.18607341*inputs[35] + -0.48838658*inputs[36] + -0.50454496*inputs[37] + 0.05126794*inputs[38] + 0.33937356*inputs[39] + -0.46472908*inputs[40] + -0.09180438*inputs[41] + 0.11450477*inputs[42] + -0.02419560*inputs[43] + -0.13278562*inputs[44] + -0.06104701*inputs[45] + 0.41831912*inputs[46] + 0.37813420*inputs[47] + 0.18858607*inputs[48] + 0.26356049*inputs[49] + 0.62612419*inputs[50] + 0.68815256*inputs[51] + 0.49762487*inputs[52] + 0.33623824*inputs[53] + 0.26867837*inputs[54] + 0.60274697*inputs[55] + -0.00375448*inputs[56] + 0.53588155*inputs[57] + 0.60490063*inputs[58] + -0.53756151*inputs[59] + 0.16601648*inputs[60] + -0.07248968*inputs[61] + 0.39931469*inputs[62] + 0.06241422*inputs[63] + 1.61066833)

def neuron_40(inputs):
    return relu(0.38857719*inputs[0] + -0.43816269*inputs[1] + -0.01956720*inputs[2] + -0.11396788*inputs[3] + -0.05348695*inputs[4] + -0.02652591*inputs[5] + 0.29000566*inputs[6] + 0.04037920*inputs[7] + -0.12933681*inputs[8] + 0.49814255*inputs[9] + 0.36354945*inputs[10] + -0.51764410*inputs[11] + -0.40172722*inputs[12] + -0.35026895*inputs[13] + 0.11066239*inputs[14] + -0.22507094*inputs[15] + -0.01958003*inputs[16] + -0.29445617*inputs[17] + -0.19278981*inputs[18] + 0.47560126*inputs[19] + -0.01633985*inputs[20] + -0.29943517*inputs[21] + 0.22175972*inputs[22] + 0.48542000*inputs[23] + 0.51277587*inputs[24] + -0.06877239*inputs[25] + -0.15031985*inputs[26] + -0.08074125*inputs[27] + 0.43080759*inputs[28] + 0.39053262*inputs[29] + -0.05928619*inputs[30] + -0.06617379*inputs[31] + 0.56453156*inputs[32] + 0.23713482*inputs[33] + -0.03264588*inputs[34] + -0.12615526*inputs[35] + 0.24299254*inputs[36] + 0.31054833*inputs[37] + -0.01073769*inputs[38] + -0.06663982*inputs[39] + 0.18598364*inputs[40] + -0.02868563*inputs[41] + 0.61164892*inputs[42] + 0.16879595*inputs[43] + 0.19153901*inputs[44] + -0.43854439*inputs[45] + -0.10033765*inputs[46] + -0.07455259*inputs[47] + -0.14438852*inputs[48] + -0.12306491*inputs[49] + 0.60916646*inputs[50] + 0.01617166*inputs[51] + 0.29184990*inputs[52] + -0.04742847*inputs[53] + 0.58455880*inputs[54] + 1.25722340*inputs[55] + -0.30466729*inputs[56] + -0.00287825*inputs[57] + 0.40025959*inputs[58] + -0.31591736*inputs[59] + -0.21379926*inputs[60] + -0.35876653*inputs[61] + 0.32374564*inputs[62] + -0.40097329*inputs[63] + 1.03978237)

def neuron_41(inputs):
    return relu(0.21177246*inputs[0] + 0.28359984*inputs[1] + -0.11657188*inputs[2] + 1.02531623*inputs[3] + -0.14829154*inputs[4] + -0.13910024*inputs[5] + -0.26422191*inputs[6] + 0.27981343*inputs[7] + 0.17504575*inputs[8] + -0.14016804*inputs[9] + -0.31164860*inputs[10] + 0.72778793*inputs[11] + -0.30749160*inputs[12] + -0.09387243*inputs[13] + 0.80431295*inputs[14] + 0.34842424*inputs[15] + 0.70268693*inputs[16] + 0.03601237*inputs[17] + -0.20802443*inputs[18] + -0.06394000*inputs[19] + 0.28124445*inputs[20] + -0.18117876*inputs[21] + -0.06208107*inputs[22] + 0.51659259*inputs[23] + -0.23408904*inputs[24] + -0.16945586*inputs[25] + -0.04195232*inputs[26] + -0.27204662*inputs[27] + 0.00101263*inputs[28] + 0.33663293*inputs[29] + -0.09677322*inputs[30] + 0.72687918*inputs[31] + -0.20969733*inputs[32] + -0.34300474*inputs[33] + 0.31590874*inputs[34] + -0.34603943*inputs[35] + 0.33797160*inputs[36] + 0.25381106*inputs[37] + -0.14773231*inputs[38] + -0.14266894*inputs[39] + 0.18348707*inputs[40] + 0.09333995*inputs[41] + -0.20443271*inputs[42] + -0.40021337*inputs[43] + -0.38918432*inputs[44] + -0.30570960*inputs[45] + 0.11694921*inputs[46] + -0.01365122*inputs[47] + 0.04717821*inputs[48] + 0.17570463*inputs[49] + -0.14663765*inputs[50] + -0.05695056*inputs[51] + -0.32848330*inputs[52] + -0.36538177*inputs[53] + 0.08054571*inputs[54] + 0.84200731*inputs[55] + 0.16290214*inputs[56] + 0.40195641*inputs[57] + -0.31981069*inputs[58] + 1.08831161*inputs[59] + 0.70842087*inputs[60] + 0.16839657*inputs[61] + -0.23717977*inputs[62] + -0.28529729*inputs[63] + 1.33025987)

def neuron_42(inputs):
    return relu(-0.72003253*inputs[0] + -0.46306753*inputs[1] + 0.69873717*inputs[2] + 0.09184668*inputs[3] + -0.30871311*inputs[4] + 0.09696422*inputs[5] + 0.70054282*inputs[6] + -0.34099591*inputs[7] + 0.39882798*inputs[8] + 0.55961459*inputs[9] + -0.11823386*inputs[10] + 0.13581977*inputs[11] + 0.38658356*inputs[12] + 0.26119125*inputs[13] + 0.32967109*inputs[14] + -0.29892732*inputs[15] + 0.31470489*inputs[16] + 0.11265396*inputs[17] + -0.43230836*inputs[18] + 0.12398581*inputs[19] + -0.71981185*inputs[20] + -0.30008828*inputs[21] + -0.13263492*inputs[22] + 0.16388613*inputs[23] + -0.10773559*inputs[24] + -0.29354728*inputs[25] + 0.57765131*inputs[26] + 0.02314764*inputs[27] + -0.39764120*inputs[28] + 0.12196480*inputs[29] + -0.03770559*inputs[30] + 0.05710873*inputs[31] + 0.61075843*inputs[32] + 0.18066769*inputs[33] + -0.05252196*inputs[34] + -0.03479719*inputs[35] + 0.18077640*inputs[36] + 0.42888425*inputs[37] + -0.21867616*inputs[38] + 0.30318533*inputs[39] + -0.14554617*inputs[40] + -0.30836152*inputs[41] + 0.15900547*inputs[42] + 0.17482044*inputs[43] + -0.02747454*inputs[44] + 0.07649726*inputs[45] + -0.15776090*inputs[46] + 0.04588354*inputs[47] + 0.25443016*inputs[48] + -0.17499277*inputs[49] + 0.15203872*inputs[50] + -0.18545802*inputs[51] + 0.75488970*inputs[52] + -0.43578826*inputs[53] + 0.56685647*inputs[54] + 1.05239805*inputs[55] + 0.06964769*inputs[56] + -0.03753489*inputs[57] + 0.03664636*inputs[58] + 1.08210664*inputs[59] + 1.29902384*inputs[60] + 1.11275918*inputs[61] + -0.11499971*inputs[62] + 0.00326303*inputs[63] + 1.86025595)

def neuron_43(inputs):
    return relu(-0.02278967*inputs[0] + -0.17654214*inputs[1] + 0.00233292*inputs[2] + -0.15006412*inputs[3] + 0.21632966*inputs[4] + 0.53864720*inputs[5] + -0.19511918*inputs[6] + -0.27679694*inputs[7] + -0.05509200*inputs[8] + -0.34269642*inputs[9] + -0.03013039*inputs[10] + 0.05633666*inputs[11] + 0.47754156*inputs[12] + 0.59888631*inputs[13] + -0.11550816*inputs[14] + 0.24371160*inputs[15] + -0.13100558*inputs[16] + -0.26926632*inputs[17] + 0.04748532*inputs[18] + -0.00883987*inputs[19] + -0.17440357*inputs[20] + 0.24532734*inputs[21] + -0.27688211*inputs[22] + 0.09270543*inputs[23] + 0.70417644*inputs[24] + -0.08740130*inputs[25] + -0.04015313*inputs[26] + 0.08866360*inputs[27] + 0.30959507*inputs[28] + 0.03138778*inputs[29] + -0.14022570*inputs[30] + 0.02649756*inputs[31] + 0.55349604*inputs[32] + -0.04213292*inputs[33] + 0.14412670*inputs[34] + -0.11750543*inputs[35] + 0.04446147*inputs[36] + -0.04034756*inputs[37] + -0.16272081*inputs[38] + -0.00221595*inputs[39] + -0.03146546*inputs[40] + -0.18396975*inputs[41] + -0.24217181*inputs[42] + -0.16227844*inputs[43] + -0.23307576*inputs[44] + -0.00861648*inputs[45] + -0.13547058*inputs[46] + 0.30539351*inputs[47] + -0.15117369*inputs[48] + 0.30755403*inputs[49] + 0.11576540*inputs[50] + 0.37217944*inputs[51] + 0.37834176*inputs[52] + 0.12425172*inputs[53] + -0.04535953*inputs[54] + 0.09327879*inputs[55] + -0.23401565*inputs[56] + -0.19267420*inputs[57] + -0.18873031*inputs[58] + 0.03241517*inputs[59] + -0.55777821*inputs[60] + -0.04470153*inputs[61] + 0.82985934*inputs[62] + 0.10418865*inputs[63] + 0.52427536)

def neuron_44(inputs):
    return relu(-0.60563003*inputs[0] + -0.16335853*inputs[1] + 0.15086505*inputs[2] + 0.41986505*inputs[3] + 0.10929576*inputs[4] + -0.16422726*inputs[5] + 1.30470414*inputs[6] + 0.16633816*inputs[7] + -0.15665559*inputs[8] + -0.27109596*inputs[9] + -0.23317258*inputs[10] + 0.07407052*inputs[11] + -0.04943727*inputs[12] + 0.24321874*inputs[13] + 0.80106821*inputs[14] + -0.14585615*inputs[15] + 0.35558188*inputs[16] + -0.27988466*inputs[17] + 0.12335963*inputs[18] + -0.20273133*inputs[19] + -0.19940638*inputs[20] + -0.19362403*inputs[21] + 0.63418858*inputs[22] + 0.40020634*inputs[23] + 0.26021350*inputs[24] + -0.22721948*inputs[25] + 0.27969091*inputs[26] + -0.06905956*inputs[27] + -0.34525690*inputs[28] + 0.16054427*inputs[29] + 0.00755656*inputs[30] + 0.00685740*inputs[31] + 0.18779710*inputs[32] + 0.68905718*inputs[33] + -0.10573115*inputs[34] + -0.13831505*inputs[35] + 0.14766113*inputs[36] + 0.21657546*inputs[37] + -0.21148589*inputs[38] + -0.08133125*inputs[39] + 0.31299101*inputs[40] + -0.35180784*inputs[41] + 0.09808376*inputs[42] + -0.12567700*inputs[43] + -0.41003161*inputs[44] + -0.31561662*inputs[45] + 0.32493355*inputs[46] + -0.32062562*inputs[47] + -0.02525846*inputs[48] + 0.20009154*inputs[49] + 0.18768433*inputs[50] + 0.14111593*inputs[51] + 0.31253534*inputs[52] + 0.34731116*inputs[53] + -0.09482034*inputs[54] + -0.38740677*inputs[55] + 0.53972931*inputs[56] + -0.06546926*inputs[57] + -0.16468164*inputs[58] + 0.34821543*inputs[59] + -0.06395722*inputs[60] + 0.31995856*inputs[61] + -0.09296543*inputs[62] + -0.16487127*inputs[63] + 1.14601605)

def neuron_45(inputs):
    return relu(-0.45022448*inputs[0] + 0.02757221*inputs[1] + 0.19502526*inputs[2] + 0.38802463*inputs[3] + 0.00863067*inputs[4] + -0.32780308*inputs[5] + 0.66805899*inputs[6] + -0.00103911*inputs[7] + 0.39288384*inputs[8] + -0.17703635*inputs[9] + 0.05348108*inputs[10] + -0.28958959*inputs[11] + 1.11323343*inputs[12] + -0.14999887*inputs[13] + -0.40105797*inputs[14] + -0.47077989*inputs[15] + 1.06395556*inputs[16] + -0.31708755*inputs[17] + -0.21418746*inputs[18] + -0.10358047*inputs[19] + -0.15266026*inputs[20] + 0.36052766*inputs[21] + 0.97302553*inputs[22] + -0.18702540*inputs[23] + -0.10179627*inputs[24] + 0.18456598*inputs[25] + -0.24931949*inputs[26] + -0.12389885*inputs[27] + 0.53064029*inputs[28] + 0.00788746*inputs[29] + 0.18114375*inputs[30] + -0.08644065*inputs[31] + -0.14527378*inputs[32] + 0.26974526*inputs[33] + 0.21142587*inputs[34] + 0.27800346*inputs[35] + -0.13854606*inputs[36] + -0.14391183*inputs[37] + -0.10490683*inputs[38] + 0.04415939*inputs[39] + -0.25417778*inputs[40] + 0.06142044*inputs[41] + 0.13488114*inputs[42] + -0.21977023*inputs[43] + -0.28105708*inputs[44] + 0.52912562*inputs[45] + -0.28108756*inputs[46] + -0.17510745*inputs[47] + 0.03699696*inputs[48] + 0.42043575*inputs[49] + 0.00430574*inputs[50] + 0.15567541*inputs[51] + -0.25150301*inputs[52] + 0.36743228*inputs[53] + -0.87650620*inputs[54] + 0.75078412*inputs[55] + -0.00154978*inputs[56] + 0.27522589*inputs[57] + -0.22767295*inputs[58] + 0.66610150*inputs[59] + -0.28354482*inputs[60] + -0.07209544*inputs[61] + 0.20300940*inputs[62] + -0.04001188*inputs[63] + 0.75738568)

def neuron_46(inputs):
    return relu(-0.14842785*inputs[0] + 0.37014107*inputs[1] + 0.22836782*inputs[2] + -0.25692519*inputs[3] + 0.32895233*inputs[4] + -0.08559558*inputs[5] + 0.92067437*inputs[6] + -0.01415141*inputs[7] + 0.46303646*inputs[8] + -0.10396568*inputs[9] + 0.22313032*inputs[10] + -0.11604646*inputs[11] + 0.13726798*inputs[12] + -0.16529096*inputs[13] + 0.42293015*inputs[14] + -0.34586791*inputs[15] + 0.65619963*inputs[16] + 0.62283044*inputs[17] + 0.03102187*inputs[18] + -0.25187239*inputs[19] + 0.26003189*inputs[20] + 0.16120041*inputs[21] + 0.99307586*inputs[22] + -0.00545410*inputs[23] + -0.50601742*inputs[24] + -0.07305241*inputs[25] + 0.24268658*inputs[26] + 0.02081994*inputs[27] + -0.10269608*inputs[28] + 0.26685552*inputs[29] + -0.14924931*inputs[30] + -0.10468060*inputs[31] + -0.23604681*inputs[32] + 0.52634414*inputs[33] + -0.10160890*inputs[34] + -0.06335968*inputs[35] + -0.13185543*inputs[36] + -0.18380610*inputs[37] + -0.14628174*inputs[38] + -0.24684598*inputs[39] + 0.35627155*inputs[40] + 0.02050577*inputs[41] + 0.30077204*inputs[42] + -0.05537813*inputs[43] + 0.63472212*inputs[44] + -0.00598725*inputs[45] + -0.21538129*inputs[46] + 0.00536265*inputs[47] + -0.05218648*inputs[48] + -0.44965476*inputs[49] + 0.10550248*inputs[50] + 0.26379695*inputs[51] + -0.06807675*inputs[52] + -0.09052369*inputs[53] + 0.09318761*inputs[54] + -0.49554240*inputs[55] + -0.01635055*inputs[56] + -0.15893322*inputs[57] + 0.33205256*inputs[58] + -0.11751444*inputs[59] + 0.73107889*inputs[60] + 0.37253535*inputs[61] + 0.21215378*inputs[62] + -0.13512991*inputs[63] + 1.41239550)

def neuron_47(inputs):
    return relu(1.35994105*inputs[0] + -0.11552933*inputs[1] + -0.06521075*inputs[2] + -0.23818065*inputs[3] + 0.19747512*inputs[4] + 0.34730374*inputs[5] + -0.63214827*inputs[6] + 0.09893051*inputs[7] + -0.13958185*inputs[8] + 0.05766508*inputs[9] + 0.11421182*inputs[10] + 0.10137920*inputs[11] + -0.06517932*inputs[12] + 0.27446033*inputs[13] + 0.04210084*inputs[14] + -0.27560106*inputs[15] + 0.95603822*inputs[16] + 0.00817030*inputs[17] + -0.12310137*inputs[18] + 0.22982073*inputs[19] + -0.04156946*inputs[20] + -0.13512906*inputs[21] + 1.52697864*inputs[22] + -0.18484282*inputs[23] + -0.02149537*inputs[24] + 0.29038106*inputs[25] + -0.32450372*inputs[26] + -0.07368700*inputs[27] + 0.80665210*inputs[28] + -0.44058511*inputs[29] + 0.50783766*inputs[30] + -0.02436265*inputs[31] + 0.11969067*inputs[32] + 0.62677602*inputs[33] + -0.11922139*inputs[34] + -0.15081719*inputs[35] + -0.28069997*inputs[36] + -0.22102511*inputs[37] + -0.16448095*inputs[38] + -0.20611932*inputs[39] + 0.21310967*inputs[40] + 0.11525033*inputs[41] + 0.30065177*inputs[42] + -0.63513882*inputs[43] + -0.15684102*inputs[44] + -0.02241206*inputs[45] + 0.18327698*inputs[46] + 0.33687253*inputs[47] + 0.04932721*inputs[48] + -0.17796776*inputs[49] + -0.06351248*inputs[50] + -0.06577484*inputs[51] + -0.21895235*inputs[52] + 0.03378035*inputs[53] + 0.89173811*inputs[54] + 1.08583576*inputs[55] + -0.39341639*inputs[56] + -0.01080529*inputs[57] + -0.14380601*inputs[58] + 0.20518080*inputs[59] + 0.44316644*inputs[60] + -0.63954205*inputs[61] + -0.57872483*inputs[62] + -0.51296260*inputs[63] + 1.11644465)

def neuron_48(inputs):
    return relu(-0.09859553*inputs[0] + -0.10249552*inputs[1] + -0.06823720*inputs[2] + -0.07823463*inputs[3] + -0.03210414*inputs[4] + -0.22953270*inputs[5] + -0.09453486*inputs[6] + -0.08590993*inputs[7] + -0.44036453*inputs[8] + -0.05376043*inputs[9] + -0.13756758*inputs[10] + 0.00426570*inputs[11] + 0.11767745*inputs[12] + -0.21535624*inputs[13] + 0.02580677*inputs[14] + 0.41470552*inputs[15] + -0.11755167*inputs[16] + 0.40424342*inputs[17] + 0.81633681*inputs[18] + 0.02820106*inputs[19] + 0.53385243*inputs[20] + -0.11255153*inputs[21] + -0.16923819*inputs[22] + -0.13923575*inputs[23] + -0.19695177*inputs[24] + -0.10658777*inputs[25] + -0.05012151*inputs[26] + 0.12916681*inputs[27] + -0.15797521*inputs[28] + -0.07974142*inputs[29] + -0.03290382*inputs[30] + 0.16484637*inputs[31] + -0.05440880*inputs[32] + -0.14043120*inputs[33] + 0.01881602*inputs[34] + 0.33010576*inputs[35] + -0.02877389*inputs[36] + -0.01697542*inputs[37] + -0.14538282*inputs[38] + 0.21334976*inputs[39] + -0.11587570*inputs[40] + 0.38543444*inputs[41] + -0.10549069*inputs[42] + 0.02097102*inputs[43] + 0.03642475*inputs[44] + 0.13870346*inputs[45] + 0.09059959*inputs[46] + 0.14497357*inputs[47] + -0.13972211*inputs[48] + 0.32458691*inputs[49] + 0.14090202*inputs[50] + 0.27745304*inputs[51] + -0.21134719*inputs[52] + -0.07827831*inputs[53] + -0.12264501*inputs[54] + -0.18232942*inputs[55] + 0.20008950*inputs[56] + -0.40630656*inputs[57] + 0.18090590*inputs[58] + 0.00000253*inputs[59] + -0.09192865*inputs[60] + 0.19729993*inputs[61] + 0.12708525*inputs[62] + 0.38939848*inputs[63] + 0.49018137)

def neuron_49(inputs):
    return relu(0.42682605*inputs[0] + -0.19601601*inputs[1] + 0.18291373*inputs[2] + -0.10411882*inputs[3] + 0.03363466*inputs[4] + 0.35434375*inputs[5] + 0.58626918*inputs[6] + -0.31762106*inputs[7] + -0.16904755*inputs[8] + -0.19150535*inputs[9] + 0.08149881*inputs[10] + 0.18012775*inputs[11] + 0.32664661*inputs[12] + -0.11475227*inputs[13] + -0.13594741*inputs[14] + 0.22452239*inputs[15] + -0.56698408*inputs[16] + 0.18663681*inputs[17] + -0.01958442*inputs[18] + 0.27744698*inputs[19] + 0.68057997*inputs[20] + -0.08967506*inputs[21] + -1.03098075*inputs[22] + 0.04653319*inputs[23] + -0.21140860*inputs[24] + 0.13682089*inputs[25] + 0.36257711*inputs[26] + 0.28287023*inputs[27] + 0.36512707*inputs[28] + 0.26097409*inputs[29] + -0.14938227*inputs[30] + 0.10875552*inputs[31] + 0.38996108*inputs[32] + -0.05362040*inputs[33] + -0.54640038*inputs[34] + 0.23942127*inputs[35] + 0.15433029*inputs[36] + 0.23868574*inputs[37] + 0.17640654*inputs[38] + 0.00509770*inputs[39] + 0.29512050*inputs[40] + -0.10147172*inputs[41] + 0.12106962*inputs[42] + 0.27273353*inputs[43] + -0.17832574*inputs[44] + 1.26771359*inputs[45] + -0.09805562*inputs[46] + 0.23937193*inputs[47] + -0.45796217*inputs[48] + -0.18951274*inputs[49] + 0.10436490*inputs[50] + -0.27679174*inputs[51] + -0.33131922*inputs[52] + -0.06991511*inputs[53] + 0.97432400*inputs[54] + -0.51924182*inputs[55] + 0.05128173*inputs[56] + -0.59577904*inputs[57] + -0.29010933*inputs[58] + -0.18023417*inputs[59] + 1.14967339*inputs[60] + 0.46881826*inputs[61] + 1.06970444*inputs[62] + 0.03575702*inputs[63] + 1.48355722)

def neuron_50(inputs):
    return relu(0.53226921*inputs[0] + 0.41909853*inputs[1] + 0.09888734*inputs[2] + 0.11091296*inputs[3] + -0.03714573*inputs[4] + 0.35271635*inputs[5] + 1.20741704*inputs[6] + -0.01346032*inputs[7] + -0.06343487*inputs[8] + -0.38337689*inputs[9] + -0.20771709*inputs[10] + 0.04102545*inputs[11] + 0.23697636*inputs[12] + -0.20062735*inputs[13] + 0.25666682*inputs[14] + 0.53819896*inputs[15] + 0.07645568*inputs[16] + 0.57092236*inputs[17] + 0.24943175*inputs[18] + 0.20401852*inputs[19] + 1.01262352*inputs[20] + -0.32064284*inputs[21] + 0.41252621*inputs[22] + -0.07086529*inputs[23] + -0.34619426*inputs[24] + -0.07616503*inputs[25] + -0.17969955*inputs[26] + 0.09180940*inputs[27] + -0.01932158*inputs[28] + -0.30219886*inputs[29] + -0.10672500*inputs[30] + 0.18638792*inputs[31] + -0.38581776*inputs[32] + 0.87209174*inputs[33] + 0.43864962*inputs[34] + 0.04060377*inputs[35] + -0.09419395*inputs[36] + 0.14980176*inputs[37] + -0.11261987*inputs[38] + -0.14597375*inputs[39] + -0.11540827*inputs[40] + 0.04527727*inputs[41] + -0.66353070*inputs[42] + 0.16065403*inputs[43] + -0.21842999*inputs[44] + -0.12974137*inputs[45] + 0.40452024*inputs[46] + -0.07720315*inputs[47] + -0.53540925*inputs[48] + 0.56955660*inputs[49] + 0.14755505*inputs[50] + 0.19250573*inputs[51] + -0.19154111*inputs[52] + 0.63337256*inputs[53] + -0.23385391*inputs[54] + 1.00857869*inputs[55] + 0.12519232*inputs[56] + -0.17286510*inputs[57] + 0.23709252*inputs[58] + -0.38294212*inputs[59] + 1.16864403*inputs[60] + -0.12708429*inputs[61] + -0.31022196*inputs[62] + 0.51203134*inputs[63] + 1.67594757)

def neuron_51(inputs):
    return relu(0.56287471*inputs[0] + -0.12928917*inputs[1] + 0.55288903*inputs[2] + 0.83039288*inputs[3] + 0.71899489*inputs[4] + 0.12018445*inputs[5] + -0.23182375*inputs[6] + -0.38985142*inputs[7] + 0.22593185*inputs[8] + -0.31055290*inputs[9] + -0.05911265*inputs[10] + 0.65149155*inputs[11] + -0.07020246*inputs[12] + 0.12925595*inputs[13] + -0.33961246*inputs[14] + 0.14316340*inputs[15] + 1.14940844*inputs[16] + -0.27048255*inputs[17] + -0.00835228*inputs[18] + 0.17582482*inputs[19] + -0.17948711*inputs[20] + -0.36328887*inputs[21] + -1.00061518*inputs[22] + 0.02535514*inputs[23] + 0.04263028*inputs[24] + -0.42179312*inputs[25] + 0.32153709*inputs[26] + -0.00193333*inputs[27] + 0.18141464*inputs[28] + -0.01977802*inputs[29] + -0.08098262*inputs[30] + -0.17575762*inputs[31] + 0.24488904*inputs[32] + -0.86597600*inputs[33] + 0.15426238*inputs[34] + -0.11193778*inputs[35] + 0.22445288*inputs[36] + 0.32895576*inputs[37] + -0.10713418*inputs[38] + -0.23184888*inputs[39] + 0.09904251*inputs[40] + 0.32489200*inputs[41] + -0.53812641*inputs[42] + 0.23164745*inputs[43] + 0.51142594*inputs[44] + -0.70825049*inputs[45] + -0.00471129*inputs[46] + -0.07254109*inputs[47] + -0.22460019*inputs[48] + 0.08408395*inputs[49] + -0.25171881*inputs[50] + 0.21904033*inputs[51] + -0.26474213*inputs[52] + -0.28004677*inputs[53] + 0.28007494*inputs[54] + 0.52309774*inputs[55] + 0.57615393*inputs[56] + -0.22042528*inputs[57] + -0.22930153*inputs[58] + 0.45531881*inputs[59] + 0.67538945*inputs[60] + 0.98579167*inputs[61] + 0.59669402*inputs[62] + 0.18404824*inputs[63] + 1.01227002)

def neuron_52(inputs):
    return relu(0.51355831*inputs[0] + -0.11343659*inputs[1] + -0.33883611*inputs[2] + -0.27125347*inputs[3] + 0.11379947*inputs[4] + 0.29225419*inputs[5] + 0.35347135*inputs[6] + -0.03041710*inputs[7] + 0.44549378*inputs[8] + -0.32641921*inputs[9] + -0.00113107*inputs[10] + -0.20232757*inputs[11] + 0.65384725*inputs[12] + 0.80494019*inputs[13] + 0.46511525*inputs[14] + 0.18555628*inputs[15] + -0.18941030*inputs[16] + 0.03427915*inputs[17] + -0.05628485*inputs[18] + -0.13530338*inputs[19] + -0.17323964*inputs[20] + 0.25613579*inputs[21] + -0.26091499*inputs[22] + -0.08555600*inputs[23] + 0.11984307*inputs[24] + 0.40823827*inputs[25] + -0.15209157*inputs[26] + 0.28726691*inputs[27] + 0.30196990*inputs[28] + -0.41564763*inputs[29] + 0.21488130*inputs[30] + 0.25731016*inputs[31] + -0.05321640*inputs[32] + 0.78702427*inputs[33] + -0.13706085*inputs[34] + 0.36509950*inputs[35] + -0.24730348*inputs[36] + -0.25745087*inputs[37] + 0.06343541*inputs[38] + 0.46442416*inputs[39] + 0.38626227*inputs[40] + 0.03981717*inputs[41] + -0.14645738*inputs[42] + 0.00126140*inputs[43] + 0.34447681*inputs[44] + 0.10600534*inputs[45] + -0.20936070*inputs[46] + 0.36343579*inputs[47] + 0.50198630*inputs[48] + -0.12047860*inputs[49] + 0.36083618*inputs[50] + -0.22441518*inputs[51] + 0.23831419*inputs[52] + 0.13533793*inputs[53] + 1.83689713*inputs[54] + 0.59586825*inputs[55] + -0.82289791*inputs[56] + 0.31653655*inputs[57] + -0.04424531*inputs[58] + -0.18292089*inputs[59] + 0.95073370*inputs[60] + 0.14545543*inputs[61] + -0.43480418*inputs[62] + 0.35358509*inputs[63] + 2.02322841)

def neuron_53(inputs):
    return relu(1.86340526*inputs[0] + -0.01761699*inputs[1] + 0.25854181*inputs[2] + 0.58776097*inputs[3] + 0.77955885*inputs[4] + -0.37120263*inputs[5] + 0.07758331*inputs[6] + -0.65849742*inputs[7] + 0.10233731*inputs[8] + 0.55910778*inputs[9] + 0.02791354*inputs[10] + 0.57238384*inputs[11] + -0.37828615*inputs[12] + 0.19380565*inputs[13] + -0.00892505*inputs[14] + -0.32693589*inputs[15] + 1.14734198*inputs[16] + -0.55542056*inputs[17] + -0.13407228*inputs[18] + -0.02651169*inputs[19] + 0.03251387*inputs[20] + -0.67273418*inputs[21] + 1.15573196*inputs[22] + -0.34264526*inputs[23] + 0.76443886*inputs[24] + 0.06015660*inputs[25] + 0.03247814*inputs[26] + -0.09022101*inputs[27] + 0.56518717*inputs[28] + -0.39259718*inputs[29] + -0.53194411*inputs[30] + -0.11772893*inputs[31] + 0.16894315*inputs[32] + 0.05396805*inputs[33] + 0.09917403*inputs[34] + -0.20782825*inputs[35] + -0.05858874*inputs[36] + -0.09602578*inputs[37] + -0.13637570*inputs[38] + -0.19946254*inputs[39] + 0.11110951*inputs[40] + 0.04122953*inputs[41] + 0.46488893*inputs[42] + 0.14690193*inputs[43] + 0.29835383*inputs[44] + -0.09964432*inputs[45] + 0.10276102*inputs[46] + -0.11251315*inputs[47] + -0.27618508*inputs[48] + -0.28812677*inputs[49] + -0.08618725*inputs[50] + 0.00375827*inputs[51] + 0.18343837*inputs[52] + 0.23135711*inputs[53] + 0.44578743*inputs[54] + 1.50672307*inputs[55] + -0.00543622*inputs[56] + 0.06119305*inputs[57] + -0.03090687*inputs[58] + -0.17218356*inputs[59] + 0.41303336*inputs[60] + 0.12366883*inputs[61] + -0.48404158*inputs[62] + -0.41735725*inputs[63] + 1.34106370)

def neuron_54(inputs):
    return relu(0.09483894*inputs[0] + -0.09311193*inputs[1] + 0.86976015*inputs[2] + -0.27413526*inputs[3] + 0.42595351*inputs[4] + -0.38752596*inputs[5] + 0.35805736*inputs[6] + -0.36437817*inputs[7] + -0.54938932*inputs[8] + 0.19740606*inputs[9] + 0.31494630*inputs[10] + -0.36791351*inputs[11] + -0.04769058*inputs[12] + 0.46418483*inputs[13] + 0.13229517*inputs[14] + 0.04249624*inputs[15] + 1.88080370*inputs[16] + 0.07090055*inputs[17] + 0.13949542*inputs[18] + 0.58841104*inputs[19] + 0.06926705*inputs[20] + -0.40113856*inputs[21] + 0.48764548*inputs[22] + -0.22627666*inputs[23] + 0.40415852*inputs[24] + -0.29326293*inputs[25] + 0.13074517*inputs[26] + 0.28154049*inputs[27] + 0.27237129*inputs[28] + -0.23481159*inputs[29] + 0.32738733*inputs[30] + -0.13502558*inputs[31] + -0.34329841*inputs[32] + 0.26182919*inputs[33] + 0.10429531*inputs[34] + -0.35016418*inputs[35] + -0.02061253*inputs[36] + 0.09612588*inputs[37] + 0.27726319*inputs[38] + 0.04964191*inputs[39] + -0.03951019*inputs[40] + 0.05272586*inputs[41] + -0.22014110*inputs[42] + 0.82595638*inputs[43] + 0.20097563*inputs[44] + -0.14733733*inputs[45] + -0.31252602*inputs[46] + -0.13168169*inputs[47] + -0.06023484*inputs[48] + -0.05671538*inputs[49] + 0.05573746*inputs[50] + -0.08001574*inputs[51] + 0.05256893*inputs[52] + 0.13337843*inputs[53] + -1.19357879*inputs[54] + 0.55352401*inputs[55] + -0.05323580*inputs[56] + -0.46241657*inputs[57] + -0.49803470*inputs[58] + -0.37660202*inputs[59] + -0.21635536*inputs[60] + -0.10461121*inputs[61] + 0.36894069*inputs[62] + 0.51934359*inputs[63] + 0.75517493)

def neuron_55(inputs):
    return relu(0.23976041*inputs[0] + -0.22398276*inputs[1] + -0.36449971*inputs[2] + 0.32086703*inputs[3] + -0.13281947*inputs[4] + -0.05133221*inputs[5] + 0.69615708*inputs[6] + -0.14834030*inputs[7] + 0.59862854*inputs[8] + -0.09018823*inputs[9] + -0.28209761*inputs[10] + -0.52856053*inputs[11] + 1.01517092*inputs[12] + -0.28411176*inputs[13] + 0.40792729*inputs[14] + 0.22851309*inputs[15] + 0.09474338*inputs[16] + -0.16595835*inputs[17] + 0.25258085*inputs[18] + -0.07222984*inputs[19] + -0.10017360*inputs[20] + -0.07286045*inputs[21] + 0.82385722*inputs[22] + -0.34975995*inputs[23] + -0.04995257*inputs[24] + -0.16634080*inputs[25] + -0.22895412*inputs[26] + 0.05484386*inputs[27] + -0.14967397*inputs[28] + -0.05059376*inputs[29] + -0.29262850*inputs[30] + -0.33607726*inputs[31] + -0.23135800*inputs[32] + 0.79417794*inputs[33] + 0.44951159*inputs[34] + 0.41268481*inputs[35] + -0.33097119*inputs[36] + -0.37545058*inputs[37] + 0.39577069*inputs[38] + 0.10348850*inputs[39] + -0.22714832*inputs[40] + 0.47859266*inputs[41] + 0.18372072*inputs[42] + -0.47363448*inputs[43] + 0.18182530*inputs[44] + -0.04987995*inputs[45] + 0.18401051*inputs[46] + 0.16951219*inputs[47] + -0.06638091*inputs[48] + 0.78410030*inputs[49] + -0.20799570*inputs[50] + 0.39036732*inputs[51] + -0.05996231*inputs[52] + 0.42651567*inputs[53] + -0.14907743*inputs[54] + 0.48832184*inputs[55] + 0.62831760*inputs[56] + -0.10880213*inputs[57] + 0.09349086*inputs[58] + 1.21864108*inputs[59] + 0.83207157*inputs[60] + -0.00546159*inputs[61] + -0.08636914*inputs[62] + 0.71130241*inputs[63] + 1.81972637)

def neuron_56(inputs):
    return relu(-0.11079409*inputs[0] + 0.02867956*inputs[1] + -0.23860244*inputs[2] + -0.25709777*inputs[3] + -0.29781593*inputs[4] + 0.37896805*inputs[5] + 0.99178688*inputs[6] + -0.22719140*inputs[7] + 0.26105077*inputs[8] + -0.09395906*inputs[9] + 0.01933191*inputs[10] + -0.10041923*inputs[11] + 0.95169048*inputs[12] + -0.03154334*inputs[13] + -0.17267841*inputs[14] + -0.36851385*inputs[15] + 0.09389226*inputs[16] + -0.23613463*inputs[17] + 0.13928801*inputs[18] + -0.06076041*inputs[19] + -0.23997103*inputs[20] + -0.07131911*inputs[21] + 1.51390941*inputs[22] + 0.41740877*inputs[23] + -0.16667154*inputs[24] + -0.12020101*inputs[25] + 0.11129650*inputs[26] + -0.09986061*inputs[27] + -0.23835480*inputs[28] + 0.14217427*inputs[29] + 0.08705322*inputs[30] + -0.41250688*inputs[31] + 0.17543346*inputs[32] + 1.21812387*inputs[33] + -0.33811238*inputs[34] + 0.65977826*inputs[35] + 0.48076220*inputs[36] + 0.31485414*inputs[37] + 0.22280533*inputs[38] + -0.09266769*inputs[39] + 0.41721622*inputs[40] + 0.24610058*inputs[41] + 0.09167106*inputs[42] + -0.08337549*inputs[43] + 0.48248223*inputs[44] + 0.27459600*inputs[45] + -0.14714303*inputs[46] + 0.31034463*inputs[47] + 0.05143898*inputs[48] + 0.21734548*inputs[49] + -0.29523294*inputs[50] + 0.11880607*inputs[51] + -0.30261079*inputs[52] + 0.21268902*inputs[53] + 0.08276047*inputs[54] + 0.91619828*inputs[55] + -0.47797080*inputs[56] + 0.00043977*inputs[57] + -0.08998473*inputs[58] + -0.16764257*inputs[59] + 0.74880309*inputs[60] + 0.03532803*inputs[61] + 0.92182181*inputs[62] + -0.12028853*inputs[63] + 1.91073420)

def neuron_57(inputs):
    return relu(0.66214416*inputs[0] + -0.47331546*inputs[1] + -0.43981416*inputs[2] + -0.10278109*inputs[3] + -0.43581448*inputs[4] + 0.17559484*inputs[5] + -0.26362987*inputs[6] + -0.14641392*inputs[7] + 0.35073352*inputs[8] + 0.35928167*inputs[9] + -0.21491367*inputs[10] + -0.26494821*inputs[11] + 0.33128860*inputs[12] + -0.10823455*inputs[13] + 0.64422829*inputs[14] + 0.20291905*inputs[15] + -0.46085917*inputs[16] + 0.46707257*inputs[17] + 0.08699376*inputs[18] + -0.48615356*inputs[19] + -0.09547865*inputs[20] + -0.07844663*inputs[21] + -0.09670267*inputs[22] + 0.26317157*inputs[23] + -0.03723651*inputs[24] + -0.12798049*inputs[25] + -0.28777255*inputs[26] + 0.03508726*inputs[27] + -0.06176310*inputs[28] + 0.26152182*inputs[29] + -0.33373446*inputs[30] + 0.09399466*inputs[31] + 0.30829260*inputs[32] + 0.62276921*inputs[33] + 0.18933875*inputs[34] + 0.29004488*inputs[35] + -0.05077235*inputs[36] + -0.11525027*inputs[37] + -0.29087706*inputs[38] + -0.11134064*inputs[39] + -0.10339447*inputs[40] + 0.25010447*inputs[41] + 1.01903004*inputs[42] + -0.17078769*inputs[43] + 0.34509340*inputs[44] + 1.22702150*inputs[45] + 0.47609154*inputs[46] + -0.01931358*inputs[47] + -0.32196104*inputs[48] + -0.13978949*inputs[49] + 0.61905706*inputs[50] + 0.11451872*inputs[51] + 0.41274321*inputs[52] + -0.17256926*inputs[53] + 0.66303446*inputs[54] + -0.08586185*inputs[55] + 0.37296332*inputs[56] + -0.58764860*inputs[57] + 0.02126652*inputs[58] + 0.86934939*inputs[59] + 0.84900501*inputs[60] + -0.03120988*inputs[61] + -0.14246983*inputs[62] + -0.01151420*inputs[63] + 1.41364255)

def neuron_58(inputs):
    return relu(-0.51659934*inputs[0] + 0.22704324*inputs[1] + 0.09849570*inputs[2] + 0.21673045*inputs[3] + 0.17333117*inputs[4] + 0.04476982*inputs[5] + 0.13795499*inputs[6] + -0.00700870*inputs[7] + 0.09907979*inputs[8] + -0.03132012*inputs[9] + 0.10345186*inputs[10] + 0.37126585*inputs[11] + -0.02385568*inputs[12] + 0.33212113*inputs[13] + -0.04703505*inputs[14] + -0.17052358*inputs[15] + -0.08087557*inputs[16] + 0.29301471*inputs[17] + -0.10972327*inputs[18] + 0.00684252*inputs[19] + 0.23807581*inputs[20] + 0.12389709*inputs[21] + 1.02928616*inputs[22] + -0.17481145*inputs[23] + 0.02625472*inputs[24] + 0.22192314*inputs[25] + 0.09157385*inputs[26] + 0.13975867*inputs[27] + -0.13598614*inputs[28] + 0.09792899*inputs[29] + -0.22449515*inputs[30] + -0.09041965*inputs[31] + -0.14598876*inputs[32] + -0.17897794*inputs[33] + -0.11506081*inputs[34] + -0.07873732*inputs[35] + -0.06704330*inputs[36] + -0.26237000*inputs[37] + 0.23313950*inputs[38] + 0.04513793*inputs[39] + -0.23752805*inputs[40] + -0.16817794*inputs[41] + 0.04783791*inputs[42] + -0.04534116*inputs[43] + -0.05968226*inputs[44] + 0.22927754*inputs[45] + -0.17756909*inputs[46] + -0.04566599*inputs[47] + 0.01193873*inputs[48] + -0.16425129*inputs[49] + -0.05283227*inputs[50] + -0.00777387*inputs[51] + 0.18167991*inputs[52] + 0.08710331*inputs[53] + -0.21237683*inputs[54] + -0.24014115*inputs[55] + 0.00697428*inputs[56] + -0.19246621*inputs[57] + -0.15194001*inputs[58] + 0.24379838*inputs[59] + 0.32478845*inputs[60] + 0.23393065*inputs[61] + 0.14460325*inputs[62] + 0.05939181*inputs[63] + 0.49762504)

def neuron_59(inputs):
    return relu(-0.91069076*inputs[0] + 0.26666016*inputs[1] + -0.07362503*inputs[2] + -0.14415292*inputs[3] + 0.79535812*inputs[4] + 0.39682697*inputs[5] + 0.57521180*inputs[6] + 0.29620421*inputs[7] + 0.19198369*inputs[8] + 0.08439391*inputs[9] + -0.24370168*inputs[10] + 0.41578441*inputs[11] + 0.59648199*inputs[12] + 0.01503696*inputs[13] + 0.35308232*inputs[14] + 0.36714979*inputs[15] + 0.34023400*inputs[16] + -0.02995790*inputs[17] + -0.24339762*inputs[18] + 0.15587409*inputs[19] + 0.00102886*inputs[20] + -0.01740186*inputs[21] + 0.39980662*inputs[22] + 0.38028876*inputs[23] + -0.17065430*inputs[24] + 0.31703889*inputs[25] + 0.49559080*inputs[26] + 0.21965315*inputs[27] + -0.25419540*inputs[28] + 0.12200800*inputs[29] + -0.41691684*inputs[30] + 0.23029033*inputs[31] + 0.00255024*inputs[32] + 0.37073205*inputs[33] + -0.33359102*inputs[34] + 0.02426186*inputs[35] + -0.05609486*inputs[36] + -0.12660208*inputs[37] + 0.13985288*inputs[38] + 0.21257180*inputs[39] + 0.55330242*inputs[40] + -0.36860768*inputs[41] + 0.13510581*inputs[42] + 0.04069488*inputs[43] + 0.04864728*inputs[44] + 0.52113213*inputs[45] + -0.58004200*inputs[46] + 0.13406499*inputs[47] + 0.10786954*inputs[48] + -0.21435834*inputs[49] + -0.45866625*inputs[50] + -0.31513312*inputs[51] + -0.36282331*inputs[52] + -0.08517138*inputs[53] + -0.14184674*inputs[54] + -0.80838670*inputs[55] + -0.21839270*inputs[56] + -0.06215958*inputs[57] + -0.12234828*inputs[58] + 0.37829888*inputs[59] + 0.60795079*inputs[60] + 1.00037451*inputs[61] + 0.42702539*inputs[62] + 0.07819537*inputs[63] + 1.24294921)

def neuron_60(inputs):
    return relu(0.91722207*inputs[0] + -0.17861355*inputs[1] + 0.07820335*inputs[2] + -0.37964940*inputs[3] + -0.03798282*inputs[4] + -0.11630763*inputs[5] + 0.82796790*inputs[6] + 0.05143012*inputs[7] + 0.18289534*inputs[8] + 0.03956175*inputs[9] + -0.09656528*inputs[10] + 0.55378715*inputs[11] + 0.48830365*inputs[12] + -0.31264147*inputs[13] + -0.29229379*inputs[14] + -0.06945832*inputs[15] + -0.45155792*inputs[16] + -0.25076247*inputs[17] + 0.07976798*inputs[18] + -0.19674243*inputs[19] + -0.07265913*inputs[20] + -0.14807166*inputs[21] + 0.45532833*inputs[22] + 0.22761026*inputs[23] + -0.11642695*inputs[24] + 0.42936512*inputs[25] + 0.70400106*inputs[26] + 0.07753448*inputs[27] + -0.40950270*inputs[28] + 0.08006834*inputs[29] + -0.04682474*inputs[30] + 0.00779307*inputs[31] + 0.07783313*inputs[32] + -0.70031422*inputs[33] + -0.12601888*inputs[34] + 0.28122299*inputs[35] + 0.65323791*inputs[36] + 0.68384066*inputs[37] + 0.02997202*inputs[38] + -0.15052928*inputs[39] + 0.14246514*inputs[40] + -0.55706107*inputs[41] + 0.05274019*inputs[42] + -0.30660748*inputs[43] + 0.16304428*inputs[44] + 0.30431383*inputs[45] + -0.31643435*inputs[46] + 0.00772712*inputs[47] + -0.20847657*inputs[48] + 0.05408168*inputs[49] + -0.08941552*inputs[50] + -0.38859023*inputs[51] + 0.07851512*inputs[52] + 0.77803369*inputs[53] + 0.72553971*inputs[54] + 0.47332877*inputs[55] + -0.46767082*inputs[56] + -0.21595659*inputs[57] + -0.05685239*inputs[58] + -0.49546456*inputs[59] + -0.09176018*inputs[60] + 0.52932614*inputs[61] + -0.57462990*inputs[62] + 0.31616179*inputs[63] + 0.66205709)

def neuron_61(inputs):
    return relu(0.74625376*inputs[0] + -0.14924271*inputs[1] + 0.03954077*inputs[2] + 0.06271375*inputs[3] + -0.28536317*inputs[4] + -0.21107733*inputs[5] + 0.82467922*inputs[6] + -0.18713888*inputs[7] + 0.75440787*inputs[8] + -0.49979801*inputs[9] + 0.14501808*inputs[10] + 0.04963399*inputs[11] + 0.40618782*inputs[12] + 0.46184845*inputs[13] + -0.21708102*inputs[14] + -0.10778634*inputs[15] + 0.03682276*inputs[16] + -0.08107115*inputs[17] + -0.03842568*inputs[18] + 0.11044283*inputs[19] + -0.06512116*inputs[20] + -0.19824397*inputs[21] + 0.66101921*inputs[22] + -0.21190057*inputs[23] + -0.01009038*inputs[24] + -0.23766340*inputs[25] + 0.16836731*inputs[26] + -0.18836619*inputs[27] + 0.13931284*inputs[28] + -0.07363770*inputs[29] + -0.00405160*inputs[30] + -0.19964421*inputs[31] + 0.41909474*inputs[32] + 0.35956132*inputs[33] + -0.09473137*inputs[34] + 0.21885403*inputs[35] + 0.07570000*inputs[36] + 0.26903295*inputs[37] + 0.19108948*inputs[38] + -0.01547089*inputs[39] + 0.04504492*inputs[40] + 0.58455664*inputs[41] + -0.60586440*inputs[42] + -0.09337841*inputs[43] + 0.63479180*inputs[44] + 0.17398442*inputs[45] + 0.10056396*inputs[46] + -0.22645683*inputs[47] + 0.01050707*inputs[48] + -0.17952832*inputs[49] + -0.08454086*inputs[50] + 0.15022208*inputs[51] + -0.19833654*inputs[52] + -0.15861995*inputs[53] + 0.53411228*inputs[54] + 1.22053758*inputs[55] + 0.40775006*inputs[56] + 0.11441835*inputs[57] + -0.16163284*inputs[58] + 0.08008866*inputs[59] + 1.33901323*inputs[60] + 0.23050092*inputs[61] + 0.10231540*inputs[62] + -0.27920968*inputs[63] + 1.65784037)

def neuron_62(inputs):
    return relu(0.09855438*inputs[0] + -0.12567190*inputs[1] + -0.21040344*inputs[2] + 0.72285738*inputs[3] + -0.19252507*inputs[4] + 0.22379761*inputs[5] + 1.12789402*inputs[6] + -0.19691840*inputs[7] + -0.01290807*inputs[8] + -0.16439174*inputs[9] + -0.04367368*inputs[10] + -0.47238069*inputs[11] + -0.51855775*inputs[12] + 0.17311459*inputs[13] + -0.12043887*inputs[14] + 0.31778123*inputs[15] + 0.22480799*inputs[16] + -0.42975576*inputs[17] + 0.12613054*inputs[18] + -0.01629444*inputs[19] + 0.25154453*inputs[20] + 0.15297680*inputs[21] + 1.38983838*inputs[22] + 0.28954823*inputs[23] + 0.27164579*inputs[24] + -0.05130676*inputs[25] + -0.19753802*inputs[26] + -0.19514059*inputs[27] + 0.88826267*inputs[28] + -0.26971018*inputs[29] + 0.41645900*inputs[30] + 0.32299251*inputs[31] + -0.22811822*inputs[32] + 0.57453463*inputs[33] + -0.12909491*inputs[34] + 0.06324073*inputs[35] + -0.29280464*inputs[36] + -0.29035408*inputs[37] + -0.08592553*inputs[38] + -0.05308513*inputs[39] + -0.25319061*inputs[40] + 0.41594176*inputs[41] + -0.40359800*inputs[42] + 0.27696318*inputs[43] + -0.26841660*inputs[44] + -0.07961766*inputs[45] + 0.22198800*inputs[46] + 0.08245247*inputs[47] + -0.28094356*inputs[48] + 0.23317129*inputs[49] + 0.02169275*inputs[50] + 0.12366773*inputs[51] + 0.11824345*inputs[52] + -0.30832878*inputs[53] + -0.78146010*inputs[54] + 0.38108633*inputs[55] + 0.04166961*inputs[56] + 0.43448119*inputs[57] + -0.39627169*inputs[58] + 0.26703214*inputs[59] + -0.64644251*inputs[60] + -0.27228501*inputs[61] + 0.82630471*inputs[62] + -0.61344639*inputs[63] + 0.71363494)

def neuron_63(inputs):
    return relu(-0.33593529*inputs[0] + 0.77217111*inputs[1] + 0.08468755*inputs[2] + 0.72958478*inputs[3] + 0.55553374*inputs[4] + -0.03768743*inputs[5] + 0.22013851*inputs[6] + -0.05485481*inputs[7] + 0.50759143*inputs[8] + -0.08588955*inputs[9] + 0.04192499*inputs[10] + 0.58181375*inputs[11] + -0.09046935*inputs[12] + -0.09989861*inputs[13] + -0.12859035*inputs[14] + -0.07227460*inputs[15] + 0.14611666*inputs[16] + -0.10907222*inputs[17] + -0.06912738*inputs[18] + 0.10993608*inputs[19] + -0.04334562*inputs[20] + 0.26058061*inputs[21] + 0.72786402*inputs[22] + -0.29819491*inputs[23] + -0.28275286*inputs[24] + -0.07445872*inputs[25] + 0.02178124*inputs[26] + -0.16765930*inputs[27] + 0.45593344*inputs[28] + -0.35314991*inputs[29] + 0.27379024*inputs[30] + 0.68517445*inputs[31] + 0.15512736*inputs[32] + 0.52362833*inputs[33] + -0.27130134*inputs[34] + 0.25263408*inputs[35] + -0.20496379*inputs[36] + -0.16190743*inputs[37] + -0.42999962*inputs[38] + -0.27859490*inputs[39] + -0.25188646*inputs[40] + -0.29066053*inputs[41] + -0.26342408*inputs[42] + -0.15856954*inputs[43] + -0.10031118*inputs[44] + -0.33504249*inputs[45] + -0.10383123*inputs[46] + 0.03671309*inputs[47] + 0.24292756*inputs[48] + 0.19814151*inputs[49] + -0.15806695*inputs[50] + -0.05351933*inputs[51] + -0.07359467*inputs[52] + 0.01801864*inputs[53] + -0.33688407*inputs[54] + -0.09280082*inputs[55] + -0.20760412*inputs[56] + 0.62923777*inputs[57] + -0.01765251*inputs[58] + 0.36361745*inputs[59] + 0.08346925*inputs[60] + 0.77456493*inputs[61] + -0.17716800*inputs[62] + -0.26590119*inputs[63] + 0.59695252)

def neuron_64(inputs):
    return -0.76243655*inputs[0] + -0.92306360*inputs[1] + 0.23015192*inputs[2] + -0.01785458*inputs[3] + 0.39448065*inputs[4] + -1.48701747*inputs[5] + -1.13725035*inputs[6] + 0.55389964*inputs[7] + -0.61270109*inputs[8] + -0.62199758*inputs[9] + -1.51847001*inputs[10] + -1.63997118*inputs[11] + -0.33092808*inputs[12] + -0.64028338*inputs[13] + -0.78021319*inputs[14] + -1.12504484*inputs[15] + -0.12557438*inputs[16] + -0.98819736*inputs[17] + -1.33126590*inputs[18] + -0.73082530*inputs[19] + -1.66083020*inputs[20] + -0.50661054*inputs[21] + -1.36124243*inputs[22] + -0.05064032*inputs[23] + -1.08148926*inputs[24] + -0.07584738*inputs[25] + -0.93319587*inputs[26] + 0.55133420*inputs[27] + -1.89624155*inputs[28] + -0.23563513*inputs[29] + 0.49496915*inputs[30] + -0.15716898*inputs[31] + -1.70129403*inputs[32] + -0.18401277*inputs[33] + -0.56721649*inputs[34] + -2.26105543*inputs[35] + -1.67842592*inputs[36] + -0.41220545*inputs[37] + 0.22346473*inputs[38] + -1.23573245*inputs[39] + -1.36042721*inputs[40] + -1.56559397*inputs[41] + -0.71521002*inputs[42] + 0.14191083*inputs[43] + 0.06317665*inputs[44] + -0.60412346*inputs[45] + -0.04824476*inputs[46] + -1.37861905*inputs[47] + 0.30725033*inputs[48] + 0.02523212*inputs[49] + -1.22904682*inputs[50] + -1.14627024*inputs[51] + -0.43040216*inputs[52] + -1.74251694*inputs[53] + 0.49966646*inputs[54] + -1.29682624*inputs[55] + -1.00096414*inputs[56] + -1.19060395*inputs[57] + 0.29363494*inputs[58] + 0.95879481*inputs[59] + -0.97285386*inputs[60] + -1.75669064*inputs[61] + -0.70957467*inputs[62] + -0.31774856*inputs[63] + 0.30357175

def neuron_65(inputs):
    return -1.55690113*inputs[0] + -1.12181683*inputs[1] + -0.08843074*inputs[2] + -0.20178354*inputs[3] + 0.04208702*inputs[4] + -0.77431632*inputs[5] + -0.76854578*inputs[6] + 0.24455611*inputs[7] + -1.57399143*inputs[8] + -0.92211282*inputs[9] + -0.90757898*inputs[10] + -1.17885541*inputs[11] + -1.04241103*inputs[12] + -1.26083183*inputs[13] + -1.10656376*inputs[14] + -0.52612208*inputs[15] + 0.01504911*inputs[16] + -0.58177379*inputs[17] + -1.22855714*inputs[18] + -1.13891060*inputs[19] + -0.60697679*inputs[20] + -1.46629279*inputs[21] + -0.73567474*inputs[22] + 0.43102121*inputs[23] + -0.84558648*inputs[24] + 0.21534436*inputs[25] + 0.09795909*inputs[26] + -0.21915454*inputs[27] + -1.68433930*inputs[28] + 0.18315446*inputs[29] + 0.23083462*inputs[30] + 0.16888065*inputs[31] + -1.04715662*inputs[32] + -1.30967773*inputs[33] + -1.30320831*inputs[34] + -1.34063632*inputs[35] + -1.01462749*inputs[36] + 0.38393888*inputs[37] + -1.44679785*inputs[38] + -0.69593642*inputs[39] + -0.66495407*inputs[40] + -0.93149445*inputs[41] + -1.20267503*inputs[42] + -0.33294339*inputs[43] + -0.22805062*inputs[44] + -0.35817610*inputs[45] + 0.31635916*inputs[46] + -0.87510042*inputs[47] + 0.54402552*inputs[48] + -0.42983337*inputs[49] + -0.37200409*inputs[50] + -1.10154317*inputs[51] + -1.00659458*inputs[52] + -1.32492066*inputs[53] + -0.08570149*inputs[54] + -1.26749606*inputs[55] + -1.22783853*inputs[56] + -0.48581117*inputs[57] + 0.03378919*inputs[58] + -0.30874549*inputs[59] + -1.15451115*inputs[60] + -1.16808814*inputs[61] + -0.21648151*inputs[62] + -0.31190469*inputs[63] + -0.25862061

def neuron_66(inputs):
    return -1.38477067*inputs[0] + -0.29126781*inputs[1] + -0.52124958*inputs[2] + 0.63752745*inputs[3] + 0.11964746*inputs[4] + -0.93298941*inputs[5] + -0.83638782*inputs[6] + -0.21913821*inputs[7] + -1.39656542*inputs[8] + -1.48331405*inputs[9] + -0.90518527*inputs[10] + -0.93708197*inputs[11] + -1.48863885*inputs[12] + -1.13908090*inputs[13] + -1.03568408*inputs[14] + -0.97309324*inputs[15] + -0.04224415*inputs[16] + -1.17786231*inputs[17] + -0.96319782*inputs[18] + -1.42584534*inputs[19] + -1.37490339*inputs[20] + -0.60794518*inputs[21] + -1.63637477*inputs[22] + 0.03073864*inputs[23] + -0.50734156*inputs[24] + -0.04082469*inputs[25] + 0.77662724*inputs[26] + 0.05662860*inputs[27] + -1.26911798*inputs[28] + 0.08486079*inputs[29] + -0.40883454*inputs[30] + -0.37843749*inputs[31] + -0.67577482*inputs[32] + -0.77678480*inputs[33] + -1.25258233*inputs[34] + -1.18685431*inputs[35] + -0.86527989*inputs[36] + 0.35911977*inputs[37] + -1.37662108*inputs[38] + -0.47817384*inputs[39] + -0.72408602*inputs[40] + -0.88672707*inputs[41] + -0.94376932*inputs[42] + 0.27258784*inputs[43] + -0.02079324*inputs[44] + 0.22537593*inputs[45] + -0.38405473*inputs[46] + -0.28370562*inputs[47] + -0.09844311*inputs[48] + -1.25906375*inputs[49] + -1.00641038*inputs[50] + -1.00107950*inputs[51] + -1.29152871*inputs[52] + -0.58868840*inputs[53] + 0.20865940*inputs[54] + -0.94680228*inputs[55] + -0.91620958*inputs[56] + -0.92396459*inputs[57] + -0.19162422*inputs[58] + -0.50115547*inputs[59] + -1.10325760*inputs[60] + -0.70267431*inputs[61] + 0.24939926*inputs[62] + 0.01842060*inputs[63] + -0.31394704

def neuron_67(inputs):
    return -1.19894174*inputs[0] + -1.00847530*inputs[1] + 0.01241481*inputs[2] + -0.17593435*inputs[3] + -0.81021839*inputs[4] + -1.17639875*inputs[5] + -0.78343065*inputs[6] + -0.25396197*inputs[7] + -1.31480379*inputs[8] + -1.38019896*inputs[9] + -1.35533460*inputs[10] + -0.88947107*inputs[11] + -1.14856438*inputs[12] + -1.35373653*inputs[13] + -0.79368668*inputs[14] + -1.05911784*inputs[15] + -0.22651200*inputs[16] + -1.33788690*inputs[17] + -0.24208826*inputs[18] + -1.36248782*inputs[19] + -0.65558612*inputs[20] + -0.78131882*inputs[21] + -1.51939967*inputs[22] + -0.03973899*inputs[23] + -0.32787584*inputs[24] + -0.51332600*inputs[25] + -0.32590036*inputs[26] + 0.30276432*inputs[27] + -0.38487243*inputs[28] + 0.25011588*inputs[29] + 0.14008676*inputs[30] + -0.19750761*inputs[31] + -0.56398228*inputs[32] + -1.00319330*inputs[33] + -1.11978980*inputs[34] + -0.50131273*inputs[35] + -0.65159385*inputs[36] + -0.41488225*inputs[37] + -1.56201646*inputs[38] + -1.72969878*inputs[39] + -0.83927937*inputs[40] + -0.54000497*inputs[41] + -1.24274267*inputs[42] + -0.33301315*inputs[43] + -0.06276541*inputs[44] + 0.06469075*inputs[45] + -0.28707441*inputs[46] + -0.72709359*inputs[47] + -0.08207790*inputs[48] + -1.41347678*inputs[49] + -0.54092675*inputs[50] + -0.87416636*inputs[51] + -1.41193978*inputs[52] + -0.75477493*inputs[53] + 0.80775289*inputs[54] + -1.25233542*inputs[55] + -0.57926654*inputs[56] + -1.34795495*inputs[57] + -0.15724440*inputs[58] + -0.50880546*inputs[59] + -0.33291685*inputs[60] + -0.91912991*inputs[61] + -0.00305334*inputs[62] + -0.49976792*inputs[63] + -0.36363805

def neuron_68(inputs):
    return -1.01959938*inputs[0] + 0.14991533*inputs[1] + -0.41403571*inputs[2] + -0.61124238*inputs[3] + -0.00722399*inputs[4] + -0.62102651*inputs[5] + -1.54913285*inputs[6] + -0.31973838*inputs[7] + -1.37213550*inputs[8] + -1.29637022*inputs[9] + -1.19563198*inputs[10] + -1.23182495*inputs[11] + -1.06238127*inputs[12] + -0.70986530*inputs[13] + -1.56058405*inputs[14] + -1.16340478*inputs[15] + 0.17688264*inputs[16] + -1.08946803*inputs[17] + -1.50631655*inputs[18] + -1.37815960*inputs[19] + -1.08694285*inputs[20] + -0.76305597*inputs[21] + -1.06837268*inputs[22] + 0.92391113*inputs[23] + -2.11527901*inputs[24] + 0.06982737*inputs[25] + 0.49604247*inputs[26] + -0.14761447*inputs[27] + -1.47484438*inputs[28] + -0.34128385*inputs[29] + -0.05211907*inputs[30] + 0.46466418*inputs[31] + -0.83919580*inputs[32] + -1.74960200*inputs[33] + -0.93782628*inputs[34] + -0.46484234*inputs[35] + -0.57479179*inputs[36] + 0.13087711*inputs[37] + -1.21652879*inputs[38] + -0.88514291*inputs[39] + -0.43112002*inputs[40] + -0.97363960*inputs[41] + -0.31345329*inputs[42] + -0.15223537*inputs[43] + 0.01069008*inputs[44] + 0.21890506*inputs[45] + -0.26961371*inputs[46] + -0.42387898*inputs[47] + 0.00389794*inputs[48] + -0.72272538*inputs[49] + -0.74189970*inputs[50] + -0.89258003*inputs[51] + -1.37400461*inputs[52] + -1.21926156*inputs[53] + 0.90159255*inputs[54] + -1.51045365*inputs[55] + -0.91428966*inputs[56] + -1.56707376*inputs[57] + -0.33411839*inputs[58] + -0.60879365*inputs[59] + -1.16220255*inputs[60] + -0.88463558*inputs[61] + 0.08965063*inputs[62] + 0.00127847*inputs[63] + -0.17306069

def neuron_69(inputs):
    return -1.32172411*inputs[0] + -0.75845532*inputs[1] + -0.24023904*inputs[2] + -0.07319207*inputs[3] + -0.11947760*inputs[4] + -1.06963081*inputs[5] + -1.30689700*inputs[6] + -0.12044123*inputs[7] + -1.11834340*inputs[8] + -1.24563079*inputs[9] + -0.91604580*inputs[10] + -1.25136445*inputs[11] + -1.20065013*inputs[12] + -1.13220996*inputs[13] + -1.01469012*inputs[14] + -1.27737801*inputs[15] + -0.05021947*inputs[16] + -0.84444374*inputs[17] + -0.91170146*inputs[18] + -1.15825878*inputs[19] + -0.99229897*inputs[20] + -0.87596989*inputs[21] + -1.24720154*inputs[22] + -0.33689374*inputs[23] + -0.92911016*inputs[24] + -0.21373558*inputs[25] + -0.18277609*inputs[26] + -0.14887668*inputs[27] + -1.09614995*inputs[28] + -0.17448647*inputs[29] + -0.26585780*inputs[30] + -0.07345636*inputs[31] + -1.31981782*inputs[32] + -0.95599304*inputs[33] + -1.07605821*inputs[34] + -1.02426622*inputs[35] + -0.97357447*inputs[36] + -0.09404339*inputs[37] + -0.98670456*inputs[38] + -0.99109862*inputs[39] + -0.97387737*inputs[40] + -0.73036820*inputs[41] + -1.01575284*inputs[42] + -0.18318891*inputs[43] + -0.20604771*inputs[44] + -0.30280747*inputs[45] + 0.33572062*inputs[46] + -0.67643118*inputs[47] + -0.07409868*inputs[48] + -0.94001646*inputs[49] + -0.99782969*inputs[50] + -1.02819837*inputs[51] + -1.12815026*inputs[52] + -0.95408576*inputs[53] + -0.32605932*inputs[54] + -1.42420269*inputs[55] + -1.00274886*inputs[56] + -1.04591735*inputs[57] + -0.13359769*inputs[58] + -0.21260023*inputs[59] + -1.10647059*inputs[60] + -1.24954476*inputs[61] + -0.30544140*inputs[62] + -0.03708029*inputs[63] + 4.05693204

def neuron_70(inputs):
    return -1.19141956*inputs[0] + -0.08773713*inputs[1] + -0.39321265*inputs[2] + -0.21959678*inputs[3] + -0.74947374*inputs[4] + -1.19714536*inputs[5] + -1.49164748*inputs[6] + 0.00150364*inputs[7] + -0.78036829*inputs[8] + -1.39559940*inputs[9] + -1.29233112*inputs[10] + -1.03639739*inputs[11] + -0.95088323*inputs[12] + -1.58134969*inputs[13] + -0.76584127*inputs[14] + -0.95029049*inputs[15] + -0.15096557*inputs[16] + -0.90615953*inputs[17] + -0.50618421*inputs[18] + -0.52327832*inputs[19] + -1.27447966*inputs[20] + -1.07799424*inputs[21] + -0.72012749*inputs[22] + -0.25755676*inputs[23] + -0.32377609*inputs[24] + 0.21912223*inputs[25] + 0.33096315*inputs[26] + -0.07386371*inputs[27] + -0.92276328*inputs[28] + -0.25671427*inputs[29] + 0.01592126*inputs[30] + -0.39302988*inputs[31] + -0.96153495*inputs[32] + -1.51783331*inputs[33] + -1.63119590*inputs[34] + -0.80473978*inputs[35] + -0.19448465*inputs[36] + -0.15210006*inputs[37] + -0.99734124*inputs[38] + -1.18558962*inputs[39] + -1.32694722*inputs[40] + -0.48048956*inputs[41] + -1.42471777*inputs[42] + -0.21607908*inputs[43] + -0.33466244*inputs[44] + 0.18194359*inputs[45] + 0.11247813*inputs[46] + -0.07939763*inputs[47] + -0.17147924*inputs[48] + -1.60977798*inputs[49] + -1.34927456*inputs[50] + -0.66185630*inputs[51] + -1.38958823*inputs[52] + -0.24780129*inputs[53] + 0.21965821*inputs[54] + -1.23041454*inputs[55] + -1.30896950*inputs[56] + -1.22558399*inputs[57] + 0.43830414*inputs[58] + -0.00774448*inputs[59] + -1.19043044*inputs[60] + -1.42849160*inputs[61] + -0.08363173*inputs[62] + 0.47427241*inputs[63] + -0.54955144

def neuron_71(inputs):
    return -0.90546860*inputs[0] + -0.74100457*inputs[1] + -0.21513879*inputs[2] + 0.26773554*inputs[3] + -0.18911640*inputs[4] + -1.20399200*inputs[5] + -1.24642468*inputs[6] + 0.77294077*inputs[7] + -0.82059380*inputs[8] + -1.36088965*inputs[9] + -1.27328717*inputs[10] + -1.03872461*inputs[11] + -0.90397018*inputs[12] + -1.21748175*inputs[13] + -0.83899760*inputs[14] + -0.91570304*inputs[15] + -0.14825073*inputs[16] + -1.03132840*inputs[17] + -1.04112449*inputs[18] + -1.04195564*inputs[19] + -1.32539946*inputs[20] + -1.28863617*inputs[21] + -1.27480310*inputs[22] + 0.06929071*inputs[23] + -0.60721105*inputs[24] + -0.27384367*inputs[25] + -0.32649500*inputs[26] + 0.01189059*inputs[27] + -0.71663212*inputs[28] + -0.20076500*inputs[29] + -0.00822882*inputs[30] + -0.40386409*inputs[31] + -1.22224881*inputs[32] + -1.39369673*inputs[33] + -1.23973376*inputs[34] + -1.09673838*inputs[35] + -0.49803288*inputs[36] + -0.43233786*inputs[37] + -0.49628232*inputs[38] + -0.91073383*inputs[39] + -0.69210700*inputs[40] + -0.63872098*inputs[41] + -0.89429175*inputs[42] + 0.17850176*inputs[43] + 0.14393765*inputs[44] + 0.06143690*inputs[45] + 0.23951723*inputs[46] + -1.12877020*inputs[47] + 0.00458867*inputs[48] + -0.47831873*inputs[49] + -1.32176702*inputs[50] + -0.51629589*inputs[51] + -1.42199285*inputs[52] + -1.11957180*inputs[53] + 0.33830848*inputs[54] + -1.22501709*inputs[55] + -0.49857003*inputs[56] + -0.88543941*inputs[57] + -0.10274335*inputs[58] + 0.06647542*inputs[59] + -1.14633999*inputs[60] + -1.23573454*inputs[61] + 0.30634420*inputs[62] + -0.33501460*inputs[63] + -0.37328985

def neuron_72(inputs):
    return -1.18789865*inputs[0] + -0.61529496*inputs[1] + -0.34758875*inputs[2] + 0.27629648*inputs[3] + -0.16862332*inputs[4] + -1.25442676*inputs[5] + -0.71771873*inputs[6] + -0.39489728*inputs[7] + -1.09358447*inputs[8] + -0.76673799*inputs[9] + -1.27304560*inputs[10] + -1.14480965*inputs[11] + -1.03640147*inputs[12] + -0.89543538*inputs[13] + -0.85819070*inputs[14] + -1.07979459*inputs[15] + -0.11969737*inputs[16] + -1.08467832*inputs[17] + -0.43717805*inputs[18] + -1.25086124*inputs[19] + -1.28016778*inputs[20] + -0.62650738*inputs[21] + -1.55415572*inputs[22] + 0.18235524*inputs[23] + -0.67348522*inputs[24] + -0.27913317*inputs[25] + -0.10143685*inputs[26] + 0.21836866*inputs[27] + -0.72965467*inputs[28] + -0.34133656*inputs[29] + 0.32955520*inputs[30] + 0.02476182*inputs[31] + -1.01861768*inputs[32] + -1.26830386*inputs[33] + -1.05093954*inputs[34] + -1.10941763*inputs[35] + -0.56990390*inputs[36] + -0.32025026*inputs[37] + -0.90819403*inputs[38] + -1.19472270*inputs[39] + -1.15932490*inputs[40] + -0.80577996*inputs[41] + -0.75413102*inputs[42] + -0.26397832*inputs[43] + -0.12898377*inputs[44] + 0.20201299*inputs[45] + -0.02919130*inputs[46] + -0.98391971*inputs[47] + 0.09974864*inputs[48] + -0.63409650*inputs[49] + -1.35667482*inputs[50] + -0.74115265*inputs[51] + -1.49066836*inputs[52] + -0.78135673*inputs[53] + 0.35160397*inputs[54] + -1.19139455*inputs[55] + -1.29587456*inputs[56] + -0.65716262*inputs[57] + -0.04175627*inputs[58] + 0.19558467*inputs[59] + -1.09683419*inputs[60] + -1.29527940*inputs[61] + -0.09673598*inputs[62] + -0.09423741*inputs[63] + -0.46925391

def neuron_73(inputs):
    return -0.63456728*inputs[0] + -0.98656775*inputs[1] + 0.06131171*inputs[2] + -0.19076198*inputs[3] + 0.65989648*inputs[4] + -0.62763256*inputs[5] + -0.75250051*inputs[6] + -0.05410688*inputs[7] + -1.37371980*inputs[8] + -1.39174075*inputs[9] + -1.01839571*inputs[10] + -1.25158911*inputs[11] + -0.74169925*inputs[12] + -1.17250873*inputs[13] + -0.93725754*inputs[14] + -1.10516177*inputs[15] + -0.02870914*inputs[16] + -0.98170450*inputs[17] + -0.86692883*inputs[18] + -1.19347368*inputs[19] + -1.29752802*inputs[20] + -1.44332807*inputs[21] + -1.06202007*inputs[22] + 0.02539852*inputs[23] + -0.82819198*inputs[24] + -0.62828865*inputs[25] + -0.39211423*inputs[26] + -0.33279210*inputs[27] + -0.93354718*inputs[28] + -0.14482843*inputs[29] + -0.26072090*inputs[30] + -0.15419668*inputs[31] + -1.11022827*inputs[32] + -0.70635349*inputs[33] + -1.27698570*inputs[34] + -1.27653569*inputs[35] + -1.02420052*inputs[36] + -0.00373878*inputs[37] + -0.58564776*inputs[38] + -0.64816443*inputs[39] + -0.86854929*inputs[40] + -1.16993286*inputs[41] + -1.11049058*inputs[42] + 0.39008531*inputs[43] + -0.22370215*inputs[44] + 0.21275119*inputs[45] + -0.17407959*inputs[46] + -1.39293281*inputs[47] + 0.06015316*inputs[48] + -0.50561585*inputs[49] + -1.00369718*inputs[50] + -0.64170545*inputs[51] + -1.49492299*inputs[52] + -0.88755163*inputs[53] + 0.74465434*inputs[54] + -1.34741396*inputs[55] + -0.70601183*inputs[56] + -1.17973925*inputs[57] + 0.00917493*inputs[58] + -0.37472752*inputs[59] + -1.36583938*inputs[60] + -0.91402740*inputs[61] + 0.92697299*inputs[62] + -0.07274460*inputs[63] + -0.25580015

def neuron_74(inputs):
    return -1.08899592*inputs[0] + -0.36213486*inputs[1] + -0.19437462*inputs[2] + 0.00047092*inputs[3] + -0.41922418*inputs[4] + -1.26430094*inputs[5] + -0.90934540*inputs[6] + -0.38201487*inputs[7] + -0.80566869*inputs[8] + -0.87992270*inputs[9] + -1.01285842*inputs[10] + -1.19066249*inputs[11] + -1.40214098*inputs[12] + -0.58742786*inputs[13] + -1.44988828*inputs[14] + -1.07001154*inputs[15] + 0.33481855*inputs[16] + -1.18071681*inputs[17] + -0.81566450*inputs[18] + -1.19779347*inputs[19] + -0.80718232*inputs[20] + -0.57394889*inputs[21] + -1.06177357*inputs[22] + 0.02181030*inputs[23] + -0.97548135*inputs[24] + -0.02902747*inputs[25] + 0.29800244*inputs[26] + 0.01822599*inputs[27] + -0.90283778*inputs[28] + 0.51788038*inputs[29] + -0.32893424*inputs[30] + 0.13360314*inputs[31] + -1.11358233*inputs[32] + -0.84590896*inputs[33] + -1.16714957*inputs[34] + -1.29312454*inputs[35] + -0.66899019*inputs[36] + 0.37387039*inputs[37] + -1.54902933*inputs[38] + -1.21925107*inputs[39] + -1.17233298*inputs[40] + -0.86487464*inputs[41] + -1.10365719*inputs[42] + -0.23453681*inputs[43] + 0.05914868*inputs[44] + 0.24524703*inputs[45] + -0.05466176*inputs[46] + -0.35674693*inputs[47] + 0.03503395*inputs[48] + -1.32684270*inputs[49] + -1.06847649*inputs[50] + -0.94283285*inputs[51] + -0.90679715*inputs[52] + -1.47145123*inputs[53] + 0.24601593*inputs[54] + -1.38704909*inputs[55] + -0.98602661*inputs[56] + -1.36896448*inputs[57] + -0.32038705*inputs[58] + -0.08429960*inputs[59] + -1.09906665*inputs[60] + -1.34669315*inputs[61] + 0.16057625*inputs[62] + 0.31459483*inputs[63] + -0.33597885

def neuron_75(inputs):
    return -1.39617681*inputs[0] + -0.86354230*inputs[1] + -0.09194498*inputs[2] + -0.46967451*inputs[3] + -0.12296822*inputs[4] + -0.95843565*inputs[5] + -0.19721160*inputs[6] + -0.26221866*inputs[7] + -0.87765855*inputs[8] + -1.13196156*inputs[9] + -1.28134061*inputs[10] + -0.94601397*inputs[11] + -1.42943732*inputs[12] + -1.18170508*inputs[13] + -0.67467294*inputs[14] + -1.08085320*inputs[15] + -0.01162294*inputs[16] + -0.93819989*inputs[17] + -0.57095423*inputs[18] + -1.17362364*inputs[19] + -0.63208640*inputs[20] + -0.76601602*inputs[21] + -1.53196496*inputs[22] + 0.50347179*inputs[23] + -1.67313029*inputs[24] + -0.16057961*inputs[25] + -0.97356609*inputs[26] + -0.10806157*inputs[27] + -0.69138439*inputs[28] + -0.41432257*inputs[29] + -0.15894766*inputs[30] + -0.24595415*inputs[31] + -0.61136152*inputs[32] + -1.47570840*inputs[33] + -1.25753491*inputs[34] + -0.74115932*inputs[35] + -1.73517145*inputs[36] + 0.06574453*inputs[37] + -1.16852209*inputs[38] + -1.41129356*inputs[39] + -0.76519361*inputs[40] + -0.02638996*inputs[41] + -0.37933095*inputs[42] + -0.21225360*inputs[43] + 0.30055627*inputs[44] + 0.48333628*inputs[45] + -0.52588747*inputs[46] + -1.37810853*inputs[47] + -0.15931811*inputs[48] + -1.59706964*inputs[49] + -0.75251021*inputs[50] + -0.48338660*inputs[51] + -1.58309536*inputs[52] + -0.83123725*inputs[53] + -0.03512676*inputs[54] + -0.55232931*inputs[55] + -0.88306254*inputs[56] + -1.33580498*inputs[57] + -0.25470232*inputs[58] + -0.38276466*inputs[59] + -1.22195805*inputs[60] + -0.89062477*inputs[61] + 0.60441763*inputs[62] + 0.49387099*inputs[63] + -0.20677620

def neuron_76(inputs):
    return -1.21206977*inputs[0] + -1.74124324*inputs[1] + 0.20183181*inputs[2] + 0.70726150*inputs[3] + 0.30077673*inputs[4] + -0.42084456*inputs[5] + -1.90942350*inputs[6] + -0.07750039*inputs[7] + -1.61760350*inputs[8] + -1.38622523*inputs[9] + -0.51459707*inputs[10] + -0.84700751*inputs[11] + -1.47446321*inputs[12] + -0.63471957*inputs[13] + -1.23376606*inputs[14] + -0.66991585*inputs[15] + -0.06096424*inputs[16] + -1.04957512*inputs[17] + -1.43509912*inputs[18] + -1.63758306*inputs[19] + -1.25661517*inputs[20] + -0.18841687*inputs[21] + -0.85067967*inputs[22] + 0.16369645*inputs[23] + -0.59936487*inputs[24] + 0.26820688*inputs[25] + 0.39678173*inputs[26] + 0.01612143*inputs[27] + -0.57757837*inputs[28] + -0.03007311*inputs[29] + -0.83807232*inputs[30] + -0.63463006*inputs[31] + -1.24281823*inputs[32] + -0.68659086*inputs[33] + -1.44606776*inputs[34] + 0.01168459*inputs[35] + -1.01854598*inputs[36] + 0.59699126*inputs[37] + -0.91990450*inputs[38] + -0.53482007*inputs[39] + -1.00822343*inputs[40] + -0.63762267*inputs[41] + -1.53163346*inputs[42] + 0.18697963*inputs[43] + 0.32518820*inputs[44] + -0.70055103*inputs[45] + 0.00257507*inputs[46] + -1.25582089*inputs[47] + 0.48573232*inputs[48] + -1.29079250*inputs[49] + -0.13452704*inputs[50] + -0.80115654*inputs[51] + -1.23300709*inputs[52] + -0.85605386*inputs[53] + 0.29956619*inputs[54] + -0.77410375*inputs[55] + -1.56710388*inputs[56] + -0.89254114*inputs[57] + -0.04002275*inputs[58] + -0.76024805*inputs[59] + -0.83644662*inputs[60] + -1.27739786*inputs[61] + 0.09636026*inputs[62] + -0.36830688*inputs[63] + 0.03123301

def neuron_77(inputs):
    return -1.31374331*inputs[0] + -0.82885880*inputs[1] + -0.14861383*inputs[2] + 0.19751898*inputs[3] + -0.42024790*inputs[4] + -1.25689599*inputs[5] + -1.20563102*inputs[6] + -0.23722561*inputs[7] + -1.21302972*inputs[8] + -1.40154254*inputs[9] + -0.75743269*inputs[10] + -0.93333260*inputs[11] + -1.33887519*inputs[12] + -1.08104020*inputs[13] + -1.30248159*inputs[14] + -1.07036285*inputs[15] + -0.25304993*inputs[16] + -1.24642802*inputs[17] + -0.84048070*inputs[18] + -1.28873579*inputs[19] + -1.06741871*inputs[20] + -0.87454125*inputs[21] + -1.15505867*inputs[22] + 0.14542614*inputs[23] + -0.48523979*inputs[24] + -0.24281952*inputs[25] + 0.48968226*inputs[26] + 0.36765960*inputs[27] + -1.05327966*inputs[28] + -0.27076383*inputs[29] + -0.27315694*inputs[30] + -0.08670587*inputs[31] + -1.16025466*inputs[32] + -1.36917791*inputs[33] + -1.14717063*inputs[34] + -0.57203560*inputs[35] + -0.89170828*inputs[36] + -0.28140382*inputs[37] + -0.54476492*inputs[38] + -1.14288149*inputs[39] + -0.59687831*inputs[40] + -0.68670673*inputs[41] + -0.97926114*inputs[42] + -0.39579950*inputs[43] + 0.46859085*inputs[44] + -0.15506013*inputs[45] + 0.62866481*inputs[46] + -0.68471275*inputs[47] + -0.07998367*inputs[48] + -0.80996713*inputs[49] + -1.28134170*inputs[50] + -1.08853883*inputs[51] + -0.98458078*inputs[52] + -0.66826994*inputs[53] + 0.09592210*inputs[54] + -0.99386783*inputs[55] + -0.88945209*inputs[56] + -0.41095098*inputs[57] + -0.26579368*inputs[58] + 0.31674153*inputs[59] + -1.00971852*inputs[60] + -1.55173653*inputs[61] + -0.44871051*inputs[62] + -0.31162415*inputs[63] + -0.38635847

def neuron_78(inputs):
    return -1.59247750*inputs[0] + -1.22694043*inputs[1] + -0.43900719*inputs[2] + 0.21047021*inputs[3] + -0.43637375*inputs[4] + -0.84924305*inputs[5] + -0.81066688*inputs[6] + 0.10444995*inputs[7] + -1.76455491*inputs[8] + -1.27912923*inputs[9] + -0.94945183*inputs[10] + -1.36494477*inputs[11] + -1.18349334*inputs[12] + -0.65596945*inputs[13] + -0.11487016*inputs[14] + -1.15972644*inputs[15] + -0.08072576*inputs[16] + -0.77355192*inputs[17] + -0.57696996*inputs[18] + -0.54427804*inputs[19] + -1.33602649*inputs[20] + -1.15255517*inputs[21] + -1.35849277*inputs[22] + 0.01715960*inputs[23] + -0.76400207*inputs[24] + -0.02120760*inputs[25] + 0.49371913*inputs[26] + -0.56738793*inputs[27] + -1.03133225*inputs[28] + -0.32936541*inputs[29] + 0.13907040*inputs[30] + 0.21478218*inputs[31] + -1.12703593*inputs[32] + -1.07862469*inputs[33] + -1.49691410*inputs[34] + -0.80737457*inputs[35] + -0.15364762*inputs[36] + -0.42501424*inputs[37] + -0.03763343*inputs[38] + -1.05125395*inputs[39] + -0.81553442*inputs[40] + -1.03967641*inputs[41] + -1.03868088*inputs[42] + -0.22223078*inputs[43] + -0.51124404*inputs[44] + 0.25313077*inputs[45] + -0.36624082*inputs[46] + 0.05882762*inputs[47] + -0.18743237*inputs[48] + -1.27369178*inputs[49] + -1.72589966*inputs[50] + -1.50719025*inputs[51] + -1.55109261*inputs[52] + -0.28235495*inputs[53] + -0.09504198*inputs[54] + -0.56505638*inputs[55] + -1.00911780*inputs[56] + -0.20978055*inputs[57] + 0.48597078*inputs[58] + -0.14046194*inputs[59] + -0.90777372*inputs[60] + -1.53934105*inputs[61] + -0.02357626*inputs[62] + 0.12985860*inputs[63] + -0.07308131

def neuron_79(inputs):
    return -1.27259051*inputs[0] + -0.74467170*inputs[1] + -0.14039410*inputs[2] + -0.39869367*inputs[3] + 0.45721331*inputs[4] + -0.68099269*inputs[5] + -1.08691248*inputs[6] + -0.36363910*inputs[7] + -0.83593194*inputs[8] + -1.48825314*inputs[9] + -1.35441561*inputs[10] + -1.04992818*inputs[11] + -0.73458994*inputs[12] + -1.47980865*inputs[13] + -0.41089994*inputs[14] + -1.18257087*inputs[15] + -0.12993865*inputs[16] + -0.72812224*inputs[17] + -1.24218055*inputs[18] + -1.05360443*inputs[19] + -1.04029085*inputs[20] + -1.07348975*inputs[21] + -1.55737537*inputs[22] + -0.04830598*inputs[23] + -1.05449778*inputs[24] + 0.22349785*inputs[25] + 0.11100894*inputs[26] + -0.37868567*inputs[27] + -1.58663994*inputs[28] + -0.29124479*inputs[29] + 0.34207750*inputs[30] + 0.28840613*inputs[31] + -0.84972056*inputs[32] + -1.30672165*inputs[33] + -1.06984557*inputs[34] + -0.65898494*inputs[35] + -0.77480370*inputs[36] + 0.33515785*inputs[37] + -0.59184147*inputs[38] + -1.29432749*inputs[39] + -0.42522435*inputs[40] + -1.22480569*inputs[41] + -1.18867199*inputs[42] + 0.06611993*inputs[43] + -0.17394414*inputs[44] + -0.04865527*inputs[45] + 0.23119766*inputs[46] + -0.54977868*inputs[47] + -0.17959905*inputs[48] + -0.69762852*inputs[49] + -1.23288760*inputs[50] + -0.68847814*inputs[51] + -1.20972837*inputs[52] + -0.56172810*inputs[53] + 0.35561997*inputs[54] + -1.46490026*inputs[55] + -1.11025800*inputs[56] + -1.38022570*inputs[57] + 0.12649463*inputs[58] + 0.15258099*inputs[59] + -1.30970146*inputs[60] + -1.20334825*inputs[61] + -0.25965610*inputs[62] + 0.30538928*inputs[63] + -0.36423242

def neuron_80(inputs):
    return -1.15281057*inputs[0] + -1.12434152*inputs[1] + 0.55670290*inputs[2] + -0.24168783*inputs[3] + 0.09518950*inputs[4] + -1.89635924*inputs[5] + -0.13745048*inputs[6] + 0.79937098*inputs[7] + -0.27883272*inputs[8] + -2.41971667*inputs[9] + -0.30228425*inputs[10] + -1.46986086*inputs[11] + -1.36125700*inputs[12] + -1.18764427*inputs[13] + -0.20854889*inputs[14] + -1.02021884*inputs[15] + -0.13144586*inputs[16] + -0.83429721*inputs[17] + -1.58774418*inputs[18] + -1.61341556*inputs[19] + -1.40576083*inputs[20] + -0.45315639*inputs[21] + -0.84899886*inputs[22] + 0.64681713*inputs[23] + -0.42602163*inputs[24] + 0.44814457*inputs[25] + 0.12752092*inputs[26] + -0.00229267*inputs[27] + -1.62653065*inputs[28] + -0.45279746*inputs[29] + 0.42919661*inputs[30] + 0.13885233*inputs[31] + -0.90595383*inputs[32] + -1.45403697*inputs[33] + -1.63542875*inputs[34] + -0.96523697*inputs[35] + -1.28454391*inputs[36] + -0.52848293*inputs[37] + 0.22847181*inputs[38] + -0.96244208*inputs[39] + 0.06912745*inputs[40] + -0.70163757*inputs[41] + -0.72153912*inputs[42] + 0.35086850*inputs[43] + 0.12120636*inputs[44] + -1.25488983*inputs[45] + -0.14408520*inputs[46] + -0.94400909*inputs[47] + -0.00779903*inputs[48] + -0.41046597*inputs[49] + -1.78710908*inputs[50] + -1.01066438*inputs[51] + -1.15870529*inputs[52] + -1.07492406*inputs[53] + -0.92208122*inputs[54] + -2.02920095*inputs[55] + -0.35868986*inputs[56] + -0.92089798*inputs[57] + 0.30891567*inputs[58] + 0.56896737*inputs[59] + 0.28689580*inputs[60] + -0.75440699*inputs[61] + -0.76812340*inputs[62] + -0.21546619*inputs[63] + 0.34831641

def neuron_81(inputs):
    return -0.98929293*inputs[0] + -0.66989138*inputs[1] + -0.17014823*inputs[2] + 0.24829810*inputs[3] + -0.12206995*inputs[4] + -0.86136497*inputs[5] + -1.06032798*inputs[6] + -0.20610699*inputs[7] + -0.90303901*inputs[8] + -0.48170264*inputs[9] + -0.72032563*inputs[10] + -1.49085930*inputs[11] + -0.99665614*inputs[12] + -1.35964781*inputs[13] + -1.09816309*inputs[14] + -0.58265901*inputs[15] + -0.31149273*inputs[16] + -1.07248013*inputs[17] + -1.21594385*inputs[18] + -1.09075299*inputs[19] + -1.19546804*inputs[20] + -1.11401717*inputs[21] + -1.63157702*inputs[22] + 0.54334035*inputs[23] + -1.05285232*inputs[24] + -0.02164035*inputs[25] + -0.20724224*inputs[26] + -0.30825974*inputs[27] + -1.24841943*inputs[28] + 0.57670518*inputs[29] + 0.61987440*inputs[30] + 0.00296658*inputs[31] + -1.10859921*inputs[32] + -1.26241805*inputs[33] + -1.01656733*inputs[34] + -1.14310073*inputs[35] + -1.17663894*inputs[36] + 0.50708937*inputs[37] + -0.75428121*inputs[38] + -0.53834519*inputs[39] + -0.09609963*inputs[40] + -1.22854448*inputs[41] + -0.85301489*inputs[42] + 0.22300168*inputs[43] + 0.17151870*inputs[44] + -0.37134750*inputs[45] + -0.31183390*inputs[46] + -1.20899541*inputs[47] + -0.12174288*inputs[48] + -1.14666226*inputs[49] + -1.13997966*inputs[50] + -1.23483638*inputs[51] + -1.13699501*inputs[52] + -0.59573288*inputs[53] + -0.28109289*inputs[54] + -0.99238802*inputs[55] + -1.20706241*inputs[56] + -0.74421077*inputs[57] + -0.26115727*inputs[58] + -0.20508696*inputs[59] + -0.83013511*inputs[60] + -1.44328365*inputs[61] + -0.05329937*inputs[62] + -0.22872582*inputs[63] + -0.22610582

def neuron_82(inputs):
    return -0.44770690*inputs[0] + -1.00035735*inputs[1] + 0.30479181*inputs[2] + 0.18615091*inputs[3] + -0.07325946*inputs[4] + -1.36977795*inputs[5] + -1.47634098*inputs[6] + -0.15873870*inputs[7] + -0.75982694*inputs[8] + -1.35470154*inputs[9] + -0.76995063*inputs[10] + -0.85560757*inputs[11] + -1.66976649*inputs[12] + -0.82761340*inputs[13] + -1.30369986*inputs[14] + -1.51247287*inputs[15] + -0.11623407*inputs[16] + -1.03533271*inputs[17] + -1.43009871*inputs[18] + -0.95404798*inputs[19] + -1.04080550*inputs[20] + -1.66161571*inputs[21] + -1.07184522*inputs[22] + -0.05890255*inputs[23] + -1.61318471*inputs[24] + 0.17129490*inputs[25] + -0.09931579*inputs[26] + -0.76482734*inputs[27] + -1.64955833*inputs[28] + 0.46452189*inputs[29] + -0.21065615*inputs[30] + 0.47856650*inputs[31] + -1.51549291*inputs[32] + -1.07943484*inputs[33] + -1.14133967*inputs[34] + -1.64022178*inputs[35] + -1.34315693*inputs[36] + -0.11850350*inputs[37] + -0.86424330*inputs[38] + -1.16262617*inputs[39] + -1.04257654*inputs[40] + -1.00883301*inputs[41] + -0.78880911*inputs[42] + -0.16708405*inputs[43] + -0.20861969*inputs[44] + 0.07548841*inputs[45] + 0.26940930*inputs[46] + -1.17175005*inputs[47] + -0.16914968*inputs[48] + -0.94286429*inputs[49] + -1.12283714*inputs[50] + -0.77574672*inputs[51] + -0.73744077*inputs[52] + -0.99865206*inputs[53] + -0.70260008*inputs[54] + -0.77638797*inputs[55] + -0.57422920*inputs[56] + -0.43030939*inputs[57] + -0.10241999*inputs[58] + 0.10587672*inputs[59] + -0.96740668*inputs[60] + -0.58298981*inputs[61] + 0.02257299*inputs[62] + 0.15304830*inputs[63] + -0.29100735

def neuron_83(inputs):
    return -1.09693224*inputs[0] + -0.60437199*inputs[1] + 0.36498619*inputs[2] + -0.32597282*inputs[3] + 0.28559988*inputs[4] + -1.10702895*inputs[5] + -1.16320528*inputs[6] + -0.14365996*inputs[7] + -0.98512540*inputs[8] + -0.85319845*inputs[9] + -1.26399819*inputs[10] + -1.39528920*inputs[11] + -1.30535464*inputs[12] + -0.85719293*inputs[13] + -0.96654589*inputs[14] + -1.15543875*inputs[15] + 0.10185235*inputs[16] + -0.87497006*inputs[17] + -1.30113053*inputs[18] + -1.36424734*inputs[19] + -1.05718209*inputs[20] + -1.29611157*inputs[21] + -0.99347442*inputs[22] + -0.20992020*inputs[23] + -0.94754182*inputs[24] + 0.26157384*inputs[25] + 0.38207927*inputs[26] + -0.51883555*inputs[27] + -0.92773032*inputs[28] + -0.07515681*inputs[29] + -0.17802989*inputs[30] + 0.58752487*inputs[31] + -0.94564928*inputs[32] + -0.70609504*inputs[33] + -1.06150165*inputs[34] + -1.22882391*inputs[35] + -0.55417364*inputs[36] + 0.74403004*inputs[37] + -0.82247211*inputs[38] + -1.29278772*inputs[39] + -0.87162843*inputs[40] + -1.00818868*inputs[41] + -1.21278285*inputs[42] + 0.24056556*inputs[43] + -0.28352922*inputs[44] + 0.24819500*inputs[45] + 0.07232913*inputs[46] + -0.66161468*inputs[47] + -0.14034697*inputs[48] + -0.79910257*inputs[49] + -1.35142794*inputs[50] + -1.24987904*inputs[51] + -0.77147672*inputs[52] + -1.45907637*inputs[53] + -0.08068387*inputs[54] + -1.31962334*inputs[55] + -0.99181715*inputs[56] + -0.94523270*inputs[57] + -0.21127227*inputs[58] + -0.44024431*inputs[59] + -1.28675943*inputs[60] + -1.22555086*inputs[61] + 0.46780823*inputs[62] + 0.23608477*inputs[63] + -0.32243664

def neuron_84(inputs):
    return -0.93845425*inputs[0] + -0.95220777*inputs[1] + 0.11934525*inputs[2] + 0.37028967*inputs[3] + -0.31241545*inputs[4] + -0.59488278*inputs[5] + -1.36004701*inputs[6] + -0.26419190*inputs[7] + -1.07074270*inputs[8] + -0.89884948*inputs[9] + -1.17045389*inputs[10] + -1.43628270*inputs[11] + -1.67446850*inputs[12] + -1.32676642*inputs[13] + -1.29748132*inputs[14] + -0.30523581*inputs[15] + -0.33309155*inputs[16] + -0.76055820*inputs[17] + -1.19419181*inputs[18] + -1.04249292*inputs[19] + -0.41096045*inputs[20] + -0.85657915*inputs[21] + -1.33934142*inputs[22] + -0.07439511*inputs[23] + -1.19391629*inputs[24] + 0.01500777*inputs[25] + 0.25328244*inputs[26] + 0.29758704*inputs[27] + -1.60288423*inputs[28] + 0.35424283*inputs[29] + 0.31469501*inputs[30] + 0.26313930*inputs[31] + -0.99420162*inputs[32] + -0.81704021*inputs[33] + -1.23643442*inputs[34] + -1.26873352*inputs[35] + -0.97852705*inputs[36] + -0.41957250*inputs[37] + -0.93466727*inputs[38] + -0.66042077*inputs[39] + -0.76923635*inputs[40] + -1.15662201*inputs[41] + -0.27797423*inputs[42] + -0.19644467*inputs[43] + -0.05119668*inputs[44] + -0.29160328*inputs[45] + 0.33235742*inputs[46] + -1.10303891*inputs[47] + 0.05472667*inputs[48] + -1.06540904*inputs[49] + -0.90932013*inputs[50] + -1.27971129*inputs[51] + -0.90067293*inputs[52] + -1.49424356*inputs[53] + -0.32723636*inputs[54] + -1.22603361*inputs[55] + -1.23064957*inputs[56] + -0.36533125*inputs[57] + -0.01495901*inputs[58] + -0.33437252*inputs[59] + -0.97993493*inputs[60] + -1.43036340*inputs[61] + -0.46036960*inputs[62] + -0.02485766*inputs[63] + -0.24341765

def neuron_85(inputs):
    return -1.19594501*inputs[0] + -0.72575662*inputs[1] + 0.04766975*inputs[2] + 0.36564709*inputs[3] + -0.35012971*inputs[4] + -1.22418917*inputs[5] + -1.39193980*inputs[6] + 0.45192378*inputs[7] + -0.74997406*inputs[8] + -1.67649834*inputs[9] + -1.02626160*inputs[10] + -0.97098356*inputs[11] + -1.06436331*inputs[12] + -0.76125089*inputs[13] + -1.03364040*inputs[14] + -1.02181329*inputs[15] + -0.25105502*inputs[16] + -1.17345808*inputs[17] + -0.72532884*inputs[18] + -0.69713534*inputs[19] + -0.58446018*inputs[20] + -1.11107733*inputs[21] + -1.51802799*inputs[22] + 0.04570945*inputs[23] + -1.30253825*inputs[24] + -0.35522893*inputs[25] + 0.03139130*inputs[26] + 0.26961238*inputs[27] + -1.10859688*inputs[28] + 0.56345700*inputs[29] + 0.44378790*inputs[30] + -0.50752228*inputs[31] + -0.94528104*inputs[32] + -1.53909167*inputs[33] + -1.11446438*inputs[34] + -0.55404019*inputs[35] + -0.77470478*inputs[36] + -0.26111137*inputs[37] + -1.13414492*inputs[38] + -0.89217415*inputs[39] + -0.44034665*inputs[40] + -0.19343936*inputs[41] + -0.86171904*inputs[42] + -0.33166596*inputs[43] + 0.37793239*inputs[44] + -0.17496241*inputs[45] + 0.01189711*inputs[46] + -0.91606694*inputs[47] + -0.18431547*inputs[48] + -1.04661156*inputs[49] + -0.95799304*inputs[50] + -0.87792031*inputs[51] + -1.18872466*inputs[52] + -1.28228318*inputs[53] + -0.15275197*inputs[54] + -1.27014888*inputs[55] + -0.95925922*inputs[56] + -0.71126795*inputs[57] + -0.33880891*inputs[58] + 0.25711705*inputs[59] + -0.67589027*inputs[60] + -1.22570099*inputs[61] + -0.18541799*inputs[62] + -0.42766124*inputs[63] + -0.28288869

def neuron_86(inputs):
    return -1.05050149*inputs[0] + -0.49862202*inputs[1] + -0.01319536*inputs[2] + -0.50792750*inputs[3] + 0.06049788*inputs[4] + -0.89163129*inputs[5] + -0.45957091*inputs[6] + 0.22254673*inputs[7] + -0.43402300*inputs[8] + -1.23277028*inputs[9] + -1.61442134*inputs[10] + -1.43009123*inputs[11] + -0.79182731*inputs[12] + -1.69285344*inputs[13] + -1.02972647*inputs[14] + -1.01781255*inputs[15] + -0.09586824*inputs[16] + -1.27137129*inputs[17] + -0.46148577*inputs[18] + -1.38428569*inputs[19] + -1.15564933*inputs[20] + -0.55060810*inputs[21] + -1.93420640*inputs[22] + -0.04699903*inputs[23] + 0.36339847*inputs[24] + 0.12515167*inputs[25] + 0.46784111*inputs[26] + 0.39233082*inputs[27] + -1.26014757*inputs[28] + -0.22213765*inputs[29] + -0.37415451*inputs[30] + -0.65853500*inputs[31] + -1.40465271*inputs[32] + -1.36221034*inputs[33] + -1.03678716*inputs[34] + -0.82641706*inputs[35] + -1.25607909*inputs[36] + 0.46959192*inputs[37] + -1.14611772*inputs[38] + -0.84022337*inputs[39] + -1.27584903*inputs[40] + -0.63505804*inputs[41] + -0.37194041*inputs[42] + 0.18146158*inputs[43] + 0.31293725*inputs[44] + -0.59133029*inputs[45] + 0.04298042*inputs[46] + -1.61730841*inputs[47] + 0.04821997*inputs[48] + -0.30431945*inputs[49] + -0.64936582*inputs[50] + 0.21358272*inputs[51] + -1.34847029*inputs[52] + -0.52296051*inputs[53] + 0.20626017*inputs[54] + -1.81724297*inputs[55] + -1.40033534*inputs[56] + -1.66430873*inputs[57] + -0.38218655*inputs[58] + 0.35099618*inputs[59] + -0.36315469*inputs[60] + -1.22238244*inputs[61] + -0.80180393*inputs[62] + 0.37510061*inputs[63] + -0.13534946

def neuron_87(inputs):
    return -1.51153841*inputs[0] + -1.35717235*inputs[1] + -0.10463919*inputs[2] + 0.04054226*inputs[3] + 0.19379098*inputs[4] + -0.65121255*inputs[5] + -0.94908797*inputs[6] + 0.38147308*inputs[7] + -1.49112848*inputs[8] + -0.97466824*inputs[9] + -0.55739428*inputs[10] + -1.27064570*inputs[11] + -0.99655269*inputs[12] + -1.72926528*inputs[13] + -0.56322474*inputs[14] + -1.17866489*inputs[15] + -0.18727032*inputs[16] + -0.36427632*inputs[17] + -0.96087992*inputs[18] + -1.52173695*inputs[19] + -0.96688762*inputs[20] + -1.46557069*inputs[21] + -1.38067918*inputs[22] + -0.16234535*inputs[23] + -0.65285529*inputs[24] + 0.38294787*inputs[25] + -0.28025831*inputs[26] + -0.60213240*inputs[27] + -0.90660090*inputs[28] + -0.10570231*inputs[29] + -0.19827569*inputs[30] + -0.05078786*inputs[31] + -0.72332630*inputs[32] + -1.14753418*inputs[33] + -1.18531530*inputs[34] + -0.70595692*inputs[35] + -0.73451694*inputs[36] + 0.02369446*inputs[37] + -1.20048500*inputs[38] + -0.66546761*inputs[39] + -0.97188035*inputs[40] + -0.99733448*inputs[41] + -1.19207173*inputs[42] + 0.54639617*inputs[43] + -0.28942248*inputs[44] + -0.12395183*inputs[45] + -0.04477614*inputs[46] + -0.72964216*inputs[47] + -0.12031521*inputs[48] + -0.45830050*inputs[49] + -0.86166470*inputs[50] + -0.65761246*inputs[51] + -1.45634739*inputs[52] + -1.03074026*inputs[53] + 0.07893122*inputs[54] + -1.01360362*inputs[55] + -0.87399969*inputs[56] + -0.96858743*inputs[57] + -0.01774811*inputs[58] + -0.08140084*inputs[59] + -1.11323802*inputs[60] + -0.97984821*inputs[61] + 0.58272853*inputs[62] + -0.18988392*inputs[63] + -0.32255272

def neuron_88(inputs):
    return -1.23080492*inputs[0] + -0.93541384*inputs[1] + 0.11014808*inputs[2] + 0.05126985*inputs[3] + 0.17786384*inputs[4] + -1.31173304*inputs[5] + -1.23716270*inputs[6] + 0.06727001*inputs[7] + -1.68518145*inputs[8] + -1.68512892*inputs[9] + -0.45138389*inputs[10] + -0.52474002*inputs[11] + -1.51176560*inputs[12] + -1.00092161*inputs[13] + -1.45687787*inputs[14] + -0.99056635*inputs[15] + 0.14122466*inputs[16] + -0.84905464*inputs[17] + -0.65822815*inputs[18] + -1.25259175*inputs[19] + -1.12402665*inputs[20] + -0.38374257*inputs[21] + -0.67535558*inputs[22] + -0.02872707*inputs[23] + -1.09740320*inputs[24] + -0.30860549*inputs[25] + 0.02951395*inputs[26] + 0.08320295*inputs[27] + -0.70733992*inputs[28] + -0.10214199*inputs[29] + -0.38892217*inputs[30] + -0.02046444*inputs[31] + -1.23320011*inputs[32] + -1.13704195*inputs[33] + -1.28881788*inputs[34] + -0.79488441*inputs[35] + -1.63300960*inputs[36] + -0.18907628*inputs[37] + -1.28735950*inputs[38] + -1.37643360*inputs[39] + -1.24415052*inputs[40] + -0.43602919*inputs[41] + -0.84477499*inputs[42] + 0.05198553*inputs[43] + 0.36009332*inputs[44] + -0.37964241*inputs[45] + 0.26337660*inputs[46] + -0.63364130*inputs[47] + -0.15379611*inputs[48] + -1.06099239*inputs[49] + -0.90855580*inputs[50] + -0.77817904*inputs[51] + -0.47985209*inputs[52] + -1.04371547*inputs[53] + 0.21236287*inputs[54] + -1.23510827*inputs[55] + -0.90432464*inputs[56] + -1.21134824*inputs[57] + -0.12601397*inputs[58] + 0.25697644*inputs[59] + -1.17769337*inputs[60] + -0.89912974*inputs[61] + -0.13669876*inputs[62] + -0.14545012*inputs[63] + -0.40446822

def neuron_89(inputs):
    return -1.26287933*inputs[0] + -1.03694898*inputs[1] + 0.05512009*inputs[2] + -0.45484478*inputs[3] + 0.29948511*inputs[4] + -1.21873051*inputs[5] + -0.37723126*inputs[6] + -0.10467939*inputs[7] + -0.37732146*inputs[8] + -1.12810917*inputs[9] + -0.85229793*inputs[10] + -1.34261033*inputs[11] + -1.11257275*inputs[12] + -1.52788415*inputs[13] + -0.93624108*inputs[14] + -1.05015435*inputs[15] + -0.06021529*inputs[16] + -0.89118856*inputs[17] + -0.96525844*inputs[18] + -0.68622356*inputs[19] + -0.89667148*inputs[20] + -1.25047344*inputs[21] + -1.26873661*inputs[22] + -0.21707814*inputs[23] + -0.77132883*inputs[24] + 0.45144730*inputs[25] + -0.22025477*inputs[26] + 0.02030995*inputs[27] + -1.16424808*inputs[28] + -0.32803693*inputs[29] + -0.12147230*inputs[30] + -0.20673135*inputs[31] + -1.21138453*inputs[32] + -1.17743718*inputs[33] + -1.07950458*inputs[34] + -0.90812207*inputs[35] + -1.95880563*inputs[36] + 0.62037432*inputs[37] + -1.28421691*inputs[38] + -0.89372237*inputs[39] + -1.02706389*inputs[40] + -0.19957818*inputs[41] + -1.20526140*inputs[42] + -0.06210862*inputs[43] + 0.39580075*inputs[44] + -0.09802777*inputs[45] + -0.28288819*inputs[46] + -1.08202487*inputs[47] + -0.07015415*inputs[48] + -0.83567663*inputs[49] + -1.09048410*inputs[50] + -0.69953307*inputs[51] + -1.27135052*inputs[52] + -0.71853573*inputs[53] + -0.68863443*inputs[54] + -1.23734356*inputs[55] + -1.29217268*inputs[56] + -1.05903387*inputs[57] + 0.41230956*inputs[58] + -0.13836806*inputs[59] + -0.56423207*inputs[60] + -1.01412339*inputs[61] + 0.51838987*inputs[62] + 0.35454876*inputs[63] + -0.50723808

def neuron_90(inputs):
    return -1.37159313*inputs[0] + -0.88055857*inputs[1] + -0.19764366*inputs[2] + -0.33590804*inputs[3] + -0.31881766*inputs[4] + -0.96365936*inputs[5] + -1.12794500*inputs[6] + 0.13683946*inputs[7] + -1.02399323*inputs[8] + -1.27528759*inputs[9] + -0.65034519*inputs[10] + -1.16485406*inputs[11] + -1.02920276*inputs[12] + -0.63667680*inputs[13] + -1.30202848*inputs[14] + -1.00082842*inputs[15] + -0.00382012*inputs[16] + -1.09677024*inputs[17] + -1.22312544*inputs[18] + -0.45553902*inputs[19] + -0.52927792*inputs[20] + -1.23963657*inputs[21] + -0.85730623*inputs[22] + -0.09557817*inputs[23] + -1.54243428*inputs[24] + -0.02397773*inputs[25] + 0.18797236*inputs[26] + -0.16229935*inputs[27] + -1.15745435*inputs[28] + -0.27116847*inputs[29] + -0.04471004*inputs[30] + -0.20958762*inputs[31] + -1.13967873*inputs[32] + -1.32463902*inputs[33] + -1.54256095*inputs[34] + -0.71621522*inputs[35] + -0.87621531*inputs[36] + 0.60150138*inputs[37] + -1.40483907*inputs[38] + -0.85601917*inputs[39] + -1.15917098*inputs[40] + -0.40845285*inputs[41] + -0.79286885*inputs[42] + -0.23517050*inputs[43] + -0.42711714*inputs[44] + 0.27281029*inputs[45] + -0.26450631*inputs[46] + -0.48076147*inputs[47] + -0.14011271*inputs[48] + -1.35782141*inputs[49] + -0.96452359*inputs[50] + -0.81402669*inputs[51] + -1.60411669*inputs[52] + -0.77668098*inputs[53] + -0.16664016*inputs[54] + -1.20173975*inputs[55] + -0.79093543*inputs[56] + -1.18132532*inputs[57] + 0.61309247*inputs[58] + 0.07215232*inputs[59] + -0.73592955*inputs[60] + -0.91517981*inputs[61] + -0.22741893*inputs[62] + 0.27550720*inputs[63] + -0.60450390

def neuron_91(inputs):
    return -0.66416673*inputs[0] + -0.51743098*inputs[1] + 0.62713041*inputs[2] + 0.31375357*inputs[3] + -0.10703939*inputs[4] + -1.41341035*inputs[5] + -0.74944749*inputs[6] + -0.20219849*inputs[7] + -1.08438185*inputs[8] + -0.79523106*inputs[9] + -0.92376764*inputs[10] + -1.19169329*inputs[11] + -0.75499825*inputs[12] + -0.59800062*inputs[13] + -0.42611254*inputs[14] + -1.23149020*inputs[15] + 0.45748005*inputs[16] + -1.08284157*inputs[17] + -0.85588735*inputs[18] + -0.65524664*inputs[19] + -0.66070254*inputs[20] + -1.46582356*inputs[21] + -1.27006875*inputs[22] + 0.03875124*inputs[23] + -0.98399841*inputs[24] + 0.09011444*inputs[25] + -0.17005500*inputs[26] + 0.04134837*inputs[27] + -1.90973579*inputs[28] + 0.23049004*inputs[29] + 0.00797278*inputs[30] + -0.25513786*inputs[31] + -1.56937178*inputs[32] + -1.08757274*inputs[33] + -0.91857218*inputs[34] + -1.50969806*inputs[35] + -1.55722714*inputs[36] + -0.08973933*inputs[37] + -0.85689929*inputs[38] + -0.74587061*inputs[39] + -1.10610487*inputs[40] + -0.96130751*inputs[41] + -0.99967700*inputs[42] + -0.27863754*inputs[43] + -0.18584447*inputs[44] + 0.00639803*inputs[45] + -0.18562876*inputs[46] + -1.07734435*inputs[47] + -0.30675104*inputs[48] + -1.16778990*inputs[49] + -1.53808170*inputs[50] + -1.36400949*inputs[51] + -0.79092886*inputs[52] + -1.13384697*inputs[53] + -0.04973679*inputs[54] + -0.87817639*inputs[55] + -0.78316404*inputs[56] + -1.62147537*inputs[57] + 0.01048542*inputs[58] + 0.15141116*inputs[59] + -1.31537327*inputs[60] + -1.06631025*inputs[61] + -0.06371693*inputs[62] + -0.26165902*inputs[63] + -0.24498301

def neuron_92(inputs):
    return -1.12117794*inputs[0] + -1.06861189*inputs[1] + 0.37747055*inputs[2] + 0.00233987*inputs[3] + 0.52273646*inputs[4] + -1.37001361*inputs[5] + -0.68338322*inputs[6] + -0.14420441*inputs[7] + -0.72038127*inputs[8] + -1.56399010*inputs[9] + -0.29458409*inputs[10] + -1.47579317*inputs[11] + -1.49714093*inputs[12] + -0.25372608*inputs[13] + -1.35685878*inputs[14] + -1.21209064*inputs[15] + -0.00228813*inputs[16] + -1.08756374*inputs[17] + -1.67388820*inputs[18] + -1.17662387*inputs[19] + -0.03358884*inputs[20] + -0.63184815*inputs[21] + -0.82465723*inputs[22] + -0.76545201*inputs[23] + -1.37632820*inputs[24] + 0.31324641*inputs[25] + 0.30774715*inputs[26] + 0.50514158*inputs[27] + -1.64223346*inputs[28] + 0.34714324*inputs[29] + -0.28776110*inputs[30] + 0.51158424*inputs[31] + -1.30634650*inputs[32] + -0.33197192*inputs[33] + -0.95214318*inputs[34] + -1.17512358*inputs[35] + -1.30286781*inputs[36] + 0.95882374*inputs[37] + -1.20676066*inputs[38] + -0.99467190*inputs[39] + -0.91927048*inputs[40] + -0.81697105*inputs[41] + -1.35546396*inputs[42] + -0.14146230*inputs[43] + -0.07808372*inputs[44] + -0.46923486*inputs[45] + -0.05385564*inputs[46] + -0.74764415*inputs[47] + -0.09460271*inputs[48] + -0.98834708*inputs[49] + -1.08128612*inputs[50] + -1.63419057*inputs[51] + -1.03121379*inputs[52] + -1.11540460*inputs[53] + -0.71376353*inputs[54] + -1.59534065*inputs[55] + -0.97509593*inputs[56] + -1.19668474*inputs[57] + 0.22942499*inputs[58] + 0.23030502*inputs[59] + -0.25094941*inputs[60] + -1.42009487*inputs[61] + -0.35331182*inputs[62] + -0.13470595*inputs[63] + -0.08747620

def neuron_93(inputs):
    return -1.32495907*inputs[0] + -0.81919573*inputs[1] + 0.03319250*inputs[2] + 0.12239894*inputs[3] + -0.04017823*inputs[4] + -0.98650879*inputs[5] + -1.18798820*inputs[6] + 0.72333254*inputs[7] + -0.88338613*inputs[8] + -1.18949688*inputs[9] + -0.51854423*inputs[10] + -1.18141400*inputs[11] + -0.99233856*inputs[12] + -1.05530897*inputs[13] + -0.97273451*inputs[14] + -1.06593122*inputs[15] + -0.12417847*inputs[16] + -0.75439378*inputs[17] + -1.33969431*inputs[18] + -0.99013198*inputs[19] + -0.72780907*inputs[20] + -1.34758864*inputs[21] + -1.02701614*inputs[22] + 0.37183652*inputs[23] + -1.81358631*inputs[24] + 0.02123894*inputs[25] + -0.39815870*inputs[26] + -0.25426452*inputs[27] + -1.01517572*inputs[28] + -0.27257344*inputs[29] + -0.15219845*inputs[30] + -0.33284152*inputs[31] + -0.97411978*inputs[32] + -1.65945139*inputs[33] + -1.21231882*inputs[34] + -0.65399513*inputs[35] + -0.86117507*inputs[36] + -0.31187831*inputs[37] + -1.32376075*inputs[38] + -0.60368927*inputs[39] + -0.60722254*inputs[40] + -0.76152896*inputs[41] + -0.56817054*inputs[42] + 0.41411708*inputs[43] + 0.09135991*inputs[44] + 0.11663843*inputs[45] + -0.25620526*inputs[46] + -1.12897534*inputs[47] + -0.15048883*inputs[48] + -0.77487700*inputs[49] + -0.92097723*inputs[50] + -0.85845745*inputs[51] + -1.12368433*inputs[52] + -1.45239919*inputs[53] + -0.08705390*inputs[54] + -1.31549266*inputs[55] + -0.41585244*inputs[56] + -1.00998399*inputs[57] + -0.07584344*inputs[58] + 0.17403626*inputs[59] + -1.10361339*inputs[60] + -1.19816970*inputs[61] + 0.36832167*inputs[62] + -0.12756098*inputs[63] + -0.40340550

def neuron_94(inputs):
    return -0.97291039*inputs[0] + -1.10660965*inputs[1] + 0.53290751*inputs[2] + 0.33830265*inputs[3] + -0.22519384*inputs[4] + -1.26177021*inputs[5] + -1.20860484*inputs[6] + -0.18955914*inputs[7] + -0.62972923*inputs[8] + -0.86380455*inputs[9] + -0.70479126*inputs[10] + -1.20566225*inputs[11] + -1.13407778*inputs[12] + -0.50305184*inputs[13] + -1.05511519*inputs[14] + -1.13577223*inputs[15] + -0.00088709*inputs[16] + -1.08632789*inputs[17] + -0.97808508*inputs[18] + -1.25770021*inputs[19] + -0.35150543*inputs[20] + -1.35631068*inputs[21] + -1.67031222*inputs[22] + -0.72699730*inputs[23] + -0.59205017*inputs[24] + -0.13566903*inputs[25] + -0.19168474*inputs[26] + 0.15716676*inputs[27] + -0.83056640*inputs[28] + 0.25056533*inputs[29] + 0.44616787*inputs[30] + -0.33334215*inputs[31] + -1.18606250*inputs[32] + -0.88052410*inputs[33] + -1.19800499*inputs[34] + -1.64525830*inputs[35] + -0.54845455*inputs[36] + 0.41419501*inputs[37] + -0.88040793*inputs[38] + -0.99931246*inputs[39] + -0.84826841*inputs[40] + -0.65228391*inputs[41] + -0.95436055*inputs[42] + 0.01910445*inputs[43] + -0.02727614*inputs[44] + 0.31536835*inputs[45] + 0.25811580*inputs[46] + -1.10432795*inputs[47] + -0.08718589*inputs[48] + -0.91222001*inputs[49] + -1.21542245*inputs[50] + -0.94400310*inputs[51] + -1.25971241*inputs[52] + -1.35791248*inputs[53] + -0.14533271*inputs[54] + -1.09565100*inputs[55] + -1.07225013*inputs[56] + -0.90686508*inputs[57] + 0.04858975*inputs[58] + 0.07293520*inputs[59] + -1.07732899*inputs[60] + -1.26375262*inputs[61] + -0.43054040*inputs[62] + -0.11443336*inputs[63] + -0.23327404

def neuron_95(inputs):
    return -1.11391892*inputs[0] + -0.60665476*inputs[1] + -0.09471711*inputs[2] + -0.36245689*inputs[3] + 0.33362202*inputs[4] + -1.42910390*inputs[5] + -1.10470886*inputs[6] + 0.30285950*inputs[7] + -1.26444388*inputs[8] + -0.63710405*inputs[9] + -1.40426198*inputs[10] + -1.25391711*inputs[11] + -0.94743923*inputs[12] + -1.60146815*inputs[13] + -1.02914426*inputs[14] + -1.22072307*inputs[15] + 0.26175214*inputs[16] + -0.63935099*inputs[17] + -1.10334879*inputs[18] + -1.43006177*inputs[19] + -0.29964083*inputs[20] + -1.35213239*inputs[21] + -0.69590800*inputs[22] + 0.13800314*inputs[23] + -1.17063658*inputs[24] + 0.16664551*inputs[25] + -0.19544622*inputs[26] + 0.16515632*inputs[27] + -0.95339666*inputs[28] + 0.15743131*inputs[29] + -0.05928812*inputs[30] + 0.09542941*inputs[31] + -0.33926824*inputs[32] + -1.14410612*inputs[33] + -1.19635679*inputs[34] + -1.30343219*inputs[35] + -1.22018416*inputs[36] + -0.00116386*inputs[37] + -0.24572377*inputs[38] + -1.02890577*inputs[39] + -1.21146322*inputs[40] + -1.01522713*inputs[41] + -1.28680294*inputs[42] + -0.19815436*inputs[43] + -0.28945010*inputs[44] + -0.43042476*inputs[45] + 0.42759305*inputs[46] + -1.03108462*inputs[47] + 0.24009367*inputs[48] + -0.90949141*inputs[49] + -0.48357592*inputs[50] + -1.14489619*inputs[51] + -1.24960164*inputs[52] + -1.20849980*inputs[53] + -0.34313863*inputs[54] + -1.14134542*inputs[55] + -0.99228910*inputs[56] + -1.19427716*inputs[57] + 0.24018865*inputs[58] + 0.11684059*inputs[59] + -1.14649228*inputs[60] + -1.19982247*inputs[61] + -0.56014180*inputs[62] + 0.07874547*inputs[63] + -0.22126686

def neuron_96(inputs):
    return -1.20974329*inputs[0] + -0.68674311*inputs[1] + -0.17469487*inputs[2] + -0.18055482*inputs[3] + -0.24396196*inputs[4] + -1.08404361*inputs[5] + -1.19652960*inputs[6] + -0.11248237*inputs[7] + -1.12274438*inputs[8] + -1.15575035*inputs[9] + -0.94424330*inputs[10] + -1.27014981*inputs[11] + -1.15868336*inputs[12] + -1.13899564*inputs[13] + -1.01862642*inputs[14] + -1.23333061*inputs[15] + -0.01480975*inputs[16] + -0.93431674*inputs[17] + -0.82952301*inputs[18] + -1.03884818*inputs[19] + -1.00245345*inputs[20] + -0.97600436*inputs[21] + -1.35194000*inputs[22] + -0.35618588*inputs[23] + -0.89506457*inputs[24] + -0.27914248*inputs[25] + -0.20693559*inputs[26] + -0.17842909*inputs[27] + -1.11801365*inputs[28] + -0.09033640*inputs[29] + -0.14172772*inputs[30] + -0.19780895*inputs[31] + -1.42479571*inputs[32] + -0.97789312*inputs[33] + -1.21633132*inputs[34] + -0.92702127*inputs[35] + -0.88776663*inputs[36] + -0.16062979*inputs[37] + -0.94403201*inputs[38] + -0.96322254*inputs[39] + -0.93731731*inputs[40] + -0.72175146*inputs[41] + -0.92767937*inputs[42] + -0.16385827*inputs[43] + -0.16743114*inputs[44] + -0.34411285*inputs[45] + 0.20862660*inputs[46] + -0.65065523*inputs[47] + 0.02919042*inputs[48] + -0.95982682*inputs[49] + -0.85462598*inputs[50] + -0.89528827*inputs[51] + -1.29170763*inputs[52] + -0.98786727*inputs[53] + -0.23908954*inputs[54] + -1.39199351*inputs[55] + -1.13348207*inputs[56] + -0.98140482*inputs[57] + -0.00986292*inputs[58] + -0.27823852*inputs[59] + -1.11545619*inputs[60] + -1.23998378*inputs[61] + -0.16073123*inputs[62] + -0.09650540*inputs[63] + 4.02595166

def neuron_97(inputs):
    return -0.99048420*inputs[0] + -0.76088831*inputs[1] + -0.05359892*inputs[2] + -0.23773955*inputs[3] + 0.47054847*inputs[4] + -0.73964583*inputs[5] + -1.26364091*inputs[6] + -0.15396389*inputs[7] + -0.80318289*inputs[8] + -1.10468487*inputs[9] + -1.01534376*inputs[10] + -1.30968920*inputs[11] + -0.96557615*inputs[12] + -1.52917804*inputs[13] + -0.67177720*inputs[14] + -1.01627170*inputs[15] + -0.04020383*inputs[16] + -1.20335196*inputs[17] + -1.76580995*inputs[18] + -0.70175527*inputs[19] + -1.16166555*inputs[20] + -1.23707104*inputs[21] + -1.08140608*inputs[22] + -0.07176092*inputs[23] + -0.73923995*inputs[24] + 0.17312865*inputs[25] + 0.38863864*inputs[26] + 0.23272264*inputs[27] + -1.64668414*inputs[28] + 0.00953320*inputs[29] + -0.01145188*inputs[30] + -0.55536688*inputs[31] + -1.24726006*inputs[32] + -1.29013015*inputs[33] + -0.98699156*inputs[34] + -0.41243822*inputs[35] + -1.03928804*inputs[36] + -0.48767415*inputs[37] + -1.54803742*inputs[38] + -0.41817081*inputs[39] + -0.79635808*inputs[40] + -1.24162838*inputs[41] + -0.74178326*inputs[42] + -0.16341538*inputs[43] + 0.31419895*inputs[44] + 0.07042697*inputs[45] + 0.43043746*inputs[46] + -0.91283892*inputs[47] + -0.11763361*inputs[48] + -0.89081468*inputs[49] + -1.13177109*inputs[50] + -0.97024003*inputs[51] + -1.37908357*inputs[52] + -0.79368616*inputs[53] + 0.53768693*inputs[54] + -1.27858101*inputs[55] + -1.07346805*inputs[56] + -1.55570102*inputs[57] + 0.36923892*inputs[58] + 0.13950012*inputs[59] + 0.01751828*inputs[60] + -1.01124158*inputs[61] + 0.30433263*inputs[62] + -0.24606324*inputs[63] + -0.40491364

def neuron_98(inputs):
    return -0.90063759*inputs[0] + -1.22704696*inputs[1] + 0.43335390*inputs[2] + -0.27870313*inputs[3] + 0.22013597*inputs[4] + -1.02136482*inputs[5] + -0.99759654*inputs[6] + -0.08572690*inputs[7] + -1.37208580*inputs[8] + -1.74351019*inputs[9] + -1.06381195*inputs[10] + -1.46975767*inputs[11] + -0.97498077*inputs[12] + -1.23195047*inputs[13] + -1.29415205*inputs[14] + -0.74245889*inputs[15] + 0.50605648*inputs[16] + -0.85863236*inputs[17] + -1.15182671*inputs[18] + -1.25778378*inputs[19] + -1.47250869*inputs[20] + -1.20753679*inputs[21] + -0.78533074*inputs[22] + -0.30927772*inputs[23] + -1.26957432*inputs[24] + 0.42299160*inputs[25] + 0.39428851*inputs[26] + -0.10958666*inputs[27] + -0.45330499*inputs[28] + -0.07487706*inputs[29] + -0.31973597*inputs[30] + -0.40999951*inputs[31] + -1.44218482*inputs[32] + -0.74840586*inputs[33] + -0.75232466*inputs[34] + -0.88831755*inputs[35] + -1.23789785*inputs[36] + 0.29128925*inputs[37] + -0.97074812*inputs[38] + -0.49936115*inputs[39] + -1.12445489*inputs[40] + -1.35431924*inputs[41] + -1.29158894*inputs[42] + 0.12428045*inputs[43] + 0.35848432*inputs[44] + 0.24464610*inputs[45] + -0.25440928*inputs[46] + -1.01037952*inputs[47] + 0.33162426*inputs[48] + -0.67449346*inputs[49] + -0.51256465*inputs[50] + -1.31976271*inputs[51] + -0.83344849*inputs[52] + -1.10517735*inputs[53] + -0.24640076*inputs[54] + -0.78500635*inputs[55] + -0.44845277*inputs[56] + -0.98522898*inputs[57] + -0.11234282*inputs[58] + -0.15205470*inputs[59] + -0.23420663*inputs[60] + -1.28997572*inputs[61] + -0.17475598*inputs[62] + 0.29115538*inputs[63] + -0.21609588

def neuron_99(inputs):
    return -0.57063966*inputs[0] + -0.59695272*inputs[1] + -0.05588532*inputs[2] + 0.61397993*inputs[3] + -0.21456744*inputs[4] + -1.43383810*inputs[5] + -1.59390706*inputs[6] + -0.13236638*inputs[7] + -0.84337202*inputs[8] + -1.35970597*inputs[9] + -0.73271696*inputs[10] + -0.85325364*inputs[11] + -1.27304826*inputs[12] + -1.05655509*inputs[13] + -1.52414006*inputs[14] + -1.11738477*inputs[15] + -0.12500285*inputs[16] + -1.12312025*inputs[17] + -1.07550665*inputs[18] + -1.01292677*inputs[19] + -1.06057518*inputs[20] + -1.23946433*inputs[21] + -1.25776590*inputs[22] + -0.16071182*inputs[23] + -1.12204914*inputs[24] + -0.12507766*inputs[25] + 0.39502508*inputs[26] + -0.23961017*inputs[27] + -1.35020573*inputs[28] + 0.46435255*inputs[29] + -0.32225328*inputs[30] + 0.10257750*inputs[31] + -1.27325919*inputs[32] + -1.36381042*inputs[33] + -1.29023505*inputs[34] + -1.00469109*inputs[35] + -0.91721771*inputs[36] + -0.22884447*inputs[37] + -1.36259121*inputs[38] + -1.28049255*inputs[39] + -0.96475806*inputs[40] + -0.73048312*inputs[41] + -1.15593546*inputs[42] + -0.12817874*inputs[43] + -0.26149755*inputs[44] + 0.22752569*inputs[45] + 0.40341197*inputs[46] + -0.60178829*inputs[47] + -0.06791661*inputs[48] + -1.25906268*inputs[49] + -0.90392487*inputs[50] + -0.58615641*inputs[51] + -1.08168525*inputs[52] + -0.58869846*inputs[53] + 0.37555648*inputs[54] + -0.74930546*inputs[55] + -0.71403331*inputs[56] + -0.95342982*inputs[57] + -0.27973306*inputs[58] + -0.28482308*inputs[59] + -1.40002914*inputs[60] + -0.65841849*inputs[61] + 0.05820169*inputs[62] + -0.09482581*inputs[63] + -0.35655367

def neuron_100(inputs):
    return -1.21964347*inputs[0] + -0.81741449*inputs[1] + -0.24172016*inputs[2] + -0.22119314*inputs[3] + -0.22334189*inputs[4] + -1.07855935*inputs[5] + -1.22926807*inputs[6] + -0.02169875*inputs[7] + -1.12235167*inputs[8] + -1.22042658*inputs[9] + -0.92283518*inputs[10] + -1.37964795*inputs[11] + -1.20546271*inputs[12] + -1.05058353*inputs[13] + -0.94593004*inputs[14] + -1.41900617*inputs[15] + -0.05122387*inputs[16] + -0.88851960*inputs[17] + -0.91141710*inputs[18] + -1.18414067*inputs[19] + -1.00629970*inputs[20] + -0.84323826*inputs[21] + -1.16323298*inputs[22] + -0.34277015*inputs[23] + -0.87248999*inputs[24] + -0.23762779*inputs[25] + -0.15953661*inputs[26] + -0.29678219*inputs[27] + -1.12996197*inputs[28] + -0.05678952*inputs[29] + -0.24766805*inputs[30] + -0.21088226*inputs[31] + -1.34004997*inputs[32] + -0.93752997*inputs[33] + -1.10099104*inputs[34] + -0.91063683*inputs[35] + -0.87833335*inputs[36] + -0.17784903*inputs[37] + -1.03310064*inputs[38] + -1.06158902*inputs[39] + -0.96276173*inputs[40] + -0.58185355*inputs[41] + -0.94960103*inputs[42] + -0.20629366*inputs[43] + -0.07714158*inputs[44] + -0.27464567*inputs[45] + 0.29250701*inputs[46] + -0.68791892*inputs[47] + -0.10405221*inputs[48] + -0.90960549*inputs[49] + -0.91058857*inputs[50] + -0.85729428*inputs[51] + -1.11744139*inputs[52] + -0.94585084*inputs[53] + -0.29643643*inputs[54] + -1.41782951*inputs[55] + -0.99166082*inputs[56] + -0.93590231*inputs[57] + -0.02904004*inputs[58] + -0.24120311*inputs[59] + -1.08572674*inputs[60] + -1.34924681*inputs[61] + -0.17062274*inputs[62] + -0.06827916*inputs[63] + 4.17125692

def neuron_101(inputs):
    return -1.22021663*inputs[0] + -0.73628675*inputs[1] + -0.22897517*inputs[2] + -0.11687020*inputs[3] + -0.17285481*inputs[4] + -1.00414653*inputs[5] + -1.32933569*inputs[6] + -0.08972424*inputs[7] + -1.19122738*inputs[8] + -1.21918067*inputs[9] + -1.05252503*inputs[10] + -1.28368496*inputs[11] + -1.13649863*inputs[12] + -1.10033099*inputs[13] + -1.04325680*inputs[14] + -1.30426694*inputs[15] + -0.12344391*inputs[16] + -0.86676678*inputs[17] + -0.84849713*inputs[18] + -1.12832535*inputs[19] + -0.94228373*inputs[20] + -0.88092961*inputs[21] + -1.38739565*inputs[22] + -0.26352251*inputs[23] + -0.98093454*inputs[24] + -0.17750477*inputs[25] + -0.20814458*inputs[26] + -0.26616754*inputs[27] + -1.18116530*inputs[28] + -0.18694418*inputs[29] + -0.11078335*inputs[30] + -0.22361857*inputs[31] + -1.30200214*inputs[32] + -0.94618571*inputs[33] + -1.03755405*inputs[34] + -0.91480803*inputs[35] + -0.90160677*inputs[36] + -0.08258962*inputs[37] + -1.07590158*inputs[38] + -0.95584285*inputs[39] + -0.88957159*inputs[40] + -0.71354936*inputs[41] + -0.90871140*inputs[42] + -0.10779222*inputs[43] + -0.05125296*inputs[44] + -0.26519538*inputs[45] + 0.22848514*inputs[46] + -0.70988526*inputs[47] + -0.01253447*inputs[48] + -1.02912388*inputs[49] + -0.93661581*inputs[50] + -0.87063028*inputs[51] + -1.15761189*inputs[52] + -1.00549808*inputs[53] + -0.16843993*inputs[54] + -1.39658543*inputs[55] + -1.05135818*inputs[56] + -0.93709155*inputs[57] + -0.13729465*inputs[58] + -0.28929677*inputs[59] + -1.06700165*inputs[60] + -1.41422932*inputs[61] + -0.29652754*inputs[62] + -0.09780199*inputs[63] + 4.06829118

def neuron_102(inputs):
    return -0.70990029*inputs[0] + -0.96628983*inputs[1] + 0.46086131*inputs[2] + 0.60140270*inputs[3] + -0.32169657*inputs[4] + -0.61288354*inputs[5] + -1.01494430*inputs[6] + -0.10979938*inputs[7] + -1.48858583*inputs[8] + -1.40815660*inputs[9] + -0.58863945*inputs[10] + -1.39664226*inputs[11] + -0.83643353*inputs[12] + -0.49908882*inputs[13] + -0.75656026*inputs[14] + -1.01938413*inputs[15] + 0.55000137*inputs[16] + -1.07495942*inputs[17] + -0.85282856*inputs[18] + -0.63806895*inputs[19] + -1.23838093*inputs[20] + -0.97773001*inputs[21] + -1.48822737*inputs[22] + 0.55389238*inputs[23] + -1.23922011*inputs[24] + -0.16684732*inputs[25] + -0.27480969*inputs[26] + -0.36894367*inputs[27] + -0.93846296*inputs[28] + -0.08065363*inputs[29] + -0.19778995*inputs[30] + -0.37023967*inputs[31] + -1.55716546*inputs[32] + -0.80421113*inputs[33] + -1.20167078*inputs[34] + -1.15141216*inputs[35] + -0.71761823*inputs[36] + -0.03562643*inputs[37] + -1.61535015*inputs[38] + -0.57706907*inputs[39] + -0.95382537*inputs[40] + -0.56788174*inputs[41] + -0.45572539*inputs[42] + -0.00076549*inputs[43] + 0.05547580*inputs[44] + -0.02011005*inputs[45] + -0.39654194*inputs[46] + -0.92144342*inputs[47] + 0.09521641*inputs[48] + -1.10031711*inputs[49] + -1.31604015*inputs[50] + -1.22026810*inputs[51] + -0.43552086*inputs[52] + -1.19020775*inputs[53] + -0.45742596*inputs[54] + -1.32682674*inputs[55] + -1.25443595*inputs[56] + -0.99846830*inputs[57] + -0.36334431*inputs[58] + 0.16581957*inputs[59] + -1.12560911*inputs[60] + -1.24400026*inputs[61] + 0.14183057*inputs[62] + 0.32354377*inputs[63] + -0.26883022

def neuron_103(inputs):
    return -0.66651848*inputs[0] + -0.59230941*inputs[1] + 0.31646066*inputs[2] + -0.13171187*inputs[3] + -0.48625829*inputs[4] + -1.08225815*inputs[5] + -1.62111102*inputs[6] + -0.27832923*inputs[7] + -0.83594879*inputs[8] + -1.32042625*inputs[9] + -0.37489813*inputs[10] + -1.32808521*inputs[11] + -0.96402421*inputs[12] + -0.80365208*inputs[13] + -0.97665014*inputs[14] + -1.06421687*inputs[15] + 0.48919116*inputs[16] + -1.34723946*inputs[17] + -1.00487247*inputs[18] + -0.86603597*inputs[19] + -0.86015655*inputs[20] + -1.25955017*inputs[21] + -1.04458768*inputs[22] + 0.06188645*inputs[23] + -1.27168541*inputs[24] + -0.25726922*inputs[25] + -0.39260793*inputs[26] + 0.06690901*inputs[27] + -0.25570640*inputs[28] + 0.17931150*inputs[29] + -0.14050242*inputs[30] + -0.09314599*inputs[31] + -0.70151320*inputs[32] + -1.39778214*inputs[33] + -1.00366115*inputs[34] + -0.67509910*inputs[35] + -1.28387626*inputs[36] + 0.15446073*inputs[37] + -0.83596999*inputs[38] + -1.02415145*inputs[39] + -1.18504204*inputs[40] + -0.47038022*inputs[41] + -0.97936403*inputs[42] + -0.19848661*inputs[43] + -0.08848556*inputs[44] + -0.03253863*inputs[45] + -0.00939240*inputs[46] + -0.87468294*inputs[47] + -0.44541681*inputs[48] + -1.41907788*inputs[49] + -1.28104403*inputs[50] + -1.09559875*inputs[51] + -0.78377608*inputs[52] + -1.15492239*inputs[53] + -0.21228440*inputs[54] + -1.46047324*inputs[55] + -0.92224282*inputs[56] + -1.37621256*inputs[57] + -0.17576243*inputs[58] + 0.11066994*inputs[59] + -1.16490860*inputs[60] + -1.23712389*inputs[61] + -0.14288869*inputs[62] + 0.89186909*inputs[63] + -0.27836011

def neuron_104(inputs):
    return -1.16866390*inputs[0] + -1.27676828*inputs[1] + -0.14179158*inputs[2] + 0.08338765*inputs[3] + -0.37973894*inputs[4] + -1.04318650*inputs[5] + -0.68751557*inputs[6] + -0.14430685*inputs[7] + -1.39005800*inputs[8] + -1.38972371*inputs[9] + -0.47519996*inputs[10] + -1.09021177*inputs[11] + -1.31200308*inputs[12] + -0.64854550*inputs[13] + -1.20456914*inputs[14] + -1.08894187*inputs[15] + -0.10598755*inputs[16] + -0.76794649*inputs[17] + -1.41086077*inputs[18] + -0.97712286*inputs[19] + -0.63675738*inputs[20] + -0.83699642*inputs[21] + -1.12160346*inputs[22] + 0.56962812*inputs[23] + -1.73431261*inputs[24] + -0.04144007*inputs[25] + 0.22871586*inputs[26] + -0.00646578*inputs[27] + -0.92091512*inputs[28] + -0.17329973*inputs[29] + -0.39617727*inputs[30] + -0.12331874*inputs[31] + -1.29916428*inputs[32] + -1.74029410*inputs[33] + -1.13836432*inputs[34] + -0.63232156*inputs[35] + -1.19416592*inputs[36] + -0.19679952*inputs[37] + -0.72932754*inputs[38] + -0.61686732*inputs[39] + -0.53590137*inputs[40] + -0.67141360*inputs[41] + -0.36509035*inputs[42] + -0.10196226*inputs[43] + 0.21663013*inputs[44] + -0.07568304*inputs[45] + -0.09486605*inputs[46] + -0.93051392*inputs[47] + 0.01120259*inputs[48] + -1.32844784*inputs[49] + -1.14576411*inputs[50] + -1.42307091*inputs[51] + -0.98373417*inputs[52] + -0.72878190*inputs[53] + 0.18224181*inputs[54] + -0.94235078*inputs[55] + -0.79447666*inputs[56] + -0.52297596*inputs[57] + -0.01988807*inputs[58] + -0.06877647*inputs[59] + -1.18750818*inputs[60] + -1.44551658*inputs[61] + -0.07936756*inputs[62] + -0.23986679*inputs[63] + -0.33707881

def neuron_105(inputs):
    return -0.68686688*inputs[0] + -0.90958531*inputs[1] + -0.08501266*inputs[2] + 0.25318506*inputs[3] + -0.19639896*inputs[4] + -1.37642426*inputs[5] + -1.55674171*inputs[6] + -0.28304179*inputs[7] + -0.74660217*inputs[8] + -1.37082699*inputs[9] + -1.30052065*inputs[10] + -0.71719286*inputs[11] + -1.36375579*inputs[12] + -0.82599673*inputs[13] + -1.02394969*inputs[14] + -1.17374000*inputs[15] + -0.01831982*inputs[16] + -0.98506236*inputs[17] + -0.87338077*inputs[18] + -1.44675105*inputs[19] + -1.32464448*inputs[20] + -1.28403618*inputs[21] + -1.66160291*inputs[22] + 0.20445758*inputs[23] + -0.30597487*inputs[24] + 0.15327066*inputs[25] + 0.33026435*inputs[26] + 0.20021493*inputs[27] + -1.15707944*inputs[28] + 0.12983815*inputs[29] + -0.50320394*inputs[30] + -0.18076586*inputs[31] + -1.24789509*inputs[32] + -1.15524514*inputs[33] + -1.23913536*inputs[34] + -1.48421876*inputs[35] + -0.86616109*inputs[36] + -0.18465850*inputs[37] + -0.90746072*inputs[38] + -1.09720135*inputs[39] + -0.99807115*inputs[40] + -1.03011351*inputs[41] + -0.39825463*inputs[42] + -0.16637011*inputs[43] + -0.12390461*inputs[44] + -0.16917298*inputs[45] + 0.57016449*inputs[46] + -1.21112432*inputs[47] + -0.13051852*inputs[48] + -0.94371149*inputs[49] + -1.16983366*inputs[50] + -0.48871386*inputs[51] + -1.02922601*inputs[52] + -0.66781619*inputs[53] + 0.02340959*inputs[54] + -1.30644042*inputs[55] + -0.69272402*inputs[56] + -1.00846813*inputs[57] + -0.01614954*inputs[58] + 0.51365957*inputs[59] + -0.54703910*inputs[60] + -0.88422823*inputs[61] + -0.42710551*inputs[62] + 0.53890577*inputs[63] + -0.32464456

def neuron_106(inputs):
    return -0.45897039*inputs[0] + -0.95618534*inputs[1] + 0.54324434*inputs[2] + -0.21334154*inputs[3] + 0.05630246*inputs[4] + -0.58306294*inputs[5] + -0.63799655*inputs[6] + -0.12477784*inputs[7] + -1.51420430*inputs[8] + -1.56755901*inputs[9] + -1.08014899*inputs[10] + -1.26732130*inputs[11] + -1.24792056*inputs[12] + -0.63140762*inputs[13] + -0.93875610*inputs[14] + -1.00479085*inputs[15] + 0.22124568*inputs[16] + -0.65142193*inputs[17] + -0.79832711*inputs[18] + -0.53880010*inputs[19] + -1.06045794*inputs[20] + -1.15973800*inputs[21] + -1.70504002*inputs[22] + 0.26287950*inputs[23] + -1.18489548*inputs[24] + 0.07250194*inputs[25] + 0.47220389*inputs[26] + -0.49453460*inputs[27] + -0.92858129*inputs[28] + -0.17865839*inputs[29] + -0.34493211*inputs[30] + -0.30439729*inputs[31] + -1.28248482*inputs[32] + -0.88299479*inputs[33] + -1.21536233*inputs[34] + -1.09380226*inputs[35] + -1.28287376*inputs[36] + -0.27124374*inputs[37] + -0.63416878*inputs[38] + -1.02272590*inputs[39] + -0.88436842*inputs[40] + -1.07286204*inputs[41] + -0.73814381*inputs[42] + -0.29674059*inputs[43] + -0.34330667*inputs[44] + -0.14678626*inputs[45] + -0.03609453*inputs[46] + -0.94157248*inputs[47] + -0.04499642*inputs[48] + -1.37447351*inputs[49] + -0.85450977*inputs[50] + -0.97736787*inputs[51] + -1.46716341*inputs[52] + -0.23289394*inputs[53] + 0.85052058*inputs[54] + -1.27225807*inputs[55] + -1.21930282*inputs[56] + -1.04679761*inputs[57] + -0.14013544*inputs[58] + -0.14535367*inputs[59] + -1.01426354*inputs[60] + -1.34424716*inputs[61] + 0.40711493*inputs[62] + -0.13190433*inputs[63] + -0.15156488

def neuron_107(inputs):
    return -1.09543383*inputs[0] + -1.20430577*inputs[1] + -0.50396193*inputs[2] + -0.31216797*inputs[3] + -0.11501311*inputs[4] + -1.15047235*inputs[5] + -1.54102246*inputs[6] + 0.33298022*inputs[7] + -1.13823335*inputs[8] + -0.85875475*inputs[9] + -0.82332392*inputs[10] + -1.20413175*inputs[11] + -0.63683386*inputs[12] + -1.45498565*inputs[13] + -0.70750492*inputs[14] + -1.33216312*inputs[15] + -0.11844499*inputs[16] + -0.67116888*inputs[17] + -1.39247886*inputs[18] + -1.44223080*inputs[19] + -1.09979145*inputs[20] + -0.91825566*inputs[21] + -0.94360613*inputs[22] + -0.14171981*inputs[23] + -0.53295961*inputs[24] + 0.24333999*inputs[25] + -0.27852004*inputs[26] + 0.11997653*inputs[27] + -1.42054551*inputs[28] + -0.04005003*inputs[29] + -0.25242517*inputs[30] + -0.00974906*inputs[31] + -1.50867386*inputs[32] + -1.03114294*inputs[33] + -1.17360345*inputs[34] + -1.29015806*inputs[35] + -0.80524569*inputs[36] + -0.27018985*inputs[37] + -0.58725505*inputs[38] + -0.53069621*inputs[39] + -0.97180652*inputs[40] + -1.13937066*inputs[41] + -1.00522928*inputs[42] + 0.64447178*inputs[43] + -0.21835891*inputs[44] + 0.15213677*inputs[45] + 0.25780726*inputs[46] + -1.11454284*inputs[47] + 0.28429446*inputs[48] + -0.52883953*inputs[49] + -1.39241331*inputs[50] + -0.88062292*inputs[51] + -1.02231460*inputs[52] + -1.34748491*inputs[53] + -0.13894084*inputs[54] + -0.79875856*inputs[55] + -0.38109236*inputs[56] + -1.09233628*inputs[57] + 0.04156708*inputs[58] + 0.40418790*inputs[59] + -1.20029836*inputs[60] + -1.14680586*inputs[61] + 0.02717229*inputs[62] + -0.18019294*inputs[63] + -0.35197058

def neuron_108(inputs):
    return -1.14913337*inputs[0] + -0.48367241*inputs[1] + -0.12979695*inputs[2] + 0.15419844*inputs[3] + -0.42620419*inputs[4] + -1.06308326*inputs[5] + -1.05355782*inputs[6] + -0.23102667*inputs[7] + -0.74770848*inputs[8] + -1.28353603*inputs[9] + -1.50242950*inputs[10] + -1.02576245*inputs[11] + -1.32543345*inputs[12] + -0.95638518*inputs[13] + -0.59980603*inputs[14] + -1.10694597*inputs[15] + -0.06842212*inputs[16] + -1.25694937*inputs[17] + -0.73609754*inputs[18] + -1.16476553*inputs[19] + -1.41988125*inputs[20] + -0.70067932*inputs[21] + -1.37368168*inputs[22] + 0.23412241*inputs[23] + -1.32512268*inputs[24] + -0.36524853*inputs[25] + -0.32447113*inputs[26] + -0.17518536*inputs[27] + -0.75984918*inputs[28] + 0.37510014*inputs[29] + -0.49328152*inputs[30] + -0.46615136*inputs[31] + -1.13721249*inputs[32] + -1.36091502*inputs[33] + -1.19633348*inputs[34] + -1.30290765*inputs[35] + -0.86612445*inputs[36] + -0.32960569*inputs[37] + -0.60987746*inputs[38] + -1.17201269*inputs[39] + -1.31070929*inputs[40] + -0.43695658*inputs[41] + -0.47168943*inputs[42] + -0.10070220*inputs[43] + 0.25636686*inputs[44] + 0.25820030*inputs[45] + 0.22748126*inputs[46] + -1.06524510*inputs[47] + -0.29011061*inputs[48] + -1.27962401*inputs[49] + -1.30847418*inputs[50] + -0.62824605*inputs[51] + -1.06426780*inputs[52] + -0.95994907*inputs[53] + -0.27123742*inputs[54] + -0.56800059*inputs[55] + -1.12554442*inputs[56] + -0.97148525*inputs[57] + 0.03556702*inputs[58] + 0.20503080*inputs[59] + -1.09604926*inputs[60] + -0.89189616*inputs[61] + 0.01405117*inputs[62] + 0.60758510*inputs[63] + -0.34364399

def neuron_109(inputs):
    return -1.55355246*inputs[0] + -1.11934293*inputs[1] + -0.07554074*inputs[2] + -0.28311898*inputs[3] + -0.47863000*inputs[4] + -0.91021418*inputs[5] + -1.09790900*inputs[6] + 0.07444174*inputs[7] + -1.35123133*inputs[8] + -0.45712653*inputs[9] + -0.63127589*inputs[10] + -1.22971152*inputs[11] + -0.87251472*inputs[12] + -0.91458129*inputs[13] + -0.59341164*inputs[14] + -1.25331992*inputs[15] + 0.30007389*inputs[16] + -1.44686714*inputs[17] + -1.46538630*inputs[18] + -1.72717502*inputs[19] + -1.19231337*inputs[20] + -0.82990205*inputs[21] + -0.51008867*inputs[22] + -0.20803691*inputs[23] + -0.84207713*inputs[24] + 0.27037875*inputs[25] + -0.07722373*inputs[26] + 0.02691144*inputs[27] + -1.08532916*inputs[28] + 0.01293380*inputs[29] + -0.23533863*inputs[30] + -0.83097984*inputs[31] + -1.09365139*inputs[32] + -0.64115945*inputs[33] + -1.29923519*inputs[34] + -1.01233992*inputs[35] + -1.25044212*inputs[36] + 0.19505462*inputs[37] + -1.16193763*inputs[38] + -0.76598882*inputs[39] + -1.20533161*inputs[40] + -1.27755943*inputs[41] + -1.17679007*inputs[42] + 0.35100060*inputs[43] + -0.07547484*inputs[44] + 0.62574457*inputs[45] + -0.14952967*inputs[46] + -1.17979354*inputs[47] + 0.10132343*inputs[48] + -1.69784024*inputs[49] + -0.48436323*inputs[50] + -0.93920752*inputs[51] + -0.87047666*inputs[52] + -1.16045302*inputs[53] + 0.42653421*inputs[54] + -0.16663631*inputs[55] + -0.69422191*inputs[56] + -1.48653248*inputs[57] + -0.21770373*inputs[58] + -0.37955090*inputs[59] + -0.58473550*inputs[60] + -1.32168593*inputs[61] + -0.51237097*inputs[62] + -0.10518839*inputs[63] + -0.39211947

def neuron_110(inputs):
    return -1.19206824*inputs[0] + -0.70132018*inputs[1] + 0.00772532*inputs[2] + -0.02074058*inputs[3] + -0.20434588*inputs[4] + -0.59356577*inputs[5] + -1.16041691*inputs[6] + 0.19989281*inputs[7] + -1.32666140*inputs[8] + -1.20975514*inputs[9] + -0.84084837*inputs[10] + -0.74458428*inputs[11] + -1.08491475*inputs[12] + -0.80106623*inputs[13] + -1.18014178*inputs[14] + -1.10141101*inputs[15] + -0.09535323*inputs[16] + -1.27918933*inputs[17] + -0.81444376*inputs[18] + -0.71977290*inputs[19] + -1.31267299*inputs[20] + -0.64273810*inputs[21] + -0.47744709*inputs[22] + -0.00298811*inputs[23] + -1.45137875*inputs[24] + -0.43310503*inputs[25] + -0.27126046*inputs[26] + -0.41505058*inputs[27] + -1.51138905*inputs[28] + -0.35616205*inputs[29] + -0.34207568*inputs[30] + -0.07570097*inputs[31] + -1.05849732*inputs[32] + -1.32602288*inputs[33] + -1.26670673*inputs[34] + -0.74968926*inputs[35] + -1.20699181*inputs[36] + 0.14970534*inputs[37] + -0.64295014*inputs[38] + -1.31261135*inputs[39] + -1.49745207*inputs[40] + -0.36838489*inputs[41] + -0.46304260*inputs[42] + -0.14664314*inputs[43] + 0.23692404*inputs[44] + -0.25914207*inputs[45] + 0.03588391*inputs[46] + -1.39134193*inputs[47] + 0.09770739*inputs[48] + -0.65255955*inputs[49] + -1.13183752*inputs[50] + -0.42066299*inputs[51] + -1.59405886*inputs[52] + -1.43025240*inputs[53] + -0.22867830*inputs[54] + -0.59821628*inputs[55] + -1.48614702*inputs[56] + -0.87729903*inputs[57] + 0.17913636*inputs[58] + 0.29736859*inputs[59] + -1.57926418*inputs[60] + -1.07847531*inputs[61] + -0.43470366*inputs[62] + -0.12645123*inputs[63] + -0.42132245

def neuron_111(inputs):
    return -1.50931165*inputs[0] + -0.73171895*inputs[1] + 0.15286460*inputs[2] + -0.36216422*inputs[3] + -0.16518095*inputs[4] + -0.70164088*inputs[5] + -1.65847002*inputs[6] + -0.20466248*inputs[7] + -0.92404180*inputs[8] + -0.70514913*inputs[9] + -0.74232088*inputs[10] + -1.20710971*inputs[11] + -0.73935278*inputs[12] + -1.24264356*inputs[13] + -1.08008937*inputs[14] + -0.68196101*inputs[15] + 0.06969761*inputs[16] + -1.05976670*inputs[17] + -0.95854097*inputs[18] + -1.31394426*inputs[19] + -0.95642163*inputs[20] + -0.74506640*inputs[21] + -0.90493919*inputs[22] + 0.22125479*inputs[23] + -0.71338701*inputs[24] + 0.67577960*inputs[25] + -0.33720800*inputs[26] + -0.07705302*inputs[27] + -1.58003927*inputs[28] + 0.26339178*inputs[29] + -0.24623896*inputs[30] + 0.05665909*inputs[31] + -1.46066015*inputs[32] + -0.82668328*inputs[33] + -1.20519840*inputs[34] + -0.55560830*inputs[35] + -1.43516917*inputs[36] + 0.02273397*inputs[37] + -1.04701458*inputs[38] + -0.71830322*inputs[39] + -1.43938964*inputs[40] + -1.22583191*inputs[41] + -1.08809742*inputs[42] + -0.06309242*inputs[43] + 0.38877741*inputs[44] + 0.18008596*inputs[45] + -0.07497459*inputs[46] + -1.20109242*inputs[47] + 0.17193535*inputs[48] + -0.90390763*inputs[49] + -0.88281250*inputs[50] + -0.74593815*inputs[51] + -1.66198153*inputs[52] + -1.26815334*inputs[53] + -0.32699986*inputs[54] + -0.77244070*inputs[55] + -1.18510723*inputs[56] + -0.69760023*inputs[57] + -0.12434127*inputs[58] + -0.28099469*inputs[59] + -1.50476246*inputs[60] + -0.78793739*inputs[61] + -0.10653503*inputs[62] + -0.25236676*inputs[63] + -0.41192313

def neuron_112(inputs):
    return -1.47069037*inputs[0] + -1.05049238*inputs[1] + 0.07843537*inputs[2] + -0.17153419*inputs[3] + -0.25085178*inputs[4] + -1.42408332*inputs[5] + -0.70622614*inputs[6] + 0.21708775*inputs[7] + -1.30089405*inputs[8] + -1.47536971*inputs[9] + -0.68344692*inputs[10] + -1.06124764*inputs[11] + -0.67901113*inputs[12] + -0.68506349*inputs[13] + -1.08713005*inputs[14] + -1.13996255*inputs[15] + 0.49074353*inputs[16] + -0.97428421*inputs[17] + -0.97716864*inputs[18] + -1.14026937*inputs[19] + -1.16231290*inputs[20] + -1.10853428*inputs[21] + -0.71587372*inputs[22] + 0.33967064*inputs[23] + -1.00261325*inputs[24] + -0.21490317*inputs[25] + 0.06267196*inputs[26] + -0.32368729*inputs[27] + -0.30251799*inputs[28] + -0.27122500*inputs[29] + -0.42364657*inputs[30] + -0.01185541*inputs[31] + -0.51695137*inputs[32] + -1.42477819*inputs[33] + -1.22652165*inputs[34] + -1.01554644*inputs[35] + -1.18616470*inputs[36] + 0.26687622*inputs[37] + -1.49969292*inputs[38] + -0.74614647*inputs[39] + -0.93447157*inputs[40] + -0.41911072*inputs[41] + -1.50306400*inputs[42] + -0.15773988*inputs[43] + -0.13440101*inputs[44] + -0.03208157*inputs[45] + -0.08789022*inputs[46] + -1.02577879*inputs[47] + -0.02805415*inputs[48] + -0.54571874*inputs[49] + -0.36652609*inputs[50] + -1.02475316*inputs[51] + -1.02462211*inputs[52] + -0.75096212*inputs[53] + -0.40387549*inputs[54] + -1.24055924*inputs[55] + -1.07950356*inputs[56] + -1.28815756*inputs[57] + -0.09988913*inputs[58] + 0.03028274*inputs[59] + -0.87867602*inputs[60] + -1.12829012*inputs[61] + 0.49271399*inputs[62] + 0.54643692*inputs[63] + -0.22730718

def neuron_113(inputs):
    return -0.61578854*inputs[0] + -1.34881925*inputs[1] + 0.50948389*inputs[2] + 0.11258743*inputs[3] + 0.41074129*inputs[4] + -1.09871542*inputs[5] + -0.99337062*inputs[6] + -0.01657189*inputs[7] + -1.36016360*inputs[8] + -1.40520600*inputs[9] + -0.82320587*inputs[10] + -0.86646193*inputs[11] + -1.00281845*inputs[12] + -1.10669523*inputs[13] + -1.44128031*inputs[14] + -0.92792215*inputs[15] + 0.07502269*inputs[16] + -0.80249392*inputs[17] + -1.18608812*inputs[18] + -0.78557982*inputs[19] + -1.27387902*inputs[20] + -1.07923997*inputs[21] + -0.98316737*inputs[22] + -0.40331659*inputs[23] + -1.01895802*inputs[24] + 0.45341244*inputs[25] + 0.16298773*inputs[26] + 0.14265484*inputs[27] + -1.44876267*inputs[28] + 0.29005151*inputs[29] + -0.12428547*inputs[30] + 0.71765915*inputs[31] + -1.31900953*inputs[32] + -1.38215485*inputs[33] + -1.11704924*inputs[34] + -0.83701161*inputs[35] + -1.24526980*inputs[36] + -0.51407250*inputs[37] + -0.99928170*inputs[38] + -0.83384913*inputs[39] + -0.92005064*inputs[40] + -1.36239169*inputs[41] + -1.31952567*inputs[42] + -0.25389930*inputs[43] + -0.44974145*inputs[44] + -0.55675516*inputs[45] + 0.25909919*inputs[46] + -0.96959530*inputs[47] + 0.71864011*inputs[48] + -0.87223797*inputs[49] + -1.14302026*inputs[50] + -0.67181878*inputs[51] + -0.88474828*inputs[52] + -0.88941474*inputs[53] + 0.16427375*inputs[54] + -1.18590768*inputs[55] + -0.59680938*inputs[56] + -0.63341476*inputs[57] + -0.20728228*inputs[58] + -0.28833599*inputs[59] + -0.97566450*inputs[60] + -0.84669152*inputs[61] + -0.09647481*inputs[62] + -0.37729982*inputs[63] + -0.24448209

def neuron_114(inputs):
    return -0.80639910*inputs[0] + -0.66910907*inputs[1] + -0.30795160*inputs[2] + 0.46998750*inputs[3] + -0.28523706*inputs[4] + -0.93026239*inputs[5] + -1.40667511*inputs[6] + -0.13155103*inputs[7] + -0.87795402*inputs[8] + -1.03287289*inputs[9] + -1.23765579*inputs[10] + -1.06318618*inputs[11] + -0.90161028*inputs[12] + -1.29533793*inputs[13] + -1.15764077*inputs[14] + -1.03732505*inputs[15] + -0.12095971*inputs[16] + -1.09897661*inputs[17] + -0.85145071*inputs[18] + -1.11380474*inputs[19] + -1.32519777*inputs[20] + -0.33906997*inputs[21] + -1.82977410*inputs[22] + 0.05071867*inputs[23] + -1.25841467*inputs[24] + -0.24156599*inputs[25] + 0.00656190*inputs[26] + 0.30592255*inputs[27] + -0.50633090*inputs[28] + 0.34539375*inputs[29] + 0.06652004*inputs[30] + -0.19312095*inputs[31] + -1.11532351*inputs[32] + -1.07089474*inputs[33] + -1.25607355*inputs[34] + -1.53388695*inputs[35] + -0.84368743*inputs[36] + -0.09676208*inputs[37] + -1.14570256*inputs[38] + -0.73730037*inputs[39] + -0.92640905*inputs[40] + -1.04798965*inputs[41] + -0.50110336*inputs[42] + 0.47963052*inputs[43] + 0.18441188*inputs[44] + -0.15557938*inputs[45] + -0.27394172*inputs[46] + -0.70894047*inputs[47] + -0.04874524*inputs[48] + -1.32202238*inputs[49] + -1.11836836*inputs[50] + -0.74082555*inputs[51] + -0.93734783*inputs[52] + -0.52182309*inputs[53] + 0.42112845*inputs[54] + -1.21599814*inputs[55] + -1.21627937*inputs[56] + -0.89523873*inputs[57] + 0.23102856*inputs[58] + -0.30204295*inputs[59] + -1.09605730*inputs[60] + -1.13919345*inputs[61] + 0.18508637*inputs[62] + -0.15191070*inputs[63] + -0.32512169

def neuron_115(inputs):
    return -1.30215919*inputs[0] + -1.05418727*inputs[1] + 0.18331221*inputs[2] + 0.06337224*inputs[3] + 0.34179312*inputs[4] + -0.78470426*inputs[5] + -0.75695681*inputs[6] + -0.20805623*inputs[7] + -1.23663178*inputs[8] + -1.38055279*inputs[9] + -0.62360886*inputs[10] + -1.31960380*inputs[11] + -1.42035428*inputs[12] + -1.20532768*inputs[13] + -0.76981919*inputs[14] + -0.82732859*inputs[15] + -0.01174878*inputs[16] + -0.72558106*inputs[17] + -0.82463306*inputs[18] + -1.11958283*inputs[19] + -1.35605195*inputs[20] + -0.42235848*inputs[21] + -0.98144285*inputs[22] + 0.19825294*inputs[23] + -1.56506393*inputs[24] + 0.26796754*inputs[25] + -0.32677172*inputs[26] + -0.13425432*inputs[27] + -1.29026071*inputs[28] + 0.00976493*inputs[29] + -0.28050219*inputs[30] + 0.07253621*inputs[31] + -1.23987298*inputs[32] + -0.97533701*inputs[33] + -1.25599124*inputs[34] + -0.50242316*inputs[35] + -1.44541870*inputs[36] + -0.01934274*inputs[37] + -0.70522648*inputs[38] + -1.01539172*inputs[39] + -1.02805530*inputs[40] + -0.35478689*inputs[41] + -0.85537989*inputs[42] + -0.23742594*inputs[43] + 0.57943256*inputs[44] + -0.24815518*inputs[45] + -0.22052242*inputs[46] + -0.91691258*inputs[47] + 0.02106526*inputs[48] + -1.16752935*inputs[49] + -1.00351594*inputs[50] + -0.91123686*inputs[51] + -1.47619697*inputs[52] + -0.94241931*inputs[53] + -0.37060332*inputs[54] + -0.53895482*inputs[55] + -1.32578145*inputs[56] + -0.63267268*inputs[57] + -0.23145987*inputs[58] + -0.31484014*inputs[59] + -1.00670146*inputs[60] + -1.12119614*inputs[61] + 0.31220713*inputs[62] + -0.18433402*inputs[63] + -0.31266713

def neuron_116(inputs):
    return -1.24424013*inputs[0] + -0.49976687*inputs[1] + -0.04197473*inputs[2] + -0.14736519*inputs[3] + 0.19144516*inputs[4] + -1.56663806*inputs[5] + -1.51473689*inputs[6] + 0.18607175*inputs[7] + -1.35777525*inputs[8] + -1.13432780*inputs[9] + -0.42664741*inputs[10] + -0.77777682*inputs[11] + -0.46928410*inputs[12] + -1.12295290*inputs[13] + -1.18314000*inputs[14] + -1.39525669*inputs[15] + 0.27703494*inputs[16] + -1.28025241*inputs[17] + -0.84728622*inputs[18] + -1.00593469*inputs[19] + -1.54551480*inputs[20] + -0.76988177*inputs[21] + -1.22897217*inputs[22] + 0.26649940*inputs[23] + -0.52158710*inputs[24] + -0.15424786*inputs[25] + -0.54428525*inputs[26] + -0.37380723*inputs[27] + -0.61234631*inputs[28] + 0.26720871*inputs[29] + 0.30085259*inputs[30] + 0.23986328*inputs[31] + -1.14254921*inputs[32] + -1.24588283*inputs[33] + -1.03681143*inputs[34] + -1.21797674*inputs[35] + -1.32709465*inputs[36] + 0.12775527*inputs[37] + -0.88062953*inputs[38] + -1.37540274*inputs[39] + -0.80357677*inputs[40] + -0.88732761*inputs[41] + -1.15590579*inputs[42] + 0.34384640*inputs[43] + 0.08019770*inputs[44] + -0.13254795*inputs[45] + -0.18262502*inputs[46] + -0.50856092*inputs[47] + -0.00463965*inputs[48] + -0.90068548*inputs[49] + -1.30613623*inputs[50] + -0.46841836*inputs[51] + -0.79590335*inputs[52] + -0.50976677*inputs[53] + 0.27836746*inputs[54] + -1.43911893*inputs[55] + -0.71643669*inputs[56] + -1.41746310*inputs[57] + -0.20590188*inputs[58] + 0.17145322*inputs[59] + -1.11043452*inputs[60] + -0.95888933*inputs[61] + -0.05785103*inputs[62] + -0.27852532*inputs[63] + -0.33065440

def neuron_117(inputs):
    return -0.87430217*inputs[0] + -0.92981130*inputs[1] + 0.23683176*inputs[2] + 0.33546223*inputs[3] + 0.58735264*inputs[4] + -1.30420431*inputs[5] + -0.21701225*inputs[6] + -0.22665296*inputs[7] + -1.31508604*inputs[8] + -1.21381909*inputs[9] + -0.66826006*inputs[10] + -1.46855702*inputs[11] + -0.61032670*inputs[12] + -1.57474294*inputs[13] + -0.91641511*inputs[14] + -1.12549456*inputs[15] + 0.02122116*inputs[16] + -1.18928365*inputs[17] + -1.19064711*inputs[18] + -0.77412599*inputs[19] + -1.20427718*inputs[20] + -0.67838353*inputs[21] + -0.93527940*inputs[22] + 0.11921736*inputs[23] + -1.42927436*inputs[24] + 0.36117900*inputs[25] + 0.06095849*inputs[26] + -0.25794210*inputs[27] + -1.19857464*inputs[28] + 0.30384672*inputs[29] + -0.24776568*inputs[30] + -0.29220152*inputs[31] + -1.08508223*inputs[32] + -1.19889857*inputs[33] + -0.90881014*inputs[34] + -1.14897781*inputs[35] + -1.23097867*inputs[36] + -0.14264497*inputs[37] + -0.55645274*inputs[38] + -0.79540396*inputs[39] + -1.11965222*inputs[40] + -0.72345397*inputs[41] + -1.10149251*inputs[42] + 0.00459606*inputs[43] + -0.17657525*inputs[44] + 0.06769063*inputs[45] + -0.50127913*inputs[46] + -0.91741531*inputs[47] + 0.63765020*inputs[48] + -0.73705385*inputs[49] + -0.76408511*inputs[50] + -0.90731117*inputs[51] + -1.16305404*inputs[52] + -1.35090527*inputs[53] + -0.33102407*inputs[54] + -0.77709088*inputs[55] + -0.71883237*inputs[56] + -0.77739442*inputs[57] + -0.09170568*inputs[58] + -0.43506110*inputs[59] + -1.27134856*inputs[60] + -0.97781206*inputs[61] + 0.45150693*inputs[62] + 0.01099556*inputs[63] + -0.30922998

def neuron_118(inputs):
    return -1.34077397*inputs[0] + -1.81068383*inputs[1] + -0.35958756*inputs[2] + -0.21620329*inputs[3] + 0.12113667*inputs[4] + -0.81931247*inputs[5] + -1.46154825*inputs[6] + 0.42821574*inputs[7] + -1.51959502*inputs[8] + -0.21809333*inputs[9] + -0.92405217*inputs[10] + -1.32925257*inputs[11] + -0.59183918*inputs[12] + -0.31625286*inputs[13] + -1.25177380*inputs[14] + -1.14919209*inputs[15] + 0.00145139*inputs[16] + -1.24672039*inputs[17] + -0.82507634*inputs[18] + 0.93023001*inputs[19] + -0.78215226*inputs[20] + -1.63021813*inputs[21] + -1.26021486*inputs[22] + -0.25582803*inputs[23] + -0.61783460*inputs[24] + -0.62316428*inputs[25] + 0.42090555*inputs[26] + -0.08841469*inputs[27] + -1.05742766*inputs[28] + -0.15549319*inputs[29] + 0.40257170*inputs[30] + 0.41401632*inputs[31] + -1.69591969*inputs[32] + -0.70455159*inputs[33] + -0.43566500*inputs[34] + -0.84281118*inputs[35] + -1.10213737*inputs[36] + 0.39642529*inputs[37] + -1.75844851*inputs[38] + -1.30384928*inputs[39] + -1.85983507*inputs[40] + -1.69868118*inputs[41] + -1.50830224*inputs[42] + -0.08239059*inputs[43] + -0.64186507*inputs[44] + 0.65596639*inputs[45] + -0.31303082*inputs[46] + -0.89324803*inputs[47] + -0.03022015*inputs[48] + -0.03137951*inputs[49] + -1.15546241*inputs[50] + -1.64742849*inputs[51] + -1.05566759*inputs[52] + -0.93328054*inputs[53] + -0.57217435*inputs[54] + -1.27626340*inputs[55] + -1.31302364*inputs[56] + -0.45150468*inputs[57] + 0.19712624*inputs[58] + 0.08007434*inputs[59] + -0.49616359*inputs[60] + -1.19071134*inputs[61] + 0.12874698*inputs[62] + -0.01396960*inputs[63] + -1.86470188

def neuron_119(inputs):
    return -1.01148467*inputs[0] + -1.30111163*inputs[1] + -0.00739135*inputs[2] + 0.00386610*inputs[3] + 0.41474507*inputs[4] + -1.16883080*inputs[5] + -0.79994863*inputs[6] + -0.14167704*inputs[7] + -1.43448284*inputs[8] + -0.98297985*inputs[9] + -1.43299217*inputs[10] + -1.30581067*inputs[11] + -0.93626842*inputs[12] + -1.43926588*inputs[13] + -0.13223864*inputs[14] + -1.11845516*inputs[15] + -0.07088445*inputs[16] + -0.99132556*inputs[17] + -0.31344556*inputs[18] + -1.43963054*inputs[19] + -1.82965023*inputs[20] + -0.76312480*inputs[21] + -1.77670173*inputs[22] + -0.56009378*inputs[23] + 0.67315205*inputs[24] + 0.02094520*inputs[25] + -0.12150630*inputs[26] + -0.56590864*inputs[27] + -0.69651007*inputs[28] + 0.09803725*inputs[29] + 0.07002274*inputs[30] + 0.39808686*inputs[31] + -1.52150775*inputs[32] + 0.02389855*inputs[33] + -0.92463774*inputs[34] + -1.41656162*inputs[35] + -0.34748941*inputs[36] + -0.21284412*inputs[37] + 0.39919819*inputs[38] + -1.42637880*inputs[39] + -1.49469148*inputs[40] + -1.32050590*inputs[41] + -1.60531342*inputs[42] + -0.00720664*inputs[43] + -0.13083025*inputs[44] + -0.74708438*inputs[45] + -0.07934405*inputs[46] + -0.95160062*inputs[47] + 0.05861073*inputs[48] + -0.11232960*inputs[49] + -1.32990182*inputs[50] + -0.89426865*inputs[51] + -1.02604075*inputs[52] + -1.07740807*inputs[53] + -0.19608867*inputs[54] + -1.18919896*inputs[55] + -1.48082269*inputs[56] + -0.27588110*inputs[57] + -0.33658548*inputs[58] + -0.16294545*inputs[59] + -1.04456246*inputs[60] + -1.36178825*inputs[61] + -0.07011994*inputs[62] + -0.21151262*inputs[63] + -0.09500492

def neuron_120(inputs):
    return -1.43463403*inputs[0] + -1.32872996*inputs[1] + -0.18684474*inputs[2] + 0.11162569*inputs[3] + -0.09818947*inputs[4] + -0.86616338*inputs[5] + -0.67707069*inputs[6] + 0.40405658*inputs[7] + -1.53007876*inputs[8] + -1.18415676*inputs[9] + -1.02407436*inputs[10] + -1.03864442*inputs[11] + -1.26634736*inputs[12] + -0.39835397*inputs[13] + -0.94621177*inputs[14] + -1.06884488*inputs[15] + -0.18423083*inputs[16] + -0.61791844*inputs[17] + -0.52036052*inputs[18] + -1.06141666*inputs[19] + -1.51838581*inputs[20] + -0.50563013*inputs[21] + -1.25320080*inputs[22] + -0.40290199*inputs[23] + -1.09916580*inputs[24] + -0.22580403*inputs[25] + -0.37390171*inputs[26] + -0.21325915*inputs[27] + -0.63679055*inputs[28] + -0.19579856*inputs[29] + -0.17938009*inputs[30] + 0.02079091*inputs[31] + -1.30599064*inputs[32] + -0.87773458*inputs[33] + -1.25183430*inputs[34] + -0.98754306*inputs[35] + -1.03884936*inputs[36] + -0.38433719*inputs[37] + -0.49283526*inputs[38] + -1.49031335*inputs[39] + -1.24300580*inputs[40] + -0.52065235*inputs[41] + -0.77425634*inputs[42] + -0.16252634*inputs[43] + 0.17064017*inputs[44] + -0.13326119*inputs[45] + -0.15846717*inputs[46] + -0.69460053*inputs[47] + -0.07620483*inputs[48] + -0.65672944*inputs[49] + -1.15191882*inputs[50] + -1.39731554*inputs[51] + -0.59044020*inputs[52] + -1.42528789*inputs[53] + -0.21583701*inputs[54] + -0.84850899*inputs[55] + -1.31412448*inputs[56] + -0.58466780*inputs[57] + -0.04088010*inputs[58] + 0.48845515*inputs[59] + -1.62502426*inputs[60] + -1.49422742*inputs[61] + -0.32589905*inputs[62] + 0.16853098*inputs[63] + -0.32802879

def neuron_121(inputs):
    return -1.18245162*inputs[0] + -1.24304165*inputs[1] + 0.16618408*inputs[2] + -0.30053300*inputs[3] + 0.05458480*inputs[4] + -0.90343000*inputs[5] + -1.61440520*inputs[6] + 0.12720491*inputs[7] + -1.36038849*inputs[8] + -1.29081853*inputs[9] + -1.29419111*inputs[10] + -1.21704970*inputs[11] + -0.60513411*inputs[12] + -1.09470269*inputs[13] + -1.44076983*inputs[14] + -1.34832224*inputs[15] + 0.15431020*inputs[16] + -0.87364633*inputs[17] + -1.36221856*inputs[18] + -1.14866215*inputs[19] + -0.93770978*inputs[20] + -0.64768170*inputs[21] + -0.81514835*inputs[22] + -0.18640236*inputs[23] + -1.21773978*inputs[24] + -0.42306580*inputs[25] + -0.16596843*inputs[26] + 0.62899492*inputs[27] + -0.25201637*inputs[28] + -0.30055046*inputs[29] + -0.46635785*inputs[30] + 0.07001643*inputs[31] + -0.43893501*inputs[32] + -0.90555782*inputs[33] + -1.29433095*inputs[34] + -0.77043139*inputs[35] + -0.98173934*inputs[36] + -0.28351246*inputs[37] + -0.83996274*inputs[38] + -0.85339963*inputs[39] + -1.34689248*inputs[40] + -0.39549395*inputs[41] + -1.27499708*inputs[42] + -0.03284999*inputs[43] + -0.22885285*inputs[44] + -0.44792182*inputs[45] + 0.25684620*inputs[46] + -0.97729418*inputs[47] + 0.40520206*inputs[48] + -0.29836884*inputs[49] + -0.37920068*inputs[50] + -1.19479822*inputs[51] + -1.17738609*inputs[52] + -1.31889558*inputs[53] + 0.18871668*inputs[54] + -1.27952894*inputs[55] + -1.30927480*inputs[56] + -0.64291681*inputs[57] + 0.28273336*inputs[58] + 0.21528075*inputs[59] + -0.99879354*inputs[60] + -1.18825811*inputs[61] + -0.06968895*inputs[62] + 0.11505491*inputs[63] + -0.26617912

def neuron_122(inputs):
    return -1.07015618*inputs[0] + -1.29753017*inputs[1] + 0.04518126*inputs[2] + 0.13773345*inputs[3] + 0.25279876*inputs[4] + -0.95252653*inputs[5] + -1.13821976*inputs[6] + -0.01073182*inputs[7] + -1.17200524*inputs[8] + -1.29422727*inputs[9] + -0.27160765*inputs[10] + -1.02610345*inputs[11] + -0.94653476*inputs[12] + -1.02490829*inputs[13] + -1.09254331*inputs[14] + -0.68034845*inputs[15] + -0.00436063*inputs[16] + -0.79499037*inputs[17] + -1.21548993*inputs[18] + -0.90987287*inputs[19] + -1.54825113*inputs[20] + -0.24745814*inputs[21] + -1.35581371*inputs[22] + 0.13129565*inputs[23] + -1.42531339*inputs[24] + -0.28065208*inputs[25] + -0.51496126*inputs[26] + -0.34842783*inputs[27] + -0.85135258*inputs[28] + 0.24592069*inputs[29] + 0.17039578*inputs[30] + 0.17163432*inputs[31] + -1.48310753*inputs[32] + -0.97017854*inputs[33] + -1.22954946*inputs[34] + -1.33342976*inputs[35] + -1.58652008*inputs[36] + 0.00004624*inputs[37] + -1.13737123*inputs[38] + -0.76815491*inputs[39] + -0.68000669*inputs[40] + -1.27656430*inputs[41] + -0.60624909*inputs[42] + 0.67027929*inputs[43] + 0.37150018*inputs[44] + -0.30535224*inputs[45] + -0.48717018*inputs[46] + -0.94335785*inputs[47] + -0.31593882*inputs[48] + -0.91374368*inputs[49] + -1.24964979*inputs[50] + -1.24428497*inputs[51] + -0.40686413*inputs[52] + -0.78603571*inputs[53] + 0.21287119*inputs[54] + -1.45000457*inputs[55] + -1.19009158*inputs[56] + -0.49644142*inputs[57] + 0.28724733*inputs[58] + -0.38277932*inputs[59] + -1.14506625*inputs[60] + -1.01617562*inputs[61] + 0.16743011*inputs[62] + -0.21322346*inputs[63] + -0.20486087

def neuron_123(inputs):
    return -1.08513211*inputs[0] + -0.96899507*inputs[1] + -0.07964616*inputs[2] + -0.44761572*inputs[3] + 0.36384741*inputs[4] + -0.84055538*inputs[5] + -1.18683574*inputs[6] + 0.20436401*inputs[7] + -1.29477395*inputs[8] + -0.94471304*inputs[9] + -0.78541390*inputs[10] + -1.31839237*inputs[11] + -1.03050844*inputs[12] + -0.93708000*inputs[13] + -1.09528828*inputs[14] + -0.97223151*inputs[15] + -0.21357047*inputs[16] + -0.88518178*inputs[17] + -0.87673222*inputs[18] + -3.47651580*inputs[19] + -0.77304139*inputs[20] + -1.04328252*inputs[21] + -1.43123257*inputs[22] + -0.47854684*inputs[23] + -0.81782577*inputs[24] + -0.49184236*inputs[25] + 0.30708534*inputs[26] + -0.05909562*inputs[27] + -1.06153671*inputs[28] + -0.53327182*inputs[29] + 0.25616026*inputs[30] + 0.34640555*inputs[31] + -1.06290239*inputs[32] + -0.62659805*inputs[33] + -1.11470377*inputs[34] + -0.84814662*inputs[35] + -1.11720243*inputs[36] + 0.26974152*inputs[37] + -1.42426307*inputs[38] + -1.08855740*inputs[39] + -0.84288408*inputs[40] + -0.87452354*inputs[41] + -1.13165519*inputs[42] + -0.04913466*inputs[43] + 0.26929734*inputs[44] + 0.69796751*inputs[45] + 0.26607295*inputs[46] + -0.90789424*inputs[47] + -0.16737031*inputs[48] + -0.25013650*inputs[49] + -0.83583007*inputs[50] + -2.12726567*inputs[51] + -1.34031199*inputs[52] + -1.14824501*inputs[53] + 0.20479724*inputs[54] + -1.35193046*inputs[55] + -0.71931210*inputs[56] + -0.67200614*inputs[57] + 0.66267207*inputs[58] + 0.56199423*inputs[59] + -0.38995746*inputs[60] + -1.19388488*inputs[61] + 0.09053633*inputs[62] + -0.03165967*inputs[63] + 1.86041937

def neuron_124(inputs):
    return -1.26276641*inputs[0] + -1.44888382*inputs[1] + -0.33591378*inputs[2] + -0.01238369*inputs[3] + 0.73290887*inputs[4] + -0.56410100*inputs[5] + -1.22598334*inputs[6] + -0.91710617*inputs[7] + -1.80369650*inputs[8] + -1.67582930*inputs[9] + -1.23035441*inputs[10] + -1.20209910*inputs[11] + -1.41375894*inputs[12] + -1.03583745*inputs[13] + -0.40484517*inputs[14] + -1.17862548*inputs[15] + -0.17249210*inputs[16] + -1.05063155*inputs[17] + -1.28263435*inputs[18] + -0.94493081*inputs[19] + -0.87782917*inputs[20] + -1.32056879*inputs[21] + -1.86335129*inputs[22] + -0.81140462*inputs[23] + -0.80207725*inputs[24] + 0.37073274*inputs[25] + 0.35153409*inputs[26] + 0.02357661*inputs[27] + -0.62352438*inputs[28] + 0.12978044*inputs[29] + 0.49647727*inputs[30] + 0.01614117*inputs[31] + -0.85774177*inputs[32] + -0.25623646*inputs[33] + -0.70724303*inputs[34] + -0.86708095*inputs[35] + -0.79180769*inputs[36] + 0.13573158*inputs[37] + -1.57436483*inputs[38] + -1.22457983*inputs[39] + -0.66357958*inputs[40] + -1.01324555*inputs[41] + -1.99741674*inputs[42] + -0.15905949*inputs[43] + 0.02919726*inputs[44] + 0.36209662*inputs[45] + 0.01454258*inputs[46] + 0.45720763*inputs[47] + -0.04899572*inputs[48] + -1.51860442*inputs[49] + -0.95117785*inputs[50] + -1.39860660*inputs[51] + -0.59541369*inputs[52] + -0.08887119*inputs[53] + -0.01236433*inputs[54] + -1.09086812*inputs[55] + -0.84864206*inputs[56] + -1.29974616*inputs[57] + 0.01079256*inputs[58] + -0.13567497*inputs[59] + -0.64179462*inputs[60] + -1.22135555*inputs[61] + 0.67650980*inputs[62] + 0.30873902*inputs[63] + -0.28901008

def neuron_125(inputs):
    return -1.22117555*inputs[0] + -0.67073253*inputs[1] + -0.31875631*inputs[2] + -0.28965754*inputs[3] + -0.56883205*inputs[4] + -1.36196792*inputs[5] + -0.75632300*inputs[6] + -0.25350185*inputs[7] + -1.15132071*inputs[8] + -0.41275475*inputs[9] + -0.54187851*inputs[10] + -1.28169905*inputs[11] + -1.08694750*inputs[12] + -0.48300928*inputs[13] + -0.70486517*inputs[14] + -1.33349721*inputs[15] + -0.03934637*inputs[16] + -1.06988398*inputs[17] + -1.11662060*inputs[18] + -0.86489718*inputs[19] + -0.92406394*inputs[20] + -0.53378384*inputs[21] + -0.74352348*inputs[22] + 0.02249344*inputs[23] + -1.67935475*inputs[24] + -0.34533127*inputs[25] + -0.66936690*inputs[26] + -0.22070932*inputs[27] + -1.28840892*inputs[28] + -0.14060201*inputs[29] + 0.56691088*inputs[30] + 0.12670753*inputs[31] + -1.14393116*inputs[32] + -1.32116114*inputs[33] + -1.32757189*inputs[34] + -0.57198098*inputs[35] + -1.39112203*inputs[36] + -0.29159748*inputs[37] + -1.43376291*inputs[38] + -1.19974252*inputs[39] + -1.08131961*inputs[40] + -0.71916181*inputs[41] + -0.63564303*inputs[42] + 0.19015378*inputs[43] + -0.40644590*inputs[44] + 0.61089765*inputs[45] + -0.32171875*inputs[46] + -1.19754886*inputs[47] + -0.00855868*inputs[48] + -1.14477318*inputs[49] + -1.07525683*inputs[50] + -1.16024403*inputs[51] + -1.21868220*inputs[52] + -1.42795357*inputs[53] + -0.19608968*inputs[54] + -0.70901077*inputs[55] + -0.90239789*inputs[56] + -0.64994931*inputs[57] + -0.29925532*inputs[58] + -0.20499108*inputs[59] + -1.34542594*inputs[60] + -1.21043960*inputs[61] + -0.21570261*inputs[62] + -0.42215953*inputs[63] + -0.53467932

def neuron_126(inputs):
    return -1.48414117*inputs[0] + -1.45380325*inputs[1] + -0.00982774*inputs[2] + -0.33371210*inputs[3] + 0.07114491*inputs[4] + -1.39736585*inputs[5] + -1.18160844*inputs[6] + -0.42064919*inputs[7] + -0.87400372*inputs[8] + -0.93228815*inputs[9] + -0.36084211*inputs[10] + -1.54971886*inputs[11] + -0.73239545*inputs[12] + -1.89822074*inputs[13] + -0.56287103*inputs[14] + -1.25209811*inputs[15] + -0.16337746*inputs[16] + 0.05094437*inputs[17] + -0.89484814*inputs[18] + -1.11680175*inputs[19] + -0.99112705*inputs[20] + -0.51281777*inputs[21] + -1.84872947*inputs[22] + -0.21176419*inputs[23] + -0.89514892*inputs[24] + 1.49590690*inputs[25] + -0.39934667*inputs[26] + 0.39529670*inputs[27] + -1.43754514*inputs[28] + 0.60666759*inputs[29] + -0.30036438*inputs[30] + -0.10116378*inputs[31] + -1.02233366*inputs[32] + -0.92117952*inputs[33] + -0.94256011*inputs[34] + -1.00204373*inputs[35] + -1.71777711*inputs[36] + -0.56358600*inputs[37] + -1.29806225*inputs[38] + -0.26222523*inputs[39] + -1.07392089*inputs[40] + -1.09478482*inputs[41] + -1.05191993*inputs[42] + 0.45664275*inputs[43] + -0.21720936*inputs[44] + -0.53723234*inputs[45] + -0.15646578*inputs[46] + -0.22877234*inputs[47] + 0.03290422*inputs[48] + -0.91746301*inputs[49] + -0.89981412*inputs[50] + -1.28963115*inputs[51] + -0.52041697*inputs[52] + -1.20622337*inputs[53] + -0.68278098*inputs[54] + -1.13639844*inputs[55] + -0.76226326*inputs[56] + -0.84126578*inputs[57] + -0.19279992*inputs[58] + -0.31573699*inputs[59] + -0.80938301*inputs[60] + -1.48674220*inputs[61] + 0.20308282*inputs[62] + -0.09159471*inputs[63] + -0.15904275

def neuron_127(inputs):
    return -0.85211899*inputs[0] + -0.88134747*inputs[1] + -0.22137548*inputs[2] + 0.31262567*inputs[3] + 0.08253147*inputs[4] + -0.48414435*inputs[5] + -1.68982156*inputs[6] + 0.08981806*inputs[7] + -1.31594947*inputs[8] + -0.71738568*inputs[9] + -1.47423574*inputs[10] + -1.26362572*inputs[11] + -0.78888916*inputs[12] + -1.05046109*inputs[13] + -0.57631397*inputs[14] + -1.10193809*inputs[15] + -0.25567346*inputs[16] + -0.77011362*inputs[17] + -0.95046166*inputs[18] + -0.99715136*inputs[19] + -1.66370999*inputs[20] + -0.75043027*inputs[21] + -1.99297958*inputs[22] + 0.15787933*inputs[23] + -0.77858277*inputs[24] + 0.23404479*inputs[25] + 0.03872361*inputs[26] + -0.08107599*inputs[27] + -0.95429108*inputs[28] + -0.20461758*inputs[29] + 0.31811146*inputs[30] + -0.19731543*inputs[31] + -1.24241508*inputs[32] + -0.86897298*inputs[33] + -0.96977958*inputs[34] + -1.11328937*inputs[35] + -1.28730166*inputs[36] + -0.09284582*inputs[37] + -0.50720064*inputs[38] + -1.12742971*inputs[39] + -0.82060278*inputs[40] + -0.62384927*inputs[41] + -1.40375090*inputs[42] + 0.32368553*inputs[43] + -0.14379205*inputs[44] + -0.33267687*inputs[45] + -0.33062144*inputs[46] + -0.69242712*inputs[47] + 0.10497386*inputs[48] + -0.62043178*inputs[49] + -0.77050067*inputs[50] + -0.70609670*inputs[51] + -1.06758500*inputs[52] + -0.91708118*inputs[53] + 0.03074057*inputs[54] + -1.11998811*inputs[55] + -1.33506159*inputs[56] + -1.15963538*inputs[57] + -0.19484851*inputs[58] + 0.50258477*inputs[59] + -1.33062173*inputs[60] + -1.31230965*inputs[61] + 0.42685898*inputs[62] + 0.31922543*inputs[63] + -0.46201766

def layer_0(inputs):
    return [neuron_0(inputs), neuron_1(inputs), neuron_2(inputs), neuron_3(inputs), neuron_4(inputs), neuron_5(inputs), neuron_6(inputs), neuron_7(inputs), neuron_8(inputs), neuron_9(inputs), neuron_10(inputs), neuron_11(inputs), neuron_12(inputs), neuron_13(inputs), neuron_14(inputs), neuron_15(inputs), neuron_16(inputs), neuron_17(inputs), neuron_18(inputs), neuron_19(inputs), neuron_20(inputs), neuron_21(inputs), neuron_22(inputs), neuron_23(inputs), neuron_24(inputs), neuron_25(inputs), neuron_26(inputs), neuron_27(inputs), neuron_28(inputs), neuron_29(inputs), neuron_30(inputs), neuron_31(inputs), neuron_32(inputs), neuron_33(inputs), neuron_34(inputs), neuron_35(inputs), neuron_36(inputs), neuron_37(inputs), neuron_38(inputs), neuron_39(inputs), neuron_40(inputs), neuron_41(inputs), neuron_42(inputs), neuron_43(inputs), neuron_44(inputs), neuron_45(inputs), neuron_46(inputs), neuron_47(inputs), neuron_48(inputs), neuron_49(inputs), neuron_50(inputs), neuron_51(inputs), neuron_52(inputs), neuron_53(inputs), neuron_54(inputs), neuron_55(inputs), neuron_56(inputs), neuron_57(inputs), neuron_58(inputs), neuron_59(inputs), neuron_60(inputs), neuron_61(inputs), neuron_62(inputs), neuron_63(inputs)]

def layer_1(inputs):
    return [neuron_64(inputs), neuron_65(inputs), neuron_66(inputs), neuron_67(inputs), neuron_68(inputs), neuron_69(inputs), neuron_70(inputs), neuron_71(inputs), neuron_72(inputs), neuron_73(inputs), neuron_74(inputs), neuron_75(inputs), neuron_76(inputs), neuron_77(inputs), neuron_78(inputs), neuron_79(inputs), neuron_80(inputs), neuron_81(inputs), neuron_82(inputs), neuron_83(inputs), neuron_84(inputs), neuron_85(inputs), neuron_86(inputs), neuron_87(inputs), neuron_88(inputs), neuron_89(inputs), neuron_90(inputs), neuron_91(inputs), neuron_92(inputs), neuron_93(inputs), neuron_94(inputs), neuron_95(inputs), neuron_96(inputs), neuron_97(inputs), neuron_98(inputs), neuron_99(inputs), neuron_100(inputs), neuron_101(inputs), neuron_102(inputs), neuron_103(inputs), neuron_104(inputs), neuron_105(inputs), neuron_106(inputs), neuron_107(inputs), neuron_108(inputs), neuron_109(inputs), neuron_110(inputs), neuron_111(inputs), neuron_112(inputs), neuron_113(inputs), neuron_114(inputs), neuron_115(inputs), neuron_116(inputs), neuron_117(inputs), neuron_118(inputs), neuron_119(inputs), neuron_120(inputs), neuron_121(inputs), neuron_122(inputs), neuron_123(inputs), neuron_124(inputs), neuron_125(inputs), neuron_126(inputs), neuron_127(inputs)]

def predict(inputs):
    a = inputs
    a = layer_0(a)
    a = layer_1(a)
    return softmax(a)

vocab = ['<|endoftext|>', 'Because', 'Hello!', 'Hi!', 'How', "How's", 'I', "It's", 'Not', 'Tell', 'Thanks', 'What', "What's", 'Why', 'a', 'about', 'ai:', 'an', 'and', 'asking!', 'award?', 'been', 'can', 'day', 'did', 'do', 'do?', 'field!', 'for', 'going?', 'great!', 'he', 'hello', 'help', 'help!', 'here', 'hey', 'hi', 'his', 'in', 'joke.', 'just', 'me', 'mind?', 'much,', 'new', 'of', 'on', 'outstanding', 'ready', 'scarecrow', 'tasks.', 'the', 'to', 'today?', 'user:', 'variety', 'was', 'win', 'with', 'you', 'you?', 'your', 'yours?']
word_to_idx = {w: i for i, w in enumerate(vocab)}
context_window = 4

if __name__ == '__main__':
    print('Interactive multi-word text completion.')
    print(f'Model context window: {context_window} words. Type text or empty to exit.')
    while True:
        inp = input('> ').strip()
        if not inp:
            break
        words = [w.strip() for w in inp.split(' ') if w.strip()]
        generated_words = words[:]
        print('Input:', ' '.join(generated_words), end='', flush=True)
        for _ in range(20):
            context = generated_words[-context_window:]
            x = [0.0] * len(vocab)
            for word in context:
                if word in word_to_idx:
                    x[word_to_idx[word]] = 1.0
            out = predict(x)
            idx = out.index(max(out))
            next_word = vocab[idx]
            if next_word == '<|endoftext|>': break
            generated_words.append(next_word)
            print(' ' + next_word, end='', flush=True)
            time.sleep(0.1)
        print('\n')