diff --git a/scripts/target/mame/arcade.lua b/scripts/target/mame/arcade.lua
index 463fa59af58..c4f075f74d3 100644
--- a/scripts/target/mame/arcade.lua
+++ b/scripts/target/mame/arcade.lua
@@ -2845,6 +2845,8 @@ files {
 	MAME_DIR .. "src/mame/drivers/seattle.cpp",
 	MAME_DIR .. "src/mame/drivers/sspeedr.cpp",
 	MAME_DIR .. "src/mame/includes/sspeedr.h",
+	MAME_DIR .. "src/mame/audio/nl_sspeedr.cpp",
+	MAME_DIR .. "src/mame/audio/nl_sspeedr.h",
 	MAME_DIR .. "src/mame/video/sspeedr.cpp",
 	MAME_DIR .. "src/mame/drivers/starrider.cpp",
 	MAME_DIR .. "src/mame/drivers/tmaster.cpp",
diff --git a/scripts/target/mame/nl.lua b/scripts/target/mame/nl.lua
index 0a20979c9aa..842f23541ca 100644
--- a/scripts/target/mame/nl.lua
+++ b/scripts/target/mame/nl.lua
@@ -212,6 +212,13 @@ files{
 	MAME_DIR .. "src/mame/audio/nl_280zzzap.cpp",
 	MAME_DIR .. "src/mame/audio/nl_280zzzap.h",
 
+	MAME_DIR .. "src/mame/drivers/sspeedr.cpp",
+	MAME_DIR .. "src/mame/includes/sspeedr.h",
+	MAME_DIR .. "src/mame/video/sspeedr.cpp",
+
+	MAME_DIR .. "src/mame/audio/nl_sspeedr.cpp",
+	MAME_DIR .. "src/mame/audio/nl_sspeedr.h",
+
 	MAME_DIR .. "src/mame/audio/cheekyms.cpp",
 	MAME_DIR .. "src/mame/audio/cheekyms.h",
 	MAME_DIR .. "src/mame/audio/nl_cheekyms.cpp",
diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp
index 7dd7da5d171..765143fe55b 100644
--- a/src/lib/netlist/generated/static_solvers.cpp
+++ b/src/lib/netlist/generated/static_solvers.cpp
@@ -2008,6 +2008,1112 @@ static void nl_gcr_1fad5cda2646cf42_30_double_double(double * __restrict V, cons
 	V[0] = (RHS0 - tmp0) / m_A0;
 }
 
+// sspeedr
+static void nl_gcr_2294220d3c91e762_176_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);
+	m_A0 += gt[0];
+	m_A0 += gt[1];
+	m_A1 += go[0];
+	double RHS0 = Idr[0];
+	RHS0 += Idr[1];
+	RHS0 -= go[1] * *cnV[1];
+	m_A2 += gt[2];
+	m_A2 += gt[3];
+	m_A2 += gt[4];
+	m_A3 += go[2];
+	double RHS1 = Idr[2];
+	RHS1 += Idr[3];
+	RHS1 += Idr[4];
+	RHS1 -= go[3] * *cnV[3];
+	RHS1 -= go[4] * *cnV[4];
+	m_A4 += gt[5];
+	m_A4 += gt[6];
+	m_A4 += gt[7];
+	m_A4 += gt[8];
+	m_A4 += gt[9];
+	m_A4 += gt[10];
+	m_A4 += gt[11];
+	m_A5 += go[5];
+	double RHS2 = Idr[5];
+	RHS2 += Idr[6];
+	RHS2 += Idr[7];
+	RHS2 += Idr[8];
+	RHS2 += Idr[9];
+	RHS2 += Idr[10];
+	RHS2 += Idr[11];
+	RHS2 -= go[6] * *cnV[6];
+	RHS2 -= go[7] * *cnV[7];
+	RHS2 -= go[8] * *cnV[8];
+	RHS2 -= go[9] * *cnV[9];
+	RHS2 -= go[10] * *cnV[10];
+	RHS2 -= go[11] * *cnV[11];
+	m_A6 += gt[12];
+	m_A6 += gt[13];
+	m_A7 += go[12];
+	double RHS3 = Idr[12];
+	RHS3 += Idr[13];
+	RHS3 -= go[13] * *cnV[13];
+	m_A8 += gt[14];
+	m_A8 += gt[15];
+	m_A9 += go[14];
+	double RHS4 = Idr[14];
+	RHS4 += Idr[15];
+	RHS4 -= go[15] * *cnV[15];
+	m_A10 += gt[16];
+	m_A10 += gt[17];
+	m_A11 += go[16];
+	m_A12 += go[17];
+	double RHS5 = Idr[16];
+	RHS5 += Idr[17];
+	m_A13 += gt[18];
+	m_A13 += gt[19];
+	m_A13 += gt[20];
+	m_A13 += gt[21];
+	m_A13 += gt[22];
+	m_A13 += gt[23];
+	m_A13 += gt[24];
+	m_A14 += go[18];
+	double RHS6 = Idr[18];
+	RHS6 += Idr[19];
+	RHS6 += Idr[20];
+	RHS6 += Idr[21];
+	RHS6 += Idr[22];
+	RHS6 += Idr[23];
+	RHS6 += Idr[24];
+	RHS6 -= go[19] * *cnV[19];
+	RHS6 -= go[20] * *cnV[20];
+	RHS6 -= go[21] * *cnV[21];
+	RHS6 -= go[22] * *cnV[22];
+	RHS6 -= go[23] * *cnV[23];
+	RHS6 -= go[24] * *cnV[24];
+	m_A15 += gt[25];
+	m_A15 += gt[26];
+	m_A15 += gt[27];
+	m_A16 += go[25];
+	double RHS7 = Idr[25];
+	RHS7 += Idr[26];
+	RHS7 += Idr[27];
+	RHS7 -= go[26] * *cnV[26];
+	RHS7 -= go[27] * *cnV[27];
+	m_A17 += gt[28];
+	m_A17 += gt[29];
+	m_A18 += go[28];
+	m_A19 += go[29];
+	double RHS8 = Idr[28];
+	RHS8 += Idr[29];
+	m_A20 += gt[30];
+	m_A20 += gt[31];
+	m_A21 += go[30];
+	double RHS9 = Idr[30];
+	RHS9 += Idr[31];
+	RHS9 -= go[31] * *cnV[31];
+	m_A22 += gt[32];
+	m_A22 += gt[33];
+	m_A23 += go[32];
+	double RHS10 = Idr[32];
+	RHS10 += Idr[33];
+	RHS10 -= go[33] * *cnV[33];
+	m_A24 += gt[34];
+	m_A24 += gt[35];
+	m_A25 += go[34];
+	double RHS11 = Idr[34];
+	RHS11 += Idr[35];
+	RHS11 -= go[35] * *cnV[35];
+	m_A26 += gt[36];
+	m_A26 += gt[37];
+	m_A26 += gt[38];
+	m_A26 += gt[39];
+	m_A26 += gt[40];
+	m_A26 += gt[41];
+	m_A26 += gt[42];
+	m_A27 += go[36];
+	double RHS12 = Idr[36];
+	RHS12 += Idr[37];
+	RHS12 += Idr[38];
+	RHS12 += Idr[39];
+	RHS12 += Idr[40];
+	RHS12 += Idr[41];
+	RHS12 += Idr[42];
+	RHS12 -= go[37] * *cnV[37];
+	RHS12 -= go[38] * *cnV[38];
+	RHS12 -= go[39] * *cnV[39];
+	RHS12 -= go[40] * *cnV[40];
+	RHS12 -= go[41] * *cnV[41];
+	RHS12 -= go[42] * *cnV[42];
+	m_A28 += gt[43];
+	m_A28 += gt[44];
+	m_A29 += go[43];
+	double RHS13 = Idr[43];
+	RHS13 += Idr[44];
+	RHS13 -= go[44] * *cnV[44];
+	m_A30 += gt[45];
+	m_A30 += gt[46];
+	m_A30 += gt[47];
+	m_A30 += gt[48];
+	m_A30 += gt[49];
+	m_A30 += gt[50];
+	m_A30 += gt[51];
+	m_A31 += go[45];
+	double RHS14 = Idr[45];
+	RHS14 += Idr[46];
+	RHS14 += Idr[47];
+	RHS14 += Idr[48];
+	RHS14 += Idr[49];
+	RHS14 += Idr[50];
+	RHS14 += Idr[51];
+	RHS14 -= go[46] * *cnV[46];
+	RHS14 -= go[47] * *cnV[47];
+	RHS14 -= go[48] * *cnV[48];
+	RHS14 -= go[49] * *cnV[49];
+	RHS14 -= go[50] * *cnV[50];
+	RHS14 -= go[51] * *cnV[51];
+	m_A32 += gt[52];
+	m_A32 += gt[53];
+	m_A33 += go[52];
+	double RHS15 = Idr[52];
+	RHS15 += Idr[53];
+	RHS15 -= go[53] * *cnV[53];
+	m_A34 += gt[54];
+	m_A34 += gt[55];
+	m_A34 += gt[56];
+	m_A34 += gt[57];
+	m_A36 += go[54];
+	m_A35 += go[55];
+	double RHS16 = Idr[54];
+	RHS16 += Idr[55];
+	RHS16 += Idr[56];
+	RHS16 += Idr[57];
+	RHS16 -= go[56] * *cnV[56];
+	RHS16 -= go[57] * *cnV[57];
+	m_A37 += gt[58];
+	m_A37 += gt[59];
+	m_A37 += gt[60];
+	m_A38 += go[58];
+	double RHS17 = Idr[58];
+	RHS17 += Idr[59];
+	RHS17 += Idr[60];
+	RHS17 -= go[59] * *cnV[59];
+	RHS17 -= go[60] * *cnV[60];
+	m_A39 += gt[61];
+	m_A39 += gt[62];
+	m_A39 += gt[63];
+	m_A39 += gt[64];
+	m_A40 += go[61];
+	m_A41 += go[62];
+	double RHS18 = Idr[61];
+	RHS18 += Idr[62];
+	RHS18 += Idr[63];
+	RHS18 += Idr[64];
+	RHS18 -= go[63] * *cnV[63];
+	RHS18 -= go[64] * *cnV[64];
+	m_A42 += gt[65];
+	m_A42 += gt[66];
+	m_A43 += go[65];
+	m_A44 += go[66];
+	double RHS19 = Idr[65];
+	RHS19 += Idr[66];
+	m_A45 += gt[67];
+	m_A45 += gt[68];
+	m_A45 += gt[69];
+	m_A46 += go[67];
+	double RHS20 = Idr[67];
+	RHS20 += Idr[68];
+	RHS20 += Idr[69];
+	RHS20 -= go[68] * *cnV[68];
+	RHS20 -= go[69] * *cnV[69];
+	m_A48 += gt[70];
+	m_A48 += gt[71];
+	m_A47 += go[70];
+	double RHS21 = Idr[70];
+	RHS21 += Idr[71];
+	RHS21 -= go[71] * *cnV[71];
+	m_A49 += gt[72];
+	m_A49 += gt[73];
+	m_A50 += go[72];
+	m_A51 += go[73];
+	double RHS22 = Idr[72];
+	RHS22 += Idr[73];
+	m_A53 += gt[74];
+	m_A53 += gt[75];
+	m_A52 += go[74];
+	double RHS23 = Idr[74];
+	RHS23 += Idr[75];
+	RHS23 -= go[75] * *cnV[75];
+	m_A55 += gt[76];
+	m_A55 += gt[77];
+	m_A55 += gt[78];
+	m_A55 += gt[79];
+	m_A54 += go[76];
+	m_A56 += go[77];
+	double RHS24 = Idr[76];
+	RHS24 += Idr[77];
+	RHS24 += Idr[78];
+	RHS24 += Idr[79];
+	RHS24 -= go[78] * *cnV[78];
+	RHS24 -= go[79] * *cnV[79];
+	m_A58 += gt[80];
+	m_A58 += gt[81];
+	m_A58 += gt[82];
+	m_A58 += gt[83];
+	m_A58 += gt[84];
+	m_A57 += go[80];
+	m_A60 += go[81];
+	m_A61 += go[82];
+	m_A59 += go[83];
+	double RHS25 = Idr[80];
+	RHS25 += Idr[81];
+	RHS25 += Idr[82];
+	RHS25 += Idr[83];
+	RHS25 += Idr[84];
+	RHS25 -= go[84] * *cnV[84];
+	m_A63 += gt[85];
+	m_A63 += gt[86];
+	m_A65 += go[85];
+	m_A62 += go[86];
+	double RHS26 = Idr[85];
+	RHS26 += Idr[86];
+	m_A67 += gt[87];
+	m_A67 += gt[88];
+	m_A67 += gt[89];
+	m_A67 += gt[90];
+	m_A66 += go[87];
+	m_A68 += go[88];
+	double RHS27 = Idr[87];
+	RHS27 += Idr[88];
+	RHS27 += Idr[89];
+	RHS27 += Idr[90];
+	RHS27 -= go[89] * *cnV[89];
+	RHS27 -= go[90] * *cnV[90];
+	m_A70 += gt[91];
+	m_A70 += gt[92];
+	m_A70 += gt[93];
+	m_A70 += gt[94];
+	m_A69 += go[91];
+	m_A71 += go[92];
+	double RHS28 = Idr[91];
+	RHS28 += Idr[92];
+	RHS28 += Idr[93];
+	RHS28 += Idr[94];
+	RHS28 -= go[93] * *cnV[93];
+	RHS28 -= go[94] * *cnV[94];
+	m_A74 += gt[95];
+	m_A74 += gt[96];
+	m_A73 += go[95];
+	m_A75 += go[96];
+	double RHS29 = Idr[95];
+	RHS29 += Idr[96];
+	m_A79 += gt[97];
+	m_A79 += gt[98];
+	m_A79 += gt[99];
+	m_A79 += gt[100];
+	m_A78 += go[97];
+	m_A77 += go[98];
+	m_A80 += go[99];
+	m_A76 += go[100];
+	double RHS30 = Idr[97];
+	RHS30 += Idr[98];
+	RHS30 += Idr[99];
+	RHS30 += Idr[100];
+	m_A84 += gt[101];
+	m_A84 += gt[102];
+	m_A83 += go[101];
+	m_A82 += go[102];
+	double RHS31 = Idr[101];
+	RHS31 += Idr[102];
+	m_A89 += gt[103];
+	m_A89 += gt[104];
+	m_A87 += go[103];
+	m_A86 += go[104];
+	double RHS32 = Idr[103];
+	RHS32 += Idr[104];
+	m_A91 += gt[105];
+	m_A91 += gt[106];
+	m_A90 += go[105];
+	m_A93 += go[106];
+	double RHS33 = Idr[105];
+	RHS33 += Idr[106];
+	m_A95 += gt[107];
+	m_A95 += gt[108];
+	m_A95 += gt[109];
+	m_A95 += gt[110];
+	m_A94 += go[107];
+	m_A96 += go[108];
+	double RHS34 = Idr[107];
+	RHS34 += Idr[108];
+	RHS34 += Idr[109];
+	RHS34 += Idr[110];
+	RHS34 -= go[109] * *cnV[109];
+	RHS34 -= go[110] * *cnV[110];
+	m_A99 += gt[111];
+	m_A99 += gt[112];
+	m_A97 += go[111];
+	m_A101 += go[112];
+	double RHS35 = Idr[111];
+	RHS35 += Idr[112];
+	m_A106 += gt[113];
+	m_A106 += gt[114];
+	m_A106 += gt[115];
+	m_A106 += gt[116];
+	m_A106 += gt[117];
+	m_A106 += gt[118];
+	m_A102 += go[113];
+	m_A104 += go[114];
+	m_A103 += go[115];
+	m_A108 += go[116];
+	double RHS36 = Idr[113];
+	RHS36 += Idr[114];
+	RHS36 += Idr[115];
+	RHS36 += Idr[116];
+	RHS36 += Idr[117];
+	RHS36 += Idr[118];
+	RHS36 -= go[117] * *cnV[117];
+	RHS36 -= go[118] * *cnV[118];
+	m_A113 += gt[119];
+	m_A113 += gt[120];
+	m_A113 += gt[121];
+	m_A113 += gt[122];
+	m_A113 += gt[123];
+	m_A115 += go[119];
+	m_A111 += go[120];
+	m_A112 += go[121];
+	m_A110 += go[122];
+	m_A109 += go[123];
+	double RHS37 = Idr[119];
+	RHS37 += Idr[120];
+	RHS37 += Idr[121];
+	RHS37 += Idr[122];
+	RHS37 += Idr[123];
+	m_A124 += gt[124];
+	m_A124 += gt[125];
+	m_A124 += gt[126];
+	m_A124 += gt[127];
+	m_A124 += gt[128];
+	m_A124 += gt[129];
+	m_A119 += go[124];
+	m_A118 += go[125];
+	m_A121 += go[126];
+	m_A120 += go[127];
+	m_A117 += go[128];
+	m_A116 += go[129];
+	double RHS38 = Idr[124];
+	RHS38 += Idr[125];
+	RHS38 += Idr[126];
+	RHS38 += Idr[127];
+	RHS38 += Idr[128];
+	RHS38 += Idr[129];
+	m_A137 += gt[130];
+	m_A137 += gt[131];
+	m_A137 += gt[132];
+	m_A137 += gt[133];
+	m_A137 += gt[134];
+	m_A137 += gt[135];
+	m_A137 += gt[136];
+	m_A137 += gt[137];
+	m_A135 += go[130];
+	m_A129 += go[131];
+	m_A134 += go[132];
+	m_A132 += go[133];
+	m_A128 += go[134];
+	m_A127 += go[135];
+	m_A130 += go[136];
+	m_A131 += go[137];
+	double RHS39 = Idr[130];
+	RHS39 += Idr[131];
+	RHS39 += Idr[132];
+	RHS39 += Idr[133];
+	RHS39 += Idr[134];
+	RHS39 += Idr[135];
+	RHS39 += Idr[136];
+	RHS39 += Idr[137];
+	m_A147 += gt[138];
+	m_A147 += gt[139];
+	m_A147 += gt[140];
+	m_A147 += gt[141];
+	m_A147 += gt[142];
+	m_A147 += gt[143];
+	m_A140 += go[138];
+	m_A141 += go[139];
+	m_A150 += go[140];
+	m_A142 += go[141];
+	double RHS40 = Idr[138];
+	RHS40 += Idr[139];
+	RHS40 += Idr[140];
+	RHS40 += Idr[141];
+	RHS40 += Idr[142];
+	RHS40 += Idr[143];
+	RHS40 -= go[142] * *cnV[142];
+	RHS40 -= go[143] * *cnV[143];
+	m_A158 += gt[144];
+	m_A158 += gt[145];
+	m_A158 += gt[146];
+	m_A158 += gt[147];
+	m_A158 += gt[148];
+	m_A158 += gt[149];
+	m_A151 += go[144];
+	m_A152 += go[145];
+	m_A154 += go[146];
+	m_A156 += go[147];
+	double RHS41 = Idr[144];
+	RHS41 += Idr[145];
+	RHS41 += Idr[146];
+	RHS41 += Idr[147];
+	RHS41 += Idr[148];
+	RHS41 += Idr[149];
+	RHS41 -= go[148] * *cnV[148];
+	RHS41 -= go[149] * *cnV[149];
+	m_A166 += gt[150];
+	m_A166 += gt[151];
+	m_A166 += gt[152];
+	m_A166 += gt[153];
+	m_A161 += go[150];
+	m_A162 += go[151];
+	double RHS42 = Idr[150];
+	RHS42 += Idr[151];
+	RHS42 += Idr[152];
+	RHS42 += Idr[153];
+	RHS42 -= go[152] * *cnV[152];
+	RHS42 -= go[153] * *cnV[153];
+	m_A175 += gt[154];
+	m_A175 += gt[155];
+	m_A175 += gt[156];
+	m_A175 += gt[157];
+	m_A175 += gt[158];
+	m_A172 += go[154];
+	m_A170 += go[155];
+	m_A169 += go[156];
+	m_A168 += go[157];
+	m_A171 += go[158];
+	double RHS43 = Idr[154];
+	RHS43 += Idr[155];
+	RHS43 += Idr[156];
+	RHS43 += Idr[157];
+	RHS43 += Idr[158];
+	const double f0 = 1.0 / m_A0;
+	const double f0_21 = -f0 * m_A47;
+	m_A48 += m_A1 * f0_21;
+	RHS21 += f0_21 * RHS0;
+	const double f0_37 = -f0 * m_A109;
+	m_A111 += m_A1 * f0_37;
+	RHS37 += f0_37 * RHS0;
+	const double f1 = 1.0 / m_A2;
+	const double f1_24 = -f1 * m_A54;
+	m_A56 += m_A3 * f1_24;
+	RHS24 += f1_24 * RHS1;
+	const double f1_37 = -f1 * m_A110;
+	m_A113 += m_A3 * f1_37;
+	RHS37 += f1_37 * RHS1;
+	const double f2 = 1.0 / m_A4;
+	const double f2_41 = -f2 * m_A151;
+	m_A153 += m_A5 * f2_41;
+	RHS41 += f2_41 * RHS2;
+	const double f3 = 1.0 / m_A6;
+	const double f3_25 = -f3 * m_A57;
+	m_A58 += m_A7 * f3_25;
+	RHS25 += f3_25 * RHS3;
+	const double f4 = 1.0 / m_A8;
+	const double f4_23 = -f4 * m_A52;
+	m_A53 += m_A9 * f4_23;
+	RHS23 += f4_23 * RHS4;
+	const double f4_43 = -f4 * m_A168;
+	m_A170 += m_A9 * f4_43;
+	RHS43 += f4_43 * RHS4;
+	const double f5 = 1.0 / m_A10;
+	const double f5_26 = -f5 * m_A62;
+	m_A63 += m_A11 * f5_26;
+	m_A64 += m_A12 * f5_26;
+	RHS26 += f5_26 * RHS5;
+	const double f5_41 = -f5 * m_A152;
+	m_A155 += m_A11 * f5_41;
+	m_A158 += m_A12 * f5_41;
+	RHS41 += f5_41 * RHS5;
+	const double f6 = 1.0 / m_A13;
+	const double f6_40 = -f6 * m_A140;
+	m_A143 += m_A14 * f6_40;
+	RHS40 += f6_40 * RHS6;
+	const double f7 = 1.0 / m_A15;
+	const double f7_27 = -f7 * m_A66;
+	m_A68 += m_A16 * f7_27;
+	RHS27 += f7_27 * RHS7;
+	const double f7_43 = -f7 * m_A169;
+	m_A175 += m_A16 * f7_43;
+	RHS43 += f7_43 * RHS7;
+	const double f8 = 1.0 / m_A17;
+	const double f8_30 = -f8 * m_A76;
+	m_A79 += m_A18 * f8_30;
+	m_A81 += m_A19 * f8_30;
+	RHS30 += f8_30 * RHS8;
+	const double f8_40 = -f8 * m_A141;
+	m_A144 += m_A18 * f8_40;
+	m_A147 += m_A19 * f8_40;
+	RHS40 += f8_40 * RHS8;
+	const double f9 = 1.0 / m_A20;
+	const double f9_29 = -f9 * m_A73;
+	m_A74 += m_A21 * f9_29;
+	RHS29 += f9_29 * RHS9;
+	const double f10 = 1.0 / m_A22;
+	const double f10_30 = -f10 * m_A77;
+	m_A79 += m_A23 * f10_30;
+	RHS30 += f10_30 * RHS10;
+	const double f11 = 1.0 / m_A24;
+	const double f11_30 = -f11 * m_A78;
+	m_A79 += m_A25 * f11_30;
+	RHS30 += f11_30 * RHS11;
+	const double f12 = 1.0 / m_A26;
+	const double f12_36 = -f12 * m_A102;
+	m_A105 += m_A27 * f12_36;
+	RHS36 += f12_36 * RHS12;
+	const double f13 = 1.0 / m_A28;
+	const double f13_31 = -f13 * m_A82;
+	m_A84 += m_A29 * f13_31;
+	RHS31 += f13_31 * RHS13;
+	const double f13_39 = -f13 * m_A127;
+	m_A132 += m_A29 * f13_39;
+	RHS39 += f13_39 * RHS13;
+	const double f14 = 1.0 / m_A30;
+	const double f14_28 = -f14 * m_A69;
+	m_A72 += m_A31 * f14_28;
+	RHS28 += f14_28 * RHS14;
+	const double f15 = 1.0 / m_A32;
+	const double f15_32 = -f15 * m_A86;
+	m_A89 += m_A33 * f15_32;
+	RHS32 += f15_32 * RHS15;
+	const double f15_38 = -f15 * m_A116;
+	m_A120 += m_A33 * f15_38;
+	RHS38 += f15_38 * RHS15;
+	const double f16 = 1.0 / m_A34;
+	const double f16_31 = -f16 * m_A83;
+	m_A84 += m_A35 * f16_31;
+	m_A85 += m_A36 * f16_31;
+	RHS31 += f16_31 * RHS16;
+	const double f16_32 = -f16 * m_A87;
+	m_A88 += m_A35 * f16_32;
+	m_A89 += m_A36 * f16_32;
+	RHS32 += f16_32 * RHS16;
+	const double f17 = 1.0 / m_A37;
+	const double f17_34 = -f17 * m_A94;
+	m_A96 += m_A38 * f17_34;
+	RHS34 += f17_34 * RHS17;
+	const double f17_39 = -f17 * m_A128;
+	m_A137 += m_A38 * f17_39;
+	RHS39 += f17_39 * RHS17;
+	const double f18 = 1.0 / m_A39;
+	const double f18_33 = -f18 * m_A90;
+	m_A91 += m_A40 * f18_33;
+	m_A92 += m_A41 * f18_33;
+	RHS33 += f18_33 * RHS18;
+	const double f18_35 = -f18 * m_A97;
+	m_A98 += m_A40 * f18_35;
+	m_A99 += m_A41 * f18_35;
+	RHS35 += f18_35 * RHS18;
+	const double f19 = 1.0 / m_A42;
+	const double f19_36 = -f19 * m_A103;
+	m_A106 += m_A43 * f19_36;
+	m_A108 += m_A44 * f19_36;
+	RHS36 += f19_36 * RHS19;
+	const double f19_39 = -f19 * m_A129;
+	m_A135 += m_A43 * f19_39;
+	m_A137 += m_A44 * f19_39;
+	RHS39 += f19_39 * RHS19;
+	const double f20 = 1.0 / m_A45;
+	const double f20_38 = -f20 * m_A117;
+	m_A124 += m_A46 * f20_38;
+	RHS38 += f20_38 * RHS20;
+	const double f20_42 = -f20 * m_A161;
+	m_A162 += m_A46 * f20_42;
+	RHS42 += f20_42 * RHS20;
+	const double f21 = 1.0 / m_A48;
+	const double f21_37 = -f21 * m_A111;
+	RHS37 += f21_37 * RHS21;
+	const double f22 = 1.0 / m_A49;
+	const double f22_36 = -f22 * m_A104;
+	m_A106 += m_A50 * f22_36;
+	m_A107 += m_A51 * f22_36;
+	RHS36 += f22_36 * RHS22;
+	const double f22_38 = -f22 * m_A118;
+	m_A123 += m_A50 * f22_38;
+	m_A124 += m_A51 * f22_38;
+	RHS38 += f22_38 * RHS22;
+	const double f23 = 1.0 / m_A53;
+	const double f23_43 = -f23 * m_A170;
+	RHS43 += f23_43 * RHS23;
+	const double f24 = 1.0 / m_A55;
+	const double f24_41 = -f24 * m_A153;
+	m_A156 += m_A56 * f24_41;
+	RHS41 += f24_41 * RHS24;
+	const double f25 = 1.0 / m_A58;
+	const double f25_37 = -f25 * m_A112;
+	m_A113 += m_A59 * f25_37;
+	m_A114 += m_A60 * f25_37;
+	m_A115 += m_A61 * f25_37;
+	RHS37 += f25_37 * RHS25;
+	const double f25_40 = -f25 * m_A142;
+	m_A145 += m_A59 * f25_40;
+	m_A147 += m_A60 * f25_40;
+	m_A148 += m_A61 * f25_40;
+	RHS40 += f25_40 * RHS25;
+	const double f25_41 = -f25 * m_A154;
+	m_A156 += m_A59 * f25_41;
+	m_A157 += m_A60 * f25_41;
+	m_A158 += m_A61 * f25_41;
+	RHS41 += f25_41 * RHS25;
+	const double f26 = 1.0 / m_A63;
+	const double f26_41 = -f26 * m_A155;
+	m_A158 += m_A64 * f26_41;
+	m_A160 += m_A65 * f26_41;
+	RHS41 += f26_41 * RHS26;
+	const double f26_43 = -f26 * m_A171;
+	m_A173 += m_A64 * f26_43;
+	m_A175 += m_A65 * f26_43;
+	RHS43 += f26_43 * RHS26;
+	const double f27 = 1.0 / m_A67;
+	const double f27_40 = -f27 * m_A143;
+	m_A150 += m_A68 * f27_40;
+	RHS40 += f27_40 * RHS27;
+	const double f28 = 1.0 / m_A70;
+	const double f28_38 = -f28 * m_A119;
+	m_A124 += m_A71 * f28_38;
+	m_A126 += m_A72 * f28_38;
+	RHS38 += f28_38 * RHS28;
+	const double f29 = 1.0 / m_A74;
+	const double f29_39 = -f29 * m_A130;
+	m_A137 += m_A75 * f29_39;
+	RHS39 += f29_39 * RHS29;
+	const double f30 = 1.0 / m_A79;
+	const double f30_39 = -f30 * m_A131;
+	m_A137 += m_A80 * f30_39;
+	m_A138 += m_A81 * f30_39;
+	RHS39 += f30_39 * RHS30;
+	const double f30_40 = -f30 * m_A144;
+	m_A146 += m_A80 * f30_40;
+	m_A147 += m_A81 * f30_40;
+	RHS40 += f30_40 * RHS30;
+	const double f31 = 1.0 / m_A84;
+	const double f31_32 = -f31 * m_A88;
+	m_A89 += m_A85 * f31_32;
+	RHS32 += f31_32 * RHS31;
+	const double f31_39 = -f31 * m_A132;
+	m_A133 += m_A85 * f31_39;
+	RHS39 += f31_39 * RHS31;
+	const double f32 = 1.0 / m_A89;
+	const double f32_38 = -f32 * m_A120;
+	RHS38 += f32_38 * RHS32;
+	const double f32_39 = -f32 * m_A133;
+	RHS39 += f32_39 * RHS32;
+	const double f33 = 1.0 / m_A91;
+	const double f33_35 = -f33 * m_A98;
+	m_A99 += m_A92 * f33_35;
+	m_A100 += m_A93 * f33_35;
+	RHS35 += f33_35 * RHS33;
+	const double f33_38 = -f33 * m_A121;
+	m_A122 += m_A92 * f33_38;
+	m_A124 += m_A93 * f33_38;
+	RHS38 += f33_38 * RHS33;
+	const double f34 = 1.0 / m_A95;
+	const double f34_36 = -f34 * m_A105;
+	m_A108 += m_A96 * f34_36;
+	RHS36 += f34_36 * RHS34;
+	const double f35 = 1.0 / m_A99;
+	const double f35_38 = -f35 * m_A122;
+	m_A124 += m_A100 * f35_38;
+	m_A125 += m_A101 * f35_38;
+	RHS38 += f35_38 * RHS35;
+	const double f35_39 = -f35 * m_A134;
+	m_A136 += m_A100 * f35_39;
+	m_A137 += m_A101 * f35_39;
+	RHS39 += f35_39 * RHS35;
+	const double f36 = 1.0 / m_A106;
+	const double f36_38 = -f36 * m_A123;
+	m_A124 += m_A107 * f36_38;
+	m_A125 += m_A108 * f36_38;
+	RHS38 += f36_38 * RHS36;
+	const double f36_39 = -f36 * m_A135;
+	m_A136 += m_A107 * f36_39;
+	m_A137 += m_A108 * f36_39;
+	RHS39 += f36_39 * RHS36;
+	const double f37 = 1.0 / m_A113;
+	const double f37_40 = -f37 * m_A145;
+	m_A147 += m_A114 * f37_40;
+	m_A148 += m_A115 * f37_40;
+	RHS40 += f37_40 * RHS37;
+	const double f37_41 = -f37 * m_A156;
+	m_A157 += m_A114 * f37_41;
+	m_A158 += m_A115 * f37_41;
+	RHS41 += f37_41 * RHS37;
+	const double f38 = 1.0 / m_A124;
+	const double f38_39 = -f38 * m_A136;
+	m_A137 += m_A125 * f38_39;
+	m_A139 += m_A126 * f38_39;
+	RHS39 += f38_39 * RHS38;
+	const double f38_42 = -f38 * m_A162;
+	m_A163 += m_A125 * f38_42;
+	m_A166 += m_A126 * f38_42;
+	RHS42 += f38_42 * RHS38;
+	const double f39 = 1.0 / m_A137;
+	const double f39_40 = -f39 * m_A146;
+	m_A147 += m_A138 * f39_40;
+	m_A149 += m_A139 * f39_40;
+	RHS40 += f39_40 * RHS39;
+	const double f39_42 = -f39 * m_A163;
+	m_A164 += m_A138 * f39_42;
+	m_A166 += m_A139 * f39_42;
+	RHS42 += f39_42 * RHS39;
+	const double f40 = 1.0 / m_A147;
+	const double f40_41 = -f40 * m_A157;
+	m_A158 += m_A148 * f40_41;
+	m_A159 += m_A149 * f40_41;
+	m_A160 += m_A150 * f40_41;
+	RHS41 += f40_41 * RHS40;
+	const double f40_42 = -f40 * m_A164;
+	m_A165 += m_A148 * f40_42;
+	m_A166 += m_A149 * f40_42;
+	m_A167 += m_A150 * f40_42;
+	RHS42 += f40_42 * RHS40;
+	const double f40_43 = -f40 * m_A172;
+	m_A173 += m_A148 * f40_43;
+	m_A174 += m_A149 * f40_43;
+	m_A175 += m_A150 * f40_43;
+	RHS43 += f40_43 * RHS40;
+	const double f41 = 1.0 / m_A158;
+	const double f41_42 = -f41 * m_A165;
+	m_A166 += m_A159 * f41_42;
+	m_A167 += m_A160 * f41_42;
+	RHS42 += f41_42 * RHS41;
+	const double f41_43 = -f41 * m_A173;
+	m_A174 += m_A159 * f41_43;
+	m_A175 += m_A160 * f41_43;
+	RHS43 += f41_43 * RHS41;
+	const double f42 = 1.0 / m_A166;
+	const double f42_43 = -f42 * m_A174;
+	m_A175 += m_A167 * f42_43;
+	RHS43 += f42_43 * RHS42;
+	V[43] = RHS43 / m_A175;
+	double tmp42 = 0.0;
+	tmp42 += m_A167 * V[43];
+	V[42] = (RHS42 - tmp42) / m_A166;
+	double tmp41 = 0.0;
+	tmp41 += m_A159 * V[42];
+	tmp41 += m_A160 * V[43];
+	V[41] = (RHS41 - tmp41) / m_A158;
+	double tmp40 = 0.0;
+	tmp40 += m_A148 * V[41];
+	tmp40 += m_A149 * V[42];
+	tmp40 += m_A150 * V[43];
+	V[40] = (RHS40 - tmp40) / m_A147;
+	double tmp39 = 0.0;
+	tmp39 += m_A138 * V[40];
+	tmp39 += m_A139 * V[42];
+	V[39] = (RHS39 - tmp39) / m_A137;
+	double tmp38 = 0.0;
+	tmp38 += m_A125 * V[39];
+	tmp38 += m_A126 * V[42];
+	V[38] = (RHS38 - tmp38) / m_A124;
+	double tmp37 = 0.0;
+	tmp37 += m_A114 * V[40];
+	tmp37 += m_A115 * V[41];
+	V[37] = (RHS37 - tmp37) / m_A113;
+	double tmp36 = 0.0;
+	tmp36 += m_A107 * V[38];
+	tmp36 += m_A108 * V[39];
+	V[36] = (RHS36 - tmp36) / m_A106;
+	double tmp35 = 0.0;
+	tmp35 += m_A100 * V[38];
+	tmp35 += m_A101 * V[39];
+	V[35] = (RHS35 - tmp35) / m_A99;
+	double tmp34 = 0.0;
+	tmp34 += m_A96 * V[39];
+	V[34] = (RHS34 - tmp34) / m_A95;
+	double tmp33 = 0.0;
+	tmp33 += m_A92 * V[35];
+	tmp33 += m_A93 * V[38];
+	V[33] = (RHS33 - tmp33) / m_A91;
+	double tmp32 = 0.0;
+	V[32] = (RHS32 - tmp32) / m_A89;
+	double tmp31 = 0.0;
+	tmp31 += m_A85 * V[32];
+	V[31] = (RHS31 - tmp31) / m_A84;
+	double tmp30 = 0.0;
+	tmp30 += m_A80 * V[39];
+	tmp30 += m_A81 * V[40];
+	V[30] = (RHS30 - tmp30) / m_A79;
+	double tmp29 = 0.0;
+	tmp29 += m_A75 * V[39];
+	V[29] = (RHS29 - tmp29) / m_A74;
+	double tmp28 = 0.0;
+	tmp28 += m_A71 * V[38];
+	tmp28 += m_A72 * V[42];
+	V[28] = (RHS28 - tmp28) / m_A70;
+	double tmp27 = 0.0;
+	tmp27 += m_A68 * V[43];
+	V[27] = (RHS27 - tmp27) / m_A67;
+	double tmp26 = 0.0;
+	tmp26 += m_A64 * V[41];
+	tmp26 += m_A65 * V[43];
+	V[26] = (RHS26 - tmp26) / m_A63;
+	double tmp25 = 0.0;
+	tmp25 += m_A59 * V[37];
+	tmp25 += m_A60 * V[40];
+	tmp25 += m_A61 * V[41];
+	V[25] = (RHS25 - tmp25) / m_A58;
+	double tmp24 = 0.0;
+	tmp24 += m_A56 * V[37];
+	V[24] = (RHS24 - tmp24) / m_A55;
+	double tmp23 = 0.0;
+	V[23] = (RHS23 - tmp23) / m_A53;
+	double tmp22 = 0.0;
+	tmp22 += m_A50 * V[36];
+	tmp22 += m_A51 * V[38];
+	V[22] = (RHS22 - tmp22) / m_A49;
+	double tmp21 = 0.0;
+	V[21] = (RHS21 - tmp21) / m_A48;
+	double tmp20 = 0.0;
+	tmp20 += m_A46 * V[38];
+	V[20] = (RHS20 - tmp20) / m_A45;
+	double tmp19 = 0.0;
+	tmp19 += m_A43 * V[36];
+	tmp19 += m_A44 * V[39];
+	V[19] = (RHS19 - tmp19) / m_A42;
+	double tmp18 = 0.0;
+	tmp18 += m_A40 * V[33];
+	tmp18 += m_A41 * V[35];
+	V[18] = (RHS18 - tmp18) / m_A39;
+	double tmp17 = 0.0;
+	tmp17 += m_A38 * V[39];
+	V[17] = (RHS17 - tmp17) / m_A37;
+	double tmp16 = 0.0;
+	tmp16 += m_A35 * V[31];
+	tmp16 += m_A36 * V[32];
+	V[16] = (RHS16 - tmp16) / m_A34;
+	double tmp15 = 0.0;
+	tmp15 += m_A33 * V[32];
+	V[15] = (RHS15 - tmp15) / m_A32;
+	double tmp14 = 0.0;
+	tmp14 += m_A31 * V[42];
+	V[14] = (RHS14 - tmp14) / m_A30;
+	double tmp13 = 0.0;
+	tmp13 += m_A29 * V[31];
+	V[13] = (RHS13 - tmp13) / m_A28;
+	double tmp12 = 0.0;
+	tmp12 += m_A27 * V[34];
+	V[12] = (RHS12 - tmp12) / m_A26;
+	double tmp11 = 0.0;
+	tmp11 += m_A25 * V[30];
+	V[11] = (RHS11 - tmp11) / m_A24;
+	double tmp10 = 0.0;
+	tmp10 += m_A23 * V[30];
+	V[10] = (RHS10 - tmp10) / m_A22;
+	double tmp9 = 0.0;
+	tmp9 += m_A21 * V[29];
+	V[9] = (RHS9 - tmp9) / m_A20;
+	double tmp8 = 0.0;
+	tmp8 += m_A18 * V[30];
+	tmp8 += m_A19 * V[40];
+	V[8] = (RHS8 - tmp8) / m_A17;
+	double tmp7 = 0.0;
+	tmp7 += m_A16 * V[43];
+	V[7] = (RHS7 - tmp7) / m_A15;
+	double tmp6 = 0.0;
+	tmp6 += m_A14 * V[27];
+	V[6] = (RHS6 - tmp6) / m_A13;
+	double tmp5 = 0.0;
+	tmp5 += m_A11 * V[26];
+	tmp5 += m_A12 * V[41];
+	V[5] = (RHS5 - tmp5) / m_A10;
+	double tmp4 = 0.0;
+	tmp4 += m_A9 * V[23];
+	V[4] = (RHS4 - tmp4) / m_A8;
+	double tmp3 = 0.0;
+	tmp3 += m_A7 * V[25];
+	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[37];
+	V[1] = (RHS1 - tmp1) / m_A2;
+	double tmp0 = 0.0;
+	tmp0 += m_A1 * V[21];
+	V[0] = (RHS0 - tmp0) / m_A0;
+}
+
 // 280zzzap
 static void nl_gcr_24643c159711f292_95_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV)
 
