From add6f68bec643ac82a43504cabc21f1c384f6c48 Mon Sep 17 00:00:00 2001 From: Ryan Holtz Date: Tue, 11 Aug 2020 19:48:30 +0200 Subject: -destroyr: Added netlist sound. [Ryan Holtz] --- scripts/target/mame/arcade.lua | 2 + scripts/target/mame/nl.lua | 4 + src/lib/netlist/generated/static_solvers.cpp | 2495 ++++++++++++++++++++++++++ src/mame/audio/nl_destroyr.cpp | 316 ++++ src/mame/audio/nl_destroyr.h | 10 + src/mame/drivers/destroyr.cpp | 164 +- 6 files changed, 2925 insertions(+), 66 deletions(-) create mode 100644 src/mame/audio/nl_destroyr.cpp create mode 100644 src/mame/audio/nl_destroyr.h diff --git a/scripts/target/mame/arcade.lua b/scripts/target/mame/arcade.lua index e268cb4cbd3..0dbf379b2b4 100644 --- a/scripts/target/mame/arcade.lua +++ b/scripts/target/mame/arcade.lua @@ -1200,6 +1200,8 @@ files { MAME_DIR .. "src/mame/drivers/cybstorm.cpp", MAME_DIR .. "src/mame/includes/cybstorm.h", MAME_DIR .. "src/mame/video/cybstorm.cpp", + MAME_DIR .. "src/mame/audio/nl_destroyr.cpp", + MAME_DIR .. "src/mame/audio/nl_destroyr.h", MAME_DIR .. "src/mame/drivers/destroyr.cpp", MAME_DIR .. "src/mame/drivers/dragrace.cpp", MAME_DIR .. "src/mame/includes/dragrace.h", diff --git a/scripts/target/mame/nl.lua b/scripts/target/mame/nl.lua index d8dc91c8531..4ecd9ef4b85 100644 --- a/scripts/target/mame/nl.lua +++ b/scripts/target/mame/nl.lua @@ -161,6 +161,10 @@ files{ MAME_DIR .. "src/mame/audio/nl_flyball.h", MAME_DIR .. "src/mame/drivers/flyball.cpp", + MAME_DIR .. "src/mame/audio/nl_destroyr.cpp", + MAME_DIR .. "src/mame/audio/nl_destroyr.h", + MAME_DIR .. "src/mame/drivers/destroyr.cpp", + MAME_DIR .. "src/mame/drivers/hazeltin.cpp", MAME_DIR .. "src/mame/drivers/1942.cpp", diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp index aeb9cb286e9..b69e9d12409 100644 --- a/src/lib/netlist/generated/static_solvers.cpp +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -20050,6 +20050,2499 @@ static void nl_gcr_80b4b1e5cc58d303_29_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// destroyr +static void nl_gcr_8393a20a3ce0e3fa_399_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) + +{ + + plib::unused_var(cnV); + double m_A0(0.0); + double m_A1(0.0); + double m_A2(0.0); + double m_A3(0.0); + double m_A4(0.0); + double m_A5(0.0); + double m_A6(0.0); + double m_A7(0.0); + double m_A8(0.0); + double m_A9(0.0); + double m_A10(0.0); + double m_A11(0.0); + double m_A12(0.0); + double m_A13(0.0); + double m_A14(0.0); + double m_A15(0.0); + double m_A16(0.0); + double m_A17(0.0); + double m_A18(0.0); + double m_A19(0.0); + double m_A20(0.0); + double m_A21(0.0); + double m_A22(0.0); + double m_A23(0.0); + double m_A24(0.0); + double m_A25(0.0); + double m_A26(0.0); + double m_A27(0.0); + double m_A28(0.0); + double m_A29(0.0); + double m_A30(0.0); + double m_A31(0.0); + double m_A32(0.0); + double m_A33(0.0); + double m_A34(0.0); + double m_A35(0.0); + double m_A36(0.0); + double m_A37(0.0); + double m_A38(0.0); + double m_A39(0.0); + double m_A40(0.0); + double m_A41(0.0); + double m_A42(0.0); + double m_A43(0.0); + double m_A44(0.0); + double m_A45(0.0); + double m_A46(0.0); + double m_A47(0.0); + double m_A48(0.0); + double m_A49(0.0); + double m_A50(0.0); + double m_A51(0.0); + double m_A52(0.0); + double m_A53(0.0); + double m_A54(0.0); + double m_A55(0.0); + double m_A56(0.0); + double m_A57(0.0); + double m_A58(0.0); + double m_A59(0.0); + double m_A60(0.0); + double m_A61(0.0); + double m_A62(0.0); + double m_A63(0.0); + double m_A64(0.0); + double m_A65(0.0); + double m_A66(0.0); + double m_A67(0.0); + double m_A68(0.0); + double m_A69(0.0); + double m_A70(0.0); + double m_A71(0.0); + double m_A72(0.0); + double m_A73(0.0); + double m_A74(0.0); + double m_A75(0.0); + double m_A76(0.0); + double m_A77(0.0); + double m_A78(0.0); + double m_A79(0.0); + double m_A80(0.0); + double m_A81(0.0); + double m_A82(0.0); + double m_A83(0.0); + double m_A84(0.0); + double m_A85(0.0); + double m_A86(0.0); + double m_A87(0.0); + double m_A88(0.0); + double m_A89(0.0); + double m_A90(0.0); + double m_A91(0.0); + double m_A92(0.0); + double m_A93(0.0); + double m_A94(0.0); + double m_A95(0.0); + double m_A96(0.0); + double m_A97(0.0); + double m_A98(0.0); + double m_A99(0.0); + double m_A100(0.0); + double m_A101(0.0); + double m_A102(0.0); + double m_A103(0.0); + double m_A104(0.0); + double m_A105(0.0); + double m_A106(0.0); + double m_A107(0.0); + double m_A108(0.0); + double m_A109(0.0); + double m_A110(0.0); + double m_A111(0.0); + double m_A112(0.0); + double m_A113(0.0); + double m_A114(0.0); + double m_A115(0.0); + double m_A116(0.0); + double m_A117(0.0); + double m_A118(0.0); + double m_A119(0.0); + double m_A120(0.0); + double m_A121(0.0); + double m_A122(0.0); + double m_A123(0.0); + double m_A124(0.0); + double m_A125(0.0); + double m_A126(0.0); + double m_A127(0.0); + double m_A128(0.0); + double m_A129(0.0); + double m_A130(0.0); + double m_A131(0.0); + double m_A132(0.0); + double m_A133(0.0); + double m_A134(0.0); + double m_A135(0.0); + double m_A136(0.0); + double m_A137(0.0); + double m_A138(0.0); + double m_A139(0.0); + double m_A140(0.0); + double m_A141(0.0); + double m_A142(0.0); + double m_A143(0.0); + double m_A144(0.0); + double m_A145(0.0); + double m_A146(0.0); + double m_A147(0.0); + double m_A148(0.0); + double m_A149(0.0); + double m_A150(0.0); + double m_A151(0.0); + double m_A152(0.0); + double m_A153(0.0); + double m_A154(0.0); + double m_A155(0.0); + double m_A156(0.0); + double m_A157(0.0); + double m_A158(0.0); + double m_A159(0.0); + double m_A160(0.0); + double m_A161(0.0); + double m_A162(0.0); + double m_A163(0.0); + double m_A164(0.0); + double m_A165(0.0); + double m_A166(0.0); + double m_A167(0.0); + double m_A168(0.0); + double m_A169(0.0); + double m_A170(0.0); + double m_A171(0.0); + double m_A172(0.0); + double m_A173(0.0); + double m_A174(0.0); + double m_A175(0.0); + double m_A176(0.0); + double m_A177(0.0); + double m_A178(0.0); + double m_A179(0.0); + double m_A180(0.0); + double m_A181(0.0); + double m_A182(0.0); + double m_A183(0.0); + double m_A184(0.0); + double m_A185(0.0); + double m_A186(0.0); + double m_A187(0.0); + double m_A188(0.0); + double m_A189(0.0); + double m_A190(0.0); + double m_A191(0.0); + double m_A192(0.0); + double m_A193(0.0); + double m_A194(0.0); + double m_A195(0.0); + double m_A196(0.0); + double m_A197(0.0); + double m_A198(0.0); + double m_A199(0.0); + double m_A200(0.0); + double m_A201(0.0); + double m_A202(0.0); + double m_A203(0.0); + double m_A204(0.0); + double m_A205(0.0); + double m_A206(0.0); + double m_A207(0.0); + double m_A208(0.0); + double m_A209(0.0); + double m_A210(0.0); + double m_A211(0.0); + double m_A212(0.0); + double m_A213(0.0); + double m_A214(0.0); + double m_A215(0.0); + double m_A216(0.0); + double m_A217(0.0); + double m_A218(0.0); + double m_A219(0.0); + double m_A220(0.0); + double m_A221(0.0); + double m_A222(0.0); + double m_A223(0.0); + double m_A224(0.0); + double m_A225(0.0); + double m_A226(0.0); + double m_A227(0.0); + double m_A228(0.0); + double m_A229(0.0); + double m_A230(0.0); + double m_A231(0.0); + double m_A232(0.0); + double m_A233(0.0); + double m_A234(0.0); + double m_A235(0.0); + double m_A236(0.0); + double m_A237(0.0); + double m_A238(0.0); + double m_A239(0.0); + double m_A240(0.0); + double m_A241(0.0); + double m_A242(0.0); + double m_A243(0.0); + double m_A244(0.0); + double m_A245(0.0); + double m_A246(0.0); + double m_A247(0.0); + double m_A248(0.0); + double m_A249(0.0); + double m_A250(0.0); + double m_A251(0.0); + double m_A252(0.0); + double m_A253(0.0); + double m_A254(0.0); + double m_A255(0.0); + double m_A256(0.0); + double m_A257(0.0); + double m_A258(0.0); + double m_A259(0.0); + double m_A260(0.0); + double m_A261(0.0); + double m_A262(0.0); + double m_A263(0.0); + double m_A264(0.0); + double m_A265(0.0); + double m_A266(0.0); + double m_A267(0.0); + double m_A268(0.0); + double m_A269(0.0); + double m_A270(0.0); + double m_A271(0.0); + double m_A272(0.0); + double m_A273(0.0); + double m_A274(0.0); + double m_A275(0.0); + double m_A276(0.0); + double m_A277(0.0); + double m_A278(0.0); + double m_A279(0.0); + double m_A280(0.0); + double m_A281(0.0); + double m_A282(0.0); + double m_A283(0.0); + double m_A284(0.0); + double m_A285(0.0); + double m_A286(0.0); + double m_A287(0.0); + double m_A288(0.0); + double m_A289(0.0); + double m_A290(0.0); + double m_A291(0.0); + double m_A292(0.0); + double m_A293(0.0); + double m_A294(0.0); + double m_A295(0.0); + double m_A296(0.0); + double m_A297(0.0); + double m_A298(0.0); + double m_A299(0.0); + double m_A300(0.0); + double m_A301(0.0); + double m_A302(0.0); + double m_A303(0.0); + double m_A304(0.0); + double m_A305(0.0); + double m_A306(0.0); + double m_A307(0.0); + double m_A308(0.0); + double m_A309(0.0); + double m_A310(0.0); + double m_A311(0.0); + double m_A312(0.0); + double m_A313(0.0); + double m_A314(0.0); + double m_A315(0.0); + double m_A316(0.0); + double m_A317(0.0); + double m_A318(0.0); + double m_A319(0.0); + double m_A320(0.0); + double m_A321(0.0); + double m_A322(0.0); + double m_A323(0.0); + double m_A324(0.0); + double m_A325(0.0); + double m_A326(0.0); + double m_A327(0.0); + double m_A328(0.0); + double m_A329(0.0); + double m_A330(0.0); + double m_A331(0.0); + double m_A332(0.0); + double m_A333(0.0); + double m_A334(0.0); + double m_A335(0.0); + double m_A336(0.0); + double m_A337(0.0); + double m_A338(0.0); + double m_A339(0.0); + double m_A340(0.0); + double m_A341(0.0); + double m_A342(0.0); + double m_A343(0.0); + double m_A344(0.0); + double m_A345(0.0); + double m_A346(0.0); + double m_A347(0.0); + double m_A348(0.0); + double m_A349(0.0); + double m_A350(0.0); + double m_A351(0.0); + double m_A352(0.0); + double m_A353(0.0); + double m_A354(0.0); + double m_A355(0.0); + double m_A356(0.0); + double m_A357(0.0); + double m_A358(0.0); + double m_A359(0.0); + double m_A360(0.0); + double m_A361(0.0); + double m_A362(0.0); + double m_A363(0.0); + double m_A364(0.0); + double m_A365(0.0); + double m_A366(0.0); + double m_A367(0.0); + double m_A368(0.0); + double m_A369(0.0); + double m_A370(0.0); + double m_A371(0.0); + double m_A372(0.0); + double m_A373(0.0); + double m_A374(0.0); + double m_A375(0.0); + double m_A376(0.0); + double m_A377(0.0); + double m_A378(0.0); + double m_A379(0.0); + double m_A380(0.0); + double m_A381(0.0); + double m_A382(0.0); + double m_A383(0.0); + double m_A384(0.0); + double m_A385(0.0); + double m_A386(0.0); + double m_A387(0.0); + double m_A388(0.0); + double m_A389(0.0); + double m_A390(0.0); + double m_A391(0.0); + double m_A392(0.0); + double m_A393(0.0); + double m_A394(0.0); + double m_A395(0.0); + double m_A396(0.0); + double m_A397(0.0); + double m_A398(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A7 += go[4]; + m_A6 += go[5]; + m_A5 += go[6]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[7] * *cnV[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A9 += go[8]; + double RHS3 = Idr[8]; + RHS3 += Idr[9]; + RHS3 -= go[9] * *cnV[9]; + m_A10 += gt[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A11 += go[10]; + m_A12 += go[11]; + double RHS4 = Idr[10]; + RHS4 += Idr[11]; + RHS4 += Idr[12]; + RHS4 -= go[12] * *cnV[12]; + m_A13 += gt[13]; + m_A13 += gt[14]; + m_A13 += gt[15]; + m_A14 += go[13]; + m_A15 += go[14]; + double RHS5 = Idr[13]; + RHS5 += Idr[14]; + RHS5 += Idr[15]; + RHS5 -= go[15] * *cnV[15]; + m_A16 += gt[16]; + m_A16 += gt[17]; + m_A16 += gt[18]; + m_A16 += gt[19]; + m_A17 += go[16]; + double RHS6 = Idr[16]; + RHS6 += Idr[17]; + RHS6 += Idr[18]; + RHS6 += Idr[19]; + RHS6 -= go[17] * *cnV[17]; + RHS6 -= go[18] * *cnV[18]; + RHS6 -= go[19] * *cnV[19]; + m_A18 += gt[20]; + m_A18 += gt[21]; + m_A18 += gt[22]; + m_A18 += gt[23]; + m_A18 += gt[24]; + m_A18 += gt[25]; + m_A18 += gt[26]; + m_A22 += go[20]; + m_A21 += go[21]; + m_A20 += go[22]; + m_A19 += go[23]; + double RHS7 = Idr[20]; + RHS7 += Idr[21]; + RHS7 += Idr[22]; + RHS7 += Idr[23]; + RHS7 += Idr[24]; + RHS7 += Idr[25]; + RHS7 += Idr[26]; + RHS7 -= go[24] * *cnV[24]; + RHS7 -= go[25] * *cnV[25]; + RHS7 -= go[26] * *cnV[26]; + m_A23 += gt[27]; + m_A23 += gt[28]; + m_A23 += gt[29]; + m_A23 += gt[30]; + m_A23 += gt[31]; + m_A23 += gt[32]; + m_A23 += gt[33]; + m_A27 += go[27]; + m_A26 += go[28]; + m_A25 += go[29]; + m_A24 += go[30]; + double RHS8 = Idr[27]; + RHS8 += Idr[28]; + RHS8 += Idr[29]; + RHS8 += Idr[30]; + RHS8 += Idr[31]; + RHS8 += Idr[32]; + RHS8 += Idr[33]; + RHS8 -= go[31] * *cnV[31]; + RHS8 -= go[32] * *cnV[32]; + RHS8 -= go[33] * *cnV[33]; + m_A28 += gt[34]; + m_A28 += gt[35]; + m_A28 += gt[36]; + m_A29 += go[34]; + m_A30 += go[35]; + double RHS9 = Idr[34]; + RHS9 += Idr[35]; + RHS9 += Idr[36]; + RHS9 -= go[36] * *cnV[36]; + m_A31 += gt[37]; + m_A31 += gt[38]; + m_A31 += gt[39]; + m_A31 += gt[40]; + m_A31 += gt[41]; + m_A31 += gt[42]; + m_A31 += gt[43]; + m_A32 += go[37]; + m_A33 += go[38]; + double RHS10 = Idr[37]; + RHS10 += Idr[38]; + RHS10 += Idr[39]; + RHS10 += Idr[40]; + RHS10 += Idr[41]; + RHS10 += Idr[42]; + RHS10 += Idr[43]; + RHS10 -= go[39] * *cnV[39]; + RHS10 -= go[40] * *cnV[40]; + RHS10 -= go[41] * *cnV[41]; + RHS10 -= go[42] * *cnV[42]; + RHS10 -= go[43] * *cnV[43]; + m_A34 += gt[44]; + m_A34 += gt[45]; + m_A34 += gt[46]; + m_A36 += go[44]; + m_A35 += go[45]; + m_A37 += go[46]; + double RHS11 = Idr[44]; + RHS11 += Idr[45]; + RHS11 += Idr[46]; + m_A38 += gt[47]; + m_A38 += gt[48]; + m_A38 += gt[49]; + m_A38 += gt[50]; + m_A38 += gt[51]; + m_A38 += gt[52]; + m_A38 += gt[53]; + m_A39 += go[47]; + m_A40 += go[48]; + double RHS12 = Idr[47]; + RHS12 += Idr[48]; + RHS12 += Idr[49]; + RHS12 += Idr[50]; + RHS12 += Idr[51]; + RHS12 += Idr[52]; + RHS12 += Idr[53]; + RHS12 -= go[49] * *cnV[49]; + RHS12 -= go[50] * *cnV[50]; + RHS12 -= go[51] * *cnV[51]; + RHS12 -= go[52] * *cnV[52]; + RHS12 -= go[53] * *cnV[53]; + m_A41 += gt[54]; + m_A41 += gt[55]; + m_A41 += gt[56]; + m_A41 += gt[57]; + m_A44 += go[54]; + m_A42 += go[55]; + m_A43 += go[56]; + double RHS13 = Idr[54]; + RHS13 += Idr[55]; + RHS13 += Idr[56]; + RHS13 += Idr[57]; + RHS13 -= go[57] * *cnV[57]; + m_A45 += gt[58]; + m_A45 += gt[59]; + m_A45 += gt[60]; + m_A45 += gt[61]; + m_A45 += gt[62]; + m_A46 += go[58]; + m_A47 += go[59]; + double RHS14 = Idr[58]; + RHS14 += Idr[59]; + RHS14 += Idr[60]; + RHS14 += Idr[61]; + RHS14 += Idr[62]; + RHS14 -= go[60] * *cnV[60]; + RHS14 -= go[61] * *cnV[61]; + RHS14 -= go[62] * *cnV[62]; + m_A48 += gt[63]; + m_A48 += gt[64]; + m_A48 += gt[65]; + m_A48 += gt[66]; + m_A48 += gt[67]; + m_A48 += gt[68]; + m_A48 += gt[69]; + m_A50 += go[63]; + m_A49 += go[64]; + double RHS15 = Idr[63]; + RHS15 += Idr[64]; + RHS15 += Idr[65]; + RHS15 += Idr[66]; + RHS15 += Idr[67]; + RHS15 += Idr[68]; + RHS15 += Idr[69]; + RHS15 -= go[65] * *cnV[65]; + RHS15 -= go[66] * *cnV[66]; + RHS15 -= go[67] * *cnV[67]; + RHS15 -= go[68] * *cnV[68]; + RHS15 -= go[69] * *cnV[69]; + m_A51 += gt[70]; + m_A51 += gt[71]; + m_A51 += gt[72]; + m_A51 += gt[73]; + m_A51 += gt[74]; + m_A52 += go[70]; + m_A53 += go[71]; + double RHS16 = Idr[70]; + RHS16 += Idr[71]; + RHS16 += Idr[72]; + RHS16 += Idr[73]; + RHS16 += Idr[74]; + RHS16 -= go[72] * *cnV[72]; + RHS16 -= go[73] * *cnV[73]; + RHS16 -= go[74] * *cnV[74]; + m_A54 += gt[75]; + m_A54 += gt[76]; + m_A54 += gt[77]; + m_A55 += go[75]; + double RHS17 = Idr[75]; + RHS17 += Idr[76]; + RHS17 += Idr[77]; + RHS17 -= go[76] * *cnV[76]; + RHS17 -= go[77] * *cnV[77]; + m_A56 += gt[78]; + m_A56 += gt[79]; + m_A57 += go[78]; + m_A58 += go[79]; + double RHS18 = Idr[78]; + RHS18 += Idr[79]; + m_A59 += gt[80]; + m_A59 += gt[81]; + m_A59 += gt[82]; + m_A60 += go[80]; + double RHS19 = Idr[80]; + RHS19 += Idr[81]; + RHS19 += Idr[82]; + RHS19 -= go[81] * *cnV[81]; + RHS19 -= go[82] * *cnV[82]; + m_A61 += gt[83]; + m_A61 += gt[84]; + m_A61 += gt[85]; + m_A62 += go[83]; + double RHS20 = Idr[83]; + RHS20 += Idr[84]; + RHS20 += Idr[85]; + RHS20 -= go[84] * *cnV[84]; + RHS20 -= go[85] * *cnV[85]; + m_A63 += gt[86]; + m_A63 += gt[87]; + m_A64 += go[86]; + double RHS21 = Idr[86]; + RHS21 += Idr[87]; + RHS21 -= go[87] * *cnV[87]; + m_A65 += gt[88]; + m_A65 += gt[89]; + m_A65 += gt[90]; + m_A65 += gt[91]; + m_A67 += go[88]; + m_A66 += go[89]; + double RHS22 = Idr[88]; + RHS22 += Idr[89]; + RHS22 += Idr[90]; + RHS22 += Idr[91]; + RHS22 -= go[90] * *cnV[90]; + RHS22 -= go[91] * *cnV[91]; + m_A68 += gt[92]; + m_A68 += gt[93]; + m_A68 += gt[94]; + m_A68 += gt[95]; + m_A68 += gt[96]; + m_A68 += gt[97]; + m_A68 += gt[98]; + m_A70 += go[92]; + m_A69 += go[93]; + double RHS23 = Idr[92]; + RHS23 += Idr[93]; + RHS23 += Idr[94]; + RHS23 += Idr[95]; + RHS23 += Idr[96]; + RHS23 += Idr[97]; + RHS23 += Idr[98]; + RHS23 -= go[94] * *cnV[94]; + RHS23 -= go[95] * *cnV[95]; + RHS23 -= go[96] * *cnV[96]; + RHS23 -= go[97] * *cnV[97]; + RHS23 -= go[98] * *cnV[98]; + m_A71 += gt[99]; + m_A71 += gt[100]; + m_A72 += go[99]; + double RHS24 = Idr[99]; + RHS24 += Idr[100]; + RHS24 -= go[100] * *cnV[100]; + m_A73 += gt[101]; + m_A73 += gt[102]; + m_A73 += gt[103]; + m_A74 += go[101]; + double RHS25 = Idr[101]; + RHS25 += Idr[102]; + RHS25 += Idr[103]; + RHS25 -= go[102] * *cnV[102]; + RHS25 -= go[103] * *cnV[103]; + m_A75 += gt[104]; + m_A75 += gt[105]; + m_A75 += gt[106]; + m_A75 += gt[107]; + m_A75 += gt[108]; + m_A75 += gt[109]; + m_A75 += gt[110]; + m_A76 += go[104]; + double RHS26 = Idr[104]; + RHS26 += Idr[105]; + RHS26 += Idr[106]; + RHS26 += Idr[107]; + RHS26 += Idr[108]; + RHS26 += Idr[109]; + RHS26 += Idr[110]; + RHS26 -= go[105] * *cnV[105]; + RHS26 -= go[106] * *cnV[106]; + RHS26 -= go[107] * *cnV[107]; + RHS26 -= go[108] * *cnV[108]; + RHS26 -= go[109] * *cnV[109]; + RHS26 -= go[110] * *cnV[110]; + m_A77 += gt[111]; + m_A77 += gt[112]; + m_A77 += gt[113]; + m_A77 += gt[114]; + m_A77 += gt[115]; + m_A79 += go[111]; + m_A78 += go[112]; + m_A80 += go[113]; + double RHS27 = Idr[111]; + RHS27 += Idr[112]; + RHS27 += Idr[113]; + RHS27 += Idr[114]; + RHS27 += Idr[115]; + RHS27 -= go[114] * *cnV[114]; + RHS27 -= go[115] * *cnV[115]; + m_A81 += gt[116]; + m_A81 += gt[117]; + m_A81 += gt[118]; + m_A81 += gt[119]; + m_A81 += gt[120]; + m_A81 += gt[121]; + m_A82 += go[116]; + m_A83 += go[117]; + m_A83 += go[118]; + double RHS28 = Idr[116]; + RHS28 += Idr[117]; + RHS28 += Idr[118]; + RHS28 += Idr[119]; + RHS28 += Idr[120]; + RHS28 += Idr[121]; + RHS28 -= go[119] * *cnV[119]; + RHS28 -= go[120] * *cnV[120]; + RHS28 -= go[121] * *cnV[121]; + m_A84 += gt[122]; + m_A84 += gt[123]; + m_A84 += gt[124]; + m_A84 += gt[125]; + m_A85 += go[122]; + m_A87 += go[123]; + m_A86 += go[124]; + double RHS29 = Idr[122]; + RHS29 += Idr[123]; + RHS29 += Idr[124]; + RHS29 += Idr[125]; + RHS29 -= go[125] * *cnV[125]; + m_A88 += gt[126]; + m_A88 += gt[127]; + m_A88 += gt[128]; + m_A88 += gt[129]; + m_A89 += go[126]; + m_A90 += go[127]; + double RHS30 = Idr[126]; + RHS30 += Idr[127]; + RHS30 += Idr[128]; + RHS30 += Idr[129]; + RHS30 -= go[128] * *cnV[128]; + RHS30 -= go[129] * *cnV[129]; + m_A91 += gt[130]; + m_A91 += gt[131]; + m_A91 += gt[132]; + m_A91 += gt[133]; + m_A91 += gt[134]; + m_A92 += go[130]; + m_A94 += go[131]; + m_A93 += go[132]; + double RHS31 = Idr[130]; + RHS31 += Idr[131]; + RHS31 += Idr[132]; + RHS31 += Idr[133]; + RHS31 += Idr[134]; + RHS31 -= go[133] * *cnV[133]; + RHS31 -= go[134] * *cnV[134]; + m_A95 += gt[135]; + m_A95 += gt[136]; + m_A96 += go[135]; + m_A97 += go[136]; + double RHS32 = Idr[135]; + RHS32 += Idr[136]; + m_A98 += gt[137]; + m_A98 += gt[138]; + m_A98 += gt[139]; + m_A98 += gt[140]; + m_A98 += gt[141]; + m_A100 += go[137]; + m_A100 += go[138]; + m_A99 += go[139]; + double RHS33 = Idr[137]; + RHS33 += Idr[138]; + RHS33 += Idr[139]; + RHS33 += Idr[140]; + RHS33 += Idr[141]; + RHS33 -= go[140] * *cnV[140]; + RHS33 -= go[141] * *cnV[141]; + m_A101 += gt[142]; + m_A101 += gt[143]; + m_A103 += go[142]; + m_A102 += go[143]; + double RHS34 = Idr[142]; + RHS34 += Idr[143]; + m_A104 += gt[144]; + m_A104 += gt[145]; + m_A106 += go[144]; + m_A105 += go[145]; + double RHS35 = Idr[144]; + RHS35 += Idr[145]; + m_A107 += gt[146]; + m_A107 += gt[147]; + m_A107 += gt[148]; + m_A108 += go[146]; + double RHS36 = Idr[146]; + RHS36 += Idr[147]; + RHS36 += Idr[148]; + RHS36 -= go[147] * *cnV[147]; + RHS36 -= go[148] * *cnV[148]; + m_A110 += gt[149]; + m_A110 += gt[150]; + m_A110 += gt[151]; + m_A109 += go[149]; + m_A111 += go[150]; + double RHS37 = Idr[149]; + RHS37 += Idr[150]; + RHS37 += Idr[151]; + RHS37 -= go[151] * *cnV[151]; + m_A114 += gt[152]; + m_A114 += gt[153]; + m_A114 += gt[154]; + m_A114 += gt[155]; + m_A113 += go[152]; + m_A112 += go[153]; + double RHS38 = Idr[152]; + RHS38 += Idr[153]; + RHS38 += Idr[154]; + RHS38 += Idr[155]; + RHS38 -= go[154] * *cnV[154]; + RHS38 -= go[155] * *cnV[155]; + m_A120 += gt[156]; + m_A120 += gt[157]; + m_A120 += gt[158]; + m_A120 += gt[159]; + m_A118 += go[156]; + m_A117 += go[157]; + double RHS39 = Idr[156]; + RHS39 += Idr[157]; + RHS39 += Idr[158]; + RHS39 += Idr[159]; + RHS39 -= go[158] * *cnV[158]; + RHS39 -= go[159] * *cnV[159]; + m_A130 += gt[160]; + m_A130 += gt[161]; + m_A130 += gt[162]; + m_A130 += gt[163]; + m_A127 += go[160]; + m_A126 += go[161]; + m_A125 += go[162]; + double RHS40 = Idr[160]; + RHS40 += Idr[161]; + RHS40 += Idr[162]; + RHS40 += Idr[163]; + RHS40 -= go[163] * *cnV[163]; + m_A137 += gt[164]; + m_A137 += gt[165]; + m_A137 += gt[166]; + m_A136 += go[164]; + m_A135 += go[165]; + double RHS41 = Idr[164]; + RHS41 += Idr[165]; + RHS41 += Idr[166]; + RHS41 -= go[166] * *cnV[166]; + m_A140 += gt[167]; + m_A140 += gt[168]; + m_A140 += gt[169]; + m_A140 += gt[170]; + m_A142 += go[167]; + m_A142 += go[168]; + m_A141 += go[169]; + double RHS42 = Idr[167]; + RHS42 += Idr[168]; + RHS42 += Idr[169]; + RHS42 += Idr[170]; + RHS42 -= go[170] * *cnV[170]; + m_A144 += gt[171]; + m_A144 += gt[172]; + m_A144 += gt[173]; + m_A144 += gt[174]; + m_A144 += gt[175]; + m_A144 += gt[176]; + m_A144 += gt[177]; + m_A145 += go[171]; + m_A143 += go[172]; + double RHS43 = Idr[171]; + RHS43 += Idr[172]; + RHS43 += Idr[173]; + RHS43 += Idr[174]; + RHS43 += Idr[175]; + RHS43 += Idr[176]; + RHS43 += Idr[177]; + RHS43 -= go[173] * *cnV[173]; + RHS43 -= go[174] * *cnV[174]; + RHS43 -= go[175] * *cnV[175]; + RHS43 -= go[176] * *cnV[176]; + RHS43 -= go[177] * *cnV[177]; + m_A149 += gt[178]; + m_A149 += gt[179]; + m_A149 += gt[180]; + m_A149 += gt[181]; + m_A147 += go[178]; + m_A148 += go[179]; + m_A150 += go[180]; + double RHS44 = Idr[178]; + RHS44 += Idr[179]; + RHS44 += Idr[180]; + RHS44 += Idr[181]; + RHS44 -= go[181] * *cnV[181]; + m_A153 += gt[182]; + m_A153 += gt[183]; + m_A153 += gt[184]; + m_A153 += gt[185]; + m_A153 += gt[186]; + m_A151 += go[182]; + m_A156 += go[183]; + m_A152 += go[184]; + double RHS45 = Idr[182]; + RHS45 += Idr[183]; + RHS45 += Idr[184]; + RHS45 += Idr[185]; + RHS45 += Idr[186]; + RHS45 -= go[185] * *cnV[185]; + RHS45 -= go[186] * *cnV[186]; + m_A161 += gt[187]; + m_A161 += gt[188]; + m_A161 += gt[189]; + m_A159 += go[187]; + m_A158 += go[188]; + m_A157 += go[189]; + double RHS46 = Idr[187]; + RHS46 += Idr[188]; + RHS46 += Idr[189]; + m_A166 += gt[190]; + m_A166 += gt[191]; + m_A166 += gt[192]; + m_A167 += go[190]; + m_A165 += go[191]; + double RHS47 = Idr[190]; + RHS47 += Idr[191]; + RHS47 += Idr[192]; + RHS47 -= go[192] * *cnV[192]; + m_A171 += gt[193]; + m_A171 += gt[194]; + m_A171 += gt[195]; + m_A174 += go[193]; + m_A169 += go[194]; + m_A168 += go[195]; + double RHS48 = Idr[193]; + RHS48 += Idr[194]; + RHS48 += Idr[195]; + m_A177 += gt[196]; + m_A177 += gt[197]; + m_A177 += gt[198]; + m_A177 += gt[199]; + m_A176 += go[196]; + m_A175 += go[197]; + double RHS49 = Idr[196]; + RHS49 += Idr[197]; + RHS49 += Idr[198]; + RHS49 += Idr[199]; + RHS49 -= go[198] * *cnV[198]; + RHS49 -= go[199] * *cnV[199]; + m_A185 += gt[200]; + m_A185 += gt[201]; + m_A185 += gt[202]; + m_A185 += gt[203]; + m_A185 += gt[204]; + m_A185 += gt[205]; + m_A189 += go[200]; + m_A182 += go[201]; + m_A181 += go[202]; + m_A180 += go[203]; + m_A187 += go[204]; + double RHS50 = Idr[200]; + RHS50 += Idr[201]; + RHS50 += Idr[202]; + RHS50 += Idr[203]; + RHS50 += Idr[204]; + RHS50 += Idr[205]; + RHS50 -= go[205] * *cnV[205]; + m_A191 += gt[206]; + m_A191 += gt[207]; + m_A193 += go[206]; + m_A190 += go[207]; + double RHS51 = Idr[206]; + RHS51 += Idr[207]; + m_A196 += gt[208]; + m_A196 += gt[209]; + m_A196 += gt[210]; + m_A196 += gt[211]; + m_A196 += gt[212]; + m_A197 += go[208]; + m_A198 += go[209]; + m_A194 += go[210]; + double RHS52 = Idr[208]; + RHS52 += Idr[209]; + RHS52 += Idr[210]; + RHS52 += Idr[211]; + RHS52 += Idr[212]; + RHS52 -= go[211] * *cnV[211]; + RHS52 -= go[212] * *cnV[212]; + m_A202 += gt[213]; + m_A202 += gt[214]; + m_A202 += gt[215]; + m_A202 += gt[216]; + m_A202 += gt[217]; + m_A202 += gt[218]; + m_A202 += gt[219]; + m_A203 += go[213]; + m_A201 += go[214]; + double RHS53 = Idr[213]; + RHS53 += Idr[214]; + RHS53 += Idr[215]; + RHS53 += Idr[216]; + RHS53 += Idr[217]; + RHS53 += Idr[218]; + RHS53 += Idr[219]; + RHS53 -= go[215] * *cnV[215]; + RHS53 -= go[216] * *cnV[216]; + RHS53 -= go[217] * *cnV[217]; + RHS53 -= go[218] * *cnV[218]; + RHS53 -= go[219] * *cnV[219]; + m_A206 += gt[220]; + m_A206 += gt[221]; + m_A206 += gt[222]; + m_A207 += go[220]; + m_A205 += go[221]; + double RHS54 = Idr[220]; + RHS54 += Idr[221]; + RHS54 += Idr[222]; + RHS54 -= go[222] * *cnV[222]; + m_A211 += gt[223]; + m_A211 += gt[224]; + m_A211 += gt[225]; + m_A211 += gt[226]; + m_A209 += go[223]; + m_A209 += go[224]; + m_A208 += go[225]; + double RHS55 = Idr[223]; + RHS55 += Idr[224]; + RHS55 += Idr[225]; + RHS55 += Idr[226]; + RHS55 -= go[226] * *cnV[226]; + m_A218 += gt[227]; + m_A218 += gt[228]; + m_A218 += gt[229]; + m_A218 += gt[230]; + m_A218 += gt[231]; + m_A218 += gt[232]; + m_A218 += gt[233]; + m_A217 += go[227]; + m_A216 += go[228]; + m_A219 += go[229]; + m_A215 += go[230]; + double RHS56 = Idr[227]; + RHS56 += Idr[228]; + RHS56 += Idr[229]; + RHS56 += Idr[230]; + RHS56 += Idr[231]; + RHS56 += Idr[232]; + RHS56 += Idr[233]; + RHS56 -= go[231] * *cnV[231]; + RHS56 -= go[232] * *cnV[232]; + RHS56 -= go[233] * *cnV[233]; + m_A220 += gt[234]; + m_A220 += gt[235]; + m_A222 += go[234]; + m_A221 += go[235]; + double RHS57 = Idr[234]; + RHS57 += Idr[235]; + m_A227 += gt[236]; + m_A227 += gt[237]; + m_A227 += gt[238]; + m_A227 += gt[239]; + m_A227 += gt[240]; + m_A227 += gt[241]; + m_A227 += gt[242]; + m_A223 += go[236]; + m_A225 += go[237]; + m_A229 += go[238]; + m_A231 += go[239]; + m_A230 += go[240]; + double RHS58 = Idr[236]; + RHS58 += Idr[237]; + RHS58 += Idr[238]; + RHS58 += Idr[239]; + RHS58 += Idr[240]; + RHS58 += Idr[241]; + RHS58 += Idr[242]; + RHS58 -= go[241] * *cnV[241]; + RHS58 -= go[242] * *cnV[242]; + m_A237 += gt[243]; + m_A237 += gt[244]; + m_A240 += go[243]; + m_A233 += go[244]; + double RHS59 = Idr[243]; + RHS59 += Idr[244]; + m_A245 += gt[245]; + m_A245 += gt[246]; + m_A242 += go[245]; + m_A241 += go[246]; + double RHS60 = Idr[245]; + RHS60 += Idr[246]; + m_A253 += gt[247]; + m_A253 += gt[248]; + m_A252 += go[247]; + m_A251 += go[248]; + double RHS61 = Idr[247]; + RHS61 += Idr[248]; + m_A258 += gt[249]; + m_A258 += gt[250]; + m_A258 += gt[251]; + m_A258 += gt[252]; + m_A258 += gt[253]; + m_A258 += gt[254]; + m_A258 += gt[255]; + m_A256 += go[249]; + m_A257 += go[250]; + double RHS62 = Idr[249]; + RHS62 += Idr[250]; + RHS62 += Idr[251]; + RHS62 += Idr[252]; + RHS62 += Idr[253]; + RHS62 += Idr[254]; + RHS62 += Idr[255]; + RHS62 -= go[251] * *cnV[251]; + RHS62 -= go[252] * *cnV[252]; + RHS62 -= go[253] * *cnV[253]; + RHS62 -= go[254] * *cnV[254]; + RHS62 -= go[255] * *cnV[255]; + m_A262 += gt[256]; + m_A262 += gt[257]; + m_A261 += go[256]; + m_A260 += go[257]; + double RHS63 = Idr[256]; + RHS63 += Idr[257]; + m_A265 += gt[258]; + m_A265 += gt[259]; + m_A267 += go[258]; + m_A264 += go[259]; + double RHS64 = Idr[258]; + RHS64 += Idr[259]; + m_A276 += gt[260]; + m_A276 += gt[261]; + m_A276 += gt[262]; + m_A276 += gt[263]; + m_A270 += go[260]; + m_A269 += go[261]; + m_A268 += go[262]; + m_A271 += go[263]; + double RHS65 = Idr[260]; + RHS65 += Idr[261]; + RHS65 += Idr[262]; + RHS65 += Idr[263]; + m_A288 += gt[264]; + m_A288 += gt[265]; + m_A288 += gt[266]; + m_A288 += gt[267]; + m_A288 += gt[268]; + m_A288 += gt[269]; + m_A281 += go[264]; + m_A283 += go[265]; + m_A285 += go[266]; + m_A280 += go[267]; + double RHS66 = Idr[264]; + RHS66 += Idr[265]; + RHS66 += Idr[266]; + RHS66 += Idr[267]; + RHS66 += Idr[268]; + RHS66 += Idr[269]; + RHS66 -= go[268] * *cnV[268]; + RHS66 -= go[269] * *cnV[269]; + m_A298 += gt[270]; + m_A298 += gt[271]; + m_A298 += gt[272]; + m_A298 += gt[273]; + m_A298 += gt[274]; + m_A298 += gt[275]; + m_A296 += go[270]; + m_A301 += go[271]; + m_A293 += go[272]; + m_A291 += go[273]; + m_A292 += go[274]; + double RHS67 = Idr[270]; + RHS67 += Idr[271]; + RHS67 += Idr[272]; + RHS67 += Idr[273]; + RHS67 += Idr[274]; + RHS67 += Idr[275]; + RHS67 -= go[275] * *cnV[275]; + m_A309 += gt[276]; + m_A309 += gt[277]; + m_A309 += gt[278]; + m_A309 += gt[279]; + m_A303 += go[276]; + m_A302 += go[277]; + m_A306 += go[278]; + m_A304 += go[279]; + double RHS68 = Idr[276]; + RHS68 += Idr[277]; + RHS68 += Idr[278]; + RHS68 += Idr[279]; + m_A320 += gt[280]; + m_A320 += gt[281]; + m_A320 += gt[282]; + m_A320 += gt[283]; + m_A320 += gt[284]; + m_A320 += gt[285]; + m_A313 += go[280]; + m_A312 += go[281]; + m_A316 += go[282]; + m_A317 += go[283]; + double RHS69 = Idr[280]; + RHS69 += Idr[281]; + RHS69 += Idr[282]; + RHS69 += Idr[283]; + RHS69 += Idr[284]; + RHS69 += Idr[285]; + RHS69 -= go[284] * *cnV[284]; + RHS69 -= go[285] * *cnV[285]; + m_A326 += gt[286]; + m_A326 += gt[287]; + m_A326 += gt[288]; + m_A326 += gt[289]; + m_A326 += gt[290]; + m_A326 += gt[291]; + m_A322 += go[286]; + m_A324 += go[287]; + m_A323 += go[288]; + m_A323 += go[289]; + double RHS70 = Idr[286]; + RHS70 += Idr[287]; + RHS70 += Idr[288]; + RHS70 += Idr[289]; + RHS70 += Idr[290]; + RHS70 += Idr[291]; + RHS70 -= go[290] * *cnV[290]; + RHS70 -= go[291] * *cnV[291]; + m_A333 += gt[292]; + m_A333 += gt[293]; + m_A333 += gt[294]; + m_A329 += go[292]; + m_A328 += go[293]; + m_A331 += go[294]; + double RHS71 = Idr[292]; + RHS71 += Idr[293]; + RHS71 += Idr[294]; + m_A348 += gt[295]; + m_A348 += gt[296]; + m_A348 += gt[297]; + m_A343 += go[295]; + m_A338 += go[296]; + m_A340 += go[297]; + double RHS72 = Idr[295]; + RHS72 += Idr[296]; + RHS72 += Idr[297]; + m_A360 += gt[298]; + m_A360 += gt[299]; + m_A360 += gt[300]; + m_A352 += go[298]; + m_A356 += go[299]; + m_A353 += go[300]; + double RHS73 = Idr[298]; + RHS73 += Idr[299]; + RHS73 += Idr[300]; + m_A377 += gt[301]; + m_A377 += gt[302]; + m_A377 += gt[303]; + m_A377 += gt[304]; + m_A377 += gt[305]; + m_A377 += gt[306]; + m_A365 += go[301]; + m_A364 += go[302]; + m_A366 += go[303]; + m_A363 += go[304]; + m_A370 += go[305]; + m_A367 += go[306]; + double RHS74 = Idr[301]; + RHS74 += Idr[302]; + RHS74 += Idr[303]; + RHS74 += Idr[304]; + RHS74 += Idr[305]; + RHS74 += Idr[306]; + m_A398 += gt[307]; + m_A398 += gt[308]; + m_A398 += gt[309]; + m_A398 += gt[310]; + m_A398 += gt[311]; + m_A398 += gt[312]; + m_A398 += gt[313]; + m_A398 += gt[314]; + m_A398 += gt[315]; + m_A398 += gt[316]; + m_A381 += go[307]; + m_A381 += go[308]; + m_A382 += go[309]; + m_A380 += go[310]; + m_A391 += go[311]; + m_A379 += go[312]; + m_A386 += go[313]; + double RHS75 = Idr[307]; + RHS75 += Idr[308]; + RHS75 += Idr[309]; + RHS75 += Idr[310]; + RHS75 += Idr[311]; + RHS75 += Idr[312]; + RHS75 += Idr[313]; + RHS75 += Idr[314]; + RHS75 += Idr[315]; + RHS75 += Idr[316]; + RHS75 -= go[314] * *cnV[314]; + RHS75 -= go[315] * *cnV[315]; + RHS75 -= go[316] * *cnV[316]; + const double f0 = 1.0 / m_A0; + const double f0_38 = -f0 * m_A112; + m_A114 += m_A1 * f0_38; + RHS38 += f0_38 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_37 = -f1 * m_A109; + m_A110 += m_A3 * f1_37; + RHS37 += f1_37 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_38 = -f2 * m_A113; + m_A114 += m_A5 * f2_38; + m_A115 += m_A6 * f2_38; + m_A116 += m_A7 * f2_38; + RHS38 += f2_38 * RHS2; + const double f2_39 = -f2 * m_A117; + m_A119 += m_A5 * f2_39; + m_A120 += m_A6 * f2_39; + m_A121 += m_A7 * f2_39; + RHS39 += f2_39 * RHS2; + const double f2_40 = -f2 * m_A125; + m_A128 += m_A5 * f2_40; + m_A129 += m_A6 * f2_40; + m_A130 += m_A7 * f2_40; + RHS40 += f2_40 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_44 = -f3 * m_A147; + m_A149 += m_A9 * f3_44; + RHS44 += f3_44 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_50 = -f4 * m_A180; + m_A185 += m_A11 * f4_50; + m_A187 += m_A12 * f4_50; + RHS50 += f4_50 * RHS4; + const double f4_68 = -f4 * m_A302; + m_A306 += m_A11 * f4_68; + m_A309 += m_A12 * f4_68; + RHS68 += f4_68 * RHS4; + const double f5 = 1.0 / m_A13; + const double f5_44 = -f5 * m_A148; + m_A149 += m_A14 * f5_44; + m_A150 += m_A15 * f5_44; + RHS44 += f5_44 * RHS5; + const double f5_67 = -f5 * m_A291; + m_A296 += m_A14 * f5_67; + m_A298 += m_A15 * f5_67; + RHS67 += f5_67 * RHS5; + const double f6 = 1.0 / m_A16; + const double f6_47 = -f6 * m_A165; + m_A166 += m_A17 * f6_47; + RHS47 += f6_47 * RHS6; + const double f7 = 1.0 / m_A18; + const double f7_39 = -f7 * m_A118; + m_A120 += m_A19 * f7_39; + m_A122 += m_A20 * f7_39; + m_A123 += m_A21 * f7_39; + m_A124 += m_A22 * f7_39; + RHS39 += f7_39 * RHS7; + const double f7_50 = -f7 * m_A181; + m_A183 += m_A19 * f7_50; + m_A185 += m_A20 * f7_50; + m_A186 += m_A21 * f7_50; + m_A189 += m_A22 * f7_50; + RHS50 += f7_50 * RHS7; + const double f7_67 = -f7 * m_A292; + m_A294 += m_A19 * f7_67; + m_A297 += m_A20 * f7_67; + m_A298 += m_A21 * f7_67; + m_A301 += m_A22 * f7_67; + RHS67 += f7_67 * RHS7; + const double f7_75 = -f7 * m_A379; + m_A383 += m_A19 * f7_75; + m_A386 += m_A20 * f7_75; + m_A391 += m_A21 * f7_75; + m_A398 += m_A22 * f7_75; + RHS75 += f7_75 * RHS7; + const double f8 = 1.0 / m_A23; + const double f8_40 = -f8 * m_A126; + m_A130 += m_A24 * f8_40; + m_A131 += m_A25 * f8_40; + m_A132 += m_A26 * f8_40; + m_A134 += m_A27 * f8_40; + RHS40 += f8_40 * RHS8; + const double f8_50 = -f8 * m_A182; + m_A184 += m_A24 * f8_50; + m_A185 += m_A25 * f8_50; + m_A186 += m_A26 * f8_50; + m_A189 += m_A27 * f8_50; + RHS50 += f8_50 * RHS8; + const double f8_67 = -f8 * m_A293; + m_A295 += m_A24 * f8_67; + m_A297 += m_A25 * f8_67; + m_A298 += m_A26 * f8_67; + m_A301 += m_A27 * f8_67; + RHS67 += f8_67 * RHS8; + const double f8_75 = -f8 * m_A380; + m_A384 += m_A24 * f8_75; + m_A386 += m_A25 * f8_75; + m_A391 += m_A26 * f8_75; + m_A398 += m_A27 * f8_75; + RHS75 += f8_75 * RHS8; + const double f9 = 1.0 / m_A28; + const double f9_51 = -f9 * m_A190; + m_A191 += m_A29 * f9_51; + m_A192 += m_A30 * f9_51; + RHS51 += f9_51 * RHS9; + const double f9_65 = -f9 * m_A268; + m_A273 += m_A29 * f9_65; + m_A276 += m_A30 * f9_65; + RHS65 += f9_65 * RHS9; + const double f10 = 1.0 / m_A31; + const double f10_45 = -f10 * m_A151; + m_A152 += m_A32 * f10_45; + m_A155 += m_A33 * f10_45; + RHS45 += f10_45 * RHS10; + const double f11 = 1.0 / m_A34; + const double f11_45 = -f11 * m_A152; + m_A153 += m_A35 * f11_45; + m_A154 += m_A36 * f11_45; + m_A155 += m_A37 * f11_45; + RHS45 += f11_45 * RHS11; + const double f11_52 = -f11 * m_A194; + m_A195 += m_A35 * f11_52; + m_A196 += m_A36 * f11_52; + m_A199 += m_A37 * f11_52; + RHS52 += f11_52 * RHS11; + const double f11_72 = -f11 * m_A338; + m_A339 += m_A35 * f11_72; + m_A341 += m_A36 * f11_72; + m_A348 += m_A37 * f11_72; + RHS72 += f11_72 * RHS11; + const double f12 = 1.0 / m_A38; + const double f12_58 = -f12 * m_A223; + m_A224 += m_A39 * f12_58; + m_A231 += m_A40 * f12_58; + RHS58 += f12_58 * RHS12; + const double f13 = 1.0 / m_A41; + const double f13_48 = -f13 * m_A168; + m_A171 += m_A42 * f13_48; + m_A173 += m_A43 * f13_48; + m_A174 += m_A44 * f13_48; + RHS48 += f13_48 * RHS13; + const double f13_65 = -f13 * m_A269; + m_A272 += m_A42 * f13_65; + m_A276 += m_A43 * f13_65; + m_A277 += m_A44 * f13_65; + RHS65 += f13_65 * RHS13; + const double f13_66 = -f13 * m_A280; + m_A285 += m_A42 * f13_66; + m_A287 += m_A43 * f13_66; + m_A288 += m_A44 * f13_66; + RHS66 += f13_66 * RHS13; + const double f14 = 1.0 / m_A45; + const double f14_53 = -f14 * m_A201; + m_A203 += m_A46 * f14_53; + m_A204 += m_A47 * f14_53; + RHS53 += f14_53 * RHS14; + const double f14_58 = -f14 * m_A224; + m_A229 += m_A46 * f14_58; + m_A231 += m_A47 * f14_58; + RHS58 += f14_58 * RHS14; + const double f14_71 = -f14 * m_A328; + m_A333 += m_A46 * f14_71; + m_A335 += m_A47 * f14_71; + RHS71 += f14_71 * RHS14; + const double f14_73 = -f14 * m_A352; + m_A358 += m_A46 * f14_73; + m_A360 += m_A47 * f14_73; + RHS73 += f14_73 * RHS14; + const double f15 = 1.0 / m_A48; + const double f15_66 = -f15 * m_A281; + m_A282 += m_A49 * f15_66; + m_A285 += m_A50 * f15_66; + RHS66 += f15_66 * RHS15; + const double f16 = 1.0 / m_A51; + const double f16_43 = -f16 * m_A143; + m_A145 += m_A52 * f16_43; + m_A146 += m_A53 * f16_43; + RHS43 += f16_43 * RHS16; + const double f16_46 = -f16 * m_A157; + m_A161 += m_A52 * f16_46; + m_A162 += m_A53 * f16_46; + RHS46 += f16_46 * RHS16; + const double f16_48 = -f16 * m_A169; + m_A170 += m_A52 * f16_48; + m_A171 += m_A53 * f16_48; + RHS48 += f16_48 * RHS16; + const double f16_66 = -f16 * m_A282; + m_A284 += m_A52 * f16_66; + m_A285 += m_A53 * f16_66; + RHS66 += f16_66 * RHS16; + const double f17 = 1.0 / m_A54; + const double f17_63 = -f17 * m_A260; + m_A262 += m_A55 * f17_63; + RHS63 += f17_63 * RHS17; + const double f18 = 1.0 / m_A56; + const double f18_46 = -f18 * m_A158; + m_A161 += m_A57 * f18_46; + m_A164 += m_A58 * f18_46; + RHS46 += f18_46 * RHS18; + const double f18_66 = -f18 * m_A283; + m_A284 += m_A57 * f18_66; + m_A288 += m_A58 * f18_66; + RHS66 += f18_66 * RHS18; + const double f19 = 1.0 / m_A59; + const double f19_56 = -f19 * m_A215; + m_A218 += m_A60 * f19_56; + RHS56 += f19_56 * RHS19; + const double f20 = 1.0 / m_A61; + const double f20_54 = -f20 * m_A205; + m_A206 += m_A62 * f20_54; + RHS54 += f20_54 * RHS20; + const double f21 = 1.0 / m_A63; + const double f21_56 = -f21 * m_A216; + m_A218 += m_A64 * f21_56; + RHS56 += f21_56 * RHS21; + const double f22 = 1.0 / m_A65; + const double f22_40 = -f22 * m_A127; + m_A130 += m_A66 * f22_40; + m_A133 += m_A67 * f22_40; + RHS40 += f22_40 * RHS22; + const double f22_69 = -f22 * m_A312; + m_A314 += m_A66 * f22_69; + m_A320 += m_A67 * f22_69; + RHS69 += f22_69 * RHS22; + const double f23 = 1.0 / m_A68; + const double f23_69 = -f23 * m_A313; + m_A316 += m_A69 * f23_69; + m_A320 += m_A70 * f23_69; + RHS69 += f23_69 * RHS23; + const double f24 = 1.0 / m_A71; + const double f24_56 = -f24 * m_A217; + m_A218 += m_A72 * f24_56; + RHS56 += f24_56 * RHS24; + const double f25 = 1.0 / m_A73; + const double f25_41 = -f25 * m_A135; + m_A137 += m_A74 * f25_41; + RHS41 += f25_41 * RHS25; + const double f26 = 1.0 / m_A75; + const double f26_70 = -f26 * m_A322; + m_A323 += m_A76 * f26_70; + RHS70 += f26_70 * RHS26; + const double f27 = 1.0 / m_A77; + const double f27_41 = -f27 * m_A136; + m_A137 += m_A78 * f27_41; + m_A138 += m_A79 * f27_41; + m_A139 += m_A80 * f27_41; + RHS41 += f27_41 * RHS27; + const double f27_62 = -f27 * m_A256; + m_A257 += m_A78 * f27_62; + m_A258 += m_A79 * f27_62; + m_A259 += m_A80 * f27_62; + RHS62 += f27_62 * RHS27; + const double f27_68 = -f27 * m_A303; + m_A305 += m_A78 * f27_68; + m_A307 += m_A79 * f27_68; + m_A309 += m_A80 * f27_68; + RHS68 += f27_68 * RHS27; + const double f28 = 1.0 / m_A81; + const double f28_49 = -f28 * m_A175; + m_A177 += m_A82 * f28_49; + m_A179 += m_A83 * f28_49; + RHS49 += f28_49 * RHS28; + const double f28_75 = -f28 * m_A381; + m_A385 += m_A82 * f28_75; + m_A398 += m_A83 * f28_75; + RHS75 += f28_75 * RHS28; + const double f29 = 1.0 / m_A84; + const double f29_55 = -f29 * m_A208; + m_A211 += m_A85 * f29_55; + m_A212 += m_A86 * f29_55; + m_A213 += m_A87 * f29_55; + RHS55 += f29_55 * RHS29; + const double f29_58 = -f29 * m_A225; + m_A226 += m_A85 * f29_58; + m_A227 += m_A86 * f29_58; + m_A228 += m_A87 * f29_58; + RHS58 += f29_58 * RHS29; + const double f29_60 = -f29 * m_A241; + m_A243 += m_A85 * f29_60; + m_A244 += m_A86 * f29_60; + m_A245 += m_A87 * f29_60; + RHS60 += f29_60 * RHS29; + const double f30 = 1.0 / m_A88; + const double f30_61 = -f30 * m_A251; + m_A253 += m_A89 * f30_61; + m_A255 += m_A90 * f30_61; + RHS61 += f30_61 * RHS30; + const double f30_75 = -f30 * m_A382; + m_A390 += m_A89 * f30_75; + m_A398 += m_A90 * f30_75; + RHS75 += f30_75 * RHS30; + const double f31 = 1.0 / m_A91; + const double f31_46 = -f31 * m_A159; + m_A160 += m_A92 * f31_46; + m_A161 += m_A93 * f31_46; + m_A163 += m_A94 * f31_46; + RHS46 += f31_46 * RHS31; + const double f31_59 = -f31 * m_A233; + m_A234 += m_A92 * f31_59; + m_A235 += m_A93 * f31_59; + m_A237 += m_A94 * f31_59; + RHS59 += f31_59 * RHS31; + const double f32 = 1.0 / m_A95; + const double f32_64 = -f32 * m_A264; + m_A265 += m_A96 * f32_64; + m_A266 += m_A97 * f32_64; + RHS64 += f32_64 * RHS32; + const double f32_65 = -f32 * m_A270; + m_A275 += m_A96 * f32_65; + m_A276 += m_A97 * f32_65; + RHS65 += f32_65 * RHS32; + const double f33 = 1.0 / m_A98; + const double f33_49 = -f33 * m_A176; + m_A177 += m_A99 * f33_49; + m_A178 += m_A100 * f33_49; + RHS49 += f33_49 * RHS33; + const double f33_55 = -f33 * m_A209; + m_A210 += m_A99 * f33_55; + m_A211 += m_A100 * f33_55; + RHS55 += f33_55 * RHS33; + const double f34 = 1.0 / m_A101; + const double f34_60 = -f34 * m_A242; + m_A245 += m_A102 * f34_60; + m_A249 += m_A103 * f34_60; + RHS60 += f34_60 * RHS34; + const double f34_74 = -f34 * m_A363; + m_A368 += m_A102 * f34_74; + m_A377 += m_A103 * f34_74; + RHS74 += f34_74 * RHS34; + const double f35 = 1.0 / m_A104; + const double f35_61 = -f35 * m_A252; + m_A253 += m_A105 * f35_61; + m_A254 += m_A106 * f35_61; + RHS61 += f35_61 * RHS35; + const double f35_74 = -f35 * m_A364; + m_A369 += m_A105 * f35_74; + m_A377 += m_A106 * f35_74; + RHS74 += f35_74 * RHS35; + const double f36 = 1.0 / m_A107; + const double f36_74 = -f36 * m_A365; + m_A377 += m_A108 * f36_74; + RHS74 += f36_74 * RHS36; + const double f37 = 1.0 / m_A110; + const double f37_68 = -f37 * m_A304; + m_A309 += m_A111 * f37_68; + RHS68 += f37_68 * RHS37; + const double f38 = 1.0 / m_A114; + const double f38_39 = -f38 * m_A119; + m_A120 += m_A115 * f38_39; + m_A121 += m_A116 * f38_39; + RHS39 += f38_39 * RHS38; + const double f38_40 = -f38 * m_A128; + m_A129 += m_A115 * f38_40; + m_A130 += m_A116 * f38_40; + RHS40 += f38_40 * RHS38; + const double f39 = 1.0 / m_A120; + const double f39_40 = -f39 * m_A129; + m_A130 += m_A121 * f39_40; + m_A131 += m_A122 * f39_40; + m_A132 += m_A123 * f39_40; + m_A134 += m_A124 * f39_40; + RHS40 += f39_40 * RHS39; + const double f39_50 = -f39 * m_A183; + m_A184 += m_A121 * f39_50; + m_A185 += m_A122 * f39_50; + m_A186 += m_A123 * f39_50; + m_A189 += m_A124 * f39_50; + RHS50 += f39_50 * RHS39; + const double f39_67 = -f39 * m_A294; + m_A295 += m_A121 * f39_67; + m_A297 += m_A122 * f39_67; + m_A298 += m_A123 * f39_67; + m_A301 += m_A124 * f39_67; + RHS67 += f39_67 * RHS39; + const double f39_75 = -f39 * m_A383; + m_A384 += m_A121 * f39_75; + m_A386 += m_A122 * f39_75; + m_A391 += m_A123 * f39_75; + m_A398 += m_A124 * f39_75; + RHS75 += f39_75 * RHS39; + const double f40 = 1.0 / m_A130; + const double f40_50 = -f40 * m_A184; + m_A185 += m_A131 * f40_50; + m_A186 += m_A132 * f40_50; + m_A188 += m_A133 * f40_50; + m_A189 += m_A134 * f40_50; + RHS50 += f40_50 * RHS40; + const double f40_67 = -f40 * m_A295; + m_A297 += m_A131 * f40_67; + m_A298 += m_A132 * f40_67; + m_A300 += m_A133 * f40_67; + m_A301 += m_A134 * f40_67; + RHS67 += f40_67 * RHS40; + const double f40_69 = -f40 * m_A314; + m_A315 += m_A131 * f40_69; + m_A318 += m_A132 * f40_69; + m_A320 += m_A133 * f40_69; + m_A321 += m_A134 * f40_69; + RHS69 += f40_69 * RHS40; + const double f40_75 = -f40 * m_A384; + m_A386 += m_A131 * f40_75; + m_A391 += m_A132 * f40_75; + m_A393 += m_A133 * f40_75; + m_A398 += m_A134 * f40_75; + RHS75 += f40_75 * RHS40; + const double f41 = 1.0 / m_A137; + const double f41_62 = -f41 * m_A257; + m_A258 += m_A138 * f41_62; + m_A259 += m_A139 * f41_62; + RHS62 += f41_62 * RHS41; + const double f41_68 = -f41 * m_A305; + m_A307 += m_A138 * f41_68; + m_A309 += m_A139 * f41_68; + RHS68 += f41_68 * RHS41; + const double f42 = 1.0 / m_A140; + const double f42_63 = -f42 * m_A261; + m_A262 += m_A141 * f42_63; + m_A263 += m_A142 * f42_63; + RHS63 += f42_63 * RHS42; + const double f42_70 = -f42 * m_A323; + m_A325 += m_A141 * f42_70; + m_A326 += m_A142 * f42_70; + RHS70 += f42_70 * RHS42; + const double f43 = 1.0 / m_A144; + const double f43_46 = -f43 * m_A160; + m_A161 += m_A145 * f43_46; + m_A162 += m_A146 * f43_46; + RHS46 += f43_46 * RHS43; + const double f43_59 = -f43 * m_A234; + m_A235 += m_A145 * f43_59; + m_A236 += m_A146 * f43_59; + RHS59 += f43_59 * RHS43; + const double f44 = 1.0 / m_A149; + const double f44_67 = -f44 * m_A296; + m_A298 += m_A150 * f44_67; + RHS67 += f44_67 * RHS44; + const double f45 = 1.0 / m_A153; + const double f45_52 = -f45 * m_A195; + m_A196 += m_A154 * f45_52; + m_A199 += m_A155 * f45_52; + m_A200 += m_A156 * f45_52; + RHS52 += f45_52 * RHS45; + const double f45_72 = -f45 * m_A339; + m_A341 += m_A154 * f45_72; + m_A348 += m_A155 * f45_72; + m_A349 += m_A156 * f45_72; + RHS72 += f45_72 * RHS45; + const double f45_73 = -f45 * m_A353; + m_A354 += m_A154 * f45_73; + m_A359 += m_A155 * f45_73; + m_A360 += m_A156 * f45_73; + RHS73 += f45_73 * RHS45; + const double f46 = 1.0 / m_A161; + const double f46_48 = -f46 * m_A170; + m_A171 += m_A162 * f46_48; + m_A172 += m_A163 * f46_48; + m_A174 += m_A164 * f46_48; + RHS48 += f46_48 * RHS46; + const double f46_59 = -f46 * m_A235; + m_A236 += m_A162 * f46_59; + m_A237 += m_A163 * f46_59; + m_A239 += m_A164 * f46_59; + RHS59 += f46_59 * RHS46; + const double f46_66 = -f46 * m_A284; + m_A285 += m_A162 * f46_66; + m_A286 += m_A163 * f46_66; + m_A288 += m_A164 * f46_66; + RHS66 += f46_66 * RHS46; + const double f47 = 1.0 / m_A166; + const double f47_65 = -f47 * m_A271; + m_A276 += m_A167 * f47_65; + RHS65 += f47_65 * RHS47; + const double f48 = 1.0 / m_A171; + const double f48_59 = -f48 * m_A236; + m_A237 += m_A172 * f48_59; + m_A238 += m_A173 * f48_59; + m_A239 += m_A174 * f48_59; + RHS59 += f48_59 * RHS48; + const double f48_65 = -f48 * m_A272; + m_A274 += m_A172 * f48_65; + m_A276 += m_A173 * f48_65; + m_A277 += m_A174 * f48_65; + RHS65 += f48_65 * RHS48; + const double f48_66 = -f48 * m_A285; + m_A286 += m_A172 * f48_66; + m_A287 += m_A173 * f48_66; + m_A288 += m_A174 * f48_66; + RHS66 += f48_66 * RHS48; + const double f49 = 1.0 / m_A177; + const double f49_55 = -f49 * m_A210; + m_A211 += m_A178 * f49_55; + m_A214 += m_A179 * f49_55; + RHS55 += f49_55 * RHS49; + const double f49_75 = -f49 * m_A385; + m_A387 += m_A178 * f49_75; + m_A398 += m_A179 * f49_75; + RHS75 += f49_75 * RHS49; + const double f50 = 1.0 / m_A185; + const double f50_67 = -f50 * m_A297; + m_A298 += m_A186 * f50_67; + m_A299 += m_A187 * f50_67; + m_A300 += m_A188 * f50_67; + m_A301 += m_A189 * f50_67; + RHS67 += f50_67 * RHS50; + const double f50_68 = -f50 * m_A306; + m_A308 += m_A186 * f50_68; + m_A309 += m_A187 * f50_68; + m_A310 += m_A188 * f50_68; + m_A311 += m_A189 * f50_68; + RHS68 += f50_68 * RHS50; + const double f50_69 = -f50 * m_A315; + m_A318 += m_A186 * f50_69; + m_A319 += m_A187 * f50_69; + m_A320 += m_A188 * f50_69; + m_A321 += m_A189 * f50_69; + RHS69 += f50_69 * RHS50; + const double f50_75 = -f50 * m_A386; + m_A391 += m_A186 * f50_75; + m_A392 += m_A187 * f50_75; + m_A393 += m_A188 * f50_75; + m_A398 += m_A189 * f50_75; + RHS75 += f50_75 * RHS50; + const double f51 = 1.0 / m_A191; + const double f51_65 = -f51 * m_A273; + m_A276 += m_A192 * f51_65; + m_A278 += m_A193 * f51_65; + RHS65 += f51_65 * RHS51; + const double f51_72 = -f51 * m_A340; + m_A345 += m_A192 * f51_72; + m_A348 += m_A193 * f51_72; + RHS72 += f51_72 * RHS51; + const double f52 = 1.0 / m_A196; + const double f52_71 = -f52 * m_A329; + m_A330 += m_A197 * f52_71; + m_A333 += m_A198 * f52_71; + m_A334 += m_A199 * f52_71; + m_A335 += m_A200 * f52_71; + RHS71 += f52_71 * RHS52; + const double f52_72 = -f52 * m_A341; + m_A342 += m_A197 * f52_72; + m_A347 += m_A198 * f52_72; + m_A348 += m_A199 * f52_72; + m_A349 += m_A200 * f52_72; + RHS72 += f52_72 * RHS52; + const double f52_73 = -f52 * m_A354; + m_A355 += m_A197 * f52_73; + m_A358 += m_A198 * f52_73; + m_A359 += m_A199 * f52_73; + m_A360 += m_A200 * f52_73; + RHS73 += f52_73 * RHS52; + const double f53 = 1.0 / m_A202; + const double f53_71 = -f53 * m_A330; + m_A333 += m_A203 * f53_71; + m_A335 += m_A204 * f53_71; + RHS71 += f53_71 * RHS53; + const double f53_72 = -f53 * m_A342; + m_A347 += m_A203 * f53_72; + m_A349 += m_A204 * f53_72; + RHS72 += f53_72 * RHS53; + const double f53_73 = -f53 * m_A355; + m_A358 += m_A203 * f53_73; + m_A360 += m_A204 * f53_73; + RHS73 += f53_73 * RHS53; + const double f54 = 1.0 / m_A206; + const double f54_69 = -f54 * m_A316; + m_A320 += m_A207 * f54_69; + RHS69 += f54_69 * RHS54; + const double f55 = 1.0 / m_A211; + const double f55_58 = -f55 * m_A226; + m_A227 += m_A212 * f55_58; + m_A228 += m_A213 * f55_58; + m_A232 += m_A214 * f55_58; + RHS58 += f55_58 * RHS55; + const double f55_60 = -f55 * m_A243; + m_A244 += m_A212 * f55_60; + m_A245 += m_A213 * f55_60; + m_A250 += m_A214 * f55_60; + RHS60 += f55_60 * RHS55; + const double f55_75 = -f55 * m_A387; + m_A388 += m_A212 * f55_75; + m_A389 += m_A213 * f55_75; + m_A398 += m_A214 * f55_75; + RHS75 += f55_75 * RHS55; + const double f56 = 1.0 / m_A218; + const double f56_69 = -f56 * m_A317; + m_A320 += m_A219 * f56_69; + RHS69 += f56_69 * RHS56; + const double f57 = 1.0 / m_A220; + const double f57_70 = -f57 * m_A324; + m_A326 += m_A221 * f57_70; + m_A327 += m_A222 * f57_70; + RHS70 += f57_70 * RHS57; + const double f57_74 = -f57 * m_A366; + m_A373 += m_A221 * f57_74; + m_A377 += m_A222 * f57_74; + RHS74 += f57_74 * RHS57; + const double f58 = 1.0 / m_A227; + const double f58_60 = -f58 * m_A244; + m_A245 += m_A228 * f58_60; + m_A246 += m_A229 * f58_60; + m_A247 += m_A230 * f58_60; + m_A248 += m_A231 * f58_60; + m_A250 += m_A232 * f58_60; + RHS60 += f58_60 * RHS58; + const double f58_71 = -f58 * m_A331; + m_A332 += m_A228 * f58_71; + m_A333 += m_A229 * f58_71; + m_A334 += m_A230 * f58_71; + m_A335 += m_A231 * f58_71; + m_A337 += m_A232 * f58_71; + RHS71 += f58_71 * RHS58; + const double f58_72 = -f58 * m_A343; + m_A344 += m_A228 * f58_72; + m_A347 += m_A229 * f58_72; + m_A348 += m_A230 * f58_72; + m_A349 += m_A231 * f58_72; + m_A351 += m_A232 * f58_72; + RHS72 += f58_72 * RHS58; + const double f58_73 = -f58 * m_A356; + m_A357 += m_A228 * f58_73; + m_A358 += m_A229 * f58_73; + m_A359 += m_A230 * f58_73; + m_A360 += m_A231 * f58_73; + m_A362 += m_A232 * f58_73; + RHS73 += f58_73 * RHS58; + const double f58_75 = -f58 * m_A388; + m_A389 += m_A228 * f58_75; + m_A394 += m_A229 * f58_75; + m_A395 += m_A230 * f58_75; + m_A396 += m_A231 * f58_75; + m_A398 += m_A232 * f58_75; + RHS75 += f58_75 * RHS58; + const double f59 = 1.0 / m_A237; + const double f59_65 = -f59 * m_A274; + m_A276 += m_A238 * f59_65; + m_A277 += m_A239 * f59_65; + m_A279 += m_A240 * f59_65; + RHS65 += f59_65 * RHS59; + const double f59_66 = -f59 * m_A286; + m_A287 += m_A238 * f59_66; + m_A288 += m_A239 * f59_66; + m_A290 += m_A240 * f59_66; + RHS66 += f59_66 * RHS59; + const double f59_74 = -f59 * m_A367; + m_A371 += m_A238 * f59_74; + m_A372 += m_A239 * f59_74; + m_A377 += m_A240 * f59_74; + RHS74 += f59_74 * RHS59; + const double f60 = 1.0 / m_A245; + const double f60_71 = -f60 * m_A332; + m_A333 += m_A246 * f60_71; + m_A334 += m_A247 * f60_71; + m_A335 += m_A248 * f60_71; + m_A336 += m_A249 * f60_71; + m_A337 += m_A250 * f60_71; + RHS71 += f60_71 * RHS60; + const double f60_72 = -f60 * m_A344; + m_A347 += m_A246 * f60_72; + m_A348 += m_A247 * f60_72; + m_A349 += m_A248 * f60_72; + m_A350 += m_A249 * f60_72; + m_A351 += m_A250 * f60_72; + RHS72 += f60_72 * RHS60; + const double f60_73 = -f60 * m_A357; + m_A358 += m_A246 * f60_73; + m_A359 += m_A247 * f60_73; + m_A360 += m_A248 * f60_73; + m_A361 += m_A249 * f60_73; + m_A362 += m_A250 * f60_73; + RHS73 += f60_73 * RHS60; + const double f60_74 = -f60 * m_A368; + m_A374 += m_A246 * f60_74; + m_A375 += m_A247 * f60_74; + m_A376 += m_A248 * f60_74; + m_A377 += m_A249 * f60_74; + m_A378 += m_A250 * f60_74; + RHS74 += f60_74 * RHS60; + const double f60_75 = -f60 * m_A389; + m_A394 += m_A246 * f60_75; + m_A395 += m_A247 * f60_75; + m_A396 += m_A248 * f60_75; + m_A397 += m_A249 * f60_75; + m_A398 += m_A250 * f60_75; + RHS75 += f60_75 * RHS60; + const double f61 = 1.0 / m_A253; + const double f61_74 = -f61 * m_A369; + m_A377 += m_A254 * f61_74; + m_A378 += m_A255 * f61_74; + RHS74 += f61_74 * RHS61; + const double f61_75 = -f61 * m_A390; + m_A397 += m_A254 * f61_75; + m_A398 += m_A255 * f61_75; + RHS75 += f61_75 * RHS61; + const double f62 = 1.0 / m_A258; + const double f62_68 = -f62 * m_A307; + m_A309 += m_A259 * f62_68; + RHS68 += f62_68 * RHS62; + const double f63 = 1.0 / m_A262; + const double f63_70 = -f63 * m_A325; + m_A326 += m_A263 * f63_70; + RHS70 += f63_70 * RHS63; + const double f64 = 1.0 / m_A265; + const double f64_65 = -f64 * m_A275; + m_A276 += m_A266 * f64_65; + m_A279 += m_A267 * f64_65; + RHS65 += f64_65 * RHS64; + const double f64_74 = -f64 * m_A370; + m_A371 += m_A266 * f64_74; + m_A377 += m_A267 * f64_74; + RHS74 += f64_74 * RHS64; + const double f65 = 1.0 / m_A276; + const double f65_66 = -f65 * m_A287; + m_A288 += m_A277 * f65_66; + m_A289 += m_A278 * f65_66; + m_A290 += m_A279 * f65_66; + RHS66 += f65_66 * RHS65; + const double f65_72 = -f65 * m_A345; + m_A346 += m_A277 * f65_72; + m_A348 += m_A278 * f65_72; + m_A350 += m_A279 * f65_72; + RHS72 += f65_72 * RHS65; + const double f65_74 = -f65 * m_A371; + m_A372 += m_A277 * f65_74; + m_A375 += m_A278 * f65_74; + m_A377 += m_A279 * f65_74; + RHS74 += f65_74 * RHS65; + const double f66 = 1.0 / m_A288; + const double f66_72 = -f66 * m_A346; + m_A348 += m_A289 * f66_72; + m_A350 += m_A290 * f66_72; + RHS72 += f66_72 * RHS66; + const double f66_74 = -f66 * m_A372; + m_A375 += m_A289 * f66_74; + m_A377 += m_A290 * f66_74; + RHS74 += f66_74 * RHS66; + const double f67 = 1.0 / m_A298; + const double f67_68 = -f67 * m_A308; + m_A309 += m_A299 * f67_68; + m_A310 += m_A300 * f67_68; + m_A311 += m_A301 * f67_68; + RHS68 += f67_68 * RHS67; + const double f67_69 = -f67 * m_A318; + m_A319 += m_A299 * f67_69; + m_A320 += m_A300 * f67_69; + m_A321 += m_A301 * f67_69; + RHS69 += f67_69 * RHS67; + const double f67_75 = -f67 * m_A391; + m_A392 += m_A299 * f67_75; + m_A393 += m_A300 * f67_75; + m_A398 += m_A301 * f67_75; + RHS75 += f67_75 * RHS67; + const double f68 = 1.0 / m_A309; + const double f68_69 = -f68 * m_A319; + m_A320 += m_A310 * f68_69; + m_A321 += m_A311 * f68_69; + RHS69 += f68_69 * RHS68; + const double f68_75 = -f68 * m_A392; + m_A393 += m_A310 * f68_75; + m_A398 += m_A311 * f68_75; + RHS75 += f68_75 * RHS68; + const double f69 = 1.0 / m_A320; + const double f69_75 = -f69 * m_A393; + m_A398 += m_A321 * f69_75; + RHS75 += f69_75 * RHS69; + const double f70 = 1.0 / m_A326; + const double f70_74 = -f70 * m_A373; + m_A377 += m_A327 * f70_74; + RHS74 += f70_74 * RHS70; + const double f71 = 1.0 / m_A333; + const double f71_72 = -f71 * m_A347; + m_A348 += m_A334 * f71_72; + m_A349 += m_A335 * f71_72; + m_A350 += m_A336 * f71_72; + m_A351 += m_A337 * f71_72; + RHS72 += f71_72 * RHS71; + const double f71_73 = -f71 * m_A358; + m_A359 += m_A334 * f71_73; + m_A360 += m_A335 * f71_73; + m_A361 += m_A336 * f71_73; + m_A362 += m_A337 * f71_73; + RHS73 += f71_73 * RHS71; + const double f71_74 = -f71 * m_A374; + m_A375 += m_A334 * f71_74; + m_A376 += m_A335 * f71_74; + m_A377 += m_A336 * f71_74; + m_A378 += m_A337 * f71_74; + RHS74 += f71_74 * RHS71; + const double f71_75 = -f71 * m_A394; + m_A395 += m_A334 * f71_75; + m_A396 += m_A335 * f71_75; + m_A397 += m_A336 * f71_75; + m_A398 += m_A337 * f71_75; + RHS75 += f71_75 * RHS71; + const double f72 = 1.0 / m_A348; + const double f72_73 = -f72 * m_A359; + m_A360 += m_A349 * f72_73; + m_A361 += m_A350 * f72_73; + m_A362 += m_A351 * f72_73; + RHS73 += f72_73 * RHS72; + const double f72_74 = -f72 * m_A375; + m_A376 += m_A349 * f72_74; + m_A377 += m_A350 * f72_74; + m_A378 += m_A351 * f72_74; + RHS74 += f72_74 * RHS72; + const double f72_75 = -f72 * m_A395; + m_A396 += m_A349 * f72_75; + m_A397 += m_A350 * f72_75; + m_A398 += m_A351 * f72_75; + RHS75 += f72_75 * RHS72; + const double f73 = 1.0 / m_A360; + const double f73_74 = -f73 * m_A376; + m_A377 += m_A361 * f73_74; + m_A378 += m_A362 * f73_74; + RHS74 += f73_74 * RHS73; + const double f73_75 = -f73 * m_A396; + m_A397 += m_A361 * f73_75; + m_A398 += m_A362 * f73_75; + RHS75 += f73_75 * RHS73; + const double f74 = 1.0 / m_A377; + const double f74_75 = -f74 * m_A397; + m_A398 += m_A378 * f74_75; + RHS75 += f74_75 * RHS74; + V[75] = RHS75 / m_A398; + double tmp74 = 0.0; + tmp74 += m_A378 * V[75]; + V[74] = (RHS74 - tmp74) / m_A377; + double tmp73 = 0.0; + tmp73 += m_A361 * V[74]; + tmp73 += m_A362 * V[75]; + V[73] = (RHS73 - tmp73) / m_A360; + double tmp72 = 0.0; + tmp72 += m_A349 * V[73]; + tmp72 += m_A350 * V[74]; + tmp72 += m_A351 * V[75]; + V[72] = (RHS72 - tmp72) / m_A348; + double tmp71 = 0.0; + tmp71 += m_A334 * V[72]; + tmp71 += m_A335 * V[73]; + tmp71 += m_A336 * V[74]; + tmp71 += m_A337 * V[75]; + V[71] = (RHS71 - tmp71) / m_A333; + double tmp70 = 0.0; + tmp70 += m_A327 * V[74]; + V[70] = (RHS70 - tmp70) / m_A326; + double tmp69 = 0.0; + tmp69 += m_A321 * V[75]; + V[69] = (RHS69 - tmp69) / m_A320; + double tmp68 = 0.0; + tmp68 += m_A310 * V[69]; + tmp68 += m_A311 * V[75]; + V[68] = (RHS68 - tmp68) / m_A309; + double tmp67 = 0.0; + tmp67 += m_A299 * V[68]; + tmp67 += m_A300 * V[69]; + tmp67 += m_A301 * V[75]; + V[67] = (RHS67 - tmp67) / m_A298; + double tmp66 = 0.0; + tmp66 += m_A289 * V[72]; + tmp66 += m_A290 * V[74]; + V[66] = (RHS66 - tmp66) / m_A288; + double tmp65 = 0.0; + tmp65 += m_A277 * V[66]; + tmp65 += m_A278 * V[72]; + tmp65 += m_A279 * V[74]; + V[65] = (RHS65 - tmp65) / m_A276; + double tmp64 = 0.0; + tmp64 += m_A266 * V[65]; + tmp64 += m_A267 * V[74]; + V[64] = (RHS64 - tmp64) / m_A265; + double tmp63 = 0.0; + tmp63 += m_A263 * V[70]; + V[63] = (RHS63 - tmp63) / m_A262; + double tmp62 = 0.0; + tmp62 += m_A259 * V[68]; + V[62] = (RHS62 - tmp62) / m_A258; + double tmp61 = 0.0; + tmp61 += m_A254 * V[74]; + tmp61 += m_A255 * V[75]; + V[61] = (RHS61 - tmp61) / m_A253; + double tmp60 = 0.0; + tmp60 += m_A246 * V[71]; + tmp60 += m_A247 * V[72]; + tmp60 += m_A248 * V[73]; + tmp60 += m_A249 * V[74]; + tmp60 += m_A250 * V[75]; + V[60] = (RHS60 - tmp60) / m_A245; + double tmp59 = 0.0; + tmp59 += m_A238 * V[65]; + tmp59 += m_A239 * V[66]; + tmp59 += m_A240 * V[74]; + V[59] = (RHS59 - tmp59) / m_A237; + double tmp58 = 0.0; + tmp58 += m_A228 * V[60]; + tmp58 += m_A229 * V[71]; + tmp58 += m_A230 * V[72]; + tmp58 += m_A231 * V[73]; + tmp58 += m_A232 * V[75]; + V[58] = (RHS58 - tmp58) / m_A227; + double tmp57 = 0.0; + tmp57 += m_A221 * V[70]; + tmp57 += m_A222 * V[74]; + V[57] = (RHS57 - tmp57) / m_A220; + double tmp56 = 0.0; + tmp56 += m_A219 * V[69]; + V[56] = (RHS56 - tmp56) / m_A218; + double tmp55 = 0.0; + tmp55 += m_A212 * V[58]; + tmp55 += m_A213 * V[60]; + tmp55 += m_A214 * V[75]; + V[55] = (RHS55 - tmp55) / m_A211; + double tmp54 = 0.0; + tmp54 += m_A207 * V[69]; + V[54] = (RHS54 - tmp54) / m_A206; + double tmp53 = 0.0; + tmp53 += m_A203 * V[71]; + tmp53 += m_A204 * V[73]; + V[53] = (RHS53 - tmp53) / m_A202; + double tmp52 = 0.0; + tmp52 += m_A197 * V[53]; + tmp52 += m_A198 * V[71]; + tmp52 += m_A199 * V[72]; + tmp52 += m_A200 * V[73]; + V[52] = (RHS52 - tmp52) / m_A196; + double tmp51 = 0.0; + tmp51 += m_A192 * V[65]; + tmp51 += m_A193 * V[72]; + V[51] = (RHS51 - tmp51) / m_A191; + double tmp50 = 0.0; + tmp50 += m_A186 * V[67]; + tmp50 += m_A187 * V[68]; + tmp50 += m_A188 * V[69]; + tmp50 += m_A189 * V[75]; + V[50] = (RHS50 - tmp50) / m_A185; + double tmp49 = 0.0; + tmp49 += m_A178 * V[55]; + tmp49 += m_A179 * V[75]; + V[49] = (RHS49 - tmp49) / m_A177; + double tmp48 = 0.0; + tmp48 += m_A172 * V[59]; + tmp48 += m_A173 * V[65]; + tmp48 += m_A174 * V[66]; + V[48] = (RHS48 - tmp48) / m_A171; + double tmp47 = 0.0; + tmp47 += m_A167 * V[65]; + V[47] = (RHS47 - tmp47) / m_A166; + double tmp46 = 0.0; + tmp46 += m_A162 * V[48]; + tmp46 += m_A163 * V[59]; + tmp46 += m_A164 * V[66]; + V[46] = (RHS46 - tmp46) / m_A161; + double tmp45 = 0.0; + tmp45 += m_A154 * V[52]; + tmp45 += m_A155 * V[72]; + tmp45 += m_A156 * V[73]; + V[45] = (RHS45 - tmp45) / m_A153; + double tmp44 = 0.0; + tmp44 += m_A150 * V[67]; + V[44] = (RHS44 - tmp44) / m_A149; + double tmp43 = 0.0; + tmp43 += m_A145 * V[46]; + tmp43 += m_A146 * V[48]; + V[43] = (RHS43 - tmp43) / m_A144; + double tmp42 = 0.0; + tmp42 += m_A141 * V[63]; + tmp42 += m_A142 * V[70]; + V[42] = (RHS42 - tmp42) / m_A140; + double tmp41 = 0.0; + tmp41 += m_A138 * V[62]; + tmp41 += m_A139 * V[68]; + V[41] = (RHS41 - tmp41) / m_A137; + double tmp40 = 0.0; + tmp40 += m_A131 * V[50]; + tmp40 += m_A132 * V[67]; + tmp40 += m_A133 * V[69]; + tmp40 += m_A134 * V[75]; + V[40] = (RHS40 - tmp40) / m_A130; + double tmp39 = 0.0; + tmp39 += m_A121 * V[40]; + tmp39 += m_A122 * V[50]; + tmp39 += m_A123 * V[67]; + tmp39 += m_A124 * V[75]; + V[39] = (RHS39 - tmp39) / m_A120; + double tmp38 = 0.0; + tmp38 += m_A115 * V[39]; + tmp38 += m_A116 * V[40]; + V[38] = (RHS38 - tmp38) / m_A114; + double tmp37 = 0.0; + tmp37 += m_A111 * V[68]; + V[37] = (RHS37 - tmp37) / m_A110; + double tmp36 = 0.0; + tmp36 += m_A108 * V[74]; + V[36] = (RHS36 - tmp36) / m_A107; + double tmp35 = 0.0; + tmp35 += m_A105 * V[61]; + tmp35 += m_A106 * V[74]; + V[35] = (RHS35 - tmp35) / m_A104; + double tmp34 = 0.0; + tmp34 += m_A102 * V[60]; + tmp34 += m_A103 * V[74]; + V[34] = (RHS34 - tmp34) / m_A101; + double tmp33 = 0.0; + tmp33 += m_A99 * V[49]; + tmp33 += m_A100 * V[55]; + V[33] = (RHS33 - tmp33) / m_A98; + double tmp32 = 0.0; + tmp32 += m_A96 * V[64]; + tmp32 += m_A97 * V[65]; + V[32] = (RHS32 - tmp32) / m_A95; + double tmp31 = 0.0; + tmp31 += m_A92 * V[43]; + tmp31 += m_A93 * V[46]; + tmp31 += m_A94 * V[59]; + V[31] = (RHS31 - tmp31) / m_A91; + double tmp30 = 0.0; + tmp30 += m_A89 * V[61]; + tmp30 += m_A90 * V[75]; + V[30] = (RHS30 - tmp30) / m_A88; + double tmp29 = 0.0; + tmp29 += m_A85 * V[55]; + tmp29 += m_A86 * V[58]; + tmp29 += m_A87 * V[60]; + V[29] = (RHS29 - tmp29) / m_A84; + double tmp28 = 0.0; + tmp28 += m_A82 * V[49]; + tmp28 += m_A83 * V[75]; + V[28] = (RHS28 - tmp28) / m_A81; + double tmp27 = 0.0; + tmp27 += m_A78 * V[41]; + tmp27 += m_A79 * V[62]; + tmp27 += m_A80 * V[68]; + V[27] = (RHS27 - tmp27) / m_A77; + double tmp26 = 0.0; + tmp26 += m_A76 * V[42]; + V[26] = (RHS26 - tmp26) / m_A75; + double tmp25 = 0.0; + tmp25 += m_A74 * V[41]; + V[25] = (RHS25 - tmp25) / m_A73; + double tmp24 = 0.0; + tmp24 += m_A72 * V[56]; + V[24] = (RHS24 - tmp24) / m_A71; + double tmp23 = 0.0; + tmp23 += m_A69 * V[54]; + tmp23 += m_A70 * V[69]; + V[23] = (RHS23 - tmp23) / m_A68; + double tmp22 = 0.0; + tmp22 += m_A66 * V[40]; + tmp22 += m_A67 * V[69]; + V[22] = (RHS22 - tmp22) / m_A65; + double tmp21 = 0.0; + tmp21 += m_A64 * V[56]; + V[21] = (RHS21 - tmp21) / m_A63; + double tmp20 = 0.0; + tmp20 += m_A62 * V[54]; + V[20] = (RHS20 - tmp20) / m_A61; + double tmp19 = 0.0; + tmp19 += m_A60 * V[56]; + V[19] = (RHS19 - tmp19) / m_A59; + double tmp18 = 0.0; + tmp18 += m_A57 * V[46]; + tmp18 += m_A58 * V[66]; + V[18] = (RHS18 - tmp18) / m_A56; + double tmp17 = 0.0; + tmp17 += m_A55 * V[63]; + V[17] = (RHS17 - tmp17) / m_A54; + double tmp16 = 0.0; + tmp16 += m_A52 * V[46]; + tmp16 += m_A53 * V[48]; + V[16] = (RHS16 - tmp16) / m_A51; + double tmp15 = 0.0; + tmp15 += m_A49 * V[16]; + tmp15 += m_A50 * V[48]; + V[15] = (RHS15 - tmp15) / m_A48; + double tmp14 = 0.0; + tmp14 += m_A46 * V[71]; + tmp14 += m_A47 * V[73]; + V[14] = (RHS14 - tmp14) / m_A45; + double tmp13 = 0.0; + tmp13 += m_A42 * V[48]; + tmp13 += m_A43 * V[65]; + tmp13 += m_A44 * V[66]; + V[13] = (RHS13 - tmp13) / m_A41; + double tmp12 = 0.0; + tmp12 += m_A39 * V[14]; + tmp12 += m_A40 * V[73]; + V[12] = (RHS12 - tmp12) / m_A38; + double tmp11 = 0.0; + tmp11 += m_A35 * V[45]; + tmp11 += m_A36 * V[52]; + tmp11 += m_A37 * V[72]; + V[11] = (RHS11 - tmp11) / m_A34; + double tmp10 = 0.0; + tmp10 += m_A32 * V[11]; + tmp10 += m_A33 * V[72]; + V[10] = (RHS10 - tmp10) / m_A31; + double tmp9 = 0.0; + tmp9 += m_A29 * V[51]; + tmp9 += m_A30 * V[65]; + V[9] = (RHS9 - tmp9) / m_A28; + double tmp8 = 0.0; + tmp8 += m_A24 * V[40]; + tmp8 += m_A25 * V[50]; + tmp8 += m_A26 * V[67]; + tmp8 += m_A27 * V[75]; + V[8] = (RHS8 - tmp8) / m_A23; + double tmp7 = 0.0; + tmp7 += m_A19 * V[39]; + tmp7 += m_A20 * V[50]; + tmp7 += m_A21 * V[67]; + tmp7 += m_A22 * V[75]; + V[7] = (RHS7 - tmp7) / m_A18; + double tmp6 = 0.0; + tmp6 += m_A17 * V[47]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[44]; + tmp5 += m_A15 * V[67]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[50]; + tmp4 += m_A12 * V[68]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A9 * V[44]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A5 * V[38]; + tmp2 += m_A6 * V[39]; + tmp2 += m_A7 * V[40]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[37]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[38]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // sundance static void nl_gcr_8446e63d7842f6a6_70_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -50130,6 +52623,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_8046625a0fe0959_21_double_double", reinterpret_cast(&nl_gcr_8046625a0fe0959_21_double_double)}, // mario {"nl_gcr_80b4b1e5cc58d303_29_double_double", reinterpret_cast(&nl_gcr_80b4b1e5cc58d303_29_double_double)}, +// destroyr + {"nl_gcr_8393a20a3ce0e3fa_399_double_double", reinterpret_cast(&nl_gcr_8393a20a3ce0e3fa_399_double_double)}, // sundance {"nl_gcr_8446e63d7842f6a6_70_double_double", reinterpret_cast(&nl_gcr_8446e63d7842f6a6_70_double_double)}, // dpatrol diff --git a/src/mame/audio/nl_destroyr.cpp b/src/mame/audio/nl_destroyr.cpp new file mode 100644 index 00000000000..2f3e8f7f81b --- /dev/null +++ b/src/mame/audio/nl_destroyr.cpp @@ -0,0 +1,316 @@ +// license:BSD-3-Clause +// copyright-holders:Ryan Holtz +// +// Netlist for Atari's Destroyer +// +// Derived from the schematics in the manual. +// +// Known problems/issues: +// * Sonar sound effect appears to be more noisy than a real cabinet. Unsure, as yet, why. +// + +#include "netlist/devices/net_lib.h" + +static NETLIST_START(LM324_VM5V12_DIP) + OPAMP(A, "LM324_M5V12V") + OPAMP(B, "LM324_M5V12V") + OPAMP(C, "LM324_M5V12V") + OPAMP(D, "LM324_M5V12V") + + DIPPINS( /* +--------------+ */ + A.OUT, /* |1 ++ 14| */ D.OUT, + A.MINUS, /* |2 13| */ D.MINUS, + A.PLUS, /* |3 12| */ D.PLUS, + A.VCC, /* |4 11| */ A.GND, + B.PLUS, /* |5 10| */ C.PLUS, + B.MINUS, /* |6 9| */ C.MINUS, + B.OUT, /* |7 8| */ C.OUT + /* +--------------+ */ + ) + + NET_C(A.GND, B.GND, C.GND, D.GND) + NET_C(A.VCC, B.VCC, C.VCC, D.VCC) +NETLIST_END() + +static NETLIST_START(NE556_DIP) + NE555(A) + NE555(B) + + NET_C(A.GND, B.GND) + NET_C(A.VCC, B.VCC) + + DIPPINS( /* +--------------+ */ + A.DISCH, /* 1DISCH |1 ++ 14| VCC */ A.VCC, + A.THRESH, /* 1THRES |2 13| 2DISCH */ B.DISCH, + A.CONT, /* 1CONT |3 12| 2THRES */ B.THRESH, + A.RESET, /* 1RESET |4 NE556 11| 2CONT */ B.CONT, + A.OUT, /* 1OUT |5 10| 2RESET */ B.RESET, + A.TRIG, /* 1TRIG |6 9| 2OUT */ B.OUT, + A.GND, /* GND |7 8| 2TRIG */ B.TRIG + /* +--------------+ */ + ) +NETLIST_END() + +NETLIST_START(destroyr) + + SOLVER(Solver, 48000) + ANALOG_INPUT(V5, 5) + ANALOG_INPUT(VM5, -5) + ANALOG_INPUT(V12, 12) + ALIAS(VCC, V5) + CLOCK(H256, 15750) + CLOCK(V8, 984.375) + NET_C(VCC, H256.VCC, V8.VCC) + NET_C(GND, H256.GND, V8.GND) + + NET_MODEL("LM324_M5V12V OPAMP(TYPE=3 VLH=1.1 VLL=0.11 FPF=5 UGF=50k SLEW=0.3M RI=1000k RO=50 DAB=0.00075)") + + LOCAL_SOURCE(NE556_DIP) + LOCAL_SOURCE(LM324_VM5V12_DIP) + + TTL_INPUT(MOTOR_SPEED, 0) + TTL_INPUT(NOISE, 0) + TTL_INPUT(ATTRACT, 0) + TTL_INPUT(SONGATE, 0) + TTL_INPUT(LAUNCH, 0) + TTL_INPUT(EXPLO, 0) + TTL_INPUT(SONLAT, 0) + TTL_INPUT(HE, 0) + TTL_INPUT(LE, 0) + NET_C(VCC, MOTOR_SPEED.VCC, NOISE.VCC, ATTRACT.VCC, SONGATE.VCC, LAUNCH.VCC, EXPLO.VCC, SONLAT.VCC, HE.VCC, LE.VCC) + NET_C(GND, MOTOR_SPEED.GND, NOISE.GND, ATTRACT.GND, SONGATE.GND, LAUNCH.GND, EXPLO.GND, SONLAT.GND, HE.GND, LE.GND) + + RES(R39, 220) + RES(R40, 220) + RES(R41, RES_K(2.2)) + RES(R42, RES_K(39)) + RES(R43, RES_K(150)) + RES(R44, 820) + RES(R54, RES_K(10)) + RES(R59, RES_K(470)) + RES(R60, RES_K(470)) + RES(R61, RES_K(10)) + RES(R62, RES_K(10)) + RES(R63, RES_M(10)) + RES(R64, RES_K(100)) + RES(R65, RES_K(100)) + RES(R66, RES_K(100)) + RES(R67, RES_K(10)) + RES(R68, RES_K(10)) + RES(R69, RES_K(10)) + RES(R70, RES_K(3.3)) + RES(R71, RES_K(15)) + RES(R72, RES_K(33)) + RES(R73, RES_K(10)) + RES(R74, RES_K(100)) + RES(R75, RES_K(33)) + RES(R76, RES_K(22)) + RES(R77, RES_K(47)) + RES(R78, RES_K(5.6)) + RES(R79, RES_K(33)) + RES(R80, RES_K(3.9)) + RES(R81, RES_K(3.9)) + RES(R82, RES_K(2.2)) + RES(R83, RES_K(330)) + RES(R86, 680) + RES(R88, RES_K(2.7)) + RES(R89, RES_K(10)) + RES(R92, RES_K(2.2)) + RES(R93, RES_K(2.2)) + RES(R94, RES_K(68)) + POT(R95, RES_K(50)) + + CAP(C38, CAP_U(10)) + CAP(C39, CAP_U(0.1)) + CAP(C40, CAP_U(0.1)) + CAP(C48, CAP_U(10)) + CAP(C49, CAP_P(330)) + CAP(C51, CAP_P(330)) + CAP(C52, CAP_U(0.1)) + CAP(C53, CAP_U(10)) + CAP(C56, CAP_U(0.22)) + CAP(C57, CAP_U(0.22)) + CAP(C58, CAP_U(0.22)) + CAP(C59, CAP_U(0.1)) + CAP(C61, CAP_U(0.22)) + CAP(C62, CAP_U(0.022)) + CAP(C63, CAP_U(22)) + CAP(C64, CAP_U(0.022)) + CAP(C66, CAP_U(10)) + CAP(C71, CAP_U(0.1)) + CAP(C72, CAP_U(0.1)) + CAP(C74, CAP_U(0.22)) + //CAP(C81, CAP_U(0.1)) + CAP(C85, CAP_U(22)) + + DIODE(CR2, "1N914") + + QBJT_EB(Q4, "2N3643") + QBJT_EB(Q6, "2N3643") + + TTL_7486_DIP(IC_L7) + TTL_74164_DIP(IC_L9) + TTL_74164_DIP(IC_M9) + TTL_7402_DIP(IC_K8) // Should be a 7428 positive-NOR gate + TTL_7432_DIP(IC_M8) + TTL_7400_DIP(IC_A9) + TTL_7404_DIP(IC_K9) + NET_C(VCC, IC_L9.14, IC_M9.14, IC_L7.14, IC_K8.14, IC_M8.14, IC_K9.14, IC_A9.14) + NET_C(GND, IC_L9.7, IC_M9.7, IC_L7.7, IC_K8.7, IC_M8.7, IC_K9.7, IC_A9.7) + + SUBMODEL(NE556_DIP, IC_H8) + NET_C(VCC, IC_H8.14) + NET_C(GND, IC_H8.7) + + MC3340_DIP(IC_D10) + NET_C(VCC, IC_D10.8) + NET_C(VM5, IC_D10.3) + + CD4066_DIP(IC_E9) + NET_C(VCC, IC_E9.14) + NET_C(GND, IC_E9.7) + + SUBMODEL(LM324_VM5V12_DIP, IC_C9) + SUBMODEL(LM324_VM5V12_DIP, IC_H9) + NET_C(V12, IC_C9.4, IC_H9.4) + NET_C(VM5, IC_C9.11, IC_H9.11) + + // Tie off unused gates and pins + NET_C(GND, IC_L7.1, IC_L7.2) + NET_C(GND, IC_L7.4, IC_L7.5) + NET_C(GND, IC_L7.9, IC_L7.10) + NET_C(GND, IC_M8.4, IC_M8.5) + NET_C(GND, IC_M8.9, IC_M8.10) + NET_C(GND, IC_M8.12, IC_M8.13) + NET_C(GND, IC_A9.1, IC_A9.2) + NET_C(GND, IC_A9.9, IC_A9.10) + NET_C(GND, IC_A9.12, IC_A9.13) + NET_C(GND, IC_K9.1, IC_K9.5, IC_K9.9, IC_K9.11, IC_K9.13) + NET_C(GND, IC_H8.5, IC_H8.9) + NET_C(VCC, IC_H8.4, IC_H8.10) + + // Noise Clock + NET_C(H256.Q, IC_K8.2) + NET_C(EXPLO.Q, IC_K8.3) + NET_C(V8.Q, IC_K8.5) + NET_C(SONLAT.Q, IC_K8.6) + NET_C(IC_K8.1, IC_M8.1) + NET_C(IC_K8.4, IC_M8.2) + ALIAS(NOISECLK, IC_M8.3) + + // Noise + NET_C(NOISE.Q, IC_L9.9, IC_M9.9) + NET_C(NOISECLK, IC_L9.8, IC_M9.8) + NET_C(IC_M9.12, IC_K9.3) + NET_C(IC_K9.4, IC_L7.13) + NET_C(IC_M9.11, IC_L7.12) + ALIAS(RNOISE, IC_M9.11) + NET_C(IC_L7.11, IC_L9.1, IC_L9.2) + NET_C(IC_L9.13, IC_M9.1, IC_M9.2) + + // Explosions + NET_C(SONLAT.Q, IC_K8.9) + NET_C(EXPLO.Q, IC_K8.8) + NET_C(IC_K8.10, CR2.A, R39.2, IC_K8.11) + NET_C(RNOISE, IC_K8.12) + NET_C(V5, R39.1, R68.1) + NET_C(IC_K8.13, IC_E9.5) + NET_C(CR2.K, C38.1, IC_E9.4) + NET_C(GND, C38.2, R70.2, R61.2, C48.2, R73.2, R86.2, C53.2, R67.2, Q6.E, Q4.E, C85.2) + NET_C(IC_E9.3, R74.1, IC_E9.11, R71.1) + NET_C(LE.Q, IC_E9.13) + NET_C(HE.Q, IC_E9.12) + NET_C(R71.2, C52.1, R70.1) + NET_C(C52.2, R66.1) + NET_C(R66.2, IC_H9.10, R63.1) + NET_C(IC_H9.9, R64.1, R65.1) + NET_C(IC_H9.8, R64.2, R60.1) + NET_C(R60.2, C49.1, IC_H9.6) + NET_C(C49.2, IC_H9.7, R59.1, R63.2, R72.1) + NET_C(IC_H9.5, IC_H9.3, R62.2, R61.1, C48.1) + NET_C(V12, R62.1) + NET_C(R59.2, C51.1, IC_H9.2) + NET_C(IC_H9.1, C51.2, R65.2) + NET_C(SONGATE.Q, IC_E9.6) + NET_C(R72.2, R73.1, IC_E9.8, R82.1) + NET_C(R74.2, R86.1, C71.1, C72.1) + NET_C(R68.2, R67.1, C53.1, IC_H9.12, IC_C9.3) + NET_C(C71.2, R83.1, IC_H9.13) + NET_C(C72.2, R83.2, IC_H9.14, R69.1) + NET_C(R69.2, IC_E9.1) + NET_C(IC_E9.2, R79.1, IC_C9.2) + NET_C(IC_C9.1, R79.2, C61.1) + NET_C(C61.2, R78.1) + NET_C(IC_E9.10, C57.1) + NET_C(C57.2, R77.1) + NET_C(IC_E9.9, C56.1) + NET_C(C56.2, R76.1) + + // Launch + NET_C(RNOISE, IC_A9.4) + NET_C(LAUNCH.Q, IC_A9.5) + NET_C(IC_A9.6, R81.1) + NET_C(R81.2, C64.1) + NET_C(C64.2, IC_C9.9, R80.1, C62.1) + NET_C(C62.2, R80.2, IC_C9.8, C58.1) + NET_C(GND, IC_C9.10) + NET_C(C58.2, R75.1) + + // Motor + NET_C(MOTOR_SPEED.Q, R44.1) + NET_C(R44.2, R40.2, IC_H8.3, IC_H8.11, C63.1) + NET_C(V5, R40.1, R41.1, R54.1, R89.1) + NET_C(R41.2, R42.1, IC_H8.1) + NET_C(R42.2, IC_H8.2, IC_H8.6, C39.1, IC_C9.5) + NET_C(R54.2, R43.1, IC_H8.13) + NET_C(R43.2, IC_H8.8, IC_H8.12, C40.1, IC_C9.12) + NET_C(C63.2, IC_C9.13, IC_C9.14, C66.2) + NET_C(GND, C39.2, C40.2) + NET_C(IC_C9.6, IC_C9.7, C59.2) + NET_C(C59.1, IC_D10.1) + NET_C(C66.1, R88.2, R89.2, IC_D10.2) + NET_C(VM5, R88.1) + NET_C(IC_D10.6, Q4.C) + NET_C(IC_D10.7, C74.1) + NET_C(C74.2, R94.1) + + // Attract Mute + NET_C(ATTRACT.Q, R92.1, R93.1) + NET_C(R92.2, C85.1, Q4.B) + NET_C(R93.2, Q6.B) + NET_C(Q6.C, R82.2) + + // Mixer + NET_C(GND, R95.1) + NET_C(R94.2, R75.2, R76.2, R77.2, R78.2, R95.3) + ALIAS(OUTPUT, R95.2) + + // Unconnected pins + HINT(IC_A9.3, NC) + HINT(IC_A9.8, NC) + HINT(IC_A9.11, NC) + HINT(IC_K9.2, NC) + HINT(IC_K9.6, NC) + HINT(IC_K9.8, NC) + HINT(IC_K9.10, NC) + HINT(IC_K9.12, NC) + HINT(IC_L9.3, NC) + HINT(IC_L9.4, NC) + HINT(IC_L9.5, NC) + HINT(IC_L9.6, NC) + HINT(IC_L9.10, NC) + HINT(IC_L9.11, NC) + HINT(IC_L9.12, NC) + HINT(IC_M9.3, NC) + HINT(IC_M9.4, NC) + HINT(IC_M9.5, NC) + HINT(IC_M9.6, NC) + HINT(IC_M9.10, NC) + HINT(IC_M9.13, NC) + HINT(IC_L7.3, NC) + HINT(IC_L7.6, NC) + HINT(IC_L7.8, NC) + HINT(IC_M8.6, NC) + HINT(IC_M8.8, NC) + HINT(IC_M8.11, NC) +NETLIST_END() diff --git a/src/mame/audio/nl_destroyr.h b/src/mame/audio/nl_destroyr.h new file mode 100644 index 00000000000..676127f5ebd --- /dev/null +++ b/src/mame/audio/nl_destroyr.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Ryan Holtz +#ifndef MAME_AUDIO_NL_DESTROYR_H +#define MAME_AUDIO_NL_DESTROYR_H + +#pragma once + +NETLIST_EXTERNAL(destroyr) + +#endif // MAME_AUDIO_NL_DESTROYR_H diff --git a/src/mame/drivers/destroyr.cpp b/src/mame/drivers/destroyr.cpp index 9115b3bd4c7..0ad2419958c 100644 --- a/src/mame/drivers/destroyr.cpp +++ b/src/mame/drivers/destroyr.cpp @@ -18,6 +18,11 @@ TODO: #include "machine/watchdog.h" #include "emupal.h" #include "screen.h" +#include "speaker.h" +#include "machine/netlist.h" + +#include "netlist/nl_setup.h" +#include "audio/nl_destroyr.h" #include "destroyr.lh" @@ -25,27 +30,40 @@ TODO: class destroyr_state : public driver_device { public: - destroyr_state(const machine_config &mconfig, device_type type, const char *tag) : - driver_device(mconfig, type, tag), - m_maincpu(*this, "maincpu"), - m_watchdog(*this, "watchdog"), - m_gfxdecode(*this, "gfxdecode"), - m_screen(*this, "screen"), - m_palette(*this, "palette"), - m_alpha_num_ram(*this, "alpha_nuram"), - m_major_obj_ram(*this, "major_obj_ram"), - m_minor_obj_ram(*this, "minor_obj_ram") + destroyr_state(const machine_config &mconfig, device_type type, const char *tag) + : driver_device(mconfig, type, tag) + , m_maincpu(*this, "maincpu") + , m_watchdog(*this, "watchdog") + , m_gfxdecode(*this, "gfxdecode") + , m_screen(*this, "screen") + , m_palette(*this, "palette") + , m_inputs(*this, "IN%u", 0U) + , m_paddle(*this, "PADDLE") + , m_alpha_num_ram(*this, "alpha_nuram") + , m_major_obj_ram(*this, "major_obj_ram") + , m_minor_obj_ram(*this, "minor_obj_ram") + , m_sound_motor_speed(*this, "sound_nl:motor_speed") + , m_sound_noise(*this, "sound_nl:noise") + , m_sound_attract(*this, "sound_nl:attract") + , m_sound_songate(*this, "sound_nl:songate") + , m_sound_launch(*this, "sound_nl:launch") + , m_sound_explo(*this, "sound_nl:explo") + , m_sound_sonlat(*this, "sound_nl:sonlat") + , m_sound_hexplo(*this, "sound_nl:hexplo") + , m_sound_lexplo(*this, "sound_nl:lexplo") { } void destroyr(machine_config &config); private: + virtual void machine_start() override; + virtual void machine_reset() override; + virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override; - enum - { - TIMER_DESTROYR_DIAL, - TIMER_DESTROYR_FRAME - }; + static const device_timer_id TIMER_DIAL = 0; + static const device_timer_id TIMER_FRAME = 1; + + void main_map(address_map &map); void misc_w(uint8_t data); void cursor_load_w(uint8_t data); @@ -53,30 +71,38 @@ private: uint8_t input_r(offs_t offset); uint8_t scanline_r(); - void destroyr_palette(palette_device &palette) const; + void palette_init(palette_device &palette) const; uint32_t screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect); TIMER_CALLBACK_MEMBER(dial_callback); TIMER_CALLBACK_MEMBER(frame_callback); - virtual void machine_start() override; - virtual void machine_reset() override; - virtual void device_timer(emu_timer &timer, device_timer_id id, int param, void *ptr) override; - void destroyr_map(address_map &map); - /* devices */ required_device m_maincpu; required_device m_watchdog; required_device m_gfxdecode; required_device m_screen; required_device m_palette; + required_ioport_array<3> m_inputs; + required_ioport m_paddle; /* memory pointers */ required_shared_ptr m_alpha_num_ram; required_shared_ptr m_major_obj_ram; required_shared_ptr m_minor_obj_ram; + /* audio triggers */ + required_device m_sound_motor_speed; + required_device m_sound_noise; + required_device m_sound_attract; + required_device m_sound_songate; + required_device m_sound_launch; + required_device m_sound_explo; + required_device m_sound_sonlat; + required_device m_sound_hexplo; + required_device m_sound_lexplo; + /* video-related */ int m_cursor; int m_wavemod; @@ -85,8 +111,6 @@ private: int m_potmask[2]; int m_potsense[2]; int m_attract; - int m_motor_speed; - int m_noise; emu_timer *m_dial_timer; emu_timer *m_frame_timer; }; @@ -94,12 +118,10 @@ private: uint32_t destroyr_state::screen_update(screen_device &screen, bitmap_ind16 &bitmap, const rectangle &cliprect) { - int i, j; - bitmap.fill(0, cliprect); /* draw major objects */ - for (i = 0; i < 16; i++) + for (int i = 0; i < 16; i++) { int attr = m_major_obj_ram[2 * i + 0] ^ 0xff; int horz = m_major_obj_ram[2 * i + 1]; @@ -123,9 +145,9 @@ uint32_t destroyr_state::screen_update(screen_device &screen, bitmap_ind16 &bitm } /* draw alpha numerics */ - for (i = 0; i < 8; i++) + for (int i = 0; i < 8; i++) { - for (j = 0; j < 32; j++) + for (int j = 0; j < 32; j++) { int num = m_alpha_num_ram[32 * i + j]; @@ -134,7 +156,7 @@ uint32_t destroyr_state::screen_update(screen_device &screen, bitmap_ind16 &bitm } /* draw minor objects */ - for (i = 0; i < 2; i++) + for (int i = 0; i < 2; i++) { int num = i << 4 | (m_minor_obj_ram[i + 0] & 0xf); int horz = 256 - m_minor_obj_ram[i + 2]; @@ -144,13 +166,13 @@ uint32_t destroyr_state::screen_update(screen_device &screen, bitmap_ind16 &bitm } /* draw waves */ - for (i = 0; i < 4; i++) + for (int i = 0; i < 4; i++) { m_gfxdecode->gfx(3)->transpen(bitmap,cliprect, m_wavemod ? 1 : 0, 0, 0, 0, 64 * i, 0x4e, 0); } /* draw cursor */ - for (i = 0; i < 256; i++) + for (int i = 0; i < 256; i++) { if (i & 4) bitmap.pix16(m_cursor ^ 0xff, i) = 7; @@ -163,10 +185,10 @@ void destroyr_state::device_timer(emu_timer &timer, device_timer_id id, int para { switch (id) { - case TIMER_DESTROYR_DIAL: + case TIMER_DIAL: dial_callback(ptr, param); break; - case TIMER_DESTROYR_FRAME: + case TIMER_FRAME: frame_callback(ptr, param); break; default: @@ -201,7 +223,7 @@ TIMER_CALLBACK_MEMBER(destroyr_state::frame_callback) m_potsense[1] = 0; /* PCB supports two dials, but cab has only got one */ - m_dial_timer->adjust(m_screen->time_until_pos(ioport("PADDLE")->read())); + m_dial_timer->adjust(m_screen->time_until_pos(m_paddle->read())); m_frame_timer->adjust(m_screen->time_until_pos(0)); } @@ -217,20 +239,19 @@ void destroyr_state::machine_reset() m_potsense[0] = 0; m_potsense[1] = 0; m_attract = 0; - m_motor_speed = 0; - m_noise = 0; } void destroyr_state::misc_w(uint8_t data) { /* bits 0 to 2 connect to the sound circuits */ - m_attract = data & 0x01; - m_noise = data & 0x02; - m_motor_speed = data & 0x04; - m_potmask[0] = data & 0x08; - m_wavemod = data & 0x10; - m_potmask[1] = data & 0x20; + m_attract = BIT(data, 0); + m_sound_attract->write(m_attract); + m_sound_noise->write(BIT(data, 1)); + m_sound_motor_speed->write(BIT(data, 2)); + m_potmask[0] = BIT(data, 3); + m_wavemod = BIT(data, 4); + m_potmask[1] = BIT(data, 5); machine().bookkeeping().coin_lockout_w(0, !m_attract); machine().bookkeeping().coin_lockout_w(1, !m_attract); @@ -254,18 +275,14 @@ uint8_t destroyr_state::input_r(offs_t offset) { if (offset & 1) { - return ioport("IN1")->read(); + return m_inputs[1]->read(); } else { - uint8_t ret = ioport("IN0")->read(); - - if (m_potsense[0] && m_potmask[0]) - ret |= 4; - if (m_potsense[1] && m_potmask[1]) - ret |= 8; - + uint8_t ret = m_inputs[0]->read(); + ret |= (m_potsense[0] && m_potmask[0]) ? (1 << 2) : 0; + ret |= (m_potsense[1] && m_potmask[1]) ? (1 << 3) : 0; return ret; } } @@ -277,7 +294,7 @@ uint8_t destroyr_state::scanline_r() } -void destroyr_state::destroyr_map(address_map &map) +void destroyr_state::main_map(address_map &map) { map.global_mask(0x7fff); map(0x0000, 0x00ff).mirror(0xf00).ram(); @@ -438,7 +455,7 @@ static GFXDECODE_START( gfx_destroyr ) GFXDECODE_END -void destroyr_state::destroyr_palette(palette_device &palette) const +void destroyr_state::palette_init(palette_device &palette) const { palette.set_pen_color(0, rgb_t(0x00, 0x00, 0x00)); // major objects palette.set_pen_color(1, rgb_t(0x50, 0x50, 0x50)); @@ -453,14 +470,12 @@ void destroyr_state::destroyr_palette(palette_device &palette) const void destroyr_state::machine_start() { - m_dial_timer = timer_alloc(TIMER_DESTROYR_DIAL); - m_frame_timer = timer_alloc(TIMER_DESTROYR_FRAME); + m_dial_timer = timer_alloc(TIMER_DIAL); + m_frame_timer = timer_alloc(TIMER_FRAME); save_item(NAME(m_cursor)); save_item(NAME(m_wavemod)); save_item(NAME(m_attract)); - save_item(NAME(m_motor_speed)); - save_item(NAME(m_noise)); save_item(NAME(m_potmask)); save_item(NAME(m_potsense)); } @@ -469,18 +484,18 @@ void destroyr_state::destroyr(machine_config &config) { /* basic machine hardware */ M6800(config, m_maincpu, XTAL(12'096'000) / 16); - m_maincpu->set_addrmap(AS_PROGRAM, &destroyr_state::destroyr_map); + m_maincpu->set_addrmap(AS_PROGRAM, &destroyr_state::main_map); m_maincpu->set_periodic_int(FUNC(destroyr_state::irq0_line_assert), attotime::from_hz(4*60)); f9334_device &outlatch(F9334(config, "outlatch")); // F8 outlatch.q_out_cb<0>().set_output("led0").invert(); // LED 1 outlatch.q_out_cb<1>().set_output("led1").invert(); // LED 2 (no second LED present on cab) - // Q2 => songate - // Q3 => launch - // Q4 => explosion - // Q5 => sonar - // Q6 => high explosion - // Q7 => low explosion + outlatch.q_out_cb<2>().set(m_sound_songate, FUNC(netlist_mame_logic_input_device::write)); + outlatch.q_out_cb<3>().set(m_sound_launch, FUNC(netlist_mame_logic_input_device::write)); + outlatch.q_out_cb<4>().set(m_sound_explo, FUNC(netlist_mame_logic_input_device::write)); + outlatch.q_out_cb<5>().set(m_sound_sonlat, FUNC(netlist_mame_logic_input_device::write)); + outlatch.q_out_cb<6>().set(m_sound_hexplo, FUNC(netlist_mame_logic_input_device::write)); + outlatch.q_out_cb<7>().set(m_sound_lexplo, FUNC(netlist_mame_logic_input_device::write)); WATCHDOG_TIMER(config, m_watchdog); @@ -493,9 +508,26 @@ void destroyr_state::destroyr(machine_config &config) m_screen->set_palette(m_palette); GFXDECODE(config, m_gfxdecode, m_palette, gfx_destroyr); - PALETTE(config, m_palette, FUNC(destroyr_state::destroyr_palette), 8); + PALETTE(config, m_palette, FUNC(destroyr_state::palette_init), 8); /* sound hardware */ + SPEAKER(config, "mono").front_center(); + + NETLIST_SOUND(config, "sound_nl", 48000) + .set_source(NETLIST_NAME(destroyr)) + .add_route(ALL_OUTPUTS, "mono", 1.0); + + NETLIST_LOGIC_INPUT(config, "sound_nl:motor_speed", "MOTOR_SPEED.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:noise", "NOISE.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:attract", "ATTRACT.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:songate", "SONGATE.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:launch", "LAUNCH.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:explo", "EXPLO.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:sonlat", "SONLAT.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:hexplo", "HE.IN", 0); + NETLIST_LOGIC_INPUT(config, "sound_nl:lexplo", "LE.IN", 0); + + NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(32767.0, 0.0); } @@ -549,5 +581,5 @@ ROM_START( destroyr1 ) ROM_END -GAMEL( 1977, destroyr, 0, destroyr, destroyr, destroyr_state, empty_init, ORIENTATION_FLIP_X, "Atari", "Destroyer (version O2)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE, layout_destroyr ) -GAMEL( 1977, destroyr1, destroyr, destroyr, destroyr, destroyr_state, empty_init, ORIENTATION_FLIP_X, "Atari", "Destroyer (version O1)", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE, layout_destroyr ) +GAMEL( 1977, destroyr, 0, destroyr, destroyr, destroyr_state, empty_init, ORIENTATION_FLIP_X, "Atari", "Destroyer (version O2)", MACHINE_SUPPORTS_SAVE, layout_destroyr ) +GAMEL( 1977, destroyr1, destroyr, destroyr, destroyr, destroyr_state, empty_init, ORIENTATION_FLIP_X, "Atari", "Destroyer (version O1)", MACHINE_SUPPORTS_SAVE, layout_destroyr ) -- cgit v1.2.3