diff --git a/scripts/target/mame/arcade.lua b/scripts/target/mame/arcade.lua index 40670049a41..abe23d59dd0 100644 --- a/scripts/target/mame/arcade.lua +++ b/scripts/target/mame/arcade.lua @@ -3610,6 +3610,8 @@ files { MAME_DIR .. "src/mame/audio/vicdual.h", MAME_DIR .. "src/mame/audio/nl_brdrline.cpp", MAME_DIR .. "src/mame/audio/nl_brdrline.h", + MAME_DIR .. "src/mame/audio/nl_frogs.cpp", + MAME_DIR .. "src/mame/audio/nl_frogs.h", MAME_DIR .. "src/mame/audio/vicdual-97271p.cpp", MAME_DIR .. "src/mame/audio/vicdual-97271p.h", MAME_DIR .. "src/mame/video/vicdual.cpp", diff --git a/scripts/target/mame/nl.lua b/scripts/target/mame/nl.lua index b16f1bbd001..f5c8e88d1e5 100644 --- a/scripts/target/mame/nl.lua +++ b/scripts/target/mame/nl.lua @@ -294,6 +294,8 @@ files{ MAME_DIR .. "src/mame/audio/vicdual.h", MAME_DIR .. "src/mame/audio/nl_brdrline.cpp", MAME_DIR .. "src/mame/audio/nl_brdrline.h", + MAME_DIR .. "src/mame/audio/nl_frogs.cpp", + MAME_DIR .. "src/mame/audio/nl_frogs.h", MAME_DIR .. "src/mame/audio/vicdual-97271p.cpp", MAME_DIR .. "src/mame/audio/vicdual-97271p.h", MAME_DIR .. "src/mame/video/vicdual.cpp", diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp index b4f60d74895..f2d2a09e494 100644 --- a/src/lib/netlist/generated/static_solvers.cpp +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -32621,6 +32621,89 @@ static void nl_gcr_80b4b1e5cc58d303_29_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// frogs +static void nl_gcr_815733e3f2e05029_9_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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A2 += go[0]; + m_A1 += go[1]; + m_A1 += 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_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A5 += go[5]; + m_A5 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + m_A8 += gt[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A7 += go[11]; + m_A7 += go[12]; + m_A6 += go[13]; + double RHS2 = Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 -= go[14] * *cnV[14]; + const double f0 = 1.0 / m_A0; + const double f0_1 = -f0 * m_A3; + m_A4 += m_A1 * f0_1; + m_A5 += m_A2 * f0_1; + RHS1 += f0_1 * RHS0; + const double f0_2 = -f0 * m_A6; + m_A7 += m_A1 * f0_2; + m_A8 += m_A2 * f0_2; + RHS2 += f0_2 * RHS0; + const double f1 = 1.0 / m_A4; + const double f1_2 = -f1 * m_A7; + m_A8 += m_A5 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A8; + double tmp1 = 0.0; + tmp1 += m_A5 * V[2]; + V[1] = (RHS1 - tmp1) / m_A4; + double tmp0 = 0.0; + tmp0 += m_A1 * V[1]; + tmp0 += m_A2 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // elim static void nl_gcr_81f40a54af2ca202_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -32706,6 +32789,2783 @@ static void nl_gcr_81f40a54af2ca202_10_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// frogs +static void nl_gcr_8213b1839349be25_422_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); + double m_A291(0.0); + double m_A292(0.0); + double m_A293(0.0); + double m_A294(0.0); + double m_A295(0.0); + double m_A296(0.0); + double m_A297(0.0); + double m_A298(0.0); + double m_A299(0.0); + double m_A300(0.0); + double m_A301(0.0); + double m_A302(0.0); + double m_A303(0.0); + double m_A304(0.0); + double m_A305(0.0); + double m_A306(0.0); + double m_A307(0.0); + double m_A308(0.0); + double m_A309(0.0); + double m_A310(0.0); + double m_A311(0.0); + double m_A312(0.0); + double m_A313(0.0); + double m_A314(0.0); + double m_A315(0.0); + double m_A316(0.0); + double m_A317(0.0); + double m_A318(0.0); + double m_A319(0.0); + double m_A320(0.0); + double m_A321(0.0); + double m_A322(0.0); + double m_A323(0.0); + double m_A324(0.0); + double m_A325(0.0); + double m_A326(0.0); + double m_A327(0.0); + double m_A328(0.0); + double m_A329(0.0); + double m_A330(0.0); + double m_A331(0.0); + double m_A332(0.0); + double m_A333(0.0); + double m_A334(0.0); + double m_A335(0.0); + double m_A336(0.0); + double m_A337(0.0); + double m_A338(0.0); + double m_A339(0.0); + double m_A340(0.0); + double m_A341(0.0); + double m_A342(0.0); + double m_A343(0.0); + double m_A344(0.0); + double m_A345(0.0); + double m_A346(0.0); + double m_A347(0.0); + double m_A348(0.0); + double m_A349(0.0); + double m_A350(0.0); + double m_A351(0.0); + double m_A352(0.0); + double m_A353(0.0); + double m_A354(0.0); + double m_A355(0.0); + double m_A356(0.0); + double m_A357(0.0); + double m_A358(0.0); + double m_A359(0.0); + double m_A360(0.0); + double m_A361(0.0); + double m_A362(0.0); + double m_A363(0.0); + double m_A364(0.0); + double m_A365(0.0); + double m_A366(0.0); + double m_A367(0.0); + double m_A368(0.0); + double m_A369(0.0); + double m_A370(0.0); + double m_A371(0.0); + double m_A372(0.0); + double m_A373(0.0); + double m_A374(0.0); + double m_A375(0.0); + double m_A376(0.0); + double m_A377(0.0); + double m_A378(0.0); + double m_A379(0.0); + double m_A380(0.0); + double m_A381(0.0); + double m_A382(0.0); + double m_A383(0.0); + double m_A384(0.0); + double m_A385(0.0); + double m_A386(0.0); + double m_A387(0.0); + double m_A388(0.0); + double m_A389(0.0); + double m_A390(0.0); + double m_A391(0.0); + double m_A392(0.0); + double m_A393(0.0); + double m_A394(0.0); + double m_A395(0.0); + double m_A396(0.0); + double m_A397(0.0); + double m_A398(0.0); + double m_A399(0.0); + double m_A400(0.0); + double m_A401(0.0); + double m_A402(0.0); + double m_A403(0.0); + double m_A404(0.0); + double m_A405(0.0); + double m_A406(0.0); + double m_A407(0.0); + double m_A408(0.0); + double m_A409(0.0); + double m_A410(0.0); + double m_A411(0.0); + double m_A412(0.0); + double m_A413(0.0); + double m_A414(0.0); + double m_A415(0.0); + double m_A416(0.0); + double m_A417(0.0); + double m_A418(0.0); + double m_A419(0.0); + double m_A420(0.0); + double m_A421(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A2 += go[0]; + m_A1 += go[1]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A3 += gt[4]; + m_A3 += gt[5]; + m_A4 += go[4]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[5] * *cnV[5]; + m_A5 += gt[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A6 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + RHS2 -= go[10] * *cnV[10]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + m_A7 += gt[13]; + m_A7 += gt[14]; + m_A7 += gt[15]; + m_A7 += gt[16]; + m_A10 += go[13]; + m_A9 += go[14]; + m_A8 += go[15]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 -= go[16] * *cnV[16]; + m_A11 += gt[17]; + m_A11 += gt[18]; + m_A11 += gt[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A14 += go[17]; + m_A14 += go[18]; + m_A13 += go[19]; + m_A13 += go[20]; + m_A12 += go[21]; + double RHS4 = Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 -= go[22] * *cnV[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A15 += gt[25]; + m_A15 += gt[26]; + m_A15 += gt[27]; + m_A15 += gt[28]; + m_A18 += go[23]; + m_A18 += go[24]; + m_A17 += go[25]; + m_A17 += go[26]; + m_A16 += go[27]; + double RHS5 = Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 -= go[28] * *cnV[28]; + m_A19 += gt[29]; + m_A19 += gt[30]; + m_A20 += go[29]; + m_A21 += go[30]; + double RHS6 = Idr[29]; + RHS6 += Idr[30]; + m_A22 += gt[31]; + m_A22 += gt[32]; + m_A22 += gt[33]; + m_A22 += gt[34]; + m_A22 += gt[35]; + m_A22 += gt[36]; + m_A22 += gt[37]; + m_A23 += go[31]; + m_A24 += go[32]; + double RHS7 = Idr[31]; + RHS7 += Idr[32]; + RHS7 += Idr[33]; + RHS7 += Idr[34]; + RHS7 += Idr[35]; + RHS7 += Idr[36]; + RHS7 += Idr[37]; + RHS7 -= go[33] * *cnV[33]; + RHS7 -= go[34] * *cnV[34]; + RHS7 -= go[35] * *cnV[35]; + RHS7 -= go[36] * *cnV[36]; + RHS7 -= go[37] * *cnV[37]; + m_A25 += gt[38]; + m_A25 += gt[39]; + m_A25 += gt[40]; + m_A25 += gt[41]; + m_A25 += gt[42]; + m_A25 += gt[43]; + m_A26 += go[38]; + m_A26 += go[39]; + m_A27 += go[40]; + m_A28 += go[41]; + double RHS8 = Idr[38]; + RHS8 += Idr[39]; + RHS8 += Idr[40]; + RHS8 += Idr[41]; + RHS8 += Idr[42]; + RHS8 += Idr[43]; + RHS8 -= go[42] * *cnV[42]; + RHS8 -= go[43] * *cnV[43]; + m_A29 += gt[44]; + m_A29 += gt[45]; + m_A29 += gt[46]; + m_A29 += gt[47]; + m_A30 += go[44]; + double RHS9 = Idr[44]; + RHS9 += Idr[45]; + RHS9 += Idr[46]; + RHS9 += Idr[47]; + RHS9 -= go[45] * *cnV[45]; + RHS9 -= go[46] * *cnV[46]; + RHS9 -= go[47] * *cnV[47]; + m_A31 += gt[48]; + m_A31 += gt[49]; + m_A31 += gt[50]; + m_A31 += gt[51]; + m_A31 += gt[52]; + m_A31 += gt[53]; + m_A31 += gt[54]; + m_A32 += go[48]; + double RHS10 = Idr[48]; + RHS10 += Idr[49]; + RHS10 += Idr[50]; + RHS10 += Idr[51]; + RHS10 += Idr[52]; + RHS10 += Idr[53]; + RHS10 += Idr[54]; + RHS10 -= go[49] * *cnV[49]; + RHS10 -= go[50] * *cnV[50]; + RHS10 -= go[51] * *cnV[51]; + RHS10 -= go[52] * *cnV[52]; + RHS10 -= go[53] * *cnV[53]; + RHS10 -= go[54] * *cnV[54]; + m_A33 += gt[55]; + m_A33 += gt[56]; + m_A33 += gt[57]; + m_A33 += gt[58]; + m_A33 += gt[59]; + m_A33 += gt[60]; + m_A33 += gt[61]; + m_A36 += go[55]; + m_A36 += go[56]; + m_A35 += go[57]; + m_A35 += go[58]; + m_A34 += go[59]; + m_A34 += go[60]; + double RHS11 = Idr[55]; + RHS11 += Idr[56]; + RHS11 += Idr[57]; + RHS11 += Idr[58]; + RHS11 += Idr[59]; + RHS11 += Idr[60]; + RHS11 += Idr[61]; + RHS11 -= go[61] * *cnV[61]; + m_A37 += gt[62]; + m_A37 += gt[63]; + m_A37 += gt[64]; + m_A38 += go[62]; + m_A39 += go[63]; + double RHS12 = Idr[62]; + RHS12 += Idr[63]; + RHS12 += Idr[64]; + RHS12 -= go[64] * *cnV[64]; + m_A40 += gt[65]; + m_A40 += gt[66]; + m_A40 += gt[67]; + m_A40 += gt[68]; + m_A43 += go[65]; + m_A41 += go[66]; + m_A42 += go[67]; + double RHS13 = Idr[65]; + RHS13 += Idr[66]; + RHS13 += Idr[67]; + RHS13 += Idr[68]; + RHS13 -= go[68] * *cnV[68]; + m_A44 += gt[69]; + m_A44 += gt[70]; + m_A45 += go[69]; + double RHS14 = Idr[69]; + RHS14 += Idr[70]; + RHS14 -= go[70] * *cnV[70]; + m_A46 += gt[71]; + m_A46 += gt[72]; + m_A47 += go[71]; + double RHS15 = Idr[71]; + RHS15 += Idr[72]; + RHS15 -= go[72] * *cnV[72]; + m_A48 += gt[73]; + m_A48 += gt[74]; + m_A48 += gt[75]; + m_A50 += go[73]; + m_A49 += go[74]; + double RHS16 = Idr[73]; + RHS16 += Idr[74]; + RHS16 += Idr[75]; + RHS16 -= go[75] * *cnV[75]; + m_A51 += gt[76]; + m_A51 += gt[77]; + m_A51 += gt[78]; + m_A51 += gt[79]; + m_A51 += gt[80]; + m_A51 += gt[81]; + m_A51 += gt[82]; + m_A52 += go[76]; + double RHS17 = Idr[76]; + RHS17 += Idr[77]; + RHS17 += Idr[78]; + RHS17 += Idr[79]; + RHS17 += Idr[80]; + RHS17 += Idr[81]; + RHS17 += Idr[82]; + RHS17 -= go[77] * *cnV[77]; + RHS17 -= go[78] * *cnV[78]; + RHS17 -= go[79] * *cnV[79]; + RHS17 -= go[80] * *cnV[80]; + RHS17 -= go[81] * *cnV[81]; + RHS17 -= go[82] * *cnV[82]; + m_A53 += gt[83]; + m_A53 += gt[84]; + m_A53 += gt[85]; + m_A53 += gt[86]; + m_A54 += go[83]; + m_A55 += go[84]; + m_A55 += go[85]; + double RHS18 = Idr[83]; + RHS18 += Idr[84]; + RHS18 += Idr[85]; + RHS18 += Idr[86]; + RHS18 -= go[86] * *cnV[86]; + m_A56 += gt[87]; + m_A56 += gt[88]; + m_A57 += go[87]; + double RHS19 = Idr[87]; + RHS19 += Idr[88]; + RHS19 -= go[88] * *cnV[88]; + m_A58 += gt[89]; + m_A58 += gt[90]; + m_A58 += gt[91]; + m_A58 += gt[92]; + m_A60 += go[89]; + m_A59 += go[90]; + double RHS20 = Idr[89]; + RHS20 += Idr[90]; + RHS20 += Idr[91]; + RHS20 += Idr[92]; + RHS20 -= go[91] * *cnV[91]; + RHS20 -= go[92] * *cnV[92]; + m_A61 += gt[93]; + m_A61 += gt[94]; + m_A62 += go[93]; + double RHS21 = Idr[93]; + RHS21 += Idr[94]; + RHS21 -= go[94] * *cnV[94]; + m_A63 += gt[95]; + m_A63 += gt[96]; + m_A64 += go[95]; + double RHS22 = Idr[95]; + RHS22 += Idr[96]; + RHS22 -= go[96] * *cnV[96]; + m_A65 += gt[97]; + m_A65 += gt[98]; + m_A65 += gt[99]; + m_A65 += gt[100]; + m_A67 += go[97]; + m_A66 += go[98]; + m_A66 += go[99]; + double RHS23 = Idr[97]; + RHS23 += Idr[98]; + RHS23 += Idr[99]; + RHS23 += Idr[100]; + RHS23 -= go[100] * *cnV[100]; + m_A68 += gt[101]; + m_A68 += gt[102]; + m_A69 += go[101]; + double RHS24 = Idr[101]; + RHS24 += Idr[102]; + RHS24 -= go[102] * *cnV[102]; + m_A70 += gt[103]; + m_A70 += gt[104]; + m_A70 += gt[105]; + m_A70 += gt[106]; + m_A71 += go[103]; + m_A71 += go[104]; + double RHS25 = Idr[103]; + RHS25 += Idr[104]; + RHS25 += Idr[105]; + RHS25 += Idr[106]; + RHS25 -= go[105] * *cnV[105]; + RHS25 -= go[106] * *cnV[106]; + m_A72 += gt[107]; + m_A72 += gt[108]; + m_A72 += gt[109]; + m_A72 += gt[110]; + m_A73 += go[107]; + m_A74 += go[108]; + m_A74 += go[109]; + double RHS26 = Idr[107]; + RHS26 += Idr[108]; + RHS26 += Idr[109]; + RHS26 += Idr[110]; + RHS26 -= go[110] * *cnV[110]; + m_A75 += gt[111]; + m_A75 += gt[112]; + m_A76 += go[111]; + double RHS27 = Idr[111]; + RHS27 += Idr[112]; + RHS27 -= go[112] * *cnV[112]; + m_A77 += gt[113]; + m_A77 += gt[114]; + m_A77 += gt[115]; + m_A78 += go[113]; + m_A79 += go[114]; + double RHS28 = Idr[113]; + RHS28 += Idr[114]; + RHS28 += Idr[115]; + RHS28 -= go[115] * *cnV[115]; + m_A80 += gt[116]; + m_A80 += gt[117]; + m_A80 += gt[118]; + m_A82 += go[116]; + m_A81 += go[117]; + double RHS29 = Idr[116]; + RHS29 += Idr[117]; + RHS29 += Idr[118]; + RHS29 -= go[118] * *cnV[118]; + m_A83 += gt[119]; + m_A83 += gt[120]; + m_A83 += gt[121]; + m_A85 += go[119]; + m_A84 += go[120]; + double RHS30 = Idr[119]; + RHS30 += Idr[120]; + RHS30 += Idr[121]; + RHS30 -= go[121] * *cnV[121]; + m_A86 += gt[122]; + m_A86 += gt[123]; + m_A86 += gt[124]; + m_A88 += go[122]; + m_A87 += go[123]; + double RHS31 = Idr[122]; + RHS31 += Idr[123]; + RHS31 += Idr[124]; + RHS31 -= go[124] * *cnV[124]; + m_A89 += gt[125]; + m_A89 += gt[126]; + m_A89 += gt[127]; + m_A89 += gt[128]; + m_A89 += gt[129]; + m_A89 += gt[130]; + m_A89 += gt[131]; + m_A90 += go[125]; + double RHS32 = Idr[125]; + RHS32 += Idr[126]; + RHS32 += Idr[127]; + RHS32 += Idr[128]; + RHS32 += Idr[129]; + RHS32 += Idr[130]; + RHS32 += Idr[131]; + RHS32 -= go[126] * *cnV[126]; + RHS32 -= go[127] * *cnV[127]; + RHS32 -= go[128] * *cnV[128]; + RHS32 -= go[129] * *cnV[129]; + RHS32 -= go[130] * *cnV[130]; + RHS32 -= go[131] * *cnV[131]; + m_A91 += gt[132]; + m_A91 += gt[133]; + m_A92 += go[132]; + m_A93 += go[133]; + double RHS33 = Idr[132]; + RHS33 += Idr[133]; + m_A94 += gt[134]; + m_A94 += gt[135]; + m_A95 += go[134]; + m_A96 += go[135]; + double RHS34 = Idr[134]; + RHS34 += Idr[135]; + m_A97 += gt[136]; + m_A97 += gt[137]; + m_A97 += gt[138]; + m_A97 += gt[139]; + m_A97 += gt[140]; + m_A99 += go[136]; + m_A98 += go[137]; + double RHS35 = Idr[136]; + RHS35 += Idr[137]; + RHS35 += Idr[138]; + RHS35 += Idr[139]; + RHS35 += Idr[140]; + RHS35 -= go[138] * *cnV[138]; + RHS35 -= go[139] * *cnV[139]; + RHS35 -= go[140] * *cnV[140]; + m_A100 += gt[141]; + m_A100 += gt[142]; + m_A100 += gt[143]; + m_A101 += go[141]; + m_A102 += go[142]; + double RHS36 = Idr[141]; + RHS36 += Idr[142]; + RHS36 += Idr[143]; + RHS36 -= go[143] * *cnV[143]; + m_A103 += gt[144]; + m_A103 += gt[145]; + m_A103 += gt[146]; + m_A104 += go[144]; + m_A105 += go[145]; + double RHS37 = Idr[144]; + RHS37 += Idr[145]; + RHS37 += Idr[146]; + RHS37 -= go[146] * *cnV[146]; + m_A106 += gt[147]; + m_A106 += gt[148]; + m_A106 += gt[149]; + m_A107 += go[147]; + m_A108 += go[148]; + double RHS38 = Idr[147]; + RHS38 += Idr[148]; + RHS38 += Idr[149]; + RHS38 -= go[149] * *cnV[149]; + m_A109 += gt[150]; + m_A109 += gt[151]; + m_A109 += gt[152]; + m_A109 += gt[153]; + m_A109 += gt[154]; + m_A109 += gt[155]; + m_A109 += gt[156]; + m_A110 += go[150]; + double RHS39 = Idr[150]; + RHS39 += Idr[151]; + RHS39 += Idr[152]; + RHS39 += Idr[153]; + RHS39 += Idr[154]; + RHS39 += Idr[155]; + RHS39 += Idr[156]; + RHS39 -= go[151] * *cnV[151]; + RHS39 -= go[152] * *cnV[152]; + RHS39 -= go[153] * *cnV[153]; + RHS39 -= go[154] * *cnV[154]; + RHS39 -= go[155] * *cnV[155]; + RHS39 -= go[156] * *cnV[156]; + m_A111 += gt[157]; + m_A111 += gt[158]; + m_A111 += gt[159]; + m_A111 += gt[160]; + m_A111 += gt[161]; + m_A114 += go[157]; + m_A113 += go[158]; + m_A112 += go[159]; + double RHS40 = Idr[157]; + RHS40 += Idr[158]; + RHS40 += Idr[159]; + RHS40 += Idr[160]; + RHS40 += Idr[161]; + RHS40 -= go[160] * *cnV[160]; + RHS40 -= go[161] * *cnV[161]; + m_A115 += gt[162]; + m_A115 += gt[163]; + m_A117 += go[162]; + m_A116 += go[163]; + double RHS41 = Idr[162]; + RHS41 += Idr[163]; + m_A118 += gt[164]; + m_A118 += gt[165]; + m_A120 += go[164]; + m_A119 += go[165]; + double RHS42 = Idr[164]; + RHS42 += Idr[165]; + m_A121 += gt[166]; + m_A121 += gt[167]; + m_A123 += go[166]; + m_A122 += go[167]; + double RHS43 = Idr[166]; + RHS43 += Idr[167]; + m_A124 += gt[168]; + m_A124 += gt[169]; + m_A124 += gt[170]; + m_A126 += go[168]; + m_A125 += go[169]; + double RHS44 = Idr[168]; + RHS44 += Idr[169]; + RHS44 += Idr[170]; + RHS44 -= go[170] * *cnV[170]; + m_A127 += gt[171]; + m_A127 += gt[172]; + m_A129 += go[171]; + m_A128 += go[172]; + double RHS45 = Idr[171]; + RHS45 += Idr[172]; + m_A132 += gt[173]; + m_A132 += gt[174]; + m_A132 += gt[175]; + m_A131 += go[173]; + m_A130 += go[174]; + double RHS46 = Idr[173]; + RHS46 += Idr[174]; + RHS46 += Idr[175]; + RHS46 -= go[175] * *cnV[175]; + m_A138 += gt[176]; + m_A138 += gt[177]; + m_A138 += gt[178]; + m_A140 += go[176]; + m_A136 += go[177]; + double RHS47 = Idr[176]; + RHS47 += Idr[177]; + RHS47 += Idr[178]; + RHS47 -= go[178] * *cnV[178]; + m_A146 += gt[179]; + m_A146 += gt[180]; + m_A146 += gt[181]; + m_A146 += gt[182]; + m_A146 += gt[183]; + m_A143 += go[179]; + m_A142 += go[180]; + m_A141 += go[181]; + double RHS48 = Idr[179]; + RHS48 += Idr[180]; + RHS48 += Idr[181]; + RHS48 += Idr[182]; + RHS48 += Idr[183]; + RHS48 -= go[182] * *cnV[182]; + RHS48 -= go[183] * *cnV[183]; + m_A150 += gt[184]; + m_A150 += gt[185]; + m_A152 += go[184]; + m_A151 += go[185]; + double RHS49 = Idr[184]; + RHS49 += Idr[185]; + m_A155 += gt[186]; + m_A155 += gt[187]; + m_A155 += gt[188]; + m_A155 += gt[189]; + m_A157 += go[186]; + m_A153 += go[187]; + m_A153 += go[188]; + double RHS50 = Idr[186]; + RHS50 += Idr[187]; + RHS50 += Idr[188]; + RHS50 += Idr[189]; + RHS50 -= go[189] * *cnV[189]; + m_A159 += gt[190]; + m_A159 += gt[191]; + m_A158 += go[190]; + double RHS51 = Idr[190]; + RHS51 += Idr[191]; + RHS51 -= go[191] * *cnV[191]; + m_A163 += gt[192]; + m_A163 += gt[193]; + m_A163 += gt[194]; + m_A163 += gt[195]; + m_A163 += gt[196]; + m_A162 += go[192]; + m_A162 += go[193]; + m_A161 += go[194]; + double RHS52 = Idr[192]; + RHS52 += Idr[193]; + RHS52 += Idr[194]; + RHS52 += Idr[195]; + RHS52 += Idr[196]; + RHS52 -= go[195] * *cnV[195]; + RHS52 -= go[196] * *cnV[196]; + m_A169 += gt[197]; + m_A169 += gt[198]; + m_A169 += gt[199]; + m_A169 += gt[200]; + m_A169 += gt[201]; + m_A169 += gt[202]; + m_A166 += go[197]; + m_A167 += go[198]; + m_A167 += go[199]; + m_A171 += go[200]; + m_A171 += 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_A174 += gt[203]; + m_A174 += gt[204]; + m_A174 += gt[205]; + m_A174 += gt[206]; + m_A174 += gt[207]; + m_A174 += gt[208]; + m_A175 += go[203]; + m_A172 += go[204]; + m_A176 += go[205]; + double RHS54 = Idr[203]; + RHS54 += Idr[204]; + RHS54 += Idr[205]; + RHS54 += Idr[206]; + RHS54 += Idr[207]; + RHS54 += Idr[208]; + RHS54 -= go[206] * *cnV[206]; + RHS54 -= go[207] * *cnV[207]; + RHS54 -= go[208] * *cnV[208]; + m_A179 += gt[209]; + m_A179 += gt[210]; + m_A179 += gt[211]; + m_A179 += gt[212]; + m_A179 += gt[213]; + m_A179 += gt[214]; + m_A178 += go[209]; + m_A178 += go[210]; + m_A177 += go[211]; + double RHS55 = Idr[209]; + RHS55 += Idr[210]; + RHS55 += Idr[211]; + RHS55 += Idr[212]; + RHS55 += Idr[213]; + RHS55 += Idr[214]; + RHS55 -= go[212] * *cnV[212]; + RHS55 -= go[213] * *cnV[213]; + RHS55 -= go[214] * *cnV[214]; + m_A183 += gt[215]; + m_A183 += gt[216]; + m_A183 += gt[217]; + m_A183 += gt[218]; + m_A184 += go[215]; + m_A181 += go[216]; + m_A181 += go[217]; + double RHS56 = Idr[215]; + RHS56 += Idr[216]; + RHS56 += Idr[217]; + RHS56 += Idr[218]; + RHS56 -= go[218] * *cnV[218]; + m_A187 += gt[219]; + m_A187 += gt[220]; + m_A187 += gt[221]; + m_A187 += gt[222]; + m_A185 += go[219]; + m_A186 += go[220]; + double RHS57 = Idr[219]; + RHS57 += Idr[220]; + RHS57 += Idr[221]; + RHS57 += Idr[222]; + RHS57 -= go[221] * *cnV[221]; + RHS57 -= go[222] * *cnV[222]; + m_A192 += gt[223]; + m_A192 += gt[224]; + m_A192 += gt[225]; + m_A192 += gt[226]; + m_A192 += gt[227]; + m_A189 += go[223]; + m_A189 += go[224]; + m_A190 += go[225]; + double RHS58 = Idr[223]; + RHS58 += Idr[224]; + RHS58 += Idr[225]; + RHS58 += Idr[226]; + RHS58 += Idr[227]; + RHS58 -= go[226] * *cnV[226]; + RHS58 -= go[227] * *cnV[227]; + m_A195 += gt[228]; + m_A195 += gt[229]; + m_A195 += gt[230]; + m_A195 += gt[231]; + m_A197 += go[228]; + m_A194 += go[229]; + double RHS59 = Idr[228]; + RHS59 += Idr[229]; + RHS59 += Idr[230]; + RHS59 += Idr[231]; + RHS59 -= go[230] * *cnV[230]; + RHS59 -= go[231] * *cnV[231]; + m_A200 += gt[232]; + m_A200 += gt[233]; + m_A200 += gt[234]; + m_A202 += go[232]; + m_A198 += go[233]; + double RHS60 = Idr[232]; + RHS60 += Idr[233]; + RHS60 += Idr[234]; + RHS60 -= go[234] * *cnV[234]; + m_A205 += gt[235]; + m_A205 += gt[236]; + m_A203 += go[235]; + m_A204 += go[236]; + double RHS61 = Idr[235]; + RHS61 += Idr[236]; + m_A208 += gt[237]; + m_A208 += gt[238]; + m_A208 += gt[239]; + m_A209 += go[237]; + m_A207 += go[238]; + double RHS62 = Idr[237]; + RHS62 += Idr[238]; + RHS62 += Idr[239]; + RHS62 -= go[239] * *cnV[239]; + m_A212 += gt[240]; + m_A212 += gt[241]; + m_A212 += gt[242]; + m_A212 += gt[243]; + m_A212 += gt[244]; + m_A212 += gt[245]; + m_A212 += gt[246]; + m_A214 += go[240]; + m_A211 += go[241]; + double RHS63 = Idr[240]; + RHS63 += Idr[241]; + RHS63 += Idr[242]; + RHS63 += Idr[243]; + RHS63 += Idr[244]; + RHS63 += Idr[245]; + RHS63 += Idr[246]; + RHS63 -= go[242] * *cnV[242]; + RHS63 -= go[243] * *cnV[243]; + RHS63 -= go[244] * *cnV[244]; + RHS63 -= go[245] * *cnV[245]; + RHS63 -= go[246] * *cnV[246]; + m_A218 += gt[247]; + m_A218 += gt[248]; + m_A218 += gt[249]; + m_A218 += gt[250]; + m_A216 += go[247]; + m_A219 += go[248]; + m_A215 += go[249]; + double RHS64 = Idr[247]; + RHS64 += Idr[248]; + RHS64 += Idr[249]; + RHS64 += Idr[250]; + RHS64 -= go[250] * *cnV[250]; + m_A221 += gt[251]; + m_A221 += gt[252]; + m_A221 += gt[253]; + m_A221 += gt[254]; + m_A220 += go[251]; + m_A220 += go[252]; + m_A222 += go[253]; + double RHS65 = Idr[251]; + RHS65 += Idr[252]; + RHS65 += Idr[253]; + RHS65 += Idr[254]; + RHS65 -= go[254] * *cnV[254]; + m_A224 += gt[255]; + m_A224 += gt[256]; + m_A224 += gt[257]; + m_A226 += go[255]; + m_A223 += go[256]; + double RHS66 = Idr[255]; + RHS66 += Idr[256]; + RHS66 += Idr[257]; + RHS66 -= go[257] * *cnV[257]; + m_A229 += gt[258]; + m_A229 += gt[259]; + m_A229 += gt[260]; + m_A230 += go[258]; + m_A228 += go[259]; + m_A227 += go[260]; + double RHS67 = Idr[258]; + RHS67 += Idr[259]; + RHS67 += Idr[260]; + m_A234 += gt[261]; + m_A234 += gt[262]; + m_A232 += go[261]; + m_A231 += go[262]; + double RHS68 = Idr[261]; + RHS68 += Idr[262]; + m_A238 += gt[263]; + m_A238 += gt[264]; + m_A238 += gt[265]; + m_A237 += go[263]; + m_A236 += go[264]; + double RHS69 = Idr[263]; + RHS69 += Idr[264]; + RHS69 += Idr[265]; + RHS69 -= go[265] * *cnV[265]; + m_A244 += gt[266]; + m_A244 += gt[267]; + m_A244 += gt[268]; + m_A244 += gt[269]; + m_A244 += gt[270]; + m_A244 += gt[271]; + m_A243 += go[266]; + m_A242 += go[267]; + m_A246 += go[268]; + m_A246 += go[269]; + double RHS70 = Idr[266]; + RHS70 += Idr[267]; + RHS70 += Idr[268]; + RHS70 += Idr[269]; + RHS70 += Idr[270]; + RHS70 += Idr[271]; + RHS70 -= go[270] * *cnV[270]; + RHS70 -= go[271] * *cnV[271]; + m_A248 += gt[272]; + m_A248 += gt[273]; + m_A248 += gt[274]; + m_A250 += go[272]; + m_A247 += go[273]; + double RHS71 = Idr[272]; + RHS71 += Idr[273]; + RHS71 += Idr[274]; + RHS71 -= go[274] * *cnV[274]; + m_A253 += gt[275]; + m_A253 += gt[276]; + m_A256 += go[275]; + m_A251 += go[276]; + double RHS72 = Idr[275]; + RHS72 += Idr[276]; + m_A259 += gt[277]; + m_A259 += gt[278]; + m_A261 += go[277]; + m_A257 += go[278]; + double RHS73 = Idr[277]; + RHS73 += Idr[278]; + m_A264 += gt[279]; + m_A264 += gt[280]; + m_A263 += go[279]; + m_A262 += go[280]; + double RHS74 = Idr[279]; + RHS74 += Idr[280]; + m_A270 += gt[281]; + m_A270 += gt[282]; + m_A270 += gt[283]; + m_A270 += gt[284]; + m_A270 += gt[285]; + m_A270 += gt[286]; + m_A267 += go[281]; + m_A269 += go[282]; + m_A268 += go[283]; + m_A272 += go[284]; + double RHS75 = Idr[281]; + RHS75 += Idr[282]; + RHS75 += Idr[283]; + RHS75 += Idr[284]; + RHS75 += Idr[285]; + RHS75 += Idr[286]; + RHS75 -= go[285] * *cnV[285]; + RHS75 -= go[286] * *cnV[286]; + m_A280 += gt[287]; + m_A280 += gt[288]; + m_A280 += gt[289]; + m_A280 += gt[290]; + m_A280 += gt[291]; + m_A280 += gt[292]; + m_A273 += go[287]; + m_A275 += go[288]; + m_A277 += go[289]; + m_A274 += go[290]; + double RHS76 = Idr[287]; + RHS76 += Idr[288]; + RHS76 += Idr[289]; + RHS76 += Idr[290]; + RHS76 += Idr[291]; + RHS76 += Idr[292]; + RHS76 -= go[291] * *cnV[291]; + RHS76 -= go[292] * *cnV[292]; + m_A287 += gt[293]; + m_A287 += gt[294]; + m_A287 += gt[295]; + m_A287 += gt[296]; + m_A287 += gt[297]; + m_A283 += go[293]; + m_A285 += go[294]; + m_A284 += go[295]; + double RHS77 = Idr[293]; + RHS77 += Idr[294]; + RHS77 += Idr[295]; + RHS77 += Idr[296]; + RHS77 += Idr[297]; + RHS77 -= go[296] * *cnV[296]; + RHS77 -= go[297] * *cnV[297]; + m_A296 += gt[298]; + m_A296 += gt[299]; + m_A296 += gt[300]; + m_A296 += gt[301]; + m_A296 += gt[302]; + m_A290 += go[298]; + m_A292 += go[299]; + m_A294 += go[300]; + double RHS78 = Idr[298]; + RHS78 += Idr[299]; + RHS78 += Idr[300]; + RHS78 += Idr[301]; + RHS78 += Idr[302]; + RHS78 -= go[301] * *cnV[301]; + RHS78 -= go[302] * *cnV[302]; + m_A305 += gt[303]; + m_A305 += gt[304]; + m_A305 += gt[305]; + m_A300 += go[303]; + m_A301 += go[304]; + m_A299 += go[305]; + double RHS79 = Idr[303]; + RHS79 += Idr[304]; + RHS79 += Idr[305]; + m_A315 += gt[306]; + m_A315 += gt[307]; + m_A315 += gt[308]; + m_A315 += gt[309]; + m_A309 += go[306]; + m_A308 += go[307]; + m_A312 += go[308]; + m_A311 += go[309]; + double RHS80 = Idr[306]; + RHS80 += Idr[307]; + RHS80 += Idr[308]; + RHS80 += Idr[309]; + m_A322 += gt[310]; + m_A322 += gt[311]; + m_A322 += gt[312]; + m_A322 += gt[313]; + m_A322 += gt[314]; + m_A322 += gt[315]; + m_A322 += gt[316]; + m_A322 += gt[317]; + m_A320 += go[310]; + m_A323 += go[311]; + m_A319 += go[312]; + m_A318 += go[313]; + double RHS81 = Idr[310]; + RHS81 += Idr[311]; + RHS81 += Idr[312]; + RHS81 += Idr[313]; + RHS81 += Idr[314]; + RHS81 += Idr[315]; + RHS81 += Idr[316]; + RHS81 += Idr[317]; + RHS81 -= go[314] * *cnV[314]; + RHS81 -= go[315] * *cnV[315]; + RHS81 -= go[316] * *cnV[316]; + RHS81 -= go[317] * *cnV[317]; + m_A330 += gt[318]; + m_A330 += gt[319]; + m_A330 += gt[320]; + m_A330 += gt[321]; + m_A330 += gt[322]; + m_A330 += gt[323]; + m_A327 += go[318]; + m_A325 += go[319]; + m_A324 += go[320]; + m_A328 += go[321]; + double RHS82 = Idr[318]; + RHS82 += Idr[319]; + RHS82 += Idr[320]; + RHS82 += Idr[321]; + RHS82 += Idr[322]; + RHS82 += Idr[323]; + RHS82 -= go[322] * *cnV[322]; + RHS82 -= go[323] * *cnV[323]; + m_A337 += gt[324]; + m_A337 += gt[325]; + m_A337 += gt[326]; + m_A337 += gt[327]; + m_A337 += gt[328]; + m_A337 += gt[329]; + m_A337 += gt[330]; + m_A338 += go[324]; + m_A333 += go[325]; + m_A333 += go[326]; + m_A335 += go[327]; + m_A332 += go[328]; + m_A332 += go[329]; + double RHS83 = Idr[324]; + RHS83 += Idr[325]; + RHS83 += Idr[326]; + RHS83 += Idr[327]; + RHS83 += Idr[328]; + RHS83 += Idr[329]; + RHS83 += Idr[330]; + RHS83 -= go[330] * *cnV[330]; + m_A343 += gt[331]; + m_A343 += gt[332]; + m_A343 += gt[333]; + m_A343 += gt[334]; + m_A343 += gt[335]; + m_A343 += gt[336]; + m_A343 += gt[337]; + m_A340 += go[331]; + m_A339 += go[332]; + double RHS84 = Idr[331]; + RHS84 += Idr[332]; + RHS84 += Idr[333]; + RHS84 += Idr[334]; + RHS84 += Idr[335]; + RHS84 += Idr[336]; + RHS84 += Idr[337]; + RHS84 -= go[333] * *cnV[333]; + RHS84 -= go[334] * *cnV[334]; + RHS84 -= go[335] * *cnV[335]; + RHS84 -= go[336] * *cnV[336]; + RHS84 -= go[337] * *cnV[337]; + m_A349 += gt[338]; + m_A349 += gt[339]; + m_A349 += gt[340]; + m_A349 += gt[341]; + m_A349 += gt[342]; + m_A349 += gt[343]; + m_A349 += gt[344]; + m_A346 += go[338]; + m_A350 += go[339]; + m_A345 += go[340]; + m_A347 += go[341]; + double RHS85 = Idr[338]; + RHS85 += Idr[339]; + RHS85 += Idr[340]; + RHS85 += Idr[341]; + RHS85 += Idr[342]; + RHS85 += Idr[343]; + RHS85 += Idr[344]; + RHS85 -= go[342] * *cnV[342]; + RHS85 -= go[343] * *cnV[343]; + RHS85 -= go[344] * *cnV[344]; + m_A354 += gt[345]; + m_A354 += gt[346]; + m_A354 += gt[347]; + m_A354 += gt[348]; + m_A354 += gt[349]; + m_A354 += gt[350]; + m_A351 += go[345]; + m_A353 += go[346]; + m_A352 += go[347]; + m_A356 += go[348]; + double RHS86 = Idr[345]; + RHS86 += Idr[346]; + RHS86 += Idr[347]; + RHS86 += Idr[348]; + RHS86 += Idr[349]; + RHS86 += Idr[350]; + RHS86 -= go[349] * *cnV[349]; + RHS86 -= go[350] * *cnV[350]; + m_A363 += gt[351]; + m_A363 += gt[352]; + m_A363 += gt[353]; + m_A363 += gt[354]; + m_A363 += gt[355]; + m_A363 += gt[356]; + m_A363 += gt[357]; + m_A363 += gt[358]; + m_A361 += go[351]; + m_A361 += go[352]; + m_A358 += go[353]; + m_A358 += go[354]; + m_A360 += go[355]; + m_A357 += go[356]; + m_A357 += go[357]; + double RHS87 = Idr[351]; + RHS87 += Idr[352]; + RHS87 += Idr[353]; + RHS87 += Idr[354]; + RHS87 += Idr[355]; + RHS87 += Idr[356]; + RHS87 += Idr[357]; + RHS87 += Idr[358]; + RHS87 -= go[358] * *cnV[358]; + m_A370 += gt[359]; + m_A370 += gt[360]; + m_A370 += gt[361]; + m_A370 += gt[362]; + m_A370 += gt[363]; + m_A370 += gt[364]; + m_A365 += go[359]; + m_A367 += go[360]; + m_A368 += go[361]; + m_A366 += go[362]; + double RHS88 = Idr[359]; + RHS88 += Idr[360]; + RHS88 += Idr[361]; + RHS88 += Idr[362]; + RHS88 += Idr[363]; + RHS88 += Idr[364]; + RHS88 -= go[363] * *cnV[363]; + RHS88 -= go[364] * *cnV[364]; + m_A388 += gt[365]; + m_A388 += gt[366]; + m_A388 += gt[367]; + m_A388 += gt[368]; + m_A388 += gt[369]; + m_A388 += gt[370]; + m_A388 += gt[371]; + m_A376 += go[365]; + m_A375 += go[366]; + m_A374 += go[367]; + m_A378 += go[368]; + m_A373 += go[369]; + m_A377 += go[370]; + double RHS89 = Idr[365]; + RHS89 += Idr[366]; + RHS89 += Idr[367]; + RHS89 += Idr[368]; + RHS89 += Idr[369]; + RHS89 += Idr[370]; + RHS89 += Idr[371]; + RHS89 -= go[371] * *cnV[371]; + m_A401 += gt[372]; + m_A401 += gt[373]; + m_A401 += gt[374]; + m_A401 += gt[375]; + m_A401 += gt[376]; + m_A401 += gt[377]; + m_A401 += gt[378]; + m_A401 += gt[379]; + m_A401 += gt[380]; + m_A394 += go[372]; + m_A394 += go[373]; + m_A393 += go[374]; + m_A395 += go[375]; + m_A398 += go[376]; + m_A392 += go[377]; + m_A392 += go[378]; + double RHS90 = Idr[372]; + RHS90 += Idr[373]; + RHS90 += Idr[374]; + RHS90 += Idr[375]; + RHS90 += Idr[376]; + RHS90 += Idr[377]; + RHS90 += Idr[378]; + RHS90 += Idr[379]; + RHS90 += Idr[380]; + RHS90 -= go[379] * *cnV[379]; + RHS90 -= go[380] * *cnV[380]; + m_A411 += gt[381]; + m_A411 += gt[382]; + m_A411 += gt[383]; + m_A411 += gt[384]; + m_A411 += gt[385]; + m_A407 += go[381]; + m_A405 += go[382]; + m_A404 += go[383]; + m_A408 += go[384]; + m_A406 += go[385]; + double RHS91 = Idr[381]; + RHS91 += Idr[382]; + RHS91 += Idr[383]; + RHS91 += Idr[384]; + RHS91 += Idr[385]; + m_A421 += gt[386]; + m_A421 += gt[387]; + m_A421 += gt[388]; + m_A421 += gt[389]; + m_A421 += gt[390]; + m_A417 += go[386]; + m_A414 += go[387]; + m_A413 += go[388]; + m_A416 += go[389]; + m_A415 += go[390]; + double RHS92 = Idr[386]; + RHS92 += Idr[387]; + RHS92 += Idr[388]; + RHS92 += Idr[389]; + RHS92 += Idr[390]; + const double f0 = 1.0 / m_A0; + const double f0_46 = -f0 * m_A130; + m_A132 += m_A1 * f0_46; + m_A134 += m_A2 * f0_46; + RHS46 += f0_46 * RHS0; + const double f0_48 = -f0 * m_A141; + m_A144 += m_A1 * f0_48; + m_A146 += m_A2 * f0_48; + RHS48 += f0_48 * RHS0; + const double f1 = 1.0 / m_A3; + const double f1_48 = -f1 * m_A142; + m_A146 += m_A4 * f1_48; + RHS48 += f1_48 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_76 = -f2 * m_A273; + m_A277 += m_A6 * f2_76; + RHS76 += f2_76 * RHS2; + const double f3 = 1.0 / m_A7; + const double f3_46 = -f3 * m_A131; + m_A132 += m_A8 * f3_46; + m_A133 += m_A9 * f3_46; + m_A135 += m_A10 * f3_46; + RHS46 += f3_46 * RHS3; + const double f3_47 = -f3 * m_A136; + m_A137 += m_A8 * f3_47; + m_A138 += m_A9 * f3_47; + m_A140 += m_A10 * f3_47; + RHS47 += f3_47 * RHS3; + const double f3_76 = -f3 * m_A274; + m_A276 += m_A8 * f3_76; + m_A277 += m_A9 * f3_76; + m_A280 += m_A10 * f3_76; + RHS76 += f3_76 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_48 = -f4 * m_A143; + m_A146 += m_A12 * f4_48; + m_A147 += m_A13 * f4_48; + m_A149 += m_A14 * f4_48; + RHS48 += f4_48 * RHS4; + const double f4_50 = -f4 * m_A153; + m_A154 += m_A12 * f4_50; + m_A155 += m_A13 * f4_50; + m_A157 += m_A14 * f4_50; + RHS50 += f4_50 * RHS4; + const double f4_83 = -f4 * m_A332; + m_A334 += m_A12 * f4_83; + m_A335 += m_A13 * f4_83; + m_A337 += m_A14 * f4_83; + RHS83 += f4_83 * RHS4; + const double f5 = 1.0 / m_A15; + const double f5_76 = -f5 * m_A275; + m_A280 += m_A16 * f5_76; + m_A281 += m_A17 * f5_76; + m_A282 += m_A18 * f5_76; + RHS76 += f5_76 * RHS5; + const double f5_83 = -f5 * m_A333; + m_A336 += m_A16 * f5_83; + m_A337 += m_A17 * f5_83; + m_A338 += m_A18 * f5_83; + RHS83 += f5_83 * RHS5; + const double f5_90 = -f5 * m_A392; + m_A396 += m_A16 * f5_90; + m_A398 += m_A17 * f5_90; + m_A401 += m_A18 * f5_90; + RHS90 += f5_90 * RHS5; + const double f6 = 1.0 / m_A19; + const double f6_51 = -f6 * m_A158; + m_A159 += m_A20 * f6_51; + m_A160 += m_A21 * f6_51; + RHS51 += f6_51 * RHS6; + const double f6_53 = -f6 * m_A166; + m_A168 += m_A20 * f6_53; + m_A169 += m_A21 * f6_53; + RHS53 += f6_53 * RHS6; + const double f7 = 1.0 / m_A22; + const double f7_78 = -f7 * m_A290; + m_A291 += m_A23 * f7_78; + m_A294 += m_A24 * f7_78; + RHS78 += f7_78 * RHS7; + const double f8 = 1.0 / m_A25; + const double f8_53 = -f8 * m_A167; + m_A169 += m_A26 * f8_53; + m_A170 += m_A27 * f8_53; + m_A171 += m_A28 * f8_53; + RHS53 += f8_53 * RHS8; + const double f8_54 = -f8 * m_A172; + m_A173 += m_A26 * f8_54; + m_A174 += m_A27 * f8_54; + m_A176 += m_A28 * f8_54; + RHS54 += f8_54 * RHS8; + const double f8_78 = -f8 * m_A291; + m_A293 += m_A26 * f8_78; + m_A294 += m_A27 * f8_78; + m_A298 += m_A28 * f8_78; + RHS78 += f8_78 * RHS8; + const double f8_90 = -f8 * m_A393; + m_A394 += m_A26 * f8_90; + m_A395 += m_A27 * f8_90; + m_A401 += m_A28 * f8_90; + RHS90 += f8_90 * RHS8; + const double f9 = 1.0 / m_A29; + const double f9_52 = -f9 * m_A161; + m_A163 += m_A30 * f9_52; + RHS52 += f9_52 * RHS9; + const double f10 = 1.0 / m_A31; + const double f10_88 = -f10 * m_A365; + m_A368 += m_A32 * f10_88; + RHS88 += f10_88 * RHS10; + const double f11 = 1.0 / m_A33; + const double f11_52 = -f11 * m_A162; + m_A163 += m_A34 * f11_52; + m_A164 += m_A35 * f11_52; + m_A165 += m_A36 * f11_52; + RHS52 += f11_52 * RHS11; + const double f11_56 = -f11 * m_A181; + m_A182 += m_A34 * f11_56; + m_A183 += m_A35 * f11_56; + m_A184 += m_A36 * f11_56; + RHS56 += f11_56 * RHS11; + const double f11_87 = -f11 * m_A357; + m_A359 += m_A34 * f11_87; + m_A360 += m_A35 * f11_87; + m_A363 += m_A36 * f11_87; + RHS87 += f11_87 * RHS11; + const double f12 = 1.0 / m_A37; + const double f12_59 = -f12 * m_A194; + m_A195 += m_A38 * f12_59; + m_A196 += m_A39 * f12_59; + RHS59 += f12_59 * RHS12; + const double f12_60 = -f12 * m_A198; + m_A199 += m_A38 * f12_60; + m_A200 += m_A39 * f12_60; + RHS60 += f12_60 * RHS12; + const double f13 = 1.0 / m_A40; + const double f13_71 = -f13 * m_A247; + m_A248 += m_A41 * f13_71; + m_A249 += m_A42 * f13_71; + m_A250 += m_A43 * f13_71; + RHS71 += f13_71 * RHS13; + const double f13_78 = -f13 * m_A292; + m_A295 += m_A41 * f13_78; + m_A296 += m_A42 * f13_78; + m_A297 += m_A43 * f13_78; + RHS78 += f13_78 * RHS13; + const double f13_88 = -f13 * m_A366; + m_A368 += m_A41 * f13_88; + m_A369 += m_A42 * f13_88; + m_A370 += m_A43 * f13_88; + RHS88 += f13_88 * RHS13; + const double f14 = 1.0 / m_A44; + const double f14_85 = -f14 * m_A345; + m_A349 += m_A45 * f14_85; + RHS85 += f14_85 * RHS14; + const double f15 = 1.0 / m_A46; + const double f15_55 = -f15 * m_A177; + m_A179 += m_A47 * f15_55; + RHS55 += f15_55 * RHS15; + const double f16 = 1.0 / m_A48; + const double f16_85 = -f16 * m_A346; + m_A349 += m_A49 * f16_85; + m_A350 += m_A50 * f16_85; + RHS85 += f16_85 * RHS16; + const double f16_91 = -f16 * m_A404; + m_A408 += m_A49 * f16_91; + m_A411 += m_A50 * f16_91; + RHS91 += f16_91 * RHS16; + const double f17 = 1.0 / m_A51; + const double f17_75 = -f17 * m_A267; + m_A268 += m_A52 * f17_75; + RHS75 += f17_75 * RHS17; + const double f18 = 1.0 / m_A53; + const double f18_70 = -f18 * m_A242; + m_A244 += m_A54 * f18_70; + m_A246 += m_A55 * f18_70; + RHS70 += f18_70 * RHS18; + const double f18_87 = -f18 * m_A358; + m_A361 += m_A54 * f18_87; + m_A363 += m_A55 * f18_87; + RHS87 += f18_87 * RHS18; + const double f19 = 1.0 / m_A56; + const double f19_81 = -f19 * m_A318; + m_A322 += m_A57 * f19_81; + RHS81 += f19_81 * RHS19; + const double f20 = 1.0 / m_A58; + const double f20_66 = -f20 * m_A223; + m_A224 += m_A59 * f20_66; + m_A225 += m_A60 * f20_66; + RHS66 += f20_66 * RHS20; + const double f20_81 = -f20 * m_A319; + m_A321 += m_A59 * f20_81; + m_A322 += m_A60 * f20_81; + RHS81 += f20_81 * RHS20; + const double f21 = 1.0 / m_A61; + const double f21_61 = -f21 * m_A203; + m_A205 += m_A62 * f21_61; + RHS61 += f21_61 * RHS21; + const double f22 = 1.0 / m_A63; + const double f22_57 = -f22 * m_A185; + m_A187 += m_A64 * f22_57; + RHS57 += f22_57 * RHS22; + const double f23 = 1.0 / m_A65; + const double f23_55 = -f23 * m_A178; + m_A179 += m_A66 * f23_55; + m_A180 += m_A67 * f23_55; + RHS55 += f23_55 * RHS23; + const double f23_64 = -f23 * m_A215; + m_A217 += m_A66 * f23_64; + m_A218 += m_A67 * f23_64; + RHS64 += f23_64 * RHS23; + const double f24 = 1.0 / m_A68; + const double f24_64 = -f24 * m_A216; + m_A218 += m_A69 * f24_64; + RHS64 += f24_64 * RHS24; + const double f25 = 1.0 / m_A70; + const double f25_65 = -f25 * m_A220; + m_A221 += m_A71 * f25_65; + RHS65 += f25_65 * RHS25; + const double f26 = 1.0 / m_A72; + const double f26_57 = -f26 * m_A186; + m_A187 += m_A73 * f26_57; + m_A188 += m_A74 * f26_57; + RHS57 += f26_57 * RHS26; + const double f26_58 = -f26 * m_A189; + m_A191 += m_A73 * f26_58; + m_A192 += m_A74 * f26_58; + RHS58 += f26_58 * RHS26; + const double f27 = 1.0 / m_A75; + const double f27_67 = -f27 * m_A227; + m_A229 += m_A76 * f27_67; + RHS67 += f27_67 * RHS27; + const double f28 = 1.0 / m_A77; + const double f28_75 = -f28 * m_A268; + m_A270 += m_A78 * f28_75; + m_A272 += m_A79 * f28_75; + RHS75 += f28_75 * RHS28; + const double f28_91 = -f28 * m_A405; + m_A407 += m_A78 * f28_91; + m_A411 += m_A79 * f28_91; + RHS91 += f28_91 * RHS28; + const double f29 = 1.0 / m_A80; + const double f29_63 = -f29 * m_A211; + m_A213 += m_A81 * f29_63; + m_A214 += m_A82 * f29_63; + RHS63 += f29_63 * RHS29; + const double f29_67 = -f29 * m_A228; + m_A229 += m_A81 * f29_67; + m_A230 += m_A82 * f29_67; + RHS67 += f29_67 * RHS29; + const double f29_82 = -f29 * m_A324; + m_A328 += m_A81 * f29_82; + m_A330 += m_A82 * f29_82; + RHS82 += f29_82 * RHS29; + const double f30 = 1.0 / m_A83; + const double f30_58 = -f30 * m_A190; + m_A192 += m_A84 * f30_58; + m_A193 += m_A85 * f30_58; + RHS58 += f30_58 * RHS30; + const double f30_68 = -f30 * m_A231; + m_A233 += m_A84 * f30_68; + m_A234 += m_A85 * f30_68; + RHS68 += f30_68 * RHS30; + const double f31 = 1.0 / m_A86; + const double f31_81 = -f31 * m_A320; + m_A322 += m_A87 * f31_81; + m_A323 += m_A88 * f31_81; + RHS81 += f31_81 * RHS31; + const double f31_92 = -f31 * m_A413; + m_A416 += m_A87 * f31_92; + m_A421 += m_A88 * f31_92; + RHS92 += f31_92 * RHS31; + const double f32 = 1.0 / m_A89; + const double f32_86 = -f32 * m_A351; + m_A352 += m_A90 * f32_86; + RHS86 += f32_86 * RHS32; + const double f33 = 1.0 / m_A91; + const double f33_62 = -f33 * m_A207; + m_A208 += m_A92 * f33_62; + m_A210 += m_A93 * f33_62; + RHS62 += f33_62 * RHS33; + const double f33_82 = -f33 * m_A325; + m_A326 += m_A92 * f33_82; + m_A330 += m_A93 * f33_82; + RHS82 += f33_82 * RHS33; + const double f34 = 1.0 / m_A94; + const double f34_61 = -f34 * m_A204; + m_A205 += m_A95 * f34_61; + m_A206 += m_A96 * f34_61; + RHS61 += f34_61 * RHS34; + const double f34_80 = -f34 * m_A308; + m_A310 += m_A95 * f34_80; + m_A315 += m_A96 * f34_80; + RHS80 += f34_80 * RHS34; + const double f35 = 1.0 / m_A97; + const double f35_68 = -f35 * m_A232; + m_A234 += m_A98 * f35_68; + m_A235 += m_A99 * f35_68; + RHS68 += f35_68 * RHS35; + const double f35_79 = -f35 * m_A299; + m_A302 += m_A98 * f35_79; + m_A305 += m_A99 * f35_79; + RHS79 += f35_79 * RHS35; + const double f36 = 1.0 / m_A100; + const double f36_69 = -f36 * m_A236; + m_A238 += m_A101 * f36_69; + m_A240 += m_A102 * f36_69; + RHS69 += f36_69 * RHS36; + const double f36_80 = -f36 * m_A309; + m_A313 += m_A101 * f36_80; + m_A315 += m_A102 * f36_80; + RHS80 += f36_80 * RHS36; + const double f36_84 = -f36 * m_A339; + m_A340 += m_A101 * f36_84; + m_A342 += m_A102 * f36_84; + RHS84 += f36_84 * RHS36; + const double f37 = 1.0 / m_A103; + const double f37_74 = -f37 * m_A262; + m_A264 += m_A104 * f37_74; + m_A266 += m_A105 * f37_74; + RHS74 += f37_74 * RHS37; + const double f37_79 = -f37 * m_A300; + m_A303 += m_A104 * f37_79; + m_A305 += m_A105 * f37_79; + RHS79 += f37_79 * RHS37; + const double f38 = 1.0 / m_A106; + const double f38_86 = -f38 * m_A352; + m_A354 += m_A107 * f38_86; + m_A356 += m_A108 * f38_86; + RHS86 += f38_86 * RHS38; + const double f38_92 = -f38 * m_A414; + m_A417 += m_A107 * f38_92; + m_A421 += m_A108 * f38_92; + RHS92 += f38_92 * RHS38; + const double f39 = 1.0 / m_A109; + const double f39_77 = -f39 * m_A283; + m_A284 += m_A110 * f39_77; + RHS77 += f39_77 * RHS39; + const double f40 = 1.0 / m_A111; + const double f40_69 = -f40 * m_A237; + m_A238 += m_A112 * f40_69; + m_A239 += m_A113 * f40_69; + m_A241 += m_A114 * f40_69; + RHS69 += f40_69 * RHS40; + const double f40_72 = -f40 * m_A251; + m_A252 += m_A112 * f40_72; + m_A253 += m_A113 * f40_72; + m_A255 += m_A114 * f40_72; + RHS72 += f40_72 * RHS40; + const double f41 = 1.0 / m_A115; + const double f41_70 = -f41 * m_A243; + m_A244 += m_A116 * f41_70; + m_A245 += m_A117 * f41_70; + RHS70 += f41_70 * RHS41; + const double f41_73 = -f41 * m_A257; + m_A258 += m_A116 * f41_73; + m_A259 += m_A117 * f41_73; + RHS73 += f41_73 * RHS41; + const double f42 = 1.0 / m_A118; + const double f42_86 = -f42 * m_A353; + m_A354 += m_A119 * f42_86; + m_A355 += m_A120 * f42_86; + RHS86 += f42_86 * RHS42; + const double f42_89 = -f42 * m_A373; + m_A385 += m_A119 * f42_89; + m_A388 += m_A120 * f42_89; + RHS89 += f42_89 * RHS42; + const double f43 = 1.0 / m_A121; + const double f43_75 = -f43 * m_A269; + m_A270 += m_A122 * f43_75; + m_A271 += m_A123 * f43_75; + RHS75 += f43_75 * RHS43; + const double f43_89 = -f43 * m_A374; + m_A379 += m_A122 * f43_89; + m_A388 += m_A123 * f43_89; + RHS89 += f43_89 * RHS43; + const double f44 = 1.0 / m_A124; + const double f44_74 = -f44 * m_A263; + m_A264 += m_A125 * f44_74; + m_A265 += m_A126 * f44_74; + RHS74 += f44_74 * RHS44; + const double f44_77 = -f44 * m_A284; + m_A286 += m_A125 * f44_77; + m_A287 += m_A126 * f44_77; + RHS77 += f44_77 * RHS44; + const double f45 = 1.0 / m_A127; + const double f45_88 = -f45 * m_A367; + m_A370 += m_A128 * f45_88; + m_A371 += m_A129 * f45_88; + RHS88 += f45_88 * RHS45; + const double f45_89 = -f45 * m_A375; + m_A387 += m_A128 * f45_89; + m_A388 += m_A129 * f45_89; + RHS89 += f45_89 * RHS45; + const double f46 = 1.0 / m_A132; + const double f46_47 = -f46 * m_A137; + m_A138 += m_A133 * f46_47; + m_A139 += m_A134 * f46_47; + m_A140 += m_A135 * f46_47; + RHS47 += f46_47 * RHS46; + const double f46_48 = -f46 * m_A144; + m_A145 += m_A133 * f46_48; + m_A146 += m_A134 * f46_48; + m_A148 += m_A135 * f46_48; + RHS48 += f46_48 * RHS46; + const double f46_76 = -f46 * m_A276; + m_A277 += m_A133 * f46_76; + m_A278 += m_A134 * f46_76; + m_A280 += m_A135 * f46_76; + RHS76 += f46_76 * RHS46; + const double f47 = 1.0 / m_A138; + const double f47_48 = -f47 * m_A145; + m_A146 += m_A139 * f47_48; + m_A148 += m_A140 * f47_48; + RHS48 += f47_48 * RHS47; + const double f47_76 = -f47 * m_A277; + m_A278 += m_A139 * f47_76; + m_A280 += m_A140 * f47_76; + RHS76 += f47_76 * RHS47; + const double f48 = 1.0 / m_A146; + const double f48_50 = -f48 * m_A154; + m_A155 += m_A147 * f48_50; + m_A156 += m_A148 * f48_50; + m_A157 += m_A149 * f48_50; + RHS50 += f48_50 * RHS48; + const double f48_76 = -f48 * m_A278; + m_A279 += m_A147 * f48_76; + m_A280 += m_A148 * f48_76; + m_A281 += m_A149 * f48_76; + RHS76 += f48_76 * RHS48; + const double f48_83 = -f48 * m_A334; + m_A335 += m_A147 * f48_83; + m_A336 += m_A148 * f48_83; + m_A337 += m_A149 * f48_83; + RHS83 += f48_83 * RHS48; + const double f49 = 1.0 / m_A150; + const double f49_77 = -f49 * m_A285; + m_A287 += m_A151 * f49_77; + m_A289 += m_A152 * f49_77; + RHS77 += f49_77 * RHS49; + const double f49_89 = -f49 * m_A376; + m_A380 += m_A151 * f49_89; + m_A388 += m_A152 * f49_89; + RHS89 += f49_89 * RHS49; + const double f50 = 1.0 / m_A155; + const double f50_76 = -f50 * m_A279; + m_A280 += m_A156 * f50_76; + m_A281 += m_A157 * f50_76; + RHS76 += f50_76 * RHS50; + const double f50_83 = -f50 * m_A335; + m_A336 += m_A156 * f50_83; + m_A337 += m_A157 * f50_83; + RHS83 += f50_83 * RHS50; + const double f51 = 1.0 / m_A159; + const double f51_53 = -f51 * m_A168; + m_A169 += m_A160 * f51_53; + RHS53 += f51_53 * RHS51; + const double f52 = 1.0 / m_A163; + const double f52_56 = -f52 * m_A182; + m_A183 += m_A164 * f52_56; + m_A184 += m_A165 * f52_56; + RHS56 += f52_56 * RHS52; + const double f52_87 = -f52 * m_A359; + m_A360 += m_A164 * f52_87; + m_A363 += m_A165 * f52_87; + RHS87 += f52_87 * RHS52; + const double f53 = 1.0 / m_A169; + const double f53_54 = -f53 * m_A173; + m_A174 += m_A170 * f53_54; + m_A176 += m_A171 * f53_54; + RHS54 += f53_54 * RHS53; + const double f53_78 = -f53 * m_A293; + m_A294 += m_A170 * f53_78; + m_A298 += m_A171 * f53_78; + RHS78 += f53_78 * RHS53; + const double f53_90 = -f53 * m_A394; + m_A395 += m_A170 * f53_90; + m_A401 += m_A171 * f53_90; + RHS90 += f53_90 * RHS53; + const double f54 = 1.0 / m_A174; + const double f54_78 = -f54 * m_A294; + m_A296 += m_A175 * f54_78; + m_A298 += m_A176 * f54_78; + RHS78 += f54_78 * RHS54; + const double f54_90 = -f54 * m_A395; + m_A397 += m_A175 * f54_90; + m_A401 += m_A176 * f54_90; + RHS90 += f54_90 * RHS54; + const double f55 = 1.0 / m_A179; + const double f55_64 = -f55 * m_A217; + m_A218 += m_A180 * f55_64; + RHS64 += f55_64 * RHS55; + const double f56 = 1.0 / m_A183; + const double f56_87 = -f56 * m_A360; + m_A363 += m_A184 * f56_87; + RHS87 += f56_87 * RHS56; + const double f57 = 1.0 / m_A187; + const double f57_58 = -f57 * m_A191; + m_A192 += m_A188 * f57_58; + RHS58 += f57_58 * RHS57; + const double f58 = 1.0 / m_A192; + const double f58_68 = -f58 * m_A233; + m_A234 += m_A193 * f58_68; + RHS68 += f58_68 * RHS58; + const double f59 = 1.0 / m_A195; + const double f59_60 = -f59 * m_A199; + m_A200 += m_A196 * f59_60; + m_A201 += m_A197 * f59_60; + RHS60 += f59_60 * RHS59; + const double f59_85 = -f59 * m_A347; + m_A348 += m_A196 * f59_85; + m_A349 += m_A197 * f59_85; + RHS85 += f59_85 * RHS59; + const double f60 = 1.0 / m_A200; + const double f60_85 = -f60 * m_A348; + m_A349 += m_A201 * f60_85; + m_A350 += m_A202 * f60_85; + RHS85 += f60_85 * RHS60; + const double f60_91 = -f60 * m_A406; + m_A408 += m_A201 * f60_91; + m_A411 += m_A202 * f60_91; + RHS91 += f60_91 * RHS60; + const double f61 = 1.0 / m_A205; + const double f61_80 = -f61 * m_A310; + m_A315 += m_A206 * f61_80; + RHS80 += f61_80 * RHS61; + const double f62 = 1.0 / m_A208; + const double f62_79 = -f62 * m_A301; + m_A305 += m_A209 * f62_79; + m_A306 += m_A210 * f62_79; + RHS79 += f62_79 * RHS62; + const double f62_82 = -f62 * m_A326; + m_A329 += m_A209 * f62_82; + m_A330 += m_A210 * f62_82; + RHS82 += f62_82 * RHS62; + const double f63 = 1.0 / m_A212; + const double f63_82 = -f63 * m_A327; + m_A328 += m_A213 * f63_82; + m_A330 += m_A214 * f63_82; + RHS82 += f63_82 * RHS63; + const double f64 = 1.0 / m_A218; + const double f64_80 = -f64 * m_A311; + m_A315 += m_A219 * f64_80; + RHS80 += f64_80 * RHS64; + const double f65 = 1.0 / m_A221; + const double f65_80 = -f65 * m_A312; + m_A315 += m_A222 * f65_80; + RHS80 += f65_80 * RHS65; + const double f66 = 1.0 / m_A224; + const double f66_81 = -f66 * m_A321; + m_A322 += m_A225 * f66_81; + m_A323 += m_A226 * f66_81; + RHS81 += f66_81 * RHS66; + const double f66_92 = -f66 * m_A415; + m_A416 += m_A225 * f66_92; + m_A421 += m_A226 * f66_92; + RHS92 += f66_92 * RHS66; + const double f67 = 1.0 / m_A229; + const double f67_82 = -f67 * m_A328; + m_A330 += m_A230 * f67_82; + RHS82 += f67_82 * RHS67; + const double f68 = 1.0 / m_A234; + const double f68_79 = -f68 * m_A302; + m_A305 += m_A235 * f68_79; + RHS79 += f68_79 * RHS68; + const double f69 = 1.0 / m_A238; + const double f69_72 = -f69 * m_A252; + m_A253 += m_A239 * f69_72; + m_A254 += m_A240 * f69_72; + m_A255 += m_A241 * f69_72; + RHS72 += f69_72 * RHS69; + const double f69_80 = -f69 * m_A313; + m_A314 += m_A239 * f69_80; + m_A315 += m_A240 * f69_80; + m_A316 += m_A241 * f69_80; + RHS80 += f69_80 * RHS69; + const double f69_84 = -f69 * m_A340; + m_A341 += m_A239 * f69_84; + m_A342 += m_A240 * f69_84; + m_A343 += m_A241 * f69_84; + RHS84 += f69_84 * RHS69; + const double f70 = 1.0 / m_A244; + const double f70_73 = -f70 * m_A258; + m_A259 += m_A245 * f70_73; + m_A260 += m_A246 * f70_73; + RHS73 += f70_73 * RHS70; + const double f70_87 = -f70 * m_A361; + m_A362 += m_A245 * f70_87; + m_A363 += m_A246 * f70_87; + RHS87 += f70_87 * RHS70; + const double f71 = 1.0 / m_A248; + const double f71_78 = -f71 * m_A295; + m_A296 += m_A249 * f71_78; + m_A297 += m_A250 * f71_78; + RHS78 += f71_78 * RHS71; + const double f71_88 = -f71 * m_A368; + m_A369 += m_A249 * f71_88; + m_A370 += m_A250 * f71_88; + RHS88 += f71_88 * RHS71; + const double f72 = 1.0 / m_A253; + const double f72_80 = -f72 * m_A314; + m_A315 += m_A254 * f72_80; + m_A316 += m_A255 * f72_80; + m_A317 += m_A256 * f72_80; + RHS80 += f72_80 * RHS72; + const double f72_84 = -f72 * m_A341; + m_A342 += m_A254 * f72_84; + m_A343 += m_A255 * f72_84; + m_A344 += m_A256 * f72_84; + RHS84 += f72_84 * RHS72; + const double f72_89 = -f72 * m_A377; + m_A382 += m_A254 * f72_89; + m_A384 += m_A255 * f72_89; + m_A388 += m_A256 * f72_89; + RHS89 += f72_89 * RHS72; + const double f73 = 1.0 / m_A259; + const double f73_87 = -f73 * m_A362; + m_A363 += m_A260 * f73_87; + m_A364 += m_A261 * f73_87; + RHS87 += f73_87 * RHS73; + const double f73_89 = -f73 * m_A378; + m_A386 += m_A260 * f73_89; + m_A388 += m_A261 * f73_89; + RHS89 += f73_89 * RHS73; + const double f74 = 1.0 / m_A264; + const double f74_77 = -f74 * m_A286; + m_A287 += m_A265 * f74_77; + m_A288 += m_A266 * f74_77; + RHS77 += f74_77 * RHS74; + const double f74_79 = -f74 * m_A303; + m_A304 += m_A265 * f74_79; + m_A305 += m_A266 * f74_79; + RHS79 += f74_79 * RHS74; + const double f75 = 1.0 / m_A270; + const double f75_89 = -f75 * m_A379; + m_A388 += m_A271 * f75_89; + m_A390 += m_A272 * f75_89; + RHS89 += f75_89 * RHS75; + const double f75_91 = -f75 * m_A407; + m_A409 += m_A271 * f75_91; + m_A411 += m_A272 * f75_91; + RHS91 += f75_91 * RHS75; + const double f76 = 1.0 / m_A280; + const double f76_83 = -f76 * m_A336; + m_A337 += m_A281 * f76_83; + m_A338 += m_A282 * f76_83; + RHS83 += f76_83 * RHS76; + const double f76_90 = -f76 * m_A396; + m_A398 += m_A281 * f76_90; + m_A401 += m_A282 * f76_90; + RHS90 += f76_90 * RHS76; + const double f77 = 1.0 / m_A287; + const double f77_79 = -f77 * m_A304; + m_A305 += m_A288 * f77_79; + m_A307 += m_A289 * f77_79; + RHS79 += f77_79 * RHS77; + const double f77_89 = -f77 * m_A380; + m_A381 += m_A288 * f77_89; + m_A388 += m_A289 * f77_89; + RHS89 += f77_89 * RHS77; + const double f78 = 1.0 / m_A296; + const double f78_88 = -f78 * m_A369; + m_A370 += m_A297 * f78_88; + m_A372 += m_A298 * f78_88; + RHS88 += f78_88 * RHS78; + const double f78_90 = -f78 * m_A397; + m_A399 += m_A297 * f78_90; + m_A401 += m_A298 * f78_90; + RHS90 += f78_90 * RHS78; + const double f79 = 1.0 / m_A305; + const double f79_82 = -f79 * m_A329; + m_A330 += m_A306 * f79_82; + m_A331 += m_A307 * f79_82; + RHS82 += f79_82 * RHS79; + const double f79_89 = -f79 * m_A381; + m_A383 += m_A306 * f79_89; + m_A388 += m_A307 * f79_89; + RHS89 += f79_89 * RHS79; + const double f80 = 1.0 / m_A315; + const double f80_84 = -f80 * m_A342; + m_A343 += m_A316 * f80_84; + m_A344 += m_A317 * f80_84; + RHS84 += f80_84 * RHS80; + const double f80_89 = -f80 * m_A382; + m_A384 += m_A316 * f80_89; + m_A388 += m_A317 * f80_89; + RHS89 += f80_89 * RHS80; + const double f81 = 1.0 / m_A322; + const double f81_92 = -f81 * m_A416; + m_A421 += m_A323 * f81_92; + RHS92 += f81_92 * RHS81; + const double f82 = 1.0 / m_A330; + const double f82_89 = -f82 * m_A383; + m_A388 += m_A331 * f82_89; + RHS89 += f82_89 * RHS82; + const double f83 = 1.0 / m_A337; + const double f83_90 = -f83 * m_A398; + m_A401 += m_A338 * f83_90; + RHS90 += f83_90 * RHS83; + const double f84 = 1.0 / m_A343; + const double f84_89 = -f84 * m_A384; + m_A388 += m_A344 * f84_89; + RHS89 += f84_89 * RHS84; + const double f85 = 1.0 / m_A349; + const double f85_91 = -f85 * m_A408; + m_A411 += m_A350 * f85_91; + RHS91 += f85_91 * RHS85; + const double f86 = 1.0 / m_A354; + const double f86_89 = -f86 * m_A385; + m_A388 += m_A355 * f86_89; + m_A391 += m_A356 * f86_89; + RHS89 += f86_89 * RHS86; + const double f86_92 = -f86 * m_A417; + m_A418 += m_A355 * f86_92; + m_A421 += m_A356 * f86_92; + RHS92 += f86_92 * RHS86; + const double f87 = 1.0 / m_A363; + const double f87_89 = -f87 * m_A386; + m_A388 += m_A364 * f87_89; + RHS89 += f87_89 * RHS87; + const double f88 = 1.0 / m_A370; + const double f88_89 = -f88 * m_A387; + m_A388 += m_A371 * f88_89; + m_A389 += m_A372 * f88_89; + RHS89 += f88_89 * RHS88; + const double f88_90 = -f88 * m_A399; + m_A400 += m_A371 * f88_90; + m_A401 += m_A372 * f88_90; + RHS90 += f88_90 * RHS88; + const double f89 = 1.0 / m_A388; + const double f89_90 = -f89 * m_A400; + m_A401 += m_A389 * f89_90; + m_A402 += m_A390 * f89_90; + m_A403 += m_A391 * f89_90; + RHS90 += f89_90 * RHS89; + const double f89_91 = -f89 * m_A409; + m_A410 += m_A389 * f89_91; + m_A411 += m_A390 * f89_91; + m_A412 += m_A391 * f89_91; + RHS91 += f89_91 * RHS89; + const double f89_92 = -f89 * m_A418; + m_A419 += m_A389 * f89_92; + m_A420 += m_A390 * f89_92; + m_A421 += m_A391 * f89_92; + RHS92 += f89_92 * RHS89; + const double f90 = 1.0 / m_A401; + const double f90_91 = -f90 * m_A410; + m_A411 += m_A402 * f90_91; + m_A412 += m_A403 * f90_91; + RHS91 += f90_91 * RHS90; + const double f90_92 = -f90 * m_A419; + m_A420 += m_A402 * f90_92; + m_A421 += m_A403 * f90_92; + RHS92 += f90_92 * RHS90; + const double f91 = 1.0 / m_A411; + const double f91_92 = -f91 * m_A420; + m_A421 += m_A412 * f91_92; + RHS92 += f91_92 * RHS91; + V[92] = RHS92 / m_A421; + double tmp91 = 0.0; + tmp91 += m_A412 * V[92]; + V[91] = (RHS91 - tmp91) / m_A411; + double tmp90 = 0.0; + tmp90 += m_A402 * V[91]; + tmp90 += m_A403 * V[92]; + V[90] = (RHS90 - tmp90) / m_A401; + double tmp89 = 0.0; + tmp89 += m_A389 * V[90]; + tmp89 += m_A390 * V[91]; + tmp89 += m_A391 * V[92]; + V[89] = (RHS89 - tmp89) / m_A388; + double tmp88 = 0.0; + tmp88 += m_A371 * V[89]; + tmp88 += m_A372 * V[90]; + V[88] = (RHS88 - tmp88) / m_A370; + double tmp87 = 0.0; + tmp87 += m_A364 * V[89]; + V[87] = (RHS87 - tmp87) / m_A363; + double tmp86 = 0.0; + tmp86 += m_A355 * V[89]; + tmp86 += m_A356 * V[92]; + V[86] = (RHS86 - tmp86) / m_A354; + double tmp85 = 0.0; + tmp85 += m_A350 * V[91]; + V[85] = (RHS85 - tmp85) / m_A349; + double tmp84 = 0.0; + tmp84 += m_A344 * V[89]; + V[84] = (RHS84 - tmp84) / m_A343; + double tmp83 = 0.0; + tmp83 += m_A338 * V[90]; + V[83] = (RHS83 - tmp83) / m_A337; + double tmp82 = 0.0; + tmp82 += m_A331 * V[89]; + V[82] = (RHS82 - tmp82) / m_A330; + double tmp81 = 0.0; + tmp81 += m_A323 * V[92]; + V[81] = (RHS81 - tmp81) / m_A322; + double tmp80 = 0.0; + tmp80 += m_A316 * V[84]; + tmp80 += m_A317 * V[89]; + V[80] = (RHS80 - tmp80) / m_A315; + double tmp79 = 0.0; + tmp79 += m_A306 * V[82]; + tmp79 += m_A307 * V[89]; + V[79] = (RHS79 - tmp79) / m_A305; + double tmp78 = 0.0; + tmp78 += m_A297 * V[88]; + tmp78 += m_A298 * V[90]; + V[78] = (RHS78 - tmp78) / m_A296; + double tmp77 = 0.0; + tmp77 += m_A288 * V[79]; + tmp77 += m_A289 * V[89]; + V[77] = (RHS77 - tmp77) / m_A287; + double tmp76 = 0.0; + tmp76 += m_A281 * V[83]; + tmp76 += m_A282 * V[90]; + V[76] = (RHS76 - tmp76) / m_A280; + double tmp75 = 0.0; + tmp75 += m_A271 * V[89]; + tmp75 += m_A272 * V[91]; + V[75] = (RHS75 - tmp75) / m_A270; + double tmp74 = 0.0; + tmp74 += m_A265 * V[77]; + tmp74 += m_A266 * V[79]; + V[74] = (RHS74 - tmp74) / m_A264; + double tmp73 = 0.0; + tmp73 += m_A260 * V[87]; + tmp73 += m_A261 * V[89]; + V[73] = (RHS73 - tmp73) / m_A259; + double tmp72 = 0.0; + tmp72 += m_A254 * V[80]; + tmp72 += m_A255 * V[84]; + tmp72 += m_A256 * V[89]; + V[72] = (RHS72 - tmp72) / m_A253; + double tmp71 = 0.0; + tmp71 += m_A249 * V[78]; + tmp71 += m_A250 * V[88]; + V[71] = (RHS71 - tmp71) / m_A248; + double tmp70 = 0.0; + tmp70 += m_A245 * V[73]; + tmp70 += m_A246 * V[87]; + V[70] = (RHS70 - tmp70) / m_A244; + double tmp69 = 0.0; + tmp69 += m_A239 * V[72]; + tmp69 += m_A240 * V[80]; + tmp69 += m_A241 * V[84]; + V[69] = (RHS69 - tmp69) / m_A238; + double tmp68 = 0.0; + tmp68 += m_A235 * V[79]; + V[68] = (RHS68 - tmp68) / m_A234; + double tmp67 = 0.0; + tmp67 += m_A230 * V[82]; + V[67] = (RHS67 - tmp67) / m_A229; + double tmp66 = 0.0; + tmp66 += m_A225 * V[81]; + tmp66 += m_A226 * V[92]; + V[66] = (RHS66 - tmp66) / m_A224; + double tmp65 = 0.0; + tmp65 += m_A222 * V[80]; + V[65] = (RHS65 - tmp65) / m_A221; + double tmp64 = 0.0; + tmp64 += m_A219 * V[80]; + V[64] = (RHS64 - tmp64) / m_A218; + double tmp63 = 0.0; + tmp63 += m_A213 * V[67]; + tmp63 += m_A214 * V[82]; + V[63] = (RHS63 - tmp63) / m_A212; + double tmp62 = 0.0; + tmp62 += m_A209 * V[79]; + tmp62 += m_A210 * V[82]; + V[62] = (RHS62 - tmp62) / m_A208; + double tmp61 = 0.0; + tmp61 += m_A206 * V[80]; + V[61] = (RHS61 - tmp61) / m_A205; + double tmp60 = 0.0; + tmp60 += m_A201 * V[85]; + tmp60 += m_A202 * V[91]; + V[60] = (RHS60 - tmp60) / m_A200; + double tmp59 = 0.0; + tmp59 += m_A196 * V[60]; + tmp59 += m_A197 * V[85]; + V[59] = (RHS59 - tmp59) / m_A195; + double tmp58 = 0.0; + tmp58 += m_A193 * V[68]; + V[58] = (RHS58 - tmp58) / m_A192; + double tmp57 = 0.0; + tmp57 += m_A188 * V[58]; + V[57] = (RHS57 - tmp57) / m_A187; + double tmp56 = 0.0; + tmp56 += m_A184 * V[87]; + V[56] = (RHS56 - tmp56) / m_A183; + double tmp55 = 0.0; + tmp55 += m_A180 * V[64]; + V[55] = (RHS55 - tmp55) / m_A179; + double tmp54 = 0.0; + tmp54 += m_A175 * V[78]; + tmp54 += m_A176 * V[90]; + V[54] = (RHS54 - tmp54) / m_A174; + double tmp53 = 0.0; + tmp53 += m_A170 * V[54]; + tmp53 += m_A171 * V[90]; + V[53] = (RHS53 - tmp53) / m_A169; + double tmp52 = 0.0; + tmp52 += m_A164 * V[56]; + tmp52 += m_A165 * V[87]; + V[52] = (RHS52 - tmp52) / m_A163; + double tmp51 = 0.0; + tmp51 += m_A160 * V[53]; + V[51] = (RHS51 - tmp51) / m_A159; + double tmp50 = 0.0; + tmp50 += m_A156 * V[76]; + tmp50 += m_A157 * V[83]; + V[50] = (RHS50 - tmp50) / m_A155; + double tmp49 = 0.0; + tmp49 += m_A151 * V[77]; + tmp49 += m_A152 * V[89]; + V[49] = (RHS49 - tmp49) / m_A150; + double tmp48 = 0.0; + tmp48 += m_A147 * V[50]; + tmp48 += m_A148 * V[76]; + tmp48 += m_A149 * V[83]; + V[48] = (RHS48 - tmp48) / m_A146; + double tmp47 = 0.0; + tmp47 += m_A139 * V[48]; + tmp47 += m_A140 * V[76]; + V[47] = (RHS47 - tmp47) / m_A138; + double tmp46 = 0.0; + tmp46 += m_A133 * V[47]; + tmp46 += m_A134 * V[48]; + tmp46 += m_A135 * V[76]; + V[46] = (RHS46 - tmp46) / m_A132; + double tmp45 = 0.0; + tmp45 += m_A128 * V[88]; + tmp45 += m_A129 * V[89]; + V[45] = (RHS45 - tmp45) / m_A127; + double tmp44 = 0.0; + tmp44 += m_A125 * V[74]; + tmp44 += m_A126 * V[77]; + V[44] = (RHS44 - tmp44) / m_A124; + double tmp43 = 0.0; + tmp43 += m_A122 * V[75]; + tmp43 += m_A123 * V[89]; + V[43] = (RHS43 - tmp43) / m_A121; + double tmp42 = 0.0; + tmp42 += m_A119 * V[86]; + tmp42 += m_A120 * V[89]; + V[42] = (RHS42 - tmp42) / m_A118; + double tmp41 = 0.0; + tmp41 += m_A116 * V[70]; + tmp41 += m_A117 * V[73]; + V[41] = (RHS41 - tmp41) / m_A115; + double tmp40 = 0.0; + tmp40 += m_A112 * V[69]; + tmp40 += m_A113 * V[72]; + tmp40 += m_A114 * V[84]; + V[40] = (RHS40 - tmp40) / m_A111; + double tmp39 = 0.0; + tmp39 += m_A110 * V[44]; + V[39] = (RHS39 - tmp39) / m_A109; + double tmp38 = 0.0; + tmp38 += m_A107 * V[86]; + tmp38 += m_A108 * V[92]; + V[38] = (RHS38 - tmp38) / m_A106; + double tmp37 = 0.0; + tmp37 += m_A104 * V[74]; + tmp37 += m_A105 * V[79]; + V[37] = (RHS37 - tmp37) / m_A103; + double tmp36 = 0.0; + tmp36 += m_A101 * V[69]; + tmp36 += m_A102 * V[80]; + V[36] = (RHS36 - tmp36) / m_A100; + double tmp35 = 0.0; + tmp35 += m_A98 * V[68]; + tmp35 += m_A99 * V[79]; + V[35] = (RHS35 - tmp35) / m_A97; + double tmp34 = 0.0; + tmp34 += m_A95 * V[61]; + tmp34 += m_A96 * V[80]; + V[34] = (RHS34 - tmp34) / m_A94; + double tmp33 = 0.0; + tmp33 += m_A92 * V[62]; + tmp33 += m_A93 * V[82]; + V[33] = (RHS33 - tmp33) / m_A91; + double tmp32 = 0.0; + tmp32 += m_A90 * V[38]; + V[32] = (RHS32 - tmp32) / m_A89; + double tmp31 = 0.0; + tmp31 += m_A87 * V[81]; + tmp31 += m_A88 * V[92]; + V[31] = (RHS31 - tmp31) / m_A86; + double tmp30 = 0.0; + tmp30 += m_A84 * V[58]; + tmp30 += m_A85 * V[68]; + V[30] = (RHS30 - tmp30) / m_A83; + double tmp29 = 0.0; + tmp29 += m_A81 * V[67]; + tmp29 += m_A82 * V[82]; + V[29] = (RHS29 - tmp29) / m_A80; + double tmp28 = 0.0; + tmp28 += m_A78 * V[75]; + tmp28 += m_A79 * V[91]; + V[28] = (RHS28 - tmp28) / m_A77; + double tmp27 = 0.0; + tmp27 += m_A76 * V[67]; + V[27] = (RHS27 - tmp27) / m_A75; + double tmp26 = 0.0; + tmp26 += m_A73 * V[57]; + tmp26 += m_A74 * V[58]; + V[26] = (RHS26 - tmp26) / m_A72; + double tmp25 = 0.0; + tmp25 += m_A71 * V[65]; + V[25] = (RHS25 - tmp25) / m_A70; + double tmp24 = 0.0; + tmp24 += m_A69 * V[64]; + V[24] = (RHS24 - tmp24) / m_A68; + double tmp23 = 0.0; + tmp23 += m_A66 * V[55]; + tmp23 += m_A67 * V[64]; + V[23] = (RHS23 - tmp23) / m_A65; + double tmp22 = 0.0; + tmp22 += m_A64 * V[57]; + V[22] = (RHS22 - tmp22) / m_A63; + double tmp21 = 0.0; + tmp21 += m_A62 * V[61]; + V[21] = (RHS21 - tmp21) / m_A61; + double tmp20 = 0.0; + tmp20 += m_A59 * V[66]; + tmp20 += m_A60 * V[81]; + V[20] = (RHS20 - tmp20) / m_A58; + double tmp19 = 0.0; + tmp19 += m_A57 * V[81]; + V[19] = (RHS19 - tmp19) / m_A56; + double tmp18 = 0.0; + tmp18 += m_A54 * V[70]; + tmp18 += m_A55 * V[87]; + V[18] = (RHS18 - tmp18) / m_A53; + double tmp17 = 0.0; + tmp17 += m_A52 * V[28]; + V[17] = (RHS17 - tmp17) / m_A51; + double tmp16 = 0.0; + tmp16 += m_A49 * V[85]; + tmp16 += m_A50 * V[91]; + V[16] = (RHS16 - tmp16) / m_A48; + double tmp15 = 0.0; + tmp15 += m_A47 * V[55]; + V[15] = (RHS15 - tmp15) / m_A46; + double tmp14 = 0.0; + tmp14 += m_A45 * V[85]; + V[14] = (RHS14 - tmp14) / m_A44; + double tmp13 = 0.0; + tmp13 += m_A41 * V[71]; + tmp13 += m_A42 * V[78]; + tmp13 += m_A43 * V[88]; + V[13] = (RHS13 - tmp13) / m_A40; + double tmp12 = 0.0; + tmp12 += m_A38 * V[59]; + tmp12 += m_A39 * V[60]; + V[12] = (RHS12 - tmp12) / m_A37; + double tmp11 = 0.0; + tmp11 += m_A34 * V[52]; + tmp11 += m_A35 * V[56]; + tmp11 += m_A36 * V[87]; + V[11] = (RHS11 - tmp11) / m_A33; + double tmp10 = 0.0; + tmp10 += m_A32 * V[71]; + V[10] = (RHS10 - tmp10) / m_A31; + double tmp9 = 0.0; + tmp9 += m_A30 * V[52]; + V[9] = (RHS9 - tmp9) / m_A29; + double tmp8 = 0.0; + tmp8 += m_A26 * V[53]; + tmp8 += m_A27 * V[54]; + tmp8 += m_A28 * V[90]; + V[8] = (RHS8 - tmp8) / m_A25; + double tmp7 = 0.0; + tmp7 += m_A23 * V[8]; + tmp7 += m_A24 * V[54]; + V[7] = (RHS7 - tmp7) / m_A22; + double tmp6 = 0.0; + tmp6 += m_A20 * V[51]; + tmp6 += m_A21 * V[53]; + V[6] = (RHS6 - tmp6) / m_A19; + double tmp5 = 0.0; + tmp5 += m_A16 * V[76]; + tmp5 += m_A17 * V[83]; + tmp5 += m_A18 * V[90]; + V[5] = (RHS5 - tmp5) / m_A15; + double tmp4 = 0.0; + tmp4 += m_A12 * V[48]; + tmp4 += m_A13 * V[50]; + tmp4 += m_A14 * V[83]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A8 * V[46]; + tmp3 += m_A9 * V[47]; + tmp3 += m_A10 * V[76]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A6 * V[47]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A4 * V[48]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[46]; + tmp0 += m_A2 * V[48]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// frogs +static void nl_gcr_84425fea9033e75d_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_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A5 += go[7]; + m_A5 += go[8]; + m_A4 += go[9]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[10] * *cnV[10]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + 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; +} + // sundance static void nl_gcr_8446e63d7842f6a6_70_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -77713,423 +80573,429 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { #if !defined(__EMSCRIPTEN__) // elim - {"nl_gcr_11c2ae166b240b6e_10_double_double", reinterpret_cast(&nl_gcr_11c2ae166b240b6e_10_double_double)}, // NOLINT + {"nl_gcr_11c2ae166b240b6e_10_double_double", reinterpret_cast(&nl_gcr_11c2ae166b240b6e_10_double_double)}, // tankbatt - {"nl_gcr_124f7aa10f044582_16_double_double", reinterpret_cast(&nl_gcr_124f7aa10f044582_16_double_double)}, // NOLINT + {"nl_gcr_124f7aa10f044582_16_double_double", reinterpret_cast(&nl_gcr_124f7aa10f044582_16_double_double)}, // armora - {"nl_gcr_1250f340dea396ae_22_double_double", reinterpret_cast(&nl_gcr_1250f340dea396ae_22_double_double)}, // NOLINT + {"nl_gcr_1250f340dea396ae_22_double_double", reinterpret_cast(&nl_gcr_1250f340dea396ae_22_double_double)}, // astrob - {"nl_gcr_13833bf8c127deaa_154_double_double", reinterpret_cast(&nl_gcr_13833bf8c127deaa_154_double_double)}, // NOLINT + {"nl_gcr_13833bf8c127deaa_154_double_double", reinterpret_cast(&nl_gcr_13833bf8c127deaa_154_double_double)}, // pongf - {"nl_gcr_13e7b5ac1a260dbf_10_double_double", reinterpret_cast(&nl_gcr_13e7b5ac1a260dbf_10_double_double)}, // NOLINT + {"nl_gcr_13e7b5ac1a260dbf_10_double_double", reinterpret_cast(&nl_gcr_13e7b5ac1a260dbf_10_double_double)}, // tailg - {"nl_gcr_144ed14e6bafdb_119_double_double", reinterpret_cast(&nl_gcr_144ed14e6bafdb_119_double_double)}, // NOLINT + {"nl_gcr_144ed14e6bafdb_119_double_double", reinterpret_cast(&nl_gcr_144ed14e6bafdb_119_double_double)}, // spacewar - {"nl_gcr_15e8f6fb021de0f9_28_double_double", reinterpret_cast(&nl_gcr_15e8f6fb021de0f9_28_double_double)}, // NOLINT + {"nl_gcr_15e8f6fb021de0f9_28_double_double", reinterpret_cast(&nl_gcr_15e8f6fb021de0f9_28_double_double)}, // dpatrol - {"nl_gcr_18f4d9160b51d613_20_double_double", reinterpret_cast(&nl_gcr_18f4d9160b51d613_20_double_double)}, // NOLINT + {"nl_gcr_18f4d9160b51d613_20_double_double", reinterpret_cast(&nl_gcr_18f4d9160b51d613_20_double_double)}, // starhawk - {"nl_gcr_1f1086787c94f97c_40_double_double", reinterpret_cast(&nl_gcr_1f1086787c94f97c_40_double_double)}, // NOLINT + {"nl_gcr_1f1086787c94f97c_40_double_double", reinterpret_cast(&nl_gcr_1f1086787c94f97c_40_double_double)}, // zac1b11142 - {"nl_gcr_1fad5cda2646cf42_30_double_double", reinterpret_cast(&nl_gcr_1fad5cda2646cf42_30_double_double)}, // NOLINT + {"nl_gcr_1fad5cda2646cf42_30_double_double", reinterpret_cast(&nl_gcr_1fad5cda2646cf42_30_double_double)}, // sspeedr - {"nl_gcr_2294220d3c91e762_176_double_double", reinterpret_cast(&nl_gcr_2294220d3c91e762_176_double_double)}, // NOLINT + {"nl_gcr_2294220d3c91e762_176_double_double", reinterpret_cast(&nl_gcr_2294220d3c91e762_176_double_double)}, // 280zzzap - {"nl_gcr_24643c159711f292_95_double_double", reinterpret_cast(&nl_gcr_24643c159711f292_95_double_double)}, // NOLINT + {"nl_gcr_24643c159711f292_95_double_double", reinterpret_cast(&nl_gcr_24643c159711f292_95_double_double)}, // brdrline - {"nl_gcr_2753fc1815ce0cba_23_double_double", reinterpret_cast(&nl_gcr_2753fc1815ce0cba_23_double_double)}, // NOLINT + {"nl_gcr_2753fc1815ce0cba_23_double_double", reinterpret_cast(&nl_gcr_2753fc1815ce0cba_23_double_double)}, // zac1b11142 - {"nl_gcr_287a160e7c36b5b0_96_double_double", reinterpret_cast(&nl_gcr_287a160e7c36b5b0_96_double_double)}, // NOLINT + {"nl_gcr_287a160e7c36b5b0_96_double_double", reinterpret_cast(&nl_gcr_287a160e7c36b5b0_96_double_double)}, // elim - {"nl_gcr_28b736fe552777a9_45_double_double", reinterpret_cast(&nl_gcr_28b736fe552777a9_45_double_double)}, // NOLINT + {"nl_gcr_28b736fe552777a9_45_double_double", reinterpret_cast(&nl_gcr_28b736fe552777a9_45_double_double)}, // kidniki - {"nl_gcr_294dde1e0ecca6d0_37_double_double", reinterpret_cast(&nl_gcr_294dde1e0ecca6d0_37_double_double)}, // NOLINT + {"nl_gcr_294dde1e0ecca6d0_37_double_double", reinterpret_cast(&nl_gcr_294dde1e0ecca6d0_37_double_double)}, // ripoff - {"nl_gcr_295cf2e2f3d489bf_12_double_double", reinterpret_cast(&nl_gcr_295cf2e2f3d489bf_12_double_double)}, // NOLINT + {"nl_gcr_295cf2e2f3d489bf_12_double_double", reinterpret_cast(&nl_gcr_295cf2e2f3d489bf_12_double_double)}, // spacfury - {"nl_gcr_2a153513d3e8e2cc_53_double_double", reinterpret_cast(&nl_gcr_2a153513d3e8e2cc_53_double_double)}, // NOLINT + {"nl_gcr_2a153513d3e8e2cc_53_double_double", reinterpret_cast(&nl_gcr_2a153513d3e8e2cc_53_double_double)}, // boxingb - {"nl_gcr_2f84bc98d737730b_22_double_double", reinterpret_cast(&nl_gcr_2f84bc98d737730b_22_double_double)}, // NOLINT + {"nl_gcr_2f84bc98d737730b_22_double_double", reinterpret_cast(&nl_gcr_2f84bc98d737730b_22_double_double)}, // brdrline - {"nl_gcr_30923b54310ae144_8_double_double", reinterpret_cast(&nl_gcr_30923b54310ae144_8_double_double)}, // NOLINT + {"nl_gcr_30923b54310ae144_8_double_double", reinterpret_cast(&nl_gcr_30923b54310ae144_8_double_double)}, // tankbatt - {"nl_gcr_328d886b444b586b_137_double_double", reinterpret_cast(&nl_gcr_328d886b444b586b_137_double_double)}, // NOLINT + {"nl_gcr_328d886b444b586b_137_double_double", reinterpret_cast(&nl_gcr_328d886b444b586b_137_double_double)}, // astrob - {"nl_gcr_339c6b457f339538_159_double_double", reinterpret_cast(&nl_gcr_339c6b457f339538_159_double_double)}, // NOLINT + {"nl_gcr_339c6b457f339538_159_double_double", reinterpret_cast(&nl_gcr_339c6b457f339538_159_double_double)}, // solarq - {"nl_gcr_34e910fc1896999f_76_double_double", reinterpret_cast(&nl_gcr_34e910fc1896999f_76_double_double)}, // NOLINT + {"nl_gcr_34e910fc1896999f_76_double_double", reinterpret_cast(&nl_gcr_34e910fc1896999f_76_double_double)}, // brdrline - {"nl_gcr_3c79fd354e01fa8c_89_double_double", reinterpret_cast(&nl_gcr_3c79fd354e01fa8c_89_double_double)}, // NOLINT + {"nl_gcr_3c79fd354e01fa8c_89_double_double", reinterpret_cast(&nl_gcr_3c79fd354e01fa8c_89_double_double)}, // sspeedr - {"nl_gcr_3e833834e5ce5aee_13_double_double", reinterpret_cast(&nl_gcr_3e833834e5ce5aee_13_double_double)}, // NOLINT + {"nl_gcr_3e833834e5ce5aee_13_double_double", reinterpret_cast(&nl_gcr_3e833834e5ce5aee_13_double_double)}, // astrob - {"nl_gcr_41c6441d98369158_20_double_double", reinterpret_cast(&nl_gcr_41c6441d98369158_20_double_double)}, // NOLINT + {"nl_gcr_41c6441d98369158_20_double_double", reinterpret_cast(&nl_gcr_41c6441d98369158_20_double_double)}, // warrior - {"nl_gcr_42a31ce5c187b308_12_double_double", reinterpret_cast(&nl_gcr_42a31ce5c187b308_12_double_double)}, // NOLINT + {"nl_gcr_42a31ce5c187b308_12_double_double", reinterpret_cast(&nl_gcr_42a31ce5c187b308_12_double_double)}, // 280zzzap - {"nl_gcr_42c57d523cac30d0_122_double_double", reinterpret_cast(&nl_gcr_42c57d523cac30d0_122_double_double)}, // NOLINT + {"nl_gcr_42c57d523cac30d0_122_double_double", reinterpret_cast(&nl_gcr_42c57d523cac30d0_122_double_double)}, // ripoff - {"nl_gcr_43188bf576854ae0_10_double_double", reinterpret_cast(&nl_gcr_43188bf576854ae0_10_double_double)}, // NOLINT + {"nl_gcr_43188bf576854ae0_10_double_double", reinterpret_cast(&nl_gcr_43188bf576854ae0_10_double_double)}, // destroyr - {"nl_gcr_4334c95878d1be92_399_double_double", reinterpret_cast(&nl_gcr_4334c95878d1be92_399_double_double)}, // NOLINT + {"nl_gcr_4334c95878d1be92_399_double_double", reinterpret_cast(&nl_gcr_4334c95878d1be92_399_double_double)}, // brdrline - {"nl_gcr_437326911721091_77_double_double", reinterpret_cast(&nl_gcr_437326911721091_77_double_double)}, // NOLINT + {"nl_gcr_437326911721091_77_double_double", reinterpret_cast(&nl_gcr_437326911721091_77_double_double)}, // kidniki - {"nl_gcr_43f7ff9bc651cc7a_198_double_double", reinterpret_cast(&nl_gcr_43f7ff9bc651cc7a_198_double_double)}, // NOLINT + {"nl_gcr_43f7ff9bc651cc7a_198_double_double", reinterpret_cast(&nl_gcr_43f7ff9bc651cc7a_198_double_double)}, // gamemachine - {"nl_gcr_491f95430bfdfd05_19_double_double", reinterpret_cast(&nl_gcr_491f95430bfdfd05_19_double_double)}, // NOLINT + {"nl_gcr_491f95430bfdfd05_19_double_double", reinterpret_cast(&nl_gcr_491f95430bfdfd05_19_double_double)}, // sspeedr - {"nl_gcr_4a8e2b707bbac8a6_95_double_double", reinterpret_cast(&nl_gcr_4a8e2b707bbac8a6_95_double_double)}, // NOLINT + {"nl_gcr_4a8e2b707bbac8a6_95_double_double", reinterpret_cast(&nl_gcr_4a8e2b707bbac8a6_95_double_double)}, // ripoff - {"nl_gcr_4b5ecfbb8f9fa97b_29_double_double", reinterpret_cast(&nl_gcr_4b5ecfbb8f9fa97b_29_double_double)}, // NOLINT + {"nl_gcr_4b5ecfbb8f9fa97b_29_double_double", reinterpret_cast(&nl_gcr_4b5ecfbb8f9fa97b_29_double_double)}, // gtrak10 - {"nl_gcr_4c46fdf7c0037727_43_double_double", reinterpret_cast(&nl_gcr_4c46fdf7c0037727_43_double_double)}, // NOLINT + {"nl_gcr_4c46fdf7c0037727_43_double_double", reinterpret_cast(&nl_gcr_4c46fdf7c0037727_43_double_double)}, // solarq - {"nl_gcr_4cb524006206eb1a_25_double_double", reinterpret_cast(&nl_gcr_4cb524006206eb1a_25_double_double)}, // NOLINT + {"nl_gcr_4cb524006206eb1a_25_double_double", reinterpret_cast(&nl_gcr_4cb524006206eb1a_25_double_double)}, // spacfury - {"nl_gcr_4dbd0f2aec7ef707_110_double_double", reinterpret_cast(&nl_gcr_4dbd0f2aec7ef707_110_double_double)}, // NOLINT + {"nl_gcr_4dbd0f2aec7ef707_110_double_double", reinterpret_cast(&nl_gcr_4dbd0f2aec7ef707_110_double_double)}, // solarq - {"nl_gcr_4e4931ccbfb7a3c_70_double_double", reinterpret_cast(&nl_gcr_4e4931ccbfb7a3c_70_double_double)}, // NOLINT + {"nl_gcr_4e4931ccbfb7a3c_70_double_double", reinterpret_cast(&nl_gcr_4e4931ccbfb7a3c_70_double_double)}, // fireone - {"nl_gcr_4f2b2f3cdc384f75_41_double_double", reinterpret_cast(&nl_gcr_4f2b2f3cdc384f75_41_double_double)}, // NOLINT + {"nl_gcr_4f2b2f3cdc384f75_41_double_double", reinterpret_cast(&nl_gcr_4f2b2f3cdc384f75_41_double_double)}, // boxingb - {"nl_gcr_50f5194a994d56ec_16_double_double", reinterpret_cast(&nl_gcr_50f5194a994d56ec_16_double_double)}, // NOLINT + {"nl_gcr_50f5194a994d56ec_16_double_double", reinterpret_cast(&nl_gcr_50f5194a994d56ec_16_double_double)}, // starhawk - {"nl_gcr_528a27fe9ed07d67_45_double_double", reinterpret_cast(&nl_gcr_528a27fe9ed07d67_45_double_double)}, // NOLINT + {"nl_gcr_528a27fe9ed07d67_45_double_double", reinterpret_cast(&nl_gcr_528a27fe9ed07d67_45_double_double)}, // astrob - {"nl_gcr_536c3652eb3bc075_46_double_double", reinterpret_cast(&nl_gcr_536c3652eb3bc075_46_double_double)}, // NOLINT + {"nl_gcr_536c3652eb3bc075_46_double_double", reinterpret_cast(&nl_gcr_536c3652eb3bc075_46_double_double)}, // boxingb - {"nl_gcr_53e1117fdb16f546_23_double_double", reinterpret_cast(&nl_gcr_53e1117fdb16f546_23_double_double)}, // NOLINT + {"nl_gcr_53e1117fdb16f546_23_double_double", reinterpret_cast(&nl_gcr_53e1117fdb16f546_23_double_double)}, // cheekyms - {"nl_gcr_546396f65ce48700_12_double_double", reinterpret_cast(&nl_gcr_546396f65ce48700_12_double_double)}, // NOLINT + {"nl_gcr_546396f65ce48700_12_double_double", reinterpret_cast(&nl_gcr_546396f65ce48700_12_double_double)}, // brdrline - {"nl_gcr_59cb6bf7cb9d17dc_7_double_double", reinterpret_cast(&nl_gcr_59cb6bf7cb9d17dc_7_double_double)}, // NOLINT + {"nl_gcr_59cb6bf7cb9d17dc_7_double_double", reinterpret_cast(&nl_gcr_59cb6bf7cb9d17dc_7_double_double)}, // breakout - {"nl_gcr_5a3419e2809520de_13_double_double", reinterpret_cast(&nl_gcr_5a3419e2809520de_13_double_double)}, // NOLINT + {"nl_gcr_5a3419e2809520de_13_double_double", reinterpret_cast(&nl_gcr_5a3419e2809520de_13_double_double)}, // segausb - {"nl_gcr_5b73834d5f313d38_12_double_double", reinterpret_cast(&nl_gcr_5b73834d5f313d38_12_double_double)}, // NOLINT + {"nl_gcr_5b73834d5f313d38_12_double_double", reinterpret_cast(&nl_gcr_5b73834d5f313d38_12_double_double)}, // tailg - {"nl_gcr_5ccf7da1202da2e5_31_double_double", reinterpret_cast(&nl_gcr_5ccf7da1202da2e5_31_double_double)}, // NOLINT + {"nl_gcr_5ccf7da1202da2e5_31_double_double", reinterpret_cast(&nl_gcr_5ccf7da1202da2e5_31_double_double)}, // starcas - {"nl_gcr_5d550fc7441617a2_109_double_double", reinterpret_cast(&nl_gcr_5d550fc7441617a2_109_double_double)}, // NOLINT + {"nl_gcr_5d550fc7441617a2_109_double_double", reinterpret_cast(&nl_gcr_5d550fc7441617a2_109_double_double)}, // zac1b11142 - {"nl_gcr_6041272373b8603c_178_double_double", reinterpret_cast(&nl_gcr_6041272373b8603c_178_double_double)}, // NOLINT + {"nl_gcr_6041272373b8603c_178_double_double", reinterpret_cast(&nl_gcr_6041272373b8603c_178_double_double)}, // astrob - {"nl_gcr_62464664b1c5aa1e_27_double_double", reinterpret_cast(&nl_gcr_62464664b1c5aa1e_27_double_double)}, // NOLINT + {"nl_gcr_62464664b1c5aa1e_27_double_double", reinterpret_cast(&nl_gcr_62464664b1c5aa1e_27_double_double)}, // solarq - {"nl_gcr_62612f71055b8fd4_303_double_double", reinterpret_cast(&nl_gcr_62612f71055b8fd4_303_double_double)}, // NOLINT + {"nl_gcr_62612f71055b8fd4_303_double_double", reinterpret_cast(&nl_gcr_62612f71055b8fd4_303_double_double)}, // konami1x - {"nl_gcr_62b99b9904a8c804_49_double_double", reinterpret_cast(&nl_gcr_62b99b9904a8c804_49_double_double)}, // NOLINT + {"nl_gcr_62b99b9904a8c804_49_double_double", reinterpret_cast(&nl_gcr_62b99b9904a8c804_49_double_double)}, // fireone - {"nl_gcr_643133e86b2b1628_73_double_double", reinterpret_cast(&nl_gcr_643133e86b2b1628_73_double_double)}, // NOLINT + {"nl_gcr_643133e86b2b1628_73_double_double", reinterpret_cast(&nl_gcr_643133e86b2b1628_73_double_double)}, // starfire - {"nl_gcr_649ebca7fa6793ed_27_double_double", reinterpret_cast(&nl_gcr_649ebca7fa6793ed_27_double_double)}, // NOLINT + {"nl_gcr_649ebca7fa6793ed_27_double_double", reinterpret_cast(&nl_gcr_649ebca7fa6793ed_27_double_double)}, // armora - {"nl_gcr_64e460d8f716cd89_58_double_double", reinterpret_cast(&nl_gcr_64e460d8f716cd89_58_double_double)}, // NOLINT + {"nl_gcr_64e460d8f716cd89_58_double_double", reinterpret_cast(&nl_gcr_64e460d8f716cd89_58_double_double)}, // flyball - {"nl_gcr_6622b53554e3776_291_double_double", reinterpret_cast(&nl_gcr_6622b53554e3776_291_double_double)}, // NOLINT + {"nl_gcr_6622b53554e3776_291_double_double", reinterpret_cast(&nl_gcr_6622b53554e3776_291_double_double)}, // solarq - {"nl_gcr_66496d6073aca98e_20_double_double", reinterpret_cast(&nl_gcr_66496d6073aca98e_20_double_double)}, // NOLINT + {"nl_gcr_66496d6073aca98e_20_double_double", reinterpret_cast(&nl_gcr_66496d6073aca98e_20_double_double)}, // starhawk - {"nl_gcr_67838e11f714c455_12_double_double", reinterpret_cast(&nl_gcr_67838e11f714c455_12_double_double)}, // NOLINT + {"nl_gcr_67838e11f714c455_12_double_double", reinterpret_cast(&nl_gcr_67838e11f714c455_12_double_double)}, // ripoff - {"nl_gcr_698d5dd47fb16d5_16_double_double", reinterpret_cast(&nl_gcr_698d5dd47fb16d5_16_double_double)}, // NOLINT + {"nl_gcr_698d5dd47fb16d5_16_double_double", reinterpret_cast(&nl_gcr_698d5dd47fb16d5_16_double_double)}, // astrob - {"nl_gcr_6c24726f30e8dc34_15_double_double", reinterpret_cast(&nl_gcr_6c24726f30e8dc34_15_double_double)}, // NOLINT + {"nl_gcr_6c24726f30e8dc34_15_double_double", reinterpret_cast(&nl_gcr_6c24726f30e8dc34_15_double_double)}, // spacfury - {"nl_gcr_6eae7b15cd376318_43_double_double", reinterpret_cast(&nl_gcr_6eae7b15cd376318_43_double_double)}, // NOLINT + {"nl_gcr_6eae7b15cd376318_43_double_double", reinterpret_cast(&nl_gcr_6eae7b15cd376318_43_double_double)}, // barrier - {"nl_gcr_6ef39a62161d596c_47_double_double", reinterpret_cast(&nl_gcr_6ef39a62161d596c_47_double_double)}, // NOLINT + {"nl_gcr_6ef39a62161d596c_47_double_double", reinterpret_cast(&nl_gcr_6ef39a62161d596c_47_double_double)}, // starhawk - {"nl_gcr_723fa454468a93d_7_double_double", reinterpret_cast(&nl_gcr_723fa454468a93d_7_double_double)}, // NOLINT + {"nl_gcr_723fa454468a93d_7_double_double", reinterpret_cast(&nl_gcr_723fa454468a93d_7_double_double)}, // cheekyms - {"nl_gcr_733c72a820fdbd1f_7_double_double", reinterpret_cast(&nl_gcr_733c72a820fdbd1f_7_double_double)}, // NOLINT + {"nl_gcr_733c72a820fdbd1f_7_double_double", reinterpret_cast(&nl_gcr_733c72a820fdbd1f_7_double_double)}, // tailg - {"nl_gcr_7388106355fb27c3_12_double_double", reinterpret_cast(&nl_gcr_7388106355fb27c3_12_double_double)}, // NOLINT + {"nl_gcr_7388106355fb27c3_12_double_double", reinterpret_cast(&nl_gcr_7388106355fb27c3_12_double_double)}, // tp1985 - {"nl_gcr_73f2ba8ad4a45b26_10_double_double", reinterpret_cast(&nl_gcr_73f2ba8ad4a45b26_10_double_double)}, // NOLINT + {"nl_gcr_73f2ba8ad4a45b26_10_double_double", reinterpret_cast(&nl_gcr_73f2ba8ad4a45b26_10_double_double)}, // zac1b11142 - {"nl_gcr_7425594cec8024ad_30_double_double", reinterpret_cast(&nl_gcr_7425594cec8024ad_30_double_double)}, // NOLINT + {"nl_gcr_7425594cec8024ad_30_double_double", reinterpret_cast(&nl_gcr_7425594cec8024ad_30_double_double)}, // tp1985 - {"nl_gcr_74349e9889a2630b_7_double_double", reinterpret_cast(&nl_gcr_74349e9889a2630b_7_double_double)}, // NOLINT + {"nl_gcr_74349e9889a2630b_7_double_double", reinterpret_cast(&nl_gcr_74349e9889a2630b_7_double_double)}, // gunfight - {"nl_gcr_743595e64cee0a5e_112_double_double", reinterpret_cast(&nl_gcr_743595e64cee0a5e_112_double_double)}, // NOLINT + {"nl_gcr_743595e64cee0a5e_112_double_double", reinterpret_cast(&nl_gcr_743595e64cee0a5e_112_double_double)}, // brdrline - {"nl_gcr_75400df5d559a266_75_double_double", reinterpret_cast(&nl_gcr_75400df5d559a266_75_double_double)}, // NOLINT + {"nl_gcr_75400df5d559a266_75_double_double", reinterpret_cast(&nl_gcr_75400df5d559a266_75_double_double)}, // ripoff - {"nl_gcr_76c9e236353caed1_35_double_double", reinterpret_cast(&nl_gcr_76c9e236353caed1_35_double_double)}, // NOLINT + {"nl_gcr_76c9e236353caed1_35_double_double", reinterpret_cast(&nl_gcr_76c9e236353caed1_35_double_double)}, // gamemachine - {"nl_gcr_782d79b5cbe953b1_7_double_double", reinterpret_cast(&nl_gcr_782d79b5cbe953b1_7_double_double)}, // NOLINT + {"nl_gcr_782d79b5cbe953b1_7_double_double", reinterpret_cast(&nl_gcr_782d79b5cbe953b1_7_double_double)}, // barrier - {"nl_gcr_79e756c5892cf87d_31_double_double", reinterpret_cast(&nl_gcr_79e756c5892cf87d_31_double_double)}, // NOLINT + {"nl_gcr_79e756c5892cf87d_31_double_double", reinterpret_cast(&nl_gcr_79e756c5892cf87d_31_double_double)}, // breakout - {"nl_gcr_7a42b97d838ca073_7_double_double", reinterpret_cast(&nl_gcr_7a42b97d838ca073_7_double_double)}, // NOLINT + {"nl_gcr_7a42b97d838ca073_7_double_double", reinterpret_cast(&nl_gcr_7a42b97d838ca073_7_double_double)}, // fireone - {"nl_gcr_7aee4423e3fdbfda_128_double_double", reinterpret_cast(&nl_gcr_7aee4423e3fdbfda_128_double_double)}, // NOLINT + {"nl_gcr_7aee4423e3fdbfda_128_double_double", reinterpret_cast(&nl_gcr_7aee4423e3fdbfda_128_double_double)}, // astrob - {"nl_gcr_7c86a9bc1c6aef4c_7_double_double", reinterpret_cast(&nl_gcr_7c86a9bc1c6aef4c_7_double_double)}, // NOLINT + {"nl_gcr_7c86a9bc1c6aef4c_7_double_double", reinterpret_cast(&nl_gcr_7c86a9bc1c6aef4c_7_double_double)}, // solarq - {"nl_gcr_7caaa135bff3d9f3_15_double_double", reinterpret_cast(&nl_gcr_7caaa135bff3d9f3_15_double_double)}, // NOLINT + {"nl_gcr_7caaa135bff3d9f3_15_double_double", reinterpret_cast(&nl_gcr_7caaa135bff3d9f3_15_double_double)}, // warrior - {"nl_gcr_8003d4625273fa4d_10_double_double", reinterpret_cast(&nl_gcr_8003d4625273fa4d_10_double_double)}, // NOLINT + {"nl_gcr_8003d4625273fa4d_10_double_double", reinterpret_cast(&nl_gcr_8003d4625273fa4d_10_double_double)}, // kidniki - {"nl_gcr_8046625a0fe0959_21_double_double", reinterpret_cast(&nl_gcr_8046625a0fe0959_21_double_double)}, // NOLINT + {"nl_gcr_8046625a0fe0959_21_double_double", reinterpret_cast(&nl_gcr_8046625a0fe0959_21_double_double)}, // mario - {"nl_gcr_80b4b1e5cc58d303_29_double_double", reinterpret_cast(&nl_gcr_80b4b1e5cc58d303_29_double_double)}, // NOLINT + {"nl_gcr_80b4b1e5cc58d303_29_double_double", reinterpret_cast(&nl_gcr_80b4b1e5cc58d303_29_double_double)}, +// frogs + {"nl_gcr_815733e3f2e05029_9_double_double", reinterpret_cast(&nl_gcr_815733e3f2e05029_9_double_double)}, // elim - {"nl_gcr_81f40a54af2ca202_10_double_double", reinterpret_cast(&nl_gcr_81f40a54af2ca202_10_double_double)}, // NOLINT + {"nl_gcr_81f40a54af2ca202_10_double_double", reinterpret_cast(&nl_gcr_81f40a54af2ca202_10_double_double)}, +// frogs + {"nl_gcr_8213b1839349be25_422_double_double", reinterpret_cast(&nl_gcr_8213b1839349be25_422_double_double)}, +// frogs + {"nl_gcr_84425fea9033e75d_7_double_double", reinterpret_cast(&nl_gcr_84425fea9033e75d_7_double_double)}, // sundance - {"nl_gcr_8446e63d7842f6a6_70_double_double", reinterpret_cast(&nl_gcr_8446e63d7842f6a6_70_double_double)}, // NOLINT + {"nl_gcr_8446e63d7842f6a6_70_double_double", reinterpret_cast(&nl_gcr_8446e63d7842f6a6_70_double_double)}, // dpatrol - {"nl_gcr_85652d3e3ada285a_10_double_double", reinterpret_cast(&nl_gcr_85652d3e3ada285a_10_double_double)}, // NOLINT + {"nl_gcr_85652d3e3ada285a_10_double_double", reinterpret_cast(&nl_gcr_85652d3e3ada285a_10_double_double)}, // zac1b11142 - {"nl_gcr_861d39f81d29d51_12_double_double", reinterpret_cast(&nl_gcr_861d39f81d29d51_12_double_double)}, // NOLINT + {"nl_gcr_861d39f81d29d51_12_double_double", reinterpret_cast(&nl_gcr_861d39f81d29d51_12_double_double)}, // 280zzzap - {"nl_gcr_864a61c57bac9c38_123_double_double", reinterpret_cast(&nl_gcr_864a61c57bac9c38_123_double_double)}, // NOLINT + {"nl_gcr_864a61c57bac9c38_123_double_double", reinterpret_cast(&nl_gcr_864a61c57bac9c38_123_double_double)}, // zac1b11142 - {"nl_gcr_87cb2c78a2628efd_7_double_double", reinterpret_cast(&nl_gcr_87cb2c78a2628efd_7_double_double)}, // NOLINT + {"nl_gcr_87cb2c78a2628efd_7_double_double", reinterpret_cast(&nl_gcr_87cb2c78a2628efd_7_double_double)}, // starcas - {"nl_gcr_88a8ef5f6bd43d48_12_double_double", reinterpret_cast(&nl_gcr_88a8ef5f6bd43d48_12_double_double)}, // NOLINT + {"nl_gcr_88a8ef5f6bd43d48_12_double_double", reinterpret_cast(&nl_gcr_88a8ef5f6bd43d48_12_double_double)}, // breakout - {"nl_gcr_8a1565d1413f42f7_31_double_double", reinterpret_cast(&nl_gcr_8a1565d1413f42f7_31_double_double)}, // NOLINT + {"nl_gcr_8a1565d1413f42f7_31_double_double", reinterpret_cast(&nl_gcr_8a1565d1413f42f7_31_double_double)}, // starhawk - {"nl_gcr_8b1ac1e181eec3fc_40_double_double", reinterpret_cast(&nl_gcr_8b1ac1e181eec3fc_40_double_double)}, // NOLINT + {"nl_gcr_8b1ac1e181eec3fc_40_double_double", reinterpret_cast(&nl_gcr_8b1ac1e181eec3fc_40_double_double)}, // rebound - {"nl_gcr_8bec817b324dcc3_28_double_double", reinterpret_cast(&nl_gcr_8bec817b324dcc3_28_double_double)}, // NOLINT + {"nl_gcr_8bec817b324dcc3_28_double_double", reinterpret_cast(&nl_gcr_8bec817b324dcc3_28_double_double)}, // cocoloco - {"nl_gcr_8c0f7f2284333de5_16_double_double", reinterpret_cast(&nl_gcr_8c0f7f2284333de5_16_double_double)}, // NOLINT + {"nl_gcr_8c0f7f2284333de5_16_double_double", reinterpret_cast(&nl_gcr_8c0f7f2284333de5_16_double_double)}, // spacfury - {"nl_gcr_8c1dd4afcf0f8ea2_15_double_double", reinterpret_cast(&nl_gcr_8c1dd4afcf0f8ea2_15_double_double)}, // NOLINT + {"nl_gcr_8c1dd4afcf0f8ea2_15_double_double", reinterpret_cast(&nl_gcr_8c1dd4afcf0f8ea2_15_double_double)}, // fireone - {"nl_gcr_8c512fd6a6dabc50_35_double_double", reinterpret_cast(&nl_gcr_8c512fd6a6dabc50_35_double_double)}, // NOLINT + {"nl_gcr_8c512fd6a6dabc50_35_double_double", reinterpret_cast(&nl_gcr_8c512fd6a6dabc50_35_double_double)}, // segausb - {"nl_gcr_8cc4eb213eaeef9b_30_double_double", reinterpret_cast(&nl_gcr_8cc4eb213eaeef9b_30_double_double)}, // NOLINT + {"nl_gcr_8cc4eb213eaeef9b_30_double_double", reinterpret_cast(&nl_gcr_8cc4eb213eaeef9b_30_double_double)}, // starcrus - {"nl_gcr_8d7bddf33d942482_129_double_double", reinterpret_cast(&nl_gcr_8d7bddf33d942482_129_double_double)}, // NOLINT + {"nl_gcr_8d7bddf33d942482_129_double_double", reinterpret_cast(&nl_gcr_8d7bddf33d942482_129_double_double)}, // tank - {"nl_gcr_930b64361c2cdba8_328_double_double", reinterpret_cast(&nl_gcr_930b64361c2cdba8_328_double_double)}, // NOLINT + {"nl_gcr_930b64361c2cdba8_328_double_double", reinterpret_cast(&nl_gcr_930b64361c2cdba8_328_double_double)}, // gamemachine - {"nl_gcr_934712b55bb3b2b2_10_double_double", reinterpret_cast(&nl_gcr_934712b55bb3b2b2_10_double_double)}, // NOLINT + {"nl_gcr_934712b55bb3b2b2_10_double_double", reinterpret_cast(&nl_gcr_934712b55bb3b2b2_10_double_double)}, // kidniki - {"nl_gcr_9a5874c8e2da79d2_37_double_double", reinterpret_cast(&nl_gcr_9a5874c8e2da79d2_37_double_double)}, // NOLINT + {"nl_gcr_9a5874c8e2da79d2_37_double_double", reinterpret_cast(&nl_gcr_9a5874c8e2da79d2_37_double_double)}, // fireone - {"nl_gcr_9aa159329f86ca8b_70_double_double", reinterpret_cast(&nl_gcr_9aa159329f86ca8b_70_double_double)}, // NOLINT + {"nl_gcr_9aa159329f86ca8b_70_double_double", reinterpret_cast(&nl_gcr_9aa159329f86ca8b_70_double_double)}, // warrior - {"nl_gcr_9c975530a1a529d6_7_double_double", reinterpret_cast(&nl_gcr_9c975530a1a529d6_7_double_double)}, // NOLINT + {"nl_gcr_9c975530a1a529d6_7_double_double", reinterpret_cast(&nl_gcr_9c975530a1a529d6_7_double_double)}, // kidniki - {"nl_gcr_9f141889c2091efc_24_double_double", reinterpret_cast(&nl_gcr_9f141889c2091efc_24_double_double)}, // NOLINT + {"nl_gcr_9f141889c2091efc_24_double_double", reinterpret_cast(&nl_gcr_9f141889c2091efc_24_double_double)}, // segas16b_audio - {"nl_gcr_9f7104c5e25c87dd_111_double_double", reinterpret_cast(&nl_gcr_9f7104c5e25c87dd_111_double_double)}, // NOLINT + {"nl_gcr_9f7104c5e25c87dd_111_double_double", reinterpret_cast(&nl_gcr_9f7104c5e25c87dd_111_double_double)}, // boxingb - {"nl_gcr_a0bf548977306172_25_double_double", reinterpret_cast(&nl_gcr_a0bf548977306172_25_double_double)}, // NOLINT + {"nl_gcr_a0bf548977306172_25_double_double", reinterpret_cast(&nl_gcr_a0bf548977306172_25_double_double)}, // boxingb - {"nl_gcr_a1132c8737d5d463_96_double_double", reinterpret_cast(&nl_gcr_a1132c8737d5d463_96_double_double)}, // NOLINT + {"nl_gcr_a1132c8737d5d463_96_double_double", reinterpret_cast(&nl_gcr_a1132c8737d5d463_96_double_double)}, // astrob - {"nl_gcr_a41a44bd5c424f88_13_double_double", reinterpret_cast(&nl_gcr_a41a44bd5c424f88_13_double_double)}, // NOLINT + {"nl_gcr_a41a44bd5c424f88_13_double_double", reinterpret_cast(&nl_gcr_a41a44bd5c424f88_13_double_double)}, // tp1985 - {"nl_gcr_a4540ffea06b4346_26_double_double", reinterpret_cast(&nl_gcr_a4540ffea06b4346_26_double_double)}, // NOLINT + {"nl_gcr_a4540ffea06b4346_26_double_double", reinterpret_cast(&nl_gcr_a4540ffea06b4346_26_double_double)}, // tailg - {"nl_gcr_a46301cd3479b8db_15_double_double", reinterpret_cast(&nl_gcr_a46301cd3479b8db_15_double_double)}, // NOLINT + {"nl_gcr_a46301cd3479b8db_15_double_double", reinterpret_cast(&nl_gcr_a46301cd3479b8db_15_double_double)}, // barrier - {"nl_gcr_a50a4b733e95414a_10_double_double", reinterpret_cast(&nl_gcr_a50a4b733e95414a_10_double_double)}, // NOLINT + {"nl_gcr_a50a4b733e95414a_10_double_double", reinterpret_cast(&nl_gcr_a50a4b733e95414a_10_double_double)}, // starcas - {"nl_gcr_a582a424cb61c678_62_double_double", reinterpret_cast(&nl_gcr_a582a424cb61c678_62_double_double)}, // NOLINT + {"nl_gcr_a582a424cb61c678_62_double_double", reinterpret_cast(&nl_gcr_a582a424cb61c678_62_double_double)}, // tank - {"nl_gcr_a63d1344e34bef4b_36_double_double", reinterpret_cast(&nl_gcr_a63d1344e34bef4b_36_double_double)}, // NOLINT + {"nl_gcr_a63d1344e34bef4b_36_double_double", reinterpret_cast(&nl_gcr_a63d1344e34bef4b_36_double_double)}, // boxingb - {"nl_gcr_a6b734322b3ea924_22_double_double", reinterpret_cast(&nl_gcr_a6b734322b3ea924_22_double_double)}, // NOLINT + {"nl_gcr_a6b734322b3ea924_22_double_double", reinterpret_cast(&nl_gcr_a6b734322b3ea924_22_double_double)}, // armora - {"nl_gcr_a6cfda6668b153c2_22_double_double", reinterpret_cast(&nl_gcr_a6cfda6668b153c2_22_double_double)}, // NOLINT + {"nl_gcr_a6cfda6668b153c2_22_double_double", reinterpret_cast(&nl_gcr_a6cfda6668b153c2_22_double_double)}, // boxingb - {"nl_gcr_a6f74be7f61e6db2_29_double_double", reinterpret_cast(&nl_gcr_a6f74be7f61e6db2_29_double_double)}, // NOLINT + {"nl_gcr_a6f74be7f61e6db2_29_double_double", reinterpret_cast(&nl_gcr_a6f74be7f61e6db2_29_double_double)}, // carpolo - {"nl_gcr_a8f1d076330f06b7_34_double_double", reinterpret_cast(&nl_gcr_a8f1d076330f06b7_34_double_double)}, // NOLINT + {"nl_gcr_a8f1d076330f06b7_34_double_double", reinterpret_cast(&nl_gcr_a8f1d076330f06b7_34_double_double)}, // breakout - {"nl_gcr_a971eeb2ef76f75f_13_double_double", reinterpret_cast(&nl_gcr_a971eeb2ef76f75f_13_double_double)}, // NOLINT + {"nl_gcr_a971eeb2ef76f75f_13_double_double", reinterpret_cast(&nl_gcr_a971eeb2ef76f75f_13_double_double)}, // ripoff - {"nl_gcr_aa07266ef5d420d1_11_double_double", reinterpret_cast(&nl_gcr_aa07266ef5d420d1_11_double_double)}, // NOLINT + {"nl_gcr_aa07266ef5d420d1_11_double_double", reinterpret_cast(&nl_gcr_aa07266ef5d420d1_11_double_double)}, // brdrline - {"nl_gcr_aa68b74ffdea9bd8_47_double_double", reinterpret_cast(&nl_gcr_aa68b74ffdea9bd8_47_double_double)}, // NOLINT + {"nl_gcr_aa68b74ffdea9bd8_47_double_double", reinterpret_cast(&nl_gcr_aa68b74ffdea9bd8_47_double_double)}, // 280zzzap - {"nl_gcr_ab9144d965a37e4_113_double_double", reinterpret_cast(&nl_gcr_ab9144d965a37e4_113_double_double)}, // NOLINT + {"nl_gcr_ab9144d965a37e4_113_double_double", reinterpret_cast(&nl_gcr_ab9144d965a37e4_113_double_double)}, // sspeedr - {"nl_gcr_ac1e401ddf971e15_10_double_double", reinterpret_cast(&nl_gcr_ac1e401ddf971e15_10_double_double)}, // NOLINT + {"nl_gcr_ac1e401ddf971e15_10_double_double", reinterpret_cast(&nl_gcr_ac1e401ddf971e15_10_double_double)}, // starfire - {"nl_gcr_aceb6035dfb557c9_12_double_double", reinterpret_cast(&nl_gcr_aceb6035dfb557c9_12_double_double)}, // NOLINT + {"nl_gcr_aceb6035dfb557c9_12_double_double", reinterpret_cast(&nl_gcr_aceb6035dfb557c9_12_double_double)}, // sundance - {"nl_gcr_ad6dba01ff2425c3_12_double_double", reinterpret_cast(&nl_gcr_ad6dba01ff2425c3_12_double_double)}, // NOLINT + {"nl_gcr_ad6dba01ff2425c3_12_double_double", reinterpret_cast(&nl_gcr_ad6dba01ff2425c3_12_double_double)}, // rebound - {"nl_gcr_ae15f7f8a55fc96_7_double_double", reinterpret_cast(&nl_gcr_ae15f7f8a55fc96_7_double_double)}, // NOLINT + {"nl_gcr_ae15f7f8a55fc96_7_double_double", reinterpret_cast(&nl_gcr_ae15f7f8a55fc96_7_double_double)}, // armora - {"nl_gcr_afcde432efdafb81_56_double_double", reinterpret_cast(&nl_gcr_afcde432efdafb81_56_double_double)}, // NOLINT + {"nl_gcr_afcde432efdafb81_56_double_double", reinterpret_cast(&nl_gcr_afcde432efdafb81_56_double_double)}, // mario - {"nl_gcr_afce66fb47d3c5f3_62_double_double", reinterpret_cast(&nl_gcr_afce66fb47d3c5f3_62_double_double)}, // NOLINT + {"nl_gcr_afce66fb47d3c5f3_62_double_double", reinterpret_cast(&nl_gcr_afce66fb47d3c5f3_62_double_double)}, // spacewar - {"nl_gcr_b09deef9a25aecaf_24_double_double", reinterpret_cast(&nl_gcr_b09deef9a25aecaf_24_double_double)}, // NOLINT + {"nl_gcr_b09deef9a25aecaf_24_double_double", reinterpret_cast(&nl_gcr_b09deef9a25aecaf_24_double_double)}, // spacfury - {"nl_gcr_b1db23287df1da54_175_double_double", reinterpret_cast(&nl_gcr_b1db23287df1da54_175_double_double)}, // NOLINT + {"nl_gcr_b1db23287df1da54_175_double_double", reinterpret_cast(&nl_gcr_b1db23287df1da54_175_double_double)}, // segaspeech - {"nl_gcr_b22769fbf3159a8d_21_double_double", reinterpret_cast(&nl_gcr_b22769fbf3159a8d_21_double_double)}, // NOLINT + {"nl_gcr_b22769fbf3159a8d_21_double_double", reinterpret_cast(&nl_gcr_b22769fbf3159a8d_21_double_double)}, // brdrline - {"nl_gcr_b66df357763b1dce_97_double_double", reinterpret_cast(&nl_gcr_b66df357763b1dce_97_double_double)}, // NOLINT + {"nl_gcr_b66df357763b1dce_97_double_double", reinterpret_cast(&nl_gcr_b66df357763b1dce_97_double_double)}, // breakout - {"nl_gcr_b66ff415b228d5f8_10_double_double", reinterpret_cast(&nl_gcr_b66ff415b228d5f8_10_double_double)}, // NOLINT + {"nl_gcr_b66ff415b228d5f8_10_double_double", reinterpret_cast(&nl_gcr_b66ff415b228d5f8_10_double_double)}, // starcas - {"nl_gcr_b7344e05aac90017_65_double_double", reinterpret_cast(&nl_gcr_b7344e05aac90017_65_double_double)}, // NOLINT + {"nl_gcr_b7344e05aac90017_65_double_double", reinterpret_cast(&nl_gcr_b7344e05aac90017_65_double_double)}, // starfire - {"nl_gcr_b75e0baeb501e907_23_double_double", reinterpret_cast(&nl_gcr_b75e0baeb501e907_23_double_double)}, // NOLINT + {"nl_gcr_b75e0baeb501e907_23_double_double", reinterpret_cast(&nl_gcr_b75e0baeb501e907_23_double_double)}, // spacfury - {"nl_gcr_b7b209d222c0a9a6_91_double_double", reinterpret_cast(&nl_gcr_b7b209d222c0a9a6_91_double_double)}, // NOLINT + {"nl_gcr_b7b209d222c0a9a6_91_double_double", reinterpret_cast(&nl_gcr_b7b209d222c0a9a6_91_double_double)}, // boxingb - {"nl_gcr_b8d6d148a50bdb8f_55_double_double", reinterpret_cast(&nl_gcr_b8d6d148a50bdb8f_55_double_double)}, // NOLINT + {"nl_gcr_b8d6d148a50bdb8f_55_double_double", reinterpret_cast(&nl_gcr_b8d6d148a50bdb8f_55_double_double)}, // 280zzzap - {"nl_gcr_bb501e6a23177009_57_double_double", reinterpret_cast(&nl_gcr_bb501e6a23177009_57_double_double)}, // NOLINT + {"nl_gcr_bb501e6a23177009_57_double_double", reinterpret_cast(&nl_gcr_bb501e6a23177009_57_double_double)}, // elim - {"nl_gcr_bb56fa5325163fc3_15_double_double", reinterpret_cast(&nl_gcr_bb56fa5325163fc3_15_double_double)}, // NOLINT + {"nl_gcr_bb56fa5325163fc3_15_double_double", reinterpret_cast(&nl_gcr_bb56fa5325163fc3_15_double_double)}, // starfire - {"nl_gcr_bd1514d7defd4062_9_double_double", reinterpret_cast(&nl_gcr_bd1514d7defd4062_9_double_double)}, // NOLINT + {"nl_gcr_bd1514d7defd4062_9_double_double", reinterpret_cast(&nl_gcr_bd1514d7defd4062_9_double_double)}, // ripoff - {"nl_gcr_be7c805100c522fd_59_double_double", reinterpret_cast(&nl_gcr_be7c805100c522fd_59_double_double)}, // NOLINT + {"nl_gcr_be7c805100c522fd_59_double_double", reinterpret_cast(&nl_gcr_be7c805100c522fd_59_double_double)}, // elim - {"nl_gcr_be831e5faa508573_150_double_double", reinterpret_cast(&nl_gcr_be831e5faa508573_150_double_double)}, // NOLINT + {"nl_gcr_be831e5faa508573_150_double_double", reinterpret_cast(&nl_gcr_be831e5faa508573_150_double_double)}, // warrior - {"nl_gcr_bff07f8d339f7cc4_89_double_double", reinterpret_cast(&nl_gcr_bff07f8d339f7cc4_89_double_double)}, // NOLINT + {"nl_gcr_bff07f8d339f7cc4_89_double_double", reinterpret_cast(&nl_gcr_bff07f8d339f7cc4_89_double_double)}, // brdrline - {"nl_gcr_c05df522276e65fd_134_double_double", reinterpret_cast(&nl_gcr_c05df522276e65fd_134_double_double)}, // NOLINT + {"nl_gcr_c05df522276e65fd_134_double_double", reinterpret_cast(&nl_gcr_c05df522276e65fd_134_double_double)}, // fireone - {"nl_gcr_c1d22fe6e895255d_79_double_double", reinterpret_cast(&nl_gcr_c1d22fe6e895255d_79_double_double)}, // NOLINT + {"nl_gcr_c1d22fe6e895255d_79_double_double", reinterpret_cast(&nl_gcr_c1d22fe6e895255d_79_double_double)}, // starcrus - {"nl_gcr_c2e616f3de30f15b_31_double_double", reinterpret_cast(&nl_gcr_c2e616f3de30f15b_31_double_double)}, // NOLINT + {"nl_gcr_c2e616f3de30f15b_31_double_double", reinterpret_cast(&nl_gcr_c2e616f3de30f15b_31_double_double)}, // tailg - {"nl_gcr_c4cec7aed23b7b94_23_double_double", reinterpret_cast(&nl_gcr_c4cec7aed23b7b94_23_double_double)}, // NOLINT + {"nl_gcr_c4cec7aed23b7b94_23_double_double", reinterpret_cast(&nl_gcr_c4cec7aed23b7b94_23_double_double)}, // segausb - {"nl_gcr_c61e08cf5e35918_84_double_double", reinterpret_cast(&nl_gcr_c61e08cf5e35918_84_double_double)}, // NOLINT + {"nl_gcr_c61e08cf5e35918_84_double_double", reinterpret_cast(&nl_gcr_c61e08cf5e35918_84_double_double)}, // popeye - {"nl_gcr_c6f25bb06e161d1c_50_double_double", reinterpret_cast(&nl_gcr_c6f25bb06e161d1c_50_double_double)}, // NOLINT + {"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)}, // NOLINT + {"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)}, // NOLINT + {"nl_gcr_c924fe5960b1479e_20_double_double", reinterpret_cast(&nl_gcr_c924fe5960b1479e_20_double_double)}, // dpatrol - {"nl_gcr_ca68d70bd8f2f62e_22_double_double", reinterpret_cast(&nl_gcr_ca68d70bd8f2f62e_22_double_double)}, // NOLINT + {"nl_gcr_ca68d70bd8f2f62e_22_double_double", reinterpret_cast(&nl_gcr_ca68d70bd8f2f62e_22_double_double)}, // breakout - {"nl_gcr_cb2aae3366e0ac1c_7_double_double", reinterpret_cast(&nl_gcr_cb2aae3366e0ac1c_7_double_double)}, // NOLINT + {"nl_gcr_cb2aae3366e0ac1c_7_double_double", reinterpret_cast(&nl_gcr_cb2aae3366e0ac1c_7_double_double)}, // barrier - {"nl_gcr_cc913f9c3f9293e7_19_double_double", reinterpret_cast(&nl_gcr_cc913f9c3f9293e7_19_double_double)}, // NOLINT + {"nl_gcr_cc913f9c3f9293e7_19_double_double", reinterpret_cast(&nl_gcr_cc913f9c3f9293e7_19_double_double)}, // fireone - {"nl_gcr_cca3d1a4219e2ec0_153_double_double", reinterpret_cast(&nl_gcr_cca3d1a4219e2ec0_153_double_double)}, // NOLINT + {"nl_gcr_cca3d1a4219e2ec0_153_double_double", reinterpret_cast(&nl_gcr_cca3d1a4219e2ec0_153_double_double)}, // 1942 - {"nl_gcr_ce766957cb26ff3e_90_double_double", reinterpret_cast(&nl_gcr_ce766957cb26ff3e_90_double_double)}, // NOLINT + {"nl_gcr_ce766957cb26ff3e_90_double_double", reinterpret_cast(&nl_gcr_ce766957cb26ff3e_90_double_double)}, // astrob - {"nl_gcr_cf1018e7ed626623_43_double_double", reinterpret_cast(&nl_gcr_cf1018e7ed626623_43_double_double)}, // NOLINT + {"nl_gcr_cf1018e7ed626623_43_double_double", reinterpret_cast(&nl_gcr_cf1018e7ed626623_43_double_double)}, // zac1b11142 - {"nl_gcr_cfd3bbf5fbba4765_71_double_double", reinterpret_cast(&nl_gcr_cfd3bbf5fbba4765_71_double_double)}, // NOLINT + {"nl_gcr_cfd3bbf5fbba4765_71_double_double", reinterpret_cast(&nl_gcr_cfd3bbf5fbba4765_71_double_double)}, // gunfight - {"nl_gcr_d05b3dbe370c7904_14_double_double", reinterpret_cast(&nl_gcr_d05b3dbe370c7904_14_double_double)}, // NOLINT + {"nl_gcr_d05b3dbe370c7904_14_double_double", reinterpret_cast(&nl_gcr_d05b3dbe370c7904_14_double_double)}, // barrier - {"nl_gcr_d06bd7ddbfd17b5e_15_double_double", reinterpret_cast(&nl_gcr_d06bd7ddbfd17b5e_15_double_double)}, // NOLINT + {"nl_gcr_d06bd7ddbfd17b5e_15_double_double", reinterpret_cast(&nl_gcr_d06bd7ddbfd17b5e_15_double_double)}, // elim - {"nl_gcr_d13f9c6838af6aeb_13_double_double", reinterpret_cast(&nl_gcr_d13f9c6838af6aeb_13_double_double)}, // NOLINT + {"nl_gcr_d13f9c6838af6aeb_13_double_double", reinterpret_cast(&nl_gcr_d13f9c6838af6aeb_13_double_double)}, // elim - {"nl_gcr_d190a0e3b8e1f4a7_7_double_double", reinterpret_cast(&nl_gcr_d190a0e3b8e1f4a7_7_double_double)}, // NOLINT + {"nl_gcr_d190a0e3b8e1f4a7_7_double_double", reinterpret_cast(&nl_gcr_d190a0e3b8e1f4a7_7_double_double)}, // elim - {"nl_gcr_d224211d1af6811d_12_double_double", reinterpret_cast(&nl_gcr_d224211d1af6811d_12_double_double)}, // NOLINT + {"nl_gcr_d224211d1af6811d_12_double_double", reinterpret_cast(&nl_gcr_d224211d1af6811d_12_double_double)}, // armora - {"nl_gcr_d27a39bc93616187_45_double_double", reinterpret_cast(&nl_gcr_d27a39bc93616187_45_double_double)}, // NOLINT + {"nl_gcr_d27a39bc93616187_45_double_double", reinterpret_cast(&nl_gcr_d27a39bc93616187_45_double_double)}, // elim - {"nl_gcr_d2ea3f267b959e8b_20_double_double", reinterpret_cast(&nl_gcr_d2ea3f267b959e8b_20_double_double)}, // NOLINT + {"nl_gcr_d2ea3f267b959e8b_20_double_double", reinterpret_cast(&nl_gcr_d2ea3f267b959e8b_20_double_double)}, // starfire - {"nl_gcr_d32effa2b0ea54a1_438_double_double", reinterpret_cast(&nl_gcr_d32effa2b0ea54a1_438_double_double)}, // NOLINT + {"nl_gcr_d32effa2b0ea54a1_438_double_double", reinterpret_cast(&nl_gcr_d32effa2b0ea54a1_438_double_double)}, // spacfury - {"nl_gcr_d4c34516ff6aa139_46_double_double", reinterpret_cast(&nl_gcr_d4c34516ff6aa139_46_double_double)}, // NOLINT + {"nl_gcr_d4c34516ff6aa139_46_double_double", reinterpret_cast(&nl_gcr_d4c34516ff6aa139_46_double_double)}, // brdrline - {"nl_gcr_d5e1c37cfa2d2853_30_double_double", reinterpret_cast(&nl_gcr_d5e1c37cfa2d2853_30_double_double)}, // NOLINT + {"nl_gcr_d5e1c37cfa2d2853_30_double_double", reinterpret_cast(&nl_gcr_d5e1c37cfa2d2853_30_double_double)}, // brdrline - {"nl_gcr_d74d89ba31f2cb81_126_double_double", reinterpret_cast(&nl_gcr_d74d89ba31f2cb81_126_double_double)}, // NOLINT + {"nl_gcr_d74d89ba31f2cb81_126_double_double", reinterpret_cast(&nl_gcr_d74d89ba31f2cb81_126_double_double)}, // boxingb - {"nl_gcr_d7d45dc58b08cab9_10_double_double", reinterpret_cast(&nl_gcr_d7d45dc58b08cab9_10_double_double)}, // NOLINT + {"nl_gcr_d7d45dc58b08cab9_10_double_double", reinterpret_cast(&nl_gcr_d7d45dc58b08cab9_10_double_double)}, // kidniki - {"nl_gcr_d8c511d38cef5f6f_34_double_double", reinterpret_cast(&nl_gcr_d8c511d38cef5f6f_34_double_double)}, // NOLINT + {"nl_gcr_d8c511d38cef5f6f_34_double_double", reinterpret_cast(&nl_gcr_d8c511d38cef5f6f_34_double_double)}, // warrior - {"nl_gcr_da598f43329e823_27_double_double", reinterpret_cast(&nl_gcr_da598f43329e823_27_double_double)}, // NOLINT + {"nl_gcr_da598f43329e823_27_double_double", reinterpret_cast(&nl_gcr_da598f43329e823_27_double_double)}, // pongf - {"nl_gcr_dbafc5ddaf7a08f8_35_double_double", reinterpret_cast(&nl_gcr_dbafc5ddaf7a08f8_35_double_double)}, // NOLINT + {"nl_gcr_dbafc5ddaf7a08f8_35_double_double", reinterpret_cast(&nl_gcr_dbafc5ddaf7a08f8_35_double_double)}, // fireone - {"nl_gcr_dcbecbc127c5868f_36_double_double", reinterpret_cast(&nl_gcr_dcbecbc127c5868f_36_double_double)}, // NOLINT + {"nl_gcr_dcbecbc127c5868f_36_double_double", reinterpret_cast(&nl_gcr_dcbecbc127c5868f_36_double_double)}, // sundance - {"nl_gcr_e02a162cb515a958_100_double_double", reinterpret_cast(&nl_gcr_e02a162cb515a958_100_double_double)}, // NOLINT + {"nl_gcr_e02a162cb515a958_100_double_double", reinterpret_cast(&nl_gcr_e02a162cb515a958_100_double_double)}, // brdrline - {"nl_gcr_e03f0bc5ac056326_20_double_double", reinterpret_cast(&nl_gcr_e03f0bc5ac056326_20_double_double)}, // NOLINT + {"nl_gcr_e03f0bc5ac056326_20_double_double", reinterpret_cast(&nl_gcr_e03f0bc5ac056326_20_double_double)}, // speedfrk - {"nl_gcr_e07b5b086812756c_7_double_double", reinterpret_cast(&nl_gcr_e07b5b086812756c_7_double_double)}, // NOLINT + {"nl_gcr_e07b5b086812756c_7_double_double", reinterpret_cast(&nl_gcr_e07b5b086812756c_7_double_double)}, // solarq - {"nl_gcr_e081f90c2e0313f6_45_double_double", reinterpret_cast(&nl_gcr_e081f90c2e0313f6_45_double_double)}, // NOLINT + {"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)}, // NOLINT + {"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)}, // NOLINT + {"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)}, // NOLINT + {"nl_gcr_e4f2ffbf201a3d0c_37_double_double", reinterpret_cast(&nl_gcr_e4f2ffbf201a3d0c_37_double_double)}, // pongf - {"nl_gcr_e51b463cd890ef6d_7_double_double", reinterpret_cast(&nl_gcr_e51b463cd890ef6d_7_double_double)}, // NOLINT + {"nl_gcr_e51b463cd890ef6d_7_double_double", reinterpret_cast(&nl_gcr_e51b463cd890ef6d_7_double_double)}, // sundance - {"nl_gcr_e5b7711fac1ea80c_8_double_double", reinterpret_cast(&nl_gcr_e5b7711fac1ea80c_8_double_double)}, // NOLINT + {"nl_gcr_e5b7711fac1ea80c_8_double_double", reinterpret_cast(&nl_gcr_e5b7711fac1ea80c_8_double_double)}, // ripoff - {"nl_gcr_e60314070a75e121_20_double_double", reinterpret_cast(&nl_gcr_e60314070a75e121_20_double_double)}, // NOLINT + {"nl_gcr_e60314070a75e121_20_double_double", reinterpret_cast(&nl_gcr_e60314070a75e121_20_double_double)}, // cheekyms - {"nl_gcr_e75302e17c866419_150_double_double", reinterpret_cast(&nl_gcr_e75302e17c866419_150_double_double)}, // NOLINT + {"nl_gcr_e75302e17c866419_150_double_double", reinterpret_cast(&nl_gcr_e75302e17c866419_150_double_double)}, // elim - {"nl_gcr_e76692c10e79997e_36_double_double", reinterpret_cast(&nl_gcr_e76692c10e79997e_36_double_double)}, // NOLINT + {"nl_gcr_e76692c10e79997e_36_double_double", reinterpret_cast(&nl_gcr_e76692c10e79997e_36_double_double)}, // fireone - {"nl_gcr_e7fb484f621b3ab9_7_double_double", reinterpret_cast(&nl_gcr_e7fb484f621b3ab9_7_double_double)}, // NOLINT + {"nl_gcr_e7fb484f621b3ab9_7_double_double", reinterpret_cast(&nl_gcr_e7fb484f621b3ab9_7_double_double)}, // elim - {"nl_gcr_e8aeb165b69427ec_18_double_double", reinterpret_cast(&nl_gcr_e8aeb165b69427ec_18_double_double)}, // NOLINT + {"nl_gcr_e8aeb165b69427ec_18_double_double", reinterpret_cast(&nl_gcr_e8aeb165b69427ec_18_double_double)}, // spacewar - {"nl_gcr_e9e8211f43d8f4b3_22_double_double", reinterpret_cast(&nl_gcr_e9e8211f43d8f4b3_22_double_double)}, // NOLINT + {"nl_gcr_e9e8211f43d8f4b3_22_double_double", reinterpret_cast(&nl_gcr_e9e8211f43d8f4b3_22_double_double)}, // boxingb - {"nl_gcr_ea2b6e3a05e6ef0b_23_double_double", reinterpret_cast(&nl_gcr_ea2b6e3a05e6ef0b_23_double_double)}, // NOLINT + {"nl_gcr_ea2b6e3a05e6ef0b_23_double_double", reinterpret_cast(&nl_gcr_ea2b6e3a05e6ef0b_23_double_double)}, // starcas - {"nl_gcr_ec4f6d2dad5961b9_64_double_double", reinterpret_cast(&nl_gcr_ec4f6d2dad5961b9_64_double_double)}, // NOLINT + {"nl_gcr_ec4f6d2dad5961b9_64_double_double", reinterpret_cast(&nl_gcr_ec4f6d2dad5961b9_64_double_double)}, // barrier - {"nl_gcr_ecf17036ce1c07cf_10_double_double", reinterpret_cast(&nl_gcr_ecf17036ce1c07cf_10_double_double)}, // NOLINT + {"nl_gcr_ecf17036ce1c07cf_10_double_double", reinterpret_cast(&nl_gcr_ecf17036ce1c07cf_10_double_double)}, // armora - {"nl_gcr_ee2cacaa15d32491_67_double_double", reinterpret_cast(&nl_gcr_ee2cacaa15d32491_67_double_double)}, // NOLINT + {"nl_gcr_ee2cacaa15d32491_67_double_double", reinterpret_cast(&nl_gcr_ee2cacaa15d32491_67_double_double)}, // astrob - {"nl_gcr_ee61dcaa355fc625_285_double_double", reinterpret_cast(&nl_gcr_ee61dcaa355fc625_285_double_double)}, // NOLINT + {"nl_gcr_ee61dcaa355fc625_285_double_double", reinterpret_cast(&nl_gcr_ee61dcaa355fc625_285_double_double)}, // starcrus - {"nl_gcr_ef2f49641f433a74_94_double_double", reinterpret_cast(&nl_gcr_ef2f49641f433a74_94_double_double)}, // NOLINT + {"nl_gcr_ef2f49641f433a74_94_double_double", reinterpret_cast(&nl_gcr_ef2f49641f433a74_94_double_double)}, // spacfury - {"nl_gcr_f365c3863b050e35_45_double_double", reinterpret_cast(&nl_gcr_f365c3863b050e35_45_double_double)}, // NOLINT + {"nl_gcr_f365c3863b050e35_45_double_double", reinterpret_cast(&nl_gcr_f365c3863b050e35_45_double_double)}, // spacfury - {"nl_gcr_f3c9a6d53371d709_227_double_double", reinterpret_cast(&nl_gcr_f3c9a6d53371d709_227_double_double)}, // NOLINT + {"nl_gcr_f3c9a6d53371d709_227_double_double", reinterpret_cast(&nl_gcr_f3c9a6d53371d709_227_double_double)}, // barrier - {"nl_gcr_f425d4008ae1d2c6_13_double_double", reinterpret_cast(&nl_gcr_f425d4008ae1d2c6_13_double_double)}, // NOLINT + {"nl_gcr_f425d4008ae1d2c6_13_double_double", reinterpret_cast(&nl_gcr_f425d4008ae1d2c6_13_double_double)}, // boxingb - {"nl_gcr_f43cf2a28a5a5561_23_double_double", reinterpret_cast(&nl_gcr_f43cf2a28a5a5561_23_double_double)}, // NOLINT + {"nl_gcr_f43cf2a28a5a5561_23_double_double", reinterpret_cast(&nl_gcr_f43cf2a28a5a5561_23_double_double)}, // spacfury - {"nl_gcr_f4da1503eabe16cf_16_double_double", reinterpret_cast(&nl_gcr_f4da1503eabe16cf_16_double_double)}, // NOLINT + {"nl_gcr_f4da1503eabe16cf_16_double_double", reinterpret_cast(&nl_gcr_f4da1503eabe16cf_16_double_double)}, // elim - {"nl_gcr_f4f4e2ee05cb584e_13_double_double", reinterpret_cast(&nl_gcr_f4f4e2ee05cb584e_13_double_double)}, // NOLINT + {"nl_gcr_f4f4e2ee05cb584e_13_double_double", reinterpret_cast(&nl_gcr_f4f4e2ee05cb584e_13_double_double)}, // konami2x - {"nl_gcr_f6900d3f36a91049_85_double_double", reinterpret_cast(&nl_gcr_f6900d3f36a91049_85_double_double)}, // NOLINT + {"nl_gcr_f6900d3f36a91049_85_double_double", reinterpret_cast(&nl_gcr_f6900d3f36a91049_85_double_double)}, // breakout - {"nl_gcr_f7dc4f87b5a8ba93_7_double_double", reinterpret_cast(&nl_gcr_f7dc4f87b5a8ba93_7_double_double)}, // NOLINT + {"nl_gcr_f7dc4f87b5a8ba93_7_double_double", reinterpret_cast(&nl_gcr_f7dc4f87b5a8ba93_7_double_double)}, // fireone - {"nl_gcr_f8f6a951fd1af6bc_7_double_double", reinterpret_cast(&nl_gcr_f8f6a951fd1af6bc_7_double_double)}, // NOLINT + {"nl_gcr_f8f6a951fd1af6bc_7_double_double", reinterpret_cast(&nl_gcr_f8f6a951fd1af6bc_7_double_double)}, // brdrline - {"nl_gcr_f99b1245e708ec85_83_double_double", reinterpret_cast(&nl_gcr_f99b1245e708ec85_83_double_double)}, // NOLINT + {"nl_gcr_f99b1245e708ec85_83_double_double", reinterpret_cast(&nl_gcr_f99b1245e708ec85_83_double_double)}, // zektor - {"nl_gcr_fbff020f5f5d5a5_144_double_double", reinterpret_cast(&nl_gcr_fbff020f5f5d5a5_144_double_double)}, // NOLINT + {"nl_gcr_fbff020f5f5d5a5_144_double_double", reinterpret_cast(&nl_gcr_fbff020f5f5d5a5_144_double_double)}, // kidniki - {"nl_gcr_fc02559fdbfb0e10_67_double_double", reinterpret_cast(&nl_gcr_fc02559fdbfb0e10_67_double_double)}, // NOLINT + {"nl_gcr_fc02559fdbfb0e10_67_double_double", reinterpret_cast(&nl_gcr_fc02559fdbfb0e10_67_double_double)}, // 280zzzap - {"nl_gcr_fc9971724787b82b_149_double_double", reinterpret_cast(&nl_gcr_fc9971724787b82b_149_double_double)}, // NOLINT + {"nl_gcr_fc9971724787b82b_149_double_double", reinterpret_cast(&nl_gcr_fc9971724787b82b_149_double_double)}, // elim - {"nl_gcr_fcce97532ad2f49d_18_double_double", reinterpret_cast(&nl_gcr_fcce97532ad2f49d_18_double_double)}, // NOLINT + {"nl_gcr_fcce97532ad2f49d_18_double_double", reinterpret_cast(&nl_gcr_fcce97532ad2f49d_18_double_double)}, // fireone - {"nl_gcr_fd2796828f1ebd00_36_double_double", reinterpret_cast(&nl_gcr_fd2796828f1ebd00_36_double_double)}, // NOLINT + {"nl_gcr_fd2796828f1ebd00_36_double_double", reinterpret_cast(&nl_gcr_fd2796828f1ebd00_36_double_double)}, // starfire - {"nl_gcr_feae15b80dd73620_7_double_double", reinterpret_cast(&nl_gcr_feae15b80dd73620_7_double_double)}, // NOLINT + {"nl_gcr_feae15b80dd73620_7_double_double", reinterpret_cast(&nl_gcr_feae15b80dd73620_7_double_double)}, #endif {"", nullptr} diff --git a/src/mame/audio/nl_frogs.cpp b/src/mame/audio/nl_frogs.cpp new file mode 100644 index 00000000000..127b12ee9a6 --- /dev/null +++ b/src/mame/audio/nl_frogs.cpp @@ -0,0 +1,540 @@ +// license:CC0 +// copyright-holders:Aaron Giles + +// +// Netlist for Frogs +// +// Derived from the schematics in the Frogs manual. +// +// Known problems/issues: +// +// * Croak sound should have a little bit more tonality. +// +// * Performance work needed +// + +#include "netlist/devices/net_lib.h" +#include "nl_frogs.h" + + +// +// Optimizations +// + +#define ENABLE_FRONTIERS (0) +#define UNDERCLOCK_NOISE_GEN (1) + + + +// +// Hacks +// + + + +// +// Main netlist +// + +#define D_1N914(name) DIODE(name, "1N914") + +#define Q_2N4401(name) QBJT_EB(name, "2N4401") +#define Q_2N4403(name) QBJT_EB(name, "2N4403") + +// JFET transistors not supported, but this should do the trick +#define Q_2N4093(name) MOSFET(name, "NMOS(VTO=-1 CAPMOD=0)") + +#define LM741_DIP UA741_DIP8 + +NETLIST_START(frogs) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 4e-6) + + TTL_INPUT(I_SOUND_0, 0) + TTL_INPUT(I_SOUND_1, 0) + TTL_INPUT(I_SOUND_2, 0) + TTL_INPUT(I_SOUND_3, 0) + TTL_INPUT(I_SOUND_4, 0) + TTL_INPUT(I_SOUND_5, 0) + TTL_INPUT(I_SOUND_6, 0) + TTL_INPUT(I_SOUND_7, 0) + + NET_C(GND, I_SOUND_0.GND, I_SOUND_1.GND, I_SOUND_2.GND, I_SOUND_3.GND, I_SOUND_4.GND, I_SOUND_5.GND, I_SOUND_6.GND, I_SOUND_7.GND) + NET_C(I_V5, I_SOUND_0.VCC, I_SOUND_1.VCC, I_SOUND_2.VCC, I_SOUND_3.VCC, I_SOUND_4.VCC, I_SOUND_5.VCC, I_SOUND_6.VCC, I_SOUND_7.VCC) + + ALIAS(I_HOP, I_SOUND_0) + ALIAS(I_JUMP, I_SOUND_1) + ALIAS(I_TONGUE, I_SOUND_2) + ALIAS(I_CAPTURE, I_SOUND_3) + ALIAS(I_FLY, I_SOUND_4) + ALIAS(I_SPLASH, I_SOUND_7) + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V12, 12) + ANALOG_INPUT(I_VM12, -12) + + RES(R1, RES_K(3.3)) // SPLASH + RES(R2, RES_K(3.3)) // SPLASH + RES(R3, RES_K(3.3)) // CAPTURE + RES(R4, RES_K(3.3)) // CAPTURE + RES(R5, RES_K(3.3)) // TONGUE + RES(R6, RES_K(3.3)) // TONGUE + RES(R7, RES_K(3.3)) // HOP + RES(R8, RES_K(3.3)) // HOP + RES(R9, RES_K(3.3)) // JUMP + RES(R10, RES_K(3.3)) // JUMP + RES(R11, RES_K(3.3)) // FLY + RES(R12, RES_K(10)) // FLY + RES(R13, RES_K(10)) // SPLASH + RES(R14, RES_K(4.7)) // SPLASH + RES(R15, RES_K(100)) // SPLASH + RES(R16, RES_K(4.7)) // CAPTURE + RES(R17, RES_K(330)) // CAPTURE + RES(R18, RES_K(4.7)) // TONGUE + RES(R19, RES_K(100)) // TONGUE + RES(R20, RES_K(4.7)) // HOP + RES(R21, RES_K(3.3)) // HOP + RES(R22, RES_K(4.7)) // JUMP + RES(R23, RES_K(150)) // JUMP + RES(R24, RES_K(4.7)) // FLY + RES(R25, RES_K(22)) // SPLASH + RES(R26, 51) // HOP + RES(R27, RES_K(10)) // FLY + RES(R28, RES_K(22)) // TONGUE + RES(R29, RES_K(100)) // TONGUE + RES(R30, RES_K(470)) // HOP + RES(R31, 220) // HOP + RES(R32, RES_K(33)) // HOP (mislabelled R22) + RES(R33, 330) // JUMP + RES(R34, 820) // JUMP + RES(R35, RES_K(100)) // FLY + RES(R36, RES_K(2.2)) // FLY + RES(R37, RES_K(2.2)) // SPLASH + RES(R38, RES_K(10)) // SPLASH + RES(R39, RES_K(10)) // SPLASH + RES(R40, RES_K(68)) // CAPTURE + RES(R41, RES_K(4.7)) // CAPTURE + RES(R42, RES_K(1)) // TONGUE + RES(R43, RES_K(82)) // HOP + RES(R44, RES_K(3.3)) // FLY + RES(R45, RES_K(100)) // FLY + RES(R46, RES_K(3.3)) // FLY + POT(R47, RES_K(50)) // SPLASH + RES(R48, RES_K(47)) // CAPTURE + RES(R49, RES_K(3.3)) // CAPTURE + RES(R50, RES_K(100)) // CAPTURE + RES(R51, RES_K(39)) // TONGUE + RES(R52, 51) // HOP + RES(R53, RES_K(62)) + RES(R54, 470) // JUMP + RES(R55, RES_K(22)) // JUMP + RES(R56, RES_M(2.2)) // JUMP + RES(R57, RES_K(22)) + RES(R58, RES_K(22)) + RES(R59, RES_K(3.3)) // FLY +// RES(R60, RES_K(10)) -- final amp + RES(R61, RES_K(100)) // SPLASH + RES(R62, RES_K(47)) // SPLASH + RES(R63, RES_K(33)) // SPLASH + RES(R64, RES_K(820)) // CAPTURE + RES(R65, RES_K(150)) // CAPTURE + RES(R66, 51) // CAPTURE + RES(R67, 51) // CAPTURE + RES(R68, RES_K(1)) // JUMP + RES(R69, RES_K(82)) // JUMP + RES(R70, 51) // JUMP + RES(R71, RES_K(4.7)) // JUMP + RES(R72, RES_K(27)) // FLY + RES(R73, RES_K(10)) // FLY + RES(R74, RES_K(1)) // FLY + RES(R75, RES_K(10)) // JUMP + RES(R76, RES_K(10)) // JUMP + RES(R77, 560) // JUMP + RES(R78, RES_K(10)) // JUMP + RES(R79, RES_K(10)) // JUMP + RES(R80, RES_K(39)) // FLY + RES(R81, RES_K(100)) // FLY + RES(R82, RES_K(10)) // FLY + RES(R83, RES_K(100)) // JUMP + RES(R84, RES_K(1)) // JUMP + RES(R85, RES_K(10)) // JUMP + RES(R86, RES_K(1)) // FLY + RES(R87, RES_K(100)) // FLY + RES(R88, RES_K(82)) // FLY + RES(R90, RES_K(56)) // MIXER + POT(R91, RES_K(100)) + POT(R92, RES_M(1)) + POT(R93, RES_M(1)) + POT(R94, RES_M(1)) + POT(R95, RES_M(1)) + POT(R96, RES_K(50)) + +// CAP(C1, CAP_U(10)) +// CAP(C2, CAP_U(10)) + CAP(C3, CAP_U(0.047)) + CAP(C4, CAP_U(1)) + CAP(C5, CAP_U(1)) + CAP(C6, CAP_U(0.1)) + CAP(C7, CAP_U(0.1)) + CAP(C8, CAP_U(1)) + CAP(C9, CAP_U(0.1)) + CAP(C10, CAP_U(0.1)) + CAP(C11, CAP_U(0.05)) + CAP(C12, CAP_U(0.05)) + CAP(C13, CAP_U(0.05)) + CAP(C14, CAP_U(0.05)) + CAP(C15, CAP_U(0.05)) + CAP(C16, CAP_U(0.05)) + CAP(C17, CAP_U(0.05)) + CAP(C18, CAP_U(0.05)) + CAP(C19, CAP_U(0.05)) + CAP(C20, CAP_U(0.05)) + CAP(C21, CAP_U(0.05)) + CAP(C22, CAP_U(2.2)) + CAP(C23, CAP_U(10)) + CAP(C24, CAP_U(0.1)) + CAP(C25, CAP_U(4.7)) + CAP(C26, CAP_U(0.05)) + CAP(C27, CAP_U(1)) + CAP(C28, CAP_U(0.05)) + CAP(C29, CAP_U(0.047)) + CAP(C30, CAP_U(10)) + CAP(C31, CAP_U(0.47)) + CAP(C32, CAP_U(0.47)) + CAP(C33, CAP_U(0.05)) +// CAP(C34, CAP_U(0.05)) -- final amp +// CAP(C35, CAP_U(0.05)) -- final amp + CAP(C36, CAP_U(0.05)) + CAP(C37, CAP_U(0.05)) + CAP(C38, CAP_U(0.05)) + CAP(C39, CAP_U(0.1)) + CAP(C40, CAP_U(0.1)) + CAP(C41, CAP_U(0.05)) + CAP(C42, CAP_U(0.05)) + CAP(C43, CAP_U(0.05)) + CAP(C44, CAP_U(10)) + CAP(C45, CAP_U(0.01)) + CAP(C46, CAP_U(0.01)) + CAP(C47, CAP_U(1)) + CAP(C48, CAP_U(0.05)) + CAP(C49, CAP_U(0.1)) + CAP(C50, CAP_U(0.01)) + CAP(C51, CAP_U(0.01)) + CAP(C52, CAP_U(0.1)) + CAP(C53, CAP_U(0.05)) + CAP(C54, CAP_U(0.01)) + CAP(C55, CAP_U(0.05)) + CAP(C56, CAP_U(0.05)) + CAP(C57, CAP_U(2.2)) +// CAP(C58, CAP_U(0.1)) -- final amp + CAP(C59, CAP_U(0.05)) + CAP(C60, CAP_U(0.05)) + CAP(C61, CAP_U(0.05)) + CAP(C62, CAP_U(0.1)) + CAP(C63, CAP_U(0.05)) + CAP(C64, CAP_U(0.05)) + CAP(C65, CAP_U(0.1)) + CAP(C66, CAP_U(2.2)) + CAP(C67, CAP_U(0.05)) + CAP(C68, CAP_U(0.05)) + CAP(C69, CAP_U(0.05)) + CAP(C70, CAP_U(0.05)) + CAP(C71, CAP_U(0.05)) + CAP(C72, CAP_U(1)) + CAP(C73, CAP_U(0.047)) + CAP(C74, CAP_U(0.05)) + + D_1N914(D1) + D_1N914(D2) + D_1N914(D3) + D_1N914(D4) + D_1N914(D5) + D_1N914(D6) + D_1N914(D7) + D_1N914(D8) + D_1N914(D9) + + Q_2N4401(Q1) + Q_2N4401(Q2) + Q_2N4401(Q3) + Q_2N4401(Q4) + Q_2N4401(Q5) + Q_2N4401(Q6) + Q_2N4401(Q7) + Q_2N4403(Q8) + Q_2N4403(Q9) + Q_2N4093(Q10) + Q_2N4401(Q11) + Q_2N4401(Q12) + Q_2N4403(Q13) + Q_2N4401(Q14) + Q_2N4403(Q15) + Q_2N4401(Q16) + Q_2N4403(Q17) + Q_2N4093(Q18) + Q_2N4401(Q19) + Q_2N4401(Q20) + Q_2N4401(Q21) + + MM5837_DIP(U1) // Noise Generator +#if (UNDERCLOCK_NOISE_GEN) + PARAM(U1.FREQ, 24000) +#endif + NE555_DIP(U2) // Timer + NE555_DIP(U3) // Timer + NE555_DIP(U4) // Timer + NE555_DIP(U5) // Timer + NE555_DIP(U6) // Timer + NE555_DIP(U7) // Timer + LM741_DIP(U8) // Op. Amp. + NE555_DIP(U9) // Timer + LM741_DIP(U10) // Op. Amp. + LM741_DIP(U11) // Op. Amp. + NE555_DIP(U12) // Timer +// LM741_DIP(U13) // Op. Amp. -- final amp + LM741_DIP(U14) // Op. Amp. + NE555_DIP(U15) // Timer + LM741_DIP(U16) // Op. Amp. + LM741_DIP(U17) // Op. Amp. + LM741_DIP(U18) // Op. Amp. + NE555_DIP(U19) // Timer + LM741_DIP(U20) // Op. Amp. + + // + // JUMP + // + + NET_C(I_V12, R22.2, U6.4, U6.8, C68.2, R23.2) + NET_C(GND, R10.1, Q2.E, C15.1, U6.1, C7.1, R34.1, U11.3, C71.1, C70.1, R54.1, Q19.B, D7.A, R84.1, R75.1, C64.1, R77.1, U19.1, C53.1, C52.1, U16.3) + NET_C(I_JUMP, R9.1) + NET_C(R9.2, R10.2, Q2.B) + NET_C(Q2.C, R22.1, U6.2) + NET_C(C15.2, U6.5) + NET_C(C68.1, GND) + NET_C(R23.1, U6.7, U6.6, C7.2) + NET_C(U6.3, C22.1, R33.1) + NET_C(R33.2, Q8.E) + NET_C(Q8.B, GND) + NET_C(Q8.C, C44.1, R57.1) + NET_C(C44.2, R70.1) + NET_C(R57.2, R58.2, Q16.B) + NET_C(Q16.E, R71.2) + NET_C(R71.1, R58.1, R70.2, I_VM12) + NET_C(R34.2, C22.2, C32.1, C31.1) + NET_C(C32.2, R56.1, U11.2) + NET_C(R56.2, C31.2, U11.6, R55.1) + NET_C(I_V12, C70.2, U11.7) + NET_C(I_VM12, U11.4, C71.2) + NET_C(R55.2, R54.2, Q21.B) + NET_C(Q21.E, D7.K, Q16.C) + NET_C(Q19.E, Q21.C, Q20.E) + NET_C(Q19.C, R76.1, R85.1, U20.2) + NET_C(I_V12, R76.2, R78.2) + NET_C(R78.1, Q20.C, U20.3, R75.2) + NET_C(Q20.B, R84.2, R83.1) + NET_C(R85.2, U20.6, R79.1) + NET_C(I_V12, U20.7, C63.2) + NET_C(C63.1, GND) + NET_C(I_VM12, U20.4, C64.2) + NET_C(R83.2, C62.1) + NET_C(R79.2, R77.2, C54.1, C51.1) + NET_C(C62.2, U19.3) + NET_C(I_V12, U19.4, C61.2, U19.8, R68.2) + NET_C(C61.1, GND) + NET_C(C53.2, U19.5) + NET_C(U19.2, U19.6, R69.1, C52.2) + NET_C(U19.7, R69.2, R68.1) + NET_C(C54.2, U16.2, R53.1) + NET_C(R53.2, U16.6, C51.2) + NET_C(I_V12, U16.7, C42.2) + NET_C(C42.1, GND) + NET_C(I_VM12, U16.4, C43.2) + NET_C(C43.1, GND) + ALIAS(BOING, U16.6) + + // + // TONGUE + // + + NET_C(I_V12, C20.2, R18.2, U4.4, U4.8, R19.2, Q11.C, R28.2, R42.2, U15.4, U15.8, C48.2) + NET_C(GND, R6.1, Q4.E, C13.1, U4.1, C5.2, R51.1, C49.1, U15.1, C41.1, C48.1) + NET_C(I_TONGUE, R5.1) + NET_C(R5.2, R6.2, Q4.B) + NET_C(C20.1, GND) + NET_C(Q4.C, R18.1, U4.2) + NET_C(C13.2, U4.5) + NET_C(C5.1, U4.7, U4.6, R19.1, R29.1) + RES(RU4, RES_K(100)) // netlist doesn't like unconnected + NET_C(RU4.1, U4.3) // 555 outputs, so run it through + NET_C(RU4.2, GND) // a 100k resistor to ground + NET_C(R29.2, Q11.B) + NET_C(Q11.E, Q12.B) + NET_C(Q12.E, R51.2) + NET_C(Q12.C, R28.1, Q13.B) + NET_C(Q13.E, R42.1) + NET_C(Q13.C, C49.2, U15.2, U15.6, U15.7, C50.1) + NET_C(U15.5, C41.2) + RES(RU15, RES_K(100)) // netlist doesn't like unconnected + NET_C(RU15.1, U15.3) // 555 outputs, so run it through + NET_C(RU15.2, GND) // a 100k resistor to ground + ALIAS(ZIP, C50.2) + + // + // HOP + // + + NET_C(I_V12, C69.2, R20.2, U5.4, U5.8, R21.2) + NET_C(GND, R8.1, Q3.E, C14.1, U5.1, C6.1, C30.2, Q9.B, R52.1, U10.3) + NET_C(I_HOP, R7.1) + NET_C(R7.2, R8.2, Q3.B) + NET_C(C69.1, GND) + NET_C(Q3.C, R20.1, U5.2) + NET_C(U5.5, C14.2) + NET_C(R21.1, U5.6, U5.7, C6.2) + NET_C(U5.3, D2.A, R31.1) + NET_C(D2.K, R32.2, C30.1) + NET_C(R32.1, Q9.E) + NET_C(Q9.C, C72.1, R43.2, Q10.G) + NET_C(C72.2, R26.2) + NET_C(I_VM12, R26.1, R43.1) + NET_C(R31.2, Q10.D, C29.1, C73.1) + NET_C(Q10.S, R52.2) + NET_C(C29.2, U10.2, R30.1) + NET_C(C73.2, R30.2, U10.6) + NET_C(I_V12, U10.7, C28.2) + NET_C(I_VM12, U10.4, C21.2) + NET_C(C21.1, GND) + NET_C(C28.1, GND) + ALIAS(HOP, U10.6) + + // + // CAPTURE + // + + NET_C(I_V12, R16.2, C18.2, U3.4, U3.8, R17.2, C74.2, U9.8, R41.2) + NET_C(GND, R4.1, Q5.E, C12.1, U3.1, C4.2, C19.1, U9.1, C27.2, R65.1, Q17.B, R66.1, U8.3, C18.1) + NET_C(I_CAPTURE, R3.1) + NET_C(R3.2, R4.2, Q5.B) + NET_C(Q5.C, R16.1, U3.2) + NET_C(U3.5, C12.2) + NET_C(R17.1, U3.6, U3.7, C4.1) + NET_C(U3.3, U9.4) + NET_C(C74.1, GND) + NET_C(C19.2, U9.5) + NET_C(R41.1, R48.2, D4.A, U9.7) + NET_C(U9.2, U9.6, R48.1, D4.K, C27.1) + NET_C(U9.3, R50.2, R49.1) + NET_C(R65.2, R64.2, C47.1, Q17.C, Q18.G) + NET_C(I_VM12, R64.1, R67.1) + NET_C(R67.2, C47.2) + NET_C(R50.1, Q17.E) + NET_C(R49.2, Q18.D, C39.1, C40.1) + NET_C(Q18.S, R66.2) + NET_C(C39.2, R40.1, U8.2) + NET_C(C40.2, R40.2, U8.6) + NET_C(I_V12, U8.7, C38.2) + NET_C(C38.1, GND) + NET_C(I_VM12, U8.4, C26.2) + NET_C(C26.1, GND) + ALIAS(CROAK, U8.6) + + // + // SPLASH + // + + NET_C(I_V12, R14.2, C17.2, U2.4, U2.8, R15.2, C25.1, R47.3, Q15.E, U1.4) + NET_C(GND, R2.1, Q6.E, C11.1, U2.1, C3.1, R38.1, Q14.E, U1.1, R62.1, R63.1, C37.1) + NET_C(I_SPLASH, R1.1) + NET_C(R1.2, R2.2, Q6.B) + NET_C(Q6.C, R14.1, U2.2) + NET_C(U2.5, C11.2) + NET_C(C17.1, GND) + NET_C(U2.6, U2.7, R15.1, C3.2) + NET_C(U2.3, R39.1) + NET_C(R39.2, R38.2, Q14.B) + NET_C(Q14.C, R37.1) + NET_C(R37.2, C25.2, R47.1, R25.1) + NET_C(R25.2, C10.1, R13.2, C9.1) + NET_C(Q15.C, C10.2) + NET_C(R13.1, D1.K) + NET_C(D1.A, D5.K) + NET_C(D5.A, U1.3) + NET_C(U1.2, I_VM12) + NET_C(C9.2, R63.2, U14.3) + NET_C(R62.2, U14.2, R61.1) + NET_C(R61.2, U14.6) + NET_C(I_V12, U14.7, C36.2) + NET_C(C36.1, GND) + NET_C(I_VM12, C37.2, U14.4) + ALIAS(SPLASH, U14.6) + + // + // FLY + // + + NET_C(I_V12, R12.2, R24.2, C67.2, U7.8, R35.2, C33.2, U12.8, R44.2, U17.7, C55.2, R87.2) + NET_C(GND, R11.1, C16.1, U7.1, C8.2, Q7.E, C23.2, U12.1, C24.1, R72.1, C56.1, R74.1, R88.1, C66.2, R86.1, U18.3, C60.1) + NET_C(I_FLY, Q1.E) + NET_C(R11.2, R12.1, Q1.B) + NET_C(Q1.C, R24.1, U7.2, U7.4, U12.4) + NET_C(C16.2, U7.5) + NET_C(C67.1, GND) + NET_C(R35.1, U7.6, U7.7, C8.1) + NET_C(U7.3, R27.1, D3.A) + NET_C(R27.2, Q7.B) + NET_C(Q7.C, R36.1) + NET_C(R36.2, C23.1, U12.5) + NET_C(C33.1, GND) + NET_C(U12.2, U12.6, D6.K, R45.1, C24.2) + NET_C(U12.7, D6.A, R45.2, R44.1) + NET_C(U12.3, C46.1) + NET_C(C46.2, C45.1, R59.1) + NET_C(C45.2, R72.2, U17.3) + NET_C(R59.2, U17.2, U17.6, C57.1) + NET_C(I_VM12, U17.4, C56.2) + NET_C(C55.1, GND) + NET_C(C57.2, R73.1) + NET_C(D3.K, R46.1) + NET_C(R46.2, R87.1, R80.2, R88.2, C66.1) + NET_C(R73.2, R74.2, D8.K) + NET_C(D8.A, R80.1, D9.A) + NET_C(D9.K, R86.2, C65.1) + NET_C(C65.2, R82.1) + NET_C(R82.2, U18.2, R81.1) + NET_C(R81.2, U18.6) + NET_C(I_V12, U18.7, C59.2) + NET_C(I_VM12, U18.4, C60.2) + NET_C(C59.1, GND) + ALIAS(BUZZZ, U18.6) + + // + // Mixer + // + + NET_C(BOING, R95.1) + NET_C(ZIP, R93.1) + NET_C(HOP, R94.1) + NET_C(CROAK, R92.1) + NET_C(SPLASH, R91.1) + NET_C(BUZZZ, R96.1) + NET_C(R95.3, R93.3, R94.3, R92.3, R91.3, R96.3, R90.1) + ALIAS(OUTPUT, R90.1) + NET_C(R90.2, GND) + + // + // Unconnected inputs + // + + + // + // Unconnected outputs + // + +#if (ENABLE_FRONTIERS) +#define RXX 192 + OPTIMIZE_FRONTIER(BOING, RES_M(1), RXX) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_frogs.h b/src/mame/audio/nl_frogs.h new file mode 100644 index 00000000000..c1a2cedc56b --- /dev/null +++ b/src/mame/audio/nl_frogs.h @@ -0,0 +1,10 @@ +// license:CC0 +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_FROGS_H +#define MAME_AUDIO_NL_FROGS_H + +#pragma once + +NETLIST_EXTERNAL(frogs) + +#endif // MAME_AUDIO_NL_FROGS_H diff --git a/src/mame/audio/vicdual.cpp b/src/mame/audio/vicdual.cpp index 99e904e6d77..2c44cd6107c 100644 --- a/src/mame/audio/vicdual.cpp +++ b/src/mame/audio/vicdual.cpp @@ -10,188 +10,7 @@ #include "includes/vicdual.h" #include "audio/nl_brdrline.h" - - -/************************************************************************ - * frogs Sound System Analog emulation - * Oct 2004, Derrick Renaud - ************************************************************************/ - - -/* Discrete Sound Input Nodes */ -#define FROGS_FLY_EN NODE_01 -#define FROGS_JUMP_EN NODE_03 -#define FROGS_HOP_EN NODE_04 -#define FROGS_TONGUE_EN NODE_05 -#define FROGS_CAPTURE_EN NODE_06 -#define FROGS_SPLASH_EN NODE_08 - -/* Nodes - Sounds */ -#define FROGS_BUZZZ_SND NODE_11 -#define FROGS_BOING_SND NODE_13 -#define FROGS_HOP_SND NODE_14 -#define FROGS_ZIP_SND NODE_15 -#define FROGS_CROAK_SND NODE_16 -#define FROGS_SPLASH_SND NODE_18 -/* VRs */ -#define FROGS_R93 NODE_25 - -static const discrete_555_desc frogsZip555m = -{ - DISC_555_OUT_CAP | DISC_555_OUT_DC | DISC_555_TRIGGER_IS_LOGIC, - 12, // B+ voltage of 555 - DEFAULT_555_VALUES -}; - -static const discrete_555_cc_desc frogsZip555cc = -{ - DISC_555_OUT_CAP | DISC_555_OUT_DC, - 12, // B+ voltage of 555 - DEFAULT_555_VALUES, - 0.6 // Q13 Vbe -}; - -static const discrete_mixer_desc frogsMixer = -{ - DISC_MIXER_IS_OP_AMP, - {RES_K(1), RES_K(5)}, - {FROGS_R93, 0}, - {CAP_U(0.01), CAP_U(0.01)}, - 0, RES_K(56), 0, CAP_U(0.1), 0, 10000 -}; - -static DISCRETE_SOUND_START(frogs_discrete) - /************************************************ - * Input register mapping for frogs - * - * All inputs are inverted by initial transistor. - ************************************************/ - DISCRETE_INPUT_LOGIC(FROGS_FLY_EN) - DISCRETE_INPUT_NOT(FROGS_JUMP_EN) - DISCRETE_INPUT_NOT(FROGS_HOP_EN) - DISCRETE_INPUT_NOT(FROGS_TONGUE_EN) - DISCRETE_INPUT_NOT(FROGS_CAPTURE_EN) - DISCRETE_INPUT_NOT(FROGS_SPLASH_EN) - - DISCRETE_ADJUSTMENT(FROGS_R93, RES_M(1), RES_K(10), DISC_LOGADJ, "R93") - - DISCRETE_555_MSTABLE(NODE_30, 1, FROGS_TONGUE_EN, RES_K(100), CAP_U(1), &frogsZip555m) - - /* Q11 & Q12 transform the voltage from the oneshot U4, to what is - * needed by the 555CC circuit. Vin to R29 must be > 1V for things - * to change. <=1 then The Vout of this circuit is 12V. - * The Current through R28 equals current through R51. iR28 = iR51 - * So when Vin>.5, iR51 = (Vin-.5)/39k. =0 when Vin<=.5 - * So the voltage drop across R28 is vR28 = iR51 * 22k. - * Finally the Vout = 12 - vR28. - * Note this formula only works when Vin < 39/(22+39)*12V+1. - * Which it always is, due to the 555 clamping to 12V*2/3. - * The Zip effect is hard to emulate 100% due to loading effects - * of the output stage on the charge stage. So I added some values - * to get a similar waveshape to the breadboarded circuit. - */ - DISCRETE_TRANSFORM5(NODE_31, 12, NODE_30, .5, RES_K(22)/RES_K(39), 0, "012-P4>*3*-") - - DISCRETE_555_CC(NODE_32, 1, NODE_31, RES_K(1.1), CAP_U(0.14), 0, RES_K(100), 500, &frogsZip555cc) - - DISCRETE_MIXER2(NODE_90, 1, NODE_32, 0, &frogsMixer) - - DISCRETE_OUTPUT(NODE_90, 1) - -DISCRETE_SOUND_END - -static const char *const frogs_sample_names[] = -{ - "*frogs", - "boing", - "buzzz", - "croak", - "hop", - "splash", - "zip", - nullptr -}; - - -void vicdual_state::frogs_audio(machine_config &config) -{ - SAMPLES(config, m_samples); - m_samples->set_channels(5); - m_samples->set_samples_names(frogs_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.35); - - DISCRETE(config, m_discrete, frogs_discrete); - m_discrete->add_route(ALL_OUTPUTS, "mono", 1.0); -} - - -TIMER_CALLBACK_MEMBER( vicdual_state::frogs_croak_callback ) -{ - m_samples->stop(2); -} - - -MACHINE_START_MEMBER(vicdual_state,frogs_audio) -{ - m_frogs_croak_timer = machine().scheduler().timer_alloc(timer_expired_delegate(FUNC(vicdual_state::frogs_croak_callback), this)); - - machine_start(); -} - - -void vicdual_state::frogs_audio_w(uint8_t data) -{ - static int last_croak = 0; - static int last_buzzz = 0; - int new_croak = data & 0x08; - int new_buzzz = data & 0x10; - -// m_discrete->write(FROGS_HOP_EN, data & 0x01); -// m_discrete->write(FROGS_JUMP_EN, data & 0x02); - m_discrete->write(FROGS_TONGUE_EN, data & 0x04); -// m_discrete->write(FROGS_CAPTURE_EN, data & 0x08); -// m_discrete->write(FROGS_FLY_EN, data & 0x10); -// m_discrete->write(FROGS_SPLASH_EN, data & 0x80); - - if (data & 0x01) - m_samples->start(3, 3); // Hop - if (data & 0x02) - m_samples->start(0, 0); // Boing - if (new_croak) - m_samples->start(2, 2); // Croak - else - { - if (last_croak) - { - /* The croak will keep playing until .429s after being disabled */ - m_frogs_croak_timer->adjust(attotime::from_double(1.1 * RES_K(390) * CAP_U(1))); - } - } - if (new_buzzz) - { - /* The Buzzz sound starts off a little louder in volume then - * settles down to a steady buzzz. Whenever the trigger goes - * low, the sound is disabled. If it then goes high, the buzzz - * then starts off louder again. The games does this every time - * the fly moves. - * So I made the sample start with the louder effect and then play - * for 12 seconds. A fly should move before this. If not the - * sample loops, adding the loud part as if the fly moved. - * This is obviously incorrect, but a fly never stands still for - * 12 seconds. - */ - if (!last_buzzz) - m_samples->start(1, 1, true); // Buzzz - } - else - m_samples->stop(1); - if (data & 0x80) - m_samples->start(4, 4); // Splash - - last_croak = new_croak; - last_buzzz = new_buzzz; -} - +#include "audio/nl_frogs.h" /************************************************************************ @@ -481,101 +300,55 @@ void vicdual_state::invho2_audio_w(uint8_t data) } -/* -static const char *const brdrline_sample_names[] = -{ - "*brdrline", - "boot_and_start", - "coin", - "crashes", - "end_level", - "engine_noise", - "field", - "fire", - nullptr -}; - - -void vicdual_state::brdrline_audio(machine_config &config) -{ - SAMPLES(config, m_samples); - m_samples->set_channels(7); - m_samples->set_samples_names(brdrline_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.35); -} - -void vicdual_state::brdrline_audio_w(uint8_t data) -{ - uint8_t res = data ^ 0xff; - -// if(res & 2) // low fuel, MISSING - - if(res & 8) // end level - m_samples->start(3, 3); - - if(res & 0x10) // moving in the brush - m_samples->start(5, 5); - - if(res & 0x20) // fire - m_samples->start(6, 6); - - if(res & 0x40) // car engine noise - m_samples->start(4, 4); - - if(res & 0x80) // crashes - m_samples->start(2, 2); - - //printf("%02x\n",res); -} - -void vicdual_state::brdrline_audio_aux_w(uint8_t data) -{ - if(data & 0xfc) // coin, unknown which is the trigger - m_samples->start(1, 1); - else // boot sample - m_samples->start(0, 0); -} -*/ - - /************************************* * - * Borderline + * Netlist-based Vic Dual Audio * *************************************/ -borderline_audio_device::borderline_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) : - device_t(mconfig, BORDERLINE_AUDIO, tag, owner, clock), +vicdual_audio_device_base::vicdual_audio_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 inputs_mask, void (*netlist)(netlist::nlparse_t &), double output_scale) : + device_t(mconfig, type, tag, owner, clock), device_mixer_interface(mconfig, *this), - m_input_line(*this, "sound_nl:in_%u", 0) + m_input_line(*this, "sound_nl:in_%u", 0), + m_inputs_mask(inputs_mask), + m_netlist(netlist), + m_output_scale(output_scale) { } -void borderline_audio_device::device_add_mconfig(machine_config &config) +void vicdual_audio_device_base::device_add_mconfig(machine_config &config) { NETLIST_SOUND(config, "sound_nl", 48000) - .set_source(NETLIST_NAME(brdrline)) + .set_source(m_netlist) .add_route(ALL_OUTPUTS, *this, 1.0); - NETLIST_LOGIC_INPUT(config, m_input_line[0], "I_SOUND_0.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[1], "I_SOUND_1.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[2], "I_SOUND_2.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[3], "I_SOUND_3.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[4], "I_SOUND_4.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[5], "I_SOUND_5.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[6], "I_SOUND_6.IN", 0); - NETLIST_LOGIC_INPUT(config, m_input_line[7], "I_SOUND_7.IN", 0); + if (BIT(m_inputs_mask, 0)) + NETLIST_LOGIC_INPUT(config, m_input_line[0], "I_SOUND_0.IN", 0); + if (BIT(m_inputs_mask, 1)) + NETLIST_LOGIC_INPUT(config, m_input_line[1], "I_SOUND_1.IN", 0); + if (BIT(m_inputs_mask, 2)) + NETLIST_LOGIC_INPUT(config, m_input_line[2], "I_SOUND_2.IN", 0); + if (BIT(m_inputs_mask, 3)) + NETLIST_LOGIC_INPUT(config, m_input_line[3], "I_SOUND_3.IN", 0); + if (BIT(m_inputs_mask, 4)) + NETLIST_LOGIC_INPUT(config, m_input_line[4], "I_SOUND_4.IN", 0); + if (BIT(m_inputs_mask, 5)) + NETLIST_LOGIC_INPUT(config, m_input_line[5], "I_SOUND_5.IN", 0); + if (BIT(m_inputs_mask, 6)) + NETLIST_LOGIC_INPUT(config, m_input_line[6], "I_SOUND_6.IN", 0); + if (BIT(m_inputs_mask, 7)) + NETLIST_LOGIC_INPUT(config, m_input_line[7], "I_SOUND_7.IN", 0); - NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(1.0, 0.0); + NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(m_output_scale, 0.0); } -void borderline_audio_device::device_start() +void vicdual_audio_device_base::device_start() { save_item(NAME(m_input_state)); } -void borderline_audio_device::write(u8 value) +void vicdual_audio_device_base::write(u8 value) { if (value != m_input_state) { @@ -586,4 +359,31 @@ void borderline_audio_device::write(u8 value) } } + +/************************************* + * + * Borderline/Tranquilizer Gun + * + *************************************/ + DEFINE_DEVICE_TYPE(BORDERLINE_AUDIO, borderline_audio_device, "borderline_audio", "Borderline Sound Board") + +borderline_audio_device::borderline_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) : + vicdual_audio_device_base(mconfig, BORDERLINE_AUDIO, tag, owner, clock, 0xff, NETLIST_NAME(brdrline), 1.0) +{ +} + + + +/************************************* + * + * Frogs + * + *************************************/ + +DEFINE_DEVICE_TYPE(FROGS_AUDIO, frogs_audio_device, "frogs_audio", "Frogs Sound Board") + +frogs_audio_device::frogs_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) : + vicdual_audio_device_base(mconfig, FROGS_AUDIO, tag, owner, clock, 0xff, NETLIST_NAME(frogs), 1.0) +{ +} diff --git a/src/mame/audio/vicdual.h b/src/mame/audio/vicdual.h index ab8aa45086e..e0a918899e2 100644 --- a/src/mame/audio/vicdual.h +++ b/src/mame/audio/vicdual.h @@ -9,22 +9,41 @@ #include "netlist/nl_setup.h" -class borderline_audio_device : public device_t, public device_mixer_interface +class vicdual_audio_device_base : public device_t, public device_mixer_interface { -public: - borderline_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +protected: + vicdual_audio_device_base(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 inputs_mask, void (*netlist)(netlist::nlparse_t &), double output_scale); virtual void device_add_mconfig(machine_config &config) override; virtual void device_start() override; +public: void write(u8 data); private: optional_device_array m_input_line; u8 m_input_state = 0xff; + u8 const m_inputs_mask; + void (*const m_netlist)(netlist::nlparse_t &); + double const m_output_scale; +}; + + +class borderline_audio_device : public vicdual_audio_device_base +{ +public: + borderline_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class frogs_audio_device : public vicdual_audio_device_base +{ +public: + frogs_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); }; DECLARE_DEVICE_TYPE(BORDERLINE_AUDIO, borderline_audio_device) +DECLARE_DEVICE_TYPE(FROGS_AUDIO, frogs_audio_device) #endif // MAME_AUDIO_VICDUAL_H diff --git a/src/mame/drivers/vicdual.cpp b/src/mame/drivers/vicdual.cpp index 88e8514a2e2..be4c5516c87 100644 --- a/src/mame/drivers/vicdual.cpp +++ b/src/mame/drivers/vicdual.cpp @@ -477,7 +477,7 @@ uint8_t vicdual_state::frogs_io_r(offs_t offset) void vicdual_state::frogs_io_w(offs_t offset, uint8_t data) { if (offset & 0x01) assert_coin_status(); - if (offset & 0x02) frogs_audio_w(data); + if (offset & 0x02) m_vicdual_sound->write(data); } @@ -557,14 +557,12 @@ void vicdual_state::frogs(machine_config &config) m_maincpu->set_addrmap(AS_PROGRAM, &vicdual_state::frogs_map); m_maincpu->set_addrmap(AS_IO, &vicdual_state::frogs_io_map); - MCFG_MACHINE_START_OVERRIDE(vicdual_state,frogs_audio) - /* video hardware */ m_screen->set_screen_update(FUNC(vicdual_state::screen_update_bw)); /* audio hardware */ SPEAKER(config, "mono").front_center(); - frogs_audio(config); + FROGS_AUDIO(config, m_vicdual_sound, 0).add_route(ALL_OUTPUTS, "mono", 1.0); } @@ -1168,12 +1166,8 @@ void carnival_state::carnival_io_w(offs_t offset, uint8_t data) void vicdual_state::brdrline_io_w(offs_t offset, uint8_t data) { - if (offset & 0x01) m_borderline_sound->write(data); - if (offset & 0x02) - { - palette_bank_w(data); -// brdrline_audio_aux_w(data); - } + if (offset & 0x01) m_vicdual_sound->write(data); + if (offset & 0x02) palette_bank_w(data); if (offset & 0x08) assert_coin_status(); } @@ -2279,7 +2273,7 @@ void vicdual_state::brdrline(machine_config &config) /* audio hardware */ SPEAKER(config, "mono").front_center(); - BORDERLINE_AUDIO(config, "borderline_sound", 0).add_route(ALL_OUTPUTS, "mono", 1.0); + BORDERLINE_AUDIO(config, m_vicdual_sound, 0).add_route(ALL_OUTPUTS, "mono", 1.0); } diff --git a/src/mame/includes/vicdual.h b/src/mame/includes/vicdual.h index 0c00c712f0a..94edc7e6884 100644 --- a/src/mame/includes/vicdual.h +++ b/src/mame/includes/vicdual.h @@ -30,7 +30,7 @@ public: m_coinstate_timer(*this, "coinstate"), m_nsub_coinage_timer(*this, "nsub_coin"), m_screen(*this, "screen"), - m_borderline_sound(*this, "borderline_sound"), + m_vicdual_sound(*this, "vicdual_sound"), m_proms(*this, "proms"), m_videoram(*this, "videoram"), m_characterram(*this, "characterram"), @@ -51,7 +51,6 @@ public: void headonn(machine_config &config); void invho2(machine_config &config); void frogs(machine_config &config); - void frogs_audio(machine_config &config); void headons(machine_config &config); void invinco(machine_config &config); void invinco_audio(machine_config &config); @@ -89,7 +88,7 @@ protected: required_device m_coinstate_timer; optional_device m_nsub_coinage_timer; required_device m_screen; - optional_device m_borderline_sound; + optional_device m_vicdual_sound; optional_memory_region m_proms; required_shared_ptr m_videoram; @@ -148,10 +147,8 @@ protected: void invinco_io_w(offs_t offset, uint8_t data); /*----------- defined in audio/vicdual.cpp -----------*/ - void frogs_audio_w(uint8_t data); void headon_audio_w(uint8_t data); void invho2_audio_w(uint8_t data); - TIMER_CALLBACK_MEMBER( frogs_croak_callback ); /*----------- defined in audio/depthch.cpp -----------*/ void depthch_audio_w(uint8_t data); @@ -169,7 +166,6 @@ protected: TIMER_DEVICE_CALLBACK_MEMBER(clear_coin_status); DECLARE_MACHINE_START(samurai); - DECLARE_MACHINE_START(frogs_audio); virtual void machine_start() override; diff --git a/src/mame/nl.lst b/src/mame/nl.lst index 8c199c4b74c..0071872f41d 100644 --- a/src/mame/nl.lst +++ b/src/mame/nl.lst @@ -370,6 +370,7 @@ brdrline // (c) 1980 Sega brdrlinet // (c) 1981 Sega brdrlins // Sidam bootleg starrkr // (c) 1981 Sega +frogs // 112-119 [1978 Gremlin?] @source:zaxxon.cpp congo // 605-5167 (c) 1983 (2 board stack)