@@ -5265,6 +6371,92 @@ static void nl_gcr_34e910fc1896999f_76_double_double(double * __restrict V, cons
 	V[0] = (RHS0 - tmp0) / m_A0;
 }
 
+// sspeedr
+static void nl_gcr_3e833834e5ce5aee_13_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);
+	m_A0 += gt[0];
+	m_A1 += go[0];
+	double RHS0 = Idr[0];
+	m_A2 += gt[1];
+	m_A2 += gt[2];
+	m_A2 += gt[3];
+	m_A3 += go[1];
+	double RHS1 = Idr[1];
+	RHS1 += Idr[2];
+	RHS1 += Idr[3];
+	RHS1 -= go[2] * *cnV[2];
+	RHS1 -= go[3] * *cnV[3];
+	m_A4 += gt[4];
+	m_A4 += gt[5];
+	m_A5 += go[4];
+	double RHS2 = Idr[4];
+	RHS2 += Idr[5];
+	RHS2 -= go[5] * *cnV[5];
+	m_A8 += gt[6];
+	m_A8 += gt[7];
+	m_A8 += gt[8];
+	m_A9 += go[6];
+	m_A7 += go[7];
+	m_A6 += go[8];
+	double RHS3 = Idr[6];
+	RHS3 += Idr[7];
+	RHS3 += Idr[8];
+	m_A12 += gt[9];
+	m_A12 += gt[10];
+	m_A12 += gt[11];
+	m_A10 += go[9];
+	m_A11 += go[10];
+	double RHS4 = Idr[9];
+	RHS4 += Idr[10];
+	RHS4 += Idr[11];
+	RHS4 -= go[11] * *cnV[11];
+	const double f0 = 1.0 / m_A0;
+	const double f0_3 = -f0 * m_A6;
+	m_A8 += m_A1 * f0_3;
+	RHS3 += f0_3 * RHS0;
+	const double f1 = 1.0 / m_A2;
+	const double f1_3 = -f1 * m_A7;
+	m_A8 += m_A3 * f1_3;
+	RHS3 += f1_3 * RHS1;
+	const double f2 = 1.0 / m_A4;
+	const double f2_4 = -f2 * m_A10;
+	m_A12 += m_A5 * f2_4;
+	RHS4 += f2_4 * RHS2;
+	const double f3 = 1.0 / m_A8;
+	const double f3_4 = -f3 * m_A11;
+	m_A12 += m_A9 * f3_4;
+	RHS4 += f3_4 * RHS3;
+	V[4] = RHS4 / m_A12;
+	double tmp3 = 0.0;
+	tmp3 += m_A9 * V[4];
+	V[3] = (RHS3 - tmp3) / m_A8;
+	double tmp2 = 0.0;
+	tmp2 += m_A5 * V[4];
+	V[2] = (RHS2 - tmp2) / m_A4;
+	double tmp1 = 0.0;
+	tmp1 += m_A3 * V[3];
+	V[1] = (RHS1 - tmp1) / m_A2;
+	double tmp0 = 0.0;
+	tmp0 += m_A1 * V[3];
+	V[0] = (RHS0 - tmp0) / m_A0;
+}
+
 // warrior
 static void nl_gcr_42a31ce5c187b308_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV)
 
