From aadd5173db6211f1158699c503e783775e79336e Mon Sep 17 00:00:00 2001 From: Paperinik <42046613+aovestdipaperino@users.noreply.github.com> Date: Thu, 21 Mar 2024 10:24:49 +0100 Subject: [PATCH] mr/dribling.cpp: Added netlist sound simulation for Model Racing Dribbling. (#12147) Marked as imperfect sound for now due to lack of a suitable JFET model for the PARATA function generator. --- src/lib/netlist/generated/static_solvers.cpp | 4141 ++++++++++++------ src/mame/mr/dribling.cpp | 118 +- src/mame/mr/nl_dribling.cpp | 565 +++ src/mame/mr/nl_dribling.h | 10 + src/mame/nl.flt | 1 + 5 files changed, 3526 insertions(+), 1309 deletions(-) create mode 100644 src/mame/mr/nl_dribling.cpp create mode 100644 src/mame/mr/nl_dribling.h diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp index ff615be2670..f531ea58f67 100644 --- a/src/lib/netlist/generated/static_solvers.cpp +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -4889,6 +4889,182 @@ static void nl_gcr_95_double_double_24643c159711f292(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// armora,solarq,starcas,wotw +static void nl_gcr_22_double_double_1250f340dea396ae(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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[4]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A7 += go[6]; + m_A6 += go[7]; + m_A6 += go[8]; + m_A5 += go[9]; + m_A5 += go[10]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + RHS2 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A9 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A16 += go[20]; + m_A16 += go[21]; + m_A13 += go[22]; + m_A13 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[24] * *cnV[24]; + m_A21 += gt[25]; + m_A21 += gt[26]; + m_A21 += gt[27]; + m_A21 += gt[28]; + m_A21 += gt[29]; + m_A20 += go[25]; + m_A20 += go[26]; + m_A18 += go[27]; + m_A17 += go[28]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[29] * *cnV[29]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A17; + m_A21 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A5 * f2_3; + m_A11 += m_A6 * f2_3; + m_A12 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A13; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A18; + m_A19 += m_A5 * f2_5; + m_A20 += m_A6 * f2_5; + m_A21 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += m_A12 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_5 = -f3 * m_A19; + m_A20 += m_A11 * f3_5; + m_A21 += m_A12 * f3_5; + RHS5 += f3_5 * RHS3; + const double f4 = 1.0 / m_A15; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A21; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + double tmp3 = 0.0; + tmp3 += m_A11 * V[4]; + tmp3 += m_A12 * V[5]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A5 * V[3]; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // armora static void nl_gcr_22_double_double_a6cfda6668b153c2(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -6698,107 +6874,6 @@ static void nl_gcr_67_double_double_ee2cacaa15d32491(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } -// astrob,rebound -static void nl_gcr_13_double_double_a41a44bd5c424f88(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); - 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_A3 += go[3]; - double RHS1 = Idr[3]; - RHS1 += Idr[4]; - RHS1 += Idr[5]; - RHS1 -= go[4] * *cnV[4]; - RHS1 -= go[5] * *cnV[5]; - m_A4 += gt[6]; - m_A4 += gt[7]; - m_A4 += gt[8]; - m_A5 += go[6]; - double RHS2 = Idr[6]; - RHS2 += Idr[7]; - RHS2 += Idr[8]; - RHS2 -= go[7] * *cnV[7]; - RHS2 -= go[8] * *cnV[8]; - m_A6 += gt[9]; - m_A6 += gt[10]; - m_A6 += gt[11]; - m_A7 += go[9]; - double RHS3 = Idr[9]; - RHS3 += Idr[10]; - RHS3 += Idr[11]; - RHS3 -= go[10] * *cnV[10]; - RHS3 -= go[11] * *cnV[11]; - m_A12 += gt[12]; - m_A12 += gt[13]; - m_A12 += gt[14]; - m_A12 += gt[15]; - m_A12 += gt[16]; - m_A11 += go[12]; - m_A10 += go[13]; - m_A9 += go[14]; - m_A8 += go[15]; - double RHS4 = Idr[12]; - RHS4 += Idr[13]; - RHS4 += Idr[14]; - RHS4 += Idr[15]; - RHS4 += Idr[16]; - RHS4 -= go[16] * *cnV[16]; - const double f0 = 1.0 / m_A0; - const double f0_4 = -f0 * m_A8; - m_A12 += m_A1 * f0_4; - RHS4 += f0_4 * RHS0; - const double f1 = 1.0 / m_A2; - const double f1_4 = -f1 * m_A9; - m_A12 += m_A3 * f1_4; - RHS4 += f1_4 * RHS1; - const double f2 = 1.0 / m_A4; - const double f2_4 = -f2 * m_A10; - m_A12 += m_A5 * f2_4; - RHS4 += f2_4 * RHS2; - const double f3 = 1.0 / m_A6; - const double f3_4 = -f3 * m_A11; - m_A12 += m_A7 * f3_4; - RHS4 += f3_4 * RHS3; - V[4] = RHS4 / m_A12; - double tmp3 = 0.0; - tmp3 += m_A7 * V[4]; - V[3] = (RHS3 - tmp3) / m_A6; - double tmp2 = 0.0; - tmp2 += m_A5 * V[4]; - V[2] = (RHS2 - tmp2) / m_A4; - double tmp1 = 0.0; - tmp1 += m_A3 * V[4]; - V[1] = (RHS1 - tmp1) / m_A2; - double tmp0 = 0.0; - tmp0 += m_A1 * V[4]; - V[0] = (RHS0 - tmp0) / m_A0; -} - // astrob static void nl_gcr_154_double_double_13833bf8c127deaa(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -12987,6 +13062,79 @@ static void nl_gcr_47_double_double_6ef39a62161d596c(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb,solarq +static void nl_gcr_10_double_double_d7d45dc58b08cab9(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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A5 += gt[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A6 += go[6]; + m_A4 += go[7]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[8] * *cnV[8]; + m_A9 += gt[9]; + m_A9 += gt[10]; + m_A7 += go[9]; + m_A8 += go[10]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A5 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A7; + m_A9 += m_A3 * f1_3; + RHS3 += f1_3 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_3 = -f2 * m_A8; + m_A9 += m_A6 * f2_3; + RHS3 += f2_3 * RHS2; + V[3] = RHS3 / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * V[3]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // boxingb static void nl_gcr_16_double_double_50f5194a994d56ec(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -13635,6 +13783,188 @@ static void nl_gcr_23_double_double_53e1117fdb16f546(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb,starcas,wotw +static void nl_gcr_23_double_double_ea2b6e3a05e6ef0b(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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A4 += go[4]; + m_A3 += go[5]; + m_A3 += go[6]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A5 += gt[13]; + m_A7 += go[10]; + m_A6 += go[11]; + m_A6 += go[12]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A9 += go[14]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[15] * *cnV[15]; + m_A12 += gt[16]; + m_A12 += gt[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A12 += gt[21]; + m_A11 += go[16]; + m_A11 += go[17]; + m_A10 += go[18]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 -= go[19] * *cnV[19]; + RHS4 -= go[20] * *cnV[20]; + RHS4 -= go[21] * *cnV[21]; + m_A17 += gt[22]; + m_A17 += gt[23]; + m_A17 += gt[24]; + m_A17 += gt[25]; + m_A17 += gt[26]; + m_A15 += go[22]; + m_A15 += go[23]; + m_A14 += go[24]; + double RHS5 = Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 += Idr[26]; + RHS5 -= go[25] * *cnV[25]; + RHS5 -= go[26] * *cnV[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A22 += gt[29]; + m_A22 += gt[30]; + m_A22 += gt[31]; + m_A20 += go[27]; + m_A19 += go[28]; + double RHS6 = Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + RHS6 -= go[31] * *cnV[31]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A11; + m_A12 += m_A3 * f1_4; + m_A13 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A14; + m_A16 += m_A3 * f1_5; + m_A17 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_5 = -f2 * m_A15; + m_A17 += m_A6 * f2_5; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A19; + m_A21 += m_A6 * f2_6; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_6 = -f3 * m_A20; + m_A22 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_5 = -f4 * m_A16; + m_A17 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[6]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[5]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[6]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A6 * V[5]; + tmp2 += m_A7 * V[6]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + tmp1 += m_A4 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // boxingb static void nl_gcr_23_double_double_f43cf2a28a5a5561(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -18473,60 +18803,6 @@ static void nl_gcr_77_double_double_437326911721091(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } -// brdrline,stuntcyc -static void nl_gcr_7_double_double_59cb6bf7cb9d17dc(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) - -{ - - plib::unused_var(cnV); - double m_A0(0.0); - double m_A1(0.0); - double m_A2(0.0); - double m_A3(0.0); - double m_A4(0.0); - double m_A5(0.0); - double m_A6(0.0); - m_A0 += gt[0]; - m_A0 += gt[1]; - m_A1 += go[0]; - double RHS0 = Idr[0]; - RHS0 += Idr[1]; - RHS0 -= go[1] * *cnV[1]; - m_A2 += gt[2]; - m_A2 += gt[3]; - m_A3 += go[2]; - double RHS1 = Idr[2]; - RHS1 += Idr[3]; - RHS1 -= go[3] * *cnV[3]; - m_A6 += gt[4]; - m_A6 += gt[5]; - m_A6 += gt[6]; - m_A6 += gt[7]; - m_A5 += go[4]; - m_A4 += go[5]; - double RHS2 = Idr[4]; - RHS2 += Idr[5]; - RHS2 += Idr[6]; - RHS2 += Idr[7]; - RHS2 -= go[6] * *cnV[6]; - RHS2 -= go[7] * *cnV[7]; - 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; -} - // brdrline static void nl_gcr_83_double_double_f99b1245e708ec85(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -26154,6 +26430,1737 @@ static void nl_gcr_399_double_double_4334c95878d1be92(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// dribling +static void nl_gcr_257_double_double_5dc652d6668315af(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); + 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_A2 += gt[7]; + m_A2 += gt[8]; + m_A4 += go[3]; + m_A3 += go[4]; + m_A3 += go[5]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A6 += go[9]; + double 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]; + m_A7 += gt[13]; + m_A7 += gt[14]; + m_A7 += gt[15]; + m_A8 += go[13]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + m_A9 += gt[16]; + m_A9 += gt[17]; + m_A10 += go[16]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 -= go[17] * *cnV[17]; + m_A11 += gt[18]; + m_A11 += gt[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A11 += gt[23]; + m_A13 += go[18]; + m_A12 += go[19]; + m_A12 += go[20]; + double RHS5 = Idr[18]; + RHS5 += Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 += Idr[23]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + RHS5 -= go[23] * *cnV[23]; + m_A14 += gt[24]; + m_A14 += gt[25]; + m_A14 += gt[26]; + m_A14 += gt[27]; + m_A15 += go[24]; + double RHS6 = Idr[24]; + RHS6 += Idr[25]; + RHS6 += Idr[26]; + RHS6 += Idr[27]; + RHS6 -= go[25] * *cnV[25]; + RHS6 -= go[26] * *cnV[26]; + RHS6 -= go[27] * *cnV[27]; + m_A16 += gt[28]; + m_A16 += gt[29]; + m_A16 += gt[30]; + m_A18 += go[28]; + m_A17 += go[29]; + double RHS7 = Idr[28]; + RHS7 += Idr[29]; + RHS7 += Idr[30]; + RHS7 -= go[30] * *cnV[30]; + m_A19 += gt[31]; + m_A19 += gt[32]; + m_A19 += gt[33]; + m_A19 += gt[34]; + m_A20 += go[31]; + m_A21 += go[32]; + m_A21 += go[33]; + double RHS8 = Idr[31]; + RHS8 += Idr[32]; + RHS8 += Idr[33]; + RHS8 += Idr[34]; + RHS8 -= go[34] * *cnV[34]; + m_A22 += gt[35]; + m_A22 += gt[36]; + m_A22 += gt[37]; + m_A22 += gt[38]; + m_A23 += go[35]; + double RHS9 = Idr[35]; + RHS9 += Idr[36]; + RHS9 += Idr[37]; + RHS9 += Idr[38]; + RHS9 -= go[36] * *cnV[36]; + RHS9 -= go[37] * *cnV[37]; + RHS9 -= go[38] * *cnV[38]; + m_A24 += gt[39]; + m_A24 += gt[40]; + m_A24 += gt[41]; + m_A24 += gt[42]; + m_A25 += go[39]; + double RHS10 = Idr[39]; + RHS10 += Idr[40]; + RHS10 += Idr[41]; + RHS10 += Idr[42]; + RHS10 -= go[40] * *cnV[40]; + RHS10 -= go[41] * *cnV[41]; + RHS10 -= go[42] * *cnV[42]; + m_A26 += gt[43]; + m_A26 += gt[44]; + m_A27 += go[43]; + double RHS11 = Idr[43]; + RHS11 += Idr[44]; + RHS11 -= go[44] * *cnV[44]; + m_A28 += gt[45]; + m_A28 += gt[46]; + m_A28 += gt[47]; + m_A30 += go[45]; + m_A29 += go[46]; + double RHS12 = Idr[45]; + RHS12 += Idr[46]; + RHS12 += Idr[47]; + RHS12 -= go[47] * *cnV[47]; + m_A31 += gt[48]; + m_A31 += gt[49]; + m_A31 += gt[50]; + m_A31 += gt[51]; + m_A32 += go[48]; + m_A33 += go[49]; + m_A33 += go[50]; + double RHS13 = Idr[48]; + RHS13 += Idr[49]; + RHS13 += Idr[50]; + RHS13 += Idr[51]; + RHS13 -= go[51] * *cnV[51]; + m_A34 += gt[52]; + m_A34 += gt[53]; + m_A36 += go[52]; + m_A35 += go[53]; + double RHS14 = Idr[52]; + RHS14 += Idr[53]; + m_A37 += gt[54]; + m_A37 += gt[55]; + m_A38 += go[54]; + double RHS15 = Idr[54]; + RHS15 += Idr[55]; + RHS15 -= go[55] * *cnV[55]; + m_A39 += gt[56]; + m_A39 += gt[57]; + m_A39 += gt[58]; + m_A40 += go[56]; + double RHS16 = Idr[56]; + RHS16 += Idr[57]; + RHS16 += Idr[58]; + RHS16 -= go[57] * *cnV[57]; + RHS16 -= go[58] * *cnV[58]; + m_A41 += gt[59]; + m_A41 += gt[60]; + m_A41 += gt[61]; + m_A42 += go[59]; + double RHS17 = Idr[59]; + RHS17 += Idr[60]; + RHS17 += Idr[61]; + RHS17 -= go[60] * *cnV[60]; + RHS17 -= go[61] * *cnV[61]; + m_A43 += gt[62]; + m_A43 += gt[63]; + m_A45 += go[62]; + m_A44 += go[63]; + double RHS18 = Idr[62]; + RHS18 += Idr[63]; + m_A46 += gt[64]; + m_A46 += gt[65]; + m_A47 += go[64]; + double RHS19 = Idr[64]; + RHS19 += Idr[65]; + RHS19 -= go[65] * *cnV[65]; + m_A48 += gt[66]; + m_A48 += gt[67]; + m_A48 += gt[68]; + m_A49 += go[66]; + double RHS20 = Idr[66]; + RHS20 += Idr[67]; + RHS20 += Idr[68]; + RHS20 -= go[67] * *cnV[67]; + RHS20 -= go[68] * *cnV[68]; + m_A50 += gt[69]; + m_A50 += gt[70]; + m_A50 += gt[71]; + m_A51 += go[69]; + double RHS21 = Idr[69]; + RHS21 += Idr[70]; + RHS21 += Idr[71]; + RHS21 -= go[70] * *cnV[70]; + RHS21 -= go[71] * *cnV[71]; + m_A52 += gt[72]; + m_A52 += gt[73]; + m_A53 += go[72]; + double RHS22 = Idr[72]; + RHS22 += Idr[73]; + RHS22 -= go[73] * *cnV[73]; + m_A54 += gt[74]; + m_A54 += gt[75]; + m_A54 += gt[76]; + m_A55 += go[74]; + double RHS23 = Idr[74]; + RHS23 += Idr[75]; + RHS23 += Idr[76]; + RHS23 -= go[75] * *cnV[75]; + RHS23 -= go[76] * *cnV[76]; + m_A56 += gt[77]; + m_A56 += gt[78]; + m_A57 += go[77]; + double RHS24 = Idr[77]; + RHS24 += Idr[78]; + RHS24 -= go[78] * *cnV[78]; + m_A58 += gt[79]; + m_A58 += gt[80]; + m_A58 += gt[81]; + m_A58 += gt[82]; + m_A58 += gt[83]; + m_A58 += gt[84]; + m_A59 += go[79]; + m_A61 += go[80]; + m_A60 += go[81]; + m_A62 += go[82]; + double RHS25 = Idr[79]; + RHS25 += Idr[80]; + RHS25 += Idr[81]; + RHS25 += Idr[82]; + RHS25 += Idr[83]; + RHS25 += Idr[84]; + RHS25 -= go[83] * *cnV[83]; + RHS25 -= go[84] * *cnV[84]; + m_A63 += gt[85]; + m_A63 += gt[86]; + m_A63 += gt[87]; + m_A63 += gt[88]; + m_A63 += gt[89]; + m_A65 += go[85]; + m_A64 += go[86]; + m_A66 += go[87]; + m_A66 += go[88]; + double RHS26 = Idr[85]; + RHS26 += Idr[86]; + RHS26 += Idr[87]; + RHS26 += Idr[88]; + RHS26 += Idr[89]; + RHS26 -= go[89] * *cnV[89]; + m_A67 += gt[90]; + m_A67 += gt[91]; + m_A67 += gt[92]; + m_A67 += gt[93]; + m_A67 += gt[94]; + m_A69 += go[90]; + m_A68 += go[91]; + m_A70 += go[92]; + m_A70 += go[93]; + double RHS27 = Idr[90]; + RHS27 += Idr[91]; + RHS27 += Idr[92]; + RHS27 += Idr[93]; + RHS27 += Idr[94]; + RHS27 -= go[94] * *cnV[94]; + m_A71 += gt[95]; + m_A71 += gt[96]; + m_A71 += gt[97]; + m_A71 += gt[98]; + m_A72 += go[95]; + double RHS28 = Idr[95]; + RHS28 += Idr[96]; + RHS28 += Idr[97]; + RHS28 += Idr[98]; + RHS28 -= go[96] * *cnV[96]; + RHS28 -= go[97] * *cnV[97]; + RHS28 -= go[98] * *cnV[98]; + m_A73 += gt[99]; + m_A73 += gt[100]; + m_A75 += go[99]; + m_A74 += go[100]; + double RHS29 = Idr[99]; + RHS29 += Idr[100]; + m_A76 += gt[101]; + m_A76 += gt[102]; + m_A78 += go[101]; + m_A77 += go[102]; + double RHS30 = Idr[101]; + RHS30 += Idr[102]; + m_A79 += gt[103]; + m_A79 += gt[104]; + m_A79 += gt[105]; + m_A80 += go[103]; + m_A81 += go[104]; + double RHS31 = Idr[103]; + RHS31 += Idr[104]; + RHS31 += Idr[105]; + RHS31 -= go[105] * *cnV[105]; + m_A82 += gt[106]; + m_A82 += gt[107]; + m_A82 += gt[108]; + m_A84 += go[106]; + m_A83 += go[107]; + double RHS32 = Idr[106]; + RHS32 += Idr[107]; + RHS32 += Idr[108]; + RHS32 -= go[108] * *cnV[108]; + m_A87 += gt[109]; + m_A87 += gt[110]; + m_A87 += gt[111]; + m_A87 += gt[112]; + m_A87 += gt[113]; + m_A85 += go[109]; + m_A86 += go[110]; + m_A86 += go[111]; + double RHS33 = Idr[109]; + RHS33 += Idr[110]; + RHS33 += Idr[111]; + RHS33 += Idr[112]; + RHS33 += Idr[113]; + RHS33 -= go[112] * *cnV[112]; + RHS33 -= go[113] * *cnV[113]; + m_A91 += gt[114]; + m_A91 += gt[115]; + m_A92 += go[114]; + m_A89 += go[115]; + double RHS34 = Idr[114]; + RHS34 += Idr[115]; + m_A95 += gt[116]; + m_A95 += gt[117]; + m_A95 += gt[118]; + m_A95 += gt[119]; + m_A95 += gt[120]; + m_A93 += go[116]; + m_A94 += go[117]; + m_A94 += go[118]; + double RHS35 = Idr[116]; + RHS35 += Idr[117]; + RHS35 += Idr[118]; + RHS35 += Idr[119]; + RHS35 += Idr[120]; + RHS35 -= go[119] * *cnV[119]; + RHS35 -= go[120] * *cnV[120]; + m_A98 += gt[121]; + m_A98 += gt[122]; + m_A98 += gt[123]; + m_A100 += go[121]; + m_A99 += go[122]; + m_A97 += go[123]; + double RHS36 = Idr[121]; + RHS36 += Idr[122]; + RHS36 += Idr[123]; + m_A102 += gt[124]; + m_A102 += gt[125]; + m_A102 += gt[126]; + m_A104 += go[124]; + m_A103 += go[125]; + m_A101 += go[126]; + double RHS37 = Idr[124]; + RHS37 += Idr[125]; + RHS37 += Idr[126]; + m_A107 += gt[127]; + m_A107 += gt[128]; + m_A107 += gt[129]; + m_A107 += gt[130]; + m_A107 += gt[131]; + m_A107 += gt[132]; + m_A107 += gt[133]; + m_A106 += go[127]; + m_A105 += go[128]; + m_A109 += go[129]; + m_A109 += go[130]; + m_A109 += go[131]; + m_A108 += go[132]; + double RHS38 = Idr[127]; + RHS38 += Idr[128]; + RHS38 += Idr[129]; + RHS38 += Idr[130]; + RHS38 += Idr[131]; + RHS38 += Idr[132]; + RHS38 += Idr[133]; + RHS38 -= go[133] * *cnV[133]; + m_A113 += gt[134]; + m_A113 += gt[135]; + m_A113 += gt[136]; + m_A113 += gt[137]; + m_A113 += gt[138]; + m_A113 += gt[139]; + m_A113 += gt[140]; + m_A112 += go[134]; + m_A111 += go[135]; + m_A115 += go[136]; + m_A115 += go[137]; + m_A115 += go[138]; + m_A114 += go[139]; + double RHS39 = Idr[134]; + RHS39 += Idr[135]; + RHS39 += Idr[136]; + RHS39 += Idr[137]; + RHS39 += Idr[138]; + RHS39 += Idr[139]; + RHS39 += Idr[140]; + RHS39 -= go[140] * *cnV[140]; + m_A118 += gt[141]; + m_A118 += gt[142]; + m_A118 += gt[143]; + m_A118 += gt[144]; + m_A118 += gt[145]; + m_A118 += gt[146]; + m_A118 += gt[147]; + m_A117 += go[141]; + m_A119 += go[142]; + double RHS40 = Idr[141]; + RHS40 += Idr[142]; + RHS40 += Idr[143]; + RHS40 += Idr[144]; + RHS40 += Idr[145]; + RHS40 += Idr[146]; + RHS40 += Idr[147]; + RHS40 -= go[143] * *cnV[143]; + RHS40 -= go[144] * *cnV[144]; + RHS40 -= go[145] * *cnV[145]; + RHS40 -= go[146] * *cnV[146]; + RHS40 -= go[147] * *cnV[147]; + m_A123 += gt[148]; + m_A123 += gt[149]; + m_A123 += gt[150]; + m_A120 += go[148]; + m_A121 += go[149]; + m_A125 += go[150]; + double RHS41 = Idr[148]; + RHS41 += Idr[149]; + RHS41 += Idr[150]; + m_A128 += gt[151]; + m_A128 += gt[152]; + m_A129 += go[151]; + m_A126 += go[152]; + double RHS42 = Idr[151]; + RHS42 += Idr[152]; + m_A132 += gt[153]; + m_A132 += gt[154]; + m_A132 += gt[155]; + m_A132 += gt[156]; + m_A132 += gt[157]; + m_A130 += go[153]; + m_A131 += go[154]; + m_A134 += go[155]; + m_A134 += go[156]; + double RHS43 = Idr[153]; + RHS43 += Idr[154]; + RHS43 += Idr[155]; + RHS43 += Idr[156]; + RHS43 += Idr[157]; + RHS43 -= go[157] * *cnV[157]; + m_A137 += gt[158]; + m_A137 += gt[159]; + m_A137 += gt[160]; + m_A137 += gt[161]; + m_A137 += gt[162]; + m_A135 += go[158]; + m_A136 += go[159]; + m_A139 += go[160]; + m_A139 += go[161]; + double RHS44 = Idr[158]; + RHS44 += Idr[159]; + RHS44 += Idr[160]; + RHS44 += Idr[161]; + RHS44 += Idr[162]; + RHS44 -= go[162] * *cnV[162]; + m_A141 += gt[163]; + m_A141 += gt[164]; + m_A142 += go[163]; + m_A140 += go[164]; + double RHS45 = Idr[163]; + RHS45 += Idr[164]; + m_A144 += gt[165]; + m_A144 += gt[166]; + m_A145 += go[165]; + m_A143 += go[166]; + double RHS46 = Idr[165]; + RHS46 += Idr[166]; + m_A148 += gt[167]; + m_A148 += gt[168]; + m_A148 += gt[169]; + m_A149 += go[167]; + m_A147 += go[168]; + m_A146 += go[169]; + double RHS47 = Idr[167]; + RHS47 += Idr[168]; + RHS47 += Idr[169]; + m_A154 += gt[170]; + m_A154 += gt[171]; + m_A156 += go[170]; + m_A151 += go[171]; + double RHS48 = Idr[170]; + RHS48 += Idr[171]; + m_A161 += gt[172]; + m_A161 += gt[173]; + m_A161 += gt[174]; + m_A161 += gt[175]; + m_A161 += gt[176]; + m_A161 += gt[177]; + m_A159 += go[172]; + m_A158 += go[173]; + m_A160 += go[174]; + m_A157 += go[175]; + double RHS49 = Idr[172]; + RHS49 += Idr[173]; + RHS49 += Idr[174]; + RHS49 += Idr[175]; + RHS49 += Idr[176]; + RHS49 += Idr[177]; + RHS49 -= go[176] * *cnV[176]; + RHS49 -= go[177] * *cnV[177]; + m_A166 += gt[178]; + m_A166 += gt[179]; + m_A166 += gt[180]; + m_A165 += go[178]; + m_A163 += go[179]; + m_A164 += go[180]; + double RHS50 = Idr[178]; + RHS50 += Idr[179]; + RHS50 += Idr[180]; + m_A174 += gt[181]; + m_A174 += gt[182]; + m_A174 += gt[183]; + m_A174 += gt[184]; + m_A174 += gt[185]; + m_A174 += gt[186]; + m_A174 += gt[187]; + m_A170 += go[181]; + m_A170 += go[182]; + m_A172 += go[183]; + m_A172 += go[184]; + m_A172 += go[185]; + m_A169 += go[186]; + m_A171 += go[187]; + double RHS51 = Idr[181]; + RHS51 += Idr[182]; + RHS51 += Idr[183]; + RHS51 += Idr[184]; + RHS51 += Idr[185]; + RHS51 += Idr[186]; + RHS51 += Idr[187]; + m_A179 += gt[188]; + m_A179 += gt[189]; + m_A179 += gt[190]; + m_A178 += go[188]; + m_A176 += go[189]; + m_A177 += go[190]; + double RHS52 = Idr[188]; + RHS52 += Idr[189]; + RHS52 += Idr[190]; + m_A184 += gt[191]; + m_A184 += gt[192]; + m_A186 += go[191]; + m_A182 += go[192]; + double RHS53 = Idr[191]; + RHS53 += Idr[192]; + m_A189 += gt[193]; + m_A189 += gt[194]; + m_A191 += go[193]; + m_A187 += go[194]; + double RHS54 = Idr[193]; + RHS54 += Idr[194]; + m_A193 += gt[195]; + m_A193 += gt[196]; + m_A193 += gt[197]; + m_A193 += gt[198]; + m_A193 += gt[199]; + m_A194 += go[195]; + m_A194 += go[196]; + m_A192 += go[197]; + double RHS55 = Idr[195]; + RHS55 += Idr[196]; + RHS55 += Idr[197]; + RHS55 += Idr[198]; + RHS55 += Idr[199]; + RHS55 -= go[198] * *cnV[198]; + RHS55 -= go[199] * *cnV[199]; + m_A200 += gt[200]; + m_A200 += gt[201]; + m_A200 += gt[202]; + m_A200 += gt[203]; + m_A200 += gt[204]; + m_A200 += gt[205]; + m_A200 += gt[206]; + m_A196 += go[200]; + m_A196 += go[201]; + m_A198 += go[202]; + m_A198 += go[203]; + m_A198 += go[204]; + m_A195 += go[205]; + m_A197 += go[206]; + double RHS56 = Idr[200]; + RHS56 += Idr[201]; + RHS56 += Idr[202]; + RHS56 += Idr[203]; + RHS56 += Idr[204]; + RHS56 += Idr[205]; + RHS56 += Idr[206]; + m_A210 += gt[207]; + m_A210 += gt[208]; + m_A210 += gt[209]; + m_A210 += gt[210]; + m_A210 += gt[211]; + m_A210 += gt[212]; + m_A210 += gt[213]; + m_A205 += go[207]; + m_A208 += go[208]; + m_A206 += go[209]; + m_A204 += go[210]; + m_A203 += go[211]; + m_A202 += go[212]; + double RHS57 = Idr[207]; + RHS57 += Idr[208]; + RHS57 += Idr[209]; + RHS57 += Idr[210]; + RHS57 += Idr[211]; + RHS57 += Idr[212]; + RHS57 += Idr[213]; + RHS57 -= go[213] * *cnV[213]; + m_A216 += gt[214]; + m_A216 += gt[215]; + m_A216 += gt[216]; + m_A216 += gt[217]; + m_A216 += gt[218]; + m_A216 += gt[219]; + m_A214 += go[214]; + m_A213 += go[215]; + m_A215 += go[216]; + m_A212 += go[217]; + double RHS58 = Idr[214]; + RHS58 += Idr[215]; + RHS58 += Idr[216]; + RHS58 += Idr[217]; + RHS58 += Idr[218]; + RHS58 += Idr[219]; + RHS58 -= go[218] * *cnV[218]; + RHS58 -= go[219] * *cnV[219]; + m_A225 += gt[220]; + m_A225 += gt[221]; + m_A225 += gt[222]; + m_A225 += gt[223]; + m_A225 += gt[224]; + m_A225 += gt[225]; + m_A225 += gt[226]; + m_A221 += go[220]; + m_A221 += go[221]; + m_A219 += go[222]; + m_A219 += go[223]; + m_A218 += go[224]; + double RHS59 = Idr[220]; + RHS59 += Idr[221]; + RHS59 += Idr[222]; + RHS59 += Idr[223]; + RHS59 += Idr[224]; + RHS59 += Idr[225]; + RHS59 += Idr[226]; + RHS59 -= go[225] * *cnV[225]; + RHS59 -= go[226] * *cnV[226]; + m_A234 += gt[227]; + m_A234 += gt[228]; + m_A234 += gt[229]; + m_A234 += gt[230]; + m_A234 += gt[231]; + m_A234 += gt[232]; + m_A234 += gt[233]; + m_A230 += go[227]; + m_A230 += go[228]; + m_A228 += go[229]; + m_A228 += go[230]; + m_A227 += go[231]; + double RHS60 = Idr[227]; + RHS60 += Idr[228]; + RHS60 += Idr[229]; + RHS60 += Idr[230]; + RHS60 += Idr[231]; + RHS60 += Idr[232]; + RHS60 += Idr[233]; + RHS60 -= go[232] * *cnV[232]; + RHS60 -= go[233] * *cnV[233]; + m_A238 += gt[234]; + m_A238 += gt[235]; + m_A238 += gt[236]; + m_A238 += gt[237]; + m_A238 += gt[238]; + m_A238 += go[234]; + m_A236 += go[235]; + m_A236 += go[236]; + m_A237 += go[237]; + double RHS61 = Idr[234]; + RHS61 += Idr[235]; + RHS61 += Idr[236]; + RHS61 += Idr[237]; + RHS61 += Idr[238]; + RHS61 -= go[238] * *cnV[238]; + m_A256 += gt[239]; + m_A256 += gt[240]; + m_A256 += gt[241]; + m_A256 += gt[242]; + m_A256 += gt[243]; + m_A256 += gt[244]; + m_A256 += gt[245]; + m_A256 += gt[246]; + m_A256 += gt[247]; + m_A256 += gt[248]; + m_A256 += gt[249]; + m_A242 += go[239]; + m_A250 += go[240]; + m_A250 += go[241]; + m_A241 += go[242]; + m_A240 += go[243]; + m_A249 += go[244]; + m_A248 += go[245]; + m_A246 += go[246]; + m_A244 += go[247]; + m_A243 += go[248]; + double RHS62 = Idr[239]; + RHS62 += Idr[240]; + RHS62 += Idr[241]; + RHS62 += Idr[242]; + RHS62 += Idr[243]; + RHS62 += Idr[244]; + RHS62 += Idr[245]; + RHS62 += Idr[246]; + RHS62 += Idr[247]; + RHS62 += Idr[248]; + RHS62 += Idr[249]; + RHS62 -= go[249] * *cnV[249]; + const double f0 = 1.0 / m_A0; + const double f0_33 = -f0 * m_A85; + m_A87 += m_A1 * f0_33; + RHS33 += f0_33 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_33 = -f1 * m_A86; + m_A87 += m_A3 * f1_33; + m_A88 += m_A4 * f1_33; + RHS33 += f1_33 * RHS1; + const double f1_34 = -f1 * m_A89; + m_A90 += m_A3 * f1_34; + m_A91 += m_A4 * f1_34; + RHS34 += f1_34 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_49 = -f2 * m_A157; + m_A161 += m_A6 * f2_49; + RHS49 += f2_49 * RHS2; + const double f3 = 1.0 / m_A7; + const double f3_35 = -f3 * m_A93; + m_A95 += m_A8 * f3_35; + RHS35 += f3_35 * RHS3; + const double f4 = 1.0 / m_A9; + const double f4_49 = -f4 * m_A158; + m_A161 += m_A10 * f4_49; + RHS49 += f4_49 * RHS4; + const double f5 = 1.0 / m_A11; + const double f5_35 = -f5 * m_A94; + m_A95 += m_A12 * f5_35; + m_A96 += m_A13 * f5_35; + RHS35 += f5_35 * RHS5; + const double f5_42 = -f5 * m_A126; + m_A127 += m_A12 * f5_42; + m_A128 += m_A13 * f5_42; + RHS42 += f5_42 * RHS5; + const double f6 = 1.0 / m_A14; + const double f6_36 = -f6 * m_A97; + m_A98 += m_A15 * f6_36; + RHS36 += f6_36 * RHS6; + const double f7 = 1.0 / m_A16; + const double f7_50 = -f7 * m_A163; + m_A166 += m_A17 * f7_50; + m_A167 += m_A18 * f7_50; + RHS50 += f7_50 * RHS7; + const double f7_51 = -f7 * m_A169; + m_A173 += m_A17 * f7_51; + m_A174 += m_A18 * f7_51; + RHS51 += f7_51 * RHS7; + const double f8 = 1.0 / m_A19; + const double f8_38 = -f8 * m_A105; + m_A107 += m_A20 * f8_38; + m_A109 += m_A21 * f8_38; + RHS38 += f8_38 * RHS8; + const double f8_51 = -f8 * m_A170; + m_A172 += m_A20 * f8_51; + m_A174 += m_A21 * f8_51; + RHS51 += f8_51 * RHS8; + const double f9 = 1.0 / m_A22; + const double f9_58 = -f9 * m_A212; + m_A216 += m_A23 * f9_58; + RHS58 += f9_58 * RHS9; + const double f10 = 1.0 / m_A24; + const double f10_37 = -f10 * m_A101; + m_A102 += m_A25 * f10_37; + RHS37 += f10_37 * RHS10; + const double f11 = 1.0 / m_A26; + const double f11_58 = -f11 * m_A213; + m_A216 += m_A27 * f11_58; + RHS58 += f11_58 * RHS11; + const double f12 = 1.0 / m_A28; + const double f12_52 = -f12 * m_A176; + m_A179 += m_A29 * f12_52; + m_A180 += m_A30 * f12_52; + RHS52 += f12_52 * RHS12; + const double f12_56 = -f12 * m_A195; + m_A199 += m_A29 * f12_56; + m_A200 += m_A30 * f12_56; + RHS56 += f12_56 * RHS12; + const double f13 = 1.0 / m_A31; + const double f13_39 = -f13 * m_A111; + m_A113 += m_A32 * f13_39; + m_A115 += m_A33 * f13_39; + RHS39 += f13_39 * RHS13; + const double f13_56 = -f13 * m_A196; + m_A198 += m_A32 * f13_56; + m_A200 += m_A33 * f13_56; + RHS56 += f13_56 * RHS13; + const double f14 = 1.0 / m_A34; + const double f14_38 = -f14 * m_A106; + m_A107 += m_A35 * f14_38; + m_A110 += m_A36 * f14_38; + RHS38 += f14_38 * RHS14; + const double f14_59 = -f14 * m_A218; + m_A220 += m_A35 * f14_59; + m_A225 += m_A36 * f14_59; + RHS59 += f14_59 * RHS14; + const double f15 = 1.0 / m_A37; + const double f15_43 = -f15 * m_A130; + m_A132 += m_A38 * f15_43; + RHS43 += f15_43 * RHS15; + const double f16 = 1.0 / m_A39; + const double f16_57 = -f16 * m_A202; + m_A210 += m_A40 * f16_57; + RHS57 += f16_57 * RHS16; + const double f17 = 1.0 / m_A41; + const double f17_40 = -f17 * m_A117; + m_A119 += m_A42 * f17_40; + RHS40 += f17_40 * RHS17; + const double f17_41 = -f17 * m_A120; + m_A123 += m_A42 * f17_41; + RHS41 += f17_41 * RHS17; + const double f18 = 1.0 / m_A43; + const double f18_39 = -f18 * m_A112; + m_A113 += m_A44 * f18_39; + m_A116 += m_A45 * f18_39; + RHS39 += f18_39 * RHS18; + const double f18_60 = -f18 * m_A227; + m_A229 += m_A44 * f18_60; + m_A234 += m_A45 * f18_60; + RHS60 += f18_60 * RHS18; + const double f19 = 1.0 / m_A46; + const double f19_44 = -f19 * m_A135; + m_A137 += m_A47 * f19_44; + RHS44 += f19_44 * RHS19; + const double f20 = 1.0 / m_A48; + const double f20_57 = -f20 * m_A203; + m_A210 += m_A49 * f20_57; + RHS57 += f20_57 * RHS20; + const double f21 = 1.0 / m_A50; + const double f21_57 = -f21 * m_A204; + m_A210 += m_A51 * f21_57; + RHS57 += f21_57 * RHS21; + const double f22 = 1.0 / m_A52; + const double f22_57 = -f22 * m_A205; + m_A210 += m_A53 * f22_57; + RHS57 += f22_57 * RHS22; + const double f23 = 1.0 / m_A54; + const double f23_45 = -f23 * m_A140; + m_A141 += m_A55 * f23_45; + RHS45 += f23_45 * RHS23; + const double f24 = 1.0 / m_A56; + const double f24_46 = -f24 * m_A143; + m_A144 += m_A57 * f24_46; + RHS46 += f24_46 * RHS24; + const double f25 = 1.0 / m_A58; + const double f25_41 = -f25 * m_A121; + m_A122 += m_A59 * f25_41; + m_A123 += m_A60 * f25_41; + m_A124 += m_A61 * f25_41; + m_A125 += m_A62 * f25_41; + RHS41 += f25_41 * RHS25; + const double f25_48 = -f25 * m_A151; + m_A152 += m_A59 * f25_48; + m_A153 += m_A60 * f25_48; + m_A154 += m_A61 * f25_48; + m_A155 += m_A62 * f25_48; + RHS48 += f25_48 * RHS25; + const double f25_57 = -f25 * m_A206; + m_A207 += m_A59 * f25_57; + m_A208 += m_A60 * f25_57; + m_A209 += m_A61 * f25_57; + m_A210 += m_A62 * f25_57; + RHS57 += f25_57 * RHS25; + const double f26 = 1.0 / m_A63; + const double f26_43 = -f26 * m_A131; + m_A132 += m_A64 * f26_43; + m_A133 += m_A65 * f26_43; + m_A134 += m_A66 * f26_43; + RHS43 += f26_43 * RHS26; + const double f26_53 = -f26 * m_A182; + m_A183 += m_A64 * f26_53; + m_A184 += m_A65 * f26_53; + m_A185 += m_A66 * f26_53; + RHS53 += f26_53 * RHS26; + const double f26_59 = -f26 * m_A219; + m_A221 += m_A64 * f26_59; + m_A224 += m_A65 * f26_59; + m_A225 += m_A66 * f26_59; + RHS59 += f26_59 * RHS26; + const double f27 = 1.0 / m_A67; + const double f27_44 = -f27 * m_A136; + m_A137 += m_A68 * f27_44; + m_A138 += m_A69 * f27_44; + m_A139 += m_A70 * f27_44; + RHS44 += f27_44 * RHS27; + const double f27_54 = -f27 * m_A187; + m_A188 += m_A68 * f27_54; + m_A189 += m_A69 * f27_54; + m_A190 += m_A70 * f27_54; + RHS54 += f27_54 * RHS27; + const double f27_60 = -f27 * m_A228; + m_A230 += m_A68 * f27_60; + m_A232 += m_A69 * f27_60; + m_A234 += m_A70 * f27_60; + RHS60 += f27_60 * RHS27; + const double f28 = 1.0 / m_A71; + const double f28_55 = -f28 * m_A192; + m_A193 += m_A72 * f28_55; + RHS55 += f28_55 * RHS28; + const double f29 = 1.0 / m_A73; + const double f29_49 = -f29 * m_A159; + m_A161 += m_A74 * f29_49; + m_A162 += m_A75 * f29_49; + RHS49 += f29_49 * RHS29; + const double f29_62 = -f29 * m_A240; + m_A247 += m_A74 * f29_62; + m_A256 += m_A75 * f29_62; + RHS62 += f29_62 * RHS29; + const double f30 = 1.0 / m_A76; + const double f30_58 = -f30 * m_A214; + m_A216 += m_A77 * f30_58; + m_A217 += m_A78 * f30_58; + RHS58 += f30_58 * RHS30; + const double f30_62 = -f30 * m_A241; + m_A252 += m_A77 * f30_62; + m_A256 += m_A78 * f30_62; + RHS62 += f30_62 * RHS30; + const double f31 = 1.0 / m_A79; + const double f31_47 = -f31 * m_A146; + m_A148 += m_A80 * f31_47; + m_A150 += m_A81 * f31_47; + RHS47 += f31_47 * RHS31; + const double f31_62 = -f31 * m_A242; + m_A245 += m_A80 * f31_62; + m_A256 += m_A81 * f31_62; + RHS62 += f31_62 * RHS31; + const double f32 = 1.0 / m_A82; + const double f32_47 = -f32 * m_A147; + m_A148 += m_A83 * f32_47; + m_A149 += m_A84 * f32_47; + RHS47 += f32_47 * RHS32; + const double f32_61 = -f32 * m_A236; + m_A237 += m_A83 * f32_61; + m_A238 += m_A84 * f32_61; + RHS61 += f32_61 * RHS32; + const double f33 = 1.0 / m_A87; + const double f33_34 = -f33 * m_A90; + m_A91 += m_A88 * f33_34; + RHS34 += f33_34 * RHS33; + const double f34 = 1.0 / m_A91; + const double f34_49 = -f34 * m_A160; + m_A161 += m_A92 * f34_49; + RHS49 += f34_49 * RHS34; + const double f35 = 1.0 / m_A95; + const double f35_42 = -f35 * m_A127; + m_A128 += m_A96 * f35_42; + RHS42 += f35_42 * RHS35; + const double f36 = 1.0 / m_A98; + const double f36_50 = -f36 * m_A164; + m_A166 += m_A99 * f36_50; + m_A167 += m_A100 * f36_50; + RHS50 += f36_50 * RHS36; + const double f36_51 = -f36 * m_A171; + m_A173 += m_A99 * f36_51; + m_A174 += m_A100 * f36_51; + RHS51 += f36_51 * RHS36; + const double f37 = 1.0 / m_A102; + const double f37_52 = -f37 * m_A177; + m_A179 += m_A103 * f37_52; + m_A180 += m_A104 * f37_52; + RHS52 += f37_52 * RHS37; + const double f37_56 = -f37 * m_A197; + m_A199 += m_A103 * f37_56; + m_A200 += m_A104 * f37_56; + RHS56 += f37_56 * RHS37; + const double f38 = 1.0 / m_A107; + const double f38_50 = -f38 * m_A165; + m_A166 += m_A108 * f38_50; + m_A167 += m_A109 * f38_50; + m_A168 += m_A110 * f38_50; + RHS50 += f38_50 * RHS38; + const double f38_51 = -f38 * m_A172; + m_A173 += m_A108 * f38_51; + m_A174 += m_A109 * f38_51; + m_A175 += m_A110 * f38_51; + RHS51 += f38_51 * RHS38; + const double f38_59 = -f38 * m_A220; + m_A222 += m_A108 * f38_59; + m_A223 += m_A109 * f38_59; + m_A225 += m_A110 * f38_59; + RHS59 += f38_59 * RHS38; + const double f39 = 1.0 / m_A113; + const double f39_52 = -f39 * m_A178; + m_A179 += m_A114 * f39_52; + m_A180 += m_A115 * f39_52; + m_A181 += m_A116 * f39_52; + RHS52 += f39_52 * RHS39; + const double f39_56 = -f39 * m_A198; + m_A199 += m_A114 * f39_56; + m_A200 += m_A115 * f39_56; + m_A201 += m_A116 * f39_56; + RHS56 += f39_56 * RHS39; + const double f39_60 = -f39 * m_A229; + m_A231 += m_A114 * f39_60; + m_A233 += m_A115 * f39_60; + m_A234 += m_A116 * f39_60; + RHS60 += f39_60 * RHS39; + const double f40 = 1.0 / m_A118; + const double f40_41 = -f40 * m_A122; + m_A123 += m_A119 * f40_41; + RHS41 += f40_41 * RHS40; + const double f40_48 = -f40 * m_A152; + m_A153 += m_A119 * f40_48; + RHS48 += f40_48 * RHS40; + const double f40_57 = -f40 * m_A207; + m_A208 += m_A119 * f40_57; + RHS57 += f40_57 * RHS40; + const double f41 = 1.0 / m_A123; + const double f41_48 = -f41 * m_A153; + m_A154 += m_A124 * f41_48; + m_A155 += m_A125 * f41_48; + RHS48 += f41_48 * RHS41; + const double f41_57 = -f41 * m_A208; + m_A209 += m_A124 * f41_57; + m_A210 += m_A125 * f41_57; + RHS57 += f41_57 * RHS41; + const double f42 = 1.0 / m_A128; + const double f42_58 = -f42 * m_A215; + m_A216 += m_A129 * f42_58; + RHS58 += f42_58 * RHS42; + const double f43 = 1.0 / m_A132; + const double f43_53 = -f43 * m_A183; + m_A184 += m_A133 * f43_53; + m_A185 += m_A134 * f43_53; + RHS53 += f43_53 * RHS43; + const double f43_59 = -f43 * m_A221; + m_A224 += m_A133 * f43_59; + m_A225 += m_A134 * f43_59; + RHS59 += f43_59 * RHS43; + const double f44 = 1.0 / m_A137; + const double f44_54 = -f44 * m_A188; + m_A189 += m_A138 * f44_54; + m_A190 += m_A139 * f44_54; + RHS54 += f44_54 * RHS44; + const double f44_60 = -f44 * m_A230; + m_A232 += m_A138 * f44_60; + m_A234 += m_A139 * f44_60; + RHS60 += f44_60 * RHS44; + const double f45 = 1.0 / m_A141; + const double f45_62 = -f45 * m_A243; + m_A256 += m_A142 * f45_62; + RHS62 += f45_62 * RHS45; + const double f46 = 1.0 / m_A144; + const double f46_62 = -f46 * m_A244; + m_A256 += m_A145 * f46_62; + RHS62 += f46_62 * RHS46; + const double f47 = 1.0 / m_A148; + const double f47_61 = -f47 * m_A237; + m_A238 += m_A149 * f47_61; + m_A239 += m_A150 * f47_61; + RHS61 += f47_61 * RHS47; + const double f47_62 = -f47 * m_A245; + m_A255 += m_A149 * f47_62; + m_A256 += m_A150 * f47_62; + RHS62 += f47_62 * RHS47; + const double f48 = 1.0 / m_A154; + const double f48_57 = -f48 * m_A209; + m_A210 += m_A155 * f48_57; + m_A211 += m_A156 * f48_57; + RHS57 += f48_57 * RHS48; + const double f48_62 = -f48 * m_A246; + m_A251 += m_A155 * f48_62; + m_A256 += m_A156 * f48_62; + RHS62 += f48_62 * RHS48; + const double f49 = 1.0 / m_A161; + const double f49_62 = -f49 * m_A247; + m_A256 += m_A162 * f49_62; + RHS62 += f49_62 * RHS49; + const double f50 = 1.0 / m_A166; + const double f50_51 = -f50 * m_A173; + m_A174 += m_A167 * f50_51; + m_A175 += m_A168 * f50_51; + RHS51 += f50_51 * RHS50; + const double f50_59 = -f50 * m_A222; + m_A223 += m_A167 * f50_59; + m_A225 += m_A168 * f50_59; + RHS59 += f50_59 * RHS50; + const double f51 = 1.0 / m_A174; + const double f51_59 = -f51 * m_A223; + m_A225 += m_A175 * f51_59; + RHS59 += f51_59 * RHS51; + const double f52 = 1.0 / m_A179; + const double f52_56 = -f52 * m_A199; + m_A200 += m_A180 * f52_56; + m_A201 += m_A181 * f52_56; + RHS56 += f52_56 * RHS52; + const double f52_60 = -f52 * m_A231; + m_A233 += m_A180 * f52_60; + m_A234 += m_A181 * f52_60; + RHS60 += f52_60 * RHS52; + const double f53 = 1.0 / m_A184; + const double f53_59 = -f53 * m_A224; + m_A225 += m_A185 * f53_59; + m_A226 += m_A186 * f53_59; + RHS59 += f53_59 * RHS53; + const double f53_62 = -f53 * m_A248; + m_A253 += m_A185 * f53_62; + m_A256 += m_A186 * f53_62; + RHS62 += f53_62 * RHS53; + const double f54 = 1.0 / m_A189; + const double f54_60 = -f54 * m_A232; + m_A234 += m_A190 * f54_60; + m_A235 += m_A191 * f54_60; + RHS60 += f54_60 * RHS54; + const double f54_62 = -f54 * m_A249; + m_A254 += m_A190 * f54_62; + m_A256 += m_A191 * f54_62; + RHS62 += f54_62 * RHS54; + const double f55 = 1.0 / m_A193; + const double f55_62 = -f55 * m_A250; + m_A256 += m_A194 * f55_62; + RHS62 += f55_62 * RHS55; + const double f56 = 1.0 / m_A200; + const double f56_60 = -f56 * m_A233; + m_A234 += m_A201 * f56_60; + RHS60 += f56_60 * RHS56; + const double f57 = 1.0 / m_A210; + const double f57_62 = -f57 * m_A251; + m_A256 += m_A211 * f57_62; + RHS62 += f57_62 * RHS57; + const double f58 = 1.0 / m_A216; + const double f58_62 = -f58 * m_A252; + m_A256 += m_A217 * f58_62; + RHS62 += f58_62 * RHS58; + const double f59 = 1.0 / m_A225; + const double f59_62 = -f59 * m_A253; + m_A256 += m_A226 * f59_62; + RHS62 += f59_62 * RHS59; + const double f60 = 1.0 / m_A234; + const double f60_62 = -f60 * m_A254; + m_A256 += m_A235 * f60_62; + RHS62 += f60_62 * RHS60; + const double f61 = 1.0 / m_A238; + const double f61_62 = -f61 * m_A255; + m_A256 += m_A239 * f61_62; + RHS62 += f61_62 * RHS61; + V[62] = RHS62 / m_A256; + double tmp61 = 0.0; + tmp61 += m_A239 * V[62]; + V[61] = (RHS61 - tmp61) / m_A238; + double tmp60 = 0.0; + tmp60 += m_A235 * V[62]; + V[60] = (RHS60 - tmp60) / m_A234; + double tmp59 = 0.0; + tmp59 += m_A226 * V[62]; + V[59] = (RHS59 - tmp59) / m_A225; + double tmp58 = 0.0; + tmp58 += m_A217 * V[62]; + V[58] = (RHS58 - tmp58) / m_A216; + double tmp57 = 0.0; + tmp57 += m_A211 * V[62]; + V[57] = (RHS57 - tmp57) / m_A210; + double tmp56 = 0.0; + tmp56 += m_A201 * V[60]; + V[56] = (RHS56 - tmp56) / m_A200; + double tmp55 = 0.0; + tmp55 += m_A194 * V[62]; + V[55] = (RHS55 - tmp55) / m_A193; + double tmp54 = 0.0; + tmp54 += m_A190 * V[60]; + tmp54 += m_A191 * V[62]; + V[54] = (RHS54 - tmp54) / m_A189; + double tmp53 = 0.0; + tmp53 += m_A185 * V[59]; + tmp53 += m_A186 * V[62]; + V[53] = (RHS53 - tmp53) / m_A184; + double tmp52 = 0.0; + tmp52 += m_A180 * V[56]; + tmp52 += m_A181 * V[60]; + V[52] = (RHS52 - tmp52) / m_A179; + double tmp51 = 0.0; + tmp51 += m_A175 * V[59]; + V[51] = (RHS51 - tmp51) / m_A174; + double tmp50 = 0.0; + tmp50 += m_A167 * V[51]; + tmp50 += m_A168 * V[59]; + V[50] = (RHS50 - tmp50) / m_A166; + double tmp49 = 0.0; + tmp49 += m_A162 * V[62]; + V[49] = (RHS49 - tmp49) / m_A161; + double tmp48 = 0.0; + tmp48 += m_A155 * V[57]; + tmp48 += m_A156 * V[62]; + V[48] = (RHS48 - tmp48) / m_A154; + double tmp47 = 0.0; + tmp47 += m_A149 * V[61]; + tmp47 += m_A150 * V[62]; + V[47] = (RHS47 - tmp47) / m_A148; + double tmp46 = 0.0; + tmp46 += m_A145 * V[62]; + V[46] = (RHS46 - tmp46) / m_A144; + double tmp45 = 0.0; + tmp45 += m_A142 * V[62]; + V[45] = (RHS45 - tmp45) / m_A141; + double tmp44 = 0.0; + tmp44 += m_A138 * V[54]; + tmp44 += m_A139 * V[60]; + V[44] = (RHS44 - tmp44) / m_A137; + double tmp43 = 0.0; + tmp43 += m_A133 * V[53]; + tmp43 += m_A134 * V[59]; + V[43] = (RHS43 - tmp43) / m_A132; + double tmp42 = 0.0; + tmp42 += m_A129 * V[58]; + V[42] = (RHS42 - tmp42) / m_A128; + double tmp41 = 0.0; + tmp41 += m_A124 * V[48]; + tmp41 += m_A125 * V[57]; + V[41] = (RHS41 - tmp41) / m_A123; + double tmp40 = 0.0; + tmp40 += m_A119 * V[41]; + V[40] = (RHS40 - tmp40) / m_A118; + double tmp39 = 0.0; + tmp39 += m_A114 * V[52]; + tmp39 += m_A115 * V[56]; + tmp39 += m_A116 * V[60]; + V[39] = (RHS39 - tmp39) / m_A113; + double tmp38 = 0.0; + tmp38 += m_A108 * V[50]; + tmp38 += m_A109 * V[51]; + tmp38 += m_A110 * V[59]; + V[38] = (RHS38 - tmp38) / m_A107; + double tmp37 = 0.0; + tmp37 += m_A103 * V[52]; + tmp37 += m_A104 * V[56]; + V[37] = (RHS37 - tmp37) / m_A102; + double tmp36 = 0.0; + tmp36 += m_A99 * V[50]; + tmp36 += m_A100 * V[51]; + V[36] = (RHS36 - tmp36) / m_A98; + double tmp35 = 0.0; + tmp35 += m_A96 * V[42]; + V[35] = (RHS35 - tmp35) / m_A95; + double tmp34 = 0.0; + tmp34 += m_A92 * V[49]; + V[34] = (RHS34 - tmp34) / m_A91; + double tmp33 = 0.0; + tmp33 += m_A88 * V[34]; + V[33] = (RHS33 - tmp33) / m_A87; + double tmp32 = 0.0; + tmp32 += m_A83 * V[47]; + tmp32 += m_A84 * V[61]; + V[32] = (RHS32 - tmp32) / m_A82; + double tmp31 = 0.0; + tmp31 += m_A80 * V[47]; + tmp31 += m_A81 * V[62]; + V[31] = (RHS31 - tmp31) / m_A79; + double tmp30 = 0.0; + tmp30 += m_A77 * V[58]; + tmp30 += m_A78 * V[62]; + V[30] = (RHS30 - tmp30) / m_A76; + double tmp29 = 0.0; + tmp29 += m_A74 * V[49]; + tmp29 += m_A75 * V[62]; + V[29] = (RHS29 - tmp29) / m_A73; + double tmp28 = 0.0; + tmp28 += m_A72 * V[55]; + V[28] = (RHS28 - tmp28) / m_A71; + double tmp27 = 0.0; + tmp27 += m_A68 * V[44]; + tmp27 += m_A69 * V[54]; + tmp27 += m_A70 * V[60]; + V[27] = (RHS27 - tmp27) / m_A67; + double tmp26 = 0.0; + tmp26 += m_A64 * V[43]; + tmp26 += m_A65 * V[53]; + tmp26 += m_A66 * V[59]; + V[26] = (RHS26 - tmp26) / m_A63; + double tmp25 = 0.0; + tmp25 += m_A59 * V[40]; + tmp25 += m_A60 * V[41]; + tmp25 += m_A61 * V[48]; + tmp25 += m_A62 * V[57]; + V[25] = (RHS25 - tmp25) / m_A58; + double tmp24 = 0.0; + tmp24 += m_A57 * V[46]; + V[24] = (RHS24 - tmp24) / m_A56; + double tmp23 = 0.0; + tmp23 += m_A55 * V[45]; + V[23] = (RHS23 - tmp23) / m_A54; + double tmp22 = 0.0; + tmp22 += m_A53 * V[57]; + V[22] = (RHS22 - tmp22) / m_A52; + double tmp21 = 0.0; + tmp21 += m_A51 * V[57]; + V[21] = (RHS21 - tmp21) / m_A50; + double tmp20 = 0.0; + tmp20 += m_A49 * V[57]; + V[20] = (RHS20 - tmp20) / m_A48; + double tmp19 = 0.0; + tmp19 += m_A47 * V[44]; + V[19] = (RHS19 - tmp19) / m_A46; + double tmp18 = 0.0; + tmp18 += m_A44 * V[39]; + tmp18 += m_A45 * V[60]; + V[18] = (RHS18 - tmp18) / m_A43; + double tmp17 = 0.0; + tmp17 += m_A42 * V[41]; + V[17] = (RHS17 - tmp17) / m_A41; + double tmp16 = 0.0; + tmp16 += m_A40 * V[57]; + V[16] = (RHS16 - tmp16) / m_A39; + double tmp15 = 0.0; + tmp15 += m_A38 * V[43]; + V[15] = (RHS15 - tmp15) / m_A37; + double tmp14 = 0.0; + tmp14 += m_A35 * V[38]; + tmp14 += m_A36 * V[59]; + V[14] = (RHS14 - tmp14) / m_A34; + double tmp13 = 0.0; + tmp13 += m_A32 * V[39]; + tmp13 += m_A33 * V[56]; + V[13] = (RHS13 - tmp13) / m_A31; + double tmp12 = 0.0; + tmp12 += m_A29 * V[52]; + tmp12 += m_A30 * V[56]; + V[12] = (RHS12 - tmp12) / m_A28; + double tmp11 = 0.0; + tmp11 += m_A27 * V[58]; + V[11] = (RHS11 - tmp11) / m_A26; + double tmp10 = 0.0; + tmp10 += m_A25 * V[37]; + V[10] = (RHS10 - tmp10) / m_A24; + double tmp9 = 0.0; + tmp9 += m_A23 * V[58]; + V[9] = (RHS9 - tmp9) / m_A22; + double tmp8 = 0.0; + tmp8 += m_A20 * V[38]; + tmp8 += m_A21 * V[51]; + V[8] = (RHS8 - tmp8) / m_A19; + double tmp7 = 0.0; + tmp7 += m_A17 * V[50]; + tmp7 += m_A18 * V[51]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A15 * V[36]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A12 * V[35]; + tmp5 += m_A13 * V[42]; + V[5] = (RHS5 - tmp5) / m_A11; + double tmp4 = 0.0; + tmp4 += m_A10 * V[49]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A8 * V[35]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A6 * V[49]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[33]; + tmp1 += m_A4 * V[34]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[33]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// dribling +static void nl_gcr_7_double_double_a1ecff4d37b54b76(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A3 += go[4]; + double 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_A5 += go[7]; + m_A4 += go[8]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[9] * *cnV[9]; + 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; +} + // elim,zektor static void nl_gcr_10_double_double_11c2ae166b240b6e(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -28709,57 +30716,6 @@ static void nl_gcr_45_double_double_28b736fe552777a9(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } -// elim,zektor -static void nl_gcr_7_double_double_d190a0e3b8e1f4a7(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) - -{ - - plib::unused_var(cnV); - double m_A0(0.0); - double m_A1(0.0); - double m_A2(0.0); - double m_A3(0.0); - double m_A4(0.0); - double m_A5(0.0); - double m_A6(0.0); - m_A0 += gt[0]; - m_A0 += gt[1]; - m_A1 += go[0]; - double RHS0 = Idr[0]; - RHS0 += Idr[1]; - RHS0 -= go[1] * *cnV[1]; - m_A2 += gt[2]; - m_A2 += gt[3]; - m_A3 += go[2]; - double RHS1 = Idr[2]; - RHS1 += Idr[3]; - RHS1 -= go[3] * *cnV[3]; - m_A6 += gt[4]; - m_A6 += gt[5]; - m_A6 += gt[6]; - m_A5 += go[4]; - m_A4 += go[5]; - double RHS2 = Idr[4]; - RHS2 += Idr[5]; - RHS2 += Idr[6]; - RHS2 -= go[6] * *cnV[6]; - 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; -} - // fireone static void nl_gcr_128_double_double_7aee4423e3fdbfda(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -33183,63 +35139,6 @@ static void nl_gcr_79_double_double_c1d22fe6e895255d(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } -// fireone,astrob,rebound,speedfrk,cheekyms -static void nl_gcr_7_double_double_7c86a9bc1c6aef4c(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_A3 += go[3]; - double RHS1 = Idr[3]; - RHS1 += Idr[4]; - RHS1 -= go[4] * *cnV[4]; - m_A6 += gt[5]; - m_A6 += gt[6]; - m_A6 += gt[7]; - m_A6 += gt[8]; - m_A5 += go[5]; - m_A4 += go[6]; - double RHS2 = Idr[5]; - RHS2 += Idr[6]; - RHS2 += Idr[7]; - RHS2 += Idr[8]; - RHS2 -= go[7] * *cnV[7]; - RHS2 -= go[8] * *cnV[8]; - const double f0 = 1.0 / m_A0; - const double f0_2 = -f0 * m_A4; - m_A6 += m_A1 * f0_2; - RHS2 += f0_2 * RHS0; - const double f1 = 1.0 / m_A2; - const double f1_2 = -f1 * m_A5; - m_A6 += m_A3 * f1_2; - RHS2 += f1_2 * RHS1; - V[2] = RHS2 / m_A6; - double tmp1 = 0.0; - tmp1 += m_A3 * V[2]; - V[1] = (RHS1 - tmp1) / m_A2; - double tmp0 = 0.0; - tmp0 += m_A1 * V[2]; - V[0] = (RHS0 - tmp0) / m_A0; -} - // fireone static void nl_gcr_7_double_double_e7fb484f621b3ab9(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -38153,8 +40052,163 @@ static void nl_gcr_7_double_double_782d79b5cbe953b1(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// gi6809 +static void nl_gcr_13_double_double_9eda6de0d275a3e5(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); + 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]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A5 += go[7]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + RHS2 -= go[10] * *cnV[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A7 += go[11]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 -= go[12] * *cnV[12]; + m_A12 += gt[13]; + m_A12 += gt[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A12 += gt[17]; + m_A12 += gt[18]; + m_A11 += go[13]; + m_A10 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS4 = Idr[13]; + RHS4 += Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 -= go[17] * *cnV[17]; + RHS4 -= go[18] * *cnV[18]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A8; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A9; + m_A12 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A10; + m_A12 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_4 = -f3 * m_A11; + m_A12 += m_A7 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A12; + double tmp3 = 0.0; + tmp3 += m_A7 * V[4]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// gi6809 +static void nl_gcr_7_double_double_8a409a18e77784cb(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A6 += gt[4]; + m_A6 += gt[5]; + m_A5 += go[4]; + m_A4 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + 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; +} + // gtrak10 -static void nl_gcr_43_double_double_4c46fdf7c0037727(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) +static void nl_gcr_22_double_double_1f38df4919cdddae(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) { @@ -38181,27 +40235,6 @@ static void nl_gcr_43_double_double_4c46fdf7c0037727(double * __restrict V, cons 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); m_A0 += gt[0]; m_A0 += gt[1]; m_A0 += gt[2]; @@ -38221,262 +40254,159 @@ static void nl_gcr_43_double_double_4c46fdf7c0037727(double * __restrict V, cons RHS1 -= go[4] * *cnV[4]; RHS1 -= go[5] * *cnV[5]; m_A4 += gt[6]; - m_A4 += gt[7]; - m_A4 += gt[8]; m_A5 += go[6]; double RHS2 = Idr[6]; - RHS2 += Idr[7]; - RHS2 += Idr[8]; - RHS2 -= go[7] * *cnV[7]; - RHS2 -= go[8] * *cnV[8]; - m_A6 += gt[9]; - m_A6 += gt[10]; - m_A6 += gt[11]; - m_A7 += go[9]; - double RHS3 = Idr[9]; - RHS3 += Idr[10]; - RHS3 += Idr[11]; - RHS3 -= go[10] * *cnV[10]; - RHS3 -= go[11] * *cnV[11]; - m_A8 += gt[12]; - m_A8 += gt[13]; - m_A8 += gt[14]; - m_A9 += go[12]; - double RHS4 = Idr[12]; - RHS4 += Idr[13]; - RHS4 += Idr[14]; - RHS4 -= go[13] * *cnV[13]; - RHS4 -= go[14] * *cnV[14]; - m_A10 += gt[15]; - m_A10 += gt[16]; - m_A10 += gt[17]; - m_A11 += go[15]; - double RHS5 = Idr[15]; - RHS5 += Idr[16]; - RHS5 += Idr[17]; - RHS5 -= go[16] * *cnV[16]; - RHS5 -= go[17] * *cnV[17]; - m_A12 += gt[18]; - m_A12 += gt[19]; - m_A12 += gt[20]; - m_A13 += go[18]; - double RHS6 = Idr[18]; - RHS6 += Idr[19]; - RHS6 += Idr[20]; - RHS6 -= go[19] * *cnV[19]; - RHS6 -= go[20] * *cnV[20]; - m_A14 += gt[21]; - m_A14 += gt[22]; - m_A14 += gt[23]; - m_A15 += go[21]; - double RHS7 = Idr[21]; + m_A6 += gt[7]; + m_A7 += go[7]; + double RHS3 = Idr[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A8 += gt[10]; + m_A9 += go[8]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + RHS4 += Idr[10]; + RHS4 -= go[9] * *cnV[9]; + RHS4 -= go[10] * *cnV[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A10 += gt[13]; + m_A11 += go[11]; + double RHS5 = Idr[11]; + RHS5 += Idr[12]; + RHS5 += Idr[13]; + RHS5 -= go[12] * *cnV[12]; + RHS5 -= go[13] * *cnV[13]; + m_A14 += gt[14]; + m_A14 += gt[15]; + m_A14 += gt[16]; + m_A13 += go[14]; + m_A12 += go[15]; + m_A15 += go[16]; + double RHS6 = Idr[14]; + RHS6 += Idr[15]; + RHS6 += Idr[16]; + m_A21 += gt[17]; + m_A21 += gt[18]; + m_A21 += gt[19]; + m_A21 += gt[20]; + m_A21 += gt[21]; + m_A21 += gt[22]; + m_A21 += gt[23]; + m_A20 += go[17]; + m_A19 += go[18]; + m_A18 += go[19]; + m_A17 += go[20]; + m_A16 += go[21]; + double RHS7 = Idr[17]; + RHS7 += Idr[18]; + RHS7 += Idr[19]; + RHS7 += Idr[20]; + RHS7 += Idr[21]; RHS7 += Idr[22]; RHS7 += Idr[23]; RHS7 -= go[22] * *cnV[22]; RHS7 -= go[23] * *cnV[23]; - m_A16 += gt[24]; - m_A16 += gt[25]; - m_A16 += gt[26]; - m_A17 += go[24]; - double RHS8 = Idr[24]; - RHS8 += Idr[25]; - RHS8 += Idr[26]; - RHS8 -= go[25] * *cnV[25]; - RHS8 -= go[26] * *cnV[26]; - m_A18 += gt[27]; - m_A18 += gt[28]; - m_A18 += gt[29]; - m_A19 += go[27]; - double RHS9 = Idr[27]; - RHS9 += Idr[28]; - RHS9 += Idr[29]; - RHS9 -= go[28] * *cnV[28]; - RHS9 -= go[29] * *cnV[29]; - m_A20 += gt[30]; - m_A20 += gt[31]; - m_A20 += gt[32]; - m_A21 += go[30]; - double RHS10 = Idr[30]; - RHS10 += Idr[31]; - RHS10 += Idr[32]; - RHS10 -= go[31] * *cnV[31]; - RHS10 -= go[32] * *cnV[32]; - m_A22 += gt[33]; - m_A22 += gt[34]; - m_A22 += gt[35]; - m_A23 += go[33]; - double RHS11 = Idr[33]; - RHS11 += Idr[34]; - RHS11 += Idr[35]; - RHS11 -= go[34] * *cnV[34]; - RHS11 -= go[35] * *cnV[35]; - m_A25 += gt[36]; - m_A25 += gt[37]; - m_A25 += gt[38]; - m_A26 += go[36]; - m_A24 += go[37]; - double RHS12 = Idr[36]; - RHS12 += Idr[37]; - RHS12 += Idr[38]; - RHS12 -= go[38] * *cnV[38]; - m_A30 += gt[39]; - m_A30 += gt[40]; - m_A30 += gt[41]; - m_A30 += gt[42]; - m_A30 += gt[43]; - m_A30 += gt[44]; - m_A30 += gt[45]; - m_A29 += go[39]; - m_A28 += go[40]; - m_A27 += go[41]; - m_A31 += go[42]; - m_A31 += go[43]; - double RHS13 = Idr[39]; - RHS13 += Idr[40]; - RHS13 += Idr[41]; - RHS13 += Idr[42]; - RHS13 += Idr[43]; - RHS13 += Idr[44]; - RHS13 += Idr[45]; - RHS13 -= go[44] * *cnV[44]; - RHS13 -= go[45] * *cnV[45]; - m_A42 += gt[46]; - m_A42 += gt[47]; - m_A42 += gt[48]; - m_A42 += gt[49]; - m_A42 += gt[50]; - m_A42 += gt[51]; - m_A42 += gt[52]; - m_A42 += gt[53]; - m_A42 += gt[54]; - m_A42 += gt[55]; - m_A42 += gt[56]; - m_A42 += gt[57]; - m_A42 += gt[58]; - m_A41 += go[46]; - m_A41 += go[47]; - m_A39 += go[48]; - m_A38 += go[49]; - m_A37 += go[50]; - m_A36 += go[51]; - m_A35 += go[52]; - m_A34 += go[53]; - m_A33 += go[54]; - m_A32 += go[55]; - m_A40 += go[56]; - double RHS14 = Idr[46]; - RHS14 += Idr[47]; - RHS14 += Idr[48]; - RHS14 += Idr[49]; - RHS14 += Idr[50]; - RHS14 += Idr[51]; - RHS14 += Idr[52]; - RHS14 += Idr[53]; - RHS14 += Idr[54]; - RHS14 += Idr[55]; - RHS14 += Idr[56]; - RHS14 += Idr[57]; - RHS14 += Idr[58]; - RHS14 -= go[57] * *cnV[57]; - RHS14 -= go[58] * *cnV[58]; const double f0 = 1.0 / m_A0; - const double f0_12 = -f0 * m_A24; - m_A25 += m_A1 * f0_12; - RHS12 += f0_12 * RHS0; + const double f0_7 = -f0 * m_A16; + m_A21 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; const double f1 = 1.0 / m_A2; - const double f1_14 = -f1 * m_A32; - m_A42 += m_A3 * f1_14; - RHS14 += f1_14 * RHS1; + const double f1_7 = -f1 * m_A17; + m_A21 += m_A3 * f1_7; + RHS7 += f1_7 * RHS1; const double f2 = 1.0 / m_A4; - const double f2_14 = -f2 * m_A33; - m_A42 += m_A5 * f2_14; - RHS14 += f2_14 * RHS2; + const double f2_6 = -f2 * m_A12; + m_A14 += m_A5 * f2_6; + RHS6 += f2_6 * RHS2; const double f3 = 1.0 / m_A6; - const double f3_14 = -f3 * m_A34; - m_A42 += m_A7 * f3_14; - RHS14 += f3_14 * RHS3; + const double f3_6 = -f3 * m_A13; + m_A14 += m_A7 * f3_6; + RHS6 += f3_6 * RHS3; const double f4 = 1.0 / m_A8; - const double f4_14 = -f4 * m_A35; - m_A42 += m_A9 * f4_14; - RHS14 += f4_14 * RHS4; + const double f4_7 = -f4 * m_A18; + m_A21 += m_A9 * f4_7; + RHS7 += f4_7 * RHS4; const double f5 = 1.0 / m_A10; - const double f5_14 = -f5 * m_A36; - m_A42 += m_A11 * f5_14; - RHS14 += f5_14 * RHS5; - const double f6 = 1.0 / m_A12; - const double f6_14 = -f6 * m_A37; - m_A42 += m_A13 * f6_14; - RHS14 += f6_14 * RHS6; - const double f7 = 1.0 / m_A14; - const double f7_14 = -f7 * m_A38; - m_A42 += m_A15 * f7_14; - RHS14 += f7_14 * RHS7; - const double f8 = 1.0 / m_A16; - const double f8_14 = -f8 * m_A39; - m_A42 += m_A17 * f8_14; - RHS14 += f8_14 * RHS8; - const double f9 = 1.0 / m_A18; - const double f9_13 = -f9 * m_A27; - m_A30 += m_A19 * f9_13; - RHS13 += f9_13 * RHS9; - const double f10 = 1.0 / m_A20; - const double f10_13 = -f10 * m_A28; - m_A30 += m_A21 * f10_13; - RHS13 += f10_13 * RHS10; - const double f11 = 1.0 / m_A22; - const double f11_13 = -f11 * m_A29; - m_A30 += m_A23 * f11_13; - RHS13 += f11_13 * RHS11; - const double f12 = 1.0 / m_A25; - const double f12_14 = -f12 * m_A40; - m_A42 += m_A26 * f12_14; - RHS14 += f12_14 * RHS12; - const double f13 = 1.0 / m_A30; - const double f13_14 = -f13 * m_A41; - m_A42 += m_A31 * f13_14; - RHS14 += f13_14 * RHS13; - V[14] = RHS14 / m_A42; - double tmp13 = 0.0; - tmp13 += m_A31 * V[14]; - V[13] = (RHS13 - tmp13) / m_A30; - double tmp12 = 0.0; - tmp12 += m_A26 * V[14]; - V[12] = (RHS12 - tmp12) / m_A25; - double tmp11 = 0.0; - tmp11 += m_A23 * V[13]; - V[11] = (RHS11 - tmp11) / m_A22; - double tmp10 = 0.0; - tmp10 += m_A21 * V[13]; - V[10] = (RHS10 - tmp10) / m_A20; - double tmp9 = 0.0; - tmp9 += m_A19 * V[13]; - V[9] = (RHS9 - tmp9) / m_A18; - double tmp8 = 0.0; - tmp8 += m_A17 * V[14]; - V[8] = (RHS8 - tmp8) / m_A16; - double tmp7 = 0.0; - tmp7 += m_A15 * V[14]; - V[7] = (RHS7 - tmp7) / m_A14; + const double f5_7 = -f5 * m_A19; + m_A21 += m_A11 * f5_7; + RHS7 += f5_7 * RHS5; + const double f6 = 1.0 / m_A14; + const double f6_7 = -f6 * m_A20; + m_A21 += m_A15 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A21; double tmp6 = 0.0; - tmp6 += m_A13 * V[14]; - V[6] = (RHS6 - tmp6) / m_A12; + tmp6 += m_A15 * V[7]; + V[6] = (RHS6 - tmp6) / m_A14; double tmp5 = 0.0; - tmp5 += m_A11 * V[14]; + tmp5 += m_A11 * V[7]; V[5] = (RHS5 - tmp5) / m_A10; double tmp4 = 0.0; - tmp4 += m_A9 * V[14]; + tmp4 += m_A9 * V[7]; V[4] = (RHS4 - tmp4) / m_A8; double tmp3 = 0.0; - tmp3 += m_A7 * V[14]; + tmp3 += m_A7 * V[6]; V[3] = (RHS3 - tmp3) / m_A6; double tmp2 = 0.0; - tmp2 += m_A5 * V[14]; + tmp2 += m_A5 * V[6]; V[2] = (RHS2 - tmp2) / m_A4; double tmp1 = 0.0; - tmp1 += m_A3 * V[14]; + tmp1 += m_A3 * V[7]; V[1] = (RHS1 - tmp1) / m_A2; double tmp0 = 0.0; - tmp0 += m_A1 * V[12]; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// gtrak10,elim,zektor +static void nl_gcr_7_double_double_d190a0e3b8e1f4a7(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A6 += gt[4]; + m_A6 += gt[5]; + m_A6 += gt[6]; + m_A5 += go[4]; + m_A4 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 -= go[6] * *cnV[6]; + 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; } @@ -44601,6 +46531,107 @@ static void nl_gcr_50_double_double_c6f25bb06e161d1c(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// rebound,astrob +static void nl_gcr_13_double_double_a41a44bd5c424f88(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); + 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_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[9]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + RHS3 += Idr[11]; + RHS3 -= go[10] * *cnV[10]; + RHS3 -= go[11] * *cnV[11]; + m_A12 += gt[12]; + m_A12 += gt[13]; + m_A12 += gt[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A11 += go[12]; + m_A10 += go[13]; + m_A9 += go[14]; + m_A8 += go[15]; + double RHS4 = Idr[12]; + RHS4 += Idr[13]; + RHS4 += Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 -= go[16] * *cnV[16]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A8; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A9; + m_A12 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A10; + m_A12 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_4 = -f3 * m_A11; + m_A12 += m_A7 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A12; + double tmp3 = 0.0; + tmp3 += m_A7 * V[4]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // rebound static void nl_gcr_28_double_double_8bec817b324dcc3(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -44831,6 +46862,63 @@ static void nl_gcr_28_double_double_8bec817b324dcc3(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// rebound,speedfrk,fireone,astrob,cheekyms +static void nl_gcr_7_double_double_7c86a9bc1c6aef4c(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_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[4] * *cnV[4]; + m_A6 += gt[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A5 += go[5]; + m_A4 += go[6]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // rebound static void nl_gcr_7_double_double_ae15f7f8a55fc96(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -48324,79 +50412,6 @@ static void nl_gcr_40_double_double_53bd9f9a45276ed0(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } -// solarq,boxingb -static void nl_gcr_10_double_double_d7d45dc58b08cab9(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); - m_A0 += gt[0]; - m_A0 += gt[1]; - m_A1 += go[0]; - double RHS0 = Idr[0]; - RHS0 += Idr[1]; - RHS0 -= go[1] * *cnV[1]; - m_A2 += gt[2]; - m_A2 += gt[3]; - m_A2 += gt[4]; - m_A2 += gt[5]; - m_A3 += go[2]; - double RHS1 = Idr[2]; - RHS1 += Idr[3]; - RHS1 += Idr[4]; - RHS1 += Idr[5]; - RHS1 -= go[3] * *cnV[3]; - RHS1 -= go[4] * *cnV[4]; - RHS1 -= go[5] * *cnV[5]; - m_A5 += gt[6]; - m_A5 += gt[7]; - m_A5 += gt[8]; - m_A6 += go[6]; - m_A4 += go[7]; - double RHS2 = Idr[6]; - RHS2 += Idr[7]; - RHS2 += Idr[8]; - RHS2 -= go[8] * *cnV[8]; - m_A9 += gt[9]; - m_A9 += gt[10]; - m_A7 += go[9]; - m_A8 += go[10]; - double RHS3 = Idr[9]; - RHS3 += Idr[10]; - const double f0 = 1.0 / m_A0; - const double f0_2 = -f0 * m_A4; - m_A5 += m_A1 * f0_2; - RHS2 += f0_2 * RHS0; - const double f1 = 1.0 / m_A2; - const double f1_3 = -f1 * m_A7; - m_A9 += m_A3 * f1_3; - RHS3 += f1_3 * RHS1; - const double f2 = 1.0 / m_A5; - const double f2_3 = -f2 * m_A8; - m_A9 += m_A6 * f2_3; - RHS3 += f2_3 * RHS2; - V[3] = RHS3 / m_A9; - double tmp2 = 0.0; - tmp2 += m_A6 * V[3]; - V[2] = (RHS2 - tmp2) / m_A5; - double tmp1 = 0.0; - tmp1 += m_A3 * V[3]; - V[1] = (RHS1 - tmp1) / m_A2; - double tmp0 = 0.0; - tmp0 += m_A1 * V[2]; - V[0] = (RHS0 - tmp0) / m_A0; -} - // solarq static void nl_gcr_15_double_double_7caaa135bff3d9f3(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -48660,6 +50675,198 @@ static void nl_gcr_20_double_double_66496d6073aca98e(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// solarq,starcas,wotw +static void nl_gcr_25_double_double_4cb524006206eb1a(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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A2 += gt[11]; + m_A5 += go[4]; + m_A4 += go[5]; + m_A4 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A7 += go[12]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A9 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A16 += go[20]; + m_A16 += go[21]; + m_A13 += go[22]; + m_A13 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[24] * *cnV[24]; + m_A18 += gt[25]; + m_A18 += gt[26]; + m_A18 += gt[27]; + m_A19 += go[25]; + m_A17 += go[26]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 -= go[27] * *cnV[27]; + m_A24 += gt[28]; + m_A24 += gt[29]; + m_A24 += gt[30]; + m_A24 += gt[31]; + m_A23 += go[28]; + m_A22 += go[29]; + m_A22 += go[30]; + m_A20 += go[31]; + double RHS6 = Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A9; + m_A10 += m_A3 * f1_3; + m_A11 += m_A4 * f1_3; + m_A12 += m_A5 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_4 = -f1 * m_A13; + m_A14 += m_A3 * f1_4; + m_A15 += m_A4 * f1_4; + m_A16 += m_A5 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_6 = -f1 * m_A20; + m_A21 += m_A3 * f1_6; + m_A22 += m_A4 * f1_6; + m_A24 += m_A5 * f1_6; + RHS6 += f1_6 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_5 = -f2 * m_A17; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += m_A12 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_6 = -f3 * m_A21; + m_A22 += m_A11 * f3_6; + m_A24 += m_A12 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A15; + const double f4_6 = -f4 * m_A22; + m_A24 += m_A16 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A18; + const double f5_6 = -f5 * m_A23; + m_A24 += m_A19 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A24; + double tmp5 = 0.0; + tmp5 += m_A19 * V[6]; + V[5] = (RHS5 - tmp5) / m_A18; + double tmp4 = 0.0; + tmp4 += m_A16 * V[6]; + V[4] = (RHS4 - tmp4) / m_A15; + double tmp3 = 0.0; + tmp3 += m_A11 * V[4]; + tmp3 += m_A12 * V[6]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A7 * V[5]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + tmp1 += m_A4 * V[4]; + tmp1 += m_A5 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // solarq static void nl_gcr_303_double_double_62612f71055b8fd4(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -62238,556 +64445,6 @@ static void nl_gcr_12_double_double_88a8ef5f6bd43d48(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } -// starcas,wotw,solarq,armora -static void nl_gcr_22_double_double_1250f340dea396ae(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); - m_A0 += gt[0]; - m_A0 += gt[1]; - m_A0 += gt[2]; - m_A0 += gt[3]; - m_A1 += go[0]; - double RHS0 = Idr[0]; - RHS0 += Idr[1]; - RHS0 += Idr[2]; - RHS0 += Idr[3]; - RHS0 -= go[1] * *cnV[1]; - RHS0 -= go[2] * *cnV[2]; - RHS0 -= go[3] * *cnV[3]; - m_A2 += gt[4]; - m_A2 += gt[5]; - m_A3 += go[4]; - double RHS1 = Idr[4]; - RHS1 += Idr[5]; - RHS1 -= go[5] * *cnV[5]; - m_A4 += gt[6]; - m_A4 += gt[7]; - m_A4 += gt[8]; - m_A4 += gt[9]; - m_A4 += gt[10]; - m_A4 += gt[11]; - m_A4 += gt[12]; - m_A4 += gt[13]; - m_A7 += go[6]; - m_A6 += go[7]; - m_A6 += go[8]; - m_A5 += go[9]; - m_A5 += go[10]; - double RHS2 = Idr[6]; - RHS2 += Idr[7]; - RHS2 += Idr[8]; - RHS2 += Idr[9]; - RHS2 += Idr[10]; - RHS2 += Idr[11]; - RHS2 += Idr[12]; - RHS2 += Idr[13]; - RHS2 -= go[11] * *cnV[11]; - RHS2 -= go[12] * *cnV[12]; - RHS2 -= go[13] * *cnV[13]; - m_A10 += gt[14]; - m_A10 += gt[15]; - m_A10 += gt[16]; - m_A10 += gt[17]; - m_A10 += gt[18]; - m_A10 += gt[19]; - m_A9 += go[14]; - m_A9 += go[15]; - m_A8 += go[16]; - double RHS3 = Idr[14]; - RHS3 += Idr[15]; - RHS3 += Idr[16]; - RHS3 += Idr[17]; - RHS3 += Idr[18]; - RHS3 += Idr[19]; - RHS3 -= go[17] * *cnV[17]; - RHS3 -= go[18] * *cnV[18]; - RHS3 -= go[19] * *cnV[19]; - m_A15 += gt[20]; - m_A15 += gt[21]; - m_A15 += gt[22]; - m_A15 += gt[23]; - m_A15 += gt[24]; - m_A16 += go[20]; - m_A16 += go[21]; - m_A13 += go[22]; - m_A13 += go[23]; - double RHS4 = Idr[20]; - RHS4 += Idr[21]; - RHS4 += Idr[22]; - RHS4 += Idr[23]; - RHS4 += Idr[24]; - RHS4 -= go[24] * *cnV[24]; - m_A21 += gt[25]; - m_A21 += gt[26]; - m_A21 += gt[27]; - m_A21 += gt[28]; - m_A21 += gt[29]; - m_A20 += go[25]; - m_A20 += go[26]; - m_A18 += go[27]; - m_A17 += go[28]; - double RHS5 = Idr[25]; - RHS5 += Idr[26]; - RHS5 += Idr[27]; - RHS5 += Idr[28]; - RHS5 += Idr[29]; - RHS5 -= go[29] * *cnV[29]; - const double f0 = 1.0 / m_A0; - const double f0_3 = -f0 * m_A8; - m_A10 += m_A1 * f0_3; - RHS3 += f0_3 * RHS0; - const double f1 = 1.0 / m_A2; - const double f1_5 = -f1 * m_A17; - m_A21 += m_A3 * f1_5; - RHS5 += f1_5 * RHS1; - const double f2 = 1.0 / m_A4; - const double f2_3 = -f2 * m_A9; - m_A10 += m_A5 * f2_3; - m_A11 += m_A6 * f2_3; - m_A12 += m_A7 * f2_3; - RHS3 += f2_3 * RHS2; - const double f2_4 = -f2 * m_A13; - m_A14 += m_A5 * f2_4; - m_A15 += m_A6 * f2_4; - m_A16 += m_A7 * f2_4; - RHS4 += f2_4 * RHS2; - const double f2_5 = -f2 * m_A18; - m_A19 += m_A5 * f2_5; - m_A20 += m_A6 * f2_5; - m_A21 += m_A7 * f2_5; - RHS5 += f2_5 * RHS2; - const double f3 = 1.0 / m_A10; - const double f3_4 = -f3 * m_A14; - m_A15 += m_A11 * f3_4; - m_A16 += m_A12 * f3_4; - RHS4 += f3_4 * RHS3; - const double f3_5 = -f3 * m_A19; - m_A20 += m_A11 * f3_5; - m_A21 += m_A12 * f3_5; - RHS5 += f3_5 * RHS3; - const double f4 = 1.0 / m_A15; - const double f4_5 = -f4 * m_A20; - m_A21 += m_A16 * f4_5; - RHS5 += f4_5 * RHS4; - V[5] = RHS5 / m_A21; - double tmp4 = 0.0; - tmp4 += m_A16 * V[5]; - V[4] = (RHS4 - tmp4) / m_A15; - double tmp3 = 0.0; - tmp3 += m_A11 * V[4]; - tmp3 += m_A12 * V[5]; - V[3] = (RHS3 - tmp3) / m_A10; - double tmp2 = 0.0; - tmp2 += m_A5 * V[3]; - tmp2 += m_A6 * V[4]; - tmp2 += m_A7 * V[5]; - V[2] = (RHS2 - tmp2) / m_A4; - double tmp1 = 0.0; - tmp1 += m_A3 * V[5]; - V[1] = (RHS1 - tmp1) / m_A2; - double tmp0 = 0.0; - tmp0 += m_A1 * V[3]; - V[0] = (RHS0 - tmp0) / m_A0; -} - -// starcas,wotw,boxingb -static void nl_gcr_23_double_double_ea2b6e3a05e6ef0b(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); - m_A0 += gt[0]; - m_A0 += gt[1]; - m_A0 += gt[2]; - m_A0 += gt[3]; - m_A1 += go[0]; - double RHS0 = Idr[0]; - RHS0 += Idr[1]; - RHS0 += Idr[2]; - RHS0 += Idr[3]; - RHS0 -= go[1] * *cnV[1]; - RHS0 -= go[2] * *cnV[2]; - RHS0 -= go[3] * *cnV[3]; - m_A2 += gt[4]; - m_A2 += gt[5]; - m_A2 += gt[6]; - m_A2 += gt[7]; - m_A2 += gt[8]; - m_A2 += gt[9]; - m_A4 += go[4]; - m_A3 += go[5]; - m_A3 += go[6]; - double RHS1 = Idr[4]; - RHS1 += Idr[5]; - RHS1 += Idr[6]; - RHS1 += Idr[7]; - RHS1 += Idr[8]; - RHS1 += Idr[9]; - RHS1 -= go[7] * *cnV[7]; - RHS1 -= go[8] * *cnV[8]; - RHS1 -= go[9] * *cnV[9]; - m_A5 += gt[10]; - m_A5 += gt[11]; - m_A5 += gt[12]; - m_A5 += gt[13]; - m_A7 += go[10]; - m_A6 += go[11]; - m_A6 += go[12]; - double RHS2 = Idr[10]; - RHS2 += Idr[11]; - RHS2 += Idr[12]; - RHS2 += Idr[13]; - RHS2 -= go[13] * *cnV[13]; - m_A8 += gt[14]; - m_A8 += gt[15]; - m_A9 += go[14]; - double RHS3 = Idr[14]; - RHS3 += Idr[15]; - RHS3 -= go[15] * *cnV[15]; - m_A12 += gt[16]; - m_A12 += gt[17]; - m_A12 += gt[18]; - m_A12 += gt[19]; - m_A12 += gt[20]; - m_A12 += gt[21]; - m_A11 += go[16]; - m_A11 += go[17]; - m_A10 += go[18]; - double RHS4 = Idr[16]; - RHS4 += Idr[17]; - RHS4 += Idr[18]; - RHS4 += Idr[19]; - RHS4 += Idr[20]; - RHS4 += Idr[21]; - RHS4 -= go[19] * *cnV[19]; - RHS4 -= go[20] * *cnV[20]; - RHS4 -= go[21] * *cnV[21]; - m_A17 += gt[22]; - m_A17 += gt[23]; - m_A17 += gt[24]; - m_A17 += gt[25]; - m_A17 += gt[26]; - m_A15 += go[22]; - m_A15 += go[23]; - m_A14 += go[24]; - double RHS5 = Idr[22]; - RHS5 += Idr[23]; - RHS5 += Idr[24]; - RHS5 += Idr[25]; - RHS5 += Idr[26]; - RHS5 -= go[25] * *cnV[25]; - RHS5 -= go[26] * *cnV[26]; - m_A22 += gt[27]; - m_A22 += gt[28]; - m_A22 += gt[29]; - m_A22 += gt[30]; - m_A22 += gt[31]; - m_A20 += go[27]; - m_A19 += go[28]; - double RHS6 = Idr[27]; - RHS6 += Idr[28]; - RHS6 += Idr[29]; - RHS6 += Idr[30]; - RHS6 += Idr[31]; - RHS6 -= go[29] * *cnV[29]; - RHS6 -= go[30] * *cnV[30]; - RHS6 -= go[31] * *cnV[31]; - const double f0 = 1.0 / m_A0; - const double f0_4 = -f0 * m_A10; - m_A12 += m_A1 * f0_4; - RHS4 += f0_4 * RHS0; - const double f1 = 1.0 / m_A2; - const double f1_4 = -f1 * m_A11; - m_A12 += m_A3 * f1_4; - m_A13 += m_A4 * f1_4; - RHS4 += f1_4 * RHS1; - const double f1_5 = -f1 * m_A14; - m_A16 += m_A3 * f1_5; - m_A17 += m_A4 * f1_5; - RHS5 += f1_5 * RHS1; - const double f2 = 1.0 / m_A5; - const double f2_5 = -f2 * m_A15; - m_A17 += m_A6 * f2_5; - m_A18 += m_A7 * f2_5; - RHS5 += f2_5 * RHS2; - const double f2_6 = -f2 * m_A19; - m_A21 += m_A6 * f2_6; - m_A22 += m_A7 * f2_6; - RHS6 += f2_6 * RHS2; - const double f3 = 1.0 / m_A8; - const double f3_6 = -f3 * m_A20; - m_A22 += m_A9 * f3_6; - RHS6 += f3_6 * RHS3; - const double f4 = 1.0 / m_A12; - const double f4_5 = -f4 * m_A16; - m_A17 += m_A13 * f4_5; - RHS5 += f4_5 * RHS4; - const double f5 = 1.0 / m_A17; - const double f5_6 = -f5 * m_A21; - m_A22 += m_A18 * f5_6; - RHS6 += f5_6 * RHS5; - V[6] = RHS6 / m_A22; - double tmp5 = 0.0; - tmp5 += m_A18 * V[6]; - V[5] = (RHS5 - tmp5) / m_A17; - double tmp4 = 0.0; - tmp4 += m_A13 * V[5]; - V[4] = (RHS4 - tmp4) / m_A12; - double tmp3 = 0.0; - tmp3 += m_A9 * V[6]; - V[3] = (RHS3 - tmp3) / m_A8; - double tmp2 = 0.0; - tmp2 += m_A6 * V[5]; - tmp2 += m_A7 * V[6]; - V[2] = (RHS2 - tmp2) / m_A5; - double tmp1 = 0.0; - tmp1 += m_A3 * V[4]; - tmp1 += m_A4 * V[5]; - V[1] = (RHS1 - tmp1) / m_A2; - double tmp0 = 0.0; - tmp0 += m_A1 * V[4]; - V[0] = (RHS0 - tmp0) / m_A0; -} - -// starcas,wotw,solarq -static void nl_gcr_25_double_double_4cb524006206eb1a(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); - m_A0 += gt[0]; - m_A0 += gt[1]; - m_A0 += gt[2]; - m_A0 += gt[3]; - m_A1 += go[0]; - double RHS0 = Idr[0]; - RHS0 += Idr[1]; - RHS0 += Idr[2]; - RHS0 += Idr[3]; - RHS0 -= go[1] * *cnV[1]; - RHS0 -= go[2] * *cnV[2]; - RHS0 -= go[3] * *cnV[3]; - m_A2 += gt[4]; - m_A2 += gt[5]; - m_A2 += gt[6]; - m_A2 += gt[7]; - m_A2 += gt[8]; - m_A2 += gt[9]; - m_A2 += gt[10]; - m_A2 += gt[11]; - m_A5 += go[4]; - m_A4 += go[5]; - m_A4 += go[6]; - m_A3 += go[7]; - m_A3 += go[8]; - double RHS1 = Idr[4]; - RHS1 += Idr[5]; - RHS1 += Idr[6]; - RHS1 += Idr[7]; - RHS1 += Idr[8]; - RHS1 += Idr[9]; - RHS1 += Idr[10]; - RHS1 += Idr[11]; - RHS1 -= go[9] * *cnV[9]; - RHS1 -= go[10] * *cnV[10]; - RHS1 -= go[11] * *cnV[11]; - m_A6 += gt[12]; - m_A6 += gt[13]; - m_A7 += go[12]; - double RHS2 = Idr[12]; - RHS2 += Idr[13]; - RHS2 -= go[13] * *cnV[13]; - m_A10 += gt[14]; - m_A10 += gt[15]; - m_A10 += gt[16]; - m_A10 += gt[17]; - m_A10 += gt[18]; - m_A10 += gt[19]; - m_A9 += go[14]; - m_A9 += go[15]; - m_A8 += go[16]; - double RHS3 = Idr[14]; - RHS3 += Idr[15]; - RHS3 += Idr[16]; - RHS3 += Idr[17]; - RHS3 += Idr[18]; - RHS3 += Idr[19]; - RHS3 -= go[17] * *cnV[17]; - RHS3 -= go[18] * *cnV[18]; - RHS3 -= go[19] * *cnV[19]; - m_A15 += gt[20]; - m_A15 += gt[21]; - m_A15 += gt[22]; - m_A15 += gt[23]; - m_A15 += gt[24]; - m_A16 += go[20]; - m_A16 += go[21]; - m_A13 += go[22]; - m_A13 += go[23]; - double RHS4 = Idr[20]; - RHS4 += Idr[21]; - RHS4 += Idr[22]; - RHS4 += Idr[23]; - RHS4 += Idr[24]; - RHS4 -= go[24] * *cnV[24]; - m_A18 += gt[25]; - m_A18 += gt[26]; - m_A18 += gt[27]; - m_A19 += go[25]; - m_A17 += go[26]; - double RHS5 = Idr[25]; - RHS5 += Idr[26]; - RHS5 += Idr[27]; - RHS5 -= go[27] * *cnV[27]; - m_A24 += gt[28]; - m_A24 += gt[29]; - m_A24 += gt[30]; - m_A24 += gt[31]; - m_A23 += go[28]; - m_A22 += go[29]; - m_A22 += go[30]; - m_A20 += go[31]; - double RHS6 = Idr[28]; - RHS6 += Idr[29]; - RHS6 += Idr[30]; - RHS6 += Idr[31]; - const double f0 = 1.0 / m_A0; - const double f0_3 = -f0 * m_A8; - m_A10 += m_A1 * f0_3; - RHS3 += f0_3 * RHS0; - const double f1 = 1.0 / m_A2; - const double f1_3 = -f1 * m_A9; - m_A10 += m_A3 * f1_3; - m_A11 += m_A4 * f1_3; - m_A12 += m_A5 * f1_3; - RHS3 += f1_3 * RHS1; - const double f1_4 = -f1 * m_A13; - m_A14 += m_A3 * f1_4; - m_A15 += m_A4 * f1_4; - m_A16 += m_A5 * f1_4; - RHS4 += f1_4 * RHS1; - const double f1_6 = -f1 * m_A20; - m_A21 += m_A3 * f1_6; - m_A22 += m_A4 * f1_6; - m_A24 += m_A5 * f1_6; - RHS6 += f1_6 * RHS1; - const double f2 = 1.0 / m_A6; - const double f2_5 = -f2 * m_A17; - m_A18 += m_A7 * f2_5; - RHS5 += f2_5 * RHS2; - const double f3 = 1.0 / m_A10; - const double f3_4 = -f3 * m_A14; - m_A15 += m_A11 * f3_4; - m_A16 += m_A12 * f3_4; - RHS4 += f3_4 * RHS3; - const double f3_6 = -f3 * m_A21; - m_A22 += m_A11 * f3_6; - m_A24 += m_A12 * f3_6; - RHS6 += f3_6 * RHS3; - const double f4 = 1.0 / m_A15; - const double f4_6 = -f4 * m_A22; - m_A24 += m_A16 * f4_6; - RHS6 += f4_6 * RHS4; - const double f5 = 1.0 / m_A18; - const double f5_6 = -f5 * m_A23; - m_A24 += m_A19 * f5_6; - RHS6 += f5_6 * RHS5; - V[6] = RHS6 / m_A24; - double tmp5 = 0.0; - tmp5 += m_A19 * V[6]; - V[5] = (RHS5 - tmp5) / m_A18; - double tmp4 = 0.0; - tmp4 += m_A16 * V[6]; - V[4] = (RHS4 - tmp4) / m_A15; - double tmp3 = 0.0; - tmp3 += m_A11 * V[4]; - tmp3 += m_A12 * V[6]; - V[3] = (RHS3 - tmp3) / m_A10; - double tmp2 = 0.0; - tmp2 += m_A7 * V[5]; - V[2] = (RHS2 - tmp2) / m_A6; - double tmp1 = 0.0; - tmp1 += m_A3 * V[3]; - tmp1 += m_A4 * V[4]; - tmp1 += m_A5 * V[6]; - V[1] = (RHS1 - tmp1) / m_A2; - double tmp0 = 0.0; - tmp0 += m_A1 * V[3]; - V[0] = (RHS0 - tmp0) / m_A0; -} - // starcas,wotw static void nl_gcr_62_double_double_a582a424cb61c678(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -70535,8 +72192,8 @@ static void nl_gcr_20_double_double_c924fe5960b1479e(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } -// stuntcyc -static void nl_gcr_22_double_double_ca68d70bd8f2f62e(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) +// stuntcyc,brdrline +static void nl_gcr_7_double_double_59cb6bf7cb9d17dc(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) { @@ -70548,140 +72205,44 @@ static void nl_gcr_22_double_double_ca68d70bd8f2f62e(double * __restrict V, cons 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); m_A0 += gt[0]; m_A0 += gt[1]; - m_A0 += gt[2]; - m_A0 += gt[3]; - m_A2 += go[0]; - m_A2 += go[1]; - m_A1 += go[2]; + m_A1 += go[0]; double RHS0 = Idr[0]; RHS0 += Idr[1]; - RHS0 += Idr[2]; - RHS0 += Idr[3]; - RHS0 -= go[3] * *cnV[3]; - m_A3 += gt[4]; - m_A3 += gt[5]; - m_A3 += gt[6]; - m_A3 += gt[7]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A6 += gt[4]; + m_A6 += gt[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; m_A5 += go[4]; - m_A5 += go[5]; - m_A4 += go[6]; - double RHS1 = Idr[4]; - RHS1 += Idr[5]; - RHS1 += Idr[6]; - RHS1 += Idr[7]; - RHS1 -= go[7] * *cnV[7]; - m_A6 += gt[8]; - m_A6 += gt[9]; - m_A6 += gt[10]; - m_A7 += go[8]; - double RHS2 = Idr[8]; - RHS2 += Idr[9]; - RHS2 += Idr[10]; - RHS2 -= go[9] * *cnV[9]; - RHS2 -= go[10] * *cnV[10]; - m_A10 += gt[11]; - m_A10 += gt[12]; - m_A10 += gt[13]; - m_A12 += go[11]; - m_A9 += go[12]; - m_A8 += go[13]; - double RHS3 = Idr[11]; - RHS3 += Idr[12]; - RHS3 += Idr[13]; - m_A16 += gt[14]; - m_A16 += gt[15]; - m_A16 += gt[16]; - m_A16 += gt[17]; - m_A16 += gt[18]; - m_A17 += go[14]; - m_A14 += go[15]; - m_A14 += go[16]; - m_A13 += go[17]; - m_A13 += go[18]; - double RHS4 = Idr[14]; - RHS4 += Idr[15]; - RHS4 += Idr[16]; - RHS4 += Idr[17]; - RHS4 += Idr[18]; - m_A21 += gt[19]; - m_A21 += gt[20]; - m_A21 += gt[21]; - m_A18 += go[19]; - m_A20 += go[20]; - m_A19 += go[21]; - double RHS5 = Idr[19]; - RHS5 += Idr[20]; - RHS5 += Idr[21]; + m_A4 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[6] * *cnV[6]; + RHS2 -= go[7] * *cnV[7]; const double f0 = 1.0 / m_A0; - const double f0_3 = -f0 * m_A8; - m_A10 += m_A1 * f0_3; - m_A11 += m_A2 * f0_3; - RHS3 += f0_3 * RHS0; - const double f0_4 = -f0 * m_A13; - m_A15 += m_A1 * f0_4; - m_A16 += m_A2 * f0_4; - RHS4 += f0_4 * RHS0; - const double f1 = 1.0 / m_A3; - const double f1_3 = -f1 * m_A9; - m_A10 += m_A4 * f1_3; - m_A11 += m_A5 * f1_3; - RHS3 += f1_3 * RHS1; - const double f1_4 = -f1 * m_A14; - m_A15 += m_A4 * f1_4; - m_A16 += m_A5 * f1_4; - RHS4 += f1_4 * RHS1; - const double f2 = 1.0 / m_A6; - const double f2_5 = -f2 * m_A18; - m_A21 += m_A7 * f2_5; - RHS5 += f2_5 * RHS2; - const double f3 = 1.0 / m_A10; - const double f3_4 = -f3 * m_A15; - m_A16 += m_A11 * f3_4; - m_A17 += m_A12 * f3_4; - RHS4 += f3_4 * RHS3; - const double f3_5 = -f3 * m_A19; - m_A20 += m_A11 * f3_5; - m_A21 += m_A12 * f3_5; - RHS5 += f3_5 * RHS3; - const double f4 = 1.0 / m_A16; - const double f4_5 = -f4 * m_A20; - m_A21 += m_A17 * f4_5; - RHS5 += f4_5 * RHS4; - V[5] = RHS5 / m_A21; - double tmp4 = 0.0; - tmp4 += m_A17 * V[5]; - V[4] = (RHS4 - tmp4) / m_A16; - double tmp3 = 0.0; - tmp3 += m_A11 * V[4]; - tmp3 += m_A12 * V[5]; - V[3] = (RHS3 - tmp3) / m_A10; - double tmp2 = 0.0; - tmp2 += m_A7 * V[5]; - V[2] = (RHS2 - tmp2) / m_A6; + 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_A4 * V[3]; - tmp1 += m_A5 * V[4]; - V[1] = (RHS1 - tmp1) / m_A3; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; double tmp0 = 0.0; - tmp0 += m_A1 * V[3]; - tmp0 += m_A2 * V[4]; + tmp0 += m_A1 * V[2]; V[0] = (RHS0 - tmp0) / m_A0; } @@ -81845,6 +83406,8 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_57_double_double_bb501e6a23177009", reinterpret_cast(&nl_gcr_57_double_double_bb501e6a23177009)}, // NOLINT // 280zzzap {"nl_gcr_95_double_double_24643c159711f292", reinterpret_cast(&nl_gcr_95_double_double_24643c159711f292)}, // NOLINT +// armora,solarq,starcas,wotw + {"nl_gcr_22_double_double_1250f340dea396ae", reinterpret_cast(&nl_gcr_22_double_double_1250f340dea396ae)}, // NOLINT // armora {"nl_gcr_22_double_double_a6cfda6668b153c2", reinterpret_cast(&nl_gcr_22_double_double_a6cfda6668b153c2)}, // NOLINT // armora,boxingb @@ -81855,8 +83418,6 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_58_double_double_64e460d8f716cd89", reinterpret_cast(&nl_gcr_58_double_double_64e460d8f716cd89)}, // NOLINT // armora {"nl_gcr_67_double_double_ee2cacaa15d32491", reinterpret_cast(&nl_gcr_67_double_double_ee2cacaa15d32491)}, // NOLINT -// astrob,rebound - {"nl_gcr_13_double_double_a41a44bd5c424f88", reinterpret_cast(&nl_gcr_13_double_double_a41a44bd5c424f88)}, // NOLINT // astrob {"nl_gcr_154_double_double_13833bf8c127deaa", reinterpret_cast(&nl_gcr_154_double_double_13833bf8c127deaa)}, // NOLINT // astrob @@ -81887,6 +83448,8 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_31_double_double_79e756c5892cf87d", reinterpret_cast(&nl_gcr_31_double_double_79e756c5892cf87d)}, // NOLINT // barrier,spacewar {"nl_gcr_47_double_double_6ef39a62161d596c", reinterpret_cast(&nl_gcr_47_double_double_6ef39a62161d596c)}, // NOLINT +// boxingb,solarq + {"nl_gcr_10_double_double_d7d45dc58b08cab9", reinterpret_cast(&nl_gcr_10_double_double_d7d45dc58b08cab9)}, // NOLINT // boxingb {"nl_gcr_16_double_double_50f5194a994d56ec", reinterpret_cast(&nl_gcr_16_double_double_50f5194a994d56ec)}, // NOLINT // boxingb @@ -81895,6 +83458,8 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_22_double_double_a6b734322b3ea924", reinterpret_cast(&nl_gcr_22_double_double_a6b734322b3ea924)}, // NOLINT // boxingb {"nl_gcr_23_double_double_53e1117fdb16f546", reinterpret_cast(&nl_gcr_23_double_double_53e1117fdb16f546)}, // NOLINT +// boxingb,starcas,wotw + {"nl_gcr_23_double_double_ea2b6e3a05e6ef0b", reinterpret_cast(&nl_gcr_23_double_double_ea2b6e3a05e6ef0b)}, // NOLINT // boxingb {"nl_gcr_23_double_double_f43cf2a28a5a5561", reinterpret_cast(&nl_gcr_23_double_double_f43cf2a28a5a5561)}, // NOLINT // boxingb @@ -81925,8 +83490,6 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_75_double_double_75400df5d559a266", reinterpret_cast(&nl_gcr_75_double_double_75400df5d559a266)}, // NOLINT // brdrline {"nl_gcr_77_double_double_437326911721091", reinterpret_cast(&nl_gcr_77_double_double_437326911721091)}, // NOLINT -// brdrline,stuntcyc - {"nl_gcr_7_double_double_59cb6bf7cb9d17dc", reinterpret_cast(&nl_gcr_7_double_double_59cb6bf7cb9d17dc)}, // NOLINT // brdrline {"nl_gcr_83_double_double_f99b1245e708ec85", reinterpret_cast(&nl_gcr_83_double_double_f99b1245e708ec85)}, // NOLINT // brdrline @@ -81965,6 +83528,10 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_16_double_double_8c0f7f2284333de5", reinterpret_cast(&nl_gcr_16_double_double_8c0f7f2284333de5)}, // NOLINT // destroyr {"nl_gcr_399_double_double_4334c95878d1be92", reinterpret_cast(&nl_gcr_399_double_double_4334c95878d1be92)}, // NOLINT +// dribling + {"nl_gcr_257_double_double_5dc652d6668315af", reinterpret_cast(&nl_gcr_257_double_double_5dc652d6668315af)}, // NOLINT +// dribling + {"nl_gcr_7_double_double_a1ecff4d37b54b76", reinterpret_cast(&nl_gcr_7_double_double_a1ecff4d37b54b76)}, // NOLINT // elim,zektor {"nl_gcr_10_double_double_11c2ae166b240b6e", reinterpret_cast(&nl_gcr_10_double_double_11c2ae166b240b6e)}, // NOLINT // elim,zektor @@ -81989,8 +83556,6 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_36_double_double_e76692c10e79997e", reinterpret_cast(&nl_gcr_36_double_double_e76692c10e79997e)}, // NOLINT // elim,zektor {"nl_gcr_45_double_double_28b736fe552777a9", reinterpret_cast(&nl_gcr_45_double_double_28b736fe552777a9)}, // NOLINT -// elim,zektor - {"nl_gcr_7_double_double_d190a0e3b8e1f4a7", reinterpret_cast(&nl_gcr_7_double_double_d190a0e3b8e1f4a7)}, // NOLINT // fireone {"nl_gcr_128_double_double_7aee4423e3fdbfda", reinterpret_cast(&nl_gcr_128_double_double_7aee4423e3fdbfda)}, // NOLINT // fireone @@ -82009,8 +83574,6 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_73_double_double_643133e86b2b1628", reinterpret_cast(&nl_gcr_73_double_double_643133e86b2b1628)}, // NOLINT // fireone {"nl_gcr_79_double_double_c1d22fe6e895255d", reinterpret_cast(&nl_gcr_79_double_double_c1d22fe6e895255d)}, // NOLINT -// fireone,astrob,rebound,speedfrk,cheekyms - {"nl_gcr_7_double_double_7c86a9bc1c6aef4c", reinterpret_cast(&nl_gcr_7_double_double_7c86a9bc1c6aef4c)}, // NOLINT // fireone {"nl_gcr_7_double_double_e7fb484f621b3ab9", reinterpret_cast(&nl_gcr_7_double_double_e7fb484f621b3ab9)}, // NOLINT // fireone @@ -82043,8 +83606,14 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_10_double_double_934712b55bb3b2b2", reinterpret_cast(&nl_gcr_10_double_double_934712b55bb3b2b2)}, // NOLINT // gamemachine {"nl_gcr_7_double_double_782d79b5cbe953b1", reinterpret_cast(&nl_gcr_7_double_double_782d79b5cbe953b1)}, // NOLINT +// gi6809 + {"nl_gcr_13_double_double_9eda6de0d275a3e5", reinterpret_cast(&nl_gcr_13_double_double_9eda6de0d275a3e5)}, // NOLINT +// gi6809 + {"nl_gcr_7_double_double_8a409a18e77784cb", reinterpret_cast(&nl_gcr_7_double_double_8a409a18e77784cb)}, // NOLINT // gtrak10 - {"nl_gcr_43_double_double_4c46fdf7c0037727", reinterpret_cast(&nl_gcr_43_double_double_4c46fdf7c0037727)}, // NOLINT + {"nl_gcr_22_double_double_1f38df4919cdddae", reinterpret_cast(&nl_gcr_22_double_double_1f38df4919cdddae)}, // NOLINT +// gtrak10,elim,zektor + {"nl_gcr_7_double_double_d190a0e3b8e1f4a7", reinterpret_cast(&nl_gcr_7_double_double_d190a0e3b8e1f4a7)}, // NOLINT // gunfight {"nl_gcr_112_double_double_743595e64cee0a5e", reinterpret_cast(&nl_gcr_112_double_double_743595e64cee0a5e)}, // NOLINT // gunfight @@ -82081,8 +83650,12 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_7_double_double_e51b463cd890ef6d", reinterpret_cast(&nl_gcr_7_double_double_e51b463cd890ef6d)}, // NOLINT // popeye {"nl_gcr_50_double_double_c6f25bb06e161d1c", reinterpret_cast(&nl_gcr_50_double_double_c6f25bb06e161d1c)}, // NOLINT +// rebound,astrob + {"nl_gcr_13_double_double_a41a44bd5c424f88", reinterpret_cast(&nl_gcr_13_double_double_a41a44bd5c424f88)}, // NOLINT // rebound {"nl_gcr_28_double_double_8bec817b324dcc3", reinterpret_cast(&nl_gcr_28_double_double_8bec817b324dcc3)}, // NOLINT +// rebound,speedfrk,fireone,astrob,cheekyms + {"nl_gcr_7_double_double_7c86a9bc1c6aef4c", reinterpret_cast(&nl_gcr_7_double_double_7c86a9bc1c6aef4c)}, // NOLINT // rebound {"nl_gcr_7_double_double_ae15f7f8a55fc96", reinterpret_cast(&nl_gcr_7_double_double_ae15f7f8a55fc96)}, // NOLINT // ripoff,sundance @@ -82113,12 +83686,12 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_84_double_double_c61e08cf5e35918", reinterpret_cast(&nl_gcr_84_double_double_c61e08cf5e35918)}, // NOLINT // sfxphasor {"nl_gcr_40_double_double_53bd9f9a45276ed0", reinterpret_cast(&nl_gcr_40_double_double_53bd9f9a45276ed0)}, // NOLINT -// solarq,boxingb - {"nl_gcr_10_double_double_d7d45dc58b08cab9", reinterpret_cast(&nl_gcr_10_double_double_d7d45dc58b08cab9)}, // NOLINT // solarq {"nl_gcr_15_double_double_7caaa135bff3d9f3", reinterpret_cast(&nl_gcr_15_double_double_7caaa135bff3d9f3)}, // NOLINT // solarq {"nl_gcr_20_double_double_66496d6073aca98e", reinterpret_cast(&nl_gcr_20_double_double_66496d6073aca98e)}, // NOLINT +// solarq,starcas,wotw + {"nl_gcr_25_double_double_4cb524006206eb1a", reinterpret_cast(&nl_gcr_25_double_double_4cb524006206eb1a)}, // NOLINT // solarq {"nl_gcr_303_double_double_62612f71055b8fd4", reinterpret_cast(&nl_gcr_303_double_double_62612f71055b8fd4)}, // NOLINT // solarq @@ -82171,12 +83744,6 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_109_double_double_5d550fc7441617a2", reinterpret_cast(&nl_gcr_109_double_double_5d550fc7441617a2)}, // NOLINT // starcas,wotw {"nl_gcr_12_double_double_88a8ef5f6bd43d48", reinterpret_cast(&nl_gcr_12_double_double_88a8ef5f6bd43d48)}, // NOLINT -// starcas,wotw,solarq,armora - {"nl_gcr_22_double_double_1250f340dea396ae", reinterpret_cast(&nl_gcr_22_double_double_1250f340dea396ae)}, // NOLINT -// starcas,wotw,boxingb - {"nl_gcr_23_double_double_ea2b6e3a05e6ef0b", reinterpret_cast(&nl_gcr_23_double_double_ea2b6e3a05e6ef0b)}, // NOLINT -// starcas,wotw,solarq - {"nl_gcr_25_double_double_4cb524006206eb1a", reinterpret_cast(&nl_gcr_25_double_double_4cb524006206eb1a)}, // NOLINT // starcas,wotw {"nl_gcr_62_double_double_a582a424cb61c678", reinterpret_cast(&nl_gcr_62_double_double_a582a424cb61c678)}, // NOLINT // starcas,wotw @@ -82215,8 +83782,8 @@ const plib::static_library::symbol nl_static_solver_syms[] = { {"nl_gcr_10_double_double_85652d3e3ada285a", reinterpret_cast(&nl_gcr_10_double_double_85652d3e3ada285a)}, // NOLINT // stuntcyc {"nl_gcr_20_double_double_c924fe5960b1479e", reinterpret_cast(&nl_gcr_20_double_double_c924fe5960b1479e)}, // NOLINT -// stuntcyc - {"nl_gcr_22_double_double_ca68d70bd8f2f62e", reinterpret_cast(&nl_gcr_22_double_double_ca68d70bd8f2f62e)}, // NOLINT +// stuntcyc,brdrline + {"nl_gcr_7_double_double_59cb6bf7cb9d17dc", reinterpret_cast(&nl_gcr_7_double_double_59cb6bf7cb9d17dc)}, // NOLINT // sundance {"nl_gcr_100_double_double_e02a162cb515a958", reinterpret_cast(&nl_gcr_100_double_double_e02a162cb515a958)}, // NOLINT // sundance,warrior diff --git a/src/mame/mr/dribling.cpp b/src/mame/mr/dribling.cpp index 3e57e84fc50..caa6c89ab91 100644 --- a/src/mame/mr/dribling.cpp +++ b/src/mame/mr/dribling.cpp @@ -1,6 +1,5 @@ // license:BSD-3-Clause -// copyright-holders: Aaron Giles - +// copyright-holders: Aaron Giles, Enzo Lombardi /*************************************************************************** Model Racing Dribbling hardware @@ -12,7 +11,6 @@ * Dribbling TODO: - * Audio (discrete components, schematics available) * Implement the 2 banks of 8 dips which determine coinage for the 2 players * Actual game duration doesn't match the time reported in the manual @@ -36,12 +34,16 @@ #include "emu.h" +#include "nl_dribling.h" + #include "cpu/z80/z80.h" #include "machine/i8255.h" +#include "machine/netlist.h" #include "machine/watchdog.h" #include "emupal.h" #include "screen.h" +#include "speaker.h" // configurable logging @@ -72,7 +74,18 @@ public: m_colorram(*this, "colorram"), m_mux(*this, "MUX%u", 0), m_proms(*this, "proms"), - m_gfxroms(*this, "gfx") + m_gfxroms(*this, "gfx"), + m_i_pb(*this, "snd_nl:pb%u", 0U), + m_i_folla_b(*this, "snd_nl:folla_b"), + m_i_folla_m(*this, "snd_nl:folla_m"), + m_i_folla_a(*this, "snd_nl:folla_a"), + m_i_calcio_b(*this, "snd_nl:calcio_b"), + m_i_fischio(*this, "snd_nl:fischio"), + m_i_calcio_a(*this, "snd_nl:calcio_a"), + m_i_contrasto(*this, "snd_nl:contrasto"), + m_i_stop_palla(*this, "snd_nl:stop_palla"), + m_i_parata(*this, "snd_nl:parata"), + m_i_enable(*this, "snd_nl:enable") { } void dribling(machine_config &config); @@ -94,6 +107,19 @@ private: required_region_ptr m_proms; required_region_ptr m_gfxroms; + // sound + required_device_array m_i_pb; + required_device m_i_folla_b; + required_device m_i_folla_m; + required_device m_i_folla_a; + required_device m_i_calcio_b; + required_device m_i_fischio; + required_device m_i_calcio_a; + required_device m_i_contrasto; + required_device m_i_stop_palla; + required_device m_i_parata; + required_device m_i_enable; + // misc uint8_t m_abca = 0U; uint8_t m_dr = 0U; @@ -191,6 +217,7 @@ uint32_t dribling_state::screen_update(screen_device &screen, bitmap_ind16 &bitm } + /************************************* * * Interrupt generation @@ -240,45 +267,68 @@ uint8_t dribling_state::input_mux0_r() void dribling_state::misc_w(uint8_t data) { + LOGMISC("%s:misc_w(%02X)\n", machine().describe_context(), data); + // bit 7 = di - m_di = (data >> 7) & 1; + m_di = BIT(data, 7); if (!m_di) m_maincpu->set_input_line(0, CLEAR_LINE); // bit 6 = parata (save by goalkeeper) + m_i_parata->write_line(BIT(data, 6)); // bit 5 = ab. campo (field enable) - m_abca = (data >> 5) & 1; + m_abca = BIT(data, 5); // bit 4 = ab. a.b.f. - // bit 3 = n/c + m_i_enable->write_line(BIT(data, 4)); + // bit 3 = n/c // bit 2 = (9) = PC2 // bit 1 = (10) = PC1 // bit 0 = (32) = PC0 m_input_mux = data & 7; - LOGMISC("%s:misc_w(%02X)\n", machine().describe_context(), data); } void dribling_state::sound_w(uint8_t data) { - // bit 7 = stop palla (ball stop) - // bit 6 = contrasto (tackle) - // bit 5 = calcio a (kick a) - // bit 4 = fischio (whistle) - // bit 3 = calcio b (kick b) - // bit 2 = folla a (crowd a) - // bit 1 = folla m (crowd m) - // bit 0 = folla b (crowd b) LOGSOUND("%s:sound_w(%02X)\n", machine().describe_context(), data); + + // bit 7 = stop palla (ball stop) + m_i_stop_palla->write_line(BIT(data, 7)); + + // bit 6 = contrasto (tackle) + m_i_contrasto->write_line(BIT(data, 6)); + + // bit 5 = calcio a (kick a) + m_i_calcio_a->write_line(BIT(data, 5)); + + // bit 4 = fischio (whistle) + m_i_fischio->write_line(BIT(data, 4)); + + // bit 3 = calcio b (kick b) + m_i_calcio_b->write_line(BIT(data, 3)); + + // bit 2 = folla a (crowd a) + m_i_folla_a->write_line(BIT(data, 2)); + + // bit 1 = folla m (crowd m) + m_i_folla_m->write_line(BIT(data, 1)); + + // bit 0 = folla b (crowd b) + m_i_folla_b->write_line(BIT(data, 0)); } void dribling_state::pb_w(uint8_t data) { - // write PB0-7 LOGPB("%s:pb_w(%02X)\n", machine().describe_context(), data); + + for (int i = 0; i < 8; i++) + { + m_i_pb[i]->write_line(BIT(data, i)); + } } @@ -453,8 +503,32 @@ void dribling_state::dribling(machine_config &config) PALETTE(config, "palette", FUNC(dribling_state::palette), 256); // sound hardware -} + SPEAKER(config, "mono").front_center(); + NETLIST_SOUND(config, "snd_nl", 48000) + .set_source(NETLIST_NAME(dribling)) + .add_route(ALL_OUTPUTS, "mono", 1.0); + + NETLIST_LOGIC_INPUT(config, m_i_pb[0], "I_PB0.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[1], "I_PB1.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[2], "I_PB2.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[3], "I_PB3.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[4], "I_PB4.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[5], "I_PB5.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[6], "I_PB6.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_pb[7], "I_PB7.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_folla_b, "I_FOLLA_B.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_folla_m, "I_FOLLA_M.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_folla_a, "I_FOLLA_A.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_calcio_a, "I_CALCIO_A.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_fischio, "I_FISCHIO.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_calcio_b, "I_CALCIO_B.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_contrasto, "I_CONTRASTO.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_stop_palla, "I_STOP_PALLA.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_parata, "I_PARATA.IN", 0); + NETLIST_LOGIC_INPUT(config, m_i_enable, "ENABLE_SOUND.IN", 0); + NETLIST_STREAM_OUTPUT(config, "snd_nl:cout0", 0, "OUTPUT").set_mult_offset(1.0, 0); +} /************************************* @@ -551,7 +625,7 @@ ROM_END * *************************************/ -GAME( 1983, dribling, 0, dribling, dribling, dribling_state, empty_init, ROT0, "Model Racing", "Dribbling (set 1)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) -GAME( 1983, driblinga, dribling, dribling, dribling, dribling_state, empty_init, ROT0, "Model Racing", "Dribbling (set 2)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) -GAME( 1983, driblingo, dribling, dribling, dribling, dribling_state, empty_init, ROT0, "Model Racing (Olympia license)", "Dribbling (Olympia)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) -GAME( 1983, driblingbr, dribling, dribling, dribling, dribling_state, empty_init, ROT0, "bootleg (Videomac)", "Dribbling (bootleg, Brazil)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) +GAME( 1983, dribling, 0, dribling, dribling, dribling_state, empty_init, ROT0, "Model Racing", "Dribbling (set 1)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE) +GAME( 1983, driblinga, dribling, dribling, dribling, dribling_state, empty_init, ROT0, "Model Racing", "Dribbling (set 2)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE) +GAME( 1983, driblingo, dribling, dribling, dribling, dribling_state, empty_init, ROT0, "Model Racing (Olympia license)", "Dribbling (Olympia)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE) +GAME( 1983, driblingbr, dribling, dribling, dribling, dribling_state, empty_init, ROT0, "bootleg (Videomac)", "Dribbling (bootleg, Brazil)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE) diff --git a/src/mame/mr/nl_dribling.cpp b/src/mame/mr/nl_dribling.cpp new file mode 100644 index 00000000000..0f2d31a2d0d --- /dev/null +++ b/src/mame/mr/nl_dribling.cpp @@ -0,0 +1,565 @@ +// license:CC0-1.0 +// copyright-holders: Enzo Lombardi + +// Netlist for Model Racing Dribbling: derived from the schematics in the Dribbling manual, located here: +// https://archive.org/details/ArcadeGameManualDribbling +// Known issues: +// In the PARATA netlist the JFET emulation based on MOSFET doesn't work well. The whole netlist has been +// replaced with a quite similar one, at least to my ears. The real netlist is commented behind the FAKE_PARATA +// define. + +#include "netlist/devices/net_lib.h" + +#define TTL_74LS86_DIP TTL_7486_DIP +#define TTL_74LS107_DIP TTL_74107_DIP +#define TTL_74LS161_DIP TTL_74161_DIP +#define TTL_74LS164_DIP TTL_74164_DIP +#define ATTENUATE_FOLLA 200 +#define USE_SIMPLIFIED_LM339 +#define USE_FAKE_PARATA + +// JFET transistors not supported, but this should do the trick; but not for this game. +#define Q_2N3819(name) MOSFET(name, "NMOS(VTO=-3 KP=0.001 CAPMOD=0)") + +#ifdef USE_SIMPLIFIED_LM339 +// Simplified LM339 model - uses high-level simulation of differential input stage. +static NETLIST_START(LM339) +{ + // * CONNECTIONS: NON-INVERTING INPUT + // * | INVERTING INPUT + // * | | POSITIVE POWER SUPPLY + // * | | | NEGATIVE POWER SUPPLY + // * | | | | OPEN COLLECTOR OUTPUT + // * | | | | | + // * 1 2 3 4 5 + NET_MODEL("LM339_QO NPN(BF=200)") + + AFUNC(CMP, 2, "min(max(A1 - A0, 0), 1e-6)") + VCCS(QB, 80) + QBJT_EB(QO, "LM339_QO") + ANALOG_INPUT(XGND, 0) + RES(RDUMMY, RES_M(1000)) + + NET_C(CMP.Q, QB.IP) + NET_C(QB.OP, QO.B) + NET_C(XGND, QB.IN) + NET_C(QB.ON, QO.E, RDUMMY.2) + + ALIAS(1, CMP.A0) + ALIAS(2, CMP.A1) + ALIAS(3, RDUMMY.1) + ALIAS(4, QO.E) + ALIAS(5, QO.C) +} +#else // USE_SIMPLIFIED_LM339 +// LM339 model adapted from here: https://github.com/evenator/LTSpice-Libraries/blob/master/sub/LM339.sub +// It's too slow for the circuits emulated in this netlist, but might be useful in the future. +static NETLIST_START(LM339) +{ + // * CONNECTIONS: NON-INVERTING INPUT + // * | INVERTING INPUT + // * | | POSITIVE POWER SUPPLY + // * | | | NEGATIVE POWER SUPPLY + // * | | | | OPEN COLLECTOR OUTPUT + // * | | | | | + // * 1 2 3 4 5 + NET_MODEL("LM339A_TI_QIN PNP(IS=800.0E-18 BF=2.000E3)") + NET_MODEL("LM339A_TI_QMI NPN(IS=800.0E-18 BF=1002)") + NET_MODEL("LM339A_TI_QMO NPN(IS=800.0E-18 BF=1000 CJC=1E-15 TR=807.4E-9)") + NET_MODEL("LM339A_TI_QOC NPN(IS=800.0E-18 BF=20.29E3 CJC=1E-15 TF=942.6E-12 TR=543.8E-9)") + NET_MODEL("LM339A_TI_DX D(IS=800.0E-18)") + ALIAS(1, VI1.2) + ALIAS(2, VI2.2) + ALIAS(3, F10.ON) + ALIAS(4, Q3.E) + ALIAS(5, Q5.C) + DIODE(DP, "LM339A_TI_DX") + VCVS(E1, 1) + CCCS(F10, 1) + CS(IEE, 0.0001) + QBJT_EB(Q1, "LM339A_TI_QIN") + QBJT_EB(Q2, "LM339A_TI_QIN") + QBJT_EB(Q3, "LM339A_TI_QMO") + QBJT_EB(Q4, "LM339A_TI_QMI") + QBJT_EB(Q5, "LM339A_TI_QOC") + RES(RP, 46.300000) + VS(V1, 0) + VS(VI1, 0.75) + VS(VI2, 0.75) + NET_C(E1.OP, F10.IP) + NET_C(Q2.C, Q3.B, Q4.C, Q4.B) + NET_C(VI1.1, Q1.B) + NET_C(VI2.1, Q2.B) + NET_C(IEE.2, Q1.E, Q2.E) + NET_C(F10.IN, V1.1) + NET_C(F10.ON, IEE.1, DP.K, RP.1) + NET_C(F10.OP, Q1.C, Q3.C, E1.IP) + NET_C(V1.2, Q5.B) + NET_C(Q3.E, Q4.E, E1.ON, E1.IN, Q5.E, DP.A, RP.2) +} +#endif // USE_SIMPLIFIED_LM339 + +// CALCIO_A and CALCIO_B differ only for the parameters of 3 capacitors. +static NETLIST_START(calcio) +{ + DEFPARAM(CAP1, 33) + DEFPARAM(CAP2, 68) + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V6, 6) + ANALOG_INPUT(I_V12, 12) + QBJT_EB(Q8, "BC239C") + QBJT_EB(Q9, "BC239C") + ALIAS(INPUT, R45.2) + RES(R45, 420) + RES(R46, RES_K(8.2)) + RES(R48, RES_K(220)) + RES(R49, RES_K(56)) + RES(R50, RES_K(56)) + RES(R51, RES_M(1)) + RES(R52, RES_K(68)) + RES(R53, RES_K(82)) + RES(R54, RES_K(1.9)) // WAS POT + RES(R55, RES_K(10)) + RES(R56, RES_K(100)) + RES(R57, RES_K(10)) + RES(R58, RES_K(3.9)) + CAP(C29, CAP_U(4.2)) + CAP(C30, CAP_N($(@.CAP2))) + CAP(C31, CAP_N(150)) + CAP(C32, CAP_U(4.7)) + CAP(C33, CAP_N($(@.CAP1))) + CAP(C34, CAP_N($(@.CAP1))) + NET_C(INPUT, R46.1) + ALIAS(GND, R45.1) + NET_C(R46.2, C33.2, C34.1) + NET_C(C33.1, R49.1, C29.1) + NET_C(C34.2, R50.2, R51.1, Q8.B) + NET_C(R49.2, C30.2, R50.1) + NET_C(C30.1, GND) + NET_C(C29.2, R52.1, R51.2, R53.1, Q8.C) + NET_C(R52.2, I_V5) + NET_C(Q8.E, R54.2) + NET_C(R54.1, GND) + NET_C(R53.2, C31.1) + NET_C(C31.2, R48.1, R56.2, Q9.B) + NET_C(R48.2, I_V5) + NET_C(R56.1, GND) + NET_C(Q9.C, R55.1) + ALIAS(OUTPUT, Q9.C) + NET_C(R55.2, I_V5) + NET_C(Q9.E, R57.2, C32.2) + NET_C(R57.1, GND) + NET_C(C32.1, R58.2) + NET_C(R58.1, GND) +} + +static NETLIST_START(stop_palla) +{ + ANALOG_INPUT(I_V5, 5) + QBJT_EB(Q1, "BC309") + RES(R5, RES_K(1)) + RES(R6, RES_K(160)) + RES(R7, RES_K(150)) + RES(R8, RES_K(10)) + RES(R9, RES_K(2.2)) + CAP(C5, CAP_U(1)) + CAP(C6, CAP_U(1)) + DIODE(D1, "1N914") + SUBMODEL(LM339, IC_B9) + ALIAS(GND, IC_B9.4) + ALIAS(INPUT, R5.1) + NET_C(R5.2, Q1.B) + NET_C(Q1.E, I_V5) + NET_C(Q1.C, C5.2, R7.2, R6.1) + NET_C(C5.1, GND) + NET_C(R7.1, GND) + NET_C(R6.2, IC_B9.1, D1.A) + NET_C(D1.K, R9.1, IC_B9.5, R8.2) + NET_C(IC_B9.2, C6.2, R8.1) + NET_C(C6.1, GND) + NET_C(R9.2, I_V5) + NET_C(IC_B9.3, I_V5) + + ALIAS(OUTPUT, IC_B9.5) +} + +// The actual PARATA schematics requires JFETs (2N3819) and using 'MOSFET(Q21, "NMOS(VTO=-1.0)")' as proposed in the FAQ +// doesn't work. So using the same circuit STOP_PALLA with different values to emulate the sound which has a higher pitch. +#ifdef USE_FAKE_PARATA +static NETLIST_START(parata) +{ + ANALOG_INPUT(I_V5, 5) + QBJT_EB(Q1, "BC309") + RES(R5, RES_K(1)) + RES(R6, RES_K(160)) + RES(R7, RES_K(75)) + RES(R8, RES_K(3.75)) + RES(R9, RES_K(2.2)) + CAP(C5, CAP_U(1)) + CAP(C6, CAP_U(1)) + DIODE(D1, "1N914") + SUBMODEL(LM339, IC_B9) + ALIAS(GND, IC_B9.4) + ALIAS(INPUT, R5.1) + NET_C(R5.2, Q1.B) + NET_C(Q1.E, I_V5) + NET_C(Q1.C, C5.2, R7.2, R6.1) + NET_C(C5.1, GND) + NET_C(R7.1, GND) + NET_C(R6.2, IC_B9.1, D1.A) + NET_C(D1.K, R9.1, IC_B9.5, R8.2) + NET_C(IC_B9.2, C6.2, R8.1) + NET_C(C6.1, GND) + NET_C(R9.2, I_V5) + NET_C(IC_B9.3, I_V5) + + ALIAS(OUTPUT, IC_B9.5) +} +#else // USE_FAKE_PARATA +static NETLIST_START(parata) +{ + ANALOG_INPUT(I_V5, 5) + QBJT_EB(Q1, "BC309") + Q_2N3819(Q2) + Q_2N3819(Q3) + RES(R5, RES_K(1)) + RES(R6, RES_K(150)) + RES(R7, RES_K(220)) + RES(R8, RES_K(1)) + RES(R9, RES_K(2.2)) + CAP(C5, CAP_U(2.2)) + CAP(C6, CAP_U(1)) + DIODE(D1, "1N914") + SUBMODEL(LM339, IC_B9) + ALIAS(GND, IC_B9.4) + ALIAS(INPUT, R5.1) + NET_C(R5.2, Q1.B) + NET_C(Q1.E, I_V5) + NET_C(Q1.C, C5.2, R7.2, R6.1) + NET_C(C5.1, GND) + NET_C(R7.1, GND) + NET_C(R6.2, IC_B9.1, D1.A) + NET_C(D1.K, R9.1, IC_B9.5, Q2.G, Q2.S) + NET_C(IC_B9.2, C6.2, Q2.D, Q3.G) + NET_C(C6.1, GND) + NET_C(R9.2, Q3.D, I_V5) + NET_C(IC_B9.3, I_V5) + NET_C(Q3.D, R8.2) + NET_C(R8.1, GND) + ALIAS(OUTPUT, Q3.S) +} +#endif // USE_FAKE_PARATA + +// Sallen-Key approximation of a third-order Butterworth filter with 15KHz cutoff frequency. +// Values computed using http://sim.okawa-denshi.jp/en/Sallen3tool.php . +// This is because the tone generator outputs a 40KHz square wave at idle, and this is to avoid aliasing when outputing at 48KHz. +static NETLIST_START(output_filter) +{ + OPAMP(AMP, "OPAMP(TYPE=1 FPF=5 RI=1M RO=50 UGF=1M SLEW=1M VLH=0.5 VLL=0.03 DAB=0.0015)") + RES(R1, RES_K(11)) + RES(R2, RES_K(110)) + RES(R3, RES_K(33)) + CAP(C1, CAP_U(0.001)) + CAP(C2, CAP_P(470)) + CAP(C3, CAP_P(68)) + ANALOG_INPUT(VPLUS, 12) + ANALOG_INPUT(VMINUS, -12) + NET_C(VPLUS, AMP.VCC) + NET_C(VMINUS, AMP.GND) + ALIAS(INPUT, R1.1) + ALIAS(OUTPUT, AMP.OUT) + ALIAS(GND, C1.2) + + NET_C(GND, C3.2) + NET_C(R1.2, R2.1, C1.1) + NET_C(R2.2, R3.1, C2.1) + NET_C(R3.2, C3.1, AMP.PLUS) + NET_C(OUTPUT, C2.2, AMP.MINUS) +} + +NETLIST_START(dribling) +{ + NET_MODEL("BC239C NPN(IS=1.5813E-15 ISE=4.637E-14 ISC=8.0864E-18 XTI=3 BF=113.32 BR=86.718 IKF=1.4907 IKR=0.03360 XTB=0 VAF=12.331 VAR=31.901 VJE=0.71518 VJC=1.1381 RE=0.22081 RC=0.01636 RB=1.0078 CJE=3.3904E-14 CJC=2.9774E-12 XCJC=0.02899 FC=0.99886 NF=1.0653 NR=1.8047 NE=1.4254 NC=1.8821 MJE=0.36824 MJC=0.31461 TF=2.0691E-11 TR=1.0033E-09 EG=1.11 IRB=0.00083992 RBM=0 XTF=0.31338 VTF=0.10174 ITF=0.0045579 PTF=0 CJS=0 MJS=0 VJS=0.75)") // )") + NET_MODEL("BC309 PNP(IS=1.0366E-15 ISE=1.6295E-14 ISC=9.4971E-17 XTI=3 BF=80 BR=16.116 IKF=0.47497 IKR=0.012081 XTB=0 VAF=8.486 VAR=9.5149 VJE=0.84456 VJC=1.0282 RE=1.9597 RC=1.1393 RB=3.2133 CJE=2.0636E-14 CJC=2.6904E-12 XCJC=0.075977 FC=0.54298 NF=1.03136 NR=1.2907 NE=1.3702 NC=1.038 MJE=0.68352 MJC=0.5401 TF=5.4303E-11 TR=3.4233E-10 EG=1.11 IRB=0.00046855 RBM=2.0822 XTF=0.27447 VTF=0.19311 ITF=0.0030573 PTF=0 CJS=0 VJS=0.75 MJS=0)") + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 1e-5) + + CLOCK(clk, 40000) // 40KHz + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V6, 6) + ANALOG_INPUT(I_V12, 12) + + TTL_7414_DIP(IC_L9) // SHARED INVERTER, FISCHIO 1-2, TOS 3-9 + NC_PIN(NC) + NET_C(IC_L9.10, GND.Q) + NET_C(IC_L9.12, GND.Q) + + LOCAL_SOURCE(LM339) + LOCAL_SOURCE(calcio) + LOCAL_SOURCE(stop_palla) + LOCAL_SOURCE(parata) + LOCAL_SOURCE(output_filter) + + // TOS Section + TTL_INPUT(I_PB0, 0) + TTL_INPUT(I_PB1, 0) + TTL_INPUT(I_PB2, 0) + TTL_INPUT(I_PB3, 0) + TTL_INPUT(I_PB4, 0) + TTL_INPUT(I_PB5, 0) + TTL_INPUT(I_PB6, 0) + TTL_INPUT(I_PB7, 0) + NET_C(GND, I_PB0.GND, I_PB1.GND, I_PB2.GND, I_PB3.GND, I_PB4.GND, I_PB5.GND, I_PB6.GND, I_PB7.GND, clk.GND) + NET_C(I_V5, I_PB0.VCC, I_PB1.VCC, I_PB2.VCC, I_PB3.VCC, I_PB4.VCC, I_PB5.VCC, I_PB6.VCC, I_PB7.VCC, clk.VCC) + CAP(C7_1, CAP_P(330)) + CAP(C7_2, CAP_P(330)) + TTL_74161_DIP(IC_D7) // 4 bit counter + TTL_74161_DIP(IC_E7) // same + TTL_74LS107_DIP(IC_C7) // dual JK flip flop + NET_C(GND, IC_C7.7, IC_D7.8, IC_E7.8, C7_1.2) + NET_C(I_V5, IC_C7.14, IC_D7.16, IC_E7.16) + NET_C(I_PB0, IC_D7.3) + NET_C(I_PB1, IC_D7.4) + NET_C(I_PB2, IC_D7.5) + NET_C(I_PB3, IC_D7.6) + NET_C(I_PB4, IC_E7.3) + NET_C(I_PB5, IC_E7.4) + NET_C(I_PB6, IC_E7.5) + NET_C(I_PB7, IC_E7.6) + NET_C(IC_E7.1, IC_D7.1, I_V5) // CLEAR FLAG + NET_C(IC_D7.7, IC_D7.10, I_V5) + NET_C(IC_E7.9, IC_D7.9, C7_1.1, IC_L9.4) + NET_C(IC_D7.15, IC_E7.7, IC_E7.10) + NET_C(IC_E7.15, IC_L9.3) + NET_C(IC_L9.6, IC_E7.2, IC_D7.2) + NET_C(IC_L9.5, C7_2.1, IC_C7.9, IC_L9.8) + NET_C(GND, C7_2.2) + NET_C(IC_L9.9, clk) + NET_C(IC_C7.10, I_V5) + NET_C(IC_C7.1, IC_C7.13, IC_C7.4, IC_C7.12, GND.Q) + NET_C(IC_C7.8, IC_E7.15) // FLIP-FLOP + NET_C(IC_C7.11, IC_E7.15) + ALIAS(TOS, IC_C7.5) + + // FISCHIO + TTL_INPUT(I_FISCHIO, 0) + NET_C(GND, I_FISCHIO.GND) + NET_C(I_V5, I_FISCHIO.VCC) + SUBMODEL(NE556_DIP, IC_N9) + TTL_74393_DIP(IC_M9) + NET_C(IC_L9.7, GND) + NET_C(IC_L9.14, I_V5) + NET_C(IC_M9.7, GND) + NET_C(IC_M9.14, I_V5) + NET_C(IC_N9.7, GND) + NET_C(IC_N9.14, I_V5) + RES(R1, RES_K(6.8)) + RES(R2, RES_K(39)) + RES(R3, RES_K(100)) + RES(R4, RES_K(47)) + CAP(C42, CAP_U(4.2)) + CAP(C2, CAP_N(2.2)) + NET_C(IC_M9.6, IC_L9.1) + NET_C(IC_N9.4, IC_L9.2) + NET_C(IC_N9.10, IC_L9.2) + NET_C(I_V5, R1.1) + NET_C(I_V5, R2.1) + NET_C(R1.2, IC_N9.1, R3.1, IC_N9.2, IC_N9.6, C42.1) + NET_C(C42.2, GND) + NET_C(R3.2, R4.2, IC_N9.8, IC_N9.12, C2.1) + NET_C(R4.1, R2.2, IC_N9.13) + NET_C(C2.2, GND) + NET_C(IC_N9.5, IC_M9.1) // Counter tick + NET_C(I_FISCHIO, IC_M9.2) // Counter CLEAR + NET_C(I_FISCHIO, IC_M9.12) + NET_C(GND.Q, IC_L9.11, IC_L9.13 ) + NET_C(IC_M9.6, IC_M9.13) + HINT(IC_M9.3, NC) + HINT(IC_M9.4, NC) + HINT(IC_M9.5, NC) + HINT(IC_M9.8, NC) + HINT(IC_M9.9, NC) + HINT(IC_M9.10, NC) + HINT(IC_M9.11, NC) + ALIAS(FISCHIO, IC_N9.9) + + // STOP_PALLA + TTL_INPUT(I_STOP_PALLA, 0) + NET_C(GND, I_STOP_PALLA.GND) + NET_C(I_V6, I_STOP_PALLA.VCC) + SUBMODEL(stop_palla, STOP_PALLA) + NET_C(STOP_PALLA.GND, GND) + NET_C(STOP_PALLA.INPUT, I_STOP_PALLA) + + // PARATA + TTL_INPUT(I_PARATA, 0) + NET_C(GND, I_PARATA.GND) + NET_C(I_V6, I_PARATA.VCC) + SUBMODEL(parata, PARATA) + NET_C(PARATA.GND, GND) + NET_C(PARATA.INPUT, I_PARATA) + + // CALCIO_A and CALCIO_B + TTL_INPUT(I_CALCIO_A, 0) + NET_C(GND, I_CALCIO_A.GND) + NET_C(I_V5, I_CALCIO_A.VCC) + TTL_INPUT(I_CALCIO_B, 0) + NET_C(GND, I_CALCIO_B.GND) + NET_C(I_V5, I_CALCIO_B.VCC) + SUBMODEL(calcio, CALCIO_A) + PARAM(CALCIO_A.CAP1, 22) + PARAM(CALCIO_A.CAP1, 47) + NET_C(I_CALCIO_A, CALCIO_A.INPUT) + NET_C(CALCIO_A.GND, GND) + SUBMODEL(calcio, CALCIO_B) + PARAM(CALCIO_B.CAP1, 33) + PARAM(CALCIO_B.CAP1, 68) + NET_C(I_CALCIO_B, CALCIO_B.INPUT) + NET_C(CALCIO_B.GND, GND) + + // FOLLA A, M, B + TTL_INPUT(I_FOLLA_A, 0) + TTL_INPUT(I_FOLLA_M, 0) + TTL_INPUT(I_FOLLA_B, 0) + TTL_INPUT(I_CONTRASTO, 0) + NET_C(GND, I_FOLLA_A.GND, I_FOLLA_M.GND, I_FOLLA_B.GND, I_CONTRASTO.GND) + NET_C(I_V5, I_FOLLA_A.VCC, I_FOLLA_M.VCC, I_FOLLA_B.VCC, I_CONTRASTO.VCC) + NET_C(GND, IC_E8.5, IC_C8.9, IC_C8.6, IC_C8.2, IC_C8.3, IC_8B.12, IC_8B.5, IC_8B.9, IC_7B.12, IC_7B.10, IC_7B.2, IC_7B.8) + NET_C(GND, IC_8B.4, IC_C8.5, IC_7B.8, IC_8B.10, IC_8B.13, IC_C8.10, IC_E8.4) + TTL_74LS164_DIP(IC_7A) + TTL_7414_DIP(IC_7B) + TTL_74LS164_DIP(IC_8A) + TTL_74LS86_DIP(IC_8B) + LM324_DIP(IC_C8) + TTL_7408_DIP(IC_E8) + NET_C(I_V5, IC_7A.14, IC_7B.14, IC_8A.14, IC_8B.14, IC_E8.14) + NET_C(I_V12, IC_C8.4) + NET_C(GND, IC_7A.7, IC_7B.7, IC_8A.7, IC_8B.7, IC_E8.7, IC_C8.11) + RES(R32, RES_K(1)) + RES(R33, RES_K(220 + ATTENUATE_FOLLA)) + RES(R34, RES_K(100 + ATTENUATE_FOLLA)) + RES(R35, RES_K(1)) + RES(R36, RES_K(56 + ATTENUATE_FOLLA)) + RES(R37, RES_K(10)) + RES(R47, RES_K(330)) + CAP(C20, CAP_N(100)) + CAP(C21, CAP_N(10)) + CAP(C22, CAP_N(22)) + CAP(C24, CAP_U(10)) + NET_C(IC_8B.1, IC_7B.4) + NET_C(IC_8B.2, IC_8A.3) + NET_C(IC_8B.3, IC_8A.1, IC_8A.2) + NET_C(IC_8A.9, IC_7A.9, I_V5) + NET_C(IC_8A.8, IC_7A.8, R32.1, IC_7B.6) + NET_C(IC_8A.13, IC_7A.1, IC_7A.2) + NET_C(IC_7A.12, IC_7B.3) + NET_C(R32.2, IC_7B.5, C20.2) + NET_C(C20.1, GND) + ALIAS(NOISE, IC_7A.13) + ALIAS(C_IN, IC_8A.8) + NET_C(I_FOLLA_B, IC_E8.10) + NET_C(I_FOLLA_M, IC_E8.12) + NET_C(I_FOLLA_A, IC_E8.1) + NET_C(IC_E8.9, IC_E8.13, IC_E8.2, NOISE) + NET_C(IC_E8.8, R33.1) + NET_C(IC_E8.11, R34.1) + NET_C(IC_E8.3, R36.1) + NET_C(R35.1, GND) + NET_C(R33.2, R34.2, R35.2, R36.2, C22.1, C21.1) + NET_C(C21.2, R47.2, IC_C8.14) + ALIAS(FOLLA, IC_C8.14) + NET_C(R37.2, I_V5) + NET_C(C22.2, R47.1, IC_C8.13) + NET_C(R37.1, C24.2, IC_C8.12) + NET_C(C24.1, GND) + + // CONTRASTO + SUBMODEL(NE556_DIP, IC_Q9) + NET_C(IC_Q9.7, GND) + NET_C(IC_Q9.14, I_V5) + RES(R38, RES_M(1)) + RES(R39, RES_K(100)) + CAP(C23, CAP_U(0.1)) + CAP(C25, CAP_U(0.1)) + CAP(C26, CAP_U(0.47)) + NET_C(R38.1, I_V5) + NET_C(R39.1, I_V5) + NET_C(R38.2, IC_Q9.1, IC_Q9.2, C25.1) + NET_C(C25.2, C26.2, GND) + NET_C(R39.2, IC_Q9.13, IC_Q9.12, IC_Q9.8, C26.1) + NET_C(IC_Q9.5, IC_Q9.10) + NET_C(IC_Q9.9, C23.1) + NET_C(IC_Q9.4, I_V5) + NET_C(I_CONTRASTO, IC_Q9.6) + ALIAS(CONT_OUT, C23.2) + NET_C(C23.2, R36.2) + + + + // OUTPUT SECTION ---------------------- + // TOS + CAP(C_TOS, CAP_N(100)) + RES(R_TOS, RES_K(220)) + NET_C(TOS, C_TOS.1) + NET_C(R_TOS.1, C_TOS.2) + + // FISCHIO + CAP(C_FISCHIO, CAP_N(1000)) + RES(R_FISCHIO, RES_K(220)) + NET_C(FISCHIO, C_FISCHIO.1) + NET_C(R_FISCHIO.1, C_FISCHIO.2) + + // FOLLA + CAP(C_FOLLA, CAP_N(10)) + RES(R_FOLLA, RES_K(100)) + NET_C(FOLLA, C_FOLLA.1) + NET_C(C_FOLLA.2, R_FOLLA.1) + + // CALCIO_A + CAP(C_CALCIO_A, CAP_U(1)) + RES(R_CALCIO_A, RES_K(10)) + NET_C(CALCIO_A.OUTPUT, C_CALCIO_A.1) + NET_C(C_CALCIO_A.2, R_CALCIO_A.1) + + // CALCIO_B + CAP(C_CALCIO_B, CAP_U(1)) + RES(R_CALCIO_B, RES_K(10)) + NET_C(CALCIO_B.OUTPUT, C_CALCIO_B.1) + NET_C(C_CALCIO_B.2, R_CALCIO_B.1) + + // STOP_PALLA + CAP(C_STOP_PALLA, CAP_U(1)) + RES(R_STOP_PALLA, RES_K(100)) + NET_C(STOP_PALLA.OUTPUT, C_STOP_PALLA.1) + NET_C(C_STOP_PALLA.2, R_STOP_PALLA.1) + + // PARATA + CAP(C_PARATA, CAP_U(1)) + RES(R_PARATA, RES_K(100)) + NET_C(PARATA.OUTPUT, C_PARATA.1) + NET_C(C_PARATA.2, R_PARATA.1) + + + + // FINAL MIX, DISABLE CIRCUITRY AND OUTPUT FILTER + TTL_INPUT(ENABLE_SOUND, 0) + NET_C(ENABLE_SOUND.VCC, I_V5) + NET_C(ENABLE_SOUND.GND, GND) + QBJT_EB(Q_OUT, "BC239C") + RES(R_OUT, RES_K(2.2)) + RES(R_PU_OUT, RES_K(10)) + NET_C(R_PU_OUT.1, I_V5) + NET_C(ENABLE_SOUND, R_OUT.1, R_PU_OUT.2) + NET_C(Q_OUT.B, R_OUT.2) + NET_C(Q_OUT.C, R_TOS.2, R_FISCHIO.2, R_FOLLA.2, R_CALCIO_A.2, R_CALCIO_B.2, R_STOP_PALLA.2, R_PARATA.2) + NET_C(Q_OUT.E, GND) + SUBMODEL(output_filter, OUTPUT_FILTER) + NET_C(OUTPUT_FILTER.INPUT, Q_OUT.C) + NET_C(OUTPUT_FILTER.GND, GND) + + + + ALIAS(OUTPUT, OUTPUT_FILTER.OUTPUT) +} diff --git a/src/mame/mr/nl_dribling.h b/src/mame/mr/nl_dribling.h new file mode 100644 index 00000000000..bf48dde146c --- /dev/null +++ b/src/mame/mr/nl_dribling.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders: Enzo Lombardi +#ifndef MAME_MR_NL_DRIBLING_H +#define MAME_MR_NL_DRIBLING_H + +#include "netlist/nl_setup.h" + +NETLIST_EXTERNAL(dribling) + +#endif // MAME_MR_NL_DRIBLING_H diff --git a/src/mame/nl.flt b/src/mame/nl.flt index 3a2f7d804a5..0ac39331a85 100644 --- a/src/mame/nl.flt +++ b/src/mame/nl.flt @@ -11,6 +11,7 @@ irem/m62.cpp jpm/jpmsru.cpp midway/sspeedr.cpp misc/cocoloco.cpp +mr/dribling.cpp nintendo/mario.cpp nintendo/popeye.cpp ramtek/starcrus.cpp