From 5b6013caea7999deb8d481fbf67b28969d5e79ff Mon Sep 17 00:00:00 2001 From: couriersud Date: Mon, 13 Apr 2020 21:32:00 +0200 Subject: [PATCH] netlist: improve performance up to 65% on audio netlists. [Couriersud] This commit introduces precompiled static solver code. Due to additional optimizations the compiler can use because the detail calculation steps for the solution are known e.g. the kidniki netlist sees a 100% speed increase. In all environments (windows/*nix/osx) the source for the static solver code can be created using bash src/lib/netlist/nl_create_mame_solvers.sh This will create src/lib/netlist/generated/static_solvers.cpp which is compiled into the mame binary. The script is just a temporary workaround. The intention is that nltool whill be able to create this file with one call. There are other improvements in this commit speeding up the processing of timestep and dynamic calculations. --- scripts/src/netlist.lua | 2 + scripts/src/tools.lua | 4 + src/devices/machine/netlist.cpp | 8 +- src/lib/netlist/analog/nld_generic_models.h | 27 +- src/lib/netlist/analog/nlid_twoterm.cpp | 4 +- src/lib/netlist/analog/nlid_twoterm.h | 39 +- src/lib/netlist/devices/nld_mm5837.cpp | 2 +- src/lib/netlist/devices/nld_schmitt.cpp | 2 +- src/lib/netlist/devices/nlid_proxy.cpp | 2 +- src/lib/netlist/generated/static_solvers.cpp | 9871 ++++++++++++++++++ src/lib/netlist/nl_base.cpp | 21 +- src/lib/netlist/nl_base.h | 28 +- src/lib/netlist/nl_create_mame_solvers.sh | 40 + src/lib/netlist/nltypes.h | 4 + src/lib/netlist/plib/pdynlib.cpp | 12 +- src/lib/netlist/plib/pdynlib.h | 134 +- src/lib/netlist/plib/pmatrix2d.h | 14 + src/lib/netlist/plib/putil.h | 13 + src/lib/netlist/prg/nltool.cpp | 26 +- src/lib/netlist/solver/nld_matrix_solver.cpp | 36 +- src/lib/netlist/solver/nld_matrix_solver.h | 14 +- src/lib/netlist/solver/nld_ms_gcr.h | 75 +- src/lib/netlist/solver/nld_solver.cpp | 6 +- src/mame/audio/nl_kidniki.cpp | 6 +- 24 files changed, 10263 insertions(+), 127 deletions(-) create mode 100755 src/lib/netlist/generated/static_solvers.cpp create mode 100644 src/lib/netlist/nl_create_mame_solvers.sh 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)