@@ -10335,6 +11527,665 @@ static void nl_gcr_491f95430bfdfd05_19_double_double(double * __restrict V, cons
 	V[0] = (RHS0 - tmp0) / m_A0;
 }
 
+// sspeedr
+static void nl_gcr_4a8e2b707bbac8a6_95_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);
+	m_A0 += gt[0];
+	m_A0 += gt[1];
+	m_A0 += gt[2];
+	m_A1 += go[0];
+	double RHS0 = Idr[0];
+	RHS0 += Idr[1];
+	RHS0 += Idr[2];
+	RHS0 -= go[1] * *cnV[1];
+	RHS0 -= go[2] * *cnV[2];
+	m_A2 += gt[3];
+	m_A2 += gt[4];
+	m_A2 += gt[5];
+	m_A2 += gt[6];
+	m_A2 += gt[7];
+	m_A2 += gt[8];
+	m_A2 += gt[9];
+	m_A3 += go[3];
+	double RHS1 = Idr[3];
+	RHS1 += Idr[4];
+	RHS1 += Idr[5];
+	RHS1 += Idr[6];
+	RHS1 += Idr[7];
+	RHS1 += Idr[8];
+	RHS1 += Idr[9];
+	RHS1 -= go[4] * *cnV[4];
+	RHS1 -= go[5] * *cnV[5];
+	RHS1 -= go[6] * *cnV[6];
+	RHS1 -= go[7] * *cnV[7];
+	RHS1 -= go[8] * *cnV[8];
+	RHS1 -= go[9] * *cnV[9];
+	m_A4 += gt[10];
+	m_A4 += gt[11];
+	m_A4 += gt[12];
+	m_A5 += go[10];
+	double RHS2 = Idr[10];
+	RHS2 += Idr[11];
+	RHS2 += Idr[12];
+	RHS2 -= go[11] * *cnV[11];
+	RHS2 -= go[12] * *cnV[12];
+	m_A6 += gt[13];
+	m_A6 += gt[14];
+	m_A6 += gt[15];
+	m_A6 += gt[16];
+	m_A6 += gt[17];
+	m_A6 += gt[18];
+	m_A6 += gt[19];
+	m_A7 += go[13];
+	double RHS3 = Idr[13];
+	RHS3 += Idr[14];
+	RHS3 += Idr[15];
+	RHS3 += Idr[16];
+	RHS3 += Idr[17];
+	RHS3 += Idr[18];
+	RHS3 += Idr[19];
+	RHS3 -= go[14] * *cnV[14];
+	RHS3 -= go[15] * *cnV[15];
+	RHS3 -= go[16] * *cnV[16];
+	RHS3 -= go[17] * *cnV[17];
+	RHS3 -= go[18] * *cnV[18];
+	RHS3 -= go[19] * *cnV[19];
+	m_A8 += gt[20];
+	m_A8 += gt[21];
+	m_A9 += go[20];
+	double RHS4 = Idr[20];
+	RHS4 += Idr[21];
+	RHS4 -= go[21] * *cnV[21];
+	m_A10 += gt[22];
+	m_A10 += gt[23];
+	m_A11 += go[22];
+	double RHS5 = Idr[22];
+	RHS5 += Idr[23];
+	RHS5 -= go[23] * *cnV[23];
+	m_A12 += gt[24];
+	m_A12 += gt[25];
+	m_A12 += gt[26];
+	m_A12 += gt[27];
+	m_A13 += go[24];
+	double RHS6 = Idr[24];
+	RHS6 += Idr[25];
+	RHS6 += Idr[26];
+	RHS6 += Idr[27];
+	RHS6 -= go[25] * *cnV[25];
+	RHS6 -= go[26] * *cnV[26];
+	RHS6 -= go[27] * *cnV[27];
+	m_A14 += gt[28];
+	m_A14 += gt[29];
+	m_A14 += gt[30];
+	m_A14 += gt[31];
+	m_A15 += go[28];
+	double RHS7 = Idr[28];
+	RHS7 += Idr[29];
+	RHS7 += Idr[30];
+	RHS7 += Idr[31];
+	RHS7 -= go[29] * *cnV[29];
+	RHS7 -= go[30] * *cnV[30];
+	RHS7 -= go[31] * *cnV[31];
+	m_A16 += gt[32];
+	m_A16 += gt[33];
+	m_A17 += go[32];
+	double RHS8 = Idr[32];
+	RHS8 += Idr[33];
+	RHS8 -= go[33] * *cnV[33];
+	m_A18 += gt[34];
+	m_A18 += gt[35];
+	m_A18 += gt[36];
+	m_A18 += gt[37];
+	m_A19 += go[34];
+	double RHS9 = Idr[34];
+	RHS9 += Idr[35];
+	RHS9 += Idr[36];
+	RHS9 += Idr[37];
+	RHS9 -= go[35] * *cnV[35];
+	RHS9 -= go[36] * *cnV[36];
+	RHS9 -= go[37] * *cnV[37];
+	m_A20 += gt[38];
+	m_A20 += gt[39];
+	m_A22 += go[38];
+	m_A21 += go[39];
+	double RHS10 = Idr[38];
+	RHS10 += Idr[39];
+	m_A23 += gt[40];
+	m_A23 += gt[41];
+	m_A23 += gt[42];
+	m_A23 += gt[43];
+	m_A24 += go[40];
+	double RHS11 = Idr[40];
+	RHS11 += Idr[41];
+	RHS11 += Idr[42];
+	RHS11 += Idr[43];
+	RHS11 -= go[41] * *cnV[41];
+	RHS11 -= go[42] * *cnV[42];
+	RHS11 -= go[43] * *cnV[43];
+	m_A25 += gt[44];
+	m_A25 += gt[45];
+	m_A25 += gt[46];
+	m_A27 += go[44];
+	m_A28 += go[45];
+	m_A26 += go[46];
+	double RHS12 = Idr[44];
+	RHS12 += Idr[45];
+	RHS12 += Idr[46];
+	m_A29 += gt[47];
+	m_A29 += gt[48];
+	m_A31 += go[47];
+	m_A30 += go[48];
+	double RHS13 = Idr[47];
+	RHS13 += Idr[48];
+	m_A37 += gt[49];
+	m_A37 += gt[50];
+	m_A37 += gt[51];
+	m_A37 += gt[52];
+	m_A37 += gt[53];
+	m_A37 += gt[54];
+	m_A36 += go[49];
+	m_A35 += go[50];
+	m_A34 += go[51];
+	m_A33 += go[52];
+	m_A32 += go[53];
+	double RHS14 = Idr[49];
+	RHS14 += Idr[50];
+	RHS14 += Idr[51];
+	RHS14 += Idr[52];
+	RHS14 += Idr[53];
+	RHS14 += Idr[54];
+	RHS14 -= go[54] * *cnV[54];
+	m_A39 += gt[55];
+	m_A39 += gt[56];
+	m_A39 += gt[57];
+	m_A39 += gt[58];
+	m_A38 += go[55];
+	m_A40 += go[56];
+	double RHS15 = Idr[55];
+	RHS15 += Idr[56];
+	RHS15 += Idr[57];
+	RHS15 += Idr[58];
+	RHS15 -= go[57] * *cnV[57];
+	RHS15 -= go[58] * *cnV[58];
+	m_A42 += gt[59];
+	m_A42 += gt[60];
+	m_A42 += gt[61];
+	m_A42 += gt[62];
+	m_A41 += go[59];
+	m_A43 += go[60];
+	double RHS16 = Idr[59];
+	RHS16 += Idr[60];
+	RHS16 += Idr[61];
+	RHS16 += Idr[62];
+	RHS16 -= go[61] * *cnV[61];
+	RHS16 -= go[62] * *cnV[62];
+	m_A45 += gt[63];
+	m_A45 += gt[64];
+	m_A45 += gt[65];
+	m_A46 += go[63];
+	m_A44 += go[64];
+	double RHS17 = Idr[63];
+	RHS17 += Idr[64];
+	RHS17 += Idr[65];
+	RHS17 -= go[65] * *cnV[65];
+	m_A52 += gt[66];
+	m_A52 += gt[67];
+	m_A52 += gt[68];
+	m_A52 += gt[69];
+	m_A52 += gt[70];
+	m_A52 += gt[71];
+	m_A49 += go[66];
+	m_A50 += go[67];
+	m_A51 += go[68];
+	m_A47 += go[69];
+	m_A48 += go[70];
+	double RHS18 = Idr[66];
+	RHS18 += Idr[67];
+	RHS18 += Idr[68];
+	RHS18 += Idr[69];
+	RHS18 += Idr[70];
+	RHS18 += Idr[71];
+	RHS18 -= go[71] * *cnV[71];
+	m_A59 += gt[72];
+	m_A59 += gt[73];
+	m_A57 += go[72];
+	m_A62 += go[73];
+	double RHS19 = Idr[72];
+	RHS19 += Idr[73];
+	m_A66 += gt[74];
+	m_A66 += gt[75];
+	m_A66 += gt[76];
+	m_A66 += gt[77];
+	m_A66 += gt[78];
+	m_A66 += gt[79];
+	m_A66 += gt[80];
+	m_A63 += go[74];
+	m_A64 += go[75];
+	m_A68 += go[76];
+	m_A67 += go[77];
+	m_A67 += go[78];
+	double RHS20 = Idr[74];
+	RHS20 += Idr[75];
+	RHS20 += Idr[76];
+	RHS20 += Idr[77];
+	RHS20 += Idr[78];
+	RHS20 += Idr[79];
+	RHS20 += Idr[80];
+	RHS20 -= go[79] * *cnV[79];
+	RHS20 -= go[80] * *cnV[80];
+	m_A73 += gt[81];
+	m_A73 += gt[82];
+	m_A73 += gt[83];
+	m_A73 += gt[84];
+	m_A73 += gt[85];
+	m_A72 += go[81];
+	m_A72 += go[82];
+	m_A71 += go[83];
+	m_A69 += go[84];
+	m_A70 += go[85];
+	double RHS21 = Idr[81];
+	RHS21 += Idr[82];
+	RHS21 += Idr[83];
+	RHS21 += Idr[84];
+	RHS21 += Idr[85];
+	m_A80 += gt[86];
+	m_A80 += gt[87];
+	m_A80 += gt[88];
+	m_A80 += gt[89];
+	m_A80 += gt[90];
+	m_A80 += gt[91];
+	m_A80 += gt[92];
+	m_A80 += gt[93];
+	m_A80 += gt[94];
+	m_A80 += gt[95];
+	m_A80 += gt[96];
+	m_A75 += go[86];
+	m_A82 += go[87];
+	m_A76 += go[88];
+	double RHS22 = Idr[86];
+	RHS22 += Idr[87];
+	RHS22 += Idr[88];
+	RHS22 += Idr[89];
+	RHS22 += Idr[90];
+	RHS22 += Idr[91];
+	RHS22 += Idr[92];
+	RHS22 += Idr[93];
+	RHS22 += Idr[94];
+	RHS22 += Idr[95];
+	RHS22 += Idr[96];
+	RHS22 -= go[89] * *cnV[89];
+	RHS22 -= go[90] * *cnV[90];
+	RHS22 -= go[91] * *cnV[91];
+	RHS22 -= go[92] * *cnV[92];
+	RHS22 -= go[93] * *cnV[93];
+	RHS22 -= go[94] * *cnV[94];
+	RHS22 -= go[95] * *cnV[95];
+	RHS22 -= go[96] * *cnV[96];
+	m_A88 += gt[97];
+	m_A88 += gt[98];
+	m_A88 += gt[99];
+	m_A88 += gt[100];
+	m_A88 += gt[101];
+	m_A83 += go[97];
+	m_A85 += go[98];
+	m_A84 += go[99];
+	m_A86 += go[100];
+	double RHS23 = Idr[97];
+	RHS23 += Idr[98];
+	RHS23 += Idr[99];
+	RHS23 += Idr[100];
+	RHS23 += Idr[101];
+	RHS23 -= go[101] * *cnV[101];
+	m_A94 += gt[102];
+	m_A94 += gt[103];
+	m_A94 += gt[104];
+	m_A91 += go[102];
+	m_A89 += go[103];
+	m_A92 += go[104];
+	double RHS24 = Idr[102];
+	RHS24 += Idr[103];
+	RHS24 += Idr[104];
+	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;
+}
+
 // ripoff
 static void nl_gcr_4b5ecfbb8f9fa97b_29_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV)
 
