summaryrefslogtreecommitdiffstatshomepage
diff options
context:
space:
mode:
author Aaron Giles <aaron@aarongiles.com>2020-10-07 01:06:20 -0700
committer Aaron Giles <aaron@aarongiles.com>2020-10-07 01:06:20 -0700
commit4fb2dfeb6926f8c8a244915cfafde799e4495bc5 (patch)
tree53ab0c1264b5cf6db4757ac1e6c0b4dcc3fb4e9d
parent288ca1150361d70ec0b44bf0183867530037ef9d (diff)
vicdual: Add frogs netlist. Make sound board interface more general.
-rw-r--r--scripts/target/mame/arcade.lua2
-rw-r--r--scripts/target/mame/nl.lua2
-rw-r--r--src/lib/netlist/generated/static_solvers.cpp3284
-rw-r--r--src/mame/audio/nl_frogs.cpp540
-rw-r--r--src/mame/audio/nl_frogs.h10
-rw-r--r--src/mame/audio/vicdual.cpp314
-rw-r--r--src/mame/audio/vicdual.h25
-rw-r--r--src/mame/drivers/vicdual.cpp16
-rw-r--r--src/mame/includes/vicdual.h8
-rw-r--r--src/mame/nl.lst1
10 files changed, 3716 insertions, 486 deletions
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<void *>(&nl_gcr_11c2ae166b240b6e_10_double_double)}, // NOLINT
+ {"nl_gcr_11c2ae166b240b6e_10_double_double", reinterpret_cast<void *>(&nl_gcr_11c2ae166b240b6e_10_double_double)},
// tankbatt
- {"nl_gcr_124f7aa10f044582_16_double_double", reinterpret_cast<void *>(&nl_gcr_124f7aa10f044582_16_double_double)}, // NOLINT
+ {"nl_gcr_124f7aa10f044582_16_double_double", reinterpret_cast<void *>(&nl_gcr_124f7aa10f044582_16_double_double)},
// armora
- {"nl_gcr_1250f340dea396ae_22_double_double", reinterpret_cast<void *>(&nl_gcr_1250f340dea396ae_22_double_double)}, // NOLINT
+ {"nl_gcr_1250f340dea396ae_22_double_double", reinterpret_cast<void *>(&nl_gcr_1250f340dea396ae_22_double_double)},
// astrob
- {"nl_gcr_13833bf8c127deaa_154_double_double", reinterpret_cast<void *>(&nl_gcr_13833bf8c127deaa_154_double_double)}, // NOLINT
+ {"nl_gcr_13833bf8c127deaa_154_double_double", reinterpret_cast<void *>(&nl_gcr_13833bf8c127deaa_154_double_double)},
// pongf
- {"nl_gcr_13e7b5ac1a260dbf_10_double_double", reinterpret_cast<void *>(&nl_gcr_13e7b5ac1a260dbf_10_double_double)}, // NOLINT
+ {"nl_gcr_13e7b5ac1a260dbf_10_double_double", reinterpret_cast<void *>(&nl_gcr_13e7b5ac1a260dbf_10_double_double)},
// tailg
- {"nl_gcr_144ed14e6bafdb_119_double_double", reinterpret_cast<void *>(&nl_gcr_144ed14e6bafdb_119_double_double)}, // NOLINT
+ {"nl_gcr_144ed14e6bafdb_119_double_double", reinterpret_cast<void *>(&nl_gcr_144ed14e6bafdb_119_double_double)},
// spacewar
- {"nl_gcr_15e8f6fb021de0f9_28_double_double", reinterpret_cast<void *>(&nl_gcr_15e8f6fb021de0f9_28_double_double)}, // NOLINT
+ {"nl_gcr_15e8f6fb021de0f9_28_double_double", reinterpret_cast<void *>(&nl_gcr_15e8f6fb021de0f9_28_double_double)},
// dpatrol
- {"nl_gcr_18f4d9160b51d613_20_double_double", reinterpret_cast<void *>(&nl_gcr_18f4d9160b51d613_20_double_double)}, // NOLINT
+ {"nl_gcr_18f4d9160b51d613_20_double_double", reinterpret_cast<void *>(&nl_gcr_18f4d9160b51d613_20_double_double)},
// starhawk
- {"nl_gcr_1f1086787c94f97c_40_double_double", reinterpret_cast<void *>(&nl_gcr_1f1086787c94f97c_40_double_double)}, // NOLINT
+ {"nl_gcr_1f1086787c94f97c_40_double_double", reinterpret_cast<void *>(&nl_gcr_1f1086787c94f97c_40_double_double)},
// zac1b11142
- {"nl_gcr_1fad5cda2646cf42_30_double_double", reinterpret_cast<void *>(&nl_gcr_1fad5cda2646cf42_30_double_double)}, // NOLINT
+ {"nl_gcr_1fad5cda2646cf42_30_double_double", reinterpret_cast<void *>(&nl_gcr_1fad5cda2646cf42_30_double_double)},
// sspeedr
- {"nl_gcr_2294220d3c91e762_176_double_double", reinterpret_cast<void *>(&nl_gcr_2294220d3c91e762_176_double_double)}, // NOLINT
+ {"nl_gcr_2294220d3c91e762_176_double_double", reinterpret_cast<void *>(&nl_gcr_2294220d3c91e762_176_double_double)},
// 280zzzap
- {"nl_gcr_24643c159711f292_95_double_double", reinterpret_cast<void *>(&nl_gcr_24643c159711f292_95_double_double)}, // NOLINT
+ {"nl_gcr_24643c159711f292_95_double_double", reinterpret_cast<void *>(&nl_gcr_24643c159711f292_95_double_double)},
// brdrline
- {"nl_gcr_2753fc1815ce0cba_23_double_double", reinterpret_cast<void *>(&nl_gcr_2753fc1815ce0cba_23_double_double)}, // NOLINT
+ {"nl_gcr_2753fc1815ce0cba_23_double_double", reinterpret_cast<void *>(&nl_gcr_2753fc1815ce0cba_23_double_double)},
// zac1b11142
- {"nl_gcr_287a160e7c36b5b0_96_double_double", reinterpret_cast<void *>(&nl_gcr_287a160e7c36b5b0_96_double_double)}, // NOLINT
+ {"nl_gcr_287a160e7c36b5b0_96_double_double", reinterpret_cast<void *>(&nl_gcr_287a160e7c36b5b0_96_double_double)},
// elim
- {"nl_gcr_28b736fe552777a9_45_double_double", reinterpret_cast<void *>(&nl_gcr_28b736fe552777a9_45_double_double)}, // NOLINT
+ {"nl_gcr_28b736fe552777a9_45_double_double", reinterpret_cast<void *>(&nl_gcr_28b736fe552777a9_45_double_double)},
// kidniki
- {"nl_gcr_294dde1e0ecca6d0_37_double_double", reinterpret_cast<void *>(&nl_gcr_294dde1e0ecca6d0_37_double_double)}, // NOLINT
+ {"nl_gcr_294dde1e0ecca6d0_37_double_double", reinterpret_cast<void *>(&nl_gcr_294dde1e0ecca6d0_37_double_double)},
// ripoff
- {"nl_gcr_295cf2e2f3d489bf_12_double_double", reinterpret_cast<void *>(&nl_gcr_295cf2e2f3d489bf_12_double_double)}, // NOLINT
+ {"nl_gcr_295cf2e2f3d489bf_12_double_double", reinterpret_cast<void *>(&nl_gcr_295cf2e2f3d489bf_12_double_double)},
// spacfury
- {"nl_gcr_2a153513d3e8e2cc_53_double_double", reinterpret_cast<void *>(&nl_gcr_2a153513d3e8e2cc_53_double_double)}, // NOLINT
+ {"nl_gcr_2a153513d3e8e2cc_53_double_double", reinterpret_cast<void *>(&nl_gcr_2a153513d3e8e2cc_53_double_double)},
// boxingb
- {"nl_gcr_2f84bc98d737730b_22_double_double", reinterpret_cast<void *>(&nl_gcr_2f84bc98d737730b_22_double_double)}, // NOLINT
+ {"nl_gcr_2f84bc98d737730b_22_double_double", reinterpret_cast<void *>(&nl_gcr_2f84bc98d737730b_22_double_double)},
// brdrline
- {"nl_gcr_30923b54310ae144_8_double_double", reinterpret_cast<void *>(&nl_gcr_30923b54310ae144_8_double_double)}, // NOLINT
+ {"nl_gcr_30923b54310ae144_8_double_double", reinterpret_cast<void *>(&nl_gcr_30923b54310ae144_8_double_double)},
// tankbatt
- {"nl_gcr_328d886b444b586b_137_double_double", reinterpret_cast<void *>(&nl_gcr_328d886b444b586b_137_double_double)}, // NOLINT
+ {"nl_gcr_328d886b444b586b_137_double_double", reinterpret_cast<void *>(&nl_gcr_328d886b444b586b_137_double_double)},
// astrob
- {"nl_gcr_339c6b457f339538_159_double_double", reinterpret_cast<void *>(&nl_gcr_339c6b457f339538_159_double_double)}, // NOLINT
+ {"nl_gcr_339c6b457f339538_159_double_double", reinterpret_cast<void *>(&nl_gcr_339c6b457f339538_159_double_double)},
// solarq
- {"nl_gcr_34e910fc1896999f_76_double_double", reinterpret_cast<void *>(&nl_gcr_34e910fc1896999f_76_double_double)}, // NOLINT
+ {"nl_gcr_34e910fc1896999f_76_double_double", reinterpret_cast<void *>(&nl_gcr_34e910fc1896999f_76_double_double)},
// brdrline
- {"nl_gcr_3c79fd354e01fa8c_89_double_double", reinterpret_cast<void *>(&nl_gcr_3c79fd354e01fa8c_89_double_double)}, // NOLINT
+ {"nl_gcr_3c79fd354e01fa8c_89_double_double", reinterpret_cast<void *>(&nl_gcr_3c79fd354e01fa8c_89_double_double)},
// sspeedr
- {"nl_gcr_3e833834e5ce5aee_13_double_double", reinterpret_cast<void *>(&nl_gcr_3e833834e5ce5aee_13_double_double)}, // NOLINT
+ {"nl_gcr_3e833834e5ce5aee_13_double_double", reinterpret_cast<void *>(&nl_gcr_3e833834e5ce5aee_13_double_double)},
// astrob
- {"nl_gcr_41c6441d98369158_20_double_double", reinterpret_cast<void *>(&nl_gcr_41c6441d98369158_20_double_double)}, // NOLINT
+ {"nl_gcr_41c6441d98369158_20_double_double", reinterpret_cast<void *>(&nl_gcr_41c6441d98369158_20_double_double)},
// warrior
- {"nl_gcr_42a31ce5c187b308_12_double_double", reinterpret_cast<void *>(&nl_gcr_42a31ce5c187b308_12_double_double)}, // NOLINT
+ {"nl_gcr_42a31ce5c187b308_12_double_double", reinterpret_cast<void *>(&nl_gcr_42a31ce5c187b308_12_double_double)},
// 280zzzap
- {"nl_gcr_42c57d523cac30d0_122_double_double", reinterpret_cast<void *>(&nl_gcr_42c57d523cac30d0_122_double_double)}, // NOLINT
+ {"nl_gcr_42c57d523cac30d0_122_double_double", reinterpret_cast<void *>(&nl_gcr_42c57d523cac30d0_122_double_double)},
// ripoff
- {"nl_gcr_43188bf576854ae0_10_double_double", reinterpret_cast<void *>(&nl_gcr_43188bf576854ae0_10_double_double)}, // NOLINT
+ {"nl_gcr_43188bf576854ae0_10_double_double", reinterpret_cast<void *>(&nl_gcr_43188bf576854ae0_10_double_double)},
// destroyr
- {"nl_gcr_4334c95878d1be92_399_double_double", reinterpret_cast<void *>(&nl_gcr_4334c95878d1be92_399_double_double)}, // NOLINT
+ {"nl_gcr_4334c95878d1be92_399_double_double", reinterpret_cast<void *>(&nl_gcr_4334c95878d1be92_399_double_double)},
// brdrline
- {"nl_gcr_437326911721091_77_double_double", reinterpret_cast<void *>(&nl_gcr_437326911721091_77_double_double)}, // NOLINT
+ {"nl_gcr_437326911721091_77_double_double", reinterpret_cast<void *>(&nl_gcr_437326911721091_77_double_double)},
// kidniki
- {"nl_gcr_43f7ff9bc651cc7a_198_double_double", reinterpret_cast<void *>(&nl_gcr_43f7ff9bc651cc7a_198_double_double)}, // NOLINT
+ {"nl_gcr_43f7ff9bc651cc7a_198_double_double", reinterpret_cast<void *>(&nl_gcr_43f7ff9bc651cc7a_198_double_double)},
// gamemachine
- {"nl_gcr_491f95430bfdfd05_19_double_double", reinterpret_cast<void *>(&nl_gcr_491f95430bfdfd05_19_double_double)}, // NOLINT
+ {"nl_gcr_491f95430bfdfd05_19_double_double", reinterpret_cast<void *>(&nl_gcr_491f95430bfdfd05_19_double_double)},
// sspeedr
- {"nl_gcr_4a8e2b707bbac8a6_95_double_double", reinterpret_cast<void *>(&nl_gcr_4a8e2b707bbac8a6_95_double_double)}, // NOLINT
+ {"nl_gcr_4a8e2b707bbac8a6_95_double_double", reinterpret_cast<void *>(&nl_gcr_4a8e2b707bbac8a6_95_double_double)},
// ripoff
- {"nl_gcr_4b5ecfbb8f9fa97b_29_double_double", reinterpret_cast<void *>(&nl_gcr_4b5ecfbb8f9fa97b_29_double_double)}, // NOLINT
+ {"nl_gcr_4b5ecfbb8f9fa97b_29_double_double", reinterpret_cast<void *>(&nl_gcr_4b5ecfbb8f9fa97b_29_double_double)},
// gtrak10
- {"nl_gcr_4c46fdf7c0037727_43_double_double", reinterpret_cast<void *>(&nl_gcr_4c46fdf7c0037727_43_double_double)}, // NOLINT
+ {"nl_gcr_4c46fdf7c0037727_43_double_double", reinterpret_cast<void *>(&nl_gcr_4c46fdf7c0037727_43_double_double)},
// solarq
- {"nl_gcr_4cb524006206eb1a_25_double_double", reinterpret_cast<void *>(&nl_gcr_4cb524006206eb1a_25_double_double)}, // NOLINT
+ {"nl_gcr_4cb524006206eb1a_25_double_double", reinterpret_cast<void *>(&nl_gcr_4cb524006206eb1a_25_double_double)},
// spacfury
- {"nl_gcr_4dbd0f2aec7ef707_110_double_double", reinterpret_cast<void *>(&nl_gcr_4dbd0f2aec7ef707_110_double_double)}, // NOLINT
+ {"nl_gcr_4dbd0f2aec7ef707_110_double_double", reinterpret_cast<void *>(&nl_gcr_4dbd0f2aec7ef707_110_double_double)},
// solarq
- {"nl_gcr_4e4931ccbfb7a3c_70_double_double", reinterpret_cast<void *>(&nl_gcr_4e4931ccbfb7a3c_70_double_double)}, // NOLINT
+ {"nl_gcr_4e4931ccbfb7a3c_70_double_double", reinterpret_cast<void *>(&nl_gcr_4e4931ccbfb7a3c_70_double_double)},
// fireone
- {"nl_gcr_4f2b2f3cdc384f75_41_double_double", reinterpret_cast<void *>(&nl_gcr_4f2b2f3cdc384f75_41_double_double)}, // NOLINT
+ {"nl_gcr_4f2b2f3cdc384f75_41_double_double", reinterpret_cast<void *>(&nl_gcr_4f2b2f3cdc384f75_41_double_double)},
// boxingb
- {"nl_gcr_50f5194a994d56ec_16_double_double", reinterpret_cast<void *>(&nl_gcr_50f5194a994d56ec_16_double_double)}, // NOLINT
+ {"nl_gcr_50f5194a994d56ec_16_double_double", reinterpret_cast<void *>(&nl_gcr_50f5194a994d56ec_16_double_double)},
// starhawk
- {"nl_gcr_528a27fe9ed07d67_45_double_double", reinterpret_cast<void *>(&nl_gcr_528a27fe9ed07d67_45_double_double)}, // NOLINT
+ {"nl_gcr_528a27fe9ed07d67_45_double_double", reinterpret_cast<void *>(&nl_gcr_528a27fe9ed07d67_45_double_double)},
// astrob
- {"nl_gcr_536c3652eb3bc075_46_double_double", reinterpret_cast<void *>(&nl_gcr_536c3652eb3bc075_46_double_double)}, // NOLINT
+ {"nl_gcr_536c3652eb3bc075_46_double_double", reinterpret_cast<void *>(&nl_gcr_536c3652eb3bc075_46_double_double)},
// boxingb
- {"nl_gcr_53e1117fdb16f546_23_double_double", reinterpret_cast<void *>(&nl_gcr_53e1117fdb16f546_23_double_double)}, // NOLINT
+ {"nl_gcr_53e1117fdb16f546_23_double_double", reinterpret_cast<void *>(&nl_gcr_53e1117fdb16f546_23_double_double)},
// cheekyms
- {"nl_gcr_546396f65ce48700_12_double_double", reinterpret_cast<void *>(&nl_gcr_546396f65ce48700_12_double_double)}, // NOLINT
+ {"nl_gcr_546396f65ce48700_12_double_double", reinterpret_cast<void *>(&nl_gcr_546396f65ce48700_12_double_double)},
// brdrline
- {"nl_gcr_59cb6bf7cb9d17dc_7_double_double", reinterpret_cast<void *>(&nl_gcr_59cb6bf7cb9d17dc_7_double_double)}, // NOLINT
+ {"nl_gcr_59cb6bf7cb9d17dc_7_double_double", reinterpret_cast<void *>(&nl_gcr_59cb6bf7cb9d17dc_7_double_double)},
// breakout
- {"nl_gcr_5a3419e2809520de_13_double_double", reinterpret_cast<void *>(&nl_gcr_5a3419e2809520de_13_double_double)}, // NOLINT
+ {"nl_gcr_5a3419e2809520de_13_double_double", reinterpret_cast<void *>(&nl_gcr_5a3419e2809520de_13_double_double)},
// segausb
- {"nl_gcr_5b73834d5f313d38_12_double_double", reinterpret_cast<void *>(&nl_gcr_5b73834d5f313d38_12_double_double)}, // NOLINT
+ {"nl_gcr_5b73834d5f313d38_12_double_double", reinterpret_cast<void *>(&nl_gcr_5b73834d5f313d38_12_double_double)},
// tailg
- {"nl_gcr_5ccf7da1202da2e5_31_double_double", reinterpret_cast<void *>(&nl_gcr_5ccf7da1202da2e5_31_double_double)}, // NOLINT
+ {"nl_gcr_5ccf7da1202da2e5_31_double_double", reinterpret_cast<void *>(&nl_gcr_5ccf7da1202da2e5_31_double_double)},
// starcas
- {"nl_gcr_5d550fc7441617a2_109_double_double", reinterpret_cast<void *>(&nl_gcr_5d550fc7441617a2_109_double_double)}, // NOLINT
+ {"nl_gcr_5d550fc7441617a2_109_double_double", reinterpret_cast<void *>(&nl_gcr_5d550fc7441617a2_109_double_double)},
// zac1b11142
- {"nl_gcr_6041272373b8603c_178_double_double", reinterpret_cast<void *>(&nl_gcr_6041272373b8603c_178_double_double)}, // NOLINT
+ {"nl_gcr_6041272373b8603c_178_double_double", reinterpret_cast<void *>(&nl_gcr_6041272373b8603c_178_double_double)},
// astrob
- {"nl_gcr_62464664b1c5aa1e_27_double_double", reinterpret_cast<void *>(&nl_gcr_62464664b1c5aa1e_27_double_double)}, // NOLINT
+ {"nl_gcr_62464664b1c5aa1e_27_double_double", reinterpret_cast<void *>(&nl_gcr_62464664b1c5aa1e_27_double_double)},
// solarq
- {"nl_gcr_62612f71055b8fd4_303_double_double", reinterpret_cast<void *>(&nl_gcr_62612f71055b8fd4_303_double_double)}, // NOLINT
+ {"nl_gcr_62612f71055b8fd4_303_double_double", reinterpret_cast<void *>(&nl_gcr_62612f71055b8fd4_303_double_double)},
// konami1x
- {"nl_gcr_62b99b9904a8c804_49_double_double", reinterpret_cast<void *>(&nl_gcr_62b99b9904a8c804_49_double_double)}, // NOLINT
+ {"nl_gcr_62b99b9904a8c804_49_double_double", reinterpret_cast<void *>(&nl_gcr_62b99b9904a8c804_49_double_double)},
// fireone
- {"nl_gcr_643133e86b2b1628_73_double_double", reinterpret_cast<void *>(&nl_gcr_643133e86b2b1628_73_double_double)}, // NOLINT
+ {"nl_gcr_643133e86b2b1628_73_double_double", reinterpret_cast<void *>(&nl_gcr_643133e86b2b1628_73_double_double)},
// starfire
- {"nl_gcr_649ebca7fa6793ed_27_double_double", reinterpret_cast<void *>(&nl_gcr_649ebca7fa6793ed_27_double_double)}, // NOLINT
+ {"nl_gcr_649ebca7fa6793ed_27_double_double", reinterpret_cast<void *>(&nl_gcr_649ebca7fa6793ed_27_double_double)},
// armora
- {"nl_gcr_64e460d8f716cd89_58_double_double", reinterpret_cast<void *>(&nl_gcr_64e460d8f716cd89_58_double_double)}, // NOLINT
+ {"nl_gcr_64e460d8f716cd89_58_double_double", reinterpret_cast<void *>(&nl_gcr_64e460d8f716cd89_58_double_double)},
// flyball
- {"nl_gcr_6622b53554e3776_291_double_double", reinterpret_cast<void *>(&nl_gcr_6622b53554e3776_291_double_double)}, // NOLINT
+ {"nl_gcr_6622b53554e3776_291_double_double", reinterpret_cast<void *>(&nl_gcr_6622b53554e3776_291_double_double)},
// solarq
- {"nl_gcr_66496d6073aca98e_20_double_double", reinterpret_cast<void *>(&nl_gcr_66496d6073aca98e_20_double_double)}, // NOLINT
+ {"nl_gcr_66496d6073aca98e_20_double_double", reinterpret_cast<void *>(&nl_gcr_66496d6073aca98e_20_double_double)},
// starhawk
- {"nl_gcr_67838e11f714c455_12_double_double", reinterpret_cast<void *>(&nl_gcr_67838e11f714c455_12_double_double)}, // NOLINT
+ {"nl_gcr_67838e11f714c455_12_double_double", reinterpret_cast<void *>(&nl_gcr_67838e11f714c455_12_double_double)},
// ripoff
- {"nl_gcr_698d5dd47fb16d5_16_double_double", reinterpret_cast<void *>(&nl_gcr_698d5dd47fb16d5_16_double_double)}, // NOLINT
+ {"nl_gcr_698d5dd47fb16d5_16_double_double", reinterpret_cast<void *>(&nl_gcr_698d5dd47fb16d5_16_double_double)},
// astrob
- {"nl_gcr_6c24726f30e8dc34_15_double_double", reinterpret_cast<void *>(&nl_gcr_6c24726f30e8dc34_15_double_double)}, // NOLINT
+ {"nl_gcr_6c24726f30e8dc34_15_double_double", reinterpret_cast<void *>(&nl_gcr_6c24726f30e8dc34_15_double_double)},
// spacfury
- {"nl_gcr_6eae7b15cd376318_43_double_double", reinterpret_cast<void *>(&nl_gcr_6eae7b15cd376318_43_double_double)}, // NOLINT
+ {"nl_gcr_6eae7b15cd376318_43_double_double", reinterpret_cast<void *>(&nl_gcr_6eae7b15cd376318_43_double_double)},
// barrier
- {"nl_gcr_6ef39a62161d596c_47_double_double", reinterpret_cast<void *>(&nl_gcr_6ef39a62161d596c_47_double_double)}, // NOLINT
+ {"nl_gcr_6ef39a62161d596c_47_double_double", reinterpret_cast<void *>(&nl_gcr_6ef39a62161d596c_47_double_double)},
// starhawk
- {"nl_gcr_723fa454468a93d_7_double_double", reinterpret_cast<void *>(&nl_gcr_723fa454468a93d_7_double_double)}, // NOLINT
+ {"nl_gcr_723fa454468a93d_7_double_double", reinterpret_cast<void *>(&nl_gcr_723fa454468a93d_7_double_double)},
// cheekyms
- {"nl_gcr_733c72a820fdbd1f_7_double_double", reinterpret_cast<void *>(&nl_gcr_733c72a820fdbd1f_7_double_double)}, // NOLINT
+ {"nl_gcr_733c72a820fdbd1f_7_double_double", reinterpret_cast<void *>(&nl_gcr_733c72a820fdbd1f_7_double_double)},
// tailg
- {"nl_gcr_7388106355fb27c3_12_double_double", reinterpret_cast<void *>(&nl_gcr_7388106355fb27c3_12_double_double)}, // NOLINT
+ {"nl_gcr_7388106355fb27c3_12_double_double", reinterpret_cast<void *>(&nl_gcr_7388106355fb27c3_12_double_double)},
// tp1985
- {"nl_gcr_73f2ba8ad4a45b26_10_double_double", reinterpret_cast<void *>(&nl_gcr_73f2ba8ad4a45b26_10_double_double)}, // NOLINT
+ {"nl_gcr_73f2ba8ad4a45b26_10_double_double", reinterpret_cast<void *>(&nl_gcr_73f2ba8ad4a45b26_10_double_double)},
// zac1b11142
- {"nl_gcr_7425594cec8024ad_30_double_double", reinterpret_cast<void *>(&nl_gcr_7425594cec8024ad_30_double_double)}, // NOLINT
+ {"nl_gcr_7425594cec8024ad_30_double_double", reinterpret_cast<void *>(&nl_gcr_7425594cec8024ad_30_double_double)},
// tp1985
- {"nl_gcr_74349e9889a2630b_7_double_double", reinterpret_cast<void *>(&nl_gcr_74349e9889a2630b_7_double_double)}, // NOLINT
+ {"nl_gcr_74349e9889a2630b_7_double_double", reinterpret_cast<void *>(&nl_gcr_74349e9889a2630b_7_double_double)},
// gunfight
- {"nl_gcr_743595e64cee0a5e_112_double_double", reinterpret_cast<void *>(&nl_gcr_743595e64cee0a5e_112_double_double)}, // NOLINT
+ {"nl_gcr_743595e64cee0a5e_112_double_double", reinterpret_cast<void *>(&nl_gcr_743595e64cee0a5e_112_double_double)},
// brdrline
- {"nl_gcr_75400df5d559a266_75_double_double", reinterpret_cast<void *>(&nl_gcr_75400df5d559a266_75_double_double)}, // NOLINT
+ {"nl_gcr_75400df5d559a266_75_double_double", reinterpret_cast<void *>(&nl_gcr_75400df5d559a266_75_double_double)},
// ripoff
- {"nl_gcr_76c9e236353caed1_35_double_double", reinterpret_cast<void *>(&nl_gcr_76c9e236353caed1_35_double_double)}, // NOLINT
+ {"nl_gcr_76c9e236353caed1_35_double_double", reinterpret_cast<void *>(&nl_gcr_76c9e236353caed1_35_double_double)},
// gamemachine
- {"nl_gcr_782d79b5cbe953b1_7_double_double", reinterpret_cast<void *>(&nl_gcr_782d79b5cbe953b1_7_double_double)}, // NOLINT
+ {"nl_gcr_782d79b5cbe953b1_7_double_double", reinterpret_cast<void *>(&nl_gcr_782d79b5cbe953b1_7_double_double)},
// barrier
- {"nl_gcr_79e756c5892cf87d_31_double_double", reinterpret_cast<void *>(&nl_gcr_79e756c5892cf87d_31_double_double)}, // NOLINT
+ {"nl_gcr_79e756c5892cf87d_31_double_double", reinterpret_cast<void *>(&nl_gcr_79e756c5892cf87d_31_double_double)},
// breakout
- {"nl_gcr_7a42b97d838ca073_7_double_double", reinterpret_cast<void *>(&nl_gcr_7a42b97d838ca073_7_double_double)}, // NOLINT
+ {"nl_gcr_7a42b97d838ca073_7_double_double", reinterpret_cast<void *>(&nl_gcr_7a42b97d838ca073_7_double_double)},
// fireone
- {"nl_gcr_7aee4423e3fdbfda_128_double_double", reinterpret_cast<void *>(&nl_gcr_7aee4423e3fdbfda_128_double_double)}, // NOLINT
+ {"nl_gcr_7aee4423e3fdbfda_128_double_double", reinterpret_cast<void *>(&nl_gcr_7aee4423e3fdbfda_128_double_double)},
// astrob
- {"nl_gcr_7c86a9bc1c6aef4c_7_double_double", reinterpret_cast<void *>(&nl_gcr_7c86a9bc1c6aef4c_7_double_double)}, // NOLINT
+ {"nl_gcr_7c86a9bc1c6aef4c_7_double_double", reinterpret_cast<void *>(&nl_gcr_7c86a9bc1c6aef4c_7_double_double)},
// solarq
- {"nl_gcr_7caaa135bff3d9f3_15_double_double", reinterpret_cast<void *>(&nl_gcr_7caaa135bff3d9f3_15_double_double)}, // NOLINT
+ {"nl_gcr_7caaa135bff3d9f3_15_double_double", reinterpret_cast<void *>(&nl_gcr_7caaa135bff3d9f3_15_double_double)},
// warrior
- {"nl_gcr_8003d4625273fa4d_10_double_double", reinterpret_cast<void *>(&nl_gcr_8003d4625273fa4d_10_double_double)}, // NOLINT
+ {"nl_gcr_8003d4625273fa4d_10_double_double", reinterpret_cast<void *>(&nl_gcr_8003d4625273fa4d_10_double_double)},
// kidniki
- {"nl_gcr_8046625a0fe0959_21_double_double", reinterpret_cast<void *>(&nl_gcr_8046625a0fe0959_21_double_double)}, // NOLINT
+ {"nl_gcr_8046625a0fe0959_21_double_double", reinterpret_cast<void *>(&nl_gcr_8046625a0fe0959_21_double_double)},
// mario
- {"nl_gcr_80b4b1e5cc58d303_29_double_double", reinterpret_cast<void *>(&nl_gcr_80b4b1e5cc58d303_29_double_double)}, // NOLINT
+ {"nl_gcr_80b4b1e5cc58d303_29_double_double", reinterpret_cast<void *>(&nl_gcr_80b4b1e5cc58d303_29_double_double)},
+// frogs
+ {"nl_gcr_815733e3f2e05029_9_double_double", reinterpret_cast<void *>(&nl_gcr_815733e3f2e05029_9_double_double)},
// elim
- {"nl_gcr_81f40a54af2ca202_10_double_double", reinterpret_cast<void *>(&nl_gcr_81f40a54af2ca202_10_double_double)}, // NOLINT
+ {"nl_gcr_81f40a54af2ca202_10_double_double", reinterpret_cast<void *>(&nl_gcr_81f40a54af2ca202_10_double_double)},
+// frogs
+ {"nl_gcr_8213b1839349be25_422_double_double", reinterpret_cast<void *>(&nl_gcr_8213b1839349be25_422_double_double)},
+// frogs
+ {"nl_gcr_84425fea9033e75d_7_double_double", reinterpret_cast<void *>(&nl_gcr_84425fea9033e75d_7_double_double)},
// sundance
- {"nl_gcr_8446e63d7842f6a6_70_double_double", reinterpret_cast<void *>(&nl_gcr_8446e63d7842f6a6_70_double_double)}, // NOLINT
+ {"nl_gcr_8446e63d7842f6a6_70_double_double", reinterpret_cast<void *>(&nl_gcr_8446e63d7842f6a6_70_double_double)},
// dpatrol
- {"nl_gcr_85652d3e3ada285a_10_double_double", reinterpret_cast<void *>(&nl_gcr_85652d3e3ada285a_10_double_double)}, // NOLINT
+ {"nl_gcr_85652d3e3ada285a_10_double_double", reinterpret_cast<void *>(&nl_gcr_85652d3e3ada285a_10_double_double)},
// zac1b11142
- {"nl_gcr_861d39f81d29d51_12_double_double", reinterpret_cast<void *>(&nl_gcr_861d39f81d29d51_12_double_double)}, // NOLINT
+ {"nl_gcr_861d39f81d29d51_12_double_double", reinterpret_cast<void *>(&nl_gcr_861d39f81d29d51_12_double_double)},
// 280zzzap
- {"nl_gcr_864a61c57bac9c38_123_double_double", reinterpret_cast<void *>(&nl_gcr_864a61c57bac9c38_123_double_double)}, // NOLINT
+ {"nl_gcr_864a61c57bac9c38_123_double_double", reinterpret_cast<void *>(&nl_gcr_864a61c57bac9c38_123_double_double)},
// zac1b11142
- {"nl_gcr_87cb2c78a2628efd_7_double_double", reinterpret_cast<void *>(&nl_gcr_87cb2c78a2628efd_7_double_double)}, // NOLINT
+ {"nl_gcr_87cb2c78a2628efd_7_double_double", reinterpret_cast<void *>(&nl_gcr_87cb2c78a2628efd_7_double_double)},
// starcas
- {"nl_gcr_88a8ef5f6bd43d48_12_double_double", reinterpret_cast<void *>(&nl_gcr_88a8ef5f6bd43d48_12_double_double)}, // NOLINT
+ {"nl_gcr_88a8ef5f6bd43d48_12_double_double", reinterpret_cast<void *>(&nl_gcr_88a8ef5f6bd43d48_12_double_double)},
// breakout
- {"nl_gcr_8a1565d1413f42f7_31_double_double", reinterpret_cast<void *>(&nl_gcr_8a1565d1413f42f7_31_double_double)}, // NOLINT
+ {"nl_gcr_8a1565d1413f42f7_31_double_double", reinterpret_cast<void *>(&nl_gcr_8a1565d1413f42f7_31_double_double)},
// starhawk
- {"nl_gcr_8b1ac1e181eec3fc_40_double_double", reinterpret_cast<void *>(&nl_gcr_8b1ac1e181eec3fc_40_double_double)}, // NOLINT
+ {"nl_gcr_8b1ac1e181eec3fc_40_double_double", reinterpret_cast<void *>(&nl_gcr_8b1ac1e181eec3fc_40_double_double)},
// rebound
- {"nl_gcr_8bec817b324dcc3_28_double_double", reinterpret_cast<void *>(&nl_gcr_8bec817b324dcc3_28_double_double)}, // NOLINT
+ {"nl_gcr_8bec817b324dcc3_28_double_double", reinterpret_cast<void *>(&nl_gcr_8bec817b324dcc3_28_double_double)},
// cocoloco
- {"nl_gcr_8c0f7f2284333de5_16_double_double", reinterpret_cast<void *>(&nl_gcr_8c0f7f2284333de5_16_double_double)}, // NOLINT
+ {"nl_gcr_8c0f7f2284333de5_16_double_double", reinterpret_cast<void *>(&nl_gcr_8c0f7f2284333de5_16_double_double)},
// spacfury
- {"nl_gcr_8c1dd4afcf0f8ea2_15_double_double", reinterpret_cast<void *>(&nl_gcr_8c1dd4afcf0f8ea2_15_double_double)}, // NOLINT
+ {"nl_gcr_8c1dd4afcf0f8ea2_15_double_double", reinterpret_cast<void *>(&nl_gcr_8c1dd4afcf0f8ea2_15_double_double)},
// fireone
- {"nl_gcr_8c512fd6a6dabc50_35_double_double", reinterpret_cast<void *>(&nl_gcr_8c512fd6a6dabc50_35_double_double)}, // NOLINT
+ {"nl_gcr_8c512fd6a6dabc50_35_double_double", reinterpret_cast<void *>(&nl_gcr_8c512fd6a6dabc50_35_double_double)},
// segausb
- {"nl_gcr_8cc4eb213eaeef9b_30_double_double", reinterpret_cast<void *>(&nl_gcr_8cc4eb213eaeef9b_30_double_double)}, // NOLINT
+ {"nl_gcr_8cc4eb213eaeef9b_30_double_double", reinterpret_cast<void *>(&nl_gcr_8cc4eb213eaeef9b_30_double_double)},
// starcrus
- {"nl_gcr_8d7bddf33d942482_129_double_double", reinterpret_cast<void *>(&nl_gcr_8d7bddf33d942482_129_double_double)}, // NOLINT
+ {"nl_gcr_8d7bddf33d942482_129_double_double", reinterpret_cast<void *>(&nl_gcr_8d7bddf33d942482_129_double_double)},
// tank
- {"nl_gcr_930b64361c2cdba8_328_double_double", reinterpret_cast<void *>(&nl_gcr_930b64361c2cdba8_328_double_double)}, // NOLINT
+ {"nl_gcr_930b64361c2cdba8_328_double_double", reinterpret_cast<void *>(&nl_gcr_930b64361c2cdba8_328_double_double)},
// gamemachine
- {"nl_gcr_934712b55bb3b2b2_10_double_double", reinterpret_cast<void *>(&nl_gcr_934712b55bb3b2b2_10_double_double)}, // NOLINT
+ {"nl_gcr_934712b55bb3b2b2_10_double_double", reinterpret_cast<void *>(&nl_gcr_934712b55bb3b2b2_10_double_double)},
// kidniki
- {"nl_gcr_9a5874c8e2da79d2_37_double_double", reinterpret_cast<void *>(&nl_gcr_9a5874c8e2da79d2_37_double_double)}, // NOLINT
+ {"nl_gcr_9a5874c8e2da79d2_37_double_double", reinterpret_cast<void *>(&nl_gcr_9a5874c8e2da79d2_37_double_double)},
// fireone
- {"nl_gcr_9aa159329f86ca8b_70_double_double", reinterpret_cast<void *>(&nl_gcr_9aa159329f86ca8b_70_double_double)}, // NOLINT
+ {"nl_gcr_9aa159329f86ca8b_70_double_double", reinterpret_cast<void *>(&nl_gcr_9aa159329f86ca8b_70_double_double)},
// warrior
- {"nl_gcr_9c975530a1a529d6_7_double_double", reinterpret_cast<void *>(&nl_gcr_9c975530a1a529d6_7_double_double)}, // NOLINT
+ {"nl_gcr_9c975530a1a529d6_7_double_double", reinterpret_cast<void *>(&nl_gcr_9c975530a1a529d6_7_double_double)},
// kidniki
- {"nl_gcr_9f141889c2091efc_24_double_double", reinterpret_cast<void *>(&nl_gcr_9f141889c2091efc_24_double_double)}, // NOLINT
+ {"nl_gcr_9f141889c2091efc_24_double_double", reinterpret_cast<void *>(&nl_gcr_9f141889c2091efc_24_double_double)},
// segas16b_audio
- {"nl_gcr_9f7104c5e25c87dd_111_double_double", reinterpret_cast<void *>(&nl_gcr_9f7104c5e25c87dd_111_double_double)}, // NOLINT
+ {"nl_gcr_9f7104c5e25c87dd_111_double_double", reinterpret_cast<void *>(&nl_gcr_9f7104c5e25c87dd_111_double_double)},
// boxingb
- {"nl_gcr_a0bf548977306172_25_double_double", reinterpret_cast<void *>(&nl_gcr_a0bf548977306172_25_double_double)}, // NOLINT
+ {"nl_gcr_a0bf548977306172_25_double_double", reinterpret_cast<void *>(&nl_gcr_a0bf548977306172_25_double_double)},
// boxingb
- {"nl_gcr_a1132c8737d5d463_96_double_double", reinterpret_cast<void *>(&nl_gcr_a1132c8737d5d463_96_double_double)}, // NOLINT
+ {"nl_gcr_a1132c8737d5d463_96_double_double", reinterpret_cast<void *>(&nl_gcr_a1132c8737d5d463_96_double_double)},
// astrob
- {"nl_gcr_a41a44bd5c424f88_13_double_double", reinterpret_cast<void *>(&nl_gcr_a41a44bd5c424f88_13_double_double)}, // NOLINT
+ {"nl_gcr_a41a44bd5c424f88_13_double_double", reinterpret_cast<void *>(&nl_gcr_a41a44bd5c424f88_13_double_double)},
// tp1985
- {"nl_gcr_a4540ffea06b4346_26_double_double", reinterpret_cast<void *>(&nl_gcr_a4540ffea06b4346_26_double_double)}, // NOLINT
+ {"nl_gcr_a4540ffea06b4346_26_double_double", reinterpret_cast<void *>(&nl_gcr_a4540ffea06b4346_26_double_double)},
// tailg
- {"nl_gcr_a46301cd3479b8db_15_double_double", reinterpret_cast<void *>(&nl_gcr_a46301cd3479b8db_15_double_double)}, // NOLINT
+ {"nl_gcr_a46301cd3479b8db_15_double_double", reinterpret_cast<void *>(&nl_gcr_a46301cd3479b8db_15_double_double)},
// barrier
- {"nl_gcr_a50a4b733e95414a_10_double_double", reinterpret_cast<void *>(&nl_gcr_a50a4b733e95414a_10_double_double)}, // NOLINT
+ {"nl_gcr_a50a4b733e95414a_10_double_double", reinterpret_cast<void *>(&nl_gcr_a50a4b733e95414a_10_double_double)},
// starcas
- {"nl_gcr_a582a424cb61c678_62_double_double", reinterpret_cast<void *>(&nl_gcr_a582a424cb61c678_62_double_double)}, // NOLINT
+ {"nl_gcr_a582a424cb61c678_62_double_double", reinterpret_cast<void *>(&nl_gcr_a582a424cb61c678_62_double_double)},
// tank
- {"nl_gcr_a63d1344e34bef4b_36_double_double", reinterpret_cast<void *>(&nl_gcr_a63d1344e34bef4b_36_double_double)}, // NOLINT
+ {"nl_gcr_a63d1344e34bef4b_36_double_double", reinterpret_cast<void *>(&nl_gcr_a63d1344e34bef4b_36_double_double)},
// boxingb
- {"nl_gcr_a6b734322b3ea924_22_double_double", reinterpret_cast<void *>(&nl_gcr_a6b734322b3ea924_22_double_double)}, // NOLINT
+ {"nl_gcr_a6b734322b3ea924_22_double_double", reinterpret_cast<void *>(&nl_gcr_a6b734322b3ea924_22_double_double)},
// armora
- {"nl_gcr_a6cfda6668b153c2_22_double_double", reinterpret_cast<void *>(&nl_gcr_a6cfda6668b153c2_22_double_double)}, // NOLINT
+ {"nl_gcr_a6cfda6668b153c2_22_double_double", reinterpret_cast<void *>(&nl_gcr_a6cfda6668b153c2_22_double_double)},
// boxingb
- {"nl_gcr_a6f74be7f61e6db2_29_double_double", reinterpret_cast<void *>(&nl_gcr_a6f74be7f61e6db2_29_double_double)}, // NOLINT
+ {"nl_gcr_a6f74be7f61e6db2_29_double_double", reinterpret_cast<void *>(&nl_gcr_a6f74be7f61e6db2_29_double_double)},
// carpolo
- {"nl_gcr_a8f1d076330f06b7_34_double_double", reinterpret_cast<void *>(&nl_gcr_a8f1d076330f06b7_34_double_double)}, // NOLINT
+ {"nl_gcr_a8f1d076330f06b7_34_double_double", reinterpret_cast<void *>(&nl_gcr_a8f1d076330f06b7_34_double_double)},
// breakout
- {"nl_gcr_a971eeb2ef76f75f_13_double_double", reinterpret_cast<void *>(&nl_gcr_a971eeb2ef76f75f_13_double_double)}, // NOLINT
+ {"nl_gcr_a971eeb2ef76f75f_13_double_double", reinterpret_cast<void *>(&nl_gcr_a971eeb2ef76f75f_13_double_double)},
// ripoff
- {"nl_gcr_aa07266ef5d420d1_11_double_double", reinterpret_cast<void *>(&nl_gcr_aa07266ef5d420d1_11_double_double)}, // NOLINT
+ {"nl_gcr_aa07266ef5d420d1_11_double_double", reinterpret_cast<void *>(&nl_gcr_aa07266ef5d420d1_11_double_double)},
// brdrline
- {"nl_gcr_aa68b74ffdea9bd8_47_double_double", reinterpret_cast<void *>(&nl_gcr_aa68b74ffdea9bd8_47_double_double)}, // NOLINT
+ {"nl_gcr_aa68b74ffdea9bd8_47_double_double", reinterpret_cast<void *>(&nl_gcr_aa68b74ffdea9bd8_47_double_double)},
// 280zzzap
- {"nl_gcr_ab9144d965a37e4_113_double_double", reinterpret_cast<void *>(&nl_gcr_ab9144d965a37e4_113_double_double)}, // NOLINT
+ {"nl_gcr_ab9144d965a37e4_113_double_double", reinterpret_cast<void *>(&nl_gcr_ab9144d965a37e4_113_double_double)},
// sspeedr
- {"nl_gcr_ac1e401ddf971e15_10_double_double", reinterpret_cast<void *>(&nl_gcr_ac1e401ddf971e15_10_double_double)}, // NOLINT
+ {"nl_gcr_ac1e401ddf971e15_10_double_double", reinterpret_cast<void *>(&nl_gcr_ac1e401ddf971e15_10_double_double)},
// starfire
- {"nl_gcr_aceb6035dfb557c9_12_double_double", reinterpret_cast<void *>(&nl_gcr_aceb6035dfb557c9_12_double_double)}, // NOLINT
+ {"nl_gcr_aceb6035dfb557c9_12_double_double", reinterpret_cast<void *>(&nl_gcr_aceb6035dfb557c9_12_double_double)},
// sundance
- {"nl_gcr_ad6dba01ff2425c3_12_double_double", reinterpret_cast<void *>(&nl_gcr_ad6dba01ff2425c3_12_double_double)}, // NOLINT
+ {"nl_gcr_ad6dba01ff2425c3_12_double_double", reinterpret_cast<void *>(&nl_gcr_ad6dba01ff2425c3_12_double_double)},
// rebound
- {"nl_gcr_ae15f7f8a55fc96_7_double_double", reinterpret_cast<void *>(&nl_gcr_ae15f7f8a55fc96_7_double_double)}, // NOLINT
+ {"nl_gcr_ae15f7f8a55fc96_7_double_double", reinterpret_cast<void *>(&nl_gcr_ae15f7f8a55fc96_7_double_double)},
// armora
- {"nl_gcr_afcde432efdafb81_56_double_double", reinterpret_cast<void *>(&nl_gcr_afcde432efdafb81_56_double_double)}, // NOLINT
+ {"nl_gcr_afcde432efdafb81_56_double_double", reinterpret_cast<void *>(&nl_gcr_afcde432efdafb81_56_double_double)},
// mario
- {"nl_gcr_afce66fb47d3c5f3_62_double_double", reinterpret_cast<void *>(&nl_gcr_afce66fb47d3c5f3_62_double_double)}, // NOLINT
+ {"nl_gcr_afce66fb47d3c5f3_62_double_double", reinterpret_cast<void *>(&nl_gcr_afce66fb47d3c5f3_62_double_double)},
// spacewar
- {"nl_gcr_b09deef9a25aecaf_24_double_double", reinterpret_cast<void *>(&nl_gcr_b09deef9a25aecaf_24_double_double)}, // NOLINT
+ {"nl_gcr_b09deef9a25aecaf_24_double_double", reinterpret_cast<void *>(&nl_gcr_b09deef9a25aecaf_24_double_double)},
// spacfury
- {"nl_gcr_b1db23287df1da54_175_double_double", reinterpret_cast<void *>(&nl_gcr_b1db23287df1da54_175_double_double)}, // NOLINT
+ {"nl_gcr_b1db23287df1da54_175_double_double", reinterpret_cast<void *>(&nl_gcr_b1db23287df1da54_175_double_double)},
// segaspeech
- {"nl_gcr_b22769fbf3159a8d_21_double_double", reinterpret_cast<void *>(&nl_gcr_b22769fbf3159a8d_21_double_double)}, // NOLINT
+ {"nl_gcr_b22769fbf3159a8d_21_double_double", reinterpret_cast<void *>(&nl_gcr_b22769fbf3159a8d_21_double_double)},
// brdrline
- {"nl_gcr_b66df357763b1dce_97_double_double", reinterpret_cast<void *>(&nl_gcr_b66df357763b1dce_97_double_double)}, // NOLINT
+ {"nl_gcr_b66df357763b1dce_97_double_double", reinterpret_cast<void *>(&nl_gcr_b66df357763b1dce_97_double_double)},
// breakout
- {"nl_gcr_b66ff415b228d5f8_10_double_double", reinterpret_cast<void *>(&nl_gcr_b66ff415b228d5f8_10_double_double)}, // NOLINT
+ {"nl_gcr_b66ff415b228d5f8_10_double_double", reinterpret_cast<void *>(&nl_gcr_b66ff415b228d5f8_10_double_double)},
// starcas
- {"nl_gcr_b7344e05aac90017_65_double_double", reinterpret_cast<void *>(&nl_gcr_b7344e05aac90017_65_double_double)}, // NOLINT
+ {"nl_gcr_b7344e05aac90017_65_double_double", reinterpret_cast<void *>(&nl_gcr_b7344e05aac90017_65_double_double)},
// starfire
- {"nl_gcr_b75e0baeb501e907_23_double_double", reinterpret_cast<void *>(&nl_gcr_b75e0baeb501e907_23_double_double)}, // NOLINT
+ {"nl_gcr_b75e0baeb501e907_23_double_double", reinterpret_cast<void *>(&nl_gcr_b75e0baeb501e907_23_double_double)},
// spacfury
- {"nl_gcr_b7b209d222c0a9a6_91_double_double", reinterpret_cast<void *>(&nl_gcr_b7b209d222c0a9a6_91_double_double)}, // NOLINT
+ {"nl_gcr_b7b209d222c0a9a6_91_double_double", reinterpret_cast<void *>(&nl_gcr_b7b209d222c0a9a6_91_double_double)},
// boxingb
- {"nl_gcr_b8d6d148a50bdb8f_55_double_double", reinterpret_cast<void *>(&nl_gcr_b8d6d148a50bdb8f_55_double_double)}, // NOLINT
+ {"nl_gcr_b8d6d148a50bdb8f_55_double_double", reinterpret_cast<void *>(&nl_gcr_b8d6d148a50bdb8f_55_double_double)},
// 280zzzap
- {"nl_gcr_bb501e6a23177009_57_double_double", reinterpret_cast<void *>(&nl_gcr_bb501e6a23177009_57_double_double)}, // NOLINT
+ {"nl_gcr_bb501e6a23177009_57_double_double", reinterpret_cast<void *>(&nl_gcr_bb501e6a23177009_57_double_double)},
// elim
- {"nl_gcr_bb56fa5325163fc3_15_double_double", reinterpret_cast<void *>(&nl_gcr_bb56fa5325163fc3_15_double_double)}, // NOLINT
+ {"nl_gcr_bb56fa5325163fc3_15_double_double", reinterpret_cast<void *>(&nl_gcr_bb56fa5325163fc3_15_double_double)},
// starfire
- {"nl_gcr_bd1514d7defd4062_9_double_double", reinterpret_cast<void *>(&nl_gcr_bd1514d7defd4062_9_double_double)}, // NOLINT
+ {"nl_gcr_bd1514d7defd4062_9_double_double", reinterpret_cast<void *>(&nl_gcr_bd1514d7defd4062_9_double_double)},
// ripoff
- {"nl_gcr_be7c805100c522fd_59_double_double", reinterpret_cast<void *>(&nl_gcr_be7c805100c522fd_59_double_double)}, // NOLINT
+ {"nl_gcr_be7c805100c522fd_59_double_double", reinterpret_cast<void *>(&nl_gcr_be7c805100c522fd_59_double_double)},
// elim
- {"nl_gcr_be831e5faa508573_150_double_double", reinterpret_cast<void *>(&nl_gcr_be831e5faa508573_150_double_double)}, // NOLINT
+ {"nl_gcr_be831e5faa508573_150_double_double", reinterpret_cast<void *>(&nl_gcr_be831e5faa508573_150_double_double)},
// warrior
- {"nl_gcr_bff07f8d339f7cc4_89_double_double", reinterpret_cast<void *>(&nl_gcr_bff07f8d339f7cc4_89_double_double)}, // NOLINT
+ {"nl_gcr_bff07f8d339f7cc4_89_double_double", reinterpret_cast<void *>(&nl_gcr_bff07f8d339f7cc4_89_double_double)},
// brdrline
- {"nl_gcr_c05df522276e65fd_134_double_double", reinterpret_cast<void *>(&nl_gcr_c05df522276e65fd_134_double_double)}, // NOLINT
+ {"nl_gcr_c05df522276e65fd_134_double_double", reinterpret_cast<void *>(&nl_gcr_c05df522276e65fd_134_double_double)},
// fireone
- {"nl_gcr_c1d22fe6e895255d_79_double_double", reinterpret_cast<void *>(&nl_gcr_c1d22fe6e895255d_79_double_double)}, // NOLINT
+ {"nl_gcr_c1d22fe6e895255d_79_double_double", reinterpret_cast<void *>(&nl_gcr_c1d22fe6e895255d_79_double_double)},
// starcrus
- {"nl_gcr_c2e616f3de30f15b_31_double_double", reinterpret_cast<void *>(&nl_gcr_c2e616f3de30f15b_31_double_double)}, // NOLINT
+ {"nl_gcr_c2e616f3de30f15b_31_double_double", reinterpret_cast<void *>(&nl_gcr_c2e616f3de30f15b_31_double_double)},
// tailg
- {"nl_gcr_c4cec7aed23b7b94_23_double_double", reinterpret_cast<void *>(&nl_gcr_c4cec7aed23b7b94_23_double_double)}, // NOLINT
+ {"nl_gcr_c4cec7aed23b7b94_23_double_double", reinterpret_cast<void *>(&nl_gcr_c4cec7aed23b7b94_23_double_double)},
// segausb
- {"nl_gcr_c61e08cf5e35918_84_double_double", reinterpret_cast<void *>(&nl_gcr_c61e08cf5e35918_84_double_double)}, // NOLINT
+ {"nl_gcr_c61e08cf5e35918_84_double_double", reinterpret_cast<void *>(&nl_gcr_c61e08cf5e35918_84_double_double)},
// popeye
- {"nl_gcr_c6f25bb06e161d1c_50_double_double", reinterpret_cast<void *>(&nl_gcr_c6f25bb06e161d1c_50_double_double)}, // NOLINT
+ {"nl_gcr_c6f25bb06e161d1c_50_double_double", reinterpret_cast<void *>(&nl_gcr_c6f25bb06e161d1c_50_double_double)},
// flyball
- {"nl_gcr_c74b1a65978d7121_7_double_double", reinterpret_cast<void *>(&nl_gcr_c74b1a65978d7121_7_double_double)}, // NOLINT
+ {"nl_gcr_c74b1a65978d7121_7_double_double", reinterpret_cast<void *>(&nl_gcr_c74b1a65978d7121_7_double_double)},
// stuntcyc
- {"nl_gcr_c924fe5960b1479e_20_double_double", reinterpret_cast<void *>(&nl_gcr_c924fe5960b1479e_20_double_double)}, // NOLINT
+ {"nl_gcr_c924fe5960b1479e_20_double_double", reinterpret_cast<void *>(&nl_gcr_c924fe5960b1479e_20_double_double)},
// dpatrol
- {"nl_gcr_ca68d70bd8f2f62e_22_double_double", reinterpret_cast<void *>(&nl_gcr_ca68d70bd8f2f62e_22_double_double)}, // NOLINT
+ {"nl_gcr_ca68d70bd8f2f62e_22_double_double", reinterpret_cast<void *>(&nl_gcr_ca68d70bd8f2f62e_22_double_double)},
// breakout
- {"nl_gcr_cb2aae3366e0ac1c_7_double_double", reinterpret_cast<void *>(&nl_gcr_cb2aae3366e0ac1c_7_double_double)}, // NOLINT
+ {"nl_gcr_cb2aae3366e0ac1c_7_double_double", reinterpret_cast<void *>(&nl_gcr_cb2aae3366e0ac1c_7_double_double)},
// barrier
- {"nl_gcr_cc913f9c3f9293e7_19_double_double", reinterpret_cast<void *>(&nl_gcr_cc913f9c3f9293e7_19_double_double)}, // NOLINT
+ {"nl_gcr_cc913f9c3f9293e7_19_double_double", reinterpret_cast<void *>(&nl_gcr_cc913f9c3f9293e7_19_double_double)},
// fireone
- {"nl_gcr_cca3d1a4219e2ec0_153_double_double", reinterpret_cast<void *>(&nl_gcr_cca3d1a4219e2ec0_153_double_double)}, // NOLINT
+ {"nl_gcr_cca3d1a4219e2ec0_153_double_double", reinterpret_cast<void *>(&nl_gcr_cca3d1a4219e2ec0_153_double_double)},
// 1942
- {"nl_gcr_ce766957cb26ff3e_90_double_double", reinterpret_cast<void *>(&nl_gcr_ce766957cb26ff3e_90_double_double)}, // NOLINT
+ {"nl_gcr_ce766957cb26ff3e_90_double_double", reinterpret_cast<void *>(&nl_gcr_ce766957cb26ff3e_90_double_double)},
// astrob
- {"nl_gcr_cf1018e7ed626623_43_double_double", reinterpret_cast<void *>(&nl_gcr_cf1018e7ed626623_43_double_double)}, // NOLINT
+ {"nl_gcr_cf1018e7ed626623_43_double_double", reinterpret_cast<void *>(&nl_gcr_cf1018e7ed626623_43_double_double)},
// zac1b11142
- {"nl_gcr_cfd3bbf5fbba4765_71_double_double", reinterpret_cast<void *>(&nl_gcr_cfd3bbf5fbba4765_71_double_double)}, // NOLINT
+ {"nl_gcr_cfd3bbf5fbba4765_71_double_double", reinterpret_cast<void *>(&nl_gcr_cfd3bbf5fbba4765_71_double_double)},
// gunfight
- {"nl_gcr_d05b3dbe370c7904_14_double_double", reinterpret_cast<void *>(&nl_gcr_d05b3dbe370c7904_14_double_double)}, // NOLINT
+ {"nl_gcr_d05b3dbe370c7904_14_double_double", reinterpret_cast<void *>(&nl_gcr_d05b3dbe370c7904_14_double_double)},
// barrier
- {"nl_gcr_d06bd7ddbfd17b5e_15_double_double", reinterpret_cast<void *>(&nl_gcr_d06bd7ddbfd17b5e_15_double_double)}, // NOLINT
+ {"nl_gcr_d06bd7ddbfd17b5e_15_double_double", reinterpret_cast<void *>(&nl_gcr_d06bd7ddbfd17b5e_15_double_double)},
// elim
- {"nl_gcr_d13f9c6838af6aeb_13_double_double", reinterpret_cast<void *>(&nl_gcr_d13f9c6838af6aeb_13_double_double)}, // NOLINT
+ {"nl_gcr_d13f9c6838af6aeb_13_double_double", reinterpret_cast<void *>(&nl_gcr_d13f9c6838af6aeb_13_double_double)},
// elim
- {"nl_gcr_d190a0e3b8e1f4a7_7_double_double", reinterpret_cast<void *>(&nl_gcr_d190a0e3b8e1f4a7_7_double_double)}, // NOLINT
+ {"nl_gcr_d190a0e3b8e1f4a7_7_double_double", reinterpret_cast<void *>(&nl_gcr_d190a0e3b8e1f4a7_7_double_double)},
// elim
- {"nl_gcr_d224211d1af6811d_12_double_double", reinterpret_cast<void *>(&nl_gcr_d224211d1af6811d_12_double_double)}, // NOLINT
+ {"nl_gcr_d224211d1af6811d_12_double_double", reinterpret_cast<void *>(&nl_gcr_d224211d1af6811d_12_double_double)},
// armora
- {"nl_gcr_d27a39bc93616187_45_double_double", reinterpret_cast<void *>(&nl_gcr_d27a39bc93616187_45_double_double)}, // NOLINT
+ {"nl_gcr_d27a39bc93616187_45_double_double", reinterpret_cast<void *>(&nl_gcr_d27a39bc93616187_45_double_double)},
// elim
- {"nl_gcr_d2ea3f267b959e8b_20_double_double", reinterpret_cast<void *>(&nl_gcr_d2ea3f267b959e8b_20_double_double)}, // NOLINT
+ {"nl_gcr_d2ea3f267b959e8b_20_double_double", reinterpret_cast<void *>(&nl_gcr_d2ea3f267b959e8b_20_double_double)},
// starfire
- {"nl_gcr_d32effa2b0ea54a1_438_double_double", reinterpret_cast<void *>(&nl_gcr_d32effa2b0ea54a1_438_double_double)}, // NOLINT
+ {"nl_gcr_d32effa2b0ea54a1_438_double_double", reinterpret_cast<void *>(&nl_gcr_d32effa2b0ea54a1_438_double_double)},
// spacfury
- {"nl_gcr_d4c34516ff6aa139_46_double_double", reinterpret_cast<void *>(&nl_gcr_d4c34516ff6aa139_46_double_double)}, // NOLINT
+ {"nl_gcr_d4c34516ff6aa139_46_double_double", reinterpret_cast<void *>(&nl_gcr_d4c34516ff6aa139_46_double_double)},
// brdrline
- {"nl_gcr_d5e1c37cfa2d2853_30_double_double", reinterpret_cast<void *>(&nl_gcr_d5e1c37cfa2d2853_30_double_double)}, // NOLINT
+ {"nl_gcr_d5e1c37cfa2d2853_30_double_double", reinterpret_cast<void *>(&nl_gcr_d5e1c37cfa2d2853_30_double_double)},
// brdrline
- {"nl_gcr_d74d89ba31f2cb81_126_double_double", reinterpret_cast<void *>(&nl_gcr_d74d89ba31f2cb81_126_double_double)}, // NOLINT
+ {"nl_gcr_d74d89ba31f2cb81_126_double_double", reinterpret_cast<void *>(&nl_gcr_d74d89ba31f2cb81_126_double_double)},
// boxingb
- {"nl_gcr_d7d45dc58b08cab9_10_double_double", reinterpret_cast<void *>(&nl_gcr_d7d45dc58b08cab9_10_double_double)}, // NOLINT
+ {"nl_gcr_d7d45dc58b08cab9_10_double_double", reinterpret_cast<void *>(&nl_gcr_d7d45dc58b08cab9_10_double_double)},
// kidniki
- {"nl_gcr_d8c511d38cef5f6f_34_double_double", reinterpret_cast<void *>(&nl_gcr_d8c511d38cef5f6f_34_double_double)}, // NOLINT
+ {"nl_gcr_d8c511d38cef5f6f_34_double_double", reinterpret_cast<void *>(&nl_gcr_d8c511d38cef5f6f_34_double_double)},
// warrior
- {"nl_gcr_da598f43329e823_27_double_double", reinterpret_cast<void *>(&nl_gcr_da598f43329e823_27_double_double)}, // NOLINT
+ {"nl_gcr_da598f43329e823_27_double_double", reinterpret_cast<void *>(&nl_gcr_da598f43329e823_27_double_double)},
// pongf
- {"nl_gcr_dbafc5ddaf7a08f8_35_double_double", reinterpret_cast<void *>(&nl_gcr_dbafc5ddaf7a08f8_35_double_double)}, // NOLINT
+ {"nl_gcr_dbafc5ddaf7a08f8_35_double_double", reinterpret_cast<void *>(&nl_gcr_dbafc5ddaf7a08f8_35_double_double)},
// fireone
- {"nl_gcr_dcbecbc127c5868f_36_double_double", reinterpret_cast<void *>(&nl_gcr_dcbecbc127c5868f_36_double_double)}, // NOLINT
+ {"nl_gcr_dcbecbc127c5868f_36_double_double", reinterpret_cast<void *>(&nl_gcr_dcbecbc127c5868f_36_double_double)},
// sundance
- {"nl_gcr_e02a162cb515a958_100_double_double", reinterpret_cast<void *>(&nl_gcr_e02a162cb515a958_100_double_double)}, // NOLINT
+ {"nl_gcr_e02a162cb515a958_100_double_double", reinterpret_cast<void *>(&nl_gcr_e02a162cb515a958_100_double_double)},
// brdrline
- {"nl_gcr_e03f0bc5ac056326_20_double_double", reinterpret_cast<void *>(&nl_gcr_e03f0bc5ac056326_20_double_double)}, // NOLINT
+ {"nl_gcr_e03f0bc5ac056326_20_double_double", reinterpret_cast<void *>(&nl_gcr_e03f0bc5ac056326_20_double_double)},
// speedfrk
- {"nl_gcr_e07b5b086812756c_7_double_double", reinterpret_cast<void *>(&nl_gcr_e07b5b086812756c_7_double_double)}, // NOLINT
+ {"nl_gcr_e07b5b086812756c_7_double_double", reinterpret_cast<void *>(&nl_gcr_e07b5b086812756c_7_double_double)},
// solarq
- {"nl_gcr_e081f90c2e0313f6_45_double_double", reinterpret_cast<void *>(&nl_gcr_e081f90c2e0313f6_45_double_double)}, // NOLINT
+ {"nl_gcr_e081f90c2e0313f6_45_double_double", reinterpret_cast<void *>(&nl_gcr_e081f90c2e0313f6_45_double_double)},
// spacewar
- {"nl_gcr_e0b492db40bba291_20_double_double", reinterpret_cast<void *>(&nl_gcr_e0b492db40bba291_20_double_double)}, // NOLINT
+ {"nl_gcr_e0b492db40bba291_20_double_double", reinterpret_cast<void *>(&nl_gcr_e0b492db40bba291_20_double_double)},
// flyball
- {"nl_gcr_e15d9316d59cdad9_7_double_double", reinterpret_cast<void *>(&nl_gcr_e15d9316d59cdad9_7_double_double)}, // NOLINT
+ {"nl_gcr_e15d9316d59cdad9_7_double_double", reinterpret_cast<void *>(&nl_gcr_e15d9316d59cdad9_7_double_double)},
// speedfrk
- {"nl_gcr_e4f2ffbf201a3d0c_37_double_double", reinterpret_cast<void *>(&nl_gcr_e4f2ffbf201a3d0c_37_double_double)}, // NOLINT
+ {"nl_gcr_e4f2ffbf201a3d0c_37_double_double", reinterpret_cast<void *>(&nl_gcr_e4f2ffbf201a3d0c_37_double_double)},
// pongf
- {"nl_gcr_e51b463cd890ef6d_7_double_double", reinterpret_cast<void *>(&nl_gcr_e51b463cd890ef6d_7_double_double)}, // NOLINT
+ {"nl_gcr_e51b463cd890ef6d_7_double_double", reinterpret_cast<void *>(&nl_gcr_e51b463cd890ef6d_7_double_double)},
// sundance
- {"nl_gcr_e5b7711fac1ea80c_8_double_double", reinterpret_cast<void *>(&nl_gcr_e5b7711fac1ea80c_8_double_double)}, // NOLINT
+ {"nl_gcr_e5b7711fac1ea80c_8_double_double", reinterpret_cast<void *>(&nl_gcr_e5b7711fac1ea80c_8_double_double)},
// ripoff
- {"nl_gcr_e60314070a75e121_20_double_double", reinterpret_cast<void *>(&nl_gcr_e60314070a75e121_20_double_double)}, // NOLINT
+ {"nl_gcr_e60314070a75e121_20_double_double", reinterpret_cast<void *>(&nl_gcr_e60314070a75e121_20_double_double)},
// cheekyms
- {"nl_gcr_e75302e17c866419_150_double_double", reinterpret_cast<void *>(&nl_gcr_e75302e17c866419_150_double_double)}, // NOLINT
+ {"nl_gcr_e75302e17c866419_150_double_double", reinterpret_cast<void *>(&nl_gcr_e75302e17c866419_150_double_double)},
// elim
- {"nl_gcr_e76692c10e79997e_36_double_double", reinterpret_cast<void *>(&nl_gcr_e76692c10e79997e_36_double_double)}, // NOLINT
+ {"nl_gcr_e76692c10e79997e_36_double_double", reinterpret_cast<void *>(&nl_gcr_e76692c10e79997e_36_double_double)},
// fireone
- {"nl_gcr_e7fb484f621b3ab9_7_double_double", reinterpret_cast<void *>(&nl_gcr_e7fb484f621b3ab9_7_double_double)}, // NOLINT
+ {"nl_gcr_e7fb484f621b3ab9_7_double_double", reinterpret_cast<void *>(&nl_gcr_e7fb484f621b3ab9_7_double_double)},
// elim
- {"nl_gcr_e8aeb165b69427ec_18_double_double", reinterpret_cast<void *>(&nl_gcr_e8aeb165b69427ec_18_double_double)}, // NOLINT
+ {"nl_gcr_e8aeb165b69427ec_18_double_double", reinterpret_cast<void *>(&nl_gcr_e8aeb165b69427ec_18_double_double)},
// spacewar
- {"nl_gcr_e9e8211f43d8f4b3_22_double_double", reinterpret_cast<void *>(&nl_gcr_e9e8211f43d8f4b3_22_double_double)}, // NOLINT
+ {"nl_gcr_e9e8211f43d8f4b3_22_double_double", reinterpret_cast<void *>(&nl_gcr_e9e8211f43d8f4b3_22_double_double)},
// boxingb
- {"nl_gcr_ea2b6e3a05e6ef0b_23_double_double", reinterpret_cast<void *>(&nl_gcr_ea2b6e3a05e6ef0b_23_double_double)}, // NOLINT
+ {"nl_gcr_ea2b6e3a05e6ef0b_23_double_double", reinterpret_cast<void *>(&nl_gcr_ea2b6e3a05e6ef0b_23_double_double)},
// starcas
- {"nl_gcr_ec4f6d2dad5961b9_64_double_double", reinterpret_cast<void *>(&nl_gcr_ec4f6d2dad5961b9_64_double_double)}, // NOLINT
+ {"nl_gcr_ec4f6d2dad5961b9_64_double_double", reinterpret_cast<void *>(&nl_gcr_ec4f6d2dad5961b9_64_double_double)},
// barrier
- {"nl_gcr_ecf17036ce1c07cf_10_double_double", reinterpret_cast<void *>(&nl_gcr_ecf17036ce1c07cf_10_double_double)}, // NOLINT
+ {"nl_gcr_ecf17036ce1c07cf_10_double_double", reinterpret_cast<void *>(&nl_gcr_ecf17036ce1c07cf_10_double_double)},
// armora
- {"nl_gcr_ee2cacaa15d32491_67_double_double", reinterpret_cast<void *>(&nl_gcr_ee2cacaa15d32491_67_double_double)}, // NOLINT
+ {"nl_gcr_ee2cacaa15d32491_67_double_double", reinterpret_cast<void *>(&nl_gcr_ee2cacaa15d32491_67_double_double)},
// astrob
- {"nl_gcr_ee61dcaa355fc625_285_double_double", reinterpret_cast<void *>(&nl_gcr_ee61dcaa355fc625_285_double_double)}, // NOLINT
+ {"nl_gcr_ee61dcaa355fc625_285_double_double", reinterpret_cast<void *>(&nl_gcr_ee61dcaa355fc625_285_double_double)},
// starcrus
- {"nl_gcr_ef2f49641f433a74_94_double_double", reinterpret_cast<void *>(&nl_gcr_ef2f49641f433a74_94_double_double)}, // NOLINT
+ {"nl_gcr_ef2f49641f433a74_94_double_double", reinterpret_cast<void *>(&nl_gcr_ef2f49641f433a74_94_double_double)},
// spacfury
- {"nl_gcr_f365c3863b050e35_45_double_double", reinterpret_cast<void *>(&nl_gcr_f365c3863b050e35_45_double_double)}, // NOLINT
+ {"nl_gcr_f365c3863b050e35_45_double_double", reinterpret_cast<void *>(&nl_gcr_f365c3863b050e35_45_double_double)},
// spacfury
- {"nl_gcr_f3c9a6d53371d709_227_double_double", reinterpret_cast<void *>(&nl_gcr_f3c9a6d53371d709_227_double_double)}, // NOLINT
+ {"nl_gcr_f3c9a6d53371d709_227_double_double", reinterpret_cast<void *>(&nl_gcr_f3c9a6d53371d709_227_double_double)},
// barrier
- {"nl_gcr_f425d4008ae1d2c6_13_double_double", reinterpret_cast<void *>(&nl_gcr_f425d4008ae1d2c6_13_double_double)}, // NOLINT
+ {"nl_gcr_f425d4008ae1d2c6_13_double_double", reinterpret_cast<void *>(&nl_gcr_f425d4008ae1d2c6_13_double_double)},
// boxingb
- {"nl_gcr_f43cf2a28a5a5561_23_double_double", reinterpret_cast<void *>(&nl_gcr_f43cf2a28a5a5561_23_double_double)}, // NOLINT
+ {"nl_gcr_f43cf2a28a5a5561_23_double_double", reinterpret_cast<void *>(&nl_gcr_f43cf2a28a5a5561_23_double_double)},
// spacfury
- {"nl_gcr_f4da1503eabe16cf_16_double_double", reinterpret_cast<void *>(&nl_gcr_f4da1503eabe16cf_16_double_double)}, // NOLINT
+ {"nl_gcr_f4da1503eabe16cf_16_double_double", reinterpret_cast<void *>(&nl_gcr_f4da1503eabe16cf_16_double_double)},
// elim
- {"nl_gcr_f4f4e2ee05cb584e_13_double_double", reinterpret_cast<void *>(&nl_gcr_f4f4e2ee05cb584e_13_double_double)}, // NOLINT
+ {"nl_gcr_f4f4e2ee05cb584e_13_double_double", reinterpret_cast<void *>(&nl_gcr_f4f4e2ee05cb584e_13_double_double)},
// konami2x
- {"nl_gcr_f6900d3f36a91049_85_double_double", reinterpret_cast<void *>(&nl_gcr_f6900d3f36a91049_85_double_double)}, // NOLINT
+ {"nl_gcr_f6900d3f36a91049_85_double_double", reinterpret_cast<void *>(&nl_gcr_f6900d3f36a91049_85_double_double)},
// breakout
- {"nl_gcr_f7dc4f87b5a8ba93_7_double_double", reinterpret_cast<void *>(&nl_gcr_f7dc4f87b5a8ba93_7_double_double)}, // NOLINT
+ {"nl_gcr_f7dc4f87b5a8ba93_7_double_double", reinterpret_cast<void *>(&nl_gcr_f7dc4f87b5a8ba93_7_double_double)},
// fireone
- {"nl_gcr_f8f6a951fd1af6bc_7_double_double", reinterpret_cast<void *>(&nl_gcr_f8f6a951fd1af6bc_7_double_double)}, // NOLINT
+ {"nl_gcr_f8f6a951fd1af6bc_7_double_double", reinterpret_cast<void *>(&nl_gcr_f8f6a951fd1af6bc_7_double_double)},
// brdrline
- {"nl_gcr_f99b1245e708ec85_83_double_double", reinterpret_cast<void *>(&nl_gcr_f99b1245e708ec85_83_double_double)}, // NOLINT
+ {"nl_gcr_f99b1245e708ec85_83_double_double", reinterpret_cast<void *>(&nl_gcr_f99b1245e708ec85_83_double_double)},
// zektor
- {"nl_gcr_fbff020f5f5d5a5_144_double_double", reinterpret_cast<void *>(&nl_gcr_fbff020f5f5d5a5_144_double_double)}, // NOLINT
+ {"nl_gcr_fbff020f5f5d5a5_144_double_double", reinterpret_cast<void *>(&nl_gcr_fbff020f5f5d5a5_144_double_double)},
// kidniki
- {"nl_gcr_fc02559fdbfb0e10_67_double_double", reinterpret_cast<void *>(&nl_gcr_fc02559fdbfb0e10_67_double_double)}, // NOLINT
+ {"nl_gcr_fc02559fdbfb0e10_67_double_double", reinterpret_cast<void *>(&nl_gcr_fc02559fdbfb0e10_67_double_double)},
// 280zzzap
- {"nl_gcr_fc9971724787b82b_149_double_double", reinterpret_cast<void *>(&nl_gcr_fc9971724787b82b_149_double_double)}, // NOLINT
+ {"nl_gcr_fc9971724787b82b_149_double_double", reinterpret_cast<void *>(&nl_gcr_fc9971724787b82b_149_double_double)},
// elim
- {"nl_gcr_fcce97532ad2f49d_18_double_double", reinterpret_cast<void *>(&nl_gcr_fcce97532ad2f49d_18_double_double)}, // NOLINT
+ {"nl_gcr_fcce97532ad2f49d_18_double_double", reinterpret_cast<void *>(&nl_gcr_fcce97532ad2f49d_18_double_double)},
// fireone
- {"nl_gcr_fd2796828f1ebd00_36_double_double", reinterpret_cast<void *>(&nl_gcr_fd2796828f1ebd00_36_double_double)}, // NOLINT
+ {"nl_gcr_fd2796828f1ebd00_36_double_double", reinterpret_cast<void *>(&nl_gcr_fd2796828f1ebd00_36_double_double)},
// starfire
- {"nl_gcr_feae15b80dd73620_7_double_double", reinterpret_cast<void *>(&nl_gcr_feae15b80dd73620_7_double_double)}, // NOLINT
+ {"nl_gcr_feae15b80dd73620_7_double_double", reinterpret_cast<void *>(&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);
-
- NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(1.0, 0.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(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<netlist_mame_logic_input_device, 8> 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<timer_device> m_coinstate_timer;
optional_device<timer_device> m_nsub_coinage_timer;
required_device<screen_device> m_screen;
- optional_device<borderline_audio_device> m_borderline_sound;
+ optional_device<vicdual_audio_device_base> m_vicdual_sound;
optional_memory_region m_proms;
required_shared_ptr<uint8_t> 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)