From 461b8338a25167fc6641faab7566d6ca18610156 Mon Sep 17 00:00:00 2001 From: Ryan Holtz Date: Tue, 11 Aug 2020 05:36:30 +0200 Subject: [PATCH] -flyball: Added netlist sound. [Ryan Holtz, Ivan Vangelista] --- scripts/target/mame/arcade.lua | 2 + scripts/target/mame/nl.lua | 4 + src/lib/netlist/generated/static_solvers.cpp | 1921 ++++++++++++++++++ src/mame/audio/nl_flyball.cpp | 190 ++ src/mame/audio/nl_flyball.h | 10 + src/mame/drivers/flyball.cpp | 56 +- src/mame/nl.lst | 3 + 7 files changed, 2175 insertions(+), 11 deletions(-) create mode 100644 src/mame/audio/nl_flyball.cpp create mode 100644 src/mame/audio/nl_flyball.h diff --git a/scripts/target/mame/arcade.lua b/scripts/target/mame/arcade.lua index 4589901ecbe..e268cb4cbd3 100644 --- a/scripts/target/mame/arcade.lua +++ b/scripts/target/mame/arcade.lua @@ -1213,6 +1213,8 @@ files { MAME_DIR .. "src/mame/includes/firetrk.h", MAME_DIR .. "src/mame/audio/firetrk.cpp", MAME_DIR .. "src/mame/video/firetrk.cpp", + MAME_DIR .. "src/mame/audio/nl_flyball.cpp", + MAME_DIR .. "src/mame/audio/nl_flyball.h", MAME_DIR .. "src/mame/drivers/flyball.cpp", MAME_DIR .. "src/mame/drivers/foodf.cpp", MAME_DIR .. "src/mame/includes/foodf.h", diff --git a/scripts/target/mame/nl.lua b/scripts/target/mame/nl.lua index 2c5d6950961..fc28d892fe1 100644 --- a/scripts/target/mame/nl.lua +++ b/scripts/target/mame/nl.lua @@ -157,6 +157,10 @@ files{ MAME_DIR .. "src/mame/machine/nl_gtrak10.cpp", MAME_DIR .. "src/mame/machine/nl_gtrak10.h", + MAME_DIR .. "src/mame/audio/nl_flyball.cpp", + MAME_DIR .. "src/mame/audio/nl_flyball.h", + MAME_DIR .. "src/mame/drivers/flyball.cpp", + MAME_DIR .. "src/mame/drivers/hazeltin.cpp", MAME_DIR .. "src/mame/drivers/1942.cpp", diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp index 5845f51ff3d..aeb9cb286e9 100644 --- a/src/lib/netlist/generated/static_solvers.cpp +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -23627,6 +23627,1807 @@ static void nl_gcr_934712b55bb3b2b2_10_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// flyball +static void nl_gcr_93d3ff6e33ffafdb_291_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + double m_A7(0.0); + double m_A8(0.0); + double m_A9(0.0); + double m_A10(0.0); + double m_A11(0.0); + double m_A12(0.0); + double m_A13(0.0); + double m_A14(0.0); + double m_A15(0.0); + double m_A16(0.0); + double m_A17(0.0); + double m_A18(0.0); + double m_A19(0.0); + double m_A20(0.0); + double m_A21(0.0); + double m_A22(0.0); + double m_A23(0.0); + double m_A24(0.0); + double m_A25(0.0); + double m_A26(0.0); + double m_A27(0.0); + double m_A28(0.0); + double m_A29(0.0); + double m_A30(0.0); + double m_A31(0.0); + double m_A32(0.0); + double m_A33(0.0); + double m_A34(0.0); + double m_A35(0.0); + double m_A36(0.0); + double m_A37(0.0); + double m_A38(0.0); + double m_A39(0.0); + double m_A40(0.0); + double m_A41(0.0); + double m_A42(0.0); + double m_A43(0.0); + double m_A44(0.0); + double m_A45(0.0); + double m_A46(0.0); + double m_A47(0.0); + double m_A48(0.0); + double m_A49(0.0); + double m_A50(0.0); + double m_A51(0.0); + double m_A52(0.0); + double m_A53(0.0); + double m_A54(0.0); + double m_A55(0.0); + double m_A56(0.0); + double m_A57(0.0); + double m_A58(0.0); + double m_A59(0.0); + double m_A60(0.0); + double m_A61(0.0); + double m_A62(0.0); + double m_A63(0.0); + double m_A64(0.0); + double m_A65(0.0); + double m_A66(0.0); + double m_A67(0.0); + double m_A68(0.0); + double m_A69(0.0); + double m_A70(0.0); + double m_A71(0.0); + double m_A72(0.0); + double m_A73(0.0); + double m_A74(0.0); + double m_A75(0.0); + double m_A76(0.0); + double m_A77(0.0); + double m_A78(0.0); + double m_A79(0.0); + double m_A80(0.0); + double m_A81(0.0); + double m_A82(0.0); + double m_A83(0.0); + double m_A84(0.0); + double m_A85(0.0); + double m_A86(0.0); + double m_A87(0.0); + double m_A88(0.0); + double m_A89(0.0); + double m_A90(0.0); + double m_A91(0.0); + double m_A92(0.0); + double m_A93(0.0); + double m_A94(0.0); + double m_A95(0.0); + double m_A96(0.0); + double m_A97(0.0); + double m_A98(0.0); + double m_A99(0.0); + double m_A100(0.0); + double m_A101(0.0); + double m_A102(0.0); + double m_A103(0.0); + double m_A104(0.0); + double m_A105(0.0); + double m_A106(0.0); + double m_A107(0.0); + double m_A108(0.0); + double m_A109(0.0); + double m_A110(0.0); + double m_A111(0.0); + double m_A112(0.0); + double m_A113(0.0); + double m_A114(0.0); + double m_A115(0.0); + double m_A116(0.0); + double m_A117(0.0); + double m_A118(0.0); + double m_A119(0.0); + double m_A120(0.0); + double m_A121(0.0); + double m_A122(0.0); + double m_A123(0.0); + double m_A124(0.0); + double m_A125(0.0); + double m_A126(0.0); + double m_A127(0.0); + double m_A128(0.0); + double m_A129(0.0); + double m_A130(0.0); + double m_A131(0.0); + double m_A132(0.0); + double m_A133(0.0); + double m_A134(0.0); + double m_A135(0.0); + double m_A136(0.0); + double m_A137(0.0); + double m_A138(0.0); + double m_A139(0.0); + double m_A140(0.0); + double m_A141(0.0); + double m_A142(0.0); + double m_A143(0.0); + double m_A144(0.0); + double m_A145(0.0); + double m_A146(0.0); + double m_A147(0.0); + double m_A148(0.0); + double m_A149(0.0); + double m_A150(0.0); + double m_A151(0.0); + double m_A152(0.0); + double m_A153(0.0); + double m_A154(0.0); + double m_A155(0.0); + double m_A156(0.0); + double m_A157(0.0); + double m_A158(0.0); + double m_A159(0.0); + double m_A160(0.0); + double m_A161(0.0); + double m_A162(0.0); + double m_A163(0.0); + double m_A164(0.0); + double m_A165(0.0); + double m_A166(0.0); + double m_A167(0.0); + double m_A168(0.0); + double m_A169(0.0); + double m_A170(0.0); + double m_A171(0.0); + double m_A172(0.0); + double m_A173(0.0); + double m_A174(0.0); + double m_A175(0.0); + double m_A176(0.0); + double m_A177(0.0); + double m_A178(0.0); + double m_A179(0.0); + double m_A180(0.0); + double m_A181(0.0); + double m_A182(0.0); + double m_A183(0.0); + double m_A184(0.0); + double m_A185(0.0); + double m_A186(0.0); + double m_A187(0.0); + double m_A188(0.0); + double m_A189(0.0); + double m_A190(0.0); + double m_A191(0.0); + double m_A192(0.0); + double m_A193(0.0); + double m_A194(0.0); + double m_A195(0.0); + double m_A196(0.0); + double m_A197(0.0); + double m_A198(0.0); + double m_A199(0.0); + double m_A200(0.0); + double m_A201(0.0); + double m_A202(0.0); + double m_A203(0.0); + double m_A204(0.0); + double m_A205(0.0); + double m_A206(0.0); + double m_A207(0.0); + double m_A208(0.0); + double m_A209(0.0); + double m_A210(0.0); + double m_A211(0.0); + double m_A212(0.0); + double m_A213(0.0); + double m_A214(0.0); + double m_A215(0.0); + double m_A216(0.0); + double m_A217(0.0); + double m_A218(0.0); + double m_A219(0.0); + double m_A220(0.0); + double m_A221(0.0); + double m_A222(0.0); + double m_A223(0.0); + double m_A224(0.0); + double m_A225(0.0); + double m_A226(0.0); + double m_A227(0.0); + double m_A228(0.0); + double m_A229(0.0); + double m_A230(0.0); + double m_A231(0.0); + double m_A232(0.0); + double m_A233(0.0); + double m_A234(0.0); + double m_A235(0.0); + double m_A236(0.0); + double m_A237(0.0); + double m_A238(0.0); + double m_A239(0.0); + double m_A240(0.0); + double m_A241(0.0); + double m_A242(0.0); + double m_A243(0.0); + double m_A244(0.0); + double m_A245(0.0); + double m_A246(0.0); + double m_A247(0.0); + double m_A248(0.0); + double m_A249(0.0); + double m_A250(0.0); + double m_A251(0.0); + double m_A252(0.0); + double m_A253(0.0); + double m_A254(0.0); + double m_A255(0.0); + double m_A256(0.0); + double m_A257(0.0); + double m_A258(0.0); + double m_A259(0.0); + double m_A260(0.0); + double m_A261(0.0); + double m_A262(0.0); + double m_A263(0.0); + double m_A264(0.0); + double m_A265(0.0); + double m_A266(0.0); + double m_A267(0.0); + double m_A268(0.0); + double m_A269(0.0); + double m_A270(0.0); + double m_A271(0.0); + double m_A272(0.0); + double m_A273(0.0); + double m_A274(0.0); + double m_A275(0.0); + double m_A276(0.0); + double m_A277(0.0); + double m_A278(0.0); + double m_A279(0.0); + double m_A280(0.0); + double m_A281(0.0); + double m_A282(0.0); + double m_A283(0.0); + double m_A284(0.0); + double m_A285(0.0); + double m_A286(0.0); + double m_A287(0.0); + double m_A288(0.0); + double m_A289(0.0); + double m_A290(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A7 += go[4]; + m_A6 += go[5]; + m_A5 += go[6]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[7] * *cnV[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A9 += go[8]; + double RHS3 = Idr[8]; + RHS3 += Idr[9]; + RHS3 -= go[9] * *cnV[9]; + m_A10 += gt[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A11 += go[10]; + m_A12 += go[11]; + double RHS4 = Idr[10]; + RHS4 += Idr[11]; + RHS4 += Idr[12]; + RHS4 -= go[12] * *cnV[12]; + m_A13 += gt[13]; + m_A13 += gt[14]; + m_A13 += gt[15]; + m_A14 += go[13]; + m_A15 += go[14]; + double RHS5 = Idr[13]; + RHS5 += Idr[14]; + RHS5 += Idr[15]; + RHS5 -= go[15] * *cnV[15]; + m_A16 += gt[16]; + m_A16 += gt[17]; + m_A16 += gt[18]; + m_A16 += gt[19]; + m_A16 += gt[20]; + m_A16 += gt[21]; + m_A16 += gt[22]; + m_A20 += go[16]; + m_A19 += go[17]; + m_A18 += go[18]; + m_A17 += go[19]; + double RHS6 = Idr[16]; + RHS6 += Idr[17]; + RHS6 += Idr[18]; + RHS6 += Idr[19]; + RHS6 += Idr[20]; + RHS6 += Idr[21]; + RHS6 += Idr[22]; + RHS6 -= go[20] * *cnV[20]; + RHS6 -= go[21] * *cnV[21]; + RHS6 -= go[22] * *cnV[22]; + m_A21 += gt[23]; + m_A21 += gt[24]; + m_A22 += go[23]; + double RHS7 = Idr[23]; + RHS7 += Idr[24]; + RHS7 -= go[24] * *cnV[24]; + m_A23 += gt[25]; + m_A23 += gt[26]; + m_A24 += go[25]; + double RHS8 = Idr[25]; + RHS8 += Idr[26]; + RHS8 -= go[26] * *cnV[26]; + m_A25 += gt[27]; + m_A25 += gt[28]; + m_A25 += gt[29]; + m_A25 += gt[30]; + m_A25 += gt[31]; + m_A25 += gt[32]; + m_A25 += gt[33]; + m_A29 += go[27]; + m_A28 += go[28]; + m_A27 += go[29]; + m_A26 += go[30]; + double RHS9 = Idr[27]; + RHS9 += Idr[28]; + RHS9 += Idr[29]; + RHS9 += Idr[30]; + RHS9 += Idr[31]; + RHS9 += Idr[32]; + RHS9 += Idr[33]; + RHS9 -= go[31] * *cnV[31]; + RHS9 -= go[32] * *cnV[32]; + RHS9 -= go[33] * *cnV[33]; + m_A30 += gt[34]; + m_A30 += gt[35]; + m_A31 += go[34]; + m_A32 += go[35]; + double RHS10 = Idr[34]; + RHS10 += Idr[35]; + m_A33 += gt[36]; + m_A33 += gt[37]; + m_A34 += go[36]; + double RHS11 = Idr[36]; + RHS11 += Idr[37]; + RHS11 -= go[37] * *cnV[37]; + m_A35 += gt[38]; + m_A35 += gt[39]; + m_A35 += gt[40]; + m_A35 += gt[41]; + m_A35 += gt[42]; + m_A35 += gt[43]; + m_A35 += gt[44]; + m_A36 += go[38]; + double RHS12 = Idr[38]; + RHS12 += Idr[39]; + RHS12 += Idr[40]; + RHS12 += Idr[41]; + RHS12 += Idr[42]; + RHS12 += Idr[43]; + RHS12 += Idr[44]; + RHS12 -= go[39] * *cnV[39]; + RHS12 -= go[40] * *cnV[40]; + RHS12 -= go[41] * *cnV[41]; + RHS12 -= go[42] * *cnV[42]; + RHS12 -= go[43] * *cnV[43]; + RHS12 -= go[44] * *cnV[44]; + m_A37 += gt[45]; + m_A37 += gt[46]; + m_A37 += gt[47]; + m_A37 += gt[48]; + m_A39 += go[45]; + m_A40 += go[46]; + m_A38 += go[47]; + double RHS13 = Idr[45]; + RHS13 += Idr[46]; + RHS13 += Idr[47]; + RHS13 += Idr[48]; + RHS13 -= go[48] * *cnV[48]; + m_A41 += gt[49]; + m_A41 += gt[50]; + m_A42 += go[49]; + m_A43 += go[50]; + double RHS14 = Idr[49]; + RHS14 += Idr[50]; + m_A44 += gt[51]; + m_A44 += gt[52]; + m_A44 += gt[53]; + m_A45 += go[51]; + double RHS15 = Idr[51]; + RHS15 += Idr[52]; + RHS15 += Idr[53]; + RHS15 -= go[52] * *cnV[52]; + RHS15 -= go[53] * *cnV[53]; + m_A46 += gt[54]; + m_A46 += gt[55]; + m_A46 += gt[56]; + m_A46 += gt[57]; + m_A49 += go[54]; + m_A48 += go[55]; + m_A47 += go[56]; + double RHS16 = Idr[54]; + RHS16 += Idr[55]; + RHS16 += Idr[56]; + RHS16 += Idr[57]; + RHS16 -= go[57] * *cnV[57]; + m_A50 += gt[58]; + m_A50 += gt[59]; + m_A50 += gt[60]; + m_A52 += go[58]; + m_A51 += go[59]; + double RHS17 = Idr[58]; + RHS17 += Idr[59]; + RHS17 += Idr[60]; + RHS17 -= go[60] * *cnV[60]; + m_A53 += gt[61]; + m_A53 += gt[62]; + m_A53 += gt[63]; + m_A54 += go[61]; + m_A55 += go[62]; + double RHS18 = Idr[61]; + RHS18 += Idr[62]; + RHS18 += Idr[63]; + RHS18 -= go[63] * *cnV[63]; + m_A56 += gt[64]; + m_A56 += gt[65]; + m_A56 += gt[66]; + m_A57 += go[64]; + double RHS19 = Idr[64]; + RHS19 += Idr[65]; + RHS19 += Idr[66]; + RHS19 -= go[65] * *cnV[65]; + RHS19 -= go[66] * *cnV[66]; + m_A58 += gt[67]; + m_A58 += gt[68]; + m_A58 += gt[69]; + m_A58 += gt[70]; + m_A58 += gt[71]; + m_A58 += gt[72]; + m_A58 += gt[73]; + m_A60 += go[67]; + m_A61 += go[68]; + m_A62 += go[69]; + m_A59 += go[70]; + double RHS20 = Idr[67]; + RHS20 += Idr[68]; + RHS20 += Idr[69]; + RHS20 += Idr[70]; + RHS20 += Idr[71]; + RHS20 += Idr[72]; + RHS20 += Idr[73]; + RHS20 -= go[71] * *cnV[71]; + RHS20 -= go[72] * *cnV[72]; + RHS20 -= go[73] * *cnV[73]; + m_A63 += gt[74]; + m_A63 += gt[75]; + m_A63 += gt[76]; + m_A63 += gt[77]; + m_A63 += gt[78]; + m_A63 += gt[79]; + m_A63 += gt[80]; + m_A64 += go[74]; + m_A66 += go[75]; + m_A67 += go[76]; + m_A65 += go[77]; + double RHS21 = Idr[74]; + RHS21 += Idr[75]; + RHS21 += Idr[76]; + RHS21 += Idr[77]; + RHS21 += Idr[78]; + RHS21 += Idr[79]; + RHS21 += Idr[80]; + RHS21 -= go[78] * *cnV[78]; + RHS21 -= go[79] * *cnV[79]; + RHS21 -= go[80] * *cnV[80]; + m_A68 += gt[81]; + m_A68 += gt[82]; + m_A68 += gt[83]; + m_A69 += go[81]; + double RHS22 = Idr[81]; + RHS22 += Idr[82]; + RHS22 += Idr[83]; + RHS22 -= go[82] * *cnV[82]; + RHS22 -= go[83] * *cnV[83]; + m_A70 += gt[84]; + m_A70 += gt[85]; + m_A70 += gt[86]; + m_A71 += go[84]; + double RHS23 = Idr[84]; + RHS23 += Idr[85]; + RHS23 += Idr[86]; + RHS23 -= go[85] * *cnV[85]; + RHS23 -= go[86] * *cnV[86]; + m_A72 += gt[87]; + m_A72 += gt[88]; + m_A72 += gt[89]; + m_A72 += gt[90]; + m_A74 += go[87]; + m_A73 += go[88]; + double RHS24 = Idr[87]; + RHS24 += Idr[88]; + RHS24 += Idr[89]; + RHS24 += Idr[90]; + RHS24 -= go[89] * *cnV[89]; + RHS24 -= go[90] * *cnV[90]; + m_A75 += gt[91]; + m_A75 += gt[92]; + m_A75 += gt[93]; + m_A75 += gt[94]; + m_A76 += go[91]; + m_A77 += go[92]; + double RHS25 = Idr[91]; + RHS25 += Idr[92]; + RHS25 += Idr[93]; + RHS25 += Idr[94]; + RHS25 -= go[93] * *cnV[93]; + RHS25 -= go[94] * *cnV[94]; + m_A78 += gt[95]; + m_A78 += gt[96]; + m_A79 += go[95]; + double RHS26 = Idr[95]; + RHS26 += Idr[96]; + RHS26 -= go[96] * *cnV[96]; + m_A80 += gt[97]; + m_A80 += gt[98]; + m_A81 += go[97]; + double RHS27 = Idr[97]; + RHS27 += Idr[98]; + RHS27 -= go[98] * *cnV[98]; + m_A82 += gt[99]; + m_A82 += gt[100]; + m_A83 += go[99]; + double RHS28 = Idr[99]; + RHS28 += Idr[100]; + RHS28 -= go[100] * *cnV[100]; + m_A86 += gt[101]; + m_A86 += gt[102]; + m_A86 += gt[103]; + m_A86 += gt[104]; + m_A85 += go[101]; + m_A84 += go[102]; + double RHS29 = Idr[101]; + RHS29 += Idr[102]; + RHS29 += Idr[103]; + RHS29 += Idr[104]; + RHS29 -= go[103] * *cnV[103]; + RHS29 -= go[104] * *cnV[104]; + m_A92 += gt[105]; + m_A92 += gt[106]; + m_A92 += gt[107]; + m_A92 += gt[108]; + m_A90 += go[105]; + m_A89 += go[106]; + double RHS30 = Idr[105]; + RHS30 += Idr[106]; + RHS30 += Idr[107]; + RHS30 += Idr[108]; + RHS30 -= go[107] * *cnV[107]; + RHS30 -= go[108] * *cnV[108]; + m_A99 += gt[109]; + m_A99 += gt[110]; + m_A99 += gt[111]; + m_A99 += gt[112]; + m_A97 += go[109]; + m_A98 += go[110]; + double RHS31 = Idr[109]; + RHS31 += Idr[110]; + RHS31 += Idr[111]; + RHS31 += Idr[112]; + RHS31 -= go[111] * *cnV[111]; + RHS31 -= go[112] * *cnV[112]; + m_A104 += gt[113]; + m_A104 += gt[114]; + m_A104 += gt[115]; + m_A103 += go[113]; + m_A105 += go[114]; + double RHS32 = Idr[113]; + RHS32 += Idr[114]; + RHS32 += Idr[115]; + RHS32 -= go[115] * *cnV[115]; + m_A108 += gt[116]; + m_A108 += gt[117]; + m_A108 += gt[118]; + m_A108 += gt[119]; + m_A107 += go[116]; + m_A106 += go[117]; + double RHS33 = Idr[116]; + RHS33 += Idr[117]; + RHS33 += Idr[118]; + RHS33 += Idr[119]; + RHS33 -= go[118] * *cnV[118]; + RHS33 -= go[119] * *cnV[119]; + m_A113 += gt[120]; + m_A113 += gt[121]; + m_A113 += gt[122]; + m_A113 += gt[123]; + m_A111 += go[120]; + m_A112 += go[121]; + m_A114 += go[122]; + double RHS34 = Idr[120]; + RHS34 += Idr[121]; + RHS34 += Idr[122]; + RHS34 += Idr[123]; + RHS34 -= go[123] * *cnV[123]; + m_A116 += gt[124]; + m_A116 += gt[125]; + m_A116 += gt[126]; + m_A115 += go[124]; + m_A117 += go[125]; + double RHS35 = Idr[124]; + RHS35 += Idr[125]; + RHS35 += Idr[126]; + RHS35 -= go[126] * *cnV[126]; + m_A120 += gt[127]; + m_A120 += gt[128]; + m_A120 += gt[129]; + m_A121 += go[127]; + m_A118 += go[128]; + double RHS36 = Idr[127]; + RHS36 += Idr[128]; + RHS36 += Idr[129]; + RHS36 -= go[129] * *cnV[129]; + m_A127 += gt[130]; + m_A127 += gt[131]; + m_A127 += gt[132]; + m_A127 += gt[133]; + m_A129 += go[130]; + m_A124 += go[131]; + m_A123 += go[132]; + double RHS37 = Idr[130]; + RHS37 += Idr[131]; + RHS37 += Idr[132]; + RHS37 += Idr[133]; + RHS37 -= go[133] * *cnV[133]; + m_A135 += gt[134]; + m_A135 += gt[135]; + m_A135 += gt[136]; + m_A135 += gt[137]; + m_A133 += go[134]; + m_A132 += go[135]; + double RHS38 = Idr[134]; + RHS38 += Idr[135]; + RHS38 += Idr[136]; + RHS38 += Idr[137]; + RHS38 -= go[136] * *cnV[136]; + RHS38 -= go[137] * *cnV[137]; + m_A140 += gt[138]; + m_A140 += gt[139]; + m_A140 += gt[140]; + m_A141 += go[138]; + double RHS39 = Idr[138]; + RHS39 += Idr[139]; + RHS39 += Idr[140]; + RHS39 -= go[139] * *cnV[139]; + RHS39 -= go[140] * *cnV[140]; + m_A143 += gt[141]; + m_A143 += gt[142]; + m_A143 += gt[143]; + m_A142 += go[141]; + m_A144 += go[142]; + double RHS40 = Idr[141]; + RHS40 += Idr[142]; + RHS40 += Idr[143]; + RHS40 -= go[143] * *cnV[143]; + m_A147 += gt[144]; + m_A147 += gt[145]; + m_A147 += gt[146]; + m_A147 += gt[147]; + m_A145 += go[144]; + m_A146 += go[145]; + m_A148 += go[146]; + double RHS41 = Idr[144]; + RHS41 += Idr[145]; + RHS41 += Idr[146]; + RHS41 += Idr[147]; + RHS41 -= go[147] * *cnV[147]; + m_A153 += gt[148]; + m_A153 += gt[149]; + m_A153 += gt[150]; + m_A153 += gt[151]; + m_A153 += gt[152]; + m_A153 += gt[153]; + m_A153 += gt[154]; + m_A151 += go[148]; + m_A150 += go[149]; + m_A156 += go[150]; + m_A149 += go[151]; + m_A157 += go[152]; + double RHS42 = Idr[148]; + RHS42 += Idr[149]; + RHS42 += Idr[150]; + RHS42 += Idr[151]; + RHS42 += Idr[152]; + RHS42 += Idr[153]; + RHS42 += Idr[154]; + RHS42 -= go[153] * *cnV[153]; + RHS42 -= go[154] * *cnV[154]; + m_A163 += gt[155]; + m_A163 += gt[156]; + m_A163 += gt[157]; + m_A163 += gt[158]; + m_A163 += gt[159]; + m_A163 += gt[160]; + m_A167 += go[155]; + m_A160 += go[156]; + m_A159 += go[157]; + m_A158 += go[158]; + m_A165 += go[159]; + double RHS43 = Idr[155]; + RHS43 += Idr[156]; + RHS43 += Idr[157]; + RHS43 += Idr[158]; + RHS43 += Idr[159]; + RHS43 += Idr[160]; + RHS43 -= go[160] * *cnV[160]; + m_A170 += gt[161]; + m_A170 += gt[162]; + m_A174 += go[161]; + m_A168 += go[162]; + double RHS44 = Idr[161]; + RHS44 += Idr[162]; + m_A180 += gt[163]; + m_A180 += gt[164]; + m_A180 += gt[165]; + m_A180 += gt[166]; + m_A180 += gt[167]; + m_A180 += gt[168]; + m_A175 += go[163]; + m_A177 += go[164]; + m_A179 += go[165]; + m_A176 += go[166]; + double RHS45 = Idr[163]; + RHS45 += Idr[164]; + RHS45 += Idr[165]; + RHS45 += Idr[166]; + RHS45 += Idr[167]; + RHS45 += Idr[168]; + RHS45 -= go[167] * *cnV[167]; + RHS45 -= go[168] * *cnV[168]; + m_A184 += gt[169]; + m_A184 += gt[170]; + m_A185 += go[169]; + m_A183 += go[170]; + double RHS46 = Idr[169]; + RHS46 += Idr[170]; + m_A192 += gt[171]; + m_A192 += gt[172]; + m_A192 += gt[173]; + m_A192 += gt[174]; + m_A192 += gt[175]; + m_A189 += go[171]; + m_A188 += go[172]; + m_A187 += go[173]; + m_A190 += go[174]; + double RHS47 = Idr[171]; + RHS47 += Idr[172]; + RHS47 += Idr[173]; + RHS47 += Idr[174]; + RHS47 += Idr[175]; + RHS47 -= go[175] * *cnV[175]; + m_A202 += gt[176]; + m_A202 += gt[177]; + m_A202 += gt[178]; + m_A202 += gt[179]; + m_A196 += go[176]; + m_A197 += go[177]; + m_A204 += go[178]; + m_A199 += go[179]; + double RHS48 = Idr[176]; + RHS48 += Idr[177]; + RHS48 += Idr[178]; + RHS48 += Idr[179]; + m_A206 += gt[180]; + m_A206 += gt[181]; + m_A206 += gt[182]; + m_A205 += go[180]; + m_A207 += go[181]; + double RHS49 = Idr[180]; + RHS49 += Idr[181]; + RHS49 += Idr[182]; + RHS49 -= go[182] * *cnV[182]; + m_A215 += gt[183]; + m_A215 += gt[184]; + m_A215 += gt[185]; + m_A215 += gt[186]; + m_A212 += go[183]; + m_A209 += go[184]; + m_A208 += go[185]; + double RHS50 = Idr[183]; + RHS50 += Idr[184]; + RHS50 += Idr[185]; + RHS50 += Idr[186]; + RHS50 -= go[186] * *cnV[186]; + m_A227 += gt[187]; + m_A227 += gt[188]; + m_A227 += gt[189]; + m_A227 += gt[190]; + m_A227 += gt[191]; + m_A227 += gt[192]; + m_A223 += go[187]; + m_A224 += go[188]; + m_A221 += go[189]; + m_A219 += go[190]; + m_A220 += go[191]; + double RHS51 = Idr[187]; + RHS51 += Idr[188]; + RHS51 += Idr[189]; + RHS51 += Idr[190]; + RHS51 += Idr[191]; + RHS51 += Idr[192]; + RHS51 -= go[192] * *cnV[192]; + m_A237 += gt[193]; + m_A237 += gt[194]; + m_A237 += gt[195]; + m_A237 += gt[196]; + m_A231 += go[193]; + m_A230 += go[194]; + m_A233 += go[195]; + m_A232 += go[196]; + double RHS52 = Idr[193]; + RHS52 += Idr[194]; + RHS52 += Idr[195]; + RHS52 += Idr[196]; + m_A250 += gt[197]; + m_A250 += gt[198]; + m_A250 += gt[199]; + m_A250 += gt[200]; + m_A250 += gt[201]; + m_A250 += gt[202]; + m_A245 += go[197]; + m_A252 += go[198]; + m_A243 += go[199]; + m_A241 += go[200]; + m_A242 += go[201]; + double RHS53 = Idr[197]; + RHS53 += Idr[198]; + RHS53 += Idr[199]; + RHS53 += Idr[200]; + RHS53 += Idr[201]; + RHS53 += Idr[202]; + RHS53 -= go[202] * *cnV[202]; + m_A264 += gt[203]; + m_A264 += gt[204]; + m_A264 += gt[205]; + m_A264 += gt[206]; + m_A264 += gt[207]; + m_A264 += gt[208]; + m_A257 += go[203]; + m_A255 += go[204]; + m_A254 += go[205]; + m_A253 += go[206]; + m_A259 += go[207]; + double RHS54 = Idr[203]; + RHS54 += Idr[204]; + RHS54 += Idr[205]; + RHS54 += Idr[206]; + RHS54 += Idr[207]; + RHS54 += Idr[208]; + RHS54 -= go[208] * *cnV[208]; + m_A276 += gt[209]; + m_A276 += gt[210]; + m_A276 += gt[211]; + m_A276 += gt[212]; + m_A276 += gt[213]; + m_A276 += gt[214]; + m_A276 += gt[215]; + m_A272 += go[209]; + m_A271 += go[210]; + m_A270 += go[211]; + m_A269 += go[212]; + m_A268 += go[213]; + m_A267 += go[214]; + double RHS55 = Idr[209]; + RHS55 += Idr[210]; + RHS55 += Idr[211]; + RHS55 += Idr[212]; + RHS55 += Idr[213]; + RHS55 += Idr[214]; + RHS55 += Idr[215]; + RHS55 -= go[215] * *cnV[215]; + m_A290 += gt[216]; + m_A290 += gt[217]; + m_A290 += gt[218]; + m_A290 += gt[219]; + m_A290 += gt[220]; + m_A290 += gt[221]; + m_A290 += gt[222]; + m_A280 += go[216]; + m_A279 += go[217]; + m_A287 += go[218]; + m_A278 += go[219]; + m_A283 += go[220]; + double RHS56 = Idr[216]; + RHS56 += Idr[217]; + RHS56 += Idr[218]; + RHS56 += Idr[219]; + RHS56 += Idr[220]; + RHS56 += Idr[221]; + RHS56 += Idr[222]; + RHS56 -= go[221] * *cnV[221]; + RHS56 -= go[222] * *cnV[222]; + const double f0 = 1.0 / m_A0; + const double f0_29 = -f0 * m_A84; + m_A86 += m_A1 * f0_29; + RHS29 += f0_29 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_32 = -f1 * m_A103; + m_A104 += m_A3 * f1_32; + RHS32 += f1_32 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_29 = -f2 * m_A85; + m_A86 += m_A5 * f2_29; + m_A87 += m_A6 * f2_29; + m_A88 += m_A7 * f2_29; + RHS29 += f2_29 * RHS2; + const double f2_30 = -f2 * m_A89; + m_A91 += m_A5 * f2_30; + m_A92 += m_A6 * f2_30; + m_A93 += m_A7 * f2_30; + RHS30 += f2_30 * RHS2; + const double f2_37 = -f2 * m_A123; + m_A125 += m_A5 * f2_37; + m_A126 += m_A6 * f2_37; + m_A127 += m_A7 * f2_37; + RHS37 += f2_37 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_34 = -f3 * m_A111; + m_A113 += m_A9 * f3_34; + RHS34 += f3_34 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_43 = -f4 * m_A158; + m_A163 += m_A11 * f4_43; + m_A165 += m_A12 * f4_43; + RHS43 += f4_43 * RHS4; + const double f4_52 = -f4 * m_A230; + m_A233 += m_A11 * f4_52; + m_A237 += m_A12 * f4_52; + RHS52 += f4_52 * RHS4; + const double f5 = 1.0 / m_A13; + const double f5_34 = -f5 * m_A112; + m_A113 += m_A14 * f5_34; + m_A114 += m_A15 * f5_34; + RHS34 += f5_34 * RHS5; + const double f5_53 = -f5 * m_A241; + m_A245 += m_A14 * f5_53; + m_A250 += m_A15 * f5_53; + RHS53 += f5_53 * RHS5; + const double f6 = 1.0 / m_A16; + const double f6_30 = -f6 * m_A90; + m_A92 += m_A17 * f6_30; + m_A94 += m_A18 * f6_30; + m_A95 += m_A19 * f6_30; + m_A96 += m_A20 * f6_30; + RHS30 += f6_30 * RHS6; + const double f6_43 = -f6 * m_A159; + m_A161 += m_A17 * f6_43; + m_A163 += m_A18 * f6_43; + m_A166 += m_A19 * f6_43; + m_A167 += m_A20 * f6_43; + RHS43 += f6_43 * RHS6; + const double f6_53 = -f6 * m_A242; + m_A244 += m_A17 * f6_53; + m_A247 += m_A18 * f6_53; + m_A250 += m_A19 * f6_53; + m_A252 += m_A20 * f6_53; + RHS53 += f6_53 * RHS6; + const double f6_56 = -f6 * m_A278; + m_A281 += m_A17 * f6_56; + m_A283 += m_A18 * f6_56; + m_A287 += m_A19 * f6_56; + m_A290 += m_A20 * f6_56; + RHS56 += f6_56 * RHS6; + const double f7 = 1.0 / m_A21; + const double f7_33 = -f7 * m_A106; + m_A108 += m_A22 * f7_33; + RHS33 += f7_33 * RHS7; + const double f8 = 1.0 / m_A23; + const double f8_35 = -f8 * m_A115; + m_A116 += m_A24 * f8_35; + RHS35 += f8_35 * RHS8; + const double f9 = 1.0 / m_A25; + const double f9_37 = -f9 * m_A124; + m_A127 += m_A26 * f9_37; + m_A128 += m_A27 * f9_37; + m_A130 += m_A28 * f9_37; + m_A131 += m_A29 * f9_37; + RHS37 += f9_37 * RHS9; + const double f9_43 = -f9 * m_A160; + m_A162 += m_A26 * f9_43; + m_A163 += m_A27 * f9_43; + m_A166 += m_A28 * f9_43; + m_A167 += m_A29 * f9_43; + RHS43 += f9_43 * RHS9; + const double f9_53 = -f9 * m_A243; + m_A246 += m_A26 * f9_53; + m_A247 += m_A27 * f9_53; + m_A250 += m_A28 * f9_53; + m_A252 += m_A29 * f9_53; + RHS53 += f9_53 * RHS9; + const double f9_56 = -f9 * m_A279; + m_A282 += m_A26 * f9_56; + m_A283 += m_A27 * f9_56; + m_A287 += m_A28 * f9_56; + m_A290 += m_A29 * f9_56; + RHS56 += f9_56 * RHS9; + const double f10 = 1.0 / m_A30; + const double f10_31 = -f10 * m_A97; + m_A99 += m_A31 * f10_31; + m_A102 += m_A32 * f10_31; + RHS31 += f10_31 * RHS10; + const double f10_48 = -f10 * m_A196; + m_A198 += m_A31 * f10_48; + m_A202 += m_A32 * f10_48; + RHS48 += f10_48 * RHS10; + const double f11 = 1.0 / m_A33; + const double f11_41 = -f11 * m_A145; + m_A147 += m_A34 * f11_41; + RHS41 += f11_41 * RHS11; + const double f12 = 1.0 / m_A35; + const double f12_45 = -f12 * m_A175; + m_A179 += m_A36 * f12_45; + RHS45 += f12_45 * RHS12; + const double f13 = 1.0 / m_A37; + const double f13_31 = -f13 * m_A98; + m_A99 += m_A38 * f13_31; + m_A100 += m_A39 * f13_31; + m_A101 += m_A40 * f13_31; + RHS31 += f13_31 * RHS13; + const double f13_36 = -f13 * m_A118; + m_A119 += m_A38 * f13_36; + m_A120 += m_A39 * f13_36; + m_A121 += m_A40 * f13_36; + RHS36 += f13_36 * RHS13; + const double f13_45 = -f13 * m_A176; + m_A178 += m_A38 * f13_45; + m_A179 += m_A39 * f13_45; + m_A180 += m_A40 * f13_45; + RHS45 += f13_45 * RHS13; + const double f14 = 1.0 / m_A41; + const double f14_45 = -f14 * m_A177; + m_A180 += m_A42 * f14_45; + m_A182 += m_A43 * f14_45; + RHS45 += f14_45 * RHS14; + const double f14_52 = -f14 * m_A231; + m_A234 += m_A42 * f14_52; + m_A237 += m_A43 * f14_52; + RHS52 += f14_52 * RHS14; + const double f15 = 1.0 / m_A44; + const double f15_40 = -f15 * m_A142; + m_A143 += m_A45 * f15_40; + RHS40 += f15_40 * RHS15; + const double f16 = 1.0 / m_A46; + const double f16_33 = -f16 * m_A107; + m_A108 += m_A47 * f16_33; + m_A109 += m_A48 * f16_33; + m_A110 += m_A49 * f16_33; + RHS33 += f16_33 * RHS16; + const double f16_38 = -f16 * m_A132; + m_A134 += m_A47 * f16_38; + m_A135 += m_A48 * f16_38; + m_A137 += m_A49 * f16_38; + RHS38 += f16_38 * RHS16; + const double f16_50 = -f16 * m_A208; + m_A210 += m_A47 * f16_50; + m_A211 += m_A48 * f16_50; + m_A215 += m_A49 * f16_50; + RHS50 += f16_50 * RHS16; + const double f17 = 1.0 / m_A50; + const double f17_48 = -f17 * m_A197; + m_A202 += m_A51 * f17_48; + m_A204 += m_A52 * f17_48; + RHS48 += f17_48 * RHS17; + const double f17_54 = -f17 * m_A253; + m_A259 += m_A51 * f17_54; + m_A264 += m_A52 * f17_54; + RHS54 += f17_54 * RHS17; + const double f18 = 1.0 / m_A53; + const double f18_41 = -f18 * m_A146; + m_A147 += m_A54 * f18_41; + m_A148 += m_A55 * f18_41; + RHS41 += f18_41 * RHS18; + const double f18_51 = -f18 * m_A219; + m_A223 += m_A54 * f18_51; + m_A227 += m_A55 * f18_51; + RHS51 += f18_51 * RHS18; + const double f19 = 1.0 / m_A56; + const double f19_47 = -f19 * m_A187; + m_A192 += m_A57 * f19_47; + RHS47 += f19_47 * RHS19; + const double f20 = 1.0 / m_A58; + const double f20_38 = -f20 * m_A133; + m_A135 += m_A59 * f20_38; + m_A136 += m_A60 * f20_38; + m_A138 += m_A61 * f20_38; + m_A139 += m_A62 * f20_38; + RHS38 += f20_38 * RHS20; + const double f20_42 = -f20 * m_A149; + m_A152 += m_A59 * f20_42; + m_A153 += m_A60 * f20_42; + m_A156 += m_A61 * f20_42; + m_A157 += m_A62 * f20_42; + RHS42 += f20_42 * RHS20; + const double f20_51 = -f20 * m_A220; + m_A222 += m_A59 * f20_51; + m_A224 += m_A60 * f20_51; + m_A227 += m_A61 * f20_51; + m_A228 += m_A62 * f20_51; + RHS51 += f20_51 * RHS20; + const double f20_54 = -f20 * m_A254; + m_A256 += m_A59 * f20_54; + m_A257 += m_A60 * f20_54; + m_A261 += m_A61 * f20_54; + m_A264 += m_A62 * f20_54; + RHS54 += f20_54 * RHS20; + const double f21 = 1.0 / m_A63; + const double f21_42 = -f21 * m_A150; + m_A153 += m_A64 * f21_42; + m_A155 += m_A65 * f21_42; + m_A156 += m_A66 * f21_42; + m_A157 += m_A67 * f21_42; + RHS42 += f21_42 * RHS21; + const double f21_50 = -f21 * m_A209; + m_A213 += m_A64 * f21_50; + m_A215 += m_A65 * f21_50; + m_A216 += m_A66 * f21_50; + m_A217 += m_A67 * f21_50; + RHS50 += f21_50 * RHS21; + const double f21_51 = -f21 * m_A221; + m_A224 += m_A64 * f21_51; + m_A226 += m_A65 * f21_51; + m_A227 += m_A66 * f21_51; + m_A228 += m_A67 * f21_51; + RHS51 += f21_51 * RHS21; + const double f21_54 = -f21 * m_A255; + m_A257 += m_A64 * f21_54; + m_A260 += m_A65 * f21_54; + m_A261 += m_A66 * f21_54; + m_A264 += m_A67 * f21_54; + RHS54 += f21_54 * RHS21; + const double f22 = 1.0 / m_A68; + const double f22_47 = -f22 * m_A188; + m_A192 += m_A69 * f22_47; + RHS47 += f22_47 * RHS22; + const double f23 = 1.0 / m_A70; + const double f23_47 = -f23 * m_A189; + m_A192 += m_A71 * f23_47; + RHS47 += f23_47 * RHS23; + const double f24 = 1.0 / m_A72; + const double f24_42 = -f24 * m_A151; + m_A153 += m_A73 * f24_42; + m_A154 += m_A74 * f24_42; + RHS42 += f24_42 * RHS24; + const double f24_44 = -f24 * m_A168; + m_A169 += m_A73 * f24_44; + m_A170 += m_A74 * f24_44; + RHS44 += f24_44 * RHS24; + const double f25 = 1.0 / m_A75; + const double f25_46 = -f25 * m_A183; + m_A184 += m_A76 * f25_46; + m_A186 += m_A77 * f25_46; + RHS46 += f25_46 * RHS25; + const double f25_56 = -f25 * m_A280; + m_A284 += m_A76 * f25_56; + m_A290 += m_A77 * f25_56; + RHS56 += f25_56 * RHS25; + const double f26 = 1.0 / m_A78; + const double f26_55 = -f26 * m_A267; + m_A276 += m_A79 * f26_55; + RHS55 += f26_55 * RHS26; + const double f27 = 1.0 / m_A80; + const double f27_55 = -f27 * m_A268; + m_A276 += m_A81 * f27_55; + RHS55 += f27_55 * RHS27; + const double f28 = 1.0 / m_A82; + const double f28_49 = -f28 * m_A205; + m_A206 += m_A83 * f28_49; + RHS49 += f28_49 * RHS28; + const double f29 = 1.0 / m_A86; + const double f29_30 = -f29 * m_A91; + m_A92 += m_A87 * f29_30; + m_A93 += m_A88 * f29_30; + RHS30 += f29_30 * RHS29; + const double f29_37 = -f29 * m_A125; + m_A126 += m_A87 * f29_37; + m_A127 += m_A88 * f29_37; + RHS37 += f29_37 * RHS29; + const double f30 = 1.0 / m_A92; + const double f30_37 = -f30 * m_A126; + m_A127 += m_A93 * f30_37; + m_A128 += m_A94 * f30_37; + m_A130 += m_A95 * f30_37; + m_A131 += m_A96 * f30_37; + RHS37 += f30_37 * RHS30; + const double f30_43 = -f30 * m_A161; + m_A162 += m_A93 * f30_43; + m_A163 += m_A94 * f30_43; + m_A166 += m_A95 * f30_43; + m_A167 += m_A96 * f30_43; + RHS43 += f30_43 * RHS30; + const double f30_53 = -f30 * m_A244; + m_A246 += m_A93 * f30_53; + m_A247 += m_A94 * f30_53; + m_A250 += m_A95 * f30_53; + m_A252 += m_A96 * f30_53; + RHS53 += f30_53 * RHS30; + const double f30_56 = -f30 * m_A281; + m_A282 += m_A93 * f30_56; + m_A283 += m_A94 * f30_56; + m_A287 += m_A95 * f30_56; + m_A290 += m_A96 * f30_56; + RHS56 += f30_56 * RHS30; + const double f31 = 1.0 / m_A99; + const double f31_36 = -f31 * m_A119; + m_A120 += m_A100 * f31_36; + m_A121 += m_A101 * f31_36; + m_A122 += m_A102 * f31_36; + RHS36 += f31_36 * RHS31; + const double f31_45 = -f31 * m_A178; + m_A179 += m_A100 * f31_45; + m_A180 += m_A101 * f31_45; + m_A181 += m_A102 * f31_45; + RHS45 += f31_45 * RHS31; + const double f31_48 = -f31 * m_A198; + m_A200 += m_A100 * f31_48; + m_A201 += m_A101 * f31_48; + m_A202 += m_A102 * f31_48; + RHS48 += f31_48 * RHS31; + const double f32 = 1.0 / m_A104; + const double f32_52 = -f32 * m_A232; + m_A237 += m_A105 * f32_52; + RHS52 += f32_52 * RHS32; + const double f33 = 1.0 / m_A108; + const double f33_38 = -f33 * m_A134; + m_A135 += m_A109 * f33_38; + m_A137 += m_A110 * f33_38; + RHS38 += f33_38 * RHS33; + const double f33_50 = -f33 * m_A210; + m_A211 += m_A109 * f33_50; + m_A215 += m_A110 * f33_50; + RHS50 += f33_50 * RHS33; + const double f34 = 1.0 / m_A113; + const double f34_53 = -f34 * m_A245; + m_A250 += m_A114 * f34_53; + RHS53 += f34_53 * RHS34; + const double f35 = 1.0 / m_A116; + const double f35_48 = -f35 * m_A199; + m_A202 += m_A117 * f35_48; + RHS48 += f35_48 * RHS35; + const double f36 = 1.0 / m_A120; + const double f36_45 = -f36 * m_A179; + m_A180 += m_A121 * f36_45; + m_A181 += m_A122 * f36_45; + RHS45 += f36_45 * RHS36; + const double f36_48 = -f36 * m_A200; + m_A201 += m_A121 * f36_48; + m_A202 += m_A122 * f36_48; + RHS48 += f36_48 * RHS36; + const double f37 = 1.0 / m_A127; + const double f37_43 = -f37 * m_A162; + m_A163 += m_A128 * f37_43; + m_A164 += m_A129 * f37_43; + m_A166 += m_A130 * f37_43; + m_A167 += m_A131 * f37_43; + RHS43 += f37_43 * RHS37; + const double f37_47 = -f37 * m_A190; + m_A191 += m_A128 * f37_47; + m_A192 += m_A129 * f37_47; + m_A194 += m_A130 * f37_47; + m_A195 += m_A131 * f37_47; + RHS47 += f37_47 * RHS37; + const double f37_53 = -f37 * m_A246; + m_A247 += m_A128 * f37_53; + m_A248 += m_A129 * f37_53; + m_A250 += m_A130 * f37_53; + m_A252 += m_A131 * f37_53; + RHS53 += f37_53 * RHS37; + const double f37_56 = -f37 * m_A282; + m_A283 += m_A128 * f37_56; + m_A285 += m_A129 * f37_56; + m_A287 += m_A130 * f37_56; + m_A290 += m_A131 * f37_56; + RHS56 += f37_56 * RHS37; + const double f38 = 1.0 / m_A135; + const double f38_42 = -f38 * m_A152; + m_A153 += m_A136 * f38_42; + m_A155 += m_A137 * f38_42; + m_A156 += m_A138 * f38_42; + m_A157 += m_A139 * f38_42; + RHS42 += f38_42 * RHS38; + const double f38_50 = -f38 * m_A211; + m_A213 += m_A136 * f38_50; + m_A215 += m_A137 * f38_50; + m_A216 += m_A138 * f38_50; + m_A217 += m_A139 * f38_50; + RHS50 += f38_50 * RHS38; + const double f38_51 = -f38 * m_A222; + m_A224 += m_A136 * f38_51; + m_A226 += m_A137 * f38_51; + m_A227 += m_A138 * f38_51; + m_A228 += m_A139 * f38_51; + RHS51 += f38_51 * RHS38; + const double f38_54 = -f38 * m_A256; + m_A257 += m_A136 * f38_54; + m_A260 += m_A137 * f38_54; + m_A261 += m_A138 * f38_54; + m_A264 += m_A139 * f38_54; + RHS54 += f38_54 * RHS38; + const double f39 = 1.0 / m_A140; + const double f39_55 = -f39 * m_A269; + m_A276 += m_A141 * f39_55; + RHS55 += f39_55 * RHS39; + const double f40 = 1.0 / m_A143; + const double f40_50 = -f40 * m_A212; + m_A215 += m_A144 * f40_50; + RHS50 += f40_50 * RHS40; + const double f41 = 1.0 / m_A147; + const double f41_51 = -f41 * m_A223; + m_A227 += m_A148 * f41_51; + RHS51 += f41_51 * RHS41; + const double f42 = 1.0 / m_A153; + const double f42_44 = -f42 * m_A169; + m_A170 += m_A154 * f42_44; + m_A171 += m_A155 * f42_44; + m_A172 += m_A156 * f42_44; + m_A173 += m_A157 * f42_44; + RHS44 += f42_44 * RHS42; + const double f42_50 = -f42 * m_A213; + m_A214 += m_A154 * f42_50; + m_A215 += m_A155 * f42_50; + m_A216 += m_A156 * f42_50; + m_A217 += m_A157 * f42_50; + RHS50 += f42_50 * RHS42; + const double f42_51 = -f42 * m_A224; + m_A225 += m_A154 * f42_51; + m_A226 += m_A155 * f42_51; + m_A227 += m_A156 * f42_51; + m_A228 += m_A157 * f42_51; + RHS51 += f42_51 * RHS42; + const double f42_54 = -f42 * m_A257; + m_A258 += m_A154 * f42_54; + m_A260 += m_A155 * f42_54; + m_A261 += m_A156 * f42_54; + m_A264 += m_A157 * f42_54; + RHS54 += f42_54 * RHS42; + const double f43 = 1.0 / m_A163; + const double f43_47 = -f43 * m_A191; + m_A192 += m_A164 * f43_47; + m_A193 += m_A165 * f43_47; + m_A194 += m_A166 * f43_47; + m_A195 += m_A167 * f43_47; + RHS47 += f43_47 * RHS43; + const double f43_52 = -f43 * m_A233; + m_A235 += m_A164 * f43_52; + m_A237 += m_A165 * f43_52; + m_A238 += m_A166 * f43_52; + m_A240 += m_A167 * f43_52; + RHS52 += f43_52 * RHS43; + const double f43_53 = -f43 * m_A247; + m_A248 += m_A164 * f43_53; + m_A249 += m_A165 * f43_53; + m_A250 += m_A166 * f43_53; + m_A252 += m_A167 * f43_53; + RHS53 += f43_53 * RHS43; + const double f43_56 = -f43 * m_A283; + m_A285 += m_A164 * f43_56; + m_A286 += m_A165 * f43_56; + m_A287 += m_A166 * f43_56; + m_A290 += m_A167 * f43_56; + RHS56 += f43_56 * RHS43; + const double f44 = 1.0 / m_A170; + const double f44_50 = -f44 * m_A214; + m_A215 += m_A171 * f44_50; + m_A216 += m_A172 * f44_50; + m_A217 += m_A173 * f44_50; + m_A218 += m_A174 * f44_50; + RHS50 += f44_50 * RHS44; + const double f44_51 = -f44 * m_A225; + m_A226 += m_A171 * f44_51; + m_A227 += m_A172 * f44_51; + m_A228 += m_A173 * f44_51; + m_A229 += m_A174 * f44_51; + RHS51 += f44_51 * RHS44; + const double f44_54 = -f44 * m_A258; + m_A260 += m_A171 * f44_54; + m_A261 += m_A172 * f44_54; + m_A264 += m_A173 * f44_54; + m_A265 += m_A174 * f44_54; + RHS54 += f44_54 * RHS44; + const double f44_55 = -f44 * m_A270; + m_A273 += m_A171 * f44_55; + m_A274 += m_A172 * f44_55; + m_A275 += m_A173 * f44_55; + m_A276 += m_A174 * f44_55; + RHS55 += f44_55 * RHS44; + const double f45 = 1.0 / m_A180; + const double f45_48 = -f45 * m_A201; + m_A202 += m_A181 * f45_48; + m_A203 += m_A182 * f45_48; + RHS48 += f45_48 * RHS45; + const double f45_52 = -f45 * m_A234; + m_A236 += m_A181 * f45_52; + m_A237 += m_A182 * f45_52; + RHS52 += f45_52 * RHS45; + const double f46 = 1.0 / m_A184; + const double f46_55 = -f46 * m_A271; + m_A276 += m_A185 * f46_55; + m_A277 += m_A186 * f46_55; + RHS55 += f46_55 * RHS46; + const double f46_56 = -f46 * m_A284; + m_A289 += m_A185 * f46_56; + m_A290 += m_A186 * f46_56; + RHS56 += f46_56 * RHS46; + const double f47 = 1.0 / m_A192; + const double f47_52 = -f47 * m_A235; + m_A237 += m_A193 * f47_52; + m_A238 += m_A194 * f47_52; + m_A240 += m_A195 * f47_52; + RHS52 += f47_52 * RHS47; + const double f47_53 = -f47 * m_A248; + m_A249 += m_A193 * f47_53; + m_A250 += m_A194 * f47_53; + m_A252 += m_A195 * f47_53; + RHS53 += f47_53 * RHS47; + const double f47_56 = -f47 * m_A285; + m_A286 += m_A193 * f47_56; + m_A287 += m_A194 * f47_56; + m_A290 += m_A195 * f47_56; + RHS56 += f47_56 * RHS47; + const double f48 = 1.0 / m_A202; + const double f48_52 = -f48 * m_A236; + m_A237 += m_A203 * f48_52; + m_A239 += m_A204 * f48_52; + RHS52 += f48_52 * RHS48; + const double f48_54 = -f48 * m_A259; + m_A262 += m_A203 * f48_54; + m_A264 += m_A204 * f48_54; + RHS54 += f48_54 * RHS48; + const double f49 = 1.0 / m_A206; + const double f49_55 = -f49 * m_A272; + m_A276 += m_A207 * f49_55; + RHS55 += f49_55 * RHS49; + const double f50 = 1.0 / m_A215; + const double f50_51 = -f50 * m_A226; + m_A227 += m_A216 * f50_51; + m_A228 += m_A217 * f50_51; + m_A229 += m_A218 * f50_51; + RHS51 += f50_51 * RHS50; + const double f50_54 = -f50 * m_A260; + m_A261 += m_A216 * f50_54; + m_A264 += m_A217 * f50_54; + m_A265 += m_A218 * f50_54; + RHS54 += f50_54 * RHS50; + const double f50_55 = -f50 * m_A273; + m_A274 += m_A216 * f50_55; + m_A275 += m_A217 * f50_55; + m_A276 += m_A218 * f50_55; + RHS55 += f50_55 * RHS50; + const double f51 = 1.0 / m_A227; + const double f51_54 = -f51 * m_A261; + m_A264 += m_A228 * f51_54; + m_A265 += m_A229 * f51_54; + RHS54 += f51_54 * RHS51; + const double f51_55 = -f51 * m_A274; + m_A275 += m_A228 * f51_55; + m_A276 += m_A229 * f51_55; + RHS55 += f51_55 * RHS51; + const double f52 = 1.0 / m_A237; + const double f52_53 = -f52 * m_A249; + m_A250 += m_A238 * f52_53; + m_A251 += m_A239 * f52_53; + m_A252 += m_A240 * f52_53; + RHS53 += f52_53 * RHS52; + const double f52_54 = -f52 * m_A262; + m_A263 += m_A238 * f52_54; + m_A264 += m_A239 * f52_54; + m_A266 += m_A240 * f52_54; + RHS54 += f52_54 * RHS52; + const double f52_56 = -f52 * m_A286; + m_A287 += m_A238 * f52_56; + m_A288 += m_A239 * f52_56; + m_A290 += m_A240 * f52_56; + RHS56 += f52_56 * RHS52; + const double f53 = 1.0 / m_A250; + const double f53_54 = -f53 * m_A263; + m_A264 += m_A251 * f53_54; + m_A266 += m_A252 * f53_54; + RHS54 += f53_54 * RHS53; + const double f53_56 = -f53 * m_A287; + m_A288 += m_A251 * f53_56; + m_A290 += m_A252 * f53_56; + RHS56 += f53_56 * RHS53; + const double f54 = 1.0 / m_A264; + const double f54_55 = -f54 * m_A275; + m_A276 += m_A265 * f54_55; + m_A277 += m_A266 * f54_55; + RHS55 += f54_55 * RHS54; + const double f54_56 = -f54 * m_A288; + m_A289 += m_A265 * f54_56; + m_A290 += m_A266 * f54_56; + RHS56 += f54_56 * RHS54; + const double f55 = 1.0 / m_A276; + const double f55_56 = -f55 * m_A289; + m_A290 += m_A277 * f55_56; + RHS56 += f55_56 * RHS55; + V[56] = RHS56 / m_A290; + double tmp55 = 0.0; + tmp55 += m_A277 * V[56]; + V[55] = (RHS55 - tmp55) / m_A276; + double tmp54 = 0.0; + tmp54 += m_A265 * V[55]; + tmp54 += m_A266 * V[56]; + V[54] = (RHS54 - tmp54) / m_A264; + double tmp53 = 0.0; + tmp53 += m_A251 * V[54]; + tmp53 += m_A252 * V[56]; + V[53] = (RHS53 - tmp53) / m_A250; + double tmp52 = 0.0; + tmp52 += m_A238 * V[53]; + tmp52 += m_A239 * V[54]; + tmp52 += m_A240 * V[56]; + V[52] = (RHS52 - tmp52) / m_A237; + double tmp51 = 0.0; + tmp51 += m_A228 * V[54]; + tmp51 += m_A229 * V[55]; + V[51] = (RHS51 - tmp51) / m_A227; + double tmp50 = 0.0; + tmp50 += m_A216 * V[51]; + tmp50 += m_A217 * V[54]; + tmp50 += m_A218 * V[55]; + V[50] = (RHS50 - tmp50) / m_A215; + double tmp49 = 0.0; + tmp49 += m_A207 * V[55]; + V[49] = (RHS49 - tmp49) / m_A206; + double tmp48 = 0.0; + tmp48 += m_A203 * V[52]; + tmp48 += m_A204 * V[54]; + V[48] = (RHS48 - tmp48) / m_A202; + double tmp47 = 0.0; + tmp47 += m_A193 * V[52]; + tmp47 += m_A194 * V[53]; + tmp47 += m_A195 * V[56]; + V[47] = (RHS47 - tmp47) / m_A192; + double tmp46 = 0.0; + tmp46 += m_A185 * V[55]; + tmp46 += m_A186 * V[56]; + V[46] = (RHS46 - tmp46) / m_A184; + double tmp45 = 0.0; + tmp45 += m_A181 * V[48]; + tmp45 += m_A182 * V[52]; + V[45] = (RHS45 - tmp45) / m_A180; + double tmp44 = 0.0; + tmp44 += m_A171 * V[50]; + tmp44 += m_A172 * V[51]; + tmp44 += m_A173 * V[54]; + tmp44 += m_A174 * V[55]; + V[44] = (RHS44 - tmp44) / m_A170; + double tmp43 = 0.0; + tmp43 += m_A164 * V[47]; + tmp43 += m_A165 * V[52]; + tmp43 += m_A166 * V[53]; + tmp43 += m_A167 * V[56]; + V[43] = (RHS43 - tmp43) / m_A163; + double tmp42 = 0.0; + tmp42 += m_A154 * V[44]; + tmp42 += m_A155 * V[50]; + tmp42 += m_A156 * V[51]; + tmp42 += m_A157 * V[54]; + V[42] = (RHS42 - tmp42) / m_A153; + double tmp41 = 0.0; + tmp41 += m_A148 * V[51]; + V[41] = (RHS41 - tmp41) / m_A147; + double tmp40 = 0.0; + tmp40 += m_A144 * V[50]; + V[40] = (RHS40 - tmp40) / m_A143; + double tmp39 = 0.0; + tmp39 += m_A141 * V[55]; + V[39] = (RHS39 - tmp39) / m_A140; + double tmp38 = 0.0; + tmp38 += m_A136 * V[42]; + tmp38 += m_A137 * V[50]; + tmp38 += m_A138 * V[51]; + tmp38 += m_A139 * V[54]; + V[38] = (RHS38 - tmp38) / m_A135; + double tmp37 = 0.0; + tmp37 += m_A128 * V[43]; + tmp37 += m_A129 * V[47]; + tmp37 += m_A130 * V[53]; + tmp37 += m_A131 * V[56]; + V[37] = (RHS37 - tmp37) / m_A127; + double tmp36 = 0.0; + tmp36 += m_A121 * V[45]; + tmp36 += m_A122 * V[48]; + V[36] = (RHS36 - tmp36) / m_A120; + double tmp35 = 0.0; + tmp35 += m_A117 * V[48]; + V[35] = (RHS35 - tmp35) / m_A116; + double tmp34 = 0.0; + tmp34 += m_A114 * V[53]; + V[34] = (RHS34 - tmp34) / m_A113; + double tmp33 = 0.0; + tmp33 += m_A109 * V[38]; + tmp33 += m_A110 * V[50]; + V[33] = (RHS33 - tmp33) / m_A108; + double tmp32 = 0.0; + tmp32 += m_A105 * V[52]; + V[32] = (RHS32 - tmp32) / m_A104; + double tmp31 = 0.0; + tmp31 += m_A100 * V[36]; + tmp31 += m_A101 * V[45]; + tmp31 += m_A102 * V[48]; + V[31] = (RHS31 - tmp31) / m_A99; + double tmp30 = 0.0; + tmp30 += m_A93 * V[37]; + tmp30 += m_A94 * V[43]; + tmp30 += m_A95 * V[53]; + tmp30 += m_A96 * V[56]; + V[30] = (RHS30 - tmp30) / m_A92; + double tmp29 = 0.0; + tmp29 += m_A87 * V[30]; + tmp29 += m_A88 * V[37]; + V[29] = (RHS29 - tmp29) / m_A86; + double tmp28 = 0.0; + tmp28 += m_A83 * V[49]; + V[28] = (RHS28 - tmp28) / m_A82; + double tmp27 = 0.0; + tmp27 += m_A81 * V[55]; + V[27] = (RHS27 - tmp27) / m_A80; + double tmp26 = 0.0; + tmp26 += m_A79 * V[55]; + V[26] = (RHS26 - tmp26) / m_A78; + double tmp25 = 0.0; + tmp25 += m_A76 * V[46]; + tmp25 += m_A77 * V[56]; + V[25] = (RHS25 - tmp25) / m_A75; + double tmp24 = 0.0; + tmp24 += m_A73 * V[42]; + tmp24 += m_A74 * V[44]; + V[24] = (RHS24 - tmp24) / m_A72; + double tmp23 = 0.0; + tmp23 += m_A71 * V[47]; + V[23] = (RHS23 - tmp23) / m_A70; + double tmp22 = 0.0; + tmp22 += m_A69 * V[47]; + V[22] = (RHS22 - tmp22) / m_A68; + double tmp21 = 0.0; + tmp21 += m_A64 * V[42]; + tmp21 += m_A65 * V[50]; + tmp21 += m_A66 * V[51]; + tmp21 += m_A67 * V[54]; + V[21] = (RHS21 - tmp21) / m_A63; + double tmp20 = 0.0; + tmp20 += m_A59 * V[38]; + tmp20 += m_A60 * V[42]; + tmp20 += m_A61 * V[51]; + tmp20 += m_A62 * V[54]; + V[20] = (RHS20 - tmp20) / m_A58; + double tmp19 = 0.0; + tmp19 += m_A57 * V[47]; + V[19] = (RHS19 - tmp19) / m_A56; + double tmp18 = 0.0; + tmp18 += m_A54 * V[41]; + tmp18 += m_A55 * V[51]; + V[18] = (RHS18 - tmp18) / m_A53; + double tmp17 = 0.0; + tmp17 += m_A51 * V[48]; + tmp17 += m_A52 * V[54]; + V[17] = (RHS17 - tmp17) / m_A50; + double tmp16 = 0.0; + tmp16 += m_A47 * V[33]; + tmp16 += m_A48 * V[38]; + tmp16 += m_A49 * V[50]; + V[16] = (RHS16 - tmp16) / m_A46; + double tmp15 = 0.0; + tmp15 += m_A45 * V[40]; + V[15] = (RHS15 - tmp15) / m_A44; + double tmp14 = 0.0; + tmp14 += m_A42 * V[45]; + tmp14 += m_A43 * V[52]; + V[14] = (RHS14 - tmp14) / m_A41; + double tmp13 = 0.0; + tmp13 += m_A38 * V[31]; + tmp13 += m_A39 * V[36]; + tmp13 += m_A40 * V[45]; + V[13] = (RHS13 - tmp13) / m_A37; + double tmp12 = 0.0; + tmp12 += m_A36 * V[36]; + V[12] = (RHS12 - tmp12) / m_A35; + double tmp11 = 0.0; + tmp11 += m_A34 * V[41]; + V[11] = (RHS11 - tmp11) / m_A33; + double tmp10 = 0.0; + tmp10 += m_A31 * V[31]; + tmp10 += m_A32 * V[48]; + V[10] = (RHS10 - tmp10) / m_A30; + double tmp9 = 0.0; + tmp9 += m_A26 * V[37]; + tmp9 += m_A27 * V[43]; + tmp9 += m_A28 * V[53]; + tmp9 += m_A29 * V[56]; + V[9] = (RHS9 - tmp9) / m_A25; + double tmp8 = 0.0; + tmp8 += m_A24 * V[35]; + V[8] = (RHS8 - tmp8) / m_A23; + double tmp7 = 0.0; + tmp7 += m_A22 * V[33]; + V[7] = (RHS7 - tmp7) / m_A21; + double tmp6 = 0.0; + tmp6 += m_A17 * V[30]; + tmp6 += m_A18 * V[43]; + tmp6 += m_A19 * V[53]; + tmp6 += m_A20 * V[56]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[34]; + tmp5 += m_A15 * V[53]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[43]; + tmp4 += m_A12 * V[52]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A9 * V[34]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A5 * V[29]; + tmp2 += m_A6 * V[30]; + tmp2 += m_A7 * V[37]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[32]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[29]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_9a5874c8e2da79d2_37_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -33760,6 +35561,63 @@ static void nl_gcr_c6f25bb06e161d1c_50_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// flyball +static void nl_gcr_c74b1a65978d7121_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A6 += gt[4]; + m_A6 += gt[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A5 += go[4]; + m_A4 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[6] * *cnV[6]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // stuntcyc static void nl_gcr_c924fe5960b1479e_20_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -41933,6 +43791,63 @@ static void nl_gcr_e0b492db40bba291_20_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// flyball +static void nl_gcr_e15d9316d59cdad9_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A1 += go[0]; + m_A0 += go[1]; + m_A0 += go[2]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A3 += go[5]; + double RHS1 = Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A5 += go[7]; + m_A4 += go[8]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // speedfrk static void nl_gcr_e4f2ffbf201a3d0c_37_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -48241,6 +50156,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_8d7bddf33d942482_129_double_double", reinterpret_cast(&nl_gcr_8d7bddf33d942482_129_double_double)}, // gamemachine {"nl_gcr_934712b55bb3b2b2_10_double_double", reinterpret_cast(&nl_gcr_934712b55bb3b2b2_10_double_double)}, +// flyball + {"nl_gcr_93d3ff6e33ffafdb_291_double_double", reinterpret_cast(&nl_gcr_93d3ff6e33ffafdb_291_double_double)}, // kidniki {"nl_gcr_9a5874c8e2da79d2_37_double_double", reinterpret_cast(&nl_gcr_9a5874c8e2da79d2_37_double_double)}, // fireone @@ -48315,6 +50232,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_c4cec7aed23b7b94_23_double_double", reinterpret_cast(&nl_gcr_c4cec7aed23b7b94_23_double_double)}, // popeye {"nl_gcr_c6f25bb06e161d1c_50_double_double", reinterpret_cast(&nl_gcr_c6f25bb06e161d1c_50_double_double)}, +// flyball + {"nl_gcr_c74b1a65978d7121_7_double_double", reinterpret_cast(&nl_gcr_c74b1a65978d7121_7_double_double)}, // stuntcyc {"nl_gcr_c924fe5960b1479e_20_double_double", reinterpret_cast(&nl_gcr_c924fe5960b1479e_20_double_double)}, // dpatrol @@ -48355,6 +50274,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_e081f90c2e0313f6_45_double_double", reinterpret_cast(&nl_gcr_e081f90c2e0313f6_45_double_double)}, // spacewar {"nl_gcr_e0b492db40bba291_20_double_double", reinterpret_cast(&nl_gcr_e0b492db40bba291_20_double_double)}, +// flyball + {"nl_gcr_e15d9316d59cdad9_7_double_double", reinterpret_cast(&nl_gcr_e15d9316d59cdad9_7_double_double)}, // speedfrk {"nl_gcr_e4f2ffbf201a3d0c_37_double_double", reinterpret_cast(&nl_gcr_e4f2ffbf201a3d0c_37_double_double)}, // pongf diff --git a/src/mame/audio/nl_flyball.cpp b/src/mame/audio/nl_flyball.cpp new file mode 100644 index 00000000000..174675c7fd5 --- /dev/null +++ b/src/mame/audio/nl_flyball.cpp @@ -0,0 +1,190 @@ +// license:CC0 +// copyright-holders:Ryan Holtz, Ivan Vangelista +// +// Netlist for Atari's Flyball +// +// Derived from the schematics in the manual. +// +// Known problems/issues: +// * None. +// + +#include "netlist/devices/net_lib.h" + +static NETLIST_START(NE556_DIP) + NE555(A) + NE555(B) + + NET_C(A.GND, B.GND) + NET_C(A.VCC, B.VCC) + + DIPPINS( /* +--------------+ */ + A.DISCH, /* 1DISCH |1 ++ 14| VCC */ A.VCC, + A.THRESH, /* 1THRES |2 13| 2DISCH */ B.DISCH, + A.CONT, /* 1CONT |3 12| 2THRES */ B.THRESH, + A.RESET, /* 1RESET |4 NE556 11| 2CONT */ B.CONT, + A.OUT, /* 1OUT |5 10| 2RESET */ B.RESET, + A.TRIG, /* 1TRIG |6 9| 2OUT */ B.OUT, + A.GND, /* GND |7 8| 2TRIG */ B.TRIG + /* +--------------+ */ + ) +NETLIST_END() + +NETLIST_START(flyball) + + SOLVER(Solver, 48000) + ANALOG_INPUT(V5, 5) + ANALOG_INPUT(V18, 18) + ALIAS(VCC, V5) + CLOCK(H256, 15750.0) + CLOCK(V128, 61.5234375) + NET_C(VCC, H256.VCC, V128.VCC) + NET_C(GND, H256.GND, V128.GND) + + LOCAL_SOURCE(NE556_DIP) + + TTL_INPUT(BAT_SOUND, 1) + TTL_INPUT(FOOTSTEP, 1) + TTL_INPUT(CROWD_SL, 1) + TTL_INPUT(CROWD_ON, 1) + TTL_INPUT(CROWD_VL, 1) + NET_C(VCC, BAT_SOUND.VCC, FOOTSTEP.VCC, CROWD_SL.VCC, CROWD_ON.VCC, CROWD_VL.VCC) + NET_C(GND, BAT_SOUND.GND, FOOTSTEP.GND, CROWD_SL.GND, CROWD_ON.GND, CROWD_VL.GND) + + RES(R43, RES_K(68)) // RES., CARBON, 5%, 1/4W, 68K + RES(R73, RES_K(1)) // RES., CARBON, 5%, 1/4W, 1K + RES(R74, RES_K(1)) // RES., CARBON, 5%, 1/4W, 1K + POT(R75, RES_K(50)) // TRIMPOT, 50K + RES(R76, RES_K(100)) // RES., CARBON, 5%, 1/4W, 100K + RES(R77, 820) // RES., CARBON, 5%, 1/4W, 820 + RES(R78, RES_K(100)) // RES., CARBON, 5%, 1/4W, 100K + RES(R79, RES_K(820)) // RES., CARBON, 5%, 1/4W, 820K + RES(R80, RES_K(330)) // RES., CARBON, 5%, 1/4W, 330 // (330 on parts list, but 330K on schematic, 330 does not work in the netlist) + RES(R87, RES_K(1)) // RES., CARBON, 5%, 1/4W, 1K + RES(R88, RES_K(3.3)) // RES., CARBON, 5%, 1/4W, 3.3K + RES(R89, RES_K(10)) // RES., CARBON, 5%, 1/4W, 10K + RES(R90, RES_K(10)) // RES., CARBON, 5%, 1/4W, 10K + RES(R91, RES_K(10)) // RES., CARBON, 5%, 1/4W, 10K + RES(R92, RES_K(10)) // RES., CARBON, 5%, 1/4W, 10K + POT(R95, RES_K(10)) // TRIMPOT, 10K + RES(R96, RES_K(47)) // RES., CARBON, 5%, 1/4W, 47K + RES(R97, RES_K(10)) // RES., CARBON, 5%, 1/4W, 10K + RES(R98, RES_K(10)) // RES., CARBON, 5%, 1/4W, 10K + RES(R99, RES_K(33)) // RES., CARBON, 5%, 1/4W, 33K + + CAP(C34, CAP_U(0.0047)) // CAP., MYLAR, .0047uf + CAP(C44, CAP_U(0.0047)) // CAP., MYLAR, .0047uf + CAP(C45, CAP_U(0.1)) // CAP., CERAMIC DISC., 0.1 uf, 25V + CAP(C46, CAP_U(0.015)) // CAP., CERAMIC DISC., 0.015 uf, 25V + CAP(C47, CAP_U(0.015)) // CAP., CERAMIC DISC., 0.015 uf, 25V + CAP(C48, CAP_U(10)) // CAP., ELECTROLYTIC, 10 uf, 25V + CAP(C49, CAP_U(100)) // CAP., ELECTROLYTIC, 100 uf, 25V + CAP(C51, CAP_U(0.1)) // CAP., CERAMIC DISC., 0.1 uf, 25V + CAP(C52, CAP_U(0.1)) // CAP., CERAMIC DISC., 0.1 uf, 25V + CAP(C53, CAP_U(0.1)) // CAP., CERAMIC DISC., 0.1 uf, 25V + CAP(C79, CAP_U(0.1)) // CAP., CERAMIC DISC., 0.1 uf, 25V + CAP(C80, CAP_U(0.1)) // CAP., CERAMIC DISC., 0.1 uf, 25V + + TTL_7486_DIP(IC_E7) + TTL_74164_DIP(IC_B7) + TTL_74164_DIP(IC_C7) + TTL_7474_DIP(IC_D7) + NET_C(VCC, IC_E7.14, IC_B7.14, IC_C7.14, IC_D7.14, IC_E7.13, IC_B7.9, IC_B7.2, IC_C7.9, IC_C7.2) + NET_C(GND, IC_E7.7, IC_B7.7, IC_C7.7, IC_D7.7, IC_D7.2, IC_E7.4, IC_E7.5) + + SUBMODEL(NE556_DIP, IC_E8) + NET_C(VCC, IC_E8.14) + NET_C(GND, IC_E8.7) + + MC3340_DIP(IC_A8) + MC3340_DIP(IC_C8) + NET_C(V18, IC_A8.8, IC_C8.8) + NET_C(GND, IC_A8.3, IC_C8.3) + + UA741_DIP8(IC_D8) + NET_C(V18, IC_D8.7) + NET_C(GND, IC_D8.4) + + // Random Noise Generator + NET_C(H256.Q, IC_B7.8, IC_C7.8, IC_D7.11, IC_D7.4) + NET_C(VCC, IC_D7.13, IC_D7.1) + NET_C(IC_B7.13, IC_C7.1) + NET_C(IC_C7.13, IC_D7.12) + NET_C(IC_D7.9, IC_E7.9) + NET_C(IC_B7.5, IC_E7.10) + NET_C(IC_E7.8, IC_E7.12) + NET_C(IC_E7.11, IC_B7.1) + NET_C(IC_D7.5, IC_D7.10) + NET_C(V128, IC_D7.3) + + // Band Pass Filter + NET_C(IC_D7.8, R78.1) + NET_C(R78.2, R77.1, C46.1, C47.1) + NET_C(GND, R77.2) + NET_C(C46.2, R80.1, IC_D8.6) + NET_C(C47.2, R80.2, IC_D8.2) + NET_C(V5, IC_D8.3) + + // Bat Sound + NET_C(BAT_SOUND.Q, IC_E8.4, IC_E8.10, IC_E7.1) + NET_C(V5, IC_E7.2, R73.1, R74.1) + NET_C(R74.2, R75.3, R75.2, IC_E8.1) + NET_C(R75.1, R43.1) + NET_C(R43.2, IC_E8.2, IC_E8.6, C34.1) + NET_C(R73.2, IC_E8.13, R76.1) + NET_C(R76.2, IC_E8.12, IC_E8.8, C44.1) + NET_C(IC_E8.3, IC_E8.11, C45.1) + NET_C(GND, C34.2, C44.2, C45.2) + NET_C(IC_E8.5, R91.1) + NET_C(IC_E8.9, R90.1) + NET_C(IC_E7.3, R89.1) + + // Footstep Envelope Generator + NET_C(FOOTSTEP.Q, R88.1) + NET_C(IC_D7.8, R79.1) + NET_C(R79.2, C79.1) + NET_C(C79.2, IC_C8.1) + NET_C(R88.2, C48.1, IC_C8.2) + NET_C(GND, C48.2) + NET_C(IC_C8.7, R92.1) + + // Crowd & Whistle Volume Control + NET_C(IC_D8.6, R87.1) + NET_C(R87.2, C80.1) + NET_C(C80.2, IC_A8.1) + NET_C(CROWD_VL.Q, R97.2) + NET_C(CROWD_ON.Q, R98.2) + NET_C(CROWD_SL.Q, R99.2) + NET_C(R97.1, R98.1, R99.1, C49.1, IC_A8.2) + NET_C(GND, C49.2) + NET_C(IC_A8.7, R96.1) + + // Mixer + NET_C(R89.2, R90.2, R91.2, R92.2, R96.2, C51.1, R95.3) + NET_C(GND, C51.2, R95.1) + NET_C(R95.2, C53.1) + NET_C(C53.2, C52.1) + NET_C(C52.2, GND) + ALIAS(OUTPUT, C53.2) + + // Unconnected pins + HINT(IC_A8.6, NC) + HINT(IC_C8.6, NC) + HINT(IC_B7.2, NC) + HINT(IC_B7.9, NC) + HINT(IC_B7.3, NC) + HINT(IC_B7.4, NC) + HINT(IC_B7.6, NC) + HINT(IC_B7.10, NC) + HINT(IC_B7.11, NC) + HINT(IC_B7.12, NC) + HINT(IC_C7.3, NC) + HINT(IC_C7.4, NC) + HINT(IC_C7.5, NC) + HINT(IC_C7.6, NC) + HINT(IC_C7.10, NC) + HINT(IC_C7.11, NC) + HINT(IC_C7.12, NC) + HINT(IC_D7.6, NC) + HINT(IC_E7.6, NC) +NETLIST_END() diff --git a/src/mame/audio/nl_flyball.h b/src/mame/audio/nl_flyball.h new file mode 100644 index 00000000000..554290cd617 --- /dev/null +++ b/src/mame/audio/nl_flyball.h @@ -0,0 +1,10 @@ +// license:CC0 +// copyright-holders:Ivan Vangelista, Ryan Holtz +#ifndef MAME_AUDIO_NL_FLYBALL_H +#define MAME_AUDIO_NL_FLYBALL_H + +#pragma once + +NETLIST_EXTERNAL(flyball) + +#endif // MAME_AUDIO_NL_FLYBALL_H diff --git a/src/mame/drivers/flyball.cpp b/src/mame/drivers/flyball.cpp index efbd2583137..0aaa7b23539 100644 --- a/src/mame/drivers/flyball.cpp +++ b/src/mame/drivers/flyball.cpp @@ -1,5 +1,5 @@ // license:BSD-3-Clause -// copyright-holders:Stefan Jokisch +// copyright-holders:Stefan Jokisch, Ivan Vangelista, Ryan Holtz /*************************************************************************** Atari Flyball Driver @@ -11,9 +11,7 @@ Etched in copper on top of board: MADE IN USA PAT NO 3793483 - TODO: -- discrete sound - accurate video timing ***************************************************************************/ @@ -23,7 +21,12 @@ TODO: #include "machine/74259.h" #include "emupal.h" #include "screen.h" +#include "speaker.h" #include "tilemap.h" +#include "machine/netlist.h" + +#include "netlist/nl_setup.h" +#include "audio/nl_flyball.h" static constexpr XTAL MASTER_CLOCK = 12.096_MHz_XTAL; static constexpr XTAL PIXEL_CLOCK = MASTER_CLOCK / 2; @@ -39,6 +42,11 @@ public: m_screen(*this, "screen"), m_palette(*this, "palette"), m_outlatch(*this, "outlatch"), + m_bat_sound(*this, "sound_nl:bat_sound"), + m_footstep(*this, "sound_nl:footstep"), + m_crowd_sl(*this, "sound_nl:crowd_sl"), + m_crowd_on(*this, "sound_nl:crowd_on"), + m_crowd_vl(*this, "sound_nl:crowd_vl"), m_playfield_ram(*this, "playfield_ram"), m_lamp(*this, "lamp0") { } @@ -87,6 +95,11 @@ private: required_device m_screen; required_device m_palette; required_device m_outlatch; + required_device m_bat_sound; + required_device m_footstep; + required_device m_crowd_sl; + required_device m_crowd_on; + required_device m_crowd_vl; /* memory pointers */ required_shared_ptr m_playfield_ram; @@ -317,7 +330,7 @@ void flyball_state::flyball_map(address_map &map) map(0x0900, 0x0900).w(FUNC(flyball_state::potmask_w)); map(0x0a00, 0x0a07).w(FUNC(flyball_state::misc_w)); map(0x0b00, 0x0b00).r(FUNC(flyball_state::input_r)); - map(0x0d00, 0x0eff).writeonly().share("playfield_ram"); + map(0x0d00, 0x0eff).writeonly().share("playfield_ram").nopr(); map(0x1000, 0x1fff).rom().region("maincpu", 0); } @@ -358,6 +371,12 @@ static INPUT_PORTS_START( flyball ) PORT_START("IN1") /* IN5 */ PORT_BIT( 0x01, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_BIT( 0xFE, IP_ACTIVE_LOW, IPT_UNUSED ) + + PORT_START("BAT_VOL") + PORT_ADJUSTER( 50, "Bat Volume" ) NETLIST_ANALOG_PORT_CHANGED("sound_nl", "bat_volume") + + PORT_START("MAIN_VOL") + PORT_ADJUSTER( 50, "Main Volume" ) NETLIST_ANALOG_PORT_CHANGED("sound_nl", "main_volume") INPUT_PORTS_END @@ -467,11 +486,11 @@ void flyball_state::flyball(machine_config &config) m_maincpu->set_addrmap(AS_PROGRAM, &flyball_state::flyball_map); F9334(config, m_outlatch); // F7 - m_outlatch->q_out_cb<2>().set_nop(); // bat hit - m_outlatch->q_out_cb<3>().set_nop(); // crowd soft-loud - m_outlatch->q_out_cb<4>().set_nop(); // crowd off-on - m_outlatch->q_out_cb<5>().set_nop(); // footstep off-on - m_outlatch->q_out_cb<6>().set_nop(); // crowd very loud + m_outlatch->q_out_cb<2>().set(m_bat_sound, FUNC(netlist_mame_logic_input_device::write)); + m_outlatch->q_out_cb<3>().set(m_crowd_sl, FUNC(netlist_mame_logic_input_device::write)); + m_outlatch->q_out_cb<4>().set(m_crowd_on, FUNC(netlist_mame_logic_input_device::write)); + m_outlatch->q_out_cb<5>().set(m_footstep, FUNC(netlist_mame_logic_input_device::write)); + m_outlatch->q_out_cb<6>().set(m_crowd_vl, FUNC(netlist_mame_logic_input_device::write)); m_outlatch->q_out_cb<7>().set(FUNC(flyball_state::lamp_w)); // 1 player lamp /* video hardware */ @@ -487,6 +506,21 @@ void flyball_state::flyball(machine_config &config) PALETTE(config, m_palette, FUNC(flyball_state::flyball_palette), 4); /* sound hardware */ + SPEAKER(config, "mono").front_center(); + + NETLIST_SOUND(config, "sound_nl", 48000) + .set_source(NETLIST_NAME(flyball)) + .add_route(ALL_OUTPUTS, "mono", 1.0); + + NETLIST_LOGIC_INPUT(config, "sound_nl:bat_sound", "BAT_SOUND.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:footstep", "FOOTSTEP.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:crowd_sl", "CROWD_SL.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:crowd_on", "CROWD_ON.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:crowd_vl", "CROWD_VL.IN", 0); + NETLIST_ANALOG_INPUT(config, "sound_nl:bat_volume", "R75.DIAL"); + NETLIST_ANALOG_INPUT(config, "sound_nl:main_volume", "R95.DIAL"); + + NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(32767.0 / 0.13, -(32767.0 / 0.13) * 0.78); } @@ -547,5 +581,5 @@ ROM_END * *************************************/ -GAME( 1976, flyball, 0, flyball, flyball, flyball_state, empty_init, 0, "Atari", "Flyball (rev 2)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) -GAME( 1976, flyball1, flyball, flyball, flyball, flyball_state, empty_init, 0, "Atari", "Flyball (rev 1)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) +GAME( 1976, flyball, 0, flyball, flyball, flyball_state, empty_init, 0, "Atari", "Flyball (rev 2)", MACHINE_SUPPORTS_SAVE ) +GAME( 1976, flyball1, flyball, flyball, flyball, flyball_state, empty_init, 0, "Atari", "Flyball (rev 1)", MACHINE_SUPPORTS_SAVE ) diff --git a/src/mame/nl.lst b/src/mame/nl.lst index cda1adb440d..f9445c31c80 100644 --- a/src/mame/nl.lst +++ b/src/mame/nl.lst @@ -58,6 +58,9 @@ starfir2 // (c) 1979 Exidy starfire // Exidy [1979?] starfirea // Exidy [1979?] +@source:flyball.cpp +flyball + @source:galaxian.cpp 600 // GX353 (c) 1981 Konami amidar // GX337 (c) 1982 Konami