@@ -39720,6 +41571,76 @@ static void nl_gcr_ab9144d965a37e4_113_double_double(double * __restrict V, cons
 	V[0] = (RHS0 - tmp0) / m_A0;
 }
 
+// sspeedr
+static void nl_gcr_ac1e401ddf971e15_10_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);
+	m_A0 += gt[0];
+	m_A0 += gt[1];
+	m_A0 += gt[2];
+	m_A1 += go[0];
+	double RHS0 = Idr[0];
+	RHS0 += Idr[1];
+	RHS0 += Idr[2];
+	RHS0 -= go[1] * *cnV[1];
+	RHS0 -= go[2] * *cnV[2];
+	m_A2 += gt[3];
+	m_A2 += gt[4];
+	m_A2 += gt[5];
+	m_A3 += go[3];
+	double RHS1 = Idr[3];
+	RHS1 += Idr[4];
+	RHS1 += Idr[5];
+	RHS1 -= go[4] * *cnV[4];
+	RHS1 -= go[5] * *cnV[5];
+	m_A4 += gt[6];
+	m_A5 += go[6];
+	double RHS2 = Idr[6];
+	m_A9 += gt[7];
+	m_A9 += gt[8];
+	m_A9 += gt[9];
+	m_A8 += go[7];
+	m_A7 += go[8];
+	m_A6 += go[9];
+	double RHS3 = Idr[7];
+	RHS3 += Idr[8];
+	RHS3 += Idr[9];
+	const double f0 = 1.0 / m_A0;
+	const double f0_3 = -f0 * m_A6;
+	m_A9 += m_A1 * f0_3;
+	RHS3 += f0_3 * RHS0;
+	const double f1 = 1.0 / m_A2;
+	const double f1_3 = -f1 * m_A7;
+	m_A9 += m_A3 * f1_3;
+	RHS3 += f1_3 * RHS1;
+	const double f2 = 1.0 / m_A4;
+	const double f2_3 = -f2 * m_A8;
+	m_A9 += m_A5 * f2_3;
+	RHS3 += f2_3 * RHS2;
+	V[3] = RHS3 / m_A9;
+	double tmp2 = 0.0;
+	tmp2 += m_A5 * V[3];
+	V[2] = (RHS2 - tmp2) / m_A4;
+	double tmp1 = 0.0;
+	tmp1 += m_A3 * V[3];
+	V[1] = (RHS1 - tmp1) / m_A2;
+	double tmp0 = 0.0;
+	tmp0 += m_A1 * V[3];
+	V[0] = (RHS0 - tmp0) / m_A0;
+}
+
 // starfire
 static void nl_gcr_aceb6035dfb557c9_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV)
 
