diff --git a/scripts/target/mame/arcade.lua b/scripts/target/mame/arcade.lua index 8ed6e85db4b..645334c25b6 100644 --- a/scripts/target/mame/arcade.lua +++ b/scripts/target/mame/arcade.lua @@ -2735,6 +2735,8 @@ files { MAME_DIR .. "src/mame/audio/mw8080bw.h", MAME_DIR .. "src/mame/audio/nl_gunfight.cpp", MAME_DIR .. "src/mame/audio/nl_gunfight.h", + MAME_DIR .. "src/mame/audio/nl_280zzzap.cpp", + MAME_DIR .. "src/mame/audio/nl_280zzzap.h", MAME_DIR .. "src/mame/video/mw8080bw.cpp", MAME_DIR .. "src/mame/drivers/rotaryf.cpp", } diff --git a/scripts/target/mame/nl.lua b/scripts/target/mame/nl.lua index 0b4fbd9b042..062527037cd 100644 --- a/scripts/target/mame/nl.lua +++ b/scripts/target/mame/nl.lua @@ -193,6 +193,8 @@ files{ MAME_DIR .. "src/mame/video/mw8080bw.cpp", MAME_DIR .. "src/mame/audio/nl_gunfight.cpp", MAME_DIR .. "src/mame/audio/nl_gunfight.h", + MAME_DIR .. "src/mame/audio/nl_280zzzap.cpp", + MAME_DIR .. "src/mame/audio/nl_280zzzap.h", MAME_DIR .. "src/mame/audio/cheekyms.cpp", MAME_DIR .. "src/mame/audio/cheekyms.h", diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp index 2417a3f34c0..d751d5f49dc 100644 --- a/src/lib/netlist/generated/static_solvers.cpp +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -2747,7 +2747,7 @@ const double f8 = 1.0 / m_A21; V[0] = (RHS0 - tmp0) / m_A0; } -// dpatrol +// stuntcyc static void nl_gcr_27a78682a9b70f8c_10_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) { @@ -2800,6 +2800,154 @@ const double f2 = 1.0 / m_A4; V[0] = (RHS0 - tmp0) / m_A0; } +// 280zzzap +static void nl_gcr_2e7df52e4934b257_31_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10] + gt[11] + gt[12] + gt[13] + gt[14]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] + Idr[11] + Idr[12] + Idr[13] + Idr[14] - go[9] * *cnV[9] - go[10] * *cnV[10] - go[11] * *cnV[11] - go[12] * *cnV[12] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A9 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36] + gt[37]; + m_A8 = m_A8 + go[32]; + m_A11 = m_A11 + go[33]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] + Idr[37] - go[34] * *cnV[34] - go[35] * *cnV[35] - go[36] * *cnV[36] - go[37] * *cnV[37]; + m_A13 = gt[40] + gt[41]; + m_A14 = m_A14 + go[40]; + m_A12 = m_A12 + go[41]; + double RHS5 = Idr[40] + Idr[41]; + m_A16 = gt[48] + gt[49] + gt[50] + gt[51]; + m_A15 = m_A15 + go[48]; + m_A17 = m_A17 + go[49]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] - go[50] * *cnV[50] - go[51] * *cnV[51]; + m_A20 = gt[56] + gt[57] + gt[58] + gt[59]; + m_A21 = m_A21 + go[56]; + m_A22 = m_A22 + go[57]; + m_A18 = m_A18 + go[58]; + m_A19 = m_A19 + go[59]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59]; + m_A25 = gt[64] + gt[65]; + m_A24 = m_A24 + go[64]; + m_A23 = m_A23 + go[65]; + double RHS8 = Idr[64] + Idr[65]; + m_A30 = gt[72] + gt[73] + gt[74]; + m_A26 = m_A26 + go[72]; + m_A28 = m_A28 + go[73]; + double RHS9 = Idr[72] + Idr[73] + Idr[74] - go[74] * *cnV[74]; +const double f0 = 1.0 / m_A0; + const double f0_6 = -f0 * m_A15; + m_A17 += m_A1 * f0_6; + RHS6 += f0_6 * RHS0; + const double f0_7 = -f0 * m_A18; + m_A20 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A8; + m_A10 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_5 = -f2 * m_A12; + m_A13 += m_A5 * f2_5; + RHS5 += f2_5 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_7 = -f3 * m_A19; + m_A21 += m_A7 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_8 = -f3 * m_A23; + m_A25 += m_A7 * f3_8; + RHS8 += f3_8 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_9 = -f4 * m_A26; + m_A27 += m_A10 * f4_9; + m_A30 += m_A11 * f4_9; + RHS9 += f4_9 * RHS4; +const double f5 = 1.0 / m_A13; + const double f5_8 = -f5 * m_A24; + m_A25 += m_A14 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A16; + const double f6_9 = -f6 * m_A27; + m_A28 += m_A17 * f6_9; + RHS9 += f6_9 * RHS6; +const double f7 = 1.0 / m_A20; + const double f7_9 = -f7 * m_A28; + m_A29 += m_A21 * f7_9; + m_A30 += m_A22 * f7_9; + RHS9 += f7_9 * RHS7; +const double f8 = 1.0 / m_A25; + const double f8_9 = -f8 * m_A29; + RHS9 += f8_9 * RHS8; + V[9] = RHS9 / m_A30; + double tmp8 = 0.0; + V[8] = (RHS8 - tmp8) / m_A25; + double tmp7 = 0.0; + tmp7 += m_A21 * V[8]; + tmp7 += m_A22 * V[9]; + V[7] = (RHS7 - tmp7) / m_A20; + double tmp6 = 0.0; + tmp6 += m_A17 * V[7]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[8]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A10 * V[6]; + tmp4 += m_A11 * V[9]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[8]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[5]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // mario static void nl_gcr_2eb3d95f720484d_62_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -3741,7 +3889,7 @@ const double f1 = 1.0 / m_A2; V[0] = (RHS0 - tmp0) / m_A0; } -// dpatrol +// stuntcyc static void nl_gcr_38f1806722626d7e_7_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) { @@ -3897,105 +4045,6 @@ const double f6 = 1.0 / m_A18; V[0] = (RHS0 - tmp0) / m_A0; } -// dpatrol -static void nl_gcr_57a832104e53c9a8_20_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); - m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; - m_A1 = m_A1 + go[0]; - double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3]; - m_A2 = gt[8]; - m_A3 = m_A3 + go[8]; - double RHS1 = Idr[8]; - m_A4 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20]; - m_A6 = m_A6 + go[16]; - m_A5 = m_A5 + go[17]; - double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] - go[18] * *cnV[18] - go[19] * *cnV[19] - go[20] * *cnV[20]; - m_A8 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28] + gt[29] + gt[30]; - m_A10 = m_A10 + go[24]; - m_A9 = m_A9 + go[25]; - m_A7 = m_A7 + go[26]; - double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] + Idr[29] + Idr[30] - go[27] * *cnV[27] - go[28] * *cnV[28] - go[29] * *cnV[29] - go[30] * *cnV[30]; - m_A14 = gt[32] + gt[33] + gt[34] + gt[35]; - m_A11 = m_A11 + go[32]; - m_A12 = m_A12 + go[33]; - m_A13 = m_A13 + go[34]; - double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] - go[35] * *cnV[35]; - m_A19 = gt[40] + gt[41] + gt[42]; - m_A16 = m_A16 + go[40]; - m_A17 = m_A17 + go[41]; - double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[42] * *cnV[42]; -const double f0 = 1.0 / m_A0; - const double f0_3 = -f0 * m_A7; - m_A8 += m_A1 * f0_3; - RHS3 += f0_3 * RHS0; -const double f1 = 1.0 / m_A2; - const double f1_4 = -f1 * m_A11; - m_A14 += m_A3 * f1_4; - RHS4 += f1_4 * RHS1; -const double f2 = 1.0 / m_A4; - const double f2_4 = -f2 * m_A12; - m_A14 += m_A5 * f2_4; - m_A15 += m_A6 * f2_4; - RHS4 += f2_4 * RHS2; - const double f2_5 = -f2 * m_A16; - m_A18 += m_A5 * f2_5; - m_A19 += m_A6 * f2_5; - RHS5 += f2_5 * RHS2; -const double f3 = 1.0 / m_A8; - const double f3_4 = -f3 * m_A13; - m_A14 += m_A9 * f3_4; - m_A15 += m_A10 * f3_4; - RHS4 += f3_4 * RHS3; - const double f3_5 = -f3 * m_A17; - m_A18 += m_A9 * f3_5; - m_A19 += m_A10 * f3_5; - RHS5 += f3_5 * RHS3; -const double f4 = 1.0 / m_A14; - const double f4_5 = -f4 * m_A18; - m_A19 += m_A15 * f4_5; - RHS5 += f4_5 * RHS4; - V[5] = RHS5 / m_A19; - double tmp4 = 0.0; - tmp4 += m_A15 * V[5]; - V[4] = (RHS4 - tmp4) / m_A14; - double tmp3 = 0.0; - tmp3 += m_A9 * V[4]; - tmp3 += m_A10 * V[5]; - V[3] = (RHS3 - tmp3) / m_A8; - double tmp2 = 0.0; - tmp2 += m_A5 * V[4]; - tmp2 += m_A6 * V[5]; - 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[3]; - V[0] = (RHS0 - tmp0) / m_A0; -} - // rebound static void nl_gcr_5985dfb549280eeb_13_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -4282,6 +4331,273 @@ const double f1 = 1.0 / m_A2; V[0] = (RHS0 - tmp0) / m_A0; } +// 280zzzap +static void nl_gcr_66a07f8f9d33245b_57_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] - go[17] * *cnV[17] - go[18] * *cnV[18] - go[19] * *cnV[19] - go[20] * *cnV[20] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A6 = gt[24] + gt[25] + gt[26]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A8 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36] + gt[37] + gt[38]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] + Idr[37] + Idr[38] - go[33] * *cnV[33] - go[34] * *cnV[34] - go[35] * *cnV[35] - go[36] * *cnV[36] - go[37] * *cnV[37] - go[38] * *cnV[38]; + m_A10 = gt[40] + gt[41]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A12 = gt[48] + gt[49]; + m_A14 = m_A14 + go[48]; + m_A13 = m_A13 + go[49]; + double RHS6 = Idr[48] + Idr[49]; + m_A15 = gt[56] + gt[57]; + m_A16 = m_A16 + go[56]; + double RHS7 = Idr[56] + Idr[57] - go[57] * *cnV[57]; + m_A17 = gt[64] + gt[65]; + m_A18 = m_A18 + go[64]; + double RHS8 = Idr[64] + Idr[65] - go[65] * *cnV[65]; + m_A20 = gt[72] + gt[73] + gt[74] + gt[75]; + m_A19 = m_A19 + go[72]; + double RHS9 = Idr[72] + Idr[73] + Idr[74] + Idr[75] - go[73] * *cnV[73] - go[74] * *cnV[74] - go[75] * *cnV[75]; + m_A24 = gt[80] + gt[81]; + m_A23 = m_A23 + go[80]; + m_A22 = m_A22 + go[81]; + double RHS10 = Idr[80] + Idr[81]; + m_A27 = gt[88] + gt[89] + gt[90] + gt[91]; + m_A26 = m_A26 + go[88]; + m_A28 = m_A28 + go[89]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91] - go[90] * *cnV[90] - go[91] * *cnV[91]; + m_A31 = gt[96] + gt[97] + gt[98] + gt[99] + gt[100] + gt[101]; + m_A29 = m_A29 + go[96]; + m_A33 = m_A33 + go[97]; + m_A32 = m_A32 + go[98]; + double RHS12 = Idr[96] + Idr[97] + Idr[98] + Idr[99] + Idr[100] + Idr[101] - go[99] * *cnV[99] - go[100] * *cnV[100] - go[101] * *cnV[101]; + m_A36 = gt[104] + gt[105]; + m_A34 = m_A34 + go[104]; + double RHS13 = Idr[104] + Idr[105] - go[105] * *cnV[105]; + m_A39 = gt[112] + gt[113] + gt[114]; + m_A38 = m_A38 + go[112]; + m_A37 = m_A37 + go[113]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] - go[114] * *cnV[114]; + m_A41 = gt[120] + gt[121] + gt[122] + gt[123]; + m_A40 = m_A40 + go[120]; + m_A42 = m_A42 + go[121]; + double RHS15 = Idr[120] + Idr[121] + Idr[122] + Idr[123] - go[122] * *cnV[122] - go[123] * *cnV[123]; + m_A49 = gt[128] + gt[129] + gt[130] + gt[131] + gt[132]; + m_A44 = m_A44 + go[128]; + m_A47 = m_A47 + go[129]; + m_A46 = m_A46 + go[130]; + m_A43 = m_A43 + go[131]; + m_A45 = m_A45 + go[132]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131] + Idr[132]; + m_A56 = gt[136] + gt[137] + gt[138] + gt[139]; + m_A54 = m_A54 + go[136]; + m_A53 = m_A53 + go[137]; + m_A51 = m_A51 + go[138]; + m_A52 = m_A52 + go[139]; + double RHS17 = Idr[136] + Idr[137] + Idr[138] + Idr[139]; +const double f0 = 1.0 / m_A0; + const double f0_11 = -f0 * m_A26; + m_A28 += m_A1 * f0_11; + RHS11 += f0_11 * RHS0; + const double f0_16 = -f0 * m_A43; + m_A49 += m_A1 * f0_16; + RHS16 += f0_16 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_16 = -f1 * m_A44; + m_A49 += m_A3 * f1_16; + RHS16 += f1_16 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_12 = -f2 * m_A29; + m_A30 += m_A5 * f2_12; + RHS12 += f2_12 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_15 = -f3 * m_A40; + m_A42 += m_A7 * f3_15; + RHS15 += f3_15 * RHS3; + const double f3_17 = -f3 * m_A51; + m_A56 += m_A7 * f3_17; + RHS17 += f3_17 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_9 = -f4 * m_A19; + m_A21 += m_A9 * f4_9; + RHS9 += f4_9 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_10 = -f5 * m_A22; + m_A24 += m_A11 * f5_10; + RHS10 += f5_10 * RHS5; + const double f5_16 = -f5 * m_A45; + m_A46 += m_A11 * f5_16; + RHS16 += f5_16 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_10 = -f6 * m_A23; + m_A24 += m_A13 * f6_10; + m_A25 += m_A14 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_13 = -f6 * m_A34; + m_A35 += m_A13 * f6_13; + m_A36 += m_A14 * f6_13; + RHS13 += f6_13 * RHS6; +const double f7 = 1.0 / m_A15; + const double f7_14 = -f7 * m_A37; + m_A39 += m_A16 * f7_14; + RHS14 += f7_14 * RHS7; + const double f7_17 = -f7 * m_A52; + m_A54 += m_A16 * f7_17; + RHS17 += f7_17 * RHS7; +const double f8 = 1.0 / m_A17; + const double f8_14 = -f8 * m_A38; + m_A39 += m_A18 * f8_14; + RHS14 += f8_14 * RHS8; +const double f10 = 1.0 / m_A24; + const double f10_13 = -f10 * m_A35; + m_A36 += m_A25 * f10_13; + RHS13 += f10_13 * RHS10; + const double f10_16 = -f10 * m_A46; + m_A48 += m_A25 * f10_16; + RHS16 += f10_16 * RHS10; +const double f11 = 1.0 / m_A27; + const double f11_12 = -f11 * m_A30; + m_A32 += m_A28 * f11_12; + RHS12 += f11_12 * RHS11; +const double f12 = 1.0 / m_A31; + const double f12_16 = -f12 * m_A47; + m_A49 += m_A32 * f12_16; + m_A50 += m_A33 * f12_16; + RHS16 += f12_16 * RHS12; + const double f12_17 = -f12 * m_A53; + m_A55 += m_A32 * f12_17; + m_A56 += m_A33 * f12_17; + RHS17 += f12_17 * RHS12; +const double f13 = 1.0 / m_A36; + const double f13_16 = -f13 * m_A48; + RHS16 += f13_16 * RHS13; +const double f14 = 1.0 / m_A39; + const double f14_17 = -f14 * m_A54; + RHS17 += f14_17 * RHS14; +const double f16 = 1.0 / m_A49; + const double f16_17 = -f16 * m_A55; + m_A56 += m_A50 * f16_17; + RHS17 += f16_17 * RHS16; + V[17] = RHS17 / m_A56; + double tmp16 = 0.0; + tmp16 += m_A50 * V[17]; + V[16] = (RHS16 - tmp16) / m_A49; + double tmp15 = 0.0; + tmp15 += m_A42 * V[17]; + V[15] = (RHS15 - tmp15) / m_A41; + double tmp14 = 0.0; + V[14] = (RHS14 - tmp14) / m_A39; + double tmp13 = 0.0; + V[13] = (RHS13 - tmp13) / m_A36; + double tmp12 = 0.0; + tmp12 += m_A32 * V[16]; + tmp12 += m_A33 * V[17]; + V[12] = (RHS12 - tmp12) / m_A31; + double tmp11 = 0.0; + tmp11 += m_A28 * V[16]; + V[11] = (RHS11 - tmp11) / m_A27; + double tmp10 = 0.0; + tmp10 += m_A25 * V[13]; + V[10] = (RHS10 - tmp10) / m_A24; + double tmp9 = 0.0; + tmp9 += m_A21 * V[15]; + V[9] = (RHS9 - tmp9) / m_A20; + double tmp8 = 0.0; + tmp8 += m_A18 * V[14]; + V[8] = (RHS8 - tmp8) / m_A17; + double tmp7 = 0.0; + tmp7 += m_A16 * V[14]; + V[7] = (RHS7 - tmp7) / m_A15; + double tmp6 = 0.0; + tmp6 += m_A13 * V[10]; + tmp6 += m_A14 * V[13]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[10]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[15]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[17]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[11]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[16]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[16]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // stuntcyc static void nl_gcr_6c599fc01f5b084c_20_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -4874,6 +5190,513 @@ const double f18 = 1.0 / m_A65; V[0] = (RHS0 - tmp0) / m_A0; } +// 280zzzap +static void nl_gcr_766cc932eebf25ec_104_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[8] + gt[9] + gt[10] + gt[11]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + m_A3 = m_A3 + go[10]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] + Idr[11] - go[11] * *cnV[11]; + m_A6 = gt[16] + gt[17] + gt[18]; + m_A7 = m_A7 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A8 = gt[24] + gt[25]; + m_A9 = m_A9 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A10 = gt[32] + gt[33] + gt[34]; + m_A12 = m_A12 + go[32]; + m_A11 = m_A11 + go[33]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[34] * *cnV[34]; + m_A13 = gt[40] + gt[41]; + m_A14 = m_A14 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A15 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53] + gt[54]; + m_A19 = m_A19 + go[48]; + m_A18 = m_A18 + go[49]; + m_A17 = m_A17 + go[50]; + m_A16 = m_A16 + go[51]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] - go[52] * *cnV[52] - go[53] * *cnV[53] - go[54] * *cnV[54]; + m_A20 = gt[56] + gt[57] + gt[58] + gt[59] + gt[60] + gt[61] + gt[62]; + m_A24 = m_A24 + go[56]; + m_A23 = m_A23 + go[57]; + m_A22 = m_A22 + go[58]; + m_A21 = m_A21 + go[59]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] + Idr[60] + Idr[61] + Idr[62] - go[60] * *cnV[60] - go[61] * *cnV[61] - go[62] * *cnV[62]; + m_A25 = gt[64] + gt[65] + gt[66]; + m_A26 = m_A26 + go[64]; + m_A27 = m_A27 + go[65]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] - go[66] * *cnV[66]; + m_A28 = gt[72] + gt[73]; + m_A29 = m_A29 + go[72]; + double RHS9 = Idr[72] + Idr[73] - go[73] * *cnV[73]; + m_A30 = gt[80] + gt[81] + gt[82] + gt[83]; + m_A31 = m_A31 + go[80]; + double RHS10 = Idr[80] + Idr[81] + Idr[82] + Idr[83] - go[81] * *cnV[81] - go[82] * *cnV[82] - go[83] * *cnV[83]; + m_A32 = gt[88] + gt[89]; + m_A33 = m_A33 + go[88]; + double RHS11 = Idr[88] + Idr[89] - go[89] * *cnV[89]; + m_A36 = gt[96] + gt[97] + gt[98] + gt[99]; + m_A35 = m_A35 + go[96]; + m_A34 = m_A34 + go[97]; + double RHS12 = Idr[96] + Idr[97] + Idr[98] + Idr[99] - go[98] * *cnV[98] - go[99] * *cnV[99]; + m_A42 = gt[104] + gt[105] + gt[106] + gt[107]; + m_A40 = m_A40 + go[104]; + m_A41 = m_A41 + go[105]; + m_A43 = m_A43 + go[106]; + m_A39 = m_A39 + go[107]; + double RHS13 = Idr[104] + Idr[105] + Idr[106] + Idr[107]; + m_A45 = gt[112] + gt[113] + gt[114] + gt[115]; + m_A44 = m_A44 + go[112]; + m_A46 = m_A46 + go[113]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] + Idr[115] - go[114] * *cnV[114] - go[115] * *cnV[115]; + m_A50 = gt[120] + gt[121] + gt[122] + gt[123]; + m_A48 = m_A48 + go[120]; + m_A47 = m_A47 + go[121]; + double RHS15 = Idr[120] + Idr[121] + Idr[122] + Idr[123] - go[122] * *cnV[122] - go[123] * *cnV[123]; + m_A57 = gt[128] + gt[129] + gt[130] + gt[131]; + m_A56 = m_A56 + go[128]; + m_A55 = m_A55 + go[129]; + m_A58 = m_A58 + go[130]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131] - go[131] * *cnV[131]; + m_A63 = gt[136] + gt[137] + gt[138] + gt[139]; + m_A66 = m_A66 + go[136]; + m_A60 = m_A60 + go[137]; + m_A59 = m_A59 + go[138]; + double RHS17 = Idr[136] + Idr[137] + Idr[138] + Idr[139] - go[139] * *cnV[139]; + m_A74 = gt[144] + gt[145] + gt[146] + gt[147] + gt[148] + gt[149]; + m_A77 = m_A77 + go[144]; + m_A70 = m_A70 + go[145]; + m_A69 = m_A69 + go[146]; + m_A68 = m_A68 + go[147]; + m_A71 = m_A71 + go[148]; + double RHS18 = Idr[144] + Idr[145] + Idr[146] + Idr[147] + Idr[148] + Idr[149] - go[149] * *cnV[149]; + m_A85 = gt[152] + gt[153] + gt[154] + gt[155] + gt[156] + gt[157]; + m_A82 = m_A82 + go[152]; + m_A87 = m_A87 + go[153]; + m_A79 = m_A79 + go[154]; + m_A80 = m_A80 + go[155]; + m_A78 = m_A78 + go[156]; + double RHS19 = Idr[152] + Idr[153] + Idr[154] + Idr[155] + Idr[156] + Idr[157] - go[157] * *cnV[157]; + m_A93 = gt[160] + gt[161] + gt[162] + gt[163] + gt[164]; + m_A89 = m_A89 + go[160]; + m_A88 = m_A88 + go[161]; + m_A90 = m_A90 + go[162]; + double RHS20 = Idr[160] + Idr[161] + Idr[162] + Idr[163] + Idr[164] - go[163] * *cnV[163] - go[164] * *cnV[164]; + m_A103 = gt[168] + gt[169] + gt[170] + gt[171] + gt[172] + gt[173] + gt[174]; + m_A97 = m_A97 + go[168]; + m_A96 = m_A96 + go[169]; + m_A101 = m_A101 + go[170]; + m_A95 = m_A95 + go[171]; + m_A100 = m_A100 + go[172]; + double RHS21 = Idr[168] + Idr[169] + Idr[170] + Idr[171] + Idr[172] + Idr[173] + Idr[174] - go[173] * *cnV[173] - go[174] * *cnV[174]; +const double f0 = 1.0 / m_A0; + const double f0_12 = -f0 * m_A34; + m_A36 += m_A1 * f0_12; + RHS12 += f0_12 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_12 = -f1 * m_A35; + m_A36 += m_A3 * f1_12; + m_A37 += m_A4 * f1_12; + m_A38 += m_A5 * f1_12; + RHS12 += f1_12 * RHS1; + const double f1_15 = -f1 * m_A47; + m_A49 += m_A3 * f1_15; + m_A50 += m_A4 * f1_15; + m_A51 += m_A5 * f1_15; + RHS15 += f1_15 * RHS1; + const double f1_17 = -f1 * m_A59; + m_A61 += m_A3 * f1_17; + m_A62 += m_A4 * f1_17; + m_A63 += m_A5 * f1_17; + RHS17 += f1_17 * RHS1; +const double f2 = 1.0 / m_A6; + const double f2_13 = -f2 * m_A39; + m_A42 += m_A7 * f2_13; + RHS13 += f2_13 * RHS2; +const double f3 = 1.0 / m_A8; + const double f3_13 = -f3 * m_A40; + m_A42 += m_A9 * f3_13; + RHS13 += f3_13 * RHS3; +const double f4 = 1.0 / m_A10; + const double f4_13 = -f4 * m_A41; + m_A42 += m_A11 * f4_13; + m_A43 += m_A12 * f4_13; + RHS13 += f4_13 * RHS4; + const double f4_18 = -f4 * m_A68; + m_A71 += m_A11 * f4_18; + m_A74 += m_A12 * f4_18; + RHS18 += f4_18 * RHS4; +const double f5 = 1.0 / m_A13; + const double f5_14 = -f5 * m_A44; + m_A45 += m_A14 * f5_14; + RHS14 += f5_14 * RHS5; +const double f6 = 1.0 / m_A15; + const double f6_15 = -f6 * m_A48; + m_A50 += m_A16 * f6_15; + m_A52 += m_A17 * f6_15; + m_A53 += m_A18 * f6_15; + m_A54 += m_A19 * f6_15; + RHS15 += f6_15 * RHS6; + const double f6_18 = -f6 * m_A69; + m_A72 += m_A16 * f6_18; + m_A74 += m_A17 * f6_18; + m_A75 += m_A18 * f6_18; + m_A77 += m_A19 * f6_18; + RHS18 += f6_18 * RHS6; + const double f6_19 = -f6 * m_A78; + m_A81 += m_A16 * f6_19; + m_A84 += m_A17 * f6_19; + m_A85 += m_A18 * f6_19; + m_A87 += m_A19 * f6_19; + RHS19 += f6_19 * RHS6; + const double f6_21 = -f6 * m_A95; + m_A98 += m_A16 * f6_21; + m_A100 += m_A17 * f6_21; + m_A101 += m_A18 * f6_21; + m_A103 += m_A19 * f6_21; + RHS21 += f6_21 * RHS6; +const double f7 = 1.0 / m_A20; + const double f7_17 = -f7 * m_A60; + m_A63 += m_A21 * f7_17; + m_A64 += m_A22 * f7_17; + m_A65 += m_A23 * f7_17; + m_A67 += m_A24 * f7_17; + RHS17 += f7_17 * RHS7; + const double f7_18 = -f7 * m_A70; + m_A73 += m_A21 * f7_18; + m_A74 += m_A22 * f7_18; + m_A75 += m_A23 * f7_18; + m_A77 += m_A24 * f7_18; + RHS18 += f7_18 * RHS7; + const double f7_19 = -f7 * m_A79; + m_A83 += m_A21 * f7_19; + m_A84 += m_A22 * f7_19; + m_A85 += m_A23 * f7_19; + m_A87 += m_A24 * f7_19; + RHS19 += f7_19 * RHS7; + const double f7_21 = -f7 * m_A96; + m_A99 += m_A21 * f7_21; + m_A100 += m_A22 * f7_21; + m_A101 += m_A23 * f7_21; + m_A103 += m_A24 * f7_21; + RHS21 += f7_21 * RHS7; +const double f8 = 1.0 / m_A25; + const double f8_16 = -f8 * m_A55; + m_A57 += m_A26 * f8_16; + m_A58 += m_A27 * f8_16; + RHS16 += f8_16 * RHS8; + const double f8_19 = -f8 * m_A80; + m_A82 += m_A26 * f8_19; + m_A85 += m_A27 * f8_19; + RHS19 += f8_19 * RHS8; +const double f9 = 1.0 / m_A28; + const double f9_16 = -f9 * m_A56; + m_A57 += m_A29 * f9_16; + RHS16 += f9_16 * RHS9; +const double f10 = 1.0 / m_A30; + const double f10_20 = -f10 * m_A88; + m_A93 += m_A31 * f10_20; + RHS20 += f10_20 * RHS10; +const double f11 = 1.0 / m_A32; + const double f11_20 = -f11 * m_A89; + m_A93 += m_A33 * f11_20; + RHS20 += f11_20 * RHS11; +const double f12 = 1.0 / m_A36; + const double f12_15 = -f12 * m_A49; + m_A50 += m_A37 * f12_15; + m_A51 += m_A38 * f12_15; + RHS15 += f12_15 * RHS12; + const double f12_17 = -f12 * m_A61; + m_A62 += m_A37 * f12_17; + m_A63 += m_A38 * f12_17; + RHS17 += f12_17 * RHS12; +const double f13 = 1.0 / m_A42; + const double f13_18 = -f13 * m_A71; + m_A74 += m_A43 * f13_18; + RHS18 += f13_18 * RHS13; +const double f14 = 1.0 / m_A45; + const double f14_21 = -f14 * m_A97; + m_A103 += m_A46 * f14_21; + RHS21 += f14_21 * RHS14; +const double f15 = 1.0 / m_A50; + const double f15_17 = -f15 * m_A62; + m_A63 += m_A51 * f15_17; + m_A64 += m_A52 * f15_17; + m_A65 += m_A53 * f15_17; + m_A67 += m_A54 * f15_17; + RHS17 += f15_17 * RHS15; + const double f15_18 = -f15 * m_A72; + m_A73 += m_A51 * f15_18; + m_A74 += m_A52 * f15_18; + m_A75 += m_A53 * f15_18; + m_A77 += m_A54 * f15_18; + RHS18 += f15_18 * RHS15; + const double f15_19 = -f15 * m_A81; + m_A83 += m_A51 * f15_19; + m_A84 += m_A52 * f15_19; + m_A85 += m_A53 * f15_19; + m_A87 += m_A54 * f15_19; + RHS19 += f15_19 * RHS15; + const double f15_21 = -f15 * m_A98; + m_A99 += m_A51 * f15_21; + m_A100 += m_A52 * f15_21; + m_A101 += m_A53 * f15_21; + m_A103 += m_A54 * f15_21; + RHS21 += f15_21 * RHS15; +const double f16 = 1.0 / m_A57; + const double f16_19 = -f16 * m_A82; + m_A85 += m_A58 * f16_19; + RHS19 += f16_19 * RHS16; +const double f17 = 1.0 / m_A63; + const double f17_18 = -f17 * m_A73; + m_A74 += m_A64 * f17_18; + m_A75 += m_A65 * f17_18; + m_A76 += m_A66 * f17_18; + m_A77 += m_A67 * f17_18; + RHS18 += f17_18 * RHS17; + const double f17_19 = -f17 * m_A83; + m_A84 += m_A64 * f17_19; + m_A85 += m_A65 * f17_19; + m_A86 += m_A66 * f17_19; + m_A87 += m_A67 * f17_19; + RHS19 += f17_19 * RHS17; + const double f17_20 = -f17 * m_A90; + m_A91 += m_A64 * f17_20; + m_A92 += m_A65 * f17_20; + m_A93 += m_A66 * f17_20; + m_A94 += m_A67 * f17_20; + RHS20 += f17_20 * RHS17; + const double f17_21 = -f17 * m_A99; + m_A100 += m_A64 * f17_21; + m_A101 += m_A65 * f17_21; + m_A102 += m_A66 * f17_21; + m_A103 += m_A67 * f17_21; + RHS21 += f17_21 * RHS17; +const double f18 = 1.0 / m_A74; + const double f18_19 = -f18 * m_A84; + m_A85 += m_A75 * f18_19; + m_A86 += m_A76 * f18_19; + m_A87 += m_A77 * f18_19; + RHS19 += f18_19 * RHS18; + const double f18_20 = -f18 * m_A91; + m_A92 += m_A75 * f18_20; + m_A93 += m_A76 * f18_20; + m_A94 += m_A77 * f18_20; + RHS20 += f18_20 * RHS18; + const double f18_21 = -f18 * m_A100; + m_A101 += m_A75 * f18_21; + m_A102 += m_A76 * f18_21; + m_A103 += m_A77 * f18_21; + RHS21 += f18_21 * RHS18; +const double f19 = 1.0 / m_A85; + const double f19_20 = -f19 * m_A92; + m_A93 += m_A86 * f19_20; + m_A94 += m_A87 * f19_20; + RHS20 += f19_20 * RHS19; + const double f19_21 = -f19 * m_A101; + m_A102 += m_A86 * f19_21; + m_A103 += m_A87 * f19_21; + RHS21 += f19_21 * RHS19; +const double f20 = 1.0 / m_A93; + const double f20_21 = -f20 * m_A102; + m_A103 += m_A94 * f20_21; + RHS21 += f20_21 * RHS20; + V[21] = RHS21 / m_A103; + double tmp20 = 0.0; + tmp20 += m_A94 * V[21]; + V[20] = (RHS20 - tmp20) / m_A93; + double tmp19 = 0.0; + tmp19 += m_A86 * V[20]; + tmp19 += m_A87 * V[21]; + V[19] = (RHS19 - tmp19) / m_A85; + double tmp18 = 0.0; + tmp18 += m_A75 * V[19]; + tmp18 += m_A76 * V[20]; + tmp18 += m_A77 * V[21]; + V[18] = (RHS18 - tmp18) / m_A74; + double tmp17 = 0.0; + tmp17 += m_A64 * V[18]; + tmp17 += m_A65 * V[19]; + tmp17 += m_A66 * V[20]; + tmp17 += m_A67 * V[21]; + V[17] = (RHS17 - tmp17) / m_A63; + double tmp16 = 0.0; + tmp16 += m_A58 * V[19]; + V[16] = (RHS16 - tmp16) / m_A57; + double tmp15 = 0.0; + tmp15 += m_A51 * V[17]; + tmp15 += m_A52 * V[18]; + tmp15 += m_A53 * V[19]; + tmp15 += m_A54 * V[21]; + V[15] = (RHS15 - tmp15) / m_A50; + double tmp14 = 0.0; + tmp14 += m_A46 * V[21]; + V[14] = (RHS14 - tmp14) / m_A45; + double tmp13 = 0.0; + tmp13 += m_A43 * V[18]; + V[13] = (RHS13 - tmp13) / m_A42; + double tmp12 = 0.0; + tmp12 += m_A37 * V[15]; + tmp12 += m_A38 * V[17]; + V[12] = (RHS12 - tmp12) / m_A36; + double tmp11 = 0.0; + tmp11 += m_A33 * V[20]; + V[11] = (RHS11 - tmp11) / m_A32; + double tmp10 = 0.0; + tmp10 += m_A31 * V[20]; + V[10] = (RHS10 - tmp10) / m_A30; + double tmp9 = 0.0; + tmp9 += m_A29 * V[16]; + V[9] = (RHS9 - tmp9) / m_A28; + double tmp8 = 0.0; + tmp8 += m_A26 * V[16]; + tmp8 += m_A27 * V[19]; + V[8] = (RHS8 - tmp8) / m_A25; + double tmp7 = 0.0; + tmp7 += m_A21 * V[17]; + tmp7 += m_A22 * V[18]; + tmp7 += m_A23 * V[19]; + tmp7 += m_A24 * V[21]; + V[7] = (RHS7 - tmp7) / m_A20; + double tmp6 = 0.0; + tmp6 += m_A16 * V[15]; + tmp6 += m_A17 * V[18]; + tmp6 += m_A18 * V[19]; + tmp6 += m_A19 * V[21]; + V[6] = (RHS6 - tmp6) / m_A15; + double tmp5 = 0.0; + tmp5 += m_A14 * V[14]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[13]; + tmp4 += m_A12 * V[18]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A9 * V[13]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A7 * V[13]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[12]; + tmp1 += m_A4 * V[15]; + tmp1 += m_A5 * V[17]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[12]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // popeye static void nl_gcr_794f14a13bda75f0_50_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -5154,6 +5977,654 @@ const double f1 = 1.0 / m_A2; V[0] = (RHS0 - tmp0) / m_A0; } +// 280zzzap +static void nl_gcr_7af598c34aca424d_135_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[10] + gt[11]; + m_A3 = m_A3 + go[10]; + double RHS1 = Idr[10] + Idr[11] - go[11] * *cnV[11]; + m_A4 = gt[20] + gt[21] + gt[22]; + m_A5 = m_A5 + go[20]; + double RHS2 = Idr[20] + Idr[21] + Idr[22] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A6 = gt[30] + gt[31] + gt[32] + gt[33] + gt[34] + gt[35] + gt[36]; + m_A7 = m_A7 + go[30]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] - go[31] * *cnV[31] - go[32] * *cnV[32] - go[33] * *cnV[33] - go[34] * *cnV[34] - go[35] * *cnV[35] - go[36] * *cnV[36]; + m_A8 = gt[40] + gt[41]; + m_A9 = m_A9 + go[40]; + double RHS4 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A10 = gt[50] + gt[51] + gt[52] + gt[53]; + m_A12 = m_A12 + go[50]; + m_A13 = m_A13 + go[51]; + m_A11 = m_A11 + go[52]; + double RHS5 = Idr[50] + Idr[51] + Idr[52] + Idr[53] - go[53] * *cnV[53]; + m_A14 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64] + gt[65] + gt[66]; + m_A15 = m_A15 + go[60]; + double RHS6 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] + Idr[65] + Idr[66] - go[61] * *cnV[61] - go[62] * *cnV[62] - go[63] * *cnV[63] - go[64] * *cnV[64] - go[65] * *cnV[65] - go[66] * *cnV[66]; + m_A16 = gt[70] + gt[71]; + m_A17 = m_A17 + go[70]; + m_A18 = m_A18 + go[71]; + double RHS7 = Idr[70] + Idr[71]; + m_A19 = gt[80] + gt[81] + gt[82]; + m_A20 = m_A20 + go[80]; + double RHS8 = Idr[80] + Idr[81] + Idr[82] - go[81] * *cnV[81] - go[82] * *cnV[82]; + m_A21 = gt[90] + gt[91]; + m_A22 = m_A22 + go[90]; + double RHS9 = Idr[90] + Idr[91] - go[91] * *cnV[91]; + m_A23 = gt[100] + gt[101]; + m_A24 = m_A24 + go[100]; + double RHS10 = Idr[100] + Idr[101] - go[101] * *cnV[101]; + m_A25 = gt[110] + gt[111] + gt[112]; + m_A27 = m_A27 + go[110]; + m_A26 = m_A26 + go[111]; + m_A26 = m_A26 + go[112]; + double RHS11 = Idr[110] + Idr[111] + Idr[112]; + m_A28 = gt[120] + gt[121] + gt[122] + gt[123] + gt[124] + gt[125] + gt[126]; + m_A29 = m_A29 + go[120]; + double RHS12 = Idr[120] + Idr[121] + Idr[122] + Idr[123] + Idr[124] + Idr[125] + Idr[126] - go[121] * *cnV[121] - go[122] * *cnV[122] - go[123] * *cnV[123] - go[124] * *cnV[124] - go[125] * *cnV[125] - go[126] * *cnV[126]; + m_A30 = gt[130] + gt[131] + gt[132]; + m_A31 = m_A31 + go[130]; + double RHS13 = Idr[130] + Idr[131] + Idr[132] - go[131] * *cnV[131] - go[132] * *cnV[132]; + m_A32 = gt[140] + gt[141] + gt[142] + gt[143]; + m_A34 = m_A34 + go[140]; + m_A33 = m_A33 + go[141]; + m_A35 = m_A35 + go[142]; + double RHS14 = Idr[140] + Idr[141] + Idr[142] + Idr[143] - go[143] * *cnV[143]; + m_A37 = gt[150] + gt[151]; + m_A36 = m_A36 + go[150]; + double RHS15 = Idr[150] + Idr[151] - go[151] * *cnV[151]; + m_A39 = gt[160] + gt[161] + gt[162] + gt[163]; + m_A38 = m_A38 + go[160]; + m_A40 = m_A40 + go[161]; + double RHS16 = Idr[160] + Idr[161] + Idr[162] + Idr[163] - go[162] * *cnV[162] - go[163] * *cnV[163]; + m_A42 = gt[170] + gt[171]; + m_A41 = m_A41 + go[170]; + double RHS17 = Idr[170] + Idr[171] - go[171] * *cnV[171]; + m_A45 = gt[180] + gt[181]; + m_A43 = m_A43 + go[180]; + m_A44 = m_A44 + go[181]; + double RHS18 = Idr[180] + Idr[181]; + m_A49 = gt[190] + gt[191]; + m_A48 = m_A48 + go[190]; + double RHS19 = Idr[190] + Idr[191] - go[191] * *cnV[191]; + m_A51 = gt[200] + gt[201] + gt[202] + gt[203]; + m_A53 = m_A53 + go[200]; + m_A50 = m_A50 + go[201]; + m_A54 = m_A54 + go[202]; + double RHS20 = Idr[200] + Idr[201] + Idr[202] + Idr[203] - go[203] * *cnV[203]; + m_A62 = gt[210] + gt[211] + gt[212] + gt[213] + gt[214] + gt[215] + gt[216] + gt[217] + gt[218]; + m_A55 = m_A55 + go[210]; + m_A58 = m_A58 + go[211]; + m_A58 = m_A58 + go[212]; + m_A57 = m_A57 + go[213]; + m_A56 = m_A56 + go[214]; + m_A65 = m_A65 + go[215]; + double RHS21 = Idr[210] + Idr[211] + Idr[212] + Idr[213] + Idr[214] + Idr[215] + Idr[216] + Idr[217] + Idr[218] - go[216] * *cnV[216] - go[217] * *cnV[217] - go[218] * *cnV[218]; + m_A70 = gt[220] + gt[221]; + m_A68 = m_A68 + go[220]; + m_A67 = m_A67 + go[221]; + double RHS22 = Idr[220] + Idr[221]; + m_A77 = gt[230] + gt[231] + gt[232] + gt[233]; + m_A76 = m_A76 + go[230]; + m_A78 = m_A78 + go[231]; + double RHS23 = Idr[230] + Idr[231] + Idr[232] + Idr[233] - go[232] * *cnV[232] - go[233] * *cnV[233]; + m_A83 = gt[240] + gt[241] + gt[242] + gt[243] + gt[244] + gt[245]; + m_A79 = m_A79 + go[240]; + m_A80 = m_A80 + go[241]; + m_A86 = m_A86 + go[242]; + double RHS24 = Idr[240] + Idr[241] + Idr[242] + Idr[243] + Idr[244] + Idr[245] - go[243] * *cnV[243] - go[244] * *cnV[244] - go[245] * *cnV[245]; + m_A89 = gt[250] + gt[251] + gt[252] + gt[253]; + m_A88 = m_A88 + go[250]; + m_A90 = m_A90 + go[251]; + double RHS25 = Idr[250] + Idr[251] + Idr[252] + Idr[253] - go[252] * *cnV[252] - go[253] * *cnV[253]; + m_A98 = gt[260] + gt[261] + gt[262] + gt[263] + gt[264] + gt[265]; + m_A91 = m_A91 + go[260]; + m_A92 = m_A92 + go[261]; + m_A93 = m_A93 + go[262]; + m_A101 = m_A101 + go[263]; + double RHS26 = Idr[260] + Idr[261] + Idr[262] + Idr[263] + Idr[264] + Idr[265] - go[264] * *cnV[264] - go[265] * *cnV[265]; + m_A111 = gt[270] + gt[271] + gt[272] + gt[273] + gt[274]; + m_A107 = m_A107 + go[270]; + m_A105 = m_A105 + go[271]; + m_A104 = m_A104 + go[272]; + m_A103 = m_A103 + go[273]; + m_A102 = m_A102 + go[274]; + double RHS27 = Idr[270] + Idr[271] + Idr[272] + Idr[273] + Idr[274]; + m_A122 = gt[280] + gt[281] + gt[282] + gt[283] + gt[284]; + m_A119 = m_A119 + go[280]; + m_A117 = m_A117 + go[281]; + m_A116 = m_A116 + go[282]; + m_A115 = m_A115 + go[283]; + m_A114 = m_A114 + go[284]; + double RHS28 = Idr[280] + Idr[281] + Idr[282] + Idr[283] + Idr[284]; + m_A134 = gt[290] + gt[291] + gt[292] + gt[293] + gt[294]; + m_A131 = m_A131 + go[290]; + m_A126 = m_A126 + go[291]; + m_A127 = m_A127 + go[292]; + m_A125 = m_A125 + go[293]; + m_A124 = m_A124 + go[294]; + double RHS29 = Idr[290] + Idr[291] + Idr[292] + Idr[293] + Idr[294]; +const double f0 = 1.0 / m_A0; + const double f0_18 = -f0 * m_A43; + m_A45 += m_A1 * f0_18; + RHS18 += f0_18 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_15 = -f1 * m_A36; + m_A37 += m_A3 * f1_15; + RHS15 += f1_15 * RHS1; + const double f1_27 = -f1 * m_A102; + m_A105 += m_A3 * f1_27; + RHS27 += f1_27 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_16 = -f2 * m_A38; + m_A40 += m_A5 * f2_16; + RHS16 += f2_16 * RHS2; + const double f2_27 = -f2 * m_A103; + m_A111 += m_A5 * f2_27; + RHS27 += f2_27 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_21 = -f3 * m_A55; + m_A59 += m_A7 * f3_21; + RHS21 += f3_21 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_17 = -f4 * m_A41; + m_A42 += m_A9 * f4_17; + RHS17 += f4_17 * RHS4; + const double f4_29 = -f4 * m_A124; + m_A126 += m_A9 * f4_29; + RHS29 += f4_29 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_18 = -f5 * m_A44; + m_A45 += m_A11 * f5_18; + m_A46 += m_A12 * f5_18; + m_A47 += m_A13 * f5_18; + RHS18 += f5_18 * RHS5; + const double f5_21 = -f5 * m_A56; + m_A60 += m_A11 * f5_21; + m_A62 += m_A12 * f5_21; + m_A65 += m_A13 * f5_21; + RHS21 += f5_21 * RHS5; + const double f5_27 = -f5 * m_A104; + m_A106 += m_A11 * f5_27; + m_A107 += m_A12 * f5_27; + m_A111 += m_A13 * f5_27; + RHS27 += f5_27 * RHS5; +const double f6 = 1.0 / m_A14; + const double f6_26 = -f6 * m_A91; + m_A97 += m_A15 * f6_26; + RHS26 += f6_26 * RHS6; +const double f7 = 1.0 / m_A16; + const double f7_20 = -f7 * m_A50; + m_A51 += m_A17 * f7_20; + m_A52 += m_A18 * f7_20; + RHS20 += f7_20 * RHS7; + const double f7_21 = -f7 * m_A57; + m_A61 += m_A17 * f7_21; + m_A62 += m_A18 * f7_21; + RHS21 += f7_21 * RHS7; +const double f8 = 1.0 / m_A19; + const double f8_25 = -f8 * m_A88; + m_A90 += m_A20 * f8_25; + RHS25 += f8_25 * RHS8; + const double f8_29 = -f8 * m_A125; + m_A134 += m_A20 * f8_29; + RHS29 += f8_29 * RHS8; +const double f9 = 1.0 / m_A21; + const double f9_19 = -f9 * m_A48; + m_A49 += m_A22 * f9_19; + RHS19 += f9_19 * RHS9; + const double f9_28 = -f9 * m_A114; + m_A117 += m_A22 * f9_28; + RHS28 += f9_28 * RHS9; +const double f10 = 1.0 / m_A23; + const double f10_26 = -f10 * m_A92; + m_A98 += m_A24 * f10_26; + RHS26 += f10_26 * RHS10; +const double f11 = 1.0 / m_A25; + const double f11_21 = -f11 * m_A58; + m_A62 += m_A26 * f11_21; + m_A63 += m_A27 * f11_21; + RHS21 += f11_21 * RHS11; + const double f11_22 = -f11 * m_A67; + m_A69 += m_A26 * f11_22; + m_A70 += m_A27 * f11_22; + RHS22 += f11_22 * RHS11; +const double f12 = 1.0 / m_A28; + const double f12_24 = -f12 * m_A79; + m_A82 += m_A29 * f12_24; + RHS24 += f12_24 * RHS12; +const double f13 = 1.0 / m_A30; + const double f13_23 = -f13 * m_A76; + m_A78 += m_A31 * f13_23; + RHS23 += f13_23 * RHS13; + const double f13_28 = -f13 * m_A115; + m_A122 += m_A31 * f13_28; + RHS28 += f13_28 * RHS13; +const double f14 = 1.0 / m_A32; + const double f14_22 = -f14 * m_A68; + m_A70 += m_A33 * f14_22; + m_A71 += m_A34 * f14_22; + m_A74 += m_A35 * f14_22; + RHS22 += f14_22 * RHS14; + const double f14_24 = -f14 * m_A80; + m_A81 += m_A33 * f14_24; + m_A83 += m_A34 * f14_24; + m_A86 += m_A35 * f14_24; + RHS24 += f14_24 * RHS14; + const double f14_28 = -f14 * m_A116; + m_A118 += m_A33 * f14_28; + m_A119 += m_A34 * f14_28; + m_A122 += m_A35 * f14_28; + RHS28 += f14_28 * RHS14; +const double f15 = 1.0 / m_A37; + const double f15_27 = -f15 * m_A105; + RHS27 += f15_27 * RHS15; +const double f16 = 1.0 / m_A39; + const double f16_21 = -f16 * m_A59; + m_A65 += m_A40 * f16_21; + RHS21 += f16_21 * RHS16; +const double f17 = 1.0 / m_A42; + const double f17_29 = -f17 * m_A126; + RHS29 += f17_29 * RHS17; +const double f18 = 1.0 / m_A45; + const double f18_21 = -f18 * m_A60; + m_A62 += m_A46 * f18_21; + m_A65 += m_A47 * f18_21; + RHS21 += f18_21 * RHS18; + const double f18_27 = -f18 * m_A106; + m_A107 += m_A46 * f18_27; + m_A111 += m_A47 * f18_27; + RHS27 += f18_27 * RHS18; +const double f19 = 1.0 / m_A49; + const double f19_28 = -f19 * m_A117; + RHS28 += f19_28 * RHS19; +const double f20 = 1.0 / m_A51; + const double f20_21 = -f20 * m_A61; + m_A62 += m_A52 * f20_21; + m_A64 += m_A53 * f20_21; + m_A66 += m_A54 * f20_21; + RHS21 += f20_21 * RHS20; + const double f20_26 = -f20 * m_A93; + m_A94 += m_A52 * f20_26; + m_A98 += m_A53 * f20_26; + m_A101 += m_A54 * f20_26; + RHS26 += f20_26 * RHS20; + const double f20_29 = -f20 * m_A127; + m_A128 += m_A52 * f20_29; + m_A131 += m_A53 * f20_29; + m_A134 += m_A54 * f20_29; + RHS29 += f20_29 * RHS20; +const double f21 = 1.0 / m_A62; + const double f21_22 = -f21 * m_A69; + m_A70 += m_A63 * f21_22; + m_A72 += m_A64 * f21_22; + m_A73 += m_A65 * f21_22; + m_A75 += m_A66 * f21_22; + RHS22 += f21_22 * RHS21; + const double f21_26 = -f21 * m_A94; + m_A95 += m_A63 * f21_26; + m_A98 += m_A64 * f21_26; + m_A99 += m_A65 * f21_26; + m_A101 += m_A66 * f21_26; + RHS26 += f21_26 * RHS21; + const double f21_27 = -f21 * m_A107; + m_A108 += m_A63 * f21_27; + m_A110 += m_A64 * f21_27; + m_A111 += m_A65 * f21_27; + m_A113 += m_A66 * f21_27; + RHS27 += f21_27 * RHS21; + const double f21_29 = -f21 * m_A128; + m_A129 += m_A63 * f21_29; + m_A131 += m_A64 * f21_29; + m_A132 += m_A65 * f21_29; + m_A134 += m_A66 * f21_29; + RHS29 += f21_29 * RHS21; +const double f22 = 1.0 / m_A70; + const double f22_24 = -f22 * m_A81; + m_A83 += m_A71 * f22_24; + m_A84 += m_A72 * f22_24; + m_A85 += m_A73 * f22_24; + m_A86 += m_A74 * f22_24; + m_A87 += m_A75 * f22_24; + RHS24 += f22_24 * RHS22; + const double f22_26 = -f22 * m_A95; + m_A96 += m_A71 * f22_26; + m_A98 += m_A72 * f22_26; + m_A99 += m_A73 * f22_26; + m_A100 += m_A74 * f22_26; + m_A101 += m_A75 * f22_26; + RHS26 += f22_26 * RHS22; + const double f22_27 = -f22 * m_A108; + m_A109 += m_A71 * f22_27; + m_A110 += m_A72 * f22_27; + m_A111 += m_A73 * f22_27; + m_A112 += m_A74 * f22_27; + m_A113 += m_A75 * f22_27; + RHS27 += f22_27 * RHS22; + const double f22_28 = -f22 * m_A118; + m_A119 += m_A71 * f22_28; + m_A120 += m_A72 * f22_28; + m_A121 += m_A73 * f22_28; + m_A122 += m_A74 * f22_28; + m_A123 += m_A75 * f22_28; + RHS28 += f22_28 * RHS22; + const double f22_29 = -f22 * m_A129; + m_A130 += m_A71 * f22_29; + m_A131 += m_A72 * f22_29; + m_A132 += m_A73 * f22_29; + m_A133 += m_A74 * f22_29; + m_A134 += m_A75 * f22_29; + RHS29 += f22_29 * RHS22; +const double f23 = 1.0 / m_A77; + const double f23_24 = -f23 * m_A82; + m_A86 += m_A78 * f23_24; + RHS24 += f23_24 * RHS23; +const double f24 = 1.0 / m_A83; + const double f24_26 = -f24 * m_A96; + m_A98 += m_A84 * f24_26; + m_A99 += m_A85 * f24_26; + m_A100 += m_A86 * f24_26; + m_A101 += m_A87 * f24_26; + RHS26 += f24_26 * RHS24; + const double f24_27 = -f24 * m_A109; + m_A110 += m_A84 * f24_27; + m_A111 += m_A85 * f24_27; + m_A112 += m_A86 * f24_27; + m_A113 += m_A87 * f24_27; + RHS27 += f24_27 * RHS24; + const double f24_28 = -f24 * m_A119; + m_A120 += m_A84 * f24_28; + m_A121 += m_A85 * f24_28; + m_A122 += m_A86 * f24_28; + m_A123 += m_A87 * f24_28; + RHS28 += f24_28 * RHS24; + const double f24_29 = -f24 * m_A130; + m_A131 += m_A84 * f24_29; + m_A132 += m_A85 * f24_29; + m_A133 += m_A86 * f24_29; + m_A134 += m_A87 * f24_29; + RHS29 += f24_29 * RHS24; +const double f25 = 1.0 / m_A89; + const double f25_26 = -f25 * m_A97; + m_A101 += m_A90 * f25_26; + RHS26 += f25_26 * RHS25; +const double f26 = 1.0 / m_A98; + const double f26_27 = -f26 * m_A110; + m_A111 += m_A99 * f26_27; + m_A112 += m_A100 * f26_27; + m_A113 += m_A101 * f26_27; + RHS27 += f26_27 * RHS26; + const double f26_28 = -f26 * m_A120; + m_A121 += m_A99 * f26_28; + m_A122 += m_A100 * f26_28; + m_A123 += m_A101 * f26_28; + RHS28 += f26_28 * RHS26; + const double f26_29 = -f26 * m_A131; + m_A132 += m_A99 * f26_29; + m_A133 += m_A100 * f26_29; + m_A134 += m_A101 * f26_29; + RHS29 += f26_29 * RHS26; +const double f27 = 1.0 / m_A111; + const double f27_28 = -f27 * m_A121; + m_A122 += m_A112 * f27_28; + m_A123 += m_A113 * f27_28; + RHS28 += f27_28 * RHS27; + const double f27_29 = -f27 * m_A132; + m_A133 += m_A112 * f27_29; + m_A134 += m_A113 * f27_29; + RHS29 += f27_29 * RHS27; +const double f28 = 1.0 / m_A122; + const double f28_29 = -f28 * m_A133; + m_A134 += m_A123 * f28_29; + RHS29 += f28_29 * RHS28; + V[29] = RHS29 / m_A134; + double tmp28 = 0.0; + tmp28 += m_A123 * V[29]; + V[28] = (RHS28 - tmp28) / m_A122; + double tmp27 = 0.0; + tmp27 += m_A112 * V[28]; + tmp27 += m_A113 * V[29]; + V[27] = (RHS27 - tmp27) / m_A111; + double tmp26 = 0.0; + tmp26 += m_A99 * V[27]; + tmp26 += m_A100 * V[28]; + tmp26 += m_A101 * V[29]; + V[26] = (RHS26 - tmp26) / m_A98; + double tmp25 = 0.0; + tmp25 += m_A90 * V[29]; + V[25] = (RHS25 - tmp25) / m_A89; + double tmp24 = 0.0; + tmp24 += m_A84 * V[26]; + tmp24 += m_A85 * V[27]; + tmp24 += m_A86 * V[28]; + tmp24 += m_A87 * V[29]; + V[24] = (RHS24 - tmp24) / m_A83; + double tmp23 = 0.0; + tmp23 += m_A78 * V[28]; + V[23] = (RHS23 - tmp23) / m_A77; + double tmp22 = 0.0; + tmp22 += m_A71 * V[24]; + tmp22 += m_A72 * V[26]; + tmp22 += m_A73 * V[27]; + tmp22 += m_A74 * V[28]; + tmp22 += m_A75 * V[29]; + V[22] = (RHS22 - tmp22) / m_A70; + double tmp21 = 0.0; + tmp21 += m_A63 * V[22]; + tmp21 += m_A64 * V[26]; + tmp21 += m_A65 * V[27]; + tmp21 += m_A66 * V[29]; + V[21] = (RHS21 - tmp21) / m_A62; + double tmp20 = 0.0; + tmp20 += m_A52 * V[21]; + tmp20 += m_A53 * V[26]; + tmp20 += m_A54 * V[29]; + V[20] = (RHS20 - tmp20) / m_A51; + double tmp19 = 0.0; + V[19] = (RHS19 - tmp19) / m_A49; + double tmp18 = 0.0; + tmp18 += m_A46 * V[21]; + tmp18 += m_A47 * V[27]; + V[18] = (RHS18 - tmp18) / m_A45; + double tmp17 = 0.0; + V[17] = (RHS17 - tmp17) / m_A42; + double tmp16 = 0.0; + tmp16 += m_A40 * V[27]; + V[16] = (RHS16 - tmp16) / m_A39; + double tmp15 = 0.0; + V[15] = (RHS15 - tmp15) / m_A37; + double tmp14 = 0.0; + tmp14 += m_A33 * V[22]; + tmp14 += m_A34 * V[24]; + tmp14 += m_A35 * V[28]; + V[14] = (RHS14 - tmp14) / m_A32; + double tmp13 = 0.0; + tmp13 += m_A31 * V[28]; + V[13] = (RHS13 - tmp13) / m_A30; + double tmp12 = 0.0; + tmp12 += m_A29 * V[23]; + V[12] = (RHS12 - tmp12) / m_A28; + double tmp11 = 0.0; + tmp11 += m_A26 * V[21]; + tmp11 += m_A27 * V[22]; + V[11] = (RHS11 - tmp11) / m_A25; + double tmp10 = 0.0; + tmp10 += m_A24 * V[26]; + V[10] = (RHS10 - tmp10) / m_A23; + double tmp9 = 0.0; + tmp9 += m_A22 * V[19]; + V[9] = (RHS9 - tmp9) / m_A21; + double tmp8 = 0.0; + tmp8 += m_A20 * V[29]; + V[8] = (RHS8 - tmp8) / m_A19; + double tmp7 = 0.0; + tmp7 += m_A17 * V[20]; + tmp7 += m_A18 * V[21]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A15 * V[25]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A11 * V[18]; + tmp5 += m_A12 * V[21]; + tmp5 += m_A13 * V[27]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[17]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[16]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[27]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[15]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[18]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_7b1592d23e41ce56_37_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -6114,7 +7585,7 @@ const double f15 = 1.0 / m_A43; V[0] = (RHS0 - tmp0) / m_A0; } -// dpatrol +// stuntcyc static void nl_gcr_81bfac76b696d9f3_22_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) { @@ -6852,6 +8323,1121 @@ const double f7 = 1.0 / m_A28; V[0] = (RHS0 - tmp0) / m_A0; } +// 280zzzap +static void nl_gcr_9de29bb0cfe2c4b4_116_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] - go[17] * *cnV[17] - go[18] * *cnV[18] - go[19] * *cnV[19] - go[20] * *cnV[20] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A6 = gt[24] + gt[25]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A8 = gt[32] + gt[33]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] - go[33] * *cnV[33]; + m_A10 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[41] * *cnV[41] - go[42] * *cnV[42] - go[43] * *cnV[43] - go[44] * *cnV[44] - go[45] * *cnV[45] - go[46] * *cnV[46]; + m_A12 = gt[48] + gt[49] + gt[50]; + m_A13 = m_A13 + go[48]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] - go[49] * *cnV[49] - go[50] * *cnV[50]; + m_A14 = gt[56] + gt[57]; + m_A16 = m_A16 + go[56]; + m_A15 = m_A15 + go[57]; + double RHS7 = Idr[56] + Idr[57]; + m_A17 = gt[64] + gt[65]; + m_A18 = m_A18 + go[64]; + double RHS8 = Idr[64] + Idr[65] - go[65] * *cnV[65]; + m_A19 = gt[72] + gt[73]; + m_A20 = m_A20 + go[72]; + double RHS9 = Idr[72] + Idr[73] - go[73] * *cnV[73]; + m_A21 = gt[80] + gt[81]; + m_A22 = m_A22 + go[80]; + double RHS10 = Idr[80] + Idr[81] - go[81] * *cnV[81]; + m_A23 = gt[88] + gt[89] + gt[90] + gt[91] + gt[92] + gt[93] + gt[94]; + m_A24 = m_A24 + go[88]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91] + Idr[92] + Idr[93] + Idr[94] - go[89] * *cnV[89] - go[90] * *cnV[90] - go[91] * *cnV[91] - go[92] * *cnV[92] - go[93] * *cnV[93] - go[94] * *cnV[94]; + m_A25 = gt[96] + gt[97]; + m_A26 = m_A26 + go[96]; + double RHS12 = Idr[96] + Idr[97] - go[97] * *cnV[97]; + m_A27 = gt[104] + gt[105] + gt[106]; + m_A28 = m_A28 + go[104]; + double RHS13 = Idr[104] + Idr[105] + Idr[106] - go[105] * *cnV[105] - go[106] * *cnV[106]; + m_A29 = gt[112] + gt[113] + gt[114]; + m_A30 = m_A30 + go[112]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] - go[113] * *cnV[113] - go[114] * *cnV[114]; + m_A31 = gt[120] + gt[121]; + m_A32 = m_A32 + go[120]; + m_A33 = m_A33 + go[121]; + double RHS15 = Idr[120] + Idr[121]; + m_A35 = gt[128] + gt[129]; + m_A34 = m_A34 + go[128]; + double RHS16 = Idr[128] + Idr[129] - go[129] * *cnV[129]; + m_A37 = gt[136] + gt[137]; + m_A36 = m_A36 + go[136]; + double RHS17 = Idr[136] + Idr[137] - go[137] * *cnV[137]; + m_A40 = gt[144] + gt[145]; + m_A39 = m_A39 + go[144]; + m_A38 = m_A38 + go[145]; + double RHS18 = Idr[144] + Idr[145]; + m_A42 = gt[152] + gt[153] + gt[154] + gt[155]; + m_A41 = m_A41 + go[152]; + m_A43 = m_A43 + go[153]; + double RHS19 = Idr[152] + Idr[153] + Idr[154] + Idr[155] - go[154] * *cnV[154] - go[155] * *cnV[155]; + m_A46 = gt[160] + gt[161] + gt[162] + gt[163] + gt[164] + gt[165]; + m_A44 = m_A44 + go[160]; + m_A47 = m_A47 + go[161]; + m_A49 = m_A49 + go[162]; + m_A48 = m_A48 + go[163]; + double RHS20 = Idr[160] + Idr[161] + Idr[162] + Idr[163] + Idr[164] + Idr[165] - go[164] * *cnV[164] - go[165] * *cnV[165]; + m_A51 = gt[168] + gt[169] + gt[170] + gt[171]; + m_A50 = m_A50 + go[168]; + m_A52 = m_A52 + go[169]; + double RHS21 = Idr[168] + Idr[169] + Idr[170] + Idr[171] - go[170] * *cnV[170] - go[171] * *cnV[171]; + m_A56 = gt[176] + gt[177] + gt[178] + gt[179] + gt[180] + gt[181]; + m_A53 = m_A53 + go[176]; + m_A54 = m_A54 + go[177]; + m_A57 = m_A57 + go[178]; + m_A59 = m_A59 + go[179]; + double RHS22 = Idr[176] + Idr[177] + Idr[178] + Idr[179] + Idr[180] + Idr[181] - go[180] * *cnV[180] - go[181] * *cnV[181]; + m_A61 = gt[184] + gt[185]; + m_A60 = m_A60 + go[184]; + m_A62 = m_A62 + go[185]; + double RHS23 = Idr[184] + Idr[185]; + m_A68 = gt[192] + gt[193] + gt[194] + gt[195] + gt[196]; + m_A67 = m_A67 + go[192]; + m_A65 = m_A65 + go[193]; + m_A64 = m_A64 + go[194]; + m_A63 = m_A63 + go[195]; + m_A66 = m_A66 + go[196]; + double RHS24 = Idr[192] + Idr[193] + Idr[194] + Idr[195] + Idr[196]; + m_A77 = gt[200] + gt[201] + gt[202] + gt[203]; + m_A74 = m_A74 + go[200]; + m_A73 = m_A73 + go[201]; + m_A78 = m_A78 + go[202]; + m_A72 = m_A72 + go[203]; + double RHS25 = Idr[200] + Idr[201] + Idr[202] + Idr[203]; + m_A82 = gt[208] + gt[209] + gt[210] + gt[211]; + m_A81 = m_A81 + go[208]; + m_A83 = m_A83 + go[209]; + double RHS26 = Idr[208] + Idr[209] + Idr[210] + Idr[211] - go[210] * *cnV[210] - go[211] * *cnV[211]; + m_A87 = gt[216] + gt[217] + gt[218] + gt[219] + gt[220]; + m_A84 = m_A84 + go[216]; + m_A85 = m_A85 + go[217]; + m_A88 = m_A88 + go[218]; + double RHS27 = Idr[216] + Idr[217] + Idr[218] + Idr[219] + Idr[220] - go[219] * *cnV[219] - go[220] * *cnV[220]; + m_A96 = gt[224] + gt[225] + gt[226] + gt[227] + gt[228] + gt[229] + gt[230]; + m_A95 = m_A95 + go[224]; + m_A91 = m_A91 + go[225]; + m_A92 = m_A92 + go[226]; + m_A90 = m_A90 + go[227]; + m_A89 = m_A89 + go[228]; + m_A93 = m_A93 + go[229]; + m_A94 = m_A94 + go[230]; + double RHS28 = Idr[224] + Idr[225] + Idr[226] + Idr[227] + Idr[228] + Idr[229] + Idr[230]; + m_A106 = gt[232] + gt[233] + gt[234] + gt[235] + gt[236]; + m_A102 = m_A102 + go[232]; + m_A101 = m_A101 + go[233]; + m_A107 = m_A107 + go[234]; + m_A100 = m_A100 + go[235]; + m_A99 = m_A99 + go[236]; + double RHS29 = Idr[232] + Idr[233] + Idr[234] + Idr[235] + Idr[236]; + m_A115 = gt[240] + gt[241] + gt[242] + gt[243] + gt[244]; + m_A108 = m_A108 + go[240]; + m_A110 = m_A110 + go[241]; + m_A109 = m_A109 + go[242]; + m_A114 = m_A114 + go[243]; + double RHS30 = Idr[240] + Idr[241] + Idr[242] + Idr[243] + Idr[244] - go[244] * *cnV[244]; +const double f0 = 1.0 / m_A0; + const double f0_16 = -f0 * m_A34; + m_A35 += m_A1 * f0_16; + RHS16 += f0_16 * RHS0; + const double f0_29 = -f0 * m_A99; + m_A101 += m_A1 * f0_29; + RHS29 += f0_29 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_19 = -f1 * m_A41; + m_A43 += m_A3 * f1_19; + RHS19 += f1_19 * RHS1; + const double f1_29 = -f1 * m_A100; + m_A106 += m_A3 * f1_29; + RHS29 += f1_29 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_20 = -f2 * m_A44; + m_A45 += m_A5 * f2_20; + RHS20 += f2_20 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_30 = -f3 * m_A108; + m_A115 += m_A7 * f3_30; + RHS30 += f3_30 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_17 = -f4 * m_A36; + m_A37 += m_A9 * f4_17; + RHS17 += f4_17 * RHS4; + const double f4_24 = -f4 * m_A63; + m_A65 += m_A9 * f4_24; + RHS24 += f4_24 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_22 = -f5 * m_A53; + m_A55 += m_A11 * f5_22; + RHS22 += f5_22 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_21 = -f6 * m_A50; + m_A52 += m_A13 * f6_21; + RHS21 += f6_21 * RHS6; + const double f6_24 = -f6 * m_A64; + m_A68 += m_A13 * f6_24; + RHS24 += f6_24 * RHS6; +const double f7 = 1.0 / m_A14; + const double f7_22 = -f7 * m_A54; + m_A56 += m_A15 * f7_22; + m_A58 += m_A16 * f7_22; + RHS22 += f7_22 * RHS7; + const double f7_25 = -f7 * m_A72; + m_A75 += m_A15 * f7_25; + m_A77 += m_A16 * f7_25; + RHS25 += f7_25 * RHS7; +const double f8 = 1.0 / m_A17; + const double f8_25 = -f8 * m_A73; + m_A77 += m_A18 * f8_25; + RHS25 += f8_25 * RHS8; +const double f9 = 1.0 / m_A19; + const double f9_23 = -f9 * m_A60; + m_A61 += m_A20 * f9_23; + RHS23 += f9_23 * RHS9; +const double f10 = 1.0 / m_A21; + const double f10_25 = -f10 * m_A74; + m_A77 += m_A22 * f10_25; + RHS25 += f10_25 * RHS10; +const double f11 = 1.0 / m_A23; + const double f11_27 = -f11 * m_A84; + m_A86 += m_A24 * f11_27; + RHS27 += f11_27 * RHS11; +const double f12 = 1.0 / m_A25; + const double f12_18 = -f12 * m_A38; + m_A40 += m_A26 * f12_18; + RHS18 += f12_18 * RHS12; + const double f12_28 = -f12 * m_A89; + m_A92 += m_A26 * f12_28; + RHS28 += f12_28 * RHS12; +const double f13 = 1.0 / m_A27; + const double f13_18 = -f13 * m_A39; + m_A40 += m_A28 * f13_18; + RHS18 += f13_18 * RHS13; +const double f14 = 1.0 / m_A29; + const double f14_26 = -f14 * m_A81; + m_A83 += m_A30 * f14_26; + RHS26 += f14_26 * RHS14; + const double f14_28 = -f14 * m_A90; + m_A96 += m_A30 * f14_28; + RHS28 += f14_28 * RHS14; +const double f15 = 1.0 / m_A31; + const double f15_27 = -f15 * m_A85; + m_A87 += m_A32 * f15_27; + m_A88 += m_A33 * f15_27; + RHS27 += f15_27 * RHS15; + const double f15_28 = -f15 * m_A91; + m_A95 += m_A32 * f15_28; + m_A96 += m_A33 * f15_28; + RHS28 += f15_28 * RHS15; +const double f16 = 1.0 / m_A35; + const double f16_29 = -f16 * m_A101; + RHS29 += f16_29 * RHS16; +const double f17 = 1.0 / m_A37; + const double f17_24 = -f17 * m_A65; + RHS24 += f17_24 * RHS17; +const double f18 = 1.0 / m_A40; + const double f18_28 = -f18 * m_A92; + RHS28 += f18_28 * RHS18; +const double f19 = 1.0 / m_A42; + const double f19_20 = -f19 * m_A45; + m_A48 += m_A43 * f19_20; + RHS20 += f19_20 * RHS19; +const double f20 = 1.0 / m_A46; + const double f20_24 = -f20 * m_A66; + m_A68 += m_A47 * f20_24; + m_A70 += m_A48 * f20_24; + m_A71 += m_A49 * f20_24; + RHS24 += f20_24 * RHS20; + const double f20_29 = -f20 * m_A102; + m_A103 += m_A47 * f20_29; + m_A106 += m_A48 * f20_29; + m_A107 += m_A49 * f20_29; + RHS29 += f20_29 * RHS20; + const double f20_30 = -f20 * m_A109; + m_A111 += m_A47 * f20_30; + m_A114 += m_A48 * f20_30; + m_A115 += m_A49 * f20_30; + RHS30 += f20_30 * RHS20; +const double f21 = 1.0 / m_A51; + const double f21_22 = -f21 * m_A55; + m_A57 += m_A52 * f21_22; + RHS22 += f21_22 * RHS21; +const double f22 = 1.0 / m_A56; + const double f22_24 = -f22 * m_A67; + m_A68 += m_A57 * f22_24; + m_A69 += m_A58 * f22_24; + m_A71 += m_A59 * f22_24; + RHS24 += f22_24 * RHS22; + const double f22_25 = -f22 * m_A75; + m_A76 += m_A57 * f22_25; + m_A77 += m_A58 * f22_25; + m_A80 += m_A59 * f22_25; + RHS25 += f22_25 * RHS22; + const double f22_30 = -f22 * m_A110; + m_A111 += m_A57 * f22_30; + m_A112 += m_A58 * f22_30; + m_A115 += m_A59 * f22_30; + RHS30 += f22_30 * RHS22; +const double f23 = 1.0 / m_A61; + const double f23_28 = -f23 * m_A93; + m_A96 += m_A62 * f23_28; + RHS28 += f23_28 * RHS23; +const double f24 = 1.0 / m_A68; + const double f24_25 = -f24 * m_A76; + m_A77 += m_A69 * f24_25; + m_A79 += m_A70 * f24_25; + m_A80 += m_A71 * f24_25; + RHS25 += f24_25 * RHS24; + const double f24_29 = -f24 * m_A103; + m_A104 += m_A69 * f24_29; + m_A106 += m_A70 * f24_29; + m_A107 += m_A71 * f24_29; + RHS29 += f24_29 * RHS24; + const double f24_30 = -f24 * m_A111; + m_A112 += m_A69 * f24_30; + m_A114 += m_A70 * f24_30; + m_A115 += m_A71 * f24_30; + RHS30 += f24_30 * RHS24; +const double f25 = 1.0 / m_A77; + const double f25_28 = -f25 * m_A94; + m_A96 += m_A78 * f25_28; + m_A97 += m_A79 * f25_28; + m_A98 += m_A80 * f25_28; + RHS28 += f25_28 * RHS25; + const double f25_29 = -f25 * m_A104; + m_A105 += m_A78 * f25_29; + m_A106 += m_A79 * f25_29; + m_A107 += m_A80 * f25_29; + RHS29 += f25_29 * RHS25; + const double f25_30 = -f25 * m_A112; + m_A113 += m_A78 * f25_30; + m_A114 += m_A79 * f25_30; + m_A115 += m_A80 * f25_30; + RHS30 += f25_30 * RHS25; +const double f26 = 1.0 / m_A82; + const double f26_27 = -f26 * m_A86; + m_A88 += m_A83 * f26_27; + RHS27 += f26_27 * RHS26; +const double f27 = 1.0 / m_A87; + const double f27_28 = -f27 * m_A95; + m_A96 += m_A88 * f27_28; + RHS28 += f27_28 * RHS27; +const double f28 = 1.0 / m_A96; + const double f28_29 = -f28 * m_A105; + m_A106 += m_A97 * f28_29; + m_A107 += m_A98 * f28_29; + RHS29 += f28_29 * RHS28; + const double f28_30 = -f28 * m_A113; + m_A114 += m_A97 * f28_30; + m_A115 += m_A98 * f28_30; + RHS30 += f28_30 * RHS28; +const double f29 = 1.0 / m_A106; + const double f29_30 = -f29 * m_A114; + m_A115 += m_A107 * f29_30; + RHS30 += f29_30 * RHS29; + V[30] = RHS30 / m_A115; + double tmp29 = 0.0; + tmp29 += m_A107 * V[30]; + V[29] = (RHS29 - tmp29) / m_A106; + double tmp28 = 0.0; + tmp28 += m_A97 * V[29]; + tmp28 += m_A98 * V[30]; + V[28] = (RHS28 - tmp28) / m_A96; + double tmp27 = 0.0; + tmp27 += m_A88 * V[28]; + V[27] = (RHS27 - tmp27) / m_A87; + double tmp26 = 0.0; + tmp26 += m_A83 * V[28]; + V[26] = (RHS26 - tmp26) / m_A82; + double tmp25 = 0.0; + tmp25 += m_A78 * V[28]; + tmp25 += m_A79 * V[29]; + tmp25 += m_A80 * V[30]; + V[25] = (RHS25 - tmp25) / m_A77; + double tmp24 = 0.0; + tmp24 += m_A69 * V[25]; + tmp24 += m_A70 * V[29]; + tmp24 += m_A71 * V[30]; + V[24] = (RHS24 - tmp24) / m_A68; + double tmp23 = 0.0; + tmp23 += m_A62 * V[28]; + V[23] = (RHS23 - tmp23) / m_A61; + double tmp22 = 0.0; + tmp22 += m_A57 * V[24]; + tmp22 += m_A58 * V[25]; + tmp22 += m_A59 * V[30]; + V[22] = (RHS22 - tmp22) / m_A56; + double tmp21 = 0.0; + tmp21 += m_A52 * V[24]; + V[21] = (RHS21 - tmp21) / m_A51; + double tmp20 = 0.0; + tmp20 += m_A47 * V[24]; + tmp20 += m_A48 * V[29]; + tmp20 += m_A49 * V[30]; + V[20] = (RHS20 - tmp20) / m_A46; + double tmp19 = 0.0; + tmp19 += m_A43 * V[29]; + V[19] = (RHS19 - tmp19) / m_A42; + double tmp18 = 0.0; + V[18] = (RHS18 - tmp18) / m_A40; + double tmp17 = 0.0; + V[17] = (RHS17 - tmp17) / m_A37; + double tmp16 = 0.0; + V[16] = (RHS16 - tmp16) / m_A35; + double tmp15 = 0.0; + tmp15 += m_A32 * V[27]; + tmp15 += m_A33 * V[28]; + V[15] = (RHS15 - tmp15) / m_A31; + double tmp14 = 0.0; + tmp14 += m_A30 * V[28]; + V[14] = (RHS14 - tmp14) / m_A29; + double tmp13 = 0.0; + tmp13 += m_A28 * V[18]; + V[13] = (RHS13 - tmp13) / m_A27; + double tmp12 = 0.0; + tmp12 += m_A26 * V[18]; + V[12] = (RHS12 - tmp12) / m_A25; + double tmp11 = 0.0; + tmp11 += m_A24 * V[26]; + V[11] = (RHS11 - tmp11) / m_A23; + double tmp10 = 0.0; + tmp10 += m_A22 * V[25]; + V[10] = (RHS10 - tmp10) / m_A21; + double tmp9 = 0.0; + tmp9 += m_A20 * V[23]; + V[9] = (RHS9 - tmp9) / m_A19; + double tmp8 = 0.0; + tmp8 += m_A18 * V[25]; + V[8] = (RHS8 - tmp8) / m_A17; + double tmp7 = 0.0; + tmp7 += m_A15 * V[22]; + tmp7 += m_A16 * V[25]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[24]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[21]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[17]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[30]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[19]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[29]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[16]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// 280zzzap +static void nl_gcr_9e7791458f751e0c_123_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] - go[17] * *cnV[17] - go[18] * *cnV[18] - go[19] * *cnV[19] - go[20] * *cnV[20] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A6 = gt[24] + gt[25] + gt[26]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A8 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36] + gt[37] + gt[38]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] + Idr[37] + Idr[38] - go[33] * *cnV[33] - go[34] * *cnV[34] - go[35] * *cnV[35] - go[36] * *cnV[36] - go[37] * *cnV[37] - go[38] * *cnV[38]; + m_A10 = gt[40] + gt[41]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A12 = gt[48] + gt[49]; + m_A14 = m_A14 + go[48]; + m_A13 = m_A13 + go[49]; + double RHS6 = Idr[48] + Idr[49]; + m_A15 = gt[56] + gt[57]; + m_A16 = m_A16 + go[56]; + double RHS7 = Idr[56] + Idr[57] - go[57] * *cnV[57]; + m_A17 = gt[64] + gt[65]; + m_A18 = m_A18 + go[64]; + double RHS8 = Idr[64] + Idr[65] - go[65] * *cnV[65]; + m_A19 = gt[72] + gt[73] + gt[74] + gt[75] + gt[76] + gt[77] + gt[78]; + m_A20 = m_A20 + go[72]; + double RHS9 = Idr[72] + Idr[73] + Idr[74] + Idr[75] + Idr[76] + Idr[77] + Idr[78] - go[73] * *cnV[73] - go[74] * *cnV[74] - go[75] * *cnV[75] - go[76] * *cnV[76] - go[77] * *cnV[77] - go[78] * *cnV[78]; + m_A21 = gt[80] + gt[81] + gt[82]; + m_A22 = m_A22 + go[80]; + double RHS10 = Idr[80] + Idr[81] + Idr[82] - go[81] * *cnV[81] - go[82] * *cnV[82]; + m_A23 = gt[88] + gt[89] + gt[90] + gt[91]; + m_A24 = m_A24 + go[88]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91] - go[89] * *cnV[89] - go[90] * *cnV[90] - go[91] * *cnV[91]; + m_A25 = gt[96] + gt[97] + gt[98] + gt[99] + gt[100] + gt[101] + gt[102]; + m_A26 = m_A26 + go[96]; + double RHS12 = Idr[96] + Idr[97] + Idr[98] + Idr[99] + Idr[100] + Idr[101] + Idr[102] - go[97] * *cnV[97] - go[98] * *cnV[98] - go[99] * *cnV[99] - go[100] * *cnV[100] - go[101] * *cnV[101] - go[102] * *cnV[102]; + m_A27 = gt[104] + gt[105]; + m_A28 = m_A28 + go[104]; + double RHS13 = Idr[104] + Idr[105] - go[105] * *cnV[105]; + m_A29 = gt[112] + gt[113]; + m_A30 = m_A30 + go[112]; + double RHS14 = Idr[112] + Idr[113] - go[113] * *cnV[113]; + m_A31 = gt[120] + gt[121]; + m_A32 = m_A32 + go[120]; + double RHS15 = Idr[120] + Idr[121] - go[121] * *cnV[121]; + m_A33 = gt[128] + gt[129] + gt[130] + gt[131]; + m_A35 = m_A35 + go[128]; + m_A34 = m_A34 + go[129]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131] - go[130] * *cnV[130] - go[131] * *cnV[131]; + m_A36 = gt[136] + gt[137] + gt[138]; + m_A37 = m_A37 + go[136]; + double RHS17 = Idr[136] + Idr[137] + Idr[138] - go[137] * *cnV[137] - go[138] * *cnV[138]; + m_A38 = gt[144] + gt[145]; + m_A39 = m_A39 + go[144]; + double RHS18 = Idr[144] + Idr[145] - go[145] * *cnV[145]; + m_A40 = gt[152] + gt[153]; + m_A41 = m_A41 + go[152]; + double RHS19 = Idr[152] + Idr[153] - go[153] * *cnV[153]; + m_A43 = gt[160] + gt[161] + gt[162] + gt[163]; + m_A42 = m_A42 + go[160]; + double RHS20 = Idr[160] + Idr[161] + Idr[162] + Idr[163] - go[161] * *cnV[161] - go[162] * *cnV[162] - go[163] * *cnV[163]; + m_A47 = gt[168] + gt[169]; + m_A46 = m_A46 + go[168]; + m_A45 = m_A45 + go[169]; + double RHS21 = Idr[168] + Idr[169]; + m_A51 = gt[176] + gt[177]; + m_A49 = m_A49 + go[176]; + double RHS22 = Idr[176] + Idr[177] - go[177] * *cnV[177]; + m_A54 = gt[184] + gt[185] + gt[186]; + m_A53 = m_A53 + go[184]; + m_A52 = m_A52 + go[185]; + double RHS23 = Idr[184] + Idr[185] + Idr[186] - go[186] * *cnV[186]; + m_A56 = gt[192] + gt[193] + gt[194] + gt[195]; + m_A55 = m_A55 + go[192]; + m_A57 = m_A57 + go[193]; + double RHS24 = Idr[192] + Idr[193] + Idr[194] + Idr[195] - go[194] * *cnV[194] - go[195] * *cnV[195]; + m_A59 = gt[200] + gt[201] + gt[202] + gt[203]; + m_A58 = m_A58 + go[200]; + m_A60 = m_A60 + go[201]; + double RHS25 = Idr[200] + Idr[201] + Idr[202] + Idr[203] - go[202] * *cnV[202] - go[203] * *cnV[203]; + m_A62 = gt[208] + gt[209]; + m_A63 = m_A63 + go[208]; + m_A61 = m_A61 + go[209]; + double RHS26 = Idr[208] + Idr[209]; + m_A67 = gt[216] + gt[217] + gt[218] + gt[219] + gt[220] + gt[221]; + m_A64 = m_A64 + go[216]; + m_A65 = m_A65 + go[217]; + m_A69 = m_A69 + go[218]; + m_A68 = m_A68 + go[219]; + double RHS27 = Idr[216] + Idr[217] + Idr[218] + Idr[219] + Idr[220] + Idr[221] - go[220] * *cnV[220] - go[221] * *cnV[221]; + m_A72 = gt[224] + gt[225] + gt[226] + gt[227]; + m_A71 = m_A71 + go[224]; + m_A73 = m_A73 + go[225]; + double RHS28 = Idr[224] + Idr[225] + Idr[226] + Idr[227] - go[226] * *cnV[226] - go[227] * *cnV[227]; + m_A76 = gt[232] + gt[233] + gt[234] + gt[235]; + m_A77 = m_A77 + go[232]; + m_A78 = m_A78 + go[233]; + m_A74 = m_A74 + go[234]; + m_A75 = m_A75 + go[235]; + double RHS29 = Idr[232] + Idr[233] + Idr[234] + Idr[235]; + m_A81 = gt[240] + gt[241] + gt[242]; + m_A80 = m_A80 + go[240]; + m_A79 = m_A79 + go[241]; + double RHS30 = Idr[240] + Idr[241] + Idr[242] - go[242] * *cnV[242]; + m_A84 = gt[248] + gt[249]; + m_A82 = m_A82 + go[248]; + m_A83 = m_A83 + go[249]; + double RHS31 = Idr[248] + Idr[249]; + m_A91 = gt[256] + gt[257] + gt[258] + gt[259] + gt[260]; + m_A86 = m_A86 + go[256]; + m_A90 = m_A90 + go[257]; + m_A88 = m_A88 + go[258]; + m_A85 = m_A85 + go[259]; + m_A87 = m_A87 + go[260]; + double RHS32 = Idr[256] + Idr[257] + Idr[258] + Idr[259] + Idr[260]; + m_A99 = gt[264] + gt[265] + gt[266] + gt[267] + gt[268]; + m_A96 = m_A96 + go[264]; + m_A100 = m_A100 + go[265]; + m_A97 = m_A97 + go[266]; + m_A94 = m_A94 + go[267]; + m_A95 = m_A95 + go[268]; + double RHS33 = Idr[264] + Idr[265] + Idr[266] + Idr[267] + Idr[268]; + m_A106 = gt[272] + gt[273] + gt[274] + gt[275]; + m_A103 = m_A103 + go[272]; + m_A104 = m_A104 + go[273]; + m_A101 = m_A101 + go[274]; + m_A102 = m_A102 + go[275]; + double RHS34 = Idr[272] + Idr[273] + Idr[274] + Idr[275]; + m_A111 = gt[280] + gt[281] + gt[282] + gt[283]; + m_A108 = m_A108 + go[280]; + m_A109 = m_A109 + go[281]; + double RHS35 = Idr[280] + Idr[281] + Idr[282] + Idr[283] - go[282] * *cnV[282] - go[283] * *cnV[283]; + m_A122 = gt[288] + gt[289] + gt[290] + gt[291] + gt[292] + gt[293]; + m_A113 = m_A113 + go[288]; + m_A117 = m_A117 + go[289]; + m_A120 = m_A120 + go[290]; + m_A114 = m_A114 + go[291]; + double RHS36 = Idr[288] + Idr[289] + Idr[290] + Idr[291] + Idr[292] + Idr[293] - go[292] * *cnV[292] - go[293] * *cnV[293]; +const double f0 = 1.0 / m_A0; + const double f0_24 = -f0 * m_A55; + m_A57 += m_A1 * f0_24; + RHS24 += f0_24 * RHS0; + const double f0_32 = -f0 * m_A85; + m_A91 += m_A1 * f0_32; + RHS32 += f0_32 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_32 = -f1 * m_A86; + m_A91 += m_A3 * f1_32; + RHS32 += f1_32 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_27 = -f2 * m_A64; + m_A66 += m_A5 * f2_27; + RHS27 += f2_27 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_25 = -f3 * m_A58; + m_A60 += m_A7 * f3_25; + RHS25 += f3_25 * RHS3; + const double f3_34 = -f3 * m_A101; + m_A106 += m_A7 * f3_34; + RHS34 += f3_34 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_20 = -f4 * m_A42; + m_A44 += m_A9 * f4_20; + RHS20 += f4_20 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_21 = -f5 * m_A45; + m_A47 += m_A11 * f5_21; + RHS21 += f5_21 * RHS5; + const double f5_32 = -f5 * m_A87; + m_A88 += m_A11 * f5_32; + RHS32 += f5_32 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_21 = -f6 * m_A46; + m_A47 += m_A13 * f6_21; + m_A48 += m_A14 * f6_21; + RHS21 += f6_21 * RHS6; + const double f6_22 = -f6 * m_A49; + m_A50 += m_A13 * f6_22; + m_A51 += m_A14 * f6_22; + RHS22 += f6_22 * RHS6; +const double f7 = 1.0 / m_A15; + const double f7_23 = -f7 * m_A52; + m_A54 += m_A16 * f7_23; + RHS23 += f7_23 * RHS7; + const double f7_34 = -f7 * m_A102; + m_A103 += m_A16 * f7_34; + RHS34 += f7_34 * RHS7; +const double f8 = 1.0 / m_A17; + const double f8_23 = -f8 * m_A53; + m_A54 += m_A18 * f8_23; + RHS23 += f8_23 * RHS8; +const double f9 = 1.0 / m_A19; + const double f9_36 = -f9 * m_A113; + m_A116 += m_A20 * f9_36; + RHS36 += f9_36 * RHS9; +const double f10 = 1.0 / m_A21; + const double f10_28 = -f10 * m_A71; + m_A73 += m_A22 * f10_28; + RHS28 += f10_28 * RHS10; + const double f10_33 = -f10 * m_A94; + m_A99 += m_A22 * f10_33; + RHS33 += f10_33 * RHS10; +const double f13 = 1.0 / m_A27; + const double f13_26 = -f13 * m_A61; + m_A62 += m_A28 * f13_26; + RHS26 += f13_26 * RHS13; + const double f13_33 = -f13 * m_A95; + m_A97 += m_A28 * f13_33; + RHS33 += f13_33 * RHS13; +const double f14 = 1.0 / m_A29; + const double f14_33 = -f14 * m_A96; + m_A99 += m_A30 * f14_33; + RHS33 += f14_33 * RHS14; +const double f15 = 1.0 / m_A31; + const double f15_31 = -f15 * m_A82; + m_A84 += m_A32 * f15_31; + RHS31 += f15_31 * RHS15; +const double f16 = 1.0 / m_A33; + const double f16_27 = -f16 * m_A65; + m_A67 += m_A34 * f16_27; + m_A70 += m_A35 * f16_27; + RHS27 += f16_27 * RHS16; + const double f16_36 = -f16 * m_A114; + m_A115 += m_A34 * f16_36; + m_A122 += m_A35 * f16_36; + RHS36 += f16_36 * RHS16; +const double f17 = 1.0 / m_A36; + const double f17_29 = -f17 * m_A74; + m_A76 += m_A37 * f17_29; + RHS29 += f17_29 * RHS17; + const double f17_35 = -f17 * m_A108; + m_A109 += m_A37 * f17_35; + RHS35 += f17_35 * RHS17; +const double f18 = 1.0 / m_A38; + const double f18_29 = -f18 * m_A75; + m_A77 += m_A39 * f18_29; + RHS29 += f18_29 * RHS18; + const double f18_30 = -f18 * m_A79; + m_A81 += m_A39 * f18_30; + RHS30 += f18_30 * RHS18; +const double f19 = 1.0 / m_A40; + const double f19_30 = -f19 * m_A80; + m_A81 += m_A41 * f19_30; + RHS30 += f19_30 * RHS19; +const double f21 = 1.0 / m_A47; + const double f21_22 = -f21 * m_A50; + m_A51 += m_A48 * f21_22; + RHS22 += f21_22 * RHS21; + const double f21_32 = -f21 * m_A88; + m_A89 += m_A48 * f21_32; + RHS32 += f21_32 * RHS21; +const double f22 = 1.0 / m_A51; + const double f22_32 = -f22 * m_A89; + RHS32 += f22_32 * RHS22; +const double f23 = 1.0 / m_A54; + const double f23_34 = -f23 * m_A103; + RHS34 += f23_34 * RHS23; +const double f24 = 1.0 / m_A56; + const double f24_27 = -f24 * m_A66; + m_A68 += m_A57 * f24_27; + RHS27 += f24_27 * RHS24; +const double f26 = 1.0 / m_A62; + const double f26_31 = -f26 * m_A83; + m_A84 += m_A63 * f26_31; + RHS31 += f26_31 * RHS26; + const double f26_33 = -f26 * m_A97; + m_A98 += m_A63 * f26_33; + RHS33 += f26_33 * RHS26; +const double f27 = 1.0 / m_A67; + const double f27_32 = -f27 * m_A90; + m_A91 += m_A68 * f27_32; + m_A92 += m_A69 * f27_32; + m_A93 += m_A70 * f27_32; + RHS32 += f27_32 * RHS27; + const double f27_34 = -f27 * m_A104; + m_A105 += m_A68 * f27_34; + m_A106 += m_A69 * f27_34; + m_A107 += m_A70 * f27_34; + RHS34 += f27_34 * RHS27; + const double f27_36 = -f27 * m_A115; + m_A119 += m_A68 * f27_36; + m_A121 += m_A69 * f27_36; + m_A122 += m_A70 * f27_36; + RHS36 += f27_36 * RHS27; +const double f28 = 1.0 / m_A72; + const double f28_36 = -f28 * m_A116; + m_A120 += m_A73 * f28_36; + RHS36 += f28_36 * RHS28; +const double f29 = 1.0 / m_A76; + const double f29_35 = -f29 * m_A109; + m_A110 += m_A77 * f29_35; + m_A112 += m_A78 * f29_35; + RHS35 += f29_35 * RHS29; + const double f29_36 = -f29 * m_A117; + m_A118 += m_A77 * f29_36; + m_A122 += m_A78 * f29_36; + RHS36 += f29_36 * RHS29; +const double f30 = 1.0 / m_A81; + const double f30_35 = -f30 * m_A110; + RHS35 += f30_35 * RHS30; + const double f30_36 = -f30 * m_A118; + RHS36 += f30_36 * RHS30; +const double f31 = 1.0 / m_A84; + const double f31_33 = -f31 * m_A98; + RHS33 += f31_33 * RHS31; +const double f32 = 1.0 / m_A91; + const double f32_34 = -f32 * m_A105; + m_A106 += m_A92 * f32_34; + m_A107 += m_A93 * f32_34; + RHS34 += f32_34 * RHS32; + const double f32_36 = -f32 * m_A119; + m_A121 += m_A92 * f32_36; + m_A122 += m_A93 * f32_36; + RHS36 += f32_36 * RHS32; +const double f33 = 1.0 / m_A99; + const double f33_36 = -f33 * m_A120; + m_A122 += m_A100 * f33_36; + RHS36 += f33_36 * RHS33; +const double f34 = 1.0 / m_A106; + const double f34_36 = -f34 * m_A121; + m_A122 += m_A107 * f34_36; + RHS36 += f34_36 * RHS34; + V[36] = RHS36 / m_A122; + double tmp35 = 0.0; + tmp35 += m_A112 * V[36]; + V[35] = (RHS35 - tmp35) / m_A111; + double tmp34 = 0.0; + tmp34 += m_A107 * V[36]; + V[34] = (RHS34 - tmp34) / m_A106; + double tmp33 = 0.0; + tmp33 += m_A100 * V[36]; + V[33] = (RHS33 - tmp33) / m_A99; + double tmp32 = 0.0; + tmp32 += m_A92 * V[34]; + tmp32 += m_A93 * V[36]; + V[32] = (RHS32 - tmp32) / m_A91; + double tmp31 = 0.0; + V[31] = (RHS31 - tmp31) / m_A84; + double tmp30 = 0.0; + V[30] = (RHS30 - tmp30) / m_A81; + double tmp29 = 0.0; + tmp29 += m_A77 * V[30]; + tmp29 += m_A78 * V[36]; + V[29] = (RHS29 - tmp29) / m_A76; + double tmp28 = 0.0; + tmp28 += m_A73 * V[33]; + V[28] = (RHS28 - tmp28) / m_A72; + double tmp27 = 0.0; + tmp27 += m_A68 * V[32]; + tmp27 += m_A69 * V[34]; + tmp27 += m_A70 * V[36]; + V[27] = (RHS27 - tmp27) / m_A67; + double tmp26 = 0.0; + tmp26 += m_A63 * V[31]; + V[26] = (RHS26 - tmp26) / m_A62; + double tmp25 = 0.0; + tmp25 += m_A60 * V[34]; + V[25] = (RHS25 - tmp25) / m_A59; + double tmp24 = 0.0; + tmp24 += m_A57 * V[32]; + V[24] = (RHS24 - tmp24) / m_A56; + double tmp23 = 0.0; + V[23] = (RHS23 - tmp23) / m_A54; + double tmp22 = 0.0; + V[22] = (RHS22 - tmp22) / m_A51; + double tmp21 = 0.0; + tmp21 += m_A48 * V[22]; + V[21] = (RHS21 - tmp21) / m_A47; + double tmp20 = 0.0; + tmp20 += m_A44 * V[25]; + V[20] = (RHS20 - tmp20) / m_A43; + double tmp19 = 0.0; + tmp19 += m_A41 * V[30]; + V[19] = (RHS19 - tmp19) / m_A40; + double tmp18 = 0.0; + tmp18 += m_A39 * V[30]; + V[18] = (RHS18 - tmp18) / m_A38; + double tmp17 = 0.0; + tmp17 += m_A37 * V[29]; + V[17] = (RHS17 - tmp17) / m_A36; + double tmp16 = 0.0; + tmp16 += m_A34 * V[27]; + tmp16 += m_A35 * V[36]; + V[16] = (RHS16 - tmp16) / m_A33; + double tmp15 = 0.0; + tmp15 += m_A32 * V[31]; + V[15] = (RHS15 - tmp15) / m_A31; + double tmp14 = 0.0; + tmp14 += m_A30 * V[33]; + V[14] = (RHS14 - tmp14) / m_A29; + double tmp13 = 0.0; + tmp13 += m_A28 * V[26]; + V[13] = (RHS13 - tmp13) / m_A27; + double tmp12 = 0.0; + tmp12 += m_A26 * V[35]; + V[12] = (RHS12 - tmp12) / m_A25; + double tmp11 = 0.0; + tmp11 += m_A24 * V[12]; + V[11] = (RHS11 - tmp11) / m_A23; + double tmp10 = 0.0; + tmp10 += m_A22 * V[33]; + V[10] = (RHS10 - tmp10) / m_A21; + double tmp9 = 0.0; + tmp9 += m_A20 * V[28]; + V[9] = (RHS9 - tmp9) / m_A19; + double tmp8 = 0.0; + tmp8 += m_A18 * V[23]; + V[8] = (RHS8 - tmp8) / m_A17; + double tmp7 = 0.0; + tmp7 += m_A16 * V[23]; + V[7] = (RHS7 - tmp7) / m_A15; + double tmp6 = 0.0; + tmp6 += m_A13 * V[21]; + tmp6 += m_A14 * V[22]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[21]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[25]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[34]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[24]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[32]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[32]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // 1942 static void nl_gcr_a1b753ac9c408940_90_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -9653,6 +12239,453 @@ const double f2 = 1.0 / m_A4; V[0] = (RHS0 - tmp0) / m_A0; } +// 280zzzap +static void nl_gcr_f1804fa5ede37373_95_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict 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); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[12] + gt[13] + gt[14] + gt[15] + gt[16] + gt[17] + gt[18]; + m_A3 = m_A3 + go[12]; + double RHS1 = Idr[12] + Idr[13] + Idr[14] + Idr[15] + Idr[16] + Idr[17] + Idr[18] - go[13] * *cnV[13] - go[14] * *cnV[14] - go[15] * *cnV[15] - go[16] * *cnV[16] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A4 = gt[24] + gt[25] + gt[26]; + m_A5 = m_A5 + go[24]; + double RHS2 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A6 = gt[36] + gt[37] + gt[38] + gt[39] + gt[40] + gt[41] + gt[42]; + m_A7 = m_A7 + go[36]; + double RHS3 = Idr[36] + Idr[37] + Idr[38] + Idr[39] + Idr[40] + Idr[41] + Idr[42] - go[37] * *cnV[37] - go[38] * *cnV[38] - go[39] * *cnV[39] - go[40] * *cnV[40] - go[41] * *cnV[41] - go[42] * *cnV[42]; + m_A8 = gt[48] + gt[49]; + m_A9 = m_A9 + go[48]; + double RHS4 = Idr[48] + Idr[49] - go[49] * *cnV[49]; + m_A10 = gt[60] + gt[61]; + m_A11 = m_A11 + go[60]; + double RHS5 = Idr[60] + Idr[61] - go[61] * *cnV[61]; + m_A12 = gt[72] + gt[73] + gt[74] + gt[75]; + m_A13 = m_A13 + go[72]; + double RHS6 = Idr[72] + Idr[73] + Idr[74] + Idr[75] - go[73] * *cnV[73] - go[74] * *cnV[74] - go[75] * *cnV[75]; + m_A14 = gt[84] + gt[85] + gt[86] + gt[87]; + m_A15 = m_A15 + go[84]; + double RHS7 = Idr[84] + Idr[85] + Idr[86] + Idr[87] - go[85] * *cnV[85] - go[86] * *cnV[86] - go[87] * *cnV[87]; + m_A16 = gt[96] + gt[97]; + m_A17 = m_A17 + go[96]; + double RHS8 = Idr[96] + Idr[97] - go[97] * *cnV[97]; + m_A18 = gt[108] + gt[109] + gt[110] + gt[111]; + m_A19 = m_A19 + go[108]; + double RHS9 = Idr[108] + Idr[109] + Idr[110] + Idr[111] - go[109] * *cnV[109] - go[110] * *cnV[110] - go[111] * *cnV[111]; + m_A20 = gt[120] + gt[121]; + m_A22 = m_A22 + go[120]; + m_A21 = m_A21 + go[121]; + double RHS10 = Idr[120] + Idr[121]; + m_A23 = gt[132] + gt[133] + gt[134] + gt[135]; + m_A24 = m_A24 + go[132]; + double RHS11 = Idr[132] + Idr[133] + Idr[134] + Idr[135] - go[133] * *cnV[133] - go[134] * *cnV[134] - go[135] * *cnV[135]; + m_A25 = gt[144] + gt[145] + gt[146]; + m_A27 = m_A27 + go[144]; + m_A28 = m_A28 + go[145]; + m_A26 = m_A26 + go[146]; + double RHS12 = Idr[144] + Idr[145] + Idr[146]; + m_A29 = gt[156] + gt[157]; + m_A31 = m_A31 + go[156]; + m_A30 = m_A30 + go[157]; + double RHS13 = Idr[156] + Idr[157]; + m_A37 = gt[168] + gt[169] + gt[170] + gt[171] + gt[172] + gt[173]; + m_A36 = m_A36 + go[168]; + m_A35 = m_A35 + go[169]; + m_A34 = m_A34 + go[170]; + m_A33 = m_A33 + go[171]; + m_A32 = m_A32 + go[172]; + double RHS14 = Idr[168] + Idr[169] + Idr[170] + Idr[171] + Idr[172] + Idr[173] - go[173] * *cnV[173]; + m_A39 = gt[180] + gt[181] + gt[182] + gt[183]; + m_A38 = m_A38 + go[180]; + m_A40 = m_A40 + go[181]; + double RHS15 = Idr[180] + Idr[181] + Idr[182] + Idr[183] - go[182] * *cnV[182] - go[183] * *cnV[183]; + m_A42 = gt[192] + gt[193] + gt[194] + gt[195]; + m_A41 = m_A41 + go[192]; + m_A43 = m_A43 + go[193]; + double RHS16 = Idr[192] + Idr[193] + Idr[194] + Idr[195] - go[194] * *cnV[194] - go[195] * *cnV[195]; + m_A45 = gt[204] + gt[205] + gt[206]; + m_A46 = m_A46 + go[204]; + m_A44 = m_A44 + go[205]; + double RHS17 = Idr[204] + Idr[205] + Idr[206] - go[206] * *cnV[206]; + m_A52 = gt[216] + gt[217] + gt[218] + gt[219] + gt[220] + gt[221]; + m_A49 = m_A49 + go[216]; + m_A50 = m_A50 + go[217]; + m_A51 = m_A51 + go[218]; + m_A47 = m_A47 + go[219]; + m_A48 = m_A48 + go[220]; + double RHS18 = Idr[216] + Idr[217] + Idr[218] + Idr[219] + Idr[220] + Idr[221] - go[221] * *cnV[221]; + m_A59 = gt[228] + gt[229]; + m_A57 = m_A57 + go[228]; + m_A62 = m_A62 + go[229]; + double RHS19 = Idr[228] + Idr[229]; + m_A66 = gt[240] + gt[241] + gt[242] + gt[243] + gt[244] + gt[245]; + m_A63 = m_A63 + go[240]; + m_A64 = m_A64 + go[241]; + m_A68 = m_A68 + go[242]; + m_A67 = m_A67 + go[243]; + double RHS20 = Idr[240] + Idr[241] + Idr[242] + Idr[243] + Idr[244] + Idr[245] - go[244] * *cnV[244] - go[245] * *cnV[245]; + m_A73 = gt[252] + gt[253] + gt[254] + gt[255]; + m_A72 = m_A72 + go[252]; + m_A71 = m_A71 + go[253]; + m_A69 = m_A69 + go[254]; + m_A70 = m_A70 + go[255]; + double RHS21 = Idr[252] + Idr[253] + Idr[254] + Idr[255]; + m_A80 = gt[264] + gt[265] + gt[266] + gt[267] + gt[268] + gt[269] + gt[270] + gt[271] + gt[272] + gt[273] + gt[274]; + m_A75 = m_A75 + go[264]; + m_A82 = m_A82 + go[265]; + m_A76 = m_A76 + go[266]; + double RHS22 = Idr[264] + Idr[265] + Idr[266] + Idr[267] + Idr[268] + Idr[269] + Idr[270] + Idr[271] + Idr[272] + Idr[273] + Idr[274] - go[267] * *cnV[267] - go[268] * *cnV[268] - go[269] * *cnV[269] - go[270] * *cnV[270] - go[271] * *cnV[271] - go[272] * *cnV[272] - go[273] * *cnV[273] - go[274] * *cnV[274]; + m_A88 = gt[276] + gt[277] + gt[278] + gt[279] + gt[280]; + m_A83 = m_A83 + go[276]; + m_A85 = m_A85 + go[277]; + m_A84 = m_A84 + go[278]; + m_A86 = m_A86 + go[279]; + double RHS23 = Idr[276] + Idr[277] + Idr[278] + Idr[279] + Idr[280] - go[280] * *cnV[280]; + m_A94 = gt[288] + gt[289] + gt[290]; + m_A91 = m_A91 + go[288]; + m_A89 = m_A89 + go[289]; + m_A92 = m_A92 + go[290]; + double RHS24 = Idr[288] + Idr[289] + Idr[290]; +const double f0 = 1.0 / m_A0; + const double f0_15 = -f0 * m_A38; + m_A40 += m_A1 * f0_15; + RHS15 += f0_15 * RHS0; + const double f0_21 = -f0 * m_A69; + m_A73 += m_A1 * f0_21; + RHS21 += f0_21 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_20 = -f1 * m_A63; + m_A65 += m_A3 * f1_20; + RHS20 += f1_20 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_16 = -f2 * m_A41; + m_A43 += m_A5 * f2_16; + RHS16 += f2_16 * RHS2; + const double f2_18 = -f2 * m_A47; + m_A52 += m_A5 * f2_18; + RHS18 += f2_18 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_22 = -f3 * m_A75; + m_A77 += m_A7 * f3_22; + RHS22 += f3_22 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_14 = -f4 * m_A32; + m_A37 += m_A9 * f4_14; + RHS14 += f4_14 * RHS4; + const double f4_21 = -f4 * m_A70; + m_A71 += m_A9 * f4_21; + RHS21 += f4_21 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_17 = -f5 * m_A44; + m_A45 += m_A11 * f5_17; + RHS17 += f5_17 * RHS5; + const double f5_18 = -f5 * m_A48; + m_A51 += m_A11 * f5_18; + RHS18 += f5_18 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_14 = -f6 * m_A33; + m_A37 += m_A13 * f6_14; + RHS14 += f6_14 * RHS6; +const double f7 = 1.0 / m_A14; + const double f7_14 = -f7 * m_A34; + m_A37 += m_A15 * f7_14; + RHS14 += f7_14 * RHS7; +const double f8 = 1.0 / m_A16; + const double f8_23 = -f8 * m_A83; + m_A88 += m_A17 * f8_23; + RHS23 += f8_23 * RHS8; +const double f9 = 1.0 / m_A18; + const double f9_14 = -f9 * m_A35; + m_A37 += m_A19 * f9_14; + RHS14 += f9_14 * RHS9; +const double f10 = 1.0 / m_A20; + const double f10_20 = -f10 * m_A64; + m_A66 += m_A21 * f10_20; + m_A68 += m_A22 * f10_20; + RHS20 += f10_20 * RHS10; + const double f10_23 = -f10 * m_A84; + m_A86 += m_A21 * f10_23; + m_A88 += m_A22 * f10_23; + RHS23 += f10_23 * RHS10; +const double f11 = 1.0 / m_A23; + const double f11_14 = -f11 * m_A36; + m_A37 += m_A24 * f11_14; + RHS14 += f11_14 * RHS11; +const double f12 = 1.0 / m_A25; + const double f12_18 = -f12 * m_A49; + m_A52 += m_A26 * f12_18; + m_A53 += m_A27 * f12_18; + m_A56 += m_A28 * f12_18; + RHS18 += f12_18 * RHS12; + const double f12_19 = -f12 * m_A57; + m_A58 += m_A26 * f12_19; + m_A59 += m_A27 * f12_19; + m_A62 += m_A28 * f12_19; + RHS19 += f12_19 * RHS12; + const double f12_24 = -f12 * m_A89; + m_A90 += m_A26 * f12_24; + m_A91 += m_A27 * f12_24; + m_A94 += m_A28 * f12_24; + RHS24 += f12_24 * RHS12; +const double f13 = 1.0 / m_A29; + const double f13_18 = -f13 * m_A50; + m_A52 += m_A30 * f13_18; + m_A54 += m_A31 * f13_18; + RHS18 += f13_18 * RHS13; + const double f13_22 = -f13 * m_A76; + m_A78 += m_A30 * f13_22; + m_A80 += m_A31 * f13_22; + RHS22 += f13_22 * RHS13; +const double f14 = 1.0 / m_A37; + const double f14_21 = -f14 * m_A71; + RHS21 += f14_21 * RHS14; +const double f15 = 1.0 / m_A39; + const double f15_20 = -f15 * m_A65; + m_A67 += m_A40 * f15_20; + RHS20 += f15_20 * RHS15; +const double f16 = 1.0 / m_A42; + const double f16_22 = -f16 * m_A77; + m_A78 += m_A43 * f16_22; + RHS22 += f16_22 * RHS16; +const double f17 = 1.0 / m_A45; + const double f17_18 = -f17 * m_A51; + m_A55 += m_A46 * f17_18; + RHS18 += f17_18 * RHS17; + const double f17_23 = -f17 * m_A85; + m_A88 += m_A46 * f17_23; + RHS23 += f17_23 * RHS17; +const double f18 = 1.0 / m_A52; + const double f18_19 = -f18 * m_A58; + m_A59 += m_A53 * f18_19; + m_A60 += m_A54 * f18_19; + m_A61 += m_A55 * f18_19; + m_A62 += m_A56 * f18_19; + RHS19 += f18_19 * RHS18; + const double f18_22 = -f18 * m_A78; + m_A79 += m_A53 * f18_22; + m_A80 += m_A54 * f18_22; + m_A81 += m_A55 * f18_22; + m_A82 += m_A56 * f18_22; + RHS22 += f18_22 * RHS18; + const double f18_24 = -f18 * m_A90; + m_A91 += m_A53 * f18_24; + m_A92 += m_A54 * f18_24; + m_A93 += m_A55 * f18_24; + m_A94 += m_A56 * f18_24; + RHS24 += f18_24 * RHS18; +const double f19 = 1.0 / m_A59; + const double f19_22 = -f19 * m_A79; + m_A80 += m_A60 * f19_22; + m_A81 += m_A61 * f19_22; + m_A82 += m_A62 * f19_22; + RHS22 += f19_22 * RHS19; + const double f19_24 = -f19 * m_A91; + m_A92 += m_A60 * f19_24; + m_A93 += m_A61 * f19_24; + m_A94 += m_A62 * f19_24; + RHS24 += f19_24 * RHS19; +const double f20 = 1.0 / m_A66; + const double f20_21 = -f20 * m_A72; + m_A73 += m_A67 * f20_21; + m_A74 += m_A68 * f20_21; + RHS21 += f20_21 * RHS20; + const double f20_23 = -f20 * m_A86; + m_A87 += m_A67 * f20_23; + m_A88 += m_A68 * f20_23; + RHS23 += f20_23 * RHS20; +const double f21 = 1.0 / m_A73; + const double f21_23 = -f21 * m_A87; + m_A88 += m_A74 * f21_23; + RHS23 += f21_23 * RHS21; +const double f22 = 1.0 / m_A80; + const double f22_24 = -f22 * m_A92; + m_A93 += m_A81 * f22_24; + m_A94 += m_A82 * f22_24; + RHS24 += f22_24 * RHS22; +const double f23 = 1.0 / m_A88; + const double f23_24 = -f23 * m_A93; + RHS24 += f23_24 * RHS23; + V[24] = RHS24 / m_A94; + double tmp23 = 0.0; + V[23] = (RHS23 - tmp23) / m_A88; + double tmp22 = 0.0; + tmp22 += m_A81 * V[23]; + tmp22 += m_A82 * V[24]; + V[22] = (RHS22 - tmp22) / m_A80; + double tmp21 = 0.0; + tmp21 += m_A74 * V[23]; + V[21] = (RHS21 - tmp21) / m_A73; + double tmp20 = 0.0; + tmp20 += m_A67 * V[21]; + tmp20 += m_A68 * V[23]; + V[20] = (RHS20 - tmp20) / m_A66; + double tmp19 = 0.0; + tmp19 += m_A60 * V[22]; + tmp19 += m_A61 * V[23]; + tmp19 += m_A62 * V[24]; + V[19] = (RHS19 - tmp19) / m_A59; + double tmp18 = 0.0; + tmp18 += m_A53 * V[19]; + tmp18 += m_A54 * V[22]; + tmp18 += m_A55 * V[23]; + tmp18 += m_A56 * V[24]; + V[18] = (RHS18 - tmp18) / m_A52; + double tmp17 = 0.0; + tmp17 += m_A46 * V[23]; + V[17] = (RHS17 - tmp17) / m_A45; + double tmp16 = 0.0; + tmp16 += m_A43 * V[18]; + V[16] = (RHS16 - tmp16) / m_A42; + double tmp15 = 0.0; + tmp15 += m_A40 * V[21]; + V[15] = (RHS15 - tmp15) / m_A39; + double tmp14 = 0.0; + V[14] = (RHS14 - tmp14) / m_A37; + double tmp13 = 0.0; + tmp13 += m_A30 * V[18]; + tmp13 += m_A31 * V[22]; + V[13] = (RHS13 - tmp13) / m_A29; + double tmp12 = 0.0; + tmp12 += m_A26 * V[18]; + tmp12 += m_A27 * V[19]; + tmp12 += m_A28 * V[24]; + V[12] = (RHS12 - tmp12) / m_A25; + double tmp11 = 0.0; + tmp11 += m_A24 * V[14]; + V[11] = (RHS11 - tmp11) / m_A23; + double tmp10 = 0.0; + tmp10 += m_A21 * V[20]; + tmp10 += m_A22 * V[23]; + V[10] = (RHS10 - tmp10) / m_A20; + double tmp9 = 0.0; + tmp9 += m_A19 * V[14]; + V[9] = (RHS9 - tmp9) / m_A18; + double tmp8 = 0.0; + tmp8 += m_A17 * V[23]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[14]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[14]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[17]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[14]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[16]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[18]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[15]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[21]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // breakout static void nl_gcr_fbbf6eebb7621abc_7_double_double(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) @@ -9754,8 +12787,10 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_20615d28f46254cb_10_double_double", reinterpret_cast(&nl_gcr_20615d28f46254cb_10_double_double)}, // zac1b11142 {"nl_gcr_21d92b630d2e9a99_30_double_double", reinterpret_cast(&nl_gcr_21d92b630d2e9a99_30_double_double)}, -// dpatrol +// stuntcyc {"nl_gcr_27a78682a9b70f8c_10_double_double", reinterpret_cast(&nl_gcr_27a78682a9b70f8c_10_double_double)}, +// 280zzzap + {"nl_gcr_2e7df52e4934b257_31_double_double", reinterpret_cast(&nl_gcr_2e7df52e4934b257_31_double_double)}, // mario {"nl_gcr_2eb3d95f720484d_62_double_double", reinterpret_cast(&nl_gcr_2eb3d95f720484d_62_double_double)}, // segas16b_audio @@ -9764,12 +12799,10 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_3641ac25e244c362_16_double_double", reinterpret_cast(&nl_gcr_3641ac25e244c362_16_double_double)}, // zac1b11142 {"nl_gcr_38a3ac18f52bf78a_7_double_double", reinterpret_cast(&nl_gcr_38a3ac18f52bf78a_7_double_double)}, -// dpatrol +// stuntcyc {"nl_gcr_38f1806722626d7e_7_double_double", reinterpret_cast(&nl_gcr_38f1806722626d7e_7_double_double)}, // kidniki {"nl_gcr_3e4821cabc0aeb96_24_double_double", reinterpret_cast(&nl_gcr_3e4821cabc0aeb96_24_double_double)}, -// dpatrol - {"nl_gcr_57a832104e53c9a8_20_double_double", reinterpret_cast(&nl_gcr_57a832104e53c9a8_20_double_double)}, // rebound {"nl_gcr_5985dfb549280eeb_13_double_double", reinterpret_cast(&nl_gcr_5985dfb549280eeb_13_double_double)}, // tp1985 @@ -9778,6 +12811,8 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_6148fa421800febb_10_double_double", reinterpret_cast(&nl_gcr_6148fa421800febb_10_double_double)}, // tp1985 {"nl_gcr_6480c7a1d69e9131_7_double_double", reinterpret_cast(&nl_gcr_6480c7a1d69e9131_7_double_double)}, +// 280zzzap + {"nl_gcr_66a07f8f9d33245b_57_double_double", reinterpret_cast(&nl_gcr_66a07f8f9d33245b_57_double_double)}, // stuntcyc {"nl_gcr_6c599fc01f5b084c_20_double_double", reinterpret_cast(&nl_gcr_6c599fc01f5b084c_20_double_double)}, // breakout @@ -9788,10 +12823,14 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_7421995adbfda1ad_10_double_double", reinterpret_cast(&nl_gcr_7421995adbfda1ad_10_double_double)}, // zac1b11142 {"nl_gcr_7572db25f250cf5a_71_double_double", reinterpret_cast(&nl_gcr_7572db25f250cf5a_71_double_double)}, +// 280zzzap + {"nl_gcr_766cc932eebf25ec_104_double_double", reinterpret_cast(&nl_gcr_766cc932eebf25ec_104_double_double)}, // popeye {"nl_gcr_794f14a13bda75f0_50_double_double", reinterpret_cast(&nl_gcr_794f14a13bda75f0_50_double_double)}, // breakout {"nl_gcr_7a4e8b4f388d66d7_7_double_double", reinterpret_cast(&nl_gcr_7a4e8b4f388d66d7_7_double_double)}, +// 280zzzap + {"nl_gcr_7af598c34aca424d_135_double_double", reinterpret_cast(&nl_gcr_7af598c34aca424d_135_double_double)}, // kidniki {"nl_gcr_7b1592d23e41ce56_37_double_double", reinterpret_cast(&nl_gcr_7b1592d23e41ce56_37_double_double)}, // rebound @@ -9800,7 +12839,7 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_7dbbdf7feecfa9bd_108_double_double", reinterpret_cast(&nl_gcr_7dbbdf7feecfa9bd_108_double_double)}, // konami1x {"nl_gcr_7f2f6447ea71d31e_49_double_double", reinterpret_cast(&nl_gcr_7f2f6447ea71d31e_49_double_double)}, -// dpatrol +// stuntcyc {"nl_gcr_81bfac76b696d9f3_22_double_double", reinterpret_cast(&nl_gcr_81bfac76b696d9f3_22_double_double)}, // breakout {"nl_gcr_876240e48d904d1f_7_double_double", reinterpret_cast(&nl_gcr_876240e48d904d1f_7_double_double)}, @@ -9808,6 +12847,10 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_8e55e5f9e065890e_85_double_double", reinterpret_cast(&nl_gcr_8e55e5f9e065890e_85_double_double)}, // kidniki {"nl_gcr_933b3efec18faab_37_double_double", reinterpret_cast(&nl_gcr_933b3efec18faab_37_double_double)}, +// 280zzzap + {"nl_gcr_9de29bb0cfe2c4b4_116_double_double", reinterpret_cast(&nl_gcr_9de29bb0cfe2c4b4_116_double_double)}, +// 280zzzap + {"nl_gcr_9e7791458f751e0c_123_double_double", reinterpret_cast(&nl_gcr_9e7791458f751e0c_123_double_double)}, // 1942 {"nl_gcr_a1b753ac9c408940_90_double_double", reinterpret_cast(&nl_gcr_a1b753ac9c408940_90_double_double)}, // zac1b11142 @@ -9834,6 +12877,8 @@ plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_e7e5566e352b80c1_67_double_double", reinterpret_cast(&nl_gcr_e7e5566e352b80c1_67_double_double)}, // gamemachine {"nl_gcr_ec17a9dbc8cd78fd_10_double_double", reinterpret_cast(&nl_gcr_ec17a9dbc8cd78fd_10_double_double)}, +// 280zzzap + {"nl_gcr_f1804fa5ede37373_95_double_double", reinterpret_cast(&nl_gcr_f1804fa5ede37373_95_double_double)}, // breakout {"nl_gcr_fbbf6eebb7621abc_7_double_double", reinterpret_cast(&nl_gcr_fbbf6eebb7621abc_7_double_double)}, // cheekyms diff --git a/src/mame/audio/mw8080bw.cpp b/src/mame/audio/mw8080bw.cpp index c6142839e98..26fa00f2d94 100644 --- a/src/mame/audio/mw8080bw.cpp +++ b/src/mame/audio/mw8080bw.cpp @@ -10,6 +10,7 @@ #include "emu.h" #include "audio/mw8080bw.h" #include "audio/nl_gunfight.h" +#include "audio/nl_280zzzap.h" #include "includes/mw8080bw.h" #include "speaker.h" @@ -572,6 +573,7 @@ DEFINE_DEVICE_TYPE(SPCENCTR_AUDIO, spcenctr_audio_device, "spcenctr_audio", "Mid DEFINE_DEVICE_TYPE(PHANTOM2_AUDIO, phantom2_audio_device, "phantom2_audio", "Midway Phantom 2 Audio") DEFINE_DEVICE_TYPE(INVADERS_AUDIO, invaders_audio_device, "invaders_audio", "Taito Space Invaders Audio") DEFINE_DEVICE_TYPE(INVAD2CT_AUDIO, invad2ct_audio_device, "invad2ct_audio", "Midway Space Invaders II Audio") +DEFINE_DEVICE_TYPE(ZZZAP_AUDIO, zzzap_audio_device, "zzzap_audio", "Midway 280-ZZZAP Audio") /************************************* @@ -3611,36 +3613,56 @@ WRITE8_MEMBER(mw8080bw_state::tornbase_audio_w) * *************************************/ -void mw8080bw_state::zzzap_audio(machine_config &config) +zzzap_audio_device::zzzap_audio_device(machine_config const &mconfig, char const *tag, device_t *owner, u32 clock) : + device_t(mconfig, ZZZAP_AUDIO, tag, owner, clock), + m_pedal_bit0(*this, "sound_nl:pedal_bit0"), + m_pedal_bit1(*this, "sound_nl:pedal_bit1"), + m_pedal_bit2(*this, "sound_nl:pedal_bit2"), + m_pedal_bit3(*this, "sound_nl:pedal_bit3"), + m_hi_shift(*this, "sound_nl:hi_shift"), + m_lo_shift(*this, "sound_nl:lo_shift"), + m_boom(*this, "sound_nl:boom"), + m_engine_sound_off(*this, "sound_nl:engine_sound_off"), + m_noise_cr_1(*this, "sound_nl:noise_cr_1"), + m_noise_cr_2(*this, "sound_nl:noise_cr_2") { - SPEAKER(config, "mono").front_center(); } -WRITE8_MEMBER(mw8080bw_state::zzzap_audio_1_w) +void zzzap_audio_device::p1_w(u8 data) { /* set ENGINE SOUND FREQ(data & 0x0f) the value written is the gas pedal position */ + m_pedal_bit0->write_line(BIT(data, 0)); + m_pedal_bit1->write_line(BIT(data, 1)); + m_pedal_bit2->write_line(BIT(data, 2)); + m_pedal_bit3->write_line(BIT(data, 3)); /* if (data & 0x10) enable HI SHIFT engine sound modifier */ + m_hi_shift->write_line(BIT(data, 4)); /* if (data & 0x20) enable LO SHIFT engine sound modifier */ + m_lo_shift->write_line(BIT(data, 5)); /* D6 and D7 are not connected */ } -WRITE8_MEMBER(mw8080bw_state::zzzap_audio_2_w) +void zzzap_audio_device::p2_w(u8 data) { /* if (data & 0x01) enable BOOM sound */ + m_boom->write_line(BIT(data, 0)); /* if (data & 0x02) enable ENGINE sound (global) */ + m_engine_sound_off->write_line(BIT(data, 1)); /* if (data & 0x04) enable CR 1 (screeching sound) */ + m_noise_cr_1->write_line(BIT(data, 2)); /* if (data & 0x08) enable NOISE CR 2 (happens only after the car blows up, but before it appears again, not sure what it is supposed to sound like) */ + m_noise_cr_2->write_line(BIT(data, 3)); machine().bookkeeping().coin_counter_w(0, (data >> 5) & 0x01); @@ -3648,6 +3670,34 @@ WRITE8_MEMBER(mw8080bw_state::zzzap_audio_2_w) } +void zzzap_audio_device::device_add_mconfig(machine_config &config) +{ + SPEAKER(config, "mono").front_center(); + + NETLIST_SOUND(config, "sound_nl", 48000) + .set_source(NETLIST_NAME(280zzzap)) + .add_route(ALL_OUTPUTS, "mono", 1.0); + + NETLIST_LOGIC_INPUT(config, "sound_nl:pedal_bit0", "I_PEDAL_BIT0", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:pedal_bit1", "I_PEDAL_BIT1", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:pedal_bit2", "I_PEDAL_BIT2", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:pedal_bit3", "I_PEDAL_BIT3", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:hi_shift", "I_HI_SHIFT", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:lo_shift", "I_LO_SHIFT", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:boom", "I_BOOM", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:engine_sound_off", "I_ENGINE_SOUND_OFF", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:noise_cr_1", "I_NOISE_CR_1", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:noise_cr_2", "I_NOISE_CR_2", 0); + + NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(30000.0 / 2.5, -30000.0); +} + + +void zzzap_audio_device::device_start() +{ +} + + /************************************* * diff --git a/src/mame/audio/mw8080bw.h b/src/mame/audio/mw8080bw.h index 5d010f8bc17..498fbf65e78 100644 --- a/src/mame/audio/mw8080bw.h +++ b/src/mame/audio/mw8080bw.h @@ -300,6 +300,32 @@ private: }; +class zzzap_audio_device : public device_t +{ +public: + zzzap_audio_device(machine_config const &mconfig, char const *tag, device_t *owner, u32 clock = 0); + + void p1_w(u8 data); + void p2_w(u8 data); + +protected: + virtual void device_add_mconfig(machine_config &config) override; + virtual void device_start() override; + +private: + required_device m_pedal_bit0; + required_device m_pedal_bit1; + required_device m_pedal_bit2; + required_device m_pedal_bit3; + required_device m_hi_shift; + required_device m_lo_shift; + required_device m_boom; + required_device m_engine_sound_off; + required_device m_noise_cr_1; + required_device m_noise_cr_2; +}; + + DECLARE_DEVICE_TYPE(SEAWOLF_AUDIO, seawolf_audio_device) DECLARE_DEVICE_TYPE(GUNFIGHT_AUDIO, gunfight_audio_device) DECLARE_DEVICE_TYPE(BOOTHILL_AUDIO, boothill_audio_device) @@ -314,5 +340,6 @@ DECLARE_DEVICE_TYPE(SPCENCTR_AUDIO, spcenctr_audio_device) DECLARE_DEVICE_TYPE(PHANTOM2_AUDIO, phantom2_audio_device) DECLARE_DEVICE_TYPE(INVADERS_AUDIO, invaders_audio_device) DECLARE_DEVICE_TYPE(INVAD2CT_AUDIO, invad2ct_audio_device) +DECLARE_DEVICE_TYPE(ZZZAP_AUDIO, zzzap_audio_device) #endif // MAME_AUDIO_MW8080BW_H diff --git a/src/mame/audio/nl_280zzzap.cpp b/src/mame/audio/nl_280zzzap.cpp new file mode 100644 index 00000000000..98f0fa9f0cd --- /dev/null +++ b/src/mame/audio/nl_280zzzap.cpp @@ -0,0 +1,979 @@ +// license:CC0 +// copyright-holders:Colin Douglas Howell + +#include "netlist/devices/net_lib.h" + + +// This is a netlist description for the sound circuits of Midway's 280-ZZZAP, +// based on Midway's schematic "280 ZZZAP Game Logic P.C. 0610-00907A". It +// should also apply to Midway's Laguna Racer with only very minor changes and +// to Taito/Midway's Super Speed Race with only modest changes, because these +// games use almost identical sound circuits to 280-ZZZAP. + +// (Incidentally, the 280-ZZZAP schematic has some notes on changes made to +// the circuitry during production, a few of which were to audio circuits. +// This netlist uses the final state of the schematic, but it could be +// adjusted to the earlier state by modifying a couple of component values.) + +// Due to its complexity, this netlist is rather CPU intensive. Various +// speedups have been employed to allow the game to run at full speed on +// modern hardware with some CPU to spare. The main sources of complexity are +// the op-amps (15 of them, all of which are National Semiconductor LM3900 +// current-differencing "Norton-type" opamps) and the Motorola MC3340 +// Electronic Attenuator, the latter of which is emulated at its internal +// component level, which includes 10 bipolar junction transistors. Several of +// the circuits are oscillators which run at frequencies up to hundreds of +// hertz and which switch state abruptly, increasing the computing demands of +// the emulation. + +// Midway's 280-ZZZAP and Laguna Racer schematics don't label discrete +// components, though they do label ICs with their PCB coordinates, as well as +// IC pins. Midway's Super Speed Race schematic, however, does label discrete +// components, most of which directly correspond to the 280-ZZZAP and Laguna +// Racer ones. I have used the Super Speed Race labels for the 280-ZZZAP +// discrete components. IC components I have labeled with their 280-ZZZAP PCB +// coordinates, consistent with the 280-ZZZAP schematic. Each LM3900 IC +// contains 4 op-amps, so I have labeled these op-amps as _1 to _4, the same +// scheme used in the LM3900 datasheet, using the pin numbers on the schematic +// to identify the specific op-amp. Likewise, each CD4016 IC contains 4 +// switches, so I identify a specific switch from its pin numbers on the +// schematic; these are labeled _A through _D in the CD4016 datasheet, so I +// use that scheme. + +// The sound circuitry can be divided into three sections: engine sound +// generation and control, generation of noise-based sound effects (skidding +// and crashes), and the final mix and amplification of all sounds. + + +// Include special frontiers within engine sound oscillators whose purpose is +// to improve solution convergence by reducing the oscillators' inherent +// numeric instability. Also adjusts values of resistors associated with these +// oscillators to maintain their frequency and voltage levels. + +#define CONVERGENCE_FRONTIERS 1 + + +static NETLIST_START(mc3340) + + // A netlist description of the Motorola MC3340 Electronic Attenuator + // IC, a voltage-controlled amplifier/attenuator. It amplifies or + // attenuates an input signal according to the voltage of a second, + // control signal, with a maximum gain of about 12-13 dB (about a + // factor of 4 in voltage), and higher control voltages giving greater + // attenuation, which scales logarithmically. + + // The netlist here is based on the circuit schematic given in + // Motorola's own data books, especially the most recent ones + // published in the 1990s (e.g. _Motorola Analog/Interface ICs Device + // Data, Vol. II_ (1996), p. 9-67), which are the only schematics that + // include resistor values. However, the 1990s schematics are missing + // one crossover connection which is present in older schematics + // published in the 1970s (e.g. _Motorola Linear Integrated Circuits_ + // (1979), p. 5-130). This missing connection is clearly an error + // which has been fixed in this netlist; without it, the circuit won't + // amplify properly, generating only a very weak output signal. + + // The 1990s schematics also omit a couple of diodes which are present + // in the 1970s schematics. One of these omitted diodes noticeably + // raises the minimum control voltage at which signal attenuation + // starts; that diode has been included here, to get the netlist's + // profile of attenuation vs. control voltage to better match + // Motorola's charts for the device. + + // The Motorola schematics do not label components, so I've created my + // own labeling scheme based on numbering components on the schematics + // from top to bottom, left to right, with resistors also getting + // their value (expressed European-style to avoid decimal points) as + // part of the name. The netlist is also listed following the + // schematics in roughly top-to-bottom, left-to-right order. + + // A very simple model is used for the transistors here, based on the + // generic NPN default but with a larger scale current. Again, this + // was chosen to better match the netlist's attenuation vs. control + // voltage profile to that given in Motorola's charts for the device. + + // The MC3340 has the same circuit internally as an older Motorola + // device, the MFC6040, which was replaced by the MC3340 in the + // mid-1970s. The two chips differ only in packaging. Older arcade + // games which use the MFC6040 may also benefit from this netlist + // implementation. + + RES(R1_5K1, RES_K(5.1)) + + DIODE(D1_MC3340, "D(IS=1e-15 N=1)") + + RES(R2_4K7, RES_K(4.7)) + + NET_MODEL("NPN1 NPN(IS=1E-13 BF=100)") + + QBJT_EB(Q1, "NPN1") + + RES(R3_750, RES_R(750)) + RES(R4_10K, RES_K(10)) + + QBJT_EB(Q2, "NPN1") + + RES(R5_750, RES_R(750)) + RES(R6_3K9, RES_K(3.9)) + + RES(R7_5K1, RES_K(5.1)) + RES(R8_20K, RES_K(20)) + + // 1970s Motorola schematics have another diode just above what I call + // "R9_510"; this diode doesn't seem to affect normal operation much, + // so I've left it out. + RES(R9_510, RES_R(510)) + + QBJT_EB(Q3, "NPN1") + + QBJT_EB(Q4, "NPN1") + + QBJT_EB(Q5, "NPN1") + + RES(R10_1K3, RES_K(1.3)) + + QBJT_EB(Q6, "NPN1") + + RES(R11_5K1, RES_K(5.1)) + + QBJT_EB(Q7, "NPN1") + + QBJT_EB(Q8, "NPN1") + + RES(R12_1K5, RES_K(1.5)) + + RES(R13_6K2, RES_K(6.2)) + + QBJT_EB(Q9, "NPN1") + + RES(R14_5K1, RES_K(5.1)) + + QBJT_EB(Q10, "NPN1") + + RES(R15_5K1, RES_K(5.1)) + + RES(R16_200, RES_R(200)) + + RES(R17_5K1, RES_K(5.1)) + + DIODE(D2_MC3340, "D(IS=1e-15 N=1)") + + RES(R18_510, RES_R(510)) + + ALIAS(MC3340_VCC, R1_5K1.1) + NET_C(R1_5K1.1, Q1.C, Q2.C, R7_5K1.1, Q3.C, Q4.C, Q7.C, + R13_6K2.1, Q10.C, R17_5K1.1) + // Location of first diode present on 1970s schematics but omitted on + // 1990s ones. Including it raises the control voltage threshold for + // attenuation significantly. + NET_C(R1_5K1.2, D1_MC3340.A, Q1.B) + NET_C(D1_MC3340.K, R2_4K7.1) + NET_C(R2_4K7.2, GND) + + NET_C(Q1.E, R3_750.1, R5_750.1) + NET_C(R3_750.2, R4_10K.1, Q2.B) + NET_C(R4_10K.2, GND) + + NET_C(R5_750.2, R6_3K9.1, Q3.B) + ALIAS(MC3340_CONTROL, R6_3K9.2) + + ALIAS(MC3340_INPUT, Q5.B) + + NET_C(MC3340_INPUT, R8_20K.1) + NET_C(R7_5K1.2, R8_20K.2, R9_510.1) + // (This is approximately where the other omitted diode, which I've + // left out, would go.) + NET_C(R9_510.2, GND) + + NET_C(Q4.E, Q6.E, Q5.C) + NET_C(Q5.E, R10_1K3.1) + NET_C(R10_1K3.2, GND) + + NET_C(Q6.B, Q7.B, Q2.E, R11_5K1.1) + NET_C(R11_5K1.2, GND) + + NET_C(Q7.E, Q9.E, Q8.C) + NET_C(Q8.E, R12_1K5.1) + NET_C(R12_1K5.2, GND) + + NET_C(Q4.B, Q9.B, Q3.E, R14_5K1.1) + NET_C(R14_5K1.2, GND) + + // This is where the cross-connection is erroneously omitted from + // 1990s schematics. + NET_C(Q6.C, R13_6K2.2, Q9.C, Q10.B) + + // Connection for external frequency compensation capacitor; unused + // here. + ALIAS(MC3340_ROLLOFF, Q10.B) + + NET_C(Q10.E, R16_200.1, R15_5K1.1) + NET_C(R15_5K1.2, GND) + ALIAS(MC3340_OUTPUT, R16_200.2) + + NET_C(R17_5K1.2, D2_MC3340.A, Q8.B) + NET_C(D2_MC3340.K, R18_510.1) + NET_C(R18_510.2, GND) + +NETLIST_END() + + +static NETLIST_START(280zzzap_schematics) + + // **** Conversion of accelerator level to "engine speed" control + // **** voltage for engine sound, with capacitor-based "engine + // **** inertia" and gear shift changes. + + // The accelerator pedal input gives a 4-bit digital value which the + // microprocessor stores in 74174 latch F5. The 4-bit value from the + // latch output is converted by a resistor network to an analog + // current of about 5.5 to 43 microamps, depending on the accelerator + // level, with 5.5 µA being "zero" and each additional accelerator + // increment adding another 2.5 µA. This current is then converted to + // a corresponding analog voltage by the first LM3900 op-amp H5_3 at a + // ratio of about 0.25 volts per accelerator increment. This op-amp's + // output charges or discharges capacitor C18, whose voltage provides + // the reference input for the second op-amp H5_4. The charging and + // discharging of C18 is how the engine sound's pitch and volume are + // changed, so more accelerator will charge it faster, and less + // accelerator will charge it slower or make it discharge faster. + // Also, it can discharge faster than it can charge (RC time constants + // of about 0.5 seconds vs. 2.2 seconds), so the engine will lose + // speed faster than it will gain it. Normally ENGINE_SOUND_OFF is + // low, but if it goes high (if you crash, or when the game is in + // attract mode), it closes CD4016 switch G5_A, which almost instantly + // discharges C18 through 270-ohm resistor R56 and cuts off the engine + // sound completely. + // + // Op-amp H5_4's output, which is driven to match the input current + // from capacitor C18, provides the actual speed voltage signal to the + // engine sound oscillators. This voltage is shifted down in level + // from H5_3, ranging from 0.7 to 4.1 V. It also accounts for gear + // shift, via capacitor C19 and the two adjacent CD4016 switches G5_B + // and G5_C. When in low gear, LO_SHIFT is active, switch G5_C is + // closed, and C19 is discharged via 10K resistor R60. HI_SHIFT is + // inactive, switch G5_B is open, and all the feedback current to H5_4 + // runs through its 560K feedback resistor R58. However, when in high + // gear, the state of the two switches is reversed, and C19 is free to + // slowly charge through 560K resistor R59 while supplying additional + // feedback current to the op-amp without a resistor. This has the + // effect of temporarily depressing (or slowing the growth of) H5_4's + // output voltage while C19 is being charged until it eventually + // reaches equilibrium, at which point the output voltage will be the + // same as in the low-gear case. The effect is to slow down the engine + // speed, as you would expect in a higher gear. Likewise, if the + // accelerator is reduced in high gear, lowering the op-amp's input + // current, the fall in the op-amp's output voltage is temporarily + // delayed while C19 is charged until it has sufficiently discharged + // through R59. Thus the rate of engine slowing is also lowered. + + // Some component values here were changed in the later version of the + // Laguna Racer game logic board or in Super Speed Race. + + CD4016_DIP(G5) + + LM3900(H5_3) + LM3900(H5_4) + + RES(R42, RES_K(1)) + RES(R43, RES_K(1)) + RES(R44, RES_K(1)) + RES(R45, RES_K(1)) + RES(R62, RES_K(1)) + RES(R61, RES_K(1)) + + // The 480 Kohm resistors listed here are shown as such on the + // 280-ZZZAP schematic and the schematic for the earlier Laguna Racer + // board, but this is a non-standard value. The nearest standard value + // is 470 Kohm, and this may have been used in production. Need to + // check against actual PCBs. + RES(R51, RES_K(480)) // 470 Kohm in later Laguna and Super Speed Race + RES(R46, RES_M(2)) // 2.2 Mohm in later Laguna and Super Speed Race + RES(R47, RES_M(1)) + RES(R48, RES_K(480)) // 470 Kohm in later Laguna and Super Speed Race + RES(R49, RES_K(240)) + + RES(R50, RES_K(100)) + // Super Speed Race also has a 1 uF capacitor in parallel with R50. + RES(R53, RES_K(47)) + RES(R52, RES_K(10)) + RES(R56, RES_R(270)) + + RES(R54, RES_K(560)) + RES(R55, RES_M(4.7)) + + RES(R57, RES_M(2.7)) + RES(R58, RES_K(560)) + + RES(R59, RES_K(560)) + RES(R60, RES_K(10)) + + CAP(C18, CAP_U(47)) // 22 uF in later Laguna and Super Speed Race + NET_C(C18.2, GND) + + CAP(C19, CAP_U(2.2)) + + DIODE(D4, 1N914) + DIODE(D5, 1N914) + + NET_C(I_V5.Q, R42.1, R43.1, R44.1, R45.1, R62.1, R61.1, R51.1, + R55.1, R57.1) + + NET_C(PEDAL_BIT0, R42.2, R46.1) + NET_C(PEDAL_BIT1, R43.2, R47.1) + NET_C(PEDAL_BIT2, R44.2, R48.1) + NET_C(PEDAL_BIT3, R45.2, R49.1) + NET_C(H5_3.PLUS, R46.2, R47.2, R48.2, R49.2, R51.2) + NET_C(H5_3.MINUS, R50.2) + NET_C(H5_3.OUT, R50.1, R53.1, D4.K) + // Super Speed Race also has a 1 uF capacitor in parallel with R50. + NET_C(R53.2, R52.1, C18.1, R56.2, R54.1) + NET_C(R52.2, D4.A) + NET_C(H5_4.PLUS, R54.2, R55.2) + NET_C(H5_4.MINUS, R58.2, R57.2, G5.4) + // The following are only local connections to H5_4.OUT. It also runs + // to all the oscillators; those connections are listed further down. + NET_C(H5_4.OUT, D5.A, R59.1) + NET_C(D5.K, R58.1) + NET_C(C19.1, R59.2, R60.2) + + NET_C(G5.1, GND) + NET_C(G5.2, R56.1) + NET_C(G5.13, ENGINE_SOUND_OFF) + + NET_C(G5.5, R62.2, HI_SHIFT) + + NET_C(G5.3, G5.8, C19.2) + NET_C(G5.9, R60.1) + NET_C(G5.6, R61.2, LO_SHIFT) + + + // **** Engine sound generation, using three triangle-wave oscillators + // **** running at frequency and amplitude determined by engine speed + // **** control voltage and modulated by MC3340 amplifier/attenuator. + + // Engine sound oscillators. There are three of these, at different + // frequencies; all three are triangle-wave oscillators whose + // frequency and amplitude are controlled by the "engine speed" + // voltage signal output from LM3900 op-amp H5_4. Each oscillator is a + // cascaded pair of LM3900s with a CD4016 switch. The switch feeds + // into the reference input of the first op-amp, whose output is also + // the final oscillator output; the second op-amp acts as a Schmitt + // trigger on the first op-amp's output, generating a square wave that + // controls the switch and determines whether the triangle wave is + // rising or falling. + + // The two lower-frequency oscillators are summed together. One has + // four times the frequency of the other, producing a "ragged" + // triangle wave. The combined signal is fed into the signal input of + // the MC3340 voltage-controlled amplifier/attenuator. The third, + // highest-frequency oscillator drives the MC3340's control input, + // amplitude-modulating the signal input from the first two + // oscillators. Greater voltages on this control signal produce + // greater attenuation in a logarithmic fashion. The final output + // signal from the MC3340 thus has a waveform of narrow needle-like + // spikes which grow taller and shorter according to the original + // input waveform. + + // The Schmitt triggers in these oscillator circuits are numerically + // unstable at the switching points, which makes numeric convergence + // difficult. The standard way to guarantee convergence with such a + // circuit is to use dynamic timestepping with very short minimum + // timesteps. In this case that solution is unacceptably slow, so an + // alternate solution is used instead. To remove the unstable behavior + // of the Schmitt triggers in the solver, a "frontier" is inserted at + // the output of each Schmitt trigger op-amp. With this, a change in + // the op-amp's output level, caused by a change in its inputs, will + // not affect either its feedback input or the CD4016 switch during + // the same timestep. Instead, it will only take effect when computing + // the following timestep. This greatly improves the stability and + // performance of the solver while only slightly altering the + // frequency and voltage levels of the oscillator's triangle-wave + // output. These waveform changes are compensated for by slightly + // adjusting the value of the resistors which determine the Schmitt + // trigger's switch points, bringing the waveform very close to what + // it would be if the standard approach of dynamic timestepping were + // used instead. + + // These are the remaining connections from H5_4.OUT: + NET_C(H5_4.OUT, R36.1, R37.1, R31.1, R32.1, R29.1, R30.1) + + CD4016_DIP(J4) + + // First oscillator (bottommost in schematics). + // Schematic shows frequency of "76 Hz", but when modeled without a + // frontier, the maximum in low gear is 87 Hz. + // With a frontier, uncompensated, this decreases to 86 Hz. + + LM3900(J5_2) + LM3900(J5_1) + + RES(R36, RES_K(560)) + RES(R37, RES_K(270)) + RES(R38, RES_K(100)) + RES(R41, RES_K(10)) + NET_C(R41.2, GND) + +#if CONVERGENCE_FRONTIERS + // Schmitt trigger resistors changed to compensate for waveform changes + // from use of frontier: + RES(R39, RES_K(465.0)) + RES(R40, RES_K(275.0)) +#else + RES(R39, RES_K(470)) + RES(R40, RES_K(270)) +#endif + + CAP(C17, CAP_U(0.022)) + + DIODE(D3, 1N914) + + // Note the connections to this oscillator's CD4016 switch at J4 have + // mislabeled pin numbers on the schematics for 280-ZZZAP and both + // Laguna Racer versions; they are shown as pins 3, 4, 5, which are + // for switch B, the same switch which is used by the middle + // oscillator. The Super Speed Race schematic correctly shows this + // oscillator using pins 10, 11, 12, which are for switch D of the + // CD4016 (located at B1 in that game). It seems very unlikely that + // the earlier games had two oscillators sharing the same switch; that + // shouldn't work at all. I assume that this was a schematic error + // which was not corrected until much later. + + NET_C(R37.2, J4.10) + NET_C(J4.11, J5_2.PLUS) + NET_C(R36.2, J5_2.MINUS, C17.1) + NET_C(J5_2.OUT, C17.2, R38.1, D3.A) + NET_C(R38.2, J5_1.MINUS) + NET_C(J5_1.OUT, R40.1, J4.12) + NET_C(I_V5.Q, R39.1) + NET_C(J5_1.PLUS, R39.2, R40.2) + NET_C(R41.1, D3.K, D2.K, C16.1) + + // Second oscillator (middle in schematics). + // Schematic shows frequency of "315 Hz", but when modeled without a + // frontier, the maximum in low gear is 343 Hz. + // With a frontier, uncompensated, this decreases to 329 Hz. + + LM3900(J3_3) + LM3900(J3_4) + + RES(R31, RES_K(300)) + RES(R32, RES_K(150)) + RES(R33, RES_K(100)) + +#if CONVERGENCE_FRONTIERS + // Schmitt trigger resistors changed to compensate for waveform changes + // from use of frontier: + RES(R34, RES_K(460)) + RES(R35, RES_K(281)) +#else + RES(R34, RES_K(470)) + RES(R35, RES_K(270)) +#endif + + CAP(C15, CAP_U(0.01)) + + CAP(C16, CAP_U(10)) + + DIODE(D2, 1N914) + + NET_C(R32.2, J4.4) + NET_C(J4.3, J3_3.PLUS) + NET_C(R31.2, J3_3.MINUS, C15.1) + NET_C(J3_3.OUT, C15.2, R33.1, D2.A) + NET_C(R33.2, J3_4.MINUS) + NET_C(J3_4.OUT, R35.1, J4.5) + NET_C(I_V5.Q, R34.1) + NET_C(J3_4.PLUS, R34.2, R35.2) + NET_C(C16.2, MC3340_INPUT) // to MC3340 H2 pin 1 + + // Third oscillator (topmost in schematics). + // This is the amplitude-modulation oscillator. + // Schematic shows frequency of "428 Hz", but when modeled without a + // frontier, the maximum in low gear is 465 Hz. + // With a frontier, uncompensated, this decreases to 442 Hz. + + LM3900(J3_2) + LM3900(J3_1) + + RES(R29, RES_K(220)) + RES(R30, RES_K(110)) // 100 Kohm in later Laguna and Super Speed Race + RES(R28, RES_K(100)) + +#if CONVERGENCE_FRONTIERS + // Schmitt trigger resistors changed to compensate for waveform changes + // from use of frontier: + RES(R26, RES_K(455)) + RES(R27, RES_K(284)) +#else + RES(R26, RES_K(470)) + RES(R27, RES_K(270)) +#endif + + CAP(C14, CAP_U(0.01)) + + RES(R23, RES_K(10)) + NET_C(R23.1, I_V12.Q) + + RES(R25, RES_K(3.3)) + NET_C(R25.2, GND) + + CAP(C13, CAP_U(10)) + + RES(R22, RES_R(470)) + + DIODE(D1, 1N914) + + NET_C(I_V5.Q, R22.1) + NET_C(ENGINE_SOUND_OFF, R22.2, D1.A) + + NET_C(R30.2, J4.1) + NET_C(J4.2, J3_2.PLUS) + NET_C(R29.2, J3_2.MINUS, C14.1) + NET_C(J3_2.OUT, C14.2, R28.1, C13.1) + NET_C(R28.2, J3_1.MINUS) + NET_C(J3_1.OUT, R27.1, J4.13) + NET_C(I_V5.Q, R26.1) + NET_C(J3_1.PLUS, R26.2, R27.2) + NET_C(D1.K, R23.2, C13.2, R25.1, MC3340_CONTROL) // to MC3340 H2 pin 2 + + // The MC3340's output is the complete engine sound, which is sent to + // the final mix. + + + // **** Noise generation and noise-based sound effects: tire skid + // **** (NOISE_CR_1), boom from crash (BOOM), post-crash noise + // **** (NOISE_CR_2). + + // The noise generator circuit for 280-ZZZAP and Laguna Racer is based + // on a reverse-biased 9.1-volt 1N5239 Zener diode which generates a + // noisy current for an LM3900 Norton op-amp input. The op-amp then + // amplifies the noise in that current to generate more intense noise + // for the other circuits. + + // The netlist library supports Zener diodes, but not their noise + // behavior, so I simulate it with an additional source of noise + // voltage, inserted in series between the Zener and the op-amp input. + + // Super Speed Race generates its noise in a different fashion, using + // a linear-feedback shift register on the main motherboard. However, + // it processes the noise signal through similar sound effect + // circuits. + + // Since the noise generator discrete components are unlabeled on the + // 280-ZZZAP and Laguna Racer schematics and are not present in Super + // Speed Race, I've chosen my own labels for them. + + // Simple model of a 1N5239 9.1-volt Zener diode; according to + // datasheets, this diode conducts 20 mA of current at 9.1 V reverse + // bias. The amount of noise produced by the generator turns out to + // depend on NBV, as does the mean voltage. I choose NBV=1 to maximize + // the noise and reduce the mean voltage offset. + ZDIODE(ZD_1N5239, "D(BV=9.1 IBV=0.020 NBV=1)") + + // 24 kHz noise clock for the noise source, chosen to retain noise + // frequencies as high as possible for 48 kHz sample rate. + CLOCK(NCLK, 24000) + NET_C(I_V5.Q, NCLK.VCC) + NET_C(GND, NCLK.GND) + + // Normally-distributed noise of 10 microvolts RMS voltage. + // With the Zener above using NBV=1, this seems to be good enough. + // Increasing it further begins to distort the NOISE_CR_2 post-crash + // noise while not adding much volume to the NOISE_CR_1 skid noise. + SYS_NOISE_MT_N(NOISE, 10e-6) + + NET_C(NCLK.Q, NOISE.I) + + RES(RNOISE0, RES_K(100)) + CAP(CNOISE0, CAP_U(10)) + NET_C(CNOISE0.2, GND) + + NET_C(I_V12.Q, RNOISE0.1) + NET_C(RNOISE0.2, CNOISE0.1, ZD_1N5239.K) + + LM3900(H4_2) + + RES(RNOISE1, RES_K(56)) + RES(RNOISE2, RES_K(47)) + RES(RNOISE3, RES_K(1)) + + CAP(CNOISE, CAP_U(10)) + + NET_C(CNOISE.1, RNOISE1.1, RNOISE2.1) + NET_C(CNOISE.2, GND) + NET_C(H4_2.MINUS, RNOISE1.2) + NET_C(ZD_1N5239.A, NOISE.1) + NET_C(H4_2.PLUS, NOISE.2) + NET_C(H4_2.OUT, RNOISE2.2, RNOISE3.1, C1.1) + NET_C(RNOISE3.2, GND) + + // In Super Speed Race, which lacks the noise generator described + // above, the noise signal enters at the upstream end of capacitor C1. + + CAP(C1, CAP_U(10)) + + NET_C(C1.2, R1.1) + + // The noise generator is followed by a single-amplifier active + // low-pass filter with a corner frequency of about 6.3 kHz, a very + // broad Q of 0.014, and a gain of about 0.8. This filter basically + // attenuates the highest noise frequencies. + + RES(R1, RES_K(330)) // 680 Kohm in Super Speed Race + + LM3900(H4_1) + + CAP(C2, CAP_P(6800)) + RES(R2, RES_K(10)) + RES(R3, RES_K(820)) + RES(R4, RES_K(270)) + CAP(C3, CAP_P(220)) + + NET_C(R1.2, C2.1, R2.1, R4.1) + NET_C(C2.2, GND) + NET_C(H4_1.MINUS, R2.2, C3.1) + NET_C(I_V5.Q, R3.1) + NET_C(H4_1.PLUS, R3.2) + NET_C(H4_1.OUT, C3.2, R4.2, R5.1, R17.1, C5.1, C4.1) + + // The low-pass-filtered noise is passed to three different + // sound-effect circuits, each of which is also an active-filter type. + + // First noise circuit: tire skid (NOISE_CR_1) + + // This is a two-amplifier active bandpass filter with a center + // frequency of about 1 kHz and a high Q value of 25, giving a + // narrow bandwidth of 40 Hz. The gain is about 15. + + // The result is a high-pitched "tire skid" screeching sound. + + // The circuit appears to be taken almost verbatim from page 19 of + // National Semiconductor's Application Note 72 about the LM3900, with + // only minor changes in the values of a few components to alter the + // DC bias. + + CD4016_DIP(G4) + + LM3900(H4_3) + + RES(R5, RES_K(39)) + RES(R6, RES_R(62)) + RES(R7, RES_K(82)) + RES(R8, RES_K(39)) + + CAP(C7, CAP_U(0.1)) + CAP(C8, CAP_U(0.1)) + + NET_C(R5.2, R6.1, C7.1, C8.1, R12.1) + NET_C(R6.2, GND) + NET_C(H4_3.MINUS, C7.2, R8.1) + NET_C(I_V5.Q, R7.1) + NET_C(H4_3.PLUS, R7.2) + NET_C(H4_3.OUT, R8.2, C8.2, R9.1) + + // Super Speed Race has an extra CD4016 switch (controlled by the same + // NOISE_CR_1 control line as the one at the end of this circuit) and + // a 0.1 uF capacitor between H4_3.OUT and R9.1 here. + + LM3900(H4_4) + + RES(R9, RES_K(39)) + RES(R10, RES_K(62)) // 240 Kohm in Super Speed Race + RES(R11, RES_K(100)) // 120 Kohm in later Laguna and Super Speed Race + RES(R12, RES_K(62)) + + NET_C(H4_4.MINUS, R9.2, R11.1) + NET_C(I_V5.Q, R10.1) + NET_C(H4_4.PLUS, R10.2) + NET_C(H4_4.OUT, R11.2, R12.2, G4.4) + NET_C(G4.3, R63.1) + NET_C(G4.5, NOISE_CR_1) + + // Second noise circuit: post-crash noise (NOISE_CR_2) + + // This circuit is peculiar. It's structured like a single-amplifier + // active low-pass filter, with a corner frequency of about 1 kHz and + // a gain of 100--but its Q factor turns out to be a small *negative* + // number. (I'm not sure what effect this has on a filter, but it + // might indicate instability.) + + // The result is saturated, clipped noise, a bit like randomized + // square waves, with frequencies mainly below 1 kHz. + + // I don't know why the circuit was designed this way, or whether it + // was deliberate or a design or production error which the makers + // decided they liked or at least could accept. It doesn't look like + // they fixed it later; this same circuit is unchanged in the + // schematics for all three games. + + RES(R17, RES_K(10)) + + CAP(C5, CAP_U(10)) + CAP(C4, CAP_U(0.022)) + + LM3900(H5_2) + + RES(R16, RES_K(1.5)) + RES(R15, RES_K(15)) + RES(R14, RES_M(2.7)) + RES(R13, RES_K(150)) + + CAP(C6, CAP_U(0.01)) + CAP(C9, CAP_U(0.001)) + + NET_C(C4.2, R16.1) + NET_C(R16.2, C6.1, R15.1, R13.1) + NET_C(C6.2, GND) + NET_C(H5_2.MINUS, R15.2, C9.1) + NET_C(I_V5.Q, R14.1) + NET_C(H5_2.PLUS, R14.2) + NET_C(H5_2.OUT, C9.2, R13.2, G4.8) + NET_C(G4.9, R64.1) + NET_C(G4.6, NOISE_CR_2) + + // Third noise circuit: boom from crash (BOOM) + + // This is a single-amplifier active bandpass filter with a center + // frequency of about 60 Hz and a high Q value of about 19, giving a + // narrow 3 Hz bandwidth. The gain is also very high, a little over + // 200. + + // The filter is normally cut off from the noise signal, and thus it + // remains quiet. When the BOOM signal is activated, CD4016 switch + // G4_A opens, letting in the noise to be filtered and amplified until + // the switch is cut off again, generating a loud sort of "boom". + // (The sound doesn't have much decay, though; it gets cut abruptly.) + + LM3900(H5_1) + + // On the 280-ZZZAP game logic board schematic, resistor R18 (which is + // not labeled as such) is a 2.2K resistor, but it has a note "E" + // stating that one of the changes made after the first 325 units was: + // "2.2K resistor at G4 pin 2 was 6.8K." I interpret this to mean that + // the resistor was lowered to 2.2K from 6.8K. + RES(R18, RES_K(2.2)) // 20 Kohm in Super Speed Race + RES(R19, RES_K(1)) + RES(R20, RES_M(3.3)) + RES(R21, RES_M(1)) // 1.5 Mohm in Super Speed Race + + CAP(C10, CAP_U(0.1)) + CAP(C11, CAP_U(0.1)) + + NET_C(R17.2, C5.2, G4.1) + NET_C(G4.2, R18.1) + NET_C(G4.13, BOOM) + NET_C(R18.2, R19.1, C10.1, C11.1) + NET_C(R19.2, GND) + NET_C(H5_1.MINUS, C10.2, R21.1) + NET_C(I_V5.Q, R20.1) + NET_C(H5_1.PLUS, R20.2) + NET_C(H5_1.OUT, R21.2, C11.2, R65.1) + + + // **** Final mix of sound effects and sound preamplification. + + // The preamplification stage after the final mix has two LM3900 + // op-amps, only one of which is modeled here. This is because of the + // way the speaker is driven. The power amplification that drives the + // speaker is done by a National Semiconductor LM377 dual audio power + // amplifier chip, with the chip's two amplifiers wired in a so-called + // "bridge configuration" to drive the speaker's positive and negative + // terminals in a push-pull fashion. This effectively converts the + // dual power amp into a single amp of twice the power. + + // The preamplified input signals for these power amps are generated + // from the final mix by the two LM3900s, each driving one power amp. + // The first LM3900, J5_3, also preamplifies the final mix signal, + // sending its output to the first power amp. The second LM3900, J5_4, + // simply inverts J5_3's output so it can drive the second power amp + // in opposing fashion. Since the second LM3900 doesn't otherwise + // alter the output signal, and we don't care about power + // amplification, this op-amp and its associated circuitry can be + // omitted. + + RES(R63, RES_K(12)) // 3 Kohm in Super Speed Race + RES(R64, RES_K(150)) + // On the 280-ZZZAP game logic board schematic, resistor R65 (which is + // not labeled as such) is a 12K resistor, but it has a note "F" + // stating that one of the changes made after the first 325 units was: + // "12K resistor in series with 10MF cap and J5 pin 8 was 4.3K." I + // interpret this to mean that the resistor was raised to 12K from + // 4.3K. + RES(R65, RES_K(12)) + RES(R66, RES_K(33)) + + CAP(C20, CAP_U(10)) + CAP(C21, CAP_U(10)) + + NET_C(R63.2, R64.2, R65.2, C20.1) + NET_C(MC3340_OUTPUT, R66.1) + NET_C(R66.2, C21.1) + + LM3900(J5_3) + + RES(R67, RES_K(2)) + CAP(C22, CAP_U(10)) + RES(R68, RES_K(220)) + + NET_C(I_V5.Q, R67.1) + NET_C(R67.2, C22.1, R68.1) + NET_C(C22.2, GND) + NET_C(J5_3.PLUS, R68.2) + + RES(R69, RES_K(100)) + RES(R70, RES_K(10)) // actually a potentiometer, at max. volume + CAP(C23, CAP_U(10)) + + NET_C(R70.2, C23.2) + NET_C(J5_3.MINUS, C20.2, C21.2, R69.1, R70.1) + NET_C(J5_3.OUT, C23.1, R69.2) + + ALIAS(OUTPUT, J5_3.OUT) + +NETLIST_END() + + +NETLIST_START(280zzzap) + + SOLVER(Solver, 48000) + + // All together, loosening both tolerances and reducing accuracy + // increases speed by ~10%, but it also causes audible "crackling". +// PARAM(Solver.RELTOL, 1e-2) // default 1e-3 (several % faster, but < quality) +// PARAM(Solver.VNTOL, 5e-3) // default 1e-7 (several % faster, but < quality) +// PARAM(Solver.ACCURACY, 1e-3) // default 1e-7 (few % faster) + +// PARAM(Solver.DYNAMIC_TS, 1) +// PARAM(Solver.DYNAMIC_LTE, 1e-4) // default 1e-5 +// PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 1e-8) // default 1e-6 + + ANALOG_INPUT(I_V12, 12) + ANALOG_INPUT(I_V5, 5) + + LOCAL_SOURCE(mc3340) + INCLUDE(mc3340) + + // The MC3340 gets 12-volt power in 280-ZZZAP and Laguna Racer. + // In Super Speed Race it gets 5-volt power. + NET_C(I_V12.Q, MC3340_VCC) + + LOCAL_SOURCE(280zzzap_schematics) + INCLUDE(280zzzap_schematics) + + // Logic inputs which represent output pins from 74174 latches at F4 + // and F5 + LOGIC_INPUT(I_F4_2, 0, "74XX") // BOOM + LOGIC_INPUT(I_F4_5, 0, "74XX") // labeled "ENGINE SOUND", but really + // an "engine sound off" flag + LOGIC_INPUT(I_F4_7, 0, "74XX") // NOISE CR 1 + LOGIC_INPUT(I_F4_10, 0, "74XX") // NOISE CR 2 + LOGIC_INPUT(I_F5_2, 0, "74XX") // PEDAL_BIT0 + LOGIC_INPUT(I_F5_5, 0, "74XX") // PEDAL_BIT1 + LOGIC_INPUT(I_F5_7, 0, "74XX") // PEDAL_BIT2 + LOGIC_INPUT(I_F5_10, 0, "74XX") // PEDAL_BIT3 + LOGIC_INPUT(I_F5_12, 0, "74XX") // HI SHIFT + LOGIC_INPUT(I_F5_15, 0, "74XX") // LO SHIFT + + ALIAS(I_BOOM, I_F4_2.IN) + ALIAS(I_ENGINE_SOUND_OFF, I_F4_5.IN) + ALIAS(I_NOISE_CR_1, I_F4_7.IN) + ALIAS(I_NOISE_CR_2, I_F4_10.IN) + ALIAS(I_PEDAL_BIT0, I_F5_2.IN) + ALIAS(I_PEDAL_BIT1, I_F5_5.IN) + ALIAS(I_PEDAL_BIT2, I_F5_7.IN) + ALIAS(I_PEDAL_BIT3, I_F5_10.IN) + ALIAS(I_HI_SHIFT, I_F5_12.IN) + ALIAS(I_LO_SHIFT, I_F5_15.IN) + + ALIAS(BOOM, I_F4_2.Q) + ALIAS(ENGINE_SOUND_OFF, I_F4_5.Q) + ALIAS(NOISE_CR_1, I_F4_7.Q) + ALIAS(NOISE_CR_2, I_F4_10.Q) + ALIAS(PEDAL_BIT0, I_F5_2.Q) + ALIAS(PEDAL_BIT1, I_F5_5.Q) + ALIAS(PEDAL_BIT2, I_F5_7.Q) + ALIAS(PEDAL_BIT3, I_F5_10.Q) + ALIAS(HI_SHIFT, I_F5_12.Q) + ALIAS(LO_SHIFT, I_F5_15.Q) + + // Power pins for logic inputs: + NET_C(I_V5.Q, + I_F4_2.VCC, I_F4_5.VCC, I_F4_7.VCC, I_F4_10.VCC, + I_F5_2.VCC, I_F5_5.VCC, I_F5_7.VCC, I_F5_10.VCC, + I_F5_12.VCC, I_F5_15.VCC) + NET_C(GND, + I_F4_2.GND, I_F4_5.GND, I_F4_7.GND, I_F4_10.GND, + I_F5_2.GND, I_F5_5.GND, I_F5_7.GND, I_F5_10.GND, + I_F5_12.GND, I_F5_15.GND) + + // Power inputs for the LM3900 op-amps. These aren't shown on the + // schematics, but it looks like 5-volt power is needed to get proper + // results. + NET_C(I_V5.Q, + H4_1.VCC, H4_2.VCC, H4_3.VCC, H4_4.VCC, + H5_1.VCC, H5_2.VCC, H5_3.VCC, H5_4.VCC, + J3_1.VCC, J3_2.VCC, J3_3.VCC, J3_4.VCC, + J5_1.VCC, J5_2.VCC, J5_3.VCC) + NET_C(GND, + H4_1.GND, H4_2.GND, H4_3.GND, H4_4.GND, + H5_1.GND, H5_2.GND, H5_3.GND, H5_4.GND, + J3_1.GND, J3_2.GND, J3_3.GND, J3_4.GND, + J5_1.GND, J5_2.GND, J5_3.GND) + + // Power inputs for the CD4016 switches. Again, these aren't shown on + // the schematics, but 5-volt power must be used for the switches to + // handle the voltage levels they are switching. + NET_C(I_V5.Q, G5.14, J4.14, G4.14) + NET_C(GND, G5.7, J4.7, G4.7) + // Switches G5_D, J4_C, and G4_D are unused. + NET_C(GND, G5.10, G5.11, G5.12, J4.6, J4.8, J4.9, G4.10, G4.11, G4.12) + + // Frontier after output of noise generator. + // This makes a speed boost of ~10%. + OPTIMIZE_FRONTIER(C1.1, RES_M(1), 50) + + // Frontier before skid screech generator. + // This makes a speed boost of ~8%. + OPTIMIZE_FRONTIER(R5.1, RES_K(39), 50) + // (Adding a frontier *after* the skid screech generator makes the + // sudden jumps in signal level on skids much larger, so the resulting + // clicks are louder and more objectionable. Also it does little or + // nothing for speed. That's why I don't have such a frontier.) + + // Frontiers after NOISE CR 2 and BOOM generators. + // Each of these boosts speed by several percent and reduces + // NEWTON_LOOPS warnings. + OPTIMIZE_FRONTIER(R64.1, RES_K(150), 50) + OPTIMIZE_FRONTIER(R65.1, RES_K(12), 50) + + // Frontier after engine sound generation. + // This makes a speed boost of ~5%. + OPTIMIZE_FRONTIER(R66.1, RES_K(33), 50) + + // Frontiers before MC3340 inputs. + // Together, these make a speed boost of ~15%. + OPTIMIZE_FRONTIER(C16.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(C13.1, RES_M(1), 50) + + // Frontiers before engine sound op-amp oscillators. + // All together, these make a speed boost of ~12%. + OPTIMIZE_FRONTIER(R36.1, RES_K(560), 50) + OPTIMIZE_FRONTIER(R37.1, RES_K(270), 50) + OPTIMIZE_FRONTIER(R31.1, RES_K(300), 50) + OPTIMIZE_FRONTIER(R32.1, RES_K(150), 50) + OPTIMIZE_FRONTIER(R29.1, RES_K(220), 50) + OPTIMIZE_FRONTIER(R30.1, RES_K(110), 50) + +#if CONVERGENCE_FRONTIERS + // Frontiers at Schmitt trigger op-amp outputs of engine sound + // oscillators, to eliminate numeric instability and speed convergence + // rather than to partition matrices. The resistor values given are + // the modified ones which compensate for how the frontiers would + // otherwise change the oscillator waveforms. + OPTIMIZE_FRONTIER(R40.1, RES_K(275), 50) + OPTIMIZE_FRONTIER(R35.1, RES_K(281), 50) + OPTIMIZE_FRONTIER(R27.1, RES_K(284), 50) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_280zzzap.h b/src/mame/audio/nl_280zzzap.h new file mode 100644 index 00000000000..81611a64411 --- /dev/null +++ b/src/mame/audio/nl_280zzzap.h @@ -0,0 +1,12 @@ +// license:CC0 +// copyright-holders:Colin Douglas Howell +#ifndef MAME_AUDIO_NL_280ZZZAP_H +#define MAME_AUDIO_NL_280ZZZAP_H + +#pragma once + +#include "netlist/nl_setup.h" + +NETLIST_EXTERNAL(280zzzap) + +#endif // MAME_AUDIO_NL_280ZZZAP_H diff --git a/src/mame/drivers/mw8080bw.cpp b/src/mame/drivers/mw8080bw.cpp index 583eb5b9f77..fdc484f8836 100644 --- a/src/mame/drivers/mw8080bw.cpp +++ b/src/mame/drivers/mw8080bw.cpp @@ -739,7 +739,7 @@ void mw8080bw_state::tornbase(machine_config &config) * *************************************/ -void mw8080bw_state::zzzap_io_map(address_map &map) +void zzzap_state::io_map(address_map &map) { map.global_mask(0x7); map(0x00, 0x00).mirror(0x04).portr("IN0"); @@ -747,10 +747,10 @@ void mw8080bw_state::zzzap_io_map(address_map &map) map(0x02, 0x02).mirror(0x04).portr("IN2"); map(0x03, 0x03).mirror(0x04).r(m_mb14241, FUNC(mb14241_device::shift_result_r)); - map(0x02, 0x02).w(FUNC(mw8080bw_state::zzzap_audio_1_w)); + map(0x02, 0x02).w("soundboard", FUNC(zzzap_audio_device::p1_w)); map(0x03, 0x03).w(m_mb14241, FUNC(mb14241_device::shift_data_w)); map(0x04, 0x04).w(m_mb14241, FUNC(mb14241_device::shift_count_w)); - map(0x05, 0x05).w(FUNC(mw8080bw_state::zzzap_audio_2_w)); + map(0x05, 0x05).w("soundboard", FUNC(zzzap_audio_device::p2_w)); map(0x07, 0x07).w(m_watchdog, FUNC(watchdog_timer_device::reset_w)); } @@ -824,12 +824,12 @@ static INPUT_PORTS_START( lagunar ) INPUT_PORTS_END -void mw8080bw_state::zzzap(machine_config &config) +void zzzap_state::zzzap(machine_config &config) { mw8080bw_root(config); /* basic machine hardware */ - m_maincpu->set_addrmap(AS_IO, &mw8080bw_state::zzzap_io_map); + m_maincpu->set_addrmap(AS_IO, &zzzap_state::io_map); WATCHDOG_TIMER(config, m_watchdog).set_time(PERIOD_OF_555_MONOSTABLE(RES_M(1), CAP_U(1))); /* 1.1s */ @@ -837,7 +837,7 @@ void mw8080bw_state::zzzap(machine_config &config) MB14241(config, m_mb14241); /* audio hardware */ - /* zzzap_audio(config); */ + ZZZAP_AUDIO(config, "soundboard"); } @@ -3094,14 +3094,14 @@ ROM_END /* 597 */ GAMEL( 1975, gunfighto, gunfight, gunfight, gunfight, gunfight_state, empty_init, ROT0, "Dave Nutting Associates / Midway", "Gun Fight (set 2)", MACHINE_SUPPORTS_SAVE, layout_gunfight ) /* 604 Gun Fight (cocktail, dump does not exist) */ /* 605 */ GAME( 1976, tornbase, 0, tornbase, tornbase, mw8080bw_state, empty_init, ROT0, "Dave Nutting Associates / Midway / Taito", "Tornado Baseball / Ball Park", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -/* 610 */ GAMEL( 1976, 280zzzap, 0, zzzap, zzzap, mw8080bw_state, empty_init, ROT0, "Dave Nutting Associates / Midway", "280-ZZZAP", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE, layout_280zzzap ) +/* 610 */ GAMEL( 1976, 280zzzap, 0, zzzap, zzzap, zzzap_state, empty_init, ROT0, "Dave Nutting Associates / Midway", "280-ZZZAP", MACHINE_SUPPORTS_SAVE, layout_280zzzap ) /* 611 */ GAMEL( 1976, maze, 0, maze, maze, mw8080bw_state, empty_init, ROT0, "Midway", "Amazing Maze", MACHINE_SUPPORTS_SAVE, layout_maze ) /* 612 */ GAME( 1977, boothill, 0, boothill, boothill, boothill_state, empty_init, ROT0, "Dave Nutting Associates / Midway", "Boot Hill", MACHINE_SUPPORTS_SAVE ) /* 615 */ GAME( 1977, checkmat, 0, checkmat, checkmat, mw8080bw_state, empty_init, ROT0, "Dave Nutting Associates / Midway", "Checkmate", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) /* 618 */ GAME( 1977, desertgu, 0, desertgu, desertgu, desertgu_state, empty_init, ROT0, "Dave Nutting Associates / Midway", "Desert Gun", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) /* 618 */ GAME( 1977, roadrunm, desertgu, desertgu, desertgu, desertgu_state, empty_init, ROT0, "Midway", "Road Runner (Midway)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) /* 619 */ GAME( 1977, dplay, 0, dplay, dplay, dplay_state, empty_init, ROT0, "Midway", "Double Play", MACHINE_SUPPORTS_SAVE ) -/* 622 */ GAMEL( 1977, lagunar, 0, zzzap, lagunar, mw8080bw_state, empty_init, ROT90, "Midway", "Laguna Racer", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE, layout_lagunar ) +/* 622 */ GAMEL( 1977, lagunar, 0, zzzap, lagunar, zzzap_state, empty_init, ROT90, "Midway", "Laguna Racer", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE, layout_lagunar ) /* 623 */ GAME( 1977, gmissile, 0, gmissile, gmissile, boothill_state, empty_init, ROT0, "Midway", "Guided Missile", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) /* 626 */ GAME( 1977, m4, 0, m4, m4, boothill_state, empty_init, ROT0, "Midway", "M-4", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) /* 630 */ GAMEL( 1978, clowns, 0, clowns, clowns, clowns_state, empty_init, ROT0, "Midway", "Clowns (rev. 2)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_clowns ) diff --git a/src/mame/includes/mw8080bw.h b/src/mame/includes/mw8080bw.h index c6d71f089cf..27b99e96cc0 100644 --- a/src/mame/includes/mw8080bw.h +++ b/src/mame/includes/mw8080bw.h @@ -65,7 +65,6 @@ public: void phantom2(machine_config &config); void shuffle(machine_config &config); void tornbase(machine_config &config); - void zzzap(machine_config &config); DECLARE_INPUT_CHANGED_MEMBER(direct_coin_count); @@ -125,8 +124,6 @@ private: DECLARE_READ8_MEMBER(bowler_shift_result_r); DECLARE_WRITE8_MEMBER(bowler_lights_1_w); DECLARE_WRITE8_MEMBER(bowler_lights_2_w); - DECLARE_WRITE8_MEMBER(zzzap_audio_1_w); - DECLARE_WRITE8_MEMBER(zzzap_audio_2_w); DECLARE_WRITE8_MEMBER(bowler_audio_2_w); DECLARE_WRITE8_MEMBER(bowler_audio_3_w); DECLARE_WRITE8_MEMBER(bowler_audio_4_w); @@ -159,7 +156,6 @@ private: void maze_audio(machine_config &config); void shuffle_audio(machine_config &config); void tornbase_audio(machine_config &config); - void zzzap_audio(machine_config &config); void blueshrk_io_map(address_map &map); void bowler_io_map(address_map &map); @@ -172,7 +168,6 @@ private: void phantom2_io_map(address_map &map); void shuffle_io_map(address_map &map); void tornbase_io_map(address_map &map); - void zzzap_io_map(address_map &map); }; @@ -380,6 +375,26 @@ private: }; +class zzzap_state : public mw8080bw_state +{ +public: + zzzap_state(machine_config const &mconfig, device_type type, char const *tag) : + mw8080bw_state(mconfig, type, tag), + m_soundboard(*this, "soundboard") + { + } + + void zzzap(machine_config &config); + +private: + void io_w(offs_t offset, u8 data); + + void io_map(address_map &map); + + required_device m_soundboard; +}; + + #define TORNBASE_CAB_TYPE_UPRIGHT_OLD (0) #define TORNBASE_CAB_TYPE_UPRIGHT_NEW (1) #define TORNBASE_CAB_TYPE_COCKTAIL (2) diff --git a/src/mame/nl.lst b/src/mame/nl.lst index be1d3cefd0c..68cdb66a8e2 100644 --- a/src/mame/nl.lst +++ b/src/mame/nl.lst @@ -278,6 +278,7 @@ masao // bootleg @source:mw8080bw.cpp gunfight // 597 [1975] Dave Nutting Associates / Midway gunfighto // 597 [1975] Dave Nutting Associates / Midway +280zzzap // 610 [1976] Dave Nutting Associates / Midway @source:palestra.cpp palestra