diff --git a/scripts/src/netlist.lua b/scripts/src/netlist.lua index 3bc6cb34645..fca5dc2a3ce 100644 --- a/scripts/src/netlist.lua +++ b/scripts/src/netlist.lua @@ -233,4 +233,6 @@ project "netlist" MAME_DIR .. "src/lib/netlist/macro/nlm_opamp.h", MAME_DIR .. "src/lib/netlist/macro/nlm_other.cpp", MAME_DIR .. "src/lib/netlist/macro/nlm_other.h", + + MAME_DIR .. "src/lib/netlist/generated/static_solvers.cpp", } diff --git a/scripts/src/tools.lua b/scripts/src/tools.lua index 283b53f1b2c..a31abad29e9 100644 --- a/scripts/src/tools.lua +++ b/scripts/src/tools.lua @@ -462,6 +462,10 @@ includedirs { MAME_DIR .. "src/lib/netlist", } +defines { + "NL_DISABLE_DYNAMIC_LOAD=1", +} + files { MAME_DIR .. "src/lib/netlist/prg/nltool.cpp", } diff --git a/src/devices/machine/netlist.cpp b/src/devices/machine/netlist.cpp index 851c63cc2c9..bfd654dfff3 100644 --- a/src/devices/machine/netlist.cpp +++ b/src/devices/machine/netlist.cpp @@ -52,7 +52,6 @@ DEFINE_DEVICE_TYPE(NETLIST_LOGIC_OUTPUT, netlist_mame_logic_output_device, "nl DEFINE_DEVICE_TYPE(NETLIST_ANALOG_OUTPUT, netlist_mame_analog_output_device, "nl_analog_out", "Netlist Analog Output") DEFINE_DEVICE_TYPE(NETLIST_STREAM_OUTPUT, netlist_mame_stream_output_device, "nl_stream_out", "Netlist Stream Output") - // ---------------------------------------------------------------------------------------- // Special netlist extension devices .... // ---------------------------------------------------------------------------------------- @@ -88,7 +87,6 @@ protected: m_parent.logerror("netlist ERROR: %s\n", ls.c_str()); break; case plib::plog_level::FATAL: - //throw emu_fatalerror(1, "netlist FATAL: %s\n", ls.c_str()); m_parent.logerror("netlist FATAL: %s\n", ls.c_str()); break; } @@ -128,10 +126,14 @@ protected: case plib::plog_level::FATAL: osd_printf_error("netlist FATAL: %s\n", ls); break; - //throw emu_fatalerror(1, "netlist FATAL: %s\n", ls.c_str()); } } + plib::unique_ptr static_solver_lib() const noexcept override + { + return plib::make_unique(nullptr); + } + private: }; diff --git a/src/lib/netlist/analog/nld_generic_models.h b/src/lib/netlist/analog/nld_generic_models.h index 336699fcaad..59ba3455966 100644 --- a/src/lib/netlist/analog/nld_generic_models.h +++ b/src/lib/netlist/analog/nld_generic_models.h @@ -124,6 +124,29 @@ namespace analog nl_fptype m_gmin; }; + // Constant model for constant capacitor model + // "Circuit simulation", page 274 + struct generic_capacitor_const + { + public: + generic_capacitor_const(device_t &dev, const pstring &name) + : m_gmin(nlconst::zero()) + { + } + + // Returns { G, Ieq } + std::pair timestep(nl_fptype cap, nl_fptype v, nl_fptype step) const noexcept + { + const nl_fptype h(plib::reciprocal(step)); + const nl_fptype G(cap * h + m_gmin); + return { G, - G * v }; + } + void setparams(nl_fptype gmin) noexcept { m_gmin = gmin; } + private: + nl_fptype m_gmin; + }; + + // ----------------------------------------------------------------------------- // A generic diode model to be used in other devices (Diode, BJT ...) // ----------------------------------------------------------------------------- @@ -155,9 +178,9 @@ namespace analog , nlconst::magic(1) , nlconst::magic(1e-15) , nlconst::magic(300.0)); - m_name = name; + //m_name = name; } - pstring m_name; + //pstring m_name; // Basic math // // I(V) = f(V) diff --git a/src/lib/netlist/analog/nlid_twoterm.cpp b/src/lib/netlist/analog/nlid_twoterm.cpp index 13aca445c77..eeaf1919fef 100644 --- a/src/lib/netlist/analog/nlid_twoterm.cpp +++ b/src/lib/netlist/analog/nlid_twoterm.cpp @@ -164,8 +164,8 @@ namespace analog NETLIB_UPDATE_TERMINALS(D) { m_D.update_diode(deltaV()); - const nl_fptype G = m_D.G(); - const nl_fptype I = m_D.Ieq(); + const nl_fptype G(m_D.G()); + const nl_fptype I(m_D.Ieq()); set_mat( G, -G, -I, -G, G, I); //set(m_D.G(), 0.0, m_D.Ieq()); diff --git a/src/lib/netlist/analog/nlid_twoterm.h b/src/lib/netlist/analog/nlid_twoterm.h index d869144cbe2..c0c7def1613 100644 --- a/src/lib/netlist/analog/nlid_twoterm.h +++ b/src/lib/netlist/analog/nlid_twoterm.h @@ -245,7 +245,44 @@ namespace analog // ----------------------------------------------------------------------------- // nld_C // ----------------------------------------------------------------------------- +#if 1 + NETLIB_OBJECT_DERIVED(C, twoterm) + { + public: + NETLIB_CONSTRUCTOR_DERIVED(C, twoterm) + , m_C(*this, "C", nlconst::magic(1e-6)) + , m_cap(*this, "m_cap") + { + } + NETLIB_IS_TIMESTEP(true) + NETLIB_TIMESTEPI() + { + // G, Ieq + const auto res(m_cap.timestep(m_C(), deltaV(), step)); + const nl_fptype G = res.first; + const nl_fptype I = res.second; + set_mat( G, -G, -I, + -G, G, I); + } + + NETLIB_RESETI() + { + m_cap.setparams(exec().gmin()); + } + + param_fp_t m_C; + protected: + //NETLIB_UPDATEI(); + //FIXME: should be able to change + NETLIB_UPDATE_PARAMI() { } + + private: + generic_capacitor_const m_cap; + }; + +#else + // Code preserved as a basis for a current/voltage controlled capacitor NETLIB_OBJECT_DERIVED(C, twoterm) { public: @@ -292,7 +329,7 @@ namespace analog //generic_capacitor m_cap; generic_capacitor m_cap; }; - +#endif // ----------------------------------------------------------------------------- // nld_L // ----------------------------------------------------------------------------- diff --git a/src/lib/netlist/devices/nld_mm5837.cpp b/src/lib/netlist/devices/nld_mm5837.cpp index c9583ed503b..42d5a176265 100644 --- a/src/lib/netlist/devices/nld_mm5837.cpp +++ b/src/lib/netlist/devices/nld_mm5837.cpp @@ -74,7 +74,7 @@ namespace netlist log().warning(MW_FREQUENCY_OUTSIDE_OF_SPECS_1(m_FREQ())); m_shift = 0x1ffff; - m_is_timestep = m_RV.m_P.net().solver()->has_timestep_devices(); + m_is_timestep = (m_RV.m_P.net().solver()->timestep_device_count() > 0); } NETLIB_UPDATE_PARAM(MM5837_dip) diff --git a/src/lib/netlist/devices/nld_schmitt.cpp b/src/lib/netlist/devices/nld_schmitt.cpp index c36ce978b0d..fdbde7af7b4 100644 --- a/src/lib/netlist/devices/nld_schmitt.cpp +++ b/src/lib/netlist/devices/nld_schmitt.cpp @@ -82,7 +82,7 @@ namespace netlist m_last_state = 1; m_RVI.reset(); m_RVO.reset(); - m_is_timestep = m_RVO.m_P.net().solver()->has_timestep_devices(); + m_is_timestep = (m_RVO.m_P.net().solver()->timestep_device_count() > 0); m_RVI.set_G_V_I(plib::reciprocal(m_model.m_RI()), m_model.m_VI, nlconst::zero()); m_RVO.set_G_V_I(plib::reciprocal(m_model.m_ROL()), m_model.m_VOL, nlconst::zero()); } diff --git a/src/lib/netlist/devices/nlid_proxy.cpp b/src/lib/netlist/devices/nlid_proxy.cpp index fd86f7381ef..e8629f55290 100644 --- a/src/lib/netlist/devices/nlid_proxy.cpp +++ b/src/lib/netlist/devices/nlid_proxy.cpp @@ -145,7 +145,7 @@ namespace netlist m_last_state = -1; m_RN.reset(); m_RP.reset(); - m_is_timestep = m_RN.m_P.net().solver()->has_timestep_devices(); + m_is_timestep = (m_RN.m_P.net().solver()->timestep_device_count() > 0); m_RN.set_G_V_I(plib::reciprocal(logic_family()->R_low()), logic_family()->low_offset_V(), nlconst::zero()); m_RP.set_G_V_I(G_OFF, diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp new file mode 100755 index 00000000000..484d27fefea --- /dev/null +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -0,0 +1,9871 @@ +#include "plib/pdynlib.h" +static void nl_gcr_111d6ad4781c136_19(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25] + gt[26]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A8 = gt[32] + gt[33] + gt[34]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A10 = gt[40] + gt[41] + gt[42]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[41] * *cnV[41] - go[42] * *cnV[42]; + m_A18 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53] + gt[54]; + m_A17 = m_A17 + go[48]; + m_A16 = m_A16 + go[49]; + m_A15 = m_A15 + go[50]; + m_A14 = m_A14 + go[51]; + m_A13 = m_A13 + go[52]; + m_A12 = m_A12 + go[53]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] - go[54] * *cnV[54]; +const double f0 = 1.0 / m_A0; + const double f0_6 = -f0 * m_A12; + m_A18 += m_A1 * f0_6; + RHS6 += f0_6 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A13; + m_A18 += m_A3 * f1_6; + RHS6 += f1_6 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_6 = -f2 * m_A14; + m_A18 += m_A5 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_6 = -f3 * m_A15; + m_A18 += m_A7 * f3_6; + RHS6 += f3_6 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_6 = -f4 * m_A16; + m_A18 += m_A9 * f4_6; + RHS6 += f4_6 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_6 = -f5 * m_A17; + m_A18 += m_A11 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A18; + double tmp5 = 0.0; + tmp5 += m_A11 * V[6]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[6]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[6]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[6]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[6]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_11995a0d28843023_150(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); +double m_A90(0.0); +double m_A91(0.0); +double m_A92(0.0); +double m_A93(0.0); +double m_A94(0.0); +double m_A95(0.0); +double m_A96(0.0); +double m_A97(0.0); +double m_A98(0.0); +double m_A99(0.0); +double m_A100(0.0); +double m_A101(0.0); +double m_A102(0.0); +double m_A103(0.0); +double m_A104(0.0); +double m_A105(0.0); +double m_A106(0.0); +double m_A107(0.0); +double m_A108(0.0); +double m_A109(0.0); +double m_A110(0.0); +double m_A111(0.0); +double m_A112(0.0); +double m_A113(0.0); +double m_A114(0.0); +double m_A115(0.0); +double m_A116(0.0); +double m_A117(0.0); +double m_A118(0.0); +double m_A119(0.0); +double m_A120(0.0); +double m_A121(0.0); +double m_A122(0.0); +double m_A123(0.0); +double m_A124(0.0); +double m_A125(0.0); +double m_A126(0.0); +double m_A127(0.0); +double m_A128(0.0); +double m_A129(0.0); +double m_A130(0.0); +double m_A131(0.0); +double m_A132(0.0); +double m_A133(0.0); +double m_A134(0.0); +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); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[12] + gt[13] + gt[14]; + m_A3 = m_A3 + go[12]; + double RHS1 = Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A4 = gt[24] + gt[25] + gt[26]; + m_A6 = m_A6 + go[24]; + m_A5 = m_A5 + go[25]; + double RHS2 = Idr[24] + Idr[25] + Idr[26] - go[26] * *cnV[26]; + m_A7 = gt[36] + gt[37] + gt[38] + gt[39] + gt[40]; + m_A10 = m_A10 + go[36]; + m_A9 = m_A9 + go[37]; + m_A8 = m_A8 + go[38]; + double RHS3 = Idr[36] + Idr[37] + Idr[38] + Idr[39] + Idr[40] - go[39] * *cnV[39] - go[40] * *cnV[40]; + m_A11 = gt[48] + gt[49] + gt[50]; + m_A12 = m_A12 + go[48]; + double RHS4 = Idr[48] + Idr[49] + Idr[50] - go[49] * *cnV[49] - go[50] * *cnV[50]; + m_A13 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64] + gt[65] + gt[66]; + m_A15 = m_A15 + go[60]; + m_A14 = m_A14 + go[61]; + double RHS5 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] + Idr[65] + Idr[66] - go[62] * *cnV[62] - go[63] * *cnV[63] - go[64] * *cnV[64] - go[65] * *cnV[65] - go[66] * *cnV[66]; + m_A16 = gt[72] + gt[73] + gt[74]; + m_A17 = m_A17 + go[72]; + double RHS6 = Idr[72] + Idr[73] + Idr[74] - go[73] * *cnV[73] - go[74] * *cnV[74]; + m_A18 = gt[84] + gt[85]; + m_A19 = m_A19 + go[84]; + double RHS7 = Idr[84] + Idr[85] - go[85] * *cnV[85]; + m_A20 = gt[96] + gt[97] + gt[98]; + m_A21 = m_A21 + go[96]; + m_A23 = m_A23 + go[97]; + m_A22 = m_A22 + go[98]; + double RHS8 = Idr[96] + Idr[97] + Idr[98]; + m_A24 = gt[108] + gt[109] + gt[110]; + m_A25 = m_A25 + go[108]; + double RHS9 = Idr[108] + Idr[109] + Idr[110] - go[109] * *cnV[109] - go[110] * *cnV[110]; + m_A26 = gt[120] + gt[121] + gt[122] + gt[123]; + m_A27 = m_A27 + go[120]; + m_A28 = m_A28 + go[121]; + double RHS10 = Idr[120] + Idr[121] + Idr[122] + Idr[123] - go[122] * *cnV[122] - go[123] * *cnV[123]; + m_A29 = gt[132] + gt[133]; + m_A30 = m_A30 + go[132]; + double RHS11 = Idr[132] + Idr[133] - go[133] * *cnV[133]; + m_A31 = gt[144] + gt[145] + gt[146] + gt[147]; + m_A32 = m_A32 + go[144]; + m_A33 = m_A33 + go[145]; + double RHS12 = Idr[144] + Idr[145] + Idr[146] + Idr[147] - go[146] * *cnV[146] - go[147] * *cnV[147]; + m_A34 = gt[156] + gt[157] + gt[158]; + m_A36 = m_A36 + go[156]; + m_A35 = m_A35 + go[157]; + double RHS13 = Idr[156] + Idr[157] + Idr[158] - go[158] * *cnV[158]; + m_A37 = gt[168] + gt[169]; + m_A38 = m_A38 + go[168]; + double RHS14 = Idr[168] + Idr[169] - go[169] * *cnV[169]; + m_A39 = gt[180] + gt[181]; + m_A40 = m_A40 + go[180]; + double RHS15 = Idr[180] + Idr[181] - go[181] * *cnV[181]; + m_A41 = gt[192] + gt[193]; + m_A42 = m_A42 + go[192]; + double RHS16 = Idr[192] + Idr[193] - go[193] * *cnV[193]; + m_A43 = gt[204] + gt[205] + gt[206] + gt[207] + gt[208]; + m_A44 = m_A44 + go[204]; + m_A46 = m_A46 + go[205]; + m_A45 = m_A45 + go[206]; + double RHS17 = Idr[204] + Idr[205] + Idr[206] + Idr[207] + Idr[208] - go[207] * *cnV[207] - go[208] * *cnV[208]; + m_A47 = gt[216] + gt[217] + gt[218] + gt[219] + gt[220]; + m_A48 = m_A48 + go[216]; + m_A50 = m_A50 + go[217]; + m_A49 = m_A49 + go[218]; + double RHS18 = Idr[216] + Idr[217] + Idr[218] + Idr[219] + Idr[220] - go[219] * *cnV[219] - go[220] * *cnV[220]; + m_A51 = gt[228] + gt[229]; + m_A52 = m_A52 + go[228]; + double RHS19 = Idr[228] + Idr[229] - go[229] * *cnV[229]; + m_A55 = gt[240] + gt[241]; + m_A54 = m_A54 + go[240]; + m_A53 = m_A53 + go[241]; + double RHS20 = Idr[240] + Idr[241]; + m_A60 = gt[252] + gt[253] + gt[254]; + m_A58 = m_A58 + go[252]; + m_A57 = m_A57 + go[253]; + double RHS21 = Idr[252] + Idr[253] + Idr[254] - go[254] * *cnV[254]; + m_A63 = gt[264] + gt[265]; + m_A64 = m_A64 + go[264]; + double RHS22 = Idr[264] + Idr[265] - go[265] * *cnV[265]; + m_A65 = gt[276] + gt[277] + gt[278]; + m_A66 = m_A66 + go[276]; + double RHS23 = Idr[276] + Idr[277] + Idr[278] - go[277] * *cnV[277] - go[278] * *cnV[278]; + m_A69 = gt[288] + gt[289] + gt[290]; + m_A67 = m_A67 + go[288]; + m_A68 = m_A68 + go[289]; + double RHS24 = Idr[288] + Idr[289] + Idr[290] - go[290] * *cnV[290]; + m_A76 = gt[300] + gt[301]; + m_A73 = m_A73 + go[300]; + m_A72 = m_A72 + go[301]; + double RHS25 = Idr[300] + Idr[301]; + m_A81 = gt[312] + gt[313]; + m_A80 = m_A80 + go[312]; + m_A79 = m_A79 + go[313]; + double RHS26 = Idr[312] + Idr[313]; + m_A84 = gt[324] + gt[325] + gt[326]; + m_A85 = m_A85 + go[324]; + m_A83 = m_A83 + go[325]; + double RHS27 = Idr[324] + Idr[325] + Idr[326] - go[326] * *cnV[326]; + m_A88 = gt[336] + gt[337]; + m_A87 = m_A87 + go[336]; + m_A86 = m_A86 + go[337]; + double RHS28 = Idr[336] + Idr[337]; + m_A95 = gt[348] + gt[349] + gt[350] + gt[351] + gt[352]; + m_A90 = m_A90 + go[348]; + m_A92 = m_A92 + go[349]; + m_A91 = m_A91 + go[350]; + double RHS29 = Idr[348] + Idr[349] + Idr[350] + Idr[351] + Idr[352] - go[351] * *cnV[351] - go[352] * *cnV[352]; + m_A100 = gt[360] + gt[361] + gt[362] + gt[363] + gt[364] + gt[365] + gt[366]; + m_A98 = m_A98 + go[360]; + m_A101 = m_A101 + go[361]; + double RHS30 = Idr[360] + Idr[361] + Idr[362] + Idr[363] + Idr[364] + Idr[365] + Idr[366] - go[362] * *cnV[362] - go[363] * *cnV[363] - go[364] * *cnV[364] - go[365] * *cnV[365] - go[366] * *cnV[366]; + m_A103 = gt[372] + gt[373] + gt[374] + gt[375] + gt[376] + gt[377]; + m_A104 = m_A104 + go[372]; + m_A104 = m_A104 + go[373]; + m_A102 = m_A102 + go[374]; + double RHS31 = Idr[372] + Idr[373] + Idr[374] + Idr[375] + Idr[376] + Idr[377] - go[375] * *cnV[375] - go[376] * *cnV[376] - go[377] * *cnV[377]; + m_A110 = gt[384] + gt[385] + gt[386]; + m_A106 = m_A106 + go[384]; + m_A107 = m_A107 + go[385]; + m_A105 = m_A105 + go[386]; + double RHS32 = Idr[384] + Idr[385] + Idr[386]; + m_A114 = gt[396] + gt[397] + gt[398] + gt[399] + gt[400] + gt[401] + gt[402]; + m_A112 = m_A112 + go[396]; + m_A115 = m_A115 + go[397]; + double RHS33 = Idr[396] + Idr[397] + Idr[398] + Idr[399] + Idr[400] + Idr[401] + Idr[402] - go[398] * *cnV[398] - go[399] * *cnV[399] - go[400] * *cnV[400] - go[401] * *cnV[401] - go[402] * *cnV[402]; + m_A121 = gt[408] + gt[409] + gt[410] + gt[411] + gt[412] + gt[413] + gt[414]; + m_A118 = m_A118 + go[408]; + m_A116 = m_A116 + go[409]; + double RHS34 = Idr[408] + Idr[409] + Idr[410] + Idr[411] + Idr[412] + Idr[413] + Idr[414] - go[410] * *cnV[410] - go[411] * *cnV[411] - go[412] * *cnV[412] - go[413] * *cnV[413] - go[414] * *cnV[414]; + m_A125 = gt[420] + gt[421] + gt[422]; + m_A124 = m_A124 + go[420]; + m_A126 = m_A126 + go[421]; + m_A123 = m_A123 + go[422]; + double RHS35 = Idr[420] + Idr[421] + Idr[422]; + m_A132 = gt[432] + gt[433] + gt[434]; + m_A127 = m_A127 + go[432]; + m_A128 = m_A128 + go[433]; + m_A130 = m_A130 + go[434]; + double RHS36 = Idr[432] + Idr[433] + Idr[434]; + m_A149 = gt[444] + gt[445] + gt[446] + gt[447] + gt[448] + gt[449] + gt[450] + gt[451] + gt[452] + gt[453] + gt[454]; + m_A140 = m_A140 + go[444]; + m_A147 = m_A147 + go[445]; + m_A139 = m_A139 + go[446]; + m_A138 = m_A138 + go[447]; + m_A137 = m_A137 + go[448]; + m_A136 = m_A136 + go[449]; + m_A135 = m_A135 + go[450]; + m_A134 = m_A134 + go[451]; + m_A143 = m_A143 + go[452]; + m_A143 = m_A143 + go[453]; + double RHS37 = Idr[444] + Idr[445] + Idr[446] + Idr[447] + Idr[448] + Idr[449] + Idr[450] + Idr[451] + Idr[452] + Idr[453] + Idr[454] - go[454] * *cnV[454]; +const double f0 = 1.0 / m_A0; + const double f0_31 = -f0 * m_A102; + m_A103 += m_A1 * f0_31; + RHS31 += f0_31 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_20 = -f1 * m_A53; + m_A55 += m_A3 * f1_20; + RHS20 += f1_20 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_20 = -f2 * m_A54; + m_A55 += m_A5 * f2_20; + m_A56 += m_A6 * f2_20; + RHS20 += f2_20 * RHS2; + const double f2_21 = -f2 * m_A57; + m_A59 += m_A5 * f2_21; + m_A60 += m_A6 * f2_21; + RHS21 += f2_21 * RHS2; + const double f2_34 = -f2 * m_A116; + m_A117 += m_A5 * f2_34; + m_A118 += m_A6 * f2_34; + RHS34 += f2_34 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_21 = -f3 * m_A58; + m_A60 += m_A8 * f3_21; + m_A61 += m_A9 * f3_21; + m_A62 += m_A10 * f3_21; + RHS21 += f3_21 * RHS3; + const double f3_25 = -f3 * m_A72; + m_A74 += m_A8 * f3_25; + m_A76 += m_A9 * f3_25; + m_A78 += m_A10 * f3_25; + RHS25 += f3_25 * RHS3; +const double f4 = 1.0 / m_A11; + const double f4_24 = -f4 * m_A67; + m_A69 += m_A12 * f4_24; + RHS24 += f4_24 * RHS4; +const double f5 = 1.0 / m_A13; + const double f5_29 = -f5 * m_A90; + m_A91 += m_A14 * f5_29; + m_A93 += m_A15 * f5_29; + RHS29 += f5_29 * RHS5; +const double f6 = 1.0 / m_A16; + const double f6_26 = -f6 * m_A79; + m_A81 += m_A17 * f6_26; + RHS26 += f6_26 * RHS6; +const double f7 = 1.0 / m_A18; + const double f7_27 = -f7 * m_A83; + m_A84 += m_A19 * f7_27; + RHS27 += f7_27 * RHS7; +const double f8 = 1.0 / m_A20; + const double f8_24 = -f8 * m_A68; + m_A69 += m_A21 * f8_24; + m_A70 += m_A22 * f8_24; + m_A71 += m_A23 * f8_24; + RHS24 += f8_24 * RHS8; + const double f8_25 = -f8 * m_A73; + m_A75 += m_A21 * f8_25; + m_A76 += m_A22 * f8_25; + m_A77 += m_A23 * f8_25; + RHS25 += f8_25 * RHS8; + const double f8_29 = -f8 * m_A91; + m_A93 += m_A21 * f8_29; + m_A94 += m_A22 * f8_29; + m_A95 += m_A23 * f8_29; + RHS29 += f8_29 * RHS8; +const double f9 = 1.0 / m_A24; + const double f9_28 = -f9 * m_A86; + m_A88 += m_A25 * f9_28; + RHS28 += f9_28 * RHS9; +const double f10 = 1.0 / m_A26; + const double f10_26 = -f10 * m_A80; + m_A81 += m_A27 * f10_26; + m_A82 += m_A28 * f10_26; + RHS26 += f10_26 * RHS10; + const double f10_33 = -f10 * m_A112; + m_A113 += m_A27 * f10_33; + m_A115 += m_A28 * f10_33; + RHS33 += f10_33 * RHS10; + const double f10_36 = -f10 * m_A127; + m_A129 += m_A27 * f10_36; + m_A132 += m_A28 * f10_36; + RHS36 += f10_36 * RHS10; +const double f11 = 1.0 / m_A29; + const double f11_32 = -f11 * m_A105; + m_A110 += m_A30 * f11_32; + RHS32 += f11_32 * RHS11; +const double f12 = 1.0 / m_A31; + const double f12_28 = -f12 * m_A87; + m_A88 += m_A32 * f12_28; + m_A89 += m_A33 * f12_28; + RHS28 += f12_28 * RHS12; + const double f12_30 = -f12 * m_A98; + m_A99 += m_A32 * f12_30; + m_A101 += m_A33 * f12_30; + RHS30 += f12_30 * RHS12; + const double f12_32 = -f12 * m_A106; + m_A108 += m_A32 * f12_32; + m_A110 += m_A33 * f12_32; + RHS32 += f12_32 * RHS12; +const double f13 = 1.0 / m_A34; + const double f13_29 = -f13 * m_A92; + m_A95 += m_A35 * f13_29; + m_A97 += m_A36 * f13_29; + RHS29 += f13_29 * RHS13; + const double f13_37 = -f13 * m_A134; + m_A141 += m_A35 * f13_37; + m_A149 += m_A36 * f13_37; + RHS37 += f13_37 * RHS13; +const double f14 = 1.0 / m_A37; + const double f14_35 = -f14 * m_A123; + m_A125 += m_A38 * f14_35; + RHS35 += f14_35 * RHS14; +const double f15 = 1.0 / m_A39; + const double f15_35 = -f15 * m_A124; + m_A125 += m_A40 * f15_35; + RHS35 += f15_35 * RHS15; +const double f16 = 1.0 / m_A41; + const double f16_37 = -f16 * m_A135; + m_A149 += m_A42 * f16_37; + RHS37 += f16_37 * RHS16; +const double f17 = 1.0 / m_A43; + const double f17_36 = -f17 * m_A128; + m_A131 += m_A44 * f17_36; + m_A132 += m_A45 * f17_36; + m_A133 += m_A46 * f17_36; + RHS36 += f17_36 * RHS17; + const double f17_37 = -f17 * m_A136; + m_A145 += m_A44 * f17_37; + m_A148 += m_A45 * f17_37; + m_A149 += m_A46 * f17_37; + RHS37 += f17_37 * RHS17; +const double f18 = 1.0 / m_A47; + const double f18_32 = -f18 * m_A107; + m_A109 += m_A48 * f18_32; + m_A110 += m_A49 * f18_32; + m_A111 += m_A50 * f18_32; + RHS32 += f18_32 * RHS18; + const double f18_37 = -f18 * m_A137; + m_A142 += m_A48 * f18_37; + m_A144 += m_A49 * f18_37; + m_A149 += m_A50 * f18_37; + RHS37 += f18_37 * RHS18; +const double f19 = 1.0 / m_A51; + const double f19_37 = -f19 * m_A138; + m_A149 += m_A52 * f19_37; + RHS37 += f19_37 * RHS19; +const double f20 = 1.0 / m_A55; + const double f20_21 = -f20 * m_A59; + m_A60 += m_A56 * f20_21; + RHS21 += f20_21 * RHS20; + const double f20_34 = -f20 * m_A117; + m_A118 += m_A56 * f20_34; + RHS34 += f20_34 * RHS20; +const double f21 = 1.0 / m_A60; + const double f21_25 = -f21 * m_A74; + m_A76 += m_A61 * f21_25; + m_A78 += m_A62 * f21_25; + RHS25 += f21_25 * RHS21; + const double f21_34 = -f21 * m_A118; + m_A119 += m_A61 * f21_34; + m_A121 += m_A62 * f21_34; + RHS34 += f21_34 * RHS21; +const double f22 = 1.0 / m_A63; + const double f22_37 = -f22 * m_A139; + m_A149 += m_A64 * f22_37; + RHS37 += f22_37 * RHS22; +const double f23 = 1.0 / m_A65; + const double f23_37 = -f23 * m_A140; + m_A149 += m_A66 * f23_37; + RHS37 += f23_37 * RHS23; +const double f24 = 1.0 / m_A69; + const double f24_25 = -f24 * m_A75; + m_A76 += m_A70 * f24_25; + m_A77 += m_A71 * f24_25; + RHS25 += f24_25 * RHS24; + const double f24_29 = -f24 * m_A93; + m_A94 += m_A70 * f24_29; + m_A95 += m_A71 * f24_29; + RHS29 += f24_29 * RHS24; +const double f25 = 1.0 / m_A76; + const double f25_29 = -f25 * m_A94; + m_A95 += m_A77 * f25_29; + m_A96 += m_A78 * f25_29; + RHS29 += f25_29 * RHS25; + const double f25_34 = -f25 * m_A119; + m_A120 += m_A77 * f25_34; + m_A121 += m_A78 * f25_34; + RHS34 += f25_34 * RHS25; +const double f26 = 1.0 / m_A81; + const double f26_33 = -f26 * m_A113; + m_A115 += m_A82 * f26_33; + RHS33 += f26_33 * RHS26; + const double f26_36 = -f26 * m_A129; + m_A132 += m_A82 * f26_36; + RHS36 += f26_36 * RHS26; +const double f27 = 1.0 / m_A84; + const double f27_36 = -f27 * m_A130; + m_A132 += m_A85 * f27_36; + RHS36 += f27_36 * RHS27; +const double f28 = 1.0 / m_A88; + const double f28_30 = -f28 * m_A99; + m_A101 += m_A89 * f28_30; + RHS30 += f28_30 * RHS28; + const double f28_32 = -f28 * m_A108; + m_A110 += m_A89 * f28_32; + RHS32 += f28_32 * RHS28; +const double f29 = 1.0 / m_A95; + const double f29_34 = -f29 * m_A120; + m_A121 += m_A96 * f29_34; + m_A122 += m_A97 * f29_34; + RHS34 += f29_34 * RHS29; + const double f29_37 = -f29 * m_A141; + m_A146 += m_A96 * f29_37; + m_A149 += m_A97 * f29_37; + RHS37 += f29_37 * RHS29; +const double f30 = 1.0 / m_A100; + const double f30_32 = -f30 * m_A109; + m_A110 += m_A101 * f30_32; + RHS32 += f30_32 * RHS30; + const double f30_37 = -f30 * m_A142; + m_A144 += m_A101 * f30_37; + RHS37 += f30_37 * RHS30; +const double f31 = 1.0 / m_A103; + const double f31_37 = -f31 * m_A143; + m_A149 += m_A104 * f31_37; + RHS37 += f31_37 * RHS31; +const double f32 = 1.0 / m_A110; + const double f32_37 = -f32 * m_A144; + m_A149 += m_A111 * f32_37; + RHS37 += f32_37 * RHS32; +const double f33 = 1.0 / m_A114; + const double f33_36 = -f33 * m_A131; + m_A132 += m_A115 * f33_36; + RHS36 += f33_36 * RHS33; + const double f33_37 = -f33 * m_A145; + m_A148 += m_A115 * f33_37; + RHS37 += f33_37 * RHS33; +const double f34 = 1.0 / m_A121; + const double f34_37 = -f34 * m_A146; + m_A149 += m_A122 * f34_37; + RHS37 += f34_37 * RHS34; +const double f35 = 1.0 / m_A125; + const double f35_37 = -f35 * m_A147; + m_A149 += m_A126 * f35_37; + RHS37 += f35_37 * RHS35; +const double f36 = 1.0 / m_A132; + const double f36_37 = -f36 * m_A148; + m_A149 += m_A133 * f36_37; + RHS37 += f36_37 * RHS36; + V[37] = RHS37 / m_A149; + double tmp36 = 0.0; + tmp36 += m_A133 * V[37]; + V[36] = (RHS36 - tmp36) / m_A132; + double tmp35 = 0.0; + tmp35 += m_A126 * V[37]; + V[35] = (RHS35 - tmp35) / m_A125; + double tmp34 = 0.0; + tmp34 += m_A122 * V[37]; + V[34] = (RHS34 - tmp34) / m_A121; + double tmp33 = 0.0; + tmp33 += m_A115 * V[36]; + V[33] = (RHS33 - tmp33) / m_A114; + double tmp32 = 0.0; + tmp32 += m_A111 * V[37]; + V[32] = (RHS32 - tmp32) / m_A110; + double tmp31 = 0.0; + tmp31 += m_A104 * V[37]; + V[31] = (RHS31 - tmp31) / m_A103; + double tmp30 = 0.0; + tmp30 += m_A101 * V[32]; + V[30] = (RHS30 - tmp30) / m_A100; + double tmp29 = 0.0; + tmp29 += m_A96 * V[34]; + tmp29 += m_A97 * V[37]; + V[29] = (RHS29 - tmp29) / m_A95; + double tmp28 = 0.0; + tmp28 += m_A89 * V[32]; + V[28] = (RHS28 - tmp28) / m_A88; + double tmp27 = 0.0; + tmp27 += m_A85 * V[36]; + V[27] = (RHS27 - tmp27) / m_A84; + double tmp26 = 0.0; + tmp26 += m_A82 * V[36]; + V[26] = (RHS26 - tmp26) / m_A81; + double tmp25 = 0.0; + tmp25 += m_A77 * V[29]; + tmp25 += m_A78 * V[34]; + V[25] = (RHS25 - tmp25) / m_A76; + double tmp24 = 0.0; + tmp24 += m_A70 * V[25]; + tmp24 += m_A71 * V[29]; + V[24] = (RHS24 - tmp24) / m_A69; + double tmp23 = 0.0; + tmp23 += m_A66 * V[37]; + V[23] = (RHS23 - tmp23) / m_A65; + double tmp22 = 0.0; + tmp22 += m_A64 * V[37]; + V[22] = (RHS22 - tmp22) / m_A63; + double tmp21 = 0.0; + tmp21 += m_A61 * V[25]; + tmp21 += m_A62 * V[34]; + V[21] = (RHS21 - tmp21) / m_A60; + double tmp20 = 0.0; + tmp20 += m_A56 * V[21]; + V[20] = (RHS20 - tmp20) / m_A55; + double tmp19 = 0.0; + tmp19 += m_A52 * V[37]; + V[19] = (RHS19 - tmp19) / m_A51; + double tmp18 = 0.0; + tmp18 += m_A48 * V[30]; + tmp18 += m_A49 * V[32]; + tmp18 += m_A50 * V[37]; + V[18] = (RHS18 - tmp18) / m_A47; + double tmp17 = 0.0; + tmp17 += m_A44 * V[33]; + tmp17 += m_A45 * V[36]; + tmp17 += m_A46 * V[37]; + V[17] = (RHS17 - tmp17) / m_A43; + double tmp16 = 0.0; + tmp16 += m_A42 * V[37]; + V[16] = (RHS16 - tmp16) / m_A41; + double tmp15 = 0.0; + tmp15 += m_A40 * V[35]; + V[15] = (RHS15 - tmp15) / m_A39; + double tmp14 = 0.0; + tmp14 += m_A38 * V[35]; + V[14] = (RHS14 - tmp14) / m_A37; + double tmp13 = 0.0; + tmp13 += m_A35 * V[29]; + tmp13 += m_A36 * V[37]; + V[13] = (RHS13 - tmp13) / m_A34; + double tmp12 = 0.0; + tmp12 += m_A32 * V[28]; + tmp12 += m_A33 * V[32]; + V[12] = (RHS12 - tmp12) / m_A31; + double tmp11 = 0.0; + tmp11 += m_A30 * V[32]; + V[11] = (RHS11 - tmp11) / m_A29; + double tmp10 = 0.0; + tmp10 += m_A27 * V[26]; + tmp10 += m_A28 * V[36]; + V[10] = (RHS10 - tmp10) / m_A26; + double tmp9 = 0.0; + tmp9 += m_A25 * V[28]; + V[9] = (RHS9 - tmp9) / m_A24; + double tmp8 = 0.0; + tmp8 += m_A21 * V[24]; + tmp8 += m_A22 * V[25]; + tmp8 += m_A23 * V[29]; + V[8] = (RHS8 - tmp8) / m_A20; + double tmp7 = 0.0; + tmp7 += m_A19 * V[27]; + V[7] = (RHS7 - tmp7) / m_A18; + double tmp6 = 0.0; + tmp6 += m_A17 * V[26]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[8]; + tmp5 += m_A15 * V[24]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A12 * V[24]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A8 * V[21]; + tmp3 += m_A9 * V[25]; + tmp3 += m_A10 * V[34]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A5 * V[20]; + tmp2 += m_A6 * V[21]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[20]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[31]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_15fa1a3cf923c9fd_29(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25] + gt[26] + gt[27]; + m_A8 = m_A8 + go[24]; + m_A7 = m_A7 + go[25]; + m_A7 = m_A7 + go[26]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] - go[27] * *cnV[27]; + m_A9 = gt[32] + gt[33] + gt[34]; + m_A10 = m_A10 + go[32]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A11 = gt[40] + gt[41]; + m_A12 = m_A12 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A14 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53] + gt[54]; + m_A16 = m_A16 + go[48]; + m_A16 = m_A16 + go[49]; + m_A13 = m_A13 + go[50]; + m_A13 = m_A13 + go[51]; + m_A15 = m_A15 + go[52]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] - go[53] * *cnV[53] - go[54] * *cnV[54]; + m_A22 = gt[56] + gt[57] + gt[58] + gt[59] + gt[60] + gt[61]; + m_A20 = m_A20 + go[56]; + m_A21 = m_A21 + go[57]; + m_A19 = m_A19 + go[58]; + m_A18 = m_A18 + go[59]; + m_A17 = m_A17 + go[60]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] + Idr[60] + Idr[61] - go[61] * *cnV[61]; + m_A28 = gt[64] + gt[65] + gt[66] + gt[67] + gt[68] + gt[69]; + m_A25 = m_A25 + go[64]; + m_A24 = m_A24 + go[65]; + m_A26 = m_A26 + go[66]; + m_A26 = m_A26 + go[67]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] + Idr[67] + Idr[68] + Idr[69] - go[68] * *cnV[68] - go[69] * *cnV[69]; +const double f0 = 1.0 / m_A0; + const double f0_7 = -f0 * m_A17; + m_A22 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_7 = -f1 * m_A18; + m_A22 += m_A3 * f1_7; + RHS7 += f1_7 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_7 = -f2 * m_A19; + m_A22 += m_A5 * f2_7; + RHS7 += f2_7 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_6 = -f3 * m_A13; + m_A14 += m_A7 * f3_6; + m_A16 += m_A8 * f3_6; + RHS6 += f3_6 * RHS3; + const double f3_8 = -f3 * m_A24; + m_A26 += m_A7 * f3_8; + m_A28 += m_A8 * f3_8; + RHS8 += f3_8 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_8 = -f4 * m_A25; + m_A28 += m_A10 * f4_8; + RHS8 += f4_8 * RHS4; +const double f5 = 1.0 / m_A11; + const double f5_7 = -f5 * m_A20; + m_A22 += m_A12 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A14; + const double f6_7 = -f6 * m_A21; + m_A22 += m_A15 * f6_7; + m_A23 += m_A16 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_8 = -f6 * m_A26; + m_A27 += m_A15 * f6_8; + m_A28 += m_A16 * f6_8; + RHS8 += f6_8 * RHS6; +const double f7 = 1.0 / m_A22; + const double f7_8 = -f7 * m_A27; + m_A28 += m_A23 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A28; + double tmp7 = 0.0; + tmp7 += m_A23 * V[8]; + V[7] = (RHS7 - tmp7) / m_A22; + double tmp6 = 0.0; + tmp6 += m_A15 * V[7]; + tmp6 += m_A16 * V[8]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A12 * V[7]; + V[5] = (RHS5 - tmp5) / m_A11; + double tmp4 = 0.0; + tmp4 += m_A10 * V[8]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[6]; + tmp3 += m_A8 * V[8]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[7]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[7]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_169c14d438ffb621_198(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); +double m_A90(0.0); +double m_A91(0.0); +double m_A92(0.0); +double m_A93(0.0); +double m_A94(0.0); +double m_A95(0.0); +double m_A96(0.0); +double m_A97(0.0); +double m_A98(0.0); +double m_A99(0.0); +double m_A100(0.0); +double m_A101(0.0); +double m_A102(0.0); +double m_A103(0.0); +double m_A104(0.0); +double m_A105(0.0); +double m_A106(0.0); +double m_A107(0.0); +double m_A108(0.0); +double m_A109(0.0); +double m_A110(0.0); +double m_A111(0.0); +double m_A112(0.0); +double m_A113(0.0); +double m_A114(0.0); +double m_A115(0.0); +double m_A116(0.0); +double m_A117(0.0); +double m_A118(0.0); +double m_A119(0.0); +double m_A120(0.0); +double m_A121(0.0); +double m_A122(0.0); +double m_A123(0.0); +double m_A124(0.0); +double m_A125(0.0); +double m_A126(0.0); +double m_A127(0.0); +double m_A128(0.0); +double m_A129(0.0); +double m_A130(0.0); +double m_A131(0.0); +double m_A132(0.0); +double m_A133(0.0); +double m_A134(0.0); +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); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A6 = m_A6 + go[16]; + m_A5 = m_A5 + go[17]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[18] * *cnV[18]; + m_A7 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28] + gt[29] + gt[30]; + m_A8 = m_A8 + go[24]; + m_A9 = m_A9 + go[25]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] + Idr[29] + Idr[30] - go[26] * *cnV[26] - go[27] * *cnV[27] - go[28] * *cnV[28] - go[29] * *cnV[29] - go[30] * *cnV[30]; + m_A10 = gt[32] + gt[33]; + m_A12 = m_A12 + go[32]; + m_A11 = m_A11 + go[33]; + double RHS4 = Idr[32] + Idr[33]; + m_A13 = gt[40] + gt[41]; + m_A14 = m_A14 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A15 = gt[48] + gt[49] + gt[50]; + m_A16 = m_A16 + go[48]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] - go[49] * *cnV[49] - go[50] * *cnV[50]; + m_A17 = gt[56] + gt[57] + gt[58] + gt[59] + gt[60] + gt[61] + gt[62]; + m_A19 = m_A19 + go[56]; + m_A18 = m_A18 + go[57]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] + Idr[60] + Idr[61] + Idr[62] - go[58] * *cnV[58] - go[59] * *cnV[59] - go[60] * *cnV[60] - go[61] * *cnV[61] - go[62] * *cnV[62]; + m_A20 = gt[64] + gt[65]; + m_A21 = m_A21 + go[64]; + m_A22 = m_A22 + go[65]; + double RHS8 = Idr[64] + Idr[65]; + m_A23 = gt[72] + gt[73] + gt[74]; + m_A24 = m_A24 + go[72]; + m_A25 = m_A25 + go[73]; + double RHS9 = Idr[72] + Idr[73] + Idr[74] - go[74] * *cnV[74]; + m_A26 = gt[80] + gt[81]; + m_A27 = m_A27 + go[80]; + double RHS10 = Idr[80] + Idr[81] - go[81] * *cnV[81]; + m_A28 = gt[88] + gt[89] + gt[90] + gt[91]; + m_A30 = m_A30 + go[88]; + m_A29 = m_A29 + go[89]; + m_A29 = m_A29 + go[90]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91] - go[91] * *cnV[91]; + m_A31 = gt[96] + gt[97]; + m_A33 = m_A33 + go[96]; + m_A32 = m_A32 + go[97]; + double RHS12 = Idr[96] + Idr[97]; + m_A34 = gt[104] + gt[105] + gt[106]; + m_A36 = m_A36 + go[104]; + m_A35 = m_A35 + go[105]; + double RHS13 = Idr[104] + Idr[105] + Idr[106] - go[106] * *cnV[106]; + m_A37 = gt[112] + gt[113] + gt[114]; + m_A38 = m_A38 + go[112]; + m_A39 = m_A39 + go[113]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] - go[114] * *cnV[114]; + m_A40 = gt[120] + gt[121] + gt[122] + gt[123] + gt[124]; + m_A42 = m_A42 + go[120]; + m_A41 = m_A41 + go[121]; + m_A41 = m_A41 + go[122]; + double RHS15 = Idr[120] + Idr[121] + Idr[122] + Idr[123] + Idr[124] - go[123] * *cnV[123] - go[124] * *cnV[124]; + m_A43 = gt[128] + gt[129] + gt[130] + gt[131]; + m_A44 = m_A44 + go[128]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131] - go[129] * *cnV[129] - go[130] * *cnV[130] - go[131] * *cnV[131]; + m_A45 = gt[136] + gt[137] + gt[138] + gt[139]; + m_A46 = m_A46 + go[136]; + double RHS17 = Idr[136] + Idr[137] + Idr[138] + Idr[139] - go[137] * *cnV[137] - go[138] * *cnV[138] - go[139] * *cnV[139]; + m_A47 = gt[144] + gt[145] + gt[146] + gt[147] + gt[148]; + m_A49 = m_A49 + go[144]; + m_A49 = m_A49 + go[145]; + m_A48 = m_A48 + go[146]; + double RHS18 = Idr[144] + Idr[145] + Idr[146] + Idr[147] + Idr[148] - go[147] * *cnV[147] - go[148] * *cnV[148]; + m_A50 = gt[152] + gt[153] + gt[154] + gt[155] + gt[156]; + m_A53 = m_A53 + go[152]; + m_A52 = m_A52 + go[153]; + m_A51 = m_A51 + go[154]; + m_A51 = m_A51 + go[155]; + double RHS19 = Idr[152] + Idr[153] + Idr[154] + Idr[155] + Idr[156] - go[156] * *cnV[156]; + m_A54 = gt[160] + gt[161] + gt[162] + gt[163]; + m_A57 = m_A57 + go[160]; + m_A56 = m_A56 + go[161]; + m_A55 = m_A55 + go[162]; + double RHS20 = Idr[160] + Idr[161] + Idr[162] + Idr[163] - go[163] * *cnV[163]; + m_A58 = gt[168] + gt[169] + gt[170]; + m_A59 = m_A59 + go[168]; + m_A60 = m_A60 + go[169]; + double RHS21 = Idr[168] + Idr[169] + Idr[170] - go[170] * *cnV[170]; + m_A61 = gt[176] + gt[177]; + m_A62 = m_A62 + go[176]; + m_A63 = m_A63 + go[177]; + double RHS22 = Idr[176] + Idr[177]; + m_A64 = gt[184] + gt[185]; + m_A65 = m_A65 + go[184]; + m_A66 = m_A66 + go[185]; + double RHS23 = Idr[184] + Idr[185]; + m_A69 = gt[192] + gt[193] + gt[194] + gt[195]; + m_A68 = m_A68 + go[192]; + m_A68 = m_A68 + go[193]; + m_A67 = m_A67 + go[194]; + double RHS24 = Idr[192] + Idr[193] + Idr[194] + Idr[195] - go[195] * *cnV[195]; + m_A75 = gt[200] + gt[201] + gt[202]; + m_A73 = m_A73 + go[200]; + m_A72 = m_A72 + go[201]; + double RHS25 = Idr[200] + Idr[201] + Idr[202] - go[202] * *cnV[202]; + m_A79 = gt[208] + gt[209] + gt[210]; + m_A78 = m_A78 + go[208]; + m_A77 = m_A77 + go[209]; + double RHS26 = Idr[208] + Idr[209] + Idr[210] - go[210] * *cnV[210]; + m_A83 = gt[216] + gt[217] + gt[218] + gt[219] + gt[220] + gt[221]; + m_A82 = m_A82 + go[216]; + m_A82 = m_A82 + go[217]; + m_A81 = m_A81 + go[218]; + double RHS27 = Idr[216] + Idr[217] + Idr[218] + Idr[219] + Idr[220] + Idr[221] - go[219] * *cnV[219] - go[220] * *cnV[220] - go[221] * *cnV[221]; + m_A93 = gt[224] + gt[225] + gt[226]; + m_A87 = m_A87 + go[224]; + m_A89 = m_A89 + go[225]; + m_A88 = m_A88 + go[226]; + double RHS28 = Idr[224] + Idr[225] + Idr[226]; + m_A102 = gt[232] + gt[233] + gt[234]; + m_A99 = m_A99 + go[232]; + m_A98 = m_A98 + go[233]; + m_A97 = m_A97 + go[234]; + double RHS29 = Idr[232] + Idr[233] + Idr[234]; + m_A110 = gt[240] + gt[241] + gt[242] + gt[243]; + m_A107 = m_A107 + go[240]; + m_A106 = m_A106 + go[241]; + m_A106 = m_A106 + go[242]; + double RHS30 = Idr[240] + Idr[241] + Idr[242] + Idr[243] - go[243] * *cnV[243]; + m_A116 = gt[248] + gt[249] + gt[250] + gt[251] + gt[252] + gt[253]; + m_A114 = m_A114 + go[248]; + m_A115 = m_A115 + go[249]; + m_A115 = m_A115 + go[250]; + m_A117 = m_A117 + go[251]; + m_A117 = m_A117 + go[252]; + m_A113 = m_A113 + go[253]; + double RHS31 = Idr[248] + Idr[249] + Idr[250] + Idr[251] + Idr[252] + Idr[253]; + m_A120 = gt[256] + gt[257]; + m_A119 = m_A119 + go[256]; + double RHS32 = Idr[256] + Idr[257] - go[257] * *cnV[257]; + m_A123 = gt[264] + gt[265]; + m_A122 = m_A122 + go[264]; + m_A124 = m_A124 + go[265]; + double RHS33 = Idr[264] + Idr[265]; + m_A126 = gt[272] + gt[273] + gt[274] + gt[275] + gt[276] + gt[277] + gt[278]; + m_A125 = m_A125 + go[272]; + m_A127 = m_A127 + go[273]; + double RHS34 = Idr[272] + Idr[273] + Idr[274] + Idr[275] + Idr[276] + Idr[277] + Idr[278] - go[274] * *cnV[274] - go[275] * *cnV[275] - go[276] * *cnV[276] - go[277] * *cnV[277] - go[278] * *cnV[278]; + m_A129 = gt[280] + gt[281]; + m_A128 = m_A128 + go[280]; + double RHS35 = Idr[280] + Idr[281] - go[281] * *cnV[281]; + m_A133 = gt[288] + gt[289] + gt[290] + gt[291] + gt[292] + gt[293]; + m_A132 = m_A132 + go[288]; + m_A135 = m_A135 + go[289]; + m_A131 = m_A131 + go[290]; + double RHS36 = Idr[288] + Idr[289] + Idr[290] + Idr[291] + Idr[292] + Idr[293] - go[291] * *cnV[291] - go[292] * *cnV[292] - go[293] * *cnV[293]; + m_A139 = gt[296] + gt[297] + gt[298] + gt[299] + gt[300] + gt[301]; + m_A136 = m_A136 + go[296]; + m_A137 = m_A137 + go[297]; + m_A141 = m_A141 + go[298]; + m_A138 = m_A138 + go[299]; + double RHS37 = Idr[296] + Idr[297] + Idr[298] + Idr[299] + Idr[300] + Idr[301] - go[300] * *cnV[300] - go[301] * *cnV[301]; + m_A149 = gt[304] + gt[305] + gt[306] + gt[307] + gt[308] + gt[309]; + m_A145 = m_A145 + go[304]; + m_A144 = m_A144 + go[305]; + m_A142 = m_A142 + go[306]; + m_A143 = m_A143 + go[307]; + m_A152 = m_A152 + go[308]; + double RHS38 = Idr[304] + Idr[305] + Idr[306] + Idr[307] + Idr[308] + Idr[309] - go[309] * *cnV[309]; + m_A157 = gt[312] + gt[313] + gt[314] + gt[315] + gt[316]; + m_A154 = m_A154 + go[312]; + m_A153 = m_A153 + go[313]; + m_A155 = m_A155 + go[314]; + m_A155 = m_A155 + go[315]; + double RHS39 = Idr[312] + Idr[313] + Idr[314] + Idr[315] + Idr[316] - go[316] * *cnV[316]; + m_A164 = gt[320] + gt[321] + gt[322] + gt[323] + gt[324]; + m_A162 = m_A162 + go[320]; + m_A165 = m_A165 + go[321]; + m_A165 = m_A165 + go[322]; + m_A161 = m_A161 + go[323]; + m_A163 = m_A163 + go[324]; + double RHS40 = Idr[320] + Idr[321] + Idr[322] + Idr[323] + Idr[324]; + m_A174 = gt[328] + gt[329] + gt[330]; + m_A167 = m_A167 + go[328]; + m_A166 = m_A166 + go[329]; + m_A171 = m_A171 + go[330]; + double RHS41 = Idr[328] + Idr[329] + Idr[330]; + m_A182 = gt[336] + gt[337] + gt[338]; + m_A177 = m_A177 + go[336]; + m_A178 = m_A178 + go[337]; + m_A179 = m_A179 + go[338]; + double RHS42 = Idr[336] + Idr[337] + Idr[338]; + m_A197 = gt[344] + gt[345] + gt[346] + gt[347] + gt[348] + gt[349] + gt[350] + gt[351]; + m_A192 = m_A192 + go[344]; + m_A185 = m_A185 + go[345]; + m_A186 = m_A186 + go[346]; + m_A184 = m_A184 + go[347]; + m_A194 = m_A194 + go[348]; + m_A194 = m_A194 + go[349]; + double RHS43 = Idr[344] + Idr[345] + Idr[346] + Idr[347] + Idr[348] + Idr[349] + Idr[350] + Idr[351] - go[350] * *cnV[350] - go[351] * *cnV[351]; +const double f0 = 1.0 / m_A0; + const double f0_33 = -f0 * m_A122; + m_A123 += m_A1 * f0_33; + RHS33 += f0_33 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_34 = -f1 * m_A125; + m_A127 += m_A3 * f1_34; + RHS34 += f1_34 * RHS1; + const double f1_40 = -f1 * m_A161; + m_A164 += m_A3 * f1_40; + RHS40 += f1_40 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_40 = -f2 * m_A162; + m_A164 += m_A5 * f2_40; + m_A165 += m_A6 * f2_40; + RHS40 += f2_40 * RHS2; + const double f2_43 = -f2 * m_A184; + m_A194 += m_A5 * f2_43; + m_A197 += m_A6 * f2_43; + RHS43 += f2_43 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_37 = -f3 * m_A136; + m_A138 += m_A8 * f3_37; + m_A139 += m_A9 * f3_37; + RHS37 += f3_37 * RHS3; +const double f4 = 1.0 / m_A10; + const double f4_37 = -f4 * m_A137; + m_A139 += m_A11 * f4_37; + m_A140 += m_A12 * f4_37; + RHS37 += f4_37 * RHS4; + const double f4_38 = -f4 * m_A142; + m_A148 += m_A11 * f4_38; + m_A149 += m_A12 * f4_38; + RHS38 += f4_38 * RHS4; +const double f5 = 1.0 / m_A13; + const double f5_42 = -f5 * m_A177; + m_A182 += m_A14 * f5_42; + RHS42 += f5_42 * RHS5; +const double f6 = 1.0 / m_A15; + const double f6_36 = -f6 * m_A131; + m_A133 += m_A16 * f6_36; + RHS36 += f6_36 * RHS6; +const double f7 = 1.0 / m_A17; + const double f7_36 = -f7 * m_A132; + m_A134 += m_A18 * f7_36; + m_A135 += m_A19 * f7_36; + RHS36 += f7_36 * RHS7; +const double f8 = 1.0 / m_A20; + const double f8_27 = -f8 * m_A81; + m_A83 += m_A21 * f8_27; + m_A86 += m_A22 * f8_27; + RHS27 += f8_27 * RHS8; + const double f8_43 = -f8 * m_A185; + m_A187 += m_A21 * f8_43; + m_A197 += m_A22 * f8_43; + RHS43 += f8_43 * RHS8; +const double f9 = 1.0 / m_A23; + const double f9_31 = -f9 * m_A113; + m_A116 += m_A24 * f9_31; + m_A118 += m_A25 * f9_31; + RHS31 += f9_31 * RHS9; + const double f9_43 = -f9 * m_A186; + m_A191 += m_A24 * f9_43; + m_A197 += m_A25 * f9_43; + RHS43 += f9_43 * RHS9; +const double f10 = 1.0 / m_A26; + const double f10_31 = -f10 * m_A114; + m_A116 += m_A27 * f10_31; + RHS31 += f10_31 * RHS10; +const double f11 = 1.0 / m_A28; + const double f11_31 = -f11 * m_A115; + m_A116 += m_A29 * f11_31; + m_A117 += m_A30 * f11_31; + RHS31 += f11_31 * RHS11; + const double f11_39 = -f11 * m_A153; + m_A155 += m_A29 * f11_39; + m_A157 += m_A30 * f11_39; + RHS39 += f11_39 * RHS11; +const double f12 = 1.0 / m_A31; + const double f12_38 = -f12 * m_A143; + m_A149 += m_A32 * f12_38; + m_A150 += m_A33 * f12_38; + RHS38 += f12_38 * RHS12; + const double f12_39 = -f12 * m_A154; + m_A156 += m_A32 * f12_39; + m_A157 += m_A33 * f12_39; + RHS39 += f12_39 * RHS12; +const double f13 = 1.0 / m_A34; + const double f13_37 = -f13 * m_A138; + m_A139 += m_A35 * f13_37; + m_A141 += m_A36 * f13_37; + RHS37 += f13_37 * RHS13; + const double f13_41 = -f13 * m_A166; + m_A171 += m_A35 * f13_41; + m_A174 += m_A36 * f13_41; + RHS41 += f13_41 * RHS13; +const double f14 = 1.0 / m_A37; + const double f14_24 = -f14 * m_A67; + m_A69 += m_A38 * f14_24; + m_A71 += m_A39 * f14_24; + RHS24 += f14_24 * RHS14; + const double f14_28 = -f14 * m_A87; + m_A90 += m_A38 * f14_28; + m_A93 += m_A39 * f14_28; + RHS28 += f14_28 * RHS14; +const double f15 = 1.0 / m_A40; + const double f15_24 = -f15 * m_A68; + m_A69 += m_A41 * f15_24; + m_A70 += m_A42 * f15_24; + RHS24 += f15_24 * RHS15; + const double f15_25 = -f15 * m_A72; + m_A74 += m_A41 * f15_25; + m_A75 += m_A42 * f15_25; + RHS25 += f15_25 * RHS15; +const double f16 = 1.0 / m_A43; + const double f16_25 = -f16 * m_A73; + m_A75 += m_A44 * f16_25; + RHS25 += f16_25 * RHS16; +const double f17 = 1.0 / m_A45; + const double f17_26 = -f17 * m_A77; + m_A79 += m_A46 * f17_26; + RHS26 += f17_26 * RHS17; +const double f18 = 1.0 / m_A47; + const double f18_26 = -f18 * m_A78; + m_A79 += m_A48 * f18_26; + m_A80 += m_A49 * f18_26; + RHS26 += f18_26 * RHS18; + const double f18_30 = -f18 * m_A106; + m_A108 += m_A48 * f18_30; + m_A110 += m_A49 * f18_30; + RHS30 += f18_30 * RHS18; +const double f19 = 1.0 / m_A50; + const double f19_27 = -f19 * m_A82; + m_A83 += m_A51 * f19_27; + m_A84 += m_A52 * f19_27; + m_A85 += m_A53 * f19_27; + RHS27 += f19_27 * RHS19; + const double f19_28 = -f19 * m_A88; + m_A92 += m_A51 * f19_28; + m_A93 += m_A52 * f19_28; + m_A94 += m_A53 * f19_28; + RHS28 += f19_28 * RHS19; + const double f19_29 = -f19 * m_A97; + m_A100 += m_A51 * f19_29; + m_A101 += m_A52 * f19_29; + m_A102 += m_A53 * f19_29; + RHS29 += f19_29 * RHS19; +const double f20 = 1.0 / m_A54; + const double f20_28 = -f20 * m_A89; + m_A93 += m_A55 * f20_28; + m_A94 += m_A56 * f20_28; + m_A95 += m_A57 * f20_28; + RHS28 += f20_28 * RHS20; + const double f20_29 = -f20 * m_A98; + m_A101 += m_A55 * f20_29; + m_A102 += m_A56 * f20_29; + m_A104 += m_A57 * f20_29; + RHS29 += f20_29 * RHS20; + const double f20_41 = -f20 * m_A167; + m_A168 += m_A55 * f20_41; + m_A169 += m_A56 * f20_41; + m_A174 += m_A57 * f20_41; + RHS41 += f20_41 * RHS20; +const double f21 = 1.0 / m_A58; + const double f21_29 = -f21 * m_A99; + m_A102 += m_A59 * f21_29; + m_A103 += m_A60 * f21_29; + RHS29 += f21_29 * RHS21; + const double f21_30 = -f21 * m_A107; + m_A109 += m_A59 * f21_30; + m_A110 += m_A60 * f21_30; + RHS30 += f21_30 * RHS21; +const double f22 = 1.0 / m_A61; + const double f22_32 = -f22 * m_A119; + m_A120 += m_A62 * f22_32; + m_A121 += m_A63 * f22_32; + RHS32 += f22_32 * RHS22; + const double f22_38 = -f22 * m_A144; + m_A146 += m_A62 * f22_38; + m_A149 += m_A63 * f22_38; + RHS38 += f22_38 * RHS22; +const double f23 = 1.0 / m_A64; + const double f23_35 = -f23 * m_A128; + m_A129 += m_A65 * f23_35; + m_A130 += m_A66 * f23_35; + RHS35 += f23_35 * RHS23; + const double f23_38 = -f23 * m_A145; + m_A147 += m_A65 * f23_38; + m_A149 += m_A66 * f23_38; + RHS38 += f23_38 * RHS23; +const double f24 = 1.0 / m_A69; + const double f24_25 = -f24 * m_A74; + m_A75 += m_A70 * f24_25; + m_A76 += m_A71 * f24_25; + RHS25 += f24_25 * RHS24; + const double f24_28 = -f24 * m_A90; + m_A91 += m_A70 * f24_28; + m_A93 += m_A71 * f24_28; + RHS28 += f24_28 * RHS24; +const double f25 = 1.0 / m_A75; + const double f25_28 = -f25 * m_A91; + m_A93 += m_A76 * f25_28; + RHS28 += f25_28 * RHS25; +const double f26 = 1.0 / m_A79; + const double f26_30 = -f26 * m_A108; + m_A110 += m_A80 * f26_30; + RHS30 += f26_30 * RHS26; +const double f27 = 1.0 / m_A83; + const double f27_28 = -f27 * m_A92; + m_A93 += m_A84 * f27_28; + m_A94 += m_A85 * f27_28; + m_A96 += m_A86 * f27_28; + RHS28 += f27_28 * RHS27; + const double f27_29 = -f27 * m_A100; + m_A101 += m_A84 * f27_29; + m_A102 += m_A85 * f27_29; + m_A105 += m_A86 * f27_29; + RHS29 += f27_29 * RHS27; + const double f27_43 = -f27 * m_A187; + m_A188 += m_A84 * f27_43; + m_A189 += m_A85 * f27_43; + m_A197 += m_A86 * f27_43; + RHS43 += f27_43 * RHS27; +const double f28 = 1.0 / m_A93; + const double f28_29 = -f28 * m_A101; + m_A102 += m_A94 * f28_29; + m_A104 += m_A95 * f28_29; + m_A105 += m_A96 * f28_29; + RHS29 += f28_29 * RHS28; + const double f28_41 = -f28 * m_A168; + m_A169 += m_A94 * f28_41; + m_A174 += m_A95 * f28_41; + m_A176 += m_A96 * f28_41; + RHS41 += f28_41 * RHS28; + const double f28_43 = -f28 * m_A188; + m_A189 += m_A94 * f28_43; + m_A195 += m_A95 * f28_43; + m_A197 += m_A96 * f28_43; + RHS43 += f28_43 * RHS28; +const double f29 = 1.0 / m_A102; + const double f29_30 = -f29 * m_A109; + m_A110 += m_A103 * f29_30; + m_A111 += m_A104 * f29_30; + m_A112 += m_A105 * f29_30; + RHS30 += f29_30 * RHS29; + const double f29_41 = -f29 * m_A169; + m_A170 += m_A103 * f29_41; + m_A174 += m_A104 * f29_41; + m_A176 += m_A105 * f29_41; + RHS41 += f29_41 * RHS29; + const double f29_43 = -f29 * m_A189; + m_A190 += m_A103 * f29_43; + m_A195 += m_A104 * f29_43; + m_A197 += m_A105 * f29_43; + RHS43 += f29_43 * RHS29; +const double f30 = 1.0 / m_A110; + const double f30_41 = -f30 * m_A170; + m_A174 += m_A111 * f30_41; + m_A176 += m_A112 * f30_41; + RHS41 += f30_41 * RHS30; + const double f30_43 = -f30 * m_A190; + m_A195 += m_A111 * f30_43; + m_A197 += m_A112 * f30_43; + RHS43 += f30_43 * RHS30; +const double f31 = 1.0 / m_A116; + const double f31_39 = -f31 * m_A155; + m_A157 += m_A117 * f31_39; + m_A160 += m_A118 * f31_39; + RHS39 += f31_39 * RHS31; + const double f31_43 = -f31 * m_A191; + m_A193 += m_A117 * f31_43; + m_A197 += m_A118 * f31_43; + RHS43 += f31_43 * RHS31; +const double f32 = 1.0 / m_A120; + const double f32_38 = -f32 * m_A146; + m_A149 += m_A121 * f32_38; + RHS38 += f32_38 * RHS32; +const double f33 = 1.0 / m_A123; + const double f33_40 = -f33 * m_A163; + m_A164 += m_A124 * f33_40; + RHS40 += f33_40 * RHS33; +const double f34 = 1.0 / m_A126; + const double f34_43 = -f34 * m_A192; + m_A194 += m_A127 * f34_43; + RHS43 += f34_43 * RHS34; +const double f35 = 1.0 / m_A129; + const double f35_38 = -f35 * m_A147; + m_A149 += m_A130 * f35_38; + RHS38 += f35_38 * RHS35; +const double f36 = 1.0 / m_A133; + const double f36_42 = -f36 * m_A178; + m_A179 += m_A134 * f36_42; + m_A182 += m_A135 * f36_42; + RHS42 += f36_42 * RHS36; +const double f37 = 1.0 / m_A139; + const double f37_38 = -f37 * m_A148; + m_A149 += m_A140 * f37_38; + m_A151 += m_A141 * f37_38; + RHS38 += f37_38 * RHS37; + const double f37_41 = -f37 * m_A171; + m_A172 += m_A140 * f37_41; + m_A174 += m_A141 * f37_41; + RHS41 += f37_41 * RHS37; +const double f38 = 1.0 / m_A149; + const double f38_39 = -f38 * m_A156; + m_A157 += m_A150 * f38_39; + m_A158 += m_A151 * f38_39; + m_A159 += m_A152 * f38_39; + RHS39 += f38_39 * RHS38; + const double f38_41 = -f38 * m_A172; + m_A173 += m_A150 * f38_41; + m_A174 += m_A151 * f38_41; + m_A175 += m_A152 * f38_41; + RHS41 += f38_41 * RHS38; + const double f38_42 = -f38 * m_A179; + m_A180 += m_A150 * f38_42; + m_A181 += m_A151 * f38_42; + m_A182 += m_A152 * f38_42; + RHS42 += f38_42 * RHS38; +const double f39 = 1.0 / m_A157; + const double f39_41 = -f39 * m_A173; + m_A174 += m_A158 * f39_41; + m_A175 += m_A159 * f39_41; + m_A176 += m_A160 * f39_41; + RHS41 += f39_41 * RHS39; + const double f39_42 = -f39 * m_A180; + m_A181 += m_A158 * f39_42; + m_A182 += m_A159 * f39_42; + m_A183 += m_A160 * f39_42; + RHS42 += f39_42 * RHS39; + const double f39_43 = -f39 * m_A193; + m_A195 += m_A158 * f39_43; + m_A196 += m_A159 * f39_43; + m_A197 += m_A160 * f39_43; + RHS43 += f39_43 * RHS39; +const double f40 = 1.0 / m_A164; + const double f40_43 = -f40 * m_A194; + m_A197 += m_A165 * f40_43; + RHS43 += f40_43 * RHS40; +const double f41 = 1.0 / m_A174; + const double f41_42 = -f41 * m_A181; + m_A182 += m_A175 * f41_42; + m_A183 += m_A176 * f41_42; + RHS42 += f41_42 * RHS41; + const double f41_43 = -f41 * m_A195; + m_A196 += m_A175 * f41_43; + m_A197 += m_A176 * f41_43; + RHS43 += f41_43 * RHS41; +const double f42 = 1.0 / m_A182; + const double f42_43 = -f42 * m_A196; + m_A197 += m_A183 * f42_43; + RHS43 += f42_43 * RHS42; + V[43] = RHS43 / m_A197; + double tmp42 = 0.0; + tmp42 += m_A183 * V[43]; + V[42] = (RHS42 - tmp42) / m_A182; + double tmp41 = 0.0; + tmp41 += m_A175 * V[42]; + tmp41 += m_A176 * V[43]; + V[41] = (RHS41 - tmp41) / m_A174; + double tmp40 = 0.0; + tmp40 += m_A165 * V[43]; + V[40] = (RHS40 - tmp40) / m_A164; + double tmp39 = 0.0; + tmp39 += m_A158 * V[41]; + tmp39 += m_A159 * V[42]; + tmp39 += m_A160 * V[43]; + V[39] = (RHS39 - tmp39) / m_A157; + double tmp38 = 0.0; + tmp38 += m_A150 * V[39]; + tmp38 += m_A151 * V[41]; + tmp38 += m_A152 * V[42]; + V[38] = (RHS38 - tmp38) / m_A149; + double tmp37 = 0.0; + tmp37 += m_A140 * V[38]; + tmp37 += m_A141 * V[41]; + V[37] = (RHS37 - tmp37) / m_A139; + double tmp36 = 0.0; + tmp36 += m_A134 * V[38]; + tmp36 += m_A135 * V[42]; + V[36] = (RHS36 - tmp36) / m_A133; + double tmp35 = 0.0; + tmp35 += m_A130 * V[38]; + V[35] = (RHS35 - tmp35) / m_A129; + double tmp34 = 0.0; + tmp34 += m_A127 * V[40]; + V[34] = (RHS34 - tmp34) / m_A126; + double tmp33 = 0.0; + tmp33 += m_A124 * V[40]; + V[33] = (RHS33 - tmp33) / m_A123; + double tmp32 = 0.0; + tmp32 += m_A121 * V[38]; + V[32] = (RHS32 - tmp32) / m_A120; + double tmp31 = 0.0; + tmp31 += m_A117 * V[39]; + tmp31 += m_A118 * V[43]; + V[31] = (RHS31 - tmp31) / m_A116; + double tmp30 = 0.0; + tmp30 += m_A111 * V[41]; + tmp30 += m_A112 * V[43]; + V[30] = (RHS30 - tmp30) / m_A110; + double tmp29 = 0.0; + tmp29 += m_A103 * V[30]; + tmp29 += m_A104 * V[41]; + tmp29 += m_A105 * V[43]; + V[29] = (RHS29 - tmp29) / m_A102; + double tmp28 = 0.0; + tmp28 += m_A94 * V[29]; + tmp28 += m_A95 * V[41]; + tmp28 += m_A96 * V[43]; + V[28] = (RHS28 - tmp28) / m_A93; + double tmp27 = 0.0; + tmp27 += m_A84 * V[28]; + tmp27 += m_A85 * V[29]; + tmp27 += m_A86 * V[43]; + V[27] = (RHS27 - tmp27) / m_A83; + double tmp26 = 0.0; + tmp26 += m_A80 * V[30]; + V[26] = (RHS26 - tmp26) / m_A79; + double tmp25 = 0.0; + tmp25 += m_A76 * V[28]; + V[25] = (RHS25 - tmp25) / m_A75; + double tmp24 = 0.0; + tmp24 += m_A70 * V[25]; + tmp24 += m_A71 * V[28]; + V[24] = (RHS24 - tmp24) / m_A69; + double tmp23 = 0.0; + tmp23 += m_A65 * V[35]; + tmp23 += m_A66 * V[38]; + V[23] = (RHS23 - tmp23) / m_A64; + double tmp22 = 0.0; + tmp22 += m_A62 * V[32]; + tmp22 += m_A63 * V[38]; + V[22] = (RHS22 - tmp22) / m_A61; + double tmp21 = 0.0; + tmp21 += m_A59 * V[29]; + tmp21 += m_A60 * V[30]; + V[21] = (RHS21 - tmp21) / m_A58; + double tmp20 = 0.0; + tmp20 += m_A55 * V[28]; + tmp20 += m_A56 * V[29]; + tmp20 += m_A57 * V[41]; + V[20] = (RHS20 - tmp20) / m_A54; + double tmp19 = 0.0; + tmp19 += m_A51 * V[27]; + tmp19 += m_A52 * V[28]; + tmp19 += m_A53 * V[29]; + V[19] = (RHS19 - tmp19) / m_A50; + double tmp18 = 0.0; + tmp18 += m_A48 * V[26]; + tmp18 += m_A49 * V[30]; + V[18] = (RHS18 - tmp18) / m_A47; + double tmp17 = 0.0; + tmp17 += m_A46 * V[26]; + V[17] = (RHS17 - tmp17) / m_A45; + double tmp16 = 0.0; + tmp16 += m_A44 * V[25]; + V[16] = (RHS16 - tmp16) / m_A43; + double tmp15 = 0.0; + tmp15 += m_A41 * V[24]; + tmp15 += m_A42 * V[25]; + V[15] = (RHS15 - tmp15) / m_A40; + double tmp14 = 0.0; + tmp14 += m_A38 * V[24]; + tmp14 += m_A39 * V[28]; + V[14] = (RHS14 - tmp14) / m_A37; + double tmp13 = 0.0; + tmp13 += m_A35 * V[37]; + tmp13 += m_A36 * V[41]; + V[13] = (RHS13 - tmp13) / m_A34; + double tmp12 = 0.0; + tmp12 += m_A32 * V[38]; + tmp12 += m_A33 * V[39]; + V[12] = (RHS12 - tmp12) / m_A31; + double tmp11 = 0.0; + tmp11 += m_A29 * V[31]; + tmp11 += m_A30 * V[39]; + V[11] = (RHS11 - tmp11) / m_A28; + double tmp10 = 0.0; + tmp10 += m_A27 * V[31]; + V[10] = (RHS10 - tmp10) / m_A26; + double tmp9 = 0.0; + tmp9 += m_A24 * V[31]; + tmp9 += m_A25 * V[43]; + V[9] = (RHS9 - tmp9) / m_A23; + double tmp8 = 0.0; + tmp8 += m_A21 * V[27]; + tmp8 += m_A22 * V[43]; + V[8] = (RHS8 - tmp8) / m_A20; + double tmp7 = 0.0; + tmp7 += m_A18 * V[38]; + tmp7 += m_A19 * V[42]; + V[7] = (RHS7 - tmp7) / m_A17; + double tmp6 = 0.0; + tmp6 += m_A16 * V[36]; + V[6] = (RHS6 - tmp6) / m_A15; + double tmp5 = 0.0; + tmp5 += m_A14 * V[42]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[37]; + tmp4 += m_A12 * V[38]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A8 * V[13]; + tmp3 += m_A9 * V[37]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A5 * V[40]; + tmp2 += m_A6 * V[43]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[40]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[33]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_18deaad4b2fab70d_26(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[10] + gt[11] + gt[12]; + m_A3 = m_A3 + go[10]; + double RHS1 = Idr[10] + Idr[11] + Idr[12] - go[11] * *cnV[11] - go[12] * *cnV[12]; + m_A4 = gt[20] + gt[21] + gt[22] + gt[23] + gt[24]; + m_A6 = m_A6 + go[20]; + m_A6 = m_A6 + go[21]; + m_A5 = m_A5 + go[22]; + double RHS2 = Idr[20] + Idr[21] + Idr[22] + Idr[23] + Idr[24] - go[23] * *cnV[23] - go[24] * *cnV[24]; + m_A8 = gt[30] + gt[31] + gt[32] + gt[33] + gt[34] + gt[35] + gt[36]; + m_A7 = m_A7 + go[30]; + m_A9 = m_A9 + go[31]; + m_A8 = m_A8 + go[32]; + m_A8 = m_A8 + go[33]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] - go[34] * *cnV[34] - go[35] * *cnV[35] - go[36] * *cnV[36]; + m_A11 = gt[40] + gt[41]; + m_A12 = m_A12 + go[40]; + m_A10 = m_A10 + go[41]; + double RHS4 = Idr[40] + Idr[41]; + m_A14 = gt[50] + gt[51] + gt[52] + gt[53] + gt[54] + gt[55] + gt[56]; + m_A15 = m_A15 + go[50]; + m_A15 = m_A15 + go[51]; + m_A16 = m_A16 + go[52]; + m_A13 = m_A13 + go[53]; + double RHS5 = Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] + Idr[55] + Idr[56] - go[54] * *cnV[54] - go[55] * *cnV[55] - go[56] * *cnV[56]; + m_A19 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64] + gt[65] + gt[66] + gt[67] + gt[68] + gt[69]; + m_A20 = m_A20 + go[60]; + m_A20 = m_A20 + go[61]; + m_A18 = m_A18 + go[62]; + m_A18 = m_A18 + go[63]; + m_A17 = m_A17 + go[64]; + m_A17 = m_A17 + go[65]; + double RHS6 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] + Idr[65] + Idr[66] + Idr[67] + Idr[68] + Idr[69] - go[66] * *cnV[66] - go[67] * *cnV[67] - go[68] * *cnV[68] - go[69] * *cnV[69]; + m_A25 = gt[70] + gt[71] + gt[72] + gt[73] + gt[74] + gt[75] + gt[76]; + m_A24 = m_A24 + go[70]; + m_A24 = m_A24 + go[71]; + m_A22 = m_A22 + go[72]; + m_A23 = m_A23 + go[73]; + m_A21 = m_A21 + go[74]; + double RHS7 = Idr[70] + Idr[71] + Idr[72] + Idr[73] + Idr[74] + Idr[75] + Idr[76] - go[75] * *cnV[75] - go[76] * *cnV[76]; +const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A7; + m_A8 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A10; + m_A11 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_5 = -f2 * m_A13; + m_A14 += m_A5 * f2_5; + m_A15 += m_A6 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A17; + m_A18 += m_A5 * f2_6; + m_A19 += m_A6 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A8; + const double f3_7 = -f3 * m_A21; + m_A25 += m_A9 * f3_7; + RHS7 += f3_7 * RHS3; +const double f4 = 1.0 / m_A11; + const double f4_7 = -f4 * m_A22; + m_A25 += m_A12 * f4_7; + RHS7 += f4_7 * RHS4; +const double f5 = 1.0 / m_A14; + const double f5_6 = -f5 * m_A18; + m_A19 += m_A15 * f5_6; + m_A20 += m_A16 * f5_6; + RHS6 += f5_6 * RHS5; + const double f5_7 = -f5 * m_A23; + m_A24 += m_A15 * f5_7; + m_A25 += m_A16 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A19; + const double f6_7 = -f6 * m_A24; + m_A25 += m_A20 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A25; + double tmp6 = 0.0; + tmp6 += m_A20 * V[7]; + V[6] = (RHS6 - tmp6) / m_A19; + double tmp5 = 0.0; + tmp5 += m_A15 * V[6]; + tmp5 += m_A16 * V[7]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A12 * V[7]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A9 * V[7]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A5 * V[5]; + tmp2 += m_A6 * V[6]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_19f6e9708f37ad65_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A6 = gt[8] + gt[9] + gt[10] + gt[11]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] + Idr[11] - go[10] * *cnV[10] - go[11] * *cnV[11]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_1e27a9bddeac729d_64(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3] + gt[4]; + m_A1 = m_A1 + go[0]; + m_A2 = m_A2 + go[1]; + m_A2 = m_A2 + go[2]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] + Idr[4] - go[3] * *cnV[3] - go[4] * *cnV[4]; + m_A3 = gt[10] + gt[11] + gt[12] + gt[13] + gt[14] + gt[15] + gt[16]; + m_A4 = m_A4 + go[10]; + m_A3 = m_A3 + go[11]; + m_A3 = m_A3 + go[12]; + double RHS1 = Idr[10] + Idr[11] + Idr[12] + Idr[13] + Idr[14] + Idr[15] + Idr[16] - go[13] * *cnV[13] - go[14] * *cnV[14] - go[15] * *cnV[15] - go[16] * *cnV[16]; + m_A5 = gt[20] + gt[21]; + m_A6 = m_A6 + go[20]; + double RHS2 = Idr[20] + Idr[21] - go[21] * *cnV[21]; + m_A7 = gt[30] + gt[31] + gt[32] + gt[33]; + m_A8 = m_A8 + go[30]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] - go[31] * *cnV[31] - go[32] * *cnV[32] - go[33] * *cnV[33]; + m_A9 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44]; + m_A10 = m_A10 + go[40]; + m_A11 = m_A11 + go[41]; + m_A11 = m_A11 + go[42]; + double RHS4 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] - go[43] * *cnV[43] - go[44] * *cnV[44]; + m_A12 = gt[50] + gt[51]; + m_A13 = m_A13 + go[50]; + m_A14 = m_A14 + go[51]; + double RHS5 = Idr[50] + Idr[51]; + m_A15 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64] + gt[65]; + m_A17 = m_A17 + go[60]; + m_A18 = m_A18 + go[61]; + m_A16 = m_A16 + go[62]; + m_A19 = m_A19 + go[63]; + double RHS6 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] + Idr[65] - go[64] * *cnV[64] - go[65] * *cnV[65]; + m_A22 = gt[70] + gt[71] + gt[72] + gt[73] + gt[74] + gt[75] + gt[76]; + m_A20 = m_A20 + go[70]; + m_A21 = m_A21 + go[71]; + m_A22 = m_A22 + go[72]; + m_A22 = m_A22 + go[73]; + double RHS7 = Idr[70] + Idr[71] + Idr[72] + Idr[73] + Idr[74] + Idr[75] + Idr[76] - go[74] * *cnV[74] - go[75] * *cnV[75] - go[76] * *cnV[76]; + m_A27 = gt[80] + gt[81] + gt[82] + gt[83] + gt[84] + gt[85] + gt[86]; + m_A28 = m_A28 + go[80]; + m_A29 = m_A29 + go[81]; + m_A29 = m_A29 + go[82]; + m_A26 = m_A26 + go[83]; + double RHS8 = Idr[80] + Idr[81] + Idr[82] + Idr[83] + Idr[84] + Idr[85] + Idr[86] - go[84] * *cnV[84] - go[85] * *cnV[85] - go[86] * *cnV[86]; + m_A33 = gt[90] + gt[91] + gt[92] + gt[93]; + m_A31 = m_A31 + go[90]; + m_A30 = m_A30 + go[91]; + m_A35 = m_A35 + go[92]; + double RHS9 = Idr[90] + Idr[91] + Idr[92] + Idr[93] - go[93] * *cnV[93]; + m_A41 = gt[100] + gt[101] + gt[102] + gt[103] + gt[104] + gt[105] + gt[106]; + m_A38 = m_A38 + go[100]; + m_A42 = m_A42 + go[101]; + m_A42 = m_A42 + go[102]; + m_A37 = m_A37 + go[103]; + double RHS10 = Idr[100] + Idr[101] + Idr[102] + Idr[103] + Idr[104] + Idr[105] + Idr[106] - go[104] * *cnV[104] - go[105] * *cnV[105] - go[106] * *cnV[106]; + m_A49 = gt[110] + gt[111] + gt[112] + gt[113] + gt[114] + gt[115] + gt[116] + gt[117] + gt[118] + gt[119]; + m_A45 = m_A45 + go[110]; + m_A47 = m_A47 + go[111]; + m_A48 = m_A48 + go[112]; + m_A48 = m_A48 + go[113]; + m_A44 = m_A44 + go[114]; + m_A44 = m_A44 + go[115]; + double RHS11 = Idr[110] + Idr[111] + Idr[112] + Idr[113] + Idr[114] + Idr[115] + Idr[116] + Idr[117] + Idr[118] + Idr[119] - go[116] * *cnV[116] - go[117] * *cnV[117] - go[118] * *cnV[118] - go[119] * *cnV[119]; + m_A54 = gt[120] + gt[121] + gt[122] + gt[123] + gt[124] + gt[125]; + m_A52 = m_A52 + go[120]; + m_A53 = m_A53 + go[121]; + m_A51 = m_A51 + go[122]; + m_A55 = m_A55 + go[123]; + double RHS12 = Idr[120] + Idr[121] + Idr[122] + Idr[123] + Idr[124] + Idr[125] - go[124] * *cnV[124] - go[125] * *cnV[125]; + m_A63 = gt[130] + gt[131] + gt[132] + gt[133] + gt[134] + gt[135] + gt[136] + gt[137] + gt[138]; + m_A57 = m_A57 + go[130]; + m_A58 = m_A58 + go[131]; + m_A58 = m_A58 + go[132]; + m_A62 = m_A62 + go[133]; + m_A56 = m_A56 + go[134]; + m_A56 = m_A56 + go[135]; + double RHS13 = Idr[130] + Idr[131] + Idr[132] + Idr[133] + Idr[134] + Idr[135] + Idr[136] + Idr[137] + Idr[138] - go[136] * *cnV[136] - go[137] * *cnV[137] - go[138] * *cnV[138]; +const double f0 = 1.0 / m_A0; + const double f0_8 = -f0 * m_A26; + m_A27 += m_A1 * f0_8; + m_A29 += m_A2 * f0_8; + RHS8 += f0_8 * RHS0; + const double f0_13 = -f0 * m_A56; + m_A58 += m_A1 * f0_13; + m_A63 += m_A2 * f0_13; + RHS13 += f0_13 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_12 = -f1 * m_A51; + m_A54 += m_A4 * f1_12; + RHS12 += f1_12 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_12 = -f2 * m_A52; + m_A54 += m_A6 * f2_12; + RHS12 += f2_12 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_7 = -f3 * m_A20; + m_A22 += m_A8 * f3_7; + RHS7 += f3_7 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_10 = -f4 * m_A37; + m_A41 += m_A10 * f4_10; + m_A42 += m_A11 * f4_10; + RHS10 += f4_10 * RHS4; + const double f4_11 = -f4 * m_A44; + m_A48 += m_A10 * f4_11; + m_A49 += m_A11 * f4_11; + RHS11 += f4_11 * RHS4; +const double f5 = 1.0 / m_A12; + const double f5_9 = -f5 * m_A30; + m_A33 += m_A13 * f5_9; + m_A36 += m_A14 * f5_9; + RHS9 += f5_9 * RHS5; + const double f5_13 = -f5 * m_A57; + m_A59 += m_A13 * f5_13; + m_A63 += m_A14 * f5_13; + RHS13 += f5_13 * RHS5; +const double f6 = 1.0 / m_A15; + const double f6_7 = -f6 * m_A21; + m_A22 += m_A16 * f6_7; + m_A23 += m_A17 * f6_7; + m_A24 += m_A18 * f6_7; + m_A25 += m_A19 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_9 = -f6 * m_A31; + m_A32 += m_A16 * f6_9; + m_A33 += m_A17 * f6_9; + m_A34 += m_A18 * f6_9; + m_A35 += m_A19 * f6_9; + RHS9 += f6_9 * RHS6; + const double f6_10 = -f6 * m_A38; + m_A39 += m_A16 * f6_10; + m_A40 += m_A17 * f6_10; + m_A41 += m_A18 * f6_10; + m_A42 += m_A19 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_11 = -f6 * m_A45; + m_A46 += m_A16 * f6_11; + m_A47 += m_A17 * f6_11; + m_A48 += m_A18 * f6_11; + m_A49 += m_A19 * f6_11; + RHS11 += f6_11 * RHS6; +const double f7 = 1.0 / m_A22; + const double f7_9 = -f7 * m_A32; + m_A33 += m_A23 * f7_9; + m_A34 += m_A24 * f7_9; + m_A35 += m_A25 * f7_9; + RHS9 += f7_9 * RHS7; + const double f7_10 = -f7 * m_A39; + m_A40 += m_A23 * f7_10; + m_A41 += m_A24 * f7_10; + m_A42 += m_A25 * f7_10; + RHS10 += f7_10 * RHS7; + const double f7_11 = -f7 * m_A46; + m_A47 += m_A23 * f7_11; + m_A48 += m_A24 * f7_11; + m_A49 += m_A25 * f7_11; + RHS11 += f7_11 * RHS7; +const double f8 = 1.0 / m_A27; + const double f8_12 = -f8 * m_A53; + m_A54 += m_A28 * f8_12; + m_A55 += m_A29 * f8_12; + RHS12 += f8_12 * RHS8; + const double f8_13 = -f8 * m_A58; + m_A62 += m_A28 * f8_13; + m_A63 += m_A29 * f8_13; + RHS13 += f8_13 * RHS8; +const double f9 = 1.0 / m_A33; + const double f9_10 = -f9 * m_A40; + m_A41 += m_A34 * f9_10; + m_A42 += m_A35 * f9_10; + m_A43 += m_A36 * f9_10; + RHS10 += f9_10 * RHS9; + const double f9_11 = -f9 * m_A47; + m_A48 += m_A34 * f9_11; + m_A49 += m_A35 * f9_11; + m_A50 += m_A36 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_13 = -f9 * m_A59; + m_A60 += m_A34 * f9_13; + m_A61 += m_A35 * f9_13; + m_A63 += m_A36 * f9_13; + RHS13 += f9_13 * RHS9; +const double f10 = 1.0 / m_A41; + const double f10_11 = -f10 * m_A48; + m_A49 += m_A42 * f10_11; + m_A50 += m_A43 * f10_11; + RHS11 += f10_11 * RHS10; + const double f10_13 = -f10 * m_A60; + m_A61 += m_A42 * f10_13; + m_A63 += m_A43 * f10_13; + RHS13 += f10_13 * RHS10; +const double f11 = 1.0 / m_A49; + const double f11_13 = -f11 * m_A61; + m_A63 += m_A50 * f11_13; + RHS13 += f11_13 * RHS11; +const double f12 = 1.0 / m_A54; + const double f12_13 = -f12 * m_A62; + m_A63 += m_A55 * f12_13; + RHS13 += f12_13 * RHS12; + V[13] = RHS13 / m_A63; + double tmp12 = 0.0; + tmp12 += m_A55 * V[13]; + V[12] = (RHS12 - tmp12) / m_A54; + double tmp11 = 0.0; + tmp11 += m_A50 * V[13]; + V[11] = (RHS11 - tmp11) / m_A49; + double tmp10 = 0.0; + tmp10 += m_A42 * V[11]; + tmp10 += m_A43 * V[13]; + V[10] = (RHS10 - tmp10) / m_A41; + double tmp9 = 0.0; + tmp9 += m_A34 * V[10]; + tmp9 += m_A35 * V[11]; + tmp9 += m_A36 * V[13]; + V[9] = (RHS9 - tmp9) / m_A33; + double tmp8 = 0.0; + tmp8 += m_A28 * V[12]; + tmp8 += m_A29 * V[13]; + V[8] = (RHS8 - tmp8) / m_A27; + double tmp7 = 0.0; + tmp7 += m_A23 * V[9]; + tmp7 += m_A24 * V[10]; + tmp7 += m_A25 * V[11]; + V[7] = (RHS7 - tmp7) / m_A22; + double tmp6 = 0.0; + tmp6 += m_A16 * V[7]; + tmp6 += m_A17 * V[9]; + tmp6 += m_A18 * V[10]; + tmp6 += m_A19 * V[11]; + V[6] = (RHS6 - tmp6) / m_A15; + double tmp5 = 0.0; + tmp5 += m_A13 * V[9]; + tmp5 += m_A14 * V[13]; + V[5] = (RHS5 - tmp5) / m_A12; + double tmp4 = 0.0; + tmp4 += m_A10 * V[10]; + tmp4 += m_A11 * V[11]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A8 * V[7]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A6 * V[12]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A4 * V[12]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[8]; + tmp0 += m_A2 * V[13]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_1faccd91c85d3ab3_28(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[10] + gt[11] + gt[12] + gt[13]; + m_A4 = m_A4 + go[10]; + m_A4 = m_A4 + go[11]; + m_A3 = m_A3 + go[12]; + double RHS1 = Idr[10] + Idr[11] + Idr[12] + Idr[13] - go[13] * *cnV[13]; + m_A5 = gt[20] + gt[21] + gt[22]; + m_A6 = m_A6 + go[20]; + double RHS2 = Idr[20] + Idr[21] + Idr[22] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A7 = gt[30] + gt[31] + gt[32] + gt[33] + gt[34] + gt[35] + gt[36]; + m_A8 = m_A8 + go[30]; + m_A8 = m_A8 + go[31]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] - go[32] * *cnV[32] - go[33] * *cnV[33] - go[34] * *cnV[34] - go[35] * *cnV[35] - go[36] * *cnV[36]; + m_A11 = gt[40] + gt[41] + gt[42]; + m_A13 = m_A13 + go[40]; + m_A10 = m_A10 + go[41]; + m_A9 = m_A9 + go[42]; + double RHS4 = Idr[40] + Idr[41] + Idr[42]; + m_A16 = gt[50] + gt[51] + gt[52] + gt[53] + gt[54] + gt[55] + gt[56]; + m_A18 = m_A18 + go[50]; + m_A14 = m_A14 + go[51]; + m_A14 = m_A14 + go[52]; + double RHS5 = Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] + Idr[55] + Idr[56] - go[53] * *cnV[53] - go[54] * *cnV[54] - go[55] * *cnV[55] - go[56] * *cnV[56]; + m_A22 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64] + gt[65] + gt[66] + gt[67] + gt[68] + gt[69]; + m_A23 = m_A23 + go[60]; + m_A23 = m_A23 + go[61]; + m_A20 = m_A20 + go[62]; + m_A19 = m_A19 + go[63]; + m_A19 = m_A19 + go[64]; + double RHS6 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] + Idr[65] + Idr[66] + Idr[67] + Idr[68] + Idr[69] - go[65] * *cnV[65] - go[66] * *cnV[66] - go[67] * *cnV[67] - go[68] * *cnV[68] - go[69] * *cnV[69]; + m_A27 = gt[70] + gt[71] + gt[72] + gt[73] + gt[74]; + m_A26 = m_A26 + go[70]; + m_A26 = m_A26 + go[71]; + m_A25 = m_A25 + go[72]; + m_A24 = m_A24 + go[73]; + double RHS7 = Idr[70] + Idr[71] + Idr[72] + Idr[73] + Idr[74] - go[74] * *cnV[74]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A9; + m_A11 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A10; + m_A11 += m_A3 * f1_4; + m_A12 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A14; + m_A15 += m_A3 * f1_5; + m_A16 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_7 = -f2 * m_A24; + m_A27 += m_A6 * f2_7; + RHS7 += f2_7 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_6 = -f3 * m_A19; + m_A22 += m_A8 * f3_6; + RHS6 += f3_6 * RHS3; +const double f4 = 1.0 / m_A11; + const double f4_5 = -f4 * m_A15; + m_A16 += m_A12 * f4_5; + m_A17 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + const double f4_6 = -f4 * m_A20; + m_A21 += m_A12 * f4_6; + m_A22 += m_A13 * f4_6; + RHS6 += f4_6 * RHS4; +const double f5 = 1.0 / m_A16; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A17 * f5_6; + m_A23 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + const double f5_7 = -f5 * m_A25; + m_A26 += m_A17 * f5_7; + m_A27 += m_A18 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A22; + const double f6_7 = -f6 * m_A26; + m_A27 += m_A23 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A27; + double tmp6 = 0.0; + tmp6 += m_A23 * V[7]; + V[6] = (RHS6 - tmp6) / m_A22; + double tmp5 = 0.0; + tmp5 += m_A17 * V[6]; + tmp5 += m_A18 * V[7]; + V[5] = (RHS5 - tmp5) / m_A16; + double tmp4 = 0.0; + tmp4 += m_A12 * V[5]; + tmp4 += m_A13 * V[6]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A8 * V[6]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A6 * V[7]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + tmp1 += m_A4 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_1fffb23aa506432d_13(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A4 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A6 = gt[12] + gt[13] + gt[14]; + m_A7 = m_A7 + go[12]; + double RHS3 = Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A12 = gt[16] + gt[17] + gt[18] + gt[19]; + m_A11 = m_A11 + go[16]; + m_A10 = m_A10 + go[17]; + m_A9 = m_A9 + go[18]; + m_A8 = m_A8 + go[19]; + double RHS4 = Idr[16] + Idr[17] + Idr[18] + Idr[19]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A8; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A9; + m_A12 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A10; + m_A12 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_4 = -f3 * m_A11; + m_A12 += m_A7 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A12; + double tmp3 = 0.0; + tmp3 += m_A7 * V[4]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_20615d28f46254cb_10(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A4 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A9 = gt[12] + gt[13] + gt[14]; + m_A8 = m_A8 + go[12]; + m_A7 = m_A7 + go[13]; + m_A6 = m_A6 + go[14]; + double RHS3 = Idr[12] + Idr[13] + Idr[14]; +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; +} + +static void nl_gcr_27a78682a9b70f8c_10(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A4 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A9 = gt[12] + gt[13] + gt[14] + gt[15]; + m_A8 = m_A8 + go[12]; + m_A7 = m_A7 + go[13]; + m_A6 = m_A6 + go[14]; + double RHS3 = Idr[12] + Idr[13] + Idr[14] + Idr[15] - go[15] * *cnV[15]; +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; +} + +static void nl_gcr_35947d349693c22_111(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); +double m_A90(0.0); +double m_A91(0.0); +double m_A92(0.0); +double m_A93(0.0); +double m_A94(0.0); +double m_A95(0.0); +double m_A96(0.0); +double m_A97(0.0); +double m_A98(0.0); +double m_A99(0.0); +double m_A100(0.0); +double m_A101(0.0); +double m_A102(0.0); +double m_A103(0.0); +double m_A104(0.0); +double m_A105(0.0); +double m_A106(0.0); +double m_A107(0.0); +double m_A108(0.0); +double m_A109(0.0); +double m_A110(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25] + gt[26]; + m_A8 = m_A8 + go[24]; + m_A7 = m_A7 + go[25]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[26] * *cnV[26]; + m_A9 = gt[32] + gt[33] + gt[34]; + m_A12 = m_A12 + go[32]; + m_A10 = m_A10 + go[33]; + m_A11 = m_A11 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34]; + m_A13 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A15 = m_A15 + go[40]; + m_A14 = m_A14 + go[41]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[42] * *cnV[42] - go[43] * *cnV[43] - go[44] * *cnV[44] - go[45] * *cnV[45] - go[46] * *cnV[46]; + m_A16 = gt[48] + gt[49]; + m_A17 = m_A17 + go[48]; + m_A18 = m_A18 + go[49]; + double RHS6 = Idr[48] + Idr[49]; + m_A19 = gt[56] + gt[57]; + m_A20 = m_A20 + go[56]; + m_A21 = m_A21 + go[57]; + double RHS7 = Idr[56] + Idr[57]; + m_A22 = gt[64] + gt[65]; + m_A23 = m_A23 + go[64]; + m_A24 = m_A24 + go[65]; + double RHS8 = Idr[64] + Idr[65]; + m_A25 = gt[72] + gt[73]; + m_A26 = m_A26 + go[72]; + m_A27 = m_A27 + go[73]; + double RHS9 = Idr[72] + Idr[73]; + m_A28 = gt[80] + gt[81]; + m_A29 = m_A29 + go[80]; + double RHS10 = Idr[80] + Idr[81] - go[81] * *cnV[81]; + m_A30 = gt[88] + gt[89] + gt[90] + gt[91]; + m_A31 = m_A31 + go[88]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91] - go[89] * *cnV[89] - go[90] * *cnV[90] - go[91] * *cnV[91]; + m_A34 = gt[96] + gt[97] + gt[98]; + m_A33 = m_A33 + go[96]; + m_A32 = m_A32 + go[97]; + double RHS12 = Idr[96] + Idr[97] + Idr[98] - go[98] * *cnV[98]; + m_A37 = gt[104] + gt[105] + gt[106] + gt[107] + gt[108] + gt[109] + gt[110]; + m_A38 = m_A38 + go[104]; + m_A36 = m_A36 + go[105]; + double RHS13 = Idr[104] + Idr[105] + Idr[106] + Idr[107] + Idr[108] + Idr[109] + Idr[110] - go[106] * *cnV[106] - go[107] * *cnV[107] - go[108] * *cnV[108] - go[109] * *cnV[109] - go[110] * *cnV[110]; + m_A40 = gt[112] + gt[113] + gt[114] + gt[115] + gt[116] + gt[117] + gt[118]; + m_A41 = m_A41 + go[112]; + m_A39 = m_A39 + go[113]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] + Idr[115] + Idr[116] + Idr[117] + Idr[118] - go[114] * *cnV[114] - go[115] * *cnV[115] - go[116] * *cnV[116] - go[117] * *cnV[117] - go[118] * *cnV[118]; + m_A44 = gt[120] + gt[121] + gt[122] + gt[123]; + m_A45 = m_A45 + go[120]; + m_A43 = m_A43 + go[121]; + m_A42 = m_A42 + go[122]; + double RHS15 = Idr[120] + Idr[121] + Idr[122] + Idr[123] - go[123] * *cnV[123]; + m_A48 = gt[128] + gt[129] + gt[130] + gt[131] + gt[132] + gt[133] + gt[134]; + m_A49 = m_A49 + go[128]; + m_A46 = m_A46 + go[129]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131] + Idr[132] + Idr[133] + Idr[134] - go[130] * *cnV[130] - go[131] * *cnV[131] - go[132] * *cnV[132] - go[133] * *cnV[133] - go[134] * *cnV[134]; + m_A51 = gt[136] + gt[137] + gt[138]; + m_A53 = m_A53 + go[136]; + m_A50 = m_A50 + go[137]; + double RHS17 = Idr[136] + Idr[137] + Idr[138] - go[138] * *cnV[138]; + m_A58 = gt[144] + gt[145] + gt[146] + gt[147] + gt[148] + gt[149]; + m_A57 = m_A57 + go[144]; + m_A62 = m_A62 + go[145]; + m_A62 = m_A62 + go[146]; + m_A56 = m_A56 + go[147]; + m_A55 = m_A55 + go[148]; + m_A54 = m_A54 + go[149]; + double RHS18 = Idr[144] + Idr[145] + Idr[146] + Idr[147] + Idr[148] + Idr[149]; + m_A67 = gt[152] + gt[153] + gt[154] + gt[155] + gt[156]; + m_A65 = m_A65 + go[152]; + m_A64 = m_A64 + go[153]; + m_A63 = m_A63 + go[154]; + double RHS19 = Idr[152] + Idr[153] + Idr[154] + Idr[155] + Idr[156] - go[155] * *cnV[155] - go[156] * *cnV[156]; + m_A76 = gt[160] + gt[161] + gt[162] + gt[163] + gt[164]; + m_A73 = m_A73 + go[160]; + m_A72 = m_A72 + go[161]; + m_A71 = m_A71 + go[162]; + double RHS20 = Idr[160] + Idr[161] + Idr[162] + Idr[163] + Idr[164] - go[163] * *cnV[163] - go[164] * *cnV[164]; + m_A84 = gt[168] + gt[169] + gt[170] + gt[171] + gt[172] + gt[173]; + m_A82 = m_A82 + go[168]; + m_A80 = m_A80 + go[169]; + m_A79 = m_A79 + go[170]; + m_A81 = m_A81 + go[171]; + double RHS21 = Idr[168] + Idr[169] + Idr[170] + Idr[171] + Idr[172] + Idr[173] - go[172] * *cnV[172] - go[173] * *cnV[173]; + m_A94 = gt[176] + gt[177] + gt[178] + gt[179] + gt[180] + gt[181]; + m_A87 = m_A87 + go[176]; + m_A88 = m_A88 + go[177]; + m_A89 = m_A89 + go[178]; + m_A86 = m_A86 + go[179]; + double RHS22 = Idr[176] + Idr[177] + Idr[178] + Idr[179] + Idr[180] + Idr[181] - go[180] * *cnV[180] - go[181] * *cnV[181]; + m_A101 = gt[184] + gt[185] + gt[186] + gt[187] + gt[188] + gt[189] + gt[190]; + m_A96 = m_A96 + go[184]; + m_A97 = m_A97 + go[185]; + double RHS23 = Idr[184] + Idr[185] + Idr[186] + Idr[187] + Idr[188] + Idr[189] + Idr[190] - go[186] * *cnV[186] - go[187] * *cnV[187] - go[188] * *cnV[188] - go[189] * *cnV[189] - go[190] * *cnV[190]; + m_A110 = gt[192] + gt[193] + gt[194] + gt[195] + gt[196] + gt[197]; + m_A109 = m_A109 + go[192]; + m_A103 = m_A103 + go[193]; + m_A105 = m_A105 + go[194]; + m_A105 = m_A105 + go[195]; + double RHS24 = Idr[192] + Idr[193] + Idr[194] + Idr[195] + Idr[196] + Idr[197] - go[196] * *cnV[196] - go[197] * *cnV[197]; +const double f0 = 1.0 / m_A0; + const double f0_13 = -f0 * m_A36; + m_A38 += m_A1 * f0_13; + RHS13 += f0_13 * RHS0; + const double f0_19 = -f0 * m_A63; + m_A67 += m_A1 * f0_19; + RHS19 += f0_19 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_14 = -f1 * m_A39; + m_A41 += m_A3 * f1_14; + RHS14 += f1_14 * RHS1; + const double f1_20 = -f1 * m_A71; + m_A76 += m_A3 * f1_20; + RHS20 += f1_20 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_15 = -f2 * m_A42; + m_A44 += m_A5 * f2_15; + RHS15 += f2_15 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_15 = -f3 * m_A43; + m_A44 += m_A7 * f3_15; + m_A45 += m_A8 * f3_15; + RHS15 += f3_15 * RHS3; + const double f3_16 = -f3 * m_A46; + m_A47 += m_A7 * f3_16; + m_A49 += m_A8 * f3_16; + RHS16 += f3_16 * RHS3; + const double f3_21 = -f3 * m_A79; + m_A81 += m_A7 * f3_21; + m_A84 += m_A8 * f3_21; + RHS21 += f3_21 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_17 = -f4 * m_A50; + m_A51 += m_A10 * f4_17; + m_A52 += m_A11 * f4_17; + m_A53 += m_A12 * f4_17; + RHS17 += f4_17 * RHS4; + const double f4_21 = -f4 * m_A80; + m_A83 += m_A10 * f4_21; + m_A84 += m_A11 * f4_21; + m_A85 += m_A12 * f4_21; + RHS21 += f4_21 * RHS4; + const double f4_22 = -f4 * m_A86; + m_A89 += m_A10 * f4_22; + m_A93 += m_A11 * f4_22; + m_A94 += m_A12 * f4_22; + RHS22 += f4_22 * RHS4; +const double f5 = 1.0 / m_A13; + const double f5_22 = -f5 * m_A87; + m_A89 += m_A14 * f5_22; + m_A94 += m_A15 * f5_22; + RHS22 += f5_22 * RHS5; +const double f6 = 1.0 / m_A16; + const double f6_18 = -f6 * m_A54; + m_A58 += m_A17 * f6_18; + m_A61 += m_A18 * f6_18; + RHS18 += f6_18 * RHS6; + const double f6_22 = -f6 * m_A88; + m_A90 += m_A17 * f6_22; + m_A94 += m_A18 * f6_22; + RHS22 += f6_22 * RHS6; +const double f7 = 1.0 / m_A19; + const double f7_18 = -f7 * m_A55; + m_A58 += m_A20 * f7_18; + m_A59 += m_A21 * f7_18; + RHS18 += f7_18 * RHS7; + const double f7_19 = -f7 * m_A64; + m_A66 += m_A20 * f7_19; + m_A67 += m_A21 * f7_19; + RHS19 += f7_19 * RHS7; +const double f8 = 1.0 / m_A22; + const double f8_18 = -f8 * m_A56; + m_A58 += m_A23 * f8_18; + m_A60 += m_A24 * f8_18; + RHS18 += f8_18 * RHS8; + const double f8_20 = -f8 * m_A72; + m_A74 += m_A23 * f8_20; + m_A76 += m_A24 * f8_20; + RHS20 += f8_20 * RHS8; +const double f9 = 1.0 / m_A25; + const double f9_12 = -f9 * m_A32; + m_A34 += m_A26 * f9_12; + m_A35 += m_A27 * f9_12; + RHS12 += f9_12 * RHS9; + const double f9_24 = -f9 * m_A103; + m_A104 += m_A26 * f9_24; + m_A110 += m_A27 * f9_24; + RHS24 += f9_24 * RHS9; +const double f10 = 1.0 / m_A28; + const double f10_12 = -f10 * m_A33; + m_A34 += m_A29 * f10_12; + RHS12 += f10_12 * RHS10; +const double f11 = 1.0 / m_A30; + const double f11_18 = -f11 * m_A57; + m_A58 += m_A31 * f11_18; + RHS18 += f11_18 * RHS11; + const double f11_23 = -f11 * m_A96; + m_A97 += m_A31 * f11_23; + RHS23 += f11_23 * RHS11; +const double f12 = 1.0 / m_A34; + const double f12_24 = -f12 * m_A104; + m_A110 += m_A35 * f12_24; + RHS24 += f12_24 * RHS12; +const double f13 = 1.0 / m_A37; + const double f13_19 = -f13 * m_A65; + m_A67 += m_A38 * f13_19; + RHS19 += f13_19 * RHS13; +const double f14 = 1.0 / m_A40; + const double f14_20 = -f14 * m_A73; + m_A76 += m_A41 * f14_20; + RHS20 += f14_20 * RHS14; +const double f15 = 1.0 / m_A44; + const double f15_16 = -f15 * m_A47; + m_A49 += m_A45 * f15_16; + RHS16 += f15_16 * RHS15; + const double f15_21 = -f15 * m_A81; + m_A84 += m_A45 * f15_21; + RHS21 += f15_21 * RHS15; +const double f16 = 1.0 / m_A48; + const double f16_21 = -f16 * m_A82; + m_A84 += m_A49 * f16_21; + RHS21 += f16_21 * RHS16; +const double f17 = 1.0 / m_A51; + const double f17_21 = -f17 * m_A83; + m_A84 += m_A52 * f17_21; + m_A85 += m_A53 * f17_21; + RHS21 += f17_21 * RHS17; + const double f17_22 = -f17 * m_A89; + m_A93 += m_A52 * f17_22; + m_A94 += m_A53 * f17_22; + RHS22 += f17_22 * RHS17; +const double f18 = 1.0 / m_A58; + const double f18_19 = -f18 * m_A66; + m_A67 += m_A59 * f18_19; + m_A68 += m_A60 * f18_19; + m_A69 += m_A61 * f18_19; + m_A70 += m_A62 * f18_19; + RHS19 += f18_19 * RHS18; + const double f18_20 = -f18 * m_A74; + m_A75 += m_A59 * f18_20; + m_A76 += m_A60 * f18_20; + m_A77 += m_A61 * f18_20; + m_A78 += m_A62 * f18_20; + RHS20 += f18_20 * RHS18; + const double f18_22 = -f18 * m_A90; + m_A91 += m_A59 * f18_22; + m_A92 += m_A60 * f18_22; + m_A94 += m_A61 * f18_22; + m_A95 += m_A62 * f18_22; + RHS22 += f18_22 * RHS18; + const double f18_23 = -f18 * m_A97; + m_A98 += m_A59 * f18_23; + m_A99 += m_A60 * f18_23; + m_A100 += m_A61 * f18_23; + m_A102 += m_A62 * f18_23; + RHS23 += f18_23 * RHS18; + const double f18_24 = -f18 * m_A105; + m_A106 += m_A59 * f18_24; + m_A107 += m_A60 * f18_24; + m_A108 += m_A61 * f18_24; + m_A110 += m_A62 * f18_24; + RHS24 += f18_24 * RHS18; +const double f19 = 1.0 / m_A67; + const double f19_20 = -f19 * m_A75; + m_A76 += m_A68 * f19_20; + m_A77 += m_A69 * f19_20; + m_A78 += m_A70 * f19_20; + RHS20 += f19_20 * RHS19; + const double f19_22 = -f19 * m_A91; + m_A92 += m_A68 * f19_22; + m_A94 += m_A69 * f19_22; + m_A95 += m_A70 * f19_22; + RHS22 += f19_22 * RHS19; + const double f19_23 = -f19 * m_A98; + m_A99 += m_A68 * f19_23; + m_A100 += m_A69 * f19_23; + m_A102 += m_A70 * f19_23; + RHS23 += f19_23 * RHS19; + const double f19_24 = -f19 * m_A106; + m_A107 += m_A68 * f19_24; + m_A108 += m_A69 * f19_24; + m_A110 += m_A70 * f19_24; + RHS24 += f19_24 * RHS19; +const double f20 = 1.0 / m_A76; + const double f20_22 = -f20 * m_A92; + m_A94 += m_A77 * f20_22; + m_A95 += m_A78 * f20_22; + RHS22 += f20_22 * RHS20; + const double f20_23 = -f20 * m_A99; + m_A100 += m_A77 * f20_23; + m_A102 += m_A78 * f20_23; + RHS23 += f20_23 * RHS20; + const double f20_24 = -f20 * m_A107; + m_A108 += m_A77 * f20_24; + m_A110 += m_A78 * f20_24; + RHS24 += f20_24 * RHS20; +const double f21 = 1.0 / m_A84; + const double f21_22 = -f21 * m_A93; + m_A94 += m_A85 * f21_22; + RHS22 += f21_22 * RHS21; +const double f22 = 1.0 / m_A94; + const double f22_23 = -f22 * m_A100; + m_A102 += m_A95 * f22_23; + RHS23 += f22_23 * RHS22; + const double f22_24 = -f22 * m_A108; + m_A110 += m_A95 * f22_24; + RHS24 += f22_24 * RHS22; +const double f23 = 1.0 / m_A101; + const double f23_24 = -f23 * m_A109; + m_A110 += m_A102 * f23_24; + RHS24 += f23_24 * RHS23; + V[24] = RHS24 / m_A110; + double tmp23 = 0.0; + tmp23 += m_A102 * V[24]; + V[23] = (RHS23 - tmp23) / m_A101; + double tmp22 = 0.0; + tmp22 += m_A95 * V[24]; + V[22] = (RHS22 - tmp22) / m_A94; + double tmp21 = 0.0; + tmp21 += m_A85 * V[22]; + V[21] = (RHS21 - tmp21) / m_A84; + double tmp20 = 0.0; + tmp20 += m_A77 * V[22]; + tmp20 += m_A78 * V[24]; + V[20] = (RHS20 - tmp20) / m_A76; + double tmp19 = 0.0; + tmp19 += m_A68 * V[20]; + tmp19 += m_A69 * V[22]; + tmp19 += m_A70 * V[24]; + V[19] = (RHS19 - tmp19) / m_A67; + double tmp18 = 0.0; + tmp18 += m_A59 * V[19]; + tmp18 += m_A60 * V[20]; + tmp18 += m_A61 * V[22]; + tmp18 += m_A62 * V[24]; + V[18] = (RHS18 - tmp18) / m_A58; + double tmp17 = 0.0; + tmp17 += m_A52 * V[21]; + tmp17 += m_A53 * V[22]; + V[17] = (RHS17 - tmp17) / m_A51; + double tmp16 = 0.0; + tmp16 += m_A49 * V[21]; + V[16] = (RHS16 - tmp16) / m_A48; + double tmp15 = 0.0; + tmp15 += m_A45 * V[21]; + V[15] = (RHS15 - tmp15) / m_A44; + double tmp14 = 0.0; + tmp14 += m_A41 * V[20]; + V[14] = (RHS14 - tmp14) / m_A40; + double tmp13 = 0.0; + tmp13 += m_A38 * V[19]; + V[13] = (RHS13 - tmp13) / m_A37; + double tmp12 = 0.0; + tmp12 += m_A35 * V[24]; + V[12] = (RHS12 - tmp12) / m_A34; + double tmp11 = 0.0; + tmp11 += m_A31 * V[18]; + V[11] = (RHS11 - tmp11) / m_A30; + double tmp10 = 0.0; + tmp10 += m_A29 * V[12]; + V[10] = (RHS10 - tmp10) / m_A28; + double tmp9 = 0.0; + tmp9 += m_A26 * V[12]; + tmp9 += m_A27 * V[24]; + V[9] = (RHS9 - tmp9) / m_A25; + double tmp8 = 0.0; + tmp8 += m_A23 * V[18]; + tmp8 += m_A24 * V[20]; + V[8] = (RHS8 - tmp8) / m_A22; + double tmp7 = 0.0; + tmp7 += m_A20 * V[18]; + tmp7 += m_A21 * V[19]; + V[7] = (RHS7 - tmp7) / m_A19; + double tmp6 = 0.0; + tmp6 += m_A17 * V[18]; + tmp6 += m_A18 * V[22]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[17]; + tmp5 += m_A15 * V[22]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A10 * V[17]; + tmp4 += m_A11 * V[21]; + tmp4 += m_A12 * V[22]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[15]; + tmp3 += m_A8 * V[21]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[15]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[20]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[19]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_3641ac25e244c362_16(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A4 = gt[8] + gt[9]; + m_A5 = m_A5 + go[8]; + double RHS2 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A6 = gt[12] + gt[13]; + m_A7 = m_A7 + go[12]; + double RHS3 = Idr[12] + Idr[13] - go[13] * *cnV[13]; + m_A9 = gt[16] + gt[17] + gt[18]; + m_A8 = m_A8 + go[16]; + m_A10 = m_A10 + go[17]; + double RHS4 = Idr[16] + Idr[17] + Idr[18] - go[18] * *cnV[18]; + m_A15 = gt[20] + gt[21] + gt[22] + gt[23]; + m_A14 = m_A14 + go[20]; + m_A13 = m_A13 + go[21]; + m_A12 = m_A12 + go[22]; + m_A11 = m_A11 + go[23]; + double RHS5 = Idr[20] + Idr[21] + Idr[22] + Idr[23]; +const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A11; + m_A15 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A12; + m_A15 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A8; + m_A9 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_5 = -f3 * m_A13; + m_A15 += m_A7 * f3_5; + RHS5 += f3_5 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_5 = -f4 * m_A14; + m_A15 += m_A10 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A15; + double tmp4 = 0.0; + tmp4 += m_A10 * V[5]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[5]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_38a3ac18f52bf78a_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10] + gt[11]; + m_A3 = m_A3 + go[8]; + m_A3 = m_A3 + go[9]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] + Idr[11] - go[10] * *cnV[10] - go[11] * *cnV[11]; + m_A6 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A5 = m_A5 + go[16]; + m_A5 = m_A5 + go[17]; + m_A4 = m_A4 + go[18]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] - go[19] * *cnV[19] - go[20] * *cnV[20] - go[21] * *cnV[21] - go[22] * *cnV[22]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_38f1806722626d7e_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A6 = gt[8] + gt[9] + gt[10] + gt[11]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] + Idr[11] - go[10] * *cnV[10] - go[11] * *cnV[11]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_3e4821cabc0aeb96_24(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3] + gt[4] + gt[5] + gt[6]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] + Idr[4] + Idr[5] + Idr[6] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3] - go[4] * *cnV[4] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] - go[17] * *cnV[17]; + m_A6 = gt[24] + gt[25]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A8 = gt[32] + gt[33] + gt[34]; + m_A10 = m_A10 + go[32]; + m_A9 = m_A9 + go[33]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[34] * *cnV[34]; + m_A11 = gt[40] + gt[41] + gt[42]; + m_A12 = m_A12 + go[40]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[41] * *cnV[41] - go[42] * *cnV[42]; + m_A18 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52]; + m_A16 = m_A16 + go[48]; + m_A15 = m_A15 + go[49]; + m_A14 = m_A14 + go[50]; + m_A17 = m_A17 + go[51]; + m_A13 = m_A13 + go[52]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52]; + m_A23 = gt[56] + gt[57]; + m_A21 = m_A21 + go[56]; + m_A20 = m_A20 + go[57]; + double RHS7 = Idr[56] + Idr[57]; +const double f0 = 1.0 / m_A0; + const double f0_6 = -f0 * m_A13; + m_A18 += m_A1 * f0_6; + RHS6 += f0_6 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A14; + m_A18 += m_A3 * f1_6; + RHS6 += f1_6 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_6 = -f2 * m_A15; + m_A18 += m_A5 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_6 = -f3 * m_A16; + m_A18 += m_A7 * f3_6; + RHS6 += f3_6 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_6 = -f4 * m_A17; + m_A18 += m_A9 * f4_6; + m_A19 += m_A10 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_7 = -f4 * m_A20; + m_A22 += m_A9 * f4_7; + m_A23 += m_A10 * f4_7; + RHS7 += f4_7 * RHS4; +const double f5 = 1.0 / m_A11; + const double f5_7 = -f5 * m_A21; + m_A23 += m_A12 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A18; + const double f6_7 = -f6 * m_A22; + m_A23 += m_A19 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A23; + double tmp6 = 0.0; + tmp6 += m_A19 * V[7]; + V[6] = (RHS6 - tmp6) / m_A18; + double tmp5 = 0.0; + tmp5 += m_A12 * V[7]; + V[5] = (RHS5 - tmp5) / m_A11; + double tmp4 = 0.0; + tmp4 += m_A9 * V[6]; + tmp4 += m_A10 * V[7]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[6]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[6]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[6]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_4966c35de59b7e6a_99(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); +double m_A90(0.0); +double m_A91(0.0); +double m_A92(0.0); +double m_A93(0.0); +double m_A94(0.0); +double m_A95(0.0); +double m_A96(0.0); +double m_A97(0.0); +double m_A98(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[10] + gt[11] + gt[12] + gt[13] + gt[14]; + m_A4 = m_A4 + go[10]; + m_A3 = m_A3 + go[11]; + m_A3 = m_A3 + go[12]; + double RHS1 = Idr[10] + Idr[11] + Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A5 = gt[20] + gt[21] + gt[22] + gt[23] + gt[24] + gt[25] + gt[26]; + m_A6 = m_A6 + go[20]; + m_A5 = m_A5 + go[21]; + m_A5 = m_A5 + go[22]; + double RHS2 = Idr[20] + Idr[21] + Idr[22] + Idr[23] + Idr[24] + Idr[25] + Idr[26] - go[23] * *cnV[23] - go[24] * *cnV[24] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A7 = gt[30] + gt[31] + gt[32] + gt[33] + gt[34]; + m_A9 = m_A9 + go[30]; + m_A9 = m_A9 + go[31]; + m_A8 = m_A8 + go[32]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A10 = gt[40] + gt[41] + gt[42]; + m_A12 = m_A12 + go[40]; + m_A11 = m_A11 + go[41]; + double RHS4 = Idr[40] + Idr[41] + Idr[42] - go[42] * *cnV[42]; + m_A13 = gt[50] + gt[51] + gt[52] + gt[53] + gt[54] + gt[55] + gt[56]; + m_A14 = m_A14 + go[50]; + m_A13 = m_A13 + go[51]; + m_A13 = m_A13 + go[52]; + double RHS5 = Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] + Idr[55] + Idr[56] - go[53] * *cnV[53] - go[54] * *cnV[54] - go[55] * *cnV[55] - go[56] * *cnV[56]; + m_A15 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64]; + m_A17 = m_A17 + go[60]; + m_A17 = m_A17 + go[61]; + m_A16 = m_A16 + go[62]; + double RHS6 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] - go[63] * *cnV[63] - go[64] * *cnV[64]; + m_A18 = gt[70] + gt[71] + gt[72]; + m_A20 = m_A20 + go[70]; + m_A19 = m_A19 + go[71]; + double RHS7 = Idr[70] + Idr[71] + Idr[72] - go[72] * *cnV[72]; + m_A21 = gt[80] + gt[81] + gt[82]; + m_A22 = m_A22 + go[80]; + m_A23 = m_A23 + go[81]; + double RHS8 = Idr[80] + Idr[81] + Idr[82] - go[82] * *cnV[82]; + m_A24 = gt[90] + gt[91] + gt[92] + gt[93] + gt[94] + gt[95]; + m_A25 = m_A25 + go[90]; + m_A28 = m_A28 + go[91]; + m_A26 = m_A26 + go[92]; + m_A27 = m_A27 + go[93]; + double RHS9 = Idr[90] + Idr[91] + Idr[92] + Idr[93] + Idr[94] + Idr[95] - go[94] * *cnV[94] - go[95] * *cnV[95]; + m_A30 = gt[100] + gt[101] + gt[102] + gt[103] + gt[104] + gt[105] + gt[106]; + m_A31 = m_A31 + go[100]; + m_A31 = m_A31 + go[101]; + m_A32 = m_A32 + go[102]; + m_A29 = m_A29 + go[103]; + double RHS10 = Idr[100] + Idr[101] + Idr[102] + Idr[103] + Idr[104] + Idr[105] + Idr[106] - go[104] * *cnV[104] - go[105] * *cnV[105] - go[106] * *cnV[106]; + m_A35 = gt[110] + gt[111] + gt[112] + gt[113] + gt[114]; + m_A34 = m_A34 + go[110]; + m_A33 = m_A33 + go[111]; + double RHS11 = Idr[110] + Idr[111] + Idr[112] + Idr[113] + Idr[114] - go[112] * *cnV[112] - go[113] * *cnV[113] - go[114] * *cnV[114]; + m_A39 = gt[120] + gt[121] + gt[122] + gt[123] + gt[124] + gt[125] + gt[126]; + m_A41 = m_A41 + go[120]; + m_A41 = m_A41 + go[121]; + m_A40 = m_A40 + go[122]; + m_A38 = m_A38 + go[123]; + double RHS12 = Idr[120] + Idr[121] + Idr[122] + Idr[123] + Idr[124] + Idr[125] + Idr[126] - go[124] * *cnV[124] - go[125] * *cnV[125] - go[126] * *cnV[126]; + m_A44 = gt[130] + gt[131]; + m_A43 = m_A43 + go[130]; + m_A42 = m_A42 + go[131]; + double RHS13 = Idr[130] + Idr[131]; + m_A52 = gt[140] + gt[141] + gt[142] + gt[143] + gt[144] + gt[145] + gt[146]; + m_A49 = m_A49 + go[140]; + m_A50 = m_A50 + go[141]; + m_A52 = m_A52 + go[142]; + m_A52 = m_A52 + go[143]; + double RHS14 = Idr[140] + Idr[141] + Idr[142] + Idr[143] + Idr[144] + Idr[145] + Idr[146] - go[144] * *cnV[144] - go[145] * *cnV[145] - go[146] * *cnV[146]; + m_A60 = gt[150] + gt[151] + gt[152] + gt[153] + gt[154] + gt[155] + gt[156] + gt[157] + gt[158]; + m_A57 = m_A57 + go[150]; + m_A61 = m_A61 + go[151]; + m_A61 = m_A61 + go[152]; + m_A56 = m_A56 + go[153]; + m_A56 = m_A56 + go[154]; + double RHS15 = Idr[150] + Idr[151] + Idr[152] + Idr[153] + Idr[154] + Idr[155] + Idr[156] + Idr[157] + Idr[158] - go[155] * *cnV[155] - go[156] * *cnV[156] - go[157] * *cnV[157] - go[158] * *cnV[158]; + m_A65 = gt[160] + gt[161] + gt[162] + gt[163] + gt[164] + gt[165] + gt[166] + gt[167] + gt[168]; + m_A66 = m_A66 + go[160]; + m_A64 = m_A64 + go[161]; + m_A64 = m_A64 + go[162]; + m_A63 = m_A63 + go[163]; + m_A63 = m_A63 + go[164]; + double RHS16 = Idr[160] + Idr[161] + Idr[162] + Idr[163] + Idr[164] + Idr[165] + Idr[166] + Idr[167] + Idr[168] - go[165] * *cnV[165] - go[166] * *cnV[166] - go[167] * *cnV[167] - go[168] * *cnV[168]; + m_A71 = gt[170] + gt[171] + gt[172] + gt[173] + gt[174] + gt[175] + gt[176] + gt[177] + gt[178]; + m_A73 = m_A73 + go[170]; + m_A73 = m_A73 + go[171]; + m_A68 = m_A68 + go[172]; + m_A70 = m_A70 + go[173]; + m_A67 = m_A67 + go[174]; + double RHS17 = Idr[170] + Idr[171] + Idr[172] + Idr[173] + Idr[174] + Idr[175] + Idr[176] + Idr[177] + Idr[178] - go[175] * *cnV[175] - go[176] * *cnV[176] - go[177] * *cnV[177] - go[178] * *cnV[178]; + m_A79 = gt[180] + gt[181] + gt[182] + gt[183] + gt[184] + gt[185] + gt[186]; + m_A75 = m_A75 + go[180]; + m_A78 = m_A78 + go[181]; + m_A78 = m_A78 + go[182]; + m_A74 = m_A74 + go[183]; + double RHS18 = Idr[180] + Idr[181] + Idr[182] + Idr[183] + Idr[184] + Idr[185] + Idr[186] - go[184] * *cnV[184] - go[185] * *cnV[185] - go[186] * *cnV[186]; + m_A87 = gt[190] + gt[191] + gt[192] + gt[193] + gt[194] + gt[195]; + m_A85 = m_A85 + go[190]; + m_A82 = m_A82 + go[191]; + m_A83 = m_A83 + go[192]; + m_A81 = m_A81 + go[193]; + double RHS19 = Idr[190] + Idr[191] + Idr[192] + Idr[193] + Idr[194] + Idr[195] - go[194] * *cnV[194] - go[195] * *cnV[195]; + m_A98 = gt[200] + gt[201] + gt[202] + gt[203] + gt[204] + gt[205] + gt[206] + gt[207] + gt[208] + gt[209]; + m_A90 = m_A90 + go[200]; + m_A95 = m_A95 + go[201]; + m_A95 = m_A95 + go[202]; + m_A91 = m_A91 + go[203]; + m_A91 = m_A91 + go[204]; + m_A89 = m_A89 + go[205]; + m_A89 = m_A89 + go[206]; + double RHS20 = Idr[200] + Idr[201] + Idr[202] + Idr[203] + Idr[204] + Idr[205] + Idr[206] + Idr[207] + Idr[208] + Idr[209] - go[207] * *cnV[207] - go[208] * *cnV[208] - go[209] * *cnV[209]; +const double f0 = 1.0 / m_A0; + const double f0_14 = -f0 * m_A49; + m_A52 += m_A1 * f0_14; + RHS14 += f0_14 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_15 = -f1 * m_A56; + m_A60 += m_A3 * f1_15; + m_A61 += m_A4 * f1_15; + RHS15 += f1_15 * RHS1; + const double f1_18 = -f1 * m_A74; + m_A78 += m_A3 * f1_18; + m_A79 += m_A4 * f1_18; + RHS18 += f1_18 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_19 = -f2 * m_A81; + m_A87 += m_A6 * f2_19; + RHS19 += f2_19 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_10 = -f3 * m_A29; + m_A30 += m_A8 * f3_10; + m_A31 += m_A9 * f3_10; + RHS10 += f3_10 * RHS3; + const double f3_16 = -f3 * m_A63; + m_A64 += m_A8 * f3_16; + m_A65 += m_A9 * f3_16; + RHS16 += f3_16 * RHS3; +const double f4 = 1.0 / m_A10; + const double f4_11 = -f4 * m_A33; + m_A35 += m_A11 * f4_11; + m_A37 += m_A12 * f4_11; + RHS11 += f4_11 * RHS4; + const double f4_19 = -f4 * m_A82; + m_A84 += m_A11 * f4_19; + m_A87 += m_A12 * f4_19; + RHS19 += f4_19 * RHS4; +const double f5 = 1.0 / m_A13; + const double f5_17 = -f5 * m_A67; + m_A71 += m_A14 * f5_17; + RHS17 += f5_17 * RHS5; +const double f6 = 1.0 / m_A15; + const double f6_12 = -f6 * m_A38; + m_A39 += m_A16 * f6_12; + m_A41 += m_A17 * f6_12; + RHS12 += f6_12 * RHS6; + const double f6_20 = -f6 * m_A89; + m_A91 += m_A16 * f6_20; + m_A98 += m_A17 * f6_20; + RHS20 += f6_20 * RHS6; +const double f7 = 1.0 / m_A18; + const double f7_11 = -f7 * m_A34; + m_A35 += m_A19 * f7_11; + m_A36 += m_A20 * f7_11; + RHS11 += f7_11 * RHS7; + const double f7_17 = -f7 * m_A68; + m_A69 += m_A19 * f7_17; + m_A71 += m_A20 * f7_17; + RHS17 += f7_17 * RHS7; +const double f8 = 1.0 / m_A21; + const double f8_13 = -f8 * m_A42; + m_A44 += m_A22 * f8_13; + m_A48 += m_A23 * f8_13; + RHS13 += f8_13 * RHS8; + const double f8_20 = -f8 * m_A90; + m_A92 += m_A22 * f8_20; + m_A98 += m_A23 * f8_20; + RHS20 += f8_20 * RHS8; +const double f9 = 1.0 / m_A24; + const double f9_13 = -f9 * m_A43; + m_A44 += m_A25 * f9_13; + m_A45 += m_A26 * f9_13; + m_A46 += m_A27 * f9_13; + m_A47 += m_A28 * f9_13; + RHS13 += f9_13 * RHS9; + const double f9_14 = -f9 * m_A50; + m_A51 += m_A25 * f9_14; + m_A52 += m_A26 * f9_14; + m_A53 += m_A27 * f9_14; + m_A54 += m_A28 * f9_14; + RHS14 += f9_14 * RHS9; + const double f9_15 = -f9 * m_A57; + m_A58 += m_A25 * f9_15; + m_A59 += m_A26 * f9_15; + m_A60 += m_A27 * f9_15; + m_A61 += m_A28 * f9_15; + RHS15 += f9_15 * RHS9; + const double f9_18 = -f9 * m_A75; + m_A76 += m_A25 * f9_18; + m_A77 += m_A26 * f9_18; + m_A78 += m_A27 * f9_18; + m_A79 += m_A28 * f9_18; + RHS18 += f9_18 * RHS9; +const double f10 = 1.0 / m_A30; + const double f10_16 = -f10 * m_A64; + m_A65 += m_A31 * f10_16; + m_A66 += m_A32 * f10_16; + RHS16 += f10_16 * RHS10; + const double f10_19 = -f10 * m_A83; + m_A85 += m_A31 * f10_19; + m_A87 += m_A32 * f10_19; + RHS19 += f10_19 * RHS10; +const double f11 = 1.0 / m_A35; + const double f11_17 = -f11 * m_A69; + m_A71 += m_A36 * f11_17; + m_A72 += m_A37 * f11_17; + RHS17 += f11_17 * RHS11; + const double f11_19 = -f11 * m_A84; + m_A86 += m_A36 * f11_19; + m_A87 += m_A37 * f11_19; + RHS19 += f11_19 * RHS11; +const double f12 = 1.0 / m_A39; + const double f12_17 = -f12 * m_A70; + m_A71 += m_A40 * f12_17; + m_A73 += m_A41 * f12_17; + RHS17 += f12_17 * RHS12; + const double f12_20 = -f12 * m_A91; + m_A95 += m_A40 * f12_20; + m_A98 += m_A41 * f12_20; + RHS20 += f12_20 * RHS12; +const double f13 = 1.0 / m_A44; + const double f13_14 = -f13 * m_A51; + m_A52 += m_A45 * f13_14; + m_A53 += m_A46 * f13_14; + m_A54 += m_A47 * f13_14; + m_A55 += m_A48 * f13_14; + RHS14 += f13_14 * RHS13; + const double f13_15 = -f13 * m_A58; + m_A59 += m_A45 * f13_15; + m_A60 += m_A46 * f13_15; + m_A61 += m_A47 * f13_15; + m_A62 += m_A48 * f13_15; + RHS15 += f13_15 * RHS13; + const double f13_18 = -f13 * m_A76; + m_A77 += m_A45 * f13_18; + m_A78 += m_A46 * f13_18; + m_A79 += m_A47 * f13_18; + m_A80 += m_A48 * f13_18; + RHS18 += f13_18 * RHS13; + const double f13_20 = -f13 * m_A92; + m_A93 += m_A45 * f13_20; + m_A94 += m_A46 * f13_20; + m_A96 += m_A47 * f13_20; + m_A98 += m_A48 * f13_20; + RHS20 += f13_20 * RHS13; +const double f14 = 1.0 / m_A52; + const double f14_15 = -f14 * m_A59; + m_A60 += m_A53 * f14_15; + m_A61 += m_A54 * f14_15; + m_A62 += m_A55 * f14_15; + RHS15 += f14_15 * RHS14; + const double f14_18 = -f14 * m_A77; + m_A78 += m_A53 * f14_18; + m_A79 += m_A54 * f14_18; + m_A80 += m_A55 * f14_18; + RHS18 += f14_18 * RHS14; + const double f14_20 = -f14 * m_A93; + m_A94 += m_A53 * f14_20; + m_A96 += m_A54 * f14_20; + m_A98 += m_A55 * f14_20; + RHS20 += f14_20 * RHS14; +const double f15 = 1.0 / m_A60; + const double f15_18 = -f15 * m_A78; + m_A79 += m_A61 * f15_18; + m_A80 += m_A62 * f15_18; + RHS18 += f15_18 * RHS15; + const double f15_20 = -f15 * m_A94; + m_A96 += m_A61 * f15_20; + m_A98 += m_A62 * f15_20; + RHS20 += f15_20 * RHS15; +const double f16 = 1.0 / m_A65; + const double f16_19 = -f16 * m_A85; + m_A87 += m_A66 * f16_19; + RHS19 += f16_19 * RHS16; +const double f17 = 1.0 / m_A71; + const double f17_19 = -f17 * m_A86; + m_A87 += m_A72 * f17_19; + m_A88 += m_A73 * f17_19; + RHS19 += f17_19 * RHS17; + const double f17_20 = -f17 * m_A95; + m_A97 += m_A72 * f17_20; + m_A98 += m_A73 * f17_20; + RHS20 += f17_20 * RHS17; +const double f18 = 1.0 / m_A79; + const double f18_20 = -f18 * m_A96; + m_A98 += m_A80 * f18_20; + RHS20 += f18_20 * RHS18; +const double f19 = 1.0 / m_A87; + const double f19_20 = -f19 * m_A97; + m_A98 += m_A88 * f19_20; + RHS20 += f19_20 * RHS19; + V[20] = RHS20 / m_A98; + double tmp19 = 0.0; + tmp19 += m_A88 * V[20]; + V[19] = (RHS19 - tmp19) / m_A87; + double tmp18 = 0.0; + tmp18 += m_A80 * V[20]; + V[18] = (RHS18 - tmp18) / m_A79; + double tmp17 = 0.0; + tmp17 += m_A72 * V[19]; + tmp17 += m_A73 * V[20]; + V[17] = (RHS17 - tmp17) / m_A71; + double tmp16 = 0.0; + tmp16 += m_A66 * V[19]; + V[16] = (RHS16 - tmp16) / m_A65; + double tmp15 = 0.0; + tmp15 += m_A61 * V[18]; + tmp15 += m_A62 * V[20]; + V[15] = (RHS15 - tmp15) / m_A60; + double tmp14 = 0.0; + tmp14 += m_A53 * V[15]; + tmp14 += m_A54 * V[18]; + tmp14 += m_A55 * V[20]; + V[14] = (RHS14 - tmp14) / m_A52; + double tmp13 = 0.0; + tmp13 += m_A45 * V[14]; + tmp13 += m_A46 * V[15]; + tmp13 += m_A47 * V[18]; + tmp13 += m_A48 * V[20]; + V[13] = (RHS13 - tmp13) / m_A44; + double tmp12 = 0.0; + tmp12 += m_A40 * V[17]; + tmp12 += m_A41 * V[20]; + V[12] = (RHS12 - tmp12) / m_A39; + double tmp11 = 0.0; + tmp11 += m_A36 * V[17]; + tmp11 += m_A37 * V[19]; + V[11] = (RHS11 - tmp11) / m_A35; + double tmp10 = 0.0; + tmp10 += m_A31 * V[16]; + tmp10 += m_A32 * V[19]; + V[10] = (RHS10 - tmp10) / m_A30; + double tmp9 = 0.0; + tmp9 += m_A25 * V[13]; + tmp9 += m_A26 * V[14]; + tmp9 += m_A27 * V[15]; + tmp9 += m_A28 * V[18]; + V[9] = (RHS9 - tmp9) / m_A24; + double tmp8 = 0.0; + tmp8 += m_A22 * V[13]; + tmp8 += m_A23 * V[20]; + V[8] = (RHS8 - tmp8) / m_A21; + double tmp7 = 0.0; + tmp7 += m_A19 * V[11]; + tmp7 += m_A20 * V[17]; + V[7] = (RHS7 - tmp7) / m_A18; + double tmp6 = 0.0; + tmp6 += m_A16 * V[12]; + tmp6 += m_A17 * V[20]; + V[6] = (RHS6 - tmp6) / m_A15; + double tmp5 = 0.0; + tmp5 += m_A14 * V[17]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[11]; + tmp4 += m_A12 * V[19]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A8 * V[10]; + tmp3 += m_A9 * V[16]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A6 * V[19]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[15]; + tmp1 += m_A4 * V[18]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[14]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_57a832104e53c9a8_20(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3]; + m_A2 = gt[8]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8]; + m_A4 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20]; + m_A6 = m_A6 + go[16]; + m_A5 = m_A5 + go[17]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] - go[18] * *cnV[18] - go[19] * *cnV[19] - go[20] * *cnV[20]; + m_A8 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28] + gt[29] + gt[30]; + m_A10 = m_A10 + go[24]; + m_A9 = m_A9 + go[25]; + m_A7 = m_A7 + go[26]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] + Idr[29] + Idr[30] - go[27] * *cnV[27] - go[28] * *cnV[28] - go[29] * *cnV[29] - go[30] * *cnV[30]; + m_A14 = gt[32] + gt[33] + gt[34] + gt[35]; + m_A11 = m_A11 + go[32]; + m_A12 = m_A12 + go[33]; + m_A13 = m_A13 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] - go[35] * *cnV[35]; + m_A19 = gt[40] + gt[41] + gt[42]; + m_A16 = m_A16 + go[40]; + m_A17 = m_A17 + go[41]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[42] * *cnV[42]; +const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A7; + m_A8 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A11; + m_A14 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A12; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A16; + m_A18 += m_A5 * f2_5; + m_A19 += m_A6 * f2_5; + RHS5 += f2_5 * RHS2; +const double f3 = 1.0 / m_A8; + const double f3_4 = -f3 * m_A13; + m_A14 += m_A9 * f3_4; + m_A15 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_5 = -f3 * m_A17; + m_A18 += m_A9 * f3_5; + m_A19 += m_A10 * f3_5; + RHS5 += f3_5 * RHS3; +const double f4 = 1.0 / m_A14; + const double f4_5 = -f4 * m_A18; + m_A19 += m_A15 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A19; + double tmp4 = 0.0; + tmp4 += m_A15 * V[5]; + V[4] = (RHS4 - tmp4) / m_A14; + double tmp3 = 0.0; + tmp3 += m_A9 * V[4]; + tmp3 += m_A10 * V[5]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + tmp2 += m_A6 * V[5]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_5985dfb549280eeb_13(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[6] + gt[7] + gt[8]; + m_A3 = m_A3 + go[6]; + double RHS1 = Idr[6] + Idr[7] + Idr[8] - go[7] * *cnV[7] - go[8] * *cnV[8]; + m_A4 = gt[12] + gt[13] + gt[14]; + m_A5 = m_A5 + go[12]; + double RHS2 = Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A6 = gt[18] + gt[19] + gt[20]; + m_A7 = m_A7 + go[18]; + double RHS3 = Idr[18] + Idr[19] + Idr[20] - go[19] * *cnV[19] - go[20] * *cnV[20]; + m_A12 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28]; + m_A11 = m_A11 + go[24]; + m_A10 = m_A10 + go[25]; + m_A9 = m_A9 + go[26]; + m_A8 = m_A8 + go[27]; + double RHS4 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] - go[28] * *cnV[28]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A8; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A9; + m_A12 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A10; + m_A12 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_4 = -f3 * m_A11; + m_A12 += m_A7 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A12; + double tmp3 = 0.0; + tmp3 += m_A7 * V[4]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_5ca1779d1825c4c9_26(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + m_A2 = m_A2 + go[1]; + double RHS0 = Idr[0] + Idr[1]; + m_A3 = gt[6] + gt[7] + gt[8]; + m_A4 = m_A4 + go[6]; + double RHS1 = Idr[6] + Idr[7] + Idr[8] - go[7] * *cnV[7] - go[8] * *cnV[8]; + m_A5 = gt[12] + gt[13] + gt[14]; + m_A6 = m_A6 + go[12]; + double RHS2 = Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A7 = gt[18] + gt[19]; + m_A8 = m_A8 + go[18]; + double RHS3 = Idr[18] + Idr[19] - go[19] * *cnV[19]; + m_A10 = gt[24] + gt[25] + gt[26] + gt[27]; + m_A11 = m_A11 + go[24]; + m_A9 = m_A9 + go[25]; + double RHS4 = Idr[24] + Idr[25] + Idr[26] + Idr[27] - go[26] * *cnV[26] - go[27] * *cnV[27]; + m_A14 = gt[30] + gt[31]; + m_A13 = m_A13 + go[30]; + m_A15 = m_A15 + go[31]; + double RHS5 = Idr[30] + Idr[31]; + m_A19 = gt[36] + gt[37] + gt[38] + gt[39]; + m_A17 = m_A17 + go[36]; + m_A16 = m_A16 + go[37]; + m_A18 = m_A18 + go[38]; + m_A20 = m_A20 + go[39]; + double RHS6 = Idr[36] + Idr[37] + Idr[38] + Idr[39]; + m_A25 = gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A23 = m_A23 + go[42]; + m_A24 = m_A24 + go[43]; + m_A21 = m_A21 + go[44]; + double RHS7 = Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[45] * *cnV[45] - go[46] * *cnV[46]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A9; + m_A10 += m_A1 * f0_4; + m_A12 += m_A2 * f0_4; + RHS4 += f0_4 * RHS0; + const double f0_7 = -f0 * m_A21; + m_A22 += m_A1 * f0_7; + m_A25 += m_A2 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_6 = -f1 * m_A16; + m_A19 += m_A4 * f1_6; + RHS6 += f1_6 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_6 = -f2 * m_A17; + m_A19 += m_A6 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_5 = -f3 * m_A13; + m_A14 += m_A8 * f3_5; + RHS5 += f3_5 * RHS3; +const double f4 = 1.0 / m_A10; + const double f4_6 = -f4 * m_A18; + m_A19 += m_A11 * f4_6; + m_A20 += m_A12 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_7 = -f4 * m_A22; + m_A24 += m_A11 * f4_7; + m_A25 += m_A12 * f4_7; + RHS7 += f4_7 * RHS4; +const double f5 = 1.0 / m_A14; + const double f5_7 = -f5 * m_A23; + m_A25 += m_A15 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A19; + const double f6_7 = -f6 * m_A24; + m_A25 += m_A20 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A25; + double tmp6 = 0.0; + tmp6 += m_A20 * V[7]; + V[6] = (RHS6 - tmp6) / m_A19; + double tmp5 = 0.0; + tmp5 += m_A15 * V[7]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A11 * V[6]; + tmp4 += m_A12 * V[7]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A8 * V[5]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A6 * V[6]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A4 * V[6]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + tmp0 += m_A2 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_6148fa421800febb_10(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A5 = gt[8] + gt[9]; + m_A6 = m_A6 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9]; + m_A9 = gt[12] + gt[13]; + m_A7 = m_A7 + go[12]; + m_A8 = m_A8 + go[13]; + double RHS3 = Idr[12] + Idr[13]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A5 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A7; + m_A9 += m_A3 * f1_3; + RHS3 += f1_3 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_3 = -f2 * m_A8; + m_A9 += m_A6 * f2_3; + RHS3 += f2_3 * RHS2; + V[3] = RHS3 / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * V[3]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_63b745ec069c7245_82(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[10] + gt[11] + gt[12]; + m_A3 = m_A3 + go[10]; + double RHS1 = Idr[10] + Idr[11] + Idr[12] - go[11] * *cnV[11] - go[12] * *cnV[12]; + m_A4 = gt[20] + gt[21] + gt[22]; + m_A5 = m_A5 + go[20]; + double RHS2 = Idr[20] + Idr[21] + Idr[22] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A6 = gt[30] + gt[31] + gt[32] + gt[33] + gt[34]; + m_A8 = m_A8 + go[30]; + m_A8 = m_A8 + go[31]; + m_A7 = m_A7 + go[32]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A9 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A13 = m_A13 + go[40]; + m_A13 = m_A13 + go[41]; + m_A11 = m_A11 + go[42]; + m_A12 = m_A12 + go[43]; + m_A10 = m_A10 + go[44]; + double RHS4 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[45] * *cnV[45] - go[46] * *cnV[46]; + m_A14 = gt[50] + gt[51]; + m_A15 = m_A15 + go[50]; + m_A16 = m_A16 + go[51]; + double RHS5 = Idr[50] + Idr[51]; + m_A17 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64]; + m_A19 = m_A19 + go[60]; + m_A19 = m_A19 + go[61]; + m_A18 = m_A18 + go[62]; + double RHS6 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] - go[63] * *cnV[63] - go[64] * *cnV[64]; + m_A22 = gt[70] + gt[71] + gt[72] + gt[73] + gt[74] + gt[75] + gt[76]; + m_A20 = m_A20 + go[70]; + m_A21 = m_A21 + go[71]; + m_A22 = m_A22 + go[72]; + m_A22 = m_A22 + go[73]; + double RHS7 = Idr[70] + Idr[71] + Idr[72] + Idr[73] + Idr[74] + Idr[75] + Idr[76] - go[74] * *cnV[74] - go[75] * *cnV[75] - go[76] * *cnV[76]; + m_A29 = gt[80] + gt[81]; + m_A27 = m_A27 + go[80]; + m_A26 = m_A26 + go[81]; + double RHS8 = Idr[80] + Idr[81]; + m_A32 = gt[90] + gt[91] + gt[92] + gt[93] + gt[94] + gt[95] + gt[96]; + m_A36 = m_A36 + go[90]; + m_A36 = m_A36 + go[91]; + m_A33 = m_A33 + go[92]; + m_A35 = m_A35 + go[93]; + m_A34 = m_A34 + go[94]; + double RHS9 = Idr[90] + Idr[91] + Idr[92] + Idr[93] + Idr[94] + Idr[95] + Idr[96] - go[95] * *cnV[95] - go[96] * *cnV[96]; + m_A39 = gt[100] + gt[101] + gt[102]; + m_A38 = m_A38 + go[100]; + m_A37 = m_A37 + go[101]; + double RHS10 = Idr[100] + Idr[101] + Idr[102] - go[102] * *cnV[102]; + m_A47 = gt[110] + gt[111] + gt[112] + gt[113] + gt[114] + gt[115] + gt[116]; + m_A44 = m_A44 + go[110]; + m_A45 = m_A45 + go[111]; + m_A47 = m_A47 + go[112]; + m_A47 = m_A47 + go[113]; + double RHS11 = Idr[110] + Idr[111] + Idr[112] + Idr[113] + Idr[114] + Idr[115] + Idr[116] - go[114] * *cnV[114] - go[115] * *cnV[115] - go[116] * *cnV[116]; + m_A55 = gt[120] + gt[121] + gt[122] + gt[123] + gt[124] + gt[125] + gt[126]; + m_A56 = m_A56 + go[120]; + m_A56 = m_A56 + go[121]; + m_A52 = m_A52 + go[122]; + m_A51 = m_A51 + go[123]; + double RHS12 = Idr[120] + Idr[121] + Idr[122] + Idr[123] + Idr[124] + Idr[125] + Idr[126] - go[124] * *cnV[124] - go[125] * *cnV[125] - go[126] * *cnV[126]; + m_A61 = gt[130] + gt[131] + gt[132] + gt[133] + gt[134] + gt[135] + gt[136]; + m_A63 = m_A63 + go[130]; + m_A63 = m_A63 + go[131]; + m_A58 = m_A58 + go[132]; + m_A57 = m_A57 + go[133]; + double RHS13 = Idr[130] + Idr[131] + Idr[132] + Idr[133] + Idr[134] + Idr[135] + Idr[136] - go[134] * *cnV[134] - go[135] * *cnV[135] - go[136] * *cnV[136]; + m_A73 = gt[140] + gt[141] + gt[142] + gt[143] + gt[144] + gt[145] + gt[146] + gt[147] + gt[148] + gt[149]; + m_A66 = m_A66 + go[140]; + m_A65 = m_A65 + go[141]; + m_A65 = m_A65 + go[142]; + m_A71 = m_A71 + go[143]; + m_A71 = m_A71 + go[144]; + m_A64 = m_A64 + go[145]; + m_A64 = m_A64 + go[146]; + double RHS14 = Idr[140] + Idr[141] + Idr[142] + Idr[143] + Idr[144] + Idr[145] + Idr[146] + Idr[147] + Idr[148] + Idr[149] - go[147] * *cnV[147] - go[148] * *cnV[148] - go[149] * *cnV[149]; + m_A81 = gt[150] + gt[151] + gt[152] + gt[153] + gt[154] + gt[155] + gt[156] + gt[157] + gt[158] + gt[159]; + m_A76 = m_A76 + go[150]; + m_A76 = m_A76 + go[151]; + m_A79 = m_A79 + go[152]; + m_A79 = m_A79 + go[153]; + m_A75 = m_A75 + go[154]; + m_A75 = m_A75 + go[155]; + double RHS15 = Idr[150] + Idr[151] + Idr[152] + Idr[153] + Idr[154] + Idr[155] + Idr[156] + Idr[157] + Idr[158] + Idr[159] - go[156] * *cnV[156] - go[157] * *cnV[157] - go[158] * *cnV[158] - go[159] * *cnV[159]; +const double f0 = 1.0 / m_A0; + const double f0_7 = -f0 * m_A20; + m_A22 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_11 = -f1 * m_A44; + m_A47 += m_A3 * f1_11; + RHS11 += f1_11 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_8 = -f2 * m_A26; + m_A29 += m_A5 * f2_8; + RHS8 += f2_8 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_12 = -f3 * m_A51; + m_A55 += m_A7 * f3_12; + m_A56 += m_A8 * f3_12; + RHS12 += f3_12 * RHS3; + const double f3_14 = -f3 * m_A64; + m_A71 += m_A7 * f3_14; + m_A73 += m_A8 * f3_14; + RHS14 += f3_14 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_7 = -f4 * m_A21; + m_A22 += m_A10 * f4_7; + m_A23 += m_A11 * f4_7; + m_A24 += m_A12 * f4_7; + m_A25 += m_A13 * f4_7; + RHS7 += f4_7 * RHS4; + const double f4_8 = -f4 * m_A27; + m_A28 += m_A10 * f4_8; + m_A29 += m_A11 * f4_8; + m_A30 += m_A12 * f4_8; + m_A31 += m_A13 * f4_8; + RHS8 += f4_8 * RHS4; + const double f4_12 = -f4 * m_A52; + m_A53 += m_A10 * f4_12; + m_A54 += m_A11 * f4_12; + m_A55 += m_A12 * f4_12; + m_A56 += m_A13 * f4_12; + RHS12 += f4_12 * RHS4; + const double f4_14 = -f4 * m_A65; + m_A67 += m_A10 * f4_14; + m_A68 += m_A11 * f4_14; + m_A71 += m_A12 * f4_14; + m_A73 += m_A13 * f4_14; + RHS14 += f4_14 * RHS4; +const double f5 = 1.0 / m_A14; + const double f5_10 = -f5 * m_A37; + m_A39 += m_A15 * f5_10; + m_A42 += m_A16 * f5_10; + RHS10 += f5_10 * RHS5; + const double f5_14 = -f5 * m_A66; + m_A69 += m_A15 * f5_14; + m_A73 += m_A16 * f5_14; + RHS14 += f5_14 * RHS5; +const double f6 = 1.0 / m_A17; + const double f6_13 = -f6 * m_A57; + m_A61 += m_A18 * f6_13; + m_A63 += m_A19 * f6_13; + RHS13 += f6_13 * RHS6; + const double f6_15 = -f6 * m_A75; + m_A79 += m_A18 * f6_15; + m_A81 += m_A19 * f6_15; + RHS15 += f6_15 * RHS6; +const double f7 = 1.0 / m_A22; + const double f7_8 = -f7 * m_A28; + m_A29 += m_A23 * f7_8; + m_A30 += m_A24 * f7_8; + m_A31 += m_A25 * f7_8; + RHS8 += f7_8 * RHS7; + const double f7_12 = -f7 * m_A53; + m_A54 += m_A23 * f7_12; + m_A55 += m_A24 * f7_12; + m_A56 += m_A25 * f7_12; + RHS12 += f7_12 * RHS7; + const double f7_14 = -f7 * m_A67; + m_A68 += m_A23 * f7_14; + m_A71 += m_A24 * f7_14; + m_A73 += m_A25 * f7_14; + RHS14 += f7_14 * RHS7; +const double f8 = 1.0 / m_A29; + const double f8_12 = -f8 * m_A54; + m_A55 += m_A30 * f8_12; + m_A56 += m_A31 * f8_12; + RHS12 += f8_12 * RHS8; + const double f8_14 = -f8 * m_A68; + m_A71 += m_A30 * f8_14; + m_A73 += m_A31 * f8_14; + RHS14 += f8_14 * RHS8; +const double f9 = 1.0 / m_A32; + const double f9_10 = -f9 * m_A38; + m_A39 += m_A33 * f9_10; + m_A40 += m_A34 * f9_10; + m_A41 += m_A35 * f9_10; + m_A43 += m_A36 * f9_10; + RHS10 += f9_10 * RHS9; + const double f9_11 = -f9 * m_A45; + m_A46 += m_A33 * f9_11; + m_A47 += m_A34 * f9_11; + m_A48 += m_A35 * f9_11; + m_A50 += m_A36 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_13 = -f9 * m_A58; + m_A59 += m_A33 * f9_13; + m_A60 += m_A34 * f9_13; + m_A61 += m_A35 * f9_13; + m_A63 += m_A36 * f9_13; + RHS13 += f9_13 * RHS9; + const double f9_15 = -f9 * m_A76; + m_A77 += m_A33 * f9_15; + m_A78 += m_A34 * f9_15; + m_A79 += m_A35 * f9_15; + m_A81 += m_A36 * f9_15; + RHS15 += f9_15 * RHS9; +const double f10 = 1.0 / m_A39; + const double f10_11 = -f10 * m_A46; + m_A47 += m_A40 * f10_11; + m_A48 += m_A41 * f10_11; + m_A49 += m_A42 * f10_11; + m_A50 += m_A43 * f10_11; + RHS11 += f10_11 * RHS10; + const double f10_13 = -f10 * m_A59; + m_A60 += m_A40 * f10_13; + m_A61 += m_A41 * f10_13; + m_A62 += m_A42 * f10_13; + m_A63 += m_A43 * f10_13; + RHS13 += f10_13 * RHS10; + const double f10_14 = -f10 * m_A69; + m_A70 += m_A40 * f10_14; + m_A72 += m_A41 * f10_14; + m_A73 += m_A42 * f10_14; + m_A74 += m_A43 * f10_14; + RHS14 += f10_14 * RHS10; + const double f10_15 = -f10 * m_A77; + m_A78 += m_A40 * f10_15; + m_A79 += m_A41 * f10_15; + m_A80 += m_A42 * f10_15; + m_A81 += m_A43 * f10_15; + RHS15 += f10_15 * RHS10; +const double f11 = 1.0 / m_A47; + const double f11_13 = -f11 * m_A60; + m_A61 += m_A48 * f11_13; + m_A62 += m_A49 * f11_13; + m_A63 += m_A50 * f11_13; + RHS13 += f11_13 * RHS11; + const double f11_14 = -f11 * m_A70; + m_A72 += m_A48 * f11_14; + m_A73 += m_A49 * f11_14; + m_A74 += m_A50 * f11_14; + RHS14 += f11_14 * RHS11; + const double f11_15 = -f11 * m_A78; + m_A79 += m_A48 * f11_15; + m_A80 += m_A49 * f11_15; + m_A81 += m_A50 * f11_15; + RHS15 += f11_15 * RHS11; +const double f12 = 1.0 / m_A55; + const double f12_14 = -f12 * m_A71; + m_A73 += m_A56 * f12_14; + RHS14 += f12_14 * RHS12; +const double f13 = 1.0 / m_A61; + const double f13_14 = -f13 * m_A72; + m_A73 += m_A62 * f13_14; + m_A74 += m_A63 * f13_14; + RHS14 += f13_14 * RHS13; + const double f13_15 = -f13 * m_A79; + m_A80 += m_A62 * f13_15; + m_A81 += m_A63 * f13_15; + RHS15 += f13_15 * RHS13; +const double f14 = 1.0 / m_A73; + const double f14_15 = -f14 * m_A80; + m_A81 += m_A74 * f14_15; + RHS15 += f14_15 * RHS14; + V[15] = RHS15 / m_A81; + double tmp14 = 0.0; + tmp14 += m_A74 * V[15]; + V[14] = (RHS14 - tmp14) / m_A73; + double tmp13 = 0.0; + tmp13 += m_A62 * V[14]; + tmp13 += m_A63 * V[15]; + V[13] = (RHS13 - tmp13) / m_A61; + double tmp12 = 0.0; + tmp12 += m_A56 * V[14]; + V[12] = (RHS12 - tmp12) / m_A55; + double tmp11 = 0.0; + tmp11 += m_A48 * V[13]; + tmp11 += m_A49 * V[14]; + tmp11 += m_A50 * V[15]; + V[11] = (RHS11 - tmp11) / m_A47; + double tmp10 = 0.0; + tmp10 += m_A40 * V[11]; + tmp10 += m_A41 * V[13]; + tmp10 += m_A42 * V[14]; + tmp10 += m_A43 * V[15]; + V[10] = (RHS10 - tmp10) / m_A39; + double tmp9 = 0.0; + tmp9 += m_A33 * V[10]; + tmp9 += m_A34 * V[11]; + tmp9 += m_A35 * V[13]; + tmp9 += m_A36 * V[15]; + V[9] = (RHS9 - tmp9) / m_A32; + double tmp8 = 0.0; + tmp8 += m_A30 * V[12]; + tmp8 += m_A31 * V[14]; + V[8] = (RHS8 - tmp8) / m_A29; + double tmp7 = 0.0; + tmp7 += m_A23 * V[8]; + tmp7 += m_A24 * V[12]; + tmp7 += m_A25 * V[14]; + V[7] = (RHS7 - tmp7) / m_A22; + double tmp6 = 0.0; + tmp6 += m_A18 * V[13]; + tmp6 += m_A19 * V[15]; + V[6] = (RHS6 - tmp6) / m_A17; + double tmp5 = 0.0; + tmp5 += m_A15 * V[10]; + tmp5 += m_A16 * V[14]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A10 * V[7]; + tmp4 += m_A11 * V[8]; + tmp4 += m_A12 * V[12]; + tmp4 += m_A13 * V[14]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[12]; + tmp3 += m_A8 * V[14]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[8]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[11]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_6480c7a1d69e9131_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A6 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] - go[10] * *cnV[10]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_6c599fc01f5b084c_20(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3] + gt[4]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] + Idr[4] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3] - go[4] * *cnV[4]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20]; + m_A6 = m_A6 + go[16]; + m_A5 = m_A5 + go[17]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] - go[18] * *cnV[18] - go[19] * *cnV[19] - go[20] * *cnV[20]; + m_A8 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28] + gt[29] + gt[30]; + m_A10 = m_A10 + go[24]; + m_A9 = m_A9 + go[25]; + m_A7 = m_A7 + go[26]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] + Idr[29] + Idr[30] - go[27] * *cnV[27] - go[28] * *cnV[28] - go[29] * *cnV[29] - go[30] * *cnV[30]; + m_A14 = gt[32] + gt[33] + gt[34] + gt[35]; + m_A12 = m_A12 + go[32]; + m_A11 = m_A11 + go[33]; + m_A13 = m_A13 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] - go[35] * *cnV[35]; + m_A19 = gt[40] + gt[41] + gt[42]; + m_A16 = m_A16 + go[40]; + m_A17 = m_A17 + go[41]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[42] * *cnV[42]; +const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A7; + m_A8 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A11; + m_A14 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A12; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A16; + m_A18 += m_A5 * f2_5; + m_A19 += m_A6 * f2_5; + RHS5 += f2_5 * RHS2; +const double f3 = 1.0 / m_A8; + const double f3_4 = -f3 * m_A13; + m_A14 += m_A9 * f3_4; + m_A15 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_5 = -f3 * m_A17; + m_A18 += m_A9 * f3_5; + m_A19 += m_A10 * f3_5; + RHS5 += f3_5 * RHS3; +const double f4 = 1.0 / m_A14; + const double f4_5 = -f4 * m_A18; + m_A19 += m_A15 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A19; + double tmp4 = 0.0; + tmp4 += m_A15 * V[5]; + V[4] = (RHS4 - tmp4) / m_A14; + double tmp3 = 0.0; + tmp3 += m_A9 * V[4]; + tmp3 += m_A10 * V[5]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + tmp2 += m_A6 * V[5]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_6d40bbc695987ef5_13(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[6] + gt[7] + gt[8]; + m_A3 = m_A3 + go[6]; + double RHS1 = Idr[6] + Idr[7] + Idr[8] - go[7] * *cnV[7] - go[8] * *cnV[8]; + m_A4 = gt[12] + gt[13] + gt[14]; + m_A5 = m_A5 + go[12]; + double RHS2 = Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A6 = gt[18] + gt[19] + gt[20]; + m_A7 = m_A7 + go[18]; + double RHS3 = Idr[18] + Idr[19] + Idr[20] - go[19] * *cnV[19] - go[20] * *cnV[20]; + m_A12 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28] + gt[29]; + m_A11 = m_A11 + go[24]; + m_A10 = m_A10 + go[25]; + m_A9 = m_A9 + go[26]; + m_A8 = m_A8 + go[27]; + double RHS4 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] + Idr[29] - go[28] * *cnV[28] - go[29] * *cnV[29]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A8; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A9; + m_A12 += m_A3 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A10; + m_A12 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_4 = -f3 * m_A11; + m_A12 += m_A7 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A12; + double tmp3 = 0.0; + tmp3 += m_A7 * V[4]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_70e1061a9deb37a4_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A6 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] - go[10] * *cnV[10]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_7421995adbfda1ad_10(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A4 = gt[8] + gt[9]; + m_A5 = m_A5 + go[8]; + double RHS2 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A9 = gt[12] + gt[13] + gt[14]; + m_A8 = m_A8 + go[12]; + m_A7 = m_A7 + go[13]; + m_A6 = m_A6 + go[14]; + double RHS3 = Idr[12] + Idr[13] + Idr[14]; +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; +} + +static void nl_gcr_794f14a13bda75f0_50(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28] + gt[29]; + m_A10 = m_A10 + go[24]; + m_A7 = m_A7 + go[25]; + m_A8 = m_A8 + go[26]; + m_A9 = m_A9 + go[27]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] + Idr[29] - go[28] * *cnV[28] - go[29] * *cnV[29]; + m_A11 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36]; + m_A13 = m_A13 + go[32]; + m_A13 = m_A13 + go[33]; + m_A12 = m_A12 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] - go[35] * *cnV[35] - go[36] * *cnV[36]; + m_A14 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44]; + m_A16 = m_A16 + go[40]; + m_A15 = m_A15 + go[41]; + m_A15 = m_A15 + go[42]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] - go[43] * *cnV[43] - go[44] * *cnV[44]; + m_A19 = gt[48] + gt[49] + gt[50]; + m_A18 = m_A18 + go[48]; + m_A17 = m_A17 + go[49]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] - go[50] * *cnV[50]; + m_A26 = gt[56] + gt[57] + gt[58]; + m_A24 = m_A24 + go[56]; + m_A23 = m_A23 + go[57]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] - go[58] * *cnV[58]; + m_A33 = gt[64] + gt[65] + gt[66]; + m_A30 = m_A30 + go[64]; + m_A29 = m_A29 + go[65]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] - go[66] * *cnV[66]; + m_A40 = gt[72] + gt[73] + gt[74] + gt[75]; + m_A36 = m_A36 + go[72]; + m_A35 = m_A35 + go[73]; + double RHS9 = Idr[72] + Idr[73] + Idr[74] + Idr[75] - go[74] * *cnV[74] - go[75] * *cnV[75]; + m_A45 = gt[80] + gt[81] + gt[82] + gt[83] + gt[84] + gt[85] + gt[86] + gt[87]; + m_A43 = m_A43 + go[80]; + m_A43 = m_A43 + go[81]; + m_A42 = m_A42 + go[82]; + m_A42 = m_A42 + go[83]; + double RHS10 = Idr[80] + Idr[81] + Idr[82] + Idr[83] + Idr[84] + Idr[85] + Idr[86] + Idr[87] - go[84] * *cnV[84] - go[85] * *cnV[85] - go[86] * *cnV[86] - go[87] * *cnV[87]; + m_A49 = gt[88] + gt[89]; + m_A47 = m_A47 + go[88]; + double RHS11 = Idr[88] + Idr[89] - go[89] * *cnV[89]; +const double f0 = 1.0 / m_A0; + const double f0_8 = -f0 * m_A29; + m_A33 += m_A1 * f0_8; + RHS8 += f0_8 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_7 = -f1 * m_A23; + m_A26 += m_A3 * f1_7; + RHS7 += f1_7 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_6 = -f2 * m_A17; + m_A19 += m_A5 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_6 = -f3 * m_A18; + m_A19 += m_A7 * f3_6; + m_A20 += m_A8 * f3_6; + m_A21 += m_A9 * f3_6; + m_A22 += m_A10 * f3_6; + RHS6 += f3_6 * RHS3; + const double f3_7 = -f3 * m_A24; + m_A25 += m_A7 * f3_7; + m_A26 += m_A8 * f3_7; + m_A27 += m_A9 * f3_7; + m_A28 += m_A10 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_8 = -f3 * m_A30; + m_A31 += m_A7 * f3_8; + m_A32 += m_A8 * f3_8; + m_A33 += m_A9 * f3_8; + m_A34 += m_A10 * f3_8; + RHS8 += f3_8 * RHS3; + const double f3_9 = -f3 * m_A35; + m_A37 += m_A7 * f3_9; + m_A38 += m_A8 * f3_9; + m_A39 += m_A9 * f3_9; + m_A40 += m_A10 * f3_9; + RHS9 += f3_9 * RHS3; +const double f4 = 1.0 / m_A11; + const double f4_9 = -f4 * m_A36; + m_A40 += m_A12 * f4_9; + m_A41 += m_A13 * f4_9; + RHS9 += f4_9 * RHS4; + const double f4_10 = -f4 * m_A42; + m_A44 += m_A12 * f4_10; + m_A45 += m_A13 * f4_10; + RHS10 += f4_10 * RHS4; +const double f5 = 1.0 / m_A14; + const double f5_10 = -f5 * m_A43; + m_A45 += m_A15 * f5_10; + m_A46 += m_A16 * f5_10; + RHS10 += f5_10 * RHS5; + const double f5_11 = -f5 * m_A47; + m_A48 += m_A15 * f5_11; + m_A49 += m_A16 * f5_11; + RHS11 += f5_11 * RHS5; +const double f6 = 1.0 / m_A19; + const double f6_7 = -f6 * m_A25; + m_A26 += m_A20 * f6_7; + m_A27 += m_A21 * f6_7; + m_A28 += m_A22 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_8 = -f6 * m_A31; + m_A32 += m_A20 * f6_8; + m_A33 += m_A21 * f6_8; + m_A34 += m_A22 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_9 = -f6 * m_A37; + m_A38 += m_A20 * f6_9; + m_A39 += m_A21 * f6_9; + m_A40 += m_A22 * f6_9; + RHS9 += f6_9 * RHS6; +const double f7 = 1.0 / m_A26; + const double f7_8 = -f7 * m_A32; + m_A33 += m_A27 * f7_8; + m_A34 += m_A28 * f7_8; + RHS8 += f7_8 * RHS7; + const double f7_9 = -f7 * m_A38; + m_A39 += m_A27 * f7_9; + m_A40 += m_A28 * f7_9; + RHS9 += f7_9 * RHS7; +const double f8 = 1.0 / m_A33; + const double f8_9 = -f8 * m_A39; + m_A40 += m_A34 * f8_9; + RHS9 += f8_9 * RHS8; +const double f9 = 1.0 / m_A40; + const double f9_10 = -f9 * m_A44; + m_A45 += m_A41 * f9_10; + RHS10 += f9_10 * RHS9; +const double f10 = 1.0 / m_A45; + const double f10_11 = -f10 * m_A48; + m_A49 += m_A46 * f10_11; + RHS11 += f10_11 * RHS10; + V[11] = RHS11 / m_A49; + double tmp10 = 0.0; + tmp10 += m_A46 * V[11]; + V[10] = (RHS10 - tmp10) / m_A45; + double tmp9 = 0.0; + tmp9 += m_A41 * V[10]; + V[9] = (RHS9 - tmp9) / m_A40; + double tmp8 = 0.0; + tmp8 += m_A34 * V[9]; + V[8] = (RHS8 - tmp8) / m_A33; + double tmp7 = 0.0; + tmp7 += m_A27 * V[8]; + tmp7 += m_A28 * V[9]; + V[7] = (RHS7 - tmp7) / m_A26; + double tmp6 = 0.0; + tmp6 += m_A20 * V[7]; + tmp6 += m_A21 * V[8]; + tmp6 += m_A22 * V[9]; + V[6] = (RHS6 - tmp6) / m_A19; + double tmp5 = 0.0; + tmp5 += m_A15 * V[10]; + tmp5 += m_A16 * V[11]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A12 * V[9]; + tmp4 += m_A13 * V[10]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A7 * V[6]; + tmp3 += m_A8 * V[7]; + tmp3 += m_A9 * V[8]; + tmp3 += m_A10 * V[9]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[6]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[7]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[8]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_7a4e8b4f388d66d7_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A6 = gt[8] + gt[9]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_7b1592d23e41ce56_37(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A2 = m_A2 + go[0]; + m_A2 = m_A2 + go[1]; + m_A1 = m_A1 + go[2]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[3] * *cnV[3]; + m_A3 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[10] * *cnV[10]; + m_A6 = gt[16] + gt[17] + gt[18] + gt[19]; + m_A7 = m_A7 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] - go[17] * *cnV[17] - go[18] * *cnV[18] - go[19] * *cnV[19]; + m_A8 = gt[24] + gt[25] + gt[26] + gt[27]; + m_A11 = m_A11 + go[24]; + m_A9 = m_A9 + go[25]; + m_A10 = m_A10 + go[26]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] - go[27] * *cnV[27]; + m_A14 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36] + gt[37] + gt[38]; + m_A13 = m_A13 + go[32]; + m_A16 = m_A16 + go[33]; + m_A16 = m_A16 + go[34]; + m_A16 = m_A16 + go[35]; + m_A12 = m_A12 + go[36]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] + Idr[37] + Idr[38] - go[37] * *cnV[37] - go[38] * *cnV[38]; + m_A20 = gt[40] + gt[41] + gt[42]; + m_A17 = m_A17 + go[40]; + m_A18 = m_A18 + go[41]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[42] * *cnV[42]; + m_A24 = gt[48] + gt[49] + gt[50]; + m_A25 = m_A25 + go[48]; + m_A23 = m_A23 + go[49]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] - go[50] * *cnV[50]; + m_A30 = gt[56] + gt[57] + gt[58] + gt[59] + gt[60] + gt[61]; + m_A27 = m_A27 + go[56]; + m_A28 = m_A28 + go[57]; + m_A28 = m_A28 + go[58]; + m_A28 = m_A28 + go[59]; + m_A26 = m_A26 + go[60]; + m_A26 = m_A26 + go[61]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] + Idr[60] + Idr[61]; + m_A36 = gt[64] + gt[65]; + m_A34 = m_A34 + go[64]; + m_A32 = m_A32 + go[65]; + double RHS8 = Idr[64] + Idr[65]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A12; + m_A14 += m_A1 * f0_4; + m_A16 += m_A2 * f0_4; + RHS4 += f0_4 * RHS0; + const double f0_7 = -f0 * m_A26; + m_A28 += m_A1 * f0_7; + m_A30 += m_A2 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_4 = -f1 * m_A13; + m_A14 += m_A4 * f1_4; + m_A15 += m_A5 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A17; + m_A19 += m_A4 * f1_5; + m_A20 += m_A5 * f1_5; + RHS5 += f1_5 * RHS1; +const double f2 = 1.0 / m_A6; + const double f2_6 = -f2 * m_A23; + m_A24 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A8; + const double f3_5 = -f3 * m_A18; + m_A20 += m_A9 * f3_5; + m_A21 += m_A10 * f3_5; + m_A22 += m_A11 * f3_5; + RHS5 += f3_5 * RHS3; + const double f3_7 = -f3 * m_A27; + m_A29 += m_A9 * f3_7; + m_A30 += m_A10 * f3_7; + m_A31 += m_A11 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_8 = -f3 * m_A32; + m_A33 += m_A9 * f3_8; + m_A35 += m_A10 * f3_8; + m_A36 += m_A11 * f3_8; + RHS8 += f3_8 * RHS3; +const double f4 = 1.0 / m_A14; + const double f4_5 = -f4 * m_A19; + m_A20 += m_A15 * f4_5; + m_A21 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + const double f4_7 = -f4 * m_A28; + m_A29 += m_A15 * f4_7; + m_A30 += m_A16 * f4_7; + RHS7 += f4_7 * RHS4; +const double f5 = 1.0 / m_A20; + const double f5_7 = -f5 * m_A29; + m_A30 += m_A21 * f5_7; + m_A31 += m_A22 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_8 = -f5 * m_A33; + m_A35 += m_A21 * f5_8; + m_A36 += m_A22 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A24; + const double f6_8 = -f6 * m_A34; + m_A36 += m_A25 * f6_8; + RHS8 += f6_8 * RHS6; +const double f7 = 1.0 / m_A30; + const double f7_8 = -f7 * m_A35; + m_A36 += m_A31 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A36; + double tmp7 = 0.0; + tmp7 += m_A31 * V[8]; + V[7] = (RHS7 - tmp7) / m_A30; + double tmp6 = 0.0; + tmp6 += m_A25 * V[8]; + V[6] = (RHS6 - tmp6) / m_A24; + double tmp5 = 0.0; + tmp5 += m_A21 * V[7]; + tmp5 += m_A22 * V[8]; + V[5] = (RHS5 - tmp5) / m_A20; + double tmp4 = 0.0; + tmp4 += m_A15 * V[5]; + tmp4 += m_A16 * V[7]; + V[4] = (RHS4 - tmp4) / m_A14; + double tmp3 = 0.0; + tmp3 += m_A9 * V[5]; + tmp3 += m_A10 * V[7]; + tmp3 += m_A11 * V[8]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A7 * V[6]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A4 * V[4]; + tmp1 += m_A5 * V[5]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + tmp0 += m_A2 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_7c58698d6a68f4a0_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A6 = gt[8] + gt[9] + gt[10] + gt[11]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] + Idr[11] - go[10] * *cnV[10] - go[11] * *cnV[11]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_7dbbdf7feecfa9bd_108(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); +double m_A90(0.0); +double m_A91(0.0); +double m_A92(0.0); +double m_A93(0.0); +double m_A94(0.0); +double m_A95(0.0); +double m_A96(0.0); +double m_A97(0.0); +double m_A98(0.0); +double m_A99(0.0); +double m_A100(0.0); +double m_A101(0.0); +double m_A102(0.0); +double m_A103(0.0); +double m_A104(0.0); +double m_A105(0.0); +double m_A106(0.0); +double m_A107(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[6] + gt[7]; + m_A3 = m_A3 + go[6]; + double RHS1 = Idr[6] + Idr[7] - go[7] * *cnV[7]; + m_A4 = gt[12] + gt[13]; + m_A5 = m_A5 + go[12]; + double RHS2 = Idr[12] + Idr[13] - go[13] * *cnV[13]; + m_A6 = gt[18] + gt[19]; + m_A7 = m_A7 + go[18]; + double RHS3 = Idr[18] + Idr[19] - go[19] * *cnV[19]; + m_A8 = gt[24] + gt[25]; + m_A9 = m_A9 + go[24]; + double RHS4 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A10 = gt[30] + gt[31] + gt[32] + gt[33]; + m_A11 = m_A11 + go[30]; + m_A12 = m_A12 + go[31]; + double RHS5 = Idr[30] + Idr[31] + Idr[32] + Idr[33] - go[32] * *cnV[32] - go[33] * *cnV[33]; + m_A13 = gt[36] + gt[37]; + m_A15 = m_A15 + go[36]; + m_A14 = m_A14 + go[37]; + double RHS6 = Idr[36] + Idr[37]; + m_A16 = gt[42] + gt[43]; + m_A18 = m_A18 + go[42]; + m_A17 = m_A17 + go[43]; + double RHS7 = Idr[42] + Idr[43]; + m_A20 = gt[48] + gt[49] + gt[50]; + m_A19 = m_A19 + go[48]; + m_A21 = m_A21 + go[49]; + double RHS8 = Idr[48] + Idr[49] + Idr[50] - go[50] * *cnV[50]; + m_A24 = gt[54] + gt[55] + gt[56]; + m_A23 = m_A23 + go[54]; + m_A25 = m_A25 + go[55]; + double RHS9 = Idr[54] + Idr[55] + Idr[56] - go[56] * *cnV[56]; + m_A28 = gt[60] + gt[61] + gt[62]; + m_A27 = m_A27 + go[60]; + m_A30 = m_A30 + go[61]; + double RHS10 = Idr[60] + Idr[61] + Idr[62] - go[62] * *cnV[62]; + m_A32 = gt[66] + gt[67] + gt[68]; + m_A31 = m_A31 + go[66]; + m_A33 = m_A33 + go[67]; + double RHS11 = Idr[66] + Idr[67] + Idr[68] - go[68] * *cnV[68]; + m_A35 = gt[72] + gt[73] + gt[74] + gt[75]; + m_A37 = m_A37 + go[72]; + m_A36 = m_A36 + go[73]; + double RHS12 = Idr[72] + Idr[73] + Idr[74] + Idr[75] - go[74] * *cnV[74] - go[75] * *cnV[75]; + m_A38 = gt[78] + gt[79] + gt[80]; + m_A40 = m_A40 + go[78]; + m_A39 = m_A39 + go[79]; + double RHS13 = Idr[78] + Idr[79] + Idr[80] - go[80] * *cnV[80]; + m_A41 = gt[84] + gt[85] + gt[86]; + m_A43 = m_A43 + go[84]; + m_A42 = m_A42 + go[85]; + double RHS14 = Idr[84] + Idr[85] + Idr[86] - go[86] * *cnV[86]; + m_A44 = gt[90] + gt[91] + gt[92]; + m_A46 = m_A46 + go[90]; + m_A45 = m_A45 + go[91]; + double RHS15 = Idr[90] + Idr[91] + Idr[92] - go[92] * *cnV[92]; + m_A49 = gt[96] + gt[97]; + m_A47 = m_A47 + go[96]; + m_A48 = m_A48 + go[97]; + double RHS16 = Idr[96] + Idr[97]; + m_A53 = gt[102] + gt[103]; + m_A51 = m_A51 + go[102]; + m_A52 = m_A52 + go[103]; + double RHS17 = Idr[102] + Idr[103]; + m_A56 = gt[108] + gt[109] + gt[110]; + m_A55 = m_A55 + go[108]; + m_A57 = m_A57 + go[109]; + double RHS18 = Idr[108] + Idr[109] + Idr[110] - go[110] * *cnV[110]; + m_A59 = gt[114] + gt[115]; + m_A58 = m_A58 + go[114]; + m_A60 = m_A60 + go[115]; + double RHS19 = Idr[114] + Idr[115]; + m_A62 = gt[120] + gt[121] + gt[122] + gt[123]; + m_A64 = m_A64 + go[120]; + m_A63 = m_A63 + go[121]; + m_A61 = m_A61 + go[122]; + double RHS20 = Idr[120] + Idr[121] + Idr[122] + Idr[123] - go[123] * *cnV[123]; + m_A67 = gt[126] + gt[127] + gt[128] + gt[129]; + m_A66 = m_A66 + go[126]; + m_A65 = m_A65 + go[127]; + m_A68 = m_A68 + go[128]; + double RHS21 = Idr[126] + Idr[127] + Idr[128] + Idr[129] - go[129] * *cnV[129]; + m_A70 = gt[132] + gt[133] + gt[134] + gt[135]; + m_A72 = m_A72 + go[132]; + m_A71 = m_A71 + go[133]; + m_A69 = m_A69 + go[134]; + double RHS22 = Idr[132] + Idr[133] + Idr[134] + Idr[135] - go[135] * *cnV[135]; + m_A77 = gt[138] + gt[139] + gt[140] + gt[141] + gt[142] + gt[143]; + m_A78 = m_A78 + go[138]; + m_A73 = m_A73 + go[139]; + m_A74 = m_A74 + go[140]; + m_A76 = m_A76 + go[141]; + double RHS23 = Idr[138] + Idr[139] + Idr[140] + Idr[141] + Idr[142] + Idr[143] - go[142] * *cnV[142] - go[143] * *cnV[143]; + m_A83 = gt[144] + gt[145] + gt[146] + gt[147] + gt[148] + gt[149]; + m_A84 = m_A84 + go[144]; + m_A79 = m_A79 + go[145]; + m_A80 = m_A80 + go[146]; + m_A82 = m_A82 + go[147]; + double RHS24 = Idr[144] + Idr[145] + Idr[146] + Idr[147] + Idr[148] + Idr[149] - go[148] * *cnV[148] - go[149] * *cnV[149]; + m_A89 = gt[150] + gt[151] + gt[152] + gt[153]; + m_A85 = m_A85 + go[150]; + m_A86 = m_A86 + go[151]; + m_A88 = m_A88 + go[152]; + m_A87 = m_A87 + go[153]; + double RHS25 = Idr[150] + Idr[151] + Idr[152] + Idr[153]; + m_A100 = gt[156] + gt[157] + gt[158] + gt[159] + gt[160] + gt[161]; + m_A98 = m_A98 + go[156]; + m_A91 = m_A91 + go[157]; + m_A92 = m_A92 + go[158]; + m_A93 = m_A93 + go[159]; + double RHS26 = Idr[156] + Idr[157] + Idr[158] + Idr[159] + Idr[160] + Idr[161] - go[160] * *cnV[160] - go[161] * *cnV[161]; + m_A107 = gt[162] + gt[163] + gt[164] + gt[165]; + m_A102 = m_A102 + go[162]; + m_A103 = m_A103 + go[163]; + m_A105 = m_A105 + go[164]; + m_A104 = m_A104 + go[165]; + double RHS27 = Idr[162] + Idr[163] + Idr[164] + Idr[165]; +const double f0 = 1.0 / m_A0; + const double f0_18 = -f0 * m_A55; + m_A56 += m_A1 * f0_18; + RHS18 += f0_18 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_16 = -f1 * m_A47; + m_A49 += m_A3 * f1_16; + RHS16 += f1_16 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_17 = -f2 * m_A51; + m_A53 += m_A5 * f2_17; + RHS17 += f2_17 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_22 = -f3 * m_A69; + m_A70 += m_A7 * f3_22; + RHS22 += f3_22 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_20 = -f4 * m_A61; + m_A62 += m_A9 * f4_20; + RHS20 += f4_20 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_21 = -f5 * m_A65; + m_A67 += m_A11 * f5_21; + m_A68 += m_A12 * f5_21; + RHS21 += f5_21 * RHS5; + const double f5_26 = -f5 * m_A91; + m_A98 += m_A11 * f5_26; + m_A100 += m_A12 * f5_26; + RHS26 += f5_26 * RHS5; +const double f6 = 1.0 / m_A13; + const double f6_8 = -f6 * m_A19; + m_A20 += m_A14 * f6_8; + m_A22 += m_A15 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_26 = -f6 * m_A92; + m_A94 += m_A14 * f6_26; + m_A100 += m_A15 * f6_26; + RHS26 += f6_26 * RHS6; +const double f7 = 1.0 / m_A16; + const double f7_9 = -f7 * m_A23; + m_A24 += m_A17 * f7_9; + m_A26 += m_A18 * f7_9; + RHS9 += f7_9 * RHS7; + const double f7_26 = -f7 * m_A93; + m_A95 += m_A17 * f7_26; + m_A100 += m_A18 * f7_26; + RHS26 += f7_26 * RHS7; +const double f8 = 1.0 / m_A20; + const double f8_10 = -f8 * m_A27; + m_A28 += m_A21 * f8_10; + m_A29 += m_A22 * f8_10; + RHS10 += f8_10 * RHS8; + const double f8_26 = -f8 * m_A94; + m_A96 += m_A21 * f8_26; + m_A100 += m_A22 * f8_26; + RHS26 += f8_26 * RHS8; +const double f9 = 1.0 / m_A24; + const double f9_11 = -f9 * m_A31; + m_A32 += m_A25 * f9_11; + m_A34 += m_A26 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_26 = -f9 * m_A95; + m_A97 += m_A25 * f9_26; + m_A100 += m_A26 * f9_26; + RHS26 += f9_26 * RHS9; +const double f10 = 1.0 / m_A28; + const double f10_26 = -f10 * m_A96; + m_A100 += m_A29 * f10_26; + m_A101 += m_A30 * f10_26; + RHS26 += f10_26 * RHS10; + const double f10_27 = -f10 * m_A102; + m_A106 += m_A29 * f10_27; + m_A107 += m_A30 * f10_27; + RHS27 += f10_27 * RHS10; +const double f11 = 1.0 / m_A32; + const double f11_25 = -f11 * m_A85; + m_A89 += m_A33 * f11_25; + m_A90 += m_A34 * f11_25; + RHS25 += f11_25 * RHS11; + const double f11_26 = -f11 * m_A97; + m_A99 += m_A33 * f11_26; + m_A100 += m_A34 * f11_26; + RHS26 += f11_26 * RHS11; +const double f12 = 1.0 / m_A35; + const double f12_23 = -f12 * m_A73; + m_A77 += m_A36 * f12_23; + m_A78 += m_A37 * f12_23; + RHS23 += f12_23 * RHS12; + const double f12_27 = -f12 * m_A103; + m_A105 += m_A36 * f12_27; + m_A107 += m_A37 * f12_27; + RHS27 += f12_27 * RHS12; +const double f13 = 1.0 / m_A38; + const double f13_24 = -f13 * m_A79; + m_A83 += m_A39 * f13_24; + m_A84 += m_A40 * f13_24; + RHS24 += f13_24 * RHS13; + const double f13_25 = -f13 * m_A86; + m_A88 += m_A39 * f13_25; + m_A89 += m_A40 * f13_25; + RHS25 += f13_25 * RHS13; +const double f14 = 1.0 / m_A41; + const double f14_16 = -f14 * m_A48; + m_A49 += m_A42 * f14_16; + m_A50 += m_A43 * f14_16; + RHS16 += f14_16 * RHS14; + const double f14_23 = -f14 * m_A74; + m_A75 += m_A42 * f14_23; + m_A77 += m_A43 * f14_23; + RHS23 += f14_23 * RHS14; +const double f15 = 1.0 / m_A44; + const double f15_17 = -f15 * m_A52; + m_A53 += m_A45 * f15_17; + m_A54 += m_A46 * f15_17; + RHS17 += f15_17 * RHS15; + const double f15_24 = -f15 * m_A80; + m_A81 += m_A45 * f15_24; + m_A83 += m_A46 * f15_24; + RHS24 += f15_24 * RHS15; +const double f16 = 1.0 / m_A49; + const double f16_23 = -f16 * m_A75; + m_A77 += m_A50 * f16_23; + RHS23 += f16_23 * RHS16; +const double f17 = 1.0 / m_A53; + const double f17_24 = -f17 * m_A81; + m_A83 += m_A54 * f17_24; + RHS24 += f17_24 * RHS17; +const double f18 = 1.0 / m_A56; + const double f18_19 = -f18 * m_A58; + m_A59 += m_A57 * f18_19; + RHS19 += f18_19 * RHS18; +const double f19 = 1.0 / m_A59; + const double f19_21 = -f19 * m_A66; + m_A67 += m_A60 * f19_21; + RHS21 += f19_21 * RHS19; +const double f20 = 1.0 / m_A62; + const double f20_24 = -f20 * m_A82; + m_A83 += m_A63 * f20_24; + m_A84 += m_A64 * f20_24; + RHS24 += f20_24 * RHS20; + const double f20_25 = -f20 * m_A87; + m_A88 += m_A63 * f20_25; + m_A89 += m_A64 * f20_25; + RHS25 += f20_25 * RHS20; +const double f21 = 1.0 / m_A67; + const double f21_26 = -f21 * m_A98; + m_A100 += m_A68 * f21_26; + RHS26 += f21_26 * RHS21; +const double f22 = 1.0 / m_A70; + const double f22_23 = -f22 * m_A76; + m_A77 += m_A71 * f22_23; + m_A78 += m_A72 * f22_23; + RHS23 += f22_23 * RHS22; + const double f22_27 = -f22 * m_A104; + m_A105 += m_A71 * f22_27; + m_A107 += m_A72 * f22_27; + RHS27 += f22_27 * RHS22; +const double f23 = 1.0 / m_A77; + const double f23_27 = -f23 * m_A105; + m_A107 += m_A78 * f23_27; + RHS27 += f23_27 * RHS23; +const double f24 = 1.0 / m_A83; + const double f24_25 = -f24 * m_A88; + m_A89 += m_A84 * f24_25; + RHS25 += f24_25 * RHS24; +const double f25 = 1.0 / m_A89; + const double f25_26 = -f25 * m_A99; + m_A100 += m_A90 * f25_26; + RHS26 += f25_26 * RHS25; +const double f26 = 1.0 / m_A100; + const double f26_27 = -f26 * m_A106; + m_A107 += m_A101 * f26_27; + RHS27 += f26_27 * RHS26; + V[27] = RHS27 / m_A107; + double tmp26 = 0.0; + tmp26 += m_A101 * V[27]; + V[26] = (RHS26 - tmp26) / m_A100; + double tmp25 = 0.0; + tmp25 += m_A90 * V[26]; + V[25] = (RHS25 - tmp25) / m_A89; + double tmp24 = 0.0; + tmp24 += m_A84 * V[25]; + V[24] = (RHS24 - tmp24) / m_A83; + double tmp23 = 0.0; + tmp23 += m_A78 * V[27]; + V[23] = (RHS23 - tmp23) / m_A77; + double tmp22 = 0.0; + tmp22 += m_A71 * V[23]; + tmp22 += m_A72 * V[27]; + V[22] = (RHS22 - tmp22) / m_A70; + double tmp21 = 0.0; + tmp21 += m_A68 * V[26]; + V[21] = (RHS21 - tmp21) / m_A67; + double tmp20 = 0.0; + tmp20 += m_A63 * V[24]; + tmp20 += m_A64 * V[25]; + V[20] = (RHS20 - tmp20) / m_A62; + double tmp19 = 0.0; + tmp19 += m_A60 * V[21]; + V[19] = (RHS19 - tmp19) / m_A59; + double tmp18 = 0.0; + tmp18 += m_A57 * V[19]; + V[18] = (RHS18 - tmp18) / m_A56; + double tmp17 = 0.0; + tmp17 += m_A54 * V[24]; + V[17] = (RHS17 - tmp17) / m_A53; + double tmp16 = 0.0; + tmp16 += m_A50 * V[23]; + V[16] = (RHS16 - tmp16) / m_A49; + double tmp15 = 0.0; + tmp15 += m_A45 * V[17]; + tmp15 += m_A46 * V[24]; + V[15] = (RHS15 - tmp15) / m_A44; + double tmp14 = 0.0; + tmp14 += m_A42 * V[16]; + tmp14 += m_A43 * V[23]; + V[14] = (RHS14 - tmp14) / m_A41; + double tmp13 = 0.0; + tmp13 += m_A39 * V[24]; + tmp13 += m_A40 * V[25]; + V[13] = (RHS13 - tmp13) / m_A38; + double tmp12 = 0.0; + tmp12 += m_A36 * V[23]; + tmp12 += m_A37 * V[27]; + V[12] = (RHS12 - tmp12) / m_A35; + double tmp11 = 0.0; + tmp11 += m_A33 * V[25]; + tmp11 += m_A34 * V[26]; + V[11] = (RHS11 - tmp11) / m_A32; + double tmp10 = 0.0; + tmp10 += m_A29 * V[26]; + tmp10 += m_A30 * V[27]; + V[10] = (RHS10 - tmp10) / m_A28; + double tmp9 = 0.0; + tmp9 += m_A25 * V[11]; + tmp9 += m_A26 * V[26]; + V[9] = (RHS9 - tmp9) / m_A24; + double tmp8 = 0.0; + tmp8 += m_A21 * V[10]; + tmp8 += m_A22 * V[26]; + V[8] = (RHS8 - tmp8) / m_A20; + double tmp7 = 0.0; + tmp7 += m_A17 * V[9]; + tmp7 += m_A18 * V[26]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A14 * V[8]; + tmp6 += m_A15 * V[26]; + V[6] = (RHS6 - tmp6) / m_A13; + double tmp5 = 0.0; + tmp5 += m_A11 * V[21]; + tmp5 += m_A12 * V[26]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[20]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[22]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[17]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[16]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[18]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_7f2f6447ea71d31e_49(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] - go[17] * *cnV[17]; + m_A6 = gt[24] + gt[25]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A8 = gt[32] + gt[33]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] - go[33] * *cnV[33]; + m_A10 = gt[40] + gt[41]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A12 = gt[48] + gt[49]; + m_A13 = m_A13 + go[48]; + double RHS6 = Idr[48] + Idr[49] - go[49] * *cnV[49]; + m_A14 = gt[56] + gt[57]; + m_A15 = m_A15 + go[56]; + double RHS7 = Idr[56] + Idr[57] - go[57] * *cnV[57]; + m_A16 = gt[64] + gt[65] + gt[66] + gt[67] + gt[68] + gt[69] + gt[70]; + m_A17 = m_A17 + go[64]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] + Idr[67] + Idr[68] + Idr[69] + Idr[70] - go[65] * *cnV[65] - go[66] * *cnV[66] - go[67] * *cnV[67] - go[68] * *cnV[68] - go[69] * *cnV[69] - go[70] * *cnV[70]; + m_A18 = gt[72] + gt[73]; + m_A19 = m_A19 + go[72]; + double RHS9 = Idr[72] + Idr[73] - go[73] * *cnV[73]; + m_A20 = gt[80] + gt[81]; + m_A21 = m_A21 + go[80]; + double RHS10 = Idr[80] + Idr[81] - go[81] * *cnV[81]; + m_A25 = gt[88] + gt[89] + gt[90] + gt[91]; + m_A26 = m_A26 + go[88]; + m_A24 = m_A24 + go[89]; + m_A23 = m_A23 + go[90]; + m_A22 = m_A22 + go[91]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91]; + m_A30 = gt[96] + gt[97] + gt[98] + gt[99]; + m_A31 = m_A31 + go[96]; + m_A29 = m_A29 + go[97]; + m_A28 = m_A28 + go[98]; + m_A27 = m_A27 + go[99]; + double RHS12 = Idr[96] + Idr[97] + Idr[98] + Idr[99]; + m_A35 = gt[104] + gt[105] + gt[106] + gt[107]; + m_A36 = m_A36 + go[104]; + m_A34 = m_A34 + go[105]; + m_A33 = m_A33 + go[106]; + m_A32 = m_A32 + go[107]; + double RHS13 = Idr[104] + Idr[105] + Idr[106] + Idr[107]; + m_A38 = gt[112] + gt[113] + gt[114]; + m_A37 = m_A37 + go[112]; + m_A39 = m_A39 + go[113]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] - go[114] * *cnV[114]; + m_A43 = gt[120] + gt[121] + gt[122] + gt[123] + gt[124]; + m_A44 = m_A44 + go[120]; + m_A42 = m_A42 + go[121]; + m_A41 = m_A41 + go[122]; + m_A40 = m_A40 + go[123]; + double RHS15 = Idr[120] + Idr[121] + Idr[122] + Idr[123] + Idr[124] - go[124] * *cnV[124]; + m_A48 = gt[128] + gt[129] + gt[130] + gt[131] + gt[132]; + m_A45 = m_A45 + go[128]; + m_A46 = m_A46 + go[129]; + m_A47 = m_A47 + go[130]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131] + Idr[132] - go[131] * *cnV[131] - go[132] * *cnV[132]; +const double f0 = 1.0 / m_A0; + const double f0_11 = -f0 * m_A22; + m_A25 += m_A1 * f0_11; + RHS11 += f0_11 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_11 = -f1 * m_A23; + m_A25 += m_A3 * f1_11; + RHS11 += f1_11 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_11 = -f2 * m_A24; + m_A25 += m_A5 * f2_11; + RHS11 += f2_11 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_12 = -f3 * m_A27; + m_A30 += m_A7 * f3_12; + RHS12 += f3_12 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_12 = -f4 * m_A28; + m_A30 += m_A9 * f4_12; + RHS12 += f4_12 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_12 = -f5 * m_A29; + m_A30 += m_A11 * f5_12; + RHS12 += f5_12 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_13 = -f6 * m_A32; + m_A35 += m_A13 * f6_13; + RHS13 += f6_13 * RHS6; +const double f7 = 1.0 / m_A14; + const double f7_13 = -f7 * m_A33; + m_A35 += m_A15 * f7_13; + RHS13 += f7_13 * RHS7; +const double f8 = 1.0 / m_A16; + const double f8_16 = -f8 * m_A45; + m_A47 += m_A17 * f8_16; + RHS16 += f8_16 * RHS8; +const double f9 = 1.0 / m_A18; + const double f9_13 = -f9 * m_A34; + m_A35 += m_A19 * f9_13; + RHS13 += f9_13 * RHS9; +const double f10 = 1.0 / m_A20; + const double f10_14 = -f10 * m_A37; + m_A38 += m_A21 * f10_14; + RHS14 += f10_14 * RHS10; +const double f11 = 1.0 / m_A25; + const double f11_15 = -f11 * m_A40; + m_A43 += m_A26 * f11_15; + RHS15 += f11_15 * RHS11; +const double f12 = 1.0 / m_A30; + const double f12_15 = -f12 * m_A41; + m_A43 += m_A31 * f12_15; + RHS15 += f12_15 * RHS12; +const double f13 = 1.0 / m_A35; + const double f13_15 = -f13 * m_A42; + m_A43 += m_A36 * f13_15; + RHS15 += f13_15 * RHS13; +const double f14 = 1.0 / m_A38; + const double f14_16 = -f14 * m_A46; + m_A48 += m_A39 * f14_16; + RHS16 += f14_16 * RHS14; +const double f15 = 1.0 / m_A43; + const double f15_16 = -f15 * m_A47; + m_A48 += m_A44 * f15_16; + RHS16 += f15_16 * RHS15; + V[16] = RHS16 / m_A48; + double tmp15 = 0.0; + tmp15 += m_A44 * V[16]; + V[15] = (RHS15 - tmp15) / m_A43; + double tmp14 = 0.0; + tmp14 += m_A39 * V[16]; + V[14] = (RHS14 - tmp14) / m_A38; + double tmp13 = 0.0; + tmp13 += m_A36 * V[15]; + V[13] = (RHS13 - tmp13) / m_A35; + double tmp12 = 0.0; + tmp12 += m_A31 * V[15]; + V[12] = (RHS12 - tmp12) / m_A30; + double tmp11 = 0.0; + tmp11 += m_A26 * V[15]; + V[11] = (RHS11 - tmp11) / m_A25; + double tmp10 = 0.0; + tmp10 += m_A21 * V[14]; + V[10] = (RHS10 - tmp10) / m_A20; + double tmp9 = 0.0; + tmp9 += m_A19 * V[13]; + V[9] = (RHS9 - tmp9) / m_A18; + double tmp8 = 0.0; + tmp8 += m_A17 * V[15]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[13]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[13]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[12]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[12]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[12]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[11]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[11]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[11]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_81bfac76b696d9f3_22(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[6] + gt[7] + gt[8] + gt[9]; + m_A4 = m_A4 + go[6]; + m_A3 = m_A3 + go[7]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[6] + Idr[7] + Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A5 = gt[12] + gt[13] + gt[14] + gt[15]; + m_A7 = m_A7 + go[12]; + m_A6 = m_A6 + go[13]; + m_A6 = m_A6 + go[14]; + double RHS2 = Idr[12] + Idr[13] + Idr[14] + Idr[15] - go[15] * *cnV[15]; + m_A10 = gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A12 = m_A12 + go[18]; + m_A9 = m_A9 + go[19]; + m_A9 = m_A9 + go[20]; + m_A8 = m_A8 + go[21]; + m_A8 = m_A8 + go[22]; + double RHS3 = Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22]; + m_A16 = gt[24] + gt[25] + gt[26]; + m_A17 = m_A17 + go[24]; + m_A14 = m_A14 + go[25]; + m_A13 = m_A13 + go[26]; + double RHS4 = Idr[24] + Idr[25] + Idr[26]; + m_A21 = gt[30] + gt[31] + gt[32]; + m_A20 = m_A20 + go[30]; + m_A19 = m_A19 + go[31]; + m_A18 = m_A18 + go[32]; + double RHS5 = Idr[30] + Idr[31] + Idr[32]; +const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A18; + m_A21 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A8; + m_A10 += m_A3 * f1_3; + m_A11 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_4 = -f1 * m_A13; + m_A15 += m_A3 * f1_4; + m_A16 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A6 * f2_3; + m_A11 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A14; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; +const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A15; + m_A16 += m_A11 * f3_4; + m_A17 += m_A12 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_5 = -f3 * m_A19; + m_A20 += m_A11 * f3_5; + m_A21 += m_A12 * f3_5; + RHS5 += f3_5 * RHS3; +const double f4 = 1.0 / m_A16; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A17 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A21; + double tmp4 = 0.0; + tmp4 += m_A17 * V[5]; + V[4] = (RHS4 - tmp4) / m_A16; + double tmp3 = 0.0; + tmp3 += m_A11 * V[4]; + tmp3 += m_A12 * V[5]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A6 * V[3]; + tmp2 += m_A7 * V[4]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + tmp1 += m_A4 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_876240e48d904d1f_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5] + gt[6] + gt[7]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] + Idr[6] + Idr[7] - go[5] * *cnV[5] - go[6] * *cnV[6] - go[7] * *cnV[7]; + m_A6 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9] + Idr[10] - go[10] * *cnV[10]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_8e55e5f9e065890e_85(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] - go[17] * *cnV[17]; + m_A6 = gt[24] + gt[25]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A8 = gt[32] + gt[33]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] - go[33] * *cnV[33]; + m_A10 = gt[40] + gt[41]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A12 = gt[48] + gt[49]; + m_A13 = m_A13 + go[48]; + double RHS6 = Idr[48] + Idr[49] - go[49] * *cnV[49]; + m_A14 = gt[56] + gt[57]; + m_A15 = m_A15 + go[56]; + double RHS7 = Idr[56] + Idr[57] - go[57] * *cnV[57]; + m_A16 = gt[64] + gt[65]; + m_A17 = m_A17 + go[64]; + double RHS8 = Idr[64] + Idr[65] - go[65] * *cnV[65]; + m_A18 = gt[72] + gt[73]; + m_A19 = m_A19 + go[72]; + double RHS9 = Idr[72] + Idr[73] - go[73] * *cnV[73]; + m_A20 = gt[80] + gt[81]; + m_A21 = m_A21 + go[80]; + double RHS10 = Idr[80] + Idr[81] - go[81] * *cnV[81]; + m_A22 = gt[88] + gt[89]; + m_A23 = m_A23 + go[88]; + double RHS11 = Idr[88] + Idr[89] - go[89] * *cnV[89]; + m_A24 = gt[96] + gt[97]; + m_A25 = m_A25 + go[96]; + double RHS12 = Idr[96] + Idr[97] - go[97] * *cnV[97]; + m_A26 = gt[104] + gt[105] + gt[106] + gt[107] + gt[108] + gt[109] + gt[110]; + m_A27 = m_A27 + go[104]; + double RHS13 = Idr[104] + Idr[105] + Idr[106] + Idr[107] + Idr[108] + Idr[109] + Idr[110] - go[105] * *cnV[105] - go[106] * *cnV[106] - go[107] * *cnV[107] - go[108] * *cnV[108] - go[109] * *cnV[109] - go[110] * *cnV[110]; + m_A28 = gt[112] + gt[113]; + m_A29 = m_A29 + go[112]; + double RHS14 = Idr[112] + Idr[113] - go[113] * *cnV[113]; + m_A30 = gt[120] + gt[121]; + m_A31 = m_A31 + go[120]; + double RHS15 = Idr[120] + Idr[121] - go[121] * *cnV[121]; + m_A35 = gt[128] + gt[129] + gt[130] + gt[131]; + m_A36 = m_A36 + go[128]; + m_A34 = m_A34 + go[129]; + m_A33 = m_A33 + go[130]; + m_A32 = m_A32 + go[131]; + double RHS16 = Idr[128] + Idr[129] + Idr[130] + Idr[131]; + m_A37 = gt[136] + gt[137]; + m_A38 = m_A38 + go[136]; + double RHS17 = Idr[136] + Idr[137] - go[137] * *cnV[137]; + m_A39 = gt[144] + gt[145]; + m_A40 = m_A40 + go[144]; + double RHS18 = Idr[144] + Idr[145] - go[145] * *cnV[145]; + m_A41 = gt[152] + gt[153]; + m_A42 = m_A42 + go[152]; + double RHS19 = Idr[152] + Idr[153] - go[153] * *cnV[153]; + m_A43 = gt[160] + gt[161]; + m_A44 = m_A44 + go[160]; + double RHS20 = Idr[160] + Idr[161] - go[161] * *cnV[161]; + m_A46 = gt[168] + gt[169] + gt[170]; + m_A45 = m_A45 + go[168]; + m_A47 = m_A47 + go[169]; + double RHS21 = Idr[168] + Idr[169] + Idr[170] - go[170] * *cnV[170]; + m_A51 = gt[176] + gt[177] + gt[178] + gt[179]; + m_A52 = m_A52 + go[176]; + m_A50 = m_A50 + go[177]; + m_A49 = m_A49 + go[178]; + m_A48 = m_A48 + go[179]; + double RHS22 = Idr[176] + Idr[177] + Idr[178] + Idr[179]; + m_A56 = gt[184] + gt[185] + gt[186] + gt[187]; + m_A57 = m_A57 + go[184]; + m_A55 = m_A55 + go[185]; + m_A54 = m_A54 + go[186]; + m_A53 = m_A53 + go[187]; + double RHS23 = Idr[184] + Idr[185] + Idr[186] + Idr[187]; + m_A61 = gt[192] + gt[193] + gt[194] + gt[195]; + m_A62 = m_A62 + go[192]; + m_A60 = m_A60 + go[193]; + m_A59 = m_A59 + go[194]; + m_A58 = m_A58 + go[195]; + double RHS24 = Idr[192] + Idr[193] + Idr[194] + Idr[195]; + m_A66 = gt[200] + gt[201] + gt[202] + gt[203]; + m_A67 = m_A67 + go[200]; + m_A65 = m_A65 + go[201]; + m_A64 = m_A64 + go[202]; + m_A63 = m_A63 + go[203]; + double RHS25 = Idr[200] + Idr[201] + Idr[202] + Idr[203]; + m_A71 = gt[208] + gt[209] + gt[210] + gt[211]; + m_A72 = m_A72 + go[208]; + m_A70 = m_A70 + go[209]; + m_A69 = m_A69 + go[210]; + m_A68 = m_A68 + go[211]; + double RHS26 = Idr[208] + Idr[209] + Idr[210] + Idr[211]; + m_A75 = gt[216] + gt[217] + gt[218] + gt[219] + gt[220]; + m_A73 = m_A73 + go[216]; + m_A74 = m_A74 + go[217]; + m_A76 = m_A76 + go[218]; + double RHS27 = Idr[216] + Idr[217] + Idr[218] + Idr[219] + Idr[220] - go[219] * *cnV[219] - go[220] * *cnV[220]; + m_A84 = gt[224] + gt[225] + gt[226] + gt[227] + gt[228] + gt[229] + gt[230] + gt[231]; + m_A83 = m_A83 + go[224]; + m_A80 = m_A80 + go[225]; + m_A82 = m_A82 + go[226]; + m_A81 = m_A81 + go[227]; + m_A79 = m_A79 + go[228]; + m_A78 = m_A78 + go[229]; + m_A77 = m_A77 + go[230]; + double RHS28 = Idr[224] + Idr[225] + Idr[226] + Idr[227] + Idr[228] + Idr[229] + Idr[230] + Idr[231] - go[231] * *cnV[231]; +const double f0 = 1.0 / m_A0; + const double f0_16 = -f0 * m_A32; + m_A35 += m_A1 * f0_16; + RHS16 += f0_16 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_16 = -f1 * m_A33; + m_A35 += m_A3 * f1_16; + RHS16 += f1_16 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_16 = -f2 * m_A34; + m_A35 += m_A5 * f2_16; + RHS16 += f2_16 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_22 = -f3 * m_A48; + m_A51 += m_A7 * f3_22; + RHS22 += f3_22 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_22 = -f4 * m_A49; + m_A51 += m_A9 * f4_22; + RHS22 += f4_22 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_22 = -f5 * m_A50; + m_A51 += m_A11 * f5_22; + RHS22 += f5_22 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_23 = -f6 * m_A53; + m_A56 += m_A13 * f6_23; + RHS23 += f6_23 * RHS6; +const double f7 = 1.0 / m_A14; + const double f7_23 = -f7 * m_A54; + m_A56 += m_A15 * f7_23; + RHS23 += f7_23 * RHS7; +const double f8 = 1.0 / m_A16; + const double f8_23 = -f8 * m_A55; + m_A56 += m_A17 * f8_23; + RHS23 += f8_23 * RHS8; +const double f9 = 1.0 / m_A18; + const double f9_25 = -f9 * m_A63; + m_A66 += m_A19 * f9_25; + RHS25 += f9_25 * RHS9; +const double f10 = 1.0 / m_A20; + const double f10_26 = -f10 * m_A68; + m_A71 += m_A21 * f10_26; + RHS26 += f10_26 * RHS10; +const double f11 = 1.0 / m_A22; + const double f11_24 = -f11 * m_A58; + m_A61 += m_A23 * f11_24; + RHS24 += f11_24 * RHS11; +const double f12 = 1.0 / m_A24; + const double f12_24 = -f12 * m_A59; + m_A61 += m_A25 * f12_24; + RHS24 += f12_24 * RHS12; +const double f13 = 1.0 / m_A26; + const double f13_27 = -f13 * m_A73; + m_A76 += m_A27 * f13_27; + RHS27 += f13_27 * RHS13; +const double f14 = 1.0 / m_A28; + const double f14_24 = -f14 * m_A60; + m_A61 += m_A29 * f14_24; + RHS24 += f14_24 * RHS14; +const double f15 = 1.0 / m_A30; + const double f15_21 = -f15 * m_A45; + m_A46 += m_A31 * f15_21; + RHS21 += f15_21 * RHS15; +const double f16 = 1.0 / m_A35; + const double f16_28 = -f16 * m_A77; + m_A84 += m_A36 * f16_28; + RHS28 += f16_28 * RHS16; +const double f17 = 1.0 / m_A37; + const double f17_25 = -f17 * m_A64; + m_A66 += m_A38 * f17_25; + RHS25 += f17_25 * RHS17; +const double f18 = 1.0 / m_A39; + const double f18_25 = -f18 * m_A65; + m_A66 += m_A40 * f18_25; + RHS25 += f18_25 * RHS18; +const double f19 = 1.0 / m_A41; + const double f19_26 = -f19 * m_A69; + m_A71 += m_A42 * f19_26; + RHS26 += f19_26 * RHS19; +const double f20 = 1.0 / m_A43; + const double f20_26 = -f20 * m_A70; + m_A71 += m_A44 * f20_26; + RHS26 += f20_26 * RHS20; +const double f21 = 1.0 / m_A46; + const double f21_27 = -f21 * m_A74; + m_A75 += m_A47 * f21_27; + RHS27 += f21_27 * RHS21; +const double f22 = 1.0 / m_A51; + const double f22_28 = -f22 * m_A78; + m_A84 += m_A52 * f22_28; + RHS28 += f22_28 * RHS22; +const double f23 = 1.0 / m_A56; + const double f23_28 = -f23 * m_A79; + m_A84 += m_A57 * f23_28; + RHS28 += f23_28 * RHS23; +const double f24 = 1.0 / m_A61; + const double f24_28 = -f24 * m_A80; + m_A84 += m_A62 * f24_28; + RHS28 += f24_28 * RHS24; +const double f25 = 1.0 / m_A66; + const double f25_28 = -f25 * m_A81; + m_A84 += m_A67 * f25_28; + RHS28 += f25_28 * RHS25; +const double f26 = 1.0 / m_A71; + const double f26_28 = -f26 * m_A82; + m_A84 += m_A72 * f26_28; + RHS28 += f26_28 * RHS26; +const double f27 = 1.0 / m_A75; + const double f27_28 = -f27 * m_A83; + m_A84 += m_A76 * f27_28; + RHS28 += f27_28 * RHS27; + V[28] = RHS28 / m_A84; + double tmp27 = 0.0; + tmp27 += m_A76 * V[28]; + V[27] = (RHS27 - tmp27) / m_A75; + double tmp26 = 0.0; + tmp26 += m_A72 * V[28]; + V[26] = (RHS26 - tmp26) / m_A71; + double tmp25 = 0.0; + tmp25 += m_A67 * V[28]; + V[25] = (RHS25 - tmp25) / m_A66; + double tmp24 = 0.0; + tmp24 += m_A62 * V[28]; + V[24] = (RHS24 - tmp24) / m_A61; + double tmp23 = 0.0; + tmp23 += m_A57 * V[28]; + V[23] = (RHS23 - tmp23) / m_A56; + double tmp22 = 0.0; + tmp22 += m_A52 * V[28]; + V[22] = (RHS22 - tmp22) / m_A51; + double tmp21 = 0.0; + tmp21 += m_A47 * V[27]; + V[21] = (RHS21 - tmp21) / m_A46; + double tmp20 = 0.0; + tmp20 += m_A44 * V[26]; + V[20] = (RHS20 - tmp20) / m_A43; + double tmp19 = 0.0; + tmp19 += m_A42 * V[26]; + V[19] = (RHS19 - tmp19) / m_A41; + double tmp18 = 0.0; + tmp18 += m_A40 * V[25]; + V[18] = (RHS18 - tmp18) / m_A39; + double tmp17 = 0.0; + tmp17 += m_A38 * V[25]; + V[17] = (RHS17 - tmp17) / m_A37; + double tmp16 = 0.0; + tmp16 += m_A36 * V[28]; + V[16] = (RHS16 - tmp16) / m_A35; + double tmp15 = 0.0; + tmp15 += m_A31 * V[21]; + V[15] = (RHS15 - tmp15) / m_A30; + double tmp14 = 0.0; + tmp14 += m_A29 * V[24]; + V[14] = (RHS14 - tmp14) / m_A28; + double tmp13 = 0.0; + tmp13 += m_A27 * V[28]; + V[13] = (RHS13 - tmp13) / m_A26; + double tmp12 = 0.0; + tmp12 += m_A25 * V[24]; + V[12] = (RHS12 - tmp12) / m_A24; + double tmp11 = 0.0; + tmp11 += m_A23 * V[24]; + V[11] = (RHS11 - tmp11) / m_A22; + double tmp10 = 0.0; + tmp10 += m_A21 * V[26]; + V[10] = (RHS10 - tmp10) / m_A20; + double tmp9 = 0.0; + tmp9 += m_A19 * V[25]; + 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[23]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[23]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[22]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[22]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[22]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[16]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[16]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[16]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_92523d559b657838_175(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); +double m_A90(0.0); +double m_A91(0.0); +double m_A92(0.0); +double m_A93(0.0); +double m_A94(0.0); +double m_A95(0.0); +double m_A96(0.0); +double m_A97(0.0); +double m_A98(0.0); +double m_A99(0.0); +double m_A100(0.0); +double m_A101(0.0); +double m_A102(0.0); +double m_A103(0.0); +double m_A104(0.0); +double m_A105(0.0); +double m_A106(0.0); +double m_A107(0.0); +double m_A108(0.0); +double m_A109(0.0); +double m_A110(0.0); +double m_A111(0.0); +double m_A112(0.0); +double m_A113(0.0); +double m_A114(0.0); +double m_A115(0.0); +double m_A116(0.0); +double m_A117(0.0); +double m_A118(0.0); +double m_A119(0.0); +double m_A120(0.0); +double m_A121(0.0); +double m_A122(0.0); +double m_A123(0.0); +double m_A124(0.0); +double m_A125(0.0); +double m_A126(0.0); +double m_A127(0.0); +double m_A128(0.0); +double m_A129(0.0); +double m_A130(0.0); +double m_A131(0.0); +double m_A132(0.0); +double m_A133(0.0); +double m_A134(0.0); +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); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[10] + gt[11]; + m_A3 = m_A3 + go[10]; + double RHS1 = Idr[10] + Idr[11] - go[11] * *cnV[11]; + m_A4 = gt[20] + gt[21]; + m_A6 = m_A6 + go[20]; + m_A5 = m_A5 + go[21]; + double RHS2 = Idr[20] + Idr[21]; + m_A7 = gt[30] + gt[31] + gt[32] + gt[33] + gt[34]; + m_A8 = m_A8 + go[30]; + m_A9 = m_A9 + go[31]; + m_A9 = m_A9 + go[32]; + double RHS3 = Idr[30] + Idr[31] + Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A10 = gt[40] + gt[41]; + m_A11 = m_A11 + go[40]; + double RHS4 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A12 = gt[50] + gt[51]; + m_A13 = m_A13 + go[50]; + double RHS5 = Idr[50] + Idr[51] - go[51] * *cnV[51]; + m_A14 = gt[60] + gt[61]; + m_A15 = m_A15 + go[60]; + double RHS6 = Idr[60] + Idr[61] - go[61] * *cnV[61]; + m_A16 = gt[70] + gt[71]; + m_A17 = m_A17 + go[70]; + double RHS7 = Idr[70] + Idr[71] - go[71] * *cnV[71]; + m_A18 = gt[80] + gt[81]; + m_A19 = m_A19 + go[80]; + m_A20 = m_A20 + go[81]; + double RHS8 = Idr[80] + Idr[81]; + m_A21 = gt[90] + gt[91] + gt[92] + gt[93]; + m_A22 = m_A22 + go[90]; + m_A22 = m_A22 + go[91]; + double RHS9 = Idr[90] + Idr[91] + Idr[92] + Idr[93] - go[92] * *cnV[92] - go[93] * *cnV[93]; + m_A23 = gt[100] + gt[101] + gt[102] + gt[103]; + m_A24 = m_A24 + go[100]; + m_A24 = m_A24 + go[101]; + double RHS10 = Idr[100] + Idr[101] + Idr[102] + Idr[103] - go[102] * *cnV[102] - go[103] * *cnV[103]; + m_A25 = gt[110] + gt[111] + gt[112] + gt[113] + gt[114] + gt[115] + gt[116]; + m_A27 = m_A27 + go[110]; + m_A26 = m_A26 + go[111]; + m_A25 = m_A25 + go[112]; + m_A25 = m_A25 + go[113]; + double RHS11 = Idr[110] + Idr[111] + Idr[112] + Idr[113] + Idr[114] + Idr[115] + Idr[116] - go[114] * *cnV[114] - go[115] * *cnV[115] - go[116] * *cnV[116]; + m_A28 = gt[120] + gt[121] + gt[122]; + m_A29 = m_A29 + go[120]; + double RHS12 = Idr[120] + Idr[121] + Idr[122] - go[121] * *cnV[121] - go[122] * *cnV[122]; + m_A30 = gt[130] + gt[131] + gt[132] + gt[133]; + m_A31 = m_A31 + go[130]; + m_A31 = m_A31 + go[131]; + double RHS13 = Idr[130] + Idr[131] + Idr[132] + Idr[133] - go[132] * *cnV[132] - go[133] * *cnV[133]; + m_A32 = gt[140] + gt[141] + gt[142]; + m_A33 = m_A33 + go[140]; + double RHS14 = Idr[140] + Idr[141] + Idr[142] - go[141] * *cnV[141] - go[142] * *cnV[142]; + m_A34 = gt[150] + gt[151] + gt[152] + gt[153]; + m_A35 = m_A35 + go[150]; + double RHS15 = Idr[150] + Idr[151] + Idr[152] + Idr[153] - go[151] * *cnV[151] - go[152] * *cnV[152] - go[153] * *cnV[153]; + m_A36 = gt[160] + gt[161] + gt[162]; + m_A37 = m_A37 + go[160]; + double RHS16 = Idr[160] + Idr[161] + Idr[162] - go[161] * *cnV[161] - go[162] * *cnV[162]; + m_A38 = gt[170] + gt[171] + gt[172]; + m_A39 = m_A39 + go[170]; + double RHS17 = Idr[170] + Idr[171] + Idr[172] - go[171] * *cnV[171] - go[172] * *cnV[172]; + m_A40 = gt[180] + gt[181]; + m_A41 = m_A41 + go[180]; + double RHS18 = Idr[180] + Idr[181] - go[181] * *cnV[181]; + m_A42 = gt[190] + gt[191] + gt[192] + gt[193] + gt[194] + gt[195] + gt[196]; + m_A43 = m_A43 + go[190]; + m_A42 = m_A42 + go[191]; + m_A42 = m_A42 + go[192]; + double RHS19 = Idr[190] + Idr[191] + Idr[192] + Idr[193] + Idr[194] + Idr[195] + Idr[196] - go[193] * *cnV[193] - go[194] * *cnV[194] - go[195] * *cnV[195] - go[196] * *cnV[196]; + m_A44 = gt[200] + gt[201]; + m_A46 = m_A46 + go[200]; + m_A45 = m_A45 + go[201]; + double RHS20 = Idr[200] + Idr[201]; + m_A47 = gt[210] + gt[211] + gt[212] + gt[213] + gt[214]; + m_A49 = m_A49 + go[210]; + m_A49 = m_A49 + go[211]; + m_A48 = m_A48 + go[212]; + double RHS21 = Idr[210] + Idr[211] + Idr[212] + Idr[213] + Idr[214] - go[213] * *cnV[213] - go[214] * *cnV[214]; + m_A50 = gt[220] + gt[221] + gt[222] + gt[223] + gt[224]; + m_A51 = m_A51 + go[220]; + double RHS22 = Idr[220] + Idr[221] + Idr[222] + Idr[223] + Idr[224] - go[221] * *cnV[221] - go[222] * *cnV[222] - go[223] * *cnV[223] - go[224] * *cnV[224]; + m_A52 = gt[230] + gt[231]; + m_A53 = m_A53 + go[230]; + m_A54 = m_A54 + go[231]; + double RHS23 = Idr[230] + Idr[231]; + m_A55 = gt[240] + gt[241]; + m_A57 = m_A57 + go[240]; + m_A56 = m_A56 + go[241]; + double RHS24 = Idr[240] + Idr[241]; + m_A58 = gt[250] + gt[251] + gt[252] + gt[253]; + m_A59 = m_A59 + go[250]; + m_A59 = m_A59 + go[251]; + m_A60 = m_A60 + go[252]; + double RHS25 = Idr[250] + Idr[251] + Idr[252] + Idr[253] - go[253] * *cnV[253]; + m_A61 = gt[260] + gt[261]; + m_A63 = m_A63 + go[260]; + m_A62 = m_A62 + go[261]; + double RHS26 = Idr[260] + Idr[261]; + m_A64 = gt[270] + gt[271]; + m_A65 = m_A65 + go[270]; + m_A66 = m_A66 + go[271]; + double RHS27 = Idr[270] + Idr[271]; + m_A67 = gt[280] + gt[281]; + m_A69 = m_A69 + go[280]; + m_A68 = m_A68 + go[281]; + double RHS28 = Idr[280] + Idr[281]; + m_A73 = gt[290] + gt[291] + gt[292]; + m_A72 = m_A72 + go[290]; + m_A71 = m_A71 + go[291]; + m_A70 = m_A70 + go[292]; + double RHS29 = Idr[290] + Idr[291] + Idr[292]; + m_A82 = gt[300] + gt[301] + gt[302] + gt[303] + gt[304] + gt[305] + gt[306] + gt[307] + gt[308] + gt[309]; + m_A81 = m_A81 + go[300]; + m_A80 = m_A80 + go[301]; + m_A79 = m_A79 + go[302]; + m_A78 = m_A78 + go[303]; + m_A78 = m_A78 + go[304]; + m_A77 = m_A77 + go[305]; + m_A77 = m_A77 + go[306]; + m_A76 = m_A76 + go[307]; + m_A76 = m_A76 + go[308]; + m_A75 = m_A75 + go[309]; + double RHS30 = Idr[300] + Idr[301] + Idr[302] + Idr[303] + Idr[304] + Idr[305] + Idr[306] + Idr[307] + Idr[308] + Idr[309]; + m_A86 = gt[310] + gt[311]; + m_A85 = m_A85 + go[310]; + m_A84 = m_A84 + go[311]; + double RHS31 = Idr[310] + Idr[311]; + m_A90 = gt[320] + gt[321] + gt[322] + gt[323] + gt[324] + gt[325] + gt[326]; + m_A89 = m_A89 + go[320]; + m_A88 = m_A88 + go[321]; + double RHS32 = Idr[320] + Idr[321] + Idr[322] + Idr[323] + Idr[324] + Idr[325] + Idr[326] - go[322] * *cnV[322] - go[323] * *cnV[323] - go[324] * *cnV[324] - go[325] * *cnV[325] - go[326] * *cnV[326]; + m_A94 = gt[330] + gt[331]; + m_A95 = m_A95 + go[330]; + m_A92 = m_A92 + go[331]; + double RHS33 = Idr[330] + Idr[331]; + m_A97 = gt[340] + gt[341] + gt[342] + gt[343] + gt[344] + gt[345] + gt[346]; + m_A98 = m_A98 + go[340]; + m_A99 = m_A99 + go[341]; + m_A99 = m_A99 + go[342]; + m_A96 = m_A96 + go[343]; + double RHS34 = Idr[340] + Idr[341] + Idr[342] + Idr[343] + Idr[344] + Idr[345] + Idr[346] - go[344] * *cnV[344] - go[345] * *cnV[345] - go[346] * *cnV[346]; + m_A103 = gt[350] + gt[351] + gt[352] + gt[353] + gt[354] + gt[355] + gt[356]; + m_A105 = m_A105 + go[350]; + m_A105 = m_A105 + go[351]; + m_A101 = m_A101 + go[352]; + m_A104 = m_A104 + go[353]; + m_A100 = m_A100 + go[354]; + double RHS35 = Idr[350] + Idr[351] + Idr[352] + Idr[353] + Idr[354] + Idr[355] + Idr[356] - go[355] * *cnV[355] - go[356] * *cnV[356]; + m_A108 = gt[360] + gt[361] + gt[362] + gt[363] + gt[364]; + m_A106 = m_A106 + go[360]; + m_A107 = m_A107 + go[361]; + m_A107 = m_A107 + go[362]; + double RHS36 = Idr[360] + Idr[361] + Idr[362] + Idr[363] + Idr[364] - go[363] * *cnV[363] - go[364] * *cnV[364]; + m_A112 = gt[370] + gt[371] + gt[372]; + m_A111 = m_A111 + go[370]; + m_A110 = m_A110 + go[371]; + double RHS37 = Idr[370] + Idr[371] + Idr[372] - go[372] * *cnV[372]; + m_A118 = gt[380] + gt[381] + gt[382]; + m_A116 = m_A116 + go[380]; + m_A115 = m_A115 + go[381]; + double RHS38 = Idr[380] + Idr[381] + Idr[382] - go[382] * *cnV[382]; + m_A122 = gt[390] + gt[391] + gt[392]; + m_A123 = m_A123 + go[390]; + m_A120 = m_A120 + go[391]; + m_A124 = m_A124 + go[392]; + double RHS39 = Idr[390] + Idr[391] + Idr[392]; + m_A130 = gt[400] + gt[401] + gt[402] + gt[403]; + m_A127 = m_A127 + go[400]; + m_A126 = m_A126 + go[401]; + m_A125 = m_A125 + go[402]; + double RHS40 = Idr[400] + Idr[401] + Idr[402] + Idr[403] - go[403] * *cnV[403]; + m_A141 = gt[410] + gt[411] + gt[412] + gt[413] + gt[414] + gt[415] + gt[416]; + m_A136 = m_A136 + go[410]; + m_A135 = m_A135 + go[411]; + m_A134 = m_A134 + go[412]; + m_A133 = m_A133 + go[413]; + m_A137 = m_A137 + go[414]; + m_A138 = m_A138 + go[415]; + m_A140 = m_A140 + go[416]; + double RHS41 = Idr[410] + Idr[411] + Idr[412] + Idr[413] + Idr[414] + Idr[415] + Idr[416]; + m_A146 = gt[420] + gt[421] + gt[422]; + m_A143 = m_A143 + go[420]; + m_A144 = m_A144 + go[421]; + double RHS42 = Idr[420] + Idr[421] + Idr[422] - go[422] * *cnV[422]; + m_A153 = gt[430] + gt[431] + gt[432] + gt[433] + gt[434] + gt[435]; + m_A150 = m_A150 + go[430]; + m_A151 = m_A151 + go[431]; + m_A149 = m_A149 + go[432]; + m_A154 = m_A154 + go[433]; + double RHS43 = Idr[430] + Idr[431] + Idr[432] + Idr[433] + Idr[434] + Idr[435] - go[434] * *cnV[434] - go[435] * *cnV[435]; + m_A160 = gt[440] + gt[441] + gt[442] + gt[443] + gt[444] + gt[445] + gt[446] + gt[447] + gt[448]; + m_A157 = m_A157 + go[440]; + m_A159 = m_A159 + go[441]; + m_A156 = m_A156 + go[442]; + m_A156 = m_A156 + go[443]; + m_A155 = m_A155 + go[444]; + m_A155 = m_A155 + go[445]; + double RHS44 = Idr[440] + Idr[441] + Idr[442] + Idr[443] + Idr[444] + Idr[445] + Idr[446] + Idr[447] + Idr[448] - go[446] * *cnV[446] - go[447] * *cnV[447] - go[448] * *cnV[448]; + m_A164 = gt[450] + gt[451] + gt[452] + gt[453] + gt[454] + gt[455] + gt[456]; + m_A165 = m_A165 + go[450]; + m_A165 = m_A165 + go[451]; + m_A163 = m_A163 + go[452]; + m_A162 = m_A162 + go[453]; + double RHS45 = Idr[450] + Idr[451] + Idr[452] + Idr[453] + Idr[454] + Idr[455] + Idr[456] - go[454] * *cnV[454] - go[455] * *cnV[455] - go[456] * *cnV[456]; + m_A174 = gt[460] + gt[461] + gt[462] + gt[463] + gt[464] + gt[465] + gt[466] + gt[467] + gt[468] + gt[469]; + m_A167 = m_A167 + go[460]; + m_A168 = m_A168 + go[461]; + m_A168 = m_A168 + go[462]; + m_A173 = m_A173 + go[463]; + m_A173 = m_A173 + go[464]; + m_A166 = m_A166 + go[465]; + m_A166 = m_A166 + go[466]; + double RHS46 = Idr[460] + Idr[461] + Idr[462] + Idr[463] + Idr[464] + Idr[465] + Idr[466] + Idr[467] + Idr[468] + Idr[469] - go[467] * *cnV[467] - go[468] * *cnV[468] - go[469] * *cnV[469]; +const double f0 = 1.0 / m_A0; + const double f0_29 = -f0 * m_A70; + m_A73 += m_A1 * f0_29; + RHS29 += f0_29 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_29 = -f1 * m_A71; + m_A73 += m_A3 * f1_29; + RHS29 += f1_29 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_29 = -f2 * m_A72; + m_A73 += m_A5 * f2_29; + m_A74 += m_A6 * f2_29; + RHS29 += f2_29 * RHS2; + const double f2_33 = -f2 * m_A92; + m_A93 += m_A5 * f2_33; + m_A94 += m_A6 * f2_33; + RHS33 += f2_33 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_34 = -f3 * m_A96; + m_A97 += m_A8 * f3_34; + m_A99 += m_A9 * f3_34; + RHS34 += f3_34 * RHS3; + const double f3_44 = -f3 * m_A155; + m_A156 += m_A8 * f3_44; + m_A160 += m_A9 * f3_44; + RHS44 += f3_44 * RHS3; +const double f4 = 1.0 / m_A10; + const double f4_41 = -f4 * m_A133; + m_A141 += m_A11 * f4_41; + RHS41 += f4_41 * RHS4; +const double f5 = 1.0 / m_A12; + const double f5_41 = -f5 * m_A134; + m_A141 += m_A13 * f5_41; + RHS41 += f5_41 * RHS5; +const double f6 = 1.0 / m_A14; + const double f6_41 = -f6 * m_A135; + m_A141 += m_A15 * f6_41; + RHS41 += f6_41 * RHS6; +const double f7 = 1.0 / m_A16; + const double f7_41 = -f7 * m_A136; + m_A141 += m_A17 * f7_41; + RHS41 += f7_41 * RHS7; +const double f8 = 1.0 / m_A18; + const double f8_30 = -f8 * m_A75; + m_A82 += m_A19 * f8_30; + m_A83 += m_A20 * f8_30; + RHS30 += f8_30 * RHS8; + const double f8_41 = -f8 * m_A137; + m_A139 += m_A19 * f8_41; + m_A141 += m_A20 * f8_41; + RHS41 += f8_41 * RHS8; +const double f9 = 1.0 / m_A21; + const double f9_30 = -f9 * m_A76; + m_A82 += m_A22 * f9_30; + RHS30 += f9_30 * RHS9; +const double f10 = 1.0 / m_A23; + const double f10_30 = -f10 * m_A77; + m_A82 += m_A24 * f10_30; + RHS30 += f10_30 * RHS10; +const double f11 = 1.0 / m_A25; + const double f11_41 = -f11 * m_A138; + m_A141 += m_A26 * f11_41; + m_A142 += m_A27 * f11_41; + RHS41 += f11_41 * RHS11; + const double f11_43 = -f11 * m_A149; + m_A152 += m_A26 * f11_43; + m_A153 += m_A27 * f11_43; + RHS43 += f11_43 * RHS11; +const double f12 = 1.0 / m_A28; + const double f12_43 = -f12 * m_A150; + m_A153 += m_A29 * f12_43; + RHS43 += f12_43 * RHS12; +const double f13 = 1.0 / m_A30; + const double f13_30 = -f13 * m_A78; + m_A82 += m_A31 * f13_30; + RHS30 += f13_30 * RHS13; +const double f14 = 1.0 / m_A32; + const double f14_36 = -f14 * m_A106; + m_A108 += m_A33 * f14_36; + RHS36 += f14_36 * RHS14; +const double f15 = 1.0 / m_A34; + const double f15_31 = -f15 * m_A84; + m_A86 += m_A35 * f15_31; + RHS31 += f15_31 * RHS15; +const double f16 = 1.0 / m_A36; + const double f16_30 = -f16 * m_A79; + m_A82 += m_A37 * f16_30; + RHS30 += f16_30 * RHS16; +const double f17 = 1.0 / m_A38; + const double f17_30 = -f17 * m_A80; + m_A82 += m_A39 * f17_30; + RHS30 += f17_30 * RHS17; +const double f18 = 1.0 / m_A40; + const double f18_30 = -f18 * m_A81; + m_A82 += m_A41 * f18_30; + RHS30 += f18_30 * RHS18; +const double f19 = 1.0 / m_A42; + const double f19_35 = -f19 * m_A100; + m_A103 += m_A43 * f19_35; + RHS35 += f19_35 * RHS19; +const double f20 = 1.0 / m_A44; + const double f20_31 = -f20 * m_A85; + m_A86 += m_A45 * f20_31; + m_A87 += m_A46 * f20_31; + RHS31 += f20_31 * RHS20; + const double f20_35 = -f20 * m_A101; + m_A102 += m_A45 * f20_35; + m_A103 += m_A46 * f20_35; + RHS35 += f20_35 * RHS20; +const double f21 = 1.0 / m_A47; + const double f21_45 = -f21 * m_A162; + m_A164 += m_A48 * f21_45; + m_A165 += m_A49 * f21_45; + RHS45 += f21_45 * RHS21; + const double f21_46 = -f21 * m_A166; + m_A173 += m_A48 * f21_46; + m_A174 += m_A49 * f21_46; + RHS46 += f21_46 * RHS21; +const double f22 = 1.0 / m_A50; + const double f22_32 = -f22 * m_A88; + m_A90 += m_A51 * f22_32; + RHS32 += f22_32 * RHS22; +const double f23 = 1.0 / m_A52; + const double f23_37 = -f23 * m_A110; + m_A112 += m_A53 * f23_37; + m_A114 += m_A54 * f23_37; + RHS37 += f23_37 * RHS23; + const double f23_46 = -f23 * m_A167; + m_A169 += m_A53 * f23_46; + m_A174 += m_A54 * f23_46; + RHS46 += f23_46 * RHS23; +const double f24 = 1.0 / m_A55; + const double f24_32 = -f24 * m_A89; + m_A90 += m_A56 * f24_32; + m_A91 += m_A57 * f24_32; + RHS32 += f24_32 * RHS24; + const double f24_38 = -f24 * m_A115; + m_A117 += m_A56 * f24_38; + m_A118 += m_A57 * f24_38; + RHS38 += f24_38 * RHS24; +const double f25 = 1.0 / m_A58; + const double f25_36 = -f25 * m_A107; + m_A108 += m_A59 * f25_36; + m_A109 += m_A60 * f25_36; + RHS36 += f25_36 * RHS25; + const double f25_39 = -f25 * m_A120; + m_A121 += m_A59 * f25_39; + m_A122 += m_A60 * f25_39; + RHS39 += f25_39 * RHS25; +const double f26 = 1.0 / m_A61; + const double f26_37 = -f26 * m_A111; + m_A112 += m_A62 * f26_37; + m_A113 += m_A63 * f26_37; + RHS37 += f26_37 * RHS26; + const double f26_40 = -f26 * m_A125; + m_A128 += m_A62 * f26_40; + m_A130 += m_A63 * f26_40; + RHS40 += f26_40 * RHS26; +const double f27 = 1.0 / m_A64; + const double f27_38 = -f27 * m_A116; + m_A118 += m_A65 * f27_38; + m_A119 += m_A66 * f27_38; + RHS38 += f27_38 * RHS27; + const double f27_40 = -f27 * m_A126; + m_A129 += m_A65 * f27_40; + m_A130 += m_A66 * f27_40; + RHS40 += f27_40 * RHS27; +const double f28 = 1.0 / m_A67; + const double f28_40 = -f28 * m_A127; + m_A130 += m_A68 * f28_40; + m_A131 += m_A69 * f28_40; + RHS40 += f28_40 * RHS28; + const double f28_42 = -f28 * m_A143; + m_A145 += m_A68 * f28_42; + m_A146 += m_A69 * f28_42; + RHS42 += f28_42 * RHS28; +const double f29 = 1.0 / m_A73; + const double f29_33 = -f29 * m_A93; + m_A94 += m_A74 * f29_33; + RHS33 += f29_33 * RHS29; +const double f30 = 1.0 / m_A82; + const double f30_41 = -f30 * m_A139; + m_A141 += m_A83 * f30_41; + RHS41 += f30_41 * RHS30; +const double f31 = 1.0 / m_A86; + const double f31_35 = -f31 * m_A102; + m_A103 += m_A87 * f31_35; + RHS35 += f31_35 * RHS31; +const double f32 = 1.0 / m_A90; + const double f32_38 = -f32 * m_A117; + m_A118 += m_A91 * f32_38; + RHS38 += f32_38 * RHS32; +const double f33 = 1.0 / m_A94; + const double f33_41 = -f33 * m_A140; + m_A141 += m_A95 * f33_41; + RHS41 += f33_41 * RHS33; +const double f34 = 1.0 / m_A97; + const double f34_43 = -f34 * m_A151; + m_A153 += m_A98 * f34_43; + m_A154 += m_A99 * f34_43; + RHS43 += f34_43 * RHS34; + const double f34_44 = -f34 * m_A156; + m_A159 += m_A98 * f34_44; + m_A160 += m_A99 * f34_44; + RHS44 += f34_44 * RHS34; +const double f35 = 1.0 / m_A103; + const double f35_45 = -f35 * m_A163; + m_A164 += m_A104 * f35_45; + m_A165 += m_A105 * f35_45; + RHS45 += f35_45 * RHS35; + const double f35_46 = -f35 * m_A168; + m_A173 += m_A104 * f35_46; + m_A174 += m_A105 * f35_46; + RHS46 += f35_46 * RHS35; +const double f36 = 1.0 / m_A108; + const double f36_39 = -f36 * m_A121; + m_A122 += m_A109 * f36_39; + RHS39 += f36_39 * RHS36; +const double f37 = 1.0 / m_A112; + const double f37_40 = -f37 * m_A128; + m_A130 += m_A113 * f37_40; + m_A132 += m_A114 * f37_40; + RHS40 += f37_40 * RHS37; + const double f37_46 = -f37 * m_A169; + m_A170 += m_A113 * f37_46; + m_A174 += m_A114 * f37_46; + RHS46 += f37_46 * RHS37; +const double f38 = 1.0 / m_A118; + const double f38_40 = -f38 * m_A129; + m_A130 += m_A119 * f38_40; + RHS40 += f38_40 * RHS38; +const double f39 = 1.0 / m_A122; + const double f39_42 = -f39 * m_A144; + m_A146 += m_A123 * f39_42; + m_A147 += m_A124 * f39_42; + RHS42 += f39_42 * RHS39; + const double f39_44 = -f39 * m_A157; + m_A158 += m_A123 * f39_44; + m_A160 += m_A124 * f39_44; + RHS44 += f39_44 * RHS39; +const double f40 = 1.0 / m_A130; + const double f40_42 = -f40 * m_A145; + m_A146 += m_A131 * f40_42; + m_A148 += m_A132 * f40_42; + RHS42 += f40_42 * RHS40; + const double f40_46 = -f40 * m_A170; + m_A171 += m_A131 * f40_46; + m_A174 += m_A132 * f40_46; + RHS46 += f40_46 * RHS40; +const double f41 = 1.0 / m_A141; + const double f41_43 = -f41 * m_A152; + m_A153 += m_A142 * f41_43; + RHS43 += f41_43 * RHS41; +const double f42 = 1.0 / m_A146; + const double f42_44 = -f42 * m_A158; + m_A160 += m_A147 * f42_44; + m_A161 += m_A148 * f42_44; + RHS44 += f42_44 * RHS42; + const double f42_46 = -f42 * m_A171; + m_A172 += m_A147 * f42_46; + m_A174 += m_A148 * f42_46; + RHS46 += f42_46 * RHS42; +const double f43 = 1.0 / m_A153; + const double f43_44 = -f43 * m_A159; + m_A160 += m_A154 * f43_44; + RHS44 += f43_44 * RHS43; +const double f44 = 1.0 / m_A160; + const double f44_46 = -f44 * m_A172; + m_A174 += m_A161 * f44_46; + RHS46 += f44_46 * RHS44; +const double f45 = 1.0 / m_A164; + const double f45_46 = -f45 * m_A173; + m_A174 += m_A165 * f45_46; + RHS46 += f45_46 * RHS45; + V[46] = RHS46 / m_A174; + double tmp45 = 0.0; + tmp45 += m_A165 * V[46]; + V[45] = (RHS45 - tmp45) / m_A164; + double tmp44 = 0.0; + tmp44 += m_A161 * V[46]; + V[44] = (RHS44 - tmp44) / m_A160; + double tmp43 = 0.0; + tmp43 += m_A154 * V[44]; + V[43] = (RHS43 - tmp43) / m_A153; + double tmp42 = 0.0; + tmp42 += m_A147 * V[44]; + tmp42 += m_A148 * V[46]; + V[42] = (RHS42 - tmp42) / m_A146; + double tmp41 = 0.0; + tmp41 += m_A142 * V[43]; + V[41] = (RHS41 - tmp41) / m_A141; + double tmp40 = 0.0; + tmp40 += m_A131 * V[42]; + tmp40 += m_A132 * V[46]; + V[40] = (RHS40 - tmp40) / m_A130; + double tmp39 = 0.0; + tmp39 += m_A123 * V[42]; + tmp39 += m_A124 * V[44]; + V[39] = (RHS39 - tmp39) / m_A122; + double tmp38 = 0.0; + tmp38 += m_A119 * V[40]; + V[38] = (RHS38 - tmp38) / m_A118; + double tmp37 = 0.0; + tmp37 += m_A113 * V[40]; + tmp37 += m_A114 * V[46]; + V[37] = (RHS37 - tmp37) / m_A112; + double tmp36 = 0.0; + tmp36 += m_A109 * V[39]; + V[36] = (RHS36 - tmp36) / m_A108; + double tmp35 = 0.0; + tmp35 += m_A104 * V[45]; + tmp35 += m_A105 * V[46]; + V[35] = (RHS35 - tmp35) / m_A103; + double tmp34 = 0.0; + tmp34 += m_A98 * V[43]; + tmp34 += m_A99 * V[44]; + V[34] = (RHS34 - tmp34) / m_A97; + double tmp33 = 0.0; + tmp33 += m_A95 * V[41]; + V[33] = (RHS33 - tmp33) / m_A94; + double tmp32 = 0.0; + tmp32 += m_A91 * V[38]; + V[32] = (RHS32 - tmp32) / m_A90; + double tmp31 = 0.0; + tmp31 += m_A87 * V[35]; + V[31] = (RHS31 - tmp31) / m_A86; + double tmp30 = 0.0; + tmp30 += m_A83 * V[41]; + V[30] = (RHS30 - tmp30) / m_A82; + double tmp29 = 0.0; + tmp29 += m_A74 * V[33]; + V[29] = (RHS29 - tmp29) / m_A73; + double tmp28 = 0.0; + tmp28 += m_A68 * V[40]; + tmp28 += m_A69 * V[42]; + V[28] = (RHS28 - tmp28) / m_A67; + double tmp27 = 0.0; + tmp27 += m_A65 * V[38]; + tmp27 += m_A66 * V[40]; + V[27] = (RHS27 - tmp27) / m_A64; + double tmp26 = 0.0; + tmp26 += m_A62 * V[37]; + tmp26 += m_A63 * V[40]; + V[26] = (RHS26 - tmp26) / m_A61; + double tmp25 = 0.0; + tmp25 += m_A59 * V[36]; + tmp25 += m_A60 * V[39]; + V[25] = (RHS25 - tmp25) / m_A58; + double tmp24 = 0.0; + tmp24 += m_A56 * V[32]; + tmp24 += m_A57 * V[38]; + V[24] = (RHS24 - tmp24) / m_A55; + double tmp23 = 0.0; + tmp23 += m_A53 * V[37]; + tmp23 += m_A54 * V[46]; + V[23] = (RHS23 - tmp23) / m_A52; + double tmp22 = 0.0; + tmp22 += m_A51 * V[32]; + V[22] = (RHS22 - tmp22) / m_A50; + double tmp21 = 0.0; + tmp21 += m_A48 * V[45]; + tmp21 += m_A49 * V[46]; + V[21] = (RHS21 - tmp21) / m_A47; + double tmp20 = 0.0; + tmp20 += m_A45 * V[31]; + tmp20 += m_A46 * V[35]; + V[20] = (RHS20 - tmp20) / m_A44; + double tmp19 = 0.0; + tmp19 += m_A43 * V[35]; + V[19] = (RHS19 - tmp19) / m_A42; + double tmp18 = 0.0; + tmp18 += m_A41 * V[30]; + V[18] = (RHS18 - tmp18) / m_A40; + double tmp17 = 0.0; + tmp17 += m_A39 * V[30]; + V[17] = (RHS17 - tmp17) / m_A38; + double tmp16 = 0.0; + tmp16 += m_A37 * V[30]; + V[16] = (RHS16 - tmp16) / m_A36; + double tmp15 = 0.0; + tmp15 += m_A35 * V[31]; + V[15] = (RHS15 - tmp15) / m_A34; + double tmp14 = 0.0; + tmp14 += m_A33 * V[36]; + V[14] = (RHS14 - tmp14) / m_A32; + double tmp13 = 0.0; + tmp13 += m_A31 * V[30]; + V[13] = (RHS13 - tmp13) / m_A30; + double tmp12 = 0.0; + tmp12 += m_A29 * V[43]; + V[12] = (RHS12 - tmp12) / m_A28; + double tmp11 = 0.0; + tmp11 += m_A26 * V[41]; + tmp11 += m_A27 * V[43]; + V[11] = (RHS11 - tmp11) / m_A25; + double tmp10 = 0.0; + tmp10 += m_A24 * V[30]; + V[10] = (RHS10 - tmp10) / m_A23; + double tmp9 = 0.0; + tmp9 += m_A22 * V[30]; + V[9] = (RHS9 - tmp9) / m_A21; + double tmp8 = 0.0; + tmp8 += m_A19 * V[30]; + tmp8 += m_A20 * V[41]; + V[8] = (RHS8 - tmp8) / m_A18; + double tmp7 = 0.0; + tmp7 += m_A17 * V[41]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A15 * V[41]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A13 * V[41]; + V[5] = (RHS5 - tmp5) / m_A12; + double tmp4 = 0.0; + tmp4 += m_A11 * V[41]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A8 * V[34]; + tmp3 += m_A9 * V[44]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A5 * V[29]; + tmp2 += m_A6 * V[33]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[29]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[29]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_933b3efec18faab_37(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A2 = m_A2 + go[0]; + m_A2 = m_A2 + go[1]; + m_A1 = m_A1 + go[2]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[3] * *cnV[3]; + m_A3 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[10] * *cnV[10]; + m_A6 = gt[16] + gt[17] + gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A7 = m_A7 + go[16]; + m_A7 = m_A7 + go[17]; + m_A8 = m_A8 + go[18]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] - go[19] * *cnV[19] - go[20] * *cnV[20] - go[21] * *cnV[21] - go[22] * *cnV[22]; + m_A9 = gt[24] + gt[25] + gt[26]; + m_A11 = m_A11 + go[24]; + m_A10 = m_A10 + go[25]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[26] * *cnV[26]; + m_A14 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36]; + m_A13 = m_A13 + go[32]; + m_A12 = m_A12 + go[33]; + m_A12 = m_A12 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] - go[35] * *cnV[35] - go[36] * *cnV[36]; + m_A18 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A20 = m_A20 + go[40]; + m_A19 = m_A19 + go[41]; + m_A19 = m_A19 + go[42]; + m_A19 = m_A19 + go[43]; + m_A17 = m_A17 + go[44]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[45] * *cnV[45] - go[46] * *cnV[46]; + m_A23 = gt[48] + gt[49] + gt[50] + gt[51]; + m_A21 = m_A21 + go[48]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] - go[49] * *cnV[49] - go[50] * *cnV[50] - go[51] * *cnV[51]; + m_A28 = gt[56] + gt[57] + gt[58] + gt[59] + gt[60] + gt[61]; + m_A26 = m_A26 + go[56]; + m_A27 = m_A27 + go[57]; + m_A27 = m_A27 + go[58]; + m_A27 = m_A27 + go[59]; + m_A25 = m_A25 + go[60]; + m_A25 = m_A25 + go[61]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] + Idr[60] + Idr[61]; + m_A36 = gt[64] + gt[65] + gt[66] + gt[67]; + m_A30 = m_A30 + go[64]; + m_A33 = m_A33 + go[65]; + m_A31 = m_A31 + go[66]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] + Idr[67] - go[67] * *cnV[67]; +const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A17; + m_A18 += m_A1 * f0_5; + m_A19 += m_A2 * f0_5; + RHS5 += f0_5 * RHS0; + const double f0_7 = -f0 * m_A25; + m_A27 += m_A1 * f0_7; + m_A28 += m_A2 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_7 = -f1 * m_A26; + m_A28 += m_A4 * f1_7; + m_A29 += m_A5 * f1_7; + RHS7 += f1_7 * RHS1; + const double f1_8 = -f1 * m_A30; + m_A35 += m_A4 * f1_8; + m_A36 += m_A5 * f1_8; + RHS8 += f1_8 * RHS1; +const double f2 = 1.0 / m_A6; + const double f2_4 = -f2 * m_A12; + m_A14 += m_A7 * f2_4; + m_A16 += m_A8 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_8 = -f2 * m_A31; + m_A32 += m_A7 * f2_8; + m_A36 += m_A8 * f2_8; + RHS8 += f2_8 * RHS2; +const double f3 = 1.0 / m_A9; + const double f3_4 = -f3 * m_A13; + m_A14 += m_A10 * f3_4; + m_A15 += m_A11 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_6 = -f3 * m_A21; + m_A22 += m_A10 * f3_6; + m_A23 += m_A11 * f3_6; + RHS6 += f3_6 * RHS3; +const double f4 = 1.0 / m_A14; + const double f4_6 = -f4 * m_A22; + m_A23 += m_A15 * f4_6; + m_A24 += m_A16 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_8 = -f4 * m_A32; + m_A34 += m_A15 * f4_8; + m_A36 += m_A16 * f4_8; + RHS8 += f4_8 * RHS4; +const double f5 = 1.0 / m_A18; + const double f5_7 = -f5 * m_A27; + m_A28 += m_A19 * f5_7; + m_A29 += m_A20 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_8 = -f5 * m_A33; + m_A35 += m_A19 * f5_8; + m_A36 += m_A20 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A23; + const double f6_8 = -f6 * m_A34; + m_A36 += m_A24 * f6_8; + RHS8 += f6_8 * RHS6; +const double f7 = 1.0 / m_A28; + const double f7_8 = -f7 * m_A35; + m_A36 += m_A29 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A36; + double tmp7 = 0.0; + tmp7 += m_A29 * V[8]; + V[7] = (RHS7 - tmp7) / m_A28; + double tmp6 = 0.0; + tmp6 += m_A24 * V[8]; + V[6] = (RHS6 - tmp6) / m_A23; + double tmp5 = 0.0; + tmp5 += m_A19 * V[7]; + tmp5 += m_A20 * V[8]; + V[5] = (RHS5 - tmp5) / m_A18; + double tmp4 = 0.0; + tmp4 += m_A15 * V[6]; + tmp4 += m_A16 * V[8]; + V[4] = (RHS4 - tmp4) / m_A14; + double tmp3 = 0.0; + tmp3 += m_A10 * V[4]; + tmp3 += m_A11 * V[6]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A7 * V[4]; + tmp2 += m_A8 * V[8]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A4 * V[7]; + tmp1 += m_A5 * V[8]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + tmp0 += m_A2 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_a1b753ac9c408940_90(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); +double m_A67(0.0); +double m_A68(0.0); +double m_A69(0.0); +double m_A70(0.0); +double m_A71(0.0); +double m_A72(0.0); +double m_A73(0.0); +double m_A74(0.0); +double m_A75(0.0); +double m_A76(0.0); +double m_A77(0.0); +double m_A78(0.0); +double m_A79(0.0); +double m_A80(0.0); +double m_A81(0.0); +double m_A82(0.0); +double m_A83(0.0); +double m_A84(0.0); +double m_A85(0.0); +double m_A86(0.0); +double m_A87(0.0); +double m_A88(0.0); +double m_A89(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25] + gt[26]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A8 = gt[32] + gt[33] + gt[34]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A10 = gt[40] + gt[41] + gt[42]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] - go[41] * *cnV[41] - go[42] * *cnV[42]; + m_A12 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53] + gt[54]; + m_A19 = m_A19 + go[48]; + m_A13 = m_A13 + go[49]; + m_A15 = m_A15 + go[50]; + m_A17 = m_A17 + go[51]; + m_A18 = m_A18 + go[52]; + m_A16 = m_A16 + go[53]; + m_A14 = m_A14 + go[54]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54]; + m_A20 = gt[56] + gt[57]; + m_A22 = m_A22 + go[56]; + m_A21 = m_A21 + go[57]; + double RHS7 = Idr[56] + Idr[57]; + m_A25 = gt[64] + gt[65]; + m_A24 = m_A24 + go[64]; + m_A23 = m_A23 + go[65]; + double RHS8 = Idr[64] + Idr[65]; + m_A35 = gt[72] + gt[73]; + m_A33 = m_A33 + go[72]; + m_A32 = m_A32 + go[73]; + double RHS9 = Idr[72] + Idr[73]; + m_A45 = gt[80] + gt[81]; + m_A42 = m_A42 + go[80]; + m_A41 = m_A41 + go[81]; + double RHS10 = Idr[80] + Idr[81]; + m_A55 = gt[88] + gt[89]; + m_A51 = m_A51 + go[88]; + m_A50 = m_A50 + go[89]; + double RHS11 = Idr[88] + Idr[89]; + m_A65 = gt[96] + gt[97]; + m_A60 = m_A60 + go[96]; + m_A59 = m_A59 + go[97]; + double RHS12 = Idr[96] + Idr[97]; + m_A75 = gt[104] + gt[105]; + m_A69 = m_A69 + go[104]; + m_A68 = m_A68 + go[105]; + double RHS13 = Idr[104] + Idr[105]; + m_A85 = gt[112] + gt[113] + gt[114]; + m_A78 = m_A78 + go[112]; + m_A77 = m_A77 + go[113]; + double RHS14 = Idr[112] + Idr[113] + Idr[114] - go[114] * *cnV[114]; + m_A89 = gt[120] + gt[121]; + m_A87 = m_A87 + go[120]; + double RHS15 = Idr[120] + Idr[121] - go[121] * *cnV[121]; +const double f0 = 1.0 / m_A0; + const double f0_9 = -f0 * m_A32; + m_A35 += m_A1 * f0_9; + RHS9 += f0_9 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_11 = -f1 * m_A50; + m_A55 += m_A3 * f1_11; + RHS11 += f1_11 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_13 = -f2 * m_A68; + m_A75 += m_A5 * f2_13; + RHS13 += f2_13 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_12 = -f3 * m_A59; + m_A65 += m_A7 * f3_12; + RHS12 += f3_12 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_10 = -f4 * m_A41; + m_A45 += m_A9 * f4_10; + RHS10 += f4_10 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_8 = -f5 * m_A23; + m_A25 += m_A11 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_8 = -f6 * m_A24; + m_A25 += m_A13 * f6_8; + m_A26 += m_A14 * f6_8; + m_A27 += m_A15 * f6_8; + m_A28 += m_A16 * f6_8; + m_A29 += m_A17 * f6_8; + m_A30 += m_A18 * f6_8; + m_A31 += m_A19 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_9 = -f6 * m_A33; + m_A34 += m_A13 * f6_9; + m_A35 += m_A14 * f6_9; + m_A36 += m_A15 * f6_9; + m_A37 += m_A16 * f6_9; + m_A38 += m_A17 * f6_9; + m_A39 += m_A18 * f6_9; + m_A40 += m_A19 * f6_9; + RHS9 += f6_9 * RHS6; + const double f6_10 = -f6 * m_A42; + m_A43 += m_A13 * f6_10; + m_A44 += m_A14 * f6_10; + m_A45 += m_A15 * f6_10; + m_A46 += m_A16 * f6_10; + m_A47 += m_A17 * f6_10; + m_A48 += m_A18 * f6_10; + m_A49 += m_A19 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_11 = -f6 * m_A51; + m_A52 += m_A13 * f6_11; + m_A53 += m_A14 * f6_11; + m_A54 += m_A15 * f6_11; + m_A55 += m_A16 * f6_11; + m_A56 += m_A17 * f6_11; + m_A57 += m_A18 * f6_11; + m_A58 += m_A19 * f6_11; + RHS11 += f6_11 * RHS6; + const double f6_12 = -f6 * m_A60; + m_A61 += m_A13 * f6_12; + m_A62 += m_A14 * f6_12; + m_A63 += m_A15 * f6_12; + m_A64 += m_A16 * f6_12; + m_A65 += m_A17 * f6_12; + m_A66 += m_A18 * f6_12; + m_A67 += m_A19 * f6_12; + RHS12 += f6_12 * RHS6; + const double f6_13 = -f6 * m_A69; + m_A70 += m_A13 * f6_13; + m_A71 += m_A14 * f6_13; + m_A72 += m_A15 * f6_13; + m_A73 += m_A16 * f6_13; + m_A74 += m_A17 * f6_13; + m_A75 += m_A18 * f6_13; + m_A76 += m_A19 * f6_13; + RHS13 += f6_13 * RHS6; + const double f6_14 = -f6 * m_A77; + m_A79 += m_A13 * f6_14; + m_A80 += m_A14 * f6_14; + m_A81 += m_A15 * f6_14; + m_A82 += m_A16 * f6_14; + m_A83 += m_A17 * f6_14; + m_A84 += m_A18 * f6_14; + m_A85 += m_A19 * f6_14; + RHS14 += f6_14 * RHS6; +const double f7 = 1.0 / m_A20; + const double f7_14 = -f7 * m_A78; + m_A85 += m_A21 * f7_14; + m_A86 += m_A22 * f7_14; + RHS14 += f7_14 * RHS7; + const double f7_15 = -f7 * m_A87; + m_A88 += m_A21 * f7_15; + m_A89 += m_A22 * f7_15; + RHS15 += f7_15 * RHS7; +const double f8 = 1.0 / m_A25; + const double f8_9 = -f8 * m_A34; + m_A35 += m_A26 * f8_9; + m_A36 += m_A27 * f8_9; + m_A37 += m_A28 * f8_9; + m_A38 += m_A29 * f8_9; + m_A39 += m_A30 * f8_9; + m_A40 += m_A31 * f8_9; + RHS9 += f8_9 * RHS8; + const double f8_10 = -f8 * m_A43; + m_A44 += m_A26 * f8_10; + m_A45 += m_A27 * f8_10; + m_A46 += m_A28 * f8_10; + m_A47 += m_A29 * f8_10; + m_A48 += m_A30 * f8_10; + m_A49 += m_A31 * f8_10; + RHS10 += f8_10 * RHS8; + const double f8_11 = -f8 * m_A52; + m_A53 += m_A26 * f8_11; + m_A54 += m_A27 * f8_11; + m_A55 += m_A28 * f8_11; + m_A56 += m_A29 * f8_11; + m_A57 += m_A30 * f8_11; + m_A58 += m_A31 * f8_11; + RHS11 += f8_11 * RHS8; + const double f8_12 = -f8 * m_A61; + m_A62 += m_A26 * f8_12; + m_A63 += m_A27 * f8_12; + m_A64 += m_A28 * f8_12; + m_A65 += m_A29 * f8_12; + m_A66 += m_A30 * f8_12; + m_A67 += m_A31 * f8_12; + RHS12 += f8_12 * RHS8; + const double f8_13 = -f8 * m_A70; + m_A71 += m_A26 * f8_13; + m_A72 += m_A27 * f8_13; + m_A73 += m_A28 * f8_13; + m_A74 += m_A29 * f8_13; + m_A75 += m_A30 * f8_13; + m_A76 += m_A31 * f8_13; + RHS13 += f8_13 * RHS8; + const double f8_14 = -f8 * m_A79; + m_A80 += m_A26 * f8_14; + m_A81 += m_A27 * f8_14; + m_A82 += m_A28 * f8_14; + m_A83 += m_A29 * f8_14; + m_A84 += m_A30 * f8_14; + m_A85 += m_A31 * f8_14; + RHS14 += f8_14 * RHS8; +const double f9 = 1.0 / m_A35; + const double f9_10 = -f9 * m_A44; + m_A45 += m_A36 * f9_10; + m_A46 += m_A37 * f9_10; + m_A47 += m_A38 * f9_10; + m_A48 += m_A39 * f9_10; + m_A49 += m_A40 * f9_10; + RHS10 += f9_10 * RHS9; + const double f9_11 = -f9 * m_A53; + m_A54 += m_A36 * f9_11; + m_A55 += m_A37 * f9_11; + m_A56 += m_A38 * f9_11; + m_A57 += m_A39 * f9_11; + m_A58 += m_A40 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_12 = -f9 * m_A62; + m_A63 += m_A36 * f9_12; + m_A64 += m_A37 * f9_12; + m_A65 += m_A38 * f9_12; + m_A66 += m_A39 * f9_12; + m_A67 += m_A40 * f9_12; + RHS12 += f9_12 * RHS9; + const double f9_13 = -f9 * m_A71; + m_A72 += m_A36 * f9_13; + m_A73 += m_A37 * f9_13; + m_A74 += m_A38 * f9_13; + m_A75 += m_A39 * f9_13; + m_A76 += m_A40 * f9_13; + RHS13 += f9_13 * RHS9; + const double f9_14 = -f9 * m_A80; + m_A81 += m_A36 * f9_14; + m_A82 += m_A37 * f9_14; + m_A83 += m_A38 * f9_14; + m_A84 += m_A39 * f9_14; + m_A85 += m_A40 * f9_14; + RHS14 += f9_14 * RHS9; +const double f10 = 1.0 / m_A45; + const double f10_11 = -f10 * m_A54; + m_A55 += m_A46 * f10_11; + m_A56 += m_A47 * f10_11; + m_A57 += m_A48 * f10_11; + m_A58 += m_A49 * f10_11; + RHS11 += f10_11 * RHS10; + const double f10_12 = -f10 * m_A63; + m_A64 += m_A46 * f10_12; + m_A65 += m_A47 * f10_12; + m_A66 += m_A48 * f10_12; + m_A67 += m_A49 * f10_12; + RHS12 += f10_12 * RHS10; + const double f10_13 = -f10 * m_A72; + m_A73 += m_A46 * f10_13; + m_A74 += m_A47 * f10_13; + m_A75 += m_A48 * f10_13; + m_A76 += m_A49 * f10_13; + RHS13 += f10_13 * RHS10; + const double f10_14 = -f10 * m_A81; + m_A82 += m_A46 * f10_14; + m_A83 += m_A47 * f10_14; + m_A84 += m_A48 * f10_14; + m_A85 += m_A49 * f10_14; + RHS14 += f10_14 * RHS10; +const double f11 = 1.0 / m_A55; + const double f11_12 = -f11 * m_A64; + m_A65 += m_A56 * f11_12; + m_A66 += m_A57 * f11_12; + m_A67 += m_A58 * f11_12; + RHS12 += f11_12 * RHS11; + const double f11_13 = -f11 * m_A73; + m_A74 += m_A56 * f11_13; + m_A75 += m_A57 * f11_13; + m_A76 += m_A58 * f11_13; + RHS13 += f11_13 * RHS11; + const double f11_14 = -f11 * m_A82; + m_A83 += m_A56 * f11_14; + m_A84 += m_A57 * f11_14; + m_A85 += m_A58 * f11_14; + RHS14 += f11_14 * RHS11; +const double f12 = 1.0 / m_A65; + const double f12_13 = -f12 * m_A74; + m_A75 += m_A66 * f12_13; + m_A76 += m_A67 * f12_13; + RHS13 += f12_13 * RHS12; + const double f12_14 = -f12 * m_A83; + m_A84 += m_A66 * f12_14; + m_A85 += m_A67 * f12_14; + RHS14 += f12_14 * RHS12; +const double f13 = 1.0 / m_A75; + const double f13_14 = -f13 * m_A84; + m_A85 += m_A76 * f13_14; + RHS14 += f13_14 * RHS13; +const double f14 = 1.0 / m_A85; + const double f14_15 = -f14 * m_A88; + m_A89 += m_A86 * f14_15; + RHS15 += f14_15 * RHS14; + V[15] = RHS15 / m_A89; + double tmp14 = 0.0; + tmp14 += m_A86 * V[15]; + V[14] = (RHS14 - tmp14) / m_A85; + double tmp13 = 0.0; + tmp13 += m_A76 * V[14]; + V[13] = (RHS13 - tmp13) / m_A75; + double tmp12 = 0.0; + tmp12 += m_A66 * V[13]; + tmp12 += m_A67 * V[14]; + V[12] = (RHS12 - tmp12) / m_A65; + double tmp11 = 0.0; + tmp11 += m_A56 * V[12]; + tmp11 += m_A57 * V[13]; + tmp11 += m_A58 * V[14]; + V[11] = (RHS11 - tmp11) / m_A55; + double tmp10 = 0.0; + tmp10 += m_A46 * V[11]; + tmp10 += m_A47 * V[12]; + tmp10 += m_A48 * V[13]; + tmp10 += m_A49 * V[14]; + V[10] = (RHS10 - tmp10) / m_A45; + double tmp9 = 0.0; + tmp9 += m_A36 * V[10]; + tmp9 += m_A37 * V[11]; + tmp9 += m_A38 * V[12]; + tmp9 += m_A39 * V[13]; + tmp9 += m_A40 * V[14]; + V[9] = (RHS9 - tmp9) / m_A35; + double tmp8 = 0.0; + tmp8 += m_A26 * V[9]; + tmp8 += m_A27 * V[10]; + tmp8 += m_A28 * V[11]; + tmp8 += m_A29 * V[12]; + tmp8 += m_A30 * V[13]; + tmp8 += m_A31 * V[14]; + V[8] = (RHS8 - tmp8) / m_A25; + double tmp7 = 0.0; + tmp7 += m_A21 * V[14]; + tmp7 += m_A22 * V[15]; + V[7] = (RHS7 - tmp7) / m_A20; + double tmp6 = 0.0; + tmp6 += m_A13 * V[8]; + tmp6 += m_A14 * V[9]; + tmp6 += m_A15 * V[10]; + tmp6 += m_A16 * V[11]; + tmp6 += m_A17 * V[12]; + tmp6 += m_A18 * V[13]; + tmp6 += m_A19 * V[14]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[8]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[10]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[12]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[13]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[11]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[9]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_a26cb0ca00cdeba6_12(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5]; + m_A4 = m_A4 + go[4]; + m_A3 = m_A3 + go[5]; + double RHS1 = Idr[4] + Idr[5]; + m_A7 = gt[8] + gt[9]; + m_A6 = m_A6 + go[8]; + m_A5 = m_A5 + go[9]; + double RHS2 = Idr[8] + Idr[9]; + m_A11 = gt[12] + gt[13]; + m_A9 = m_A9 + go[12]; + double RHS3 = Idr[12] + Idr[13] - go[13] * *cnV[13]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A5; + m_A7 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A6; + m_A7 += m_A3 * f1_2; + m_A8 += m_A4 * f1_2; + RHS2 += f1_2 * RHS1; + const double f1_3 = -f1 * m_A9; + m_A10 += m_A3 * f1_3; + m_A11 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; +const double f2 = 1.0 / m_A7; + const double f2_3 = -f2 * m_A10; + m_A11 += m_A8 * f2_3; + RHS3 += f2_3 * RHS2; + V[3] = RHS3 / m_A11; + double tmp2 = 0.0; + tmp2 += m_A8 * V[3]; + V[2] = (RHS2 - tmp2) / m_A7; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + tmp1 += m_A4 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_a2b9e1d13f95c2d3_34(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + m_A2 = m_A2 + go[1]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[2] * *cnV[2]; + m_A3 = gt[8] + gt[9] + gt[10] + gt[11] + gt[12] + gt[13] + gt[14]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] + Idr[11] + Idr[12] + Idr[13] + Idr[14] - go[10] * *cnV[10] - go[11] * *cnV[11] - go[12] * *cnV[12] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A7 = gt[16] + gt[17] + gt[18]; + m_A6 = m_A6 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A9 = gt[24] + gt[25] + gt[26]; + m_A11 = m_A11 + go[24]; + m_A10 = m_A10 + go[25]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[26] * *cnV[26]; + m_A12 = gt[32] + gt[33] + gt[34]; + m_A14 = m_A14 + go[32]; + m_A13 = m_A13 + go[33]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[34] * *cnV[34]; + m_A17 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A15 = m_A15 + go[40]; + m_A18 = m_A18 + go[41]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[42] * *cnV[42] - go[43] * *cnV[43] - go[44] * *cnV[44] - go[45] * *cnV[45] - go[46] * *cnV[46]; + m_A21 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53]; + m_A19 = m_A19 + go[48]; + m_A22 = m_A22 + go[49]; + m_A20 = m_A20 + go[50]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] - go[51] * *cnV[51] - go[52] * *cnV[52] - go[53] * *cnV[53]; + m_A27 = gt[56] + gt[57] + gt[58] + gt[59] + gt[60]; + m_A26 = m_A26 + go[56]; + m_A25 = m_A25 + go[57]; + m_A23 = m_A23 + go[58]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] + Idr[60] - go[59] * *cnV[59] - go[60] * *cnV[60]; + m_A33 = gt[64] + gt[65] + gt[66]; + m_A30 = m_A30 + go[64]; + m_A31 = m_A31 + go[65]; + m_A29 = m_A29 + go[66]; + double RHS8 = Idr[64] + Idr[65] + Idr[66]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A6; + m_A7 += m_A1 * f0_2; + m_A8 += m_A2 * f0_2; + RHS2 += f0_2 * RHS0; + const double f0_5 = -f0 * m_A15; + m_A16 += m_A1 * f0_5; + m_A18 += m_A2 * f0_5; + RHS5 += f0_5 * RHS0; + const double f0_7 = -f0 * m_A23; + m_A24 += m_A1 * f0_7; + m_A27 += m_A2 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_6 = -f1 * m_A19; + m_A20 += m_A4 * f1_6; + m_A21 += m_A5 * f1_6; + RHS6 += f1_6 * RHS1; +const double f2 = 1.0 / m_A7; + const double f2_5 = -f2 * m_A16; + m_A18 += m_A8 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_7 = -f2 * m_A24; + m_A27 += m_A8 * f2_7; + RHS7 += f2_7 * RHS2; +const double f3 = 1.0 / m_A9; + const double f3_6 = -f3 * m_A20; + m_A21 += m_A10 * f3_6; + m_A22 += m_A11 * f3_6; + RHS6 += f3_6 * RHS3; + const double f3_8 = -f3 * m_A29; + m_A31 += m_A10 * f3_8; + m_A33 += m_A11 * f3_8; + RHS8 += f3_8 * RHS3; +const double f4 = 1.0 / m_A12; + const double f4_7 = -f4 * m_A25; + m_A27 += m_A13 * f4_7; + m_A28 += m_A14 * f4_7; + RHS7 += f4_7 * RHS4; + const double f4_8 = -f4 * m_A30; + m_A32 += m_A13 * f4_8; + m_A33 += m_A14 * f4_8; + RHS8 += f4_8 * RHS4; +const double f5 = 1.0 / m_A17; + const double f5_7 = -f5 * m_A26; + m_A27 += m_A18 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A21; + const double f6_8 = -f6 * m_A31; + m_A33 += m_A22 * f6_8; + RHS8 += f6_8 * RHS6; +const double f7 = 1.0 / m_A27; + const double f7_8 = -f7 * m_A32; + m_A33 += m_A28 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A33; + double tmp7 = 0.0; + tmp7 += m_A28 * V[8]; + V[7] = (RHS7 - tmp7) / m_A27; + double tmp6 = 0.0; + tmp6 += m_A22 * V[8]; + V[6] = (RHS6 - tmp6) / m_A21; + double tmp5 = 0.0; + tmp5 += m_A18 * V[7]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[7]; + tmp4 += m_A14 * V[8]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A10 * V[6]; + tmp3 += m_A11 * V[8]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A8 * V[7]; + V[2] = (RHS2 - tmp2) / m_A7; + double tmp1 = 0.0; + tmp1 += m_A4 * V[3]; + tmp1 += m_A5 * V[6]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + tmp0 += m_A2 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_a5e9537117c3969a_31(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3] + gt[4]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] + Idr[4] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3] - go[4] * *cnV[4]; + m_A2 = gt[8] + gt[9] + gt[10]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[9] * *cnV[9] - go[10] * *cnV[10]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + m_A6 = m_A6 + go[17]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[18] * *cnV[18]; + m_A7 = gt[24] + gt[25] + gt[26]; + m_A8 = m_A8 + go[24]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A9 = gt[32] + gt[33] + gt[34]; + m_A10 = m_A10 + go[32]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] - go[33] * *cnV[33] - go[34] * *cnV[34]; + m_A12 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44] + gt[45] + gt[46]; + m_A14 = m_A14 + go[40]; + m_A13 = m_A13 + go[41]; + m_A11 = m_A11 + go[42]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] + Idr[45] + Idr[46] - go[43] * *cnV[43] - go[44] * *cnV[44] - go[45] * *cnV[45] - go[46] * *cnV[46]; + m_A16 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52]; + m_A18 = m_A18 + go[48]; + m_A15 = m_A15 + go[49]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] - go[50] * *cnV[50] - go[51] * *cnV[51] - go[52] * *cnV[52]; + m_A23 = gt[56] + gt[57] + gt[58]; + m_A19 = m_A19 + go[56]; + m_A20 = m_A20 + go[57]; + m_A21 = m_A21 + go[58]; + double RHS7 = Idr[56] + Idr[57] + Idr[58]; + m_A30 = gt[64] + gt[65] + gt[66] + gt[67] + gt[68]; + m_A26 = m_A26 + go[64]; + m_A25 = m_A25 + go[65]; + m_A28 = m_A28 + go[66]; + m_A27 = m_A27 + go[67]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] + Idr[67] + Idr[68] - go[68] * *cnV[68]; +const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A11; + m_A12 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_7 = -f1 * m_A19; + m_A23 += m_A3 * f1_7; + RHS7 += f1_7 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_6 = -f2 * m_A15; + m_A16 += m_A5 * f2_6; + m_A17 += m_A6 * f2_6; + RHS6 += f2_6 * RHS2; + const double f2_7 = -f2 * m_A20; + m_A22 += m_A5 * f2_7; + m_A23 += m_A6 * f2_7; + RHS7 += f2_7 * RHS2; +const double f3 = 1.0 / m_A7; + const double f3_8 = -f3 * m_A25; + m_A30 += m_A8 * f3_8; + RHS8 += f3_8 * RHS3; +const double f4 = 1.0 / m_A9; + const double f4_8 = -f4 * m_A26; + m_A30 += m_A10 * f4_8; + RHS8 += f4_8 * RHS4; +const double f5 = 1.0 / m_A12; + const double f5_7 = -f5 * m_A21; + m_A23 += m_A13 * f5_7; + m_A24 += m_A14 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_8 = -f5 * m_A27; + m_A29 += m_A13 * f5_8; + m_A30 += m_A14 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A16; + const double f6_7 = -f6 * m_A22; + m_A23 += m_A17 * f6_7; + m_A24 += m_A18 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_8 = -f6 * m_A28; + m_A29 += m_A17 * f6_8; + m_A30 += m_A18 * f6_8; + RHS8 += f6_8 * RHS6; +const double f7 = 1.0 / m_A23; + const double f7_8 = -f7 * m_A29; + m_A30 += m_A24 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A30; + double tmp7 = 0.0; + tmp7 += m_A24 * V[8]; + V[7] = (RHS7 - tmp7) / m_A23; + double tmp6 = 0.0; + tmp6 += m_A17 * V[7]; + tmp6 += m_A18 * V[8]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A13 * V[7]; + tmp5 += m_A14 * V[8]; + V[5] = (RHS5 - tmp5) / m_A12; + double tmp4 = 0.0; + tmp4 += m_A10 * V[8]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A8 * V[8]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A5 * V[6]; + tmp2 += m_A6 * V[7]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[7]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_b42f307001315373_21(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3] + gt[4] + gt[5] + gt[6]; + m_A1 = m_A1 + go[0]; + m_A2 = m_A2 + go[1]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] + Idr[4] + Idr[5] + Idr[6] - go[2] * *cnV[2] - go[3] * *cnV[3] - go[4] * *cnV[4] - go[5] * *cnV[5] - go[6] * *cnV[6]; + m_A3 = gt[8] + gt[9] + gt[10]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] - go[10] * *cnV[10]; + m_A6 = gt[16] + gt[17]; + m_A7 = m_A7 + go[16]; + m_A8 = m_A8 + go[17]; + double RHS2 = Idr[16] + Idr[17]; + m_A10 = gt[24] + gt[25] + gt[26]; + m_A9 = m_A9 + go[24]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] - go[25] * *cnV[25] - go[26] * *cnV[26]; + m_A14 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36] + gt[37]; + m_A12 = m_A12 + go[32]; + m_A15 = m_A15 + go[33]; + m_A13 = m_A13 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] + Idr[37] - go[35] * *cnV[35] - go[36] * *cnV[36] - go[37] * *cnV[37]; + m_A20 = gt[40] + gt[41] + gt[42]; + m_A17 = m_A17 + go[40]; + m_A16 = m_A16 + go[41]; + m_A19 = m_A19 + go[42]; + double RHS5 = Idr[40] + Idr[41] + Idr[42]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A12; + m_A13 += m_A1 * f0_4; + m_A14 += m_A2 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_4 = -f1 * m_A13; + m_A14 += m_A4 * f1_4; + m_A15 += m_A5 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A16; + m_A19 += m_A4 * f1_5; + m_A20 += m_A5 * f1_5; + RHS5 += f1_5 * RHS1; +const double f2 = 1.0 / m_A6; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A7 * f2_3; + m_A11 += m_A8 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_5 = -f2 * m_A17; + m_A18 += m_A7 * f2_5; + m_A20 += m_A8 * f2_5; + RHS5 += f2_5 * RHS2; +const double f3 = 1.0 / m_A10; + const double f3_5 = -f3 * m_A18; + m_A20 += m_A11 * f3_5; + RHS5 += f3_5 * RHS3; +const double f4 = 1.0 / m_A14; + const double f4_5 = -f4 * m_A19; + m_A20 += m_A15 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A20; + double tmp4 = 0.0; + tmp4 += m_A15 * V[5]; + V[4] = (RHS4 - tmp4) / m_A14; + double tmp3 = 0.0; + tmp3 += m_A11 * V[5]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A7 * V[3]; + tmp2 += m_A8 * V[5]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A4 * V[4]; + tmp1 += m_A5 * V[5]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[1]; + tmp0 += m_A2 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_b8e1f7dd43c1da70_35(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[1] * *cnV[1] - go[2] * *cnV[2] - go[3] * *cnV[3]; + m_A2 = gt[8] + gt[9] + gt[10] + gt[11]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] + Idr[10] + Idr[11] - go[9] * *cnV[9] - go[10] * *cnV[10] - go[11] * *cnV[11]; + m_A4 = gt[16] + gt[17] + gt[18]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] + Idr[18] - go[17] * *cnV[17] - go[18] * *cnV[18]; + m_A6 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28]; + m_A9 = m_A9 + go[24]; + m_A7 = m_A7 + go[25]; + m_A7 = m_A7 + go[26]; + m_A7 = m_A7 + go[27]; + m_A8 = m_A8 + go[28]; + double RHS3 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28]; + m_A11 = gt[32] + gt[33] + gt[34] + gt[35] + gt[36] + gt[37] + gt[38]; + m_A13 = m_A13 + go[32]; + m_A12 = m_A12 + go[33]; + m_A10 = m_A10 + go[34]; + double RHS4 = Idr[32] + Idr[33] + Idr[34] + Idr[35] + Idr[36] + Idr[37] + Idr[38] - go[35] * *cnV[35] - go[36] * *cnV[36] - go[37] * *cnV[37] - go[38] * *cnV[38]; + m_A15 = gt[40] + gt[41] + gt[42] + gt[43] + gt[44]; + m_A17 = m_A17 + go[40]; + m_A14 = m_A14 + go[41]; + m_A14 = m_A14 + go[42]; + m_A14 = m_A14 + go[43]; + double RHS5 = Idr[40] + Idr[41] + Idr[42] + Idr[43] + Idr[44] - go[44] * *cnV[44]; + m_A22 = gt[48] + gt[49] + gt[50] + gt[51]; + m_A19 = m_A19 + go[48]; + m_A20 = m_A20 + go[49]; + m_A18 = m_A18 + go[50]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] - go[51] * *cnV[51]; + m_A28 = gt[56] + gt[57] + gt[58]; + m_A29 = m_A29 + go[56]; + m_A25 = m_A25 + go[57]; + m_A26 = m_A26 + go[58]; + double RHS7 = Idr[56] + Idr[57] + Idr[58]; + m_A34 = gt[64] + gt[65] + gt[66]; + m_A31 = m_A31 + go[64]; + m_A30 = m_A30 + go[65]; + m_A33 = m_A33 + go[66]; + double RHS8 = Idr[64] + Idr[65] + Idr[66]; +const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A11 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A18; + m_A22 += m_A3 * f1_6; + RHS6 += f1_6 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_7 = -f2 * m_A25; + m_A28 += m_A5 * f2_7; + RHS7 += f2_7 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_5 = -f3 * m_A14; + m_A15 += m_A7 * f3_5; + m_A16 += m_A8 * f3_5; + m_A17 += m_A9 * f3_5; + RHS5 += f3_5 * RHS3; + const double f3_6 = -f3 * m_A19; + m_A21 += m_A7 * f3_6; + m_A22 += m_A8 * f3_6; + m_A24 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f3_8 = -f3 * m_A30; + m_A31 += m_A7 * f3_8; + m_A32 += m_A8 * f3_8; + m_A34 += m_A9 * f3_8; + RHS8 += f3_8 * RHS3; +const double f4 = 1.0 / m_A11; + const double f4_6 = -f4 * m_A20; + m_A22 += m_A12 * f4_6; + m_A23 += m_A13 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_7 = -f4 * m_A26; + m_A27 += m_A12 * f4_7; + m_A28 += m_A13 * f4_7; + RHS7 += f4_7 * RHS4; +const double f5 = 1.0 / m_A15; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A16 * f5_6; + m_A24 += m_A17 * f5_6; + RHS6 += f5_6 * RHS5; + const double f5_8 = -f5 * m_A31; + m_A32 += m_A16 * f5_8; + m_A34 += m_A17 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A22; + const double f6_7 = -f6 * m_A27; + m_A28 += m_A23 * f6_7; + m_A29 += m_A24 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_8 = -f6 * m_A32; + m_A33 += m_A23 * f6_8; + m_A34 += m_A24 * f6_8; + RHS8 += f6_8 * RHS6; +const double f7 = 1.0 / m_A28; + const double f7_8 = -f7 * m_A33; + m_A34 += m_A29 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A34; + double tmp7 = 0.0; + tmp7 += m_A29 * V[8]; + V[7] = (RHS7 - tmp7) / m_A28; + double tmp6 = 0.0; + tmp6 += m_A23 * V[7]; + tmp6 += m_A24 * V[8]; + V[6] = (RHS6 - tmp6) / m_A22; + double tmp5 = 0.0; + tmp5 += m_A16 * V[6]; + tmp5 += m_A17 * V[8]; + V[5] = (RHS5 - tmp5) / m_A15; + double tmp4 = 0.0; + tmp4 += m_A12 * V[6]; + tmp4 += m_A13 * V[7]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A7 * V[5]; + tmp3 += m_A8 * V[6]; + tmp3 += m_A9 * V[8]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[7]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_b9ccfa3d1681baf3_43(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[14] + gt[15] + gt[16]; + m_A3 = m_A3 + go[14]; + double RHS1 = Idr[14] + Idr[15] + Idr[16] - go[15] * *cnV[15] - go[16] * *cnV[16]; + m_A4 = gt[28] + gt[29] + gt[30]; + m_A5 = m_A5 + go[28]; + double RHS2 = Idr[28] + Idr[29] + Idr[30] - go[29] * *cnV[29] - go[30] * *cnV[30]; + m_A6 = gt[42] + gt[43] + gt[44]; + m_A7 = m_A7 + go[42]; + double RHS3 = Idr[42] + Idr[43] + Idr[44] - go[43] * *cnV[43] - go[44] * *cnV[44]; + m_A8 = gt[56] + gt[57] + gt[58]; + m_A9 = m_A9 + go[56]; + double RHS4 = Idr[56] + Idr[57] + Idr[58] - go[57] * *cnV[57] - go[58] * *cnV[58]; + m_A10 = gt[70] + gt[71] + gt[72]; + m_A11 = m_A11 + go[70]; + double RHS5 = Idr[70] + Idr[71] + Idr[72] - go[71] * *cnV[71] - go[72] * *cnV[72]; + m_A12 = gt[84] + gt[85] + gt[86]; + m_A13 = m_A13 + go[84]; + double RHS6 = Idr[84] + Idr[85] + Idr[86] - go[85] * *cnV[85] - go[86] * *cnV[86]; + m_A14 = gt[98] + gt[99] + gt[100]; + m_A15 = m_A15 + go[98]; + double RHS7 = Idr[98] + Idr[99] + Idr[100] - go[99] * *cnV[99] - go[100] * *cnV[100]; + m_A16 = gt[112] + gt[113] + gt[114]; + m_A17 = m_A17 + go[112]; + double RHS8 = Idr[112] + Idr[113] + Idr[114] - go[113] * *cnV[113] - go[114] * *cnV[114]; + m_A18 = gt[126] + gt[127] + gt[128]; + m_A19 = m_A19 + go[126]; + double RHS9 = Idr[126] + Idr[127] + Idr[128] - go[127] * *cnV[127] - go[128] * *cnV[128]; + m_A20 = gt[140] + gt[141] + gt[142]; + m_A21 = m_A21 + go[140]; + double RHS10 = Idr[140] + Idr[141] + Idr[142] - go[141] * *cnV[141] - go[142] * *cnV[142]; + m_A22 = gt[154] + gt[155] + gt[156]; + m_A23 = m_A23 + go[154]; + double RHS11 = Idr[154] + Idr[155] + Idr[156] - go[155] * *cnV[155] - go[156] * *cnV[156]; + m_A25 = gt[168] + gt[169] + gt[170]; + m_A26 = m_A26 + go[168]; + m_A24 = m_A24 + go[169]; + double RHS12 = Idr[168] + Idr[169] + Idr[170] - go[170] * *cnV[170]; + m_A30 = gt[182] + gt[183] + gt[184] + gt[185] + gt[186] + gt[187] + gt[188]; + m_A29 = m_A29 + go[182]; + m_A28 = m_A28 + go[183]; + m_A27 = m_A27 + go[184]; + m_A31 = m_A31 + go[185]; + m_A31 = m_A31 + go[186]; + double RHS13 = Idr[182] + Idr[183] + Idr[184] + Idr[185] + Idr[186] + Idr[187] + Idr[188] - go[187] * *cnV[187] - go[188] * *cnV[188]; + m_A42 = gt[196] + gt[197] + gt[198] + gt[199] + gt[200] + gt[201] + gt[202] + gt[203] + gt[204] + gt[205] + gt[206] + gt[207] + gt[208]; + m_A41 = m_A41 + go[196]; + m_A41 = m_A41 + go[197]; + m_A39 = m_A39 + go[198]; + m_A38 = m_A38 + go[199]; + m_A37 = m_A37 + go[200]; + m_A36 = m_A36 + go[201]; + m_A35 = m_A35 + go[202]; + m_A34 = m_A34 + go[203]; + m_A33 = m_A33 + go[204]; + m_A32 = m_A32 + go[205]; + m_A40 = m_A40 + go[206]; + double RHS14 = Idr[196] + Idr[197] + Idr[198] + Idr[199] + Idr[200] + Idr[201] + Idr[202] + Idr[203] + Idr[204] + Idr[205] + Idr[206] + Idr[207] + Idr[208] - go[207] * *cnV[207] - go[208] * *cnV[208]; +const double f0 = 1.0 / m_A0; + const double f0_12 = -f0 * m_A24; + m_A25 += m_A1 * f0_12; + RHS12 += f0_12 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_14 = -f1 * m_A32; + m_A42 += m_A3 * f1_14; + RHS14 += f1_14 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_14 = -f2 * m_A33; + m_A42 += m_A5 * f2_14; + RHS14 += f2_14 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_14 = -f3 * m_A34; + m_A42 += m_A7 * f3_14; + RHS14 += f3_14 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_14 = -f4 * m_A35; + m_A42 += m_A9 * f4_14; + RHS14 += f4_14 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_14 = -f5 * m_A36; + m_A42 += m_A11 * f5_14; + RHS14 += f5_14 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_14 = -f6 * m_A37; + m_A42 += m_A13 * f6_14; + RHS14 += f6_14 * RHS6; +const double f7 = 1.0 / m_A14; + const double f7_14 = -f7 * m_A38; + m_A42 += m_A15 * f7_14; + RHS14 += f7_14 * RHS7; +const double f8 = 1.0 / m_A16; + const double f8_14 = -f8 * m_A39; + m_A42 += m_A17 * f8_14; + RHS14 += f8_14 * RHS8; +const double f9 = 1.0 / m_A18; + const double f9_13 = -f9 * m_A27; + m_A30 += m_A19 * f9_13; + RHS13 += f9_13 * RHS9; +const double f10 = 1.0 / m_A20; + const double f10_13 = -f10 * m_A28; + m_A30 += m_A21 * f10_13; + RHS13 += f10_13 * RHS10; +const double f11 = 1.0 / m_A22; + const double f11_13 = -f11 * m_A29; + m_A30 += m_A23 * f11_13; + RHS13 += f11_13 * RHS11; +const double f12 = 1.0 / m_A25; + const double f12_14 = -f12 * m_A40; + m_A42 += m_A26 * f12_14; + RHS14 += f12_14 * RHS12; +const double f13 = 1.0 / m_A30; + const double f13_14 = -f13 * m_A41; + m_A42 += m_A31 * f13_14; + RHS14 += f13_14 * RHS13; + V[14] = RHS14 / m_A42; + double tmp13 = 0.0; + tmp13 += m_A31 * V[14]; + V[13] = (RHS13 - tmp13) / m_A30; + double tmp12 = 0.0; + tmp12 += m_A26 * V[14]; + V[12] = (RHS12 - tmp12) / m_A25; + double tmp11 = 0.0; + tmp11 += m_A23 * V[13]; + V[11] = (RHS11 - tmp11) / m_A22; + double tmp10 = 0.0; + tmp10 += m_A21 * V[13]; + V[10] = (RHS10 - tmp10) / m_A20; + double tmp9 = 0.0; + tmp9 += m_A19 * V[13]; + V[9] = (RHS9 - tmp9) / m_A18; + double tmp8 = 0.0; + tmp8 += m_A17 * V[14]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[14]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[14]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[14]; + 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[14]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[14]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[14]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[12]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_ce10642feea9ba8d_28(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A1 = m_A1 + go[0]; + m_A2 = m_A2 + go[1]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[2] * *cnV[2] - go[3] * *cnV[3]; + m_A3 = gt[12] + gt[13] + gt[14]; + m_A4 = m_A4 + go[12]; + double RHS1 = Idr[12] + Idr[13] + Idr[14] - go[13] * *cnV[13] - go[14] * *cnV[14]; + m_A5 = gt[24] + gt[25] + gt[26] + gt[27] + gt[28]; + m_A7 = m_A7 + go[24]; + m_A7 = m_A7 + go[25]; + m_A6 = m_A6 + go[26]; + double RHS2 = Idr[24] + Idr[25] + Idr[26] + Idr[27] + Idr[28] - go[27] * *cnV[27] - go[28] * *cnV[28]; + m_A9 = gt[36] + gt[37] + gt[38]; + m_A8 = m_A8 + go[36]; + double RHS3 = Idr[36] + Idr[37] + Idr[38] - go[37] * *cnV[37] - go[38] * *cnV[38]; + m_A13 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53] + gt[54]; + m_A14 = m_A14 + go[48]; + m_A11 = m_A11 + go[49]; + m_A13 = m_A13 + go[50]; + m_A13 = m_A13 + go[51]; + double RHS4 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] - go[52] * *cnV[52] - go[53] * *cnV[53] - go[54] * *cnV[54]; + m_A16 = gt[60] + gt[61] + gt[62] + gt[63] + gt[64] + gt[65] + gt[66]; + m_A17 = m_A17 + go[60]; + m_A17 = m_A17 + go[61]; + m_A18 = m_A18 + go[62]; + m_A15 = m_A15 + go[63]; + double RHS5 = Idr[60] + Idr[61] + Idr[62] + Idr[63] + Idr[64] + Idr[65] + Idr[66] - go[64] * *cnV[64] - go[65] * *cnV[65] - go[66] * *cnV[66]; + m_A21 = gt[72] + gt[73] + gt[74] + gt[75] + gt[76] + gt[77] + gt[78] + gt[79] + gt[80] + gt[81] + gt[82]; + m_A22 = m_A22 + go[72]; + m_A22 = m_A22 + go[73]; + m_A22 = m_A22 + go[74]; + m_A20 = m_A20 + go[75]; + m_A20 = m_A20 + go[76]; + m_A19 = m_A19 + go[77]; + m_A19 = m_A19 + go[78]; + double RHS6 = Idr[72] + Idr[73] + Idr[74] + Idr[75] + Idr[76] + Idr[77] + Idr[78] + Idr[79] + Idr[80] + Idr[81] + Idr[82] - go[79] * *cnV[79] - go[80] * *cnV[80] - go[81] * *cnV[81] - go[82] * *cnV[82]; + m_A27 = gt[84] + gt[85] + gt[86] + gt[87] + gt[88] + gt[89] + gt[90] + gt[91]; + m_A26 = m_A26 + go[84]; + m_A26 = m_A26 + go[85]; + m_A26 = m_A26 + go[86]; + m_A23 = m_A23 + go[87]; + m_A25 = m_A25 + go[88]; + m_A24 = m_A24 + go[89]; + double RHS7 = Idr[84] + Idr[85] + Idr[86] + Idr[87] + Idr[88] + Idr[89] + Idr[90] + Idr[91] - go[90] * *cnV[90] - go[91] * *cnV[91]; +const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A9 += m_A1 * f0_3; + m_A10 += m_A2 * f0_3; + RHS3 += f0_3 * RHS0; + const double f0_4 = -f0 * m_A11; + m_A12 += m_A1 * f0_4; + m_A13 += m_A2 * f0_4; + RHS4 += f0_4 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_7 = -f1 * m_A23; + m_A27 += m_A4 * f1_7; + RHS7 += f1_7 * RHS1; +const double f2 = 1.0 / m_A5; + const double f2_5 = -f2 * m_A15; + m_A16 += m_A6 * f2_5; + m_A17 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A19; + m_A20 += m_A6 * f2_6; + m_A21 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; +const double f3 = 1.0 / m_A9; + const double f3_4 = -f3 * m_A12; + m_A13 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; +const double f4 = 1.0 / m_A13; + const double f4_7 = -f4 * m_A24; + m_A27 += m_A14 * f4_7; + RHS7 += f4_7 * RHS4; +const double f5 = 1.0 / m_A16; + const double f5_6 = -f5 * m_A20; + m_A21 += m_A17 * f5_6; + m_A22 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + const double f5_7 = -f5 * m_A25; + m_A26 += m_A17 * f5_7; + m_A27 += m_A18 * f5_7; + RHS7 += f5_7 * RHS5; +const double f6 = 1.0 / m_A21; + const double f6_7 = -f6 * m_A26; + m_A27 += m_A22 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A27; + double tmp6 = 0.0; + tmp6 += m_A22 * V[7]; + V[6] = (RHS6 - tmp6) / m_A21; + double tmp5 = 0.0; + tmp5 += m_A17 * V[6]; + tmp5 += m_A18 * V[7]; + V[5] = (RHS5 - tmp5) / m_A16; + double tmp4 = 0.0; + tmp4 += m_A14 * V[7]; + V[4] = (RHS4 - tmp4) / m_A13; + double tmp3 = 0.0; + tmp3 += m_A10 * V[4]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * V[5]; + tmp2 += m_A7 * V[6]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A4 * V[7]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + tmp0 += m_A2 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_d028b2a263a6b4a7_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + m_A1 = m_A1 + go[1]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[2] * *cnV[2]; + m_A2 = gt[6] + gt[7] + gt[8] + gt[9]; + m_A3 = m_A3 + go[6]; + m_A3 = m_A3 + go[7]; + double RHS1 = Idr[6] + Idr[7] + Idr[8] + Idr[9] - go[8] * *cnV[8] - go[9] * *cnV[9]; + m_A6 = gt[12] + gt[13] + gt[14] + gt[15] + gt[16] + gt[17]; + m_A5 = m_A5 + go[12]; + m_A5 = m_A5 + go[13]; + m_A4 = m_A4 + go[14]; + m_A4 = m_A4 + go[15]; + double RHS2 = Idr[12] + Idr[13] + Idr[14] + Idr[15] + Idr[16] + Idr[17] - go[16] * *cnV[16] - go[17] * *cnV[17]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_e67e623b6c100b4e_12(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A2 = m_A2 + go[0]; + m_A1 = m_A1 + go[1]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[2] * *cnV[2]; + m_A3 = gt[6] + gt[7]; + m_A4 = m_A4 + go[6]; + double RHS1 = Idr[6] + Idr[7] - go[7] * *cnV[7]; + m_A6 = gt[12] + gt[13]; + m_A7 = m_A7 + go[12]; + m_A5 = m_A5 + go[13]; + double RHS2 = Idr[12] + Idr[13]; + m_A11 = gt[18] + gt[19] + gt[20] + gt[21] + gt[22] + gt[23]; + m_A9 = m_A9 + go[18]; + m_A10 = m_A10 + go[19]; + m_A8 = m_A8 + go[20]; + double RHS3 = Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] + Idr[23] - go[21] * *cnV[21] - go[22] * *cnV[22] - go[23] * *cnV[23]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A5; + m_A6 += m_A1 * f0_2; + m_A7 += m_A2 * f0_2; + RHS2 += f0_2 * RHS0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + m_A11 += m_A2 * f0_3; + RHS3 += f0_3 * RHS0; +const double f1 = 1.0 / m_A3; + const double f1_3 = -f1 * m_A9; + m_A11 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; +const double f2 = 1.0 / m_A6; + const double f2_3 = -f2 * m_A10; + m_A11 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + V[3] = RHS3 / m_A11; + double tmp2 = 0.0; + tmp2 += m_A7 * V[3]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A4 * V[3]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + tmp0 += m_A2 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_e7e5566e352b80c1_67(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); +double m_A10(0.0); +double m_A11(0.0); +double m_A12(0.0); +double m_A13(0.0); +double m_A14(0.0); +double m_A15(0.0); +double m_A16(0.0); +double m_A17(0.0); +double m_A18(0.0); +double m_A19(0.0); +double m_A20(0.0); +double m_A21(0.0); +double m_A22(0.0); +double m_A23(0.0); +double m_A24(0.0); +double m_A25(0.0); +double m_A26(0.0); +double m_A27(0.0); +double m_A28(0.0); +double m_A29(0.0); +double m_A30(0.0); +double m_A31(0.0); +double m_A32(0.0); +double m_A33(0.0); +double m_A34(0.0); +double m_A35(0.0); +double m_A36(0.0); +double m_A37(0.0); +double m_A38(0.0); +double m_A39(0.0); +double m_A40(0.0); +double m_A41(0.0); +double m_A42(0.0); +double m_A43(0.0); +double m_A44(0.0); +double m_A45(0.0); +double m_A46(0.0); +double m_A47(0.0); +double m_A48(0.0); +double m_A49(0.0); +double m_A50(0.0); +double m_A51(0.0); +double m_A52(0.0); +double m_A53(0.0); +double m_A54(0.0); +double m_A55(0.0); +double m_A56(0.0); +double m_A57(0.0); +double m_A58(0.0); +double m_A59(0.0); +double m_A60(0.0); +double m_A61(0.0); +double m_A62(0.0); +double m_A63(0.0); +double m_A64(0.0); +double m_A65(0.0); +double m_A66(0.0); + m_A0 = gt[0] + gt[1]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] - go[1] * *cnV[1]; + m_A2 = gt[8] + gt[9]; + m_A3 = m_A3 + go[8]; + double RHS1 = Idr[8] + Idr[9] - go[9] * *cnV[9]; + m_A4 = gt[16] + gt[17]; + m_A5 = m_A5 + go[16]; + double RHS2 = Idr[16] + Idr[17] - go[17] * *cnV[17]; + m_A6 = gt[24] + gt[25]; + m_A7 = m_A7 + go[24]; + double RHS3 = Idr[24] + Idr[25] - go[25] * *cnV[25]; + m_A8 = gt[32] + gt[33]; + m_A9 = m_A9 + go[32]; + double RHS4 = Idr[32] + Idr[33] - go[33] * *cnV[33]; + m_A10 = gt[40] + gt[41]; + m_A11 = m_A11 + go[40]; + double RHS5 = Idr[40] + Idr[41] - go[41] * *cnV[41]; + m_A12 = gt[48] + gt[49] + gt[50] + gt[51] + gt[52] + gt[53] + gt[54] + gt[55]; + m_A14 = m_A14 + go[48]; + m_A15 = m_A15 + go[49]; + m_A17 = m_A17 + go[50]; + m_A18 = m_A18 + go[51]; + m_A16 = m_A16 + go[52]; + m_A13 = m_A13 + go[53]; + double RHS6 = Idr[48] + Idr[49] + Idr[50] + Idr[51] + Idr[52] + Idr[53] + Idr[54] + Idr[55] - go[54] * *cnV[54] - go[55] * *cnV[55]; + m_A21 = gt[56] + gt[57] + gt[58] + gt[59]; + m_A20 = m_A20 + go[56]; + m_A19 = m_A19 + go[57]; + double RHS7 = Idr[56] + Idr[57] + Idr[58] + Idr[59] - go[58] * *cnV[58] - go[59] * *cnV[59]; + m_A30 = gt[64] + gt[65] + gt[66] + gt[67]; + m_A28 = m_A28 + go[64]; + m_A27 = m_A27 + go[65]; + double RHS8 = Idr[64] + Idr[65] + Idr[66] + Idr[67] - go[66] * *cnV[66] - go[67] * *cnV[67]; + m_A39 = gt[72] + gt[73] + gt[74] + gt[75]; + m_A36 = m_A36 + go[72]; + m_A35 = m_A35 + go[73]; + double RHS9 = Idr[72] + Idr[73] + Idr[74] + Idr[75] - go[74] * *cnV[74] - go[75] * *cnV[75]; + m_A48 = gt[80] + gt[81] + gt[82] + gt[83]; + m_A44 = m_A44 + go[80]; + m_A43 = m_A43 + go[81]; + double RHS10 = Idr[80] + Idr[81] + Idr[82] + Idr[83] - go[82] * *cnV[82] - go[83] * *cnV[83]; + m_A57 = gt[88] + gt[89] + gt[90] + gt[91]; + m_A52 = m_A52 + go[88]; + m_A51 = m_A51 + go[89]; + double RHS11 = Idr[88] + Idr[89] + Idr[90] + Idr[91] - go[90] * *cnV[90] - go[91] * *cnV[91]; + m_A66 = gt[96] + gt[97] + gt[98] + gt[99]; + m_A60 = m_A60 + go[96]; + m_A59 = m_A59 + go[97]; + double RHS12 = Idr[96] + Idr[97] + Idr[98] + Idr[99] - go[98] * *cnV[98] - go[99] * *cnV[99]; +const double f0 = 1.0 / m_A0; + const double f0_7 = -f0 * m_A19; + m_A21 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_10 = -f1 * m_A43; + m_A48 += m_A3 * f1_10; + RHS10 += f1_10 * RHS1; +const double f2 = 1.0 / m_A4; + const double f2_12 = -f2 * m_A59; + m_A66 += m_A5 * f2_12; + RHS12 += f2_12 * RHS2; +const double f3 = 1.0 / m_A6; + const double f3_11 = -f3 * m_A51; + m_A57 += m_A7 * f3_11; + RHS11 += f3_11 * RHS3; +const double f4 = 1.0 / m_A8; + const double f4_9 = -f4 * m_A35; + m_A39 += m_A9 * f4_9; + RHS9 += f4_9 * RHS4; +const double f5 = 1.0 / m_A10; + const double f5_8 = -f5 * m_A27; + m_A30 += m_A11 * f5_8; + RHS8 += f5_8 * RHS5; +const double f6 = 1.0 / m_A12; + const double f6_7 = -f6 * m_A20; + m_A21 += m_A13 * f6_7; + m_A22 += m_A14 * f6_7; + m_A23 += m_A15 * f6_7; + m_A24 += m_A16 * f6_7; + m_A25 += m_A17 * f6_7; + m_A26 += m_A18 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_8 = -f6 * m_A28; + m_A29 += m_A13 * f6_8; + m_A30 += m_A14 * f6_8; + m_A31 += m_A15 * f6_8; + m_A32 += m_A16 * f6_8; + m_A33 += m_A17 * f6_8; + m_A34 += m_A18 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_9 = -f6 * m_A36; + m_A37 += m_A13 * f6_9; + m_A38 += m_A14 * f6_9; + m_A39 += m_A15 * f6_9; + m_A40 += m_A16 * f6_9; + m_A41 += m_A17 * f6_9; + m_A42 += m_A18 * f6_9; + RHS9 += f6_9 * RHS6; + const double f6_10 = -f6 * m_A44; + m_A45 += m_A13 * f6_10; + m_A46 += m_A14 * f6_10; + m_A47 += m_A15 * f6_10; + m_A48 += m_A16 * f6_10; + m_A49 += m_A17 * f6_10; + m_A50 += m_A18 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_11 = -f6 * m_A52; + m_A53 += m_A13 * f6_11; + m_A54 += m_A14 * f6_11; + m_A55 += m_A15 * f6_11; + m_A56 += m_A16 * f6_11; + m_A57 += m_A17 * f6_11; + m_A58 += m_A18 * f6_11; + RHS11 += f6_11 * RHS6; + const double f6_12 = -f6 * m_A60; + m_A61 += m_A13 * f6_12; + m_A62 += m_A14 * f6_12; + m_A63 += m_A15 * f6_12; + m_A64 += m_A16 * f6_12; + m_A65 += m_A17 * f6_12; + m_A66 += m_A18 * f6_12; + RHS12 += f6_12 * RHS6; +const double f7 = 1.0 / m_A21; + const double f7_8 = -f7 * m_A29; + m_A30 += m_A22 * f7_8; + m_A31 += m_A23 * f7_8; + m_A32 += m_A24 * f7_8; + m_A33 += m_A25 * f7_8; + m_A34 += m_A26 * f7_8; + RHS8 += f7_8 * RHS7; + const double f7_9 = -f7 * m_A37; + m_A38 += m_A22 * f7_9; + m_A39 += m_A23 * f7_9; + m_A40 += m_A24 * f7_9; + m_A41 += m_A25 * f7_9; + m_A42 += m_A26 * f7_9; + RHS9 += f7_9 * RHS7; + const double f7_10 = -f7 * m_A45; + m_A46 += m_A22 * f7_10; + m_A47 += m_A23 * f7_10; + m_A48 += m_A24 * f7_10; + m_A49 += m_A25 * f7_10; + m_A50 += m_A26 * f7_10; + RHS10 += f7_10 * RHS7; + const double f7_11 = -f7 * m_A53; + m_A54 += m_A22 * f7_11; + m_A55 += m_A23 * f7_11; + m_A56 += m_A24 * f7_11; + m_A57 += m_A25 * f7_11; + m_A58 += m_A26 * f7_11; + RHS11 += f7_11 * RHS7; + const double f7_12 = -f7 * m_A61; + m_A62 += m_A22 * f7_12; + m_A63 += m_A23 * f7_12; + m_A64 += m_A24 * f7_12; + m_A65 += m_A25 * f7_12; + m_A66 += m_A26 * f7_12; + RHS12 += f7_12 * RHS7; +const double f8 = 1.0 / m_A30; + const double f8_9 = -f8 * m_A38; + m_A39 += m_A31 * f8_9; + m_A40 += m_A32 * f8_9; + m_A41 += m_A33 * f8_9; + m_A42 += m_A34 * f8_9; + RHS9 += f8_9 * RHS8; + const double f8_10 = -f8 * m_A46; + m_A47 += m_A31 * f8_10; + m_A48 += m_A32 * f8_10; + m_A49 += m_A33 * f8_10; + m_A50 += m_A34 * f8_10; + RHS10 += f8_10 * RHS8; + const double f8_11 = -f8 * m_A54; + m_A55 += m_A31 * f8_11; + m_A56 += m_A32 * f8_11; + m_A57 += m_A33 * f8_11; + m_A58 += m_A34 * f8_11; + RHS11 += f8_11 * RHS8; + const double f8_12 = -f8 * m_A62; + m_A63 += m_A31 * f8_12; + m_A64 += m_A32 * f8_12; + m_A65 += m_A33 * f8_12; + m_A66 += m_A34 * f8_12; + RHS12 += f8_12 * RHS8; +const double f9 = 1.0 / m_A39; + const double f9_10 = -f9 * m_A47; + m_A48 += m_A40 * f9_10; + m_A49 += m_A41 * f9_10; + m_A50 += m_A42 * f9_10; + RHS10 += f9_10 * RHS9; + const double f9_11 = -f9 * m_A55; + m_A56 += m_A40 * f9_11; + m_A57 += m_A41 * f9_11; + m_A58 += m_A42 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_12 = -f9 * m_A63; + m_A64 += m_A40 * f9_12; + m_A65 += m_A41 * f9_12; + m_A66 += m_A42 * f9_12; + RHS12 += f9_12 * RHS9; +const double f10 = 1.0 / m_A48; + const double f10_11 = -f10 * m_A56; + m_A57 += m_A49 * f10_11; + m_A58 += m_A50 * f10_11; + RHS11 += f10_11 * RHS10; + const double f10_12 = -f10 * m_A64; + m_A65 += m_A49 * f10_12; + m_A66 += m_A50 * f10_12; + RHS12 += f10_12 * RHS10; +const double f11 = 1.0 / m_A57; + const double f11_12 = -f11 * m_A65; + m_A66 += m_A58 * f11_12; + RHS12 += f11_12 * RHS11; + V[12] = RHS12 / m_A66; + double tmp11 = 0.0; + tmp11 += m_A58 * V[12]; + V[11] = (RHS11 - tmp11) / m_A57; + double tmp10 = 0.0; + tmp10 += m_A49 * V[11]; + tmp10 += m_A50 * V[12]; + V[10] = (RHS10 - tmp10) / m_A48; + double tmp9 = 0.0; + tmp9 += m_A40 * V[10]; + tmp9 += m_A41 * V[11]; + tmp9 += m_A42 * V[12]; + V[9] = (RHS9 - tmp9) / m_A39; + double tmp8 = 0.0; + tmp8 += m_A31 * V[9]; + tmp8 += m_A32 * V[10]; + tmp8 += m_A33 * V[11]; + tmp8 += m_A34 * V[12]; + V[8] = (RHS8 - tmp8) / m_A30; + double tmp7 = 0.0; + tmp7 += m_A22 * V[8]; + tmp7 += m_A23 * V[9]; + tmp7 += m_A24 * V[10]; + tmp7 += m_A25 * V[11]; + tmp7 += m_A26 * V[12]; + V[7] = (RHS7 - tmp7) / m_A21; + double tmp6 = 0.0; + tmp6 += m_A13 * V[7]; + tmp6 += m_A14 * V[8]; + tmp6 += m_A15 * V[9]; + tmp6 += m_A16 * V[10]; + tmp6 += m_A17 * V[11]; + tmp6 += m_A18 * V[12]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[8]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[9]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[11]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[12]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[10]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_ec17a9dbc8cd78fd_10(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); +double m_A7(0.0); +double m_A8(0.0); +double m_A9(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[6] + gt[7] + gt[8]; + m_A3 = m_A3 + go[6]; + double RHS1 = Idr[6] + Idr[7] + Idr[8] - go[7] * *cnV[7] - go[8] * *cnV[8]; + m_A4 = gt[12] + gt[13]; + m_A5 = m_A5 + go[12]; + double RHS2 = Idr[12] + Idr[13] - go[13] * *cnV[13]; + m_A9 = gt[18] + gt[19] + gt[20] + gt[21] + gt[22]; + m_A8 = m_A8 + go[18]; + m_A7 = m_A7 + go[19]; + m_A6 = m_A6 + go[20]; + double RHS3 = Idr[18] + Idr[19] + Idr[20] + Idr[21] + Idr[22] - go[21] * *cnV[21] - go[22] * *cnV[22]; +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; +} + +static void nl_gcr_fbbf6eebb7621abc_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2]; + m_A1 = m_A1 + go[0]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] - go[1] * *cnV[1] - go[2] * *cnV[2]; + m_A2 = gt[4] + gt[5]; + m_A3 = m_A3 + go[4]; + double RHS1 = Idr[4] + Idr[5] - go[5] * *cnV[5]; + m_A6 = gt[8] + gt[9]; + m_A5 = m_A5 + go[8]; + m_A4 = m_A4 + go[9]; + double RHS2 = Idr[8] + Idr[9]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +static void nl_gcr_feb42362d28845e7_7(double * __restrict V, double * __restrict go, double * __restrict gt, double * __restrict Idr, double ** __restrict cnV) + +{ + +double m_A0(0.0); +double m_A1(0.0); +double m_A2(0.0); +double m_A3(0.0); +double m_A4(0.0); +double m_A5(0.0); +double m_A6(0.0); + m_A0 = gt[0] + gt[1] + gt[2] + gt[3]; + m_A1 = m_A1 + go[0]; + m_A1 = m_A1 + go[1]; + double RHS0 = Idr[0] + Idr[1] + Idr[2] + Idr[3] - go[2] * *cnV[2] - go[3] * *cnV[3]; + m_A2 = gt[6] + gt[7]; + m_A3 = m_A3 + go[6]; + double RHS1 = Idr[6] + Idr[7] - go[7] * *cnV[7]; + m_A6 = gt[12] + gt[13] + gt[14] + gt[15] + gt[16]; + m_A5 = m_A5 + go[12]; + m_A4 = m_A4 + go[13]; + m_A4 = m_A4 + go[14]; + double RHS2 = Idr[12] + Idr[13] + Idr[14] + Idr[15] + Idr[16] - go[15] * *cnV[15] - go[16] * *cnV[16]; +const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A4; + m_A6 += m_A1 * f0_2; + RHS2 += f0_2 * RHS0; +const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +plib::dynlib_static_sym nl_static_syms[] = { +{ "nl_gcr_111d6ad4781c136_19", reinterpret_cast(&nl_gcr_111d6ad4781c136_19)}, +{ "nl_gcr_11995a0d28843023_150", reinterpret_cast(&nl_gcr_11995a0d28843023_150)}, +{ "nl_gcr_15fa1a3cf923c9fd_29", reinterpret_cast(&nl_gcr_15fa1a3cf923c9fd_29)}, +{ "nl_gcr_169c14d438ffb621_198", reinterpret_cast(&nl_gcr_169c14d438ffb621_198)}, +{ "nl_gcr_18deaad4b2fab70d_26", reinterpret_cast(&nl_gcr_18deaad4b2fab70d_26)}, +{ "nl_gcr_19f6e9708f37ad65_7", reinterpret_cast(&nl_gcr_19f6e9708f37ad65_7)}, +{ "nl_gcr_1e27a9bddeac729d_64", reinterpret_cast(&nl_gcr_1e27a9bddeac729d_64)}, +{ "nl_gcr_1faccd91c85d3ab3_28", reinterpret_cast(&nl_gcr_1faccd91c85d3ab3_28)}, +{ "nl_gcr_1fffb23aa506432d_13", reinterpret_cast(&nl_gcr_1fffb23aa506432d_13)}, +{ "nl_gcr_20615d28f46254cb_10", reinterpret_cast(&nl_gcr_20615d28f46254cb_10)}, +{ "nl_gcr_27a78682a9b70f8c_10", reinterpret_cast(&nl_gcr_27a78682a9b70f8c_10)}, +{ "nl_gcr_35947d349693c22_111", reinterpret_cast(&nl_gcr_35947d349693c22_111)}, +{ "nl_gcr_3641ac25e244c362_16", reinterpret_cast(&nl_gcr_3641ac25e244c362_16)}, +{ "nl_gcr_38a3ac18f52bf78a_7", reinterpret_cast(&nl_gcr_38a3ac18f52bf78a_7)}, +{ "nl_gcr_38f1806722626d7e_7", reinterpret_cast(&nl_gcr_38f1806722626d7e_7)}, +{ "nl_gcr_3e4821cabc0aeb96_24", reinterpret_cast(&nl_gcr_3e4821cabc0aeb96_24)}, +{ "nl_gcr_4966c35de59b7e6a_99", reinterpret_cast(&nl_gcr_4966c35de59b7e6a_99)}, +{ "nl_gcr_57a832104e53c9a8_20", reinterpret_cast(&nl_gcr_57a832104e53c9a8_20)}, +{ "nl_gcr_5985dfb549280eeb_13", reinterpret_cast(&nl_gcr_5985dfb549280eeb_13)}, +{ "nl_gcr_5ca1779d1825c4c9_26", reinterpret_cast(&nl_gcr_5ca1779d1825c4c9_26)}, +{ "nl_gcr_6148fa421800febb_10", reinterpret_cast(&nl_gcr_6148fa421800febb_10)}, +{ "nl_gcr_63b745ec069c7245_82", reinterpret_cast(&nl_gcr_63b745ec069c7245_82)}, +{ "nl_gcr_6480c7a1d69e9131_7", reinterpret_cast(&nl_gcr_6480c7a1d69e9131_7)}, +{ "nl_gcr_6c599fc01f5b084c_20", reinterpret_cast(&nl_gcr_6c599fc01f5b084c_20)}, +{ "nl_gcr_6d40bbc695987ef5_13", reinterpret_cast(&nl_gcr_6d40bbc695987ef5_13)}, +{ "nl_gcr_70e1061a9deb37a4_7", reinterpret_cast(&nl_gcr_70e1061a9deb37a4_7)}, +{ "nl_gcr_7421995adbfda1ad_10", reinterpret_cast(&nl_gcr_7421995adbfda1ad_10)}, +{ "nl_gcr_794f14a13bda75f0_50", reinterpret_cast(&nl_gcr_794f14a13bda75f0_50)}, +{ "nl_gcr_7a4e8b4f388d66d7_7", reinterpret_cast(&nl_gcr_7a4e8b4f388d66d7_7)}, +{ "nl_gcr_7b1592d23e41ce56_37", reinterpret_cast(&nl_gcr_7b1592d23e41ce56_37)}, +{ "nl_gcr_7c58698d6a68f4a0_7", reinterpret_cast(&nl_gcr_7c58698d6a68f4a0_7)}, +{ "nl_gcr_7dbbdf7feecfa9bd_108", reinterpret_cast(&nl_gcr_7dbbdf7feecfa9bd_108)}, +{ "nl_gcr_7f2f6447ea71d31e_49", reinterpret_cast(&nl_gcr_7f2f6447ea71d31e_49)}, +{ "nl_gcr_81bfac76b696d9f3_22", reinterpret_cast(&nl_gcr_81bfac76b696d9f3_22)}, +{ "nl_gcr_876240e48d904d1f_7", reinterpret_cast(&nl_gcr_876240e48d904d1f_7)}, +{ "nl_gcr_8e55e5f9e065890e_85", reinterpret_cast(&nl_gcr_8e55e5f9e065890e_85)}, +{ "nl_gcr_92523d559b657838_175", reinterpret_cast(&nl_gcr_92523d559b657838_175)}, +{ "nl_gcr_933b3efec18faab_37", reinterpret_cast(&nl_gcr_933b3efec18faab_37)}, +{ "nl_gcr_a1b753ac9c408940_90", reinterpret_cast(&nl_gcr_a1b753ac9c408940_90)}, +{ "nl_gcr_a26cb0ca00cdeba6_12", reinterpret_cast(&nl_gcr_a26cb0ca00cdeba6_12)}, +{ "nl_gcr_a2b9e1d13f95c2d3_34", reinterpret_cast(&nl_gcr_a2b9e1d13f95c2d3_34)}, +{ "nl_gcr_a5e9537117c3969a_31", reinterpret_cast(&nl_gcr_a5e9537117c3969a_31)}, +{ "nl_gcr_b42f307001315373_21", reinterpret_cast(&nl_gcr_b42f307001315373_21)}, +{ "nl_gcr_b8e1f7dd43c1da70_35", reinterpret_cast(&nl_gcr_b8e1f7dd43c1da70_35)}, +{ "nl_gcr_b9ccfa3d1681baf3_43", reinterpret_cast(&nl_gcr_b9ccfa3d1681baf3_43)}, +{ "nl_gcr_ce10642feea9ba8d_28", reinterpret_cast(&nl_gcr_ce10642feea9ba8d_28)}, +{ "nl_gcr_d028b2a263a6b4a7_7", reinterpret_cast(&nl_gcr_d028b2a263a6b4a7_7)}, +{ "nl_gcr_e67e623b6c100b4e_12", reinterpret_cast(&nl_gcr_e67e623b6c100b4e_12)}, +{ "nl_gcr_e7e5566e352b80c1_67", reinterpret_cast(&nl_gcr_e7e5566e352b80c1_67)}, +{ "nl_gcr_ec17a9dbc8cd78fd_10", reinterpret_cast(&nl_gcr_ec17a9dbc8cd78fd_10)}, +{ "nl_gcr_fbbf6eebb7621abc_7", reinterpret_cast(&nl_gcr_fbbf6eebb7621abc_7)}, +{ "nl_gcr_feb42362d28845e7_7", reinterpret_cast(&nl_gcr_feb42362d28845e7_7)}, +{"", nullptr} +}; diff --git a/src/lib/netlist/nl_base.cpp b/src/lib/netlist/nl_base.cpp index 09769d54f6c..059c6e76a41 100644 --- a/src/lib/netlist/nl_base.cpp +++ b/src/lib/netlist/nl_base.cpp @@ -18,9 +18,20 @@ #include +// ---------------------------------------------------------------------------------------- +// Statically compiled solvers for mame netlist +// ---------------------------------------------------------------------------------------- + +extern plib::dynlib_static_sym nl_static_syms[]; + namespace netlist { + plib::unique_ptr callbacks_t:: static_solver_lib() const + { + return plib::make_unique(nl_static_syms); + } + // ---------------------------------------------------------------------------------------- // logic_family_ttl_t // ---------------------------------------------------------------------------------------- @@ -201,8 +212,8 @@ namespace netlist , m_extended_validation(false) , m_dummy_version(1) { - pstring libpath = plib::util::environment("NL_BOOSTLIB", plib::util::buildpath({".", "nlboost.so"})); - m_lib = plib::make_unique(libpath); + + m_lib = m_callbacks->static_solver_lib(); m_setup = plib::make_unique(*this); // create the run interface @@ -795,9 +806,9 @@ namespace netlist terminal_t::terminal_t(core_device_t &dev, const pstring &aname, terminal_t *otherterm) : analog_t(dev, aname, STATE_BIDIR) - , m_Idr1(nullptr) - , m_go1(nullptr) - , m_gt1(nullptr) + , m_Idr(nullptr) + , m_go(nullptr) + , m_gt(nullptr) { state().setup().register_term(*this, *otherterm); } diff --git a/src/lib/netlist/nl_base.h b/src/lib/netlist/nl_base.h index 6710c197329..06b04bf10da 100644 --- a/src/lib/netlist/nl_base.h +++ b/src/lib/netlist/nl_base.h @@ -187,6 +187,8 @@ namespace netlist /// \brief Delegate type for device notification. /// using nldelegate = plib::pmfp; + using nldelegate_ts = plib::pmfp; + using nldelegate_dyn = plib::pmfp; // ----------------------------------------------------------------------------- // forward definitions @@ -825,11 +827,11 @@ namespace netlist void set_go_gt_I(nl_fptype GO, nl_fptype GT, nl_fptype I) const noexcept { // Check for rail nets ... - if (m_go1 != nullptr) + if (m_go != nullptr) { - *m_Idr1 = I; - *m_go1 = GO; - *m_gt1 = GT; + *m_Idr = I; + *m_go = GO; + *m_gt = GT; } } @@ -837,11 +839,11 @@ namespace netlist void schedule_solve_after(netlist_time after) noexcept; void set_ptrs(nl_fptype *gt, nl_fptype *go, nl_fptype *Idr) noexcept(false); - private: - nl_fptype *m_Idr1; // drive current - nl_fptype *m_go1; // conductance for Voltage from other term - nl_fptype *m_gt1; // conductance for total conductance + private: + nl_fptype *m_Idr; // drive current + nl_fptype *m_go; // conductance for Voltage from other term + nl_fptype *m_gt; // conductance for total conductance }; @@ -1430,7 +1432,7 @@ namespace netlist log_type & log() noexcept { return m_log; } const log_type &log() const noexcept { return m_log; } - plib::dynlib &lib() const noexcept { return *m_lib; } + plib::dynlib_base &lib() const noexcept { return *m_lib; } netlist_t &exec() noexcept { return *m_netlist; } const netlist_t &exec() const noexcept { return *m_netlist; } @@ -1576,7 +1578,7 @@ namespace netlist pstring m_name; unique_pool_ptr m_netlist; - plib::unique_ptr m_lib; // external lib needs to be loaded as long as netlist exists + plib::unique_ptr m_lib; // external lib needs to be loaded as long as netlist exists plib::state_manager_t m_state; plib::unique_ptr m_callbacks; log_type m_log; @@ -1951,9 +1953,9 @@ namespace netlist throw nl_exception("Inconsistent nullptrs for terminal {}", name()); } - m_gt1 = gt; - m_go1 = go; - m_Idr1 = Idr; + m_gt = gt; + m_go = go; + m_Idr = Idr; } inline logic_net_t & logic_t::net() noexcept diff --git a/src/lib/netlist/nl_create_mame_solvers.sh b/src/lib/netlist/nl_create_mame_solvers.sh new file mode 100644 index 00000000000..4f7e34171c4 --- /dev/null +++ b/src/lib/netlist/nl_create_mame_solvers.sh @@ -0,0 +1,40 @@ + +OUTDIR=/tmp/static_sysms +GENERATED=src/lib/netlist/generated/static_solvers.cpp + +if [ _$OS = "_Windows_NT" ]; then + NLTOOL=./nltool.exe + CXX=g++.exe +else + NLTOOL=./nltool + CXX=g++ +fi + +rm -rf $OUTDIR +mkdir $OUTDIR + +for i in src/mame/machine/nl_*.cpp src/mame/audio/nl_*.cpp; do + nn=`basename $i .cpp | sed -e "s/nl_//g"` + cn=`grep "^//NL_CONTAINS" $i | cut -f2-99 "-d "` + if [ _"$cn" != _"" ]; then + nn=$cn + fi + for j in $nn; do + echo $i : $j + if [ $j != "pongdoubles" ]; then + $NLTOOL -c static -f $i -n $j -t 6 --dir $OUTDIR + fi + done +done + +# $CXX -shared -x c++ -fPIC -O3 -march=native -mtune=native -ffast-math $OUTDIR/*.c -o nlboost.so + +echo '#include "plib/pdynlib.h"' > $GENERATED +cat $OUTDIR/*.c | sed -e 's/extern "C"/static/' >> $GENERATED +echo 'plib::dynlib_static_sym nl_static_syms[] = {' >> $GENERATED +for i in $OUTDIR/*.c; do + n=`basename $i .c` + echo '{ "'${n}'", reinterpret_cast(&'${n}')},' >> $GENERATED +done +echo '{"", nullptr}' >> $GENERATED +echo '};' >> $GENERATED diff --git a/src/lib/netlist/nltypes.h b/src/lib/netlist/nltypes.h index b3f6f534978..f5a0791a59f 100644 --- a/src/lib/netlist/nltypes.h +++ b/src/lib/netlist/nltypes.h @@ -20,6 +20,7 @@ #include "plib/pstring.h" #include "plib/ptime.h" #include "plib/putil.h" +#include "plib/pdynlib.h" #include @@ -57,6 +58,9 @@ namespace netlist /// virtual void vlog(const plib::plog_level &l, const pstring &ls) const noexcept = 0; + /// \brief provide library with static solver implementations. + /// + virtual plib::unique_ptr static_solver_lib() const; }; using log_type = plib::plog_base; diff --git a/src/lib/netlist/plib/pdynlib.cpp b/src/lib/netlist/plib/pdynlib.cpp index d92e0b471d0..d614c31cf47 100644 --- a/src/lib/netlist/plib/pdynlib.cpp +++ b/src/lib/netlist/plib/pdynlib.cpp @@ -55,7 +55,7 @@ WCHAR *wstring_from_utf8(const char *utf8string) namespace plib { dynlib::dynlib(const pstring &libname) -: m_isLoaded(false), m_lib(nullptr) +: m_lib(nullptr) { #ifdef _WIN32 //fprintf(stderr, "win: loading <%s>\n", libname.c_str()); @@ -65,7 +65,7 @@ dynlib::dynlib(const pstring &libname) else m_lib = GetModuleHandle(nullptr); if (m_lib != nullptr) - m_isLoaded = true; + m_is_loaded = true; //else // fprintf(stderr, "win: library <%s> not found!\n", libname.c_str()); delete [] buffer; @@ -78,14 +78,14 @@ dynlib::dynlib(const pstring &libname) else m_lib = dlopen(nullptr, RTLD_LAZY); if (m_lib != nullptr) - m_isLoaded = true; + m_is_loaded = true; //else // printf("library <%s> not found: %s\n", libname.c_str(), dlerror()); #endif } dynlib::dynlib(const pstring &path, const pstring &libname) -: m_isLoaded(false), m_lib(nullptr) +: m_lib(nullptr) { // FIXME: implement path search plib::unused_var(path); @@ -97,7 +97,7 @@ dynlib::dynlib(const pstring &path, const pstring &libname) else m_lib = GetModuleHandle(nullptr); if (m_lib != nullptr) - m_isLoaded = true; + m_is_loaded = true; else { //printf("win: library <%s> not found!\n", libname.c_str()); @@ -112,7 +112,7 @@ dynlib::dynlib(const pstring &path, const pstring &libname) else m_lib = dlopen(nullptr, RTLD_LAZY); if (m_lib != nullptr) - m_isLoaded = true; + m_is_loaded = true; else { //printf("library <%s> not found!\n", libname.c_str()); diff --git a/src/lib/netlist/plib/pdynlib.h b/src/lib/netlist/plib/pdynlib.h index 9c44452d16f..7a6a4b6985c 100644 --- a/src/lib/netlist/plib/pdynlib.h +++ b/src/lib/netlist/plib/pdynlib.h @@ -12,62 +12,108 @@ #include "ptypes.h" namespace plib { -// ---------------------------------------------------------------------------------------- -// pdynlib: dynamic loading of libraries ... -// ---------------------------------------------------------------------------------------- + // ---------------------------------------------------------------------------------------- + // pdynlib: dynamic loading of libraries ... + // ---------------------------------------------------------------------------------------- -class dynlib : public nocopyassignmove -{ -public: - explicit dynlib(const pstring &libname); - dynlib(const pstring &path, const pstring &libname); - - ~dynlib(); - COPYASSIGNMOVE(dynlib, delete) - - bool isLoaded() const { return m_isLoaded; } - - template - T getsym(const pstring &name) const noexcept + class dynlib_base : public nocopyassignmove { - return reinterpret_cast(getsym_p(name)); - } -private: - void *getsym_p(const pstring &name) const noexcept; + public: + explicit dynlib_base() : m_is_loaded(false) { } - bool m_isLoaded; - void *m_lib; -}; + virtual ~dynlib_base() { } + COPYASSIGNMOVE(dynlib_base, delete) -template -class dynproc -{ -public: - using calltype = R(*) (Args... args); + bool isLoaded() const { return m_is_loaded; } - dynproc() : m_sym(nullptr) { } + template + T getsym(const pstring &name) const noexcept + { + return reinterpret_cast(getsym_p(name)); + } - dynproc(dynlib &dl, const pstring &name) noexcept + protected: + bool m_is_loaded; + virtual void *getsym_p(const pstring &name) const noexcept = 0; + }; + + class dynlib : public dynlib_base { - m_sym = dl.getsym(name); - } + public: + explicit dynlib(const pstring &libname); + dynlib(const pstring &path, const pstring &libname); - void load(dynlib &dl, const pstring &name) noexcept + ~dynlib(); + + protected: + void *getsym_p(const pstring &name) const noexcept override; + + private: + void *m_lib; + }; + + struct dynlib_static_sym { - m_sym = dl.getsym(name); - } + const char *name; + void *addr; + }; - R operator ()(Args&&... args) const + class dynlib_static : public dynlib_base { - return m_sym(std::forward(args)...); - //return m_sym(args...); - } + public: + explicit dynlib_static(const dynlib_static_sym *syms) + : m_syms(syms) + { + if (syms != nullptr) + m_is_loaded = true; + } - bool resolved() const noexcept { return m_sym != nullptr; } -private: - calltype m_sym; -}; + protected: + void *getsym_p(const pstring &name) const noexcept override + { + const dynlib_static_sym *p = m_syms; + while (p->name[0] != 0) + { + if (name == pstring(p->name)) + return p->addr; + p++; + } + return nullptr; + } + + private: + const dynlib_static_sym *m_syms; + }; + + template + class dynproc + { + public: + using calltype = R(*) (Args... args); + + dynproc() : m_sym(nullptr) { } + + dynproc(dynlib_base &dl, const pstring &name) noexcept + { + m_sym = dl.getsym(name); + } + + void load(dynlib_base &dl, const pstring &name) noexcept + { + m_sym = dl.getsym(name); + } + + R operator ()(Args&&... args) const + { + return m_sym(std::forward(args)...); + //return m_sym(args...); + } + + bool resolved() const noexcept { return m_sym != nullptr; } + private: + calltype m_sym; + }; } // namespace plib -#endif // PSTRING_H_ +#endif // PDYNLIB_H_ diff --git a/src/lib/netlist/plib/pmatrix2d.h b/src/lib/netlist/plib/pmatrix2d.h index c2960f3174e..c3dfca46b23 100644 --- a/src/lib/netlist/plib/pmatrix2d.h +++ b/src/lib/netlist/plib/pmatrix2d.h @@ -67,6 +67,20 @@ namespace plib return (*this)[r][c]; } + T * data() noexcept + { + return m_v.data(); + } + + const T * data() const noexcept + { + return m_v.data(); + } + + size_type didx(size_type r, size_type c) const noexcept + { + return m_stride * r + c; + } private: size_type m_N; diff --git a/src/lib/netlist/plib/putil.h b/src/lib/netlist/plib/putil.h index 3ddf4a81f5a..cc2b000b10d 100644 --- a/src/lib/netlist/plib/putil.h +++ b/src/lib/netlist/plib/putil.h @@ -287,6 +287,19 @@ namespace plib const std::string &token, std::size_t maxsplit); + // ---------------------------------------------------------------------------------------- + // simple hash + // ---------------------------------------------------------------------------------------- + + template + std::size_t hash(const T *buf, std::size_t size) + { + std::size_t result = 5381; + for (const T* p = buf; p != buf + size; p++) + result = ((result << 5) + result ) ^ (result >> (32 - 5)) ^ static_cast(*p); + return result; + } + //============================================================ // penum - strongly typed enumeration //============================================================ diff --git a/src/lib/netlist/prg/nltool.cpp b/src/lib/netlist/prg/nltool.cpp index 16fa0d0a6ea..bd0ec17f13c 100644 --- a/src/lib/netlist/prg/nltool.cpp +++ b/src/lib/netlist/prg/nltool.cpp @@ -23,6 +23,11 @@ #include #include // scanf +#ifndef NL_DISABLE_DYNAMIC_LOAD +#define NL_DISABLE_DYNAMIC_LOAD 0 +#endif + + class tool_app_t : public plib::app { public: @@ -47,7 +52,8 @@ public: opt_dir(*this, "d", "dir", "", "output directory for the generated files"), opt_grp4(*this, "Options for run command", "These options are only used by the run command."), - opt_ttr (*this, "t", "time_to_run", 1, "time to run the emulation (seconds)\n\n abc def\n\n xyz"), + opt_ttr (*this, "t", "time_to_run", 1, "time to run the emulation (seconds)"), + opt_boostlib(*this, "", "boost_lib", "builtin", "generic: will use generic solvers.\nbuiltin: Use optimized solvers compiled in.\nsomelib.so: Use library with precompiled solvers."), opt_stats(*this, "s", "statistics", "gather runtime statistics"), opt_logs(*this, "l", "log" , "define terminal to log. This option may be specified repeatedly."), opt_inp(*this, "i", "input", "", "input file to process (default is none)"), @@ -94,6 +100,7 @@ public: plib::option_str opt_dir; plib::option_group opt_grp4; plib::option_num opt_ttr; + plib::option_str opt_boostlib; plib::option_bool opt_stats; plib::option_vec opt_logs; plib::option_str opt_inp; @@ -191,6 +198,23 @@ public: void vlog(const plib::plog_level &l, const pstring &ls) const noexcept override; + plib::unique_ptr static_solver_lib() const override + { + if (m_app.opt_boostlib() == "builtin") + return netlist::callbacks_t::static_solver_lib(); + else if (m_app.opt_boostlib() == "generic") + return plib::make_unique(nullptr); + if (NL_DISABLE_DYNAMIC_LOAD) + { + throw netlist::nl_exception("Dynamic library loading not supported due to project security concerns."); + } + else + { + //pstring libpath = plib::util::environment("NL_BOOSTLIB", plib::util::buildpath({".", "nlboost.so"})); + return plib::make_unique(m_app.opt_boostlib()); + } + } + private: tool_app_t &m_app; }; diff --git a/src/lib/netlist/solver/nld_matrix_solver.cpp b/src/lib/netlist/solver/nld_matrix_solver.cpp index de571826944..9aea4f27f7c 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.cpp +++ b/src/lib/netlist/solver/nld_matrix_solver.cpp @@ -66,6 +66,8 @@ namespace solver void matrix_solver_t::setup_base(const analog_net_t::list_t &nets) { log().debug("New solver setup\n"); + std::vector step_devices; + std::vector dynamic_devices; m_terms.clear(); @@ -90,11 +92,11 @@ namespace solver { case detail::terminal_type::TERMINAL: if (p->device().is_timestep()) - if (!plib::container::contains(m_step_devices, &p->device())) - m_step_devices.push_back(&p->device()); + if (!plib::container::contains(step_devices, &p->device())) + step_devices.push_back(&p->device()); if (p->device().is_dynamic()) - if (!plib::container::contains(m_dynamic_devices, &p->device())) - m_dynamic_devices.push_back(&p->device()); + if (!plib::container::contains(dynamic_devices, &p->device())) + dynamic_devices.push_back(&p->device()); { auto *pterm = dynamic_cast(p); add_term(k, pterm); @@ -131,6 +133,10 @@ namespace solver } } } + for (auto &d : step_devices) + m_step_funcs.push_back(nldelegate_ts(&core_device_t::timestep, d)); + for (auto &d : dynamic_devices) + m_dynamic_funcs.push_back(nldelegate_dyn(&core_device_t::update_terminals, d)); } void matrix_solver_t::sort_terms(matrix_sort_type_e sort) @@ -383,11 +389,11 @@ namespace solver inp->push(inp->proxied_net()->Q_Analog()); } - void matrix_solver_t::update_dynamic() + void matrix_solver_t::update_dynamic() noexcept { // update all non-linear devices - for (auto &dyn : m_dynamic_devices) - dyn->update_terminals(); + for (auto &dyn : m_dynamic_funcs) + dyn(); } void matrix_solver_t::reset() @@ -400,7 +406,7 @@ namespace solver const netlist_time new_timestep = solve(exec().time()); update_inputs(); - if (m_params.m_dynamic_ts && has_timestep_devices() && new_timestep > netlist_time::zero()) + if (m_params.m_dynamic_ts && (timestep_device_count() != 0) && new_timestep > netlist_time::zero()) { m_Q_sync.net().toggle_and_push_to_queue(new_timestep); } @@ -418,17 +424,17 @@ namespace solver update_inputs(); - if (m_params.m_dynamic_ts && has_timestep_devices()) + if (m_params.m_dynamic_ts && (timestep_device_count() != 0)) { m_Q_sync.net().toggle_and_push_to_queue(netlist_time::from_fp(m_params.m_min_timestep)); } } - void matrix_solver_t::step(const netlist_time &delta) + void matrix_solver_t::step(netlist_time delta) noexcept { const auto dd(delta.as_fp()); - for (auto &d : m_step_devices) - d->timestep(dd); + for (auto &d : m_step_funcs) + d(dd); } netlist_time matrix_solver_t::solve(netlist_time_ext now) @@ -445,7 +451,7 @@ namespace solver step(static_cast(delta)); ++m_stat_vsolver_calls; - if (has_dynamic_devices()) + if (dynamic_device_count() != 0) { std::size_t this_resched(0); std::size_t newton_loops = 0; @@ -574,8 +580,8 @@ namespace solver log().verbose("=============================================="); log().verbose("Solver {1}", this->name()); log().verbose(" ==> {1} nets", this->m_terms.size()); //, (*(*groups[i].first())->m_core_terms.first())->name()); - log().verbose(" has {1} elements", this->has_dynamic_devices() ? "dynamic" : "no dynamic"); - log().verbose(" has {1} elements", this->has_timestep_devices() ? "timestep" : "no timestep"); + log().verbose(" has {1} dynamic elements", this->dynamic_device_count()); + log().verbose(" has {1} timestep elements", this->timestep_device_count()); log().verbose(" {1:6.3} average newton raphson loops", static_cast(this->m_stat_newton_raphson) / static_cast(this->m_stat_vsolver_calls)); log().verbose(" {1:10} invocations ({2:6.0} Hz) {3:10} gs fails ({4:6.2} %) {5:6.3} average", diff --git a/src/lib/netlist/solver/nld_matrix_solver.h b/src/lib/netlist/solver/nld_matrix_solver.h index c55844b75ad..0555360e4db 100644 --- a/src/lib/netlist/solver/nld_matrix_solver.h +++ b/src/lib/netlist/solver/nld_matrix_solver.h @@ -182,8 +182,8 @@ namespace solver netlist_time solve(netlist_time_ext now); void update_inputs(); - bool has_dynamic_devices() const noexcept { return !m_dynamic_devices.empty(); } - bool has_timestep_devices() const noexcept { return !m_step_devices.empty(); } + std::size_t dynamic_device_count() const noexcept { return m_dynamic_funcs.size(); } + std::size_t timestep_device_count() const noexcept { return m_step_funcs.size(); } void update_forced(); void update_after(netlist_time after) noexcept @@ -238,8 +238,8 @@ namespace solver state_var m_stat_vsolver_calls; state_var m_last_step; - std::vector m_step_devices; - std::vector m_dynamic_devices; + std::vector m_step_funcs; + std::vector m_dynamic_funcs; logic_input_t m_fb_sync; logic_output_t m_Q_sync; @@ -251,8 +251,8 @@ namespace solver void sort_terms(matrix_sort_type_e sort); - void update_dynamic(); - void step(const netlist_time &delta); + void update_dynamic() noexcept; + void step(netlist_time delta) noexcept; int get_net_idx(const analog_net_t *net) const noexcept; std::pair get_left_right_of_diag(std::size_t irow, std::size_t idiag); @@ -311,7 +311,7 @@ namespace solver plib::parray m_RHS; PALIGNAS_VECTOROPT() - plib::parray2D m_mat_ptr; + plib::pmatrix2d m_mat_ptr; // FIXME: below should be private // state - variable time_stepping diff --git a/src/lib/netlist/solver/nld_ms_gcr.h b/src/lib/netlist/solver/nld_ms_gcr.h index d41a770169e..ddfda80517e 100644 --- a/src/lib/netlist/solver/nld_ms_gcr.h +++ b/src/lib/netlist/solver/nld_ms_gcr.h @@ -124,7 +124,7 @@ namespace solver mat_type mat; - plib::dynproc m_proc; + plib::dynproc m_proc; }; @@ -140,7 +140,45 @@ namespace solver pstring fpsuffix(fp_constants::suffix()); for (std::size_t i = 0; i < mat.nz_num; i++) - strm("{1} m_A{2} = m_A[{3}];\n", fptype, i, i); + strm("{1} m_A{2}(0.0);\n", fptype, i, i); + + for (std::size_t k = 0; k < iN; k++) + { + auto &net = this->m_terms[k]; + + // FIXME: gonn, gtn and Idr - which float types should they have? + + //auto gtot_t = std::accumulate(gt, gt + term_count, plib::constants::zero()); + //*tcr_r[railstart] = static_cast(gtot_t); //mat.A[mat.diag[k]] += gtot_t; + auto pd = this->m_mat_ptr[k][net.railstart()] - &this->mat.A[0]; + pstring terms = plib::pfmt("m_A{1} = gt[{2}]")(pd, this->m_gtn.didx(k,0)); + for (std::size_t i=1; i < net.count(); i++) + terms += plib::pfmt(" + gt[{1}]")(this->m_gtn.didx(k,i)); + + strm("\t{1};\n", terms); + + //for (std::size_t i = 0; i < railstart; i++) + // *tcr_r[i] += static_cast(go[i]); + + for (std::size_t i = 0; i < net.railstart(); i++) + { + auto p = this->m_mat_ptr[k][i] - &this->mat.A[0]; + strm("\tm_A{1} = m_A{1} + go[{2}];\n", p, this->m_gonn.didx(k,i)); + } + + //auto RHS_t(std::accumulate(Idr, Idr + term_count, plib::constants::zero())); + + terms = plib::pfmt("{1} RHS{2} = Idr[{3}]")(fptype, k, this->m_Idrn.didx(k,0)); + for (std::size_t i=1; i < net.count(); i++) + terms += plib::pfmt(" + Idr[{1}]")(this->m_Idrn.didx(k,i)); + //for (std::size_t i = railstart; i < term_count; i++) + // RHS_t += (- go[i]) * *cnV[i]; + + for (std::size_t i = net.railstart(); i < net.count(); i++) + terms += plib::pfmt(" - go[{1}] * *cnV[{1}]")(this->m_gonn.didx(k,i), this->m_connected_net_Vn.didx(k,i)); + + strm("\t{1};\n", terms); + } for (std::size_t i = 0; i < iN - 1; i++) { @@ -178,13 +216,13 @@ namespace solver pj++; pii++; } //RHS[j] += f1 * RHS[i]; - strm("\tRHS[{1}] += f{2}_{3} * RHS[{4}];\n", j, i, j, i); + strm("\tRHS{1} += f{2}_{3} * RHS{4};\n", j, i, j, i); } } } //new_V[iN - 1] = RHS[iN - 1] / mat.A[mat.diag[iN - 1]]; - strm("\tV[{1}] = RHS[{2}] / m_A{3};\n", iN - 1, iN - 1, mat.diag[iN - 1]); + strm("\tV[{1}] = RHS{2} / m_A{3};\n", iN - 1, iN - 1, mat.diag[iN - 1]); for (std::size_t j = iN - 1; j-- > 0;) { strm("\t{1} tmp{2} = 0.0{3};\n", fptype, j, fpsuffix); @@ -193,7 +231,7 @@ namespace solver { strm("\ttmp{1} += m_A{2} * V[{3}];\n", j, pk, mat.col_idx[pk]); } - strm("\tV[{1}] = (RHS[{1}] - tmp{1}) / m_A{4};\n", j, j, j, mat.diag[j]); + strm("\tV[{1}] = (RHS{1} - tmp{1}) / m_A{4};\n", j, j, j, mat.diag[j]); } } @@ -204,8 +242,8 @@ namespace solver t.imbue(std::locale::classic()); plib::putf8_fmt_writer w(&t); generate_code(w); - std::hash::type>::type> h; - return plib::pfmt("nl_gcr_{1:x}_{2}")(h( t.str() ))(mat.nz_num); + //std::hash::type>::type> h; + return plib::pfmt("nl_gcr_{1:x}_{2}")(plib::hash( t.str().c_str(), t.str().size() ))(mat.nz_num); } template @@ -217,7 +255,9 @@ namespace solver pstring name = static_compile_name(); pstring fptype(fp_constants::name()); - strm.writeline(plib::pfmt("extern \"C\" void {1}({2} * __restrict m_A, {2} * __restrict RHS, {2} * __restrict V)\n")(name, fptype)); + strm.writeline(plib::pfmt("extern \"C\" void {1}({2} * __restrict V, " + "{2} * __restrict go, {2} * __restrict gt, " + "{2} * __restrict Idr, {2} ** __restrict cnV)\n")(name, fptype)); strm.writeline("{\n"); generate_code(strm); strm.writeline("}\n"); @@ -228,20 +268,21 @@ namespace solver template unsigned matrix_solver_GCR_t::vsolve_non_dynamic(bool newton_raphson) { - // clear matrix - mat.set_scalar(plib::constants::zero()); - - // populate matrix - this->fill_matrix_and_rhs(); - - // now solve it - if (m_proc.resolved()) { - m_proc(&mat.A[0], &this->m_RHS[0], &this->m_new_V[0]); + m_proc(&this->m_new_V[0], + this->m_gonn.data(), this->m_gtn.data(), this->m_Idrn.data(), + this->m_connected_net_Vn.data()); } else { + // clear matrix + mat.set_scalar(plib::constants::zero()); + + // populate matrix + this->fill_matrix_and_rhs(); + + // now solve it // parallel is slow -- very slow // mat.gaussian_elimination_parallel(RHS); mat.gaussian_elimination(this->m_RHS); diff --git a/src/lib/netlist/solver/nld_solver.cpp b/src/lib/netlist/solver/nld_solver.cpp index 47c585bd14a..551b6ca49a2 100644 --- a/src/lib/netlist/solver/nld_solver.cpp +++ b/src/lib/netlist/solver/nld_solver.cpp @@ -391,8 +391,8 @@ namespace devices log().verbose("Solver {1}", ms->name()); log().verbose(" ==> {1} nets", grp.size()); - log().verbose(" has {1} elements", ms->has_dynamic_devices() ? "dynamic" : "no dynamic"); - log().verbose(" has {1} elements", ms->has_timestep_devices() ? "timestep" : "no timestep"); + log().verbose(" has {1} dynamic elements", ms->dynamic_device_count()); + log().verbose(" has {1} timestep elements", ms->timestep_device_count()); for (auto &n : grp) { log().verbose("Net {1}", n->name()); @@ -403,7 +403,7 @@ namespace devices } m_mat_solvers_all.push_back(ms.get()); - if (ms->has_timestep_devices()) + if (ms->timestep_device_count() != 0) m_mat_solvers_timestepping.push_back(ms.get()); m_mat_solvers.emplace_back(std::move(ms)); diff --git a/src/mame/audio/nl_kidniki.cpp b/src/mame/audio/nl_kidniki.cpp index e36188048bf..fb0866be7cb 100644 --- a/src/mame/audio/nl_kidniki.cpp +++ b/src/mame/audio/nl_kidniki.cpp @@ -6,11 +6,7 @@ #error Somehow nl_base.h made it into the include chain. #endif -#ifndef NLTOOL_VERSION #define USE_FRONTIERS 1 -#else -#define USE_FRONTIERS 1 -#endif /* if we use frontiers, use fixed STV for smaller matrix sizes */ #if (USE_FRONTIERS) @@ -361,7 +357,7 @@ NETLIST_END() NETLIST_START(kidniki) -#if (0 || USE_FRONTIERS) +#if (1 || USE_FRONTIERS) SOLVER(Solver, 48000) PARAM(Solver.ACCURACY, 1e-7) PARAM(Solver.NR_LOOPS, 300)