@@ -59169,6 +61090,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = {
 	{"nl_gcr_1f1086787c94f97c_40_double_double", reinterpret_cast<void *>(&nl_gcr_1f1086787c94f97c_40_double_double)},
 // zac1b11142
 	{"nl_gcr_1fad5cda2646cf42_30_double_double", reinterpret_cast<void *>(&nl_gcr_1fad5cda2646cf42_30_double_double)},
+// sspeedr
+	{"nl_gcr_2294220d3c91e762_176_double_double", reinterpret_cast<void *>(&nl_gcr_2294220d3c91e762_176_double_double)},
 // 280zzzap
 	{"nl_gcr_24643c159711f292_95_double_double", reinterpret_cast<void *>(&nl_gcr_24643c159711f292_95_double_double)},
 // zac1b11142
@@ -59183,6 +61106,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = {
 	{"nl_gcr_328d886b444b586b_137_double_double", reinterpret_cast<void *>(&nl_gcr_328d886b444b586b_137_double_double)},
 // solarq
 	{"nl_gcr_34e910fc1896999f_76_double_double", reinterpret_cast<void *>(&nl_gcr_34e910fc1896999f_76_double_double)},
+// sspeedr
+	{"nl_gcr_3e833834e5ce5aee_13_double_double", reinterpret_cast<void *>(&nl_gcr_3e833834e5ce5aee_13_double_double)},
 // warrior
 	{"nl_gcr_42a31ce5c187b308_12_double_double", reinterpret_cast<void *>(&nl_gcr_42a31ce5c187b308_12_double_double)},
 // 280zzzap
@@ -59197,6 +61122,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = {
 	{"nl_gcr_450d2a81bd0b282c_36_double_double", reinterpret_cast<void *>(&nl_gcr_450d2a81bd0b282c_36_double_double)},
 // gamemachine
 	{"nl_gcr_491f95430bfdfd05_19_double_double", reinterpret_cast<void *>(&nl_gcr_491f95430bfdfd05_19_double_double)},
+// sspeedr
+	{"nl_gcr_4a8e2b707bbac8a6_95_double_double", reinterpret_cast<void *>(&nl_gcr_4a8e2b707bbac8a6_95_double_double)},
 // ripoff
 	{"nl_gcr_4b5ecfbb8f9fa97b_29_double_double", reinterpret_cast<void *>(&nl_gcr_4b5ecfbb8f9fa97b_29_double_double)},
 // gtrak10
@@ -59345,6 +61272,8 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = {
 	{"nl_gcr_aa07266ef5d420d1_11_double_double", reinterpret_cast<void *>(&nl_gcr_aa07266ef5d420d1_11_double_double)},
 // 280zzzap
 	{"nl_gcr_ab9144d965a37e4_113_double_double", reinterpret_cast<void *>(&nl_gcr_ab9144d965a37e4_113_double_double)},
+// sspeedr
+	{"nl_gcr_ac1e401ddf971e15_10_double_double", reinterpret_cast<void *>(&nl_gcr_ac1e401ddf971e15_10_double_double)},
 // starfire
 	{"nl_gcr_aceb6035dfb557c9_12_double_double", reinterpret_cast<void *>(&nl_gcr_aceb6035dfb557c9_12_double_double)},
 // sundance
diff --git a/src/mame/audio/nl_sspeedr.cpp b/src/mame/audio/nl_sspeedr.cpp
new file mode 100644
index 00000000000..d1308ce88c2
--- /dev/null
+++ b/src/mame/audio/nl_sspeedr.cpp
@@ -0,0 +1,651 @@
+// 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 Super
+// Speed Race, based on the schematics in _Midway's Super Speed Race Parts and
+// Operating Manual_. These circuits are generally quite similar to those in
+// Midway's earlier games 280-ZZZAP and Laguna Racer (see nl_280zzzap.cpp),
+// but the Super Speed Race circuits have some significant changes, and their
+// board layout is different.
+
+// The components are all labeled as they are on the Super Speed Race
+// schematics, except that since the noise generator discrete components are
+// on the main motherboard and thus may have the same labels as components on
+// the audio board, a prefix "NOISE_" has been added to their labels. 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.
+
+// For detailed descriptions of these circuits, see the 280-ZZZAP/Laguna Racer
+// netlist, nl_280zzzap.cpp. I do not repeat those descriptions here.
+
+
+// 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
+
+// Enable a voltage limiter on the output of the op-amp which generates the
+// post-crash sound. This removes voltage glitches from the output which would
+// otherwise be audible when the netlist is run with a fixed 48 kHz timestep,
+// as it is in MAME.
+
+#define REMOVE_POST_CRASH_NOISE_GLITCHES  1
+
+
+static NETLIST_START(sspeedr_noisegen)
+
+	// See p. 25 of the Super Speed Race manual for the motherboard
+	// schematic, which includes the noise generator.
+
+	// This is a digital noise source of 12-volt amplitude, formed by a
+	// linear-feedback shift register driven by a 4 kHz clock.
+
+	CD4006_DIP(H5_SHFTREG)
+	CD4070_DIP(J5_XORx4)
+
+	NET_C(I_V12.Q, H5_SHFTREG.14, J5_XORx4.14)
+	NET_C(GND, H5_SHFTREG.7, J5_XORx4.7)
+	NET_C(GND, J5_XORx4.8, J5_XORx4.9)
+
+	RES(NOISE_R22, RES_K(680))
+	RES(NOISE_R23, RES_K(56))
+	RES(NOISE_R24, RES_K(27))
+	RES(NOISE_R25, RES_K(220))
+	RES(NOISE_R62, RES_M(1))
+
+	// The following is a very low-valued dummy resistance inserted to
+	// make the noise source's startup circuit voltage behave properly;
+	// without this it just stays at zero from the beginning and the
+	// generator refuses to start:
+	RES(NOISE_RDUMMY, RES_R(1))
+
+	CAP(NOISE_C8, CAP_U(0.001))
+	CAP(NOISE_C9, CAP_U(0.1))
+	DIODE(NOISE_CR3, "1N4148")
+
+	NET_C(GND, J5_XORx4.6)
+	NET_C(J5_XORx4.4, J5_XORx4.12, NOISE_C8.1)
+	NET_C(I_V12.Q, J5_XORx4.13)
+	NET_C(J5_XORx4.11, H5_SHFTREG.3, NOISE_R23.1)
+	NET_C(NOISE_R23.2, NOISE_C8.2, NOISE_R22.1)
+	NET_C(NOISE_R22.2, J5_XORx4.5)
+
+	NET_C(H5_SHFTREG.13, H5_SHFTREG.5)
+	NET_C(H5_SHFTREG.12, H5_SHFTREG.1, J5_XORx4.1)
+	NET_C(H5_SHFTREG.8, J5_XORx4.2)
+	NET_C(H5_SHFTREG.10, H5_SHFTREG.6)
+	NET_C(NOISE_R24.2, H5_SHFTREG.4)
+	NET_C(J5_XORx4.3, NOISE_R25.1)
+	NET_C(NOISE_R25.2, NOISE_CR3.K, NOISE_R24.1)
+	NET_C(NOISE_C9.2, NOISE_CR3.A, NOISE_R62.1)
+	NET_C(I_V12.Q, NOISE_RDUMMY.1)
+	NET_C(NOISE_RDUMMY.2, NOISE_C9.1)
+	NET_C(NOISE_R62.2, GND)
+
+	ALIAS(NOISE_OUT, H5_SHFTREG.10)
+
+NETLIST_END()
+
+
+//
+// Main netlist
+//
+
+
+static NETLIST_START(sspeedr_schematics)
+
+	// **** Conversion of accelerator level to "engine speed" control
+	// **** voltage for engine sound, with capacitor-based "engine
+	// **** inertia" and gear shift changes.
+
+	CD4016_DIP(A2)
+
+	LM3900(C1_3)
+	LM3900(C1_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))
+
+	RES(R51, RES_K(470))
+	RES(R46, RES_M(2.2))
+	RES(R47, RES_M(1))
+	RES(R48, RES_K(470))
+	RES(R49, RES_K(240))
+
+	RES(R50, RES_K(100))
+	CAP(C30, CAP_U(1))
+	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(22))
+
+	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(C1_3.PLUS, R46.2, R47.2, R48.2, R49.2, R51.2)
+	NET_C(C1_3.MINUS, R50.2, C30.2)
+	NET_C(C1_3.OUT, R50.1, C30.1, R53.1, D4.K)
+	NET_C(R53.2, R52.1, C18.1, R56.2, R54.1)
+	NET_C(R52.2, D4.A)
+	NET_C(C1_4.PLUS, R54.2, R55.2)
+	NET_C(C1_4.MINUS, R58.2, R57.2, A2.4)
+	// The following are only local connections to C1_4.OUT. It also runs
+	// to all the oscillators; those connections are listed further down.
+	NET_C(C1_4.OUT, D5.A, R59.1)
+	NET_C(D5.K, R58.1)
+	NET_C(C19.1, R59.2, R60.2)
+
+	NET_C(A2.1, GND)
+	NET_C(A2.2, R56.1)
+	NET_C(A2.13, ENGINE_SOUND_OFF)
+
+	NET_C(A2.5, R62.2, HI_SHIFT)
+
+	NET_C(A2.3, A2.8, C19.2)
+	NET_C(A2.9, R60.1)
+	NET_C(A2.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.
+
+	// These are the remaining connections from C1_4.OUT:
+	NET_C(C1_4.OUT, R36.1, R37.1, R31.1, R32.1, R29.1, R30.1)
+
+	MC3340_DIP(MC3340_F1)
+
+	CD4016_DIP(B1)
+
+	// First oscillator (bottommost in schematics).
+
+	LM3900(C1_2)
+	LM3900(C1_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)
+
+	NET_C(R37.2, B1.10)
+	NET_C(B1.11, C1_2.PLUS)
+	NET_C(R36.2, C1_2.MINUS, C17.1)
+	NET_C(C1_2.OUT, C17.2, R38.1, D3.A)
+	NET_C(R38.2, C1_1.MINUS)
+	NET_C(C1_1.OUT, R40.1, B1.12)
+	NET_C(I_V5.Q, R39.1)
+	NET_C(C1_1.PLUS, R39.2, R40.2)
+	NET_C(R41.1, D3.K, D2.K, C16.1)
+
+	// Second oscillator (middle in schematics).
+
+	LM3900(A1_3)
+	LM3900(A1_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, B1.4)
+	NET_C(B1.3, A1_3.PLUS)
+	NET_C(R31.2, A1_3.MINUS, C15.1)
+	NET_C(A1_3.OUT, C15.2, R33.1, D2.A)
+	NET_C(R33.2, A1_4.MINUS)
+	NET_C(A1_4.OUT, R35.1, B1.5)
+	NET_C(I_V5.Q, R34.1)
+	NET_C(A1_4.PLUS, R34.2, R35.2)
+	NET_C(C16.2, MC3340_F1.1)  // to MC3340 input pin
+
+	// Third oscillator (topmost in schematics).
+
+	LM3900(A1_2)
+	LM3900(A1_1)
+
+	RES(R29, RES_K(220))
+
+	RES(R30, RES_K(100))
+
+	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(453))
+	RES(R27, RES_K(286))
+#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_V5.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, B1.1)
+	NET_C(B1.2, A1_2.PLUS)
+	NET_C(R29.2, A1_2.MINUS, C14.1)
+	NET_C(A1_2.OUT, C14.2, R28.1, C13.1)
+	NET_C(R28.2, A1_1.MINUS)
+	NET_C(A1_1.OUT, R27.1, B1.13)
+	NET_C(I_V5.Q, R26.1)
+	NET_C(A1_1.PLUS, R26.2, R27.2)
+	NET_C(D1.K, R23.2, C13.2, R25.1, MC3340_F1.2)  // to MC3340 ctrl pin
+
+	// 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 Super Speed Race is a
+	// linear-feedback shift register on the main motherboard which
+	// generates a digital random noise signal. This digital noise gets
+	// smoothed and filtered into continuous analog form in the same way
+	// as in 280-ZZZAP and Laguna Racer, and the noise-based sound effect
+	// circuits are similar.
+
+	CAP(C1, CAP_U(10))
+
+	LOCAL_SOURCE(sspeedr_noisegen)
+	INCLUDE(sspeedr_noisegen)
+
+	NET_C(NOISE_OUT, C1.1)
+
+	NET_C(C1.2, R1.1)
+
+	// The noise generator is followed by a single-amplifier active
+	// low-pass filter which converts the digital noise waveform into a
+	// smoother analog noise waveform.
+
+	RES(R1, RES_K(680))
+
+	LM3900(H2_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(H2_1.MINUS, R2.2, C3.1)
+	NET_C(I_V5.Q, R3.1)
+	NET_C(H2_1.PLUS, R3.2)
+	NET_C(H2_1.OUT, C3.2, R4.2, R5.1, R17.1, C5.1, C4.1)
+
+	// The smoothed analog 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), a two-amplifier active
+	// bandpass filter.
+
+	CD4016_DIP(E2)
+
+	LM3900(H2_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))
+	CAP(C25, CAP_U(0.1))
+
+	NET_C(R5.2, R6.1, C7.1, C8.1, R12.1)
+	NET_C(R6.2, GND)
+	NET_C(H2_3.MINUS, C7.2, R8.1)
+	NET_C(I_V5.Q, R7.1)
+	NET_C(H2_3.PLUS, R7.2)
+	NET_C(H2_3.OUT, R8.2, C8.2, E2.10)
+	NET_C(E2.11, C25.1)
+	NET_C(C25.2, R9.1)
+
+	LM3900(J1_2)
+
+	// Unlike the other LM3900s, those on chip J1 get 12-volt power.
+	NET_C(I_V12.Q, J1_2.VCC)
+	NET_C(GND, J1_2.GND)
+
+	RES(R9, RES_K(39))
+	RES(R10, RES_K(240))
+	RES(R11, RES_K(120))
+	RES(R12, RES_K(62))
+
+	NET_C(J1_2.MINUS, R9.2, R11.1)
+	NET_C(I_V5.Q, R10.1)
+	NET_C(J1_2.PLUS, R10.2)
+	NET_C(J1_2.OUT, R11.2, R12.2, E2.4)
+	NET_C(E2.3, R63.1)
+	NET_C(E2.5, E2.12, NOISE_CR_1)
+
+	// Second noise circuit: secondary crash noise (NOISE_CR_2), a
+	// single-amplifier active low-pass filter.
+
+	RES(R17, RES_K(10))
+
+	CAP(C5, CAP_U(10))
+	CAP(C4, CAP_U(0.022))
+
+	LM3900(H2_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(H2_2.MINUS, R15.2, C9.1)
+	NET_C(I_V5.Q, R14.1)
+	NET_C(H2_2.PLUS, R14.2)
+#if REMOVE_POST_CRASH_NOISE_GLITCHES
+	// With the static time-stepping used to ensure acceptable performance
+	// with MAME, this part of the netlist will generate extra spikes on
+	// the op-amp output with voltages outside of the real op-amp's output
+	// range. These spikes give the sound an unwanted "grittiness" not in
+	// the original, so I've added a voltage-limiting AFUNC to the op-amp
+	// output beyond its feedback connection. This gives a smoother sound,
+	// closer to the original.
+
+	NET_C(H2_2.OUT, C9.2, R13.2, H2_2_LIM.A0)
+	AFUNC(H2_2_LIM, 1, "max(min(A0, 4.5), 0)")
+	NET_C(H2_2_LIM.Q, E2.8)
+#else
+	NET_C(H2_2.OUT, C9.2, R13.2, E2.8)
+#endif
+	NET_C(E2.9, R64.1)
+	NET_C(E2.6, NOISE_CR_2)
+
+	// Third noise circuit: boom from crash (BOOM), a single-amplifier
+	// active bandpass filter.
+
+	LM3900(H2_4)
+
+	RES(R18, RES_K(20))
+
+	RES(R19, RES_K(1))
+	RES(R20, RES_M(3.3))
+	RES(R21, RES_M(1.5))
+
+	CAP(C10, CAP_U(0.1))
+	CAP(C11, CAP_U(0.1))
+
+	NET_C(R17.2, C5.2, E2.1)
+	NET_C(E2.2, R18.1)
+	NET_C(E2.13, BOOM)
+	NET_C(R18.2, R19.1, C10.1, C11.1)
+	NET_C(R19.2, GND)
+	NET_C(H2_4.MINUS, C10.2, R21.1)
+	NET_C(I_V5.Q, R20.1)
+	NET_C(H2_4.PLUS, R20.2)
+	NET_C(H2_4.OUT, R21.2, C11.2, R65.1)
+
+
+	// **** Final mix of sound effects and sound preamplification.
+
+	RES(R63, RES_K(3))
+	RES(R64, RES_K(150))
+
+	RES(R65, RES_K(12))
+
+	RES(R66, RES_K(33))
+
+	CAP(C20, CAP_U(1.0))
+	CAP(C21, CAP_U(10))
+
+	NET_C(R63.2, R64.2, R65.2, C20.1)
+	NET_C(MC3340_F1.7, R66.1)  // MC3340 output pin
+	NET_C(R66.2, C21.1)
+
+	LM3900(J1_4)
+	LM3900(J1_1)
+
+	NET_C(I_V12.Q, J1_4.VCC, J1_1.VCC)
+	NET_C(GND, J1_4.GND, J1_1.GND)
+
+	RES(R67, RES_K(2))
+	CAP(C22, CAP_U(10))
+	RES(R68, RES_K(220))
+	RES(R74, RES_K(220))
+
+	NET_C(I_V12.Q, R67.1)
+	NET_C(R67.2, C22.1, R68.1, R74.1)
+	NET_C(C22.2, GND)
+	NET_C(J1_4.PLUS, R68.2)
+	NET_C(J1_1.PLUS, R74.2)
+
+	RES(R69, RES_K(100))
+	POT2(R70, RES_K(50))  // Master volume potentiometer (2 terminals)
+	CAP(C23, CAP_U(10))
+	CAP(C24, CAP_U(0.1))
+	RES(R73, RES_K(100))
+	RES(R75, RES_K(100))
+
+	DIODE(D6, 1N914)
+	DIODE(D7, 1N914)
+	RES(R71, RES_K(10))
+	RES(R72, RES_K(10))
+
+	NET_C(SILENCE, D6.A, D7.A)
+	NET_C(D6.K, R71.1)
+	NET_C(D7.K, R72.1)
+
+	NET_C(R70.2, C23.2)
+	NET_C(J1_4.MINUS, C20.2, C21.2, R69.1, R70.1, R71.2)
+	NET_C(J1_4.OUT, C23.1, R69.2, C24.1)
+	NET_C(C24.2, R73.1)
+	NET_C(J1_1.MINUS, R73.2, R75.1, R72.2)
+	NET_C(J1_1.OUT, R75.2)
+
+	ALIAS(OUTPUT, J1_1.OUT)
+
+NETLIST_END()
+
+
+NETLIST_START(sspeedr)
+
+	SOLVER(Solver, 48000)
+
+	ANALOG_INPUT(I_V12, 12)
+	ANALOG_INPUT(I_V5, 5)
+
+	LOCAL_SOURCE(sspeedr_schematics)
+	INCLUDE(sspeedr_schematics)
+
+	// The MC3340 gets 5-volt power in Super Speed Race.
+	NET_C(I_V5.Q, MC3340_F1.8)
+	NET_C(GND, MC3340_F1.3)
+
+	// Logic inputs which represent output pins from 74174 latches at C2
+	// and D2
+	LOGIC_INPUT(I_F4_2, 0, "74XX")  // BOOM
+	LOGIC_INPUT(I_F4_5, 0, "74XX")  // ENGINE SOUND OFF
+	LOGIC_INPUT(I_F4_7, 0, "74XX")  // NOISE CR 1
+	LOGIC_INPUT(I_F4_10, 0, "74XX")  // NOISE CR 2
+	LOGIC_INPUT(I_F4_12, 0, "74XX")  // SILENCE
+	LOGIC_INPUT(I_F5_2, 1, "74XX")  // PEDAL_BIT0
+	LOGIC_INPUT(I_F5_5, 1, "74XX")  // PEDAL_BIT1
+	LOGIC_INPUT(I_F5_7, 1, "74XX")  // PEDAL_BIT2
+	LOGIC_INPUT(I_F5_10, 1, "74XX")  // PEDAL_BIT3
+	LOGIC_INPUT(I_F5_12, 0, "74XX")  // HI SHIFT
+	LOGIC_INPUT(I_F5_15, 1, "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_SILENCE, I_F4_12.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(SILENCE, I_F4_12.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_F4_12.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_F4_12.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)
+
+	// 5-volt power for most of the LM3900 op-amps.
+	NET_C(I_V5.Q,
+		H2_1.VCC, H2_3.VCC,
+		H2_4.VCC, H2_2.VCC, C1_3.VCC, C1_4.VCC,
+		A1_1.VCC, A1_2.VCC, A1_3.VCC, A1_4.VCC,
+		C1_1.VCC, C1_2.VCC)
+	NET_C(GND,
+		H2_1.GND, H2_3.GND,
+		H2_4.GND, H2_2.GND, C1_3.GND, C1_4.GND,
+		A1_1.GND, A1_2.GND, A1_3.GND, A1_4.GND,
+		C1_1.GND, C1_2.GND)
+
+	// 5-volt power for the CD4016 switches.
+	NET_C(I_V5.Q, A2.14, B1.14, E2.14)
+	NET_C(GND, A2.7, B1.7, E2.7)
+	// Switches A2_D and B1_C are unused.
+	NET_C(GND, A2.10, A2.11, A2.12, B1.6, B1.8, B1.9)
+
+	// Frontier after output of noise generator.
+	OPTIMIZE_FRONTIER(C1.1, RES_M(1), 50)
+
+	// Frontier before skid screech generator.
+	OPTIMIZE_FRONTIER(R5.1, RES_K(39), 50)
+
+	// Frontiers after NOISE CR 2 and BOOM generators.
+	OPTIMIZE_FRONTIER(R64.1, RES_K(150), 50)
+	OPTIMIZE_FRONTIER(R65.1, RES_K(12), 50)
+
+	// Frontier after engine sound generation.
+	OPTIMIZE_FRONTIER(R66.1, RES_K(33), 50)
+
+	// Frontiers before MC3340 inputs.
+	OPTIMIZE_FRONTIER(C16.1, RES_M(1), 50)
+	OPTIMIZE_FRONTIER(C13.1, RES_M(1), 50)
+
+	// Frontiers before engine sound op-amp oscillators.
+	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(100), 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(286), 50)
+#endif
+
+NETLIST_END()
diff --git a/src/mame/audio/nl_sspeedr.h b/src/mame/audio/nl_sspeedr.h
new file mode 100644
index 00000000000..d5172fb272d
--- /dev/null
+++ b/src/mame/audio/nl_sspeedr.h
@@ -0,0 +1,12 @@
+// license:CC0
+// copyright-holders:Colin Douglas Howell
+#ifndef MAME_AUDIO_NL_SSPEEDR_H
+#define MAME_AUDIO_NL_SSPEEDR_H
+
+#pragma once
+
+#include "netlist/nl_setup.h"
+
+NETLIST_EXTERNAL(sspeedr)
+
+#endif // MAME_AUDIO_NL_SSPEEDR_H
diff --git a/src/mame/drivers/sspeedr.cpp b/src/mame/drivers/sspeedr.cpp
index 76f6f1ad271..c43d956a331 100644
--- a/src/mame/drivers/sspeedr.cpp
+++ b/src/mame/drivers/sspeedr.cpp
@@ -2,12 +2,14 @@
 // copyright-holders:Stefan Jokisch
 /***************************************************************************
 
-Taito Super Speed Race driver
+Taito / Midway Super Speed Race driver
 
 ***************************************************************************/
 
 #include "emu.h"
 #include "includes/sspeedr.h"
+#include "audio/nl_sspeedr.h"
+#include "speaker.h"
 
 #include "cpu/z80/z80.h"
 #include "machine/watchdog.h"
@@ -71,9 +73,57 @@ void sspeedr_state::sspeedr_score_w(offs_t offset, uint8_t data)
 }
 
 
-void sspeedr_state::sspeedr_sound_w(uint8_t data)
+void sspeedr_state::sspeedr_sound1_w(uint8_t data)
 {
-	/* not implemented */
+	// **** Output pins from 74174 latch at C2 ****
+
+	// Bits 0-3 (PEDAL_BIT0 to PEDAL_BIT3): accelerator pedal position
+	// Sets the frequency and volume of the engine sound oscillators.
+	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));
+
+	// Bit 4 (HI SHIFT): set when gearshift is in high gear
+	// Modifies the engine sound to be lower pitched at a given speed and
+	// to change more slowly.
+	m_hi_shift->write_line(BIT(data, 4));
+
+	// Bit 5 (LO SHIFT): set when gearshift is in low gear
+	// Modifies the engine sound to be higher pitched at a given speed and
+	// to change faster.
+	m_lo_shift->write_line(BIT(data, 5));
+
+	// Bits 6-7 (D6, D7): not connected.
+}
+
+
+void sspeedr_state::sspeedr_sound2_w(uint8_t data)
+{
+	// **** Output pins from 74174 latch at D2 ****
+
+	// Bit 0 (BOOM): Set to activate boom sound for a crash. Cleared to
+	// terminate boom.
+	m_boom->write_line(BIT(data, 0));
+
+	// Bit 1 (ENGINE SOUND OFF): Set to turn *off* engine sound.
+	// Used in a crash.
+	m_engine_sound_off->write_line(BIT(data, 1));
+
+	// Bit 2 (NOISE CR 1): tire squealing sound
+	// Set to activate "tire squeal" noise from noise generator.
+	m_noise_cr_1->write_line(BIT(data, 2));
+
+	// Bit 3 (NOISE CR 2): secondary crash noise
+	// Set to activate high-pitched screeching hiss that accompanies BOOM
+	// when the the car crashes. In Super Speed Race, the BOOM and NOISE
+	// CR 2 effects play simultaneously.
+	m_noise_cr_2->write_line(BIT(data, 3));
+
+	// Bit 4 (SILENCE): mute all sound when game is not running.
+	m_silence->write_line(BIT(data, 4));
+
+	// Bits 5-7 (D5, D6, D7): not connected.
 }
 
 
@@ -89,8 +139,9 @@ void sspeedr_state::sspeedr_io_map(address_map &map)
 {
 	map.global_mask(0xff);
 	map(0x00, 0x00).portr("IN0");
+	map(0x00, 0x00).w(FUNC(sspeedr_state::sspeedr_sound1_w));
 	map(0x01, 0x01).portr("IN1");
-	map(0x00, 0x01).w(FUNC(sspeedr_state::sspeedr_sound_w));
+	map(0x01, 0x01).w(FUNC(sspeedr_state::sspeedr_sound2_w));
 	map(0x02, 0x02).w(FUNC(sspeedr_state::sspeedr_lamp_w));
 	map(0x03, 0x03).portr("DSW");
 	map(0x04, 0x04).portr("IN2");
@@ -159,6 +210,9 @@ static INPUT_PORTS_START( sspeedr )
 	PORT_BIT( 0x02, IP_ACTIVE_LOW, IPT_UNUSED )
 	PORT_BIT( 0x04, IP_ACTIVE_LOW, IPT_BUTTON1 ) PORT_NAME("Shifter") PORT_TOGGLE
 	PORT_BIT( 0x08, IP_ACTIVE_LOW, IPT_COIN1 )
+
+	PORT_START("POT_MASTER_VOL")
+	PORT_ADJUSTER( 50, "Pot: Master Volume" )  NETLIST_ANALOG_PORT_CHANGED("sound_nl", "pot_master_vol")
 INPUT_PORTS_END
 
 
@@ -212,6 +266,31 @@ void sspeedr_state::sspeedr(machine_config &config)
 	PALETTE(config, m_palette, FUNC(sspeedr_state::sspeedr_palette), 16);
 
 	/* sound hardware */
+	SPEAKER(config, "mono").front_center();
+
+	NETLIST_SOUND(config, "sound_nl", 48000)
+		.set_source(NETLIST_NAME(sspeedr))
+		.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_LOGIC_INPUT(config, "sound_nl:silence", "I_SILENCE", 0);
+
+	// Audio output is from an LM3900 op-amp whose output has a
+	// peak-to-peak range of about 12 volts, centered on 6 volts.
+	NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(32767.0 / 6.0, -32767.0);
+
+	// Netlist volume-potentiometer interface
+	NETLIST_ANALOG_INPUT(config, "sound_nl:pot_master_vol", "R70.DIAL");
 }
 
 
@@ -231,4 +310,4 @@ ROM_START( sspeedr )
 ROM_END
 
 
-GAMEL( 1979, sspeedr, 0, sspeedr, sspeedr, sspeedr_state, empty_init, ROT270, "Midway", "Super Speed Race", MACHINE_NO_SOUND, layout_sspeedr )
+GAMEL( 1979, sspeedr, 0, sspeedr, sspeedr, sspeedr_state, empty_init, ROT270, "Midway", "Super Speed Race", 0, layout_sspeedr )
diff --git a/src/mame/includes/sspeedr.h b/src/mame/includes/sspeedr.h
index c9e223643aa..4324808941f 100644
--- a/src/mame/includes/sspeedr.h
+++ b/src/mame/includes/sspeedr.h
@@ -6,6 +6,7 @@
 #pragma once
 
 #include "emupal.h"
+#include "machine/netlist.h"
 
 class sspeedr_state : public driver_device
 {
@@ -16,6 +17,17 @@ public:
 		, m_gfxdecode(*this, "gfxdecode")
 		, m_palette(*this, "palette")
 		, m_digits(*this, "digit%u", 0U)
+		, 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")
+		, m_silence(*this, "sound_nl:silence")
 	{ }
 
 	void sspeedr(machine_config &config);
@@ -25,7 +37,8 @@ private:
 	void sspeedr_lamp_w(uint8_t data);
 	void sspeedr_time_w(offs_t offset, uint8_t data);
 	void sspeedr_score_w(offs_t offset, uint8_t data);
-	void sspeedr_sound_w(uint8_t data);
+	void sspeedr_sound1_w(uint8_t data);
+	void sspeedr_sound2_w(uint8_t data);
 	void sspeedr_driver_horz_w(uint8_t data);
 	void sspeedr_driver_horz_2_w(uint8_t data);
 	void sspeedr_driver_vert_w(uint8_t data);
@@ -65,6 +78,17 @@ private:
 	required_device<gfxdecode_device> m_gfxdecode;
 	required_device<palette_device> m_palette;
 	output_finder<26> m_digits;
+	required_device<netlist_mame_logic_input_device> m_pedal_bit0;
+	required_device<netlist_mame_logic_input_device> m_pedal_bit1;
+	required_device<netlist_mame_logic_input_device> m_pedal_bit2;
+	required_device<netlist_mame_logic_input_device> m_pedal_bit3;
+	required_device<netlist_mame_logic_input_device> m_hi_shift;
+	required_device<netlist_mame_logic_input_device> m_lo_shift;
+	required_device<netlist_mame_logic_input_device> m_boom;
+	required_device<netlist_mame_logic_input_device> m_engine_sound_off;
+	required_device<netlist_mame_logic_input_device> m_noise_cr_1;
+	required_device<netlist_mame_logic_input_device> m_noise_cr_2;
+	required_device<netlist_mame_logic_input_device> m_silence;
 };
 
 #endif // MAME_INCLUDES_SSPEEDR_H
diff --git a/src/mame/nl.lst b/src/mame/nl.lst
index 2d2b61091d2..a55bc5f1fcb 100644
--- a/src/mame/nl.lst
+++ b/src/mame/nl.lst
@@ -478,6 +478,9 @@ wrestwar1d                      //
 wrestwar2                       // (c) 1989 (FD1094)
 wrestwar2d                      //
 
+@source:sspeedr.cpp
+sspeedr                         // Midway
+
 @source:starcrus.cpp
 starcrus