diff --git a/scripts/target/mame/arcade.lua b/scripts/target/mame/arcade.lua index 36d3b9e739c..76bd4c72507 100644 --- a/scripts/target/mame/arcade.lua +++ b/scripts/target/mame/arcade.lua @@ -1568,7 +1568,33 @@ files { MAME_DIR .. "src/mame/drivers/cinemat.cpp", MAME_DIR .. "src/mame/includes/cinemat.h", MAME_DIR .. "src/mame/audio/cinemat.cpp", + MAME_DIR .. "src/mame/audio/cinemat.h", MAME_DIR .. "src/mame/video/cinemat.cpp", + MAME_DIR .. "src/mame/audio/nl_armora.cpp", + MAME_DIR .. "src/mame/audio/nl_armora.h", + MAME_DIR .. "src/mame/audio/nl_barrier.cpp", + MAME_DIR .. "src/mame/audio/nl_barrier.h", + MAME_DIR .. "src/mame/audio/nl_boxingb.cpp", + MAME_DIR .. "src/mame/audio/nl_boxingb.h", + MAME_DIR .. "src/mame/audio/nl_cinemat_common.h", + MAME_DIR .. "src/mame/audio/nl_ripoff.cpp", + MAME_DIR .. "src/mame/audio/nl_ripoff.h", + MAME_DIR .. "src/mame/audio/nl_solarq.cpp", + MAME_DIR .. "src/mame/audio/nl_solarq.h", + MAME_DIR .. "src/mame/audio/nl_spacewar.cpp", + MAME_DIR .. "src/mame/audio/nl_spacewar.h", + MAME_DIR .. "src/mame/audio/nl_speedfrk.cpp", + MAME_DIR .. "src/mame/audio/nl_speedfrk.h", + MAME_DIR .. "src/mame/audio/nl_starcas.cpp", + MAME_DIR .. "src/mame/audio/nl_starcas.h", + MAME_DIR .. "src/mame/audio/nl_starhawk.cpp", + MAME_DIR .. "src/mame/audio/nl_starhawk.h", + MAME_DIR .. "src/mame/audio/nl_sundance.cpp", + MAME_DIR .. "src/mame/audio/nl_sundance.h", + MAME_DIR .. "src/mame/audio/nl_tailg.cpp", + MAME_DIR .. "src/mame/audio/nl_tailg.h", + MAME_DIR .. "src/mame/audio/nl_warrior.cpp", + MAME_DIR .. "src/mame/audio/nl_warrior.h", MAME_DIR .. "src/mame/drivers/cchasm.cpp", MAME_DIR .. "src/mame/includes/cchasm.h", MAME_DIR .. "src/mame/machine/cchasm.cpp", @@ -4991,7 +5017,7 @@ files { MAME_DIR .. "src/mame/drivers/sothello.cpp", MAME_DIR .. "src/mame/drivers/special_gambl.cpp", MAME_DIR .. "src/mame/audio/special.cpp", - MAME_DIR .. "src/mame/audio/special.h", + MAME_DIR .. "src/mame/audio/special.h", MAME_DIR .. "src/mame/drivers/spool99.cpp", MAME_DIR .. "src/mame/drivers/sprcros2.cpp", MAME_DIR .. "src/mame/drivers/sshot.cpp", diff --git a/scripts/target/mame/nl.lua b/scripts/target/mame/nl.lua index 062527037cd..6d8372a9253 100644 --- a/scripts/target/mame/nl.lua +++ b/scripts/target/mame/nl.lua @@ -204,6 +204,37 @@ files{ MAME_DIR .. "src/mame/includes/cheekyms.h", MAME_DIR .. "src/mame/video/cheekyms.cpp", + MAME_DIR .. "src/mame/drivers/cinemat.cpp", + MAME_DIR .. "src/mame/includes/cinemat.h", + MAME_DIR .. "src/mame/audio/cinemat.cpp", + MAME_DIR .. "src/mame/audio/cinemat.h", + MAME_DIR .. "src/mame/video/cinemat.cpp", + MAME_DIR .. "src/mame/audio/nl_armora.cpp", + MAME_DIR .. "src/mame/audio/nl_armora.h", + MAME_DIR .. "src/mame/audio/nl_barrier.cpp", + MAME_DIR .. "src/mame/audio/nl_barrier.h", + MAME_DIR .. "src/mame/audio/nl_boxingb.cpp", + MAME_DIR .. "src/mame/audio/nl_boxingb.h", + MAME_DIR .. "src/mame/audio/nl_cinemat_common.h", + MAME_DIR .. "src/mame/audio/nl_ripoff.cpp", + MAME_DIR .. "src/mame/audio/nl_ripoff.h", + MAME_DIR .. "src/mame/audio/nl_solarq.cpp", + MAME_DIR .. "src/mame/audio/nl_solarq.h", + MAME_DIR .. "src/mame/audio/nl_spacewar.cpp", + MAME_DIR .. "src/mame/audio/nl_spacewar.h", + MAME_DIR .. "src/mame/audio/nl_speedfrk.cpp", + MAME_DIR .. "src/mame/audio/nl_speedfrk.h", + MAME_DIR .. "src/mame/audio/nl_starcas.cpp", + MAME_DIR .. "src/mame/audio/nl_starcas.h", + MAME_DIR .. "src/mame/audio/nl_starhawk.cpp", + MAME_DIR .. "src/mame/audio/nl_starhawk.h", + MAME_DIR .. "src/mame/audio/nl_sundance.cpp", + MAME_DIR .. "src/mame/audio/nl_sundance.h", + MAME_DIR .. "src/mame/audio/nl_tailg.cpp", + MAME_DIR .. "src/mame/audio/nl_tailg.h", + MAME_DIR .. "src/mame/audio/nl_warrior.cpp", + MAME_DIR .. "src/mame/audio/nl_Warrior.h", + MAME_DIR .. "src/mame/drivers/galaxian.cpp", MAME_DIR .. "src/mame/includes/galaxian.h", MAME_DIR .. "src/mame/audio/galaxian.cpp", diff --git a/src/emu/speaker.cpp b/src/emu/speaker.cpp index 5b3091892de..c8ae8129c74 100644 --- a/src/emu/speaker.cpp +++ b/src/emu/speaker.cpp @@ -36,7 +36,7 @@ speaker_device::speaker_device(const machine_config &mconfig, const char *tag, d , m_x(0.0) , m_y(0.0) , m_z(0.0) -#ifdef MAME_DEBUG +#if SPEAKER_TRACK_MAX_SAMPLE , m_max_sample(0) , m_clipped_samples(0) , m_total_samples(0) @@ -51,10 +51,10 @@ speaker_device::speaker_device(const machine_config &mconfig, const char *tag, d speaker_device::~speaker_device() { -#ifdef MAME_DEBUG +#if SPEAKER_TRACK_MAX_SAMPLE // log the maximum sample values for all speakers if (m_max_sample > 0) - osd_printf_debug("Speaker \"%s\" - max = %d (gain *= %f) - %d%% samples clipped\n", tag(), m_max_sample, 32767.0 / (m_max_sample ? m_max_sample : 1), (int)((double)m_clipped_samples * 100.0 / m_total_samples)); + osd_printf_verbose("Speaker \"%s\" - max = %d (gain *= %f) - %d%% samples clipped\n", tag(), m_max_sample, 32767.0 / (m_max_sample ? m_max_sample : 1), (int)((double)m_clipped_samples * 100.0 / m_total_samples)); #endif } @@ -84,18 +84,23 @@ void speaker_device::mix(s32 *leftmix, s32 *rightmix, int &samples_this_update, } assert(samples_this_update == numsamples); -#ifdef MAME_DEBUG +#if SPEAKER_TRACK_MAX_SAMPLE // debug version: keep track of the maximum sample - for (int sample = 0; sample < samples_this_update; sample++) - { - if (stream_buf[sample] > m_max_sample) - m_max_sample = stream_buf[sample]; - else if (-stream_buf[sample] > m_max_sample) - m_max_sample = -stream_buf[sample]; - if (stream_buf[sample] > 32767 || stream_buf[sample] < -32768) - m_clipped_samples++; - m_total_samples++; - } + // ignore the first 100k or so samples to avoid biasing in favor + // of initial sound glitches + if (m_total_samples < 100000) + m_total_samples += samples_this_update; + else + for (int sample = 0; sample < samples_this_update; sample++) + { + if (stream_buf[sample] > m_max_sample) + m_max_sample = stream_buf[sample]; + else if (-stream_buf[sample] > m_max_sample) + m_max_sample = -stream_buf[sample]; + if (stream_buf[sample] > 32767 || stream_buf[sample] < -32768) + m_clipped_samples++; + m_total_samples++; + } #endif // mix if sound is enabled diff --git a/src/emu/speaker.h b/src/emu/speaker.h index e4f62fb4661..0aa3dc6b66f 100644 --- a/src/emu/speaker.h +++ b/src/emu/speaker.h @@ -26,6 +26,15 @@ #pragma once +#ifndef SPEAKER_TRACK_MAX_SAMPLE +#ifdef MAME_DEBUG +#define SPEAKER_TRACK_MAX_SAMPLE (1) +#else +#define SPEAKER_TRACK_MAX_SAMPLE (0) +#endif +#endif + + //************************************************************************** // GLOBAL VARIABLES //************************************************************************** @@ -81,7 +90,7 @@ protected: double m_z; // internal state -#ifdef MAME_DEBUG +#if SPEAKER_TRACK_MAX_SAMPLE s32 m_max_sample; // largest sample value we've seen s32 m_clipped_samples; // total number of clipped samples s32 m_total_samples; // total number of samples diff --git a/src/lib/netlist/build/makefile b/src/lib/netlist/build/makefile index aa67e465300..8ab72f2d7f9 100644 --- a/src/lib/netlist/build/makefile +++ b/src/lib/netlist/build/makefile @@ -311,7 +311,7 @@ clang: clang-libc: #clang-11 currently broken - #$(MAKE) CC=clang++-11 LD=clang++-11 OBJ=obj/clang CEXTRAFLAGS="-march=native + #$(MAKE) CC=clang++-11 LD=clang++-11 OBJ=obj/clang CEXTRAFLAGS="-march=native $(MAKE) CC=clang++-10 LD=clang++-10 OBJ=obj/clang-libc CEXTRAFLAGS="-march=native \ -stdlib=libc++ -mllvm -inline-threshold=2000 \ -Wunknown-warning-option \ diff --git a/src/lib/netlist/devices/nld_74164.cpp b/src/lib/netlist/devices/nld_74164.cpp index 2907910c8b7..8bbff391157 100644 --- a/src/lib/netlist/devices/nld_74164.cpp +++ b/src/lib/netlist/devices/nld_74164.cpp @@ -20,59 +20,59 @@ namespace netlist NETLIB_OBJECT(74164) { NETLIB_CONSTRUCTOR(74164) - , m_A(*this, "A", NETLIB_DELEGATE(inputs)) - , m_B(*this, "B", NETLIB_DELEGATE(inputs)) - , m_CLRQ(*this, "CLRQ", NETLIB_DELEGATE(inputs)) - , m_CLK(*this, "CLK", NETLIB_DELEGATE(inputs)) + , m_AB(*this, {"A", "B"}, NETLIB_DELEGATE(ab)) + , m_CLRQ(*this, "CLRQ", NETLIB_DELEGATE(clrq)) + , m_CLK(*this, "CLK", NETLIB_DELEGATE(clk)) , m_cnt(*this, "m_cnt", 0) - , m_last_CLK(*this, "m_last_CLK", 0) + , m_ab(*this, "m_ab", 0) , m_Q(*this, {"QA", "QB", "QC", "QD", "QE", "QF", "QG", "QH"}) , m_power_pins(*this) { } - NETLIB_HANDLERI(inputs) + private: + NETLIB_RESETI() { - if (!m_CLRQ()) - { - m_cnt = 0; - } - else if (m_CLK() && !m_last_CLK) - { - m_cnt = (m_cnt << 1) & 0xfe; - if (m_A() && m_B()) - { - m_cnt |= 0x01; - } - else - { - m_cnt &= 0xfe; - } - } + m_CLK.set_state(logic_t::STATE_INP_LH); + m_cnt = 0; + } - m_last_CLK = m_CLK(); - - for (std::size_t i=0; i<8; i++) + NETLIB_HANDLERI(clrq) + { + if (m_CLRQ()) { - m_Q[i].push((m_cnt >> i) & 1, NLTIME_FROM_NS(30)); + m_CLK.activate_lh(); + } + else + { + m_CLK.inactivate(); + if (m_cnt != 0) + { + m_cnt = 0; + m_Q.push(0, NLTIME_FROM_NS(30)); + } } } - NETLIB_RESETI() + NETLIB_HANDLERI(clk) { - m_cnt = 0; - m_last_CLK = 0; + m_cnt = (m_cnt << 1) | m_ab; + m_Q.push(m_cnt, NLTIME_FROM_NS(30)); + } + + NETLIB_HANDLERI(ab) + { + m_ab = static_cast((m_AB() == 3) ? 1 : 0); } friend class NETLIB_NAME(74164_dip); private: - logic_input_t m_A; - logic_input_t m_B; + object_array_t m_AB; logic_input_t m_CLRQ; logic_input_t m_CLK; state_var m_cnt; - state_var m_last_CLK; + state_var m_ab; object_array_t m_Q; nld_power_pins m_power_pins; @@ -83,8 +83,8 @@ namespace netlist NETLIB_CONSTRUCTOR(74164_dip) , A(*this, "A") { - register_subalias("1", A.m_A); - register_subalias("2", A.m_B); + register_subalias("1", A.m_AB[0]); + register_subalias("2", A.m_AB[1]); register_subalias("3", A.m_Q[0]); register_subalias("4", A.m_Q[1]); register_subalias("5", A.m_Q[2]); diff --git a/src/lib/netlist/devices/nld_74393.cpp b/src/lib/netlist/devices/nld_74393.cpp index 09ac49e8ffb..10195cee0ae 100644 --- a/src/lib/netlist/devices/nld_74393.cpp +++ b/src/lib/netlist/devices/nld_74393.cpp @@ -17,8 +17,8 @@ namespace netlist NETLIB_OBJECT(74393) { NETLIB_CONSTRUCTOR(74393) - , m_CP(*this, "CP", NETLIB_DELEGATE(inputs)) - , m_MR(*this, "MR", NETLIB_DELEGATE(inputs)) + , m_CP(*this, "CP", NETLIB_DELEGATE(cp)) + , m_MR(*this, "MR", NETLIB_DELEGATE(mr)) , m_Q(*this, {"Q0", "Q1", "Q2", "Q3"}) , m_cnt(*this, "m_cnt", 0) , m_cp(*this, "m_cp", 0) @@ -30,30 +30,37 @@ namespace netlist private: NETLIB_RESETI() { + m_CP.set_state(logic_t::STATE_INP_HL); m_cnt = 0; } - NETLIB_HANDLERI(inputs) + NETLIB_HANDLERI(mr) { - netlist_sig_t last_cp = m_cp; - netlist_sig_t last_mr = m_mr; - - m_cp = m_CP(); - m_mr = m_MR(); - - if (!last_mr && m_mr) + if (!m_MR()) { - m_cnt = 0; - update_outputs_all(0, NLTIME_FROM_NS(24), NLTIME_FROM_NS(24), NLTIME_FROM_NS(24), NLTIME_FROM_NS(24)); + m_CP.activate_hl(); } - else if (!m_mr && last_cp && !m_cp) + else { - auto cnt = (m_cnt + 1) & MAXCNT; - update_outputs_all(cnt, NLTIME_FROM_NS(13), NLTIME_FROM_NS(22), NLTIME_FROM_NS(31), NLTIME_FROM_NS(40)); - m_cnt = cnt; + m_CP.inactivate(); + if (m_cnt != 0) + { + m_cnt = 0; + m_Q.push(0, NLTIME_FROM_NS(24)); + } } } + NETLIB_HANDLERI(cp) + { + auto cnt = (m_cnt + 1) & MAXCNT; + m_cnt = cnt; + m_Q[0].push((cnt >> 0) & 1, NLTIME_FROM_NS(13)); + m_Q[1].push((cnt >> 1) & 1, NLTIME_FROM_NS(22)); + m_Q[2].push((cnt >> 2) & 1, NLTIME_FROM_NS(31)); + m_Q[3].push((cnt >> 3) & 1, NLTIME_FROM_NS(40)); + } + logic_input_t m_CP; logic_input_t m_MR; object_array_t m_Q; @@ -63,14 +70,6 @@ namespace netlist state_var_sig m_mr; nld_power_pins m_power_pins; - - void update_outputs_all(unsigned cnt, netlist_time q0_delay, netlist_time q1_delay, netlist_time q2_delay, netlist_time q3_delay) noexcept - { - m_Q[0].push((cnt >> 0) & 1, q0_delay); - m_Q[1].push((cnt >> 1) & 1, q1_delay); - m_Q[2].push((cnt >> 2) & 1, q2_delay); - m_Q[3].push((cnt >> 3) & 1, q3_delay); - } }; NETLIB_OBJECT(74393_dip) diff --git a/src/lib/netlist/generated/static_solvers.cpp b/src/lib/netlist/generated/static_solvers.cpp index 3b06b7e2c45..9f92726c922 100644 --- a/src/lib/netlist/generated/static_solvers.cpp +++ b/src/lib/netlist/generated/static_solvers.cpp @@ -474,6 +474,184 @@ static void nl_gcr_10d27c48eccd37d0_22_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// sundance +static void nl_gcr_113b7d8ac4b72b66_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A4 += go[2]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[7]; + m_A7 += go[8]; + m_A5 += go[9]; + m_A5 += go[10]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[11] * *cnV[11]; + m_A11 += gt[12]; + m_A11 += gt[13]; + m_A11 += gt[14]; + m_A11 += gt[15]; + m_A11 += gt[16]; + m_A10 += go[12]; + m_A10 += go[13]; + m_A9 += go[14]; + m_A8 += go[15]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 -= go[16] * *cnV[16]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A11 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + m_A7 += 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_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_A3 * V[2]; + tmp1 += m_A4 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// starcas +static void nl_gcr_140a712e16ff3c5e_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A4 += go[2]; + m_A3 += go[3]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[4] * *cnV[4]; + m_A7 += gt[5]; + m_A7 += gt[6]; + m_A7 += gt[7]; + m_A6 += go[5]; + m_A5 += go[6]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[7] * *cnV[7]; + m_A11 += gt[8]; + m_A11 += gt[9]; + m_A11 += gt[10]; + m_A9 += go[8]; + double RHS3 = Idr[8]; + RHS3 += Idr[9]; + RHS3 += Idr[10]; + RHS3 -= go[9] * *cnV[9]; + RHS3 -= go[10] * *cnV[10]; + 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; +} + // gunfight static void nl_gcr_14360daccbfc23c0_112_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -1179,6 +1357,712 @@ static void nl_gcr_14360daccbfc23c0_112_double_double(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// tailg +static void nl_gcr_15a30e6a101b5415_119_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A8 += go[6]; + m_A7 += go[7]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + m_A9 += gt[8]; + m_A9 += gt[9]; + m_A10 += go[8]; + m_A11 += go[9]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + m_A12 += gt[10]; + m_A12 += gt[11]; + m_A12 += gt[12]; + m_A12 += gt[13]; + m_A12 += gt[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A13 += go[10]; + double RHS5 = Idr[10]; + RHS5 += Idr[11]; + RHS5 += Idr[12]; + RHS5 += Idr[13]; + RHS5 += Idr[14]; + RHS5 += Idr[15]; + RHS5 += Idr[16]; + RHS5 -= go[11] * *cnV[11]; + RHS5 -= go[12] * *cnV[12]; + RHS5 -= go[13] * *cnV[13]; + RHS5 -= go[14] * *cnV[14]; + RHS5 -= go[15] * *cnV[15]; + RHS5 -= go[16] * *cnV[16]; + m_A14 += gt[17]; + m_A14 += gt[18]; + m_A16 += go[17]; + m_A15 += go[18]; + double RHS6 = Idr[17]; + RHS6 += Idr[18]; + m_A17 += gt[19]; + m_A17 += gt[20]; + m_A18 += go[19]; + double RHS7 = Idr[19]; + RHS7 += Idr[20]; + RHS7 -= go[20] * *cnV[20]; + m_A19 += gt[21]; + m_A19 += gt[22]; + m_A19 += gt[23]; + m_A20 += go[21]; + m_A21 += go[22]; + double RHS8 = Idr[21]; + RHS8 += Idr[22]; + RHS8 += Idr[23]; + RHS8 -= go[23] * *cnV[23]; + m_A22 += gt[24]; + m_A22 += gt[25]; + m_A24 += go[24]; + m_A23 += go[25]; + double RHS9 = Idr[24]; + RHS9 += Idr[25]; + m_A25 += gt[26]; + m_A25 += gt[27]; + m_A25 += gt[28]; + m_A27 += go[26]; + m_A26 += go[27]; + double RHS10 = Idr[26]; + RHS10 += Idr[27]; + RHS10 += Idr[28]; + RHS10 -= go[28] * *cnV[28]; + m_A28 += gt[29]; + m_A28 += gt[30]; + m_A28 += gt[31]; + m_A29 += go[29]; + double RHS11 = Idr[29]; + RHS11 += Idr[30]; + RHS11 += Idr[31]; + RHS11 -= go[30] * *cnV[30]; + RHS11 -= go[31] * *cnV[31]; + m_A30 += gt[32]; + m_A30 += gt[33]; + m_A30 += gt[34]; + m_A31 += go[32]; + double RHS12 = Idr[32]; + RHS12 += Idr[33]; + RHS12 += Idr[34]; + RHS12 -= go[33] * *cnV[33]; + RHS12 -= go[34] * *cnV[34]; + m_A32 += gt[35]; + m_A32 += gt[36]; + m_A33 += go[35]; + m_A34 += go[36]; + double RHS13 = Idr[35]; + RHS13 += Idr[36]; + m_A35 += gt[37]; + m_A35 += gt[38]; + m_A35 += gt[39]; + m_A36 += go[37]; + double RHS14 = Idr[37]; + RHS14 += Idr[38]; + RHS14 += Idr[39]; + RHS14 -= go[38] * *cnV[38]; + RHS14 -= go[39] * *cnV[39]; + m_A37 += gt[40]; + m_A37 += gt[41]; + m_A37 += gt[42]; + m_A38 += go[40]; + double RHS15 = Idr[40]; + RHS15 += Idr[41]; + RHS15 += Idr[42]; + RHS15 -= go[41] * *cnV[41]; + RHS15 -= go[42] * *cnV[42]; + m_A39 += gt[43]; + m_A39 += gt[44]; + m_A40 += go[43]; + m_A41 += go[44]; + double RHS16 = Idr[43]; + RHS16 += Idr[44]; + m_A42 += gt[45]; + m_A42 += gt[46]; + m_A42 += gt[47]; + m_A44 += go[45]; + m_A43 += go[46]; + double RHS17 = Idr[45]; + RHS17 += Idr[46]; + RHS17 += Idr[47]; + RHS17 -= go[47] * *cnV[47]; + m_A47 += gt[48]; + m_A47 += gt[49]; + m_A47 += gt[50]; + m_A46 += go[48]; + m_A45 += go[49]; + double RHS18 = Idr[48]; + RHS18 += Idr[49]; + RHS18 += Idr[50]; + RHS18 -= go[50] * *cnV[50]; + m_A51 += gt[51]; + m_A51 += gt[52]; + m_A51 += gt[53]; + m_A50 += go[51]; + m_A49 += go[52]; + double RHS19 = Idr[51]; + RHS19 += Idr[52]; + RHS19 += Idr[53]; + RHS19 -= go[53] * *cnV[53]; + m_A58 += gt[54]; + m_A58 += gt[55]; + m_A58 += gt[56]; + m_A58 += gt[57]; + m_A58 += gt[58]; + m_A54 += go[54]; + m_A56 += go[55]; + m_A55 += go[56]; + m_A53 += go[57]; + double RHS20 = Idr[54]; + RHS20 += Idr[55]; + RHS20 += Idr[56]; + RHS20 += Idr[57]; + RHS20 += Idr[58]; + RHS20 -= go[58] * *cnV[58]; + m_A64 += gt[59]; + m_A64 += gt[60]; + m_A64 += gt[61]; + m_A62 += go[59]; + m_A61 += go[60]; + double RHS21 = Idr[59]; + RHS21 += Idr[60]; + RHS21 += Idr[61]; + RHS21 -= go[61] * *cnV[61]; + m_A69 += gt[62]; + m_A69 += gt[63]; + m_A67 += go[62]; + double RHS22 = Idr[62]; + RHS22 += Idr[63]; + RHS22 -= go[63] * *cnV[63]; + m_A75 += gt[64]; + m_A75 += gt[65]; + m_A75 += gt[66]; + m_A75 += gt[67]; + m_A75 += gt[68]; + m_A77 += go[64]; + m_A71 += go[65]; + m_A76 += go[66]; + double RHS23 = Idr[64]; + RHS23 += Idr[65]; + RHS23 += Idr[66]; + RHS23 += Idr[67]; + RHS23 += Idr[68]; + RHS23 -= go[67] * *cnV[67]; + RHS23 -= go[68] * *cnV[68]; + m_A81 += gt[69]; + m_A81 += gt[70]; + m_A81 += gt[71]; + m_A80 += go[69]; + m_A79 += go[70]; + m_A78 += go[71]; + double RHS24 = Idr[69]; + RHS24 += Idr[70]; + RHS24 += Idr[71]; + m_A84 += gt[72]; + m_A84 += gt[73]; + m_A84 += gt[74]; + m_A84 += gt[75]; + m_A86 += go[72]; + m_A86 += go[73]; + m_A83 += go[74]; + double RHS25 = Idr[72]; + RHS25 += Idr[73]; + RHS25 += Idr[74]; + RHS25 += Idr[75]; + RHS25 -= go[75] * *cnV[75]; + m_A90 += gt[76]; + m_A90 += gt[77]; + m_A90 += gt[78]; + m_A89 += go[76]; + m_A88 += go[77]; + m_A87 += go[78]; + double RHS26 = Idr[76]; + RHS26 += Idr[77]; + RHS26 += Idr[78]; + m_A98 += gt[79]; + m_A98 += gt[80]; + m_A98 += gt[81]; + m_A98 += gt[82]; + m_A98 += gt[83]; + m_A95 += go[79]; + m_A94 += go[80]; + m_A93 += go[81]; + m_A92 += go[82]; + double RHS27 = Idr[79]; + RHS27 += Idr[80]; + RHS27 += Idr[81]; + RHS27 += Idr[82]; + RHS27 += Idr[83]; + RHS27 -= go[83] * *cnV[83]; + m_A103 += gt[84]; + m_A103 += gt[85]; + m_A103 += gt[86]; + m_A100 += go[84]; + m_A101 += go[85]; + double RHS28 = Idr[84]; + RHS28 += Idr[85]; + RHS28 += Idr[86]; + RHS28 -= go[86] * *cnV[86]; + m_A110 += gt[87]; + m_A110 += gt[88]; + m_A106 += go[87]; + m_A107 += go[88]; + double RHS29 = Idr[87]; + RHS29 += Idr[88]; + m_A118 += gt[89]; + m_A118 += gt[90]; + m_A118 += gt[91]; + m_A118 += gt[92]; + m_A118 += gt[93]; + m_A118 += gt[94]; + m_A112 += go[89]; + m_A113 += go[90]; + m_A115 += go[91]; + m_A115 += go[92]; + double RHS30 = Idr[89]; + RHS30 += Idr[90]; + RHS30 += Idr[91]; + RHS30 += Idr[92]; + RHS30 += Idr[93]; + RHS30 += Idr[94]; + RHS30 -= go[93] * *cnV[93]; + RHS30 -= go[94] * *cnV[94]; + const double f0 = 1.0 / m_A0; + const double f0_18 = -f0 * m_A45; + m_A47 += m_A1 * f0_18; + RHS18 += f0_18 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_20 = -f1 * m_A53; + m_A58 += m_A3 * f1_20; + RHS20 += f1_20 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_27 = -f2 * m_A92; + m_A98 += m_A5 * f2_27; + RHS27 += f2_27 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_20 = -f3 * m_A54; + m_A58 += m_A7 * f3_20; + m_A60 += m_A8 * f3_20; + RHS20 += f3_20 * RHS3; + const double f3_23 = -f3 * m_A71; + m_A72 += m_A7 * f3_23; + m_A75 += m_A8 * f3_23; + RHS23 += f3_23 * RHS3; + const double f4 = 1.0 / m_A9; + const double f4_25 = -f4 * m_A83; + m_A84 += m_A10 * f4_25; + m_A85 += m_A11 * f4_25; + RHS25 += f4_25 * RHS4; + const double f4_28 = -f4 * m_A100; + m_A102 += m_A10 * f4_28; + m_A103 += m_A11 * f4_28; + RHS28 += f4_28 * RHS4; + const double f5 = 1.0 / m_A12; + const double f5_30 = -f5 * m_A112; + m_A115 += m_A13 * f5_30; + RHS30 += f5_30 * RHS5; + const double f6 = 1.0 / m_A14; + const double f6_18 = -f6 * m_A46; + m_A47 += m_A15 * f6_18; + m_A48 += m_A16 * f6_18; + RHS18 += f6_18 * RHS6; + const double f6_30 = -f6 * m_A113; + m_A114 += m_A15 * f6_30; + m_A118 += m_A16 * f6_30; + RHS30 += f6_30 * RHS6; + const double f7 = 1.0 / m_A17; + const double f7_19 = -f7 * m_A49; + m_A51 += m_A18 * f7_19; + RHS19 += f7_19 * RHS7; + const double f8 = 1.0 / m_A19; + const double f8_19 = -f8 * m_A50; + m_A51 += m_A20 * f8_19; + m_A52 += m_A21 * f8_19; + RHS19 += f8_19 * RHS8; + const double f8_20 = -f8 * m_A55; + m_A57 += m_A20 * f8_20; + m_A58 += m_A21 * f8_20; + RHS20 += f8_20 * RHS8; + const double f9 = 1.0 / m_A22; + const double f9_20 = -f9 * m_A56; + m_A58 += m_A23 * f9_20; + m_A59 += m_A24 * f9_20; + RHS20 += f9_20 * RHS9; + const double f9_21 = -f9 * m_A61; + m_A63 += m_A23 * f9_21; + m_A64 += m_A24 * f9_21; + RHS21 += f9_21 * RHS9; + const double f10 = 1.0 / m_A25; + const double f10_21 = -f10 * m_A62; + m_A64 += m_A26 * f10_21; + m_A65 += m_A27 * f10_21; + RHS21 += f10_21 * RHS10; + const double f10_22 = -f10 * m_A67; + m_A68 += m_A26 * f10_22; + m_A69 += m_A27 * f10_22; + RHS22 += f10_22 * RHS10; + const double f11 = 1.0 / m_A28; + const double f11_24 = -f11 * m_A78; + m_A81 += m_A29 * f11_24; + RHS24 += f11_24 * RHS11; + const double f12 = 1.0 / m_A30; + const double f12_24 = -f12 * m_A79; + m_A81 += m_A31 * f12_24; + RHS24 += f12_24 * RHS12; + const double f13 = 1.0 / m_A32; + const double f13_24 = -f13 * m_A80; + m_A81 += m_A33 * f13_24; + m_A82 += m_A34 * f13_24; + RHS24 += f13_24 * RHS13; + const double f13_27 = -f13 * m_A93; + m_A96 += m_A33 * f13_27; + m_A98 += m_A34 * f13_27; + RHS27 += f13_27 * RHS13; + const double f14 = 1.0 / m_A35; + const double f14_26 = -f14 * m_A87; + m_A90 += m_A36 * f14_26; + RHS26 += f14_26 * RHS14; + const double f15 = 1.0 / m_A37; + const double f15_26 = -f15 * m_A88; + m_A90 += m_A38 * f15_26; + RHS26 += f15_26 * RHS15; + const double f16 = 1.0 / m_A39; + const double f16_26 = -f16 * m_A89; + m_A90 += m_A40 * f16_26; + m_A91 += m_A41 * f16_26; + RHS26 += f16_26 * RHS16; + const double f16_27 = -f16 * m_A94; + m_A97 += m_A40 * f16_27; + m_A98 += m_A41 * f16_27; + RHS27 += f16_27 * RHS16; + const double f17 = 1.0 / m_A42; + const double f17_27 = -f17 * m_A95; + m_A98 += m_A43 * f17_27; + m_A99 += m_A44 * f17_27; + RHS27 += f17_27 * RHS17; + const double f17_29 = -f17 * m_A106; + m_A108 += m_A43 * f17_29; + m_A110 += m_A44 * f17_29; + RHS29 += f17_29 * RHS17; + const double f18 = 1.0 / m_A47; + const double f18_30 = -f18 * m_A114; + m_A118 += m_A48 * f18_30; + RHS30 += f18_30 * RHS18; + const double f19 = 1.0 / m_A51; + const double f19_20 = -f19 * m_A57; + m_A58 += m_A52 * f19_20; + RHS20 += f19_20 * RHS19; + const double f20 = 1.0 / m_A58; + const double f20_21 = -f20 * m_A63; + m_A64 += m_A59 * f20_21; + m_A66 += m_A60 * f20_21; + RHS21 += f20_21 * RHS20; + const double f20_23 = -f20 * m_A72; + m_A73 += m_A59 * f20_23; + m_A75 += m_A60 * f20_23; + RHS23 += f20_23 * RHS20; + const double f21 = 1.0 / m_A64; + const double f21_22 = -f21 * m_A68; + m_A69 += m_A65 * f21_22; + m_A70 += m_A66 * f21_22; + RHS22 += f21_22 * RHS21; + const double f21_23 = -f21 * m_A73; + m_A74 += m_A65 * f21_23; + m_A75 += m_A66 * f21_23; + RHS23 += f21_23 * RHS21; + const double f22 = 1.0 / m_A69; + const double f22_23 = -f22 * m_A74; + m_A75 += m_A70 * f22_23; + RHS23 += f22_23 * RHS22; + const double f23 = 1.0 / m_A75; + const double f23_28 = -f23 * m_A101; + m_A103 += m_A76 * f23_28; + m_A104 += m_A77 * f23_28; + RHS28 += f23_28 * RHS23; + const double f23_29 = -f23 * m_A107; + m_A109 += m_A76 * f23_29; + m_A110 += m_A77 * f23_29; + RHS29 += f23_29 * RHS23; + const double f24 = 1.0 / m_A81; + const double f24_27 = -f24 * m_A96; + m_A98 += m_A82 * f24_27; + RHS27 += f24_27 * RHS24; + const double f25 = 1.0 / m_A84; + const double f25_28 = -f25 * m_A102; + m_A103 += m_A85 * f25_28; + m_A105 += m_A86 * f25_28; + RHS28 += f25_28 * RHS25; + const double f25_30 = -f25 * m_A115; + m_A116 += m_A85 * f25_30; + m_A118 += m_A86 * f25_30; + RHS30 += f25_30 * RHS25; + const double f26 = 1.0 / m_A90; + const double f26_27 = -f26 * m_A97; + m_A98 += m_A91 * f26_27; + RHS27 += f26_27 * RHS26; + const double f27 = 1.0 / m_A98; + const double f27_29 = -f27 * m_A108; + m_A110 += m_A99 * f27_29; + RHS29 += f27_29 * RHS27; + const double f28 = 1.0 / m_A103; + const double f28_29 = -f28 * m_A109; + m_A110 += m_A104 * f28_29; + m_A111 += m_A105 * f28_29; + RHS29 += f28_29 * RHS28; + const double f28_30 = -f28 * m_A116; + m_A117 += m_A104 * f28_30; + m_A118 += m_A105 * f28_30; + RHS30 += f28_30 * RHS28; + const double f29 = 1.0 / m_A110; + const double f29_30 = -f29 * m_A117; + m_A118 += m_A111 * f29_30; + RHS30 += f29_30 * RHS29; + V[30] = RHS30 / m_A118; + double tmp29 = 0.0; + tmp29 += m_A111 * V[30]; + V[29] = (RHS29 - tmp29) / m_A110; + double tmp28 = 0.0; + tmp28 += m_A104 * V[29]; + tmp28 += m_A105 * V[30]; + V[28] = (RHS28 - tmp28) / m_A103; + double tmp27 = 0.0; + tmp27 += m_A99 * V[29]; + V[27] = (RHS27 - tmp27) / m_A98; + double tmp26 = 0.0; + tmp26 += m_A91 * V[27]; + V[26] = (RHS26 - tmp26) / m_A90; + double tmp25 = 0.0; + tmp25 += m_A85 * V[28]; + tmp25 += m_A86 * V[30]; + V[25] = (RHS25 - tmp25) / m_A84; + double tmp24 = 0.0; + tmp24 += m_A82 * V[27]; + V[24] = (RHS24 - tmp24) / m_A81; + double tmp23 = 0.0; + tmp23 += m_A76 * V[28]; + tmp23 += m_A77 * V[29]; + V[23] = (RHS23 - tmp23) / m_A75; + double tmp22 = 0.0; + tmp22 += m_A70 * V[23]; + V[22] = (RHS22 - tmp22) / m_A69; + double tmp21 = 0.0; + tmp21 += m_A65 * V[22]; + tmp21 += m_A66 * V[23]; + V[21] = (RHS21 - tmp21) / m_A64; + double tmp20 = 0.0; + tmp20 += m_A59 * V[21]; + tmp20 += m_A60 * V[23]; + V[20] = (RHS20 - tmp20) / m_A58; + double tmp19 = 0.0; + tmp19 += m_A52 * V[20]; + V[19] = (RHS19 - tmp19) / m_A51; + double tmp18 = 0.0; + tmp18 += m_A48 * V[30]; + V[18] = (RHS18 - tmp18) / m_A47; + double tmp17 = 0.0; + tmp17 += m_A43 * V[27]; + tmp17 += m_A44 * V[29]; + V[17] = (RHS17 - tmp17) / m_A42; + double tmp16 = 0.0; + tmp16 += m_A40 * V[26]; + tmp16 += m_A41 * V[27]; + V[16] = (RHS16 - tmp16) / m_A39; + double tmp15 = 0.0; + tmp15 += m_A38 * V[26]; + V[15] = (RHS15 - tmp15) / m_A37; + double tmp14 = 0.0; + tmp14 += m_A36 * V[26]; + V[14] = (RHS14 - tmp14) / m_A35; + double tmp13 = 0.0; + tmp13 += m_A33 * V[24]; + tmp13 += m_A34 * V[27]; + V[13] = (RHS13 - tmp13) / m_A32; + double tmp12 = 0.0; + tmp12 += m_A31 * V[24]; + V[12] = (RHS12 - tmp12) / m_A30; + double tmp11 = 0.0; + tmp11 += m_A29 * V[24]; + V[11] = (RHS11 - tmp11) / m_A28; + double tmp10 = 0.0; + tmp10 += m_A26 * V[21]; + tmp10 += m_A27 * V[22]; + V[10] = (RHS10 - tmp10) / m_A25; + double tmp9 = 0.0; + tmp9 += m_A23 * V[20]; + tmp9 += m_A24 * V[21]; + V[9] = (RHS9 - tmp9) / m_A22; + double tmp8 = 0.0; + tmp8 += m_A20 * V[19]; + tmp8 += m_A21 * V[20]; + V[8] = (RHS8 - tmp8) / m_A19; + double tmp7 = 0.0; + tmp7 += m_A18 * V[19]; + V[7] = (RHS7 - tmp7) / m_A17; + double tmp6 = 0.0; + tmp6 += m_A15 * V[18]; + tmp6 += m_A16 * V[30]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A13 * V[25]; + V[5] = (RHS5 - tmp5) / m_A12; + double tmp4 = 0.0; + tmp4 += m_A10 * V[25]; + tmp4 += m_A11 * V[28]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[20]; + tmp3 += m_A8 * V[23]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[27]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[20]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[18]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // breakout static void nl_gcr_15a4e7fbe5facb3a_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -1232,6 +2116,3517 @@ static void nl_gcr_15a4e7fbe5facb3a_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// warrior +static void nl_gcr_15b8f0979c29b8e7_89_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A7 += go[6]; + m_A8 += go[7]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + m_A9 += gt[8]; + m_A9 += gt[9]; + m_A11 += go[8]; + m_A10 += go[9]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + m_A12 += gt[10]; + m_A12 += gt[11]; + m_A12 += gt[12]; + m_A12 += gt[13]; + m_A12 += gt[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A13 += go[10]; + double RHS5 = Idr[10]; + RHS5 += Idr[11]; + RHS5 += Idr[12]; + RHS5 += Idr[13]; + RHS5 += Idr[14]; + RHS5 += Idr[15]; + RHS5 += Idr[16]; + RHS5 -= go[11] * *cnV[11]; + RHS5 -= go[12] * *cnV[12]; + RHS5 -= go[13] * *cnV[13]; + RHS5 -= go[14] * *cnV[14]; + RHS5 -= go[15] * *cnV[15]; + RHS5 -= go[16] * *cnV[16]; + m_A14 += gt[17]; + m_A14 += gt[18]; + m_A16 += go[17]; + m_A15 += go[18]; + double RHS6 = Idr[17]; + RHS6 += Idr[18]; + m_A17 += gt[19]; + m_A17 += gt[20]; + m_A19 += go[19]; + m_A18 += go[20]; + double RHS7 = Idr[19]; + RHS7 += Idr[20]; + m_A20 += gt[21]; + m_A20 += gt[22]; + m_A21 += go[21]; + double RHS8 = Idr[21]; + RHS8 += Idr[22]; + RHS8 -= go[22] * *cnV[22]; + m_A22 += gt[23]; + m_A22 += gt[24]; + m_A22 += gt[25]; + m_A24 += go[23]; + m_A23 += go[24]; + double RHS9 = Idr[23]; + RHS9 += Idr[24]; + RHS9 += Idr[25]; + RHS9 -= go[25] * *cnV[25]; + m_A25 += gt[26]; + m_A25 += gt[27]; + m_A26 += go[26]; + double RHS10 = Idr[26]; + RHS10 += Idr[27]; + RHS10 -= go[27] * *cnV[27]; + m_A27 += gt[28]; + m_A27 += gt[29]; + m_A27 += gt[30]; + m_A28 += go[28]; + m_A29 += go[29]; + double RHS11 = Idr[28]; + RHS11 += Idr[29]; + RHS11 += Idr[30]; + RHS11 -= go[30] * *cnV[30]; + m_A32 += gt[31]; + m_A32 += gt[32]; + m_A32 += gt[33]; + m_A31 += go[31]; + m_A30 += go[32]; + double RHS12 = Idr[31]; + RHS12 += Idr[32]; + RHS12 += Idr[33]; + RHS12 -= go[33] * *cnV[33]; + m_A35 += gt[34]; + m_A35 += gt[35]; + m_A35 += gt[36]; + m_A34 += go[34]; + m_A37 += go[35]; + double RHS13 = Idr[34]; + RHS13 += Idr[35]; + RHS13 += Idr[36]; + RHS13 -= go[36] * *cnV[36]; + m_A40 += gt[37]; + m_A40 += gt[38]; + m_A40 += gt[39]; + m_A39 += go[37]; + m_A38 += go[38]; + double RHS14 = Idr[37]; + RHS14 += Idr[38]; + RHS14 += Idr[39]; + RHS14 -= go[39] * *cnV[39]; + m_A43 += gt[40]; + m_A43 += gt[41]; + m_A43 += gt[42]; + m_A44 += go[40]; + m_A42 += go[41]; + double RHS15 = Idr[40]; + RHS15 += Idr[41]; + RHS15 += Idr[42]; + RHS15 -= go[42] * *cnV[42]; + m_A47 += gt[43]; + m_A47 += gt[44]; + m_A47 += gt[45]; + m_A47 += gt[46]; + m_A49 += go[43]; + m_A49 += go[44]; + m_A45 += go[45]; + double RHS16 = Idr[43]; + RHS16 += Idr[44]; + RHS16 += Idr[45]; + RHS16 += Idr[46]; + RHS16 -= go[46] * *cnV[46]; + m_A52 += gt[47]; + m_A52 += gt[48]; + m_A50 += go[47]; + m_A53 += go[48]; + double RHS17 = Idr[47]; + RHS17 += Idr[48]; + m_A56 += gt[49]; + m_A56 += gt[50]; + m_A56 += gt[51]; + m_A55 += go[49]; + m_A54 += go[50]; + double RHS18 = Idr[49]; + RHS18 += Idr[50]; + RHS18 += Idr[51]; + RHS18 -= go[51] * *cnV[51]; + m_A62 += gt[52]; + m_A62 += gt[53]; + m_A62 += gt[54]; + m_A62 += gt[55]; + m_A58 += go[52]; + m_A59 += go[53]; + m_A60 += go[54]; + double RHS19 = Idr[52]; + RHS19 += Idr[53]; + RHS19 += Idr[54]; + RHS19 += Idr[55]; + RHS19 -= go[55] * *cnV[55]; + m_A69 += gt[56]; + m_A69 += gt[57]; + m_A69 += gt[58]; + m_A66 += go[56]; + m_A67 += go[57]; + double RHS20 = Idr[56]; + RHS20 += Idr[57]; + RHS20 += Idr[58]; + RHS20 -= go[58] * *cnV[58]; + m_A78 += gt[59]; + m_A78 += gt[60]; + m_A78 += gt[61]; + m_A78 += gt[62]; + m_A78 += gt[63]; + m_A78 += gt[64]; + m_A72 += go[59]; + m_A73 += go[60]; + m_A75 += go[61]; + m_A75 += go[62]; + double RHS21 = Idr[59]; + RHS21 += Idr[60]; + RHS21 += Idr[61]; + RHS21 += Idr[62]; + RHS21 += Idr[63]; + RHS21 += Idr[64]; + RHS21 -= go[63] * *cnV[63]; + RHS21 -= go[64] * *cnV[64]; + m_A88 += gt[65]; + m_A88 += gt[66]; + m_A88 += gt[67]; + m_A88 += gt[68]; + m_A88 += gt[69]; + m_A83 += go[65]; + m_A81 += go[66]; + m_A82 += go[67]; + m_A80 += go[68]; + double RHS22 = Idr[65]; + RHS22 += Idr[66]; + RHS22 += Idr[67]; + RHS22 += Idr[68]; + RHS22 += Idr[69]; + RHS22 -= go[69] * *cnV[69]; + const double f0 = 1.0 / m_A0; + const double f0_12 = -f0 * m_A30; + m_A32 += m_A1 * f0_12; + RHS12 += f0_12 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_15 = -f1 * m_A42; + m_A43 += m_A3 * f1_15; + RHS15 += f1_15 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_22 = -f2 * m_A80; + m_A88 += m_A5 * f2_22; + RHS22 += f2_22 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_19 = -f3 * m_A58; + m_A62 += m_A7 * f3_19; + m_A65 += m_A8 * f3_19; + RHS19 += f3_19 * RHS3; + const double f3_22 = -f3 * m_A81; + m_A85 += m_A7 * f3_22; + m_A88 += m_A8 * f3_22; + RHS22 += f3_22 * RHS3; + const double f4 = 1.0 / m_A9; + const double f4_13 = -f4 * m_A34; + m_A35 += m_A10 * f4_13; + m_A36 += m_A11 * f4_13; + RHS13 += f4_13 * RHS4; + const double f4_16 = -f4 * m_A45; + m_A46 += m_A10 * f4_16; + m_A47 += m_A11 * f4_16; + RHS16 += f4_16 * RHS4; + const double f5 = 1.0 / m_A12; + const double f5_21 = -f5 * m_A72; + m_A75 += m_A13 * f5_21; + RHS21 += f5_21 * RHS5; + const double f6 = 1.0 / m_A14; + const double f6_12 = -f6 * m_A31; + m_A32 += m_A15 * f6_12; + m_A33 += m_A16 * f6_12; + RHS12 += f6_12 * RHS6; + const double f6_21 = -f6 * m_A73; + m_A74 += m_A15 * f6_21; + m_A78 += m_A16 * f6_21; + RHS21 += f6_21 * RHS6; + const double f7 = 1.0 / m_A17; + const double f7_19 = -f7 * m_A59; + m_A62 += m_A18 * f7_19; + m_A63 += m_A19 * f7_19; + RHS19 += f7_19 * RHS7; + const double f7_20 = -f7 * m_A66; + m_A68 += m_A18 * f7_20; + m_A69 += m_A19 * f7_20; + RHS20 += f7_20 * RHS7; + const double f8 = 1.0 / m_A20; + const double f8_14 = -f8 * m_A38; + m_A40 += m_A21 * f8_14; + RHS14 += f8_14 * RHS8; + const double f9 = 1.0 / m_A22; + const double f9_14 = -f9 * m_A39; + m_A40 += m_A23 * f9_14; + m_A41 += m_A24 * f9_14; + RHS14 += f9_14 * RHS9; + const double f9_17 = -f9 * m_A50; + m_A51 += m_A23 * f9_17; + m_A52 += m_A24 * f9_17; + RHS17 += f9_17 * RHS9; + const double f10 = 1.0 / m_A25; + const double f10_18 = -f10 * m_A54; + m_A56 += m_A26 * f10_18; + RHS18 += f10_18 * RHS10; + const double f11 = 1.0 / m_A27; + const double f11_18 = -f11 * m_A55; + m_A56 += m_A28 * f11_18; + m_A57 += m_A29 * f11_18; + RHS18 += f11_18 * RHS11; + const double f11_22 = -f11 * m_A82; + m_A84 += m_A28 * f11_22; + m_A88 += m_A29 * f11_22; + RHS22 += f11_22 * RHS11; + const double f12 = 1.0 / m_A32; + const double f12_21 = -f12 * m_A74; + m_A78 += m_A33 * f12_21; + RHS21 += f12_21 * RHS12; + const double f13 = 1.0 / m_A35; + const double f13_16 = -f13 * m_A46; + m_A47 += m_A36 * f13_16; + m_A48 += m_A37 * f13_16; + RHS16 += f13_16 * RHS13; + const double f13_19 = -f13 * m_A60; + m_A61 += m_A36 * f13_19; + m_A62 += m_A37 * f13_19; + RHS19 += f13_19 * RHS13; + const double f14 = 1.0 / m_A40; + const double f14_17 = -f14 * m_A51; + m_A52 += m_A41 * f14_17; + RHS17 += f14_17 * RHS14; + const double f15 = 1.0 / m_A43; + const double f15_20 = -f15 * m_A67; + m_A69 += m_A44 * f15_20; + RHS20 += f15_20 * RHS15; + const double f16 = 1.0 / m_A47; + const double f16_19 = -f16 * m_A61; + m_A62 += m_A48 * f16_19; + m_A64 += m_A49 * f16_19; + RHS19 += f16_19 * RHS16; + const double f16_21 = -f16 * m_A75; + m_A76 += m_A48 * f16_21; + m_A78 += m_A49 * f16_21; + RHS21 += f16_21 * RHS16; + const double f17 = 1.0 / m_A52; + const double f17_22 = -f17 * m_A83; + m_A88 += m_A53 * f17_22; + RHS22 += f17_22 * RHS17; + const double f18 = 1.0 / m_A56; + const double f18_22 = -f18 * m_A84; + m_A88 += m_A57 * f18_22; + RHS22 += f18_22 * RHS18; + const double f19 = 1.0 / m_A62; + const double f19_20 = -f19 * m_A68; + m_A69 += m_A63 * f19_20; + m_A70 += m_A64 * f19_20; + m_A71 += m_A65 * f19_20; + RHS20 += f19_20 * RHS19; + const double f19_21 = -f19 * m_A76; + m_A77 += m_A63 * f19_21; + m_A78 += m_A64 * f19_21; + m_A79 += m_A65 * f19_21; + RHS21 += f19_21 * RHS19; + const double f19_22 = -f19 * m_A85; + m_A86 += m_A63 * f19_22; + m_A87 += m_A64 * f19_22; + m_A88 += m_A65 * f19_22; + RHS22 += f19_22 * RHS19; + const double f20 = 1.0 / m_A69; + const double f20_21 = -f20 * m_A77; + m_A78 += m_A70 * f20_21; + m_A79 += m_A71 * f20_21; + RHS21 += f20_21 * RHS20; + const double f20_22 = -f20 * m_A86; + m_A87 += m_A70 * f20_22; + m_A88 += m_A71 * f20_22; + RHS22 += f20_22 * RHS20; + const double f21 = 1.0 / m_A78; + const double f21_22 = -f21 * m_A87; + m_A88 += m_A79 * f21_22; + RHS22 += f21_22 * RHS21; + V[22] = RHS22 / m_A88; + double tmp21 = 0.0; + tmp21 += m_A79 * V[22]; + V[21] = (RHS21 - tmp21) / m_A78; + double tmp20 = 0.0; + tmp20 += m_A70 * V[21]; + tmp20 += m_A71 * V[22]; + V[20] = (RHS20 - tmp20) / m_A69; + double tmp19 = 0.0; + tmp19 += m_A63 * V[20]; + tmp19 += m_A64 * V[21]; + tmp19 += m_A65 * V[22]; + V[19] = (RHS19 - tmp19) / m_A62; + double tmp18 = 0.0; + tmp18 += m_A57 * V[22]; + V[18] = (RHS18 - tmp18) / m_A56; + double tmp17 = 0.0; + tmp17 += m_A53 * V[22]; + V[17] = (RHS17 - tmp17) / m_A52; + double tmp16 = 0.0; + tmp16 += m_A48 * V[19]; + tmp16 += m_A49 * V[21]; + V[16] = (RHS16 - tmp16) / m_A47; + double tmp15 = 0.0; + tmp15 += m_A44 * V[20]; + V[15] = (RHS15 - tmp15) / m_A43; + double tmp14 = 0.0; + tmp14 += m_A41 * V[17]; + V[14] = (RHS14 - tmp14) / m_A40; + double tmp13 = 0.0; + tmp13 += m_A36 * V[16]; + tmp13 += m_A37 * V[19]; + V[13] = (RHS13 - tmp13) / m_A35; + double tmp12 = 0.0; + tmp12 += m_A33 * V[21]; + V[12] = (RHS12 - tmp12) / m_A32; + double tmp11 = 0.0; + tmp11 += m_A28 * V[18]; + tmp11 += m_A29 * V[22]; + V[11] = (RHS11 - tmp11) / m_A27; + double tmp10 = 0.0; + tmp10 += m_A26 * V[18]; + V[10] = (RHS10 - tmp10) / m_A25; + double tmp9 = 0.0; + tmp9 += m_A23 * V[14]; + tmp9 += m_A24 * V[17]; + V[9] = (RHS9 - tmp9) / m_A22; + double tmp8 = 0.0; + tmp8 += m_A21 * V[14]; + V[8] = (RHS8 - tmp8) / m_A20; + double tmp7 = 0.0; + tmp7 += m_A18 * V[19]; + tmp7 += m_A19 * V[20]; + V[7] = (RHS7 - tmp7) / m_A17; + double tmp6 = 0.0; + tmp6 += m_A15 * V[12]; + tmp6 += m_A16 * V[21]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A13 * V[16]; + V[5] = (RHS5 - tmp5) / m_A12; + double tmp4 = 0.0; + tmp4 += m_A10 * V[13]; + tmp4 += m_A11 * V[16]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[19]; + tmp3 += m_A8 * V[22]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[22]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[15]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[12]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// solarq +static void nl_gcr_15d8b80bb0b22f1e_303_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + double m_A198(0.0); + double m_A199(0.0); + double m_A200(0.0); + double m_A201(0.0); + double m_A202(0.0); + double m_A203(0.0); + double m_A204(0.0); + double m_A205(0.0); + double m_A206(0.0); + double m_A207(0.0); + double m_A208(0.0); + double m_A209(0.0); + double m_A210(0.0); + double m_A211(0.0); + double m_A212(0.0); + double m_A213(0.0); + double m_A214(0.0); + double m_A215(0.0); + double m_A216(0.0); + double m_A217(0.0); + double m_A218(0.0); + double m_A219(0.0); + double m_A220(0.0); + double m_A221(0.0); + double m_A222(0.0); + double m_A223(0.0); + double m_A224(0.0); + double m_A225(0.0); + double m_A226(0.0); + double m_A227(0.0); + double m_A228(0.0); + double m_A229(0.0); + double m_A230(0.0); + double m_A231(0.0); + double m_A232(0.0); + double m_A233(0.0); + double m_A234(0.0); + double m_A235(0.0); + double m_A236(0.0); + double m_A237(0.0); + double m_A238(0.0); + double m_A239(0.0); + double m_A240(0.0); + double m_A241(0.0); + double m_A242(0.0); + double m_A243(0.0); + double m_A244(0.0); + double m_A245(0.0); + double m_A246(0.0); + double m_A247(0.0); + double m_A248(0.0); + double m_A249(0.0); + double m_A250(0.0); + double m_A251(0.0); + double m_A252(0.0); + double m_A253(0.0); + double m_A254(0.0); + double m_A255(0.0); + double m_A256(0.0); + double m_A257(0.0); + double m_A258(0.0); + double m_A259(0.0); + double m_A260(0.0); + double m_A261(0.0); + double m_A262(0.0); + double m_A263(0.0); + double m_A264(0.0); + double m_A265(0.0); + double m_A266(0.0); + double m_A267(0.0); + double m_A268(0.0); + double m_A269(0.0); + double m_A270(0.0); + double m_A271(0.0); + double m_A272(0.0); + double m_A273(0.0); + double m_A274(0.0); + double m_A275(0.0); + double m_A276(0.0); + double m_A277(0.0); + double m_A278(0.0); + double m_A279(0.0); + double m_A280(0.0); + double m_A281(0.0); + double m_A282(0.0); + double m_A283(0.0); + double m_A284(0.0); + double m_A285(0.0); + double m_A286(0.0); + double m_A287(0.0); + double m_A288(0.0); + double m_A289(0.0); + double m_A290(0.0); + double m_A291(0.0); + double m_A292(0.0); + double m_A293(0.0); + double m_A294(0.0); + double m_A295(0.0); + double m_A296(0.0); + double m_A297(0.0); + double m_A298(0.0); + double m_A299(0.0); + double m_A300(0.0); + double m_A301(0.0); + double m_A302(0.0); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A0 += gt[6]; + m_A0 += gt[7]; + m_A0 += gt[8]; + m_A0 += gt[9]; + m_A0 += gt[10]; + m_A0 += gt[11]; + m_A0 += gt[12]; + m_A0 += gt[13]; + m_A2 += go[0]; + m_A1 += go[1]; + m_A1 += go[2]; + m_A0 += go[3]; + m_A0 += go[4]; + m_A0 += go[5]; + m_A0 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 += Idr[6]; + RHS0 += Idr[7]; + RHS0 += Idr[8]; + RHS0 += Idr[9]; + RHS0 += Idr[10]; + RHS0 += Idr[11]; + RHS0 += Idr[12]; + RHS0 += Idr[13]; + RHS0 -= go[9] * *cnV[9]; + RHS0 -= go[10] * *cnV[10]; + RHS0 -= go[11] * *cnV[11]; + RHS0 -= go[12] * *cnV[12]; + RHS0 -= go[13] * *cnV[13]; + m_A4 += gt[14]; + m_A4 += gt[15]; + m_A4 += gt[16]; + m_A4 += gt[17]; + m_A4 += gt[18]; + m_A4 += gt[19]; + m_A4 += gt[20]; + m_A4 += gt[21]; + m_A4 += gt[22]; + m_A4 += gt[23]; + m_A4 += gt[24]; + m_A4 += gt[25]; + m_A4 += gt[26]; + m_A4 += gt[27]; + m_A4 += go[14]; + m_A4 += go[15]; + m_A4 += go[16]; + m_A4 += go[17]; + m_A5 += go[18]; + m_A5 += go[19]; + m_A5 += go[20]; + m_A5 += go[21]; + m_A6 += go[22]; + double RHS1 = Idr[14]; + RHS1 += Idr[15]; + RHS1 += Idr[16]; + RHS1 += Idr[17]; + RHS1 += Idr[18]; + RHS1 += Idr[19]; + RHS1 += Idr[20]; + RHS1 += Idr[21]; + RHS1 += Idr[22]; + RHS1 += Idr[23]; + RHS1 += Idr[24]; + RHS1 += Idr[25]; + RHS1 += Idr[26]; + RHS1 += Idr[27]; + RHS1 -= go[23] * *cnV[23]; + RHS1 -= go[24] * *cnV[24]; + RHS1 -= go[25] * *cnV[25]; + RHS1 -= go[26] * *cnV[26]; + RHS1 -= go[27] * *cnV[27]; + m_A7 += gt[28]; + m_A7 += gt[29]; + m_A7 += gt[30]; + m_A7 += gt[31]; + m_A7 += gt[32]; + m_A7 += gt[33]; + m_A7 += gt[34]; + m_A7 += gt[35]; + m_A8 += go[28]; + m_A8 += go[29]; + m_A9 += go[30]; + m_A9 += go[31]; + m_A9 += go[32]; + m_A10 += go[33]; + m_A10 += go[34]; + m_A10 += go[35]; + double RHS2 = Idr[28]; + RHS2 += Idr[29]; + RHS2 += Idr[30]; + RHS2 += Idr[31]; + RHS2 += Idr[32]; + RHS2 += Idr[33]; + RHS2 += Idr[34]; + RHS2 += Idr[35]; + m_A11 += gt[36]; + m_A11 += gt[37]; + m_A11 += gt[38]; + m_A11 += gt[39]; + m_A11 += gt[40]; + m_A12 += go[36]; + m_A12 += go[37]; + m_A13 += go[38]; + m_A13 += go[39]; + double RHS3 = Idr[36]; + RHS3 += Idr[37]; + RHS3 += Idr[38]; + RHS3 += Idr[39]; + RHS3 += Idr[40]; + RHS3 -= go[40] * *cnV[40]; + m_A14 += gt[41]; + m_A14 += gt[42]; + m_A14 += gt[43]; + m_A14 += gt[44]; + m_A14 += gt[45]; + m_A14 += gt[46]; + m_A14 += gt[47]; + m_A14 += gt[48]; + m_A14 += gt[49]; + m_A14 += gt[50]; + m_A14 += gt[51]; + m_A14 += gt[52]; + m_A14 += gt[53]; + m_A14 += gt[54]; + m_A14 += go[41]; + m_A14 += go[42]; + m_A14 += go[43]; + m_A14 += go[44]; + m_A15 += go[45]; + m_A15 += go[46]; + m_A15 += go[47]; + m_A15 += go[48]; + m_A16 += go[49]; + double RHS4 = Idr[41]; + RHS4 += Idr[42]; + RHS4 += Idr[43]; + RHS4 += Idr[44]; + RHS4 += Idr[45]; + RHS4 += Idr[46]; + RHS4 += Idr[47]; + RHS4 += Idr[48]; + RHS4 += Idr[49]; + RHS4 += Idr[50]; + RHS4 += Idr[51]; + RHS4 += Idr[52]; + RHS4 += Idr[53]; + RHS4 += Idr[54]; + RHS4 -= go[50] * *cnV[50]; + RHS4 -= go[51] * *cnV[51]; + RHS4 -= go[52] * *cnV[52]; + RHS4 -= go[53] * *cnV[53]; + RHS4 -= go[54] * *cnV[54]; + m_A17 += gt[55]; + m_A17 += gt[56]; + m_A17 += gt[57]; + m_A17 += gt[58]; + m_A17 += gt[59]; + m_A17 += gt[60]; + m_A17 += gt[61]; + m_A17 += gt[62]; + m_A17 += gt[63]; + m_A17 += gt[64]; + m_A17 += gt[65]; + m_A17 += gt[66]; + m_A17 += gt[67]; + m_A17 += gt[68]; + m_A19 += go[55]; + m_A18 += go[56]; + m_A18 += go[57]; + m_A17 += go[58]; + m_A17 += go[59]; + m_A17 += go[60]; + m_A17 += go[61]; + m_A20 += go[62]; + m_A20 += go[63]; + double RHS5 = Idr[55]; + RHS5 += Idr[56]; + RHS5 += Idr[57]; + RHS5 += Idr[58]; + RHS5 += Idr[59]; + RHS5 += Idr[60]; + RHS5 += Idr[61]; + RHS5 += Idr[62]; + RHS5 += Idr[63]; + RHS5 += Idr[64]; + RHS5 += Idr[65]; + RHS5 += Idr[66]; + RHS5 += Idr[67]; + RHS5 += Idr[68]; + RHS5 -= go[64] * *cnV[64]; + RHS5 -= go[65] * *cnV[65]; + RHS5 -= go[66] * *cnV[66]; + RHS5 -= go[67] * *cnV[67]; + RHS5 -= go[68] * *cnV[68]; + m_A21 += gt[69]; + m_A21 += gt[70]; + m_A21 += gt[71]; + m_A21 += gt[72]; + m_A22 += go[69]; + double RHS6 = Idr[69]; + RHS6 += Idr[70]; + RHS6 += Idr[71]; + RHS6 += Idr[72]; + RHS6 -= go[70] * *cnV[70]; + RHS6 -= go[71] * *cnV[71]; + RHS6 -= go[72] * *cnV[72]; + m_A23 += gt[73]; + m_A23 += gt[74]; + m_A23 += gt[75]; + m_A23 += gt[76]; + m_A23 += gt[77]; + m_A23 += gt[78]; + m_A23 += gt[79]; + m_A23 += gt[80]; + m_A24 += go[73]; + m_A24 += go[74]; + m_A25 += go[75]; + m_A25 += go[76]; + m_A25 += go[77]; + m_A26 += go[78]; + m_A26 += go[79]; + m_A26 += go[80]; + double RHS7 = Idr[73]; + RHS7 += Idr[74]; + RHS7 += Idr[75]; + RHS7 += Idr[76]; + RHS7 += Idr[77]; + RHS7 += Idr[78]; + RHS7 += Idr[79]; + RHS7 += Idr[80]; + m_A27 += gt[81]; + m_A27 += gt[82]; + m_A27 += gt[83]; + m_A27 += gt[84]; + m_A27 += gt[85]; + m_A27 += gt[86]; + m_A27 += gt[87]; + m_A27 += gt[88]; + m_A27 += gt[89]; + m_A27 += gt[90]; + m_A27 += gt[91]; + m_A27 += gt[92]; + m_A29 += go[81]; + m_A28 += go[82]; + m_A28 += go[83]; + m_A27 += go[84]; + m_A27 += go[85]; + m_A27 += go[86]; + m_A27 += go[87]; + double RHS8 = Idr[81]; + RHS8 += Idr[82]; + RHS8 += Idr[83]; + RHS8 += Idr[84]; + RHS8 += Idr[85]; + RHS8 += Idr[86]; + RHS8 += Idr[87]; + RHS8 += Idr[88]; + RHS8 += Idr[89]; + RHS8 += Idr[90]; + RHS8 += Idr[91]; + RHS8 += Idr[92]; + RHS8 -= go[88] * *cnV[88]; + RHS8 -= go[89] * *cnV[89]; + RHS8 -= go[90] * *cnV[90]; + RHS8 -= go[91] * *cnV[91]; + RHS8 -= go[92] * *cnV[92]; + m_A30 += gt[93]; + m_A30 += gt[94]; + m_A30 += gt[95]; + m_A30 += gt[96]; + m_A30 += gt[97]; + m_A30 += gt[98]; + m_A30 += gt[99]; + m_A30 += gt[100]; + m_A33 += go[93]; + m_A32 += go[94]; + m_A32 += go[95]; + m_A31 += go[96]; + m_A31 += go[97]; + double RHS9 = Idr[93]; + RHS9 += Idr[94]; + RHS9 += Idr[95]; + RHS9 += Idr[96]; + RHS9 += Idr[97]; + RHS9 += Idr[98]; + RHS9 += Idr[99]; + RHS9 += Idr[100]; + RHS9 -= go[98] * *cnV[98]; + RHS9 -= go[99] * *cnV[99]; + RHS9 -= go[100] * *cnV[100]; + m_A34 += gt[101]; + m_A34 += gt[102]; + m_A34 += gt[103]; + m_A34 += gt[104]; + m_A34 += gt[105]; + m_A34 += gt[106]; + m_A34 += gt[107]; + m_A34 += gt[108]; + m_A34 += gt[109]; + m_A34 += gt[110]; + m_A34 += gt[111]; + m_A34 += gt[112]; + m_A36 += go[101]; + m_A35 += go[102]; + m_A35 += go[103]; + m_A34 += go[104]; + m_A34 += go[105]; + m_A34 += go[106]; + m_A34 += go[107]; + double RHS10 = Idr[101]; + RHS10 += Idr[102]; + RHS10 += Idr[103]; + RHS10 += Idr[104]; + RHS10 += Idr[105]; + RHS10 += Idr[106]; + RHS10 += Idr[107]; + RHS10 += Idr[108]; + RHS10 += Idr[109]; + RHS10 += Idr[110]; + RHS10 += Idr[111]; + RHS10 += Idr[112]; + RHS10 -= go[108] * *cnV[108]; + RHS10 -= go[109] * *cnV[109]; + RHS10 -= go[110] * *cnV[110]; + RHS10 -= go[111] * *cnV[111]; + RHS10 -= go[112] * *cnV[112]; + m_A37 += gt[113]; + m_A37 += gt[114]; + m_A37 += gt[115]; + m_A37 += gt[116]; + m_A37 += gt[117]; + m_A38 += go[113]; + m_A38 += go[114]; + m_A39 += go[115]; + m_A39 += go[116]; + double RHS11 = Idr[113]; + RHS11 += Idr[114]; + RHS11 += Idr[115]; + RHS11 += Idr[116]; + RHS11 += Idr[117]; + RHS11 -= go[117] * *cnV[117]; + m_A40 += gt[118]; + m_A40 += gt[119]; + m_A40 += gt[120]; + m_A40 += gt[121]; + m_A40 += gt[122]; + m_A40 += gt[123]; + m_A42 += go[118]; + m_A41 += go[119]; + m_A41 += go[120]; + m_A43 += go[121]; + m_A43 += go[122]; + double RHS12 = Idr[118]; + RHS12 += Idr[119]; + RHS12 += Idr[120]; + RHS12 += Idr[121]; + RHS12 += Idr[122]; + RHS12 += Idr[123]; + RHS12 -= go[123] * *cnV[123]; + m_A44 += gt[124]; + m_A44 += gt[125]; + m_A44 += gt[126]; + m_A44 += gt[127]; + m_A44 += gt[128]; + m_A44 += gt[129]; + m_A44 += gt[130]; + m_A45 += go[124]; + m_A46 += go[125]; + double RHS13 = Idr[124]; + RHS13 += Idr[125]; + RHS13 += Idr[126]; + RHS13 += Idr[127]; + RHS13 += Idr[128]; + RHS13 += Idr[129]; + RHS13 += Idr[130]; + RHS13 -= go[126] * *cnV[126]; + RHS13 -= go[127] * *cnV[127]; + RHS13 -= go[128] * *cnV[128]; + RHS13 -= go[129] * *cnV[129]; + RHS13 -= go[130] * *cnV[130]; + m_A47 += gt[131]; + m_A47 += gt[132]; + m_A47 += gt[133]; + m_A47 += gt[134]; + m_A48 += go[131]; + double RHS14 = Idr[131]; + RHS14 += Idr[132]; + RHS14 += Idr[133]; + RHS14 += Idr[134]; + RHS14 -= go[132] * *cnV[132]; + RHS14 -= go[133] * *cnV[133]; + RHS14 -= go[134] * *cnV[134]; + m_A49 += gt[135]; + m_A49 += gt[136]; + m_A50 += go[135]; + double RHS15 = Idr[135]; + RHS15 += Idr[136]; + RHS15 -= go[136] * *cnV[136]; + m_A51 += gt[137]; + m_A51 += gt[138]; + m_A51 += gt[139]; + m_A51 += gt[140]; + m_A51 += gt[141]; + m_A51 += gt[142]; + m_A51 += gt[143]; + m_A52 += go[137]; + double RHS16 = Idr[137]; + RHS16 += Idr[138]; + RHS16 += Idr[139]; + RHS16 += Idr[140]; + RHS16 += Idr[141]; + RHS16 += Idr[142]; + RHS16 += Idr[143]; + RHS16 -= go[138] * *cnV[138]; + RHS16 -= go[139] * *cnV[139]; + RHS16 -= go[140] * *cnV[140]; + RHS16 -= go[141] * *cnV[141]; + RHS16 -= go[142] * *cnV[142]; + RHS16 -= go[143] * *cnV[143]; + m_A53 += gt[144]; + m_A53 += gt[145]; + m_A53 += gt[146]; + m_A53 += gt[147]; + m_A53 += gt[148]; + m_A53 += gt[149]; + m_A53 += gt[150]; + m_A54 += go[144]; + m_A55 += go[145]; + double RHS17 = Idr[144]; + RHS17 += Idr[145]; + RHS17 += Idr[146]; + RHS17 += Idr[147]; + RHS17 += Idr[148]; + RHS17 += Idr[149]; + RHS17 += Idr[150]; + RHS17 -= go[146] * *cnV[146]; + RHS17 -= go[147] * *cnV[147]; + RHS17 -= go[148] * *cnV[148]; + RHS17 -= go[149] * *cnV[149]; + RHS17 -= go[150] * *cnV[150]; + m_A56 += gt[151]; + m_A56 += gt[152]; + m_A56 += gt[153]; + m_A57 += go[151]; + double RHS18 = Idr[151]; + RHS18 += Idr[152]; + RHS18 += Idr[153]; + RHS18 -= go[152] * *cnV[152]; + RHS18 -= go[153] * *cnV[153]; + m_A58 += gt[154]; + m_A58 += gt[155]; + m_A58 += gt[156]; + m_A58 += gt[157]; + m_A58 += gt[158]; + m_A58 += gt[159]; + m_A59 += go[154]; + m_A60 += go[155]; + m_A60 += go[156]; + m_A61 += go[157]; + m_A61 += go[158]; + double RHS19 = Idr[154]; + RHS19 += Idr[155]; + RHS19 += Idr[156]; + RHS19 += Idr[157]; + RHS19 += Idr[158]; + RHS19 += Idr[159]; + RHS19 -= go[159] * *cnV[159]; + m_A62 += gt[160]; + m_A62 += gt[161]; + m_A64 += go[160]; + m_A63 += go[161]; + double RHS20 = Idr[160]; + RHS20 += Idr[161]; + m_A65 += gt[162]; + m_A65 += gt[163]; + m_A65 += gt[164]; + m_A65 += gt[165]; + m_A65 += gt[166]; + m_A65 += gt[167]; + m_A65 += gt[168]; + m_A66 += go[162]; + double RHS21 = Idr[162]; + RHS21 += Idr[163]; + RHS21 += Idr[164]; + RHS21 += Idr[165]; + RHS21 += Idr[166]; + RHS21 += Idr[167]; + RHS21 += Idr[168]; + RHS21 -= go[163] * *cnV[163]; + RHS21 -= go[164] * *cnV[164]; + RHS21 -= go[165] * *cnV[165]; + RHS21 -= go[166] * *cnV[166]; + RHS21 -= go[167] * *cnV[167]; + RHS21 -= go[168] * *cnV[168]; + m_A67 += gt[169]; + m_A67 += gt[170]; + m_A68 += go[169]; + m_A69 += go[170]; + double RHS22 = Idr[169]; + RHS22 += Idr[170]; + m_A70 += gt[171]; + m_A70 += gt[172]; + m_A71 += go[171]; + double RHS23 = Idr[171]; + RHS23 += Idr[172]; + RHS23 -= go[172] * *cnV[172]; + m_A74 += gt[173]; + m_A74 += gt[174]; + m_A74 += gt[175]; + m_A74 += gt[176]; + m_A74 += gt[177]; + m_A74 += gt[178]; + m_A73 += go[173]; + m_A73 += go[174]; + m_A72 += go[175]; + double RHS24 = Idr[173]; + RHS24 += Idr[174]; + RHS24 += Idr[175]; + RHS24 += Idr[176]; + RHS24 += Idr[177]; + RHS24 += Idr[178]; + RHS24 -= go[176] * *cnV[176]; + RHS24 -= go[177] * *cnV[177]; + RHS24 -= go[178] * *cnV[178]; + m_A77 += gt[179]; + m_A77 += gt[180]; + m_A78 += go[179]; + m_A79 += go[180]; + double RHS25 = Idr[179]; + RHS25 += Idr[180]; + m_A82 += gt[181]; + m_A82 += gt[182]; + m_A82 += gt[183]; + m_A82 += gt[184]; + m_A82 += gt[185]; + m_A83 += go[181]; + m_A83 += go[182]; + m_A80 += go[183]; + m_A80 += go[184]; + double RHS26 = Idr[181]; + RHS26 += Idr[182]; + RHS26 += Idr[183]; + RHS26 += Idr[184]; + RHS26 += Idr[185]; + RHS26 -= go[185] * *cnV[185]; + m_A85 += gt[186]; + m_A85 += gt[187]; + m_A85 += gt[188]; + m_A85 += gt[189]; + m_A85 += gt[190]; + m_A85 += gt[191]; + m_A85 += gt[192]; + m_A85 += gt[193]; + m_A86 += go[186]; + m_A86 += go[187]; + m_A86 += go[188]; + m_A84 += go[189]; + m_A84 += go[190]; + m_A87 += go[191]; + m_A87 += go[192]; + m_A87 += go[193]; + double RHS27 = Idr[186]; + RHS27 += Idr[187]; + RHS27 += Idr[188]; + RHS27 += Idr[189]; + RHS27 += Idr[190]; + RHS27 += Idr[191]; + RHS27 += Idr[192]; + RHS27 += Idr[193]; + m_A89 += gt[194]; + m_A89 += gt[195]; + m_A89 += gt[196]; + m_A89 += gt[197]; + m_A89 += gt[198]; + m_A89 += gt[199]; + m_A89 += gt[200]; + m_A89 += gt[201]; + m_A89 += gt[202]; + m_A89 += gt[203]; + m_A89 += gt[204]; + m_A89 += gt[205]; + m_A89 += gt[206]; + m_A89 += gt[207]; + m_A89 += go[194]; + m_A89 += go[195]; + m_A89 += go[196]; + m_A89 += go[197]; + m_A88 += go[198]; + m_A88 += go[199]; + m_A90 += go[200]; + m_A90 += go[201]; + m_A91 += go[202]; + double RHS28 = Idr[194]; + RHS28 += Idr[195]; + RHS28 += Idr[196]; + RHS28 += Idr[197]; + RHS28 += Idr[198]; + RHS28 += Idr[199]; + RHS28 += Idr[200]; + RHS28 += Idr[201]; + RHS28 += Idr[202]; + RHS28 += Idr[203]; + RHS28 += Idr[204]; + RHS28 += Idr[205]; + RHS28 += Idr[206]; + RHS28 += Idr[207]; + RHS28 -= go[203] * *cnV[203]; + RHS28 -= go[204] * *cnV[204]; + RHS28 -= go[205] * *cnV[205]; + RHS28 -= go[206] * *cnV[206]; + RHS28 -= go[207] * *cnV[207]; + m_A94 += gt[208]; + m_A94 += gt[209]; + m_A94 += gt[210]; + m_A93 += go[208]; + m_A92 += go[209]; + double RHS29 = Idr[208]; + RHS29 += Idr[209]; + RHS29 += Idr[210]; + RHS29 -= go[210] * *cnV[210]; + m_A99 += gt[211]; + m_A99 += gt[212]; + m_A99 += gt[213]; + m_A99 += gt[214]; + m_A99 += gt[215]; + m_A99 += gt[216]; + m_A99 += gt[217]; + m_A99 += gt[218]; + m_A99 += gt[219]; + m_A96 += go[211]; + m_A96 += go[212]; + m_A98 += go[213]; + m_A98 += go[214]; + m_A102 += go[215]; + m_A103 += go[216]; + m_A97 += go[217]; + m_A97 += go[218]; + double RHS30 = Idr[211]; + RHS30 += Idr[212]; + RHS30 += Idr[213]; + RHS30 += Idr[214]; + RHS30 += Idr[215]; + RHS30 += Idr[216]; + RHS30 += Idr[217]; + RHS30 += Idr[218]; + RHS30 += Idr[219]; + RHS30 -= go[219] * *cnV[219]; + m_A105 += gt[220]; + m_A105 += gt[221]; + m_A105 += gt[222]; + m_A105 += gt[223]; + m_A105 += gt[224]; + m_A104 += go[220]; + m_A106 += go[221]; + m_A107 += go[222]; + double RHS31 = Idr[220]; + RHS31 += Idr[221]; + RHS31 += Idr[222]; + RHS31 += Idr[223]; + RHS31 += Idr[224]; + RHS31 -= go[223] * *cnV[223]; + RHS31 -= go[224] * *cnV[224]; + m_A111 += gt[225]; + m_A111 += gt[226]; + m_A111 += gt[227]; + m_A111 += gt[228]; + m_A111 += gt[229]; + m_A109 += go[225]; + m_A108 += go[226]; + m_A113 += go[227]; + double RHS32 = Idr[225]; + RHS32 += Idr[226]; + RHS32 += Idr[227]; + RHS32 += Idr[228]; + RHS32 += Idr[229]; + RHS32 -= go[228] * *cnV[228]; + RHS32 -= go[229] * *cnV[229]; + m_A119 += gt[230]; + m_A119 += gt[231]; + m_A119 += gt[232]; + m_A119 += gt[233]; + m_A119 += gt[234]; + m_A119 += gt[235]; + m_A119 += gt[236]; + m_A116 += go[230]; + m_A117 += go[231]; + m_A118 += go[232]; + m_A121 += go[233]; + m_A124 += go[234]; + double RHS33 = Idr[230]; + RHS33 += Idr[231]; + RHS33 += Idr[232]; + RHS33 += Idr[233]; + RHS33 += Idr[234]; + RHS33 += Idr[235]; + RHS33 += Idr[236]; + RHS33 -= go[235] * *cnV[235]; + RHS33 -= go[236] * *cnV[236]; + m_A126 += gt[237]; + m_A126 += gt[238]; + m_A126 += gt[239]; + m_A126 += gt[240]; + m_A126 += gt[241]; + m_A126 += gt[242]; + m_A126 += gt[243]; + m_A126 += gt[244]; + m_A127 += go[237]; + m_A127 += go[238]; + m_A127 += go[239]; + m_A125 += go[240]; + m_A125 += go[241]; + m_A128 += go[242]; + m_A128 += go[243]; + m_A128 += go[244]; + double RHS34 = Idr[237]; + RHS34 += Idr[238]; + RHS34 += Idr[239]; + RHS34 += Idr[240]; + RHS34 += Idr[241]; + RHS34 += Idr[242]; + RHS34 += Idr[243]; + RHS34 += Idr[244]; + m_A130 += gt[245]; + m_A130 += gt[246]; + m_A130 += gt[247]; + m_A130 += gt[248]; + m_A130 += gt[249]; + m_A130 += gt[250]; + m_A130 += gt[251]; + m_A130 += gt[252]; + m_A130 += gt[253]; + m_A130 += gt[254]; + m_A130 += gt[255]; + m_A130 += gt[256]; + m_A130 += gt[257]; + m_A130 += gt[258]; + m_A130 += go[245]; + m_A130 += go[246]; + m_A130 += go[247]; + m_A130 += go[248]; + m_A129 += go[249]; + m_A129 += go[250]; + m_A131 += go[251]; + m_A131 += go[252]; + m_A132 += go[253]; + double RHS35 = Idr[245]; + RHS35 += Idr[246]; + RHS35 += Idr[247]; + RHS35 += Idr[248]; + RHS35 += Idr[249]; + RHS35 += Idr[250]; + RHS35 += Idr[251]; + RHS35 += Idr[252]; + RHS35 += Idr[253]; + RHS35 += Idr[254]; + RHS35 += Idr[255]; + RHS35 += Idr[256]; + RHS35 += Idr[257]; + RHS35 += Idr[258]; + RHS35 -= go[254] * *cnV[254]; + RHS35 -= go[255] * *cnV[255]; + RHS35 -= go[256] * *cnV[256]; + RHS35 -= go[257] * *cnV[257]; + RHS35 -= go[258] * *cnV[258]; + m_A137 += gt[259]; + m_A137 += gt[260]; + m_A137 += gt[261]; + m_A137 += gt[262]; + m_A137 += gt[263]; + m_A137 += gt[264]; + m_A137 += gt[265]; + m_A137 += gt[266]; + m_A137 += gt[267]; + m_A134 += go[259]; + m_A134 += go[260]; + m_A135 += go[261]; + m_A135 += go[262]; + m_A140 += go[263]; + m_A143 += go[264]; + m_A133 += go[265]; + m_A133 += go[266]; + double RHS36 = Idr[259]; + RHS36 += Idr[260]; + RHS36 += Idr[261]; + RHS36 += Idr[262]; + RHS36 += Idr[263]; + RHS36 += Idr[264]; + RHS36 += Idr[265]; + RHS36 += Idr[266]; + RHS36 += Idr[267]; + RHS36 -= go[267] * *cnV[267]; + m_A145 += gt[268]; + m_A145 += gt[269]; + m_A146 += go[268]; + m_A144 += go[269]; + double RHS37 = Idr[268]; + RHS37 += Idr[269]; + m_A148 += gt[270]; + m_A148 += gt[271]; + m_A148 += gt[272]; + m_A148 += gt[273]; + m_A148 += gt[274]; + m_A148 += gt[275]; + m_A148 += gt[276]; + m_A147 += go[270]; + m_A149 += go[271]; + double RHS38 = Idr[270]; + RHS38 += Idr[271]; + RHS38 += Idr[272]; + RHS38 += Idr[273]; + RHS38 += Idr[274]; + RHS38 += Idr[275]; + RHS38 += Idr[276]; + RHS38 -= go[272] * *cnV[272]; + RHS38 -= go[273] * *cnV[273]; + RHS38 -= go[274] * *cnV[274]; + RHS38 -= go[275] * *cnV[275]; + RHS38 -= go[276] * *cnV[276]; + m_A158 += gt[277]; + m_A158 += gt[278]; + m_A158 += gt[279]; + m_A158 += gt[280]; + m_A158 += gt[281]; + m_A158 += gt[282]; + m_A154 += go[277]; + m_A154 += go[278]; + m_A151 += go[279]; + m_A152 += go[280]; + m_A150 += go[281]; + double RHS39 = Idr[277]; + RHS39 += Idr[278]; + RHS39 += Idr[279]; + RHS39 += Idr[280]; + RHS39 += Idr[281]; + RHS39 += Idr[282]; + RHS39 -= go[282] * *cnV[282]; + m_A172 += gt[283]; + m_A172 += gt[284]; + m_A172 += gt[285]; + m_A172 += gt[286]; + m_A172 += gt[287]; + m_A166 += go[283]; + m_A167 += go[284]; + m_A169 += go[285]; + m_A168 += go[286]; + double RHS40 = Idr[283]; + RHS40 += Idr[284]; + RHS40 += Idr[285]; + RHS40 += Idr[286]; + RHS40 += Idr[287]; + RHS40 -= go[287] * *cnV[287]; + m_A181 += gt[288]; + m_A181 += gt[289]; + m_A181 += gt[290]; + m_A181 += gt[291]; + m_A180 += go[288]; + m_A182 += go[289]; + double RHS41 = Idr[288]; + RHS41 += Idr[289]; + RHS41 += Idr[290]; + RHS41 += Idr[291]; + RHS41 -= go[290] * *cnV[290]; + RHS41 -= go[291] * *cnV[291]; + m_A186 += gt[292]; + m_A186 += gt[293]; + m_A186 += gt[294]; + m_A186 += gt[295]; + m_A186 += gt[296]; + m_A185 += go[292]; + m_A183 += go[293]; + m_A184 += go[294]; + double RHS42 = Idr[292]; + RHS42 += Idr[293]; + RHS42 += Idr[294]; + RHS42 += Idr[295]; + RHS42 += Idr[296]; + RHS42 -= go[295] * *cnV[295]; + RHS42 -= go[296] * *cnV[296]; + m_A195 += gt[297]; + m_A195 += gt[298]; + m_A195 += gt[299]; + m_A195 += gt[300]; + m_A195 += gt[301]; + m_A195 += gt[302]; + m_A195 += gt[303]; + m_A195 += gt[304]; + m_A195 += gt[305]; + m_A195 += gt[306]; + m_A195 += gt[307]; + m_A189 += go[297]; + m_A189 += go[298]; + m_A191 += go[299]; + m_A190 += go[300]; + m_A190 += go[301]; + m_A188 += go[302]; + m_A188 += go[303]; + m_A188 += go[304]; + m_A198 += go[305]; + m_A198 += go[306]; + double RHS43 = Idr[297]; + RHS43 += Idr[298]; + RHS43 += Idr[299]; + RHS43 += Idr[300]; + RHS43 += Idr[301]; + RHS43 += Idr[302]; + RHS43 += Idr[303]; + RHS43 += Idr[304]; + RHS43 += Idr[305]; + RHS43 += Idr[306]; + RHS43 += Idr[307]; + RHS43 -= go[307] * *cnV[307]; + m_A205 += gt[308]; + m_A205 += gt[309]; + m_A205 += gt[310]; + m_A205 += gt[311]; + m_A205 += gt[312]; + m_A205 += gt[313]; + m_A205 += gt[314]; + m_A205 += gt[315]; + m_A205 += gt[316]; + m_A205 += gt[317]; + m_A205 += gt[318]; + m_A205 += gt[319]; + m_A205 += gt[320]; + m_A203 += go[308]; + m_A203 += go[309]; + m_A203 += go[310]; + m_A203 += go[311]; + m_A204 += go[312]; + m_A204 += go[313]; + m_A204 += go[314]; + m_A202 += go[315]; + m_A207 += go[316]; + m_A207 += go[317]; + m_A206 += go[318]; + m_A206 += go[319]; + double RHS44 = Idr[308]; + RHS44 += Idr[309]; + RHS44 += Idr[310]; + RHS44 += Idr[311]; + RHS44 += Idr[312]; + RHS44 += Idr[313]; + RHS44 += Idr[314]; + RHS44 += Idr[315]; + RHS44 += Idr[316]; + RHS44 += Idr[317]; + RHS44 += Idr[318]; + RHS44 += Idr[319]; + RHS44 += Idr[320]; + RHS44 -= go[320] * *cnV[320]; + m_A211 += gt[321]; + m_A211 += gt[322]; + m_A211 += gt[323]; + m_A211 += gt[324]; + m_A211 += gt[325]; + m_A211 += gt[326]; + m_A211 += gt[327]; + m_A211 += gt[328]; + m_A211 += gt[329]; + m_A211 += gt[330]; + m_A211 += gt[331]; + m_A211 += gt[332]; + m_A211 += gt[333]; + m_A208 += go[321]; + m_A208 += go[322]; + m_A208 += go[323]; + m_A208 += go[324]; + m_A210 += go[325]; + m_A210 += go[326]; + m_A210 += go[327]; + m_A209 += go[328]; + m_A212 += go[329]; + m_A212 += go[330]; + m_A213 += go[331]; + m_A213 += go[332]; + double RHS45 = Idr[321]; + RHS45 += Idr[322]; + RHS45 += Idr[323]; + RHS45 += Idr[324]; + RHS45 += Idr[325]; + RHS45 += Idr[326]; + RHS45 += Idr[327]; + RHS45 += Idr[328]; + RHS45 += Idr[329]; + RHS45 += Idr[330]; + RHS45 += Idr[331]; + RHS45 += Idr[332]; + RHS45 += Idr[333]; + RHS45 -= go[333] * *cnV[333]; + m_A222 += gt[334]; + m_A222 += gt[335]; + m_A222 += gt[336]; + m_A222 += gt[337]; + m_A222 += gt[338]; + m_A222 += gt[339]; + m_A222 += gt[340]; + m_A222 += gt[341]; + m_A222 += gt[342]; + m_A222 += gt[343]; + m_A222 += gt[344]; + m_A215 += go[334]; + m_A215 += go[335]; + m_A218 += go[336]; + m_A217 += go[337]; + m_A217 += go[338]; + m_A214 += go[339]; + m_A214 += go[340]; + m_A214 += go[341]; + m_A227 += go[342]; + m_A227 += go[343]; + double RHS46 = Idr[334]; + RHS46 += Idr[335]; + RHS46 += Idr[336]; + RHS46 += Idr[337]; + RHS46 += Idr[338]; + RHS46 += Idr[339]; + RHS46 += Idr[340]; + RHS46 += Idr[341]; + RHS46 += Idr[342]; + RHS46 += Idr[343]; + RHS46 += Idr[344]; + RHS46 -= go[344] * *cnV[344]; + m_A241 += gt[345]; + m_A241 += gt[346]; + m_A241 += gt[347]; + m_A241 += gt[348]; + m_A241 += gt[349]; + m_A241 += gt[350]; + m_A237 += go[345]; + m_A230 += go[346]; + m_A229 += go[347]; + m_A228 += go[348]; + m_A234 += go[349]; + double RHS47 = Idr[345]; + RHS47 += Idr[346]; + RHS47 += Idr[347]; + RHS47 += Idr[348]; + RHS47 += Idr[349]; + RHS47 += Idr[350]; + RHS47 -= go[350] * *cnV[350]; + m_A257 += gt[351]; + m_A257 += gt[352]; + m_A257 += gt[353]; + m_A257 += gt[354]; + m_A257 += gt[355]; + m_A257 += gt[356]; + m_A257 += gt[357]; + m_A257 += gt[358]; + m_A257 += gt[359]; + m_A257 += gt[360]; + m_A257 += gt[361]; + m_A257 += gt[362]; + m_A249 += go[351]; + m_A246 += go[352]; + m_A248 += go[353]; + m_A247 += go[354]; + m_A247 += go[355]; + m_A247 += go[356]; + m_A253 += go[357]; + m_A253 += go[358]; + m_A254 += go[359]; + m_A254 += go[360]; + double RHS48 = Idr[351]; + RHS48 += Idr[352]; + RHS48 += Idr[353]; + RHS48 += Idr[354]; + RHS48 += Idr[355]; + RHS48 += Idr[356]; + RHS48 += Idr[357]; + RHS48 += Idr[358]; + RHS48 += Idr[359]; + RHS48 += Idr[360]; + RHS48 += Idr[361]; + RHS48 += Idr[362]; + RHS48 -= go[361] * *cnV[361]; + RHS48 -= go[362] * *cnV[362]; + m_A273 += gt[363]; + m_A273 += gt[364]; + m_A273 += gt[365]; + m_A273 += gt[366]; + m_A273 += gt[367]; + m_A273 += gt[368]; + m_A273 += gt[369]; + m_A273 += gt[370]; + m_A273 += gt[371]; + m_A273 += gt[372]; + m_A273 += gt[373]; + m_A262 += go[363]; + m_A262 += go[364]; + m_A264 += go[365]; + m_A269 += go[366]; + m_A269 += go[367]; + m_A263 += go[368]; + m_A263 += go[369]; + m_A263 += go[370]; + m_A261 += go[371]; + m_A261 += go[372]; + double RHS49 = Idr[363]; + RHS49 += Idr[364]; + RHS49 += Idr[365]; + RHS49 += Idr[366]; + RHS49 += Idr[367]; + RHS49 += Idr[368]; + RHS49 += Idr[369]; + RHS49 += Idr[370]; + RHS49 += Idr[371]; + RHS49 += Idr[372]; + RHS49 += Idr[373]; + RHS49 -= go[373] * *cnV[373]; + m_A288 += gt[374]; + m_A288 += gt[375]; + m_A288 += gt[376]; + m_A288 += gt[377]; + m_A288 += gt[378]; + m_A288 += gt[379]; + m_A288 += gt[380]; + m_A288 += gt[381]; + m_A288 += gt[382]; + m_A288 += gt[383]; + m_A288 += gt[384]; + m_A277 += go[374]; + m_A277 += go[375]; + m_A279 += go[376]; + m_A283 += go[377]; + m_A283 += go[378]; + m_A278 += go[379]; + m_A278 += go[380]; + m_A278 += go[381]; + m_A276 += go[382]; + m_A276 += go[383]; + double RHS50 = Idr[374]; + RHS50 += Idr[375]; + RHS50 += Idr[376]; + RHS50 += Idr[377]; + RHS50 += Idr[378]; + RHS50 += Idr[379]; + RHS50 += Idr[380]; + RHS50 += Idr[381]; + RHS50 += Idr[382]; + RHS50 += Idr[383]; + RHS50 += Idr[384]; + RHS50 -= go[384] * *cnV[384]; + m_A302 += gt[385]; + m_A302 += gt[386]; + m_A302 += gt[387]; + m_A302 += gt[388]; + m_A302 += gt[389]; + m_A302 += gt[390]; + m_A302 += gt[391]; + m_A302 += gt[392]; + m_A302 += gt[393]; + m_A302 += gt[394]; + m_A302 += gt[395]; + m_A302 += gt[396]; + m_A292 += go[385]; + m_A290 += go[386]; + m_A293 += go[387]; + m_A291 += go[388]; + m_A291 += go[389]; + m_A291 += go[390]; + m_A297 += go[391]; + m_A297 += go[392]; + m_A296 += go[393]; + m_A296 += go[394]; + double RHS51 = Idr[385]; + RHS51 += Idr[386]; + RHS51 += Idr[387]; + RHS51 += Idr[388]; + RHS51 += Idr[389]; + RHS51 += Idr[390]; + RHS51 += Idr[391]; + RHS51 += Idr[392]; + RHS51 += Idr[393]; + RHS51 += Idr[394]; + RHS51 += Idr[395]; + RHS51 += Idr[396]; + RHS51 -= go[395] * *cnV[395]; + RHS51 -= go[396] * *cnV[396]; + const double f0 = 1.0 / m_A0; + const double f0_27 = -f0 * m_A84; + m_A85 += m_A1 * f0_27; + m_A86 += m_A2 * f0_27; + m_A87 += m_A3 * f0_27; + RHS27 += f0_27 * RHS0; + const double f0_44 = -f0 * m_A202; + m_A204 += m_A1 * f0_44; + m_A205 += m_A2 * f0_44; + m_A207 += m_A3 * f0_44; + RHS44 += f0_44 * RHS0; + const double f0_49 = -f0 * m_A261; + m_A263 += m_A1 * f0_49; + m_A269 += m_A2 * f0_49; + m_A273 += m_A3 * f0_49; + RHS49 += f0_49 * RHS0; + const double f1 = 1.0 / m_A4; + const double f1_44 = -f1 * m_A203; + m_A205 += m_A5 * f1_44; + m_A206 += m_A6 * f1_44; + RHS44 += f1_44 * RHS1; + const double f1_48 = -f1 * m_A246; + m_A254 += m_A5 * f1_48; + m_A257 += m_A6 * f1_48; + RHS48 += f1_48 * RHS1; + const double f2 = 1.0 / m_A7; + const double f2_28 = -f2 * m_A88; + m_A89 += m_A8 * f2_28; + m_A90 += m_A9 * f2_28; + m_A91 += m_A10 * f2_28; + RHS28 += f2_28 * RHS2; + const double f2_43 = -f2 * m_A188; + m_A190 += m_A8 * f2_43; + m_A195 += m_A9 * f2_43; + m_A198 += m_A10 * f2_43; + RHS43 += f2_43 * RHS2; + const double f2_48 = -f2 * m_A247; + m_A248 += m_A8 * f2_48; + m_A253 += m_A9 * f2_48; + m_A257 += m_A10 * f2_48; + RHS48 += f2_48 * RHS2; + const double f3 = 1.0 / m_A11; + const double f3_30 = -f3 * m_A96; + m_A99 += m_A12 * f3_30; + m_A103 += m_A13 * f3_30; + RHS30 += f3_30 * RHS3; + const double f3_49 = -f3 * m_A262; + m_A264 += m_A12 * f3_49; + m_A273 += m_A13 * f3_49; + RHS49 += f3_49 * RHS3; + const double f4 = 1.0 / m_A14; + const double f4_45 = -f4 * m_A208; + m_A211 += m_A15 * f4_45; + m_A213 += m_A16 * f4_45; + RHS45 += f4_45 * RHS4; + const double f4_51 = -f4 * m_A290; + m_A296 += m_A15 * f4_51; + m_A302 += m_A16 * f4_51; + RHS51 += f4_51 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_34 = -f5 * m_A125; + m_A126 += m_A18 * f5_34; + m_A127 += m_A19 * f5_34; + m_A128 += m_A20 * f5_34; + RHS34 += f5_34 * RHS5; + const double f5_45 = -f5 * m_A209; + m_A210 += m_A18 * f5_45; + m_A211 += m_A19 * f5_45; + m_A212 += m_A20 * f5_45; + RHS45 += f5_45 * RHS5; + const double f5_50 = -f5 * m_A276; + m_A278 += m_A18 * f5_50; + m_A283 += m_A19 * f5_50; + m_A288 += m_A20 * f5_50; + RHS50 += f5_50 * RHS5; + const double f6 = 1.0 / m_A21; + const double f6_24 = -f6 * m_A72; + m_A74 += m_A22 * f6_24; + RHS24 += f6_24 * RHS6; + const double f7 = 1.0 / m_A23; + const double f7_35 = -f7 * m_A129; + m_A130 += m_A24 * f7_35; + m_A131 += m_A25 * f7_35; + m_A132 += m_A26 * f7_35; + RHS35 += f7_35 * RHS7; + const double f7_46 = -f7 * m_A214; + m_A217 += m_A24 * f7_46; + m_A222 += m_A25 * f7_46; + m_A227 += m_A26 * f7_46; + RHS46 += f7_46 * RHS7; + const double f7_51 = -f7 * m_A291; + m_A293 += m_A24 * f7_51; + m_A297 += m_A25 * f7_51; + m_A302 += m_A26 * f7_51; + RHS51 += f7_51 * RHS7; + const double f8 = 1.0 / m_A27; + const double f8_30 = -f8 * m_A97; + m_A99 += m_A28 * f8_30; + m_A101 += m_A29 * f8_30; + RHS30 += f8_30 * RHS8; + const double f8_39 = -f8 * m_A150; + m_A155 += m_A28 * f8_39; + m_A158 += m_A29 * f8_39; + RHS39 += f8_39 * RHS8; + const double f9 = 1.0 / m_A30; + const double f9_24 = -f9 * m_A73; + m_A74 += m_A31 * f9_24; + m_A75 += m_A32 * f9_24; + m_A76 += m_A33 * f9_24; + RHS24 += f9_24 * RHS9; + const double f9_26 = -f9 * m_A80; + m_A81 += m_A31 * f9_26; + m_A82 += m_A32 * f9_26; + m_A83 += m_A33 * f9_26; + RHS26 += f9_26 * RHS9; + const double f9_39 = -f9 * m_A151; + m_A153 += m_A31 * f9_39; + m_A154 += m_A32 * f9_39; + m_A158 += m_A33 * f9_39; + RHS39 += f9_39 * RHS9; + const double f10 = 1.0 / m_A34; + const double f10_36 = -f10 * m_A133; + m_A137 += m_A35 * f10_36; + m_A138 += m_A36 * f10_36; + RHS36 += f10_36 * RHS10; + const double f10_39 = -f10 * m_A152; + m_A157 += m_A35 * f10_39; + m_A158 += m_A36 * f10_39; + RHS39 += f10_39 * RHS10; + const double f11 = 1.0 / m_A37; + const double f11_36 = -f11 * m_A134; + m_A137 += m_A38 * f11_36; + m_A143 += m_A39 * f11_36; + RHS36 += f11_36 * RHS11; + const double f11_50 = -f11 * m_A277; + m_A279 += m_A38 * f11_50; + m_A288 += m_A39 * f11_50; + RHS50 += f11_50 * RHS11; + const double f12 = 1.0 / m_A40; + const double f12_30 = -f12 * m_A98; + m_A99 += m_A41 * f12_30; + m_A100 += m_A42 * f12_30; + m_A102 += m_A43 * f12_30; + RHS30 += f12_30 * RHS12; + const double f12_32 = -f12 * m_A108; + m_A110 += m_A41 * f12_32; + m_A111 += m_A42 * f12_32; + m_A114 += m_A43 * f12_32; + RHS32 += f12_32 * RHS12; + const double f12_43 = -f12 * m_A189; + m_A191 += m_A41 * f12_43; + m_A192 += m_A42 * f12_43; + m_A195 += m_A43 * f12_43; + RHS43 += f12_43 * RHS12; + const double f13 = 1.0 / m_A44; + const double f13_31 = -f13 * m_A104; + m_A105 += m_A45 * f13_31; + m_A107 += m_A46 * f13_31; + RHS31 += f13_31 * RHS13; + const double f14 = 1.0 / m_A47; + const double f14_37 = -f14 * m_A144; + m_A145 += m_A48 * f14_37; + RHS37 += f14_37 * RHS14; + const double f15 = 1.0 / m_A49; + const double f15_40 = -f15 * m_A166; + m_A172 += m_A50 * f15_40; + RHS40 += f15_40 * RHS15; + const double f16 = 1.0 / m_A51; + const double f16_32 = -f16 * m_A109; + m_A113 += m_A52 * f16_32; + RHS32 += f16_32 * RHS16; + const double f17 = 1.0 / m_A53; + const double f17_33 = -f17 * m_A116; + m_A119 += m_A54 * f17_33; + m_A124 += m_A55 * f17_33; + RHS33 += f17_33 * RHS17; + const double f18 = 1.0 / m_A56; + const double f18_29 = -f18 * m_A92; + m_A94 += m_A57 * f18_29; + RHS29 += f18_29 * RHS18; + const double f19 = 1.0 / m_A58; + const double f19_33 = -f19 * m_A117; + m_A119 += m_A59 * f19_33; + m_A120 += m_A60 * f19_33; + m_A122 += m_A61 * f19_33; + RHS33 += f19_33 * RHS19; + const double f19_36 = -f19 * m_A135; + m_A136 += m_A59 * f19_36; + m_A137 += m_A60 * f19_36; + m_A140 += m_A61 * f19_36; + RHS36 += f19_36 * RHS19; + const double f19_46 = -f19 * m_A215; + m_A216 += m_A59 * f19_46; + m_A218 += m_A60 * f19_46; + m_A222 += m_A61 * f19_46; + RHS46 += f19_46 * RHS19; + const double f20 = 1.0 / m_A62; + const double f20_33 = -f20 * m_A118; + m_A119 += m_A63 * f20_33; + m_A123 += m_A64 * f20_33; + RHS33 += f20_33 * RHS20; + const double f20_47 = -f20 * m_A228; + m_A232 += m_A63 * f20_47; + m_A241 += m_A64 * f20_47; + RHS47 += f20_47 * RHS20; + const double f21 = 1.0 / m_A65; + const double f21_41 = -f21 * m_A180; + m_A182 += m_A66 * f21_41; + RHS41 += f21_41 * RHS21; + const double f22 = 1.0 / m_A67; + const double f22_29 = -f22 * m_A93; + m_A94 += m_A68 * f22_29; + m_A95 += m_A69 * f22_29; + RHS29 += f22_29 * RHS22; + const double f22_47 = -f22 * m_A229; + m_A231 += m_A68 * f22_47; + m_A241 += m_A69 * f22_47; + RHS47 += f22_47 * RHS22; + const double f23 = 1.0 / m_A70; + const double f23_38 = -f23 * m_A147; + m_A149 += m_A71 * f23_38; + RHS38 += f23_38 * RHS23; + const double f23_42 = -f23 * m_A183; + m_A186 += m_A71 * f23_42; + RHS42 += f23_42 * RHS23; + const double f24 = 1.0 / m_A74; + const double f24_26 = -f24 * m_A81; + m_A82 += m_A75 * f24_26; + m_A83 += m_A76 * f24_26; + RHS26 += f24_26 * RHS24; + const double f24_39 = -f24 * m_A153; + m_A154 += m_A75 * f24_39; + m_A158 += m_A76 * f24_39; + RHS39 += f24_39 * RHS24; + const double f25 = 1.0 / m_A77; + const double f25_42 = -f25 * m_A184; + m_A186 += m_A78 * f25_42; + m_A187 += m_A79 * f25_42; + RHS42 += f25_42 * RHS25; + const double f25_47 = -f25 * m_A230; + m_A238 += m_A78 * f25_47; + m_A241 += m_A79 * f25_47; + RHS47 += f25_47 * RHS25; + const double f26 = 1.0 / m_A82; + const double f26_39 = -f26 * m_A154; + m_A158 += m_A83 * f26_39; + RHS39 += f26_39 * RHS26; + const double f27 = 1.0 / m_A85; + const double f27_44 = -f27 * m_A204; + m_A205 += m_A86 * f27_44; + m_A207 += m_A87 * f27_44; + RHS44 += f27_44 * RHS27; + const double f27_49 = -f27 * m_A263; + m_A269 += m_A86 * f27_49; + m_A273 += m_A87 * f27_49; + RHS49 += f27_49 * RHS27; + const double f28 = 1.0 / m_A89; + const double f28_43 = -f28 * m_A190; + m_A195 += m_A90 * f28_43; + m_A198 += m_A91 * f28_43; + RHS43 += f28_43 * RHS28; + const double f28_48 = -f28 * m_A248; + m_A253 += m_A90 * f28_48; + m_A257 += m_A91 * f28_48; + RHS48 += f28_48 * RHS28; + const double f29 = 1.0 / m_A94; + const double f29_47 = -f29 * m_A231; + m_A241 += m_A95 * f29_47; + RHS47 += f29_47 * RHS29; + const double f30 = 1.0 / m_A99; + const double f30_32 = -f30 * m_A110; + m_A111 += m_A100 * f30_32; + m_A112 += m_A101 * f30_32; + m_A114 += m_A102 * f30_32; + m_A115 += m_A103 * f30_32; + RHS32 += f30_32 * RHS30; + const double f30_39 = -f30 * m_A155; + m_A156 += m_A100 * f30_39; + m_A158 += m_A101 * f30_39; + m_A160 += m_A102 * f30_39; + m_A164 += m_A103 * f30_39; + RHS39 += f30_39 * RHS30; + const double f30_43 = -f30 * m_A191; + m_A192 += m_A100 * f30_43; + m_A193 += m_A101 * f30_43; + m_A195 += m_A102 * f30_43; + m_A199 += m_A103 * f30_43; + RHS43 += f30_43 * RHS30; + const double f30_49 = -f30 * m_A264; + m_A265 += m_A100 * f30_49; + m_A266 += m_A101 * f30_49; + m_A268 += m_A102 * f30_49; + m_A273 += m_A103 * f30_49; + RHS49 += f30_49 * RHS30; + const double f31 = 1.0 / m_A105; + const double f31_40 = -f31 * m_A167; + m_A172 += m_A106 * f31_40; + m_A179 += m_A107 * f31_40; + RHS40 += f31_40 * RHS31; + const double f31_51 = -f31 * m_A292; + m_A294 += m_A106 * f31_51; + m_A302 += m_A107 * f31_51; + RHS51 += f31_51 * RHS31; + const double f32 = 1.0 / m_A111; + const double f32_39 = -f32 * m_A156; + m_A158 += m_A112 * f32_39; + m_A159 += m_A113 * f32_39; + m_A160 += m_A114 * f32_39; + m_A164 += m_A115 * f32_39; + RHS39 += f32_39 * RHS32; + const double f32_40 = -f32 * m_A168; + m_A171 += m_A112 * f32_40; + m_A172 += m_A113 * f32_40; + m_A173 += m_A114 * f32_40; + m_A177 += m_A115 * f32_40; + RHS40 += f32_40 * RHS32; + const double f32_43 = -f32 * m_A192; + m_A193 += m_A112 * f32_43; + m_A194 += m_A113 * f32_43; + m_A195 += m_A114 * f32_43; + m_A199 += m_A115 * f32_43; + RHS43 += f32_43 * RHS32; + const double f32_49 = -f32 * m_A265; + m_A266 += m_A112 * f32_49; + m_A267 += m_A113 * f32_49; + m_A268 += m_A114 * f32_49; + m_A273 += m_A115 * f32_49; + RHS49 += f32_49 * RHS32; + const double f33 = 1.0 / m_A119; + const double f33_36 = -f33 * m_A136; + m_A137 += m_A120 * f33_36; + m_A139 += m_A121 * f33_36; + m_A140 += m_A122 * f33_36; + m_A141 += m_A123 * f33_36; + m_A142 += m_A124 * f33_36; + RHS36 += f33_36 * RHS33; + const double f33_40 = -f33 * m_A169; + m_A170 += m_A120 * f33_40; + m_A172 += m_A121 * f33_40; + m_A174 += m_A122 * f33_40; + m_A175 += m_A123 * f33_40; + m_A176 += m_A124 * f33_40; + RHS40 += f33_40 * RHS33; + const double f33_46 = -f33 * m_A216; + m_A218 += m_A120 * f33_46; + m_A220 += m_A121 * f33_46; + m_A222 += m_A122 * f33_46; + m_A223 += m_A123 * f33_46; + m_A224 += m_A124 * f33_46; + RHS46 += f33_46 * RHS33; + const double f33_47 = -f33 * m_A232; + m_A233 += m_A120 * f33_47; + m_A236 += m_A121 * f33_47; + m_A240 += m_A122 * f33_47; + m_A241 += m_A123 * f33_47; + m_A242 += m_A124 * f33_47; + RHS47 += f33_47 * RHS33; + const double f33_48 = -f33 * m_A249; + m_A250 += m_A120 * f33_48; + m_A252 += m_A121 * f33_48; + m_A255 += m_A122 * f33_48; + m_A256 += m_A123 * f33_48; + m_A257 += m_A124 * f33_48; + RHS48 += f33_48 * RHS33; + const double f34 = 1.0 / m_A126; + const double f34_45 = -f34 * m_A210; + m_A211 += m_A127 * f34_45; + m_A212 += m_A128 * f34_45; + RHS45 += f34_45 * RHS34; + const double f34_50 = -f34 * m_A278; + m_A283 += m_A127 * f34_50; + m_A288 += m_A128 * f34_50; + RHS50 += f34_50 * RHS34; + const double f35 = 1.0 / m_A130; + const double f35_46 = -f35 * m_A217; + m_A222 += m_A131 * f35_46; + m_A227 += m_A132 * f35_46; + RHS46 += f35_46 * RHS35; + const double f35_51 = -f35 * m_A293; + m_A297 += m_A131 * f35_51; + m_A302 += m_A132 * f35_51; + RHS51 += f35_51 * RHS35; + const double f36 = 1.0 / m_A137; + const double f36_39 = -f36 * m_A157; + m_A158 += m_A138 * f36_39; + m_A159 += m_A139 * f36_39; + m_A161 += m_A140 * f36_39; + m_A162 += m_A141 * f36_39; + m_A163 += m_A142 * f36_39; + m_A165 += m_A143 * f36_39; + RHS39 += f36_39 * RHS36; + const double f36_40 = -f36 * m_A170; + m_A171 += m_A138 * f36_40; + m_A172 += m_A139 * f36_40; + m_A174 += m_A140 * f36_40; + m_A175 += m_A141 * f36_40; + m_A176 += m_A142 * f36_40; + m_A178 += m_A143 * f36_40; + RHS40 += f36_40 * RHS36; + const double f36_46 = -f36 * m_A218; + m_A219 += m_A138 * f36_46; + m_A220 += m_A139 * f36_46; + m_A222 += m_A140 * f36_46; + m_A223 += m_A141 * f36_46; + m_A224 += m_A142 * f36_46; + m_A226 += m_A143 * f36_46; + RHS46 += f36_46 * RHS36; + const double f36_47 = -f36 * m_A233; + m_A235 += m_A138 * f36_47; + m_A236 += m_A139 * f36_47; + m_A240 += m_A140 * f36_47; + m_A241 += m_A141 * f36_47; + m_A242 += m_A142 * f36_47; + m_A244 += m_A143 * f36_47; + RHS47 += f36_47 * RHS36; + const double f36_48 = -f36 * m_A250; + m_A251 += m_A138 * f36_48; + m_A252 += m_A139 * f36_48; + m_A255 += m_A140 * f36_48; + m_A256 += m_A141 * f36_48; + m_A257 += m_A142 * f36_48; + m_A259 += m_A143 * f36_48; + RHS48 += f36_48 * RHS36; + const double f36_50 = -f36 * m_A279; + m_A280 += m_A138 * f36_50; + m_A281 += m_A139 * f36_50; + m_A284 += m_A140 * f36_50; + m_A285 += m_A141 * f36_50; + m_A286 += m_A142 * f36_50; + m_A288 += m_A143 * f36_50; + RHS50 += f36_50 * RHS36; + const double f37 = 1.0 / m_A145; + const double f37_47 = -f37 * m_A234; + m_A241 += m_A146 * f37_47; + RHS47 += f37_47 * RHS37; + const double f38 = 1.0 / m_A148; + const double f38_42 = -f38 * m_A185; + m_A186 += m_A149 * f38_42; + RHS42 += f38_42 * RHS38; + const double f39 = 1.0 / m_A158; + const double f39_40 = -f39 * m_A171; + m_A172 += m_A159 * f39_40; + m_A173 += m_A160 * f39_40; + m_A174 += m_A161 * f39_40; + m_A175 += m_A162 * f39_40; + m_A176 += m_A163 * f39_40; + m_A177 += m_A164 * f39_40; + m_A178 += m_A165 * f39_40; + RHS40 += f39_40 * RHS39; + const double f39_43 = -f39 * m_A193; + m_A194 += m_A159 * f39_43; + m_A195 += m_A160 * f39_43; + m_A196 += m_A161 * f39_43; + m_A197 += m_A162 * f39_43; + m_A198 += m_A163 * f39_43; + m_A199 += m_A164 * f39_43; + m_A200 += m_A165 * f39_43; + RHS43 += f39_43 * RHS39; + const double f39_46 = -f39 * m_A219; + m_A220 += m_A159 * f39_46; + m_A221 += m_A160 * f39_46; + m_A222 += m_A161 * f39_46; + m_A223 += m_A162 * f39_46; + m_A224 += m_A163 * f39_46; + m_A225 += m_A164 * f39_46; + m_A226 += m_A165 * f39_46; + RHS46 += f39_46 * RHS39; + const double f39_47 = -f39 * m_A235; + m_A236 += m_A159 * f39_47; + m_A239 += m_A160 * f39_47; + m_A240 += m_A161 * f39_47; + m_A241 += m_A162 * f39_47; + m_A242 += m_A163 * f39_47; + m_A243 += m_A164 * f39_47; + m_A244 += m_A165 * f39_47; + RHS47 += f39_47 * RHS39; + const double f39_48 = -f39 * m_A251; + m_A252 += m_A159 * f39_48; + m_A253 += m_A160 * f39_48; + m_A255 += m_A161 * f39_48; + m_A256 += m_A162 * f39_48; + m_A257 += m_A163 * f39_48; + m_A258 += m_A164 * f39_48; + m_A259 += m_A165 * f39_48; + RHS48 += f39_48 * RHS39; + const double f39_49 = -f39 * m_A266; + m_A267 += m_A159 * f39_49; + m_A268 += m_A160 * f39_49; + m_A270 += m_A161 * f39_49; + m_A271 += m_A162 * f39_49; + m_A272 += m_A163 * f39_49; + m_A273 += m_A164 * f39_49; + m_A274 += m_A165 * f39_49; + RHS49 += f39_49 * RHS39; + const double f39_50 = -f39 * m_A280; + m_A281 += m_A159 * f39_50; + m_A282 += m_A160 * f39_50; + m_A284 += m_A161 * f39_50; + m_A285 += m_A162 * f39_50; + m_A286 += m_A163 * f39_50; + m_A287 += m_A164 * f39_50; + m_A288 += m_A165 * f39_50; + RHS50 += f39_50 * RHS39; + const double f40 = 1.0 / m_A172; + const double f40_43 = -f40 * m_A194; + m_A195 += m_A173 * f40_43; + m_A196 += m_A174 * f40_43; + m_A197 += m_A175 * f40_43; + m_A198 += m_A176 * f40_43; + m_A199 += m_A177 * f40_43; + m_A200 += m_A178 * f40_43; + m_A201 += m_A179 * f40_43; + RHS43 += f40_43 * RHS40; + const double f40_46 = -f40 * m_A220; + m_A221 += m_A173 * f40_46; + m_A222 += m_A174 * f40_46; + m_A223 += m_A175 * f40_46; + m_A224 += m_A176 * f40_46; + m_A225 += m_A177 * f40_46; + m_A226 += m_A178 * f40_46; + m_A227 += m_A179 * f40_46; + RHS46 += f40_46 * RHS40; + const double f40_47 = -f40 * m_A236; + m_A239 += m_A173 * f40_47; + m_A240 += m_A174 * f40_47; + m_A241 += m_A175 * f40_47; + m_A242 += m_A176 * f40_47; + m_A243 += m_A177 * f40_47; + m_A244 += m_A178 * f40_47; + m_A245 += m_A179 * f40_47; + RHS47 += f40_47 * RHS40; + const double f40_48 = -f40 * m_A252; + m_A253 += m_A173 * f40_48; + m_A255 += m_A174 * f40_48; + m_A256 += m_A175 * f40_48; + m_A257 += m_A176 * f40_48; + m_A258 += m_A177 * f40_48; + m_A259 += m_A178 * f40_48; + m_A260 += m_A179 * f40_48; + RHS48 += f40_48 * RHS40; + const double f40_49 = -f40 * m_A267; + m_A268 += m_A173 * f40_49; + m_A270 += m_A174 * f40_49; + m_A271 += m_A175 * f40_49; + m_A272 += m_A176 * f40_49; + m_A273 += m_A177 * f40_49; + m_A274 += m_A178 * f40_49; + m_A275 += m_A179 * f40_49; + RHS49 += f40_49 * RHS40; + const double f40_50 = -f40 * m_A281; + m_A282 += m_A173 * f40_50; + m_A284 += m_A174 * f40_50; + m_A285 += m_A175 * f40_50; + m_A286 += m_A176 * f40_50; + m_A287 += m_A177 * f40_50; + m_A288 += m_A178 * f40_50; + m_A289 += m_A179 * f40_50; + RHS50 += f40_50 * RHS40; + const double f40_51 = -f40 * m_A294; + m_A295 += m_A173 * f40_51; + m_A297 += m_A174 * f40_51; + m_A298 += m_A175 * f40_51; + m_A299 += m_A176 * f40_51; + m_A300 += m_A177 * f40_51; + m_A301 += m_A178 * f40_51; + m_A302 += m_A179 * f40_51; + RHS51 += f40_51 * RHS40; + const double f41 = 1.0 / m_A181; + const double f41_47 = -f41 * m_A237; + m_A241 += m_A182 * f41_47; + RHS47 += f41_47 * RHS41; + const double f42 = 1.0 / m_A186; + const double f42_47 = -f42 * m_A238; + m_A241 += m_A187 * f42_47; + RHS47 += f42_47 * RHS42; + const double f43 = 1.0 / m_A195; + const double f43_46 = -f43 * m_A221; + m_A222 += m_A196 * f43_46; + m_A223 += m_A197 * f43_46; + m_A224 += m_A198 * f43_46; + m_A225 += m_A199 * f43_46; + m_A226 += m_A200 * f43_46; + m_A227 += m_A201 * f43_46; + RHS46 += f43_46 * RHS43; + const double f43_47 = -f43 * m_A239; + m_A240 += m_A196 * f43_47; + m_A241 += m_A197 * f43_47; + m_A242 += m_A198 * f43_47; + m_A243 += m_A199 * f43_47; + m_A244 += m_A200 * f43_47; + m_A245 += m_A201 * f43_47; + RHS47 += f43_47 * RHS43; + const double f43_48 = -f43 * m_A253; + m_A255 += m_A196 * f43_48; + m_A256 += m_A197 * f43_48; + m_A257 += m_A198 * f43_48; + m_A258 += m_A199 * f43_48; + m_A259 += m_A200 * f43_48; + m_A260 += m_A201 * f43_48; + RHS48 += f43_48 * RHS43; + const double f43_49 = -f43 * m_A268; + m_A270 += m_A196 * f43_49; + m_A271 += m_A197 * f43_49; + m_A272 += m_A198 * f43_49; + m_A273 += m_A199 * f43_49; + m_A274 += m_A200 * f43_49; + m_A275 += m_A201 * f43_49; + RHS49 += f43_49 * RHS43; + const double f43_50 = -f43 * m_A282; + m_A284 += m_A196 * f43_50; + m_A285 += m_A197 * f43_50; + m_A286 += m_A198 * f43_50; + m_A287 += m_A199 * f43_50; + m_A288 += m_A200 * f43_50; + m_A289 += m_A201 * f43_50; + RHS50 += f43_50 * RHS43; + const double f43_51 = -f43 * m_A295; + m_A297 += m_A196 * f43_51; + m_A298 += m_A197 * f43_51; + m_A299 += m_A198 * f43_51; + m_A300 += m_A199 * f43_51; + m_A301 += m_A200 * f43_51; + m_A302 += m_A201 * f43_51; + RHS51 += f43_51 * RHS43; + const double f44 = 1.0 / m_A205; + const double f44_48 = -f44 * m_A254; + m_A257 += m_A206 * f44_48; + m_A258 += m_A207 * f44_48; + RHS48 += f44_48 * RHS44; + const double f44_49 = -f44 * m_A269; + m_A272 += m_A206 * f44_49; + m_A273 += m_A207 * f44_49; + RHS49 += f44_49 * RHS44; + const double f45 = 1.0 / m_A211; + const double f45_50 = -f45 * m_A283; + m_A288 += m_A212 * f45_50; + m_A289 += m_A213 * f45_50; + RHS50 += f45_50 * RHS45; + const double f45_51 = -f45 * m_A296; + m_A301 += m_A212 * f45_51; + m_A302 += m_A213 * f45_51; + RHS51 += f45_51 * RHS45; + const double f46 = 1.0 / m_A222; + const double f46_47 = -f46 * m_A240; + m_A241 += m_A223 * f46_47; + m_A242 += m_A224 * f46_47; + m_A243 += m_A225 * f46_47; + m_A244 += m_A226 * f46_47; + m_A245 += m_A227 * f46_47; + RHS47 += f46_47 * RHS46; + const double f46_48 = -f46 * m_A255; + m_A256 += m_A223 * f46_48; + m_A257 += m_A224 * f46_48; + m_A258 += m_A225 * f46_48; + m_A259 += m_A226 * f46_48; + m_A260 += m_A227 * f46_48; + RHS48 += f46_48 * RHS46; + const double f46_49 = -f46 * m_A270; + m_A271 += m_A223 * f46_49; + m_A272 += m_A224 * f46_49; + m_A273 += m_A225 * f46_49; + m_A274 += m_A226 * f46_49; + m_A275 += m_A227 * f46_49; + RHS49 += f46_49 * RHS46; + const double f46_50 = -f46 * m_A284; + m_A285 += m_A223 * f46_50; + m_A286 += m_A224 * f46_50; + m_A287 += m_A225 * f46_50; + m_A288 += m_A226 * f46_50; + m_A289 += m_A227 * f46_50; + RHS50 += f46_50 * RHS46; + const double f46_51 = -f46 * m_A297; + m_A298 += m_A223 * f46_51; + m_A299 += m_A224 * f46_51; + m_A300 += m_A225 * f46_51; + m_A301 += m_A226 * f46_51; + m_A302 += m_A227 * f46_51; + RHS51 += f46_51 * RHS46; + const double f47 = 1.0 / m_A241; + const double f47_48 = -f47 * m_A256; + m_A257 += m_A242 * f47_48; + m_A258 += m_A243 * f47_48; + m_A259 += m_A244 * f47_48; + m_A260 += m_A245 * f47_48; + RHS48 += f47_48 * RHS47; + const double f47_49 = -f47 * m_A271; + m_A272 += m_A242 * f47_49; + m_A273 += m_A243 * f47_49; + m_A274 += m_A244 * f47_49; + m_A275 += m_A245 * f47_49; + RHS49 += f47_49 * RHS47; + const double f47_50 = -f47 * m_A285; + m_A286 += m_A242 * f47_50; + m_A287 += m_A243 * f47_50; + m_A288 += m_A244 * f47_50; + m_A289 += m_A245 * f47_50; + RHS50 += f47_50 * RHS47; + const double f47_51 = -f47 * m_A298; + m_A299 += m_A242 * f47_51; + m_A300 += m_A243 * f47_51; + m_A301 += m_A244 * f47_51; + m_A302 += m_A245 * f47_51; + RHS51 += f47_51 * RHS47; + const double f48 = 1.0 / m_A257; + const double f48_49 = -f48 * m_A272; + m_A273 += m_A258 * f48_49; + m_A274 += m_A259 * f48_49; + m_A275 += m_A260 * f48_49; + RHS49 += f48_49 * RHS48; + const double f48_50 = -f48 * m_A286; + m_A287 += m_A258 * f48_50; + m_A288 += m_A259 * f48_50; + m_A289 += m_A260 * f48_50; + RHS50 += f48_50 * RHS48; + const double f48_51 = -f48 * m_A299; + m_A300 += m_A258 * f48_51; + m_A301 += m_A259 * f48_51; + m_A302 += m_A260 * f48_51; + RHS51 += f48_51 * RHS48; + const double f49 = 1.0 / m_A273; + const double f49_50 = -f49 * m_A287; + m_A288 += m_A274 * f49_50; + m_A289 += m_A275 * f49_50; + RHS50 += f49_50 * RHS49; + const double f49_51 = -f49 * m_A300; + m_A301 += m_A274 * f49_51; + m_A302 += m_A275 * f49_51; + RHS51 += f49_51 * RHS49; + const double f50 = 1.0 / m_A288; + const double f50_51 = -f50 * m_A301; + m_A302 += m_A289 * f50_51; + RHS51 += f50_51 * RHS50; + V[51] = RHS51 / m_A302; + double tmp50 = 0.0; + tmp50 += m_A289 * V[51]; + V[50] = (RHS50 - tmp50) / m_A288; + double tmp49 = 0.0; + tmp49 += m_A274 * V[50]; + tmp49 += m_A275 * V[51]; + V[49] = (RHS49 - tmp49) / m_A273; + double tmp48 = 0.0; + tmp48 += m_A258 * V[49]; + tmp48 += m_A259 * V[50]; + tmp48 += m_A260 * V[51]; + V[48] = (RHS48 - tmp48) / m_A257; + double tmp47 = 0.0; + tmp47 += m_A242 * V[48]; + tmp47 += m_A243 * V[49]; + tmp47 += m_A244 * V[50]; + tmp47 += m_A245 * V[51]; + V[47] = (RHS47 - tmp47) / m_A241; + double tmp46 = 0.0; + tmp46 += m_A223 * V[47]; + tmp46 += m_A224 * V[48]; + tmp46 += m_A225 * V[49]; + tmp46 += m_A226 * V[50]; + tmp46 += m_A227 * V[51]; + V[46] = (RHS46 - tmp46) / m_A222; + double tmp45 = 0.0; + tmp45 += m_A212 * V[50]; + tmp45 += m_A213 * V[51]; + V[45] = (RHS45 - tmp45) / m_A211; + double tmp44 = 0.0; + tmp44 += m_A206 * V[48]; + tmp44 += m_A207 * V[49]; + V[44] = (RHS44 - tmp44) / m_A205; + double tmp43 = 0.0; + tmp43 += m_A196 * V[46]; + tmp43 += m_A197 * V[47]; + tmp43 += m_A198 * V[48]; + tmp43 += m_A199 * V[49]; + tmp43 += m_A200 * V[50]; + tmp43 += m_A201 * V[51]; + V[43] = (RHS43 - tmp43) / m_A195; + double tmp42 = 0.0; + tmp42 += m_A187 * V[47]; + V[42] = (RHS42 - tmp42) / m_A186; + double tmp41 = 0.0; + tmp41 += m_A182 * V[47]; + V[41] = (RHS41 - tmp41) / m_A181; + double tmp40 = 0.0; + tmp40 += m_A173 * V[43]; + tmp40 += m_A174 * V[46]; + tmp40 += m_A175 * V[47]; + tmp40 += m_A176 * V[48]; + tmp40 += m_A177 * V[49]; + tmp40 += m_A178 * V[50]; + tmp40 += m_A179 * V[51]; + V[40] = (RHS40 - tmp40) / m_A172; + double tmp39 = 0.0; + tmp39 += m_A159 * V[40]; + tmp39 += m_A160 * V[43]; + tmp39 += m_A161 * V[46]; + tmp39 += m_A162 * V[47]; + tmp39 += m_A163 * V[48]; + tmp39 += m_A164 * V[49]; + tmp39 += m_A165 * V[50]; + V[39] = (RHS39 - tmp39) / m_A158; + double tmp38 = 0.0; + tmp38 += m_A149 * V[42]; + V[38] = (RHS38 - tmp38) / m_A148; + double tmp37 = 0.0; + tmp37 += m_A146 * V[47]; + V[37] = (RHS37 - tmp37) / m_A145; + double tmp36 = 0.0; + tmp36 += m_A138 * V[39]; + tmp36 += m_A139 * V[40]; + tmp36 += m_A140 * V[46]; + tmp36 += m_A141 * V[47]; + tmp36 += m_A142 * V[48]; + tmp36 += m_A143 * V[50]; + V[36] = (RHS36 - tmp36) / m_A137; + double tmp35 = 0.0; + tmp35 += m_A131 * V[46]; + tmp35 += m_A132 * V[51]; + V[35] = (RHS35 - tmp35) / m_A130; + double tmp34 = 0.0; + tmp34 += m_A127 * V[45]; + tmp34 += m_A128 * V[50]; + V[34] = (RHS34 - tmp34) / m_A126; + double tmp33 = 0.0; + tmp33 += m_A120 * V[36]; + tmp33 += m_A121 * V[40]; + tmp33 += m_A122 * V[46]; + tmp33 += m_A123 * V[47]; + tmp33 += m_A124 * V[48]; + V[33] = (RHS33 - tmp33) / m_A119; + double tmp32 = 0.0; + tmp32 += m_A112 * V[39]; + tmp32 += m_A113 * V[40]; + tmp32 += m_A114 * V[43]; + tmp32 += m_A115 * V[49]; + V[32] = (RHS32 - tmp32) / m_A111; + double tmp31 = 0.0; + tmp31 += m_A106 * V[40]; + tmp31 += m_A107 * V[51]; + V[31] = (RHS31 - tmp31) / m_A105; + double tmp30 = 0.0; + tmp30 += m_A100 * V[32]; + tmp30 += m_A101 * V[39]; + tmp30 += m_A102 * V[43]; + tmp30 += m_A103 * V[49]; + V[30] = (RHS30 - tmp30) / m_A99; + double tmp29 = 0.0; + tmp29 += m_A95 * V[47]; + V[29] = (RHS29 - tmp29) / m_A94; + double tmp28 = 0.0; + tmp28 += m_A90 * V[43]; + tmp28 += m_A91 * V[48]; + V[28] = (RHS28 - tmp28) / m_A89; + double tmp27 = 0.0; + tmp27 += m_A86 * V[44]; + tmp27 += m_A87 * V[49]; + V[27] = (RHS27 - tmp27) / m_A85; + double tmp26 = 0.0; + tmp26 += m_A83 * V[39]; + V[26] = (RHS26 - tmp26) / m_A82; + double tmp25 = 0.0; + tmp25 += m_A78 * V[42]; + tmp25 += m_A79 * V[47]; + V[25] = (RHS25 - tmp25) / m_A77; + double tmp24 = 0.0; + tmp24 += m_A75 * V[26]; + tmp24 += m_A76 * V[39]; + V[24] = (RHS24 - tmp24) / m_A74; + double tmp23 = 0.0; + tmp23 += m_A71 * V[42]; + V[23] = (RHS23 - tmp23) / m_A70; + double tmp22 = 0.0; + tmp22 += m_A68 * V[29]; + tmp22 += m_A69 * V[47]; + V[22] = (RHS22 - tmp22) / m_A67; + double tmp21 = 0.0; + tmp21 += m_A66 * V[47]; + V[21] = (RHS21 - tmp21) / m_A65; + double tmp20 = 0.0; + tmp20 += m_A63 * V[33]; + tmp20 += m_A64 * V[47]; + V[20] = (RHS20 - tmp20) / m_A62; + double tmp19 = 0.0; + tmp19 += m_A59 * V[33]; + tmp19 += m_A60 * V[36]; + tmp19 += m_A61 * V[46]; + V[19] = (RHS19 - tmp19) / m_A58; + double tmp18 = 0.0; + tmp18 += m_A57 * V[29]; + V[18] = (RHS18 - tmp18) / m_A56; + double tmp17 = 0.0; + tmp17 += m_A54 * V[33]; + tmp17 += m_A55 * V[48]; + V[17] = (RHS17 - tmp17) / m_A53; + double tmp16 = 0.0; + tmp16 += m_A52 * V[40]; + V[16] = (RHS16 - tmp16) / m_A51; + double tmp15 = 0.0; + tmp15 += m_A50 * V[40]; + V[15] = (RHS15 - tmp15) / m_A49; + double tmp14 = 0.0; + tmp14 += m_A48 * V[37]; + V[14] = (RHS14 - tmp14) / m_A47; + double tmp13 = 0.0; + tmp13 += m_A45 * V[31]; + tmp13 += m_A46 * V[51]; + V[13] = (RHS13 - tmp13) / m_A44; + double tmp12 = 0.0; + tmp12 += m_A41 * V[30]; + tmp12 += m_A42 * V[32]; + tmp12 += m_A43 * V[43]; + V[12] = (RHS12 - tmp12) / m_A40; + double tmp11 = 0.0; + tmp11 += m_A38 * V[36]; + tmp11 += m_A39 * V[50]; + V[11] = (RHS11 - tmp11) / m_A37; + double tmp10 = 0.0; + tmp10 += m_A35 * V[36]; + tmp10 += m_A36 * V[39]; + V[10] = (RHS10 - tmp10) / m_A34; + double tmp9 = 0.0; + tmp9 += m_A31 * V[24]; + tmp9 += m_A32 * V[26]; + tmp9 += m_A33 * V[39]; + V[9] = (RHS9 - tmp9) / m_A30; + double tmp8 = 0.0; + tmp8 += m_A28 * V[30]; + tmp8 += m_A29 * V[39]; + V[8] = (RHS8 - tmp8) / m_A27; + double tmp7 = 0.0; + tmp7 += m_A24 * V[35]; + tmp7 += m_A25 * V[46]; + tmp7 += m_A26 * V[51]; + V[7] = (RHS7 - tmp7) / m_A23; + double tmp6 = 0.0; + tmp6 += m_A22 * V[24]; + V[6] = (RHS6 - tmp6) / m_A21; + double tmp5 = 0.0; + tmp5 += m_A18 * V[34]; + tmp5 += m_A19 * V[45]; + tmp5 += m_A20 * V[50]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A15 * V[45]; + tmp4 += m_A16 * V[51]; + V[4] = (RHS4 - tmp4) / m_A14; + double tmp3 = 0.0; + tmp3 += m_A12 * V[30]; + tmp3 += m_A13 * V[49]; + V[3] = (RHS3 - tmp3) / m_A11; + double tmp2 = 0.0; + tmp2 += m_A8 * V[28]; + tmp2 += m_A9 * V[43]; + tmp2 += m_A10 * V[48]; + V[2] = (RHS2 - tmp2) / m_A7; + double tmp1 = 0.0; + tmp1 += m_A5 * V[44]; + tmp1 += m_A6 * V[48]; + V[1] = (RHS1 - tmp1) / m_A4; + double tmp0 = 0.0; + tmp0 += m_A1 * V[27]; + tmp0 += m_A2 * V[44]; + tmp0 += m_A3 * V[49]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// solarq +static void nl_gcr_176caa68e0d8e6e3_70_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A4 += go[3]; + m_A3 += go[4]; + m_A3 += go[5]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A7 += go[9]; + m_A6 += go[10]; + m_A6 += go[11]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[12] * *cnV[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A8 += gt[19]; + m_A10 += go[13]; + m_A9 += go[14]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[15] * *cnV[15]; + RHS3 -= go[16] * *cnV[16]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A11 += gt[23]; + m_A11 += gt[24]; + m_A11 += gt[25]; + m_A11 += gt[26]; + m_A12 += go[20]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 += Idr[26]; + RHS4 -= go[21] * *cnV[21]; + RHS4 -= go[22] * *cnV[22]; + RHS4 -= go[23] * *cnV[23]; + RHS4 -= go[24] * *cnV[24]; + RHS4 -= go[25] * *cnV[25]; + RHS4 -= go[26] * *cnV[26]; + m_A13 += gt[27]; + m_A13 += gt[28]; + m_A13 += gt[29]; + m_A13 += gt[30]; + m_A13 += gt[31]; + m_A14 += go[27]; + m_A15 += go[28]; + double RHS5 = Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 += Idr[30]; + RHS5 += Idr[31]; + RHS5 -= go[29] * *cnV[29]; + RHS5 -= go[30] * *cnV[30]; + RHS5 -= go[31] * *cnV[31]; + m_A16 += gt[32]; + m_A16 += gt[33]; + m_A16 += gt[34]; + m_A16 += gt[35]; + m_A16 += gt[36]; + m_A16 += gt[37]; + m_A16 += gt[38]; + m_A17 += go[32]; + m_A18 += go[33]; + double RHS6 = Idr[32]; + RHS6 += Idr[33]; + RHS6 += Idr[34]; + RHS6 += Idr[35]; + RHS6 += Idr[36]; + RHS6 += Idr[37]; + RHS6 += Idr[38]; + RHS6 -= go[34] * *cnV[34]; + RHS6 -= go[35] * *cnV[35]; + RHS6 -= go[36] * *cnV[36]; + RHS6 -= go[37] * *cnV[37]; + RHS6 -= go[38] * *cnV[38]; + m_A19 += gt[39]; + m_A19 += gt[40]; + m_A19 += gt[41]; + m_A19 += gt[42]; + m_A20 += go[39]; + m_A21 += go[40]; + double RHS7 = Idr[39]; + RHS7 += Idr[40]; + RHS7 += Idr[41]; + RHS7 += Idr[42]; + RHS7 -= go[41] * *cnV[41]; + RHS7 -= go[42] * *cnV[42]; + m_A22 += gt[43]; + m_A22 += gt[44]; + m_A22 += gt[45]; + m_A22 += gt[46]; + m_A22 += gt[47]; + m_A23 += go[43]; + m_A24 += go[44]; + double RHS8 = Idr[43]; + RHS8 += Idr[44]; + RHS8 += Idr[45]; + RHS8 += Idr[46]; + RHS8 += Idr[47]; + RHS8 -= go[45] * *cnV[45]; + RHS8 -= go[46] * *cnV[46]; + RHS8 -= go[47] * *cnV[47]; + m_A25 += gt[48]; + m_A25 += gt[49]; + m_A25 += gt[50]; + m_A26 += go[48]; + m_A27 += go[49]; + double RHS9 = Idr[48]; + RHS9 += Idr[49]; + RHS9 += Idr[50]; + RHS9 -= go[50] * *cnV[50]; + m_A30 += gt[51]; + m_A30 += gt[52]; + m_A30 += gt[53]; + m_A30 += gt[54]; + m_A30 += gt[55]; + m_A30 += gt[56]; + m_A29 += go[51]; + m_A29 += go[52]; + m_A28 += go[53]; + double RHS10 = Idr[51]; + RHS10 += Idr[52]; + RHS10 += Idr[53]; + RHS10 += Idr[54]; + RHS10 += Idr[55]; + RHS10 += Idr[56]; + RHS10 -= go[54] * *cnV[54]; + RHS10 -= go[55] * *cnV[55]; + RHS10 -= go[56] * *cnV[56]; + m_A35 += gt[57]; + m_A35 += gt[58]; + m_A35 += gt[59]; + m_A35 += gt[60]; + m_A35 += gt[61]; + m_A33 += go[57]; + m_A33 += go[58]; + m_A32 += go[59]; + double RHS11 = Idr[57]; + RHS11 += Idr[58]; + RHS11 += Idr[59]; + RHS11 += Idr[60]; + RHS11 += Idr[61]; + RHS11 -= go[60] * *cnV[60]; + RHS11 -= go[61] * *cnV[61]; + m_A39 += gt[62]; + m_A39 += gt[63]; + m_A39 += gt[64]; + m_A39 += gt[65]; + m_A39 += gt[66]; + m_A40 += go[62]; + m_A37 += go[63]; + double RHS12 = Idr[62]; + RHS12 += Idr[63]; + RHS12 += Idr[64]; + RHS12 += Idr[65]; + RHS12 += Idr[66]; + RHS12 -= go[64] * *cnV[64]; + RHS12 -= go[65] * *cnV[65]; + RHS12 -= go[66] * *cnV[66]; + m_A42 += gt[67]; + m_A42 += gt[68]; + m_A42 += gt[69]; + m_A42 += gt[70]; + m_A42 += gt[71]; + m_A42 += gt[72]; + m_A42 += gt[73]; + m_A43 += go[67]; + m_A41 += go[68]; + double RHS13 = Idr[67]; + RHS13 += Idr[68]; + RHS13 += Idr[69]; + RHS13 += Idr[70]; + RHS13 += Idr[71]; + RHS13 += Idr[72]; + RHS13 += Idr[73]; + RHS13 -= go[69] * *cnV[69]; + RHS13 -= go[70] * *cnV[70]; + RHS13 -= go[71] * *cnV[71]; + RHS13 -= go[72] * *cnV[72]; + RHS13 -= go[73] * *cnV[73]; + m_A48 += gt[74]; + m_A48 += gt[75]; + m_A48 += gt[76]; + m_A46 += go[74]; + m_A45 += go[75]; + m_A50 += go[76]; + double RHS14 = Idr[74]; + RHS14 += Idr[75]; + RHS14 += Idr[76]; + m_A55 += gt[77]; + m_A55 += gt[78]; + m_A55 += gt[79]; + m_A53 += go[77]; + m_A51 += go[78]; + m_A57 += go[79]; + double RHS15 = Idr[77]; + RHS15 += Idr[78]; + RHS15 += Idr[79]; + m_A62 += gt[80]; + m_A62 += gt[81]; + m_A62 += gt[82]; + m_A62 += gt[83]; + m_A62 += gt[84]; + m_A58 += go[80]; + m_A60 += go[81]; + m_A59 += go[82]; + double RHS16 = Idr[80]; + RHS16 += Idr[81]; + RHS16 += Idr[82]; + RHS16 += Idr[83]; + RHS16 += Idr[84]; + RHS16 -= go[83] * *cnV[83]; + RHS16 -= go[84] * *cnV[84]; + m_A69 += gt[85]; + m_A69 += gt[86]; + m_A69 += gt[87]; + m_A69 += gt[88]; + m_A69 += gt[89]; + m_A69 += gt[90]; + m_A64 += go[85]; + m_A67 += go[86]; + m_A65 += go[87]; + m_A66 += go[88]; + double RHS17 = Idr[85]; + RHS17 += Idr[86]; + RHS17 += Idr[87]; + RHS17 += Idr[88]; + RHS17 += Idr[89]; + RHS17 += Idr[90]; + RHS17 -= go[89] * *cnV[89]; + RHS17 -= go[90] * *cnV[90]; + const double f0 = 1.0 / m_A0; + const double f0_10 = -f0 * m_A28; + m_A30 += m_A1 * f0_10; + RHS10 += f0_10 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_10 = -f1 * m_A29; + m_A30 += m_A3 * f1_10; + m_A31 += m_A4 * f1_10; + RHS10 += f1_10 * RHS1; + const double f1_11 = -f1 * m_A32; + m_A34 += m_A3 * f1_11; + m_A35 += m_A4 * f1_11; + RHS11 += f1_11 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_11 = -f2 * m_A33; + m_A35 += m_A6 * f2_11; + m_A36 += m_A7 * f2_11; + RHS11 += f2_11 * RHS2; + const double f2_12 = -f2 * m_A37; + m_A38 += m_A6 * f2_12; + m_A39 += m_A7 * f2_12; + RHS12 += f2_12 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_17 = -f3 * m_A64; + m_A66 += m_A9 * f3_17; + m_A69 += m_A10 * f3_17; + RHS17 += f3_17 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_16 = -f4 * m_A58; + m_A59 += m_A12 * f4_16; + RHS16 += f4_16 * RHS4; + const double f5 = 1.0 / m_A13; + const double f5_15 = -f5 * m_A51; + m_A52 += m_A14 * f5_15; + m_A55 += m_A15 * f5_15; + RHS15 += f5_15 * RHS5; + const double f6 = 1.0 / m_A16; + const double f6_15 = -f6 * m_A52; + m_A53 += m_A17 * f6_15; + m_A55 += m_A18 * f6_15; + RHS15 += f6_15 * RHS6; + const double f7 = 1.0 / m_A19; + const double f7_13 = -f7 * m_A41; + m_A43 += m_A20 * f7_13; + m_A44 += m_A21 * f7_13; + RHS13 += f7_13 * RHS7; + const double f7_14 = -f7 * m_A45; + m_A48 += m_A20 * f7_14; + m_A49 += m_A21 * f7_14; + RHS14 += f7_14 * RHS7; + const double f7_15 = -f7 * m_A53; + m_A54 += m_A20 * f7_15; + m_A55 += m_A21 * f7_15; + RHS15 += f7_15 * RHS7; + const double f8 = 1.0 / m_A22; + const double f8_14 = -f8 * m_A46; + m_A47 += m_A23 * f8_14; + m_A48 += m_A24 * f8_14; + RHS14 += f8_14 * RHS8; + const double f9 = 1.0 / m_A25; + const double f9_16 = -f9 * m_A59; + m_A62 += m_A26 * f9_16; + m_A63 += m_A27 * f9_16; + RHS16 += f9_16 * RHS9; + const double f9_17 = -f9 * m_A65; + m_A68 += m_A26 * f9_17; + m_A69 += m_A27 * f9_17; + RHS17 += f9_17 * RHS9; + const double f10 = 1.0 / m_A30; + const double f10_11 = -f10 * m_A34; + m_A35 += m_A31 * f10_11; + RHS11 += f10_11 * RHS10; + const double f11 = 1.0 / m_A35; + const double f11_12 = -f11 * m_A38; + m_A39 += m_A36 * f11_12; + RHS12 += f11_12 * RHS11; + const double f12 = 1.0 / m_A39; + const double f12_17 = -f12 * m_A66; + m_A69 += m_A40 * f12_17; + RHS17 += f12_17 * RHS12; + const double f13 = 1.0 / m_A42; + const double f13_14 = -f13 * m_A47; + m_A48 += m_A43 * f13_14; + m_A49 += m_A44 * f13_14; + RHS14 += f13_14 * RHS13; + const double f14 = 1.0 / m_A48; + const double f14_15 = -f14 * m_A54; + m_A55 += m_A49 * f14_15; + m_A56 += m_A50 * f14_15; + RHS15 += f14_15 * RHS14; + const double f14_16 = -f14 * m_A60; + m_A61 += m_A49 * f14_16; + m_A62 += m_A50 * f14_16; + RHS16 += f14_16 * RHS14; + const double f15 = 1.0 / m_A55; + const double f15_16 = -f15 * m_A61; + m_A62 += m_A56 * f15_16; + m_A63 += m_A57 * f15_16; + RHS16 += f15_16 * RHS15; + const double f15_17 = -f15 * m_A67; + m_A68 += m_A56 * f15_17; + m_A69 += m_A57 * f15_17; + RHS17 += f15_17 * RHS15; + const double f16 = 1.0 / m_A62; + const double f16_17 = -f16 * m_A68; + m_A69 += m_A63 * f16_17; + RHS17 += f16_17 * RHS16; + V[17] = RHS17 / m_A69; + double tmp16 = 0.0; + tmp16 += m_A63 * V[17]; + V[16] = (RHS16 - tmp16) / m_A62; + double tmp15 = 0.0; + tmp15 += m_A56 * V[16]; + tmp15 += m_A57 * V[17]; + V[15] = (RHS15 - tmp15) / m_A55; + double tmp14 = 0.0; + tmp14 += m_A49 * V[15]; + tmp14 += m_A50 * V[16]; + V[14] = (RHS14 - tmp14) / m_A48; + double tmp13 = 0.0; + tmp13 += m_A43 * V[14]; + tmp13 += m_A44 * V[15]; + V[13] = (RHS13 - tmp13) / m_A42; + double tmp12 = 0.0; + tmp12 += m_A40 * V[17]; + V[12] = (RHS12 - tmp12) / m_A39; + double tmp11 = 0.0; + tmp11 += m_A36 * V[12]; + V[11] = (RHS11 - tmp11) / m_A35; + double tmp10 = 0.0; + tmp10 += m_A31 * V[11]; + V[10] = (RHS10 - tmp10) / m_A30; + double tmp9 = 0.0; + tmp9 += m_A26 * V[16]; + tmp9 += m_A27 * V[17]; + V[9] = (RHS9 - tmp9) / m_A25; + double tmp8 = 0.0; + tmp8 += m_A23 * V[13]; + tmp8 += m_A24 * V[14]; + V[8] = (RHS8 - tmp8) / m_A22; + double tmp7 = 0.0; + tmp7 += m_A20 * V[14]; + tmp7 += m_A21 * V[15]; + V[7] = (RHS7 - tmp7) / m_A19; + double tmp6 = 0.0; + tmp6 += m_A17 * V[7]; + tmp6 += m_A18 * V[15]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[6]; + tmp5 += m_A15 * V[15]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A12 * V[9]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A9 * V[12]; + tmp3 += m_A10 * V[17]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A6 * V[11]; + tmp2 += m_A7 * V[12]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[10]; + tmp1 += m_A4 * V[11]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[10]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // breakout static void nl_gcr_1993cb957e80c097_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -1304,6 +5699,430 @@ static void nl_gcr_1993cb957e80c097_10_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// sundance +static void nl_gcr_1bc9f4a77b148e65_70_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A7 += go[6]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + RHS3 += Idr[8]; + RHS3 -= go[7] * *cnV[7]; + RHS3 -= go[8] * *cnV[8]; + m_A8 += gt[9]; + m_A8 += gt[10]; + m_A10 += go[9]; + m_A9 += go[10]; + double RHS4 = Idr[9]; + RHS4 += Idr[10]; + m_A11 += gt[11]; + m_A11 += gt[12]; + m_A11 += gt[13]; + m_A12 += go[11]; + m_A13 += go[12]; + double RHS5 = Idr[11]; + RHS5 += Idr[12]; + RHS5 += Idr[13]; + RHS5 -= go[13] * *cnV[13]; + m_A14 += gt[14]; + m_A14 += gt[15]; + m_A14 += gt[16]; + m_A14 += gt[17]; + m_A14 += gt[18]; + m_A14 += gt[19]; + m_A14 += gt[20]; + m_A15 += go[14]; + double RHS6 = Idr[14]; + RHS6 += Idr[15]; + RHS6 += Idr[16]; + RHS6 += Idr[17]; + RHS6 += Idr[18]; + RHS6 += Idr[19]; + RHS6 += Idr[20]; + RHS6 -= go[15] * *cnV[15]; + RHS6 -= go[16] * *cnV[16]; + RHS6 -= go[17] * *cnV[17]; + RHS6 -= go[18] * *cnV[18]; + RHS6 -= go[19] * *cnV[19]; + RHS6 -= go[20] * *cnV[20]; + m_A16 += gt[21]; + m_A16 += gt[22]; + m_A16 += gt[23]; + m_A16 += gt[24]; + m_A18 += go[21]; + m_A18 += go[22]; + m_A17 += go[23]; + double RHS7 = Idr[21]; + RHS7 += Idr[22]; + RHS7 += Idr[23]; + RHS7 += Idr[24]; + RHS7 -= go[24] * *cnV[24]; + m_A19 += gt[25]; + m_A19 += gt[26]; + m_A21 += go[25]; + m_A20 += go[26]; + double RHS8 = Idr[25]; + RHS8 += Idr[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A22 += gt[29]; + m_A24 += go[27]; + m_A23 += go[28]; + double RHS9 = Idr[27]; + RHS9 += Idr[28]; + RHS9 += Idr[29]; + RHS9 -= go[29] * *cnV[29]; + m_A27 += gt[30]; + m_A27 += gt[31]; + m_A26 += go[30]; + m_A25 += go[31]; + double RHS10 = Idr[30]; + RHS10 += Idr[31]; + m_A31 += gt[32]; + m_A31 += gt[33]; + m_A31 += gt[34]; + m_A32 += go[32]; + m_A30 += go[33]; + double RHS11 = Idr[32]; + RHS11 += Idr[33]; + RHS11 += Idr[34]; + RHS11 -= go[34] * *cnV[34]; + m_A35 += gt[35]; + m_A35 += gt[36]; + m_A35 += gt[37]; + m_A34 += go[35]; + m_A33 += go[36]; + double RHS12 = Idr[35]; + RHS12 += Idr[36]; + RHS12 += Idr[37]; + RHS12 -= go[37] * *cnV[37]; + m_A40 += gt[38]; + m_A40 += gt[39]; + m_A40 += gt[40]; + m_A40 += gt[41]; + m_A43 += go[38]; + m_A38 += go[39]; + m_A37 += go[40]; + double RHS13 = Idr[38]; + RHS13 += Idr[39]; + RHS13 += Idr[40]; + RHS13 += Idr[41]; + RHS13 -= go[41] * *cnV[41]; + m_A50 += gt[42]; + m_A50 += gt[43]; + m_A50 += gt[44]; + m_A50 += gt[45]; + m_A50 += gt[46]; + m_A50 += gt[47]; + m_A44 += go[42]; + m_A46 += go[43]; + m_A45 += go[44]; + m_A45 += go[45]; + double RHS14 = Idr[42]; + RHS14 += Idr[43]; + RHS14 += Idr[44]; + RHS14 += Idr[45]; + RHS14 += Idr[46]; + RHS14 += Idr[47]; + RHS14 -= go[46] * *cnV[46]; + RHS14 -= go[47] * *cnV[47]; + m_A55 += gt[48]; + m_A55 += gt[49]; + m_A55 += gt[50]; + m_A54 += go[48]; + m_A53 += go[49]; + double RHS15 = Idr[48]; + RHS15 += Idr[49]; + RHS15 += Idr[50]; + RHS15 -= go[50] * *cnV[50]; + m_A62 += gt[51]; + m_A62 += gt[52]; + m_A62 += gt[53]; + m_A62 += gt[54]; + m_A57 += go[51]; + m_A58 += go[52]; + m_A59 += go[53]; + double RHS16 = Idr[51]; + RHS16 += Idr[52]; + RHS16 += Idr[53]; + RHS16 += Idr[54]; + RHS16 -= go[54] * *cnV[54]; + m_A69 += gt[55]; + m_A69 += gt[56]; + m_A64 += go[55]; + m_A65 += go[56]; + double RHS17 = Idr[55]; + RHS17 += Idr[56]; + const double f0 = 1.0 / m_A0; + const double f0_15 = -f0 * m_A53; + m_A55 += m_A1 * f0_15; + RHS15 += f0_15 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_12 = -f1 * m_A33; + m_A35 += m_A3 * f1_12; + RHS12 += f1_12 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_11 = -f2 * m_A30; + m_A31 += m_A5 * f2_11; + RHS11 += f2_11 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_16 = -f3 * m_A57; + m_A62 += m_A7 * f3_16; + RHS16 += f3_16 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_13 = -f4 * m_A37; + m_A40 += m_A9 * f4_13; + m_A42 += m_A10 * f4_13; + RHS13 += f4_13 * RHS4; + const double f4_16 = -f4 * m_A58; + m_A60 += m_A9 * f4_16; + m_A62 += m_A10 * f4_16; + RHS16 += f4_16 * RHS4; + const double f5 = 1.0 / m_A11; + const double f5_10 = -f5 * m_A25; + m_A27 += m_A12 * f5_10; + m_A28 += m_A13 * f5_10; + RHS10 += f5_10 * RHS5; + const double f5_13 = -f5 * m_A38; + m_A39 += m_A12 * f5_13; + m_A40 += m_A13 * f5_13; + RHS13 += f5_13 * RHS5; + const double f6 = 1.0 / m_A14; + const double f6_14 = -f6 * m_A44; + m_A45 += m_A15 * f6_14; + RHS14 += f6_14 * RHS6; + const double f7 = 1.0 / m_A16; + const double f7_10 = -f7 * m_A26; + m_A27 += m_A17 * f7_10; + m_A29 += m_A18 * f7_10; + RHS10 += f7_10 * RHS7; + const double f7_14 = -f7 * m_A45; + m_A47 += m_A17 * f7_14; + m_A50 += m_A18 * f7_14; + RHS14 += f7_14 * RHS7; + const double f8 = 1.0 / m_A19; + const double f8_12 = -f8 * m_A34; + m_A35 += m_A20 * f8_12; + m_A36 += m_A21 * f8_12; + RHS12 += f8_12 * RHS8; + const double f8_14 = -f8 * m_A46; + m_A48 += m_A20 * f8_14; + m_A50 += m_A21 * f8_14; + RHS14 += f8_14 * RHS8; + const double f9 = 1.0 / m_A22; + const double f9_15 = -f9 * m_A54; + m_A55 += m_A23 * f9_15; + m_A56 += m_A24 * f9_15; + RHS15 += f9_15 * RHS9; + const double f9_17 = -f9 * m_A64; + m_A67 += m_A23 * f9_17; + m_A69 += m_A24 * f9_17; + RHS17 += f9_17 * RHS9; + const double f10 = 1.0 / m_A27; + const double f10_13 = -f10 * m_A39; + m_A40 += m_A28 * f10_13; + m_A41 += m_A29 * f10_13; + RHS13 += f10_13 * RHS10; + const double f10_14 = -f10 * m_A47; + m_A49 += m_A28 * f10_14; + m_A50 += m_A29 * f10_14; + RHS14 += f10_14 * RHS10; + const double f11 = 1.0 / m_A31; + const double f11_16 = -f11 * m_A59; + m_A62 += m_A32 * f11_16; + RHS16 += f11_16 * RHS11; + const double f12 = 1.0 / m_A35; + const double f12_14 = -f12 * m_A48; + m_A50 += m_A36 * f12_14; + RHS14 += f12_14 * RHS12; + const double f13 = 1.0 / m_A40; + const double f13_14 = -f13 * m_A49; + m_A50 += m_A41 * f13_14; + m_A51 += m_A42 * f13_14; + m_A52 += m_A43 * f13_14; + RHS14 += f13_14 * RHS13; + const double f13_16 = -f13 * m_A60; + m_A61 += m_A41 * f13_16; + m_A62 += m_A42 * f13_16; + m_A63 += m_A43 * f13_16; + RHS16 += f13_16 * RHS13; + const double f13_17 = -f13 * m_A65; + m_A66 += m_A41 * f13_17; + m_A68 += m_A42 * f13_17; + m_A69 += m_A43 * f13_17; + RHS17 += f13_17 * RHS13; + const double f14 = 1.0 / m_A50; + const double f14_16 = -f14 * m_A61; + m_A62 += m_A51 * f14_16; + m_A63 += m_A52 * f14_16; + RHS16 += f14_16 * RHS14; + const double f14_17 = -f14 * m_A66; + m_A68 += m_A51 * f14_17; + m_A69 += m_A52 * f14_17; + RHS17 += f14_17 * RHS14; + const double f15 = 1.0 / m_A55; + const double f15_17 = -f15 * m_A67; + m_A69 += m_A56 * f15_17; + RHS17 += f15_17 * RHS15; + const double f16 = 1.0 / m_A62; + const double f16_17 = -f16 * m_A68; + m_A69 += m_A63 * f16_17; + RHS17 += f16_17 * RHS16; + V[17] = RHS17 / m_A69; + double tmp16 = 0.0; + tmp16 += m_A63 * V[17]; + V[16] = (RHS16 - tmp16) / m_A62; + double tmp15 = 0.0; + tmp15 += m_A56 * V[17]; + V[15] = (RHS15 - tmp15) / m_A55; + double tmp14 = 0.0; + tmp14 += m_A51 * V[16]; + tmp14 += m_A52 * V[17]; + V[14] = (RHS14 - tmp14) / m_A50; + double tmp13 = 0.0; + tmp13 += m_A41 * V[14]; + tmp13 += m_A42 * V[16]; + tmp13 += m_A43 * V[17]; + V[13] = (RHS13 - tmp13) / m_A40; + double tmp12 = 0.0; + tmp12 += m_A36 * V[14]; + V[12] = (RHS12 - tmp12) / m_A35; + double tmp11 = 0.0; + tmp11 += m_A32 * V[16]; + V[11] = (RHS11 - tmp11) / m_A31; + double tmp10 = 0.0; + tmp10 += m_A28 * V[13]; + tmp10 += m_A29 * V[14]; + V[10] = (RHS10 - tmp10) / m_A27; + double tmp9 = 0.0; + tmp9 += m_A23 * V[15]; + tmp9 += m_A24 * V[17]; + V[9] = (RHS9 - tmp9) / m_A22; + double tmp8 = 0.0; + tmp8 += m_A20 * V[12]; + tmp8 += m_A21 * V[14]; + V[8] = (RHS8 - tmp8) / m_A19; + double tmp7 = 0.0; + tmp7 += m_A17 * V[10]; + tmp7 += m_A18 * V[14]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A15 * V[7]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A12 * V[10]; + tmp5 += m_A13 * V[13]; + V[5] = (RHS5 - tmp5) / m_A11; + double tmp4 = 0.0; + tmp4 += m_A9 * V[13]; + tmp4 += m_A10 * V[16]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[16]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[11]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[12]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[15]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_1cbd5d704f6e93c1_67_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -2546,6 +7365,516 @@ static void nl_gcr_20d478ed5597161_123_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// barrier +static void nl_gcr_2409b70ed4eff4c3_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A5 += gt[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A5 += gt[9]; + m_A4 += go[6]; + m_A6 += go[7]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + m_A9 += gt[10]; + m_A9 += gt[11]; + m_A9 += gt[12]; + m_A9 += gt[13]; + m_A9 += gt[14]; + m_A7 += go[10]; + m_A8 += go[11]; + double RHS3 = Idr[10]; + RHS3 += Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 -= go[12] * *cnV[12]; + RHS3 -= go[13] * *cnV[13]; + RHS3 -= go[14] * *cnV[14]; + 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; +} + +// armora +static void nl_gcr_24c4f3c5388505ff_67_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A7 += go[6]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + RHS3 -= go[7] * *cnV[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A9 += go[8]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + RHS4 -= go[9] * *cnV[9]; + m_A10 += gt[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A12 += go[10]; + m_A11 += go[11]; + double RHS5 = Idr[10]; + RHS5 += Idr[11]; + RHS5 += Idr[12]; + RHS5 -= go[12] * *cnV[12]; + m_A13 += gt[13]; + m_A13 += gt[14]; + m_A13 += gt[15]; + m_A15 += go[13]; + m_A14 += go[14]; + double RHS6 = Idr[13]; + RHS6 += Idr[14]; + RHS6 += Idr[15]; + RHS6 -= go[15] * *cnV[15]; + m_A16 += gt[16]; + m_A16 += gt[17]; + m_A16 += gt[18]; + m_A18 += go[16]; + m_A17 += go[17]; + double RHS7 = Idr[16]; + RHS7 += Idr[17]; + RHS7 += Idr[18]; + RHS7 -= go[18] * *cnV[18]; + m_A19 += gt[19]; + m_A19 += gt[20]; + m_A19 += gt[21]; + m_A19 += gt[22]; + m_A19 += gt[23]; + m_A19 += gt[24]; + m_A19 += gt[25]; + m_A21 += go[19]; + m_A20 += go[20]; + double RHS8 = Idr[19]; + RHS8 += Idr[20]; + RHS8 += Idr[21]; + RHS8 += Idr[22]; + RHS8 += Idr[23]; + RHS8 += Idr[24]; + RHS8 += Idr[25]; + RHS8 -= go[21] * *cnV[21]; + RHS8 -= go[22] * *cnV[22]; + RHS8 -= go[23] * *cnV[23]; + RHS8 -= go[24] * *cnV[24]; + RHS8 -= go[25] * *cnV[25]; + m_A22 += gt[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A23 += go[26]; + m_A24 += go[27]; + double RHS9 = Idr[26]; + RHS9 += Idr[27]; + RHS9 += Idr[28]; + RHS9 -= go[28] * *cnV[28]; + m_A26 += gt[29]; + m_A26 += gt[30]; + m_A26 += gt[31]; + m_A27 += go[29]; + m_A25 += go[30]; + double RHS10 = Idr[29]; + RHS10 += Idr[30]; + RHS10 += Idr[31]; + RHS10 -= go[31] * *cnV[31]; + m_A30 += gt[32]; + m_A30 += gt[33]; + m_A30 += gt[34]; + m_A29 += go[32]; + m_A28 += go[33]; + double RHS11 = Idr[32]; + RHS11 += Idr[33]; + RHS11 += Idr[34]; + RHS11 -= go[34] * *cnV[34]; + m_A33 += gt[35]; + m_A33 += gt[36]; + m_A33 += gt[37]; + m_A34 += go[35]; + m_A32 += go[36]; + double RHS12 = Idr[35]; + RHS12 += Idr[36]; + RHS12 += Idr[37]; + RHS12 -= go[37] * *cnV[37]; + m_A37 += gt[38]; + m_A37 += gt[39]; + m_A37 += gt[40]; + m_A36 += go[38]; + m_A35 += go[39]; + double RHS13 = Idr[38]; + RHS13 += Idr[39]; + RHS13 += Idr[40]; + RHS13 -= go[40] * *cnV[40]; + m_A41 += gt[41]; + m_A41 += gt[42]; + m_A41 += gt[43]; + m_A39 += go[41]; + m_A42 += go[42]; + double RHS14 = Idr[41]; + RHS14 += Idr[42]; + RHS14 += Idr[43]; + RHS14 -= go[43] * *cnV[43]; + m_A45 += gt[44]; + m_A45 += gt[45]; + m_A45 += gt[46]; + m_A44 += go[44]; + m_A43 += go[45]; + double RHS15 = Idr[44]; + RHS15 += Idr[45]; + RHS15 += Idr[46]; + RHS15 -= go[46] * *cnV[46]; + m_A49 += gt[47]; + m_A49 += gt[48]; + m_A49 += gt[49]; + m_A47 += go[47]; + m_A50 += go[48]; + double RHS16 = Idr[47]; + RHS16 += Idr[48]; + RHS16 += Idr[49]; + RHS16 -= go[49] * *cnV[49]; + m_A53 += gt[50]; + m_A53 += gt[51]; + m_A53 += gt[52]; + m_A51 += go[50]; + m_A52 += go[51]; + double RHS17 = Idr[50]; + RHS17 += Idr[51]; + RHS17 += Idr[52]; + RHS17 -= go[52] * *cnV[52]; + m_A57 += gt[53]; + m_A57 += gt[54]; + m_A57 += gt[55]; + m_A55 += go[53]; + m_A58 += go[54]; + double RHS18 = Idr[53]; + RHS18 += Idr[54]; + RHS18 += Idr[55]; + RHS18 -= go[55] * *cnV[55]; + m_A66 += gt[56]; + m_A66 += gt[57]; + m_A66 += gt[58]; + m_A66 += gt[59]; + m_A66 += gt[60]; + m_A66 += gt[61]; + m_A66 += gt[62]; + m_A66 += gt[63]; + m_A59 += go[56]; + m_A60 += go[57]; + m_A65 += go[58]; + m_A63 += go[59]; + m_A62 += go[60]; + m_A61 += go[61]; + double RHS19 = Idr[56]; + RHS19 += Idr[57]; + RHS19 += Idr[58]; + RHS19 += Idr[59]; + RHS19 += Idr[60]; + RHS19 += Idr[61]; + RHS19 += Idr[62]; + RHS19 += Idr[63]; + RHS19 -= go[62] * *cnV[62]; + RHS19 -= go[63] * *cnV[63]; + const double f0 = 1.0 / m_A0; + const double f0_11 = -f0 * m_A28; + m_A30 += m_A1 * f0_11; + RHS11 += f0_11 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_13 = -f1 * m_A35; + m_A37 += m_A3 * f1_13; + RHS13 += f1_13 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_15 = -f2 * m_A43; + m_A45 += m_A5 * f2_15; + RHS15 += f2_15 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_10 = -f3 * m_A25; + m_A26 += m_A7 * f3_10; + RHS10 += f3_10 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_12 = -f4 * m_A32; + m_A33 += m_A9 * f4_12; + RHS12 += f4_12 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_11 = -f5 * m_A29; + m_A30 += m_A11 * f5_11; + m_A31 += m_A12 * f5_11; + RHS11 += f5_11 * RHS5; + const double f5_14 = -f5 * m_A39; + m_A40 += m_A11 * f5_14; + m_A41 += m_A12 * f5_14; + RHS14 += f5_14 * RHS5; + const double f6 = 1.0 / m_A13; + const double f6_13 = -f6 * m_A36; + m_A37 += m_A14 * f6_13; + m_A38 += m_A15 * f6_13; + RHS13 += f6_13 * RHS6; + const double f6_16 = -f6 * m_A47; + m_A48 += m_A14 * f6_16; + m_A49 += m_A15 * f6_16; + RHS16 += f6_16 * RHS6; + const double f7 = 1.0 / m_A16; + const double f7_15 = -f7 * m_A44; + m_A45 += m_A17 * f7_15; + m_A46 += m_A18 * f7_15; + RHS15 += f7_15 * RHS7; + const double f7_18 = -f7 * m_A55; + m_A56 += m_A17 * f7_18; + m_A57 += m_A18 * f7_18; + RHS18 += f7_18 * RHS7; + const double f8 = 1.0 / m_A19; + const double f8_19 = -f8 * m_A59; + m_A61 += m_A20 * f8_19; + m_A66 += m_A21 * f8_19; + RHS19 += f8_19 * RHS8; + const double f9 = 1.0 / m_A22; + const double f9_17 = -f9 * m_A51; + m_A53 += m_A23 * f9_17; + m_A54 += m_A24 * f9_17; + RHS17 += f9_17 * RHS9; + const double f9_19 = -f9 * m_A60; + m_A64 += m_A23 * f9_19; + m_A66 += m_A24 * f9_19; + RHS19 += f9_19 * RHS9; + const double f10 = 1.0 / m_A26; + const double f10_19 = -f10 * m_A61; + m_A66 += m_A27 * f10_19; + RHS19 += f10_19 * RHS10; + const double f11 = 1.0 / m_A30; + const double f11_14 = -f11 * m_A40; + m_A41 += m_A31 * f11_14; + RHS14 += f11_14 * RHS11; + const double f12 = 1.0 / m_A33; + const double f12_17 = -f12 * m_A52; + m_A53 += m_A34 * f12_17; + RHS17 += f12_17 * RHS12; + const double f13 = 1.0 / m_A37; + const double f13_16 = -f13 * m_A48; + m_A49 += m_A38 * f13_16; + RHS16 += f13_16 * RHS13; + const double f14 = 1.0 / m_A41; + const double f14_19 = -f14 * m_A62; + m_A66 += m_A42 * f14_19; + RHS19 += f14_19 * RHS14; + const double f15 = 1.0 / m_A45; + const double f15_18 = -f15 * m_A56; + m_A57 += m_A46 * f15_18; + RHS18 += f15_18 * RHS15; + const double f16 = 1.0 / m_A49; + const double f16_19 = -f16 * m_A63; + m_A66 += m_A50 * f16_19; + RHS19 += f16_19 * RHS16; + const double f17 = 1.0 / m_A53; + const double f17_19 = -f17 * m_A64; + m_A66 += m_A54 * f17_19; + RHS19 += f17_19 * RHS17; + const double f18 = 1.0 / m_A57; + const double f18_19 = -f18 * m_A65; + m_A66 += m_A58 * f18_19; + RHS19 += f18_19 * RHS18; + V[19] = RHS19 / m_A66; + double tmp18 = 0.0; + tmp18 += m_A58 * V[19]; + V[18] = (RHS18 - tmp18) / m_A57; + double tmp17 = 0.0; + tmp17 += m_A54 * V[19]; + V[17] = (RHS17 - tmp17) / m_A53; + double tmp16 = 0.0; + tmp16 += m_A50 * V[19]; + V[16] = (RHS16 - tmp16) / m_A49; + double tmp15 = 0.0; + tmp15 += m_A46 * V[18]; + V[15] = (RHS15 - tmp15) / m_A45; + double tmp14 = 0.0; + tmp14 += m_A42 * V[19]; + V[14] = (RHS14 - tmp14) / m_A41; + double tmp13 = 0.0; + tmp13 += m_A38 * V[16]; + V[13] = (RHS13 - tmp13) / m_A37; + double tmp12 = 0.0; + tmp12 += m_A34 * V[17]; + V[12] = (RHS12 - tmp12) / m_A33; + double tmp11 = 0.0; + tmp11 += m_A31 * V[14]; + V[11] = (RHS11 - tmp11) / m_A30; + double tmp10 = 0.0; + tmp10 += m_A27 * V[19]; + V[10] = (RHS10 - tmp10) / m_A26; + double tmp9 = 0.0; + tmp9 += m_A23 * V[17]; + tmp9 += m_A24 * V[19]; + V[9] = (RHS9 - tmp9) / m_A22; + double tmp8 = 0.0; + tmp8 += m_A20 * V[10]; + tmp8 += m_A21 * V[19]; + V[8] = (RHS8 - tmp8) / m_A19; + double tmp7 = 0.0; + tmp7 += m_A17 * V[15]; + tmp7 += m_A18 * V[18]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A14 * V[13]; + tmp6 += m_A15 * V[16]; + V[6] = (RHS6 - tmp6) / m_A13; + double tmp5 = 0.0; + tmp5 += m_A11 * V[11]; + tmp5 += m_A12 * V[14]; + 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[10]; + 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[13]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[11]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // stuntcyc static void nl_gcr_251e2a2e2c8d5b33_20_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -3657,6 +8986,93 @@ static void nl_gcr_278f0b40e27b21fc_150_double_double(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// barrier +static void nl_gcr_27bf6b30d747739e_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A5 += gt[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A5 += gt[9]; + m_A4 += go[6]; + m_A6 += go[7]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + m_A9 += gt[10]; + m_A9 += gt[11]; + m_A9 += gt[12]; + m_A9 += gt[13]; + m_A9 += gt[14]; + m_A9 += gt[15]; + m_A7 += go[10]; + m_A8 += go[11]; + double RHS3 = Idr[10]; + RHS3 += Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[12] * *cnV[12]; + RHS3 -= go[13] * *cnV[13]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + 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; +} + // zac1b11142 static void nl_gcr_2b5c86f8653bcde7_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -3731,6 +9147,293 @@ static void nl_gcr_2b5c86f8653bcde7_12_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// warrior +static void nl_gcr_2b9a75b9366dbb53_27_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A4 += go[2]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A8 += go[7]; + m_A6 += go[8]; + m_A6 += go[9]; + m_A7 += go[10]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A10 += gt[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A11 += go[11]; + m_A11 += go[12]; + m_A9 += go[13]; + m_A9 += go[14]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[15] * *cnV[15]; + m_A13 += gt[16]; + m_A13 += gt[17]; + m_A13 += gt[18]; + m_A13 += gt[19]; + m_A13 += gt[20]; + m_A15 += go[16]; + m_A15 += go[17]; + m_A12 += go[18]; + m_A12 += go[19]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 -= go[20] * *cnV[20]; + m_A21 += gt[21]; + m_A21 += gt[22]; + m_A21 += gt[23]; + m_A21 += gt[24]; + m_A21 += gt[25]; + m_A18 += go[21]; + m_A19 += go[22]; + m_A19 += go[23]; + m_A17 += go[24]; + m_A16 += go[25]; + double RHS5 = Idr[21]; + RHS5 += Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + m_A26 += gt[26]; + m_A26 += gt[27]; + m_A26 += gt[28]; + m_A26 += gt[29]; + m_A26 += gt[30]; + m_A24 += go[26]; + m_A24 += go[27]; + m_A23 += go[28]; + double RHS6 = Idr[26]; + RHS6 += Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A16; + m_A21 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + 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 f1_5 = -f1 * m_A17; + m_A19 += m_A3 * f1_5; + m_A21 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A12; + m_A13 += m_A6 * f2_4; + m_A14 += m_A7 * f2_4; + m_A15 += m_A8 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A18; + m_A20 += m_A6 * f2_5; + m_A21 += m_A7 * f2_5; + m_A22 += m_A8 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A23; + m_A24 += m_A6 * f2_6; + m_A25 += m_A7 * f2_6; + m_A26 += m_A8 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_5 = -f3 * m_A19; + m_A21 += m_A11 * f3_5; + RHS5 += f3_5 * RHS3; + const double f4 = 1.0 / m_A13; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A14 * f4_5; + m_A22 += m_A15 * f4_5; + RHS5 += f4_5 * RHS4; + const double f4_6 = -f4 * m_A24; + m_A25 += m_A14 * f4_6; + m_A26 += m_A15 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A21; + const double f5_6 = -f5 * m_A25; + m_A26 += m_A22 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A26; + double tmp5 = 0.0; + tmp5 += m_A22 * V[6]; + V[5] = (RHS5 - tmp5) / m_A21; + double tmp4 = 0.0; + tmp4 += m_A14 * V[5]; + tmp4 += m_A15 * V[6]; + V[4] = (RHS4 - tmp4) / m_A13; + double tmp3 = 0.0; + tmp3 += m_A11 * V[5]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + tmp2 += m_A8 * V[6]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + tmp1 += m_A4 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// ripoff +static void nl_gcr_2ded0a8e9ab60939_11_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A6 += gt[4]; + m_A6 += gt[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A7 += go[4]; + m_A5 += go[5]; + m_A4 += go[6]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + m_A10 += gt[9]; + m_A10 += gt[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A10 += gt[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A8 += go[9]; + m_A9 += go[10]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + RHS3 += Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[11] * *cnV[11]; + RHS3 -= go[12] * *cnV[12]; + RHS3 -= go[13] * *cnV[13]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + 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; + const double f1_3 = -f1 * m_A8; + m_A9 += m_A3 * f1_3; + RHS3 += f1_3 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + V[3] = RHS3 / m_A10; + double tmp2 = 0.0; + tmp2 += m_A7 * V[3]; + V[2] = (RHS2 - tmp2) / 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; +} + // rebound static void nl_gcr_33a561080717d469_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -3843,6 +9546,1355 @@ static void nl_gcr_390fe6bd5468155d_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb +static void nl_gcr_3dcb4c16ef2de206_23_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A4 += go[4]; + m_A3 += go[5]; + m_A3 += go[6]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A5 += gt[13]; + m_A7 += go[10]; + m_A6 += go[11]; + m_A6 += go[12]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A9 += go[14]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[15] * *cnV[15]; + m_A12 += gt[16]; + m_A12 += gt[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A12 += gt[21]; + m_A11 += go[16]; + m_A11 += go[17]; + m_A10 += go[18]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 -= go[19] * *cnV[19]; + RHS4 -= go[20] * *cnV[20]; + RHS4 -= go[21] * *cnV[21]; + m_A17 += gt[22]; + m_A17 += gt[23]; + m_A17 += gt[24]; + m_A17 += gt[25]; + m_A17 += gt[26]; + m_A15 += go[22]; + m_A15 += go[23]; + m_A14 += go[24]; + double RHS5 = Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 += Idr[26]; + RHS5 -= go[25] * *cnV[25]; + RHS5 -= go[26] * *cnV[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A22 += gt[29]; + m_A22 += gt[30]; + m_A22 += gt[31]; + m_A20 += go[27]; + m_A19 += go[28]; + double RHS6 = Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + RHS6 -= go[31] * *cnV[31]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A11; + m_A12 += m_A3 * f1_4; + m_A13 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A14; + m_A16 += m_A3 * f1_5; + m_A17 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_5 = -f2 * m_A15; + m_A17 += m_A6 * f2_5; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A19; + m_A21 += m_A6 * f2_6; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_6 = -f3 * m_A20; + m_A22 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_5 = -f4 * m_A16; + m_A17 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[6]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[5]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[6]; + V[3] = (RHS3 - tmp3) / m_A8; + 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_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; +} + +// barrier +static void nl_gcr_3dfcefb0f730fed_31_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[5] * *cnV[5]; + RHS2 -= go[6] * *cnV[6]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + RHS2 -= go[10] * *cnV[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A8 += go[11]; + m_A9 += go[12]; + m_A7 += go[13]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A11 += go[16]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 -= go[17] * *cnV[17]; + RHS4 -= go[18] * *cnV[18]; + m_A14 += gt[19]; + m_A14 += gt[20]; + m_A12 += go[19]; + m_A13 += go[20]; + double RHS5 = Idr[19]; + RHS5 += Idr[20]; + m_A18 += gt[21]; + m_A18 += gt[22]; + m_A18 += gt[23]; + m_A17 += go[21]; + m_A19 += go[22]; + double RHS6 = Idr[21]; + RHS6 += Idr[22]; + RHS6 += Idr[23]; + RHS6 -= go[23] * *cnV[23]; + m_A23 += gt[24]; + m_A23 += gt[25]; + m_A21 += go[24]; + m_A20 += go[25]; + double RHS7 = Idr[24]; + RHS7 += Idr[25]; + m_A30 += gt[26]; + m_A30 += gt[27]; + m_A30 += gt[28]; + m_A30 += gt[29]; + m_A30 += gt[30]; + m_A25 += go[26]; + m_A26 += go[27]; + m_A28 += go[28]; + double RHS8 = Idr[26]; + RHS8 += Idr[27]; + RHS8 += Idr[28]; + RHS8 += Idr[29]; + RHS8 += Idr[30]; + RHS8 -= go[29] * *cnV[29]; + RHS8 -= go[30] * *cnV[30]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A12; + m_A14 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A17; + m_A18 += m_A3 * f1_6; + RHS6 += f1_6 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_8 = -f2 * m_A25; + m_A28 += m_A5 * f2_8; + RHS8 += f2_8 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_5 = -f3 * m_A13; + m_A14 += m_A7 * f3_5; + m_A15 += m_A8 * f3_5; + m_A16 += m_A9 * f3_5; + RHS5 += f3_5 * RHS3; + const double f3_7 = -f3 * m_A20; + m_A22 += m_A7 * f3_7; + m_A23 += m_A8 * f3_7; + m_A24 += m_A9 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_8 = -f3 * m_A26; + m_A27 += m_A7 * f3_8; + m_A29 += m_A8 * f3_8; + m_A30 += m_A9 * f3_8; + RHS8 += f3_8 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_7 = -f4 * m_A21; + m_A23 += m_A11 * f4_7; + RHS7 += f4_7 * RHS4; + const double f5 = 1.0 / m_A14; + const double f5_7 = -f5 * m_A22; + m_A23 += m_A15 * f5_7; + m_A24 += m_A16 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_8 = -f5 * m_A27; + m_A29 += m_A15 * f5_8; + m_A30 += m_A16 * f5_8; + RHS8 += f5_8 * RHS5; + const double f6 = 1.0 / m_A18; + const double f6_8 = -f6 * m_A28; + m_A30 += m_A19 * 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_A19 * V[8]; + V[6] = (RHS6 - tmp6) / m_A18; + double tmp5 = 0.0; + tmp5 += m_A15 * V[7]; + tmp5 += m_A16 * V[8]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A11 * V[7]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A7 * V[5]; + tmp3 += m_A8 * V[7]; + tmp3 += m_A9 * V[8]; + 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[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// sundance +static void nl_gcr_3f3c8e7ec83d34dc_100_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A0 += gt[6]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 += Idr[6]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + RHS0 -= go[5] * *cnV[5]; + RHS0 -= go[6] * *cnV[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A3 += go[7]; + double RHS1 = Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[8] * *cnV[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A5 += go[9]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[10] * *cnV[10]; + RHS2 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A6 += gt[16]; + m_A6 += gt[17]; + m_A6 += gt[18]; + m_A7 += go[12]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 -= go[13] * *cnV[13]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + RHS3 -= go[16] * *cnV[16]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + m_A8 += gt[19]; + m_A8 += gt[20]; + m_A8 += gt[21]; + m_A8 += gt[22]; + m_A8 += gt[23]; + m_A8 += gt[24]; + m_A8 += gt[25]; + m_A9 += go[19]; + double RHS4 = Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 -= go[20] * *cnV[20]; + RHS4 -= go[21] * *cnV[21]; + RHS4 -= go[22] * *cnV[22]; + RHS4 -= go[23] * *cnV[23]; + RHS4 -= go[24] * *cnV[24]; + RHS4 -= go[25] * *cnV[25]; + m_A10 += gt[26]; + m_A10 += gt[27]; + m_A11 += go[26]; + double RHS5 = Idr[26]; + RHS5 += Idr[27]; + RHS5 -= go[27] * *cnV[27]; + m_A12 += gt[28]; + m_A12 += gt[29]; + m_A13 += go[28]; + double RHS6 = Idr[28]; + RHS6 += Idr[29]; + RHS6 -= go[29] * *cnV[29]; + m_A14 += gt[30]; + m_A14 += gt[31]; + m_A15 += go[30]; + double RHS7 = Idr[30]; + RHS7 += Idr[31]; + RHS7 -= go[31] * *cnV[31]; + m_A16 += gt[32]; + m_A16 += gt[33]; + m_A16 += gt[34]; + m_A16 += gt[35]; + m_A18 += go[32]; + m_A17 += go[33]; + m_A17 += go[34]; + double RHS8 = Idr[32]; + RHS8 += Idr[33]; + RHS8 += Idr[34]; + RHS8 += Idr[35]; + RHS8 -= go[35] * *cnV[35]; + m_A19 += gt[36]; + m_A19 += gt[37]; + m_A19 += gt[38]; + m_A20 += go[36]; + double RHS9 = Idr[36]; + RHS9 += Idr[37]; + RHS9 += Idr[38]; + RHS9 -= go[37] * *cnV[37]; + RHS9 -= go[38] * *cnV[38]; + m_A21 += gt[39]; + m_A21 += gt[40]; + m_A21 += gt[41]; + m_A22 += go[39]; + double RHS10 = Idr[39]; + RHS10 += Idr[40]; + RHS10 += Idr[41]; + RHS10 -= go[40] * *cnV[40]; + RHS10 -= go[41] * *cnV[41]; + m_A23 += gt[42]; + m_A23 += gt[43]; + m_A23 += gt[44]; + m_A23 += gt[45]; + m_A24 += go[42]; + m_A25 += go[43]; + m_A25 += go[44]; + double RHS11 = Idr[42]; + RHS11 += Idr[43]; + RHS11 += Idr[44]; + RHS11 += Idr[45]; + RHS11 -= go[45] * *cnV[45]; + m_A27 += gt[46]; + m_A27 += gt[47]; + m_A26 += go[46]; + double RHS12 = Idr[46]; + RHS12 += Idr[47]; + RHS12 -= go[47] * *cnV[47]; + m_A29 += gt[48]; + m_A29 += gt[49]; + m_A29 += gt[50]; + m_A29 += gt[51]; + m_A28 += go[48]; + m_A30 += go[49]; + double RHS13 = Idr[48]; + RHS13 += Idr[49]; + RHS13 += Idr[50]; + RHS13 += Idr[51]; + RHS13 -= go[50] * *cnV[50]; + RHS13 -= go[51] * *cnV[51]; + m_A31 += gt[52]; + m_A31 += gt[53]; + m_A31 += gt[54]; + m_A32 += go[52]; + double RHS14 = Idr[52]; + RHS14 += Idr[53]; + RHS14 += Idr[54]; + RHS14 -= go[53] * *cnV[53]; + RHS14 -= go[54] * *cnV[54]; + m_A34 += gt[55]; + m_A34 += gt[56]; + m_A35 += go[55]; + m_A33 += go[56]; + double RHS15 = Idr[55]; + RHS15 += Idr[56]; + m_A38 += gt[57]; + m_A38 += gt[58]; + m_A38 += gt[59]; + m_A39 += go[57]; + m_A37 += go[58]; + m_A36 += go[59]; + double RHS16 = Idr[57]; + RHS16 += Idr[58]; + RHS16 += Idr[59]; + m_A41 += gt[60]; + m_A41 += gt[61]; + m_A41 += gt[62]; + m_A41 += gt[63]; + m_A41 += gt[64]; + m_A41 += gt[65]; + m_A41 += gt[66]; + m_A41 += gt[67]; + m_A42 += go[60]; + m_A42 += go[61]; + m_A43 += go[62]; + m_A43 += go[63]; + m_A40 += go[64]; + m_A40 += go[65]; + double RHS17 = Idr[60]; + RHS17 += Idr[61]; + RHS17 += Idr[62]; + RHS17 += Idr[63]; + RHS17 += Idr[64]; + RHS17 += Idr[65]; + RHS17 += Idr[66]; + RHS17 += Idr[67]; + RHS17 -= go[66] * *cnV[66]; + RHS17 -= go[67] * *cnV[67]; + m_A46 += gt[68]; + m_A46 += gt[69]; + m_A46 += gt[70]; + m_A46 += gt[71]; + m_A44 += go[68]; + m_A48 += go[69]; + double RHS18 = Idr[68]; + RHS18 += Idr[69]; + RHS18 += Idr[70]; + RHS18 += Idr[71]; + RHS18 -= go[70] * *cnV[70]; + RHS18 -= go[71] * *cnV[71]; + m_A52 += gt[72]; + m_A52 += gt[73]; + m_A52 += gt[74]; + m_A52 += gt[75]; + m_A50 += go[72]; + m_A51 += go[73]; + m_A51 += go[74]; + m_A49 += go[75]; + double RHS19 = Idr[72]; + RHS19 += Idr[73]; + RHS19 += Idr[74]; + RHS19 += Idr[75]; + m_A55 += gt[76]; + m_A55 += gt[77]; + m_A55 += gt[78]; + m_A55 += gt[79]; + m_A56 += go[76]; + m_A54 += go[77]; + double RHS20 = Idr[76]; + RHS20 += Idr[77]; + RHS20 += Idr[78]; + RHS20 += Idr[79]; + RHS20 -= go[78] * *cnV[78]; + RHS20 -= go[79] * *cnV[79]; + m_A60 += gt[80]; + m_A60 += gt[81]; + m_A60 += gt[82]; + m_A60 += gt[83]; + m_A60 += gt[84]; + m_A62 += go[80]; + m_A59 += go[81]; + m_A58 += go[82]; + m_A57 += go[83]; + double RHS21 = Idr[80]; + RHS21 += Idr[81]; + RHS21 += Idr[82]; + RHS21 += Idr[83]; + RHS21 += Idr[84]; + RHS21 -= go[84] * *cnV[84]; + m_A64 += gt[85]; + m_A64 += gt[86]; + m_A64 += gt[87]; + m_A64 += gt[88]; + m_A65 += go[85]; + m_A63 += go[86]; + double RHS22 = Idr[85]; + RHS22 += Idr[86]; + RHS22 += Idr[87]; + RHS22 += Idr[88]; + RHS22 -= go[87] * *cnV[87]; + RHS22 -= go[88] * *cnV[88]; + m_A69 += gt[89]; + m_A69 += gt[90]; + m_A69 += gt[91]; + m_A69 += gt[92]; + m_A68 += go[89]; + m_A70 += go[90]; + m_A67 += go[91]; + m_A66 += go[92]; + double RHS23 = Idr[89]; + RHS23 += Idr[90]; + RHS23 += Idr[91]; + RHS23 += Idr[92]; + m_A77 += gt[93]; + m_A77 += gt[94]; + m_A77 += gt[95]; + m_A77 += gt[96]; + m_A77 += gt[97]; + m_A77 += gt[98]; + m_A71 += go[93]; + m_A72 += go[94]; + m_A73 += go[95]; + m_A76 += go[96]; + double RHS24 = Idr[93]; + RHS24 += Idr[94]; + RHS24 += Idr[95]; + RHS24 += Idr[96]; + RHS24 += Idr[97]; + RHS24 += Idr[98]; + RHS24 -= go[97] * *cnV[97]; + RHS24 -= go[98] * *cnV[98]; + m_A82 += gt[99]; + m_A82 += gt[100]; + m_A82 += gt[101]; + m_A82 += gt[102]; + m_A82 += gt[103]; + m_A82 += gt[104]; + m_A82 += gt[105]; + m_A82 += gt[106]; + m_A80 += go[99]; + m_A80 += go[100]; + m_A79 += go[101]; + m_A83 += go[102]; + m_A83 += go[103]; + double RHS25 = Idr[99]; + RHS25 += Idr[100]; + RHS25 += Idr[101]; + RHS25 += Idr[102]; + RHS25 += Idr[103]; + RHS25 += Idr[104]; + RHS25 += Idr[105]; + RHS25 += Idr[106]; + RHS25 -= go[104] * *cnV[104]; + RHS25 -= go[105] * *cnV[105]; + RHS25 -= go[106] * *cnV[106]; + m_A90 += gt[107]; + m_A90 += gt[108]; + m_A90 += gt[109]; + m_A90 += gt[110]; + m_A90 += gt[111]; + m_A91 += go[107]; + m_A86 += go[108]; + m_A87 += go[109]; + m_A85 += go[110]; + m_A84 += go[111]; + double RHS26 = Idr[107]; + RHS26 += Idr[108]; + RHS26 += Idr[109]; + RHS26 += Idr[110]; + RHS26 += Idr[111]; + m_A99 += gt[112]; + m_A99 += gt[113]; + m_A99 += gt[114]; + m_A99 += gt[115]; + m_A99 += gt[116]; + m_A99 += gt[117]; + m_A99 += gt[118]; + m_A99 += gt[119]; + m_A99 += gt[120]; + m_A92 += go[112]; + m_A93 += go[113]; + m_A93 += go[114]; + m_A97 += go[115]; + m_A97 += go[116]; + m_A94 += go[117]; + m_A98 += go[118]; + double RHS27 = Idr[112]; + RHS27 += Idr[113]; + RHS27 += Idr[114]; + RHS27 += Idr[115]; + RHS27 += Idr[116]; + RHS27 += Idr[117]; + RHS27 += Idr[118]; + RHS27 += Idr[119]; + RHS27 += Idr[120]; + RHS27 -= go[119] * *cnV[119]; + RHS27 -= go[120] * *cnV[120]; + const double f0 = 1.0 / m_A0; + const double f0_27 = -f0 * m_A92; + m_A95 += m_A1 * f0_27; + RHS27 += f0_27 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_12 = -f1 * m_A26; + m_A27 += m_A3 * f1_12; + RHS12 += f1_12 * RHS1; + const double f1_23 = -f1 * m_A66; + m_A68 += m_A3 * f1_23; + RHS23 += f1_23 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_13 = -f2 * m_A28; + m_A30 += m_A5 * f2_13; + RHS13 += f2_13 * RHS2; + const double f2_23 = -f2 * m_A67; + m_A69 += m_A5 * f2_23; + RHS23 += f2_23 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_18 = -f3 * m_A44; + m_A45 += m_A7 * f3_18; + RHS18 += f3_18 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_24 = -f4 * m_A71; + m_A74 += m_A9 * f4_24; + RHS24 += f4_24 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_16 = -f5 * m_A36; + m_A38 += m_A11 * f5_16; + RHS16 += f5_16 * RHS5; + const double f5_21 = -f5 * m_A57; + m_A59 += m_A11 * f5_21; + RHS21 += f5_21 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_15 = -f6 * m_A33; + m_A34 += m_A13 * f6_15; + RHS15 += f6_15 * RHS6; + const double f6_26 = -f6 * m_A84; + m_A86 += m_A13 * f6_26; + RHS26 += f6_26 * RHS6; + const double f7 = 1.0 / m_A14; + const double f7_16 = -f7 * m_A37; + m_A38 += m_A15 * f7_16; + RHS16 += f7_16 * RHS7; + const double f8 = 1.0 / m_A16; + const double f8_17 = -f8 * m_A40; + m_A41 += m_A17 * f8_17; + m_A42 += m_A18 * f8_17; + RHS17 += f8_17 * RHS8; + const double f8_19 = -f8 * m_A49; + m_A51 += m_A17 * f8_19; + m_A52 += m_A18 * f8_19; + RHS19 += f8_19 * RHS8; + const double f9 = 1.0 / m_A19; + const double f9_19 = -f9 * m_A50; + m_A52 += m_A20 * f9_19; + RHS19 += f9_19 * RHS9; + const double f10 = 1.0 / m_A21; + const double f10_22 = -f10 * m_A63; + m_A65 += m_A22 * f10_22; + RHS22 += f10_22 * RHS10; + const double f10_26 = -f10 * m_A85; + m_A90 += m_A22 * f10_26; + RHS26 += f10_26 * RHS10; + const double f11 = 1.0 / m_A23; + const double f11_25 = -f11 * m_A79; + m_A82 += m_A24 * f11_25; + m_A83 += m_A25 * f11_25; + RHS25 += f11_25 * RHS11; + const double f11_27 = -f11 * m_A93; + m_A97 += m_A24 * f11_27; + m_A99 += m_A25 * f11_27; + RHS27 += f11_27 * RHS11; + const double f12 = 1.0 / m_A27; + const double f12_23 = -f12 * m_A68; + RHS23 += f12_23 * RHS12; + const double f13 = 1.0 / m_A29; + const double f13_18 = -f13 * m_A45; + m_A47 += m_A30 * f13_18; + RHS18 += f13_18 * RHS13; + const double f14 = 1.0 / m_A31; + const double f14_20 = -f14 * m_A54; + m_A56 += m_A32 * f14_20; + RHS20 += f14_20 * RHS14; + const double f14_21 = -f14 * m_A58; + m_A60 += m_A32 * f14_21; + RHS21 += f14_21 * RHS14; + const double f15 = 1.0 / m_A34; + const double f15_24 = -f15 * m_A72; + m_A77 += m_A35 * f15_24; + RHS24 += f15_24 * RHS15; + const double f15_26 = -f15 * m_A86; + m_A89 += m_A35 * f15_26; + RHS26 += f15_26 * RHS15; + const double f16 = 1.0 / m_A38; + const double f16_21 = -f16 * m_A59; + m_A61 += m_A39 * f16_21; + RHS21 += f16_21 * RHS16; + const double f16_24 = -f16 * m_A73; + m_A77 += m_A39 * f16_24; + RHS24 += f16_24 * RHS16; + const double f17 = 1.0 / m_A41; + const double f17_19 = -f17 * m_A51; + m_A52 += m_A42 * f17_19; + m_A53 += m_A43 * f17_19; + RHS19 += f17_19 * RHS17; + const double f17_25 = -f17 * m_A80; + m_A81 += m_A42 * f17_25; + m_A82 += m_A43 * f17_25; + RHS25 += f17_25 * RHS17; + const double f18 = 1.0 / m_A46; + const double f18_26 = -f18 * m_A87; + m_A88 += m_A47 * f18_26; + m_A90 += m_A48 * f18_26; + RHS26 += f18_26 * RHS18; + const double f19 = 1.0 / m_A52; + const double f19_25 = -f19 * m_A81; + m_A82 += m_A53 * f19_25; + RHS25 += f19_25 * RHS19; + const double f20 = 1.0 / m_A55; + const double f20_24 = -f20 * m_A74; + m_A75 += m_A56 * f20_24; + RHS24 += f20_24 * RHS20; + const double f21 = 1.0 / m_A60; + const double f21_24 = -f21 * m_A75; + m_A77 += m_A61 * f21_24; + m_A78 += m_A62 * f21_24; + RHS24 += f21_24 * RHS21; + const double f21_27 = -f21 * m_A94; + m_A96 += m_A61 * f21_27; + m_A99 += m_A62 * f21_27; + RHS27 += f21_27 * RHS21; + const double f22 = 1.0 / m_A64; + const double f22_27 = -f22 * m_A95; + m_A98 += m_A65 * f22_27; + RHS27 += f22_27 * RHS22; + const double f23 = 1.0 / m_A69; + const double f23_24 = -f23 * m_A76; + m_A77 += m_A70 * f23_24; + RHS24 += f23_24 * RHS23; + const double f23_26 = -f23 * m_A88; + m_A89 += m_A70 * f23_26; + RHS26 += f23_26 * RHS23; + const double f24 = 1.0 / m_A77; + const double f24_26 = -f24 * m_A89; + m_A91 += m_A78 * f24_26; + RHS26 += f24_26 * RHS24; + const double f24_27 = -f24 * m_A96; + m_A99 += m_A78 * f24_27; + RHS27 += f24_27 * RHS24; + const double f25 = 1.0 / m_A82; + const double f25_27 = -f25 * m_A97; + m_A99 += m_A83 * f25_27; + RHS27 += f25_27 * RHS25; + const double f26 = 1.0 / m_A90; + const double f26_27 = -f26 * m_A98; + m_A99 += m_A91 * f26_27; + RHS27 += f26_27 * RHS26; + V[27] = RHS27 / m_A99; + double tmp26 = 0.0; + tmp26 += m_A91 * V[27]; + V[26] = (RHS26 - tmp26) / m_A90; + double tmp25 = 0.0; + tmp25 += m_A83 * V[27]; + V[25] = (RHS25 - tmp25) / m_A82; + double tmp24 = 0.0; + tmp24 += m_A78 * V[27]; + V[24] = (RHS24 - tmp24) / m_A77; + double tmp23 = 0.0; + tmp23 += m_A70 * V[24]; + V[23] = (RHS23 - tmp23) / m_A69; + double tmp22 = 0.0; + tmp22 += m_A65 * V[26]; + V[22] = (RHS22 - tmp22) / m_A64; + double tmp21 = 0.0; + tmp21 += m_A61 * V[24]; + tmp21 += m_A62 * V[27]; + 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_A53 * V[25]; + V[19] = (RHS19 - tmp19) / m_A52; + double tmp18 = 0.0; + tmp18 += m_A47 * V[23]; + tmp18 += m_A48 * V[26]; + V[18] = (RHS18 - tmp18) / m_A46; + double tmp17 = 0.0; + tmp17 += m_A42 * V[19]; + tmp17 += m_A43 * V[25]; + V[17] = (RHS17 - tmp17) / m_A41; + double tmp16 = 0.0; + tmp16 += m_A39 * V[24]; + V[16] = (RHS16 - tmp16) / m_A38; + double tmp15 = 0.0; + tmp15 += m_A35 * V[24]; + V[15] = (RHS15 - tmp15) / m_A34; + double tmp14 = 0.0; + tmp14 += m_A32 * V[21]; + V[14] = (RHS14 - tmp14) / m_A31; + double tmp13 = 0.0; + tmp13 += m_A30 * V[23]; + V[13] = (RHS13 - tmp13) / m_A29; + double tmp12 = 0.0; + V[12] = (RHS12 - tmp12) / m_A27; + double tmp11 = 0.0; + tmp11 += m_A24 * V[25]; + tmp11 += m_A25 * V[27]; + V[11] = (RHS11 - tmp11) / m_A23; + double tmp10 = 0.0; + tmp10 += m_A22 * V[26]; + V[10] = (RHS10 - tmp10) / m_A21; + double tmp9 = 0.0; + tmp9 += m_A20 * V[19]; + V[9] = (RHS9 - tmp9) / m_A19; + double tmp8 = 0.0; + tmp8 += m_A17 * V[17]; + tmp8 += m_A18 * V[19]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[16]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[15]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[16]; + 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[13]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[23]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[12]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[22]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// barrier +static void nl_gcr_3f47343711c928e7_13_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[4] * *cnV[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A5 += go[5]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A7 += go[7]; + double RHS3 = Idr[7]; + RHS3 += Idr[8]; + RHS3 -= go[8] * *cnV[8]; + m_A12 += gt[9]; + m_A12 += gt[10]; + m_A12 += gt[11]; + m_A12 += gt[12]; + m_A12 += gt[13]; + m_A11 += go[9]; + m_A10 += go[10]; + m_A9 += go[11]; + m_A8 += go[12]; + double RHS4 = Idr[9]; + RHS4 += Idr[10]; + RHS4 += Idr[11]; + RHS4 += Idr[12]; + RHS4 += Idr[13]; + RHS4 -= go[13] * *cnV[13]; + 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; +} + +// spacewar +static void nl_gcr_41fae289e2d2f263_22_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A3 += go[2]; + m_A4 += go[3]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A7 += go[9]; + m_A6 += go[10]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[11] * *cnV[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A9 += go[12]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 -= go[13] * *cnV[13]; + m_A12 += gt[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A11 += go[14]; + m_A10 += go[15]; + double RHS4 = Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 -= go[16] * *cnV[16]; + m_A17 += gt[17]; + m_A17 += gt[18]; + m_A17 += gt[19]; + m_A17 += gt[20]; + m_A17 += gt[21]; + m_A17 += gt[22]; + m_A14 += go[17]; + m_A18 += go[18]; + m_A15 += go[19]; + double RHS5 = Idr[17]; + RHS5 += Idr[18]; + RHS5 += Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 -= go[20] * *cnV[20]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + m_A21 += gt[23]; + m_A21 += gt[24]; + m_A19 += go[23]; + m_A20 += go[24]; + double RHS6 = Idr[23]; + RHS6 += Idr[24]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + 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_4 = -f2 * m_A11; + m_A12 += m_A6 * f2_4; + m_A13 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + 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 f3 = 1.0 / m_A8; + const double f3_6 = -f3 * m_A19; + m_A21 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_5 = -f4 * m_A16; + m_A17 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_6 = -f5 * m_A20; + m_A21 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A21; + double tmp5 = 0.0; + tmp5 += m_A18 * V[6]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[5]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[6]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + tmp1 += m_A4 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_445192d0ef3f62c6_21_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -3993,6 +11045,899 @@ static void nl_gcr_445192d0ef3f62c6_21_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// armora +static void nl_gcr_45c12728d0dbfd13_58_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A4 += go[4]; + m_A3 += go[5]; + m_A3 += go[6]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A5 += gt[13]; + m_A6 += go[10]; + m_A6 += go[11]; + m_A7 += go[12]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A9 += go[14]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 -= go[15] * *cnV[15]; + RHS3 -= go[16] * *cnV[16]; + RHS3 -= go[17] * *cnV[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A10 += gt[20]; + m_A10 += gt[21]; + m_A10 += gt[22]; + m_A10 += gt[23]; + m_A12 += go[18]; + m_A11 += go[19]; + m_A11 += go[20]; + double RHS4 = Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 -= go[21] * *cnV[21]; + RHS4 -= go[22] * *cnV[22]; + RHS4 -= go[23] * *cnV[23]; + m_A13 += gt[24]; + m_A13 += gt[25]; + m_A13 += gt[26]; + m_A13 += gt[27]; + m_A14 += go[24]; + m_A14 += go[25]; + m_A15 += go[26]; + double RHS5 = Idr[24]; + RHS5 += Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 -= go[27] * *cnV[27]; + m_A16 += gt[28]; + m_A16 += gt[29]; + m_A16 += gt[30]; + m_A16 += gt[31]; + m_A16 += gt[32]; + m_A16 += gt[33]; + m_A17 += go[28]; + double RHS6 = Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + RHS6 += Idr[32]; + RHS6 += Idr[33]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + RHS6 -= go[31] * *cnV[31]; + RHS6 -= go[32] * *cnV[32]; + RHS6 -= go[33] * *cnV[33]; + m_A18 += gt[34]; + m_A18 += gt[35]; + m_A18 += gt[36]; + m_A18 += gt[37]; + m_A18 += gt[38]; + m_A18 += gt[39]; + m_A20 += go[34]; + m_A19 += go[35]; + m_A19 += go[36]; + double RHS7 = Idr[34]; + RHS7 += Idr[35]; + RHS7 += Idr[36]; + RHS7 += Idr[37]; + RHS7 += Idr[38]; + RHS7 += Idr[39]; + RHS7 -= go[37] * *cnV[37]; + RHS7 -= go[38] * *cnV[38]; + RHS7 -= go[39] * *cnV[39]; + m_A21 += gt[40]; + m_A21 += gt[41]; + m_A21 += gt[42]; + m_A21 += gt[43]; + m_A23 += go[40]; + m_A23 += go[41]; + m_A22 += go[42]; + double RHS8 = Idr[40]; + RHS8 += Idr[41]; + RHS8 += Idr[42]; + RHS8 += Idr[43]; + RHS8 -= go[43] * *cnV[43]; + m_A26 += gt[44]; + m_A26 += gt[45]; + m_A26 += gt[46]; + m_A26 += gt[47]; + m_A26 += gt[48]; + m_A26 += gt[49]; + m_A25 += go[44]; + m_A25 += go[45]; + m_A24 += go[46]; + double RHS9 = Idr[44]; + RHS9 += Idr[45]; + RHS9 += Idr[46]; + RHS9 += Idr[47]; + RHS9 += Idr[48]; + RHS9 += Idr[49]; + RHS9 -= go[47] * *cnV[47]; + RHS9 -= go[48] * *cnV[48]; + RHS9 -= go[49] * *cnV[49]; + m_A31 += gt[50]; + m_A31 += gt[51]; + m_A31 += gt[52]; + m_A31 += gt[53]; + m_A31 += gt[54]; + m_A29 += go[50]; + m_A29 += go[51]; + m_A28 += go[52]; + double RHS10 = Idr[50]; + RHS10 += Idr[51]; + RHS10 += Idr[52]; + RHS10 += Idr[53]; + RHS10 += Idr[54]; + RHS10 -= go[53] * *cnV[53]; + RHS10 -= go[54] * *cnV[54]; + m_A35 += gt[55]; + m_A35 += gt[56]; + m_A35 += gt[57]; + m_A35 += gt[58]; + m_A35 += gt[59]; + m_A35 += gt[60]; + m_A34 += go[55]; + m_A34 += go[56]; + m_A33 += go[57]; + double RHS11 = Idr[55]; + RHS11 += Idr[56]; + RHS11 += Idr[57]; + RHS11 += Idr[58]; + RHS11 += Idr[59]; + RHS11 += Idr[60]; + RHS11 -= go[58] * *cnV[58]; + RHS11 -= go[59] * *cnV[59]; + RHS11 -= go[60] * *cnV[60]; + m_A40 += gt[61]; + m_A40 += gt[62]; + m_A40 += gt[63]; + m_A40 += gt[64]; + m_A40 += gt[65]; + m_A38 += go[61]; + m_A38 += go[62]; + m_A37 += go[63]; + double RHS12 = Idr[61]; + RHS12 += Idr[62]; + RHS12 += Idr[63]; + RHS12 += Idr[64]; + RHS12 += Idr[65]; + RHS12 -= go[64] * *cnV[64]; + RHS12 -= go[65] * *cnV[65]; + m_A44 += gt[66]; + m_A44 += gt[67]; + m_A44 += gt[68]; + m_A44 += gt[69]; + m_A44 += gt[70]; + m_A44 += gt[71]; + m_A43 += go[66]; + m_A43 += go[67]; + m_A42 += go[68]; + double RHS13 = Idr[66]; + RHS13 += Idr[67]; + RHS13 += Idr[68]; + RHS13 += Idr[69]; + RHS13 += Idr[70]; + RHS13 += Idr[71]; + RHS13 -= go[69] * *cnV[69]; + RHS13 -= go[70] * *cnV[70]; + RHS13 -= go[71] * *cnV[71]; + m_A51 += gt[72]; + m_A51 += gt[73]; + m_A51 += gt[74]; + m_A51 += gt[75]; + m_A51 += gt[76]; + m_A51 += gt[77]; + m_A48 += go[72]; + m_A47 += go[73]; + m_A46 += go[74]; + double RHS14 = Idr[72]; + RHS14 += Idr[73]; + RHS14 += Idr[74]; + RHS14 += Idr[75]; + RHS14 += Idr[76]; + RHS14 += Idr[77]; + RHS14 -= go[75] * *cnV[75]; + RHS14 -= go[76] * *cnV[76]; + RHS14 -= go[77] * *cnV[77]; + m_A57 += gt[78]; + m_A57 += gt[79]; + m_A57 += gt[80]; + m_A57 += gt[81]; + m_A57 += gt[82]; + m_A54 += go[78]; + m_A54 += go[79]; + m_A53 += go[80]; + double RHS15 = Idr[78]; + RHS15 += Idr[79]; + RHS15 += Idr[80]; + RHS15 += Idr[81]; + RHS15 += Idr[82]; + RHS15 -= go[81] * *cnV[81]; + RHS15 -= go[82] * *cnV[82]; + const double f0 = 1.0 / m_A0; + const double f0_9 = -f0 * m_A24; + m_A26 += m_A1 * f0_9; + RHS9 += f0_9 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_9 = -f1 * m_A25; + m_A26 += m_A3 * f1_9; + m_A27 += m_A4 * f1_9; + RHS9 += f1_9 * RHS1; + const double f1_10 = -f1 * m_A28; + m_A30 += m_A3 * f1_10; + m_A31 += m_A4 * f1_10; + RHS10 += f1_10 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_10 = -f2 * m_A29; + m_A31 += m_A6 * f2_10; + m_A32 += m_A7 * f2_10; + RHS10 += f2_10 * RHS2; + const double f2_14 = -f2 * m_A46; + m_A49 += m_A6 * f2_14; + m_A51 += m_A7 * f2_14; + RHS14 += f2_14 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_11 = -f3 * m_A33; + m_A35 += m_A9 * f3_11; + RHS11 += f3_11 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_11 = -f4 * m_A34; + m_A35 += m_A11 * f4_11; + m_A36 += m_A12 * f4_11; + RHS11 += f4_11 * RHS4; + const double f4_12 = -f4 * m_A37; + m_A39 += m_A11 * f4_12; + m_A40 += m_A12 * f4_12; + RHS12 += f4_12 * RHS4; + const double f5 = 1.0 / m_A13; + const double f5_12 = -f5 * m_A38; + m_A40 += m_A14 * f5_12; + m_A41 += m_A15 * f5_12; + RHS12 += f5_12 * RHS5; + const double f5_14 = -f5 * m_A47; + m_A50 += m_A14 * f5_14; + m_A51 += m_A15 * f5_14; + RHS14 += f5_14 * RHS5; + const double f6 = 1.0 / m_A16; + const double f6_13 = -f6 * m_A42; + m_A44 += m_A17 * f6_13; + RHS13 += f6_13 * RHS6; + const double f7 = 1.0 / m_A18; + const double f7_13 = -f7 * m_A43; + m_A44 += m_A19 * f7_13; + m_A45 += m_A20 * f7_13; + RHS13 += f7_13 * RHS7; + const double f7_15 = -f7 * m_A53; + m_A55 += m_A19 * f7_15; + m_A57 += m_A20 * f7_15; + RHS15 += f7_15 * RHS7; + const double f8 = 1.0 / m_A21; + const double f8_14 = -f8 * m_A48; + m_A51 += m_A22 * f8_14; + m_A52 += m_A23 * f8_14; + RHS14 += f8_14 * RHS8; + const double f8_15 = -f8 * m_A54; + m_A56 += m_A22 * f8_15; + m_A57 += m_A23 * f8_15; + RHS15 += f8_15 * RHS8; + const double f9 = 1.0 / m_A26; + const double f9_10 = -f9 * m_A30; + m_A31 += m_A27 * f9_10; + RHS10 += f9_10 * RHS9; + const double f10 = 1.0 / m_A31; + const double f10_14 = -f10 * m_A49; + m_A51 += m_A32 * f10_14; + RHS14 += f10_14 * RHS10; + const double f11 = 1.0 / m_A35; + const double f11_12 = -f11 * m_A39; + m_A40 += m_A36 * f11_12; + RHS12 += f11_12 * RHS11; + const double f12 = 1.0 / m_A40; + const double f12_14 = -f12 * m_A50; + m_A51 += m_A41 * f12_14; + RHS14 += f12_14 * RHS12; + const double f13 = 1.0 / m_A44; + const double f13_15 = -f13 * m_A55; + m_A57 += m_A45 * f13_15; + RHS15 += f13_15 * RHS13; + const double f14 = 1.0 / m_A51; + const double f14_15 = -f14 * m_A56; + m_A57 += m_A52 * f14_15; + RHS15 += f14_15 * RHS14; + V[15] = RHS15 / m_A57; + double tmp14 = 0.0; + tmp14 += m_A52 * V[15]; + V[14] = (RHS14 - tmp14) / m_A51; + double tmp13 = 0.0; + tmp13 += m_A45 * V[15]; + V[13] = (RHS13 - tmp13) / m_A44; + double tmp12 = 0.0; + tmp12 += m_A41 * V[14]; + V[12] = (RHS12 - tmp12) / m_A40; + double tmp11 = 0.0; + tmp11 += m_A36 * V[12]; + V[11] = (RHS11 - tmp11) / m_A35; + double tmp10 = 0.0; + tmp10 += m_A32 * V[14]; + V[10] = (RHS10 - tmp10) / m_A31; + double tmp9 = 0.0; + tmp9 += m_A27 * V[10]; + V[9] = (RHS9 - tmp9) / m_A26; + double tmp8 = 0.0; + tmp8 += m_A22 * V[14]; + tmp8 += m_A23 * V[15]; + V[8] = (RHS8 - tmp8) / m_A21; + double tmp7 = 0.0; + tmp7 += m_A19 * V[13]; + tmp7 += m_A20 * V[15]; + V[7] = (RHS7 - tmp7) / m_A18; + double tmp6 = 0.0; + tmp6 += m_A17 * V[13]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[12]; + tmp5 += m_A15 * V[14]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[11]; + tmp4 += m_A12 * V[12]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A9 * V[11]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A6 * V[10]; + tmp2 += m_A7 * V[14]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[9]; + tmp1 += m_A4 * V[10]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[9]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// starhawk +static void nl_gcr_477580ff3e69f2bd_40_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A7 += go[10]; + m_A9 += go[11]; + m_A8 += go[12]; + double RHS3 = Idr[10]; + RHS3 += Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[13] * *cnV[13]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A11 += go[16]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 -= go[17] * *cnV[17]; + RHS4 -= go[18] * *cnV[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A12 += gt[21]; + m_A12 += gt[22]; + m_A12 += gt[23]; + m_A12 += gt[24]; + m_A12 += gt[25]; + m_A13 += go[19]; + double RHS5 = Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 -= go[20] * *cnV[20]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + RHS5 -= go[23] * *cnV[23]; + RHS5 -= go[24] * *cnV[24]; + RHS5 -= go[25] * *cnV[25]; + m_A15 += gt[26]; + m_A15 += gt[27]; + m_A16 += go[26]; + m_A14 += go[27]; + double RHS6 = Idr[26]; + RHS6 += Idr[27]; + m_A20 += gt[28]; + m_A20 += gt[29]; + m_A18 += go[28]; + m_A17 += go[29]; + double RHS7 = Idr[28]; + RHS7 += Idr[29]; + m_A22 += gt[30]; + m_A22 += gt[31]; + m_A23 += go[30]; + m_A24 += go[31]; + double RHS8 = Idr[30]; + RHS8 += Idr[31]; + m_A27 += gt[32]; + m_A27 += gt[33]; + m_A27 += gt[34]; + m_A27 += gt[35]; + m_A28 += go[32]; + m_A26 += go[33]; + m_A25 += go[34]; + double RHS9 = Idr[32]; + RHS9 += Idr[33]; + RHS9 += Idr[34]; + RHS9 += Idr[35]; + RHS9 -= go[35] * *cnV[35]; + m_A31 += gt[36]; + m_A31 += gt[37]; + m_A31 += gt[38]; + m_A30 += go[36]; + m_A29 += go[37]; + double RHS10 = Idr[36]; + RHS10 += Idr[37]; + RHS10 += Idr[38]; + RHS10 -= go[38] * *cnV[38]; + m_A39 += gt[39]; + m_A39 += gt[40]; + m_A39 += gt[41]; + m_A39 += gt[42]; + m_A36 += go[39]; + m_A37 += go[40]; + m_A33 += go[41]; + double RHS11 = Idr[39]; + RHS11 += Idr[40]; + RHS11 += Idr[41]; + RHS11 += Idr[42]; + RHS11 -= go[42] * *cnV[42]; + const double f0 = 1.0 / m_A0; + const double f0_7 = -f0 * m_A17; + m_A20 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A14; + m_A15 += m_A3 * f1_6; + RHS6 += f1_6 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_9 = -f2 * m_A25; + m_A27 += m_A5 * f2_9; + RHS9 += f2_9 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_7 = -f3 * m_A18; + m_A19 += m_A7 * f3_7; + m_A20 += m_A8 * f3_7; + m_A21 += m_A9 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_11 = -f3 * m_A33; + m_A34 += m_A7 * f3_11; + m_A35 += m_A8 * f3_11; + m_A39 += m_A9 * f3_11; + RHS11 += f3_11 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_10 = -f4 * m_A29; + m_A31 += m_A11 * f4_10; + RHS10 += f4_10 * RHS4; + const double f5 = 1.0 / m_A12; + const double f5_7 = -f5 * m_A19; + m_A21 += m_A13 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_11 = -f5 * m_A34; + m_A39 += m_A13 * f5_11; + RHS11 += f5_11 * RHS5; + const double f6 = 1.0 / m_A15; + const double f6_9 = -f6 * m_A26; + m_A27 += m_A16 * f6_9; + RHS9 += f6_9 * RHS6; + const double f7 = 1.0 / m_A20; + const double f7_11 = -f7 * m_A35; + m_A39 += m_A21 * f7_11; + RHS11 += f7_11 * RHS7; + const double f8 = 1.0 / m_A22; + const double f8_10 = -f8 * m_A30; + m_A31 += m_A23 * f8_10; + m_A32 += m_A24 * f8_10; + RHS10 += f8_10 * RHS8; + const double f8_11 = -f8 * m_A36; + m_A38 += m_A23 * f8_11; + m_A39 += m_A24 * f8_11; + RHS11 += f8_11 * RHS8; + const double f9 = 1.0 / m_A27; + const double f9_11 = -f9 * m_A37; + m_A39 += m_A28 * f9_11; + RHS11 += f9_11 * RHS9; + const double f10 = 1.0 / m_A31; + const double f10_11 = -f10 * m_A38; + m_A39 += m_A32 * f10_11; + RHS11 += f10_11 * RHS10; + V[11] = RHS11 / m_A39; + double tmp10 = 0.0; + tmp10 += m_A32 * V[11]; + V[10] = (RHS10 - tmp10) / m_A31; + double tmp9 = 0.0; + tmp9 += m_A28 * V[11]; + V[9] = (RHS9 - tmp9) / m_A27; + double tmp8 = 0.0; + tmp8 += m_A23 * V[10]; + tmp8 += m_A24 * V[11]; + V[8] = (RHS8 - tmp8) / m_A22; + double tmp7 = 0.0; + tmp7 += m_A21 * V[11]; + V[7] = (RHS7 - tmp7) / m_A20; + double tmp6 = 0.0; + tmp6 += m_A16 * V[9]; + V[6] = (RHS6 - tmp6) / m_A15; + double tmp5 = 0.0; + tmp5 += m_A13 * V[11]; + V[5] = (RHS5 - tmp5) / m_A12; + double tmp4 = 0.0; + tmp4 += m_A11 * V[10]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A7 * V[5]; + tmp3 += m_A8 * V[7]; + tmp3 += m_A9 * V[11]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[9]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// solarq +static void nl_gcr_495c7eab8506abb2_20_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A4 += go[4]; + m_A3 += go[5]; + m_A3 += go[6]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A5 += gt[13]; + m_A7 += go[10]; + m_A6 += go[11]; + m_A6 += go[12]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A9 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A13 += go[20]; + m_A13 += go[21]; + m_A12 += go[22]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[23] * *cnV[23]; + RHS4 -= go[24] * *cnV[24]; + m_A19 += gt[25]; + m_A19 += gt[26]; + m_A19 += gt[27]; + m_A19 += gt[28]; + m_A19 += gt[29]; + m_A17 += go[25]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[26] * *cnV[26]; + RHS5 -= go[27] * *cnV[27]; + RHS5 -= go[28] * *cnV[28]; + RHS5 -= go[29] * *cnV[29]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + 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 f1_4 = -f1 * m_A12; + m_A14 += m_A3 * f1_4; + m_A15 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A13; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A17; + m_A18 += m_A6 * f2_5; + m_A19 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + RHS4 += f3_4 * RHS3; + const double f4 = 1.0 / m_A15; + const double f4_5 = -f4 * m_A18; + m_A19 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A19; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + double tmp3 = 0.0; + tmp3 += m_A11 * V[4]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_4a06f16ac700a832_198_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -5219,6 +13164,1557 @@ static void nl_gcr_4a06f16ac700a832_198_double_double(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// starcas +static void nl_gcr_4b76db69603d04dd_64_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A1 += go[0]; + m_A1 += go[1]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + RHS0 -= go[5] * *cnV[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A3 += go[6]; + double RHS1 = Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A5 += go[10]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A6 += gt[16]; + m_A6 += gt[17]; + m_A6 += gt[18]; + m_A6 += gt[19]; + m_A9 += go[12]; + m_A7 += go[13]; + m_A7 += go[14]; + m_A8 += go[15]; + m_A8 += go[16]; + m_A10 += go[17]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A11 += gt[23]; + m_A12 += go[20]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 -= go[21] * *cnV[21]; + RHS4 -= go[22] * *cnV[22]; + RHS4 -= go[23] * *cnV[23]; + m_A13 += gt[24]; + m_A13 += gt[25]; + m_A14 += go[24]; + double RHS5 = Idr[24]; + RHS5 += Idr[25]; + RHS5 -= go[25] * *cnV[25]; + m_A15 += gt[26]; + m_A15 += gt[27]; + m_A15 += gt[28]; + m_A15 += gt[29]; + m_A15 += gt[30]; + m_A15 += gt[31]; + m_A15 += gt[32]; + m_A15 += gt[33]; + m_A18 += go[26]; + m_A16 += go[27]; + m_A16 += go[28]; + m_A17 += go[29]; + m_A17 += go[30]; + m_A19 += go[31]; + double RHS6 = Idr[26]; + RHS6 += Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + RHS6 += Idr[32]; + RHS6 += Idr[33]; + RHS6 -= go[32] * *cnV[32]; + RHS6 -= go[33] * *cnV[33]; + m_A21 += gt[34]; + m_A21 += gt[35]; + m_A21 += gt[36]; + m_A21 += gt[37]; + m_A21 += gt[38]; + m_A23 += go[34]; + m_A23 += go[35]; + m_A20 += go[36]; + m_A20 += go[37]; + double RHS7 = Idr[34]; + RHS7 += Idr[35]; + RHS7 += Idr[36]; + RHS7 += Idr[37]; + RHS7 += Idr[38]; + RHS7 -= go[38] * *cnV[38]; + m_A26 += gt[39]; + m_A26 += gt[40]; + m_A26 += gt[41]; + m_A26 += gt[42]; + m_A26 += gt[43]; + m_A28 += go[39]; + m_A28 += go[40]; + m_A25 += go[41]; + m_A25 += go[42]; + double RHS8 = Idr[39]; + RHS8 += Idr[40]; + RHS8 += Idr[41]; + RHS8 += Idr[42]; + RHS8 += Idr[43]; + RHS8 -= go[43] * *cnV[43]; + m_A33 += gt[44]; + m_A33 += gt[45]; + m_A33 += gt[46]; + m_A33 += gt[47]; + m_A33 += gt[48]; + m_A31 += go[44]; + m_A31 += go[45]; + m_A30 += go[46]; + m_A35 += go[47]; + m_A35 += go[48]; + double RHS9 = Idr[44]; + RHS9 += Idr[45]; + RHS9 += Idr[46]; + RHS9 += Idr[47]; + RHS9 += Idr[48]; + m_A39 += gt[49]; + m_A39 += gt[50]; + m_A39 += gt[51]; + m_A39 += gt[52]; + m_A39 += gt[53]; + m_A37 += go[49]; + m_A37 += go[50]; + m_A36 += go[51]; + m_A41 += go[52]; + m_A41 += go[53]; + double RHS10 = Idr[49]; + RHS10 += Idr[50]; + RHS10 += Idr[51]; + RHS10 += Idr[52]; + RHS10 += Idr[53]; + m_A46 += gt[54]; + m_A46 += gt[55]; + m_A46 += gt[56]; + m_A46 += gt[57]; + m_A46 += gt[58]; + m_A44 += go[54]; + m_A44 += go[55]; + m_A43 += go[56]; + m_A42 += go[57]; + double RHS11 = Idr[54]; + RHS11 += Idr[55]; + RHS11 += Idr[56]; + RHS11 += Idr[57]; + RHS11 += Idr[58]; + RHS11 -= go[58] * *cnV[58]; + m_A52 += gt[59]; + m_A52 += gt[60]; + m_A52 += gt[61]; + m_A52 += gt[62]; + m_A52 += gt[63]; + m_A50 += go[59]; + m_A50 += go[60]; + m_A49 += go[61]; + m_A48 += go[62]; + double RHS12 = Idr[59]; + RHS12 += Idr[60]; + RHS12 += Idr[61]; + RHS12 += Idr[62]; + RHS12 += Idr[63]; + RHS12 -= go[63] * *cnV[63]; + m_A63 += gt[64]; + m_A63 += gt[65]; + m_A63 += gt[66]; + m_A63 += gt[67]; + m_A63 += gt[68]; + m_A63 += gt[69]; + m_A63 += gt[70]; + m_A63 += gt[71]; + m_A63 += gt[72]; + m_A63 += gt[73]; + m_A63 += gt[74]; + m_A56 += go[64]; + m_A60 += go[65]; + m_A60 += go[66]; + m_A55 += go[67]; + m_A59 += go[68]; + m_A59 += go[69]; + m_A54 += go[70]; + m_A54 += go[71]; + double RHS13 = Idr[64]; + RHS13 += Idr[65]; + RHS13 += Idr[66]; + RHS13 += Idr[67]; + RHS13 += Idr[68]; + RHS13 += Idr[69]; + RHS13 += Idr[70]; + RHS13 += Idr[71]; + RHS13 += Idr[72]; + RHS13 += Idr[73]; + RHS13 += Idr[74]; + RHS13 -= go[72] * *cnV[72]; + RHS13 -= go[73] * *cnV[73]; + RHS13 -= go[74] * *cnV[74]; + const double f0 = 1.0 / m_A0; + const double f0_13 = -f0 * m_A54; + m_A63 += m_A1 * f0_13; + RHS13 += f0_13 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_9 = -f1 * m_A30; + m_A33 += m_A3 * f1_9; + RHS9 += f1_9 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_11 = -f2 * m_A42; + m_A46 += m_A5 * f2_11; + RHS11 += f2_11 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_7 = -f3 * m_A20; + m_A21 += m_A7 * f3_7; + m_A22 += m_A8 * f3_7; + m_A23 += m_A9 * f3_7; + m_A24 += m_A10 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_9 = -f3 * m_A31; + m_A32 += m_A7 * f3_9; + m_A33 += m_A8 * f3_9; + m_A34 += m_A9 * f3_9; + m_A35 += m_A10 * f3_9; + RHS9 += f3_9 * RHS3; + const double f3_11 = -f3 * m_A43; + m_A44 += m_A7 * f3_11; + m_A45 += m_A8 * f3_11; + m_A46 += m_A9 * f3_11; + m_A47 += m_A10 * f3_11; + RHS11 += f3_11 * RHS3; + const double f3_13 = -f3 * m_A55; + m_A57 += m_A7 * f3_13; + m_A59 += m_A8 * f3_13; + m_A61 += m_A9 * f3_13; + m_A63 += m_A10 * f3_13; + RHS13 += f3_13 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_10 = -f4 * m_A36; + m_A39 += m_A12 * f4_10; + RHS10 += f4_10 * RHS4; + const double f5 = 1.0 / m_A13; + const double f5_12 = -f5 * m_A48; + m_A52 += m_A14 * f5_12; + RHS12 += f5_12 * RHS5; + const double f6 = 1.0 / m_A15; + const double f6_8 = -f6 * m_A25; + m_A26 += m_A16 * f6_8; + m_A27 += m_A17 * f6_8; + m_A28 += m_A18 * f6_8; + m_A29 += m_A19 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_10 = -f6 * m_A37; + m_A38 += m_A16 * f6_10; + m_A39 += m_A17 * f6_10; + m_A40 += m_A18 * f6_10; + m_A41 += m_A19 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_12 = -f6 * m_A49; + m_A50 += m_A16 * f6_12; + m_A51 += m_A17 * f6_12; + m_A52 += m_A18 * f6_12; + m_A53 += m_A19 * f6_12; + RHS12 += f6_12 * RHS6; + const double f6_13 = -f6 * m_A56; + m_A58 += m_A16 * f6_13; + m_A60 += m_A17 * f6_13; + m_A62 += m_A18 * f6_13; + m_A63 += m_A19 * f6_13; + RHS13 += f6_13 * RHS6; + const double f7 = 1.0 / m_A21; + const double f7_9 = -f7 * m_A32; + m_A33 += m_A22 * f7_9; + m_A34 += m_A23 * f7_9; + m_A35 += m_A24 * f7_9; + RHS9 += f7_9 * RHS7; + const double f7_11 = -f7 * m_A44; + m_A45 += m_A22 * f7_11; + m_A46 += m_A23 * f7_11; + m_A47 += m_A24 * f7_11; + RHS11 += f7_11 * RHS7; + const double f7_13 = -f7 * m_A57; + m_A59 += m_A22 * f7_13; + m_A61 += m_A23 * f7_13; + m_A63 += m_A24 * f7_13; + RHS13 += f7_13 * RHS7; + const double f8 = 1.0 / m_A26; + const double f8_10 = -f8 * m_A38; + m_A39 += m_A27 * f8_10; + m_A40 += m_A28 * f8_10; + m_A41 += m_A29 * f8_10; + RHS10 += f8_10 * RHS8; + const double f8_12 = -f8 * m_A50; + m_A51 += m_A27 * f8_12; + m_A52 += m_A28 * f8_12; + m_A53 += m_A29 * f8_12; + RHS12 += f8_12 * RHS8; + const double f8_13 = -f8 * m_A58; + m_A60 += m_A27 * f8_13; + 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_11 = -f9 * m_A45; + m_A46 += m_A34 * f9_11; + m_A47 += m_A35 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_13 = -f9 * m_A59; + m_A61 += m_A34 * f9_13; + m_A63 += m_A35 * f9_13; + RHS13 += f9_13 * RHS9; + const double f10 = 1.0 / m_A39; + const double f10_12 = -f10 * m_A51; + m_A52 += m_A40 * f10_12; + m_A53 += m_A41 * f10_12; + RHS12 += f10_12 * RHS10; + const double f10_13 = -f10 * m_A60; + m_A62 += m_A40 * f10_13; + m_A63 += m_A41 * f10_13; + RHS13 += f10_13 * RHS10; + const double f11 = 1.0 / m_A46; + const double f11_13 = -f11 * m_A61; + m_A63 += m_A47 * f11_13; + RHS13 += f11_13 * RHS11; + const double f12 = 1.0 / m_A52; + const double f12_13 = -f12 * m_A62; + m_A63 += m_A53 * f12_13; + RHS13 += f12_13 * RHS12; + V[13] = RHS13 / m_A63; + double tmp12 = 0.0; + tmp12 += m_A53 * V[13]; + V[12] = (RHS12 - tmp12) / m_A52; + double tmp11 = 0.0; + tmp11 += m_A47 * V[13]; + V[11] = (RHS11 - tmp11) / m_A46; + double tmp10 = 0.0; + tmp10 += m_A40 * V[12]; + tmp10 += m_A41 * V[13]; + V[10] = (RHS10 - tmp10) / m_A39; + double tmp9 = 0.0; + tmp9 += m_A34 * V[11]; + tmp9 += m_A35 * V[13]; + V[9] = (RHS9 - tmp9) / m_A33; + double tmp8 = 0.0; + tmp8 += m_A27 * V[10]; + tmp8 += m_A28 * V[12]; + tmp8 += m_A29 * V[13]; + V[8] = (RHS8 - tmp8) / m_A26; + double tmp7 = 0.0; + tmp7 += m_A22 * V[9]; + tmp7 += m_A23 * V[11]; + tmp7 += m_A24 * V[13]; + V[7] = (RHS7 - tmp7) / m_A21; + double tmp6 = 0.0; + tmp6 += m_A16 * V[8]; + tmp6 += m_A17 * V[10]; + tmp6 += m_A18 * V[12]; + tmp6 += m_A19 * V[13]; + V[6] = (RHS6 - tmp6) / m_A15; + double tmp5 = 0.0; + tmp5 += m_A14 * V[12]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A12 * V[10]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A7 * V[7]; + tmp3 += m_A8 * V[9]; + tmp3 += m_A9 * V[11]; + tmp3 += m_A10 * V[13]; + 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[9]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[13]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// armora +static void nl_gcr_4b999b0eb39c27f5_22_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[4]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A7 += go[6]; + m_A6 += go[7]; + m_A6 += go[8]; + m_A5 += go[9]; + m_A5 += go[10]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + RHS2 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A9 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A16 += go[20]; + m_A16 += go[21]; + m_A13 += go[22]; + m_A13 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[24] * *cnV[24]; + m_A21 += gt[25]; + m_A21 += gt[26]; + m_A21 += gt[27]; + m_A21 += gt[28]; + m_A20 += go[25]; + m_A20 += go[26]; + m_A18 += go[27]; + m_A17 += go[28]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A17; + m_A21 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A5 * f2_3; + m_A11 += m_A6 * f2_3; + m_A12 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A13; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A18; + m_A19 += m_A5 * f2_5; + m_A20 += m_A6 * f2_5; + m_A21 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += 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_A15; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A21; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + 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_A5 * V[3]; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// solarq +static void nl_gcr_4c2a4b68f14c15f4_76_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A2 += gt[11]; + m_A5 += go[4]; + m_A4 += go[5]; + m_A4 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A7 += go[12]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 += Idr[15]; + RHS2 -= go[13] * *cnV[13]; + RHS2 -= go[14] * *cnV[14]; + RHS2 -= go[15] * *cnV[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A8 += gt[19]; + m_A8 += gt[20]; + m_A8 += gt[21]; + m_A8 += gt[22]; + m_A8 += gt[23]; + m_A11 += go[16]; + m_A10 += go[17]; + m_A10 += go[18]; + m_A9 += go[19]; + m_A9 += go[20]; + double RHS3 = Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 += Idr[20]; + RHS3 += Idr[21]; + RHS3 += Idr[22]; + RHS3 += Idr[23]; + RHS3 -= go[21] * *cnV[21]; + RHS3 -= go[22] * *cnV[22]; + RHS3 -= go[23] * *cnV[23]; + m_A12 += gt[24]; + m_A12 += gt[25]; + m_A12 += gt[26]; + m_A13 += go[24]; + m_A14 += go[25]; + double RHS4 = Idr[24]; + RHS4 += Idr[25]; + RHS4 += Idr[26]; + RHS4 -= go[26] * *cnV[26]; + m_A15 += gt[27]; + m_A15 += gt[28]; + m_A15 += gt[29]; + m_A15 += gt[30]; + m_A16 += go[27]; + double RHS5 = Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 += Idr[30]; + RHS5 -= go[28] * *cnV[28]; + RHS5 -= go[29] * *cnV[29]; + RHS5 -= go[30] * *cnV[30]; + m_A17 += gt[31]; + m_A17 += gt[32]; + m_A17 += gt[33]; + m_A17 += gt[34]; + m_A17 += gt[35]; + m_A17 += gt[36]; + m_A17 += gt[37]; + m_A17 += gt[38]; + m_A20 += go[31]; + m_A19 += go[32]; + m_A19 += go[33]; + m_A18 += go[34]; + m_A18 += go[35]; + double RHS6 = Idr[31]; + RHS6 += Idr[32]; + RHS6 += Idr[33]; + RHS6 += Idr[34]; + RHS6 += Idr[35]; + RHS6 += Idr[36]; + RHS6 += Idr[37]; + RHS6 += Idr[38]; + RHS6 -= go[36] * *cnV[36]; + RHS6 -= go[37] * *cnV[37]; + RHS6 -= go[38] * *cnV[38]; + m_A21 += gt[39]; + m_A21 += gt[40]; + m_A21 += gt[41]; + m_A23 += go[39]; + m_A22 += go[40]; + double RHS7 = Idr[39]; + RHS7 += Idr[40]; + RHS7 += Idr[41]; + RHS7 -= go[41] * *cnV[41]; + m_A26 += gt[42]; + m_A26 += gt[43]; + m_A26 += gt[44]; + m_A26 += gt[45]; + m_A26 += gt[46]; + m_A26 += gt[47]; + m_A25 += go[42]; + m_A25 += go[43]; + m_A24 += go[44]; + double RHS8 = Idr[42]; + RHS8 += Idr[43]; + RHS8 += Idr[44]; + RHS8 += Idr[45]; + RHS8 += Idr[46]; + RHS8 += Idr[47]; + RHS8 -= go[45] * *cnV[45]; + RHS8 -= go[46] * *cnV[46]; + RHS8 -= go[47] * *cnV[47]; + m_A31 += gt[48]; + m_A31 += gt[49]; + m_A31 += gt[50]; + m_A31 += gt[51]; + m_A31 += gt[52]; + m_A32 += go[48]; + m_A32 += go[49]; + m_A29 += go[50]; + m_A29 += go[51]; + double RHS9 = Idr[48]; + RHS9 += Idr[49]; + RHS9 += Idr[50]; + RHS9 += Idr[51]; + RHS9 += Idr[52]; + RHS9 -= go[52] * *cnV[52]; + m_A35 += gt[53]; + m_A35 += gt[54]; + m_A35 += gt[55]; + m_A35 += gt[56]; + m_A35 += gt[57]; + m_A35 += gt[58]; + m_A34 += go[53]; + m_A34 += go[54]; + m_A33 += go[55]; + double RHS10 = Idr[53]; + RHS10 += Idr[54]; + RHS10 += Idr[55]; + RHS10 += Idr[56]; + RHS10 += Idr[57]; + RHS10 += Idr[58]; + RHS10 -= go[56] * *cnV[56]; + RHS10 -= go[57] * *cnV[57]; + RHS10 -= go[58] * *cnV[58]; + m_A40 += gt[59]; + m_A40 += gt[60]; + m_A40 += gt[61]; + m_A40 += gt[62]; + m_A40 += gt[63]; + m_A40 += gt[64]; + m_A39 += go[59]; + m_A39 += go[60]; + m_A38 += go[61]; + double RHS11 = Idr[59]; + RHS11 += Idr[60]; + RHS11 += Idr[61]; + RHS11 += Idr[62]; + RHS11 += Idr[63]; + RHS11 += Idr[64]; + RHS11 -= go[62] * *cnV[62]; + RHS11 -= go[63] * *cnV[63]; + RHS11 -= go[64] * *cnV[64]; + m_A45 += gt[65]; + m_A45 += gt[66]; + m_A45 += gt[67]; + m_A45 += gt[68]; + m_A45 += gt[69]; + m_A46 += go[65]; + m_A46 += go[66]; + m_A43 += go[67]; + m_A43 += go[68]; + double RHS12 = Idr[65]; + RHS12 += Idr[66]; + RHS12 += Idr[67]; + RHS12 += Idr[68]; + RHS12 += Idr[69]; + RHS12 -= go[69] * *cnV[69]; + m_A49 += gt[70]; + m_A49 += gt[71]; + m_A49 += gt[72]; + m_A49 += gt[73]; + m_A49 += gt[74]; + m_A50 += go[70]; + m_A50 += go[71]; + m_A47 += go[72]; + m_A47 += go[73]; + double RHS13 = Idr[70]; + RHS13 += Idr[71]; + RHS13 += Idr[72]; + RHS13 += Idr[73]; + RHS13 += Idr[74]; + RHS13 -= go[74] * *cnV[74]; + m_A55 += gt[75]; + m_A55 += gt[76]; + m_A55 += gt[77]; + m_A55 += gt[78]; + m_A52 += go[75]; + m_A54 += go[76]; + m_A54 += go[77]; + m_A51 += go[78]; + double RHS14 = Idr[75]; + RHS14 += Idr[76]; + RHS14 += Idr[77]; + RHS14 += Idr[78]; + m_A60 += gt[79]; + m_A60 += gt[80]; + m_A60 += gt[81]; + m_A60 += gt[82]; + m_A58 += go[79]; + m_A57 += go[80]; + m_A62 += go[81]; + double RHS15 = Idr[79]; + RHS15 += Idr[80]; + RHS15 += Idr[81]; + RHS15 += Idr[82]; + RHS15 -= go[82] * *cnV[82]; + m_A68 += gt[83]; + m_A68 += gt[84]; + m_A68 += gt[85]; + m_A68 += gt[86]; + m_A64 += go[83]; + m_A66 += go[84]; + m_A66 += go[85]; + m_A63 += go[86]; + double RHS16 = Idr[83]; + RHS16 += Idr[84]; + RHS16 += Idr[85]; + RHS16 += Idr[86]; + m_A75 += gt[87]; + m_A75 += gt[88]; + m_A75 += gt[89]; + m_A75 += gt[90]; + m_A75 += gt[91]; + m_A72 += go[87]; + m_A72 += go[88]; + m_A70 += go[89]; + m_A73 += go[90]; + double RHS17 = Idr[87]; + RHS17 += Idr[88]; + RHS17 += Idr[89]; + RHS17 += Idr[90]; + RHS17 += Idr[91]; + RHS17 -= go[91] * *cnV[91]; + const double f0 = 1.0 / m_A0; + const double f0_8 = -f0 * m_A24; + m_A26 += m_A1 * f0_8; + RHS8 += f0_8 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_8 = -f1 * m_A25; + m_A26 += m_A3 * f1_8; + m_A27 += m_A4 * f1_8; + m_A28 += m_A5 * f1_8; + RHS8 += f1_8 * RHS1; + const double f1_9 = -f1 * m_A29; + m_A30 += m_A3 * f1_9; + m_A31 += m_A4 * f1_9; + m_A32 += m_A5 * f1_9; + RHS9 += f1_9 * RHS1; + const double f1_17 = -f1 * m_A70; + m_A71 += m_A3 * f1_17; + m_A72 += m_A4 * f1_17; + m_A75 += m_A5 * f1_17; + RHS17 += f1_17 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_10 = -f2 * m_A33; + m_A35 += m_A7 * f2_10; + RHS10 += f2_10 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_10 = -f3 * m_A34; + m_A35 += m_A9 * f3_10; + m_A36 += m_A10 * f3_10; + m_A37 += m_A11 * f3_10; + RHS10 += f3_10 * RHS3; + const double f3_12 = -f3 * m_A43; + m_A44 += m_A9 * f3_12; + m_A45 += m_A10 * f3_12; + m_A46 += m_A11 * f3_12; + RHS12 += f3_12 * RHS3; + const double f3_14 = -f3 * m_A51; + m_A53 += m_A9 * f3_14; + m_A54 += m_A10 * f3_14; + m_A55 += m_A11 * f3_14; + RHS14 += f3_14 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_14 = -f4 * m_A52; + m_A55 += m_A13 * f4_14; + m_A56 += m_A14 * f4_14; + RHS14 += f4_14 * RHS4; + const double f4_15 = -f4 * m_A57; + m_A59 += m_A13 * f4_15; + m_A60 += m_A14 * f4_15; + RHS15 += f4_15 * RHS4; + const double f5 = 1.0 / m_A15; + const double f5_11 = -f5 * m_A38; + m_A40 += m_A16 * f5_11; + RHS11 += f5_11 * RHS5; + const double f6 = 1.0 / m_A17; + const double f6_11 = -f6 * m_A39; + m_A40 += m_A18 * f6_11; + m_A41 += m_A19 * f6_11; + m_A42 += m_A20 * f6_11; + RHS11 += f6_11 * RHS6; + const double f6_13 = -f6 * m_A47; + m_A48 += m_A18 * f6_13; + m_A49 += m_A19 * f6_13; + m_A50 += m_A20 * f6_13; + RHS13 += f6_13 * RHS6; + const double f6_16 = -f6 * m_A63; + m_A65 += m_A18 * f6_16; + m_A66 += m_A19 * f6_16; + m_A68 += m_A20 * f6_16; + RHS16 += f6_16 * RHS6; + const double f7 = 1.0 / m_A21; + const double f7_15 = -f7 * m_A58; + m_A60 += m_A22 * f7_15; + m_A61 += m_A23 * f7_15; + RHS15 += f7_15 * RHS7; + const double f7_16 = -f7 * m_A64; + m_A67 += m_A22 * f7_16; + m_A68 += m_A23 * f7_16; + RHS16 += f7_16 * RHS7; + const double f8 = 1.0 / m_A26; + const double f8_9 = -f8 * m_A30; + m_A31 += m_A27 * f8_9; + m_A32 += m_A28 * f8_9; + RHS9 += f8_9 * RHS8; + const double f8_17 = -f8 * m_A71; + m_A72 += m_A27 * f8_17; + m_A75 += m_A28 * f8_17; + RHS17 += f8_17 * RHS8; + const double f9 = 1.0 / m_A31; + const double f9_17 = -f9 * m_A72; + m_A75 += m_A32 * f9_17; + RHS17 += f9_17 * RHS9; + const double f10 = 1.0 / m_A35; + const double f10_12 = -f10 * m_A44; + m_A45 += m_A36 * f10_12; + m_A46 += m_A37 * f10_12; + RHS12 += f10_12 * RHS10; + const double f10_14 = -f10 * m_A53; + m_A54 += m_A36 * f10_14; + m_A55 += m_A37 * f10_14; + RHS14 += f10_14 * RHS10; + const double f11 = 1.0 / m_A40; + const double f11_13 = -f11 * m_A48; + m_A49 += m_A41 * f11_13; + m_A50 += m_A42 * f11_13; + RHS13 += f11_13 * RHS11; + const double f11_16 = -f11 * m_A65; + m_A66 += m_A41 * f11_16; + m_A68 += m_A42 * f11_16; + RHS16 += f11_16 * RHS11; + const double f12 = 1.0 / m_A45; + const double f12_14 = -f12 * m_A54; + m_A55 += m_A46 * f12_14; + RHS14 += f12_14 * RHS12; + const double f13 = 1.0 / m_A49; + const double f13_16 = -f13 * m_A66; + m_A68 += m_A50 * f13_16; + RHS16 += f13_16 * RHS13; + const double f14 = 1.0 / m_A55; + const double f14_15 = -f14 * m_A59; + m_A60 += m_A56 * f14_15; + RHS15 += f14_15 * RHS14; + const double f15 = 1.0 / m_A60; + const double f15_16 = -f15 * m_A67; + m_A68 += m_A61 * f15_16; + m_A69 += m_A62 * f15_16; + RHS16 += f15_16 * RHS15; + const double f15_17 = -f15 * m_A73; + m_A74 += m_A61 * f15_17; + m_A75 += m_A62 * f15_17; + RHS17 += f15_17 * RHS15; + const double f16 = 1.0 / m_A68; + const double f16_17 = -f16 * m_A74; + m_A75 += m_A69 * f16_17; + RHS17 += f16_17 * RHS16; + V[17] = RHS17 / m_A75; + double tmp16 = 0.0; + tmp16 += m_A69 * V[17]; + V[16] = (RHS16 - tmp16) / m_A68; + double tmp15 = 0.0; + tmp15 += m_A61 * V[16]; + tmp15 += m_A62 * V[17]; + V[15] = (RHS15 - tmp15) / m_A60; + double tmp14 = 0.0; + tmp14 += m_A56 * V[15]; + V[14] = (RHS14 - tmp14) / m_A55; + double tmp13 = 0.0; + tmp13 += m_A50 * V[16]; + V[13] = (RHS13 - tmp13) / m_A49; + double tmp12 = 0.0; + tmp12 += m_A46 * V[14]; + V[12] = (RHS12 - tmp12) / m_A45; + double tmp11 = 0.0; + tmp11 += m_A41 * V[13]; + tmp11 += m_A42 * V[16]; + V[11] = (RHS11 - tmp11) / m_A40; + double tmp10 = 0.0; + tmp10 += m_A36 * V[12]; + tmp10 += m_A37 * V[14]; + V[10] = (RHS10 - tmp10) / m_A35; + double tmp9 = 0.0; + tmp9 += m_A32 * V[17]; + V[9] = (RHS9 - tmp9) / m_A31; + double tmp8 = 0.0; + tmp8 += m_A27 * V[9]; + tmp8 += m_A28 * V[17]; + V[8] = (RHS8 - tmp8) / m_A26; + double tmp7 = 0.0; + tmp7 += m_A22 * V[15]; + tmp7 += m_A23 * V[16]; + V[7] = (RHS7 - tmp7) / m_A21; + double tmp6 = 0.0; + tmp6 += m_A18 * V[11]; + tmp6 += m_A19 * V[13]; + tmp6 += m_A20 * V[16]; + V[6] = (RHS6 - tmp6) / m_A17; + double tmp5 = 0.0; + tmp5 += m_A16 * V[11]; + V[5] = (RHS5 - tmp5) / m_A15; + double tmp4 = 0.0; + tmp4 += m_A13 * V[14]; + tmp4 += m_A14 * V[15]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[10]; + tmp3 += m_A10 * V[12]; + tmp3 += m_A11 * V[14]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A7 * V[10]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[8]; + tmp1 += m_A4 * V[9]; + tmp1 += m_A5 * V[17]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[8]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// armora +static void nl_gcr_4cf10d4579d7c623_45_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A2 += gt[11]; + m_A5 += go[4]; + m_A4 += go[5]; + m_A4 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A7 += go[12]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 += Idr[15]; + RHS2 -= go[13] * *cnV[13]; + RHS2 -= go[14] * *cnV[14]; + RHS2 -= go[15] * *cnV[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A10 += go[16]; + m_A9 += go[17]; + double RHS3 = Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 -= go[18] * *cnV[18]; + m_A11 += gt[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A11 += gt[23]; + m_A11 += gt[24]; + m_A11 += gt[25]; + m_A11 += gt[26]; + m_A14 += go[19]; + m_A13 += go[20]; + m_A13 += go[21]; + m_A12 += go[22]; + m_A12 += go[23]; + double RHS4 = Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 += Idr[26]; + RHS4 -= go[24] * *cnV[24]; + RHS4 -= go[25] * *cnV[25]; + RHS4 -= go[26] * *cnV[26]; + m_A17 += gt[27]; + m_A17 += gt[28]; + m_A17 += gt[29]; + m_A17 += gt[30]; + m_A17 += gt[31]; + m_A17 += gt[32]; + m_A16 += go[27]; + m_A16 += go[28]; + m_A15 += go[29]; + double RHS5 = Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 += Idr[30]; + RHS5 += Idr[31]; + RHS5 += Idr[32]; + RHS5 -= go[30] * *cnV[30]; + RHS5 -= go[31] * *cnV[31]; + RHS5 -= go[32] * *cnV[32]; + m_A22 += gt[33]; + m_A22 += gt[34]; + m_A22 += gt[35]; + m_A22 += gt[36]; + m_A22 += gt[37]; + m_A22 += gt[38]; + m_A21 += go[33]; + m_A21 += go[34]; + m_A20 += go[35]; + double RHS6 = Idr[33]; + RHS6 += Idr[34]; + RHS6 += Idr[35]; + RHS6 += Idr[36]; + RHS6 += Idr[37]; + RHS6 += Idr[38]; + RHS6 -= go[36] * *cnV[36]; + RHS6 -= go[37] * *cnV[37]; + RHS6 -= go[38] * *cnV[38]; + m_A27 += gt[39]; + m_A27 += gt[40]; + m_A27 += gt[41]; + m_A27 += gt[42]; + m_A27 += gt[43]; + m_A28 += go[39]; + m_A28 += go[40]; + m_A25 += go[41]; + m_A25 += go[42]; + double RHS7 = Idr[39]; + RHS7 += Idr[40]; + RHS7 += Idr[41]; + RHS7 += Idr[42]; + RHS7 += Idr[43]; + RHS7 -= go[43] * *cnV[43]; + m_A31 += gt[44]; + m_A31 += gt[45]; + m_A31 += gt[46]; + m_A31 += gt[47]; + m_A31 += gt[48]; + m_A32 += go[44]; + m_A32 += go[45]; + m_A29 += go[46]; + m_A29 += go[47]; + double RHS8 = Idr[44]; + RHS8 += Idr[45]; + RHS8 += Idr[46]; + RHS8 += Idr[47]; + RHS8 += Idr[48]; + RHS8 -= go[48] * *cnV[48]; + m_A37 += gt[49]; + m_A37 += gt[50]; + m_A37 += gt[51]; + m_A37 += gt[52]; + m_A37 += gt[53]; + m_A34 += go[49]; + m_A36 += go[50]; + m_A36 += go[51]; + m_A33 += go[52]; + double RHS9 = Idr[49]; + RHS9 += Idr[50]; + RHS9 += Idr[51]; + RHS9 += Idr[52]; + RHS9 += Idr[53]; + RHS9 -= go[53] * *cnV[53]; + m_A44 += gt[54]; + m_A44 += gt[55]; + m_A44 += gt[56]; + m_A44 += gt[57]; + m_A44 += gt[58]; + m_A42 += go[54]; + m_A42 += go[55]; + m_A40 += go[56]; + m_A39 += go[57]; + double RHS10 = Idr[54]; + RHS10 += Idr[55]; + RHS10 += Idr[56]; + RHS10 += Idr[57]; + RHS10 += Idr[58]; + RHS10 -= go[58] * *cnV[58]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A15; + m_A17 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A16; + m_A17 += m_A3 * f1_5; + m_A18 += m_A4 * f1_5; + m_A19 += m_A5 * f1_5; + RHS5 += f1_5 * RHS1; + const double f1_7 = -f1 * m_A25; + m_A26 += m_A3 * f1_7; + m_A27 += m_A4 * f1_7; + m_A28 += m_A5 * f1_7; + RHS7 += f1_7 * RHS1; + const double f1_9 = -f1 * m_A33; + m_A35 += m_A3 * f1_9; + m_A36 += m_A4 * f1_9; + m_A37 += m_A5 * f1_9; + RHS9 += f1_9 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_6 = -f2 * m_A20; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_9 = -f3 * m_A34; + m_A37 += m_A9 * f3_9; + m_A38 += m_A10 * f3_9; + RHS9 += f3_9 * RHS3; + const double f3_10 = -f3 * m_A39; + m_A43 += m_A9 * f3_10; + m_A44 += m_A10 * f3_10; + RHS10 += f3_10 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_6 = -f4 * m_A21; + m_A22 += m_A12 * f4_6; + m_A23 += m_A13 * f4_6; + m_A24 += m_A14 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_8 = -f4 * m_A29; + m_A30 += m_A12 * f4_8; + m_A31 += m_A13 * f4_8; + m_A32 += m_A14 * f4_8; + RHS8 += f4_8 * RHS4; + const double f4_10 = -f4 * m_A40; + m_A41 += m_A12 * f4_10; + m_A42 += m_A13 * f4_10; + m_A44 += m_A14 * f4_10; + RHS10 += f4_10 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_7 = -f5 * m_A26; + m_A27 += m_A18 * f5_7; + m_A28 += m_A19 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_9 = -f5 * m_A35; + m_A36 += m_A18 * f5_9; + m_A37 += m_A19 * f5_9; + RHS9 += f5_9 * RHS5; + const double f6 = 1.0 / m_A22; + const double f6_8 = -f6 * m_A30; + m_A31 += m_A23 * f6_8; + m_A32 += m_A24 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_10 = -f6 * m_A41; + m_A42 += m_A23 * f6_10; + m_A44 += m_A24 * f6_10; + RHS10 += f6_10 * RHS6; + const double f7 = 1.0 / m_A27; + const double f7_9 = -f7 * m_A36; + m_A37 += m_A28 * f7_9; + RHS9 += f7_9 * RHS7; + const double f8 = 1.0 / m_A31; + const double f8_10 = -f8 * m_A42; + m_A44 += m_A32 * f8_10; + RHS10 += f8_10 * RHS8; + const double f9 = 1.0 / m_A37; + const double f9_10 = -f9 * m_A43; + m_A44 += m_A38 * f9_10; + RHS10 += f9_10 * RHS9; + V[10] = RHS10 / m_A44; + double tmp9 = 0.0; + tmp9 += m_A38 * V[10]; + V[9] = (RHS9 - tmp9) / m_A37; + double tmp8 = 0.0; + tmp8 += m_A32 * V[10]; + V[8] = (RHS8 - tmp8) / m_A31; + double tmp7 = 0.0; + tmp7 += m_A28 * V[9]; + V[7] = (RHS7 - tmp7) / m_A27; + double tmp6 = 0.0; + tmp6 += m_A23 * V[8]; + tmp6 += m_A24 * V[10]; + V[6] = (RHS6 - tmp6) / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[7]; + tmp5 += m_A19 * V[9]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A12 * V[6]; + tmp4 += m_A13 * V[8]; + tmp4 += m_A14 * V[10]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A9 * V[9]; + tmp3 += m_A10 * V[10]; + 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_A3 * V[5]; + tmp1 += m_A4 * V[7]; + tmp1 += m_A5 * V[9]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // gtrak10 static void nl_gcr_4e48e9f6ef4bfdc4_43_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -5545,6 +15041,267 @@ static void nl_gcr_4e48e9f6ef4bfdc4_43_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// ripoff +static void nl_gcr_4f64406bd9c100b5_20_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A0 += gt[6]; + m_A2 += go[0]; + m_A2 += go[1]; + m_A1 += go[2]; + m_A1 += go[3]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 += Idr[6]; + RHS0 -= go[4] * *cnV[4]; + RHS0 -= go[5] * *cnV[5]; + RHS0 -= go[6] * *cnV[6]; + m_A3 += gt[7]; + m_A3 += gt[8]; + m_A4 += go[7]; + double RHS1 = Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[8] * *cnV[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A7 += go[9]; + m_A5 += go[10]; + m_A5 += go[11]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[12] * *cnV[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A9 += go[13]; + m_A9 += go[14]; + m_A10 += go[15]; + m_A10 += go[16]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 -= go[17] * *cnV[17]; + m_A13 += gt[18]; + m_A13 += gt[19]; + m_A13 += gt[20]; + m_A13 += gt[21]; + m_A12 += go[18]; + m_A12 += go[19]; + m_A14 += go[20]; + m_A11 += go[21]; + double RHS4 = Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + m_A19 += gt[22]; + m_A19 += gt[23]; + m_A19 += gt[24]; + m_A19 += gt[25]; + m_A19 += gt[26]; + m_A19 += gt[27]; + m_A19 += gt[28]; + m_A19 += gt[29]; + m_A18 += go[22]; + m_A17 += go[23]; + m_A17 += go[24]; + m_A16 += go[25]; + m_A15 += go[26]; + m_A15 += go[27]; + double RHS5 = Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[28] * *cnV[28]; + RHS5 -= go[29] * *cnV[29]; + 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_5 = -f0 * m_A15; + m_A16 += m_A1 * f0_5; + m_A19 += m_A2 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A3; + const double f1_4 = -f1 * m_A11; + m_A13 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_5 = -f2 * m_A16; + m_A19 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_4 = -f3 * m_A12; + m_A13 += m_A9 * f3_4; + m_A14 += 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_A13; + const double f4_5 = -f4 * m_A18; + m_A19 += m_A14 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A19; + double tmp4 = 0.0; + tmp4 += m_A14 * V[5]; + V[4] = (RHS4 - tmp4) / m_A13; + 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_A7 * V[5]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A4 * V[4]; + V[1] = (RHS1 - tmp1) / m_A3; + double tmp0 = 0.0; + tmp0 += m_A1 * V[2]; + tmp0 += m_A2 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// solarq +static void nl_gcr_56d6ddbab32b391d_15_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A4 += go[2]; + m_A3 += go[3]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[4] * *cnV[4]; + m_A5 += gt[5]; + m_A5 += gt[6]; + m_A6 += go[5]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 -= go[6] * *cnV[6]; + m_A9 += gt[7]; + m_A9 += gt[8]; + m_A9 += gt[9]; + m_A8 += go[7]; + m_A7 += go[8]; + double RHS3 = Idr[7]; + RHS3 += Idr[8]; + RHS3 += Idr[9]; + RHS3 -= go[9] * *cnV[9]; + m_A14 += gt[10]; + m_A14 += gt[11]; + m_A14 += gt[12]; + m_A12 += go[10]; + m_A11 += go[11]; + double RHS4 = Idr[10]; + RHS4 += Idr[11]; + RHS4 += Idr[12]; + RHS4 -= go[12] * *cnV[12]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A7; + m_A9 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A8; + m_A9 += m_A3 * f1_3; + m_A10 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_4 = -f1 * m_A11; + m_A13 += m_A3 * f1_4; + m_A14 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A12; + m_A14 += m_A6 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A9; + const double f3_4 = -f3 * m_A13; + m_A14 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A14; + double tmp3 = 0.0; + tmp3 += m_A10 * V[4]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_580e08d22698f60a_37_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -5811,6 +15568,351 @@ static void nl_gcr_580e08d22698f60a_37_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// barrier +static void nl_gcr_583b020c6c17bfbc_47_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A5 += go[9]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[10] * *cnV[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A6 += gt[16]; + m_A7 += go[11]; + m_A7 += go[12]; + m_A7 += go[13]; + m_A9 += go[14]; + m_A8 += go[15]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 -= go[16] * *cnV[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A11 += go[17]; + m_A12 += go[18]; + double RHS4 = Idr[17]; + RHS4 += Idr[18]; + m_A13 += gt[19]; + m_A13 += gt[20]; + m_A13 += gt[21]; + m_A13 += gt[22]; + m_A13 += gt[23]; + m_A13 += gt[24]; + m_A13 += gt[25]; + m_A14 += go[19]; + double RHS5 = Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 -= go[20] * *cnV[20]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + RHS5 -= go[23] * *cnV[23]; + RHS5 -= go[24] * *cnV[24]; + RHS5 -= go[25] * *cnV[25]; + m_A16 += gt[26]; + m_A16 += gt[27]; + m_A16 += gt[28]; + m_A16 += gt[29]; + m_A16 += gt[30]; + m_A15 += go[26]; + m_A15 += go[27]; + m_A15 += go[28]; + double RHS6 = Idr[26]; + RHS6 += Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + m_A20 += gt[31]; + m_A20 += gt[32]; + m_A20 += gt[33]; + m_A20 += gt[34]; + m_A19 += go[31]; + m_A21 += go[32]; + m_A21 += go[33]; + double RHS7 = Idr[31]; + RHS7 += Idr[32]; + RHS7 += Idr[33]; + RHS7 += Idr[34]; + RHS7 -= go[34] * *cnV[34]; + m_A23 += gt[35]; + m_A23 += gt[36]; + m_A22 += go[35]; + m_A24 += go[36]; + double RHS8 = Idr[35]; + RHS8 += Idr[36]; + m_A26 += gt[37]; + m_A26 += gt[38]; + m_A26 += gt[39]; + m_A28 += go[37]; + m_A25 += go[38]; + double RHS9 = Idr[37]; + RHS9 += Idr[38]; + RHS9 += Idr[39]; + RHS9 -= go[39] * *cnV[39]; + m_A33 += gt[40]; + m_A33 += gt[41]; + m_A33 += gt[42]; + m_A33 += gt[43]; + m_A33 += gt[44]; + m_A33 += gt[45]; + m_A33 += gt[46]; + m_A29 += go[40]; + m_A30 += go[41]; + m_A32 += go[42]; + m_A32 += go[43]; + double RHS10 = Idr[40]; + RHS10 += Idr[41]; + RHS10 += Idr[42]; + RHS10 += Idr[43]; + RHS10 += Idr[44]; + RHS10 += Idr[45]; + RHS10 += Idr[46]; + RHS10 -= go[44] * *cnV[44]; + RHS10 -= go[45] * *cnV[45]; + RHS10 -= go[46] * *cnV[46]; + m_A41 += gt[47]; + m_A41 += gt[48]; + m_A41 += gt[49]; + m_A41 += gt[50]; + m_A41 += gt[51]; + m_A41 += gt[52]; + m_A36 += go[47]; + m_A35 += go[48]; + m_A38 += go[49]; + double RHS11 = Idr[47]; + RHS11 += Idr[48]; + RHS11 += Idr[49]; + RHS11 += Idr[50]; + RHS11 += Idr[51]; + RHS11 += Idr[52]; + RHS11 -= go[50] * *cnV[50]; + RHS11 -= go[51] * *cnV[51]; + RHS11 -= go[52] * *cnV[52]; + m_A46 += gt[53]; + m_A46 += gt[54]; + m_A46 += gt[55]; + m_A46 += gt[56]; + m_A46 += gt[57]; + m_A43 += go[53]; + m_A44 += go[54]; + double RHS12 = Idr[53]; + RHS12 += Idr[54]; + RHS12 += Idr[55]; + RHS12 += Idr[56]; + RHS12 += Idr[57]; + RHS12 -= go[55] * *cnV[55]; + RHS12 -= go[56] * *cnV[56]; + RHS12 -= go[57] * *cnV[57]; + const double f0 = 1.0 / m_A0; + const double f0_7 = -f0 * m_A19; + m_A20 += m_A1 * f0_7; + RHS7 += f0_7 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_10 = -f1 * m_A29; + m_A32 += m_A3 * f1_10; + RHS10 += f1_10 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_8 = -f2 * m_A22; + m_A23 += m_A5 * f2_8; + RHS8 += f2_8 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_6 = -f3 * m_A15; + m_A16 += m_A7 * f3_6; + m_A17 += m_A8 * f3_6; + m_A18 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f3_10 = -f3 * m_A30; + m_A31 += m_A7 * f3_10; + m_A33 += m_A8 * f3_10; + m_A34 += m_A9 * f3_10; + RHS10 += f3_10 * RHS3; + const double f3_11 = -f3 * m_A35; + m_A37 += m_A7 * f3_11; + m_A40 += m_A8 * f3_11; + m_A41 += m_A9 * f3_11; + RHS11 += f3_11 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_9 = -f4 * m_A25; + m_A26 += m_A11 * f4_9; + m_A27 += m_A12 * f4_9; + RHS9 += f4_9 * RHS4; + const double f4_11 = -f4 * m_A36; + m_A39 += m_A11 * f4_11; + m_A41 += m_A12 * f4_11; + RHS11 += f4_11 * RHS4; + const double f5 = 1.0 / m_A13; + const double f5_12 = -f5 * m_A43; + m_A44 += m_A14 * f5_12; + RHS12 += f5_12 * RHS5; + const double f6 = 1.0 / m_A16; + const double f6_10 = -f6 * m_A31; + m_A33 += m_A17 * f6_10; + m_A34 += m_A18 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_11 = -f6 * m_A37; + m_A40 += m_A17 * f6_11; + m_A41 += m_A18 * f6_11; + RHS11 += f6_11 * RHS6; + const double f7 = 1.0 / m_A20; + const double f7_10 = -f7 * m_A32; + m_A33 += m_A21 * f7_10; + RHS10 += f7_10 * RHS7; + const double f8 = 1.0 / m_A23; + const double f8_11 = -f8 * m_A38; + m_A41 += m_A24 * f8_11; + RHS11 += f8_11 * RHS8; + const double f9 = 1.0 / m_A26; + const double f9_11 = -f9 * m_A39; + m_A41 += m_A27 * f9_11; + m_A42 += m_A28 * f9_11; + RHS11 += f9_11 * RHS9; + const double f9_12 = -f9 * m_A44; + m_A45 += m_A27 * f9_12; + m_A46 += m_A28 * f9_12; + RHS12 += f9_12 * RHS9; + const double f10 = 1.0 / m_A33; + const double f10_11 = -f10 * m_A40; + m_A41 += m_A34 * f10_11; + RHS11 += f10_11 * RHS10; + const double f11 = 1.0 / m_A41; + const double f11_12 = -f11 * m_A45; + m_A46 += m_A42 * f11_12; + RHS12 += f11_12 * RHS11; + V[12] = RHS12 / m_A46; + double tmp11 = 0.0; + tmp11 += m_A42 * V[12]; + V[11] = (RHS11 - tmp11) / m_A41; + double tmp10 = 0.0; + tmp10 += m_A34 * V[11]; + V[10] = (RHS10 - tmp10) / m_A33; + double tmp9 = 0.0; + tmp9 += m_A27 * V[11]; + tmp9 += m_A28 * V[12]; + V[9] = (RHS9 - tmp9) / m_A26; + double tmp8 = 0.0; + tmp8 += m_A24 * V[11]; + V[8] = (RHS8 - tmp8) / m_A23; + double tmp7 = 0.0; + tmp7 += m_A21 * V[10]; + V[7] = (RHS7 - tmp7) / m_A20; + double tmp6 = 0.0; + tmp6 += m_A17 * V[10]; + tmp6 += m_A18 * V[11]; + V[6] = (RHS6 - tmp6) / m_A16; + double tmp5 = 0.0; + tmp5 += m_A14 * V[9]; + V[5] = (RHS5 - tmp5) / m_A13; + double tmp4 = 0.0; + tmp4 += m_A11 * V[9]; + tmp4 += m_A12 * V[11]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A7 * V[6]; + tmp3 += m_A8 * V[10]; + tmp3 += m_A9 * V[11]; + 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[7]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_58f8065842de37d4_34_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -7927,6 +18029,651 @@ static void nl_gcr_60352d234249ea57_30_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb +static void nl_gcr_64053a17068b1154_96_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A3 += go[4]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A5 += go[7]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A7 += go[10]; + double RHS3 = Idr[10]; + RHS3 += Idr[11]; + RHS3 += Idr[12]; + RHS3 -= go[11] * *cnV[11]; + RHS3 -= go[12] * *cnV[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A9 += go[13]; + double RHS4 = Idr[13]; + RHS4 += Idr[14]; + RHS4 += Idr[15]; + RHS4 -= go[14] * *cnV[14]; + RHS4 -= go[15] * *cnV[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A11 += go[16]; + double RHS5 = Idr[16]; + RHS5 += Idr[17]; + RHS5 += Idr[18]; + RHS5 -= go[17] * *cnV[17]; + RHS5 -= go[18] * *cnV[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A12 += gt[21]; + m_A13 += go[19]; + double RHS6 = Idr[19]; + RHS6 += Idr[20]; + RHS6 += Idr[21]; + RHS6 -= go[20] * *cnV[20]; + RHS6 -= go[21] * *cnV[21]; + m_A14 += gt[22]; + m_A14 += gt[23]; + m_A14 += gt[24]; + m_A15 += go[22]; + double RHS7 = Idr[22]; + RHS7 += Idr[23]; + RHS7 += Idr[24]; + RHS7 -= go[23] * *cnV[23]; + RHS7 -= go[24] * *cnV[24]; + m_A16 += gt[25]; + m_A16 += gt[26]; + m_A16 += gt[27]; + m_A17 += go[25]; + double RHS8 = Idr[25]; + RHS8 += Idr[26]; + RHS8 += Idr[27]; + RHS8 -= go[26] * *cnV[26]; + RHS8 -= go[27] * *cnV[27]; + m_A18 += gt[28]; + m_A18 += gt[29]; + m_A18 += gt[30]; + m_A19 += go[28]; + double RHS9 = Idr[28]; + RHS9 += Idr[29]; + RHS9 += Idr[30]; + RHS9 -= go[29] * *cnV[29]; + RHS9 -= go[30] * *cnV[30]; + m_A20 += gt[31]; + m_A20 += gt[32]; + m_A20 += gt[33]; + m_A21 += go[31]; + double RHS10 = Idr[31]; + RHS10 += Idr[32]; + RHS10 += Idr[33]; + RHS10 -= go[32] * *cnV[32]; + RHS10 -= go[33] * *cnV[33]; + m_A22 += gt[34]; + m_A22 += gt[35]; + m_A24 += go[34]; + m_A23 += go[35]; + double RHS11 = Idr[34]; + RHS11 += Idr[35]; + m_A25 += gt[36]; + m_A25 += gt[37]; + m_A27 += go[36]; + m_A26 += go[37]; + double RHS12 = Idr[36]; + RHS12 += Idr[37]; + m_A28 += gt[38]; + m_A28 += gt[39]; + m_A30 += go[38]; + m_A29 += go[39]; + double RHS13 = Idr[38]; + RHS13 += Idr[39]; + m_A31 += gt[40]; + m_A31 += gt[41]; + m_A32 += go[40]; + double RHS14 = Idr[40]; + RHS14 += Idr[41]; + RHS14 -= go[41] * *cnV[41]; + m_A33 += gt[42]; + m_A33 += gt[43]; + m_A35 += go[42]; + m_A34 += go[43]; + double RHS15 = Idr[42]; + RHS15 += Idr[43]; + m_A36 += gt[44]; + m_A36 += gt[45]; + m_A36 += gt[46]; + m_A36 += gt[47]; + m_A36 += gt[48]; + m_A36 += gt[49]; + m_A36 += gt[50]; + m_A37 += go[44]; + double RHS16 = Idr[44]; + RHS16 += Idr[45]; + RHS16 += Idr[46]; + RHS16 += Idr[47]; + RHS16 += Idr[48]; + RHS16 += Idr[49]; + RHS16 += Idr[50]; + RHS16 -= go[45] * *cnV[45]; + RHS16 -= go[46] * *cnV[46]; + RHS16 -= go[47] * *cnV[47]; + RHS16 -= go[48] * *cnV[48]; + RHS16 -= go[49] * *cnV[49]; + RHS16 -= go[50] * *cnV[50]; + m_A42 += gt[51]; + m_A42 += gt[52]; + m_A42 += gt[53]; + m_A42 += gt[54]; + m_A42 += gt[55]; + m_A41 += go[51]; + m_A40 += go[52]; + m_A39 += go[53]; + m_A38 += go[54]; + double RHS17 = Idr[51]; + RHS17 += Idr[52]; + RHS17 += Idr[53]; + RHS17 += Idr[54]; + RHS17 += Idr[55]; + RHS17 -= go[55] * *cnV[55]; + m_A48 += gt[56]; + m_A48 += gt[57]; + m_A48 += gt[58]; + m_A48 += gt[59]; + m_A48 += gt[60]; + m_A47 += go[56]; + m_A46 += go[57]; + m_A45 += go[58]; + m_A44 += go[59]; + double RHS18 = Idr[56]; + RHS18 += Idr[57]; + RHS18 += Idr[58]; + RHS18 += Idr[59]; + RHS18 += Idr[60]; + RHS18 -= go[60] * *cnV[60]; + m_A50 += gt[61]; + m_A50 += gt[62]; + m_A51 += go[61]; + m_A52 += go[62]; + double RHS19 = Idr[61]; + RHS19 += Idr[62]; + m_A55 += gt[63]; + m_A55 += gt[64]; + m_A55 += gt[65]; + m_A54 += go[63]; + m_A53 += go[64]; + double RHS20 = Idr[63]; + RHS20 += Idr[64]; + RHS20 += Idr[65]; + RHS20 -= go[65] * *cnV[65]; + m_A58 += gt[66]; + m_A58 += gt[67]; + m_A58 += gt[68]; + m_A59 += go[66]; + m_A57 += go[67]; + double RHS21 = Idr[66]; + RHS21 += Idr[67]; + RHS21 += Idr[68]; + RHS21 -= go[68] * *cnV[68]; + m_A62 += gt[69]; + m_A62 += gt[70]; + m_A62 += gt[71]; + m_A61 += go[69]; + m_A60 += go[70]; + double RHS22 = Idr[69]; + RHS22 += Idr[70]; + RHS22 += Idr[71]; + RHS22 -= go[71] * *cnV[71]; + m_A65 += gt[72]; + m_A65 += gt[73]; + m_A65 += gt[74]; + m_A65 += gt[75]; + m_A65 += gt[76]; + m_A65 += gt[77]; + m_A65 += gt[78]; + m_A64 += go[72]; + m_A66 += go[73]; + double RHS23 = Idr[72]; + RHS23 += Idr[73]; + RHS23 += Idr[74]; + RHS23 += Idr[75]; + RHS23 += Idr[76]; + RHS23 += Idr[77]; + RHS23 += Idr[78]; + RHS23 -= go[74] * *cnV[74]; + RHS23 -= go[75] * *cnV[75]; + RHS23 -= go[76] * *cnV[76]; + RHS23 -= go[77] * *cnV[77]; + RHS23 -= go[78] * *cnV[78]; + m_A68 += gt[79]; + m_A68 += gt[80]; + m_A69 += go[79]; + m_A67 += go[80]; + double RHS24 = Idr[79]; + RHS24 += Idr[80]; + m_A73 += gt[81]; + m_A73 += gt[82]; + m_A73 += gt[83]; + m_A73 += gt[84]; + m_A73 += gt[85]; + m_A72 += go[81]; + m_A70 += go[82]; + m_A71 += go[83]; + double RHS25 = Idr[81]; + RHS25 += Idr[82]; + RHS25 += Idr[83]; + RHS25 += Idr[84]; + RHS25 += Idr[85]; + RHS25 -= go[84] * *cnV[84]; + RHS25 -= go[85] * *cnV[85]; + m_A76 += gt[86]; + m_A76 += gt[87]; + m_A77 += go[86]; + m_A75 += go[87]; + double RHS26 = Idr[86]; + RHS26 += Idr[87]; + m_A79 += gt[88]; + m_A79 += gt[89]; + m_A79 += gt[90]; + m_A79 += gt[91]; + m_A79 += gt[92]; + m_A78 += go[88]; + m_A80 += go[89]; + m_A80 += go[90]; + double RHS27 = Idr[88]; + RHS27 += Idr[89]; + RHS27 += Idr[90]; + RHS27 += Idr[91]; + RHS27 += Idr[92]; + RHS27 -= go[91] * *cnV[91]; + RHS27 -= go[92] * *cnV[92]; + m_A95 += gt[93]; + m_A95 += gt[94]; + m_A95 += gt[95]; + m_A95 += gt[96]; + m_A95 += gt[97]; + m_A95 += gt[98]; + m_A95 += gt[99]; + m_A95 += gt[100]; + m_A95 += gt[101]; + m_A95 += gt[102]; + m_A95 += gt[103]; + m_A87 += go[93]; + m_A94 += go[94]; + m_A94 += go[95]; + m_A93 += go[96]; + m_A91 += go[97]; + m_A84 += go[98]; + m_A83 += go[99]; + m_A82 += go[100]; + m_A81 += go[101]; + m_A89 += go[102]; + double RHS28 = Idr[93]; + RHS28 += Idr[94]; + RHS28 += Idr[95]; + RHS28 += Idr[96]; + RHS28 += Idr[97]; + RHS28 += Idr[98]; + RHS28 += Idr[99]; + RHS28 += Idr[100]; + RHS28 += Idr[101]; + RHS28 += Idr[102]; + RHS28 += Idr[103]; + RHS28 -= go[103] * *cnV[103]; + const double f0 = 1.0 / m_A0; + const double f0_21 = -f0 * m_A57; + m_A58 += m_A1 * f0_21; + RHS21 += f0_21 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_17 = -f1 * m_A38; + m_A42 += m_A3 * f1_17; + RHS17 += f1_17 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_17 = -f2 * m_A39; + m_A42 += m_A5 * f2_17; + RHS17 += f2_17 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_17 = -f3 * m_A40; + m_A42 += m_A7 * f3_17; + RHS17 += f3_17 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_18 = -f4 * m_A44; + m_A48 += m_A9 * f4_18; + RHS18 += f4_18 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_20 = -f5 * m_A53; + m_A55 += m_A11 * f5_20; + RHS20 += f5_20 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_22 = -f6 * m_A60; + m_A62 += m_A13 * f6_22; + RHS22 += f6_22 * RHS6; + const double f7 = 1.0 / m_A14; + const double f7_18 = -f7 * m_A45; + m_A48 += m_A15 * f7_18; + RHS18 += f7_18 * RHS7; + const double f8 = 1.0 / m_A16; + const double f8_18 = -f8 * m_A46; + m_A48 += m_A17 * f8_18; + RHS18 += f8_18 * RHS8; + const double f9 = 1.0 / m_A18; + const double f9_24 = -f9 * m_A67; + m_A68 += m_A19 * f9_24; + RHS24 += f9_24 * RHS9; + const double f10 = 1.0 / m_A20; + const double f10_26 = -f10 * m_A75; + m_A76 += m_A21 * f10_26; + RHS26 += f10_26 * RHS10; + const double f11 = 1.0 / m_A22; + const double f11_17 = -f11 * m_A41; + m_A42 += m_A23 * f11_17; + m_A43 += m_A24 * f11_17; + RHS17 += f11_17 * RHS11; + const double f11_28 = -f11 * m_A81; + m_A85 += m_A23 * f11_28; + m_A95 += m_A24 * f11_28; + RHS28 += f11_28 * RHS11; + const double f12 = 1.0 / m_A25; + const double f12_18 = -f12 * m_A47; + m_A48 += m_A26 * f12_18; + m_A49 += m_A27 * f12_18; + RHS18 += f12_18 * RHS12; + const double f12_28 = -f12 * m_A82; + m_A86 += m_A26 * f12_28; + m_A95 += m_A27 * f12_28; + RHS28 += f12_28 * RHS12; + const double f13 = 1.0 / m_A28; + const double f13_20 = -f13 * m_A54; + m_A55 += m_A29 * f13_20; + m_A56 += m_A30 * f13_20; + RHS20 += f13_20 * RHS13; + const double f13_28 = -f13 * m_A83; + m_A88 += m_A29 * f13_28; + m_A95 += m_A30 * f13_28; + RHS28 += f13_28 * RHS13; + const double f14 = 1.0 / m_A31; + const double f14_23 = -f14 * m_A64; + m_A66 += m_A32 * f14_23; + RHS23 += f14_23 * RHS14; + const double f14_25 = -f14 * m_A70; + m_A73 += m_A32 * f14_25; + RHS25 += f14_25 * RHS14; + const double f15 = 1.0 / m_A33; + const double f15_22 = -f15 * m_A61; + m_A62 += m_A34 * f15_22; + m_A63 += m_A35 * f15_22; + RHS22 += f15_22 * RHS15; + const double f15_28 = -f15 * m_A84; + m_A90 += m_A34 * f15_28; + m_A95 += m_A35 * f15_28; + RHS28 += f15_28 * RHS15; + const double f16 = 1.0 / m_A36; + const double f16_27 = -f16 * m_A78; + m_A80 += m_A37 * f16_27; + RHS27 += f16_27 * RHS16; + const double f17 = 1.0 / m_A42; + const double f17_28 = -f17 * m_A85; + m_A95 += m_A43 * f17_28; + RHS28 += f17_28 * RHS17; + const double f18 = 1.0 / m_A48; + const double f18_28 = -f18 * m_A86; + m_A95 += m_A49 * f18_28; + RHS28 += f18_28 * RHS18; + const double f19 = 1.0 / m_A50; + const double f19_25 = -f19 * m_A71; + m_A73 += m_A51 * f19_25; + m_A74 += m_A52 * f19_25; + RHS25 += f19_25 * RHS19; + const double f19_28 = -f19 * m_A87; + m_A92 += m_A51 * f19_28; + m_A95 += m_A52 * f19_28; + RHS28 += f19_28 * RHS19; + const double f20 = 1.0 / m_A55; + const double f20_28 = -f20 * m_A88; + m_A95 += m_A56 * f20_28; + RHS28 += f20_28 * RHS20; + const double f21 = 1.0 / m_A58; + const double f21_28 = -f21 * m_A89; + m_A95 += m_A59 * f21_28; + RHS28 += f21_28 * RHS21; + const double f22 = 1.0 / m_A62; + const double f22_28 = -f22 * m_A90; + m_A95 += m_A63 * f22_28; + RHS28 += f22_28 * RHS22; + const double f23 = 1.0 / m_A65; + const double f23_25 = -f23 * m_A72; + m_A73 += m_A66 * f23_25; + RHS25 += f23_25 * RHS23; + const double f24 = 1.0 / m_A68; + const double f24_28 = -f24 * m_A91; + m_A95 += m_A69 * f24_28; + RHS28 += f24_28 * RHS24; + const double f25 = 1.0 / m_A73; + const double f25_28 = -f25 * m_A92; + m_A95 += m_A74 * f25_28; + RHS28 += f25_28 * RHS25; + const double f26 = 1.0 / m_A76; + const double f26_28 = -f26 * m_A93; + m_A95 += m_A77 * f26_28; + RHS28 += f26_28 * RHS26; + const double f27 = 1.0 / m_A79; + const double f27_28 = -f27 * m_A94; + m_A95 += m_A80 * f27_28; + RHS28 += f27_28 * RHS27; + V[28] = RHS28 / m_A95; + double tmp27 = 0.0; + tmp27 += m_A80 * V[28]; + V[27] = (RHS27 - tmp27) / m_A79; + double tmp26 = 0.0; + tmp26 += m_A77 * V[28]; + V[26] = (RHS26 - tmp26) / m_A76; + double tmp25 = 0.0; + tmp25 += m_A74 * V[28]; + V[25] = (RHS25 - tmp25) / m_A73; + double tmp24 = 0.0; + tmp24 += m_A69 * V[28]; + V[24] = (RHS24 - tmp24) / m_A68; + double tmp23 = 0.0; + tmp23 += m_A66 * V[25]; + V[23] = (RHS23 - tmp23) / m_A65; + double tmp22 = 0.0; + tmp22 += m_A63 * V[28]; + V[22] = (RHS22 - tmp22) / m_A62; + double tmp21 = 0.0; + tmp21 += m_A59 * V[28]; + V[21] = (RHS21 - tmp21) / m_A58; + double tmp20 = 0.0; + tmp20 += m_A56 * V[28]; + V[20] = (RHS20 - tmp20) / m_A55; + double tmp19 = 0.0; + tmp19 += m_A51 * V[25]; + tmp19 += m_A52 * V[28]; + V[19] = (RHS19 - tmp19) / m_A50; + double tmp18 = 0.0; + tmp18 += m_A49 * V[28]; + V[18] = (RHS18 - tmp18) / m_A48; + double tmp17 = 0.0; + tmp17 += m_A43 * V[28]; + V[17] = (RHS17 - tmp17) / m_A42; + double tmp16 = 0.0; + tmp16 += m_A37 * V[28]; + V[16] = (RHS16 - tmp16) / m_A36; + double tmp15 = 0.0; + tmp15 += m_A34 * V[22]; + tmp15 += m_A35 * V[28]; + V[15] = (RHS15 - tmp15) / m_A33; + double tmp14 = 0.0; + tmp14 += m_A32 * V[25]; + V[14] = (RHS14 - tmp14) / m_A31; + double tmp13 = 0.0; + tmp13 += m_A29 * V[20]; + tmp13 += m_A30 * V[28]; + V[13] = (RHS13 - tmp13) / m_A28; + double tmp12 = 0.0; + tmp12 += m_A26 * V[18]; + tmp12 += m_A27 * V[28]; + V[12] = (RHS12 - tmp12) / m_A25; + double tmp11 = 0.0; + tmp11 += m_A23 * V[17]; + tmp11 += m_A24 * V[28]; + 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[24]; + V[9] = (RHS9 - tmp9) / m_A18; + double tmp8 = 0.0; + tmp8 += m_A17 * V[18]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[18]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[22]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[20]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[18]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[17]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[17]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[17]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[21]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // breakout static void nl_gcr_655da76624809228_13_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -8024,6 +18771,509 @@ static void nl_gcr_655da76624809228_13_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// starcas +static void nl_gcr_664ba44cd8c70cf9_65_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A3 += go[0]; + m_A2 += go[1]; + m_A1 += go[2]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A5 += go[5]; + double RHS1 = Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A6 += gt[16]; + m_A10 += go[12]; + m_A9 += go[13]; + m_A8 += go[14]; + m_A7 += go[15]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 += Idr[15]; + RHS2 += Idr[16]; + RHS2 -= go[16] * *cnV[16]; + m_A11 += gt[17]; + m_A11 += gt[18]; + m_A11 += gt[19]; + m_A12 += go[17]; + double RHS3 = Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A13 += gt[20]; + m_A13 += gt[21]; + m_A13 += gt[22]; + m_A13 += gt[23]; + m_A13 += gt[24]; + m_A13 += gt[25]; + m_A14 += go[20]; + m_A15 += go[21]; + m_A16 += go[22]; + m_A16 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 -= go[24] * *cnV[24]; + RHS4 -= go[25] * *cnV[25]; + m_A17 += gt[26]; + m_A17 += gt[27]; + m_A17 += gt[28]; + m_A17 += gt[29]; + m_A19 += go[26]; + m_A18 += go[27]; + double RHS5 = Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[28] * *cnV[28]; + RHS5 -= go[29] * *cnV[29]; + m_A22 += gt[30]; + m_A22 += gt[31]; + m_A22 += gt[32]; + m_A22 += gt[33]; + m_A21 += go[30]; + m_A20 += go[31]; + double RHS6 = Idr[30]; + RHS6 += Idr[31]; + RHS6 += Idr[32]; + RHS6 += Idr[33]; + RHS6 -= go[32] * *cnV[32]; + RHS6 -= go[33] * *cnV[33]; + m_A29 += gt[34]; + m_A29 += gt[35]; + m_A29 += gt[36]; + m_A29 += gt[37]; + m_A27 += go[34]; + m_A26 += go[35]; + double RHS7 = Idr[34]; + RHS7 += Idr[35]; + RHS7 += Idr[36]; + RHS7 += Idr[37]; + RHS7 -= go[36] * *cnV[36]; + RHS7 -= go[37] * *cnV[37]; + m_A36 += gt[38]; + m_A36 += gt[39]; + m_A36 += gt[40]; + m_A36 += gt[41]; + m_A33 += go[38]; + m_A32 += go[39]; + double RHS8 = Idr[38]; + RHS8 += Idr[39]; + RHS8 += Idr[40]; + RHS8 += Idr[41]; + RHS8 -= go[40] * *cnV[40]; + RHS8 -= go[41] * *cnV[41]; + m_A43 += gt[42]; + m_A43 += gt[43]; + m_A43 += gt[44]; + m_A43 += gt[45]; + m_A43 += gt[46]; + m_A38 += go[42]; + m_A44 += go[43]; + m_A39 += go[44]; + double RHS9 = Idr[42]; + RHS9 += Idr[43]; + RHS9 += Idr[44]; + RHS9 += Idr[45]; + RHS9 += Idr[46]; + RHS9 -= go[45] * *cnV[45]; + RHS9 -= go[46] * *cnV[46]; + m_A46 += gt[47]; + m_A46 += gt[48]; + m_A46 += gt[49]; + m_A46 += gt[50]; + m_A46 += gt[51]; + m_A46 += gt[52]; + m_A46 += gt[53]; + m_A45 += go[47]; + m_A47 += go[48]; + double RHS10 = Idr[47]; + RHS10 += Idr[48]; + RHS10 += Idr[49]; + RHS10 += Idr[50]; + RHS10 += Idr[51]; + RHS10 += Idr[52]; + RHS10 += Idr[53]; + RHS10 -= go[49] * *cnV[49]; + RHS10 -= go[50] * *cnV[50]; + RHS10 -= go[51] * *cnV[51]; + RHS10 -= go[52] * *cnV[52]; + RHS10 -= go[53] * *cnV[53]; + m_A51 += gt[54]; + m_A51 += gt[55]; + m_A51 += gt[56]; + m_A49 += go[54]; + m_A48 += go[55]; + double RHS11 = Idr[54]; + RHS11 += Idr[55]; + RHS11 += Idr[56]; + RHS11 -= go[56] * *cnV[56]; + m_A56 += gt[57]; + m_A56 += gt[58]; + m_A54 += go[57]; + double RHS12 = Idr[57]; + RHS12 += Idr[58]; + RHS12 -= go[58] * *cnV[58]; + m_A64 += gt[59]; + m_A64 += gt[60]; + m_A64 += gt[61]; + m_A64 += gt[62]; + m_A59 += go[59]; + m_A59 += go[60]; + m_A58 += go[61]; + m_A60 += go[62]; + double RHS13 = Idr[59]; + RHS13 += Idr[60]; + RHS13 += Idr[61]; + RHS13 += Idr[62]; + const double f0 = 1.0 / m_A0; + const double f0_6 = -f0 * m_A20; + m_A22 += m_A1 * f0_6; + m_A23 += m_A2 * f0_6; + m_A24 += m_A3 * f0_6; + RHS6 += f0_6 * RHS0; + const double f0_7 = -f0 * m_A26; + m_A28 += m_A1 * f0_7; + m_A29 += m_A2 * f0_7; + m_A30 += m_A3 * f0_7; + RHS7 += f0_7 * RHS0; + const double f0_8 = -f0 * m_A32; + m_A34 += m_A1 * f0_8; + m_A35 += m_A2 * f0_8; + m_A36 += m_A3 * f0_8; + RHS8 += f0_8 * RHS0; + const double f1 = 1.0 / m_A4; + const double f1_9 = -f1 * m_A38; + m_A39 += m_A5 * f1_9; + RHS9 += f1_9 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_6 = -f2 * m_A21; + m_A22 += m_A7 * f2_6; + m_A23 += m_A8 * f2_6; + m_A24 += m_A9 * f2_6; + m_A25 += m_A10 * f2_6; + RHS6 += f2_6 * RHS2; + const double f2_7 = -f2 * m_A27; + m_A28 += m_A7 * f2_7; + m_A29 += m_A8 * f2_7; + m_A30 += m_A9 * f2_7; + m_A31 += m_A10 * f2_7; + RHS7 += f2_7 * RHS2; + const double f2_8 = -f2 * m_A33; + m_A34 += m_A7 * f2_8; + m_A35 += m_A8 * f2_8; + m_A36 += m_A9 * f2_8; + m_A37 += m_A10 * f2_8; + RHS8 += f2_8 * RHS2; + const double f2_9 = -f2 * m_A39; + m_A40 += m_A7 * f2_9; + m_A41 += m_A8 * f2_9; + m_A42 += m_A9 * f2_9; + m_A43 += m_A10 * f2_9; + RHS9 += f2_9 * RHS2; + const double f3 = 1.0 / m_A11; + const double f3_10 = -f3 * m_A45; + m_A47 += m_A12 * f3_10; + RHS10 += f3_10 * RHS3; + const double f3_13 = -f3 * m_A58; + m_A64 += m_A12 * f3_13; + RHS13 += f3_13 * RHS3; + const double f4 = 1.0 / m_A13; + const double f4_11 = -f4 * m_A48; + m_A50 += m_A14 * f4_11; + m_A51 += m_A15 * f4_11; + m_A53 += m_A16 * f4_11; + RHS11 += f4_11 * RHS4; + const double f4_13 = -f4 * m_A59; + m_A61 += m_A14 * f4_13; + m_A62 += m_A15 * f4_13; + m_A64 += m_A16 * f4_13; + RHS13 += f4_13 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_11 = -f5 * m_A49; + m_A51 += m_A18 * f5_11; + m_A52 += m_A19 * f5_11; + RHS11 += f5_11 * RHS5; + const double f5_12 = -f5 * m_A54; + m_A55 += m_A18 * f5_12; + m_A56 += m_A19 * f5_12; + RHS12 += f5_12 * RHS5; + const double f6 = 1.0 / m_A22; + const double f6_7 = -f6 * m_A28; + m_A29 += m_A23 * f6_7; + m_A30 += m_A24 * f6_7; + m_A31 += m_A25 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_8 = -f6 * m_A34; + m_A35 += m_A23 * f6_8; + m_A36 += m_A24 * f6_8; + m_A37 += m_A25 * f6_8; + RHS8 += f6_8 * RHS6; + const double f6_9 = -f6 * m_A40; + m_A41 += m_A23 * f6_9; + m_A42 += m_A24 * f6_9; + m_A43 += m_A25 * f6_9; + RHS9 += f6_9 * RHS6; + const double f7 = 1.0 / m_A29; + const double f7_8 = -f7 * m_A35; + m_A36 += m_A30 * f7_8; + m_A37 += m_A31 * f7_8; + RHS8 += f7_8 * RHS7; + const double f7_9 = -f7 * m_A41; + m_A42 += m_A30 * f7_9; + m_A43 += m_A31 * f7_9; + RHS9 += f7_9 * RHS7; + const double f8 = 1.0 / m_A36; + const double f8_9 = -f8 * m_A42; + m_A43 += m_A37 * f8_9; + RHS9 += f8_9 * RHS8; + const double f9 = 1.0 / m_A43; + const double f9_13 = -f9 * m_A60; + m_A64 += m_A44 * f9_13; + RHS13 += f9_13 * RHS9; + const double f10 = 1.0 / m_A46; + const double f10_11 = -f10 * m_A50; + m_A53 += m_A47 * f10_11; + RHS11 += f10_11 * RHS10; + const double f10_13 = -f10 * m_A61; + m_A64 += m_A47 * f10_13; + RHS13 += f10_13 * RHS10; + const double f11 = 1.0 / m_A51; + const double f11_12 = -f11 * m_A55; + m_A56 += m_A52 * f11_12; + m_A57 += m_A53 * f11_12; + RHS12 += f11_12 * RHS11; + const double f11_13 = -f11 * m_A62; + m_A63 += m_A52 * f11_13; + m_A64 += m_A53 * f11_13; + RHS13 += f11_13 * RHS11; + const double f12 = 1.0 / m_A56; + const double f12_13 = -f12 * m_A63; + m_A64 += m_A57 * f12_13; + RHS13 += f12_13 * RHS12; + V[13] = RHS13 / m_A64; + double tmp12 = 0.0; + tmp12 += m_A57 * V[13]; + V[12] = (RHS12 - tmp12) / m_A56; + double tmp11 = 0.0; + tmp11 += m_A52 * V[12]; + tmp11 += m_A53 * V[13]; + V[11] = (RHS11 - tmp11) / m_A51; + double tmp10 = 0.0; + tmp10 += m_A47 * V[13]; + V[10] = (RHS10 - tmp10) / m_A46; + double tmp9 = 0.0; + tmp9 += m_A44 * V[13]; + V[9] = (RHS9 - tmp9) / m_A43; + double tmp8 = 0.0; + tmp8 += m_A37 * V[9]; + V[8] = (RHS8 - tmp8) / m_A36; + double tmp7 = 0.0; + tmp7 += m_A30 * V[8]; + tmp7 += m_A31 * V[9]; + V[7] = (RHS7 - tmp7) / m_A29; + double tmp6 = 0.0; + tmp6 += m_A23 * V[7]; + tmp6 += m_A24 * V[8]; + tmp6 += m_A25 * V[9]; + V[6] = (RHS6 - tmp6) / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[11]; + tmp5 += m_A19 * V[12]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A14 * V[10]; + tmp4 += m_A15 * V[11]; + tmp4 += m_A16 * V[13]; + V[4] = (RHS4 - tmp4) / m_A13; + double tmp3 = 0.0; + tmp3 += m_A12 * V[13]; + V[3] = (RHS3 - tmp3) / m_A11; + double tmp2 = 0.0; + tmp2 += m_A7 * V[6]; + tmp2 += m_A8 * V[7]; + tmp2 += m_A9 * V[8]; + tmp2 += m_A10 * V[9]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A5 * V[2]; + V[1] = (RHS1 - tmp1) / m_A4; + double tmp0 = 0.0; + tmp0 += m_A1 * V[6]; + tmp0 += m_A2 * V[7]; + tmp0 += m_A3 * V[8]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// speedfrk +static void nl_gcr_6c412ad13dc3d34a_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A5 += go[7]; + m_A5 += go[8]; + m_A4 += go[9]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[10] * *cnV[10]; + RHS2 -= 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; +} + // cheekyms static void nl_gcr_6d03e64d09c956c3_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -8186,6 +19436,195 @@ static void nl_gcr_6e17dfd7d26d8933_13_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// warrior +static void nl_gcr_6e2b4deaa89a5c3d_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + m_A5 += gt[5]; + m_A5 += gt[6]; + m_A5 += gt[7]; + m_A6 += go[5]; + m_A4 += go[6]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[7] * *cnV[7]; + m_A9 += gt[8]; + m_A9 += gt[9]; + m_A7 += go[8]; + m_A8 += go[9]; + double RHS3 = Idr[8]; + RHS3 += Idr[9]; + 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; +} + +// spacewar +static void nl_gcr_7061d322af649081_20_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + m_A4 += go[3]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + m_A5 += gt[4]; + m_A5 += gt[5]; + m_A7 += go[4]; + m_A6 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + m_A9 += gt[6]; + m_A9 += gt[7]; + m_A9 += gt[8]; + m_A8 += go[6]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + RHS3 += Idr[8]; + RHS3 -= go[7] * *cnV[7]; + RHS3 -= go[8] * *cnV[8]; + m_A15 += gt[9]; + m_A15 += gt[10]; + m_A15 += gt[11]; + m_A11 += go[9]; + m_A13 += go[10]; + m_A12 += go[11]; + double RHS4 = Idr[9]; + RHS4 += Idr[10]; + RHS4 += Idr[11]; + m_A19 += gt[12]; + m_A19 += gt[13]; + m_A19 += gt[14]; + m_A17 += go[12]; + double RHS5 = Idr[12]; + RHS5 += Idr[13]; + RHS5 += Idr[14]; + RHS5 -= go[13] * *cnV[13]; + RHS5 -= go[14] * *cnV[14]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A11; + m_A15 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A8; + m_A9 += m_A3 * f1_3; + m_A10 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_4 = -f1 * m_A12; + m_A14 += m_A3 * f1_4; + m_A15 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A13; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A17; + m_A18 += m_A6 * f2_5; + m_A19 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A9; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; + const double f4 = 1.0 / m_A15; + const double f4_5 = -f4 * m_A18; + m_A19 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A19; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + double tmp3 = 0.0; + tmp3 += m_A10 * V[4]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + 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[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // gamemachine static void nl_gcr_70c1124c705dd998_19_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -8386,6 +19825,271 @@ static void nl_gcr_70f289d5486b9767_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// barrier +static void nl_gcr_7141c51f842cc0f3_15_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A4 += go[2]; + m_A3 += go[3]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + m_A5 += gt[4]; + m_A5 += gt[5]; + m_A5 += gt[6]; + m_A6 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 -= go[5] * *cnV[5]; + RHS2 -= go[6] * *cnV[6]; + m_A9 += gt[7]; + m_A9 += gt[8]; + m_A7 += go[7]; + m_A8 += go[8]; + double RHS3 = Idr[7]; + RHS3 += Idr[8]; + m_A14 += gt[9]; + m_A14 += gt[10]; + m_A12 += go[9]; + m_A11 += go[10]; + double RHS4 = Idr[9]; + RHS4 += Idr[10]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A7; + m_A9 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A8; + m_A9 += m_A3 * f1_3; + m_A10 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_4 = -f1 * m_A11; + m_A13 += m_A3 * f1_4; + m_A14 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A12; + m_A14 += m_A6 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A9; + const double f3_4 = -f3 * m_A13; + m_A14 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A14; + double tmp3 = 0.0; + tmp3 += m_A10 * V[4]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// boxingb +static void nl_gcr_723c47314fec281a_22_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A3 += go[5]; + double RHS1 = Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[6] * *cnV[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A4 += gt[14]; + m_A7 += go[7]; + m_A6 += go[8]; + m_A6 += go[9]; + m_A5 += go[10]; + m_A5 += go[11]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 -= go[12] * *cnV[12]; + RHS2 -= go[13] * *cnV[13]; + RHS2 -= go[14] * *cnV[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A8 += go[15]; + m_A9 += go[16]; + m_A9 += go[17]; + double RHS3 = Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A16 += go[20]; + m_A16 += go[21]; + m_A13 += go[22]; + m_A13 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[24] * *cnV[24]; + m_A21 += gt[25]; + m_A21 += gt[26]; + m_A21 += gt[27]; + m_A21 += gt[28]; + m_A21 += gt[29]; + m_A20 += go[25]; + m_A20 += go[26]; + m_A18 += go[27]; + m_A17 += go[28]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[29] * *cnV[29]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A17; + m_A21 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A5 * f2_3; + m_A11 += m_A6 * f2_3; + m_A12 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A13; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A18; + m_A19 += m_A5 * f2_5; + m_A20 += m_A6 * f2_5; + m_A21 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += 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_A15; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A21; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + 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_A5 * V[3]; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // zac1b11142 static void nl_gcr_752680f8e0bc6a4a_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -8457,6 +20161,298 @@ static void nl_gcr_752680f8e0bc6a4a_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// warrior +static void nl_gcr_76c41027f9d21f75_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + m_A6 += gt[3]; + m_A6 += gt[4]; + m_A5 += go[3]; + m_A4 += go[4]; + double RHS2 = Idr[3]; + RHS2 += Idr[4]; + 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; +} + +// ripoff +static void nl_gcr_7a3d44a216e9c392_35_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A3 += go[0]; + m_A2 += go[1]; + m_A1 += go[2]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A5 += go[5]; + double RHS1 = Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A6 += gt[16]; + m_A10 += go[12]; + m_A9 += go[13]; + m_A8 += go[14]; + m_A7 += go[15]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 += Idr[15]; + RHS2 += Idr[16]; + RHS2 -= go[16] * *cnV[16]; + m_A13 += gt[17]; + m_A13 += gt[18]; + m_A13 += gt[19]; + m_A13 += gt[20]; + m_A12 += go[17]; + m_A11 += go[18]; + double RHS3 = Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 += Idr[20]; + RHS3 -= go[19] * *cnV[19]; + RHS3 -= go[20] * *cnV[20]; + m_A20 += gt[21]; + m_A20 += gt[22]; + m_A20 += gt[23]; + m_A20 += gt[24]; + m_A18 += go[21]; + m_A17 += go[22]; + double RHS4 = Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[23] * *cnV[23]; + RHS4 -= go[24] * *cnV[24]; + m_A27 += gt[25]; + m_A27 += gt[26]; + m_A27 += gt[27]; + m_A27 += gt[28]; + m_A24 += go[25]; + m_A23 += go[26]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 -= go[27] * *cnV[27]; + RHS5 -= go[28] * *cnV[28]; + m_A34 += gt[29]; + m_A34 += gt[30]; + m_A34 += gt[31]; + m_A34 += gt[32]; + m_A34 += gt[33]; + m_A34 += gt[34]; + m_A29 += go[29]; + m_A30 += go[30]; + double RHS6 = Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + RHS6 += Idr[32]; + RHS6 += Idr[33]; + RHS6 += Idr[34]; + RHS6 -= go[31] * *cnV[31]; + RHS6 -= go[32] * *cnV[32]; + RHS6 -= go[33] * *cnV[33]; + RHS6 -= go[34] * *cnV[34]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A11; + m_A13 += m_A1 * f0_3; + m_A14 += m_A2 * f0_3; + m_A15 += m_A3 * f0_3; + RHS3 += f0_3 * RHS0; + const double f0_4 = -f0 * m_A17; + m_A19 += m_A1 * f0_4; + m_A20 += m_A2 * f0_4; + m_A21 += m_A3 * f0_4; + RHS4 += f0_4 * RHS0; + const double f0_5 = -f0 * m_A23; + m_A25 += m_A1 * f0_5; + m_A26 += m_A2 * f0_5; + m_A27 += m_A3 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A4; + const double f1_6 = -f1 * m_A29; + m_A30 += m_A5 * f1_6; + RHS6 += f1_6 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_3 = -f2 * m_A12; + m_A13 += m_A7 * f2_3; + m_A14 += m_A8 * f2_3; + m_A15 += m_A9 * f2_3; + m_A16 += m_A10 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A18; + m_A19 += m_A7 * f2_4; + m_A20 += m_A8 * f2_4; + m_A21 += m_A9 * f2_4; + m_A22 += m_A10 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A24; + m_A25 += m_A7 * f2_5; + m_A26 += m_A8 * f2_5; + m_A27 += m_A9 * f2_5; + m_A28 += m_A10 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A30; + m_A31 += m_A7 * f2_6; + m_A32 += m_A8 * f2_6; + m_A33 += m_A9 * f2_6; + m_A34 += m_A10 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A13; + const double f3_4 = -f3 * m_A19; + m_A20 += m_A14 * f3_4; + m_A21 += m_A15 * f3_4; + m_A22 += m_A16 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_5 = -f3 * m_A25; + m_A26 += m_A14 * f3_5; + m_A27 += m_A15 * f3_5; + m_A28 += m_A16 * f3_5; + RHS5 += f3_5 * RHS3; + const double f3_6 = -f3 * m_A31; + m_A32 += m_A14 * f3_6; + m_A33 += m_A15 * f3_6; + m_A34 += m_A16 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A20; + const double f4_5 = -f4 * m_A26; + m_A27 += m_A21 * f4_5; + m_A28 += m_A22 * f4_5; + RHS5 += f4_5 * RHS4; + const double f4_6 = -f4 * m_A32; + m_A33 += m_A21 * f4_6; + m_A34 += m_A22 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A27; + const double f5_6 = -f5 * m_A33; + m_A34 += m_A28 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A34; + double tmp5 = 0.0; + tmp5 += m_A28 * V[6]; + V[5] = (RHS5 - tmp5) / m_A27; + double tmp4 = 0.0; + tmp4 += m_A21 * V[5]; + tmp4 += m_A22 * V[6]; + V[4] = (RHS4 - tmp4) / m_A20; + double tmp3 = 0.0; + tmp3 += m_A14 * V[4]; + tmp3 += m_A15 * V[5]; + tmp3 += m_A16 * V[6]; + V[3] = (RHS3 - tmp3) / m_A13; + double tmp2 = 0.0; + tmp2 += m_A7 * V[3]; + tmp2 += m_A8 * V[4]; + tmp2 += m_A9 * V[5]; + tmp2 += m_A10 * V[6]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A5 * V[2]; + V[1] = (RHS1 - tmp1) / m_A4; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + tmp0 += m_A2 * V[4]; + tmp0 += m_A3 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // mario static void nl_gcr_7b9186d9ff77f7a1_29_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -8673,6 +20669,119 @@ static void nl_gcr_7b9186d9ff77f7a1_29_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb +static void nl_gcr_7d34f6e8c60fa024_16_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + m_A7 += gt[10]; + m_A7 += gt[11]; + m_A6 += go[10]; + m_A8 += go[11]; + double RHS3 = Idr[10]; + RHS3 += Idr[11]; + m_A10 += gt[12]; + m_A10 += gt[13]; + m_A9 += go[12]; + m_A11 += go[13]; + double RHS4 = Idr[12]; + RHS4 += Idr[13]; + m_A15 += gt[14]; + m_A15 += gt[15]; + m_A15 += gt[16]; + m_A15 += gt[17]; + m_A13 += go[14]; + m_A14 += go[15]; + m_A12 += go[16]; + double RHS5 = Idr[14]; + RHS5 += Idr[15]; + RHS5 += Idr[16]; + RHS5 += Idr[17]; + RHS5 -= go[17] * *cnV[17]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A12; + m_A15 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A6; + m_A7 += m_A3 * f1_3; + RHS3 += f1_3 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A9; + m_A10 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A7; + const double f3_5 = -f3 * m_A13; + m_A15 += m_A8 * f3_5; + RHS5 += f3_5 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_5 = -f4 * m_A14; + m_A15 += m_A11 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A15; + double tmp4 = 0.0; + tmp4 += m_A11 * V[5]; + 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_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // cheekyms static void nl_gcr_7e9498276980e5d1_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -8759,6 +20868,671 @@ static void nl_gcr_7e9498276980e5d1_12_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// starcas +static void nl_gcr_7f1603acd40cf2f3_62_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[9]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + RHS3 += Idr[11]; + RHS3 -= go[10] * *cnV[10]; + RHS3 -= go[11] * *cnV[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A9 += go[12]; + double RHS4 = Idr[12]; + RHS4 += Idr[13]; + RHS4 += Idr[14]; + RHS4 -= go[13] * *cnV[13]; + RHS4 -= go[14] * *cnV[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A11 += go[15]; + double RHS5 = Idr[15]; + RHS5 += Idr[16]; + RHS5 += Idr[17]; + RHS5 -= go[16] * *cnV[16]; + RHS5 -= go[17] * *cnV[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A13 += go[18]; + double RHS6 = Idr[18]; + RHS6 += Idr[19]; + RHS6 -= go[19] * *cnV[19]; + m_A14 += gt[20]; + m_A14 += gt[21]; + m_A16 += go[20]; + m_A15 += go[21]; + double RHS7 = Idr[20]; + RHS7 += Idr[21]; + m_A17 += gt[22]; + m_A17 += gt[23]; + m_A19 += go[22]; + m_A18 += go[23]; + double RHS8 = Idr[22]; + RHS8 += Idr[23]; + m_A20 += gt[24]; + m_A20 += gt[25]; + m_A21 += go[24]; + double RHS9 = Idr[24]; + RHS9 += Idr[25]; + RHS9 -= go[25] * *cnV[25]; + m_A23 += gt[26]; + m_A23 += gt[27]; + m_A23 += gt[28]; + m_A23 += gt[29]; + m_A23 += gt[30]; + m_A23 += gt[31]; + m_A23 += gt[32]; + m_A22 += go[26]; + m_A24 += go[27]; + double RHS10 = Idr[26]; + RHS10 += Idr[27]; + RHS10 += Idr[28]; + RHS10 += Idr[29]; + RHS10 += Idr[30]; + RHS10 += Idr[31]; + RHS10 += Idr[32]; + RHS10 -= go[28] * *cnV[28]; + RHS10 -= go[29] * *cnV[29]; + RHS10 -= go[30] * *cnV[30]; + RHS10 -= go[31] * *cnV[31]; + RHS10 -= go[32] * *cnV[32]; + m_A25 += gt[33]; + m_A25 += gt[34]; + m_A25 += gt[35]; + m_A25 += gt[36]; + m_A25 += gt[37]; + m_A25 += gt[38]; + m_A25 += gt[39]; + m_A26 += go[33]; + double RHS11 = Idr[33]; + RHS11 += Idr[34]; + RHS11 += Idr[35]; + RHS11 += Idr[36]; + RHS11 += Idr[37]; + RHS11 += Idr[38]; + RHS11 += Idr[39]; + RHS11 -= go[34] * *cnV[34]; + RHS11 -= go[35] * *cnV[35]; + RHS11 -= go[36] * *cnV[36]; + RHS11 -= go[37] * *cnV[37]; + RHS11 -= go[38] * *cnV[38]; + RHS11 -= go[39] * *cnV[39]; + m_A30 += gt[40]; + m_A30 += gt[41]; + m_A30 += gt[42]; + m_A30 += gt[43]; + m_A29 += go[40]; + m_A28 += go[41]; + m_A27 += go[42]; + double RHS12 = Idr[40]; + RHS12 += Idr[41]; + RHS12 += Idr[42]; + RHS12 += Idr[43]; + RHS12 -= go[43] * *cnV[43]; + m_A32 += gt[44]; + m_A32 += gt[45]; + m_A33 += go[44]; + m_A34 += go[45]; + double RHS13 = Idr[44]; + RHS13 += Idr[45]; + m_A36 += gt[46]; + m_A36 += gt[47]; + m_A35 += go[46]; + m_A37 += go[47]; + double RHS14 = Idr[46]; + RHS14 += Idr[47]; + m_A42 += gt[48]; + m_A42 += gt[49]; + m_A42 += gt[50]; + m_A42 += gt[51]; + m_A42 += gt[52]; + m_A41 += go[48]; + m_A40 += go[49]; + m_A39 += go[50]; + m_A38 += go[51]; + double RHS15 = Idr[48]; + RHS15 += Idr[49]; + RHS15 += Idr[50]; + RHS15 += Idr[51]; + RHS15 += Idr[52]; + RHS15 -= go[52] * *cnV[52]; + m_A46 += gt[53]; + m_A46 += gt[54]; + m_A46 += gt[55]; + m_A46 += gt[56]; + m_A46 += gt[57]; + m_A45 += go[53]; + m_A44 += go[54]; + m_A47 += go[55]; + double RHS16 = Idr[53]; + RHS16 += Idr[54]; + RHS16 += Idr[55]; + RHS16 += Idr[56]; + RHS16 += Idr[57]; + RHS16 -= go[56] * *cnV[56]; + RHS16 -= go[57] * *cnV[57]; + m_A51 += gt[58]; + m_A51 += gt[59]; + m_A51 += gt[60]; + m_A51 += gt[61]; + m_A51 += gt[62]; + m_A49 += go[58]; + m_A48 += go[59]; + m_A50 += go[60]; + double RHS17 = Idr[58]; + RHS17 += Idr[59]; + RHS17 += Idr[60]; + RHS17 += Idr[61]; + RHS17 += Idr[62]; + RHS17 -= go[61] * *cnV[61]; + RHS17 -= go[62] * *cnV[62]; + m_A61 += gt[63]; + m_A61 += gt[64]; + m_A61 += gt[65]; + m_A61 += gt[66]; + m_A61 += gt[67]; + m_A61 += gt[68]; + m_A59 += go[63]; + m_A56 += go[64]; + m_A57 += go[65]; + m_A54 += go[66]; + m_A53 += go[67]; + double RHS18 = Idr[63]; + RHS18 += Idr[64]; + RHS18 += Idr[65]; + RHS18 += Idr[66]; + RHS18 += Idr[67]; + RHS18 += Idr[68]; + RHS18 -= go[68] * *cnV[68]; + const double f0 = 1.0 / m_A0; + const double f0_12 = -f0 * m_A27; + m_A30 += m_A1 * f0_12; + RHS12 += f0_12 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_12 = -f1 * m_A28; + m_A30 += m_A3 * f1_12; + RHS12 += f1_12 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_15 = -f2 * m_A38; + m_A42 += m_A5 * f2_15; + RHS15 += f2_15 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_15 = -f3 * m_A39; + m_A42 += m_A7 * f3_15; + RHS15 += f3_15 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_15 = -f4 * m_A40; + m_A42 += m_A9 * f4_15; + RHS15 += f4_15 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_14 = -f5 * m_A35; + m_A36 += m_A11 * f5_14; + RHS14 += f5_14 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_10 = -f6 * m_A22; + m_A24 += m_A13 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_17 = -f6 * m_A48; + m_A51 += m_A13 * f6_17; + RHS17 += f6_17 * RHS6; + const double f7 = 1.0 / m_A14; + const double f7_12 = -f7 * m_A29; + m_A30 += m_A15 * f7_12; + m_A31 += m_A16 * f7_12; + RHS12 += f7_12 * RHS7; + const double f7_18 = -f7 * m_A53; + m_A55 += m_A15 * f7_18; + m_A61 += m_A16 * f7_18; + RHS18 += f7_18 * RHS7; + const double f8 = 1.0 / m_A17; + const double f8_15 = -f8 * m_A41; + m_A42 += m_A18 * f8_15; + m_A43 += m_A19 * f8_15; + RHS15 += f8_15 * RHS8; + const double f8_18 = -f8 * m_A54; + m_A58 += m_A18 * f8_18; + m_A61 += m_A19 * f8_18; + RHS18 += f8_18 * RHS8; + const double f9 = 1.0 / m_A20; + const double f9_16 = -f9 * m_A44; + m_A46 += m_A21 * f9_16; + RHS16 += f9_16 * RHS9; + const double f10 = 1.0 / m_A23; + const double f10_17 = -f10 * m_A49; + m_A51 += m_A24 * f10_17; + RHS17 += f10_17 * RHS10; + const double f11 = 1.0 / m_A25; + const double f11_16 = -f11 * m_A45; + m_A47 += m_A26 * f11_16; + RHS16 += f11_16 * RHS11; + const double f12 = 1.0 / m_A30; + const double f12_18 = -f12 * m_A55; + m_A61 += m_A31 * f12_18; + RHS18 += f12_18 * RHS12; + const double f13 = 1.0 / m_A32; + const double f13_17 = -f13 * m_A50; + m_A51 += m_A33 * f13_17; + m_A52 += m_A34 * f13_17; + RHS17 += f13_17 * RHS13; + const double f13_18 = -f13 * m_A56; + m_A60 += m_A33 * f13_18; + m_A61 += m_A34 * f13_18; + RHS18 += f13_18 * RHS13; + const double f14 = 1.0 / m_A36; + const double f14_18 = -f14 * m_A57; + m_A61 += m_A37 * f14_18; + RHS18 += f14_18 * RHS14; + const double f15 = 1.0 / m_A42; + const double f15_18 = -f15 * m_A58; + m_A61 += m_A43 * f15_18; + RHS18 += f15_18 * RHS15; + const double f16 = 1.0 / m_A46; + const double f16_18 = -f16 * m_A59; + m_A61 += m_A47 * f16_18; + RHS18 += f16_18 * RHS16; + const double f17 = 1.0 / m_A51; + const double f17_18 = -f17 * m_A60; + m_A61 += m_A52 * f17_18; + RHS18 += f17_18 * RHS17; + V[18] = RHS18 / m_A61; + double tmp17 = 0.0; + tmp17 += m_A52 * V[18]; + V[17] = (RHS17 - tmp17) / m_A51; + double tmp16 = 0.0; + tmp16 += m_A47 * V[18]; + V[16] = (RHS16 - tmp16) / m_A46; + double tmp15 = 0.0; + tmp15 += m_A43 * V[18]; + V[15] = (RHS15 - tmp15) / m_A42; + double tmp14 = 0.0; + tmp14 += m_A37 * V[18]; + V[14] = (RHS14 - tmp14) / m_A36; + double tmp13 = 0.0; + tmp13 += m_A33 * V[17]; + tmp13 += m_A34 * V[18]; + V[13] = (RHS13 - tmp13) / m_A32; + double tmp12 = 0.0; + tmp12 += m_A31 * V[18]; + V[12] = (RHS12 - tmp12) / m_A30; + double tmp11 = 0.0; + tmp11 += m_A26 * V[18]; + V[11] = (RHS11 - tmp11) / m_A25; + double tmp10 = 0.0; + tmp10 += m_A24 * V[17]; + V[10] = (RHS10 - tmp10) / m_A23; + double tmp9 = 0.0; + tmp9 += m_A21 * V[16]; + V[9] = (RHS9 - tmp9) / m_A20; + double tmp8 = 0.0; + tmp8 += m_A18 * V[15]; + tmp8 += m_A19 * V[18]; + V[8] = (RHS8 - tmp8) / m_A17; + double tmp7 = 0.0; + tmp7 += m_A15 * V[12]; + tmp7 += m_A16 * V[18]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[17]; + 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[15]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[15]; + 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[12]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[12]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// tailg +static void nl_gcr_7f7006e00be779c9_31_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A0 += gt[6]; + m_A0 += gt[7]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 += Idr[6]; + RHS0 += Idr[7]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + RHS0 -= go[5] * *cnV[5]; + RHS0 -= go[6] * *cnV[6]; + RHS0 -= go[7] * *cnV[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A3 += go[8]; + double RHS1 = Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A5 += go[11]; + double RHS2 = Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[12] * *cnV[12]; + RHS2 -= go[13] * *cnV[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A6 += gt[16]; + m_A7 += go[14]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 -= go[15] * *cnV[15]; + RHS3 -= go[16] * *cnV[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A8 += gt[19]; + m_A9 += go[17]; + double RHS4 = Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 -= go[18] * *cnV[18]; + RHS4 -= go[19] * *cnV[19]; + m_A10 += gt[20]; + m_A10 += gt[21]; + m_A10 += gt[22]; + m_A11 += go[20]; + double RHS5 = Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + m_A12 += gt[23]; + m_A12 += gt[24]; + m_A12 += gt[25]; + m_A13 += go[23]; + double RHS6 = Idr[23]; + RHS6 += Idr[24]; + RHS6 += Idr[25]; + RHS6 -= go[24] * *cnV[24]; + RHS6 -= go[25] * *cnV[25]; + m_A14 += gt[26]; + m_A14 += gt[27]; + m_A14 += gt[28]; + m_A15 += go[26]; + double RHS7 = Idr[26]; + RHS7 += Idr[27]; + RHS7 += Idr[28]; + RHS7 -= go[27] * *cnV[27]; + RHS7 -= go[28] * *cnV[28]; + m_A16 += gt[29]; + m_A16 += gt[30]; + m_A16 += gt[31]; + m_A17 += go[29]; + double RHS8 = Idr[29]; + RHS8 += Idr[30]; + RHS8 += Idr[31]; + RHS8 -= go[30] * *cnV[30]; + RHS8 -= go[31] * *cnV[31]; + m_A19 += gt[32]; + m_A19 += gt[33]; + m_A20 += go[32]; + m_A18 += go[33]; + double RHS9 = Idr[32]; + RHS9 += Idr[33]; + m_A30 += gt[34]; + m_A30 += gt[35]; + m_A30 += gt[36]; + m_A30 += gt[37]; + m_A30 += gt[38]; + m_A30 += gt[39]; + m_A30 += gt[40]; + m_A30 += gt[41]; + m_A30 += gt[42]; + m_A30 += gt[43]; + m_A28 += go[34]; + m_A27 += go[35]; + m_A26 += go[36]; + m_A25 += go[37]; + m_A29 += go[38]; + m_A24 += go[39]; + m_A23 += go[40]; + m_A22 += go[41]; + m_A21 += go[42]; + double RHS10 = Idr[34]; + RHS10 += Idr[35]; + RHS10 += Idr[36]; + RHS10 += Idr[37]; + RHS10 += Idr[38]; + RHS10 += Idr[39]; + RHS10 += Idr[40]; + RHS10 += Idr[41]; + RHS10 += Idr[42]; + RHS10 += Idr[43]; + RHS10 -= go[43] * *cnV[43]; + const double f0 = 1.0 / m_A0; + const double f0_9 = -f0 * m_A18; + m_A19 += m_A1 * f0_9; + RHS9 += f0_9 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_10 = -f1 * m_A21; + m_A30 += m_A3 * f1_10; + RHS10 += f1_10 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_10 = -f2 * m_A22; + m_A30 += m_A5 * f2_10; + RHS10 += f2_10 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_10 = -f3 * m_A23; + m_A30 += m_A7 * f3_10; + RHS10 += f3_10 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_10 = -f4 * m_A24; + m_A30 += m_A9 * f4_10; + RHS10 += f4_10 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_10 = -f5 * m_A25; + m_A30 += m_A11 * f5_10; + RHS10 += f5_10 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_10 = -f6 * m_A26; + m_A30 += m_A13 * f6_10; + RHS10 += f6_10 * RHS6; + const double f7 = 1.0 / m_A14; + const double f7_10 = -f7 * m_A27; + m_A30 += m_A15 * f7_10; + RHS10 += f7_10 * RHS7; + const double f8 = 1.0 / m_A16; + const double f8_10 = -f8 * m_A28; + m_A30 += m_A17 * f8_10; + RHS10 += f8_10 * RHS8; + const double f9 = 1.0 / m_A19; + const double f9_10 = -f9 * m_A29; + m_A30 += m_A20 * f9_10; + RHS10 += f9_10 * RHS9; + V[10] = RHS10 / m_A30; + double tmp9 = 0.0; + tmp9 += m_A20 * V[10]; + V[9] = (RHS9 - tmp9) / m_A19; + double tmp8 = 0.0; + tmp8 += m_A17 * V[10]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[10]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[10]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[10]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[10]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[10]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[10]; + 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[9]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_80d7c219807268a_24_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -9169,6 +21943,72 @@ static void nl_gcr_81ae080c83dcf6a4_35_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// ripoff +static void nl_gcr_83e8e76f05758538_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A5 += gt[4]; + m_A5 += gt[5]; + m_A5 += gt[6]; + m_A6 += go[4]; + m_A4 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 -= go[6] * *cnV[6]; + m_A9 += gt[7]; + m_A9 += gt[8]; + m_A7 += go[7]; + m_A8 += go[8]; + double RHS3 = Idr[7]; + RHS3 += Idr[8]; + 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; +} + // tp1985 static void nl_gcr_83fbe835263b28d3_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -9225,6 +22065,840 @@ static void nl_gcr_83fbe835263b28d3_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// ripoff +static void nl_gcr_8453c28c203b8bda_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A4 += go[2]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A7 += go[6]; + m_A7 += go[7]; + m_A5 += go[8]; + m_A5 += go[9]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[10] * *cnV[10]; + m_A11 += gt[11]; + m_A11 += gt[12]; + m_A11 += gt[13]; + m_A11 += gt[14]; + m_A11 += gt[15]; + m_A10 += go[11]; + m_A10 += go[12]; + m_A9 += go[13]; + m_A8 += go[14]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[15] * *cnV[15]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A11 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + m_A7 += 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_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_A3 * V[2]; + tmp1 += m_A4 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// armora +static void nl_gcr_8a86fa6a6301c07d_56_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[9]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + RHS3 += Idr[11]; + RHS3 -= go[10] * *cnV[10]; + RHS3 -= go[11] * *cnV[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A8 += gt[19]; + m_A8 += gt[20]; + m_A8 += gt[21]; + m_A9 += go[12]; + double RHS4 = Idr[12]; + RHS4 += Idr[13]; + RHS4 += Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 -= go[13] * *cnV[13]; + RHS4 -= go[14] * *cnV[14]; + RHS4 -= go[15] * *cnV[15]; + RHS4 -= go[16] * *cnV[16]; + RHS4 -= go[17] * *cnV[17]; + RHS4 -= go[18] * *cnV[18]; + RHS4 -= go[19] * *cnV[19]; + RHS4 -= go[20] * *cnV[20]; + RHS4 -= go[21] * *cnV[21]; + m_A10 += gt[22]; + m_A10 += gt[23]; + m_A11 += go[22]; + double RHS5 = Idr[22]; + RHS5 += Idr[23]; + RHS5 -= go[23] * *cnV[23]; + m_A12 += gt[24]; + m_A12 += gt[25]; + m_A14 += go[24]; + m_A13 += go[25]; + double RHS6 = Idr[24]; + RHS6 += Idr[25]; + m_A15 += gt[26]; + m_A15 += gt[27]; + m_A17 += go[26]; + m_A16 += go[27]; + double RHS7 = Idr[26]; + RHS7 += Idr[27]; + m_A18 += gt[28]; + m_A18 += gt[29]; + m_A20 += go[28]; + m_A19 += go[29]; + double RHS8 = Idr[28]; + RHS8 += Idr[29]; + m_A21 += gt[30]; + m_A21 += gt[31]; + m_A21 += gt[32]; + m_A21 += gt[33]; + m_A21 += gt[34]; + m_A21 += gt[35]; + m_A21 += gt[36]; + m_A22 += go[30]; + double RHS9 = Idr[30]; + RHS9 += Idr[31]; + RHS9 += Idr[32]; + RHS9 += Idr[33]; + RHS9 += Idr[34]; + RHS9 += Idr[35]; + RHS9 += Idr[36]; + RHS9 -= go[31] * *cnV[31]; + RHS9 -= go[32] * *cnV[32]; + RHS9 -= go[33] * *cnV[33]; + RHS9 -= go[34] * *cnV[34]; + RHS9 -= go[35] * *cnV[35]; + RHS9 -= go[36] * *cnV[36]; + m_A25 += gt[37]; + m_A25 += gt[38]; + m_A25 += gt[39]; + m_A24 += go[37]; + m_A23 += go[38]; + double RHS10 = Idr[37]; + RHS10 += Idr[38]; + RHS10 += Idr[39]; + RHS10 -= go[39] * *cnV[39]; + m_A28 += gt[40]; + m_A28 += gt[41]; + m_A28 += gt[42]; + m_A28 += gt[43]; + m_A28 += gt[44]; + m_A28 += gt[45]; + m_A28 += gt[46]; + m_A29 += go[40]; + m_A27 += go[41]; + double RHS11 = Idr[40]; + RHS11 += Idr[41]; + RHS11 += Idr[42]; + RHS11 += Idr[43]; + RHS11 += Idr[44]; + RHS11 += Idr[45]; + RHS11 += Idr[46]; + RHS11 -= go[42] * *cnV[42]; + RHS11 -= go[43] * *cnV[43]; + RHS11 -= go[44] * *cnV[44]; + RHS11 -= go[45] * *cnV[45]; + RHS11 -= go[46] * *cnV[46]; + m_A31 += gt[47]; + m_A31 += gt[48]; + m_A32 += go[47]; + m_A30 += go[48]; + double RHS12 = Idr[47]; + RHS12 += Idr[48]; + m_A37 += gt[49]; + m_A37 += gt[50]; + m_A37 += gt[51]; + m_A37 += gt[52]; + m_A37 += gt[53]; + m_A36 += go[49]; + m_A35 += go[50]; + m_A34 += go[51]; + m_A33 += go[52]; + double RHS13 = Idr[49]; + RHS13 += Idr[50]; + RHS13 += Idr[51]; + RHS13 += Idr[52]; + RHS13 += Idr[53]; + RHS13 -= go[53] * *cnV[53]; + m_A42 += gt[54]; + m_A42 += gt[55]; + m_A42 += gt[56]; + m_A42 += gt[57]; + m_A42 += gt[58]; + m_A41 += go[54]; + m_A40 += go[55]; + m_A39 += go[56]; + double RHS14 = Idr[54]; + RHS14 += Idr[55]; + RHS14 += Idr[56]; + RHS14 += Idr[57]; + RHS14 += Idr[58]; + RHS14 -= go[57] * *cnV[57]; + RHS14 -= go[58] * *cnV[58]; + m_A45 += gt[59]; + m_A45 += gt[60]; + m_A45 += gt[61]; + m_A45 += gt[62]; + m_A44 += go[59]; + m_A46 += go[60]; + double RHS15 = Idr[59]; + RHS15 += Idr[60]; + RHS15 += Idr[61]; + RHS15 += Idr[62]; + RHS15 -= go[61] * *cnV[61]; + RHS15 -= go[62] * *cnV[62]; + m_A55 += gt[63]; + m_A55 += gt[64]; + m_A55 += gt[65]; + m_A55 += gt[66]; + m_A55 += gt[67]; + m_A55 += gt[68]; + m_A54 += go[63]; + m_A49 += go[64]; + m_A51 += go[65]; + m_A48 += go[66]; + m_A47 += go[67]; + double RHS16 = Idr[63]; + RHS16 += Idr[64]; + RHS16 += Idr[65]; + RHS16 += Idr[66]; + RHS16 += Idr[67]; + RHS16 += Idr[68]; + RHS16 -= go[68] * *cnV[68]; + const double f0 = 1.0 / m_A0; + const double f0_10 = -f0 * m_A23; + m_A25 += m_A1 * f0_10; + RHS10 += f0_10 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_13 = -f1 * m_A33; + m_A37 += m_A3 * f1_13; + RHS13 += f1_13 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_13 = -f2 * m_A34; + m_A37 += m_A5 * f2_13; + RHS13 += f2_13 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_13 = -f3 * m_A35; + m_A37 += m_A7 * f3_13; + RHS13 += f3_13 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_11 = -f4 * m_A27; + m_A29 += m_A9 * f4_11; + RHS11 += f4_11 * RHS4; + const double f4_14 = -f4 * m_A39; + m_A42 += m_A9 * f4_14; + RHS14 += f4_14 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_12 = -f5 * m_A30; + m_A31 += m_A11 * f5_12; + RHS12 += f5_12 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_10 = -f6 * m_A24; + m_A25 += m_A13 * f6_10; + m_A26 += m_A14 * f6_10; + RHS10 += f6_10 * RHS6; + const double f6_16 = -f6 * m_A47; + m_A50 += m_A13 * f6_16; + m_A55 += m_A14 * f6_16; + RHS16 += f6_16 * RHS6; + const double f7 = 1.0 / m_A15; + const double f7_13 = -f7 * m_A36; + m_A37 += m_A16 * f7_13; + m_A38 += m_A17 * f7_13; + RHS13 += f7_13 * RHS7; + const double f7_16 = -f7 * m_A48; + m_A52 += m_A16 * f7_16; + m_A55 += m_A17 * f7_16; + RHS16 += f7_16 * RHS7; + const double f8 = 1.0 / m_A18; + const double f8_14 = -f8 * m_A40; + m_A42 += m_A19 * f8_14; + m_A43 += m_A20 * f8_14; + RHS14 += f8_14 * RHS8; + const double f8_16 = -f8 * m_A49; + m_A53 += m_A19 * f8_16; + m_A55 += m_A20 * f8_16; + RHS16 += f8_16 * RHS8; + const double f9 = 1.0 / m_A21; + const double f9_15 = -f9 * m_A44; + m_A46 += m_A22 * f9_15; + RHS15 += f9_15 * RHS9; + const double f10 = 1.0 / m_A25; + const double f10_16 = -f10 * m_A50; + m_A55 += m_A26 * f10_16; + RHS16 += f10_16 * RHS10; + const double f11 = 1.0 / m_A28; + const double f11_14 = -f11 * m_A41; + m_A42 += m_A29 * f11_14; + RHS14 += f11_14 * RHS11; + const double f12 = 1.0 / m_A31; + const double f12_16 = -f12 * m_A51; + m_A55 += m_A32 * f12_16; + RHS16 += f12_16 * RHS12; + const double f13 = 1.0 / m_A37; + const double f13_16 = -f13 * m_A52; + m_A55 += m_A38 * f13_16; + RHS16 += f13_16 * RHS13; + const double f14 = 1.0 / m_A42; + const double f14_16 = -f14 * m_A53; + m_A55 += m_A43 * f14_16; + RHS16 += f14_16 * RHS14; + const double f15 = 1.0 / m_A45; + const double f15_16 = -f15 * m_A54; + m_A55 += m_A46 * f15_16; + RHS16 += f15_16 * RHS15; + V[16] = RHS16 / m_A55; + double tmp15 = 0.0; + tmp15 += m_A46 * V[16]; + V[15] = (RHS15 - tmp15) / m_A45; + double tmp14 = 0.0; + tmp14 += m_A43 * V[16]; + V[14] = (RHS14 - tmp14) / m_A42; + double tmp13 = 0.0; + tmp13 += m_A38 * V[16]; + V[13] = (RHS13 - tmp13) / m_A37; + double tmp12 = 0.0; + tmp12 += m_A32 * V[16]; + V[12] = (RHS12 - tmp12) / m_A31; + double tmp11 = 0.0; + tmp11 += m_A29 * V[14]; + V[11] = (RHS11 - tmp11) / m_A28; + double tmp10 = 0.0; + tmp10 += m_A26 * V[16]; + V[10] = (RHS10 - tmp10) / m_A25; + double tmp9 = 0.0; + tmp9 += m_A22 * V[16]; + V[9] = (RHS9 - tmp9) / m_A21; + double tmp8 = 0.0; + tmp8 += m_A19 * V[14]; + tmp8 += m_A20 * V[16]; + V[8] = (RHS8 - tmp8) / m_A18; + double tmp7 = 0.0; + tmp7 += m_A16 * V[13]; + tmp7 += m_A17 * V[16]; + V[7] = (RHS7 - tmp7) / m_A15; + double tmp6 = 0.0; + tmp6 += m_A13 * V[10]; + tmp6 += m_A14 * V[16]; + 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[14]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[13]; + 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[13]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[10]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// starhawk +static void nl_gcr_8a93df40bddab087_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[4] * *cnV[4]; + m_A6 += gt[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A5 += go[5]; + m_A4 += go[6]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[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; +} + +// starhawk +static void nl_gcr_8c1b887a3bf15b45_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A4 += go[2]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A7 += go[6]; + m_A7 += go[7]; + m_A5 += go[8]; + m_A5 += go[9]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[10] * *cnV[10]; + m_A11 += gt[11]; + m_A11 += gt[12]; + m_A11 += gt[13]; + m_A11 += gt[14]; + m_A11 += gt[15]; + m_A11 += gt[16]; + m_A10 += go[11]; + m_A10 += go[12]; + m_A9 += go[13]; + m_A8 += go[14]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 -= go[15] * *cnV[15]; + RHS3 -= go[16] * *cnV[16]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A11 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + m_A7 += 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_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_A3 * V[2]; + tmp1 += m_A4 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// boxingb +static void nl_gcr_8cd5efddba414c21_23_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A4 += go[4]; + m_A3 += go[5]; + m_A3 += go[6]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A5 += gt[13]; + m_A7 += go[10]; + m_A6 += go[11]; + m_A6 += go[12]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A8 += gt[14]; + m_A8 += gt[15]; + m_A9 += go[14]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[15] * *cnV[15]; + m_A12 += gt[16]; + m_A12 += gt[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A11 += go[16]; + m_A11 += go[17]; + m_A10 += go[18]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 -= go[19] * *cnV[19]; + RHS4 -= go[20] * *cnV[20]; + m_A17 += gt[21]; + m_A17 += gt[22]; + m_A17 += gt[23]; + m_A17 += gt[24]; + m_A17 += gt[25]; + m_A15 += go[21]; + m_A15 += go[22]; + m_A14 += go[23]; + double RHS5 = Idr[21]; + RHS5 += Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 -= go[24] * *cnV[24]; + RHS5 -= go[25] * *cnV[25]; + m_A22 += gt[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A22 += gt[29]; + m_A22 += gt[30]; + m_A20 += go[26]; + m_A19 += go[27]; + double RHS6 = Idr[26]; + RHS6 += Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 -= go[28] * *cnV[28]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A11; + m_A12 += m_A3 * f1_4; + m_A13 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A14; + m_A16 += m_A3 * f1_5; + m_A17 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_5 = -f2 * m_A15; + m_A17 += m_A6 * f2_5; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A19; + m_A21 += m_A6 * f2_6; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_6 = -f3 * m_A20; + m_A22 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_5 = -f4 * m_A16; + m_A17 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[6]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[5]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[6]; + V[3] = (RHS3 - tmp3) / m_A8; + 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_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; +} + // pongf static void nl_gcr_930be1d2f1a52598_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -9300,6 +22974,993 @@ static void nl_gcr_930be1d2f1a52598_10_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// starcas +static void nl_gcr_9338de40a913f77b_109_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A7 += go[6]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + RHS3 -= go[7] * *cnV[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A8 += gt[10]; + m_A10 += go[8]; + m_A9 += go[9]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + RHS4 += Idr[10]; + RHS4 -= go[10] * *cnV[10]; + m_A11 += gt[11]; + m_A11 += gt[12]; + m_A12 += go[11]; + double RHS5 = Idr[11]; + RHS5 += Idr[12]; + RHS5 -= go[12] * *cnV[12]; + m_A13 += gt[13]; + m_A13 += gt[14]; + m_A13 += gt[15]; + m_A15 += go[13]; + m_A14 += go[14]; + double RHS6 = Idr[13]; + RHS6 += Idr[14]; + RHS6 += Idr[15]; + RHS6 -= go[15] * *cnV[15]; + m_A16 += gt[16]; + m_A16 += gt[17]; + m_A16 += gt[18]; + m_A16 += gt[19]; + m_A17 += go[16]; + double RHS7 = Idr[16]; + RHS7 += Idr[17]; + RHS7 += Idr[18]; + RHS7 += Idr[19]; + RHS7 -= go[17] * *cnV[17]; + RHS7 -= go[18] * *cnV[18]; + RHS7 -= go[19] * *cnV[19]; + m_A18 += gt[20]; + m_A18 += gt[21]; + m_A19 += go[20]; + double RHS8 = Idr[20]; + RHS8 += Idr[21]; + RHS8 -= go[21] * *cnV[21]; + m_A20 += gt[22]; + m_A20 += gt[23]; + m_A20 += gt[24]; + m_A20 += gt[25]; + m_A20 += gt[26]; + m_A21 += go[22]; + m_A23 += go[23]; + m_A22 += go[24]; + double RHS9 = Idr[22]; + RHS9 += Idr[23]; + RHS9 += Idr[24]; + RHS9 += Idr[25]; + RHS9 += Idr[26]; + RHS9 -= go[25] * *cnV[25]; + RHS9 -= go[26] * *cnV[26]; + m_A24 += gt[27]; + m_A24 += gt[28]; + m_A24 += gt[29]; + m_A24 += gt[30]; + m_A24 += gt[31]; + m_A24 += gt[32]; + m_A24 += gt[33]; + m_A27 += go[27]; + m_A26 += go[28]; + m_A26 += go[29]; + m_A26 += go[30]; + m_A25 += go[31]; + m_A25 += go[32]; + double RHS10 = Idr[27]; + RHS10 += Idr[28]; + RHS10 += Idr[29]; + RHS10 += Idr[30]; + RHS10 += Idr[31]; + RHS10 += Idr[32]; + RHS10 += Idr[33]; + RHS10 -= go[33] * *cnV[33]; + m_A28 += gt[34]; + m_A28 += gt[35]; + m_A29 += go[34]; + double RHS11 = Idr[34]; + RHS11 += Idr[35]; + RHS11 -= go[35] * *cnV[35]; + m_A30 += gt[36]; + m_A30 += gt[37]; + m_A30 += gt[38]; + m_A30 += gt[39]; + m_A30 += gt[40]; + m_A31 += go[36]; + m_A31 += go[37]; + m_A32 += go[38]; + m_A32 += go[39]; + double RHS12 = Idr[36]; + RHS12 += Idr[37]; + RHS12 += Idr[38]; + RHS12 += Idr[39]; + RHS12 += Idr[40]; + RHS12 -= go[40] * *cnV[40]; + m_A33 += gt[41]; + m_A33 += gt[42]; + m_A33 += gt[43]; + m_A35 += go[41]; + m_A34 += go[42]; + double RHS13 = Idr[41]; + RHS13 += Idr[42]; + RHS13 += Idr[43]; + RHS13 -= go[43] * *cnV[43]; + m_A38 += gt[44]; + m_A38 += gt[45]; + m_A38 += gt[46]; + m_A37 += go[44]; + m_A36 += go[45]; + double RHS14 = Idr[44]; + RHS14 += Idr[45]; + RHS14 += Idr[46]; + RHS14 -= go[46] * *cnV[46]; + m_A42 += gt[47]; + m_A42 += gt[48]; + m_A42 += gt[49]; + m_A41 += go[47]; + m_A40 += go[48]; + double RHS15 = Idr[47]; + RHS15 += Idr[48]; + RHS15 += Idr[49]; + RHS15 -= go[49] * *cnV[49]; + m_A46 += gt[50]; + m_A46 += gt[51]; + m_A46 += gt[52]; + m_A44 += go[50]; + m_A47 += go[51]; + double RHS16 = Idr[50]; + RHS16 += Idr[51]; + RHS16 += Idr[52]; + RHS16 -= go[52] * *cnV[52]; + m_A50 += gt[53]; + m_A50 += gt[54]; + m_A50 += gt[55]; + m_A48 += go[53]; + m_A51 += go[54]; + double RHS17 = Idr[53]; + RHS17 += Idr[54]; + RHS17 += Idr[55]; + RHS17 -= go[55] * *cnV[55]; + m_A54 += gt[56]; + m_A54 += gt[57]; + m_A54 += gt[58]; + m_A54 += gt[59]; + m_A54 += gt[60]; + m_A54 += gt[61]; + m_A53 += go[56]; + m_A53 += go[57]; + m_A52 += go[58]; + double RHS18 = Idr[56]; + RHS18 += Idr[57]; + RHS18 += Idr[58]; + RHS18 += Idr[59]; + RHS18 += Idr[60]; + RHS18 += Idr[61]; + RHS18 -= go[59] * *cnV[59]; + RHS18 -= go[60] * *cnV[60]; + RHS18 -= go[61] * *cnV[61]; + m_A58 += gt[62]; + m_A58 += gt[63]; + m_A58 += gt[64]; + m_A58 += gt[65]; + m_A58 += gt[66]; + m_A58 += gt[67]; + m_A58 += gt[68]; + m_A57 += go[62]; + m_A59 += go[63]; + double RHS19 = Idr[62]; + RHS19 += Idr[63]; + RHS19 += Idr[64]; + RHS19 += Idr[65]; + RHS19 += Idr[66]; + RHS19 += Idr[67]; + RHS19 += Idr[68]; + RHS19 -= go[64] * *cnV[64]; + RHS19 -= go[65] * *cnV[65]; + RHS19 -= go[66] * *cnV[66]; + RHS19 -= go[67] * *cnV[67]; + RHS19 -= go[68] * *cnV[68]; + m_A63 += gt[69]; + m_A63 += gt[70]; + m_A63 += gt[71]; + m_A63 += gt[72]; + m_A63 += gt[73]; + m_A63 += gt[74]; + m_A64 += go[69]; + m_A64 += go[70]; + m_A61 += go[71]; + m_A61 += go[72]; + m_A61 += go[73]; + m_A60 += go[74]; + double RHS20 = Idr[69]; + RHS20 += Idr[70]; + RHS20 += Idr[71]; + RHS20 += Idr[72]; + RHS20 += Idr[73]; + RHS20 += Idr[74]; + m_A69 += gt[75]; + m_A69 += gt[76]; + m_A69 += gt[77]; + m_A69 += gt[78]; + m_A68 += go[75]; + m_A68 += go[76]; + m_A70 += go[77]; + m_A67 += go[78]; + double RHS21 = Idr[75]; + RHS21 += Idr[76]; + RHS21 += Idr[77]; + RHS21 += Idr[78]; + m_A73 += gt[79]; + m_A73 += gt[80]; + m_A73 += gt[81]; + m_A72 += go[79]; + m_A71 += go[80]; + double RHS22 = Idr[79]; + RHS22 += Idr[80]; + RHS22 += Idr[81]; + RHS22 -= go[81] * *cnV[81]; + m_A80 += gt[82]; + m_A80 += gt[83]; + m_A80 += gt[84]; + m_A80 += gt[85]; + m_A80 += gt[86]; + m_A80 += gt[87]; + m_A80 += gt[88]; + m_A80 += gt[89]; + m_A79 += go[82]; + m_A76 += go[83]; + m_A76 += go[84]; + m_A78 += go[85]; + m_A78 += go[86]; + m_A75 += go[87]; + double RHS23 = Idr[82]; + RHS23 += Idr[83]; + RHS23 += Idr[84]; + RHS23 += Idr[85]; + RHS23 += Idr[86]; + RHS23 += Idr[87]; + RHS23 += Idr[88]; + RHS23 += Idr[89]; + RHS23 -= go[88] * *cnV[88]; + RHS23 -= go[89] * *cnV[89]; + m_A87 += gt[90]; + m_A87 += gt[91]; + m_A87 += gt[92]; + m_A87 += gt[93]; + m_A84 += go[90]; + m_A89 += go[91]; + m_A83 += go[92]; + double RHS24 = Idr[90]; + RHS24 += Idr[91]; + RHS24 += Idr[92]; + RHS24 += Idr[93]; + RHS24 -= go[93] * *cnV[93]; + m_A95 += gt[94]; + m_A95 += gt[95]; + m_A95 += gt[96]; + m_A95 += gt[97]; + m_A91 += go[94]; + m_A96 += go[95]; + m_A90 += go[96]; + double RHS25 = Idr[94]; + RHS25 += Idr[95]; + RHS25 += Idr[96]; + RHS25 += Idr[97]; + RHS25 -= go[97] * *cnV[97]; + m_A99 += gt[98]; + m_A99 += gt[99]; + m_A99 += gt[100]; + m_A97 += go[98]; + m_A100 += go[99]; + double RHS26 = Idr[98]; + RHS26 += Idr[99]; + RHS26 += Idr[100]; + RHS26 -= go[100] * *cnV[100]; + m_A108 += gt[101]; + m_A108 += gt[102]; + m_A108 += gt[103]; + m_A108 += gt[104]; + m_A108 += gt[105]; + m_A108 += gt[106]; + m_A108 += gt[107]; + m_A108 += gt[108]; + m_A108 += gt[109]; + m_A104 += go[101]; + m_A101 += go[102]; + m_A107 += go[103]; + m_A103 += go[104]; + m_A102 += go[105]; + m_A106 += go[106]; + m_A105 += go[107]; + double RHS27 = Idr[101]; + RHS27 += Idr[102]; + RHS27 += Idr[103]; + RHS27 += Idr[104]; + RHS27 += Idr[105]; + RHS27 += Idr[106]; + RHS27 += Idr[107]; + RHS27 += Idr[108]; + RHS27 += Idr[109]; + RHS27 -= go[108] * *cnV[108]; + RHS27 -= go[109] * *cnV[109]; + const double f0 = 1.0 / m_A0; + const double f0_14 = -f0 * m_A36; + m_A38 += m_A1 * f0_14; + RHS14 += f0_14 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_15 = -f1 * m_A40; + m_A42 += m_A3 * f1_15; + RHS15 += f1_15 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_24 = -f2 * m_A83; + m_A87 += m_A5 * f2_24; + RHS24 += f2_24 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_25 = -f3 * m_A90; + m_A95 += m_A7 * f3_25; + RHS25 += f3_25 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_14 = -f4 * m_A37; + m_A38 += m_A9 * f4_14; + m_A39 += m_A10 * f4_14; + RHS14 += f4_14 * RHS4; + const double f4_16 = -f4 * m_A44; + m_A45 += m_A9 * f4_16; + m_A46 += m_A10 * f4_16; + RHS16 += f4_16 * RHS4; + const double f5 = 1.0 / m_A11; + const double f5_22 = -f5 * m_A71; + m_A73 += m_A12 * f5_22; + RHS22 += f5_22 * RHS5; + const double f6 = 1.0 / m_A13; + const double f6_15 = -f6 * m_A41; + m_A42 += m_A14 * f6_15; + m_A43 += m_A15 * f6_15; + RHS15 += f6_15 * RHS6; + const double f6_17 = -f6 * m_A48; + m_A49 += m_A14 * f6_17; + m_A50 += m_A15 * f6_17; + RHS17 += f6_17 * RHS6; + const double f7 = 1.0 / m_A16; + const double f7_18 = -f7 * m_A52; + m_A54 += m_A17 * f7_18; + RHS18 += f7_18 * RHS7; + const double f8 = 1.0 / m_A18; + const double f8_19 = -f8 * m_A57; + m_A59 += m_A19 * f8_19; + RHS19 += f8_19 * RHS8; + const double f8_27 = -f8 * m_A101; + m_A108 += m_A19 * f8_27; + RHS27 += f8_27 * RHS8; + const double f9 = 1.0 / m_A20; + const double f9_20 = -f9 * m_A60; + m_A63 += m_A21 * f9_20; + m_A65 += m_A22 * f9_20; + m_A66 += m_A23 * f9_20; + RHS20 += f9_20 * RHS9; + const double f9_24 = -f9 * m_A84; + m_A85 += m_A21 * f9_24; + m_A87 += m_A22 * f9_24; + m_A88 += m_A23 * f9_24; + RHS24 += f9_24 * RHS9; + const double f9_25 = -f9 * m_A91; + m_A92 += m_A21 * f9_25; + m_A94 += m_A22 * f9_25; + m_A95 += m_A23 * f9_25; + RHS25 += f9_25 * RHS9; + const double f10 = 1.0 / m_A24; + const double f10_18 = -f10 * m_A53; + m_A54 += m_A25 * f10_18; + m_A55 += m_A26 * f10_18; + m_A56 += m_A27 * f10_18; + RHS18 += f10_18 * RHS10; + const double f10_20 = -f10 * m_A61; + m_A62 += m_A25 * f10_20; + m_A63 += m_A26 * f10_20; + m_A64 += m_A27 * f10_20; + RHS20 += f10_20 * RHS10; + const double f10_23 = -f10 * m_A75; + m_A77 += m_A25 * f10_23; + m_A78 += m_A26 * f10_23; + m_A80 += m_A27 * f10_23; + RHS23 += f10_23 * RHS10; + const double f11 = 1.0 / m_A28; + const double f11_21 = -f11 * m_A67; + m_A69 += m_A29 * f11_21; + RHS21 += f11_21 * RHS11; + const double f12 = 1.0 / m_A30; + const double f12_21 = -f12 * m_A68; + m_A69 += m_A31 * f12_21; + m_A70 += m_A32 * f12_21; + RHS21 += f12_21 * RHS12; + const double f12_23 = -f12 * m_A76; + m_A79 += m_A31 * f12_23; + m_A80 += m_A32 * f12_23; + RHS23 += f12_23 * RHS12; + const double f13 = 1.0 / m_A33; + const double f13_22 = -f13 * m_A72; + m_A73 += m_A34 * f13_22; + m_A74 += m_A35 * f13_22; + RHS22 += f13_22 * RHS13; + const double f13_26 = -f13 * m_A97; + m_A98 += m_A34 * f13_26; + m_A99 += m_A35 * f13_26; + RHS26 += f13_26 * RHS13; + const double f14 = 1.0 / m_A38; + const double f14_16 = -f14 * m_A45; + m_A46 += m_A39 * f14_16; + RHS16 += f14_16 * RHS14; + const double f15 = 1.0 / m_A42; + const double f15_17 = -f15 * m_A49; + m_A50 += m_A43 * f15_17; + RHS17 += f15_17 * RHS15; + const double f16 = 1.0 / m_A46; + const double f16_27 = -f16 * m_A102; + m_A108 += m_A47 * f16_27; + RHS27 += f16_27 * RHS16; + const double f17 = 1.0 / m_A50; + const double f17_27 = -f17 * m_A103; + m_A108 += m_A51 * f17_27; + RHS27 += f17_27 * RHS17; + const double f18 = 1.0 / m_A54; + const double f18_20 = -f18 * m_A62; + m_A63 += m_A55 * f18_20; + m_A64 += m_A56 * f18_20; + RHS20 += f18_20 * RHS18; + const double f18_23 = -f18 * m_A77; + m_A78 += m_A55 * f18_23; + m_A80 += m_A56 * f18_23; + RHS23 += f18_23 * RHS18; + const double f19 = 1.0 / m_A58; + const double f19_27 = -f19 * m_A104; + m_A108 += m_A59 * f19_27; + RHS27 += f19_27 * RHS19; + const double f20 = 1.0 / m_A63; + const double f20_23 = -f20 * m_A78; + m_A80 += m_A64 * f20_23; + m_A81 += m_A65 * f20_23; + m_A82 += m_A66 * f20_23; + RHS23 += f20_23 * RHS20; + const double f20_24 = -f20 * m_A85; + m_A86 += m_A64 * f20_24; + m_A87 += m_A65 * f20_24; + m_A88 += m_A66 * f20_24; + RHS24 += f20_24 * RHS20; + const double f20_25 = -f20 * m_A92; + m_A93 += m_A64 * f20_25; + m_A94 += m_A65 * f20_25; + m_A95 += m_A66 * f20_25; + RHS25 += f20_25 * RHS20; + const double f21 = 1.0 / m_A69; + const double f21_23 = -f21 * m_A79; + m_A80 += m_A70 * f21_23; + RHS23 += f21_23 * RHS21; + const double f22 = 1.0 / m_A73; + const double f22_26 = -f22 * m_A98; + m_A99 += m_A74 * f22_26; + RHS26 += f22_26 * RHS22; + const double f23 = 1.0 / m_A80; + const double f23_24 = -f23 * m_A86; + m_A87 += m_A81 * f23_24; + m_A88 += m_A82 * f23_24; + RHS24 += f23_24 * RHS23; + const double f23_25 = -f23 * m_A93; + m_A94 += m_A81 * f23_25; + m_A95 += m_A82 * f23_25; + RHS25 += f23_25 * RHS23; + const double f24 = 1.0 / m_A87; + const double f24_25 = -f24 * m_A94; + m_A95 += m_A88 * f24_25; + m_A96 += m_A89 * f24_25; + RHS25 += f24_25 * RHS24; + const double f24_27 = -f24 * m_A105; + m_A106 += m_A88 * f24_27; + m_A108 += m_A89 * f24_27; + RHS27 += f24_27 * RHS24; + const double f25 = 1.0 / m_A95; + const double f25_27 = -f25 * m_A106; + m_A108 += m_A96 * f25_27; + RHS27 += f25_27 * RHS25; + const double f26 = 1.0 / m_A99; + const double f26_27 = -f26 * m_A107; + m_A108 += m_A100 * f26_27; + RHS27 += f26_27 * RHS26; + V[27] = RHS27 / m_A108; + double tmp26 = 0.0; + tmp26 += m_A100 * V[27]; + V[26] = (RHS26 - tmp26) / m_A99; + double tmp25 = 0.0; + tmp25 += m_A96 * V[27]; + V[25] = (RHS25 - tmp25) / m_A95; + double tmp24 = 0.0; + tmp24 += m_A88 * V[25]; + tmp24 += m_A89 * V[27]; + V[24] = (RHS24 - tmp24) / m_A87; + double tmp23 = 0.0; + tmp23 += m_A81 * V[24]; + tmp23 += m_A82 * V[25]; + V[23] = (RHS23 - tmp23) / m_A80; + double tmp22 = 0.0; + tmp22 += m_A74 * V[26]; + V[22] = (RHS22 - tmp22) / m_A73; + double tmp21 = 0.0; + tmp21 += m_A70 * V[23]; + V[21] = (RHS21 - tmp21) / m_A69; + double tmp20 = 0.0; + tmp20 += m_A64 * V[23]; + tmp20 += m_A65 * V[24]; + tmp20 += m_A66 * V[25]; + V[20] = (RHS20 - tmp20) / m_A63; + double tmp19 = 0.0; + tmp19 += m_A59 * V[27]; + V[19] = (RHS19 - tmp19) / m_A58; + double tmp18 = 0.0; + tmp18 += m_A55 * V[20]; + tmp18 += m_A56 * V[23]; + V[18] = (RHS18 - tmp18) / m_A54; + double tmp17 = 0.0; + tmp17 += m_A51 * V[27]; + V[17] = (RHS17 - tmp17) / m_A50; + double tmp16 = 0.0; + tmp16 += m_A47 * V[27]; + V[16] = (RHS16 - tmp16) / m_A46; + double tmp15 = 0.0; + tmp15 += m_A43 * V[17]; + V[15] = (RHS15 - tmp15) / m_A42; + double tmp14 = 0.0; + tmp14 += m_A39 * V[16]; + V[14] = (RHS14 - tmp14) / m_A38; + double tmp13 = 0.0; + tmp13 += m_A34 * V[22]; + tmp13 += m_A35 * V[26]; + V[13] = (RHS13 - tmp13) / m_A33; + double tmp12 = 0.0; + tmp12 += m_A31 * V[21]; + tmp12 += m_A32 * V[23]; + V[12] = (RHS12 - tmp12) / m_A30; + double tmp11 = 0.0; + tmp11 += m_A29 * V[21]; + V[11] = (RHS11 - tmp11) / m_A28; + double tmp10 = 0.0; + tmp10 += m_A25 * V[18]; + tmp10 += m_A26 * V[20]; + tmp10 += m_A27 * V[23]; + V[10] = (RHS10 - tmp10) / m_A24; + double tmp9 = 0.0; + tmp9 += m_A21 * V[20]; + tmp9 += m_A22 * V[24]; + tmp9 += m_A23 * V[25]; + V[9] = (RHS9 - tmp9) / m_A20; + double tmp8 = 0.0; + tmp8 += m_A19 * V[27]; + V[8] = (RHS8 - tmp8) / m_A18; + double tmp7 = 0.0; + tmp7 += m_A17 * V[18]; + V[7] = (RHS7 - tmp7) / m_A16; + double tmp6 = 0.0; + tmp6 += m_A14 * V[15]; + tmp6 += m_A15 * V[17]; + V[6] = (RHS6 - tmp6) / m_A13; + double tmp5 = 0.0; + tmp5 += m_A12 * V[22]; + V[5] = (RHS5 - tmp5) / m_A11; + double tmp4 = 0.0; + tmp4 += m_A9 * V[14]; + tmp4 += m_A10 * V[16]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[25]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[24]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[15]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[14]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// speedfrk +static void nl_gcr_94f6984ccc0e82e_37_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[9]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + RHS3 += Idr[11]; + RHS3 -= go[10] * *cnV[10]; + RHS3 -= go[11] * *cnV[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A9 += go[12]; + double RHS4 = Idr[12]; + RHS4 += Idr[13]; + RHS4 += Idr[14]; + RHS4 -= go[13] * *cnV[13]; + RHS4 -= go[14] * *cnV[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A11 += go[15]; + double RHS5 = Idr[15]; + RHS5 += Idr[16]; + RHS5 += Idr[17]; + RHS5 -= go[16] * *cnV[16]; + RHS5 -= go[17] * *cnV[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A13 += go[18]; + double RHS6 = Idr[18]; + RHS6 += Idr[19]; + RHS6 += Idr[20]; + RHS6 -= go[19] * *cnV[19]; + RHS6 -= go[20] * *cnV[20]; + m_A14 += gt[21]; + m_A14 += gt[22]; + m_A14 += gt[23]; + m_A15 += go[21]; + double RHS7 = Idr[21]; + RHS7 += Idr[22]; + RHS7 += Idr[23]; + RHS7 -= go[22] * *cnV[22]; + RHS7 -= go[23] * *cnV[23]; + m_A16 += gt[24]; + m_A16 += gt[25]; + m_A16 += gt[26]; + m_A17 += go[24]; + double RHS8 = Idr[24]; + RHS8 += Idr[25]; + RHS8 += Idr[26]; + RHS8 -= go[25] * *cnV[25]; + RHS8 -= go[26] * *cnV[26]; + m_A18 += gt[27]; + m_A18 += gt[28]; + m_A18 += gt[29]; + m_A19 += go[27]; + double RHS9 = Idr[27]; + RHS9 += Idr[28]; + RHS9 += Idr[29]; + RHS9 -= go[28] * *cnV[28]; + RHS9 -= go[29] * *cnV[29]; + m_A24 += gt[30]; + m_A24 += gt[31]; + m_A24 += gt[32]; + m_A24 += gt[33]; + m_A24 += gt[34]; + m_A25 += go[30]; + m_A23 += go[31]; + m_A22 += go[32]; + m_A21 += go[33]; + m_A20 += go[34]; + double RHS10 = Idr[30]; + RHS10 += Idr[31]; + RHS10 += Idr[32]; + RHS10 += Idr[33]; + RHS10 += Idr[34]; + m_A29 += gt[35]; + m_A29 += gt[36]; + m_A29 += gt[37]; + m_A29 += gt[38]; + m_A29 += gt[39]; + m_A30 += go[35]; + m_A28 += go[36]; + m_A27 += go[37]; + m_A26 += go[38]; + double RHS11 = Idr[35]; + RHS11 += Idr[36]; + RHS11 += Idr[37]; + RHS11 += Idr[38]; + RHS11 += Idr[39]; + RHS11 -= go[39] * *cnV[39]; + m_A36 += gt[40]; + m_A36 += gt[41]; + m_A36 += gt[42]; + m_A36 += gt[43]; + m_A36 += gt[44]; + m_A35 += go[40]; + m_A34 += go[41]; + m_A33 += go[42]; + m_A32 += go[43]; + m_A31 += go[44]; + double RHS12 = Idr[40]; + RHS12 += Idr[41]; + RHS12 += Idr[42]; + RHS12 += Idr[43]; + RHS12 += Idr[44]; + const double f0 = 1.0 / m_A0; + const double f0_10 = -f0 * m_A20; + m_A24 += m_A1 * f0_10; + RHS10 += f0_10 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_10 = -f1 * m_A21; + m_A24 += m_A3 * f1_10; + RHS10 += f1_10 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_10 = -f2 * m_A22; + m_A24 += m_A5 * f2_10; + RHS10 += f2_10 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_11 = -f3 * m_A26; + m_A29 += m_A7 * f3_11; + RHS11 += f3_11 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_12 = -f4 * m_A31; + m_A36 += m_A9 * f4_12; + RHS12 += f4_12 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_10 = -f5 * m_A23; + m_A24 += m_A11 * f5_10; + RHS10 += f5_10 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_11 = -f6 * m_A27; + m_A29 += m_A13 * f6_11; + RHS11 += f6_11 * RHS6; + const double f7 = 1.0 / m_A14; + const double f7_12 = -f7 * m_A32; + m_A36 += m_A15 * f7_12; + RHS12 += f7_12 * RHS7; + const double f8 = 1.0 / m_A16; + const double f8_12 = -f8 * m_A33; + m_A36 += m_A17 * f8_12; + RHS12 += f8_12 * RHS8; + const double f9 = 1.0 / m_A18; + const double f9_11 = -f9 * m_A28; + m_A29 += m_A19 * f9_11; + RHS11 += f9_11 * RHS9; + const double f10 = 1.0 / m_A24; + const double f10_12 = -f10 * m_A34; + m_A36 += m_A25 * f10_12; + RHS12 += f10_12 * RHS10; + const double f11 = 1.0 / m_A29; + const double f11_12 = -f11 * m_A35; + m_A36 += m_A30 * f11_12; + RHS12 += f11_12 * RHS11; + V[12] = RHS12 / m_A36; + double tmp11 = 0.0; + tmp11 += m_A30 * V[12]; + V[11] = (RHS11 - tmp11) / m_A29; + double tmp10 = 0.0; + tmp10 += m_A25 * V[12]; + V[10] = (RHS10 - tmp10) / m_A24; + double tmp9 = 0.0; + tmp9 += m_A19 * V[11]; + V[9] = (RHS9 - tmp9) / m_A18; + double tmp8 = 0.0; + tmp8 += m_A17 * V[12]; + V[8] = (RHS8 - tmp8) / m_A16; + double tmp7 = 0.0; + tmp7 += m_A15 * V[12]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[11]; + V[6] = (RHS6 - tmp6) / m_A12; + double tmp5 = 0.0; + tmp5 += m_A11 * V[10]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[12]; + 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[10]; + 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[10]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // kidniki static void nl_gcr_9701e2657a7f4ca3_37_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -10111,6 +24772,352 @@ static void nl_gcr_a1806410e32baeb_26_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// solarq +static void nl_gcr_a52528b8650630c9_45_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A2 += gt[11]; + m_A5 += go[4]; + m_A4 += go[5]; + m_A4 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A7 += go[12]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 += Idr[15]; + RHS2 -= go[13] * *cnV[13]; + RHS2 -= go[14] * *cnV[14]; + RHS2 -= go[15] * *cnV[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A10 += go[16]; + m_A9 += go[17]; + double RHS3 = Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 -= go[18] * *cnV[18]; + m_A11 += gt[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A11 += gt[23]; + m_A11 += gt[24]; + m_A11 += gt[25]; + m_A11 += gt[26]; + m_A14 += go[19]; + m_A13 += go[20]; + m_A13 += go[21]; + m_A12 += go[22]; + m_A12 += go[23]; + double RHS4 = Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 += Idr[26]; + RHS4 -= go[24] * *cnV[24]; + RHS4 -= go[25] * *cnV[25]; + RHS4 -= go[26] * *cnV[26]; + m_A17 += gt[27]; + m_A17 += gt[28]; + m_A17 += gt[29]; + m_A17 += gt[30]; + m_A17 += gt[31]; + m_A17 += gt[32]; + m_A16 += go[27]; + m_A16 += go[28]; + m_A15 += go[29]; + double RHS5 = Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 += Idr[30]; + RHS5 += Idr[31]; + RHS5 += Idr[32]; + RHS5 -= go[30] * *cnV[30]; + RHS5 -= go[31] * *cnV[31]; + RHS5 -= go[32] * *cnV[32]; + m_A22 += gt[33]; + m_A22 += gt[34]; + m_A22 += gt[35]; + m_A22 += gt[36]; + m_A22 += gt[37]; + m_A22 += gt[38]; + m_A21 += go[33]; + m_A21 += go[34]; + m_A20 += go[35]; + double RHS6 = Idr[33]; + RHS6 += Idr[34]; + RHS6 += Idr[35]; + RHS6 += Idr[36]; + RHS6 += Idr[37]; + RHS6 += Idr[38]; + RHS6 -= go[36] * *cnV[36]; + RHS6 -= go[37] * *cnV[37]; + RHS6 -= go[38] * *cnV[38]; + m_A27 += gt[39]; + m_A27 += gt[40]; + m_A27 += gt[41]; + m_A27 += gt[42]; + m_A27 += gt[43]; + m_A28 += go[39]; + m_A28 += go[40]; + m_A25 += go[41]; + m_A25 += go[42]; + double RHS7 = Idr[39]; + RHS7 += Idr[40]; + RHS7 += Idr[41]; + RHS7 += Idr[42]; + RHS7 += Idr[43]; + RHS7 -= go[43] * *cnV[43]; + m_A33 += gt[44]; + m_A33 += gt[45]; + m_A33 += gt[46]; + m_A33 += gt[47]; + m_A33 += gt[48]; + m_A32 += go[44]; + m_A32 += go[45]; + m_A29 += go[46]; + m_A30 += go[47]; + double RHS8 = Idr[44]; + RHS8 += Idr[45]; + RHS8 += Idr[46]; + RHS8 += Idr[47]; + RHS8 += Idr[48]; + RHS8 -= go[48] * *cnV[48]; + m_A37 += gt[49]; + m_A37 += gt[50]; + m_A37 += gt[51]; + m_A37 += gt[52]; + m_A37 += gt[53]; + m_A38 += go[49]; + m_A38 += go[50]; + m_A35 += go[51]; + m_A35 += go[52]; + double RHS9 = Idr[49]; + RHS9 += Idr[50]; + RHS9 += Idr[51]; + RHS9 += Idr[52]; + RHS9 += Idr[53]; + RHS9 -= go[53] * *cnV[53]; + m_A44 += gt[54]; + m_A44 += gt[55]; + m_A44 += gt[56]; + m_A44 += gt[57]; + m_A44 += gt[58]; + m_A43 += go[54]; + m_A43 += go[55]; + m_A40 += go[56]; + m_A39 += go[57]; + double RHS10 = Idr[54]; + RHS10 += Idr[55]; + RHS10 += Idr[56]; + RHS10 += Idr[57]; + RHS10 += Idr[58]; + RHS10 -= go[58] * *cnV[58]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A15; + m_A17 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A16; + m_A17 += m_A3 * f1_5; + m_A18 += m_A4 * f1_5; + m_A19 += m_A5 * f1_5; + RHS5 += f1_5 * RHS1; + const double f1_7 = -f1 * m_A25; + m_A26 += m_A3 * f1_7; + m_A27 += m_A4 * f1_7; + m_A28 += m_A5 * f1_7; + RHS7 += f1_7 * RHS1; + const double f1_8 = -f1 * m_A29; + m_A31 += m_A3 * f1_8; + m_A32 += m_A4 * f1_8; + m_A33 += m_A5 * f1_8; + RHS8 += f1_8 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_6 = -f2 * m_A20; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_8 = -f3 * m_A30; + m_A33 += m_A9 * f3_8; + m_A34 += m_A10 * f3_8; + RHS8 += f3_8 * RHS3; + const double f3_10 = -f3 * m_A39; + m_A42 += m_A9 * f3_10; + m_A44 += m_A10 * f3_10; + RHS10 += f3_10 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_6 = -f4 * m_A21; + m_A22 += m_A12 * f4_6; + m_A23 += m_A13 * f4_6; + m_A24 += m_A14 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_9 = -f4 * m_A35; + m_A36 += m_A12 * f4_9; + m_A37 += m_A13 * f4_9; + m_A38 += m_A14 * f4_9; + RHS9 += f4_9 * RHS4; + const double f4_10 = -f4 * m_A40; + m_A41 += m_A12 * f4_10; + m_A43 += m_A13 * f4_10; + m_A44 += m_A14 * f4_10; + RHS10 += f4_10 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_7 = -f5 * m_A26; + m_A27 += m_A18 * f5_7; + m_A28 += m_A19 * f5_7; + RHS7 += f5_7 * RHS5; + const double f5_8 = -f5 * m_A31; + m_A32 += m_A18 * f5_8; + m_A33 += m_A19 * f5_8; + RHS8 += f5_8 * RHS5; + const double f6 = 1.0 / m_A22; + const double f6_9 = -f6 * m_A36; + m_A37 += m_A23 * f6_9; + m_A38 += m_A24 * f6_9; + RHS9 += f6_9 * RHS6; + const double f6_10 = -f6 * m_A41; + m_A43 += m_A23 * f6_10; + m_A44 += m_A24 * f6_10; + RHS10 += f6_10 * 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; + const double f8 = 1.0 / m_A33; + const double f8_10 = -f8 * m_A42; + m_A44 += m_A34 * f8_10; + RHS10 += f8_10 * RHS8; + const double f9 = 1.0 / m_A37; + const double f9_10 = -f9 * m_A43; + m_A44 += m_A38 * f9_10; + RHS10 += f9_10 * RHS9; + V[10] = RHS10 / m_A44; + double tmp9 = 0.0; + tmp9 += m_A38 * V[10]; + V[9] = (RHS9 - tmp9) / m_A37; + double tmp8 = 0.0; + tmp8 += m_A34 * V[10]; + V[8] = (RHS8 - tmp8) / m_A33; + double tmp7 = 0.0; + tmp7 += m_A28 * V[8]; + V[7] = (RHS7 - tmp7) / m_A27; + double tmp6 = 0.0; + tmp6 += m_A23 * V[9]; + tmp6 += m_A24 * V[10]; + V[6] = (RHS6 - tmp6) / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[7]; + tmp5 += m_A19 * V[8]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A12 * V[6]; + tmp4 += m_A13 * V[9]; + tmp4 += m_A14 * V[10]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A9 * V[8]; + tmp3 += m_A10 * V[10]; + 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_A3 * V[5]; + tmp1 += m_A4 * V[7]; + tmp1 += m_A5 * V[8]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // breakout static void nl_gcr_a59b19805d7e4461_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -11037,6 +26044,647 @@ static void nl_gcr_a716c0b150a52aeb_135_double_double(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// armora +static void nl_gcr_ade1dfefb9ca54f2_22_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[4]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A7 += go[6]; + m_A6 += go[7]; + m_A6 += go[8]; + m_A5 += go[9]; + m_A5 += go[10]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + RHS2 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A9 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A16 += go[20]; + m_A16 += go[21]; + m_A13 += go[22]; + m_A13 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[24] * *cnV[24]; + m_A21 += gt[25]; + m_A21 += gt[26]; + m_A21 += gt[27]; + m_A21 += gt[28]; + m_A21 += gt[29]; + m_A20 += go[25]; + m_A20 += go[26]; + m_A18 += go[27]; + m_A17 += go[28]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[29] * *cnV[29]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A17; + m_A21 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A5 * f2_3; + m_A11 += m_A6 * f2_3; + m_A12 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A13; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A18; + m_A19 += m_A5 * f2_5; + m_A20 += m_A6 * f2_5; + m_A21 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += 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_A15; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A21; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + 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_A5 * V[3]; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// boxingb +static void nl_gcr_af955d6ae6e0449f_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A5 += gt[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A6 += go[6]; + m_A4 += go[7]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[8] * *cnV[8]; + m_A9 += gt[9]; + m_A9 += gt[10]; + m_A7 += go[9]; + m_A8 += go[10]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + 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; +} + +// ripoff +static void nl_gcr_afe33d20712c21b9_59_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A3 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A5 += go[6]; + double RHS2 = Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A7 += go[9]; + double RHS3 = Idr[9]; + RHS3 += Idr[10]; + RHS3 -= go[10] * *cnV[10]; + m_A8 += gt[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A9 += go[11]; + double RHS4 = Idr[11]; + RHS4 += Idr[12]; + RHS4 += Idr[13]; + RHS4 -= go[12] * *cnV[12]; + RHS4 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A12 += go[14]; + m_A11 += go[15]; + double RHS5 = Idr[14]; + RHS5 += Idr[15]; + m_A13 += gt[16]; + m_A13 += gt[17]; + m_A13 += gt[18]; + m_A14 += go[16]; + double RHS6 = Idr[16]; + RHS6 += Idr[17]; + RHS6 += Idr[18]; + RHS6 -= go[17] * *cnV[17]; + RHS6 -= go[18] * *cnV[18]; + m_A15 += gt[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A16 += go[19]; + double RHS7 = Idr[19]; + RHS7 += Idr[20]; + RHS7 += Idr[21]; + RHS7 -= go[20] * *cnV[20]; + RHS7 -= go[21] * *cnV[21]; + m_A17 += gt[22]; + m_A17 += gt[23]; + m_A17 += gt[24]; + m_A18 += go[22]; + double RHS8 = Idr[22]; + RHS8 += Idr[23]; + RHS8 += Idr[24]; + RHS8 -= go[23] * *cnV[23]; + RHS8 -= go[24] * *cnV[24]; + m_A19 += gt[25]; + m_A19 += gt[26]; + m_A19 += gt[27]; + m_A20 += go[25]; + double RHS9 = Idr[25]; + RHS9 += Idr[26]; + RHS9 += Idr[27]; + RHS9 -= go[26] * *cnV[26]; + RHS9 -= go[27] * *cnV[27]; + m_A21 += gt[28]; + m_A21 += gt[29]; + m_A23 += go[28]; + m_A22 += go[29]; + double RHS10 = Idr[28]; + RHS10 += Idr[29]; + m_A24 += gt[30]; + m_A24 += gt[31]; + m_A24 += gt[32]; + m_A25 += go[30]; + double RHS11 = Idr[30]; + RHS11 += Idr[31]; + RHS11 += Idr[32]; + RHS11 -= go[31] * *cnV[31]; + RHS11 -= go[32] * *cnV[32]; + m_A26 += gt[33]; + m_A26 += gt[34]; + m_A26 += gt[35]; + m_A27 += go[33]; + double RHS12 = Idr[33]; + RHS12 += Idr[34]; + RHS12 += Idr[35]; + RHS12 -= go[34] * *cnV[34]; + RHS12 -= go[35] * *cnV[35]; + m_A28 += gt[36]; + m_A28 += gt[37]; + m_A28 += gt[38]; + m_A29 += go[36]; + double RHS13 = Idr[36]; + RHS13 += Idr[37]; + RHS13 += Idr[38]; + RHS13 -= go[37] * *cnV[37]; + RHS13 -= go[38] * *cnV[38]; + m_A35 += gt[39]; + m_A35 += gt[40]; + m_A35 += gt[41]; + m_A35 += gt[42]; + m_A35 += gt[43]; + m_A35 += gt[44]; + m_A34 += go[39]; + m_A33 += go[40]; + m_A32 += go[41]; + m_A31 += go[42]; + m_A30 += go[43]; + double RHS14 = Idr[39]; + RHS14 += Idr[40]; + RHS14 += Idr[41]; + RHS14 += Idr[42]; + RHS14 += Idr[43]; + RHS14 += Idr[44]; + RHS14 -= go[44] * *cnV[44]; + m_A38 += gt[45]; + m_A38 += gt[46]; + m_A37 += go[45]; + m_A39 += go[46]; + double RHS15 = Idr[45]; + RHS15 += Idr[46]; + m_A40 += gt[47]; + m_A40 += gt[48]; + m_A40 += gt[49]; + m_A41 += go[47]; + double RHS16 = Idr[47]; + RHS16 += Idr[48]; + RHS16 += Idr[49]; + RHS16 -= go[48] * *cnV[48]; + RHS16 -= go[49] * *cnV[49]; + m_A46 += gt[50]; + m_A46 += gt[51]; + m_A46 += gt[52]; + m_A43 += go[50]; + m_A45 += go[51]; + m_A42 += go[52]; + double RHS17 = Idr[50]; + RHS17 += Idr[51]; + RHS17 += Idr[52]; + m_A58 += gt[53]; + m_A58 += gt[54]; + m_A58 += gt[55]; + m_A58 += gt[56]; + m_A58 += gt[57]; + m_A58 += gt[58]; + m_A58 += gt[59]; + m_A58 += gt[60]; + m_A58 += gt[61]; + m_A58 += gt[62]; + m_A56 += go[53]; + m_A55 += go[54]; + m_A54 += go[55]; + m_A53 += go[56]; + m_A52 += go[57]; + m_A51 += go[58]; + m_A50 += go[59]; + m_A49 += go[60]; + m_A48 += go[61]; + double RHS18 = Idr[53]; + RHS18 += Idr[54]; + RHS18 += Idr[55]; + RHS18 += Idr[56]; + RHS18 += Idr[57]; + RHS18 += Idr[58]; + RHS18 += Idr[59]; + RHS18 += Idr[60]; + RHS18 += Idr[61]; + RHS18 += Idr[62]; + RHS18 -= go[62] * *cnV[62]; + const double f0 = 1.0 / m_A0; + const double f0_14 = -f0 * m_A30; + m_A35 += m_A1 * f0_14; + RHS14 += f0_14 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_14 = -f1 * m_A31; + m_A35 += m_A3 * f1_14; + RHS14 += f1_14 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_14 = -f2 * m_A32; + m_A35 += m_A5 * f2_14; + RHS14 += f2_14 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_15 = -f3 * m_A37; + m_A38 += m_A7 * f3_15; + RHS15 += f3_15 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_14 = -f4 * m_A33; + m_A35 += m_A9 * f4_14; + RHS14 += f4_14 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_14 = -f5 * m_A34; + m_A35 += m_A11 * f5_14; + m_A36 += m_A12 * f5_14; + RHS14 += f5_14 * RHS5; + const double f5_17 = -f5 * m_A42; + m_A44 += m_A11 * f5_17; + m_A46 += m_A12 * f5_17; + RHS17 += f5_17 * RHS5; + const double f6 = 1.0 / m_A13; + const double f6_18 = -f6 * m_A48; + m_A58 += m_A14 * f6_18; + RHS18 += f6_18 * RHS6; + const double f7 = 1.0 / m_A15; + const double f7_18 = -f7 * m_A49; + m_A58 += m_A16 * f7_18; + RHS18 += f7_18 * RHS7; + const double f8 = 1.0 / m_A17; + const double f8_18 = -f8 * m_A50; + m_A58 += m_A18 * f8_18; + RHS18 += f8_18 * RHS8; + const double f9 = 1.0 / m_A19; + const double f9_18 = -f9 * m_A51; + m_A58 += m_A20 * f9_18; + RHS18 += f9_18 * RHS9; + const double f10 = 1.0 / m_A21; + const double f10_17 = -f10 * m_A43; + m_A46 += m_A22 * f10_17; + m_A47 += m_A23 * f10_17; + RHS17 += f10_17 * RHS10; + const double f10_18 = -f10 * m_A52; + m_A57 += m_A22 * f10_18; + m_A58 += m_A23 * f10_18; + RHS18 += f10_18 * RHS10; + const double f11 = 1.0 / m_A24; + const double f11_18 = -f11 * m_A53; + m_A58 += m_A25 * f11_18; + RHS18 += f11_18 * RHS11; + const double f12 = 1.0 / m_A26; + const double f12_18 = -f12 * m_A54; + m_A58 += m_A27 * f12_18; + RHS18 += f12_18 * RHS12; + const double f13 = 1.0 / m_A28; + const double f13_18 = -f13 * m_A55; + m_A58 += m_A29 * f13_18; + RHS18 += f13_18 * RHS13; + const double f14 = 1.0 / m_A35; + const double f14_17 = -f14 * m_A44; + m_A46 += m_A36 * f14_17; + RHS17 += f14_17 * RHS14; + const double f15 = 1.0 / m_A38; + const double f15_17 = -f15 * m_A45; + m_A46 += m_A39 * f15_17; + RHS17 += f15_17 * RHS15; + const double f16 = 1.0 / m_A40; + const double f16_18 = -f16 * m_A56; + m_A58 += m_A41 * f16_18; + RHS18 += f16_18 * RHS16; + const double f17 = 1.0 / m_A46; + const double f17_18 = -f17 * m_A57; + m_A58 += m_A47 * f17_18; + RHS18 += f17_18 * RHS17; + V[18] = RHS18 / m_A58; + double tmp17 = 0.0; + tmp17 += m_A47 * V[18]; + V[17] = (RHS17 - tmp17) / m_A46; + double tmp16 = 0.0; + tmp16 += m_A41 * V[18]; + V[16] = (RHS16 - tmp16) / m_A40; + double tmp15 = 0.0; + tmp15 += m_A39 * V[17]; + V[15] = (RHS15 - tmp15) / m_A38; + double tmp14 = 0.0; + tmp14 += m_A36 * V[17]; + V[14] = (RHS14 - tmp14) / m_A35; + double tmp13 = 0.0; + tmp13 += m_A29 * V[18]; + V[13] = (RHS13 - tmp13) / m_A28; + double tmp12 = 0.0; + tmp12 += m_A27 * V[18]; + V[12] = (RHS12 - tmp12) / m_A26; + double tmp11 = 0.0; + tmp11 += m_A25 * V[18]; + V[11] = (RHS11 - tmp11) / m_A24; + double tmp10 = 0.0; + tmp10 += m_A22 * V[17]; + tmp10 += m_A23 * V[18]; + V[10] = (RHS10 - tmp10) / m_A21; + double tmp9 = 0.0; + tmp9 += m_A20 * V[18]; + V[9] = (RHS9 - tmp9) / m_A19; + double tmp8 = 0.0; + tmp8 += m_A18 * V[18]; + V[8] = (RHS8 - tmp8) / m_A17; + double tmp7 = 0.0; + tmp7 += m_A16 * V[18]; + V[7] = (RHS7 - tmp7) / m_A15; + double tmp6 = 0.0; + tmp6 += m_A14 * V[18]; + V[6] = (RHS6 - tmp6) / m_A13; + double tmp5 = 0.0; + tmp5 += m_A11 * V[14]; + tmp5 += m_A12 * V[17]; + V[5] = (RHS5 - tmp5) / m_A10; + double tmp4 = 0.0; + tmp4 += m_A9 * V[14]; + V[4] = (RHS4 - tmp4) / m_A8; + double tmp3 = 0.0; + tmp3 += m_A7 * V[15]; + 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[14]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // 1942 static void nl_gcr_b20cee3516465509_90_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -12315,6 +27963,343 @@ static void nl_gcr_b71f53c9e7a6b4a9_111_double_double(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// starhawk +static void nl_gcr_bbe87b4e0fbc0fd_45_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A0 += gt[6]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 += Idr[6]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + RHS0 -= go[5] * *cnV[5]; + RHS0 -= go[6] * *cnV[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A5 += go[11]; + double RHS2 = Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[12] * *cnV[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A7 += go[13]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + m_A8 += gt[16]; + m_A8 += gt[17]; + m_A8 += gt[18]; + m_A9 += go[16]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 -= go[17] * *cnV[17]; + RHS4 -= go[18] * *cnV[18]; + m_A10 += gt[19]; + m_A10 += gt[20]; + m_A10 += gt[21]; + m_A11 += go[19]; + double RHS5 = Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 -= go[20] * *cnV[20]; + RHS5 -= go[21] * *cnV[21]; + m_A12 += gt[22]; + m_A12 += gt[23]; + m_A12 += gt[24]; + m_A13 += go[22]; + double RHS6 = Idr[22]; + RHS6 += Idr[23]; + RHS6 += Idr[24]; + RHS6 -= go[23] * *cnV[23]; + RHS6 -= go[24] * *cnV[24]; + m_A14 += gt[25]; + m_A14 += gt[26]; + m_A15 += go[25]; + m_A16 += go[26]; + double RHS7 = Idr[25]; + RHS7 += Idr[26]; + m_A17 += gt[27]; + m_A17 += gt[28]; + m_A17 += gt[29]; + m_A18 += go[27]; + double RHS8 = Idr[27]; + RHS8 += Idr[28]; + RHS8 += Idr[29]; + RHS8 -= go[28] * *cnV[28]; + RHS8 -= go[29] * *cnV[29]; + m_A19 += gt[30]; + m_A19 += gt[31]; + m_A19 += gt[32]; + m_A20 += go[30]; + double RHS9 = Idr[30]; + RHS9 += Idr[31]; + RHS9 += Idr[32]; + RHS9 -= go[31] * *cnV[31]; + RHS9 -= go[32] * *cnV[32]; + m_A21 += gt[33]; + m_A21 += gt[34]; + m_A21 += gt[35]; + m_A22 += go[33]; + double RHS10 = Idr[33]; + RHS10 += Idr[34]; + RHS10 += Idr[35]; + RHS10 -= go[34] * *cnV[34]; + RHS10 -= go[35] * *cnV[35]; + m_A23 += gt[36]; + m_A23 += gt[37]; + m_A23 += gt[38]; + m_A24 += go[36]; + double RHS11 = Idr[36]; + RHS11 += Idr[37]; + RHS11 += Idr[38]; + RHS11 -= go[37] * *cnV[37]; + RHS11 -= go[38] * *cnV[38]; + m_A34 += gt[39]; + m_A34 += gt[40]; + m_A34 += gt[41]; + m_A34 += gt[42]; + m_A34 += gt[43]; + m_A34 += gt[44]; + m_A34 += gt[45]; + m_A34 += gt[46]; + m_A34 += gt[47]; + m_A34 += gt[48]; + m_A33 += go[39]; + m_A32 += go[40]; + m_A31 += go[41]; + m_A30 += go[42]; + m_A29 += go[43]; + m_A28 += go[44]; + m_A27 += go[45]; + m_A26 += go[46]; + m_A25 += go[47]; + double RHS12 = Idr[39]; + RHS12 += Idr[40]; + RHS12 += Idr[41]; + RHS12 += Idr[42]; + RHS12 += Idr[43]; + RHS12 += Idr[44]; + RHS12 += Idr[45]; + RHS12 += Idr[46]; + RHS12 += Idr[47]; + RHS12 += Idr[48]; + RHS12 -= go[48] * *cnV[48]; + m_A38 += gt[49]; + m_A38 += gt[50]; + m_A38 += gt[51]; + m_A38 += gt[52]; + m_A38 += gt[53]; + m_A38 += gt[54]; + m_A36 += go[49]; + m_A39 += go[50]; + m_A37 += go[51]; + m_A37 += go[52]; + double RHS13 = Idr[49]; + RHS13 += Idr[50]; + RHS13 += Idr[51]; + RHS13 += Idr[52]; + RHS13 += Idr[53]; + RHS13 += Idr[54]; + RHS13 -= go[53] * *cnV[53]; + RHS13 -= go[54] * *cnV[54]; + m_A44 += gt[55]; + m_A44 += gt[56]; + m_A44 += gt[57]; + m_A44 += gt[58]; + m_A44 += gt[59]; + m_A41 += go[55]; + m_A40 += go[56]; + m_A43 += go[57]; + double RHS14 = Idr[55]; + RHS14 += Idr[56]; + RHS14 += Idr[57]; + RHS14 += Idr[58]; + RHS14 += Idr[59]; + RHS14 -= go[58] * *cnV[58]; + RHS14 -= go[59] * *cnV[59]; + const double f0 = 1.0 / m_A0; + const double f0_13 = -f0 * m_A36; + m_A37 += m_A1 * f0_13; + RHS13 += f0_13 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_13 = -f1 * m_A37; + m_A38 += m_A3 * f1_13; + RHS13 += f1_13 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_14 = -f2 * m_A40; + m_A44 += m_A5 * f2_14; + RHS14 += f2_14 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_12 = -f3 * m_A25; + m_A34 += m_A7 * f3_12; + RHS12 += f3_12 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_12 = -f4 * m_A26; + m_A34 += m_A9 * f4_12; + RHS12 += f4_12 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_12 = -f5 * m_A27; + m_A34 += m_A11 * f5_12; + RHS12 += f5_12 * RHS5; + const double f6 = 1.0 / m_A12; + const double f6_12 = -f6 * m_A28; + m_A34 += m_A13 * f6_12; + RHS12 += f6_12 * RHS6; + const double f7 = 1.0 / m_A14; + const double f7_12 = -f7 * m_A29; + m_A34 += m_A15 * f7_12; + m_A35 += m_A16 * f7_12; + RHS12 += f7_12 * RHS7; + const double f7_14 = -f7 * m_A41; + m_A42 += m_A15 * f7_14; + m_A44 += m_A16 * f7_14; + RHS14 += f7_14 * RHS7; + const double f8 = 1.0 / m_A17; + const double f8_12 = -f8 * m_A30; + m_A34 += m_A18 * f8_12; + RHS12 += f8_12 * RHS8; + const double f9 = 1.0 / m_A19; + const double f9_12 = -f9 * m_A31; + m_A34 += m_A20 * f9_12; + RHS12 += f9_12 * RHS9; + const double f10 = 1.0 / m_A21; + const double f10_12 = -f10 * m_A32; + m_A34 += m_A22 * f10_12; + RHS12 += f10_12 * RHS10; + const double f11 = 1.0 / m_A23; + const double f11_12 = -f11 * m_A33; + m_A34 += m_A24 * f11_12; + RHS12 += f11_12 * RHS11; + const double f12 = 1.0 / m_A34; + const double f12_14 = -f12 * m_A42; + m_A44 += m_A35 * f12_14; + RHS14 += f12_14 * RHS12; + const double f13 = 1.0 / m_A38; + const double f13_14 = -f13 * m_A43; + m_A44 += m_A39 * f13_14; + RHS14 += f13_14 * RHS13; + V[14] = RHS14 / m_A44; + double tmp13 = 0.0; + tmp13 += m_A39 * V[14]; + V[13] = (RHS13 - tmp13) / m_A38; + double tmp12 = 0.0; + tmp12 += m_A35 * V[14]; + V[12] = (RHS12 - tmp12) / m_A34; + double tmp11 = 0.0; + tmp11 += m_A24 * V[12]; + V[11] = (RHS11 - tmp11) / m_A23; + double tmp10 = 0.0; + tmp10 += m_A22 * V[12]; + V[10] = (RHS10 - tmp10) / m_A21; + double tmp9 = 0.0; + tmp9 += m_A20 * V[12]; + V[9] = (RHS9 - tmp9) / m_A19; + double tmp8 = 0.0; + tmp8 += m_A18 * V[12]; + V[8] = (RHS8 - tmp8) / m_A17; + double tmp7 = 0.0; + tmp7 += m_A15 * V[12]; + tmp7 += m_A16 * V[14]; + V[7] = (RHS7 - tmp7) / m_A14; + double tmp6 = 0.0; + tmp6 += m_A13 * V[12]; + 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[14]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[13]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[1]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // 280zzzap static void nl_gcr_bcf0e3af19330ca7_116_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -13077,6 +29062,268 @@ static void nl_gcr_bcf0e3af19330ca7_116_double_double(double * __restrict V, con V[0] = (RHS0 - tmp0) / m_A0; } +// sundance +static void nl_gcr_c5fe9fb6df29b76d_8_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[0] * *cnV[0]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A1 += gt[3]; + m_A1 += gt[4]; + m_A1 += gt[5]; + m_A1 += gt[6]; + m_A1 += gt[7]; + m_A1 += gt[8]; + m_A1 += gt[9]; + m_A2 += go[3]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + RHS1 -= go[9] * *cnV[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A3 += go[10]; + double RHS2 = Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + RHS2 -= go[13] * *cnV[13]; + m_A7 += gt[14]; + m_A7 += gt[15]; + m_A7 += gt[16]; + m_A5 += go[14]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 -= go[15] * *cnV[15]; + RHS3 -= go[16] * *cnV[16]; + const double f0 = 1.0 / m_A0; + const double f0_2 = -f0 * m_A3; + RHS2 += f0_2 * RHS0; + const double f1 = 1.0 / m_A1; + const double f1_3 = -f1 * m_A5; + m_A6 += m_A2 * f1_3; + RHS3 += f1_3 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_3 = -f2 * m_A6; + RHS3 += f2_3 * RHS2; + V[3] = RHS3 / m_A7; + double tmp2 = 0.0; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A2 * V[2]; + V[1] = (RHS1 - tmp1) / m_A1; + double tmp0 = 0.0; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// boxingb +static void nl_gcr_c88598a61904fb99_23_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A4 += go[3]; + m_A3 += go[4]; + m_A3 += go[5]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A7 += go[9]; + m_A6 += go[10]; + m_A6 += go[11]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[12] * *cnV[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A9 += go[13]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 -= go[14] * *cnV[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A12 += gt[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A11 += go[15]; + m_A11 += go[16]; + m_A10 += go[17]; + double RHS4 = Idr[15]; + RHS4 += Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 -= go[18] * *cnV[18]; + RHS4 -= go[19] * *cnV[19]; + RHS4 -= go[20] * *cnV[20]; + m_A17 += gt[21]; + m_A17 += gt[22]; + m_A17 += gt[23]; + m_A17 += gt[24]; + m_A17 += gt[25]; + m_A15 += go[21]; + m_A15 += go[22]; + m_A14 += go[23]; + double RHS5 = Idr[21]; + RHS5 += Idr[22]; + RHS5 += Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 -= go[24] * *cnV[24]; + RHS5 -= go[25] * *cnV[25]; + m_A22 += gt[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A22 += gt[29]; + m_A22 += gt[30]; + m_A20 += go[26]; + m_A19 += go[27]; + double RHS6 = Idr[26]; + RHS6 += Idr[27]; + RHS6 += Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 -= go[28] * *cnV[28]; + RHS6 -= go[29] * *cnV[29]; + RHS6 -= go[30] * *cnV[30]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_4 = -f1 * m_A11; + m_A12 += m_A3 * f1_4; + m_A13 += m_A4 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_5 = -f1 * m_A14; + m_A16 += m_A3 * f1_5; + m_A17 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_5 = -f2 * m_A15; + m_A17 += m_A6 * f2_5; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f2_6 = -f2 * m_A19; + m_A21 += m_A6 * f2_6; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_6 = -f3 * m_A20; + m_A22 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_5 = -f4 * m_A16; + m_A17 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[6]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[5]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[6]; + V[3] = (RHS3 - tmp3) / m_A8; + 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_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; +} + // 280zzzap static void nl_gcr_caa814c0740131f2_104_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -14608,6 +30855,469 @@ static void nl_gcr_cffc52225ebcec8f_20_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// solarq +static void nl_gcr_d007166ab411b608_25_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A2 += gt[11]; + m_A5 += go[4]; + m_A4 += go[5]; + m_A4 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A7 += go[12]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 -= go[13] * *cnV[13]; + m_A10 += gt[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A9 += go[14]; + m_A9 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + RHS3 -= go[19] * *cnV[19]; + m_A15 += gt[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A16 += go[20]; + m_A16 += go[21]; + m_A13 += go[22]; + m_A13 += go[23]; + double RHS4 = Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 -= go[24] * *cnV[24]; + m_A18 += gt[25]; + m_A18 += gt[26]; + m_A18 += gt[27]; + m_A19 += go[25]; + m_A17 += go[26]; + double RHS5 = Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 -= go[27] * *cnV[27]; + m_A24 += gt[28]; + m_A24 += gt[29]; + m_A24 += gt[30]; + m_A24 += gt[31]; + m_A23 += go[28]; + m_A22 += go[29]; + m_A22 += go[30]; + m_A20 += go[31]; + double RHS6 = Idr[28]; + RHS6 += Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A9; + m_A10 += m_A3 * f1_3; + m_A11 += m_A4 * f1_3; + m_A12 += m_A5 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_4 = -f1 * m_A13; + m_A14 += m_A3 * f1_4; + m_A15 += m_A4 * f1_4; + m_A16 += m_A5 * f1_4; + RHS4 += f1_4 * RHS1; + const double f1_6 = -f1 * m_A20; + m_A21 += m_A3 * f1_6; + m_A22 += m_A4 * f1_6; + m_A24 += m_A5 * f1_6; + RHS6 += f1_6 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_5 = -f2 * m_A17; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += m_A12 * f3_4; + RHS4 += f3_4 * RHS3; + const double f3_6 = -f3 * m_A21; + m_A22 += m_A11 * f3_6; + m_A24 += m_A12 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A15; + const double f4_6 = -f4 * m_A22; + m_A24 += m_A16 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A18; + const double f5_6 = -f5 * m_A23; + m_A24 += m_A19 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A24; + double tmp5 = 0.0; + tmp5 += m_A19 * V[6]; + V[5] = (RHS5 - tmp5) / m_A18; + double tmp4 = 0.0; + tmp4 += m_A16 * V[6]; + V[4] = (RHS4 - tmp4) / m_A15; + double tmp3 = 0.0; + tmp3 += m_A11 * V[4]; + tmp3 += m_A12 * V[6]; + V[3] = (RHS3 - tmp3) / m_A10; + double tmp2 = 0.0; + tmp2 += m_A7 * V[5]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + tmp1 += m_A4 * V[4]; + tmp1 += m_A5 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// starhawk +static void nl_gcr_d150d48b17f73102_40_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 -= go[3] * *cnV[3]; + RHS1 -= go[4] * *cnV[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A5 += go[5]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[6] * *cnV[6]; + RHS2 -= go[7] * *cnV[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A8 += go[8]; + m_A8 += go[9]; + m_A7 += go[10]; + double RHS3 = Idr[8]; + RHS3 += Idr[9]; + RHS3 += Idr[10]; + m_A9 += gt[11]; + m_A9 += gt[12]; + m_A9 += gt[13]; + m_A9 += gt[14]; + m_A9 += gt[15]; + m_A9 += gt[16]; + m_A9 += gt[17]; + m_A10 += go[11]; + double RHS4 = Idr[11]; + RHS4 += Idr[12]; + RHS4 += Idr[13]; + RHS4 += Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 += Idr[17]; + RHS4 -= go[12] * *cnV[12]; + RHS4 -= go[13] * *cnV[13]; + RHS4 -= go[14] * *cnV[14]; + RHS4 -= go[15] * *cnV[15]; + RHS4 -= go[16] * *cnV[16]; + RHS4 -= go[17] * *cnV[17]; + m_A11 += gt[18]; + m_A11 += gt[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A12 += go[18]; + m_A12 += go[19]; + m_A13 += go[20]; + double RHS5 = Idr[18]; + RHS5 += Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 -= go[21] * *cnV[21]; + m_A14 += gt[22]; + m_A14 += gt[23]; + m_A16 += go[22]; + m_A15 += go[23]; + double RHS6 = Idr[22]; + RHS6 += Idr[23]; + m_A19 += gt[24]; + m_A19 += gt[25]; + m_A19 += gt[26]; + m_A18 += go[24]; + m_A17 += go[25]; + double RHS7 = Idr[24]; + RHS7 += Idr[25]; + RHS7 += Idr[26]; + RHS7 -= go[26] * *cnV[26]; + m_A22 += gt[27]; + m_A22 += gt[28]; + m_A22 += gt[29]; + m_A23 += go[27]; + m_A21 += go[28]; + double RHS8 = Idr[27]; + RHS8 += Idr[28]; + RHS8 += Idr[29]; + RHS8 -= go[29] * *cnV[29]; + m_A26 += gt[30]; + m_A26 += gt[31]; + m_A26 += gt[32]; + m_A25 += go[30]; + m_A24 += go[31]; + double RHS9 = Idr[30]; + RHS9 += Idr[31]; + RHS9 += Idr[32]; + RHS9 -= go[32] * *cnV[32]; + m_A32 += gt[33]; + m_A32 += gt[34]; + m_A32 += gt[35]; + m_A32 += gt[36]; + m_A32 += gt[37]; + m_A32 += gt[38]; + m_A28 += go[33]; + m_A30 += go[34]; + m_A29 += go[35]; + m_A29 += go[36]; + double RHS10 = Idr[33]; + RHS10 += Idr[34]; + RHS10 += Idr[35]; + RHS10 += Idr[36]; + RHS10 += Idr[37]; + RHS10 += Idr[38]; + RHS10 -= go[37] * *cnV[37]; + RHS10 -= go[38] * *cnV[38]; + m_A39 += gt[39]; + m_A39 += gt[40]; + m_A39 += gt[41]; + m_A39 += gt[42]; + m_A35 += go[39]; + m_A37 += go[40]; + m_A34 += go[41]; + m_A34 += go[42]; + double RHS11 = Idr[39]; + RHS11 += Idr[40]; + RHS11 += Idr[41]; + RHS11 += Idr[42]; + const double f0 = 1.0 / m_A0; + const double f0_9 = -f0 * m_A24; + m_A26 += m_A1 * f0_9; + RHS9 += f0_9 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_7 = -f1 * m_A17; + m_A19 += m_A3 * f1_7; + RHS7 += f1_7 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_8 = -f2 * m_A21; + m_A22 += m_A5 * f2_8; + RHS8 += f2_8 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_7 = -f3 * m_A18; + m_A19 += m_A7 * f3_7; + m_A20 += m_A8 * f3_7; + RHS7 += f3_7 * RHS3; + const double f3_11 = -f3 * m_A34; + m_A36 += m_A7 * f3_11; + m_A39 += m_A8 * f3_11; + RHS11 += f3_11 * RHS3; + const double f4 = 1.0 / m_A9; + const double f4_10 = -f4 * m_A28; + m_A29 += m_A10 * f4_10; + RHS10 += f4_10 * RHS4; + const double f5 = 1.0 / m_A11; + const double f5_10 = -f5 * m_A29; + m_A32 += m_A12 * f5_10; + m_A33 += m_A13 * f5_10; + RHS10 += f5_10 * RHS5; + const double f5_11 = -f5 * m_A35; + m_A38 += m_A12 * f5_11; + m_A39 += m_A13 * f5_11; + RHS11 += f5_11 * RHS5; + const double f6 = 1.0 / m_A14; + const double f6_9 = -f6 * m_A25; + m_A26 += m_A15 * f6_9; + m_A27 += m_A16 * f6_9; + RHS9 += f6_9 * RHS6; + const double f6_10 = -f6 * m_A30; + m_A31 += m_A15 * f6_10; + m_A32 += m_A16 * f6_10; + RHS10 += f6_10 * RHS6; + const double f7 = 1.0 / m_A19; + const double f7_11 = -f7 * m_A36; + m_A39 += m_A20 * f7_11; + RHS11 += f7_11 * RHS7; + const double f8 = 1.0 / m_A22; + const double f8_11 = -f8 * m_A37; + m_A39 += m_A23 * f8_11; + RHS11 += f8_11 * RHS8; + const double f9 = 1.0 / m_A26; + const double f9_10 = -f9 * m_A31; + m_A32 += m_A27 * f9_10; + RHS10 += f9_10 * RHS9; + const double f10 = 1.0 / m_A32; + const double f10_11 = -f10 * m_A38; + m_A39 += m_A33 * f10_11; + RHS11 += f10_11 * RHS10; + V[11] = RHS11 / m_A39; + double tmp10 = 0.0; + tmp10 += m_A33 * V[11]; + V[10] = (RHS10 - tmp10) / m_A32; + double tmp9 = 0.0; + tmp9 += m_A27 * V[10]; + V[9] = (RHS9 - tmp9) / m_A26; + double tmp8 = 0.0; + tmp8 += m_A23 * V[11]; + V[8] = (RHS8 - tmp8) / m_A22; + double tmp7 = 0.0; + tmp7 += m_A20 * V[11]; + V[7] = (RHS7 - tmp7) / m_A19; + double tmp6 = 0.0; + tmp6 += m_A15 * V[9]; + tmp6 += m_A16 * V[10]; + V[6] = (RHS6 - tmp6) / m_A14; + double tmp5 = 0.0; + tmp5 += m_A12 * V[10]; + tmp5 += m_A13 * V[11]; + V[5] = (RHS5 - tmp5) / m_A11; + double tmp4 = 0.0; + tmp4 += m_A10 * V[5]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A7 * V[7]; + tmp3 += m_A8 * V[11]; + 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[7]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[9]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // popeye static void nl_gcr_d153cd8a3df26761_50_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -14943,6 +31653,175 @@ static void nl_gcr_d153cd8a3df26761_50_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// tailg +static void nl_gcr_d162007d1b602940_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A4 += go[2]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[7]; + m_A7 += go[8]; + m_A5 += go[9]; + m_A5 += go[10]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[11] * *cnV[11]; + m_A11 += gt[12]; + m_A11 += gt[13]; + m_A11 += gt[14]; + m_A11 += gt[15]; + m_A10 += go[12]; + m_A10 += go[13]; + m_A9 += go[14]; + m_A8 += go[15]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A11 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_2 = -f1 * m_A5; + m_A6 += m_A3 * f1_2; + m_A7 += 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_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_A3 * V[2]; + tmp1 += m_A4 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// warrior +static void nl_gcr_d1943a7f9348144f_12_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A4 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + m_A7 += gt[5]; + m_A7 += gt[6]; + m_A7 += gt[7]; + m_A6 += go[5]; + m_A5 += go[6]; + double RHS2 = Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 -= go[7] * *cnV[7]; + m_A11 += gt[8]; + m_A9 += go[8]; + double RHS3 = Idr[8]; + 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; +} + // dpatrol static void nl_gcr_d229cf0026955cd3_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -15021,6 +31900,286 @@ static void nl_gcr_d229cf0026955cd3_10_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// armora +static void nl_gcr_d3ccfc0e9cc1acf8_9_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A2 += go[0]; + m_A1 += go[1]; + m_A1 += go[2]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + m_A4 += gt[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A5 += go[3]; + m_A5 += go[4]; + m_A3 += go[5]; + m_A3 += go[6]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + m_A8 += gt[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A7 += go[7]; + m_A7 += go[8]; + m_A6 += go[9]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + const double f0 = 1.0 / m_A0; + const double f0_1 = -f0 * m_A3; + m_A4 += m_A1 * f0_1; + m_A5 += m_A2 * f0_1; + RHS1 += f0_1 * RHS0; + 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 f1 = 1.0 / m_A4; + const double f1_2 = -f1 * m_A7; + m_A8 += m_A5 * f1_2; + RHS2 += f1_2 * RHS1; + V[2] = RHS2 / m_A8; + double tmp1 = 0.0; + tmp1 += m_A5 * V[2]; + V[1] = (RHS1 - tmp1) / m_A4; + double tmp0 = 0.0; + tmp0 += m_A1 * V[1]; + tmp0 += m_A2 * V[2]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// boxingb +static void nl_gcr_d58f17ecf07ad3a9_29_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A4 += go[3]; + m_A3 += go[4]; + m_A3 += go[5]; + double RHS1 = Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A7 += go[9]; + m_A6 += go[10]; + m_A6 += go[11]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[12] * *cnV[12]; + m_A8 += gt[13]; + m_A8 += gt[14]; + m_A9 += go[13]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 -= go[14] * *cnV[14]; + m_A10 += gt[15]; + m_A10 += gt[16]; + m_A11 += go[15]; + double RHS4 = Idr[15]; + RHS4 += Idr[16]; + RHS4 -= go[16] * *cnV[16]; + m_A14 += gt[17]; + m_A14 += gt[18]; + m_A14 += gt[19]; + m_A14 += gt[20]; + m_A14 += gt[21]; + m_A14 += gt[22]; + m_A13 += go[17]; + m_A13 += go[18]; + m_A12 += go[19]; + double RHS5 = Idr[17]; + RHS5 += Idr[18]; + RHS5 += Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 -= go[20] * *cnV[20]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + m_A19 += gt[23]; + m_A19 += gt[24]; + m_A19 += gt[25]; + m_A19 += gt[26]; + m_A19 += gt[27]; + m_A17 += go[23]; + m_A17 += go[24]; + m_A16 += go[25]; + double RHS6 = Idr[23]; + RHS6 += Idr[24]; + RHS6 += Idr[25]; + RHS6 += Idr[26]; + RHS6 += Idr[27]; + RHS6 -= go[26] * *cnV[26]; + RHS6 -= go[27] * *cnV[27]; + m_A24 += gt[28]; + m_A24 += gt[29]; + m_A24 += gt[30]; + m_A24 += gt[31]; + m_A24 += gt[32]; + m_A24 += gt[33]; + m_A22 += go[28]; + m_A25 += go[29]; + m_A21 += go[30]; + double RHS7 = Idr[28]; + RHS7 += Idr[29]; + RHS7 += Idr[30]; + RHS7 += Idr[31]; + RHS7 += Idr[32]; + RHS7 += Idr[33]; + RHS7 -= go[31] * *cnV[31]; + RHS7 -= go[32] * *cnV[32]; + RHS7 -= go[33] * *cnV[33]; + m_A28 += gt[34]; + m_A28 += gt[35]; + m_A26 += go[34]; + m_A27 += go[35]; + double RHS8 = Idr[34]; + RHS8 += Idr[35]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A12; + m_A14 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A13; + m_A14 += m_A3 * f1_5; + m_A15 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f1_6 = -f1 * m_A16; + m_A18 += m_A3 * f1_6; + 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; + m_A20 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f2_7 = -f2 * m_A21; + m_A23 += m_A6 * f2_7; + m_A24 += m_A7 * f2_7; + RHS7 += f2_7 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_7 = -f3 * m_A22; + m_A24 += m_A9 * f3_7; + RHS7 += f3_7 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_8 = -f4 * m_A26; + m_A28 += m_A11 * f4_8; + RHS8 += f4_8 * RHS4; + const double f5 = 1.0 / m_A14; + const double f5_6 = -f5 * m_A18; + m_A19 += m_A15 * f5_6; + RHS6 += f5_6 * RHS5; + const double f6 = 1.0 / m_A19; + const double f6_7 = -f6 * m_A23; + m_A24 += m_A20 * f6_7; + RHS7 += f6_7 * RHS6; + const double f7 = 1.0 / m_A24; + const double f7_8 = -f7 * m_A27; + m_A28 += m_A25 * f7_8; + RHS8 += f7_8 * RHS7; + V[8] = RHS8 / m_A28; + double tmp7 = 0.0; + tmp7 += m_A25 * V[8]; + V[7] = (RHS7 - tmp7) / m_A24; + double tmp6 = 0.0; + tmp6 += m_A20 * V[7]; + V[6] = (RHS6 - tmp6) / m_A19; + double tmp5 = 0.0; + tmp5 += m_A15 * V[6]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A11 * V[8]; + V[4] = (RHS4 - tmp4) / m_A10; + double tmp3 = 0.0; + tmp3 += m_A9 * V[7]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A6 * V[6]; + tmp2 += m_A7 * V[7]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[5]; + tmp1 += m_A4 * V[6]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // 280zzzap static void nl_gcr_d5f69adb177fea36_31_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -15239,6 +32398,444 @@ static void nl_gcr_d5f69adb177fea36_31_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// spacewar +static void nl_gcr_d6665015de207c49_24_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A6 += gt[6]; + m_A6 += gt[7]; + m_A7 += go[6]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + RHS3 -= go[7] * *cnV[7]; + m_A8 += gt[8]; + m_A8 += gt[9]; + m_A9 += go[8]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + RHS4 -= go[9] * *cnV[9]; + m_A10 += gt[10]; + m_A10 += gt[11]; + m_A10 += gt[12]; + m_A12 += go[10]; + m_A11 += go[11]; + double RHS5 = Idr[10]; + RHS5 += Idr[11]; + RHS5 += Idr[12]; + RHS5 -= go[12] * *cnV[12]; + m_A19 += gt[13]; + m_A19 += gt[14]; + m_A19 += gt[15]; + m_A19 += gt[16]; + m_A19 += gt[17]; + m_A19 += gt[18]; + m_A17 += go[13]; + m_A16 += go[14]; + m_A15 += go[15]; + m_A14 += go[16]; + m_A13 += go[17]; + m_A18 += go[18]; + double RHS6 = Idr[13]; + RHS6 += Idr[14]; + RHS6 += Idr[15]; + RHS6 += Idr[16]; + RHS6 += Idr[17]; + RHS6 += Idr[18]; + m_A23 += gt[19]; + m_A23 += gt[20]; + m_A23 += gt[21]; + m_A21 += go[19]; + double RHS7 = Idr[19]; + RHS7 += Idr[20]; + RHS7 += Idr[21]; + RHS7 -= go[20] * *cnV[20]; + RHS7 -= go[21] * *cnV[21]; + const double f0 = 1.0 / m_A0; + const double f0_6 = -f0 * m_A13; + m_A19 += m_A1 * f0_6; + RHS6 += f0_6 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A14; + m_A19 += m_A3 * f1_6; + RHS6 += f1_6 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_6 = -f2 * m_A15; + m_A19 += m_A5 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_6 = -f3 * m_A16; + m_A19 += m_A7 * f3_6; + RHS6 += f3_6 * RHS3; + const double f4 = 1.0 / m_A8; + const double f4_6 = -f4 * m_A17; + m_A19 += m_A9 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A10; + const double f5_6 = -f5 * m_A18; + m_A19 += m_A11 * f5_6; + m_A20 += m_A12 * f5_6; + RHS6 += f5_6 * RHS5; + const double f5_7 = -f5 * m_A21; + m_A22 += m_A11 * f5_7; + m_A23 += m_A12 * f5_7; + RHS7 += f5_7 * RHS5; + const double f6 = 1.0 / m_A19; + const double f6_7 = -f6 * m_A22; + m_A23 += m_A20 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A23; + double tmp6 = 0.0; + tmp6 += m_A20 * V[7]; + V[6] = (RHS6 - tmp6) / m_A19; + double tmp5 = 0.0; + tmp5 += m_A11 * V[6]; + tmp5 += m_A12 * V[7]; + 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; +} + +// tailg +static void nl_gcr_d8ceb483a3003a15_23_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A4 += go[2]; + m_A3 += go[3]; + m_A3 += go[4]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + m_A5 += gt[7]; + m_A5 += gt[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A5 += gt[12]; + m_A7 += go[7]; + m_A6 += go[8]; + m_A6 += go[9]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 -= go[10] * *cnV[10]; + RHS2 -= go[11] * *cnV[11]; + RHS2 -= go[12] * *cnV[12]; + m_A9 += gt[13]; + m_A9 += gt[14]; + m_A9 += gt[15]; + m_A9 += gt[16]; + m_A9 += gt[17]; + m_A10 += go[13]; + m_A10 += go[14]; + m_A8 += go[15]; + m_A8 += go[16]; + double RHS3 = Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 -= go[17] * *cnV[17]; + m_A12 += gt[18]; + m_A12 += gt[19]; + m_A12 += gt[20]; + m_A12 += gt[21]; + m_A12 += gt[22]; + m_A13 += go[18]; + m_A13 += go[19]; + m_A11 += go[20]; + m_A11 += go[21]; + double RHS4 = Idr[18]; + RHS4 += Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 -= go[22] * *cnV[22]; + m_A17 += gt[23]; + m_A17 += gt[24]; + m_A17 += gt[25]; + m_A17 += gt[26]; + m_A17 += gt[27]; + m_A17 += gt[28]; + m_A18 += go[23]; + m_A16 += go[24]; + m_A16 += go[25]; + m_A15 += go[26]; + m_A14 += go[27]; + double RHS5 = Idr[23]; + RHS5 += Idr[24]; + RHS5 += Idr[25]; + RHS5 += Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 -= go[28] * *cnV[28]; + m_A22 += gt[29]; + m_A22 += gt[30]; + m_A22 += gt[31]; + m_A22 += gt[32]; + m_A20 += go[29]; + m_A20 += go[30]; + m_A19 += go[31]; + m_A21 += go[32]; + double RHS6 = Idr[29]; + RHS6 += Idr[30]; + RHS6 += Idr[31]; + RHS6 += Idr[32]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A14; + m_A17 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A8; + m_A9 += m_A3 * f1_3; + m_A10 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; + const double f1_5 = -f1 * m_A15; + m_A16 += m_A3 * f1_5; + m_A17 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A11; + m_A12 += m_A6 * f2_4; + m_A13 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_6 = -f2 * m_A19; + m_A20 += m_A6 * f2_6; + m_A22 += m_A7 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A9; + const double f3_5 = -f3 * m_A16; + m_A17 += m_A10 * f3_5; + RHS5 += f3_5 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_6 = -f4 * m_A20; + m_A22 += m_A13 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A17; + const double f5_6 = -f5 * m_A21; + m_A22 += m_A18 * f5_6; + RHS6 += f5_6 * RHS5; + V[6] = RHS6 / m_A22; + double tmp5 = 0.0; + tmp5 += m_A18 * V[6]; + V[5] = (RHS5 - tmp5) / m_A17; + double tmp4 = 0.0; + tmp4 += m_A13 * V[6]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A10 * V[5]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[6]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + tmp1 += m_A4 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// ripoff +static void nl_gcr_da46a6e4fdedac9d_16_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 -= go[5] * *cnV[5]; + m_A7 += gt[6]; + m_A7 += gt[7]; + m_A6 += go[6]; + m_A8 += go[7]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + m_A10 += gt[8]; + m_A10 += gt[9]; + m_A9 += go[8]; + m_A11 += go[9]; + double RHS4 = Idr[8]; + RHS4 += Idr[9]; + m_A15 += gt[10]; + m_A15 += gt[11]; + m_A15 += gt[12]; + m_A15 += gt[13]; + m_A14 += go[10]; + m_A13 += go[11]; + m_A12 += go[12]; + double RHS5 = Idr[10]; + RHS5 += Idr[11]; + RHS5 += Idr[12]; + RHS5 += Idr[13]; + RHS5 -= go[13] * *cnV[13]; + const double f0 = 1.0 / m_A0; + const double f0_5 = -f0 * m_A12; + m_A15 += m_A1 * f0_5; + RHS5 += f0_5 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_3 = -f1 * m_A6; + m_A7 += m_A3 * f1_3; + RHS3 += f1_3 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_4 = -f2 * m_A9; + m_A10 += m_A5 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A7; + const double f3_5 = -f3 * m_A13; + m_A15 += m_A8 * f3_5; + RHS5 += f3_5 * RHS3; + const double f4 = 1.0 / m_A10; + const double f4_5 = -f4 * m_A14; + m_A15 += m_A11 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A15; + double tmp4 = 0.0; + tmp4 += m_A11 * V[5]; + 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_A5 * V[4]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[3]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[5]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // gamemachine static void nl_gcr_ddffc2781d05acf_10_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -15317,6 +32914,400 @@ static void nl_gcr_ddffc2781d05acf_10_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb +static void nl_gcr_de76ad96046b8593_55_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A2 += gt[9]; + m_A2 += gt[10]; + m_A2 += gt[11]; + m_A5 += go[4]; + m_A4 += go[5]; + m_A4 += go[6]; + m_A3 += go[7]; + m_A3 += go[8]; + double RHS1 = Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 += Idr[9]; + RHS1 += Idr[10]; + RHS1 += Idr[11]; + RHS1 -= go[9] * *cnV[9]; + RHS1 -= go[10] * *cnV[10]; + RHS1 -= go[11] * *cnV[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A8 += go[12]; + m_A7 += go[13]; + double RHS2 = Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 -= go[14] * *cnV[14]; + m_A9 += gt[15]; + m_A9 += gt[16]; + m_A9 += gt[17]; + m_A9 += gt[18]; + m_A10 += go[15]; + double RHS3 = Idr[15]; + RHS3 += Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 -= go[16] * *cnV[16]; + RHS3 -= go[17] * *cnV[17]; + RHS3 -= go[18] * *cnV[18]; + m_A11 += gt[19]; + m_A11 += gt[20]; + m_A11 += gt[21]; + m_A11 += gt[22]; + m_A11 += gt[23]; + m_A11 += gt[24]; + m_A11 += gt[25]; + m_A11 += gt[26]; + m_A14 += go[19]; + m_A13 += go[20]; + m_A13 += go[21]; + m_A12 += go[22]; + m_A12 += go[23]; + double RHS4 = Idr[19]; + RHS4 += Idr[20]; + RHS4 += Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 += Idr[26]; + RHS4 -= go[24] * *cnV[24]; + RHS4 -= go[25] * *cnV[25]; + RHS4 -= go[26] * *cnV[26]; + m_A15 += gt[27]; + m_A15 += gt[28]; + m_A15 += gt[29]; + m_A17 += go[27]; + m_A16 += go[28]; + double RHS5 = Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 -= go[29] * *cnV[29]; + m_A20 += gt[30]; + m_A20 += gt[31]; + m_A20 += gt[32]; + m_A20 += gt[33]; + m_A20 += gt[34]; + m_A20 += gt[35]; + m_A19 += go[30]; + m_A19 += go[31]; + m_A18 += go[32]; + double RHS6 = Idr[30]; + RHS6 += Idr[31]; + RHS6 += Idr[32]; + RHS6 += Idr[33]; + RHS6 += Idr[34]; + RHS6 += Idr[35]; + RHS6 -= go[33] * *cnV[33]; + RHS6 -= go[34] * *cnV[34]; + RHS6 -= go[35] * *cnV[35]; + m_A25 += gt[36]; + m_A25 += gt[37]; + m_A25 += gt[38]; + m_A25 += gt[39]; + m_A25 += gt[40]; + m_A26 += go[36]; + m_A26 += go[37]; + m_A23 += go[38]; + m_A23 += go[39]; + double RHS7 = Idr[36]; + RHS7 += Idr[37]; + RHS7 += Idr[38]; + RHS7 += Idr[39]; + RHS7 += Idr[40]; + RHS7 -= go[40] * *cnV[40]; + m_A29 += gt[41]; + m_A29 += gt[42]; + m_A29 += gt[43]; + m_A29 += gt[44]; + m_A29 += gt[45]; + m_A29 += gt[46]; + m_A28 += go[41]; + m_A28 += go[42]; + m_A27 += go[43]; + double RHS8 = Idr[41]; + RHS8 += Idr[42]; + RHS8 += Idr[43]; + RHS8 += Idr[44]; + RHS8 += Idr[45]; + RHS8 += Idr[46]; + RHS8 -= go[44] * *cnV[44]; + RHS8 -= go[45] * *cnV[45]; + RHS8 -= go[46] * *cnV[46]; + m_A34 += gt[47]; + m_A34 += gt[48]; + m_A34 += gt[49]; + m_A34 += gt[50]; + m_A34 += gt[51]; + m_A35 += go[47]; + m_A35 += go[48]; + m_A32 += go[49]; + m_A32 += go[50]; + double RHS9 = Idr[47]; + RHS9 += Idr[48]; + RHS9 += Idr[49]; + RHS9 += Idr[50]; + RHS9 += Idr[51]; + RHS9 -= go[51] * *cnV[51]; + m_A38 += gt[52]; + m_A38 += gt[53]; + m_A38 += gt[54]; + m_A37 += go[52]; + m_A36 += go[53]; + double RHS10 = Idr[52]; + RHS10 += Idr[53]; + RHS10 += Idr[54]; + RHS10 -= go[54] * *cnV[54]; + m_A46 += gt[55]; + m_A46 += gt[56]; + m_A46 += gt[57]; + m_A46 += gt[58]; + m_A42 += go[55]; + m_A44 += go[56]; + m_A44 += go[57]; + m_A41 += go[58]; + double RHS11 = Idr[55]; + RHS11 += Idr[56]; + RHS11 += Idr[57]; + RHS11 += Idr[58]; + m_A54 += gt[59]; + m_A54 += gt[60]; + m_A54 += gt[61]; + m_A54 += gt[62]; + m_A49 += go[59]; + m_A51 += go[60]; + m_A51 += go[61]; + m_A48 += go[62]; + double RHS12 = Idr[59]; + RHS12 += Idr[60]; + RHS12 += Idr[61]; + RHS12 += Idr[62]; + const double f0 = 1.0 / m_A0; + const double f0_6 = -f0 * m_A18; + m_A20 += m_A1 * f0_6; + RHS6 += f0_6 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_6 = -f1 * m_A19; + m_A20 += m_A3 * f1_6; + m_A21 += m_A4 * f1_6; + m_A22 += m_A5 * f1_6; + RHS6 += f1_6 * RHS1; + const double f1_7 = -f1 * m_A23; + m_A24 += m_A3 * f1_7; + m_A25 += m_A4 * f1_7; + m_A26 += m_A5 * f1_7; + RHS7 += f1_7 * RHS1; + const double f1_11 = -f1 * m_A41; + m_A43 += m_A3 * f1_11; + m_A44 += m_A4 * f1_11; + m_A46 += m_A5 * f1_11; + RHS11 += f1_11 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_10 = -f2 * m_A36; + m_A38 += m_A7 * f2_10; + m_A39 += m_A8 * f2_10; + RHS10 += f2_10 * RHS2; + const double f2_11 = -f2 * m_A42; + m_A45 += m_A7 * f2_11; + m_A46 += m_A8 * f2_11; + RHS11 += f2_11 * RHS2; + const double f3 = 1.0 / m_A9; + const double f3_8 = -f3 * m_A27; + m_A29 += m_A10 * f3_8; + RHS8 += f3_8 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_8 = -f4 * m_A28; + m_A29 += m_A12 * f4_8; + m_A30 += m_A13 * f4_8; + m_A31 += m_A14 * f4_8; + RHS8 += f4_8 * RHS4; + const double f4_9 = -f4 * m_A32; + m_A33 += m_A12 * f4_9; + m_A34 += m_A13 * f4_9; + m_A35 += m_A14 * f4_9; + RHS9 += f4_9 * RHS4; + const double f4_12 = -f4 * m_A48; + m_A50 += m_A12 * f4_12; + m_A51 += m_A13 * f4_12; + m_A54 += m_A14 * f4_12; + RHS12 += f4_12 * RHS4; + const double f5 = 1.0 / m_A15; + const double f5_10 = -f5 * m_A37; + m_A38 += m_A16 * f5_10; + m_A40 += m_A17 * f5_10; + RHS10 += f5_10 * RHS5; + const double f5_12 = -f5 * m_A49; + m_A52 += m_A16 * f5_12; + m_A54 += m_A17 * f5_12; + RHS12 += f5_12 * RHS5; + const double f6 = 1.0 / m_A20; + const double f6_7 = -f6 * m_A24; + m_A25 += m_A21 * f6_7; + m_A26 += m_A22 * f6_7; + RHS7 += f6_7 * RHS6; + const double f6_11 = -f6 * m_A43; + m_A44 += m_A21 * f6_11; + m_A46 += m_A22 * f6_11; + RHS11 += f6_11 * RHS6; + const double f7 = 1.0 / m_A25; + const double f7_11 = -f7 * m_A44; + m_A46 += m_A26 * f7_11; + RHS11 += f7_11 * RHS7; + const double f8 = 1.0 / m_A29; + const double f8_9 = -f8 * m_A33; + m_A34 += m_A30 * f8_9; + m_A35 += m_A31 * f8_9; + RHS9 += f8_9 * RHS8; + const double f8_12 = -f8 * m_A50; + m_A51 += m_A30 * f8_12; + m_A54 += m_A31 * f8_12; + RHS12 += f8_12 * RHS8; + const double f9 = 1.0 / m_A34; + const double f9_12 = -f9 * m_A51; + m_A54 += m_A35 * f9_12; + RHS12 += f9_12 * RHS9; + const double f10 = 1.0 / m_A38; + const double f10_11 = -f10 * m_A45; + m_A46 += m_A39 * f10_11; + m_A47 += m_A40 * f10_11; + RHS11 += f10_11 * RHS10; + const double f10_12 = -f10 * m_A52; + m_A53 += m_A39 * f10_12; + m_A54 += m_A40 * f10_12; + RHS12 += f10_12 * RHS10; + const double f11 = 1.0 / m_A46; + const double f11_12 = -f11 * m_A53; + m_A54 += m_A47 * f11_12; + RHS12 += f11_12 * RHS11; + V[12] = RHS12 / m_A54; + double tmp11 = 0.0; + tmp11 += m_A47 * V[12]; + V[11] = (RHS11 - tmp11) / m_A46; + double tmp10 = 0.0; + tmp10 += m_A39 * V[11]; + tmp10 += m_A40 * V[12]; + V[10] = (RHS10 - tmp10) / m_A38; + double tmp9 = 0.0; + tmp9 += m_A35 * V[12]; + V[9] = (RHS9 - tmp9) / m_A34; + double tmp8 = 0.0; + tmp8 += m_A30 * V[9]; + tmp8 += m_A31 * V[12]; + V[8] = (RHS8 - tmp8) / m_A29; + double tmp7 = 0.0; + tmp7 += m_A26 * V[11]; + V[7] = (RHS7 - tmp7) / m_A25; + double tmp6 = 0.0; + tmp6 += m_A21 * V[7]; + tmp6 += m_A22 * V[11]; + V[6] = (RHS6 - tmp6) / m_A20; + double tmp5 = 0.0; + tmp5 += m_A16 * V[10]; + tmp5 += m_A17 * V[12]; + V[5] = (RHS5 - tmp5) / m_A15; + double tmp4 = 0.0; + tmp4 += m_A12 * V[8]; + tmp4 += m_A13 * V[9]; + tmp4 += m_A14 * V[12]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A10 * V[8]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A7 * V[10]; + tmp2 += m_A8 * V[11]; + V[2] = (RHS2 - tmp2) / m_A6; + double tmp1 = 0.0; + tmp1 += m_A3 * V[6]; + tmp1 += m_A4 * V[7]; + tmp1 += m_A5 * V[11]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[6]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // gamemachine static void nl_gcr_df3a545642cc0a22_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -15385,6 +33376,204 @@ static void nl_gcr_df3a545642cc0a22_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// ripoff +static void nl_gcr_e1a2833d004e0493_29_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A6 += go[4]; + m_A5 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + m_A7 += gt[6]; + m_A7 += gt[7]; + m_A7 += gt[8]; + m_A7 += gt[9]; + m_A7 += gt[10]; + m_A7 += gt[11]; + m_A7 += gt[12]; + m_A8 += go[6]; + double RHS3 = Idr[6]; + RHS3 += Idr[7]; + RHS3 += Idr[8]; + RHS3 += Idr[9]; + RHS3 += Idr[10]; + RHS3 += Idr[11]; + RHS3 += Idr[12]; + RHS3 -= go[7] * *cnV[7]; + RHS3 -= go[8] * *cnV[8]; + RHS3 -= go[9] * *cnV[9]; + RHS3 -= go[10] * *cnV[10]; + RHS3 -= go[11] * *cnV[11]; + RHS3 -= go[12] * *cnV[12]; + m_A9 += gt[13]; + m_A9 += gt[14]; + m_A11 += go[13]; + m_A10 += go[14]; + double RHS4 = Idr[13]; + RHS4 += Idr[14]; + m_A14 += gt[15]; + m_A14 += gt[16]; + m_A14 += gt[17]; + m_A12 += go[15]; + m_A13 += go[16]; + double RHS5 = Idr[15]; + RHS5 += Idr[16]; + RHS5 += Idr[17]; + RHS5 -= go[17] * *cnV[17]; + m_A18 += gt[18]; + m_A18 += gt[19]; + m_A18 += gt[20]; + m_A18 += gt[21]; + m_A19 += go[18]; + m_A19 += go[19]; + m_A16 += go[20]; + double RHS6 = Idr[18]; + RHS6 += Idr[19]; + RHS6 += Idr[20]; + RHS6 += Idr[21]; + RHS6 -= go[21] * *cnV[21]; + m_A22 += gt[22]; + m_A22 += gt[23]; + m_A22 += gt[24]; + m_A21 += go[22]; + m_A20 += go[23]; + double RHS7 = Idr[22]; + RHS7 += Idr[23]; + RHS7 += Idr[24]; + RHS7 -= go[24] * *cnV[24]; + m_A28 += gt[25]; + m_A28 += gt[26]; + m_A28 += gt[27]; + m_A28 += gt[28]; + m_A28 += gt[29]; + m_A28 += gt[30]; + m_A24 += go[25]; + m_A25 += go[26]; + m_A26 += go[27]; + m_A26 += go[28]; + double RHS8 = Idr[25]; + RHS8 += Idr[26]; + RHS8 += Idr[27]; + RHS8 += Idr[28]; + RHS8 += Idr[29]; + RHS8 += Idr[30]; + RHS8 -= go[29] * *cnV[29]; + RHS8 -= go[30] * *cnV[30]; + 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_5 = -f1 * m_A12; + m_A14 += m_A3 * f1_5; + RHS5 += f1_5 * 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_A16; + m_A17 += m_A5 * f2_6; + m_A18 += m_A6 * f2_6; + RHS6 += f2_6 * RHS2; + const double f3 = 1.0 / m_A7; + const double f3_8 = -f3 * m_A24; + m_A26 += m_A8 * f3_8; + RHS8 += f3_8 * 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; + RHS7 += f4_7 * RHS4; + const double f4_8 = -f4 * m_A25; + m_A27 += m_A10 * f4_8; + m_A28 += m_A11 * f4_8; + RHS8 += f4_8 * RHS4; + const double f5 = 1.0 / m_A14; + const double f5_6 = -f5 * m_A17; + m_A18 += m_A15 * f5_6; + RHS6 += f5_6 * RHS5; + const double f6 = 1.0 / m_A18; + const double f6_8 = -f6 * m_A26; + m_A28 += m_A19 * 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_A19 * V[8]; + V[6] = (RHS6 - tmp6) / m_A18; + double tmp5 = 0.0; + tmp5 += m_A15 * V[6]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A10 * V[7]; + tmp4 += m_A11 * V[8]; + V[4] = (RHS4 - tmp4) / m_A9; + double tmp3 = 0.0; + tmp3 += m_A8 * V[6]; + V[3] = (RHS3 - tmp3) / m_A7; + 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[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[7]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // gunfight static void nl_gcr_e25792142a75f8c4_14_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -17194,6 +35383,180 @@ static void nl_gcr_e4c54910436826d1_85_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb +static void nl_gcr_e87aeaf4adec7c14_25_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A6 += go[4]; + m_A5 += go[5]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[6] * *cnV[6]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + RHS2 -= go[10] * *cnV[10]; + m_A7 += gt[11]; + m_A7 += gt[12]; + m_A7 += gt[13]; + m_A8 += go[11]; + m_A9 += go[12]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 -= go[13] * *cnV[13]; + m_A11 += gt[14]; + m_A11 += gt[15]; + m_A11 += gt[16]; + m_A12 += go[14]; + m_A10 += go[15]; + double RHS4 = Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 -= go[16] * *cnV[16]; + m_A14 += gt[17]; + m_A14 += gt[18]; + m_A14 += gt[19]; + m_A15 += go[17]; + m_A13 += go[18]; + double RHS5 = Idr[17]; + RHS5 += Idr[18]; + RHS5 += Idr[19]; + RHS5 -= go[19] * *cnV[19]; + m_A18 += gt[20]; + m_A18 += gt[21]; + m_A18 += gt[22]; + m_A16 += go[20]; + m_A17 += go[21]; + double RHS6 = Idr[20]; + RHS6 += Idr[21]; + RHS6 += Idr[22]; + RHS6 -= go[22] * *cnV[22]; + m_A24 += gt[23]; + m_A24 += gt[24]; + m_A24 += gt[25]; + m_A24 += gt[26]; + m_A24 += gt[27]; + m_A20 += go[23]; + m_A21 += go[24]; + m_A22 += go[25]; + double RHS7 = Idr[23]; + RHS7 += Idr[24]; + RHS7 += Idr[25]; + RHS7 += Idr[26]; + RHS7 += Idr[27]; + RHS7 -= go[26] * *cnV[26]; + RHS7 -= go[27] * *cnV[27]; + 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_5 = -f1 * m_A13; + m_A14 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_7 = -f2 * m_A20; + m_A22 += m_A5 * f2_7; + m_A24 += m_A6 * f2_7; + RHS7 += f2_7 * RHS2; + const double f3 = 1.0 / m_A7; + const double f3_6 = -f3 * m_A16; + m_A18 += m_A8 * f3_6; + m_A19 += m_A9 * f3_6; + RHS6 += f3_6 * RHS3; + const double f3_7 = -f3 * m_A21; + m_A23 += m_A8 * f3_7; + m_A24 += m_A9 * f3_7; + RHS7 += f3_7 * RHS3; + const double f4 = 1.0 / m_A11; + const double f4_6 = -f4 * m_A17; + m_A18 += m_A12 * f4_6; + RHS6 += f4_6 * RHS4; + const double f5 = 1.0 / m_A14; + const double f5_7 = -f5 * m_A22; + m_A24 += m_A15 * f5_7; + RHS7 += f5_7 * RHS5; + const double f6 = 1.0 / m_A18; + const double f6_7 = -f6 * m_A23; + m_A24 += m_A19 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A24; + double tmp6 = 0.0; + tmp6 += m_A19 * V[7]; + V[6] = (RHS6 - tmp6) / m_A18; + double tmp5 = 0.0; + tmp5 += m_A15 * V[7]; + V[5] = (RHS5 - tmp5) / m_A14; + double tmp4 = 0.0; + tmp4 += m_A12 * V[6]; + V[4] = (RHS4 - tmp4) / m_A11; + double tmp3 = 0.0; + tmp3 += m_A8 * V[6]; + tmp3 += m_A9 * V[7]; + V[3] = (RHS3 - tmp3) / m_A7; + double tmp2 = 0.0; + tmp2 += m_A5 * V[5]; + tmp2 += m_A6 * V[7]; + 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[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // 280zzzap static void nl_gcr_eb8f99b7d033585a_57_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -17585,6 +35948,198 @@ static void nl_gcr_eb8f99b7d033585a_57_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// spacewar +static void nl_gcr_efb6587e9b27f9a8_28_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A3 += go[2]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 -= go[3] * *cnV[3]; + m_A4 += gt[4]; + m_A4 += gt[5]; + m_A4 += gt[6]; + m_A4 += gt[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A5 += go[4]; + double RHS2 = Idr[4]; + RHS2 += Idr[5]; + RHS2 += Idr[6]; + RHS2 += Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 -= go[5] * *cnV[5]; + RHS2 -= go[6] * *cnV[6]; + RHS2 -= go[7] * *cnV[7]; + RHS2 -= go[8] * *cnV[8]; + RHS2 -= go[9] * *cnV[9]; + RHS2 -= go[10] * *cnV[10]; + m_A6 += gt[11]; + m_A6 += gt[12]; + m_A6 += gt[13]; + m_A6 += gt[14]; + m_A6 += gt[15]; + m_A8 += go[11]; + m_A9 += go[12]; + m_A7 += go[13]; + double RHS3 = Idr[11]; + RHS3 += Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 += Idr[15]; + RHS3 -= go[14] * *cnV[14]; + RHS3 -= go[15] * *cnV[15]; + m_A12 += gt[16]; + m_A12 += gt[17]; + m_A10 += go[16]; + m_A11 += go[17]; + double RHS4 = Idr[16]; + RHS4 += Idr[17]; + m_A16 += gt[18]; + m_A16 += gt[19]; + m_A16 += gt[20]; + m_A15 += go[18]; + m_A17 += go[19]; + double RHS5 = Idr[18]; + RHS5 += Idr[19]; + RHS5 += Idr[20]; + RHS5 -= go[20] * *cnV[20]; + m_A20 += gt[21]; + m_A20 += gt[22]; + m_A20 += gt[23]; + m_A18 += go[21]; + double RHS6 = Idr[21]; + RHS6 += Idr[22]; + RHS6 += Idr[23]; + RHS6 -= go[22] * *cnV[22]; + RHS6 -= go[23] * *cnV[23]; + m_A27 += gt[24]; + m_A27 += gt[25]; + m_A27 += gt[26]; + m_A27 += gt[27]; + m_A27 += gt[28]; + m_A22 += go[24]; + m_A23 += go[25]; + m_A25 += go[26]; + double RHS7 = Idr[24]; + RHS7 += Idr[25]; + RHS7 += Idr[26]; + RHS7 += Idr[27]; + RHS7 += Idr[28]; + RHS7 -= go[27] * *cnV[27]; + RHS7 -= go[28] * *cnV[28]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A15; + m_A16 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_7 = -f2 * m_A22; + m_A25 += m_A5 * f2_7; + RHS7 += f2_7 * RHS2; + const double f3 = 1.0 / m_A6; + const double f3_4 = -f3 * m_A11; + m_A12 += m_A7 * f3_4; + m_A13 += m_A8 * f3_4; + m_A14 += m_A9 * f3_4; + RHS4 += f3_4 * RHS3; + 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; + RHS6 += f3_6 * RHS3; + const double f3_7 = -f3 * m_A23; + m_A24 += m_A7 * f3_7; + m_A26 += m_A8 * f3_7; + m_A27 += m_A9 * f3_7; + RHS7 += f3_7 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_6 = -f4 * m_A19; + m_A20 += m_A13 * f4_6; + m_A21 += m_A14 * f4_6; + RHS6 += f4_6 * RHS4; + const double f4_7 = -f4 * m_A24; + m_A26 += m_A13 * f4_7; + m_A27 += m_A14 * f4_7; + RHS7 += f4_7 * RHS4; + const double f5 = 1.0 / m_A16; + const double f5_7 = -f5 * m_A25; + m_A27 += m_A17 * f5_7; + RHS7 += f5_7 * RHS5; + const double f6 = 1.0 / m_A20; + const double f6_7 = -f6 * m_A26; + m_A27 += m_A21 * f6_7; + RHS7 += f6_7 * RHS6; + V[7] = RHS7 / m_A27; + double tmp6 = 0.0; + tmp6 += m_A21 * V[7]; + V[6] = (RHS6 - tmp6) / m_A20; + double tmp5 = 0.0; + tmp5 += m_A17 * V[7]; + V[5] = (RHS5 - tmp5) / m_A16; + double tmp4 = 0.0; + tmp4 += m_A13 * V[6]; + tmp4 += m_A14 * V[7]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A7 * V[4]; + tmp3 += m_A8 * V[6]; + tmp3 += m_A9 * V[7]; + V[3] = (RHS3 - tmp3) / m_A6; + double tmp2 = 0.0; + tmp2 += m_A5 * V[5]; + V[2] = (RHS2 - tmp2) / m_A4; + double tmp1 = 0.0; + tmp1 += m_A3 * V[5]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // zac1b11142 static void nl_gcr_f0a19b84f91ff24f_71_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -18065,6 +36620,145 @@ static void nl_gcr_f0a19b84f91ff24f_71_double_double(double * __restrict V, cons V[0] = (RHS0 - tmp0) / m_A0; } +// barrier +static void nl_gcr_f6a5c0229e09da18_19_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 -= go[1] * *cnV[1]; + m_A2 += gt[2]; + m_A2 += gt[3]; + m_A2 += gt[4]; + m_A2 += gt[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A2 += gt[8]; + m_A3 += go[2]; + m_A4 += go[3]; + double RHS1 = Idr[2]; + RHS1 += Idr[3]; + RHS1 += Idr[4]; + RHS1 += Idr[5]; + RHS1 += Idr[6]; + RHS1 += Idr[7]; + RHS1 += Idr[8]; + RHS1 -= go[4] * *cnV[4]; + RHS1 -= go[5] * *cnV[5]; + RHS1 -= go[6] * *cnV[6]; + RHS1 -= go[7] * *cnV[7]; + RHS1 -= go[8] * *cnV[8]; + m_A5 += gt[9]; + m_A5 += gt[10]; + m_A5 += gt[11]; + m_A7 += go[9]; + m_A6 += go[10]; + double RHS2 = Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[11] * *cnV[11]; + m_A8 += gt[12]; + m_A8 += gt[13]; + m_A9 += go[12]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 -= go[13] * *cnV[13]; + m_A12 += gt[14]; + m_A12 += gt[15]; + m_A12 += gt[16]; + m_A11 += go[14]; + m_A10 += go[15]; + double RHS4 = Idr[14]; + RHS4 += Idr[15]; + RHS4 += Idr[16]; + RHS4 -= go[16] * *cnV[16]; + m_A18 += gt[17]; + m_A18 += gt[18]; + m_A18 += gt[19]; + m_A18 += gt[20]; + m_A18 += gt[21]; + m_A18 += gt[22]; + m_A14 += go[17]; + m_A16 += go[18]; + m_A15 += go[19]; + double RHS5 = Idr[17]; + RHS5 += Idr[18]; + RHS5 += Idr[19]; + RHS5 += Idr[20]; + RHS5 += Idr[21]; + RHS5 += Idr[22]; + RHS5 -= go[20] * *cnV[20]; + RHS5 -= go[21] * *cnV[21]; + RHS5 -= go[22] * *cnV[22]; + const double f0 = 1.0 / m_A0; + const double f0_4 = -f0 * m_A10; + m_A12 += m_A1 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A14; + m_A15 += m_A3 * f1_5; + m_A17 += m_A4 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A5; + const double f2_4 = -f2 * m_A11; + m_A12 += m_A6 * f2_4; + m_A13 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A15; + m_A17 += m_A6 * f2_5; + m_A18 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A8; + const double f3_5 = -f3 * m_A16; + m_A18 += m_A9 * f3_5; + RHS5 += f3_5 * RHS3; + const double f4 = 1.0 / m_A12; + const double f4_5 = -f4 * m_A17; + m_A18 += m_A13 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A18; + double tmp4 = 0.0; + tmp4 += m_A13 * V[5]; + V[4] = (RHS4 - tmp4) / m_A12; + double tmp3 = 0.0; + tmp3 += m_A9 * V[5]; + V[3] = (RHS3 - tmp3) / m_A8; + double tmp2 = 0.0; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + V[2] = (RHS2 - tmp2) / m_A5; + double tmp1 = 0.0; + tmp1 += m_A3 * V[2]; + tmp1 += m_A4 * V[4]; + V[1] = (RHS1 - tmp1) / m_A2; + double tmp0 = 0.0; + tmp0 += m_A1 * V[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + // breakout static void nl_gcr_f6a620d52ca4719f_7_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __restrict cnV) @@ -18115,40 +36809,386 @@ static void nl_gcr_f6a620d52ca4719f_7_double_double(double * __restrict V, const V[0] = (RHS0 - tmp0) / m_A0; } +// boxingb +static void nl_gcr_f83b2ec77569565a_22_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A0 += gt[5]; + m_A1 += go[0]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 += Idr[5]; + RHS0 -= go[1] * *cnV[1]; + RHS0 -= go[2] * *cnV[2]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + RHS0 -= go[5] * *cnV[5]; + m_A2 += gt[6]; + m_A2 += gt[7]; + m_A3 += go[6]; + double RHS1 = Idr[6]; + RHS1 += Idr[7]; + RHS1 -= go[7] * *cnV[7]; + m_A4 += gt[8]; + m_A4 += gt[9]; + m_A4 += gt[10]; + m_A4 += gt[11]; + m_A4 += gt[12]; + m_A4 += gt[13]; + m_A4 += gt[14]; + m_A4 += gt[15]; + m_A7 += go[8]; + m_A6 += go[9]; + m_A6 += go[10]; + m_A5 += go[11]; + m_A5 += go[12]; + double RHS2 = Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 += Idr[12]; + RHS2 += Idr[13]; + RHS2 += Idr[14]; + RHS2 += Idr[15]; + RHS2 -= go[13] * *cnV[13]; + RHS2 -= go[14] * *cnV[14]; + RHS2 -= go[15] * *cnV[15]; + m_A10 += gt[16]; + m_A10 += gt[17]; + m_A10 += gt[18]; + m_A10 += gt[19]; + m_A10 += gt[20]; + m_A8 += go[16]; + m_A9 += go[17]; + m_A9 += go[18]; + double RHS3 = Idr[16]; + RHS3 += Idr[17]; + RHS3 += Idr[18]; + RHS3 += Idr[19]; + RHS3 += Idr[20]; + RHS3 -= go[19] * *cnV[19]; + RHS3 -= go[20] * *cnV[20]; + m_A15 += gt[21]; + m_A15 += gt[22]; + m_A15 += gt[23]; + m_A15 += gt[24]; + m_A15 += gt[25]; + m_A16 += go[21]; + m_A16 += go[22]; + m_A13 += go[23]; + m_A13 += go[24]; + double RHS4 = Idr[21]; + RHS4 += Idr[22]; + RHS4 += Idr[23]; + RHS4 += Idr[24]; + RHS4 += Idr[25]; + RHS4 -= go[25] * *cnV[25]; + m_A21 += gt[26]; + m_A21 += gt[27]; + m_A21 += gt[28]; + m_A21 += gt[29]; + m_A21 += gt[30]; + m_A20 += go[26]; + m_A20 += go[27]; + m_A18 += go[28]; + m_A17 += go[29]; + double RHS5 = Idr[26]; + RHS5 += Idr[27]; + RHS5 += Idr[28]; + RHS5 += Idr[29]; + RHS5 += Idr[30]; + RHS5 -= go[30] * *cnV[30]; + const double f0 = 1.0 / m_A0; + const double f0_3 = -f0 * m_A8; + m_A10 += m_A1 * f0_3; + RHS3 += f0_3 * RHS0; + const double f1 = 1.0 / m_A2; + const double f1_5 = -f1 * m_A17; + m_A21 += m_A3 * f1_5; + RHS5 += f1_5 * RHS1; + const double f2 = 1.0 / m_A4; + const double f2_3 = -f2 * m_A9; + m_A10 += m_A5 * f2_3; + m_A11 += m_A6 * f2_3; + m_A12 += m_A7 * f2_3; + RHS3 += f2_3 * RHS2; + const double f2_4 = -f2 * m_A13; + m_A14 += m_A5 * f2_4; + m_A15 += m_A6 * f2_4; + m_A16 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f2_5 = -f2 * m_A18; + m_A19 += m_A5 * f2_5; + m_A20 += m_A6 * f2_5; + m_A21 += m_A7 * f2_5; + RHS5 += f2_5 * RHS2; + const double f3 = 1.0 / m_A10; + const double f3_4 = -f3 * m_A14; + m_A15 += m_A11 * f3_4; + m_A16 += 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_A15; + const double f4_5 = -f4 * m_A20; + m_A21 += m_A16 * f4_5; + RHS5 += f4_5 * RHS4; + V[5] = RHS5 / m_A21; + double tmp4 = 0.0; + tmp4 += m_A16 * V[5]; + V[4] = (RHS4 - tmp4) / m_A15; + 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_A5 * V[3]; + tmp2 += m_A6 * V[4]; + tmp2 += m_A7 * V[5]; + 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[3]; + V[0] = (RHS0 - tmp0) / m_A0; +} + +// tailg +static void nl_gcr_feac4cce6258ebb3_15_double_double(double * __restrict V, const double * __restrict go, const double * __restrict gt, const double * __restrict Idr, const double * const * __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); + m_A0 += gt[0]; + m_A0 += gt[1]; + m_A0 += gt[2]; + m_A0 += gt[3]; + m_A0 += gt[4]; + m_A2 += go[0]; + m_A1 += go[1]; + m_A1 += go[2]; + double RHS0 = Idr[0]; + RHS0 += Idr[1]; + RHS0 += Idr[2]; + RHS0 += Idr[3]; + RHS0 += Idr[4]; + RHS0 -= go[3] * *cnV[3]; + RHS0 -= go[4] * *cnV[4]; + m_A3 += gt[5]; + m_A3 += gt[6]; + m_A4 += go[5]; + double RHS1 = Idr[5]; + RHS1 += Idr[6]; + RHS1 -= go[6] * *cnV[6]; + m_A6 += gt[7]; + m_A6 += gt[8]; + m_A6 += gt[9]; + m_A6 += gt[10]; + m_A6 += gt[11]; + m_A7 += go[7]; + m_A7 += go[8]; + m_A5 += go[9]; + m_A5 += go[10]; + double RHS2 = Idr[7]; + RHS2 += Idr[8]; + RHS2 += Idr[9]; + RHS2 += Idr[10]; + RHS2 += Idr[11]; + RHS2 -= go[11] * *cnV[11]; + m_A9 += gt[12]; + m_A9 += gt[13]; + m_A9 += gt[14]; + m_A10 += go[12]; + m_A8 += go[13]; + double RHS3 = Idr[12]; + RHS3 += Idr[13]; + RHS3 += Idr[14]; + RHS3 -= go[14] * *cnV[14]; + m_A14 += gt[15]; + m_A14 += gt[16]; + m_A14 += gt[17]; + m_A14 += gt[18]; + m_A13 += go[15]; + m_A12 += go[16]; + m_A12 += go[17]; + m_A11 += go[18]; + double RHS4 = Idr[15]; + RHS4 += Idr[16]; + RHS4 += Idr[17]; + RHS4 += Idr[18]; + 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_4 = -f0 * m_A11; + m_A12 += m_A1 * f0_4; + m_A14 += m_A2 * f0_4; + RHS4 += f0_4 * RHS0; + const double f1 = 1.0 / m_A3; + const double f1_3 = -f1 * m_A8; + m_A9 += m_A4 * f1_3; + RHS3 += f1_3 * RHS1; + const double f2 = 1.0 / m_A6; + const double f2_4 = -f2 * m_A12; + m_A14 += m_A7 * f2_4; + RHS4 += f2_4 * RHS2; + const double f3 = 1.0 / m_A9; + const double f3_4 = -f3 * m_A13; + m_A14 += m_A10 * f3_4; + RHS4 += f3_4 * RHS3; + V[4] = RHS4 / m_A14; + double tmp3 = 0.0; + tmp3 += m_A10 * V[4]; + V[3] = (RHS3 - tmp3) / m_A9; + double tmp2 = 0.0; + tmp2 += m_A7 * V[4]; + 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[4]; + V[0] = (RHS0 - tmp0) / m_A0; +} + extern const plib::dynlib_static_sym nl_static_solver_syms[]; const plib::dynlib_static_sym nl_static_solver_syms[] = { // konami1x {"nl_gcr_105d3ecb773843b6_49_double_double", reinterpret_cast(&nl_gcr_105d3ecb773843b6_49_double_double)}, // dpatrol {"nl_gcr_10d27c48eccd37d0_22_double_double", reinterpret_cast(&nl_gcr_10d27c48eccd37d0_22_double_double)}, +// sundance + {"nl_gcr_113b7d8ac4b72b66_12_double_double", reinterpret_cast(&nl_gcr_113b7d8ac4b72b66_12_double_double)}, +// starcas + {"nl_gcr_140a712e16ff3c5e_12_double_double", reinterpret_cast(&nl_gcr_140a712e16ff3c5e_12_double_double)}, // gunfight {"nl_gcr_14360daccbfc23c0_112_double_double", reinterpret_cast(&nl_gcr_14360daccbfc23c0_112_double_double)}, +// tailg + {"nl_gcr_15a30e6a101b5415_119_double_double", reinterpret_cast(&nl_gcr_15a30e6a101b5415_119_double_double)}, // breakout {"nl_gcr_15a4e7fbe5facb3a_7_double_double", reinterpret_cast(&nl_gcr_15a4e7fbe5facb3a_7_double_double)}, +// warrior + {"nl_gcr_15b8f0979c29b8e7_89_double_double", reinterpret_cast(&nl_gcr_15b8f0979c29b8e7_89_double_double)}, +// solarq + {"nl_gcr_15d8b80bb0b22f1e_303_double_double", reinterpret_cast(&nl_gcr_15d8b80bb0b22f1e_303_double_double)}, +// solarq + {"nl_gcr_176caa68e0d8e6e3_70_double_double", reinterpret_cast(&nl_gcr_176caa68e0d8e6e3_70_double_double)}, // breakout {"nl_gcr_1993cb957e80c097_10_double_double", reinterpret_cast(&nl_gcr_1993cb957e80c097_10_double_double)}, +// sundance + {"nl_gcr_1bc9f4a77b148e65_70_double_double", reinterpret_cast(&nl_gcr_1bc9f4a77b148e65_70_double_double)}, // kidniki {"nl_gcr_1cbd5d704f6e93c1_67_double_double", reinterpret_cast(&nl_gcr_1cbd5d704f6e93c1_67_double_double)}, // 280zzzap {"nl_gcr_20d478ed5597161_123_double_double", reinterpret_cast(&nl_gcr_20d478ed5597161_123_double_double)}, +// barrier + {"nl_gcr_2409b70ed4eff4c3_10_double_double", reinterpret_cast(&nl_gcr_2409b70ed4eff4c3_10_double_double)}, +// armora + {"nl_gcr_24c4f3c5388505ff_67_double_double", reinterpret_cast(&nl_gcr_24c4f3c5388505ff_67_double_double)}, // stuntcyc {"nl_gcr_251e2a2e2c8d5b33_20_double_double", reinterpret_cast(&nl_gcr_251e2a2e2c8d5b33_20_double_double)}, // cheekyms {"nl_gcr_278f0b40e27b21fc_150_double_double", reinterpret_cast(&nl_gcr_278f0b40e27b21fc_150_double_double)}, +// barrier + {"nl_gcr_27bf6b30d747739e_10_double_double", reinterpret_cast(&nl_gcr_27bf6b30d747739e_10_double_double)}, // zac1b11142 {"nl_gcr_2b5c86f8653bcde7_12_double_double", reinterpret_cast(&nl_gcr_2b5c86f8653bcde7_12_double_double)}, +// warrior + {"nl_gcr_2b9a75b9366dbb53_27_double_double", reinterpret_cast(&nl_gcr_2b9a75b9366dbb53_27_double_double)}, +// ripoff + {"nl_gcr_2ded0a8e9ab60939_11_double_double", reinterpret_cast(&nl_gcr_2ded0a8e9ab60939_11_double_double)}, // rebound {"nl_gcr_33a561080717d469_7_double_double", reinterpret_cast(&nl_gcr_33a561080717d469_7_double_double)}, // dpatrol {"nl_gcr_390fe6bd5468155d_7_double_double", reinterpret_cast(&nl_gcr_390fe6bd5468155d_7_double_double)}, +// boxingb + {"nl_gcr_3dcb4c16ef2de206_23_double_double", reinterpret_cast(&nl_gcr_3dcb4c16ef2de206_23_double_double)}, +// barrier + {"nl_gcr_3dfcefb0f730fed_31_double_double", reinterpret_cast(&nl_gcr_3dfcefb0f730fed_31_double_double)}, +// sundance + {"nl_gcr_3f3c8e7ec83d34dc_100_double_double", reinterpret_cast(&nl_gcr_3f3c8e7ec83d34dc_100_double_double)}, +// barrier + {"nl_gcr_3f47343711c928e7_13_double_double", reinterpret_cast(&nl_gcr_3f47343711c928e7_13_double_double)}, +// spacewar + {"nl_gcr_41fae289e2d2f263_22_double_double", reinterpret_cast(&nl_gcr_41fae289e2d2f263_22_double_double)}, // kidniki {"nl_gcr_445192d0ef3f62c6_21_double_double", reinterpret_cast(&nl_gcr_445192d0ef3f62c6_21_double_double)}, +// armora + {"nl_gcr_45c12728d0dbfd13_58_double_double", reinterpret_cast(&nl_gcr_45c12728d0dbfd13_58_double_double)}, +// starhawk + {"nl_gcr_477580ff3e69f2bd_40_double_double", reinterpret_cast(&nl_gcr_477580ff3e69f2bd_40_double_double)}, +// solarq + {"nl_gcr_495c7eab8506abb2_20_double_double", reinterpret_cast(&nl_gcr_495c7eab8506abb2_20_double_double)}, // kidniki {"nl_gcr_4a06f16ac700a832_198_double_double", reinterpret_cast(&nl_gcr_4a06f16ac700a832_198_double_double)}, +// starcas + {"nl_gcr_4b76db69603d04dd_64_double_double", reinterpret_cast(&nl_gcr_4b76db69603d04dd_64_double_double)}, +// armora + {"nl_gcr_4b999b0eb39c27f5_22_double_double", reinterpret_cast(&nl_gcr_4b999b0eb39c27f5_22_double_double)}, +// solarq + {"nl_gcr_4c2a4b68f14c15f4_76_double_double", reinterpret_cast(&nl_gcr_4c2a4b68f14c15f4_76_double_double)}, +// armora + {"nl_gcr_4cf10d4579d7c623_45_double_double", reinterpret_cast(&nl_gcr_4cf10d4579d7c623_45_double_double)}, // gtrak10 {"nl_gcr_4e48e9f6ef4bfdc4_43_double_double", reinterpret_cast(&nl_gcr_4e48e9f6ef4bfdc4_43_double_double)}, +// ripoff + {"nl_gcr_4f64406bd9c100b5_20_double_double", reinterpret_cast(&nl_gcr_4f64406bd9c100b5_20_double_double)}, +// solarq + {"nl_gcr_56d6ddbab32b391d_15_double_double", reinterpret_cast(&nl_gcr_56d6ddbab32b391d_15_double_double)}, // kidniki {"nl_gcr_580e08d22698f60a_37_double_double", reinterpret_cast(&nl_gcr_580e08d22698f60a_37_double_double)}, +// barrier + {"nl_gcr_583b020c6c17bfbc_47_double_double", reinterpret_cast(&nl_gcr_583b020c6c17bfbc_47_double_double)}, // kidniki {"nl_gcr_58f8065842de37d4_34_double_double", reinterpret_cast(&nl_gcr_58f8065842de37d4_34_double_double)}, // breakout @@ -18161,30 +37201,70 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_5af09c93b5cf0788_95_double_double", reinterpret_cast(&nl_gcr_5af09c93b5cf0788_95_double_double)}, // zac1b11142 {"nl_gcr_60352d234249ea57_30_double_double", reinterpret_cast(&nl_gcr_60352d234249ea57_30_double_double)}, +// boxingb + {"nl_gcr_64053a17068b1154_96_double_double", reinterpret_cast(&nl_gcr_64053a17068b1154_96_double_double)}, // breakout {"nl_gcr_655da76624809228_13_double_double", reinterpret_cast(&nl_gcr_655da76624809228_13_double_double)}, +// starcas + {"nl_gcr_664ba44cd8c70cf9_65_double_double", reinterpret_cast(&nl_gcr_664ba44cd8c70cf9_65_double_double)}, +// speedfrk + {"nl_gcr_6c412ad13dc3d34a_7_double_double", reinterpret_cast(&nl_gcr_6c412ad13dc3d34a_7_double_double)}, // cheekyms {"nl_gcr_6d03e64d09c956c3_7_double_double", reinterpret_cast(&nl_gcr_6d03e64d09c956c3_7_double_double)}, // rebound {"nl_gcr_6e17dfd7d26d8933_13_double_double", reinterpret_cast(&nl_gcr_6e17dfd7d26d8933_13_double_double)}, +// warrior + {"nl_gcr_6e2b4deaa89a5c3d_10_double_double", reinterpret_cast(&nl_gcr_6e2b4deaa89a5c3d_10_double_double)}, +// spacewar + {"nl_gcr_7061d322af649081_20_double_double", reinterpret_cast(&nl_gcr_7061d322af649081_20_double_double)}, // gamemachine {"nl_gcr_70c1124c705dd998_19_double_double", reinterpret_cast(&nl_gcr_70c1124c705dd998_19_double_double)}, // cheekyms {"nl_gcr_70f289d5486b9767_7_double_double", reinterpret_cast(&nl_gcr_70f289d5486b9767_7_double_double)}, +// barrier + {"nl_gcr_7141c51f842cc0f3_15_double_double", reinterpret_cast(&nl_gcr_7141c51f842cc0f3_15_double_double)}, +// boxingb + {"nl_gcr_723c47314fec281a_22_double_double", reinterpret_cast(&nl_gcr_723c47314fec281a_22_double_double)}, // zac1b11142 {"nl_gcr_752680f8e0bc6a4a_7_double_double", reinterpret_cast(&nl_gcr_752680f8e0bc6a4a_7_double_double)}, +// warrior + {"nl_gcr_76c41027f9d21f75_7_double_double", reinterpret_cast(&nl_gcr_76c41027f9d21f75_7_double_double)}, +// ripoff + {"nl_gcr_7a3d44a216e9c392_35_double_double", reinterpret_cast(&nl_gcr_7a3d44a216e9c392_35_double_double)}, // mario {"nl_gcr_7b9186d9ff77f7a1_29_double_double", reinterpret_cast(&nl_gcr_7b9186d9ff77f7a1_29_double_double)}, +// boxingb + {"nl_gcr_7d34f6e8c60fa024_16_double_double", reinterpret_cast(&nl_gcr_7d34f6e8c60fa024_16_double_double)}, // cheekyms {"nl_gcr_7e9498276980e5d1_12_double_double", reinterpret_cast(&nl_gcr_7e9498276980e5d1_12_double_double)}, +// starcas + {"nl_gcr_7f1603acd40cf2f3_62_double_double", reinterpret_cast(&nl_gcr_7f1603acd40cf2f3_62_double_double)}, +// tailg + {"nl_gcr_7f7006e00be779c9_31_double_double", reinterpret_cast(&nl_gcr_7f7006e00be779c9_31_double_double)}, // kidniki {"nl_gcr_80d7c219807268a_24_double_double", reinterpret_cast(&nl_gcr_80d7c219807268a_24_double_double)}, // pongf {"nl_gcr_81ae080c83dcf6a4_35_double_double", reinterpret_cast(&nl_gcr_81ae080c83dcf6a4_35_double_double)}, +// ripoff + {"nl_gcr_83e8e76f05758538_10_double_double", reinterpret_cast(&nl_gcr_83e8e76f05758538_10_double_double)}, // tp1985 {"nl_gcr_83fbe835263b28d3_7_double_double", reinterpret_cast(&nl_gcr_83fbe835263b28d3_7_double_double)}, +// ripoff + {"nl_gcr_8453c28c203b8bda_12_double_double", reinterpret_cast(&nl_gcr_8453c28c203b8bda_12_double_double)}, +// armora + {"nl_gcr_8a86fa6a6301c07d_56_double_double", reinterpret_cast(&nl_gcr_8a86fa6a6301c07d_56_double_double)}, +// starhawk + {"nl_gcr_8a93df40bddab087_7_double_double", reinterpret_cast(&nl_gcr_8a93df40bddab087_7_double_double)}, +// starhawk + {"nl_gcr_8c1b887a3bf15b45_12_double_double", reinterpret_cast(&nl_gcr_8c1b887a3bf15b45_12_double_double)}, +// boxingb + {"nl_gcr_8cd5efddba414c21_23_double_double", reinterpret_cast(&nl_gcr_8cd5efddba414c21_23_double_double)}, // pongf {"nl_gcr_930be1d2f1a52598_10_double_double", reinterpret_cast(&nl_gcr_930be1d2f1a52598_10_double_double)}, +// starcas + {"nl_gcr_9338de40a913f77b_109_double_double", reinterpret_cast(&nl_gcr_9338de40a913f77b_109_double_double)}, +// speedfrk + {"nl_gcr_94f6984ccc0e82e_37_double_double", reinterpret_cast(&nl_gcr_94f6984ccc0e82e_37_double_double)}, // kidniki {"nl_gcr_9701e2657a7f4ca3_37_double_double", reinterpret_cast(&nl_gcr_9701e2657a7f4ca3_37_double_double)}, // cocoloco @@ -18195,16 +37275,30 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_99e69c1880e516a7_10_double_double", reinterpret_cast(&nl_gcr_99e69c1880e516a7_10_double_double)}, // tp1985 {"nl_gcr_a1806410e32baeb_26_double_double", reinterpret_cast(&nl_gcr_a1806410e32baeb_26_double_double)}, +// solarq + {"nl_gcr_a52528b8650630c9_45_double_double", reinterpret_cast(&nl_gcr_a52528b8650630c9_45_double_double)}, // breakout {"nl_gcr_a59b19805d7e4461_7_double_double", reinterpret_cast(&nl_gcr_a59b19805d7e4461_7_double_double)}, // 280zzzap {"nl_gcr_a716c0b150a52aeb_135_double_double", reinterpret_cast(&nl_gcr_a716c0b150a52aeb_135_double_double)}, +// armora + {"nl_gcr_ade1dfefb9ca54f2_22_double_double", reinterpret_cast(&nl_gcr_ade1dfefb9ca54f2_22_double_double)}, +// boxingb + {"nl_gcr_af955d6ae6e0449f_10_double_double", reinterpret_cast(&nl_gcr_af955d6ae6e0449f_10_double_double)}, +// ripoff + {"nl_gcr_afe33d20712c21b9_59_double_double", reinterpret_cast(&nl_gcr_afe33d20712c21b9_59_double_double)}, // 1942 {"nl_gcr_b20cee3516465509_90_double_double", reinterpret_cast(&nl_gcr_b20cee3516465509_90_double_double)}, // segas16b_audio {"nl_gcr_b71f53c9e7a6b4a9_111_double_double", reinterpret_cast(&nl_gcr_b71f53c9e7a6b4a9_111_double_double)}, +// starhawk + {"nl_gcr_bbe87b4e0fbc0fd_45_double_double", reinterpret_cast(&nl_gcr_bbe87b4e0fbc0fd_45_double_double)}, // 280zzzap {"nl_gcr_bcf0e3af19330ca7_116_double_double", reinterpret_cast(&nl_gcr_bcf0e3af19330ca7_116_double_double)}, +// sundance + {"nl_gcr_c5fe9fb6df29b76d_8_double_double", reinterpret_cast(&nl_gcr_c5fe9fb6df29b76d_8_double_double)}, +// boxingb + {"nl_gcr_c88598a61904fb99_23_double_double", reinterpret_cast(&nl_gcr_c88598a61904fb99_23_double_double)}, // 280zzzap {"nl_gcr_caa814c0740131f2_104_double_double", reinterpret_cast(&nl_gcr_caa814c0740131f2_104_double_double)}, // rebound @@ -18215,27 +37309,59 @@ const plib::dynlib_static_sym nl_static_solver_syms[] = { {"nl_gcr_cd4de579d34fc1d9_7_double_double", reinterpret_cast(&nl_gcr_cd4de579d34fc1d9_7_double_double)}, // dpatrol {"nl_gcr_cffc52225ebcec8f_20_double_double", reinterpret_cast(&nl_gcr_cffc52225ebcec8f_20_double_double)}, +// solarq + {"nl_gcr_d007166ab411b608_25_double_double", reinterpret_cast(&nl_gcr_d007166ab411b608_25_double_double)}, +// starhawk + {"nl_gcr_d150d48b17f73102_40_double_double", reinterpret_cast(&nl_gcr_d150d48b17f73102_40_double_double)}, // popeye {"nl_gcr_d153cd8a3df26761_50_double_double", reinterpret_cast(&nl_gcr_d153cd8a3df26761_50_double_double)}, +// tailg + {"nl_gcr_d162007d1b602940_12_double_double", reinterpret_cast(&nl_gcr_d162007d1b602940_12_double_double)}, +// warrior + {"nl_gcr_d1943a7f9348144f_12_double_double", reinterpret_cast(&nl_gcr_d1943a7f9348144f_12_double_double)}, // dpatrol {"nl_gcr_d229cf0026955cd3_10_double_double", reinterpret_cast(&nl_gcr_d229cf0026955cd3_10_double_double)}, +// armora + {"nl_gcr_d3ccfc0e9cc1acf8_9_double_double", reinterpret_cast(&nl_gcr_d3ccfc0e9cc1acf8_9_double_double)}, +// boxingb + {"nl_gcr_d58f17ecf07ad3a9_29_double_double", reinterpret_cast(&nl_gcr_d58f17ecf07ad3a9_29_double_double)}, // 280zzzap {"nl_gcr_d5f69adb177fea36_31_double_double", reinterpret_cast(&nl_gcr_d5f69adb177fea36_31_double_double)}, +// spacewar + {"nl_gcr_d6665015de207c49_24_double_double", reinterpret_cast(&nl_gcr_d6665015de207c49_24_double_double)}, +// tailg + {"nl_gcr_d8ceb483a3003a15_23_double_double", reinterpret_cast(&nl_gcr_d8ceb483a3003a15_23_double_double)}, +// ripoff + {"nl_gcr_da46a6e4fdedac9d_16_double_double", reinterpret_cast(&nl_gcr_da46a6e4fdedac9d_16_double_double)}, // gamemachine {"nl_gcr_ddffc2781d05acf_10_double_double", reinterpret_cast(&nl_gcr_ddffc2781d05acf_10_double_double)}, +// boxingb + {"nl_gcr_de76ad96046b8593_55_double_double", reinterpret_cast(&nl_gcr_de76ad96046b8593_55_double_double)}, // gamemachine {"nl_gcr_df3a545642cc0a22_7_double_double", reinterpret_cast(&nl_gcr_df3a545642cc0a22_7_double_double)}, +// ripoff + {"nl_gcr_e1a2833d004e0493_29_double_double", reinterpret_cast(&nl_gcr_e1a2833d004e0493_29_double_double)}, // gunfight {"nl_gcr_e25792142a75f8c4_14_double_double", reinterpret_cast(&nl_gcr_e25792142a75f8c4_14_double_double)}, // zac1b11142 {"nl_gcr_e3e057bb1961a530_178_double_double", reinterpret_cast(&nl_gcr_e3e057bb1961a530_178_double_double)}, // konami2x {"nl_gcr_e4c54910436826d1_85_double_double", reinterpret_cast(&nl_gcr_e4c54910436826d1_85_double_double)}, +// boxingb + {"nl_gcr_e87aeaf4adec7c14_25_double_double", reinterpret_cast(&nl_gcr_e87aeaf4adec7c14_25_double_double)}, // 280zzzap {"nl_gcr_eb8f99b7d033585a_57_double_double", reinterpret_cast(&nl_gcr_eb8f99b7d033585a_57_double_double)}, +// spacewar + {"nl_gcr_efb6587e9b27f9a8_28_double_double", reinterpret_cast(&nl_gcr_efb6587e9b27f9a8_28_double_double)}, // zac1b11142 {"nl_gcr_f0a19b84f91ff24f_71_double_double", reinterpret_cast(&nl_gcr_f0a19b84f91ff24f_71_double_double)}, +// barrier + {"nl_gcr_f6a5c0229e09da18_19_double_double", reinterpret_cast(&nl_gcr_f6a5c0229e09da18_19_double_double)}, // breakout {"nl_gcr_f6a620d52ca4719f_7_double_double", reinterpret_cast(&nl_gcr_f6a620d52ca4719f_7_double_double)}, +// boxingb + {"nl_gcr_f83b2ec77569565a_22_double_double", reinterpret_cast(&nl_gcr_f83b2ec77569565a_22_double_double)}, +// tailg + {"nl_gcr_feac4cce6258ebb3_15_double_double", reinterpret_cast(&nl_gcr_feac4cce6258ebb3_15_double_double)}, {"", nullptr} }; diff --git a/src/lib/netlist/nl_create_mame_solvers.sh b/src/lib/netlist/nl_create_mame_solvers.sh index 3d72e1c1bc7..1afa5b9db67 100644 --- a/src/lib/netlist/nl_create_mame_solvers.sh +++ b/src/lib/netlist/nl_create_mame_solvers.sh @@ -1,7 +1,7 @@ #!/bin/sh GENERATED=src/lib/netlist/generated/static_solvers.cpp -FILES=`ls src/mame/machine/nl_*.cpp src/mame/audio/nl_*.cpp | grep -v pongdoubles` +FILES=`ls src/mame/machine/nl_*.cpp src/mame/audio/nl_*.cpp | grep -v pongdoubles` OUTDIR=/tmp/static_syms @@ -14,9 +14,9 @@ fi rm -rf ${OUTDIR} mkdir ${OUTDIR} -if ${NLTOOL} --cmd static --output=${GENERATED}.tmp ${FILES}; then +if ${NLTOOL} --cmd static --output=${GENERATED}.tmp --include=src/mame/audio ${FILES}; then mv -f ${GENERATED}.tmp ${GENERATED} echo Created ${GENERATED} file else echo Failed to create ${GENERATED} -fi +fi diff --git a/src/mame/audio/cinemat.cpp b/src/mame/audio/cinemat.cpp index 093ca45499a..70491dce09d 100644 --- a/src/mame/audio/cinemat.cpp +++ b/src/mame/audio/cinemat.cpp @@ -21,6 +21,18 @@ #include "emu.h" #include "includes/cinemat.h" +#include "audio/nl_armora.h" +#include "audio/nl_barrier.h" +#include "audio/nl_boxingb.h" +#include "audio/nl_ripoff.h" +#include "audio/nl_solarq.h" +#include "audio/nl_spacewar.h" +#include "audio/nl_speedfrk.h" +#include "audio/nl_starcas.h" +#include "audio/nl_starhawk.h" +#include "audio/nl_sundance.h" +#include "audio/nl_tailg.h" +#include "audio/nl_warrior.h" #include "cpu/z80/z80.h" #include "machine/z80daisy.h" #include "machine/z80ctc.h" @@ -29,51 +41,99 @@ /************************************* * - * Macros + * Base class * *************************************/ -#define RISING_EDGE(bit, changed, val) (((changed) & (bit)) && ((val) & (bit))) -#define FALLING_EDGE(bit, changed, val) (((changed) & (bit)) && !((val) & (bit))) - -#define SHIFTREG_RISING_EDGE(bit) RISING_EDGE(bit, (m_last_shift ^ m_current_shift), m_current_shift) -#define SHIFTREG_FALLING_EDGE(bit) FALLING_EDGE(bit, (m_last_shift ^ m_current_shift), m_current_shift) - -#define SHIFTREG2_RISING_EDGE(bit) RISING_EDGE(bit, (m_last_shift2 ^ m_current_shift), m_current_shift) -#define SHIFTREG2_FALLING_EDGE(bit) FALLING_EDGE(bit, (m_last_shift2 ^ m_current_shift), m_current_shift) - - -/************************************* - * - * Generic sound init - * - *************************************/ - -void cinemat_state::sound_start() +cinemat_audio_device::cinemat_audio_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 inputs_mask, void (*netlist)(netlist::nlparse_t &), double output_scale) + : device_t(mconfig, type, tag, owner, clock) + , m_out_input(*this, "sound_nl:out_%u", 0) + , m_inputs_mask(inputs_mask) + , m_netlist(netlist) + , m_output_scale(output_scale) { - /* register for save states */ - save_item(NAME(m_current_shift)); - save_item(NAME(m_last_shift)); - save_item(NAME(m_last_shift2)); - save_item(NAME(m_current_pitch)); - save_item(NAME(m_last_frame)); } - -void cinemat_state::sound_reset() +void cinemat_audio_device::configure_latch_inputs(ls259_device &latch, u8 mask) { - /* reset shift register values */ - m_current_shift = 0xffff; - m_last_shift = 0xffff; - m_last_shift2 = 0xffff; - - /* reset frame counters */ - m_last_frame = 0; - - /* reset Star Castle pitch */ - m_current_pitch = 0x10000; + if (mask == 0) + mask = m_inputs_mask; + if (BIT(mask, 0)) + latch.q_out_cb<0>().set(write_line_delegate(*this, FUNC(cinemat_audio_device::sound_w<0>))); + if (BIT(mask, 1)) + latch.q_out_cb<1>().set(write_line_delegate(*this, FUNC(cinemat_audio_device::sound_w<1>))); + if (BIT(mask, 2)) + latch.q_out_cb<2>().set(write_line_delegate(*this, FUNC(cinemat_audio_device::sound_w<2>))); + if (BIT(mask, 3)) + latch.q_out_cb<3>().set(write_line_delegate(*this, FUNC(cinemat_audio_device::sound_w<3>))); + if (BIT(mask, 4)) + latch.q_out_cb<4>().set(write_line_delegate(*this, FUNC(cinemat_audio_device::sound_w<4>))); + if (BIT(mask, 7)) + latch.q_out_cb<7>().set(write_line_delegate(*this, FUNC(cinemat_audio_device::sound_w<7>))); } +void cinemat_audio_device::device_add_mconfig(machine_config &config) +{ + SPEAKER(config, "mono").front_center(); + + if (m_netlist != nullptr) + { + NETLIST_SOUND(config, "sound_nl", 48000) + .set_source(m_netlist) + .add_route(ALL_OUTPUTS, "mono", 1.0); + + if ((m_inputs_mask & 0x01) != 0) + NETLIST_LOGIC_INPUT(config, m_out_input[0], "I_OUT_0.IN", 0); + if ((m_inputs_mask & 0x02) != 0) + NETLIST_LOGIC_INPUT(config, m_out_input[1], "I_OUT_1.IN", 0); + if ((m_inputs_mask & 0x04) != 0) + NETLIST_LOGIC_INPUT(config, m_out_input[2], "I_OUT_2.IN", 0); + if ((m_inputs_mask & 0x08) != 0) + NETLIST_LOGIC_INPUT(config, m_out_input[3], "I_OUT_3.IN", 0); + if ((m_inputs_mask & 0x10) != 0) + NETLIST_LOGIC_INPUT(config, m_out_input[4], "I_OUT_4.IN", 0); + if ((m_inputs_mask & 0x80) != 0) + NETLIST_LOGIC_INPUT(config, m_out_input[7], "I_OUT_7.IN", 0); + + NETLIST_STREAM_OUTPUT(config, "sound_nl:cout0", 0, "OUTPUT").set_mult_offset(m_output_scale, 0.0); + } +} + +void cinemat_audio_device::device_start() +{ +#if ENABLE_NETLIST_LOGGING + m_logfile = fopen("cinemat.csv", "w"); +#endif +} + +void cinemat_audio_device::device_stop() +{ +#if ENABLE_NETLIST_LOGGING + if (m_logfile != nullptr) + fclose(m_logfile); +#endif +} + +void cinemat_audio_device::input_set(int bit, int state) +{ + u8 oldvals = m_inputs; + m_inputs = (m_inputs & ~(1 << bit)) | ((state & 1) << bit); + if (oldvals != m_inputs) + { +#if ENABLE_NETLIST_LOGGING + attotime time = machine().scheduler().time(); + for (int bit = 0; bit < 8; bit++) + if (((m_inputs_mask >> bit) & 1) != 0) + if ((((m_inputs ^ oldvals) >> bit) & 1) != 0) + fprintf(m_logfile, "%s,I_OUT_%u.IN,%d\n", time.as_string(), bit, (m_inputs >> bit) & 1); +#endif + for (int index = 0; index < 8; index++) + if (m_out_input[index] != nullptr) + m_out_input[index]->write_line(BIT(m_inputs, index)); + } +} + + /************************************* @@ -82,85 +142,11 @@ void cinemat_state::sound_reset() * *************************************/ -static const char *const spacewar_sample_names[] = +DEFINE_DEVICE_TYPE(SPACE_WARS_AUDIO, spacewar_audio_device, "spacewar_audio", "Space Wars Sound Board") + +spacewar_audio_device::spacewar_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, SPACE_WARS_AUDIO, tag, owner, clock, 0x1f, NETLIST_NAME(spacewar), 150000.0) { - "*spacewar", - "explode1", - "fire1", - "idle", - "thrust1", - "thrust2", - "pop", - "explode2", - "fire2", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::spacewar_sound0_w) -{ - /* Explosion - rising edge */ - if (state) - m_samples->start(0, (machine().rand() & 1) ? 0 : 6); -} - -WRITE_LINE_MEMBER(cinemat_state::spacewar_sound1_w) -{ - /* Fire sound - rising edge */ - if (state) - m_samples->start(1, (machine().rand() & 1) ? 1 : 7); -} - -WRITE_LINE_MEMBER(cinemat_state::spacewar_sound2_w) -{ - /* Player 1 thrust - 0=on, 1=off */ - if (!state) - m_samples->start(3, 3, true); - if (state) - m_samples->stop(3); -} - -WRITE_LINE_MEMBER(cinemat_state::spacewar_sound3_w) -{ - /* Player 2 thrust - 0=on, 1-off */ - if (!state) - m_samples->start(4, 4, true); - if (state) - m_samples->stop(4); -} - -WRITE_LINE_MEMBER(cinemat_state::spacewar_sound4_w) -{ - /* Mute - 0=off, 1=on */ - if (!state) - m_samples->start(2, 2, true); /* play idle sound */ - if (state) - { - int i; - - /* turn off all but the idle sound */ - for (i = 0; i < 5; i++) - if (i != 2) - m_samples->stop(i); - - /* Pop when board is shut off */ - m_samples->start(2, 5); - } -} - -void cinemat_state::spacewar_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::spacewar_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::spacewar_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::spacewar_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::spacewar_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::spacewar_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(8); - m_samples->set_samples_names(spacewar_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -171,48 +157,11 @@ void cinemat_state::spacewar_sound(machine_config &config) * *************************************/ -static const char *const barrier_sample_names[] = +DEFINE_DEVICE_TYPE(BARRIER_AUDIO, barrier_audio_device, "barrier_audio", "Barrier Sound Board") + +barrier_audio_device::barrier_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, BARRIER_AUDIO, tag, owner, clock, 0x07, NETLIST_NAME(barrier), 200000.0) { - "*barrier", - "playrdie", - "playmove", - "enemmove", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::barrier_sound0_w) -{ - /* Player die - rising edge */ - if (state) - m_samples->start(0, 0); -} - -WRITE_LINE_MEMBER(cinemat_state::barrier_sound1_w) -{ - /* Player move - falling edge */ - if (!state) - m_samples->start(1, 1); -} - -WRITE_LINE_MEMBER(cinemat_state::barrier_sound2_w) -{ - /* Enemy move - falling edge */ - if (!state) - m_samples->start(2, 2); -} - -void cinemat_state::barrier_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::barrier_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::barrier_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::barrier_sound2_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(3); - m_samples->set_samples_names(barrier_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -223,53 +172,11 @@ void cinemat_state::barrier_sound(machine_config &config) * *************************************/ -static const char *const speedfrk_sample_names[] = +DEFINE_DEVICE_TYPE(SPEED_FREAK_AUDIO, speedfrk_audio_device, "speedfrk_audio", "Speed Freak Sound Board") + +speedfrk_audio_device::speedfrk_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, SPEED_FREAK_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(speedfrk), 12000.0) { - "*speedfrk", - "offroad", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::speedfrk_sound3_w) -{ - /* on the falling edge of bit 0x08, clock the inverse of bit 0x04 into the top of the shiftreg */ - if (!state) - { - m_current_shift = ((m_current_shift >> 1) & 0x7fff) | ((~m_outlatch->q2_r() << 13) & 1); - /* high 12 bits control the frequency - counts from value to $FFF, carry triggers */ - /* another counter */ - - /* low 4 bits control the volume of the noise output (explosion?) */ - } -} - -WRITE_LINE_MEMBER(cinemat_state::speedfrk_sound4_w) -{ - /* off-road - 1=on, 0=off */ - if (state) - m_samples->start(0, 0, true); - if (!state) - m_samples->stop(0); -} - -WRITE_LINE_MEMBER(cinemat_state::speedfrk_start_led_w) -{ - /* start LED is controlled by bit 0x02 */ - m_led = !state; -} - -void cinemat_state::speedfrk_sound(machine_config &config) -{ - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::speedfrk_start_led_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::speedfrk_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::speedfrk_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(1); - m_samples->set_samples_names(speedfrk_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -280,81 +187,11 @@ void cinemat_state::speedfrk_sound(machine_config &config) * *************************************/ -static const char *const starhawk_sample_names[] = +DEFINE_DEVICE_TYPE(STAR_HAWK_AUDIO, starhawk_audio_device, "starhawk_audio", "Star Hawk Sound Board") + +starhawk_audio_device::starhawk_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, STAR_HAWK_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(starhawk), 50000.0) { - "*starhawk", - "explode", - "rlaser", - "llaser", - "k", - "master", - "kexit", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::starhawk_sound0_w) -{ - /* explosion - falling edge */ - if (!state) - m_samples->start(0, 0); -} - -WRITE_LINE_MEMBER(cinemat_state::starhawk_sound1_w) -{ - /* right laser - falling edge */ - if (!state) - m_samples->start(1, 1); -} - -WRITE_LINE_MEMBER(cinemat_state::starhawk_sound2_w) -{ - /* left laser - falling edge */ - if (!state) - m_samples->start(2, 2); -} - -WRITE_LINE_MEMBER(cinemat_state::starhawk_sound3_w) -{ - /* K - 0=on, 1=off */ - if (!state) - m_samples->start(3, 3, true); - if (state) - m_samples->stop(3); -} - -WRITE_LINE_MEMBER(cinemat_state::starhawk_sound4_w) -{ - /* master - 0=on, 1=off */ - if (!state) - m_samples->start(4, 4, true); - if (state) - m_samples->stop(4); -} - -WRITE_LINE_MEMBER(cinemat_state::starhawk_sound7_w) -{ - /* K exit - 1=on, 0=off */ - if (state && !m_outlatch->q3_r()) - m_samples->start(3, 5, true); - if (!state) - m_samples->stop(3); -} - -void cinemat_state::starhawk_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::starhawk_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::starhawk_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::starhawk_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::starhawk_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::starhawk_sound4_w)); - m_outlatch->q_out_cb<7>().set(FUNC(cinemat_state::starhawk_sound7_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(5); - m_samples->set_samples_names(starhawk_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -365,75 +202,11 @@ void cinemat_state::starhawk_sound(machine_config &config) * *************************************/ -static const char *const sundance_sample_names[] = +DEFINE_DEVICE_TYPE(SUNDANCE_AUDIO, sundance_audio_device, "sundance_audio", "Sundance Sound Board") + +sundance_audio_device::sundance_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, SUNDANCE_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(sundance), 45000.0) { - "*sundance", - "bong", - "whoosh", - "explsion", - "ping1", - "ping2", - "hatch", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_16level_state::sundance_sound0_w) -{ - /* bong - falling edge */ - if (!state) - m_samples->start(0, 0); -} - -WRITE_LINE_MEMBER(cinemat_16level_state::sundance_sound1_w) -{ - /* whoosh - falling edge */ - if (!state) - m_samples->start(1, 1); -} - -WRITE_LINE_MEMBER(cinemat_16level_state::sundance_sound2_w) -{ - /* explosion - falling edge */ - if (!state) - m_samples->start(2, 2); -} - -WRITE_LINE_MEMBER(cinemat_16level_state::sundance_sound3_w) -{ - /* ping - falling edge */ - if (!state) - m_samples->start(3, 3); -} - -WRITE_LINE_MEMBER(cinemat_16level_state::sundance_sound4_w) -{ - /* ping - falling edge */ - if (!state) - m_samples->start(4, 4); -} - -WRITE_LINE_MEMBER(cinemat_16level_state::sundance_sound7_w) -{ - /* hatch - falling edge */ - if (!state) - m_samples->start(5, 5); -} - -void cinemat_16level_state::sundance_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_16level_state::sundance_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_16level_state::sundance_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_16level_state::sundance_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_16level_state::sundance_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_16level_state::sundance_sound4_w)); - m_outlatch->q_out_cb<7>().set(FUNC(cinemat_16level_state::sundance_sound7_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(6); - m_samples->set_samples_names(sundance_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -444,74 +217,11 @@ void cinemat_16level_state::sundance_sound(machine_config &config) * *************************************/ -static const char *const tailg_sample_names[] = +DEFINE_DEVICE_TYPE(TAIL_GUNNER_AUDIO, tailg_audio_device, "tailg_audio", "Tail Gunner Sound Board") + +tailg_audio_device::tailg_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, TAIL_GUNNER_AUDIO, tag, owner, clock, 0x1f, NETLIST_NAME(tailg), 75000.0) { - "*tailg", - "sexplode", - "thrust1", - "slaser", - "shield", - "bounce", - "hypersp", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::tailg_sound_w) -{ - /* the falling edge of bit 0x10 clocks bit 0x08 into the mux selected by bits 0x07 */ - if (!state) - { - /* update the shift register (actually just a simple mux) */ - m_current_shift = (m_current_shift & ~(1 << (m_outlatch->output_state() & 7))) | (m_outlatch->q3_r() << (m_outlatch->output_state() & 7)); - - /* explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x01)) - m_samples->start(0, 0); - - /* rumble - 0=on, 1=off */ - if (SHIFTREG_FALLING_EDGE(0x02)) - m_samples->start(1, 1, true); - if (SHIFTREG_RISING_EDGE(0x02)) - m_samples->stop(1); - - /* laser - 0=on, 1=off */ - if (SHIFTREG_FALLING_EDGE(0x04)) - m_samples->start(2, 2, true); - if (SHIFTREG_RISING_EDGE(0x04)) - m_samples->stop(2); - - /* shield - 0=on, 1=off */ - if (SHIFTREG_FALLING_EDGE(0x08)) - m_samples->start(3, 3, true); - if (SHIFTREG_RISING_EDGE(0x08)) - m_samples->stop(3); - - /* bounce - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x10)) - m_samples->start(4, 4); - - /* hyperspace - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x20)) - m_samples->start(5, 5); - - /* LED */ - m_led = BIT(m_current_shift, 6); - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -void cinemat_state::tailg_sound(machine_config &config) -{ - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::tailg_sound_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(6); - m_samples->set_samples_names(tailg_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -522,70 +232,11 @@ void cinemat_state::tailg_sound(machine_config &config) * *************************************/ -static const char *const warrior_sample_names[] = +DEFINE_DEVICE_TYPE(WARRIOR_AUDIO, warrior_audio_device, "warrior_audio", "Warrior Sound Board") + +warrior_audio_device::warrior_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, WARRIOR_AUDIO, tag, owner, clock, 0x1f, NETLIST_NAME(warrior), 50000.0) { - "*warrior", - "bgmhum1", - "bgmhum2", - "killed", - "fall", - "appear", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::warrior_sound0_w) -{ - /* normal level - 0=on, 1=off */ - if (!state) - m_samples->start(0, 0, true); - if (state) - m_samples->stop(0); -} - -WRITE_LINE_MEMBER(cinemat_state::warrior_sound1_w) -{ - /* hi level - 0=on, 1=off */ - if (!state) - m_samples->start(1, 1, true); - if (state) - m_samples->stop(1); -} - -WRITE_LINE_MEMBER(cinemat_state::warrior_sound2_w) -{ - /* explosion - falling edge */ - if (!state) - m_samples->start(2, 2); -} - -WRITE_LINE_MEMBER(cinemat_state::warrior_sound3_w) -{ - /* fall - falling edge */ - if (!state) - m_samples->start(3, 3); -} - -WRITE_LINE_MEMBER(cinemat_state::warrior_sound4_w) -{ - /* appear - falling edge */ - if (!state) - m_samples->start(4, 4); -} - -void cinemat_state::warrior_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::warrior_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::warrior_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::warrior_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::warrior_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::warrior_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(5); - m_samples->set_samples_names(warrior_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -596,96 +247,11 @@ void cinemat_state::warrior_sound(machine_config &config) * *************************************/ -static const char *const armora_sample_names[] = +DEFINE_DEVICE_TYPE(ARMOR_ATTACK_AUDIO, armora_audio_device, "armora_audio", "Armor Atrack Sound Board") + +armora_audio_device::armora_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, ARMOR_ATTACK_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(armora), 5000.0) { - "*armora", - "loexp", - "jeepfire", - "hiexp", - "tankfire", - "tankeng", - "beep", - "chopper", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::armora_sound4_w) -{ - /* on the rising edge of bit 0x10, clock bit 0x80 into the shift register */ - if (state) - m_current_shift = ((m_current_shift >> 1) & 0x7f) | (m_outlatch->q7_r() << 7); -} - -WRITE_LINE_MEMBER(cinemat_state::armora_sound0_w) -{ - /* execute on the rising edge of bit 0x01 */ - if (state) - { - /* bits 0-4 control the tank sound speed */ - - /* lo explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x10)) - m_samples->start(0, 0); - - /* jeep fire - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x20)) - m_samples->start(1, 1); - - /* hi explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x40)) - m_samples->start(2, 2); - - /* tank fire - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x80)) - m_samples->start(3, 3); - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_state::armora_sound1_w) -{ - /* tank sound - 0=on, 1=off */ - /* still not totally correct - should be multiple speeds based on remaining bits in shift reg */ - if (!state) - m_samples->start(4, 4, true); - if (state) - m_samples->stop(4); -} - -WRITE_LINE_MEMBER(cinemat_state::armora_sound2_w) -{ - /* beep sound - 0=on, 1=off */ - if (!state) - m_samples->start(5, 5, true); - if (state) - m_samples->stop(5); -} - -WRITE_LINE_MEMBER(cinemat_state::armora_sound3_w) -{ - /* chopper sound - 0=on, 1=off */ - if (!state) - m_samples->start(6, 6, true); - if (state) - m_samples->stop(6); -} - -void cinemat_state::armora_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::armora_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::armora_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::armora_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::armora_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::armora_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(7); - m_samples->set_samples_names(armora_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -696,93 +262,11 @@ void cinemat_state::armora_sound(machine_config &config) * *************************************/ -static const char *const ripoff_sample_names[] = +DEFINE_DEVICE_TYPE(RIPOFF_AUDIO, ripoff_audio_device, "ripoff_audio", "Rip Off Sound Board") + +ripoff_audio_device::ripoff_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, RIPOFF_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(ripoff), 20000.0) { - "*ripoff", - "bonuslvl", - "eattack", - "shipfire", - "efire", - "explosn", - "bg1", - "bg2", - "bg3", - "bg4", - "bg5", - "bg6", - "bg7", - "bg8", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::ripoff_sound1_w) -{ - /* on the rising edge of bit 0x02, clock bit 0x01 into the shift register */ - if (state) - m_current_shift = ((m_current_shift >> 1) & 0x7f) | (m_outlatch->q0_r() << 7); -} - -WRITE_LINE_MEMBER(cinemat_state::ripoff_sound2_w) -{ - /* execute on the rising edge of bit 0x04 */ - if (state) - { - /* background - 0=on, 1=off, selected by bits 0x38 */ - if ((((m_current_shift ^ m_last_shift) & 0x38) && !(m_current_shift & 0x04)) || SHIFTREG_FALLING_EDGE(0x04)) - m_samples->start(5, 5 + ((m_current_shift >> 5) & 7), true); - if (SHIFTREG_RISING_EDGE(0x04)) - m_samples->stop(5); - - /* beep - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x02)) - m_samples->start(0, 0); - - /* motor - 0=on, 1=off */ - if (SHIFTREG_FALLING_EDGE(0x01)) - m_samples->start(1, 1, true); - if (SHIFTREG_RISING_EDGE(0x01)) - m_samples->stop(1); - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_state::ripoff_sound3_w) -{ - /* torpedo - falling edge */ - if (!state) - m_samples->start(2, 2); -} - -WRITE_LINE_MEMBER(cinemat_state::ripoff_sound4_w) -{ - /* laser - falling edge */ - if (!state) - m_samples->start(3, 3); -} - -WRITE_LINE_MEMBER(cinemat_state::ripoff_sound7_w) -{ - /* explosion - falling edge */ - if (!state) - m_samples->start(4, 4); -} - -void cinemat_state::ripoff_sound(machine_config &config) -{ - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::ripoff_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::ripoff_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::ripoff_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::ripoff_sound4_w)); - m_outlatch->q_out_cb<7>().set(FUNC(cinemat_state::ripoff_sound7_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(6); - m_samples->set_samples_names(ripoff_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -793,113 +277,11 @@ void cinemat_state::ripoff_sound(machine_config &config) * *************************************/ -static const char *const starcas_sample_names[] = +DEFINE_DEVICE_TYPE(STAR_CASTLE_AUDIO, starcas_audio_device, "starcas_audio", "Star Castle Sound Board") + +starcas_audio_device::starcas_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, STAR_CASTLE_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(starcas), 5000.0) { - "*starcas", - "cfire", - "shield", - "star", - "thrust", - "drone", - "lexplode", - "sexplode", - "pfire", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::starcas_sound4_w) -{ - /* on the rising edge of bit 0x10, clock bit 0x80 into the shift register */ - if (state) - m_current_shift = ((m_current_shift >> 1) & 0x7f) | (m_outlatch->q7_r() << 7); -} - -WRITE_LINE_MEMBER(cinemat_state::starcas_sound0_w) -{ - /* execute on the rising edge of bit 0x01 */ - if (state) - { - /* fireball - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x80)) - m_samples->start(0, 0); - - /* shield hit - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x40)) - m_samples->start(1, 1); - - /* star sound - 0=off, 1=on */ - if (SHIFTREG_RISING_EDGE(0x20)) - m_samples->start(2, 2, true); - if (SHIFTREG_FALLING_EDGE(0x20)) - m_samples->stop(2); - - /* thrust sound - 1=off, 0=on*/ - if (SHIFTREG_FALLING_EDGE(0x10)) - m_samples->start(3, 3, true); - if (SHIFTREG_RISING_EDGE(0x10)) - m_samples->stop(3); - - /* drone - 1=off, 0=on */ - if (SHIFTREG_FALLING_EDGE(0x08)) - m_samples->start(4, 4, true); - if (SHIFTREG_RISING_EDGE(0x08)) - m_samples->stop(4); - - /* latch the drone pitch */ - u32 target_pitch = (m_current_shift & 7) + ((m_current_shift & 2) << 2); - target_pitch = 0x5800 + (target_pitch << 12); - - /* once per frame slide the pitch toward the target */ - if (m_screen->frame_number() > m_last_frame) - { - if (m_current_pitch > target_pitch) - m_current_pitch -= 225; - if (m_current_pitch < target_pitch) - m_current_pitch += 150; - m_samples->set_frequency(4, m_current_pitch); - m_last_frame = m_screen->frame_number(); - } - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_state::starcas_sound1_w) -{ - /* loud explosion - falling edge */ - if (!state) - m_samples->start(5, 5); -} - -WRITE_LINE_MEMBER(cinemat_state::starcas_sound2_w) -{ - /* soft explosion - falling edge */ - if (!state) - m_samples->start(6, 6); -} - -WRITE_LINE_MEMBER(cinemat_state::starcas_sound3_w) -{ - /* player fire - falling edge */ - if (!state) - m_samples->start(7, 7); -} - -void cinemat_state::starcas_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::starcas_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::starcas_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::starcas_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::starcas_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::starcas_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(8); - m_samples->set_samples_names(starcas_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.5); } @@ -910,128 +292,11 @@ void cinemat_state::starcas_sound(machine_config &config) * *************************************/ -static const char *const solarq_sample_names[] = +DEFINE_DEVICE_TYPE(SOLAR_QUEST_AUDIO, solarq_audio_device, "solarq_audio", "Solar Quest Sound Board") + +solarq_audio_device::solarq_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, SOLAR_QUEST_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(solarq), 5000.0) { - "*solarq", - "bigexpl", - "smexpl", - "lthrust", - "slaser", - "pickup", - "nuke2", - "nuke1", - "music", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_64level_state::solarq_sound4_w) -{ - /* on the rising edge of bit 0x10, clock bit 0x80 into the shift register */ - if (state) - m_current_shift = ((m_current_shift >> 1) & 0x7fff) | (m_outlatch->q7_r() << 15); -} - -WRITE_LINE_MEMBER(cinemat_64level_state::solarq_sound1_w) -{ - /* execute on the rising edge of bit 0x02 */ - if (state) - { - /* only the upper 8 bits matter */ - m_current_shift >>= 8; - - /* loud explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x80)) - m_samples->start(0, 0); - - /* soft explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x40)) - m_samples->start(1, 1); - - /* thrust - 0=on, 1=off */ - if (SHIFTREG_FALLING_EDGE(0x20)) - { - m_target_volume = 1.0; - if (!m_samples->playing(2)) - m_samples->start(2, 2, true); - } - if (SHIFTREG_RISING_EDGE(0x20)) - m_target_volume = 0; - - /* ramp the thrust volume */ - if (m_samples->playing(2) && m_screen->frame_number() > m_last_frame) - { - if (m_current_volume > m_target_volume) - m_current_volume -= 0.078f; - if (m_current_volume < m_target_volume) - m_current_volume += 0.078f; - if (m_current_volume > 0) - m_samples->set_volume(2, m_current_volume); - else - m_samples->stop(2); - m_last_frame = m_screen->frame_number(); - } - - /* fire - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x10)) - m_samples->start(3, 3); - - /* capture - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x08)) - m_samples->start(4, 4); - - /* nuke - 1=on, 0=off */ - if (SHIFTREG_RISING_EDGE(0x04)) - m_samples->start(5, 5, true); - if (SHIFTREG_FALLING_EDGE(0x04)) - m_samples->stop(5); - - /* photon - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x02)) - m_samples->start(6, 6); - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_64level_state::solarq_sound0_w) -{ - /* clock music data on the rising edge of bit 0x01 */ - if (state) - { - int freq, vol; - - /* start/stop the music sample on the high bit */ - if (SHIFTREG2_RISING_EDGE(0x8000)) - m_samples->start(7, 7, true); - if (SHIFTREG2_FALLING_EDGE(0x8000)) - m_samples->stop(7); - - /* set the frequency */ - freq = 56818.181818 / (4096 - (m_current_shift & 0xfff)); - m_samples->set_frequency(7, 44100 * freq / 1050); - - /* set the volume */ - vol = (~m_current_shift >> 12) & 7; - m_samples->set_volume(7, vol / 7.0); - - /* remember the previous value */ - m_last_shift2 = m_current_shift; - } -} - -void cinemat_64level_state::solarq_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_64level_state::solarq_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_64level_state::solarq_sound1_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_64level_state::solarq_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(8); - m_samples->set_samples_names(solarq_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.5); } @@ -1042,136 +307,11 @@ void cinemat_64level_state::solarq_sound(machine_config &config) * *************************************/ -static const char *const boxingb_sample_names[] = +DEFINE_DEVICE_TYPE(BOXING_BUGS_AUDIO, boxingb_audio_device, "boxingb_audio", "Boxing Bugs Sound Board") + +boxingb_audio_device::boxingb_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, BOXING_BUGS_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(boxingb), 5000.0) { - "*boxingb", - "softexpl", - "loudexpl", - "chirp", - "eggcrack", - "bugpusha", - "bugpushb", - "bugdie", - "beetle", - "music", - "cannon", - "bounce", - "bell", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_color_state::boxingb_sound4_w) -{ - /* on the rising edge of bit 0x10, clock bit 0x80 into the shift register */ - if (state) - m_current_shift = ((m_current_shift >> 1) & 0x7fff) | (m_outlatch->q7_r() << 15); -} - -WRITE_LINE_MEMBER(cinemat_color_state::boxingb_sound1_w) -{ - /* execute on the rising edge of bit 0x02 */ - if (state) - { - /* only the upper 8 bits matter */ - m_current_shift >>= 8; - - /* soft explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x80)) - m_samples->start(0, 0); - - /* loud explosion - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x40)) - m_samples->start(1, 1); - - /* chirping birds - 0=on, 1=off */ - if (SHIFTREG_FALLING_EDGE(0x20)) - m_samples->start(2, 2); - if (SHIFTREG_RISING_EDGE(0x20)) - m_samples->stop(2); - - /* egg cracking - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x10)) - m_samples->start(3, 3); - - /* bug pushing A - rising edge */ - if (SHIFTREG_RISING_EDGE(0x08)) - m_samples->start(4, 4); - - /* bug pushing B - rising edge */ - if (SHIFTREG_RISING_EDGE(0x04)) - m_samples->start(5, 5); - - /* bug dying - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x02)) - m_samples->start(6, 6); - - /* beetle on screen - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x01)) - m_samples->start(7, 7); - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_color_state::boxingb_sound0_w) -{ - /* clock music data on the rising edge of bit 0x01 */ - if (state) - { - int freq, vol; - - /* start/stop the music sample on the high bit */ - if (SHIFTREG2_RISING_EDGE(0x8000)) - m_samples->start(8, 8, true); - if (SHIFTREG2_FALLING_EDGE(0x8000)) - m_samples->stop(8); - - /* set the frequency */ - freq = 56818.181818 / (4096 - (m_current_shift & 0xfff)); - m_samples->set_frequency(8, 44100 * freq / 1050); - - /* set the volume */ - vol = (~m_current_shift >> 12) & 3; - m_samples->set_volume(8, vol / 3.0); - - /* cannon - falling edge */ - if (SHIFTREG2_RISING_EDGE(0x4000)) - m_samples->start(9, 9); - - /* remember the previous value */ - m_last_shift2 = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_color_state::boxingb_sound2_w) -{ - /* bounce - rising edge */ - if (state) - m_samples->start(10, 10); -} - -WRITE_LINE_MEMBER(cinemat_color_state::boxingb_sound3_w) -{ - /* bell - falling edge */ - if (state) - m_samples->start(11, 11); -} - -void cinemat_color_state::boxingb_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_color_state::boxingb_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_color_state::boxingb_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_color_state::boxingb_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_color_state::boxingb_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_color_state::boxingb_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(12); - m_samples->set_samples_names(boxingb_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -1182,113 +322,11 @@ void cinemat_color_state::boxingb_sound(machine_config &config) * *************************************/ -static const char *const wotw_sample_names[] = +DEFINE_DEVICE_TYPE(WAR_OF_THE_WORLDS_AUDIO, wotw_audio_device, "wotw_audio", "War of the Worlds Sound Board") + +wotw_audio_device::wotw_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock) + : cinemat_audio_device(mconfig, WAR_OF_THE_WORLDS_AUDIO, tag, owner, clock, 0x9f, NETLIST_NAME(wotw), 5000.0) { - "*wotw", - "cfire", - "shield", - "star", - "thrust", - "drone", - "lexplode", - "sexplode", - "pfire", - nullptr -}; - -WRITE_LINE_MEMBER(cinemat_state::wotw_sound4_w) -{ - /* on the rising edge of bit 0x10, clock bit 0x80 into the shift register */ - if (state) - m_current_shift = ((m_current_shift >> 1) & 0x7f) | (m_outlatch->q7_r() << 7); -} - -WRITE_LINE_MEMBER(cinemat_state::wotw_sound0_w) -{ - /* execute on the rising edge of bit 0x01 */ - if (state) - { - /* fireball - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x80)) - m_samples->start(0, 0); - - /* shield hit - falling edge */ - if (SHIFTREG_FALLING_EDGE(0x40)) - m_samples->start(1, 1); - - /* star sound - 0=off, 1=on */ - if (SHIFTREG_RISING_EDGE(0x20)) - m_samples->start(2, 2, true); - if (SHIFTREG_FALLING_EDGE(0x20)) - m_samples->stop(2); - - /* thrust sound - 1=off, 0=on*/ - if (SHIFTREG_FALLING_EDGE(0x10)) - m_samples->start(3, 3, true); - if (SHIFTREG_RISING_EDGE(0x10)) - m_samples->stop(3); - - /* drone - 1=off, 0=on */ - if (SHIFTREG_FALLING_EDGE(0x08)) - m_samples->start(4, 4, true); - if (SHIFTREG_RISING_EDGE(0x08)) - m_samples->stop(4); - - /* latch the drone pitch */ - u32 target_pitch = (m_current_shift & 7) + ((m_current_shift & 2) << 2); - target_pitch = 0x10000 + (target_pitch << 12); - - /* once per frame slide the pitch toward the target */ - if (m_screen->frame_number() > m_last_frame) - { - if (m_current_pitch > target_pitch) - m_current_pitch -= 300; - if (m_current_pitch < target_pitch) - m_current_pitch += 200; - m_samples->set_frequency(4, m_current_pitch); - m_last_frame = m_screen->frame_number(); - } - - /* remember the previous value */ - m_last_shift = m_current_shift; - } -} - -WRITE_LINE_MEMBER(cinemat_state::wotw_sound1_w) -{ - /* loud explosion - falling edge */ - if (!state) - m_samples->start(5, 5); -} - -WRITE_LINE_MEMBER(cinemat_state::wotw_sound2_w) -{ - /* soft explosion - falling edge */ - if (!state) - m_samples->start(6, 6); -} - -WRITE_LINE_MEMBER(cinemat_state::wotw_sound3_w) -{ - /* player fire - falling edge */ - if (!state) - m_samples->start(7, 7); -} - -void cinemat_state::wotw_sound(machine_config &config) -{ - m_outlatch->q_out_cb<0>().set(FUNC(cinemat_state::wotw_sound0_w)); - m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::wotw_sound1_w)); - m_outlatch->q_out_cb<2>().set(FUNC(cinemat_state::wotw_sound2_w)); - m_outlatch->q_out_cb<3>().set(FUNC(cinemat_state::wotw_sound3_w)); - m_outlatch->q_out_cb<4>().set(FUNC(cinemat_state::wotw_sound4_w)); - - SPEAKER(config, "mono").front_center(); - - SAMPLES(config, m_samples); - m_samples->set_channels(8); - m_samples->set_samples_names(wotw_sample_names); - m_samples->add_route(ALL_OUTPUTS, "mono", 0.50); } @@ -1314,20 +352,20 @@ WRITE_LINE_MEMBER(demon_state::demon_sound4_w) } -uint8_t demon_state::sound_porta_r() +u8 demon_state::sound_porta_r() { /* bits 0-3 are the sound data; bit 4 is the data ready */ return m_sound_fifo[m_sound_fifo_out] | ((m_sound_fifo_in != m_sound_fifo_out) << 4); } -uint8_t demon_state::sound_portb_r() +u8 demon_state::sound_portb_r() { return m_last_portb_write; } -void demon_state::sound_portb_w(uint8_t data) +void demon_state::sound_portb_w(u8 data) { /* watch for a 0->1 edge on bit 0 ("shift out") to advance the data pointer */ if ((data & 1) != (m_last_portb_write & 1) && (data & 1) != 0) @@ -1345,7 +383,7 @@ void demon_state::sound_portb_w(uint8_t data) m_last_portb_write = data; } -void demon_state::sound_output_w(uint8_t data) +void demon_state::sound_output_w(u8 data) { logerror("sound_output = %02X\n", data); } @@ -1442,9 +480,9 @@ void demon_state::demon_sound(machine_config &config) * *************************************/ -void qb3_state::qb3_sound_fifo_w(uint8_t data) +void qb3_state::qb3_sound_fifo_w(u8 data) { - uint16_t rega = m_maincpu->state_int(ccpu_cpu_device::CCPU_A); + u16 rega = m_maincpu->state_int(ccpu_cpu_device::CCPU_A); machine().scheduler().synchronize(timer_expired_delegate(FUNC(qb3_state::synced_sound_w), this), rega & 0x0f); } diff --git a/src/mame/audio/cinemat.h b/src/mame/audio/cinemat.h new file mode 100644 index 00000000000..de12240e1dc --- /dev/null +++ b/src/mame/audio/cinemat.h @@ -0,0 +1,151 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_CINEMAT_H +#define MAME_AUDIO_CINEMAT_H + +#pragma once + +#include "machine/74259.h" +#include "machine/netlist.h" +#include "netlist/nl_setup.h" + +// log to cinemat.csv for nltool playback/analysis +#define ENABLE_NETLIST_LOGGING (0) + + +class cinemat_audio_device : public device_t +{ +public: + cinemat_audio_device(const machine_config &mconfig, device_type type, const char *tag, device_t *owner, u32 clock, u8 inputs_mask, void (*netlist)(netlist::nlparse_t &), double output_scale); + + void configure_latch_inputs(ls259_device &latch, u8 mask = 0); + +protected: + virtual void device_add_mconfig(machine_config &config) override; + virtual void device_start() override; + virtual void device_stop() override; + + template DECLARE_WRITE_LINE_MEMBER(sound_w) { input_set(_Index, state); } + void input_set(int bit, int state); + + optional_device_array m_out_input; + +private: + u8 m_inputs = 0xff; + u8 m_inputs_mask = 0xff; + void (*m_netlist)(netlist::nlparse_t &) = nullptr; + double m_output_scale = 0; + +#if ENABLE_NETLIST_LOGGING + FILE *m_logfile = nullptr; +#endif + +}; + + +class spacewar_audio_device : public cinemat_audio_device +{ +public: + spacewar_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class barrier_audio_device : public cinemat_audio_device +{ +public: + barrier_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class speedfrk_audio_device : public cinemat_audio_device +{ +public: + speedfrk_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class starhawk_audio_device : public cinemat_audio_device +{ +public: + starhawk_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class sundance_audio_device : public cinemat_audio_device +{ +public: + sundance_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class tailg_audio_device : public cinemat_audio_device +{ +public: + tailg_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class warrior_audio_device : public cinemat_audio_device +{ +public: + warrior_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class armora_audio_device : public cinemat_audio_device +{ +public: + armora_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class ripoff_audio_device : public cinemat_audio_device +{ +public: + ripoff_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class starcas_audio_device : public cinemat_audio_device +{ +public: + starcas_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class solarq_audio_device : public cinemat_audio_device +{ +public: + solarq_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class boxingb_audio_device : public cinemat_audio_device +{ +public: + boxingb_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +class wotw_audio_device : public cinemat_audio_device +{ +public: + wotw_audio_device(const machine_config &mconfig, const char *tag, device_t *owner, u32 clock); +}; + + +DECLARE_DEVICE_TYPE(SPACE_WARS_AUDIO, spacewar_audio_device) +DECLARE_DEVICE_TYPE(BARRIER_AUDIO, barrier_audio_device) +DECLARE_DEVICE_TYPE(STAR_HAWK_AUDIO, starhawk_audio_device) +DECLARE_DEVICE_TYPE(SUNDANCE_AUDIO, sundance_audio_device) +DECLARE_DEVICE_TYPE(SPEED_FREAK_AUDIO, speedfrk_audio_device) +DECLARE_DEVICE_TYPE(TAIL_GUNNER_AUDIO, tailg_audio_device) +DECLARE_DEVICE_TYPE(WARRIOR_AUDIO, warrior_audio_device) +DECLARE_DEVICE_TYPE(ARMOR_ATTACK_AUDIO, armora_audio_device) +DECLARE_DEVICE_TYPE(RIPOFF_AUDIO, ripoff_audio_device) +DECLARE_DEVICE_TYPE(SOLAR_QUEST_AUDIO, solarq_audio_device) +DECLARE_DEVICE_TYPE(BOXING_BUGS_AUDIO, boxingb_audio_device) +DECLARE_DEVICE_TYPE(STAR_CASTLE_AUDIO, starcas_audio_device) +DECLARE_DEVICE_TYPE(WAR_OF_THE_WORLDS_AUDIO, wotw_audio_device) + +#endif // MAME_AUDIO_CINEMAT_H diff --git a/src/mame/audio/nl_armora.cpp b/src/mame/audio/nl_armora.cpp new file mode 100644 index 00000000000..c3b4924db31 --- /dev/null +++ b/src/mame/audio/nl_armora.cpp @@ -0,0 +1,682 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Armor Attack +// +// Derived from the schematics in the Armor Attack manual. +// +// Known problems/issues: +// +// * Worked pretty well the first time. +// +// * The squeak on the tank treads is not right, need to +// understand what's going on. +// +// * Entire schematic needs a verification pass. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_armora.h" + + +// +// Optimizations +// + +#define HLE_TANK_VCO (1) + + + +// +// Main netlist +// + +NETLIST_START(armora) + +#if (HLE_TANK_VCO) + SOLVER(Solver, 1000) +#else + SOLVER(Solver, 4800000) +#endif + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + TTL_INPUT(I_OUT_7, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(1)) + RES(R2, RES_K(1.3)) + RES(R3, RES_K(1.3)) + RES(R4, RES_K(2)) + RES(R5, RES_K(2)) + RES(R6, RES_K(12)) + RES(R7, RES_K(24)) + RES(R8, RES_K(1)) + RES(R9, RES_K(2)) + RES(R10, RES_K(1)) + RES(R11, RES_K(3.6)) + RES(R12, RES_K(10)) + RES(R13, RES_K(1)) + RES(R14, RES_K(240)) + RES(R15, RES_K(22)) + RES(R16, RES_K(22)) + RES(R17, RES_K(22)) + RES(R18, RES_K(20)) + RES(R19, RES_K(430)) + RES(R20, RES_M(1.5)) + RES(R21, RES_K(390)) + RES(R22, RES_M(1.5)) + RES(R23, RES_K(51)) +// RES(R24, RES_K(390)) -- part of final amp (not emulated) +// RES(R25, RES_K(390)) -- part of final amp (not emulated) + RES(R26, RES_M(1)) + RES(R27, RES_K(4.7)) + RES(R28, RES_K(2.7)) + RES(R29, RES_K(4.7)) + RES(R30, RES_K(39)) + RES(R31, RES_K(12)) + RES(R32, RES_K(1)) + RES(R33, RES_K(240)) + RES(R34, RES_K(18)) + RES(R35, RES_K(16)) + RES(R36, RES_K(7.5)) + RES(R37, 620) + RES(R38, 620) + RES(R39, RES_K(4.7)) + RES(R40, RES_K(2.7)) + RES(R41, RES_K(4.7)) + RES(R42, RES_K(39)) + RES(R43, RES_K(12)) + RES(R44, RES_K(1)) + RES(R45, RES_K(150)) + RES(R46, RES_K(20)) + RES(R47, RES_K(22)) + RES(R48, RES_K(30)) + RES(R49, 680) + RES(R50, 680) + RES(R51, RES_K(4.7)) + RES(R52, RES_K(2.7)) + RES(R53, RES_K(4.7)) + RES(R54, RES_K(39)) + RES(R55, RES_K(12)) + RES(R56, RES_K(1)) + RES(R57, RES_K(220)) + RES(R58, RES_K(10)) + RES(R59, RES_K(47)) + RES(R60, 750) + RES(R61, 750) + RES(R62, RES_K(4.7)) + RES(R63, RES_K(2.7)) + RES(R64, RES_K(4.7)) + RES(R65, RES_K(39)) + RES(R66, RES_K(12)) + RES(R67, RES_K(1)) + RES(R68, RES_K(910)) + RES(R69, RES_K(8.2)) + RES(R70, RES_K(43)) + RES(R71, RES_K(22)) + RES(R72, 750) + RES(R73, 750) + RES(R74, RES_K(4.7)) + RES(R75, RES_K(2.7)) + RES(R76, RES_K(4.7)) + RES(R77, RES_K(39)) + RES(R78, RES_K(12)) + RES(R79, RES_K(1)) + RES(R80, RES_K(750)) + RES(R81, RES_K(20)) + RES(R82, RES_K(8.2)) + RES(R83, RES_K(330)) +// RES(R84, RES_K(15)) -- part of final amp (not emulated) +// RES(R85, 150) -- part of final amp (not emulated) +// RES(R86, RES_K(22)) -- part of final amp (not emulated) +// RES(R87, 150) -- part of final amp (not emulated) +// RES(R88, 0.51) -- part of final amp (not emulated) +// RES(R89, 0.51) -- part of final amp (not emulated) + RES(R90, RES_K(100)) + RES(R91, RES_K(8.2)) + RES(R92, RES_K(20)) +// POT(R93, RES_K(10)) -- part of final amp (not emulated) + RES(R94, RES_K(30)) + RES(R95, RES_K(4.7)) + RES(R96, RES_K(2.7)) + RES(R97, RES_K(39)) + RES(R98, RES_K(12)) + RES(R99, RES_K(2.4)) + RES(R100, RES_K(4.7)) + RES(R101, RES_K(2.7)) + RES(R102, RES_K(39)) + RES(R103, RES_K(12)) + RES(R104, RES_K(2.4)) + RES(R105, RES_K(4.7)) + RES(R106, RES_K(2.7)) + RES(R107, RES_K(39)) + RES(R108, RES_K(12)) + RES(R109, RES_K(2.4)) + RES(R110, RES_K(1)) + +// CAP(C1, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C2, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C3, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C4, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C5, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C6, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C7, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C8, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C9, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C10, CAP_U(0.1)) -- part of voltage converter (not emulated) + CAP(C11, CAP_U(0.047)) + CAP(C12, CAP_U(0.01)) + CAP(C13, CAP_U(0.047)) + CAP(C14, CAP_U(0.47)) + CAP(C15, CAP_U(0.001)) + CAP(C16, CAP_U(0.1)) + CAP(C17, CAP_U(0.0047)) + CAP(C18, CAP_U(2.2)) + CAP(C19, CAP_U(0.1)) + CAP(C20, CAP_U(100)) + CAP(C21, CAP_U(0.1)) + CAP(C22, CAP_U(2.2)) + CAP(C23, CAP_U(0.22)) + CAP(C24, CAP_U(0.22)) + CAP(C25, CAP_U(3.3)) + CAP(C26, CAP_U(0.1)) + CAP(C27, CAP_U(0.047)) +// CAP(C28, CAP_U()) -- don't see it anywhere + CAP(C29, CAP_U(0.047)) + CAP(C30, CAP_U(0.047)) + CAP(C31, CAP_U(0.22)) + CAP(C32, CAP_U(0.22)) + CAP(C33, CAP_U(0.0047)) + CAP(C34, CAP_U(1)) + CAP(C35, CAP_U(0.1)) + CAP(C36, CAP_U(0.1)) + CAP(C37, CAP_U(0.01)) +// CAP(C38, CAP_U(0.68)) -- part of final amp (not emulated) +// CAP(C39, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C40, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C41, CAP_U(0.005)) -- part of final amp (not emulated) +// CAP(C42, CAP_P(470)) -- part of final amp (not emulated) + CAP(C43, CAP_U(0.33)) + + +// D_1N4003(D1) -- part of voltage converter (not emulated) +// D_1N4003(D2) -- part of voltage converter (not emulated) +// D_1N4003(D3) -- part of voltage converter (not emulated) +// D_1N4003(D4) -- part of voltage converter (not emulated) + D_1N914(D5) +// D_1N4003(D6) -- part of final amp (not emulated) +// D_1N4003(D7) -- part of final amp (not emulated) + D_1N914(D8) + + + Q_2N3904(Q1) // NPN + Q_2N3906(Q2) // PNP + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3906(Q5) // PNP + Q_2N3906(Q6) // PNP + Q_2N3906(Q7) // PNP + Q_2N3906(Q8) // PNP + Q_2N3906(Q9) // PNP + Q_2N3906(Q10) // PNP + Q_2N3906(Q11) // PNP +// Q_2N6292(Q12) // NPN -- part of final amp (not emulated) +// Q_2N6107(Q13) // PNP -- part of final amp (not emulated) + Q_2N3906(Q14) // PNP + Q_2N3904(Q15) // NPN + Q_2N3906(Q16) // PNP + Q_2N3904(Q17) // NPN + Q_2N3906(Q18) // PNP + Q_2N3904(Q19) // NPN + + TTL_7414_DIP(IC1) // Hex Inverter + NET_C(IC1.7, GND) + NET_C(IC1.14, I_V5) + + TTL_74LS164_DIP(IC2) // 8-bit Shift Reg. + NET_C(IC2.7, GND) + NET_C(IC2.14, I_V5) + + TTL_74LS377_DIP(IC3) // Octal D Flip Flop + NET_C(IC3.10, GND) + NET_C(IC3.20, I_V5) + +// TTL_7815_DIP(IC4) // +15V Regulator -- part of voltage converter (not emulated) +// TTL_7915_DIP(IC5) // -15V Regulator -- part of voltage converter (not emulated) + + LM555_DIP(IC6) + + TTL_7406_DIP(IC7) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(IC7.7, GND) + NET_C(IC7.14, I_V5) + + TTL_74LS163_DIP(IC8) // Binary Counter (schems say can sub a 74161) + NET_C(IC8.8, GND) + NET_C(IC8.16, I_V5) + + TTL_74LS00_DIP(IC9) // Quad 4-Input NAND Gate + NET_C(IC9.7, GND) + NET_C(IC9.14, I_V5) + + TTL_74LS393_DIP(IC10) // Dual 4-Stage Binary Counter + NET_C(IC10.7, GND) + NET_C(IC10.14, I_V5) + + TTL_74LS163_DIP(IC11) // Binary Counter (schems say can sub a 74161) + NET_C(IC11.8, GND) + NET_C(IC11.16, I_V5) + + // IC12 was deleted from schematics + + TTL_74LS393_DIP(IC13) // Dual 4-Stage Binary Counter + NET_C(IC13.7, GND) + NET_C(IC13.14, I_V5) + + // IC14 was deleted from schematics + +#if (!HLE_TANK_VCO) + LM566_DIP(IC15) +#endif + + // IC16 was deleted from schematics + + AMI_S2688(IC17) // Noise generator + + TL081_DIP(IC18) // Op. Amp. + NET_C(IC18.7, I_V15) + NET_C(IC18.4, I_VM15) + + CA3080_DIP(IC19) // Op. Amp. + NET_C(IC19.4, I_VM15) + NET_C(IC19.7, I_V15) + + CA3080_DIP(IC20) // Op. Amp. + NET_C(IC20.4, I_VM15) + NET_C(IC20.7, I_V15) + + CA3080_DIP(IC21) // Op. Amp. + NET_C(IC21.4, I_VM15) + NET_C(IC21.7, I_V15) + + CA3080_DIP(IC22) // Op. Amp. + NET_C(IC22.4, I_VM15) + NET_C(IC22.7, I_V15) + + LM555_DIP(IC23) + + TL081_DIP(IC24) // Op. Amp. + NET_C(IC24.7, I_V15) + NET_C(IC24.4, I_VM15) + + TL081_DIP(IC25) // Op. Amp. + NET_C(IC25.7, I_V15) + NET_C(IC25.4, I_VM15) + + TL081_DIP(IC26) // Op. Amp. + NET_C(IC26.7, I_V15) + NET_C(IC26.4, I_VM15) + + TTL_7414_DIP(IC27) // Hex Inverter + NET_C(IC27.7, GND) + NET_C(IC27.14, I_V5) + + // + // Page 1: inputs and shift register + // + + NET_C(I_OUT_1, IC27.13) + ALIAS(TANK_EN, IC27.12) + NET_C(I_OUT_2, IC27.9) + ALIAS(BEEP_EN, IC27.8) + NET_C(I_OUT_3, IC27.3) + ALIAS(CHOPPER_SW, IC27.4) + + NET_C(I_V5, R1.1) + NET_C(R1.2, IC2.9, IC2.1) + ALIAS(HI, R1.2) + NET_C(I_OUT_7, IC1.13) + NET_C(IC1.12, IC1.1) + NET_C(IC1.2, IC2.2) + NET_C(I_OUT_4, IC1.11) + NET_C(IC1.10, IC1.5) + NET_C(IC1.6, IC2.8) + NET_C(IC2.3, IC3.3) + NET_C(IC2.4, IC3.4) + NET_C(IC2.5, IC3.7) + NET_C(IC2.6, IC3.8) + NET_C(IC2.10, IC3.13) + NET_C(IC2.11, IC3.14) + NET_C(IC2.12, IC3.17) + NET_C(IC2.13, IC3.18) + + NET_C(I_OUT_0, IC27.11) + NET_C(IC27.10, IC27.5) + NET_C(IC27.6, IC3.11) + NET_C(IC3.1, GND) + ALIAS(TANK_FIRE, IC3.2) + ALIAS(HI_EXP, IC3.5) + ALIAS(JEEP_FIRE, IC3.6) + ALIAS(LO_EXP, IC3.9) + NET_C(IC3.12, IC8.6) + NET_C(IC3.15, IC8.5) + NET_C(IC3.16, IC8.4) + NET_C(IC3.19, IC8.3) + + // + // Page 1: Tank EN + // + + NET_C(I_V5, IC6.8, R2.2) + NET_C(R2.1, IC6.7, R3.2) + NET_C(R3.1, IC6.2, IC6.6, C11.1) + NET_C(C11.2, GND) + NET_C(TANK_EN, IC6.4, IC7.9) + NET_C(IC6.1, GND) + NET_C(IC6.5, C12.1) + NET_C(C12.2, GND) + NET_C(IC6.3, IC1.9) + NET_C(IC1.8, IC8.2) + NET_C(IC8.7, IC8.10, IC8.1, HI) + NET_C(IC8.15, IC9.1, IC9.2, IC11.2, IC10.1) + NET_C(IC8.9, IC9.3) + NET_C(IC10.2, GND) + NET_C(IC10.6, IC9.9, IC13.13) + + NET_C(IC11.1, IC11.10, IC11.7, IC11.3, IC11.4, HI) + NET_C(IC11.5, IC11.6, GND) + NET_C(IC11.15, IC1.3) + NET_C(IC1.4, IC11.9) + NET_C(IC11.11, IC9.10) + NET_C(IC9.8, IC10.13) + NET_C(IC10.12, GND) + NET_C(IC10.11, R6.1) + NET_C(R6.2, C13.1, C14.2) + NET_C(C13.2, GND) + NET_C(C14.1, R7.1) + ALIAS(SJ, R7.2) + + NET_C(IC7.8, R8.1, IC13.12) + NET_C(R8.2, I_V5) + NET_C(IC13.8, R5.1, IC7.5) + ALIAS(SH2_1, IC13.8) + NET_C(R5.2, I_V5) + NET_C(IC13.9, IC7.11, R9.1, IC7.13) + ALIAS(SH2_3, IC13.9) + NET_C(R9.2, I_V5) + NET_C(IC7.10, IC7.6, R10.1) + ALIAS(SH2_5, R10.1) + NET_C(R10.2, I_V5) + + ALIAS(SH2_2, R19.1) + ALIAS(SH2_4, R20.1) + ALIAS(SH2_6, R21.1) + NET_C(R19.2, R20.2, R21.2, R22.2, C18.1, R23.1) + NET_C(R22.1, GND) + NET_C(C18.2, GND) + NET_C(R23.2, I_V15) + +#if (HLE_TANK_VCO) + // + // R2 = 0.98110: HP = (0.00000599036*A0) - 0.0000565124 + // R2 = 0.99782: HP = (0.00000194885*A0*A0) - (0.0000415989*A0) + 0.000233746 + // R2 = 0.99811: HP = (0.000000646112*A0*A0*A0) - (0.0000215063*A0*A0) + (0.000242010*A0) - 0.000908469 + // R2 = 0.99589: HP = (0.000000217354*A0*A0*A0*A0) - (0.0000098166*A0*A0*A0) + (0.000167248*A0*A0) - (0.00127054*A0) + 0.00363402 + // R2 = 0.92249: HP = (0.00000000630602*A0*A0*A0*A0*A0) - (0.000000220145*A0*A0*A0*A0) + (0.00000210638*A0*A0*A0) + (0.00000707526*A0*A0) - (0.000207037*A0) + 0.000836264 + // + VARCLOCK(TANKCLK, 1, "max(0.000001,min(0.1,(0.000000646112*A0*A0*A0) - (0.0000215063*A0*A0) + (0.000242010*A0) - 0.000908469))") + NET_C(TANKCLK.GND, GND) + NET_C(TANKCLK.VCC, I_V5) + NET_C(R19.2, TANKCLK.A0) + NET_C(TANKCLK.Q, IC13.1) + NET_C(GND, R4.1, R4.2, R11.1, R11.2, R12.1, R12.2, R13.1, R13.2, C15.1, C15.2, C16.1, C16.2, C17.1, C17.2, D5.A, D5.K, D8.A, D8.K) +#else + NET_C(IC15.5, R19.2, C15.2) + NET_C(IC15.7, C17.1) + NET_C(C17.2, GND) + NET_C(IC15.1, GND) + NET_C(IC15.6, C15.1, R11.1) + NET_C(R11.2, IC15.8, I_V15) + NET_C(IC15.3, C16.2) + NET_C(C16.1, R12.1, D5.K) + NET_C(D5.A, GND) + NET_C(R12.2, Q1.B) + NET_C(Q1.E, D8.K, R4.2) + NET_C(D8.A, GND) + NET_C(R4.1, I_VM15) + NET_C(Q1.C, IC13.1, R13.1) + NET_C(R13.2, I_V5) +#endif + + NET_C(IC7.12, R110.1, IC13.2) + NET_C(R110.2, I_V5) + NET_C(IC13.5, R15.1) + NET_C(IC13.4, R16.1) + NET_C(IC13.3, R17.1) + NET_C(R15.2, R16.2, R17.2, R18.2, C19.2) + NET_C(R18.1, GND) + NET_C(C19.1, R14.1) + NET_C(R14.2, SJ) + + // + // Page 2 stuff + // + + NET_C(SH2_1, R96.1) + NET_C(R96.2, R95.1, Q14.B) + NET_C(R95.2, I_V5, Q14.E) + NET_C(Q14.C, R97.2, R98.2, R99.1) + NET_C(R97.1, I_VM15) + NET_C(R98.1, GND, Q15.E) + NET_C(R99.2, Q15.B) + NET_C(Q15.C, SH2_2) + + NET_C(SH2_3, R101.1) + NET_C(R101.2, R100.1, Q16.B) + NET_C(R100.2, I_V5, Q16.E) + NET_C(Q16.C, R102.2, R103.2, R104.1) + NET_C(R102.1, I_VM15) + NET_C(R103.1, GND, Q17.E) + NET_C(R104.2, Q17.B) + NET_C(Q17.C, SH2_4) + + NET_C(SH2_5, R106.1) + NET_C(R106.2, R105.1, Q18.B) + NET_C(R105.2, I_V5, Q18.E) + NET_C(Q18.C, R107.2, R108.2, R109.1) + NET_C(R107.1, I_VM15) + NET_C(R108.1, GND, Q19.E) + NET_C(R109.2, Q19.B) + NET_C(Q19.C, SH2_6) + + // + // Page 3 + // + + NET_C(I_V15, C20.1, IC17.4) + NET_C(C20.2, GND) + NET_C(IC17.2, IC17.1, GND, R26.1) + NET_C(IC17.3, C21.2) + NET_C(C21.1, R26.2, IC18.3) + NET_C(IC18.2, IC18.6) + ALIAS(NOISE, IC18.6) + + // + // TANK FIRE + // + + NET_C(TANK_FIRE, R27.1, R28.1) + NET_C(R27.2, I_V5, R29.2, Q2.E) + NET_C(R28.2, R29.1, Q2.B) + NET_C(Q2.C, R30.2, R31.2, Q3.E) + NET_C(R30.1, I_VM15) + NET_C(R31.1, GND, R32.1) + NET_C(R32.2, Q3.B) + NET_C(Q3.C, C22.1, R33.1) + NET_C(C22.2, I_VM15) + NET_C(R33.2, IC19.5) + NET_C(NOISE, R34.1) + NET_C(R34.2, C23.1, R35.1) + NET_C(R35.2, C24.1, R36.1) + NET_C(C23.2, C24.2, GND, R37.1, R38.1) + NET_C(R36.2, R37.2, IC19.2) + NET_C(R38.2, IC19.3) + NET_C(IC19.6, IC25.3) + + // + // LO EXP + // + + NET_C(LO_EXP, R39.1, R40.1) + NET_C(R39.2, I_V5, R41.2, Q4.E) + NET_C(R40.2, R41.1, Q4.B) + NET_C(Q4.C, R42.2, R43.2, Q5.E) + NET_C(R42.1, I_VM15) + NET_C(R43.1, GND, R44.1) + NET_C(R44.2, Q5.B) + NET_C(Q5.C, C25.1, R45.1) + NET_C(C25.2, I_VM15) + NET_C(R45.2, IC20.5) + NET_C(NOISE, R46.1) + NET_C(R46.2, C26.1, R47.1) + NET_C(R47.2, C27.1, R48.1) + NET_C(C26.2, C27.2, GND, R49.1, R50.1) + NET_C(R48.2, R49.2, IC20.2) + NET_C(R50.2, IC20.3) + NET_C(IC20.6, IC25.3) + + // + // CHOPPER SW + // + + NET_C(CHOPPER_SW, IC7.3) + NET_C(IC7.4, R51.1, R52.1) + NET_C(R51.2, I_V5, R53.2, Q6.E) + NET_C(R52.2, R53.1, Q6.B) + NET_C(Q6.C, R54.2, R55.2, Q7.E) + NET_C(R54.1, I_VM15) + NET_C(R55.1, R56.1, GND) + NET_C(R56.2, Q7.B) + NET_C(Q7.C, R57.1) + NET_C(R57.2, IC21.5) + NET_C(NOISE, R58.1) + NET_C(R58.2, C29.1, R59.1) + NET_C(R59.2, C30.1, R94.1) + NET_C(C29.2, C30.2, GND, R60.1, R61.1) + NET_C(R94.2, R60.2, IC21.2) + NET_C(R61.2, IC21.3) + NET_C(IC21.6, IC25.3) + + // + // JEEP FIRE + // + + NET_C(JEEP_FIRE, R62.1, R63.1) + NET_C(R62.2, I_V5, R64.2, Q8.E) + NET_C(R63.2, R64.1, Q8.B) + NET_C(Q8.C, R65.2, R66.2, Q9.E) + NET_C(R65.1, I_VM15) + NET_C(R66.1, GND, R67.1) + NET_C(R67.2, Q9.B) + NET_C(Q9.C, C31.1, R68.1) + NET_C(C31.2, I_VM15) + NET_C(R68.2, R80.2, IC22.5) + NET_C(NOISE, R69.1) + NET_C(R69.2, C32.1, R70.1) + NET_C(R70.2, C33.1, R71.1) + NET_C(C32.2, C33.2, GND, R72.1, R73.1) + NET_C(R71.2, R72.2, IC22.2) + NET_C(R73.2, IC22.3) + NET_C(IC22.6, IC25.3) + + // + // HI EXP + // + + NET_C(HI_EXP, R74.1, R75.1) + NET_C(R74.2, I_V5, R76.2, Q10.E) + NET_C(R75.2, R76.1, Q10.B) + NET_C(Q10.C, R77.2, R78.2, Q11.E) + NET_C(R77.1, I_VM15) + NET_C(R78.1, GND, R79.1) + NET_C(R79.2, Q11.B) + NET_C(Q11.C, C34.1, R80.1) + NET_C(C34.2, I_VM15) + + // + // BEEP EN + // + + NET_C(BEEP_EN, IC23.4) + NET_C(I_V5, R81.2, IC23.8) + NET_C(R81.1, R82.1, IC23.6, IC23.2, C35.1) + NET_C(R82.2, IC23.7) + NET_C(C35.2, GND) + NET_C(IC23.1, GND) + NET_C(IC23.5, C37.1) + NET_C(C37.2, GND) + NET_C(IC23.3, R83.1) + NET_C(R83.2, C36.1) + NET_C(C36.2, SJ) + + // + // Final mix + // + + NET_C(R90.2, IC25.3) + NET_C(R90.1, GND) + NET_C(IC25.2, IC25.6, C43.1) + NET_C(C43.2, R91.1) + NET_C(R91.2, IC26.2, SJ, R92.1) + NET_C(IC26.3, GND) + NET_C(IC26.6, R92.2) + ALIAS(OUTPUT, R92.2) + + // + // Unconnected inputs + // + + NET_C(GND, IC7.1, IC9.4, IC9.5, IC9.12, IC9.13, IC27.1, IC27.2) + NET_C(GND, IC24.2, IC24.3) // part of final amp + + // + // Unconnected outputs + // + + HINT(IC7.2, NC) + HINT(IC8.11, NC) // QD + HINT(IC8.12, NC) // QC + HINT(IC8.13, NC) // QB + HINT(IC8.14, NC) // QA + HINT(IC9.6, NC) + HINT(IC9.11, NC) + HINT(IC10.3, NC) // QA + HINT(IC10.4, NC) // QB + HINT(IC10.5, NC) // QC + HINT(IC10.8, NC) // QD + HINT(IC10.9, NC) // QC + HINT(IC10.10, NC) // QB + HINT(IC11.12, NC) // QC + HINT(IC11.13, NC) // QB + HINT(IC11.14, NC) // QA + HINT(IC13.6, NC) + HINT(IC13.10, NC) + HINT(IC13.11, NC) +// HINT(IC27.2, NC) + +NETLIST_END() diff --git a/src/mame/audio/nl_armora.h b/src/mame/audio/nl_armora.h new file mode 100644 index 00000000000..a6109f0861c --- /dev/null +++ b/src/mame/audio/nl_armora.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_ARMORA_H +#define MAME_AUDIO_NL_ARMORA_H + +#pragma once + +NETLIST_EXTERNAL(armora) + +#endif // MAME_AUDIO_NL_ARMORA_H diff --git a/src/mame/audio/nl_barrier.cpp b/src/mame/audio/nl_barrier.cpp new file mode 100644 index 00000000000..6fba85cb579 --- /dev/null +++ b/src/mame/audio/nl_barrier.cpp @@ -0,0 +1,307 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Barrier +// +// Derived from the schematics in the Barrier manual. This sound +// board is quite similar to Space Wars. +// +// Known problems/issues: +// +// * The core noise source is supposed to be created via a +// pair of transistors, one with an open base. Because this +// does not model correctly, this part of the circuit is +// replaced with a generic noise device. The characteristics +// of this noise are pretty different compared to recordings +// of the original, and affects all the sounds. +// +// * The schematics show a connection betwee U8.6 and +// R37.2; however, implementing this leads to a direct input +// from the noise source at all times to the summing amp. +// Suspecting this is a typo in the schematics. +// +// * Unsure if Barrier should have the noisy background like +// Space Wars. Space Wars has a hard overall mute to suppress +// it when the game isn't running, but Barrier does not. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_barrier.h" + + +// +// Optimizations +// + +#define HLE_NOISE_GEN (1) +#define ENABLE_FRONTIERS (1) + + +// +// Main netlist +// + +NETLIST_START(barrier) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(18)) + RES(R2, 470) + RES(R3, RES_K(47)) + RES(R4, RES_K(220)) + RES(R5, 470) + RES(R6, 150) + RES(R7, RES_K(180)) + RES(R8, RES_M(10)) + RES(R9, RES_K(39)) + RES(R10, RES_K(2.2)) + RES(R11, 470) + RES(R12, RES_K(30)) + RES(R13, RES_K(8.2)) + RES(R14, RES_K(33)) + RES(R15, RES_K(15)) + RES(R16, RES_M(10)) + RES(R17, RES_K(10)) + RES(R18, RES_K(47)) + RES(R19, 820) +// POT(R20, RES_K(10)) -- part of final amp (not emulated) +// RES(R21, 150) -- part of final amp (not emulated), not present on Space Wars +// RES(R22, 2.7) -- part of final amp (not emulated), not present on Space Wars +// RES(R23, 2.7) -- part of final amp (not emulated), not present on Space Wars + RES(R24, RES_K(47)) + RES(R25, 150) + RES(R26, RES_K(160)) + RES(R27, 750) +// RES(R28, RES_K(150)) -- part of final amp (not emulated), illegible on Space Wars +// POT(R29, RES_K(10)) -- part of final amp (not emulated) +// RES(R30, 470) -- part of final amp (not emulated) + RES(R31, 470) + RES(R32, RES_K(1)) + RES(R33, RES_K(39)) + RES(R34, RES_K(6.8)) + RES(R35, RES_K(560)) + RES(R36, RES_M(1)) + RES(R37, RES_K(10)) + RES(R38, RES_K(10)) + + CAP(C1, CAP_U(1)) + CAP(C2, CAP_U(1)) + CAP(C3, CAP_U(0.01)) + CAP(C4, CAP_U(0.01)) + CAP(C5, CAP_U(0.1)) +// CAP(C6, CAP_U(4.7)) // not needed + CAP(C7, CAP_U(0.01)) + CAP(C8, CAP_U(1)) + CAP(C9, CAP_U(0.1)) + CAP(C10, CAP_P(220)) + CAP(C11, CAP_U(0.1)) +// CAP(C12, CAP_U(0.01)) -- part of final amp (not emulated) +// CAP(C13, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C14, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C15, CAP_U(50)) -- not needed +// CAP(C16, CAP_U(2.2)) -- not needed + CAP(C17, CAP_U(0.01)) + CAP(C18, CAP_U(15)) +// CAP(C19, CAP_U(50)) -- not needed +// CAP(C20, CAP_U(2.2)) -- not needed + CAP(C21, CAP_U(0.02)) + CAP(C22, CAP_U(0.1)) + + D_1N914(CR1) + D_1N914(CR2) + D_1N914(CR3) + D_1N914(CR4) + D_1N914(CR5) + D_1N914(CR6) + + Q_2N3906(Q1) // PNP + Q_2N3904(Q2) // NPN + Q_2N6426(Q3) // NPN Darlington + Q_2N6292(Q4) // NPN + Q_2N6107(Q5) // PNP + Q_2N6426(Q6) // NPN Darlington + Q_2N3904(Q7) // NPN + + TL081_DIP(U1) // Op. Amp. + NET_C(U1.4, I_VM15) + NET_C(U1.7, I_V15) + + TTL_7406_DIP(U2) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(U2.7, GND) + NET_C(U2.14, I_V5) + + TL081_DIP(U3) // Op. Amp. + NET_C(U3.4, I_VM15) + NET_C(U3.7, I_V15) + +// TTL_7815_DIP(U4) // +15V Regulator -- not needed + + TL182_DIP(U5) // Analog switch + NET_C(U5.6, I_V15) + NET_C(U5.7, I_V5) + NET_C(U5.8, GND) + NET_C(U5.9, I_VM15) + +// TL081_DIP(U6) // Op. Amp. -- part of final amp (not emulated) +// NET_C(U6.4, I_VM15) +// NET_C(U6.7, I_V15) + +// TTL_7915_DIP(U7) // -15V Regulator -- not needed + + TL081_DIP(U8) // Op. Amp. + NET_C(U8.4, I_VM15) + NET_C(U8.7, I_V15) + + TL081_DIP(U9) // Op. Amp. + NET_C(U9.4, I_VM15) + NET_C(U9.7, I_V15) + + // + // Top-left until output from U1 + // + +#if (HLE_NOISE_GEN) + CLOCK(NOISE_CLOCK, 2000) + NET_C(NOISE_CLOCK.GND, GND) + NET_C(NOISE_CLOCK.VCC, I_V5) + + SYS_NOISE_MT_U(NOISE, 3) + NET_C(NOISE.I, NOISE_CLOCK.Q) + NET_C(NOISE.1, GND) + NET_C(NOISE.2, C1.1) + + NET_C(GND, R1.1, R1.2, R2.1, R2.2, CR1.A, CR1.K, CR2.A, CR2.K) +#else + NET_C(I_V15, CR1.A) + NET_C(CR1.K, CR2.A) + NET_C(CR2.K, R1.2, Q1.B) + NET_C(R1.1, GND) + NET_C(I_V15, R2.2) + NET_C(R2.1, Q1.E) + NET_C(Q2.E, Q1.C, C1.1) + NET_C(Q2.C, GND) +#endif + + NET_C(C1.2, R3.2, U1.3) + NET_C(R3.1, GND) + NET_C(U1.2, R5.2, R4.1) + NET_C(R5.1, GND) + NET_C(R4.2, U1.6) + + // + // Top-middle, from O1 until output from CR3 + // + + NET_C(I_OUT_1, U2.13) + NET_C(U2.12, R6.1) + NET_C(R6.2, R7.1, C2.1, Q3.B) + NET_C(R7.2, I_V5) + NET_C(C2.2, GND) + NET_C(Q3.E, R11.2) + NET_C(Q3.C, I_V5) + NET_C(R11.1, CR3.A) + + // + // Middle chunk, from C3 until output from R13 + // + + NET_C(U1.6, C3.1) + NET_C(C3.2, R8.1, U3.2) + NET_C(U3.3, GND) + NET_C(R8.2, U3.6, R9.1) + NET_C(R9.2, CR3.K, C4.1, CR4.A, R10.2) + NET_C(R10.1, CR4.K, GND) + NET_C(C4.2, R12.1) + NET_C(R12.2, C5.2, R13.1) + NET_C(C5.1, GND) + + // + // Big middle section, from C8 until output from R15/R41/R37 + // + + NET_C(U1.6, C8.2) + NET_C(C8.1, R24.1) + NET_C(R24.2, U8.2, C10.1, R16.1) + NET_C(U8.3, GND) + NET_C(U8.6, R16.2, C10.2, R31.1, R38.1) +// NET_C(U8.6, R13.2) // Schems show noise source into summing amp -- wrong?? + NET_C(R38.2, U5.14) + NET_C(I_OUT_2, U5.10) + NET_C(U5.13, C7.1) + NET_C(C7.2, R14.1) + NET_C(R37.2, R13.2) + NET_C(R14.2, C9.2, R15.1) + NET_C(C9.1, GND) + NET_C(R15.2, R13.2) + NET_C(I_OUT_0, U2.9) + NET_C(U2.8, R25.1) + NET_C(R25.2, R26.1, C17.1, Q6.B, C18.1) + NET_C(R26.2, C17.2, I_V5) + NET_C(C18.2, GND) + NET_C(Q6.E, R27.2) + NET_C(Q6.C, I_V5) + NET_C(R27.1, CR5.A) + NET_C(CR5.K, R33.2, CR6.A, R34.2, C21.2, C22.1) + NET_C(R31.2, R32.2, R33.1, Q7.E) + NET_C(R32.1, Q7.B) + NET_C(Q7.C, CR6.K, R34.1, C21.1, GND) + NET_C(C22.2, R35.1) + NET_C(R35.2, U9.2, R36.1) + NET_C(U9.3, GND) + NET_C(U9.6, R36.2, R37.1) + + // + // Final stage + // + + NET_C(R17.2, C11.1, R13.2) + NET_C(R17.1, R18.1, GND) + NET_C(C11.2, R18.2, R19.1) + NET_C(R19.2, GND) + ALIAS(OUTPUT, R18.2) + + // + // Unconnected inputs + // + + NET_C(GND, U2.3, U2.5, U2.11) + NET_C(GND, U5.1, U5.2, U5.5, U2.1) + + // + // Frontier optimizations + // + +#if (ENABLE_FRONTIERS) + // Separate each input into the summing network + OPTIMIZE_FRONTIER(R13.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R15.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R37.1, RES_M(1), 50) + + // Decouple the Darlington BJTs from the sounds they enable + OPTIMIZE_FRONTIER(R27.2, RES_M(1), 50) + OPTIMIZE_FRONTIER(R11.2, RES_M(1), 50) + + // Decouple the noise source from the downstream filters + OPTIMIZE_FRONTIER(C3.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R24.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R38.1, RES_M(1), 50) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_barrier.h b/src/mame/audio/nl_barrier.h new file mode 100644 index 00000000000..451bf922f2d --- /dev/null +++ b/src/mame/audio/nl_barrier.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_BARRIER_H +#define MAME_AUDIO_NL_BARRIER_H + +#pragma once + +NETLIST_EXTERNAL(barrier) + +#endif // MAME_AUDIO_NL_BARRIER_H diff --git a/src/mame/audio/nl_boxingb.cpp b/src/mame/audio/nl_boxingb.cpp new file mode 100644 index 00000000000..6222b04352c --- /dev/null +++ b/src/mame/audio/nl_boxingb.cpp @@ -0,0 +1,1718 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Boxing Bugs +// +// Derived from the schematics in the Boxing Bugs manual. +// +// Known problems/issues: +// +// * WIP. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_boxingb.h" + + +// +// Hacks/workarounds +// + +#define HACK_SIMPLIFY_INPUTS (1) +#define HACK_VOLTAGE_SWITCH (1) + + + +// +// Optimizations +// + +#define HLE_SFX_CLOCK (1) +#define HLE_MUSIC_CLOCK (1) +#define HLE_CHIRPING_VCO (1) +#define HLE_DYING_BUG_VCO (1) +#define HLE_CRACKING_VCO (1) +#define HLE_BEETLE_VCO (1) +#define HLE_BOUNCE_VCO (1) +#define HLE_CANNON_VCO (1) +#define ENABLE_FRONTIERS (1) + + + +// +// Main netlist +// + +NETLIST_START(boxingb) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + TTL_INPUT(I_OUT_7, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V2_2, 2.2) + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + +// RES(R4, 620) -- part of voltage converter (not emulated) +// RES(R5, 620) -- part of voltage converter (not emulated) +// RES(R6, 430) -- part of 2.2V voltage converter (not emulated) +// RES(R7, 560) -- part of 2.2V voltage converter (not emulated) +// RES(R8, RES_K(3.3)) -- part of 2.2V voltage converter (not emulated) + RES(R9, RES_K(1)) + RES(R10, RES_K(4.7)) + RES(R11, RES_K(1)) + RES(R12, RES_K(39)) + RES(R13, RES_K(12)) + RES(R14, RES_K(1)) + RES(R15, RES_K(4.7)) + RES(R16, RES_K(75)) + RES(R17, RES_K(75)) + RES(R18, 200) + RES(R19, 200) + RES(R20, RES_K(200)) + RES(R21, RES_K(4.7)) + RES(R22, RES_K(4.7)) + RES(R23, RES_K(2.7)) + RES(R24, RES_K(4.7)) + RES(R25, RES_K(39)) + RES(R26, RES_K(12)) + RES(R27, RES_K(2.4)) + RES(R28, RES_K(51)) + RES(R29, RES_K(270)) + RES(R30, RES_M(1)) + RES(R31, RES_K(16)) + RES(R32, RES_K(10)) + RES(R33, RES_K(1)) + RES(R34, RES_K(4.7)) + RES(R35, RES_K(2.7)) + RES(R36, RES_K(4.7)) + RES(R37, RES_K(39)) + RES(R38, RES_K(12)) + RES(R39, RES_K(2.4)) + RES(R40, RES_K(51)) + RES(R41, RES_K(270)) + RES(R42, RES_M(1)) + RES(R43, RES_K(11)) + RES(R44, RES_K(10)) + RES(R45, RES_K(1)) + RES(R46, RES_K(2)) + RES(R47, RES_K(1)) + RES(R48, RES_K(12)) + RES(R49, RES_K(1)) + RES(R50, RES_K(20)) + RES(R51, RES_K(20)) + RES(R52, RES_K(20)) + RES(R53, RES_K(20)) + RES(R54, RES_K(2)) + RES(R55, RES_K(4.7)) + RES(R56, RES_K(2.7)) + RES(R57, RES_K(4.7)) + RES(R58, RES_K(39)) + RES(R59, RES_K(12)) + RES(R60, RES_K(2.4)) + RES(R61, RES_K(51)) + RES(R62, RES_K(270)) + RES(R63, RES_M(1)) + RES(R64, RES_K(6.2)) + RES(R65, RES_K(10)) + RES(R66, RES_K(1)) + RES(R67, RES_K(2)) + RES(R68, RES_K(22)) + RES(R69, RES_K(39)) + RES(R70, RES_K(47)) + RES(R71, RES_K(1)) + RES(R72, RES_K(10)) + RES(R73, RES_K(2)) + RES(R74, RES_K(910)) + RES(R75, 390) +#if (HACK_VOLTAGE_SWITCH) + RES(R76, 100) +#else + RES(R76, RES_K(4.7)) +#endif + RES(R77, RES_K(2.7)) + RES(R78, RES_K(4.7)) + RES(R79, RES_K(39)) + RES(R80, RES_K(12)) + RES(R81, RES_K(2.4)) + RES(R82, RES_K(51)) + RES(R83, RES_K(270)) + RES(R84, RES_M(1)) + RES(R85, RES_K(12)) + RES(R86, RES_K(10)) + RES(R87, RES_K(1)) + RES(R88, RES_K(2)) + RES(R89, RES_K(20)) + RES(R90, RES_K(2)) + RES(R91, RES_K(20)) +#if (HACK_VOLTAGE_SWITCH) + RES(R92, 100) +#else + RES(R92, RES_K(4.7)) +#endif + RES(R93, RES_K(2.7)) + RES(R94, RES_K(4.7)) + RES(R95, RES_K(39)) + RES(R96, RES_K(12)) + RES(R97, RES_K(2.4)) + RES(R98, RES_K(51)) + RES(R99, RES_K(330)) + RES(R100, RES_K(1)) + RES(R101, RES_M(1)) + RES(R102, 47) + RES(R103, RES_K(4.7)) + RES(R104, RES_K(1)) + RES(R105, RES_K(39)) + RES(R106, RES_K(12)) + RES(R107, RES_K(1)) + RES(R108, RES_K(6.8)) + RES(R109, RES_K(100)) + RES(R110, RES_K(270)) + RES(R111, 100) + RES(R112, 100) + RES(R113, RES_K(4.7)) + RES(R114, RES_K(1)) + RES(R115, RES_K(39)) + RES(R116, RES_K(12)) + RES(R117, RES_K(2.4)) + RES(R118, RES_K(51)) + RES(R119, RES_K(270)) + RES(R120, RES_M(1)) + RES(R121, RES_K(10)) + RES(R122, RES_K(10)) + RES(R123, RES_K(1)) + RES(R124, RES_K(2)) + RES(R125, RES_K(20)) + RES(R126, RES_K(2)) + RES(R127, RES_K(3.9)) + RES(R128, 10) + RES(R129, RES_M(1)) + RES(R130, RES_K(6.8)) + RES(R131, RES_K(18)) + RES(R132, RES_K(47)) + RES(R133, 390) + RES(R134, 390) + RES(R135, RES_K(4.7)) + RES(R136, RES_K(2.7)) + RES(R137, RES_K(4.7)) + RES(R138, RES_K(39)) + RES(R139, RES_K(12)) + RES(R140, RES_K(1)) + RES(R141, RES_K(75)) + RES(R142, RES_K(4.7)) + RES(R143, RES_K(2.7)) + RES(R144, RES_K(4.7)) + RES(R145, RES_K(39)) + RES(R146, RES_K(12)) + RES(R147, RES_K(1)) + RES(R148, RES_K(240)) + RES(R149, RES_K(300)) + RES(R150, RES_K(300)) +// RES(R151, RES_K(15)) -- part of final amp (not emulated) +// RES(R152, 150) -- part of final amp (not emulated) +// RES(R153, 150) -- part of final amp (not emulated) +// RES(R154, RES_K(22)) -- part of final amp (not emulated) +// RES(R155, RES_K(390)) -- part of final amp (not emulated) +// RES(R156, 0.51) -- part of final amp (not emulated) +// RES(R157, 0.51) -- part of final amp (not emulated) +// RES(R158, RES_K(390)) -- part of final amp (not emulated) + RES(R159, RES_K(30)) + RES(R160, RES_K(8.2)) + RES(R161, RES_K(20)) +// RES(R162, RES_K(10)) -- part of shaft encoder (not emulated) +// RES(R163, RES_K(100)) -- part of shaft encoder (not emulated) +// RES(R164, RES_M(1.8)) -- part of shaft encoder (not emulated) +// RES(R165, RES_K(10)) -- part of shaft encoder (not emulated) +// RES(R166, RES_K(2.4)) -- part of shaft encoder (not emulated) +// RES(R167, RES_K(1)) -- part of shaft encoder (not emulated) +// RES(R168, RES_K(470)) -- part of shaft encoder (not emulated) +// RES(R169, RES_K(10)) -- part of shaft encoder (not emulated) +// RES(R170, RES_K(470)) -- part of shaft encoder (not emulated) +// RES(R171, RES_K(100)) -- part of shaft encoder (not emulated) +// RES(R172, RES_M(1.8)) -- part of shaft encoder (not emulated) +// RES(R173, RES_K(10)) -- part of shaft encoder (not emulated) +// RES(R174, RES_K(2.4)) -- part of shaft encoder (not emulated) +// RES(R175, RES_K(1)) -- part of shaft encoder (not emulated) +// RES(R176, RES_K(1)) -- part of shaft encoder (not emulated) + RES(R177, RES_K(1)) + RES(R178, 330) + RES(R179, 330) + RES(R180, RES_K(1)) + RES(R181, RES_K(1)) + RES(R182, RES_K(1)) + RES(R183, RES_K(4.7)) + RES(R184, RES_K(510)) + RES(R185, 470) + RES(R186, 470) + RES(R187, RES_K(4.7)) + RES(R188, RES_K(2.7)) + RES(R189, RES_K(4.7)) + RES(R190, RES_K(39)) + RES(R191, RES_K(12)) + RES(R192, RES_K(1)) + RES(R193, RES_K(24)) + RES(R194, RES_K(100)) + RES(R195, RES_K(4.7)) + RES(R196, RES_K(2.7)) + RES(R197, RES_K(4.7)) + RES(R198, RES_K(39)) + RES(R199, RES_K(12)) + RES(R200, RES_K(1)) + RES(R201, RES_K(51)) + RES(R202, RES_K(36)) + RES(R203, RES_K(1)) + RES(R204, RES_K(1)) + RES(R205, RES_K(2)) + RES(R206, RES_K(1)) + RES(R207, RES_K(1)) + RES(R208, RES_K(1)) + RES(R209, RES_K(1)) + +// CAP(C1, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C2, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C3, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C4, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C5, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C6, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C7, CAP_U(22)) -- part of voltage converter (not emulated) +// CAP(C8, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C9, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C10, CAP_U(0.1)) -- part of 2.2V voltage converter (not emulated) + CAP(C11, CAP_U(0.1)) + CAP(C12, CAP_U(0.1)) + CAP(C13, CAP_U(1)) + CAP(C14, CAP_U(2.2)) + CAP(C15, CAP_U(0.001)) + CAP(C16, CAP_U(0.001)) + CAP(C17, CAP_U(0.1)) + CAP(C18, CAP_U(2.2)) + CAP(C19, CAP_U(0.001)) + CAP(C20, CAP_U(0.001)) + CAP(C21, CAP_U(0.1)) + CAP(C22, CAP_U(0.01)) + CAP(C23, CAP_U(0.1)) + CAP(C24, CAP_U(0.68)) + CAP(C25, CAP_U(0.001)) + CAP(C26, CAP_U(0.0022)) + CAP(C27, CAP_U(0.1)) + CAP(C28, CAP_U(0.1)) + CAP(C29, CAP_U(0.1)) + CAP(C30, CAP_U(0.01)) + CAP(C31, CAP_U(4.7)) + CAP(C32, CAP_U(0.001)) + CAP(C33, CAP_U(0.01)) + CAP(C34, CAP_U(0.1)) + CAP(C35, CAP_U(0.1)) + CAP(C36, CAP_U(2.2)) + CAP(C37, CAP_U(0.1)) + CAP(C38, CAP_U(0.01)) + CAP(C39, CAP_U(0.001)) + CAP(C40, CAP_U(0.47)) + CAP(C41, CAP_U(1)) + CAP(C42, CAP_U(0.1)) + CAP(C43, CAP_U(0.47)) + CAP(C44, CAP_U(0.001)) + CAP(C45, CAP_U(0.1)) + CAP(C46, CAP_U(0.1)) + CAP(C47, CAP_U(100)) + CAP(C48, CAP_U(0.1)) + CAP(C49, CAP_U(0.1)) + CAP(C50, CAP_U(0.01)) + CAP(C51, CAP_U(4.7)) + CAP(C52, CAP_U(0.47)) + CAP(C53, CAP_U(0.1)) + CAP(C54, CAP_U(0.1)) +// CAP(C55, CAP_U(0.68)) +// CAP(C56, CAP_U(0.005)) -- part of final amp (not emulated) +// CAP(C57, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C58, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C59, CAP_P(470)) -- part of final amp (not emulated) + CAP(C60, CAP_U(0.33)) + CAP(C61, CAP_P(330)) +// CAP(C62, CAP_U(0.1)) -- part of shaft encoder (not emulated) +// CAP(C63, CAP_P(330)) -- part of shaft encoder (not emulated) +// CAP(C64, CAP_P(330)) -- part of shaft encoder (not emulated) +// CAP(C65, CAP_P(330)) -- part of shaft encoder (not emulated) +// CAP(C66, CAP_P(330)) -- part of shaft encoder (not emulated) + CAP(C67, CAP_U(0.001)) + CAP(C68, CAP_P(680)) + CAP(C69, CAP_U(0.001)) + CAP(C70, CAP_U(0.001)) + CAP(C71, CAP_U(0.68)) + CAP(C72, CAP_U(0.22)) + CAP(C73, CAP_U(0.1)) + CAP(C74, CAP_U(0.1)) + CAP(C75, CAP_U(0.01)) + +// Q_2N3904(Q1) // NPN -- part of 2.2V voltage converter (not emulated) + Q_2N3906(Q2) // PNP + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3904(Q5) // NPN + Q_2N3904(Q6) // NPN + Q_2N3906(Q7) // PNP + Q_2N3904(Q8) // NPN + Q_2N3904(Q9) // NPN + Q_2N3906(Q10) // PNP + Q_2N3904(Q11) // NPN + Q_2N3904(Q12) // NPN + Q_2N3906(Q13) // PNP + Q_2N3904(Q14) // NPN + Q_2N3904(Q15) // NPN + Q_2N3906(Q16) // PNP + Q_2N3904(Q17) // NPN + Q_2N3906(Q18) // PNP + Q_2N3906(Q19) // PNP + Q_2N3906(Q20) // PNP + Q_2N3904(Q21) // NPN + Q_2N3904(Q22) // NPN + Q_2N3906(Q23) // PNP + Q_2N3906(Q24) // PNP + Q_2N3906(Q25) // PNP + Q_2N3906(Q26) // PNP +// Q_2N6292(Q27) // PNP -- part of final amp (not emulated) +// Q_2N6107(Q28) // NPN -- part of final amp (not emulated) + Q_2N5210(Q29) // NPN + Q_2N5210(Q30) // NPN + Q_2N3906(Q31) // PNP + Q_2N3906(Q32) // PNP + Q_2N3906(Q33) // PNP + Q_2N3906(Q34) // PNP + +// D_1N4003(D1) -- part of voltage converter (not emulated) +// D_1N4003(D2) -- part of voltage converter (not emulated) +// D_1N4003(D3) -- part of voltage converter (not emulated) +// D_1N4003(D4) -- part of voltage converter (not emulated) +// D_1N914(D5) -- part of voltage converter (not emulated) +// D_1N914(D6) -- part of voltage converter (not emulated) +// D_1N5236(D7) -- part of voltage converter (not emulated) +// D_1N5236(D8) -- part of voltage converter (not emulated) +// D_1N5236(D9) -- part of voltage converter (not emulated) +// D_1N5236(D10) -- part of voltage converter (not emulated) +// D_1N914(D11) -- part of voltage converter (not emulated) +// D_1N914(D12) -- part of voltage converter (not emulated) + D_1N914(D13) + D_1N914(D14) + D_1N914(D15) + D_1N914(D16) + D_1N914(D17) + D_1N914(D18) + D_1N914(D19) + D_1N914(D20) + D_1N914(D21) + D_1N914(D22) +// D_1N4003(D23) -- part of final amp (not emulated) +// D_1N4003(D24) -- part of final amp (not emulated) + D_1N914(D25) + D_1N914(D26) + D_1N914(D27) + D_1N914(D28) + D_1N914(D29) + D_1N914(D30) + +#if (!HLE_MUSIC_CLOCK) + CLOCK(Y1, 20000000) + NET_C(Y1.GND, GND) + NET_C(Y1.VCC, I_V5) +#endif + + TTL_74LS393_DIP(U1) // Dual 4-Stage Binary Counter + NET_C(U1.7, GND) + NET_C(U1.14, I_V5) + + TTL_74S04_DIP(U2) // Hex Inverting Gates + NET_C(U2.7, GND) + NET_C(U2.14, I_V5) + +// TTL_74LS74_DIP(U7) // Dual D Flip Flop -- part of shaft encoder (not emulated) +// NET_C(U7.7, GND) +// NET_C(U7.14, I_V5) + +// TTL_74LS74_DIP(U8) // Dual D Flip Flop -- part of shaft encoder (not emulated) +// NET_C(U8.7, GND) +// NET_C(U8.14, I_V5) + + TTL_74LS107_DIP(U9) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U9.7, GND) + NET_C(U9.14, I_V5) + +// TTL_74LS74_DIP(U10) // Dual D Flip Flop -- part of shaft encoder (not emulated) +// NET_C(U10.7, GND) +// NET_C(U10.14, I_V5) + + TTL_74LS164_DIP(U11) // 8-bit Shift Reg. + NET_C(U11.7, GND) + NET_C(U11.14, I_V5) + + TTL_74LS86_DIP(U12) // Quad 2-Input XOR Gates + NET_C(U12.7, GND) + NET_C(U12.14, I_V5) + + TTL_74LS393_DIP(U13) // Dual 4-Stage Binary Counter + NET_C(U13.7, GND) + NET_C(U13.14, I_V5) + + TTL_74LS393_DIP(U15) // Dual 4-Stage Binary Counter + NET_C(U15.7, GND) + NET_C(U15.14, I_V5) + +// TTL_74LS191_DIP(U16) // Presettable 4-bit Binary Up/Down Counter -- part of shaft encoder (not emulated) +// NET_C(U16.8, GND) +// NET_C(U16.16, I_V5) + +// TTL_74LS191_DIP(U17) // Presettable 4-bit Binary Up/Down Counter -- part of shaft encoder (not emulated) +// NET_C(U17.8, GND) +// NET_C(U17.16, I_V5) + +// TTL_74LS157_DIP(U18) // Quad 2-Input Multiplexor -- part of shaft encoder (not emulated) +// NET_C(U18.8, GND) +// NET_C(U18.16, I_V5) + + LM555_DIP(U19) + + TTL_7414_DIP(U20) // Hex Inverter + NET_C(U20.7, GND) + NET_C(U20.14, I_V5) + + TTL_74LS393_DIP(U21) // Dual 4-Stage Binary Counter + NET_C(U21.7, GND) + NET_C(U21.14, I_V5) + + TTL_74LS393_DIP(U22) // Dual 4-Stage Binary Counter + NET_C(U22.7, GND) + NET_C(U22.14, I_V5) + + TTL_74S113_DIP(U23) // Dual JK Negative Edge-Trigged Flip Flop + NET_C(U23.7, GND) + NET_C(U23.14, I_V5) + + TTL_74LS74_DIP(U24) // Dual D Flip Flop + NET_C(U24.7, GND) + NET_C(U24.14, I_V5) + + TTL_74LS74_DIP(U25) // Dual D Flip Flop + NET_C(U25.7, GND) + NET_C(U25.14, I_V5) + + TTL_74LS393_DIP(U26) // Dual 4-Stage Binary Counter + NET_C(U26.7, GND) + NET_C(U26.14, I_V5) + + TTL_74LS163_DIP(U27) // Binary Counter + NET_C(U27.8, GND) + NET_C(U27.16, I_V5) + + TTL_74LS163_DIP(U28) // Binary Counter + NET_C(U28.8, GND) + NET_C(U28.16, I_V5) + + TTL_74LS74_DIP(U29) // Dual D Flip Flop + NET_C(U29.7, GND) + NET_C(U29.14, I_V5) + + TTL_7414_DIP(U30) // Hex Inverter + NET_C(U30.7, GND) + NET_C(U30.14, I_V5) + + TTL_74LS04_DIP(U31) // Hex Inverting Gates + NET_C(U31.7, GND) + NET_C(U31.14, I_V5) + + TTL_74LS393_DIP(U32) // Dual 4-Stage Binary Counter + NET_C(U32.7, GND) + NET_C(U32.14, I_V5) + + TTL_74LS107_DIP(U33) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U33.7, GND) + NET_C(U33.14, I_V5) + + TTL_74LS107_DIP(U34) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U34.7, GND) + NET_C(U34.14, I_V5) + + TTL_74LS02_DIP(U35) // Quad 2-input Nor Gate + NET_C(U35.7, GND) + NET_C(U35.14, I_V5) + + TTL_74LS163_DIP(U36) // Binary Counter + NET_C(U36.8, GND) + NET_C(U36.16, I_V5) + + TTL_74LS163_DIP(U37) // Binary Counter + NET_C(U37.8, GND) + NET_C(U37.16, I_V5) + + TTL_74LS377_DIP(U38) // Octal D Flip Flop + NET_C(U38.10, GND) + NET_C(U38.20, I_V5) + + TTL_74LS164_DIP(U39) // 8-bit Shift Reg. + NET_C(U39.7, GND) + NET_C(U39.14, I_V5) + + TTL_7406_DIP(U40) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(U40.7, GND) + NET_C(U40.14, I_V5) + + TTL_74LS393_DIP(U41) // Dual 4-Stage Binary Counter + NET_C(U41.7, GND) + NET_C(U41.14, I_V5) + + TTL_74LS393_DIP(U42) // Dual 4-Stage Binary Counter + NET_C(U42.7, GND) + NET_C(U42.14, I_V5) + + TTL_74LS163_DIP(U43) // Binary Counter + NET_C(U43.8, GND) + NET_C(U43.16, I_V5) + + TTL_74LS74_DIP(U44) // Dual D Flip Flop + NET_C(U44.7, GND) + NET_C(U44.14, I_V5) + + TTL_74LS74_DIP(U45) // Dual D Flip Flop + NET_C(U45.7, GND) + NET_C(U45.14, I_V5) + + TTL_74LS163_DIP(U46) // Binary Counter + NET_C(U46.8, GND) + NET_C(U46.16, I_V5) + + TTL_74LS377_DIP(U47) // Octal D Flip Flop + NET_C(U47.10, GND) + NET_C(U47.20, I_V5) + + TTL_74LS377_DIP(U48) // Octal D Flip Flop + NET_C(U48.10, GND) + NET_C(U48.20, I_V5) + + TTL_74LS164_DIP(U49) // 8-bit Shift Reg. + NET_C(U49.7, GND) + NET_C(U49.14, I_V5) + + TTL_7414_DIP(U50) // Hex Inverter + NET_C(U50.7, GND) + NET_C(U50.14, I_V5) + +#if (!HLE_CHIRPING_VCO) + LM566_DIP(U51) // 566 VCO +#endif + +#if (!HLE_DYING_BUG_VCO) + LM566_DIP(U52) // 566 VCO +#endif + +#if (!HLE_CRACKING_VCO) + LM566_DIP(U53) // 566 VCO +#endif + + TL081_DIP(U54) // Op. Amp. + NET_C(U54.7, I_V15) + NET_C(U54.4, I_VM15) + + TL081_DIP(U55) // Op. Amp. + NET_C(U55.7, I_V15) + NET_C(U55.4, I_VM15) + +#if (!HLE_BEETLE_VCO) + LM566_DIP(U56) // 566 VCO +#endif + +#if (!HLE_BOUNCE_VCO) + LM566_DIP(U57) // 566 VCO +#endif + + LM555_DIP(U58) + + CA3080_DIP(U59) // Op. Amp. + NET_C(U59.4, I_VM15) + NET_C(U59.7, I_V15) + +#if (!HLE_CANNON_VCO) + LM566_DIP(U60) // 566 VCO +#endif + + CA3080_DIP(U61) // Op. Amp. + NET_C(U61.4, I_VM15) + NET_C(U61.7, I_V15) + + AMI_S2688(U62) // Noise generator + + TL081_DIP(U63) // Op. Amp. + NET_C(U63.7, I_V15) + NET_C(U63.4, I_VM15) + + CA3080_DIP(U64) // Op. Amp. + NET_C(U64.4, I_VM15) + NET_C(U64.7, I_V15) + +// TL081_DIP(U65) // Op. Amp. -- part of shaft encoder (not emulated) +// NET_C(U65.7, I_V15) +// NET_C(U65.4, I_VM15) + +// TL081_DIP(U66) // Op. Amp. -- part of shaft encoder (not emulated) +// NET_C(U66.7, I_V15) +// NET_C(U66.4, I_VM15) + + CA3080_DIP(U67) // Op. Amp. + NET_C(U67.4, I_VM15) + NET_C(U67.7, I_V15) + +// TTL_7815_DIP(U68) // +15V Regulator -- part of voltage converter (not emulated) +// TTL_7915_DIP(U69) // -15V Regulator -- part of voltage converter (not emulated) + +// TL081_DIP(U70) // Op. Amp. -- part of final amp (not emulated) +// NET_C(U70.7, I_V15) +// NET_C(U70.4, I_VM15) + + // + // Page 1, top right + // + + ALIAS(HIB_P, U27.6) + NET_C(HIB_P, U27.5, U27.4, U27.1, U27.7) + NET_C(GND, U27.3) + ALIAS(BLOAD_M, U27.9) + ALIAS(BCLK_P, U27.2) + NET_C(U27.2, U26.1) + NET_C(U27.10, U28.15) + NET_C(U27.15, U24.12) + HINT(U27.11, NC) + HINT(U27.12, NC) + HINT(U27.13, NC) + HINT(U27.14, NC) + + NET_C(HIB_P, U28.6, U28.3, U28.1, U28.7, U28.10) + NET_C(GND, U28.4, U28.5) + NET_C(BLOAD_M, U28.9) + ALIAS(ACLK_M, U28.2) + HINT(U28.11, NC) + HINT(U28.12, NC) + HINT(U28.13, NC) + HINT(U28.14, NC) + + ALIAS(HIA_P, U24.10) + ALIAS(BCLK_M, U24.11) + NET_C(U24.13, R9.2) + NET_C(R9.1, I_V5) + NET_C(U24.9, U34.12) + NET_C(BLOAD_M, U24.8) + + NET_C(HIA_P, U34.1, U34.4, U34.13) + NET_C(U34.3, R21.1, C11.1) + ALIAS(_588USEC_P, U34.3) + NET_C(R21.2, I_V5) + HINT(U34.2, NC) + + NET_C(U26.2, GND) + NET_C(U26.6, U26.13) + HINT(U26.5, NC) + HINT(U26.4, NC) + HINT(U26.3, NC) + NET_C(U26.12, GND) + ALIAS(_327USEC_P, U26.8) + HINT(U26.9, NC) + HINT(U26.10, NC) + NET_C(U26.11, R15.1, C12.2) + NET_C(R15.2, I_V5) + NET_C(C12.1, R16.1) + NET_C(R16.2, R17.1, R18.2, U61.2) + NET_C(R17.2, C11.2) + NET_C(R18.1, GND) + + NET_C(U61.3, R19.2) + NET_C(R19.1, GND) + + ALIAS(BELL_EN_M, R10.1) + NET_C(R10.1, R11.1) + NET_C(R10.2, I_V5) + NET_C(R11.2, Q2.B) + NET_C(Q2.E, I_V2_2) + NET_C(Q2.C, R12.2, R13.2, Q3.E) + NET_C(R12.1, I_VM15) + NET_C(R13.1, GND) + NET_C(Q3.B, R14.2) + NET_C(R14.1, GND) + NET_C(Q3.C, C13.1, R20.1) + NET_C(C13.2, I_VM15) + NET_C(R20.2, U61.5) + ALIAS(CS, U61.6) + + // + // Page 1, bottom-right + // + +#if (HLE_SFX_CLOCK) + // + // A 20MHz crystal (Y1) is divided by 4 by a pair of + // JK flip flops (U23) to 5MHz. This is fed to a + // 74LS393 counter (U13) and the divide-by-16 output + // is divided again by a JK flip flop (U9) into a + // 156250Hz counter. Skip the work of dividing this + // manually and just create a clock directly. + // + CLOCK(SFXCLOCK, 156250) + NET_C(SFXCLOCK.GND, GND) + NET_C(SFXCLOCK.VCC, I_V5) + NET_C(SFXCLOCK.Q, U29.3, U2.5) + NET_C(U2.6, U29.11) + NET_C(GND, U13.12, U13.13) + NET_C(GND, U9.9, U9.10, U9.11) +#else + NET_C(U25.5, GND) // unused inverter borrowed + HINT(U2.6, NC) // for HLE SFX clock + + ALIAS(_5MHZ_M, U13.13) + NET_C(U13.12, GND) + NET_C(U13.8, U9.9) + HINT(U13.9, NC) + HINT(U13.10, NC) + HINT(U13.11, NC) + + NET_C(U9.8, U9.10, U9.11) + NET_C(U9.5, U29.3) + NET_C(U9.6, U29.11) +#endif + ALIAS(HID_P, U9.8) + + NET_C(U29.2, BCLK_M) + NET_C(HIB_P, U29.4, U29.1) + NET_C(U29.5, U29.12) + ALIAS(ACLK_P, U29.5) + NET_C(ACLK_M, U29.6) + + NET_C(HIB_P, U29.10, U29.13) + NET_C(BCLK_P, U29.9) + NET_C(BCLK_M, U29.8) + + // + // Page 2, top (noise generator) + // + + NET_C(_588USEC_P, U1.1) + NET_C(U1.2, GND) + NET_C(U1.6, U1.13) + HINT(U1.5, NC) + HINT(U1.4, NC) + HINT(U1.3, NC) + NET_C(U1.12, GND) + HINT(U1.8, NC) + HINT(U1.9, NC) + NET_C(U1.10, U11.8, U32.1) + HINT(U1.11, NC) + + NET_C(U11.9, U35.1) + NET_C(U11.1, U11.2, U12.8) + NET_C(U11.13, U12.1) + ALIAS(RANDOM_NOISE_P, U11.13) + HINT(U11.12, NC) + HINT(U11.11, NC) + HINT(U11.10, NC) + NET_C(U11.6, U12.2) + NET_C(U11.5, U12.5) + NET_C(U11.4, U12.4) + HINT(U11.3, NC) + + NET_C(U12.3, U12.13) + NET_C(U12.6, U12.12) + NET_C(U12.11, U32.2, U12.9) + NET_C(U12.10, HID_P) + ALIAS(IN_M, U12.8) + + NET_C(U32.6, U35.2, U35.3) + HINT(U32.5, NC) + HINT(U32.4, NC) + HINT(U32.3, NC) + ALIAS(ERRCLR_M, U35.1) + + // + // Page 2, middle (Chirping Birds) + // + + NET_C(RANDOM_NOISE_P, U31.5) + NET_C(U31.6, R22.1, R23.1) + NET_C(R22.2, I_V5, R24.2, Q4.E) + NET_C(R23.2, R24.1, Q4.B) + NET_C(Q4.C, R25.2, R26.2, R27.1) + NET_C(R25.1, I_VM15) + NET_C(R26.1, GND) + NET_C(R27.2, Q5.B) + NET_C(Q5.E, GND) + NET_C(Q5.C, R29.1) + NET_C(R29.2, R28.1, C14.1, R30.2, C15.2) + NET_C(R28.2, I_V15) + NET_C(C14.2, GND) + NET_C(R30.1, GND) + NET_C(C15.1, R31.1) + NET_C(R31.2, I_V15) + +#if (HLE_CHIRPING_VCO) + // + // Standard mapping: + // R2 = 0.91650: HP = (0.0000123028*A0) - 0.000136645 + // R2 = 0.98600: HP = (0.00000750231*A0*A0) - (0.000183288*A0) + 0.00113698 + // R2 = 0.99008: HP = (0.00000414207*A0*A0*A0) - (0.000154885*A0*A0) + (0.00193729*A0) - 0.0080873 + // R2 = 0.98800: HP = (0.00000603082*A0*A0*A0*A0) - (0.000311647*A0*A0*A0) + (0.00604258*A0*A0) - (0.0520898*A0) + 0.168437 + // R2 = 0.98586: HP = (0.000000081416*A0*A0*A0*A0*A0) - (0.00000284650*A0*A0*A0*A0) + (0.0000136226*A0*A0*A0) + (0.000571759*A0*A0) - (0.0083734*A0) + 0.0333905 + // + VARCLOCK(CHIRPCLK, 1, "max(0.000001,min(0.1,(0.000000081416*A0*A0*A0*A0*A0) - (0.00000284650*A0*A0*A0*A0) + (0.0000136226*A0*A0*A0) + (0.000571759*A0*A0) - (0.0083734*A0) + 0.0333905))") + NET_C(CHIRPCLK.GND, GND) + NET_C(CHIRPCLK.VCC, I_V5) + NET_C(CHIRPCLK.A0, C15.2) + NET_C(CHIRPCLK.Q, U41.1) + NET_C(GND, R32.1, R32.2, R33.1, R33.2, R205.1, R205.2, C16.1, C16.2, C17.1, C17.2, D13.A, D13.K, D14.A, D14.K) +#else + NET_C(R29.2, U51.5) + NET_C(C15.1, U51.6) + NET_C(R31.2, U51.8) + NET_C(U51.7, C16.1) + NET_C(C16.2, GND) + NET_C(U51.1, GND) + HINT(U51.4, NC) + NET_C(U51.3, C17.2) + NET_C(C17.1, D13.K, R32.1) + NET_C(D13.A, GND) + NET_C(R32.2, Q6.B) + NET_C(Q6.E, R205.2, D14.K) + NET_C(R205.1, I_VM15) + NET_C(D14.A, GND) + NET_C(Q6.C, R33.1, U41.1) + NET_C(R33.2, I_V5) +#endif + + NET_C(U41.2, RANDOM_NOISE_P) + HINT(U41.6, NC) + HINT(U41.5, NC) + HINT(U41.4, NC) + NET_C(U41.3, U41.13) + + ALIAS(CHIRPING_BIRDS_M, U41.12) + HINT(U41.8, NC) + HINT(U41.9, NC) + NET_C(U41.10, R47.1, R48.1) + HINT(U41.11, NC) + NET_C(R47.2, I_V5) + NET_C(R48.2, R49.2, C22.2) + NET_C(R49.1, GND) + ALIAS(SJ, C22.1) + + // + // Page 2, bottom (Dying Bug) + // + + ALIAS(BUG_DYING_M, U31.3) + NET_C(U31.4, R34.1, R35.1) + NET_C(R34.2, I_V5, R36.2, Q7.E) + NET_C(R35.2, R36.1, Q7.B) + NET_C(Q7.C, R37.2, R38.2, R39.1) + NET_C(R37.1, I_VM15) + NET_C(R38.1, GND) + NET_C(R39.2, Q8.B) + NET_C(Q8.E, GND) + NET_C(Q8.C, R41.1) + NET_C(R41.2, R40.1, C18.1, R42.2, C19.2) + NET_C(R40.2, I_V15) + NET_C(C18.2, GND) + NET_C(R42.1, GND) + NET_C(R43.2, I_V15) + NET_C(C19.1, R43.1) + +#if (HLE_DYING_BUG_VCO) + // + // Standard mapping: + // R2 = 0.94234: HP = (0.0000126953*A0) - 0.000142795 + // R2 = 0.99216: HP = (0.0000085544*A0*A0) - (0.000211995*A0) + 0.00132411 + // R2 = 0.99610: HP = (0.00000512381*A0*A0*A0) - (0.000194224*A0*A0) + (0.00245729*A0) - 0.0103626 + // R2 = 0.99646: HP = (0.00000347185*A0*A0*A0*A0) - (0.000178231*A0*A0*A0) + (0.00343236*A0*A0) - (0.0293814*A0) + 0.094321 + // R2 = 0.99644: HP = (0.000000064673*A0*A0*A0*A0*A0) - (0.00000153002*A0*A0*A0*A0) - (0.0000269128*A0*A0*A0) + (0.00118283*A0*A0) - (0.0128917*A0) + 0.0465240 + // + VARCLOCK(DYINGCLK, 1, "max(0.000001,min(0.1,(0.000000064673*A0*A0*A0*A0*A0) - (0.00000153002*A0*A0*A0*A0) - (0.0000269128*A0*A0*A0) + (0.00118283*A0*A0) - (0.0128917*A0) + 0.0465240))") + NET_C(DYINGCLK.GND, GND) + NET_C(DYINGCLK.VCC, I_V5) + NET_C(DYINGCLK.A0, C19.2) + NET_C(DYINGCLK.Q, U42.1) + NET_C(GND, R44.1, R44.2, R45.1, R45.2, R46.1, R46.2, C20.1, C20.2, C21.1, C21.2, D15.A, D15.K, D16.A, D16.K) +#else + NET_C(C19.2, U52.5) + NET_C(C19.1, U52.6) + NET_C(R43.2, U52.8) + NET_C(U52.7, C20.1) + NET_C(C20.2, GND) + NET_C(U52.1, GND) + HINT(U52.4, NC) + NET_C(U52.3, C21.2) + NET_C(C21.1, D15.K, R44.1) + NET_C(D15.A, GND) + NET_C(R44.2, Q9.B) + NET_C(Q9.E, R46.2, D16.K) + NET_C(R46.1, I_VM15) + NET_C(D16.A, GND) + NET_C(Q9.C, R45.1, U42.1) + NET_C(R45.2, I_V5) +#endif + + NET_C(_327USEC_P, U32.13) + NET_C(U32.12, GND) + ALIAS(_5232USEC_P, U32.8) + ALIAS(_2616USEC_P, U32.9) + NET_C(U32.9, U42.2) + HINT(U32.10, NC) + HINT(U32.11, NC) + + HINT(U42.6, NC) + HINT(U42.5, NC) + HINT(U42.4, NC) + NET_C(U42.3, U42.13) + NET_C(U42.12, BUG_DYING_M) + NET_C(U42.8, R51.1) + NET_C(U42.9, R52.1) + NET_C(U42.10, R53.1) + HINT(U42.11, NC) + NET_C(R54.2, R53.2, R52.2, R51.2, R50.1) + NET_C(R54.1, GND) + NET_C(R50.2, C23.2) + NET_C(C23.1, SJ) + + // + // Page 3, top (Egg Cracking) + // + + ALIAS(EGG_CRACKING_M, U31.13) + NET_C(U31.12, R55.1, R56.1) + NET_C(R55.2, I_V5, R57.2, Q10.E) + NET_C(R56.2, R57.1, Q10.B) + NET_C(Q10.C, R58.2, R59.2, R60.1) + NET_C(R58.1, I_VM15) + NET_C(R59.1, GND) + NET_C(Q11.E, GND) + NET_C(R60.2, Q11.B) + NET_C(Q11.C, R62.1) + NET_C(R62.2, R61.1, C24.1, R63.2, C25.2) + NET_C(C24.2, GND) + NET_C(R63.1, GND) + NET_C(R61.2, R64.2, I_V15) + NET_C(C25.1, R64.1) + +#if (HLE_CRACKING_VCO) + // + // Standard mapping: + // R2 = 0.89585: HP = (0.0000175988*A0) - 0.000207278 + // R2 = 0.98810: HP = (0.0000104596*A0*A0) - (0.000261248*A0) + 0.00164623 + // R2 = 0.99788: HP = (0.00000629669*A0*A0*A0) - (0.000240194*A0*A0) + (0.00305980*A0) - 0.0129994 + // R2 = 0.99873: HP = (0.00000350292*A0*A0*A0*A0) - (0.000179267*A0*A0*A0) + (0.00344234*A0*A0) - (0.0293869*A0) + 0.094097 + // R2 = 0.99653: HP = (0.000000075716*A0*A0*A0*A0*A0) - (0.00000154725*A0*A0*A0*A0) - (0.0000446414*A0*A0*A0) + (0.00164941*A0*A0) - (0.0174578*A0) + 0.0623765 + // + VARCLOCK(CRACKINGCLK, 1, "max(0.000001,min(0.1,(0.000000064673*A0*A0*A0*A0*A0) - (0.00000153002*A0*A0*A0*A0) - (0.0000269128*A0*A0*A0) + (0.00118283*A0*A0) - (0.0128917*A0) + 0.0465240))") + NET_C(CRACKINGCLK.GND, GND) + NET_C(CRACKINGCLK.VCC, I_V5) + NET_C(CRACKINGCLK.A0, C25.2) + NET_C(CRACKINGCLK.Q, U22.13) + NET_C(GND, R65.1, R65.2, R66.1, R66.2, R67.1, R67.2, C26.1, C26.2, C27.1, C27.2, D17.A, D17.K, D18.A, D18.K) +#else + NET_C(R61.2, U53.8) + NET_C(C25.1, U53.6) + NET_C(R62.2, U53.5) + NET_C(U53.7, C26.1) + NET_C(C26.2, GND) + NET_C(U53.1, GND) + HINT(U53.4, NC) + NET_C(U53.3, C27.2) + NET_C(C27.1, D17.K, R65.1) + NET_C(D17.A, GND) + NET_C(R65.2, Q12.B) + NET_C(Q12.E, R67.2, D18.K) + NET_C(R67.1, I_VM15) + NET_C(D18.A, GND) + NET_C(Q12.C, R66.1, U22.13) + NET_C(R66.2, I_V5) +#endif + + NET_C(EGG_CRACKING_M, U22.12) + NET_C(U22.8, R68.1) + NET_C(U22.9, R69.1) + NET_C(U22.10, R70.1) + HINT(U22.11, NC) + NET_C(R68.2, R69.2, R70.2, R71.2, R72.1) + NET_C(R71.1, GND) + NET_C(R72.2, C28.2) + NET_C(C28.1, SJ) + + // + // Page 3, middle (Beetle on screen) + // + + ALIAS(BEETLE_ON_SCREEN_M, U31.1) + NET_C(U31.2, U19.4) + NET_C(U19.8, R73.2, I_V5) + NET_C(R73.1, U19.7, R74.2) + NET_C(R74.1, U19.6, U19.2, C29.1) + NET_C(C29.2, GND) + NET_C(U19.1, GND) + NET_C(U19.5, C30.1) + NET_C(C30.2, GND) + NET_C(U19.3, R75.2, U20.1) + NET_C(R75.1, GND) + + NET_C(U20.2, R77.1, R76.1) + NET_C(R76.2, I_V5, R78.2, Q13.E) + NET_C(R77.2, R78.1, Q13.B) + NET_C(Q13.C, R79.2, R80.2, R81.1) + NET_C(R79.1, I_VM15) + NET_C(R80.1, GND) + NET_C(R81.2, Q14.B) + NET_C(Q14.E, GND) + NET_C(Q14.C, R83.1) + NET_C(R83.2, R82.1, C31.1, R84.2, C32.2) + NET_C(C31.2, GND) + NET_C(R84.1, GND) + NET_C(R82.2, I_V15, R85.2) + NET_C(R85.1, C32.1) + +#if (HLE_BEETLE_VCO) + // + // Standard mapping: + // R2 = 0.92906: HP = (0.000127227*A0) - 0.00149583 + // R2 = 0.97372: HP = (0.000086592*A0*A0) - (0.00218553*A0) + 0.0139420 + // R2 = 0.97589: HP = (0.000063925*A0*A0*A0) - (0.00248748*A0*A0) + (0.0323532*A0) - 0.140489 + // R2 = 0.97153: HP = (-0.00000615887*A0*A0*A0*A0) + (0.000395273*A0*A0*A0) - (0.0091707*A0*A0) + (0.092250*A0) - 0.341743 + // R2 = 0.96812: HP = (0.00000145563*A0*A0*A0*A0*A0) - (0.0000505655*A0*A0*A0*A0) + (0.000151855*A0*A0*A0) + (0.0134189*A0*A0) - (0.189302*A0) + 0.763397 + // + VARCLOCK(BEETLECLK, 1, "max(0.000001,min(0.1,(0.00000145563*A0*A0*A0*A0*A0) - (0.0000505655*A0*A0*A0*A0) + (0.000151855*A0*A0*A0) + (0.0134189*A0*A0) - (0.189302*A0) + 0.763397))") + NET_C(BEETLECLK.GND, GND) + NET_C(BEETLECLK.VCC, I_V5) + NET_C(BEETLECLK.A0, C32.2) + NET_C(BEETLECLK.Q, U22.1) + NET_C(GND, R86.1, R86.2, R87.1, R87.2, R88.1, R88.2, C33.1, C33.2, C34.1, C34.2, D19.A, D19.K, D20.A, D20.K) +#else + NET_C(R83.2, U56.5) + NET_C(R82.2, U56.8) + NET_C(R85.1, U56.6) + NET_C(U56.7, C33.1) + NET_C(C33.2, GND) + NET_C(U56.1, GND) + HINT(U56.4, NC) + NET_C(U56.3, C34.2) + NET_C(C34.1, D19.K, R86.1) + NET_C(D19.A, GND) + NET_C(R86.2, Q15.B) + NET_C(Q15.E, R88.2, D20.K) + NET_C(R88.1, I_VM15) + NET_C(D20.A, GND) + NET_C(Q15.C, R87.1, U22.1) + NET_C(R87.2, I_V5) +#endif + + NET_C(BEETLE_ON_SCREEN_M, U22.2) + HINT(U22.6, NC) + HINT(U22.5, NC) + NET_C(U22.4, R89.1) + HINT(U22.3, NC) + NET_C(R89.2, R90.2, R91.1) + NET_C(R90.1, GND) + NET_C(R91.2, C35.2) + NET_C(C35.1, SJ) + + // + // Page 3, bottom (BOUNCE) + // + + ALIAS(BOUNCE_EN_P, R93.1) + NET_C(R93.1, R92.1) + NET_C(R92.2, R94.2, I_V5, Q16.E) + NET_C(R93.2, R94.1, Q16.B) + NET_C(Q16.C, R95.2, R96.2, R97.1) + NET_C(R95.1, I_VM15) + NET_C(R96.1, GND) + NET_C(R97.2, Q17.B) + NET_C(Q17.E, GND) + NET_C(Q17.C, R99.1) + NET_C(R99.2, R98.1, C36.1, R101.2, C39.2, R102.2) + NET_C(R98.2, I_V15) + NET_C(C36.2, GND) + NET_C(R101.1, GND) + + NET_C(_5232USEC_P, R100.1, U58.6, U58.2) + NET_C(R100.2, I_V5) + NET_C(U58.7, GND) // not connected + NET_C(U58.4, U58.8, I_V5) + NET_C(U58.1, GND) + NET_C(U58.5, C38.1) + NET_C(C38.2, GND) + NET_C(U58.3, C37.2) + NET_C(C37.1, R102.1) + + NET_C(C39.1, R108.1) + NET_C(R108.2, I_V15) +#if (HLE_BOUNCE_VCO) + // + // Unlike all the other VCOs, this one doesn't go directly into a + // TTL device. The actual square wave is tapered from the top and + // slightly modulated with the frequency, but it makes little + // practical difference, so we just scale the output square wave + // to +/-5V as input to R109. + // + // Standard mapping: + // R2 = 0.89933: HP = (0.00476268*A0) - 0.0576442 + // R2 = 0.97773: HP = (0.00311005*A0*A0) - (0.079281*A0) + 0.509096 + // R2 = 0.97985: HP = (0.00115078*A0*A0*A0) - (0.0435380*A0*A0) + (0.550407*A0) - 2.321385 + // R2 = 0.97985: HP = (0.0000369937*A0*A0*A0*A0) - (0.000849582*A0*A0*A0) - (0.00300315*A0*A0) + (0.185593*A0) - 1.090973 + // R2 = 0.24613: HP = (-0.000199982*A0*A0*A0*A0*A0) + (0.0134882*A0*A0*A0*A0) - (0.362557*A0*A0*A0) + (4.857498*A0*A0) - (32.45284*A0) + 86.5278 + // + VARCLOCK(BOUNCECLK, 1, "max(0.000001,min(0.1,((0.00115078*A0*A0*A0) - (0.0435380*A0*A0) + (0.550407*A0) - 2.321385))") + NET_C(BOUNCECLK.GND, GND) + NET_C(BOUNCECLK.VCC, I_V5) + NET_C(BOUNCECLK.A0, C39.2) + NET_C(BOUNCECLK.Q, BOUNCEENV.A0) + AFUNC(BOUNCEENV, 1, "if(A0>2.5,5,-5)") + NET_C(BOUNCEENV, R109.1) + NET_C(GND, C40.1, C40.2) + NET_C(GND, C42.1, C42.2) +#else + NET_C(C39.1, U57.6) + NET_C(R108.2, U57.8) + NET_C(R99.2, U57.5) + NET_C(C39.1, U57.6, R108.1) + NET_C(R108.2, I_V15, U57.8) + NET_C(U57.7, C40.1) + NET_C(C40.2, GND) + NET_C(U57.1, GND) + HINT(U57.4, NC) + NET_C(U57.3, C42.2) + NET_C(C42.1, R109.1) +#endif + + NET_C(R109.2, R111.2, U59.2) + NET_C(R111.1, GND) + NET_C(U59.3, R112.2) + NET_C(R112.1, GND) + + ALIAS(BOUNCE_EN_M, R104.1) + NET_C(R104.1, R103.1) + NET_C(R103.2, I_V5) + NET_C(R104.2, Q18.B) + NET_C(Q18.E, I_V2_2) + NET_C(Q18.C, R105.2, R106.2, Q19.E) + NET_C(R105.1, I_VM15) + NET_C(R106.1, GND) + NET_C(Q19.B, R107.2) + NET_C(R107.1, GND) + NET_C(Q19.C, C41.1, R110.1) + NET_C(C41.2, I_VM15) + NET_C(R110.2, U59.5) + NET_C(U59.6, CS) + + // + // Page 4, top (Cannon) + // + + ALIAS(CANNON_M, R114.1) + NET_C(R114.1, R113.1) + NET_C(R113.2, I_V5) + NET_C(R114.2, Q20.B) + NET_C(Q20.E, I_V2_2) + NET_C(Q20.C, R115.2, R116.2, R117.1) + NET_C(R115.1, I_VM15) + NET_C(R116.1, GND) + NET_C(R117.2, Q21.B) + NET_C(Q21.E, GND) + NET_C(Q21.C, R119.1) + NET_C(R119.2, R118.1, C43.1, R120.2, C44.2) + NET_C(R118.2, I_V15, R121.2) + NET_C(C43.2, GND) + NET_C(R120.1, GND) + NET_C(C44.1, R121.1) + +#if (HLE_CANNON_VCO) + // + // Standard mapping: + // R2 = 0.96910: HP = (0.000125667*A0) - 0.00142938 + // R2 = 0.99026: HP = (0.000076462*A0*A0) - (0.00189006*A0) + 0.0117720 + // R2 = 0.99181: HP = (0.0000429163*A0*A0*A0) - (0.00161661*A0*A0) + (0.0203246*A0) - 0.085173 + // R2 = 0.99203: HP = (0.0000167801*A0*A0*A0*A0) - (0.000839548*A0*A0*A0) + (0.0157634*A0*A0) - (0.131604*A0) + 0.412204 + // R2 = 0.99209: HP = (0.00000283657*A0*A0*A0*A0*A0) - (0.000141443*A0*A0*A0*A0) + (0.00257240*A0*A0*A0) - (0.0192167*A0*A0) + (0.0334224*A0) + 0.148265 + // + VARCLOCK(CANNONCLK, 1, "max(0.000001,min(0.1,(0.00000283657*A0*A0*A0*A0*A0) - (0.000141443*A0*A0*A0*A0) + (0.00257240*A0*A0*A0) - (0.0192167*A0*A0) + (0.0334224*A0) + 0.148265))") + NET_C(CANNONCLK.GND, GND) + NET_C(CANNONCLK.VCC, I_V5) + NET_C(CANNONCLK.A0, C44.2) + NET_C(CANNONCLK.Q, U13.1) + NET_C(GND, R122.1, R122.2, R123.1, R123.2, R124.1, R124.2, C75.1, C75.2, C45.1, C45.2, D21.A, D21.K, D22.A, D22.K) +#else + NET_C(R119.2, U60.5) + NET_C(R118.2, U60.8) + NET_C(C44.1, U60.6) + NET_C(U60.7, C75.1) + NET_C(C75.2, GND) + NET_C(U60.1, GND) + HINT(U60.4, NC) + NET_C(U60.3, C45.2) + NET_C(C45.1, D21.K, R122.1) + NET_C(D21.A, GND) + NET_C(R122.2, Q22.B) + NET_C(Q22.E, R124.2, D22.K) + NET_C(R124.1, I_VM15) + NET_C(D22.A, GND) + NET_C(Q22.C, R123.1, U13.1) + NET_C(R123.2, I_V5) +#endif + + NET_C(CANNON_M, U13.2) + HINT(U13.6, NC) + HINT(U13.5, NC) + NET_C(U13.4, R125.1) + HINT(U13.3, NC) + NET_C(R125.2, R126.1, R127.2) + NET_C(R126.2, GND) + NET_C(R127.1, C46.2) + NET_C(C46.1, SJ) + + // + // Page 4, bottom-left (explosions) + // + + NET_C(U62.2, GND) + NET_C(U62.1, GND) + NET_C(U62.4, R128.1, C47.1, C74.1) + NET_C(R128.2, I_V15) + NET_C(C47.2, GND) + NET_C(C74.2, GND) + NET_C(U62.3, C48.2) + NET_C(C48.1, R129.2, U63.3) + NET_C(R129.1, GND) + NET_C(U63.2, U63.6, R130.1) + NET_C(R130.2, C49.1, R131.1) + NET_C(C49.2, GND) + NET_C(R131.2, C50.1, R132.1) + NET_C(C50.2, GND) + NET_C(R132.2, R133.2, U64.2) + NET_C(R133.1, GND) + NET_C(U64.3, R134.2) + NET_C(R134.1, GND) + NET_C(U64.6, CS) + + ALIAS(LOUD_EXPL_M, R136.1) + NET_C(R136.1, R135.1) + NET_C(R135.2, I_V5, R137.2, Q23.E) + NET_C(R136.2, R137.1, Q23.B) + NET_C(Q23.C, R138.2, R139.2, Q24.E) + NET_C(R138.1, I_VM15) + NET_C(R139.1, GND) + NET_C(Q24.B, R140.2) + NET_C(R140.1, GND) + NET_C(Q24.C, C51.1, R141.1) + NET_C(C51.2, I_VM15) + NET_C(R141.2, R148.2, U64.5) + + ALIAS(SOFT_EXPL_M, R143.1) + NET_C(R143.1, R142.1) + NET_C(R142.2, I_V5, R144.2, Q25.E) + NET_C(R143.2, R144.1, Q25.B) + NET_C(Q25.C, R145.2, R146.2, Q26.E) + NET_C(R145.1, I_VM15) + NET_C(R146.1, GND) + NET_C(Q26.B, R147.2) + NET_C(R147.1, GND) + NET_C(Q26.C, C52.1, R148.1) + NET_C(C52.2, I_VM15) + + // + // Page 4, bottom-right (bug pushing and final mix) + // + + ALIAS(BUG_PUSHING_A_P, U31.9) + NET_C(U31.8, U21.2) + NET_C(_588USEC_P, U21.1) + HINT(U21.6, NC) + NET_C(U21.5, R149.1) + HINT(U21.4, NC) + HINT(U21.3, NC) + NET_C(R149.2, C53.1) + + ALIAS(BUG_PUSHING_B_P, U31.11) + NET_C(U31.10, U21.12) + NET_C(_588USEC_P, U21.13) + NET_C(U21.8, R150.1) + HINT(U21.9, NC) + HINT(U21.10, NC) + HINT(U21.11, NC) + NET_C(R150.2, C54.2) + + NET_C(C53.2, C54.1, SJ, U54.2, R160.2, R161.1, C61.1) + NET_C(C61.2, R161.2) + ALIAS(OUTPUT, R161.2) + NET_C(R161.2, U54.6) + NET_C(U54.3, GND) + NET_C(CS, U55.3, R159.2) + NET_C(R159.1, GND) + NET_C(U55.2, U55.6, C60.2) + NET_C(C60.1, R160.1) + + // + // Page 5, shaft encoder -- not emulated + // + + // + // Page 6, top left + // + + NET_C(I_V5, R206.1, R207.1, R208.1, R209.1) + NET_C(R206.2, HIA_P) + NET_C(R207.2, HIB_P) + ALIAS(HIC_P, R208.2) + NET_C(R209.2, HID_P) + + NET_C(I_OUT_7, D25.K, U50.9) + NET_C(D25.A, GND) + NET_C(U50.8, U50.1) + NET_C(U50.2, U49.1) + ALIAS(DATA_P, U50.2) + +#if (HACK_SIMPLIFY_INPUTS) + // + // Several of the inputs go through several rounds of inverters + // diodes and pullups, and eventually something goes wrong. + // Bypassing these extra devices helps make the inputs reliable. + // + NET_C(I_OUT_4, U30.13) + NET_C(GND, D26.A, D26.K, U50.13, U50.12, U40.9, R177.1, R177.2, C67.1, C67.2) +#else + NET_C(I_OUT_4, D26.K, U50.13) + NET_C(D26.A, GND) + NET_C(U50.12, U40.9) + NET_C(U40.8, C67.2, R177.1, U30.13) + NET_C(C67.1, GND) + NET_C(R177.2, I_V5) +#endif + NET_C(U30.12, U30.1) + NET_C(U30.2, U49.8, U39.8) + + NET_C(U49.2, U49.9, U39.2, U39.9, HIA_P) + NET_C(U49.3, U48.3, U47.3) + NET_C(U49.4, U48.4, U47.4) + NET_C(U49.5, U48.7, U47.7) + NET_C(U49.6, U48.8, U47.8) + NET_C(U49.10, U48.13, U47.13) + NET_C(U49.11, U48.14, U47.14) + NET_C(U49.12, U48.17, U47.17) + NET_C(U49.13, U48.18, U47.18, U39.1) + + NET_C(U39.3, U38.3) + NET_C(U39.4, U38.4) + NET_C(U39.5, U38.7) + NET_C(U39.6, U38.8) + NET_C(U39.10, U38.13) + NET_C(U39.11, U38.14) + NET_C(U39.12, U38.17) + NET_C(U39.13, U38.18) + + ALIAS(MEN_P, U48.2) + NET_C(CANNON_M, U48.5) + ALIAS(AS1_M, U48.6) + ALIAS(AS0_M, U48.9) + ALIAS(FS11_P, U48.12) + ALIAS(FS10_P, U48.15) + ALIAS(FS09_P, U48.16) + ALIAS(FS08_P, U48.19) + NET_C(U48.1, GND) + ALIAS(MLATCH_P, U48.11) + + ALIAS(FS07_P, U38.2) + ALIAS(FS06_P, U38.5) + ALIAS(FS05_P, U38.6) + ALIAS(FS04_P, U38.9) + ALIAS(FS03_P, U38.12) + ALIAS(FS02_P, U38.15) + ALIAS(FS01_P, U38.16) + ALIAS(FS00_P, U38.19) + NET_C(U38.1, GND) + NET_C(MLATCH_P, U38.11) + + NET_C(SOFT_EXPL_M, U47.2) + NET_C(LOUD_EXPL_M, U47.5) + NET_C(CHIRPING_BIRDS_M, U47.6) + NET_C(EGG_CRACKING_M, U47.9) + NET_C(BUG_PUSHING_A_P, U47.12) + NET_C(BUG_PUSHING_B_P, U47.15) + NET_C(BUG_DYING_M, U47.16) + NET_C(BEETLE_ON_SCREEN_M, U47.19) + NET_C(U47.11, U30.6) + NET_C(U47.1, GND) + + // + // Page 6, middle-left + // + +#if (HLE_MUSIC_CLOCK) + // + // The 20MHz clock (Y1) is divided by 4 via a pair + // of JK flip-flops (U23) to 5MHz. That signal is + // used to clock a 74LS163 counter (U43) that divides + // the clock by 9 via a preset value. It then goes + // through another JK flip-flop (U33) for another + // divide by 2, ending up at 277778Hz. No sense in + // running all this manually. + // + CLOCK(MUSICCLK, 277778) + NET_C(MUSICCLK.VCC, I_V5) + NET_C(MUSICCLK.GND, GND) + ALIAS(_227KC_P, MUSICCLK.Q) + NET_C(MUSICCLK.Q, U2.13) + ALIAS(_227KC_M, U2.12) + NET_C(GND, R178.1, R178.2, R179.1, R179.2, R204.1, R204.2, C68.1, C68.2) + NET_C(GND, U2.1, U2.3) + NET_C(GND, U23.1, U23.2, U23.3, U23.4, U23.10, U23.11, U23.12, U23.13) +#else + // + // This is just here for documentation; the crystal is + // not modelled for this circuit. + // + NET_C(U2.3, R178.1, C68.1) + NET_C(R178.2, U2.4, Y1.1) + NET_C(Y1.2, R179.1, U2.1) + NET_C(R179.2, U2.2, U2.13, C68.2) + NET_C(U2.12, U23.1) + NET_C(HIC_P, U23.3, U23.2, U23.4, U23.11, U23.12, U23.10) + NET_C(U23.5, U23.13) + HINT(U23.6, NC) + ALIAS(_5MHZ_P, U23.9) + NET_C(_5MHZ_M, U23.8) +#endif + + // + // Page 6, bottom-left + // + +#if (HACK_SIMPLIFY_INPUTS) + NET_C(I_OUT_1, U30.9) + NET_C(GND, D27.A, D27.K, U50.3, U50.4, U40.13, R180.1, R180.2, C69.1, C69.2) +#else + NET_C(I_OUT_1, U50.3, D27.K) + NET_C(D27.A, GND) + NET_C(U50.4, U40.13) + NET_C(U40.12, R180.1, C69.2, U30.9) + NET_C(R180.2, I_V5) + NET_C(C69.1, GND) +#endif + NET_C(U30.8, U30.5) + ALIAS(SLATCH_P, U30.6) + +#if (HACK_SIMPLIFY_INPUTS) + NET_C(I_OUT_0, U30.11) + NET_C(GND, D28.A, D28.K, U50.11, U50.10, U40.11, R181.1, R181.2, C70.1, C70.2) +#else + NET_C(I_OUT_0, U50.11, D28.K) + NET_C(D28.A, GND) + NET_C(U50.10, U40.11) + NET_C(U40.10, R181.1, C70.2, U30.11) + NET_C(R181.2, I_V5) + NET_C(C70.1, GND) +#endif + NET_C(U30.10, U30.3) + ALIAS(LATCH_CLK_P, U30.4) + + NET_C(I_OUT_2, U50.5, BOUNCE_EN_M, D29.K) + NET_C(D29.A, GND) + NET_C(U50.6, BOUNCE_EN_P) + + NET_C(I_OUT_3, D30.K, BELL_EN_M) + NET_C(D30.A, GND) + + // + // Page 6, bottom-middle + // + +#if (HLE_MUSIC_CLOCK) + NET_C(_227KC_P, U44.3) + NET_C(_227KC_M, U44.11) + NET_C(GND, U24.1, U24.2, U24.3, U24.4) + NET_C(GND, U33.1, U33.4, U33.12) + NET_C(GND, U43.1, U43.2, U43.3, U43.4, U43.5, U43.6, U43.7, U43.9, U43.10) + NET_C(HIC_P, U33.13) +#else + NET_C(HIC_P, U43.5, U43.3, U43.1, U43.10, U43.7) + NET_C(GND, U43.6, U43.4) + NET_C(_5MHZ_P, U43.2) + NET_C(U43.9, U33.12, U24.6) + HINT(U43.11, NC) + HINT(U43.12, NC) + HINT(U43.13, NC) + HINT(U43.14, NC) + NET_C(U43.15, U24.2) + + NET_C(U24.4, HIC_P) + HINT(U24.5, NC) + NET_C(U24.3, _5MHZ_M) + NET_C(U24.1, R204.2) + NET_C(R204.1, I_V5) + + NET_C(HIC_P, U33.1, U33.4, U33.13) + NET_C(U33.3, U44.3) + ALIAS(_227KC_P, U33.3) + NET_C(U33.2, U44.11) + ALIAS(_227KC_M, U33.2) +#endif + + NET_C(HIA_P, U44.4, U44.1, U44.10, U44.13) + ALIAS(MACLK_M, U44.2) + NET_C(U44.5, U44.12) + ALIAS(MBCLK_P, U44.5) + ALIAS(MBCLK_M, U44.6) + ALIAS(MACLK_P, U44.9) + NET_C(MACLK_M, U44.8, U25.11) + + ALIAS(MCARRY_P, U25.12) + NET_C(U25.13, R182.2) + NET_C(R182.1, I_V5) + ALIAS(MLOAD_M, U25.8) + NET_C(U25.9, U35.8, U34.9) + ALIAS(MLOAD_P, U25.9) + NET_C(HIA_P, U25.10) + + NET_C(HIA_P, U34.8, U34.11, U34.10) + ALIAS(DMUSIC_P, U34.5) + HINT(U34.6, NC) + + NET_C(HIA_P, U25.2, U25.4) + NET_C(LATCH_CLK_P, U25.3) + NET_C(U25.1, U45.6) + HINT(U25.5, NC) + NET_C(U25.6, U35.9, U15.12) + + NET_C(MBCLK_M, U15.13) + HINT(U15.8, NC) + NET_C(U15.9, U35.11, U35.12) + HINT(U15.10, NC) + HINT(U15.11, NC) + + NET_C(U35.13, U45.10) + NET_C(U35.10, U45.12) + NET_C(MBCLK_P, U45.11) + NET_C(HIA_P, U45.13) + HINT(U45.8, NC) + NET_C(U45.9, MLATCH_P, U45.2) + NET_C(HIA_P, U45.4) + HINT(U45.5, NC) + NET_C(U45.1, R203.2) + NET_C(R203.1, I_V5) + NET_C(MACLK_P, U45.3) + + // + // Page 6, right (music generator) + // + + NET_C(FS11_P, U46.6) + NET_C(FS10_P, U46.5) + NET_C(FS09_P, U46.4) + NET_C(FS08_P, U46.3) + NET_C(HIA_P, U46.1) + NET_C(MEN_P, U46.7) + NET_C(MLOAD_M, U46.9) + NET_C(MBCLK_P, U46.2) + NET_C(U46.15, MCARRY_P) + NET_C(U46.10, U36.15) + HINT(U46.11, NC) + HINT(U46.12, NC) + HINT(U46.13, NC) + HINT(U46.14, NC) + + NET_C(FS07_P, U36.6) + NET_C(FS06_P, U36.5) + NET_C(FS05_P, U36.4) + NET_C(FS04_P, U36.3) + NET_C(HIA_P, U36.1) + NET_C(MEN_P, U36.7) + NET_C(MLOAD_M, U36.9) // schems say MLOAD_P, but solarq says MLOAD_M + NET_C(MACLK_P, U36.2) + NET_C(U36.10, U37.15) + HINT(U36.11, NC) + HINT(U36.12, NC) + HINT(U36.13, NC) + HINT(U36.14, NC) + + NET_C(FS03_P, U37.6) + NET_C(FS02_P, U37.5) + NET_C(FS01_P, U37.4) + NET_C(FS00_P, U37.3) + NET_C(HIA_P, U37.1) + NET_C(MEN_P, U37.7, U37.10) + NET_C(MLOAD_M, U37.9) + NET_C(MBCLK_M, U37.2) + HINT(U37.11, NC) + HINT(U37.12, NC) + HINT(U37.13, NC) + HINT(U37.14, NC) + + NET_C(DMUSIC_P, R183.1, R184.1) + NET_C(R183.2, I_V5) + NET_C(R184.2, C71.1) + NET_C(C71.2, R185.1, U67.2) + NET_C(R185.2, R186.1, GND) + NET_C(R186.2, U67.3) + NET_C(U67.6, CS) + + NET_C(AS1_M, R187.1, R188.1) + NET_C(R187.2, I_V5, R189.2, Q31.E) + NET_C(R188.2, R189.1, Q31.B) + NET_C(Q31.C, R190.2, R191.1, Q32.E) + NET_C(R190.1, I_VM15) + NET_C(R191.2, R192.1, GND) + NET_C(R192.2, Q32.B) + NET_C(Q32.C, R193.1) + NET_C(R193.2, C72.2, R194.1) + NET_C(C72.1, I_VM15) + NET_C(R194.2, U67.5, R202.2) + + NET_C(AS0_M, R195.1, R196.1) + NET_C(R195.2, I_V5, R197.2, Q33.E) + NET_C(R196.2, R197.1, Q33.B) + NET_C(Q33.C, R198.2, R199.1, Q34.E) + NET_C(R198.1, I_VM15) + NET_C(R199.2, R200.1, GND) + NET_C(R200.2, Q34.B) + NET_C(Q34.C, R201.1) + NET_C(R201.2, C73.2, R202.1) + NET_C(C73.1, I_VM15) + + // + // Unconnected inputs + // + + NET_C(U2.9, U2.11, U9.1, U9.4, U9.12, U9.13, U15.1, U15.2, U20.4, U20.6, U20.8, U20.10, U20.12, U33.8, U33.9, U33.10, U33.11, U35.5, U35.6, U40.1, U40.3, U40.5) + + // + // Unconnected outputs + // + + HINT(U2.8, NC) + HINT(U2.10, NC) + HINT(U40.2, NC) + HINT(U40.4, NC) + HINT(U40.6, NC) + +// HINT(U2.9, NC) +// HINT(U2.11, NC) +// HINT(U24.4, NC) + +#if (ENABLE_FRONTIERS) + // + // Isolate the CS sounds from the rest of the mixer + // + OPTIMIZE_FRONTIER(U55.3, RES_M(1), 50) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_boxingb.h b/src/mame/audio/nl_boxingb.h new file mode 100644 index 00000000000..11d2648d3c3 --- /dev/null +++ b/src/mame/audio/nl_boxingb.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_BOXINGB_H +#define MAME_AUDIO_NL_BOXINGB_H + +#pragma once + +NETLIST_EXTERNAL(boxingb) + +#endif // MAME_AUDIO_NL_BOXINGB_H diff --git a/src/mame/audio/nl_cinemat_common.h b/src/mame/audio/nl_cinemat_common.h new file mode 100644 index 00000000000..9e2a14499da --- /dev/null +++ b/src/mame/audio/nl_cinemat_common.h @@ -0,0 +1,382 @@ +// license:CC0 +// copyright-holders:Aaron Giles,Couriersud +#ifndef MAME_AUDIO_NL_CINEMAT_COMMON_H +#define MAME_AUDIO_NL_CINEMAT_COMMON_H + + +// +// Misc common devices used by Cinematronics games. +// +// Eventually these should be included in the core. +// +// Known problems/issues: +// +// * There are 5 different models of the CA3080 presented here. +// More analysis on the pros/cons of each should be done. +// +// * The TL182 analog switch is cobbled together from a pair of +// CD4066 gates and a pair of inverters on the inputs. This +// seems to work but perhaps should be properly added as a +// system model. +// +// * The 2N6426 Darlington transistors are not properly emulated. +// Currently they are modeled as a pair of 2N3904s. A pspice +// model ported into the netlist schema creates a very poor +// balance with the background noise in Space Wars/Barrier. +// + +#include "netlist/devices/net_lib.h" + + +// +// Direct mappings +// + +// AMI S2688 is compatible with MM5837 +#define AMI_S2688 MM5837_DIP + +// LM555/566 is compatible with NE555/566 +#define LM555_DIP NE555_DIP +#define LM566_DIP NE566_DIP + +// alias LS devices to real devices +#define TTL_74LS00_DIP TTL_7400_DIP +#define TTL_74LS02_DIP TTL_7402_DIP // Quad 2-input Nor Gate +#define TTL_74S04_DIP TTL_7404_DIP // Hex Inverting Gates +#define TTL_74LS04_DIP TTL_7404_DIP // Hex Inverting Gates +#define TTL_74LS08_DIP TTL_7408_DIP // Quad 2-Input AND Gates +#define TTL_74LS21_DIP TTL_7421_DIP // Dual 4-Input AND Gates +#define TTL_74LS74_DIP TTL_7474_DIP // Dual D Flip Flop +#define TTL_74LS75_DIP TTL_7475_DIP // 4-Bit Bistable Latches with Complementary Outputs +#define TTL_74LS86_DIP TTL_7486_DIP // Quad 2-Input Exclusive-OR Gates +#define TTL_74LS107_DIP TTL_74107_DIP +#define TTL_74S113_DIP TTL_74113_DIP +#define TTL_74S113A_DIP TTL_74113A_DIP +#define TTL_74LS123_DIP TTL_74123_DIP +#define TTL_74LS125_DIP TTL_74125_DIP +#define TTL_74LS157_DIP TTL_74157_DIP +#define TTL_74LS163_DIP TTL_74163_DIP +#define TTL_74LS164_DIP TTL_74164_DIP +#define TTL_74LS191_DIP TTL_74191_DIP +#define TTL_74LS259_DIP TTL_9334_DIP // Seems to be pin-compatible +#define TTL_74LS377_DIP TTL_74377_DIP +#define TTL_74LS393_DIP TTL_74393_DIP + + + +// +// Diode models +// + +// models copied from https://www.diodes.com/assets/Spice-Models/Discrete-Prodcut-Groups/Zener-Diodes.txt +#define D_1N914(name) DIODE(name, "1N914") +#define D_1N914B(name) DIODE(name, "1N914") +#define D_1N5236B(name) DIODE(name, "D(BV=7.5 IS=27.5p RS=33.8 N=1.10 CJO=58.2p VJ=0.750 M=0.330 TT=50.1n)") +#define D_1N5240(name) ZDIODE(name, "D(BV=10 IS=14.4p RS=32.0 N=1.10 CJO=24.1p VJ=0.750 M=0.330 TT=50.1n)") +#define D_1N5240B(name) ZDIODE(name, "D(BV=10 IS=14.4p RS=32.0 N=1.10 CJO=24.1p VJ=0.750 M=0.330 TT=50.1n)") + + + +// +// Op-amp models +// + +// SPICE model taken directly from Fairchild Semiconductor datasheet +#define Q_2N3904(name) QBJT_EB(name, "NPN(Is=6.734f Xti=3 Eg=1.11 Vaf=74.03 Bf=416.4 Ne=1.259 Ise=6.734 Ikf=66.78m Xtb=1.5 Br=.7371 Nc=2 Isc=0 Ikr=0 Rc=1 Cjc=3.638p Mjc=.3085 Vjc=.75 Fc=.5 Cje=4.493p Mje=.2593 Vje=.75 Tr=239.5n f=301.2p Itf=.4 Vtf=4 Xtf=2 Rb=10)") + +// SPICE model taken directly from Fairchild Semiconductor datasheet +#define Q_2N3906(name) QBJT_EB(name, "PNP(Is=1.41f Xti=3 Eg=1.11 Vaf=18.7 Bf=180.7 Ne=1.5 Ise=0 Ikf=80m Xtb=1.5 Br=4.977 Nc=2 Isc=0 Ikr=0 Rc=2.5 Cjc=9.728p Mjc=.5776 Vjc=.75 Fc=.5 Cje=8.063p Mje=.3677 Vje=.75 Tr=33.42n Tf=179.3p Itf=.4 Vtf=4 Xtf=6 Rb=10)") + +// SPICE model taken from https://www.onsemi.com/support/design-resources/models?rpn=2N6107 +#define Q_2N6107(name) QBJT_EB(name, "PNP(IS=7.62308e-14 BF=6692.56 NF=0.85 VAF=10 IKF=0.032192 ISE=2.07832e-13 NE=2.41828 BR=15.6629 NR=1.5 VAR=1.44572 IKR=0.32192 ISC=4.75e-16 NC=3.9375 RB=7.19824 IRB=0.1 RBM=0.1 RE=0.0001 RC=0.355458 XTB=0.1 XTI=2.97595 EG=1.206 CJE=1.84157e-10 VJE=0.99 MJE=0.347177 TF=6.63757e-09 XTF=1.50003 VTF=1.0001 ITF=1 CJC=1.06717e-10 VJC=0.942679 MJC=0.245405 XCJC=0.8 FC=0.533334 CJS=0 VJS=0.75 MJS=0.5 TR=1.32755e-07 PTF=0 KF=0 AF=1)") + +// SPICE model taken from https://www.onsemi.com/support/design-resources/models?rpn=2N6292 +#define Q_2N6292(name) QBJT_EB(name, "NPN(IS=9.3092e-13 BF=2021.8 NF=0.85 VAF=63.2399 IKF=1 ISE=1.92869e-13 NE=1.97024 BR=40.0703 NR=1.5 VAR=0.89955 IKR=10 ISC=4.92338e-16 NC=3.9992 RB=6.98677 IRB=0.1 RBM=0.1 RE=0.0001 RC=0.326141 XTB=0.1 XTI=2.86739 EG=1.206 CJE=1.84157e-10 VJE=0.99 MJE=0.347174 TF=6.73756e-09 XTF=1.49917 VTF=0.997395 ITF=0.998426 CJC=1.06717e-10 VJC=0.942694 MJC=0.245406 XCJC=0.8 FC=0.533405 CJS=0 VJS=0.75 MJS=0.5 TR=6.0671e-08 PTF=0 KF=0 AF=1)") + +// SPICE model taken from http://ltwiki.org/files/LTspiceIV/Vendor%20List/Fairchild/2N/index.html +#define Q_2N5210(name) QBJT_EB(name, "NPN(Is=5.911f Xti=3 Eg=1.11 Vaf=62.37 Bf=809.9 Ne=1.358 Ise=5.911f Ikf=14.26m Xtb=1.5 Br=1.287 Nc=2 Isc=0 Ikr=0 Rc=1.61 Cjc=4.017p Mjc=.3174 Vjc=.75 Fc=.5 Cje=4.973p Mje=.4146 Vje=.75 Tr=4.68n Tf=820.9p Itf=.35 Vtf=4 Xtf=7 Rb=10)") + + + +// +// 556 is just two 555s in one package +// + +#define NE556_DIP(name) SUBMODEL(_NE556_DIP, name) +#define LM556_DIP NE556_DIP + +static NETLIST_START(_NE556_DIP) + NE555(A) + NE555(B) + + NET_C(A.GND, B.GND) + NET_C(A.VCC, B.VCC) + + DIPPINS( /* +--------------+ */ + A.DISCH, /* 1DISCH |1 ++ 14| VCC */ A.VCC, + A.THRESH, /* 1THRES |2 13| 2DISCH */ B.DISCH, + A.CONT, /* 1CONT |3 12| 2THRES */ B.THRESH, + A.RESET, /* 1RESET |4 NE556 11| 2CONT */ B.CONT, + A.OUT, /* 1OUT |5 10| 2RESET */ B.RESET, + A.TRIG, /* 1TRIG |6 9| 2OUT */ B.OUT, + A.GND, /* GND |7 8| 2TRIG */ B.TRIG + /* +--------------+ */ + ) +NETLIST_END() + + + +// +// TL182 analog switch +// + +#define TL182_DIP(name) SUBMODEL(_TL182_DIP, name) + +static NETLIST_START(_TL182_DIP) + CD4066_GATE(A) + CD4066_GATE(B) + + NET_C(A.VDD, B.VDD) + NET_C(A.VSS, B.VSS) + + PARAM(A.BASER, 270.0) + PARAM(B.BASER, 270.0) + + RES(VR, 100) + NC_PIN(NC) + + TTL_7406_GATE(AINV) + TTL_7406_GATE(BINV) + NET_C(AINV.VCC, BINV.VCC, A.VDD) + NET_C(AINV.GND, BINV.GND, A.VSS) + NET_C(AINV.Y, A.CTL) + NET_C(BINV.Y, B.CTL) + + DIPPINS( /* +--------------+ */ + A.R.1, /* 1S |1 ++ 14| 2S */ B.R.1, + A.R.2, /* 1D |2 13| 2D */ B.R.2, + NC.I, /* NC |3 12| NC */ NC.I, + NC.I, /* NC |4 TL182 11| NC */ NC.I, + AINV.A, /* 1A |5 10| 2A */ BINV.A, + VR.1, /* VCC |6 9| VEE */ VR.2, + A.VDD, /* VLL |7 8| VREF */ A.VSS + /* +--------------+ */ + ) +NETLIST_END() + + + +// +// 2N6426, Darlington transistor +// + +#define Q_2N6426(name) SUBMODEL(_Q_2N6426, name) + +#if 0 + +// +// This model causes the background noise level to domainate all other sounds in spacewar? +// + +// Model dervied from https://www.onsemi.com/support/design-resources/models?rpn=2N6284 +static NETLIST_START(_Q_2N6426) + + QBJT_EB(Q1, "NPN(IS=1.73583e-11 BF=831.056 NF=1.05532 VAF=957.147 IKF=0.101183 ISE=1.65383e-10 NE=1.59909 BR=2.763 NR=1.03428 VAR=4.18534 IKR=0.0674174 ISC=1.00007e-13 NC=2.00765 RB=22.2759 IRB=0.208089 RBM=22.2759 RE=0.0002 RC=0.001 XTB=2.12676 XTI=1.82449 EG=1.05 CJE=2.62709e-10 VJE=0.95 MJE=0.23 TF=1e-09 XTF=1 VTF=10 ITF=0.01 CJC=3.59851e-10 VJC=0.845279 MJC=0.23 XCJC=0.9 FC=0.5 TR=1e-07 PTF=0 KF=0 AF=1)") + + QBJT_EB(Q2, "NPN(IS=1.73583e-11 BF=831.056 NF=1.05532 VAF=957.147 IKF=0.101183 ISE=1.65383e-10 NE=1.59909 BR=2.763 NR=1.03428 VAR=4.18534 IKR=0.0674174 ISC=1.00007e-13 NC=2.00765 RB=22.2759 IRB=0.208089 RBM=22.2759 RE=0.0002 RC=0.001 XTB=2.12676 XTI=1.82449 EG=1.05 CJE=2.62709e-10 VJE=0.95 MJE=0.23 TF=1e-09 XTF=1 VTF=10 ITF=0.01 CJC=0 VJC=0.845279 MJC=0.23 XCJC=0.9 FC=0.5 TR=1e-07 PTF=0 KF=0 AF=1)") // NPN + + DIODE(D1, "D(IS=1e-12 RS=10.8089 N=1.00809 XTI=3.00809 CJO=0 VJ=0.75 M=0.33 FC=0.5)") + RES(R1, RES_K(8)) + RES(R2, 50) + + ALIAS(B, Q1.B) + ALIAS(C, Q1.C) + ALIAS(E, Q2.E) + NET_C(Q1.C, Q2.C, D1.K) + NET_C(Q1.B, R1.1) + NET_C(Q2.E, D1.A, R2.2) + NET_C(Q1.E, Q2.B, R1.2, R2.1) +NETLIST_END() + +#else + +// super brain-dead model I threw together from a pair of 2N3904 +static NETLIST_START(_Q_2N6426) + QBJT_EB(Q1, "NPN") + QBJT_EB(Q2, "NPN") + + ALIAS(B, Q1.B) + ALIAS(C, Q1.C) + ALIAS(E, Q2.E) + NET_C(Q1.C, Q2.C) + NET_C(Q1.E, Q2.B) +NETLIST_END() + +#endif + + + +// +// LM3900, quad op-amp +// + +#define LM3900_DIP(name) SUBMODEL(_LM3900_DIP, name) + +static NETLIST_START(_LM3900_DIP) + LM3900(A) + LM3900(B) + LM3900(C) + LM3900(D) + + NET_C(A.VCC, B.VCC, C.VCC, D.VCC) + NET_C(A.GND, B.GND, C.GND, D.GND) + + DIPPINS( /* +--------------+ */ + A.PLUS, /* 1IN+ |1 ++ 14| VCC */ A.VCC, + B.PLUS, /* 2IN+ |2 13| 3IN+ */ C.PLUS, + B.MINUS, /* 2IN- |3 12| 4IN+ */ D.PLUS, + B.OUT, /* 2OUT |4 LM3900 11| 4IN- */ D.MINUS, + A.OUT, /* 1OUT |5 10| 4OUT */ D.OUT, + A.MINUS, /* 1IN- |6 9| 3OUT */ C.OUT, + A.GND, /* GND |7 8| 3IN- */ C.MINUS + /* +--------------+ */ + ) +NETLIST_END() + + + +// ************************************************* +// EQUIVALENT SUBSTITUTE FOR CA3080 IS NTE996 +// (SAME 8-PIN DIP PINOUT) +// ************************************************* +// +// CA3080 OPERATIONAL TRANSCONDUCTANCE AMPLIFIER +// +// SPICE (SIMULATION PROGRAM WITH INTEGRATED CIRCUIT EMPHASIS) +// SUBCIRCUIT +// +// CONNECTIONS: +// INVERTING INPUT +// | NON-INVERTING INPUT +// | | NEGATIVE POWER SUPPLY +// | | | I BIAS +// | | | | OUTPUT +// | | | | | POSITIVE POWER SUPPLY +// | | | | | | +//.SUBCKT CA3080 2 3 4 5 6 7 + +// +// DIP mappings use the submodels below for CA3080 +// +#define CA3080_FAST_DIP(name) SUBMODEL(_CA3080_FAST_DIP, name) +#define CA3080_SLOW_DIP(name) SUBMODEL(_CA3080_SLOW_DIP, name) + + +// +// Default to the fast model unless otherwise directed +// +#ifndef CA3080_DIP +#define CA3080_DIP CA3080_FAST_DIP +#endif + + +// +// Fast model: works well for most cases in Cinematronics games, +// except when used in a network with multiple CA3080's, due to +// the presence of an AFUNC. +// +static NETLIST_START(_CA3080_FAST_DIP) + ALIAS(2, F.A0) // - + ALIAS(3, F.A1) // + + ALIAS(4, F.A2) // V- + ALIAS(5, RIABC.1) // IB + ALIAS(6, VO.OP) // FIXME + ALIAS(7, F.A4) // V+ + + RES(RI, 26000) + NET_C(RI.1, F.A0) + NET_C(RI.2, F.A1) + // Delivers I0 + AFUNC(F, 5, "max(-0.5e-3, min(0.5e-3, 19.2 * (A3 - A2) * A0))") + RES(RIABC, 1) + NET_C(RIABC.2, F.A2) + NET_C(RIABC.1, F.A3) // IB + VCCS(VO, 1) + ANALOG_INPUT(XGND, 0) + NET_C(XGND, VO.IN, VO.ON) // FIXME: assume symmetric supply + NET_C(F.Q, VO.IP) +NETLIST_END() + + +// +// Slow model: derived from +// https://github.com/xxv/gedasymbols/blob/master/www/user/john_doty/models/opamp/ca3080.mod +// +// This seems to produce reasonable results as a slow drop-in +// replacement for the fast model above in solarq, but is quite +// slow. One advantage is that it works in a network with multiple +// CA3080's. +// +static NETLIST_START(_CA3080_SLOW_DIP) +// +// These items are common to several models +// +#define CA3080_D(name) DIODE(name, "D(IS=2p RS=5 BV=40 CJO=3p TT=6n)") +#define CA3080_NPN(name) QBJT_EB(name, "NPN(IS=21.48f XTI=3 EG=1.11 VAF=80 BF=550 ISE=50f NE=1.5 IKF=10m XTB=1.5 BR=.1 ISC=10f NC=2 IKR=3m RC=10 CJC=800f MJC=.3333 VJC=.75 FC=.5 CJE=1.3p MJE=.3333 VJE=.75 TR=30n TF=400P ITF=30m XTF=1 VTF=10 CJS=5.8P MJS=.3333 VJS=.75)") +#define CA3080_PNP(name) QBJT_EB(name, "PNP(IS=50f XTI=3 EG=1.11 VAF=80 BF=100 ISE=130f NE=1.5 IKF=1m XTB=1.5 BR=1 ISC=0 NC=2 IKR=0 RC=0 CJC=4p MJC=.3333 VJC=.75 FC=.5 CJE=1.4p MJE=.3333 VJE=.75 TR=500n TF=23n ITF=.1 XTF=1 VTF=10 CJS=5.5P MJS=.3333 VJS=.75)") + + CA3080_D(D1) + CA3080_D(D2) + CA3080_NPN(Q1) + CA3080_PNP(Q2) + CA3080_PNP(Q3) + CA3080_NPN(Q4) + CA3080_NPN(Q5) + CA3080_PNP(Q6) + CA3080_PNP(Q7) + CA3080_PNP(Q8) + CA3080_PNP(Q9) + CA3080_NPN(Q10) + CA3080_NPN(Q11) + CA3080_NPN(Q12) + CA3080_NPN(Q13) + CA3080_PNP(Q14) + CA3080_PNP(Q15) + + ALIAS(2, Q10.B) // N1 + ALIAS(3, Q5.B) // N28 + ALIAS(4, Q1.E) // N13 + ALIAS(5, Q1.B) // N11 + ALIAS(6, Q6.C) // N30 + ALIAS(7, Q8.E) // N8 + NET_C(Q8.E, Q9.E, Q14.E, Q15.E) // N8 + NET_C(Q1.B, Q1.C, Q4.B) // N11 + NET_C(Q1.E, Q4.E, Q11.E, Q12.E) // N13 + NET_C(Q6.C, Q7.C, Q13.C) // N30 + NET_C(Q3.B, Q10.C, Q14.C, D1.A) // N1N13 + NET_C(Q2.E, Q14.B, Q15.C, Q15.B) // N1N15 + NET_C(Q2.B, Q3.E, D1.K) // N1N17 + NET_C(Q2.C, Q3.C, Q11.C, Q13.B) // N1N22 + NET_C(Q5.C, Q6.B, Q9.C, D2.A) // N1N32 + NET_C(Q6.E, Q7.B, D2.K) // N1N34 + NET_C(Q7.E, Q8.C, Q8.B, Q9.B) // N1N36 + NET_C(Q4.C, Q5.E, Q10.E) // N1N52 + NET_C(Q11.B, Q12.C, Q12.B, Q13.E) // N1N44 +NETLIST_END() + + + +// +// List of local models to include to make MAME happy +// + +#define CINEMAT_LOCAL_MODELS \ + LOCAL_SOURCE(_NE556_DIP) \ + LOCAL_SOURCE(_TL182_DIP) \ + LOCAL_SOURCE(_Q_2N6426) \ + LOCAL_SOURCE(_LM3900_DIP) \ + LOCAL_SOURCE(_CA3080_FAST_DIP) \ + LOCAL_SOURCE(_CA3080_SLOW_DIP) \ + + +#endif // MAME_AUDIO_NL_CINEMAT_COMMON_H diff --git a/src/mame/audio/nl_ripoff.cpp b/src/mame/audio/nl_ripoff.cpp new file mode 100644 index 00000000000..c0097d8e6b8 --- /dev/null +++ b/src/mame/audio/nl_ripoff.cpp @@ -0,0 +1,701 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Rip Off +// +// Derived from the schematics in the Rip Off manual. +// +// Known problems/issues: +// +// * Voltage triggers for Motor 1 and Beep need a hack to +// work (reducing resistance on one resistor from 4.7K to 100) +// Need to understand why. +// +// * Motor 1 and beep sounds dominate the output. They are +// controlled by the current driven into the CCAs IC12 and +// IC6. Not sure if this overdrive is related to the problem +// with the switch above, but for now a hack is enabled to +// multiply the resistance by 5x going into the CCA, which +// seems to restore the balance to something reasonable. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_ripoff.h" + + +// +// Optimizations +// + +#define HLE_LASER_VCO (1) +#define HLE_TORPEDO_VCO (1) +#define HLE_BACKGROUND_VCOS (1) +#define ENABLE_FRONTIERS (1) + + +// +// Hacks +// + +#define HACK_VOLTAGE_SWITCH (1) +#define HACK_CCA_RESISTANCE (1) + + +// +// Main netlist +// + +NETLIST_START(ripoff) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + TTL_INPUT(I_OUT_7, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(47)) + RES(R2, RES_K(47)) + RES(R3, RES_K(330)) + RES(R4, RES_K(10)) + RES(R5, RES_K(2.7)) + RES(R6, RES_K(2.7)) + RES(R7, RES_K(1)) + RES(R8, RES_K(470)) + RES(R9, 330) + RES(R10, RES_K(20)) +#if (HACK_VOLTAGE_SWITCH) + RES(R11, 100) +#else + RES(R11, RES_K(4.7)) +#endif + RES(R12, 300) + RES(R13, RES_K(4.7)) + RES(R14, RES_K(8.2)) + RES(R15, RES_K(15)) + RES(R16, RES_K(2.7)) + RES(R17, RES_K(2.7)) +#if (HACK_CCA_RESISTANCE) + RES(R18, RES_K(4100)) +#else + RES(R18, RES_K(820)) +#endif + RES(R19, RES_K(27)) + RES(R20, RES_K(39)) + RES(R21, RES_K(10)) + RES(R22, 330) + RES(R23, 160) + RES(R24, RES_K(1)) + RES(R25, RES_K(1)) + RES(R26, RES_K(1)) + RES(R27, RES_K(2)) + RES(R28, RES_K(2)) + RES(R29, RES_K(4.7)) + RES(R30, RES_K(3.3)) + RES(R31, RES_K(68)) + RES(R32, RES_K(30)) + RES(R33, RES_K(15)) + RES(R34, RES_K(2.7)) + RES(R35, RES_K(2.7)) +#if (HACK_CCA_RESISTANCE) + RES(R36, RES_M(5)) +#else + RES(R36, RES_M(1)) +#endif + RES(R37, RES_K(56)) + RES(R38, RES_K(24)) + RES(R39, RES_K(15)) +#if (HACK_VOLTAGE_SWITCH) + RES(R40, 100) +#else + RES(R40, RES_K(4.7)) +#endif + RES(R41, 300) + RES(R42, RES_K(39)) + RES(R43, RES_K(10)) + RES(R44, 330) + RES(R45, RES_K(27)) +// RES(R46, RES_K(12)) -- part of final amp (not emulated) + RES(R47, RES_K(1)) + RES(R48, RES_K(2.7)) + RES(R49, 470) +// POT(R50, RES_K()) -- listed as optional on schematics +// RES(R51, RES_K(1.5)) -- part of final amp (not emulated) +// RES(R52, 150) -- part of final amp (not emulated) +// RES(R53, RES_K(22)) -- part of final amp (not emulated) +// RES(R54, 150) -- part of final amp (not emulated) +// RES(R55, RES_K(39)) -- part of final amp (not emulated) + RES(R56, 150) + RES(R57, RES_K(2.7)) + RES(R58, RES_M(1)) + RES(R59, RES_K(20)) + RES(R60, RES_K(10)) + RES(R61, RES_K(1)) + RES(R62, RES_K(10)) + RES(R63, RES_K(20)) + RES(R64, RES_K(39)) + RES(R65, RES_K(82)) + RES(R66, RES_K(2.7)) + RES(R67, RES_K(3.9)) + RES(R68, RES_M(1)) + RES(R69, RES_K(20)) + RES(R70, RES_K(10)) + RES(R71, RES_K(1)) + RES(R72, RES_K(10)) + RES(R73, RES_K(20)) + RES(R74, RES_K(39)) + RES(R75, RES_K(82)) + RES(R76, 470) + RES(R77, RES_M(1.5)) + RES(R78, RES_K(20)) + RES(R79, RES_M(1)) + RES(R80, RES_K(43)) + RES(R81, RES_K(20)) + RES(R82, RES_M(1)) + RES(R83, RES_K(20)) + RES(R84, RES_K(10)) + RES(R85, RES_K(1)) + RES(R86, RES_K(10)) + RES(R87, RES_K(20)) + RES(R88, RES_K(39)) + RES(R89, RES_K(82)) + RES(R90, RES_K(1)) + RES(R91, RES_K(2.7)) + + CAP(C1, CAP_U(100)) + CAP(C2, CAP_U(0.1)) + CAP(C3, CAP_U(0.1)) + CAP(C4, CAP_U(0.02)) + CAP(C5, CAP_U(0.1)) + CAP(C6, CAP_U(0.68)) + CAP(C7, CAP_U(0.01)) + CAP(C8, CAP_U(4.7)) + CAP(C9, CAP_U(0.047)) + CAP(C10, CAP_U(0.01)) + CAP(C11, CAP_U(0.1)) + CAP(C12, CAP_U(0.1)) +// CAP(C13, CAP_U()) -- not used according to schematics + CAP(C14, CAP_U(0.22)) + CAP(C15, CAP_U(0.01)) + CAP(C16, CAP_U(0.1)) + CAP(C17, CAP_U(0.1)) + CAP(C18, CAP_U(0.01)) + CAP(C19, CAP_U(0.1)) +// CAP(C20, CAP_U()) -- not used according to schematics + CAP(C21, CAP_U(0.68)) +// CAP(C22, CAP_U(0.005)) -- part of final amp (not emulated) +// CAP(C23, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C24, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C25, CAP_P(470)) -- part of final amp (not emulated) + CAP(C26, CAP_U(0.1)) + CAP(C27, CAP_U(0.1)) + CAP(C28, CAP_U(0.01)) + CAP(C29, CAP_U(0.047)) + CAP(C30, CAP_U(0.22)) + CAP(C31, CAP_U(0.1)) + CAP(C32, CAP_U(0.68)) +// CAP(C33, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C34, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C35, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C36, CAP_U()) -- part of voltage converter (not emulated) +// CAP(C37, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C38, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C39, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C40, CAP_U()) -- part of voltage converter (not emulated) +// CAP(C41, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C42, CAP_U(0.1)) -- part of voltage converter (not emulated) + + D_1N5240(D1) + D_1N914(D2) + D_1N914(D3) + D_1N914(D4) + D_1N914(D5) + D_1N914(D6) + D_1N914(D7) + D_1N914(D8) + D_1N914(D9) + D_1N914(D10) + D_1N914(D11) + D_1N5240(D12) + D_1N5240(D13) + + Q_2N3906(Q1) // PNP + Q_2N3906(Q2) // PNP + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3906(Q5) // PNP +// Q_2N6292(Q6) // PNP -- part of final amp (not emulated) +// Q_2N6107(Q7) // PNP -- part of final amp (not emulated) + Q_2N3904(Q8) // NPN + Q_2N3904(Q9) // NPN + Q_2N3904(Q10) // NPN + + AMI_S2688(IC1) // Noise generator + + TL081_DIP(IC2) // Op. Amp. + NET_C(IC2.7, I_V15) + NET_C(IC2.4, I_VM15) + + CA3080_DIP(IC3) // Op. Amp. + NET_C(IC3.4, I_VM15) + NET_C(IC3.7, I_V15) + + LM555_DIP(IC4) + + LM555_DIP(IC5) + + CA3080_DIP(IC6) // Op. Amp. + NET_C(IC6.4, I_VM15) + NET_C(IC6.7, I_V15) + + TL081_DIP(IC7) // Op. Amp. + NET_C(IC7.7, I_V15) + NET_C(IC7.4, I_VM15) + + TTL_74LS164_DIP(IC8) // 8-bit Shift Reg. + NET_C(IC8.7, GND) + NET_C(IC8.14, I_V5) + + TTL_74LS377_DIP(IC9) // Octal D Flip Flop + NET_C(IC9.10, GND) + NET_C(IC9.20, I_V5) + + TTL_7406_DIP(IC10) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(IC10.7, GND) + NET_C(IC10.14, I_V5) + + LM555_DIP(IC11) + + CA3080_DIP(IC12) // Op. Amp. + NET_C(IC12.4, I_VM15) + NET_C(IC12.7, I_V15) + + LM555_DIP(IC13) + + TL081_DIP(IC14) // Op. Amp. + NET_C(IC14.7, I_V15) + NET_C(IC14.4, I_VM15) + + TL081_DIP(IC15) // Op. Amp. + NET_C(IC15.7, I_V15) + NET_C(IC15.4, I_VM15) + + TL081_DIP(IC16) // Op. Amp. + NET_C(IC16.7, I_V15) + NET_C(IC16.4, I_VM15) + + TL081_DIP(IC17) // Op. Amp. + NET_C(IC17.7, I_V15) + NET_C(IC17.4, I_VM15) + + TTL_74LS393_DIP(IC18) // Dual 4 Bit B.C. + NET_C(IC18.7, GND) + NET_C(IC18.14, I_V5) + + TL081_DIP(IC19) // Op. Amp. + NET_C(IC19.7, I_V15) + NET_C(IC19.4, I_VM15) + + TL081_DIP(IC20) // Op. Amp. + NET_C(IC20.7, I_V15) + NET_C(IC20.4, I_VM15) + + TL081_DIP(IC21) // Op. Amp. + NET_C(IC21.7, I_V15) + NET_C(IC21.4, I_VM15) + + TTL_74LS393_DIP(IC22) // Dual 4 Bit B.C. + NET_C(IC22.7, GND) + NET_C(IC22.14, I_V5) + +// TTL_7915_DIP(IC23) // -15V Regulator -- not emulated +// TTL_7815_DIP(IC24) // +15V Regulator -- not emulated + + TTL_7414_DIP(IC25) // Hex Inverter + NET_C(IC25.7, GND) + NET_C(IC25.14, I_V5) + + // + // Explosion + // + + NET_C(I_OUT_7, R7.1, IC4.2) + NET_C(IC4.8, IC4.4, I_V5) // pin 4 not documented in schematics + NET_C(R7.2, I_V5) + NET_C(R8.2, I_V5) + NET_C(R8.1, IC4.6, IC4.7, C6.1) + NET_C(C6.2, GND) + NET_C(IC4.5, C7.2) + NET_C(C7.1, GND) + NET_C(IC4.1, GND) + NET_C(IC4.3, Q1.E) + NET_C(Q1.B, R9.2) + NET_C(R9.1, GND) + NET_C(Q1.C, C8.1, R10.1) + NET_C(C8.2, I_VM15) + NET_C(R10.2, IC3.5) + + NET_C(C1.1, IC1.4, I_V15) + NET_C(C1.2, GND) + NET_C(IC1.1, IC1.2, GND) + NET_C(IC1.3, R1.1) + NET_C(R1.2, C2.2, R2.1) + NET_C(C2.1, GND) + NET_C(R2.2, C3.1) + NET_C(C3.2, IC2.2, C4.1, R3.1) + NET_C(IC2.3, GND) + NET_C(IC2.6, C4.2, R3.2, R4.1) + NET_C(R4.2, C5.1) + NET_C(C5.2, R5.2, IC3.2) + NET_C(R5.1, GND) + NET_C(IC3.3, R6.2) + NET_C(R6.1, GND) + NET_C(IC3.6, IC7.3, R19.2) + NET_C(R19.1, GND) + + // + // Shift register + // + + NET_C(I_OUT_0, IC25.1) + NET_C(IC25.2, IC25.13) + NET_C(IC25.12, IC8.2) + NET_C(I_OUT_1, IC25.3) + NET_C(IC25.4, IC25.11) + NET_C(IC25.10, IC8.8) + NET_C(R24.1, I_V5) + NET_C(R24.2, IC8.9, IC8.1) + NET_C(I_OUT_2, IC25.5) + NET_C(IC25.6, IC25.9) + NET_C(IC25.8, IC9.11) + NET_C(IC9.1, GND) + NET_C(IC8.3, IC9.3) + NET_C(IC8.4, IC9.4) + NET_C(IC8.5, IC9.7) + NET_C(IC8.6, IC9.8) + NET_C(IC8.10, IC9.13) + NET_C(IC8.11, IC9.14) + + // + // Background + // + + NET_C(IC9.9, IC22.2) + NET_C(IC9.2, IC10.1) + NET_C(IC10.2, R25.2, R26.1) + NET_C(IC9.5, IC10.3) + NET_C(IC10.4, R27.2, R28.1) + NET_C(IC9.6, IC10.5) + NET_C(IC10.6, R29.2, R30.1) + NET_C(R29.1, R27.1, R25.1, D1.K, R23.1) // also R50.2 if present + NET_C(R23.2, I_V15) + NET_C(D1.A, GND) + NET_C(R26.2, R28.2, R30.2, R76.1, IC19.2) // also R50.1 if present + NET_C(IC19.3, GND) + NET_C(IC19.6, R76.2, D8.A, D6.A) + +#if (HLE_BACKGROUND_VCOS) + // + // The two background VCOs are done with diodes and op-amps, + // but end up generating a quite linear voltage-to-period + // mapping. There is a low-frequency VCO and a high-frequency + // one. They are combined and sent to an LS393 counter as a + // clock after going through a voltage converter. Here we + // skip the whole lot. + // + // First VCO, vs IC19.6: + // R2 = 0.99406: HP = (-0.0235033*A0) + 0.0179360 + // R2 = 0.99415: HP = (0.000193041*A0*A0) - (0.0227932*A0) + 0.0182436 + // R2 = 0.99418: HP = (-0.000106682*A0*A0*A0) - (0.000443621*A0*A0) - (0.0237264*A0) + 0.0180362 + // R2 = 0.99419: HP = (0.000069781*A0*A0*A0*A0) + (0.000470159*A0*A0*A0) + (0.00104384*A0*A0) - (0.0224827*A0) + 0.0182202 + // R2 = 0.99419: HP = (-0.0000242172*A0*A0*A0*A0*A0) - (0.000186286*A0*A0*A0*A0) - (0.000483269*A0*A0*A0) - (0.000431519*A0*A0) - (0.0233265*A0) + 0.0181209 + // + // Second VCO, vs IC19.6: + // R2 = 0.99969: HP = (-0.000308955*A0) + 0.000256399 + // R2 = 0.99986: HP = (0.00000356099*A0*A0) - (0.000295774*A0) + 0.000262224 + // R2 = 0.99986: HP = (-0.000000646439*A0*A0*A0) - (0.000000309249*A0*A0) - (0.000301475*A0) + 0.000260938 + // R2 = 0.99986: HP = (0.0000000315553*A0*A0*A0*A0) - (0.000000385224*A0*A0*A0) + (0.000000365474*A0*A0) - (0.000300909*A0) + 0.000261022 + // R2 = 0.99986: HP = (-0.0000000265364*A0*A0*A0*A0*A0) - (0.000000249089*A0*A0*A0*A0) - (0.00000143038*A0*A0*A0) - (0.00000125235*A0*A0) - (0.000301835*A0) + 0.000260913 + // + VARCLOCK(BGCLK1, 1, "max(0.000001,min(0.1,(-0.0235033*A0) + 0.0179360))") + NET_C(BGCLK1.GND, GND) + NET_C(BGCLK1.VCC, I_V15) + NET_C(BGCLK1.A0, IC19.6) + NET_C(BGCLK1.Q, BGCOMBINE.A0) + NET_C(GND, R77.1, R77.2, R78.1, R78.2, R79.1, R79.2, C30.1, C30.2, D6.K, D7.A, D7.K, IC20.2, IC20.3) + + VARCLOCK(BGCLK2, 1, "max(0.000001,min(0.1,(-0.000308955*A0) + 0.000256399))") + NET_C(BGCLK2.GND, GND) + NET_C(BGCLK2.VCC, I_V15) + NET_C(BGCLK2.A0, IC19.6) + NET_C(BGCLK2.Q, BGCOMBINE.A1) + NET_C(GND, R80.1, R80.2, R81.1, R81.2, R82.1, R82.2, C31.1, C31.2, D8.K, D9.A, D9.K, IC21.2, IC21.3) + + AFUNC(BGCOMBINE, 2, "max(A0,A1)") + NET_C(BGCOMBINE.Q, IC22.1) + NET_C(GND, R83.1, R83.2, R84.1, R84.2, R85.1, R85.2, D10.A, D10.K, D11.A, D11.K) +#else + NET_C(D6.K, D7.A, R79.1, IC20.3) + NET_C(D7.K, GND) + NET_C(IC20.2, C30.2, R77.1) + NET_C(C30.1, GND) + NET_C(IC20.6, R77.2, D10.A, R78.1, R79.2) + NET_C(D10.K, R78.2, R83.1, R81.2, D11.K) + NET_C(D11.A, R82.2, IC21.6, R80.2, R81.1) + NET_C(IC21.3, R82.1, D9.A, D8.K) + NET_C(D9.K, GND) + NET_C(IC21.2, C31.2, R80.1) + NET_C(C31.1, GND) + NET_C(R83.2, R84.2, Q10.B) + NET_C(R84.1, GND) + NET_C(Q10.E, GND) + NET_C(Q10.C, R85.1, IC22.1) + NET_C(R85.2, I_V5) +#endif + NET_C(IC22.3, R86.1) + NET_C(IC22.4, R87.1) + NET_C(IC22.5, R88.1) + NET_C(IC22.6, R89.1) + NET_C(R86.2, R87.2, R88.2, R89.2, R90.2, R91.1) + NET_C(R90.1, GND) + NET_C(R91.2, C32.1) + NET_C(C32.2, R49.1) + NET_C(R49.2, R45.1) + + // + // Beep + // + + NET_C(IC9.12, Q2.B, R11.1) + NET_C(R11.2, R12.2, I_V5) + NET_C(Q2.E, R12.1) + NET_C(Q2.C, R20.2, R21.2, Q3.E) + NET_C(R20.1, I_VM15) + NET_C(R21.1, GND) + NET_C(Q3.B, R22.2) + NET_C(R22.1, GND) + NET_C(Q3.C, R18.1) + NET_C(R18.2, IC6.5) + + NET_C(R13.2, IC5.4, IC5.8, I_V5) + NET_C(R13.1, IC5.7, R14.2) + NET_C(R14.1, IC5.6, IC5.2, C9.2) + NET_C(C9.1, GND) + NET_C(IC5.1, GND) + NET_C(IC5.5, C10.2) + NET_C(C10.1, GND) + NET_C(IC5.3, R15.1) + NET_C(R15.2, C11.1) + NET_C(C11.2, R16.2, IC6.2) + NET_C(R16.1, GND) + NET_C(IC6.3, R17.2) + NET_C(R17.1, GND) + NET_C(IC6.6, IC7.3) + + NET_C(IC7.6, IC7.2, C12.1) + NET_C(C12.2, R45.2) + ALIAS(OUTPUT, R45.1) + + // + // Motor 1 + // + + NET_C(IC9.15, R40.1, Q4.B) + NET_C(R40.2, R41.1, I_V5) + NET_C(R41.2, Q4.E) + NET_C(Q4.C, R42.2, R43.2, Q5.E) + NET_C(R42.1, I_VM15) + NET_C(R43.1, GND) + NET_C(Q5.B, R44.2) + NET_C(R44.1, GND) + NET_C(Q5.C, R36.1) + NET_C(R36.2, IC12.5) + + NET_C(R31.2, IC11.4, IC11.8, I_V5) + NET_C(R31.1, IC11.7, R32.2) + NET_C(R32.1, IC11.6, IC11.2, C14.2) + NET_C(C14.1, GND, IC11.1, C15.1) + NET_C(C15.2, IC11.5) + NET_C(IC11.3, R33.1) + NET_C(R33.2, C16.1) + NET_C(C16.2, R34.2, IC12.2, C19.2) + NET_C(R34.1, GND) + NET_C(IC12.3, R35.2) + NET_C(R35.1, GND) + NET_C(IC12.6, D12.A, IC7.3) + NET_C(D12.K, D13.K) + NET_C(D13.A, GND) + + NET_C(R37.2, IC13.4, IC13.8, I_V5) + NET_C(R37.1, IC13.7, R38.2) + NET_C(R38.1, IC13.6, IC13.2, C17.2) + NET_C(C17.1, GND) + NET_C(IC13.1, GND) + NET_C(IC13.5, C18.2) + NET_C(C18.1, GND) + NET_C(IC13.3, R39.1) + NET_C(R39.2, C19.1) + + // + // Laser + // + + NET_C(I_OUT_4, IC10.13, IC18.12) + NET_C(IC10.12, R56.1) + NET_C(R56.2, C26.2, D2.K) + NET_C(C26.1, GND) + +#if (HLE_LASER_VCO) + // + // This is a typical Cinemtraonics VCO, driving a TTL counter. + // Netlist simulation requires a very small step which is not + // realtime performant, so we model it offline with the small + // step count, and then for realtime performance replace it + // with a mapping. + // + // Here is the mapping between 26.2 and the TTL clock IC18.13 + // when the circuit is present: + // + // R2 = 0.99566: HP = (0.0000211106*A0) + 0.0000233926 + // R2 = 0.99925: HP = (0.000000616538*A0*A0) + (0.0000166899*A0) + 0.0000239800 + // R2 = 0.99946: HP = (0.000000065592*A0*A0*A0) - (0.000000207181*A0*A0) + (0.0000190091*A0) + 0.0000237318 + // R2 = 0.99946: HP = (0.00000000399629*A0*A0*A0*A0) - (0.00000000517200*A0*A0*A0) + (0.000000172470*A0*A0) + (0.0000184103*A0) + 0.0000237906 + // R2 = 0.99946: HP = (0.0000000000207619*A0*A0*A0*A0*A0) + (0.00000000352382*A0*A0*A0*A0) - (0.00000000145304*A0*A0*A0) + (0.000000160778*A0*A0) + (0.0000184225*A0) + 0.0000237894 + // + // And here is the mapping when the circuit is removed: + // + // R2 = 0.98806: HP = (0.00245939*A0) - 0.000220173 + // R2 = 0.99179: HP = (0.00545522*A0*A0) + (0.00103499*A0) - 0.000132203 + // R2 = 0.99913: HP = (-0.102004*A0*A0*A0) + (0.0406935*A0*A0) - (0.00277839*A0) - 0.00000140594 + // R2 = 0.99941: HP = (0.651650*A0*A0*A0*A0) - (0.377655*A0*A0*A0) + (0.078834*A0*A0) - (0.00454290*A0) + 0.00000408830 + // R2 = 0.99941: HP = (2.264700*A0*A0*A0*A0*A0) - (0.633172*A0*A0*A0*A0) - (0.108936*A0*A0*A0) + (0.0542944*A0*A0) - (0.00371696*A0) + 0.00000401368 + // + VARCLOCK(LASERCLK, 1, "max(0.000001,min(0.1,(-0.102004*A0*A0*A0) + (0.0406935*A0*A0) - (0.00277839*A0) - 0.00000140594))") + NET_C(LASERCLK.GND, GND) + NET_C(LASERCLK.VCC, I_V5) + NET_C(LASERCLK.A0, C26.2) + NET_C(LASERCLK.Q, IC18.13) + NET_C(GND, R57.1, R57.2, R58.1, R58.2, R59.1, R59.2, R60.1, R60.2, R61.1, R61.2, C27.1, C27.2, D2.A, D3.A, D3.K, IC16.2, IC16.3) +#else + NET_C(D2.A, IC16.3, D3.K, R58.1) + NET_C(D3.A, GND) + NET_C(IC16.2, R57.1, C27.2) + NET_C(C27.1, GND) + NET_C(IC16.6, R57.2, R58.2, R59.1) + NET_C(R59.2, R60.2, Q8.B) + NET_C(R60.1, GND) + NET_C(Q8.E, GND) + NET_C(Q8.C, R61.1, IC18.13) + NET_C(R61.2, I_V5) +#endif + + NET_C(IC18.9, R62.1) + NET_C(IC18.8, R63.1) + NET_C(IC18.10, R64.1) + NET_C(IC18.11, R65.1) + NET_C(R62.2, R63.2, R64.2, R65.2, R47.2, R48.1) + NET_C(R47.1, GND) + NET_C(R48.2, C21.1) + NET_C(C21.2, R49.1) + + // + // Torpedo + // + + NET_C(I_OUT_3, IC10.11, IC18.2) + NET_C(IC10.10, R66.1) + NET_C(R66.2, C28.2, D4.K) + NET_C(C28.1, GND) + +#if (HLE_TORPEDO_VCO) + // + // Another tricky Cinematronics VCO. Here is the mapping between + // C28.2 and the TTL clock IC18.1 when the circuit is present: + // + // R2 = 0.97255: HP = (0.0000327662*A0) + 0.0000149365 + // R2 = 0.99171: HP = (0.00000331016*A0*A0) - (0.0000125849*A0) + 0.0000206090 + // R2 = 0.99613: HP = (0.000000536978*A0*A0*A0) - (0.0000078207*A0*A0) + (0.0000390037*A0) + 0.0000148210 + // R2 = 0.99748: HP = (0.000000092476*A0*A0*A0*A0) - (0.00000204069*A0*A0*A0) + (0.0000139512*A0*A0) - (0.0000143884*A0) + 0.0000205567 + // R2 = 0.99798: HP = (0.0000000168890*A0*A0*A0*A0*A0) - (0.000000498868*A0*A0*A0*A0) + (0.00000512183*A0*A0*A0) - (0.0000205655*A0*A0) + (0.0000394849*A0) + 0.0000149619 + // + // And here is the mapping when the circuit is removed: + // + // R2 = 0.83356: HP = (0.000387263*A0) - 0.0000161072 + // R2 = 0.96482: HP = (-0.000459844*A0*A0) + (0.00110697*A0) - 0.000085961 + // R2 = 0.99210: HP = (0.000512521*A0*A0*A0) - (0.00183716*A0*A0) + (0.00202778*A0) - 0.000165571 + // R2 = 0.99614: HP = (-0.000450996*A0*A0*A0*A0) + (0.00218565*A0*A0*A0) - (0.00381123*A0*A0) + (0.00280823*A0) - 0.000225737 + // R2 = 0.99625: HP = (-0.000161974*A0*A0*A0*A0*A0) + (0.000309626*A0*A0*A0*A0) + (0.000915096*A0*A0*A0) - (0.00291505*A0*A0) + (0.00256587*A0) - 0.000209241 + // + VARCLOCK(TORPEDOCLK, 1, "max(0.000001,min(0.1,(0.000512521*A0*A0*A0) - (0.00183716*A0*A0) + (0.00202778*A0) - 0.000165571))") + NET_C(TORPEDOCLK.GND, GND) + NET_C(TORPEDOCLK.VCC, I_V5) + NET_C(TORPEDOCLK.A0, C28.2) + NET_C(TORPEDOCLK.Q, IC18.1) + NET_C(GND, R67.1, R67.2, R68.1, R68.2, R69.1, R69.2, R70.1, R70.2, R71.1, R71.2, C29.1, C29.2, D4.A, D5.A, D5.K, IC17.2, IC17.3) +#else + NET_C(D4.A, IC17.3, D5.K, R68.1) + NET_C(D5.A, GND) + NET_C(IC17.2, C29.2, R67.1) + NET_C(C29.1, GND) + NET_C(IC17.6, R67.2, R68.2, R69.1) + NET_C(R69.2, R70.2, Q9.B) + NET_C(R70.1, GND) + NET_C(Q9.E, GND) + NET_C(Q9.C, R71.1, IC18.1) + NET_C(R71.2, I_V5) +#endif + + NET_C(IC18.5, R72.1) + NET_C(IC18.6, R73.1) + NET_C(IC18.4, R74.1) + NET_C(IC18.3, R75.1) + NET_C(R72.2, R73.2, R74.2, R75.2, R48.1) + + // + // Unconnected inputs + // + + NET_C(GND, IC9.17, IC9.18, IC10.9, IC22.12, IC22.13) + NET_C(GND, IC14.2, IC14.3, IC15.2, IC15.3) // part of final amp + + // + // Unconnected outputs + // + + HINT(IC9.16, NC) // Q6 + HINT(IC9.19, NC) // Q7 + HINT(IC10.8, NC) // QD + HINT(IC22.11, NC) // Q0 + HINT(IC22.10, NC) // Q1 + HINT(IC22.9, NC) // Q2 + HINT(IC22.8, NC) // Q3 + +#if (ENABLE_FRONTIERS) + // + // Split explosion/beep/motor from other sources + // + OPTIMIZE_FRONTIER(R45.2, RES_M(1), 50) + OPTIMIZE_FRONTIER(IC7.3, RES_M(1), 50) + + // + // Split noise generator from consumers + // + OPTIMIZE_FRONTIER(R1.1, RES_M(1), 50) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_ripoff.h b/src/mame/audio/nl_ripoff.h new file mode 100644 index 00000000000..e4c5efe5a7d --- /dev/null +++ b/src/mame/audio/nl_ripoff.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_RIPOFF_H +#define MAME_AUDIO_NL_RIPOFF_H + +#pragma once + +NETLIST_EXTERNAL(ripoff) + +#endif // MAME_AUDIO_NL_RIPOFF_H diff --git a/src/mame/audio/nl_solarq.cpp b/src/mame/audio/nl_solarq.cpp new file mode 100644 index 00000000000..6e2a8ec464f --- /dev/null +++ b/src/mame/audio/nl_solarq.cpp @@ -0,0 +1,1272 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Solar Quest +// +// Derived from the schematics in the Solar Quest manual. +// +// Known problems/issues: +// +// * This was the most challenging netlist so far to get +// into realtime performance. +// +// * The FIRE sound in particular uses a complex network +// of op-amps (mix of TL081 and CA3080) with lots of +// feedback. The default "fast" CA3080 is not sufficient +// here because it uses an instantaneous AFUNC which +// is bad in feedback loops, so instead we use the +// much slower 15xBJT model. Frontiers are used to +// isolate the two relevant CA3080s from the more +// common CA3080s used for final mixing. +// +// * A few important frontiers are used to isolate parts +// of the circuit from one another. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_solarq.h" + + +// +// Optimizations +// + +#define HLE_MUSIC_CLOCK (1) +#define HLE_CAPTURE_VCO (1) +#define HLE_PHOTON_VCO (1) +#define HLE_NOISE_CONVERT (1) +#define ENABLE_FRONTIERS (1) + + + +// +// Main netlist +// + +NETLIST_START(solarq) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 4e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + TTL_INPUT(I_OUT_7, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(1)) + RES(R2, RES_K(1)) + RES(R3, RES_K(1)) + RES(R4, RES_K(2)) + RES(R5, RES_K(15)) + RES(R6, 390) + RES(R7, RES_M(1)) + RES(R8, RES_K(4.7)) + RES(R9, 330) + RES(R10, 330) + RES(R11, RES_K(4.7)) + RES(R12, RES_K(20)) + RES(R13, RES_K(24)) + RES(R14, RES_M(1)) + RES(R15, RES_K(6.8)) + RES(R16, RES_K(18)) + RES(R17, RES_K(47)) + RES(R18, 390) + RES(R19, 390) + RES(R20, RES_K(4.7)) + RES(R21, RES_K(2.7)) + RES(R22, RES_K(4.7)) + RES(R23, RES_K(39)) + RES(R24, RES_K(12)) + RES(R25, RES_K(1)) + RES(R26, RES_K(75)) + RES(R27, RES_K(4.7)) + RES(R28, RES_K(2.7)) + RES(R29, RES_K(4.7)) + RES(R30, RES_K(39)) + RES(R31, RES_K(12)) + RES(R32, RES_K(1)) + RES(R33, RES_K(200)) + RES(R34, RES_K(8.2)) + RES(R35, RES_K(47)) + RES(R36, RES_K(22)) + RES(R37, RES_K(1)) + RES(R38, RES_K(1)) + RES(R39, RES_K(4.7)) + RES(R40, RES_K(2.7)) + RES(R41, RES_K(4.7)) + RES(R42, RES_K(39)) + RES(R43, RES_K(12)) + RES(R44, RES_K(1)) + RES(R45, RES_K(36)) + RES(R46, RES_K(100)) + RES(R47, RES_K(2)) + RES(R48, RES_M(1)) + RES(R49, RES_K(4.7)) + RES(R50, RES_K(2.7)) + RES(R51, RES_K(4.7)) + RES(R52, RES_K(39)) + RES(R53, RES_K(2.7)) + RES(R54, RES_K(12)) +// RES(R55, xx) -- deleted +// RES(R56, xx) -- deleted +// RES(R57, xx) -- deleted + RES(R58, RES_K(8.2)) + RES(R59, RES_K(51)) + RES(R60, RES_M(1)) + RES(R61, RES_K(20)) + RES(R62, RES_K(20)) + RES(R63, 100) + RES(R64, RES_K(100)) + RES(R65, RES_K(20)) + RES(R66, RES_K(2)) + RES(R67, 100) + RES(R68, RES_K(100)) + RES(R69, RES_K(20)) + RES(R70, RES_K(20)) + RES(R71, RES_K(13)) + RES(R72, RES_K(300)) + RES(R73, 100) + RES(R74, 100) + RES(R75, RES_K(4.7)) + RES(R76, RES_K(2.7)) + RES(R77, RES_K(4.7)) + RES(R78, RES_K(39)) + RES(R79, RES_K(12)) + RES(R80, RES_K(1)) + RES(R81, RES_K(360)) + RES(R82, RES_K(4.7)) + RES(R83, RES_K(2.7)) + RES(R84, RES_K(4.7)) + RES(R85, RES_K(39)) + RES(R86, RES_K(12)) + RES(R87, RES_K(2.7)) + RES(R88, RES_K(270)) + RES(R89, RES_K(51)) + RES(R90, RES_M(1)) + RES(R91, RES_K(10)) + RES(R92, RES_K(10)) + RES(R93, RES_K(1)) + RES(R94, RES_K(2)) + RES(R95, RES_K(10)) + RES(R96, RES_K(12)) + RES(R97, RES_K(1)) + RES(R98, RES_K(10)) + RES(R99, RES_K(11)) + RES(R100, RES_K(100)) + RES(R101, RES_K(100)) + RES(R102, RES_K(240)) + RES(R103, RES_K(100)) + RES(R104, RES_K(100)) + RES(R105, RES_K(100)) + RES(R106, 200) + RES(R107, 200) + RES(R108, RES_K(120)) + RES(R109, RES_M(10)) + RES(R110, RES_K(100)) + RES(R111, 200) + RES(R112, 200) + RES(R113, RES_K(4.7)) + RES(R114, RES_K(2.7)) + RES(R115, RES_K(4.7)) + RES(R116, RES_K(39)) + RES(R117, RES_K(12)) + RES(R118, RES_K(1)) + RES(R119, RES_K(120)) + RES(R120, RES_M(10)) + RES(R121, RES_K(4.7)) + RES(R122, RES_M(1.5)) + RES(R123, 390) + RES(R124, 390) + RES(R125, RES_K(4.7)) + RES(R126, RES_K(2.7)) + RES(R127, RES_K(4.7)) + RES(R128, RES_K(39)) + RES(R129, RES_K(12)) + RES(R130, RES_K(1)) +// RES(R131, xx) -- deleted + RES(R132, RES_K(75)) + RES(R133, RES_K(4.7)) + RES(R134, RES_K(2.7)) + RES(R135, RES_K(4.7)) + RES(R136, RES_K(39)) + RES(R137, RES_K(12)) + RES(R138, RES_K(1)) + RES(R139, RES_K(51)) + RES(R140, RES_K(100)) + RES(R141, RES_K(4.7)) + RES(R142, RES_K(2.7)) + RES(R143, RES_K(4.7)) + RES(R144, RES_K(39)) + RES(R145, RES_K(12)) + RES(R146, RES_K(1)) + RES(R147, RES_K(51)) + RES(R148, RES_K(200)) + RES(R149, RES_K(30)) + RES(R150, RES_K(8.2)) + RES(R151, RES_K(51)) +// POT(R152, RES_K(10)) -- part of final amp (not emulated) +// RES(R153, RES_K(15)) -- part of final amp (not emulated) +// RES(R154, RES_K(390)) -- part of final amp (not emulated) +// RES(R155, RES_K(150)) -- part of final amp (not emulated) +// RES(R156, 150) -- part of final amp (not emulated) +// RES(R157, RES_K(22)) -- part of final amp (not emulated) +// RES(R158, 0.51) -- part of final amp (not emulated) +// RES(R159, 0.51) -- part of final amp (not emulated) +// RES(R160, RES_K(390)) -- part of final amp (not emulated) + RES(R161, RES_K(1)) + RES(R162, RES_K(1)) + RES(R163, RES_K(1)) + RES(R164, RES_K(1)) + + CAP(C1, CAP_U(0.001)) + CAP(C2, CAP_U(0.01)) + CAP(C3, CAP_U(0.1)) + CAP(C4, CAP_P(680)) + CAP(C5, CAP_U(0.1)) + CAP(C6, CAP_U(0.1)) + CAP(C7, CAP_U(0.01)) + CAP(C8, CAP_U(3.3)) + CAP(C9, CAP_U(1)) + CAP(C10, CAP_U(0.22)) + CAP(C11, CAP_U(0.33)) + CAP(C12, CAP_U(4.7)) + CAP(C13, CAP_U(0.1)) + CAP(C14, CAP_U(0.01)) + CAP(C15, CAP_U(1)) + CAP(C16, CAP_U(0.1)) + CAP(C17, CAP_U(1)) + CAP(C18, CAP_U(0.47)) + CAP(C19, CAP_U(0.001)) + CAP(C20, CAP_U(0.01)) + CAP(C21, CAP_U(0.1)) + CAP(C22, CAP_U(0.1)) + CAP(C23, CAP_P(330)) + CAP(C24, CAP_U(0.68)) + CAP(C25, CAP_P(330)) + CAP(C26, CAP_U(2.2)) + CAP(C27, CAP_U(0.22)) + CAP(C28, CAP_U(2.2)) + CAP(C29, CAP_U(2.2)) + CAP(C30, CAP_U(0.1)) + CAP(C31, CAP_U(0.33)) +// CAP(C32, CAP_U(0.68)) -- part of final amp (not emulated) +// CAP(C33, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C34, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C35, CAP_U(0.005)) -- part of final amp (not emulated) +// CAP(C36, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C37, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C38, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C39, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C40, CAP_U(0.1)) -- part of voltage converter (not emulated) +// CAP(C41, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C42, CAP_U(25)) -- part of voltage converter (not emulated) +// CAP(C43, CAP_U(25)) -- part of voltage converter (not emulated) + +// D_1N4003(D1) -- part of voltage converter (not emulated) +// D_1N4003(D2) -- part of voltage converter (not emulated) +// D_1N4003(D3) -- part of voltage converter (not emulated) +// D_1N4003(D4) -- part of voltage converter (not emulated) + D_1N5240(D5) + D_1N5240(D6) + D_1N914(D7) + D_1N914(D8) +// D_1N4003(D9) -- part of final amp (not emulated) +// D_1N4003(D10) -- part of final amp (not emulated) + + Q_2N3906(Q1) // PNP + Q_2N3906(Q2) // PNP + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3906(Q5) // PNP + Q_2N3906(Q6) // PNP + Q_2N3906(Q7) // PNP + Q_2N3904(Q8) // NPN + Q_2N3906(Q9) // PNP + Q_2N3906(Q10) // PNP + Q_2N3906(Q11) // PNP + Q_2N3904(Q12) // NPN + Q_2N3904(Q13) // NPN + Q_2N3906(Q14) // PNP + Q_2N3906(Q15) // PNP + Q_2N3906(Q16) // PNP + Q_2N3906(Q17) // PNP + Q_2N3906(Q18) // PNP + Q_2N3906(Q19) // PNP + Q_2N3906(Q20) // PNP + Q_2N3906(Q21) // PNP +// Q_2N6292(Q22) // NPN -- part of final amp (not emulated) +// Q_2N6107(Q23) // PNP -- part of final amp (not emulated) + +#if (!HLE_MUSIC_CLOCK) + CLOCK(Y1, 20000000) + NET_C(Y1.GND, GND) + NET_C(Y1.VCC, I_V5) +#endif + + TTL_7414_DIP(U1) // Hex Inverter + NET_C(U1.7, GND) + NET_C(U1.14, I_V5) + + TTL_7414_DIP(U2) // Hex Inverter + NET_C(U2.7, GND) + NET_C(U2.14, I_V5) + + TTL_74LS164_DIP(U3) // 8-bit Shift Reg. + NET_C(U3.7, GND) + NET_C(U3.14, I_V5) + + TTL_74LS164_DIP(U4) // 8-bit Shift Reg. + NET_C(U4.7, GND) + NET_C(U4.14, I_V5) + + TTL_74LS377_DIP(U5) // Octal D Flip Flop + NET_C(U5.10, GND) + NET_C(U5.20, I_V5) + + TTL_74LS377_DIP(U6) // Octal D Flip Flop + NET_C(U6.10, GND) + NET_C(U6.20, I_V5) + + TTL_74LS377_DIP(U7) // Octal D Flip Flop + NET_C(U7.10, GND) + NET_C(U7.20, I_V5) + + TTL_74LS163_DIP(U8) // Binary Counter + NET_C(U8.8, GND) + NET_C(U8.16, I_V5) + + TTL_74LS163_DIP(U9) // Binary Counter + NET_C(U9.8, GND) + NET_C(U9.16, I_V5) + + TTL_74LS163_DIP(U10) // Binary Counter + NET_C(U10.8, GND) + NET_C(U10.16, I_V5) + + TTL_74LS163_DIP(U11) // Binary Counter + NET_C(U11.8, GND) + NET_C(U11.16, I_V5) + + TTL_74LS163_DIP(U12) // Binary Counter + NET_C(U12.8, GND) + NET_C(U12.16, I_V5) + + LM555_DIP(U13) + + TTL_74LS74_DIP(U14) // Dual D Flip Flop + NET_C(U14.7, GND) + NET_C(U14.14, I_V5) + + TTL_74LS74_DIP(U15) // Dual D Flip Flop + NET_C(U15.7, GND) + NET_C(U15.14, I_V5) + + TTL_74LS107_DIP(U16) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U16.7, GND) + NET_C(U16.14, I_V5) + + TTL_74LS393_DIP(U17) // Dual 4-Stage Binary Counter + NET_C(U17.7, GND) + NET_C(U17.14, I_V5) + + TTL_74LS86_DIP(U18) // Quad 2-Input XOR Gates + NET_C(U18.7, GND) + NET_C(U18.14, I_V5) + + TTL_74LS74_DIP(U19) // Dual D Flip Flop + NET_C(U19.7, GND) + NET_C(U19.14, I_V5) + + TTL_74LS74_DIP(U20) // Dual D Flip Flop + NET_C(U20.7, GND) + NET_C(U20.14, I_V5) + + TTL_74LS393_DIP(U21) // Dual 4-Stage Binary Counter + NET_C(U21.7, GND) + NET_C(U21.14, I_V5) + + TTL_74LS02_DIP(U22) // Quad 2-input Nor Gate + NET_C(U22.7, GND) + NET_C(U22.14, I_V5) + + TTL_74LS74_DIP(U23) // Dual D Flip Flop + NET_C(U23.7, GND) + NET_C(U23.14, I_V5) + + TTL_74S04_DIP(U24) // Hex Inverting Gates + NET_C(U24.7, GND) + NET_C(U24.14, I_V5) + + TTL_74S113A_DIP(U25) // Dual JK Negative Edge-Trigged Flip Flop + NET_C(U25.7, GND) + NET_C(U25.14, I_V5) + + TTL_74LS163_DIP(U26) // Binary Counter + NET_C(U26.8, GND) + NET_C(U26.16, I_V5) + + TTL_74LS107_DIP(U27) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U27.7, GND) + NET_C(U27.14, I_V5) + + TTL_74LS164_DIP(U28) // 8-bit Shift Reg. + NET_C(U28.7, GND) + NET_C(U28.14, I_V5) + + TTL_74LS164_DIP(U29) // 8-bit Shift Reg. + NET_C(U29.7, GND) + NET_C(U29.14, I_V5) + + TTL_74LS164_DIP(U30) // 8-bit Shift Reg. + NET_C(U30.7, GND) + NET_C(U30.14, I_V5) + + TTL_74LS393_DIP(U31) // Dual 4-Stage Binary Counter + NET_C(U31.7, GND) + NET_C(U31.14, I_V5) + + TL081_DIP(U32) // Op. Amp. + NET_C(U32.7, I_V15) + NET_C(U32.4, I_VM15) + + CA3080_DIP(U33) // Op. Amp. + NET_C(U33.4, I_VM15) + NET_C(U33.7, I_V15) + + CA3080_DIP(U34) // Op. Amp. + NET_C(U34.4, I_VM15) + NET_C(U34.7, I_V15) + + LM555_DIP(U35) + + TL081_DIP(U36) // Op. Amp. + NET_C(U36.7, I_V15) + NET_C(U36.4, I_VM15) + + TL081_DIP(U37) // Op. Amp. + NET_C(U37.7, I_V15) + NET_C(U37.4, I_VM15) + + TL081_DIP(U38) // Op. Amp. + NET_C(U38.7, I_V15) + NET_C(U38.4, I_VM15) + + TL081_DIP(U39) // Op. Amp. + NET_C(U39.7, I_V15) + NET_C(U39.4, I_VM15) + + TL081_DIP(U40) // Op. Amp. + NET_C(U40.7, I_V15) + NET_C(U40.4, I_VM15) + + CA3080_DIP(U41) // Op. Amp. + NET_C(U41.4, I_VM15) + NET_C(U41.7, I_V15) + +#if (!HLE_CAPTURE_VCO) + LM566_DIP(U42) +#endif + + TL081_DIP(U43) // Op. Amp. + NET_C(U43.7, I_V15) + NET_C(U43.4, I_VM15) + + CA3080_SLOW_DIP(U44) // Op. Amp. + NET_C(U44.4, I_VM15) + NET_C(U44.7, I_V15) + + TL081_DIP(U45) // Op. Amp. + NET_C(U45.7, I_V15) + NET_C(U45.4, I_VM15) + + CA3080_SLOW_DIP(U46) // Op. Amp. + NET_C(U46.4, I_VM15) + NET_C(U46.7, I_V15) + + TL081_DIP(U47) // Op. Amp. + NET_C(U47.7, I_V15) + NET_C(U47.4, I_VM15) + + CA3080_DIP(U48) // Op. Amp. + NET_C(U48.4, I_VM15) + NET_C(U48.7, I_V15) + + TL081_DIP(U49) // Op. Amp. + NET_C(U49.7, I_V15) + NET_C(U49.4, I_VM15) + + TL081_DIP(U50) // Op. Amp. + NET_C(U50.7, I_V15) + NET_C(U50.4, I_VM15) + +// TL081_DIP(U51) // Op. Amp. -- part of final amp (not emulated) +// NET_C(U51.7, I_V15) +// NET_C(U51.4, I_VM15) + +// TTL_7815_DIP(U52) // +15V Regulator -- part of voltage converter (not emulated) +// TTL_7915_DIP(U53) // -15V Regulator -- part of voltage converter (not emulated) + + // + // Page 1, top left + // + + NET_C(I_OUT_7, U1.1) + NET_C(U1.2, U1.3) + NET_C(U1.4, U3.1) + + NET_C(I_OUT_4, U1.5) + NET_C(U1.6, U1.13) + NET_C(U1.12, U3.8, U4.8) + + NET_C(I_V5, R1.1, R2.1, R3.1) + ALIAS(HIA_P, R1.2) + ALIAS(HIB_P, R2.2) + ALIAS(HIC_P, R3.2) + + NET_C(HIA_P, U3.9, U3.2) + NET_C(U3.3, U5.3, U7.3) + NET_C(U3.4, U5.4, U7.4) + NET_C(U3.5, U5.7, U7.7) + NET_C(U3.6, U5.8, U7.8) + NET_C(U3.10, U5.13, U7.13) + NET_C(U3.11, U5.14, U7.14) + NET_C(U3.12, U5.17, U7.17) + NET_C(U3.13, U5.18, U7.18, U4.1) + + NET_C(HIA_P, U4.2, U4.9) + NET_C(U4.3, U6.3) + NET_C(U4.4, U6.4) + NET_C(U4.5, U6.7) + NET_C(U4.6, U6.8) + NET_C(U4.10, U6.13) + NET_C(U4.11, U6.14) + NET_C(U4.12, U6.17) + NET_C(U4.13, U6.18) + + ALIAS(MEN_P, U5.2) + ALIAS(AS2_M, U5.5) + ALIAS(AS1_M, U5.6) + ALIAS(AS0_M, U5.9) + ALIAS(FS11_P, U5.12) + ALIAS(FS10_P, U5.15) + ALIAS(FS09_P, U5.16) + ALIAS(FS08_P, U5.19) + ALIAS(MLATCH_P, U5.11) + NET_C(U5.1, GND) + + ALIAS(FS07_P, U6.2) + ALIAS(FS06_P, U6.5) + ALIAS(FS05_P, U6.6) + ALIAS(FS04_P, U6.9) + ALIAS(FS03_P, U6.12) + ALIAS(FS02_P, U6.15) + ALIAS(FS01_P, U6.16) + ALIAS(FS00_P, U6.19) + NET_C(U6.11, MLATCH_P) + NET_C(U6.1, GND) + + // + // Page 1, bottom + // + + NET_C(I_OUT_0, U2.3) + NET_C(U2.4, U2.5) + ALIAS(LATCH_CLK_P, U2.6) + + NET_C(I_OUT_1, U1.11) + NET_C(U1.10, U1.9) + NET_C(U1.8, U7.11) + + ALIAS(LOUD_EXP_M, U7.2) + ALIAS(SOFT_EXP_M, U7.5) + ALIAS(THRUST_M, U7.6) + ALIAS(FIRE_M, U7.9) + ALIAS(CAPTURE_M, U7.12) + ALIAS(NUKE_P, U7.15) + ALIAS(PHOTON_M, U7.16) + HINT(U7.19, NC) + NET_C(U7.1, GND) + + NET_C(HIA_P, U19.4, U19.1) + ALIAS(MACLK_M, U19.2) + ALIAS(_227KC_P, U19.3) + ALIAS(MBCLK_P, U19.5) + ALIAS(MBCLK_M, U19.6) + + NET_C(HIA_P, U19.10, U19.13) + NET_C(MBCLK_P, U19.12) + ALIAS(_227KC_M, U19.11) + ALIAS(MACLK_P, U19.9) + NET_C(U19.8, MACLK_M, U20.11) + + NET_C(HIA_P, U16.8, U16.11, U16.10) + NET_C(U16.9, U20.9, U22.8) + ALIAS(DMUSIC_P, U16.5) + HINT(U16.6, NC) + + NET_C(HIA_P, U20.10) + ALIAS(MCARRY_P, U20.12) + NET_C(R162.1, I_V5) + NET_C(R162.2, U20.13) + ALIAS(MLOAD_M, U20.8) + + NET_C(MBCLK_M, U21.13) + HINT(U21.8, NC) + NET_C(U21.9, U22.11, U22.12) + HINT(U21.10, NC) + HINT(U21.11, NC) + NET_C(U21.12, U20.6, U22.9) + + NET_C(HIA_P, U20.2, U20.4) + NET_C(LATCH_CLK_P, U20.3) + ALIAS(KILL_FLAG_M, U20.1) + HINT(U20.5, NC) + + NET_C(U22.13, U23.10) + NET_C(U22.10, U23.12) + NET_C(MBCLK_P, U23.11) + NET_C(HIA_P, U23.13) + HINT(U23.8, NC) + NET_C(U23.9, U23.2, MLATCH_P) + + NET_C(HIA_P, U23.4) + NET_C(MACLK_P, U23.3) + NET_C(I_V5, R163.1) + NET_C(R163.2, U23.1) + HINT(U23.5, NC) + NET_C(U23.6, KILL_FLAG_M) + + // + // Page 1, middle + // + + NET_C(FS11_P, U8.6) + NET_C(FS10_P, U8.5) + NET_C(FS09_P, U8.4) + NET_C(FS08_P, U8.3) + NET_C(HIB_P, U8.1) + NET_C(MEN_P, U8.7) + NET_C(MLOAD_M, U8.9) + NET_C(MBCLK_P, U8.2) + NET_C(U8.10, U9.15) + NET_C(U8.15, MCARRY_P) + HINT(U8.11, NC) + HINT(U8.12, NC) + HINT(U8.13, NC) + HINT(U8.14, NC) + + NET_C(FS07_P, U9.6) + NET_C(FS06_P, U9.5) + NET_C(FS05_P, U9.4) + NET_C(FS04_P, U9.3) + NET_C(HIB_P, U9.1) + NET_C(MEN_P, U9.7) + NET_C(MLOAD_M, U9.9) + NET_C(MACLK_P, U9.2) + NET_C(U9.10, U10.15) + HINT(U9.11, NC) + HINT(U9.12, NC) + HINT(U9.13, NC) + HINT(U9.14, NC) + + NET_C(FS03_P, U10.6) + NET_C(FS02_P, U10.5) + NET_C(FS01_P, U10.4) + NET_C(FS00_P, U10.3) + NET_C(HIB_P, U10.1) + NET_C(MLOAD_M, U10.9) + NET_C(MBCLK_M, U10.2) + NET_C(MEN_P, U10.7, U10.10) + HINT(U10.11, NC) + HINT(U10.12, NC) + HINT(U10.13, NC) + HINT(U10.14, NC) + + // + // Page 1, top-right + // + + NET_C(GND, U11.6, U11.4, U11.3) + NET_C(HIB_P, U11.5, U11.1, U11.7) + ALIAS(NLOAD_M, U11.9) + ALIAS(NBCLK_P, U11.2) + NET_C(U11.10, U12.15) + NET_C(U11.15, U15.12) + HINT(U11.11, NC) + HINT(U11.12, NC) + HINT(U11.13, NC) + HINT(U11.14, NC) + + NET_C(GND, U12.6, U12.5, U12.4) + NET_C(HIB_P, U12.3, U12.1, U12.7, U12.10) + NET_C(NLOAD_M, U12.9) + ALIAS(NACLK_M, U12.2) + HINT(U12.11, NC) + HINT(U12.12, NC) + HINT(U12.13, NC) + HINT(U12.14, NC) + + NET_C(HIB_P, U15.10) + ALIAS(NBCLK_M, U15.11) + NET_C(I_V5, R164.1) + NET_C(R164.2, U15.13) + NET_C(U15.9, U16.12) + NET_C(U15.8, NLOAD_M) + + NET_C(U16.1, U16.4, U16.13, HIB_P) + NET_C(U16.3, U18.2) + HINT(U16.2, NC) + + NET_C(GND, U17.2) + NET_C(NBCLK_P, U17.1) + NET_C(U17.6, U17.13) + HINT(U17.5, NC) + HINT(U17.4, NC) + HINT(U17.3, NC) + + NET_C(GND, U17.12) + HINT(U17.8, NC) + NET_C(U17.9, U18.1) + HINT(U17.10, NC) + HINT(U17.11, NC) + + NET_C(U18.3, R7.1, R8.2) + NET_C(R7.2, C3.1) + ALIAS(SJ, C3.2) + NET_C(R8.1, I_V5) + + // + // Page 1, middle-right + // + + NET_C(I_V5, U13.8, R4.2) + NET_C(R4.1, U13.7, R5.2) + NET_C(R5.1, U13.2, U13.6, C1.2) + NET_C(C1.1, GND) + NET_C(NUKE_P, U13.4) + NET_C(U13.1, GND) + NET_C(U13.5, C2.2) + NET_C(C2.1, GND) + NET_C(U13.3, R6.2, U2.1) + NET_C(R6.1, GND) + NET_C(U2.2, U2.13, U14.3) + + NET_C(HIB_P, U14.1, U14.13) + NET_C(U14.6, NACLK_M) + NET_C(U14.5, U14.12) + NET_C(U14.2, U14.8, NBCLK_M) + NET_C(HIB_P, U14.4, U14.10) + NET_C(U14.9, NBCLK_P) + NET_C(U2.12, U14.11) + +#if (HLE_MUSIC_CLOCK) + // + // The 20MHz clock (Y1) is divided by 4 via a pair + // of JK flip-flops (U25) to 5MHz. That signal is only + // used to clock a 74LS163 counter (U26) that divides + // the clock by 9 via a preset value. It then goes + // through another JK flip-flop (U27) for another + // divide by 2, ending up at 277778Hz. No sense in + // running all this manually. + // + CLOCK(MUSICCLK, 277778) + NET_C(MUSICCLK.VCC, I_V5) + NET_C(MUSICCLK.GND, GND) + NET_C(_227KC_P, MUSICCLK.Q) + NET_C(MUSICCLK.Q, U24.13) + NET_C(_227KC_M, U24.12) + NET_C(GND, R9.1, R9.2, R10.1, R10.2, R161.1, R161.2, C4.1, C4.2) + NET_C(GND, U15.1, U15.2, U15.3, U15.4) + NET_C(GND, U24.1, U24.5) + NET_C(GND, U25.1, U25.2, U25.3, U25.4, U25.10, U25.11, U25.12, U25.13) + NET_C(GND, U26.1, U26.2, U26.3, U26.4, U26.5, U26.6, U26.7, U26.9, U26.10) + NET_C(GND, U27.1, U27.4, U27.12) + NET_C(HIC_P, U27.13) + +#else + + // + // Page 2, top-left (clock) + // + + // + // This is just here for documentation; the crystal is + // not modelled for this circuit. + // + NET_C(U24.5, R9.1, C4.1) + NET_C(U24.6, R9.2, Y1.1) + NET_C(Y1.2, R10.1, U24.1) + NET_C(R10.2, U24.2, C4.2, U24.13) + NET_C(U24.12, U25.1) + NET_C(HIC_P, U25.3, U25.2, U25.4, U25.11, U25.12, U25.10) + NET_C(U25.5, U25.13) + ALIAS(_5MC_P, U25.9) + ALIAS(_5MC_M, U25.8) + + // + // Page 2, middle-left + // + + NET_C(HIC_P, U26.5, U26.3, U26.1, U26.10, U26.7) + NET_C(GND, U26.6, U26.4) + NET_C(_5MC_P, U26.2) + HINT(U26.11, NC) + HINT(U26.12, NC) + HINT(U26.13, NC) + HINT(U26.14, NC) + NET_C(U26.9, U27.12, U15.6) + NET_C(U26.15, U15.2) + + NET_C(_5MC_M, U15.3) + NET_C(HIC_P, U15.4) + NET_C(I_V5, R161.1) + NET_C(R161.2, U15.1) + + NET_C(HIC_P, U27.1, U27.4, U27.13) + NET_C(_227KC_P, U27.3) + NET_C(_227KC_M, U27.2) +#endif + + // + // Page 2, top-middle + // + + NET_C(MACLK_P, U29.8) + ALIAS(IN_M, U29.2) + NET_C(U29.2, U29.1) + ALIAS(RN_M, U29.9) + NET_C(U29.9, U28.9, U30.9) + NET_C(U29.13, U28.1, U28.2) + HINT(U29.12, NC) + HINT(U29.11, NC) + HINT(U29.10, NC) + HINT(U29.6, NC) + HINT(U29.5, NC) + HINT(U29.4, NC) + HINT(U29.3, NC) + + NET_C(MACLK_P, U28.8) + NET_C(U28.13, U30.1, U30.2) + HINT(U28.12, NC) + HINT(U28.11, NC) + HINT(U28.10, NC) + HINT(U28.6, NC) + HINT(U28.5, NC) + HINT(U28.4, NC) + HINT(U28.3, NC) + + NET_C(MACLK_P, U30.8) + NET_C(U30.13, U18.10) + NET_C(U30.6, U18.5) + NET_C(U30.5, U18.4) + NET_C(U30.3, U18.9) + HINT(U30.12, NC) + HINT(U30.11, NC) + HINT(U30.10, NC) + HINT(U30.4, NC) + +#if (HLE_NOISE_CONVERT) + // + // The TTL-to-analog conversion takes a noticeable + // amount of time, so just do it directly. The 4.2 + // P-P value is observed from the original netlist. + // + AFUNC(NOISECONV, 1, "if(A0>2.5,-4.2,4.2)") + NET_C(U30.13, NOISECONV.A0) + ALIAS(NOISE, NOISECONV.Q) + NET_C(GND, C5.1, C5.2, R11.1, R11.2, R12.1, R12.2, R13.1, R13.2, R14.1, R14.2, U32.2, U32.3) +#else + NET_C(U30.13, R11.1, C5.1) + NET_C(R11.2, I_V5) + NET_C(C5.2, R14.2, U32.3) + NET_C(R14.1, GND) + NET_C(U32.2, R12.2, R13.1) + NET_C(R12.1, GND) + NET_C(R13.2, U32.6) + ALIAS(NOISE, R13.2) +#endif + + NET_C(U18.6, U18.12) + NET_C(U18.8, U18.13) + NET_C(U18.11, U31.12, U31.2, U24.9) + NET_C(U24.8, IN_M) + + NET_C(MACLK_M, U31.1) + NET_C(U31.6, U31.13) + HINT(U31.5, NC) + HINT(U31.4, NC) + HINT(U31.3, NC) + NET_C(U31.10, U24.11) + HINT(U31.8, NC) + HINT(U31.9, NC) + HINT(U31.11, NC) + NET_C(U24.10, RN_M) + + // + // Page 2, bottom-middle and top-right (fire) + // + + NET_C(FIRE_M, R113.1, R114.1) + NET_C(R113.2, I_V5, R115.2, Q14.E) + NET_C(R114.2, R115.1, Q14.B) + NET_C(Q14.C, R116.2, R117.2, Q15.E) + NET_C(R116.1, I_VM15) + NET_C(R117.1, R118.1, GND) + NET_C(R118.2, Q15.B) + NET_C(Q15.C, C26.1, R108.1, R119.1) + NET_C(C26.2, I_VM15) + NET_C(R119.2, U46.5) + NET_C(R108.2, U44.5) + + NET_C(NOISE, R98.2) + NET_C(R98.1, R99.2, R100.1) + NET_C(R99.1, GND) + NET_C(R100.2, U43.2, R104.1, R102.1, R101.1) + NET_C(U43.3, GND) + NET_C(R104.2, U43.6, R105.1) + NET_C(R105.2, R106.2, U44.3) + NET_C(R106.1, GND) + NET_C(U44.2, R107.2) + NET_C(R107.1, GND) + NET_C(U44.6, C23.2, R109.2, U45.3) + NET_C(C23.1, GND) + NET_C(R109.1, GND) + NET_C(U45.6, U45.2, R110.1, R103.1, R102.2) + NET_C(R103.2, C24.1) + NET_C(C24.2, SJ) + NET_C(R110.2, R111.2, U46.3) + NET_C(R111.1, R112.1, GND) + NET_C(R112.2, U46.2) + NET_C(U46.6, C25.2, R120.2, U47.3) + NET_C(C25.1, R120.1, GND) + NET_C(U47.2, U47.6, R101.2) + + // + // Page 2, bottom-right (AS0-2) + // + + NET_C(I_V5, R121.1) + NET_C(R121.2, DMUSIC_P, R122.1) + NET_C(R122.2, C27.1) + NET_C(C27.2, R123.2, U48.2) + NET_C(R123.1, GND, R124.1) + NET_C(R124.2, U48.3) + NET_C(R148.2, R140.2, R132.2, U48.5) + ALIAS(CS, U48.6) + + NET_C(AS2_M, R125.1, R126.1) + NET_C(R125.2, I_V5, R127.2, Q16.E) + NET_C(R126.2, R127.1, Q16.B) + NET_C(Q16.C, R128.2, R129.2, Q17.E) + NET_C(R128.1, I_VM15) + NET_C(R129.1, R130.1, GND) + NET_C(R130.2, Q17.B) + NET_C(Q17.C, C28.1, R132.1) + NET_C(C28.2, I_VM15) + + NET_C(AS1_M, R133.1, R134.1) + NET_C(R133.2, I_V5, R135.2, Q18.E) + NET_C(R134.2, R135.1, Q18.B) + NET_C(Q18.C, R136.2, R137.2, Q19.E) + NET_C(R136.1, I_VM15) + NET_C(R137.1, R138.1, GND) + NET_C(R138.2, Q19.B) + NET_C(Q19.C, R139.1) + NET_C(R139.2, C29.1, R140.1) + NET_C(C29.2, I_VM15) + + NET_C(AS0_M, R141.1, R142.1) + NET_C(R141.2, I_V5, R143.2, Q20.E) + NET_C(R142.2, R143.1, Q20.B) + NET_C(Q20.C, R144.2, R145.2, Q21.E) + NET_C(R144.1, I_VM15) + NET_C(R145.1, R146.1, GND) + NET_C(R146.2, Q21.B) + NET_C(Q21.C, R147.1) + NET_C(R147.2, C30.1, R148.1) + NET_C(C30.2, I_VM15) + + // + // Page 3, top-left (explosions) + // + + NET_C(NOISE, R15.1) + NET_C(R15.2, C6.2, R16.1) + NET_C(C6.1, GND) + NET_C(R16.2, C7.2, R17.1) + NET_C(C7.1, GND) + NET_C(R17.2, R18.2, U33.2) + NET_C(R18.1, GND) + NET_C(U33.3, R19.2) + NET_C(R19.1, GND) + NET_C(CS, U33.6) + + NET_C(LOUD_EXP_M, R20.1, R21.1) + NET_C(R20.2, I_V5, R22.2, Q1.E) + NET_C(R21.2, R22.1, Q1.B) + NET_C(Q1.C, R23.2, R24.2, Q2.E) + NET_C(R23.1, I_VM15) + NET_C(R24.1, GND) + NET_C(Q2.B, R25.2) + NET_C(R25.1, GND) + NET_C(Q2.C, C8.1, R26.1) + NET_C(C8.2, I_VM15) + NET_C(R26.2, U33.5) + + NET_C(SOFT_EXP_M, R27.1, R28.1) + NET_C(R27.2, I_V5, R29.2, Q3.E) + NET_C(R28.2, R29.1, Q3.B) + NET_C(Q3.C, R30.2, R31.2, Q4.E) + NET_C(R30.1, I_VM15) + NET_C(R31.1, GND) + NET_C(Q4.B, R32.2) + NET_C(R32.1, GND) + NET_C(Q4.C, C9.1, R33.1) + NET_C(C9.2, I_VM15) + NET_C(R33.2, U33.5) + + // + // Page 3, bottom-left (thrust) + // + + NET_C(NOISE, R34.1) + NET_C(R34.2, C10.2, R35.1) + NET_C(C10.1, GND) + NET_C(R35.2, C11.2, R36.1) + NET_C(C11.1, GND) + NET_C(R36.2, R37.2, U34.2) + NET_C(R37.1, GND) + NET_C(U34.3, R38.2) + NET_C(R38.1, GND) + NET_C(U34.6, CS) + + NET_C(THRUST_M, R39.1, R40.1) + NET_C(R39.2, I_V5, R41.2, Q5.E) + NET_C(R40.2, R41.1, Q5.B) + NET_C(Q5.C, R42.2, R43.2, Q6.E) + NET_C(R42.1, I_VM15) + NET_C(R43.1, GND) + NET_C(Q6.B, R44.2) + NET_C(R44.1, GND) + NET_C(Q6.C, R45.1) + NET_C(R45.2, C12.1, R46.1) + NET_C(C12.2, I_VM15) + NET_C(R46.2, U34.5) + + // + // Page 3, top-middle/right (capture) + // + + NET_C(CAPTURE_M, R82.1, R83.1, U21.2) + NET_C(R82.2, I_V5, R84.2, Q11.E) + NET_C(R83.2, R84.1, Q11.B) + NET_C(Q11.C, R85.2, R86.2, R87.1) + NET_C(R85.1, I_VM15) + NET_C(R86.1, GND) + NET_C(R87.2, Q12.B) + NET_C(Q12.E, GND) + NET_C(Q12.C, R88.1) + NET_C(R88.2, R89.1, C18.2, R90.2, C19.1) + NET_C(R89.2, I_V15) + NET_C(C18.1, GND) + NET_C(R90.1, GND) + +#if (HLE_CAPTURE_VCO) + // + // The capture VCO actually doesn't sound bad at default + // settings, but still takes up a lot of horsepower, so + // HLE it as usual. The mappings aren't as good as they + // usually are, but the sound is short and the result is + // pretty indistinguishable from reality, so we'll go + // with it. + // + // R2 = 0.87013: HP = (0.000085296*A0) - 0.000965124 + // R2 = 0.91754: HP = (0.0000395501*A0*A0) - (0.000953905*A0) + 0.00585023 + // R2 = 0.91858: HP = (-0.0000119561*A0*A0*A0) + (0.000513446*A0*A0) - (0.00720853*A0) + 0.0333386 + // R2 = 0.93063: HP = (-0.000085348*A0*A0*A0*A0) + (0.00450954*A0*A0*A0) - (0.089245*A0*A0) + (0.784128*A0) - 2.580951 + // R2 = 0.84993: HP = (0.00000301512*A0*A0*A0*A0*A0) - (0.000286000*A0*A0*A0*A0) + (0.0098476*A0*A0*A0) - (0.160207*A0*A0) + (1.255519*A0) - 3.832746 + // + VARCLOCK(CAPTURECLK, 1, "max(0.000001,min(0.1,(-0.0000119561*A0*A0*A0) + (0.000513446*A0*A0) - (0.00720853*A0) + 0.0333386))") + NET_C(CAPTURECLK.GND, GND) + NET_C(CAPTURECLK.VCC, I_V5) + NET_C(CAPTURECLK.Q, U21.1) + NET_C(CAPTURECLK.A0, C19.1) + NET_C(GND, R91.1, R91.2, R92.1, R92.2, R93.1, R93.2, R94.1, R94.2, C19.2, C20.1, C20.2, C21.1, C21.2, D7.A, D7.K, D8.A, D8.K) +#else + NET_C(R88.2, U42.5) + NET_C(C19.2, U42.6, R91.1) + NET_C(R91.2, I_V15, U42.8) + NET_C(U42.7, C20.2) + NET_C(C20.1, GND) + NET_C(U42.1, GND) + NET_C(U42.3, C21.1) + NET_C(C21.2, D7.K, R92.1) + NET_C(D7.A, GND) + NET_C(R92.2, Q13.B) + NET_C(Q13.C, R93.1, U21.1) + NET_C(R93.2, I_V5) + NET_C(Q13.E, D8.K, R94.2) + NET_C(D8.A, GND) + NET_C(R94.1, I_VM15) +#endif + + NET_C(U21.3, R95.1) + HINT(U21.6, NC) + HINT(U21.5, NC) + HINT(U21.4, NC) + NET_C(R95.2, R97.2, R96.1) + NET_C(R97.1, GND) + NET_C(R96.2, C22.1) + NET_C(C22.2, SJ) + + // + // Page 3, bottom-middle+right (photon) + // + + NET_C(U35.1, GND) + NET_C(U35.6, U35.2, R48.1, C13.2) + NET_C(C13.1, GND) + NET_C(R48.2, U35.7, R47.1) + NET_C(R47.2, U35.8, U35.4, R49.2, R51.2, I_V5, Q7.E) + NET_C(U35.5, C14.2) + NET_C(C14.1, GND) + NET_C(U35.3, R49.1, R50.1) + NET_C(R50.2, R51.1, Q7.B) + NET_C(Q7.C, R52.2, R54.2, R53.1) + NET_C(R52.1, I_VM15) + NET_C(R54.1, GND) + NET_C(R53.2, Q8.B) + NET_C(Q8.E, GND) + NET_C(Q8.C, R58.1) + NET_C(R58.2, R59.1, R60.2, C15.1, U36.3) + NET_C(R59.2, I_V15) + NET_C(R60.1, GND) + NET_C(C15.2, GND) + NET_C(U36.2, U36.6, R61.2) + ALIAS(VP, R61.2) + NET_C(R61.1, R62.1, U37.2) + NET_C(R62.2, U37.6) + ALIAS(VN, R62.2) + NET_C(U37.3, GND) + + NET_C(VP, R63.1) + NET_C(R63.2, U38.3, R64.1) + NET_C(R64.2, U38.6, R65.1) + NET_C(U38.2, R71.1, C16.2, U39.2) + NET_C(C16.1, GND) + +#if (HLE_PHOTON_VCO) + // + // The PHOTON VCO is modulated by the 555 timer U35, + // fed through some capacitors and an op-amp to + // produce a periodic charge/discharge curve. The + // output of the op-amp U36 tracks the final + // frequency pretty closely, but only if charge and + // discharge curves are considered separately. Use + // the raw U35.3 output as a switch to pick the + // appropriate curve. + // + // U35.3 on: + // R2 = 0.95303: HP = (0.000454865*A0) - 0.000727100 + // R2 = 0.97158: HP = (0.0000320398*A0*A0) + (0.000096187*A0) + 0.000101501 + // R2 = 0.99149: HP = (0.0000173739*A0*A0*A0) - (0.000265948*A0*A0) + (0.00163589*A0) - 0.00222259 + // R2 = 0.99201: HP = (-0.00000151250*A0*A0*A0*A0) + (0.0000522525*A0*A0*A0) - (0.000547752*A0*A0) + (0.00256844*A0) - 0.00327534 + // R2 = 0.99549: HP = (0.00000220778*A0*A0*A0*A0*A0) - (0.000065312*A0*A0*A0*A0) + (0.000753266*A0*A0*A0) - (0.00418112*A0*A0) + (0.0113844*A0) - 0.0112392 + // + // U35.3 off: + // R2 = 0.18174: HP = (0.000065384*A0) + 0.000468783 + // R2 = 0.83543: HP = (-0.0000468095*A0*A0) + (0.000655196*A0) - 0.000641642 + // R2 = 0.99434: HP = (-0.0000088969*A0*A0*A0) + (0.000127464*A0*A0) - (0.000276787*A0) + 0.000661774 + // R2 = 0.99978: HP = (-0.000000655767*A0*A0*A0*A0) + (0.0000088937*A0*A0*A0) - (0.0000336865*A0*A0) + (0.000281719*A0) + 0.0000419612 + // R2 = 0.99987: HP = (0.0000000525584*A0*A0*A0*A0*A0) - (0.00000241385*A0*A0*A0*A0) + (0.0000304913*A0*A0*A0) - (0.000153608*A0*A0) + (0.000579685*A0) - 0.000223579 + // + VARCLOCK(PHOTONCLK, 2, "max(0.000001,min(0.1,if(A1>2.5,(0.0000173739*A0*A0*A0) - (0.000265948*A0*A0) + (0.00163589*A0) - 0.00222259,(-0.0000088969*A0*A0*A0) + (0.000127464*A0*A0) - (0.000276787*A0) + 0.000661774)))") + NET_C(PHOTONCLK.GND, GND) + NET_C(PHOTONCLK.VCC, I_V5) + NET_C(PHOTONCLK.Q, PHOTONENV.A0) + NET_C(PHOTONCLK.A0, U36.6) + NET_C(PHOTONCLK.A1, U35.3) + AFUNC(PHOTONENV, 1, "if(A0>2.5,0.0038,-0.0038)") + NET_C(PHOTONENV.Q, U41.2) + NET_C(GND, U40.2, U40.3, R65.2, R66.1, R66.2, R69.2, R70.1, R70.2, R71.2, R72.1, R72.2, R73.2, D5.A, D5.K, D6.A, D6.K) +#else + NET_C(R65.2, U40.3, R70.1, R69.2) + NET_C(U40.2, GND, D5.A) + NET_C(D5.K, D6.K) + NET_C(D6.A, R71.2, R72.2, R66.2) + NET_C(U40.6, R66.1, R70.2) + NET_C(R72.1, R73.2, U41.2) +#endif + + NET_C(R73.1, GND) + NET_C(U41.3, R74.2) + NET_C(R74.1, GND) + NET_C(VN, R67.1) + NET_C(R67.2, U39.3, R68.1) + NET_C(R68.2, U39.6, R69.1) + + NET_C(PHOTON_M, R75.1, R76.1) + NET_C(R75.2, I_V5, R77.2, Q9.E) + NET_C(R76.2, R77.1, Q9.B) + NET_C(Q9.C, R78.2, R79.2, Q10.E) + NET_C(R78.1, I_VM15) + NET_C(R79.1, GND) + NET_C(Q10.B, R80.2) + NET_C(R80.1, GND) + NET_C(Q10.C, C17.1, R81.1) + NET_C(C17.2, I_VM15) + NET_C(R81.2, U41.5) + + NET_C(U41.6, CS, R149.2, U49.3) + NET_C(R149.1, GND) + NET_C(U49.2, U49.6, C31.1) + NET_C(C31.2, R150.1) + NET_C(R150.2, SJ, U50.2, R151.1) + NET_C(U50.3, GND) + NET_C(R151.2, U50.6) + ALIAS(OUTPUT, R151.2) + + // + // Unconnected inputs + // + + NET_C(GND, U2.8, U2.10, U22.2, U22.3, U22.5, U22.6, U24.3, U27.8, U27.9, U27.10, U27.11) + + // + // Unconnected outputs + // + + HINT(U2.9, NC) + HINT(U2.11, NC) + HINT(U24.4, NC) + +#if (ENABLE_FRONTIERS) + // + // Isolate the NOISE consumers from one another; the first one + // in particular is a big win + // + OPTIMIZE_FRONTIER(R100.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R15.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R34.1, RES_M(1), 50) + + // + // Isolate the CS sounds from the rest of the mixer (huge!) + // + OPTIMIZE_FRONTIER(U49.3, RES_M(1), 50) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_solarq.h b/src/mame/audio/nl_solarq.h new file mode 100644 index 00000000000..2176bed0dc2 --- /dev/null +++ b/src/mame/audio/nl_solarq.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_SOLARQ_H +#define MAME_AUDIO_NL_SOLARQ_H + +#pragma once + +NETLIST_EXTERNAL(solarq) + +#endif // MAME_AUDIO_NL_SOLARQ_H diff --git a/src/mame/audio/nl_spacewar.cpp b/src/mame/audio/nl_spacewar.cpp new file mode 100644 index 00000000000..53bae689243 --- /dev/null +++ b/src/mame/audio/nl_spacewar.cpp @@ -0,0 +1,321 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Space Wars +// +// Derived from the Audio Board Schematic redrawn by William J. +// Boucher at Biltronix.com. Part numbers are not present on the +// schematic, so the equivalent part numbers were taken from the +// Barrier schematics, which are quite similar. +// +// Known problems/issues: +// +// * The core noise source is supposed to be created via a +// pair of transistors, one with an open base. Because this +// does not model correctly, this part of the circuit is +// replaced with a generic noise device. The characteristics +// of this noise are pretty different compared to recordings +// of the original, and affects all the sounds. +// +// * Poor performance when the explosion is triggered. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_spacewar.h" + + +// +// Optimizations +// + +#define HLE_NOISE_GEN (1) +#define ENABLE_FRONTIERS (1) + + +// +// Main netlist +// + +NETLIST_START(spacewar) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) +// PARAM(Solver.MIN_TS_TS, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(18)) + RES(R2, 470) + RES(R3, RES_K(47)) + RES(R4, RES_K(220)) + RES(R5, 470) + RES(R6, 150) + RES(R7, RES_K(180)) + RES(R8, RES_M(10)) + RES(R9, RES_K(39)) + RES(R10, RES_K(2.2)) + RES(R11, 470) +// RES(R12, 0) -- not present on Space Wars + RES(R13, RES_K(8.2)) + RES(R14, RES_K(120)) + RES(R15, RES_K(20)) + RES(R16, RES_M(10)) + RES(R17, RES_K(10)) + RES(R18, RES_K(47)) + RES(R19, 820) +// POT(R20, RES_K(10)) -- part of final amp (not emulated) +// RES(R21, 150) -- part of final amp (not emulated), not present on Space Wars +// RES(R22, 2.7) -- part of final amp (not emulated), not present on Space Wars +// RES(R23, 2.7) -- part of final amp (not emulated), not present on Space Wars + RES(R24, RES_K(47)) + RES(R25, 150) + RES(R26, RES_K(160)) + RES(R27, 750) +// RES(R28, RES_K(68)) -- part of final amp (not emulated), illegible on Space Wars +// POT(R29, RES_K(10)) -- part of final amp (not emulated) +// RES(R30, 750) -- part of final amp (not emulated) + RES(R31, 470) + RES(R32, RES_K(1)) + RES(R33, RES_K(39)) + RES(R34, RES_K(6.8)) + RES(R35, RES_K(560)) + RES(R36, RES_M(1)) + RES(R37, RES_K(10)) + RES(R38, RES_K(10)) +// RES(R39, RES_K(120)) + RES(R40, RES_K(120)) + RES(R41, RES_K(20)) + RES(R42, RES_K(1)) + RES(R43, RES_K(10)) + + CAP(C1, CAP_U(1)) + CAP(C2, CAP_U(1)) + CAP(C3, CAP_U(0.01)) + CAP(C4, CAP_U(0.01)) + CAP(C5, CAP_U(0.1)) +// CAP(C6, CAP_U(4.7)) // not needed +// CAP(C7, 0) // not present + CAP(C8, CAP_U(1)) + CAP(C9, CAP_U(0.1)) + CAP(C10, CAP_P(220)) + CAP(C11, CAP_U(0.1)) +// CAP(C12, CAP_U(0.01)) -- part of final amp (not emulated) +// CAP(C13, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C14, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C15, CAP_U(50)) -- not needed +// CAP(C16, CAP_U(2.2)) -- not needed + CAP(C17, CAP_U(0.01)) + CAP(C18, CAP_U(33)) +// CAP(C19, CAP_U(50)) -- not needed +// CAP(C20, CAP_U(2.2)) -- not needed + CAP(C21, CAP_U(0.02)) + CAP(C22, CAP_U(0.1)) + CAP(C23, CAP_U(0.1)) + CAP(C24, CAP_U(2.2)) + + D_1N914(CR1) + D_1N914(CR2) + D_1N914(CR3) + D_1N914(CR4) + D_1N914(CR5) + D_1N914(CR6) + + Q_2N3906(Q1) // PNP + Q_2N3904(Q2) // NPN + Q_2N6426(Q3) // NPN Darlington + Q_2N6292(Q4) // NPN + Q_2N6107(Q5) // PNP + Q_2N6426(Q6) // NPN Darlington + Q_2N3904(Q7) // NPN + + TL081_DIP(U1) // Op. Amp. + NET_C(U1.4, I_VM15) + NET_C(U1.7, I_V15) + + TTL_7406_DIP(U2) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(U2.7, GND) + NET_C(U2.14, I_V5) + + TL081_DIP(U3) // Op. Amp. + NET_C(U3.4, I_VM15) + NET_C(U3.7, I_V15) + +// TTL_7815_DIP(U4) // +15V Regulator -- not needed + + TL182_DIP(U5) // Analog switch + NET_C(U5.6, I_V15) + NET_C(U5.7, I_V5) + NET_C(U5.8, GND) + NET_C(U5.9, I_VM15) + +// TL081_DIP(U6) // Op. Amp. -- part of final amp (not emulated) +// NET_C(U6.4, I_VM15) +// NET_C(U6.7, I_V15) + +// TTL_7915_DIP(U7) // -15V Regulator -- not needed + + TL081_DIP(U8) // Op. Amp. + NET_C(U8.4, I_VM15) + NET_C(U8.7, I_V15) + + TL081_DIP(U9) // Op. Amp. + NET_C(U9.4, I_VM15) + NET_C(U9.7, I_V15) + + TL182_DIP(U10) // Analog switch + NET_C(U10.6, I_V15) + NET_C(U10.7, I_V5) + NET_C(U10.8, GND) + NET_C(U10.9, I_VM15) + + // + // Top-left until output from U1 + // + +#if (HLE_NOISE_GEN) + CLOCK(NOISE_CLOCK, 2000) + NET_C(NOISE_CLOCK.GND, GND) + NET_C(NOISE_CLOCK.VCC, I_V5) + + SYS_NOISE_MT_U(NOISE, 3) + NET_C(NOISE.I, NOISE_CLOCK.Q) + NET_C(NOISE.1, GND) + NET_C(NOISE.2, C1.1) + + NET_C(GND, R1.1, R1.2, R2.1, R2.2, CR1.A, CR1.K, CR2.A, CR2.K) +#else + NET_C(I_V15, CR1.A, R2.2) + NET_C(CR1.K, CR2.A) + NET_C(CR2.K, R1.2, Q1.B) + NET_C(R1.1, Q2.C, GND) + NET_C(R2.1, Q1.E) + NET_C(Q2.E, Q1.C, C1.1) +#endif + + NET_C(C1.2, R3.2, U1.3) + NET_C(R3.1, GND, R5.1) + NET_C(U1.2, R5.2, R4.1) + NET_C(R4.2, U1.6) + + // + // Top-middle, from O1 until output from CR3 + // + + NET_C(I_OUT_1, U2.13) + NET_C(U2.12, R6.1) + NET_C(R6.2, R7.1, C2.1, Q3.B) + NET_C(R7.2, I_V5, Q3.C) + NET_C(C2.2, GND) + NET_C(Q3.E, R11.2) + NET_C(R11.1, CR3.A) + + // + // Middle chunk, from C3 until output from R13 + // + + NET_C(U1.6, C3.1) + NET_C(C3.2, R8.1, U3.2) + NET_C(U3.3, GND) + NET_C(R8.2, U3.6, R9.1) + NET_C(R9.2, CR3.K, C4.1, CR4.A, R10.2) + NET_C(R10.1, CR4.K, GND, C5.1) + NET_C(C4.2, C5.2, R13.1) + + // + // Big middle section, from C8 until output from R15/R41/R37 + // + + NET_C(U1.6, C8.1) + NET_C(C8.2, C24.2) + NET_C(C24.1, R24.1) + NET_C(R24.2, U8.2, C10.1, R16.1) + NET_C(U8.3, GND) + NET_C(U8.6, R16.2, C10.2, R31.2, R38.2) + NET_C(R38.1, U5.14, U5.1) + NET_C(I_OUT_2, U5.10) + NET_C(U5.13, R14.1) + NET_C(I_OUT_3, U5.5) + NET_C(U5.2, R40.1) + NET_C(R40.2, C23.2, R41.1) + NET_C(R41.2, R13.2) + NET_C(C23.1, GND) + NET_C(R37.2, R13.2) + NET_C(R14.2, C9.2, R15.1) + NET_C(C9.1, GND) + NET_C(R15.2, R13.2) + NET_C(I_OUT_0, U2.9) + NET_C(U2.8, R25.1) + NET_C(R25.2, R26.1, C17.1, Q6.B, C18.1) + NET_C(R26.2, C17.2, I_V5, Q6.C) + NET_C(C18.2, GND) + NET_C(Q6.E, R27.1) + NET_C(R27.2, CR5.A) + NET_C(CR5.K, R33.2, CR6.A, R34.2, C21.2, C22.1) + NET_C(R31.1, R32.2, R33.1, Q7.E) + NET_C(R32.1, Q7.B) + NET_C(Q7.C, CR6.K, R34.1, C21.1, GND) + NET_C(C22.2, R35.1) + NET_C(R35.2, U9.2, R36.1) + NET_C(U9.3, GND) + NET_C(U9.6, R36.2, R37.1) + + // + // Final stage + // + + NET_C(U10.1, U10.14, R13.2) + NET_C(I_OUT_4, U10.5, U2.1) + NET_C(U2.2, R42.1, U10.10) + NET_C(R42.2, I_V5) + NET_C(U10.2, R17.2, C11.1) + NET_C(U10.13, R43.2) + NET_C(R43.1, GND) + NET_C(R17.1, R18.1, GND) + NET_C(C11.2, R18.2, R19.1) + NET_C(R19.2, GND) + ALIAS(OUTPUT, R18.2) + + // + // Unconnected inputs + // + + NET_C(GND, U2.3, U2.5, U2.11) + + // + // Frontier optimizations + // + +#if (ENABLE_FRONTIERS) + // Separate each input into the summing network + OPTIMIZE_FRONTIER(R13.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R15.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R41.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R37.1, RES_M(1), 50) + + // Decouple the Darlington BJTs from the sounds they enable + OPTIMIZE_FRONTIER(R27.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R11.2, RES_M(1), 50) + + // Decouple the noise source from the downstream filters + OPTIMIZE_FRONTIER(C3.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R24.1, RES_M(1), 50) + OPTIMIZE_FRONTIER(R38.2, RES_M(1), 50) +#endif + +NETLIST_END() diff --git a/src/mame/audio/nl_spacewar.h b/src/mame/audio/nl_spacewar.h new file mode 100644 index 00000000000..0b972b2585c --- /dev/null +++ b/src/mame/audio/nl_spacewar.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_SPACEWAR_H +#define MAME_AUDIO_NL_SPACEWAR_H + +#pragma once + +NETLIST_EXTERNAL(spacewar) + +#endif // MAME_AUDIO_NL_SPACEWAR_H diff --git a/src/mame/audio/nl_speedfrk.cpp b/src/mame/audio/nl_speedfrk.cpp new file mode 100644 index 00000000000..4d14ae240d8 --- /dev/null +++ b/src/mame/audio/nl_speedfrk.cpp @@ -0,0 +1,451 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Speed Freak +// +// Derived from the utterly terrible schematics in the Speed Freak +// manual. Newly-drawn schematics are available upon request. +// +// Special thanks to: +// * Frank Palazzolo for helping to verify connections and parts +// * Brian Tarachi for supplying his corrected schematics +// +// Known problems/issues: +// +// * Works pretty well. Needs more detailed comparison with clean +// audio recordings from PCBs, but it's pretty close. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" + + +// +// Optimizations +// + +#define HLE_CLOCK_GENERATOR (1) +#define HLE_CLOCK_INPUT (1) + + +// +// Main netlist +// + +NETLIST_START(speedfrk) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 1) // active low + TTL_INPUT(I_OUT_1, 1) // active low + TTL_INPUT(I_OUT_2, 1) // active low + TTL_INPUT(I_OUT_3, 1) // active low + TTL_INPUT(I_OUT_4, 1) // active low + TTL_INPUT(I_OUT_7, 1) // active low + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + +// RES(R1, 2.7) +// RES(R2, 2.7) +// RES(R3, 2.7) +// RES(R4, 2.7) +// RES(R5, 150) // PCB verified +// RES(R6, 150) +// RES(R7, RES_K(10)) // PCB verified +// RES(R8, RES_K(68)) // PCB verified +// RES(R9, RES_K(2.2)) // PCB verified +// RES(R10, 820) // PCB verified +// RES(R11, RES_K(47)) // PCB verified +// RES(R12, RES_K(1)) ?? + RES(R13, 150) + RES(R14, RES_K(2.2)) // PCB verified + RES(R15, RES_K(10)) // PCB verified + RES(R16, RES_K(2.2)) // PCB verified + RES(R17, RES_K(1)) // PCB verified + RES(R18, RES_K(8.2)) // PCB verified + RES(R19, RES_K(3.9)) // PCB verified + RES(R20, RES_K(4.7)) // PCB verified + RES(R21, RES_K(3.3)) // PCB verified + RES(R22, RES_K(10)) // PCB verified + RES(R23, RES_K(4.7)) // PCB verified + RES(R24, RES_K(10)) + RES(R25, RES_K(18)) // PCB verified + RES(R26, RES_K(18)) // PCB verified + RES(R27, RES_K(6.8)) // PCB verified + RES(R28, RES_K(10)) // PCB verified + RES(R29, RES_K(2.2)) // PCB verified + RES(R30, 330) // PCB verified + RES(R31, 330) // PCB verified + RES(R32, RES_K(1)) // PCB verified + RES(R33, RES_K(1)) // PCB verified + RES(R34, RES_K(1)) // PCB verified +// RES(R35, 0) // PCB verified: not populated + RES(R36, RES_K(1)) // PCB verified + RES(R37, RES_K(1)) // PCB verified + RES(R38, RES_K(1)) // PCB verified + RES(R39, RES_K(1)) // PCB verified + RES(R40, RES_K(1)) // PCB verified + RES(R41, RES_K(1)) // PCB verified + RES(R42, RES_K(1)) // PCB verified + RES(R43, RES_K(1)) // PCB verified + RES(R44, RES_K(30)) // PCB verified + RES(R45, RES_K(4.7)) // PCB verified + RES(R46, RES_K(10)) // PCB verified + +// CAP(C4, CAP_U(4.7)) +// CAP(C5, CAP_U(4.7)) + CAP(C12, CAP_U(0.001)) + CAP(C13, CAP_U(0.001)) + CAP(C17, CAP_U(0.02)) + CAP(C20, CAP_U(0.1)) + CAP(C23, CAP_U(0.1)) + +// CAP(C1, CAP_U(50)) +// CAP(C2, CAP_U(50)) +// CAP(C3, CAP_U(4.7)) +// CAP(C6, CAP_U(0.002)) +// CAP(C7, CAP_U(0.002)) +// CAP(C8, CAP_U(0.01)) +// CAP(C9, CAP_U(0.1)) +// CAP(C10, CAP_U(0.1)) +// CAP(C11, CAP_U(0.02)) + +// D_1N914B(CR1) // OK +// D_1N914B(CR2) // OK + D_1N914B(CR3) // OK + +// Q_2N6292(Q1) // NPN +// Q_2N6107(Q2) // PNP + Q_2N3904(Q3) // NPN +// Q_2N3904(Q3) // NPN -- unknown type + + TTL_74LS04_DIP(U2) // Hex Inverting Gates + NET_C(U2.7, GND) + NET_C(U2.14, I_V5) + + TL081_DIP(U3) // Op. Amp. + NET_C(U3.4, GND) + NET_C(U3.7, I_V5) + + TTL_74LS163_DIP(U4) // Synchronous 4-Bit Counters + NET_C(U4.8, GND) + NET_C(U4.16, I_V5) + + TTL_74LS107_DIP(U5) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U5.7, GND) + NET_C(U5.14, I_V5) + + TTL_74LS08_DIP(U6) // Quad 2-Input AND Gates + NET_C(U6.7, GND) + NET_C(U6.14, I_V5) + + TTL_74LS163_DIP(U7) // Synchronous 4-Bit Counters + NET_C(U7.8, GND) + NET_C(U7.16, I_V5) + + TTL_74LS163_DIP(U8) // Synchronous 4-Bit Counters + NET_C(U8.8, GND) + NET_C(U8.16, I_V5) + + TTL_74LS163_DIP(U9) // Synchronous 4-Bit Counters + NET_C(U9.8, GND) + NET_C(U9.16, I_V5) + +// TTL_7915_DIP(U8) // -15V Regulator -- not needed +// TTL_7815_DIP(U9) // +15V Regulator -- not needed + + TTL_74LS04_DIP(U10) // Hex Inverting Gates + NET_C(U10.7, GND) + NET_C(U10.14, I_V5) + + TTL_74LS08_DIP(U11) // Quad 2-Input AND Gates + NET_C(U11.7, GND) + NET_C(U11.14, I_V5) + + TTL_74LS75_DIP(U12) // 4-Bit Bistable Latches with Complementary Outputs + NET_C(U12.12, GND) + NET_C(U12.5, I_V5) + + TTL_74LS164_DIP(U13) // 8-bit parallel-out serial shift registers + NET_C(U13.7, GND) + NET_C(U13.14, I_V5) + + TTL_74LS164_DIP(U14) // 8-bit parallel-out serial shift registers + NET_C(U14.7, GND) + NET_C(U14.14, I_V5) + + TTL_74LS163_DIP(U15) // Synchronous 4-Bit Counters + NET_C(U15.8, GND) + NET_C(U15.16, I_V5) + + TTL_74LS107_DIP(U17) // DUAL J-K FLIP-FLOPS WITH CLEAR + NET_C(U17.7, GND) + NET_C(U17.14, I_V5) + + TTL_74LS393_DIP(U18) // Dual 4-Stage Binary Counter + NET_C(U18.7, GND) + NET_C(U18.14, I_V5) + + TTL_74LS86_DIP(U19) // Quad 2-Input XOR Gates + NET_C(U19.7, GND) + NET_C(U19.14, I_V5) + + TTL_74LS164_DIP(U20) // 8-bit parallel-out serial shift registers + NET_C(U20.7, GND) + NET_C(U20.14, I_V5) + + LM555_DIP(U22) // 5-5-5 Timer + + TTL_74LS163_DIP(U23) // Dual 4-Stage Binary Counter + NET_C(U23.8, GND) + NET_C(U23.16, I_V5) + + TTL_74LS164_DIP(U24) // 8-bit parallel-out serial shift registers + NET_C(U24.7, GND) + NET_C(U24.14, I_V5) + + // + // 76kHz coming from the logic PCB + // + CLOCK(J4_2, 76000) + NET_C(J4_2.GND, GND) + NET_C(J4_2.VCC, I_V5) + +#if (HLE_CLOCK_GENERATOR) + // + // Skip the clock generator and just do it directly + // + CLOCK(C2MHZ, 2000000) + NET_C(C2MHZ.GND, GND) + NET_C(C2MHZ.VCC, I_V5) + NET_C(GND, R30.1, R30.2, R31.1, R31.2, C12.1, C12.2, C13.1, C13.2, U10.1, U10.3, U10.5) +#else + NET_C(R30.1, U10.1, C13.1) + NET_C(R30.2, U10.2, C12.1) + NET_C(C12.2, U10.3, R31.1) + NET_C(R31.2, U10.4, C13.2, U10.5) + ALIAS(C2MHZ, U10.6) +#endif + +#if (HLE_CLOCK_INPUT) + // + // The clock input from the main PCB is run through a voltage + // converter which eats a lot of time and is unnecessary since + // we're just generating a TTL signal already. + // + NET_C(J4_2.Q, U5.12) + NET_C(GND, R27.1, R27.2, R28.1, R28.2, R29.1, R29.2, CR3.A, CR3.K, U3.2, U3.3) +#else + NET_C(J4_2.Q, U3.3) + NET_C(R27.1, GND) + NET_C(R27.2, U3.2, R28.1) + NET_C(R28.2, I_V5) + NET_C(U3.6, R29.1) + NET_C(R29.2, CR3.K, U5.12) +#endif + + NET_C(CR3.A, GND) + NET_C(U5.1, R41.1) + NET_C(R41.2, I_V5) + NET_C(U5.4, GND) + NET_C(U5.13, U5.10, U10.9, U4.15) + NET_C(U5.3, U5.8) + NET_C(U5.2, U5.11) + NET_C(U5.6, U4.9) + NET_C(U5.9, U4.2, C2MHZ.Q) + + NET_C(U10.8, U4.7) + NET_C(U4.3, U4.1, I_V5) + NET_C(U4.6, R36.1) + NET_C(U4.4, U4.5, GND) + NET_C(U4.14, U18.1, U6.13, U7.2) + NET_C(U4.10, I_V5) // need to verify + + NET_C(U18.6, U18.13) + NET_C(U18.2, U18.12, GND) + NET_C(U18.8, U17.12) + NET_C(U18.10, U20.8, U24.8) + NET_C(U18.11, U23.2) + + NET_C(I_OUT_0, U2.13) + NET_C(U2.12, U2.1) + ALIAS(STEERING, U2.12) + NET_C(U2.2, U6.4) + NET_C(U6.6, U19.13, U19.5) + NET_C(U19.12, R39.1) + NET_C(R39.2, I_V5) + + NET_C(I_OUT_1, U6.9) + NET_C(U6.10, R32.2) + NET_C(R32.1, I_V5) + NET_C(U6.8, U2.5, U6.12, U12.4, U12.13) + NET_C(U2.6, R14.2, U6.5) + NET_C(R14.1, Q3.B) + NET_C(Q3.E, GND) + NET_C(Q3.C, R13.1) + NET_C(R13.2, GND) + ALIAS(LAMP, R13.2) + + NET_C(U19.11, U20.1) + NET_C(U20.9, R42.1) +// NET_C(R42.2, I_V5) + NET_C(U20.2, U19.3) + NET_C(U20.12, U19.1) + NET_C(U20.13, U19.4) + + NET_C(U19.6, U24.1, U24.2) + NET_C(U24.12, U19.2) + NET_C(U24.9, R43.1) + NET_C(R43.2, I_V5) + NET_C(U24.13, R44.1, U11.12, U11.9, U11.5, U11.2) + + NET_C(U23.1, U23.3, U23.5, U23.7, R40.2) + NET_C(U23.10, R40.2) // need to verify + NET_C(R40.1, I_V5) + NET_C(U23.4, U23.6, GND) + NET_C(U23.9, U19.8, U17.9) + NET_C(U23.15, U19.10) + NET_C(U19.9, R39.1) + + NET_C(I_OUT_7, U2.9) + NET_C(U2.8, U17.10, U17.13) + NET_C(U17.8, U17.11, U17.1, U17.4, R34.1) + NET_C(R34.2, I_V5) + NET_C(U17.5, R25.1) + NET_C(U17.3, R26.1) + + NET_C(R44.2, U22.7, R45.1, R46.2) + NET_C(R45.2, U22.4, U22.8, I_V5) + NET_C(R46.1, U22.6, U22.2, C23.2) + NET_C(C23.1, GND) + NET_C(U22.1, GND) + NET_C(U22.5, C17.2) + NET_C(C17.1, GND) + + NET_C(I_OUT_4, U6.2) + NET_C(U22.3, U6.1) + NET_C(U6.3, R15.1) + + NET_C(U6.11, U15.2, U9.2, U8.2) + NET_C(U15.1, U15.7, R42.1) + NET_C(R42.2, I_V5) + NET_C(U9.1, U9.7, U8.1, U8.7, R37.1) + NET_C(R37.2, I_V5) + NET_C(U15.15, U10.11, U7.10) + NET_C(U15.6, U14.3) + NET_C(U15.5, U14.4) + NET_C(U15.4, U14.5) + NET_C(U15.3, U14.6) + NET_C(U15.10, U9.15) + NET_C(U15.9, U9.9, U8.9, U10.10) + + NET_C(U9.6, U14.10) + NET_C(U9.5, U14.11) + NET_C(U9.4, U14.12) + NET_C(U9.3, U14.13, U13.1, U13.2) + NET_C(U9.10, U8.15) + + NET_C(U8.6, U13.3) + NET_C(U8.5, U13.4) + NET_C(U8.4, U13.5) + NET_C(U8.3, U13.6) + NET_C(U8.10, R36.1) + NET_C(R36.2, I_V5) + + NET_C(I_OUT_2, U2.11) + NET_C(I_OUT_3, U2.3) + NET_C(U2.10, U14.1, U14.2) + NET_C(U2.4, U14.8, U13.8) + NET_C(U14.9, U13.9, R38.1) + NET_C(R38.2, I_V5) + + NET_C(U12.9, U11.13) + NET_C(U12.10, U11.10) + NET_C(U12.15, U11.4) + NET_C(U12.16, U11.1) + NET_C(U12.7, U13.10) + NET_C(U12.6, U13.11) + NET_C(U12.3, U13.12) + NET_C(U12.2, U13.13) + + NET_C(U11.11, R17.1) + NET_C(U11.8, R16.1) + NET_C(U11.6, R19.1) + NET_C(U11.3, R18.1) + NET_C(R17.2, R16.2, R19.2, R18.2, R20.1) + + NET_C(U7.1, U7.5, R33.2) + NET_C(R33.1, I_V5) + NET_C(U7.7, STEERING) + NET_C(U7.9, U10.12) + NET_C(U7.15, U10.13) + NET_C(U7.3, U7.4, U7.6, GND) + NET_C(U7.11, R22.1) + NET_C(U7.12, R23.1) + NET_C(U7.13, R24.1) + NET_C(R22.2, R23.2, R24.2, C20.2, R21.1) + NET_C(C20.1, GND) + + NET_C(R15.2, R25.2, R26.2, R21.2, R20.2) + ALIAS(OUTPUT, R20.2) + + // + // Unconnected outputs + // + + HINT(U4.11, NC) // Q3 + HINT(U4.12, NC) // Q2 + HINT(U4.13, NC) // Q1 + HINT(U5.5, NC) // Q2 + HINT(U7.14, NC) // Q0 + HINT(U8.11, NC) // Q3 + HINT(U8.12, NC) // Q2 + HINT(U8.13, NC) // Q1 + HINT(U8.14, NC) // Q0 + HINT(U9.11, NC) // Q3 + HINT(U9.12, NC) // Q2 + HINT(U9.13, NC) // Q1 + HINT(U9.14, NC) // Q0 + HINT(U10.2, NC) // QQ1 -- part of 2MHz clock gen + HINT(U10.4, NC) // QQ2 -- part of 2MHz clock gen + HINT(U10.6, NC) // QQ3 -- part of 2MHz clock gen + HINT(U12.1, NC) // QQ0 + HINT(U12.8, NC) // QQ3 + HINT(U12.11, NC) // QQ2 + HINT(U12.14, NC) // QQ1 + HINT(U15.11, NC) // Q3 + HINT(U15.12, NC) // Q2 + HINT(U15.13, NC) // Q1 + HINT(U15.14, NC) // Q0 + HINT(U17.2, NC) // QQ1 + HINT(U17.6, NC) // QQ2 + HINT(U18.3, NC) // Q0 + HINT(U18.4, NC) // Q1 + HINT(U18.5, NC) // Q2 + HINT(U18.9, NC) // Q2 + HINT(U20.3, NC) // Q0 + HINT(U20.4, NC) // Q1 + HINT(U20.5, NC) // Q2 + HINT(U20.6, NC) // Q3 + HINT(U20.10, NC) // Q4 + HINT(U20.11, NC) // Q5 + HINT(U23.11, NC) // Q3 + HINT(U23.12, NC) // Q2 + HINT(U23.13, NC) // Q1 + HINT(U23.14, NC) // Q0 + HINT(U24.3, NC) // Q0 + HINT(U24.4, NC) // Q1 + HINT(U24.5, NC) // Q2 + HINT(U24.6, NC) // Q3 + HINT(U24.10, NC) // Q4 + HINT(U24.11, NC) // Q5 + +NETLIST_END() diff --git a/src/mame/audio/nl_speedfrk.h b/src/mame/audio/nl_speedfrk.h new file mode 100644 index 00000000000..7d32b702ad5 --- /dev/null +++ b/src/mame/audio/nl_speedfrk.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_SPEEDFRK_H +#define MAME_AUDIO_NL_SPEEDFRK_H + +#pragma once + +NETLIST_EXTERNAL(speedfrk) + +#endif // MAME_AUDIO_NL_SPEEDFRK_H diff --git a/src/mame/audio/nl_starcas.cpp b/src/mame/audio/nl_starcas.cpp new file mode 100644 index 00000000000..bc3ea5ff26c --- /dev/null +++ b/src/mame/audio/nl_starcas.cpp @@ -0,0 +1,809 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +//NL_CONTAINS starcas wotw + +// +// Netlist for Star Castle/War of the Worlds +// +// Derived from the schematics and parts list in the Star Castle +// manual. +// +// War of the Worlds uses effectively the same sound board, but +// with a swizzled set of inputs. +// +// Special thanks to: +// * Frank Palazzolo for creating a schematic of the War of the +// Worlds signal mapping +// +// Known problems/issues: +// +// * The VCOs require high solver frequencies (100x+) to reach the +// correct pitches. For this reason, HLE'ed versions are +// provided that work correctly even at 48kHz. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_starcas.h" + + +// +// Optimizations +// + +#define HLE_BACKGROUND_VCO (1) +#define HLE_LASER_VCO (1) +#define ENABLE_FRONTIERS (1) + + +// +// Initial compilation includes this section. +// + +#ifndef SOUND_VARIANT + + +// +// Now include ourselves twice, once for Star Castle and +// once for War of the Worlds +// + +#define VARIANT_STARCASTLE 0 +#define VARIANT_WOTW 1 + +#define SOUND_VARIANT (VARIANT_STARCASTLE) +#include "nl_starcas.cpp" + +#undef SOUND_VARIANT +#define SOUND_VARIANT (VARIANT_WOTW) +#include "nl_starcas.cpp" + + +#else + + +// +// Main netlist +// + +#if (SOUND_VARIANT == VARIANT_STARCASTLE) +NETLIST_START(starcas) +#else // (SOUND_VARIANT == VARIANT_WOTW) +NETLIST_START(wotw) +#endif + + // 192k is not high enough to make the laser and background pitches high enough +#if (HLE_BACKGROUND_VCO && HLE_LASER_VCO) + SOLVER(Solver, 1000) +#else + SOLVER(Solver, 4800000) +#endif + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active low + TTL_INPUT(I_OUT_1, 1) // active low + TTL_INPUT(I_OUT_2, 1) // active low + TTL_INPUT(I_OUT_3, 1) // active low + TTL_INPUT(I_OUT_4, 0) // active low + TTL_INPUT(I_OUT_7, 0) // active low + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(1)) + RES(R2, 160) + RES(R3, RES_K(1)) + RES(R4, RES_K(1)) + RES(R5, RES_K(2)) + RES(R6, RES_K(2)) + RES(R7, RES_K(4.7)) + RES(R8, RES_K(3.3)) + RES(R9, 820) + RES(R10, RES_M(3.3)) + RES(R11, RES_M(3.3)) + RES(R12, RES_M(5.1)) + RES(R13, RES_M(1.6)) + RES(R14, RES_K(2)) + RES(R15, RES_K(18)) + RES(R16, RES_K(10)) + RES(R17, RES_K(10)) + RES(R18, RES_K(91)) + RES(R19, RES_K(10)) + RES(R20, RES_K(1)) + RES(R21, RES_K(2)) + RES(R22, RES_K(1)) + RES(R24, RES_K(200)) + RES(R25, RES_K(30)) + RES(R26, RES_K(200)) + RES(R27, RES_K(51)) + RES(R28, RES_M(1)) + RES(R29, 430) + RES(R30, 560) + RES(R31, RES_K(3.3)) + RES(R32, RES_K(2)) + RES(R33, RES_K(130)) + RES(R34, RES_K(4.7)) + RES(R35, RES_K(2.7)) + RES(R36, RES_K(1)) + RES(R37, RES_K(39)) + RES(R38, RES_K(12)) + RES(R39, RES_K(51)) + RES(R40, RES_K(2.4)) + RES(R41, RES_K(270)) + RES(R42, RES_M(1)) + RES(R43, RES_K(4.3)) + RES(R44, RES_K(10)) + RES(R45, RES_K(1)) + RES(R46, RES_K(2)) + RES(R47, RES_K(82)) + RES(R48, RES_K(39)) + RES(R49, RES_K(20)) + RES(R50, RES_K(1)) + RES(R51, RES_K(12)) + RES(R52, RES_K(4.7)) + RES(R53, RES_K(1)) + RES(R54, RES_K(39)) + RES(R55, RES_K(12)) + RES(R56, RES_K(1)) + RES(R57, RES_K(100)) + RES(R58, RES_K(18)) + RES(R59, RES_K(15)) + RES(R60, RES_K(7.5)) + RES(R61, 430) + RES(R62, 430) + RES(R63, RES_K(4.7)) + RES(R64, RES_K(1)) + RES(R65, RES_K(39)) + RES(R66, RES_K(12)) + RES(R67, RES_K(1)) + RES(R68, RES_K(100)) + RES(R69, RES_K(6.8)) + RES(R70, RES_K(18)) + RES(R71, RES_K(47)) + RES(R72, 390) + RES(R73, 390) + RES(R74, RES_K(4.7)) + RES(R75, RES_K(2.7)) + RES(R76, RES_K(4.7)) + RES(R77, RES_K(39)) + RES(R78, RES_K(12)) + RES(R79, RES_K(1)) + RES(R80, RES_K(200)) + RES(R81, RES_K(300)) + RES(R82, RES_K(240)) + RES(R83, 200) + RES(R84, 200) + RES(R85, RES_K(4.7)) + RES(R86, RES_K(2.7)) + RES(R87, RES_K(4.7)) + RES(R88, RES_K(1)) + RES(R89, RES_K(1.8)) + RES(R90, RES_K(3.9)) + RES(R91, RES_K(39)) + RES(R92, RES_K(12)) + RES(R93, 620) + RES(R94, RES_K(360)) + RES(R95, RES_K(27)) + RES(R96, RES_K(33)) + RES(R97, 47) + RES(R98, 47) + RES(R99, RES_K(4.7)) + RES(R100, RES_K(2.7)) + RES(R101, RES_K(4.7)) + RES(R102, RES_K(39)) + RES(R103, RES_K(12)) + RES(R104, RES_K(1)) + RES(R105, RES_K(36)) + RES(R106, RES_K(36)) + RES(R107, RES_K(8.2)) + RES(R108, RES_K(47)) + RES(R109, RES_K(22)) + RES(R110, RES_K(1)) + RES(R111, RES_K(1)) + RES(R112, RES_K(10)) + RES(R113, RES_K(160)) + RES(R114, RES_K(39)) + RES(R115, RES_K(47)) + RES(R116, RES_K(3.9)) + RES(R117, RES_K(5.1)) + RES(R118, RES_K(820)) + RES(R119, RES_K(100)) +// RES(R120, RES_K(390)) -- part of final amp (not emulated) +// RES(R121, RES_K(15)) -- part of final amp (not emulated) +// RES(R122, 150) -- part of final amp (not emulated) +// RES(R123, RES_K(22)) -- part of final amp (not emulated) +// RES(R124, 150) -- part of final amp (not emulated) + RES(R125, RES_K(8.2)) + RES(R126, RES_K(20)) + RES(R127, RES_K(30)) + POT(R128, RES_K(10)) + PARAM(R128.DIAL, 0.500000) + +// CAP(C2, CAP_U(25)) // electrolytic +// CAP(C4, CAP_U(25)) // electrolytic +// CAP(C5, CAP_U(25)) // electrolytic +// CAP(C7, CAP_U(25)) // electrolytic +// CAP(C9, CAP_U(25)) // electrolytic + CAP(C11, CAP_U(0.68)) // film + CAP(C12, CAP_U(0.001)) // disk + CAP(C13, CAP_U(0.0022)) // film + CAP(C14, CAP_U(0.1)) // film + CAP(C15, CAP_U(0.1)) // film + CAP(C16, CAP_U(0.1)) // disk* + CAP(C17, CAP_U(100)) // electrolytic + CAP(C18, CAP_U(0.1)) // film + CAP(C19, CAP_U(0.1)) // disk* + CAP(C20, CAP_U(0.1)) // film + CAP(C21, CAP_U(0.01)) // disk + CAP(C22, CAP_U(0.68)) // film + CAP(C23, CAP_U(0.001)) // disk + CAP(C24, CAP_U(0.0047)) // film + CAP(C25, CAP_U(0.1)) // film + CAP(C26, CAP_U(0.1)) // film + CAP(C27, CAP_U(2.2)) // electrolytic + CAP(C28, CAP_U(0.22)) // film + CAP(C29, CAP_U(0.1)) // film + CAP(C30, CAP_U(4.7)) // electrolytic + CAP(C31, CAP_U(0.1)) // film + CAP(C32, CAP_U(0.01)) // film + CAP(C33, CAP_U(0.68)) // film + CAP(C34, CAP_U(3.3)) // electrolytic + CAP(C35, CAP_U(0.22)) // film + CAP(C36, CAP_U(0.33)) // film + CAP(C37, CAP_U(0.47)) // film + CAP(C38, CAP_U(0.01)) // disk + CAP(C39, CAP_U(0.68)) // film + CAP(C40, CAP_U(0.1)) // film + CAP(C41, CAP_U(0.01)) // disk + CAP(C42, CAP_U(0.1)) // film +// CAP(C43, CAP_U(0.68)) // film -- part of final amp (not emulated) +// CAP(C44, CAP_P(470)) // disk -- part of final amp (not emulated) +// CAP(C45, CAP_P(470)) // disk -- part of final amp (not emulated) +// CAP(C46, CAP_P(470)) // disk -- part of final amp (not emulated) +// CAP(C47, CAP_U(0.005)) // disk -- part of final amp (not emulated) + CAP(C48, CAP_U(0.33)) // film + +// D_1N4003(D1) // not needed +// D_1N4003(D2) // not needed +// D_1N4003(D3) // not needed +// D_1N4003(D4) // not needed + D_1N5240B(D5) + D_1N5236B(D6) + D_1N914B(D7) + D_1N914B(D8) + D_1N914B(D9) + D_1N914B(D10) + + Q_2N3904(Q1) // NPN + Q_2N3904(Q2) // NPN + Q_2N3906(Q3) // PNP + Q_2N3904(Q4) // NPN + Q_2N3904(Q5) // NPN + Q_2N3906(Q6) // PNP + Q_2N3906(Q7) // PNP + Q_2N3906(Q8) // PNP + Q_2N3906(Q9) // PNP + Q_2N3906(Q10) // PNP + Q_2N3906(Q11) // PNP + Q_2N3906(Q12) // PNP + Q_2N3906(Q13) // PNP + Q_2N3906(Q14) // PNP + Q_2N3906(Q15) // PNP + Q_2N3906(Q16) // PNP +// Q_2N6107(Q17) // PNP -- part of final amp (not emulated) +// Q_2N6292(Q18) // NPN -- part of final amp (not emulated) + + TTL_7414_DIP(IC1) // Hex Inverter + NET_C(IC1.7, GND) + NET_C(IC1.14, I_V5) + + TTL_74LS164_DIP(IC2) // 8-bit Shift Reg. + NET_C(IC2.7, GND) + NET_C(IC2.14, I_V5) + + TTL_74LS377_DIP(IC3) // Octal D Flip Flop + NET_C(IC3.10, GND) + NET_C(IC3.20, I_V5) + +// TTL_7815_DIP(IC4) // +15V Regulator -- not needed +// TTL_7915_DIP(IC5) // -15V Regulator -- not needed + + TTL_7406_DIP(IC6) // Hex Inverter -- currently using a clone of 7416, no open collector behavior + NET_C(IC6.7, GND) + NET_C(IC6.14, I_V5) + + TL081_DIP(IC7) // Op. Amp. + NET_C(IC7.7, I_V15) + NET_C(IC7.4, I_VM15) + + TL081_DIP(IC8) // Op. Amp. + NET_C(IC8.7, I_V15) + NET_C(IC8.4, I_VM15) + +#if (!HLE_BACKGROUND_VCO) + LM566_DIP(IC9) // 566 VCO +#endif + + TTL_74LS163_DIP(IC10) // Binary Counter (schems say can sub a 74161) + NET_C(IC10.8, GND) + NET_C(IC10.16, I_V5) + + TTL_74LS163_DIP(IC11) // Binary Counter (schems say can sub a 74161) + NET_C(IC11.8, GND) + NET_C(IC11.16, I_V5) + + TTL_74LS393_DIP(IC12) // Dual 4 Bit B.C. + NET_C(IC12.7, GND) + NET_C(IC12.14, I_V5) + + TTL_74LS393_DIP(IC13) // Dual 4 Bit B.C. + NET_C(IC13.7, GND) + NET_C(IC13.14, I_V5) + + AMI_S2688(IC14) // Noise generator + + TL081_DIP(IC15) // Op. Amp. + NET_C(IC15.7, I_V15) + NET_C(IC15.4, I_VM15) + + LM555_DIP(IC16) // Timer + +#if (!HLE_LASER_VCO) + LM566_DIP(IC17) // 566 VCO +#endif + + CA3080_DIP(IC18) // Trnscndt. Op. Amp. + NET_C(IC18.7, I_V15) + NET_C(IC18.4, I_VM15) + + CA3080_DIP(IC19) // Trnscndt. Op. Amp. + NET_C(IC19.7, I_V15) + NET_C(IC19.4, I_VM15) + + CA3080_DIP(IC20) // Trnscndt. Op. Amp. + NET_C(IC20.7, I_V15) + NET_C(IC20.4, I_VM15) + + CA3080_DIP(IC21) // Trnscndt. Op. Amp. + NET_C(IC21.7, I_V15) + NET_C(IC21.4, I_VM15) + + CA3080_DIP(IC22) // Trnscndt. Op. Amp. + NET_C(IC22.7, I_V15) + NET_C(IC22.4, I_VM15) + + LM555_DIP(IC23) // Timer + + LM555_DIP(IC24) // Timer + +// TL081_DIP(IC25) // Op. Amp. -- part of final amp (not emulated) +// NET_C(IC25.7, I_V15) +// NET_C(IC25.4, I_VM15) + + TL081_DIP(IC26) // Op. Amp. + NET_C(IC26.7, I_V15) + NET_C(IC26.4, I_VM15) + + TL081_DIP(IC27) // Op. Amp. + NET_C(IC27.7, I_V15) + NET_C(IC27.4, I_VM15) + + TTL_74LS107_DIP(IC28) // Dual J-K Flip Flop + NET_C(IC28.7, GND) + NET_C(IC28.14, I_V5) + + // + // Sheet 1, shift register (top left) + // + + NET_C(I_V5, R1.1) + ALIAS(HI, R1.2) + + NET_C(R1.2, IC2.9, IC2.2) + NET_C(I_OUT_7, IC1.13) + NET_C(IC1.12, IC1.1) + NET_C(IC1.2, IC2.1) + NET_C(I_OUT_4, IC1.9) + NET_C(IC1.8, IC1.5) + NET_C(IC1.6, IC2.8) + NET_C(I_OUT_0, IC1.11) + NET_C(IC1.10, IC1.3) + NET_C(IC1.4, IC3.11) + + NET_C(IC2.3, IC3.3) + NET_C(IC2.4, IC3.4) + NET_C(IC2.5, IC3.7) + NET_C(IC2.6, IC3.8) + NET_C(IC2.10, IC3.13) + NET_C(IC2.11, IC3.14) + NET_C(IC2.12, IC3.17) + NET_C(IC2.13, IC3.18) + NET_C(GND, IC3.1) + +#if (SOUND_VARIANT == VARIANT_STARCASTLE) + + ALIAS(FIREBALL_EN, IC3.2) + ALIAS(SHIELD_EN, IC3.5) + ALIAS(STAR_EN, IC3.6) + ALIAS(THRUST_EN, IC3.9) + ALIAS(BACKGROUND_EN, IC3.12) + ALIAS(BL2, IC3.15) + ALIAS(BL1, IC3.16) + ALIAS(BL0, IC3.19) + +#else // (SOUND_VARIANT == VARIANT_WOTW) + + ALIAS(BACKGROUND_EN, IC3.2) + ALIAS(BL2, IC3.6) + ALIAS(BL1, IC3.6) + ALIAS(BL0, IC3.6) + ALIAS(SHIELD_EN, IC3.9) + ALIAS(FIREBALL_EN, IC3.12) + RES(REXTRA, RES_K(1)) + NET_C(IC3.16, IC6.3) + NET_C(IC6.4, REXTRA.1) + NET_C(REXTRA.2, I_V5) + ALIAS(STAR_EN, IC6.4) + ALIAS(THRUST_EN, IC3.19) + +#endif + + // + // Sheet 1, BACKGROUND (top portion) + // + + NET_C(GND, D5.A, D6.K, R13.1, R16.1, R17.1, IC7.3) + NET_C(I_V15, R2.1) + NET_C(I_VM15, R12.1, R18.1) + NET_C(R2.2, D5.K, R3.1, R5.1, R7.1) + NET_C(BL2, IC6.9) + NET_C(IC6.8, R3.2, R4.1) + NET_C(BL1, IC6.11) + NET_C(IC6.10, R5.2, R6.1) + NET_C(BL0, IC6.13) + NET_C(IC6.12, R7.2, R8.1) + NET_C(R4.2, R6.2, R8.2, IC7.2, R9.1) + NET_C(IC7.6, R9.2, R10.1) + NET_C(R10.2, IC8.2, R11.1, C11.1) + NET_C(R12.2, R13.2, IC8.3) + NET_C(IC8.6, C11.2, R11.2, R14.1) + NET_C(R14.2, D6.A, R15.1) + +#if (HLE_BACKGROUND_VCO) + // + // The background clock is a VCO controlled via a 566 timer. + // Getting the frequency high enough to not miss clocking + // the downstream dividers requires increasing the solver + // frequency too much for realtime. + // + // Instead, clip out the circuit from the control voltage + // coming into IC9 (pin 5), through the TTL converter, and + // directly output the clock into IC10 pin 2. The equation + // for the clock frequency is computed from running the + // full emulation at 1000x frequency and fitting a curve + // to the resulting dataset. + // + VARCLOCK(BGCLK, 1, "max(0.000001,min(0.1,(0.00000215073*A0*A0*A0*A0) + (0.0000224782*A0*A0*A0) + (0.000090697*A0*A0) + (0.000175878*A0) + 0.000163685))") + NET_C(BGCLK.GND, GND) + NET_C(BGCLK.VCC, I_V5) + NET_C(R17.2, R15.2, R18.2, BGCLK.A0, C12.2) + NET_C(C12.1, R16.2) + ALIAS(CLK, BGCLK.Q) + NET_C(C13.1, C13.2, C14.1, C14.2, R19.1, R19.2, R20.1, R20.2, R21.1, R21.2, D7.A, D7.K, D8.A, D8.K, GND) +#else + NET_C(GND, IC9.8, D7.A, D8.A) + NET_C(I_V5, R20.1) + NET_C(I_VM15, IC9.1, C13.2, R21.1) + NET_C(R17.2, R15.2, R18.2, IC9.5, C12.2) + NET_C(C13.1, IC9.7) + NET_C(C12.1, IC9.6, R16.2) + NET_C(IC9.3, C14.1) + NET_C(C14.2, D7.K, R19.1) + NET_C(R19.2, Q1.B) + NET_C(Q1.E, R21.2, D8.K) + NET_C(Q1.C, R20.2) + ALIAS(CLK, R20.2) +#endif + + // + // Sheet 1, BACKGROUND (bottom portion) + // + + NET_C(GND, R27.1, IC10.4, IC10.5, IC10.6, IC11.3, IC11.4, IC12.12, IC13.12, IC28.4) + NET_C(I_V5, R22.1) + NET_C(CLK, IC10.2, IC11.2, IC13.1, IC28.12) + NET_C(BACKGROUND_EN, IC6.1, IC13.2) + NET_C(IC6.2, R22.2, IC10.1, IC11.1) + NET_C(HI, IC10.3, IC10.7, IC10.10, IC11.5, IC11.6, IC11.7) + NET_C(IC10.15, IC11.10) + NET_C(IC11.15, IC28.1, IC28.13) + NET_C(IC28.2, IC11.9, IC10.9, IC12.13) + NET_C(IC12.11, R24.1) + NET_C(R24.2, C15.1, R26.2, R27.2) + NET_C(IC13.6, IC13.13) + NET_C(IC13.9, R26.1) + NET_C(C15.2, R25.1) + ALIAS(SJ, R25.2) + + // + // Sheet 2, NOISE GENERATOR + // + + NET_C(GND, C16.2, C17.2, R28.1, IC14.1, IC14.2) + NET_C(I_V15, C16.1, C17.1, IC14.4) + NET_C(IC14.3, C18.2) + NET_C(C18.1, R28.2, IC15.3) + NET_C(IC15.6, IC15.2) + ALIAS(NOISE, IC15.6) + + // + // Sheet 2, +2.2V + // + + NET_C(GND, C19.2, R30.1, R31.1) + NET_C(I_V5, R29.1, Q2.C) + NET_C(R30.2, R29.2, Q2.B) + NET_C(R31.2, Q2.E, C19.1) + ALIAS(V2_2, Q2.E) + + // + // Sheet 2, SQUARE WAVE + // + + NET_C(GND, C20.2, C21.2, IC16.1) + NET_C(I_V5, R32.1, IC16.4, IC16.8) + NET_C(R32.2, R33.1, IC16.7) + NET_C(R33.2, IC16.6, IC16.2, C20.1) + NET_C(C21.1, IC16.5) + ALIAS(SQUAREWAVE, IC16.3) + + // + // Sheet 2, LASER VCO + // + + NET_C(GND, C22.2, C24.2, Q4.E, R38.1, R42.1, R50.1) + NET_C(I_V5, R34.1, R36.1, Q3.E) + NET_C(I_V15, R39.1, R43.1) + NET_C(I_VM15, R37.1) + NET_C(I_OUT_3, IC6.5, IC12.2) + NET_C(IC6.6, R36.2, R35.1) + NET_C(R35.2, Q3.B, R34.2) + NET_C(Q3.C, R37.2, R38.2, R40.1) + NET_C(R40.2, Q4.B) + NET_C(R39.2, R41.1, C22.1, R42.2, C23.2) + NET_C(Q4.C, R41.2) + NET_C(C23.1, R43.2) + +#if (HLE_LASER_VCO) + // + // The laser VCO is the same story as the background VCO, + // requiring a large multiplier to the solver frequency + // to clock downstream gates. Again, just replace it + // with a VARCLOCK tuned based on output from running + // the full simulation. + // + VARCLOCK(LASERCLK, 1, "max(0.000001,min(0.1,(0.00000385462*A0*A0*A0*A0) - (0.000195567*A0*A0*A0) + (0.00372371*A0*A0) - (0.0315254*A0) + 0.100119))") + NET_C(LASERCLK.GND, GND) + NET_C(LASERCLK.VCC, I_V5) + NET_C(C23.2, LASERCLK.A0) + NET_C(LASERCLK.Q, IC12.1) + NET_C(GND, C24.1, C25.1, C25.2, D9.A, D9.K, D10.A, D10.K, R44.1, R44.2, R45.1, R45.2, R46.1, R46.2) +#else + NET_C(GND, D9.A, D10.A, IC17.1) + NET_C(I_V15, IC17.8) + NET_C(C23.2, IC17.5) + NET_C(C23.1, IC17.6) + NET_C(C24.1, IC17.7) + NET_C(IC17.3, C25.1) + NET_C(C25.2, D9.K, R44.1) + NET_C(R44.2, Q5.B) + NET_C(I_VM15, R46.1) + NET_C(Q5.E, D10.K, R46.2) + NET_C(I_V5, R45.1) + NET_C(Q5.C, R45.2, IC12.1) +#endif + + NET_C(IC12.3, R47.1) + NET_C(IC12.4, R48.1) + NET_C(IC12.6, R49.1) + NET_C(R47.2, R48.2, R49.2, R50.2, R51.1) + NET_C(R51.2, C26.1) + NET_C(C26.2, SJ) + + // + // Sheet 2, SOFT EXPLOSION + // + + NET_C(GND, C28.2, C29.2, R55.1, R56.1, R61.2, R62.1) + NET_C(I_V5, R52.1) + NET_C(I_VM15, C27.2, R54.1) + NET_C(I_OUT_2, R52.2, R53.1) + NET_C(R53.2, Q6.B) + NET_C(Q6.E, V2_2) + NET_C(Q6.C, R54.2, R55.2, Q7.E) + NET_C(R56.2, Q7.B) + NET_C(Q7.C, C27.1, R57.1) + NET_C(R57.2, IC18.5) + NET_C(NOISE, R58.1) + NET_C(R58.2, C28.1, R59.1) + NET_C(R59.2, C29.1, R60.1) + NET_C(R60.2, R61.1, IC18.2) + NET_C(R62.2, IC18.3) + + // + // Sheet 2, LOUD EXPLOSION + // + + NET_C(GND, C31.2, C32.2, R66.1, R67.1, R72.2, R73.1) + NET_C(I_V5, R63.1) + NET_C(I_VM15, C30.2, R65.1) + NET_C(I_OUT_1, R63.2, R64.1) + NET_C(R64.2, Q8.B) + NET_C(Q8.E, V2_2) + NET_C(Q8.C, R65.2, R66.2, Q9.E) + NET_C(R67.2, Q9.B) + NET_C(Q9.C, C30.1, R68.1) + NET_C(R68.2, IC19.5) + NET_C(NOISE, R69.1) + NET_C(R69.2, C31.1, R70.1) + NET_C(R70.2, C32.1, R71.1) + NET_C(R71.2, R72.1, IC19.2) + NET_C(R73.2, IC19.3) + + // + // Sheet 2, FIREBALL + // + + NET_C(GND, R78.1, R79.1, R83.1, R84.1) + NET_C(I_V5, Q10.E, R74.1, R76.1) + NET_C(I_VM15, C33.2, R77.1) + NET_C(FIREBALL_EN, R74.2, R75.1) + NET_C(R75.2, R76.2, Q10.B) + NET_C(Q10.C, R77.2, R78.2, Q11.E) + NET_C(R79.2, Q11.B) + NET_C(Q11.C, C33.1, R80.1) + NET_C(R80.2, IC20.5) + NET_C(NOISE, R81.1) + NET_C(SQUAREWAVE, R82.1) + NET_C(R81.2, R82.2, R83.2, IC20.2) + NET_C(R84.2, IC20.3) + + // + // Sheet 2, SHIELD + // + + NET_C(GND, R92.1, R93.1, R97.1, R98.1) + NET_C(I_V5, R85.1, R87.1, R88.1, Q12.E) + NET_C(I_VM15, R91.1) + NET_C(SHIELD_EN, R85.2, R86.1) + NET_C(R86.2, R87.2, Q12.B) + NET_C(Q12.C, R90.1, Q13.E) + NET_C(SQUAREWAVE, R88.2, R89.1) + NET_C(R89.2, R90.2, Q13.B) + NET_C(Q13.C, R91.2, R92.2, Q14.E) + NET_C(R93.2, Q14.B) + NET_C(Q14.C, R94.1) + NET_C(R94.2, IC21.5) + NET_C(SQUAREWAVE, R96.1) + NET_C(NOISE, R95.1) + NET_C(R96.2, R95.2, R97.2, IC21.2) + NET_C(R98.2, IC21.3) + + // + // Sheet 2, THRUST + // + + NET_C(GND, R103.1, R104.1, C35.2, C36.2, R110.1, R111.1) + NET_C(I_V5, R99.1, R101.1, Q15.E) + NET_C(I_VM15, C34.2, R102.1) + NET_C(THRUST_EN, R99.2, R100.1) + NET_C(R100.2, R101.2, Q15.B) + NET_C(Q15.C, R102.2, R103.2, Q16.E) + NET_C(R104.2, Q16.B) + NET_C(Q16.C, R105.1) + NET_C(R105.2, C34.1, R106.1) + NET_C(R106.2, IC22.5) + NET_C(NOISE, R107.1) + NET_C(R107.2, C35.1, R108.1) + NET_C(R108.2, C36.1, R109.1) + NET_C(R109.2, R110.2, IC22.2) + NET_C(R111.2, IC22.3) + + // + // Sheet 2, STAR SOUND + // + + NET_C(GND, C37.1, C38.1, C39.1, C40.1, C41.1, R119.1, IC23.1, IC24.1) + NET_C(I_V5, R112.1, R117.1, IC23.8, IC24.8) + NET_C(STAR_EN, IC23.4, IC24.4) + NET_C(R112.2, IC23.7, R113.1) + NET_C(R113.2, IC23.2, IC23.6, C37.2) + NET_C(C38.2, IC23.5) + NET_C(IC23.3, R114.1) + NET_C(R114.2, C39.2, R115.1) + NET_C(R115.2, C40.2, IC24.6, IC24.2, R116.1) + NET_C(R116.2, IC24.7, R117.2) + NET_C(C41.2, IC24.5) + NET_C(IC24.3, R119.2, R118.1) + NET_C(R118.2, C42.1) + NET_C(C42.2, SJ) + + // + // Sheet 2, preamp + // + + NET_C(GND, R127.1, IC27.3, R128.1) + NET_C(IC18.6, IC19.6, IC20.6, IC21.6, IC22.6, R127.2, IC26.3) + NET_C(IC26.2, IC26.6, C48.1) + NET_C(C48.2, R125.1) + NET_C(R125.2, SJ, IC27.2, R126.1) + NET_C(R126.2, IC27.6, R128.3) + + // + // Sheet 2, final amp + // + + ALIAS(OUTPUT, R126.2) + + // + // Unconnected inputs + // + + NET_C(GND, IC28.8, IC28.9, IC28.10, IC28.11) +#if (SOUND_VARIANT == VARIANT_STARCASTLE) + NET_C(GND, IC6.3) +#endif + + // + // Unconnected outputs + // + + HINT(IC28.3, NC) + HINT(IC28.5, NC) + HINT(IC28.6, NC) + +#if (SOUND_VARIANT == VARIANT_STARCASTLE) + HINT(IC6.4, NC) +#endif + HINT(IC10.11, NC) + HINT(IC10.12, NC) + HINT(IC10.13, NC) + HINT(IC10.14, NC) + HINT(IC11.11, NC) + HINT(IC11.12, NC) + HINT(IC11.13, NC) + HINT(IC11.14, NC) + HINT(IC12.5, NC) + HINT(IC12.8, NC) + HINT(IC12.9, NC) + HINT(IC12.10, NC) + HINT(IC13.3, NC) + HINT(IC13.4, NC) + HINT(IC13.5, NC) + HINT(IC13.8, NC) + HINT(IC13.10, NC) + HINT(IC13.11, NC) + +#if (ENABLE_FRONTIERS) + // + // Disconnect noise source from consumers + // + OPTIMIZE_FRONTIER(IC15.3, RES_M(1), 50) + + // + // Split noise outputs from output outputs before the mixer + // + OPTIMIZE_FRONTIER(IC26.3, RES_M(1), 50) +#endif + +NETLIST_END() + +#endif diff --git a/src/mame/audio/nl_starcas.h b/src/mame/audio/nl_starcas.h new file mode 100644 index 00000000000..5cb02ace8fc --- /dev/null +++ b/src/mame/audio/nl_starcas.h @@ -0,0 +1,11 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_STARCAS_H +#define MAME_AUDIO_NL_STARCAS_H + +#pragma once + +NETLIST_EXTERNAL(starcas) +NETLIST_EXTERNAL(wotw) + +#endif // MAME_AUDIO_NL_STARCAS_H diff --git a/src/mame/audio/nl_starhawk.cpp b/src/mame/audio/nl_starhawk.cpp new file mode 100644 index 00000000000..d2d0b947bf3 --- /dev/null +++ b/src/mame/audio/nl_starhawk.cpp @@ -0,0 +1,640 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Star Hawk +// +// Derived from the schematics in the Star Hawk manual. +// +// Special thanks to: +// * Jay Gallagher for verifying PCB components +// +// Known problems/issues: +// +// * The VCOs require high solver frequencies (100x+) to reach the +// correct pitches. For this reason, HLE'ed versions are +// provided that work correctly even at 48kHz. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" + + +// +// Optimizations +// + +#define HLE_SHIP_VCO (1) +#define HLE_LAZER_VCOS (1) + + +// +// Debugging/test - should be off for release +// + +#define SLOW_SHIP_WOBBLE (0) + + +// +// Main netlist +// + +NETLIST_START(starhawk) + +#if (HLE_LAZER_VCOS && HLE_SHIP_VCO) + SOLVER(Solver, 1000) +#else + SOLVER(Solver, 48000000) +#endif + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + TTL_INPUT(I_OUT_7, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(10)) + RES(R2, RES_K(10)) + RES(R3, RES_K(20)) + RES(R4, RES_K(10)) + RES(R5, RES_K(1)) + RES(R6, RES_K(150)) + RES(R7, 330) + RES(R8, RES_K(10)) + RES(R9, RES_K(47)) + RES(R10, RES_K(150)) + RES(R11, RES_K(100)) + RES(R12, RES_K(47)) + RES(R13, RES_K(10)) + RES(R14, RES_K(2.7)) + RES(R15, RES_K(2.7)) + RES(R16, RES_K(30)) + RES(R17, RES_K(510)) + RES(R18, RES_K(10)) + RES(R19, RES_K(33)) +// RES(R20, 150) -- part of final amp (not emulated) +// RES(R21, RES_K(22)) -- part of final amp (not emulated) + RES(R22, RES_K(1)) +// RES(R23, RES_K(10)) -- part of final amp (not emulated) +// RES(R24, 150) -- part of final amp (not emulated) +// POT(R25, RES_K(100))-- part of final amp (not emulated) + RES(R26, RES_K(1)) + RES(R27, RES_K(1)) + RES(R28, RES_K(510)) + RES(R29, RES_K(10)) // PCB verified +// RES(R30, ???) + RES(R31, RES_K(47)) // PCB verified + RES(R32, RES_M(3.3)) // PCB verified + RES(R33, RES_M(1)) + RES(R34, RES_K(47)) + RES(R35, RES_M(1)) + RES(R36, RES_M(1)) + RES(R37, RES_M(1)) + RES(R38, RES_M(1)) + RES(R39, 150) + RES(R40, RES_K(10)) + RES(R41, RES_K(20)) + RES(R42, RES_K(1)) + RES(R43, RES_M(1)) + RES(R44, RES_K(10)) + RES(R45, RES_K(10)) + RES(R46, 150) + RES(R47, RES_K(20)) + RES(R48, RES_M(1)) + RES(R49, RES_K(10)) + RES(R50, RES_K(1)) + RES(R51, RES_K(10)) + RES(R52, RES_K(20)) + RES(R53, RES_K(39)) + RES(R54, RES_K(82)) + RES(R55, RES_K(2.2)) + RES(R56, RES_K(1)) + RES(R57, RES_K(10)) + RES(R58, RES_K(20)) + RES(R59, RES_K(39)) + RES(R60, RES_K(82)) + +// CAP(C1, CAP_U(2.2)) +// CAP(C2, CAP_U(2.2)) +// CAP(C3, CAP_U(3.3)) +// CAP(C4, CAP_U(3.3)) + CAP(C5, CAP_P(100)) + CAP(C6, CAP_U(3.3)) + CAP(C7, CAP_U(0.01)) + CAP(C8, CAP_U(1)) + CAP(C9, CAP_U(0.022)) + CAP(C10, CAP_U(0.15)) // 15? + CAP(C11, CAP_U(0.15)) + CAP(C12, CAP_U(15)) + CAP(C13, CAP_U(0.0033)) + CAP(C14, CAP_U(0.0047)) + CAP(C15, CAP_U(1)) +// CAP(C16, CAP_P(470)) -- part of final amp (not emulated) + CAP(C17, CAP_U(22)) +// CAP(C18, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C19, CAP_P(470)) -- part of final amp (not emulated) + CAP(C20, CAP_U(1)) +#if (SLOW_SHIP_WOBBLE) + CAP(C21, CAP_U(22)) // discovered by accident, makes HLE analysis easier +#else + CAP(C21, CAP_U(0.22)) // PCB verified +#endif + CAP(C22, CAP_U(0.1)) + CAP(C23, CAP_U(0.0027)) + CAP(C24, CAP_U(0.1)) + CAP(C25, CAP_U(0.0027)) + CAP(C26, CAP_U(1)) + CAP(C27, CAP_U(0.1)) +// CAP(C39, CAP_U(1)) +// CAP(C40, CAP_U(1)) + + D_1N914(CR1) + D_1N914(CR2) + D_1N914(CR3) + D_1N914(CR4) + D_1N914(CR5) + D_1N914(CR6) + D_1N914(CR7) + D_1N914(CR8) + D_1N914(CR9) + D_1N914(CR10) + + Q_2N3906(Q1) // PNP +// Q_2N6292(Q2) // NPN -- part of final amp (not emulated) +// Q_2N6107(Q3) // PNP -- part of final amp (not emulated) +#if (!HLE_LAZER_VCOS) + Q_2N3904(Q4) // NPN + Q_2N3904(Q5) // NPN +#endif + + TL182_DIP(IC3A) // Analog switch + NET_C(IC3A.6, I_V15) + NET_C(IC3A.7, I_V5) + NET_C(IC3A.8, GND) + NET_C(IC3A.9, I_VM15) + +// TTL_7815_DIP(IC2D) // +15V Regulator -- not needed +// TTL_7915_DIP(IC2C) // -15V Regulator -- not needed + + TL081_DIP(IC4A) // Op. Amp. + NET_C(IC4A.4, I_VM15) + NET_C(IC4A.7, I_V15) + + TL081_DIP(IC4B) // Op. Amp. + NET_C(IC4B.4, I_VM15) + NET_C(IC4B.7, I_V15) + +// TL081_DIP(IC4C) // Op. Amp. -- part of final amp (not emulated) +// NET_C(IC4C.4, I_VM15) +// NET_C(IC4C.7, I_V15) + + TTL_74LS393_DIP(IC4E) // Dual 4-Stage Binary Counter + NET_C(IC4E.7, GND) + NET_C(IC4E.14, I_V5) + + TL081_DIP(IC5A) // Op. Amp. + NET_C(IC5A.4, I_VM15) + NET_C(IC5A.7, I_V15) + + TL081_DIP(IC5B) // Op. Amp. + NET_C(IC5B.4, I_VM15) + NET_C(IC5B.7, I_V15) + + LM556_DIP(IC5D) + + PROM_74S287_DIP(IC5E) // 1024-bit PROM -- dump needed + PARAM(IC5E.A.ROM, "2085.5e8e") + NET_C(IC5E.8, GND) + NET_C(IC5E.16, I_V5) + + CA3080_DIP(IC6A) // Trnscndt. Op. Amp. + NET_C(IC6A.7, I_V15) + NET_C(IC6A.4, I_VM15) + + TL081_DIP(IC6B) // Op. Amp. + NET_C(IC6B.4, I_VM15) + NET_C(IC6B.7, I_V15) + + TTL_74LS04_DIP(IC6C) // Hex Inverting Gates + NET_C(IC6C.7, GND) + NET_C(IC6C.14, I_V5) + + LM556_DIP(IC6D) + + TL081_DIP(IC6E) // Op. Amp. + NET_C(IC6E.4, I_VM15) + NET_C(IC6E.7, I_V15) + + TL081_DIP(IC6F) // Op. Amp. + NET_C(IC6F.4, I_VM15) + NET_C(IC6F.7, I_V15) + + TTL_7406_DIP(IC7C) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(IC7C.7, GND) + NET_C(IC7C.14, I_V5) + + TTL_74LS393_DIP(IC7E) // Dual 4-Stage Binary Counter + NET_C(IC7E.7, GND) + NET_C(IC7E.14, I_V5) + + TTL_74LS164_DIP(IC8C) // 8-bit Shift Reg. + NET_C(IC8C.7, GND) + NET_C(IC8C.14, I_V5) + + TTL_74LS164_DIP(IC8D) // 8-bit Shift Reg. + NET_C(IC8D.7, GND) + NET_C(IC8D.14, I_V5) + + PROM_74S287_DIP(IC8E) // 1024-bit PROM -- dump needed + PARAM(IC8E.A.ROM, "2085.5e8e") + NET_C(IC8E.8, GND) + NET_C(IC8E.16, I_V5) + + TTL_74LS164_DIP(IC9C) // 8-bit Shift Reg. + NET_C(IC9C.7, GND) + NET_C(IC9C.14, I_V5) + + TTL_74LS164_DIP(IC9D) // 8-bit Shift Reg. + NET_C(IC9D.7, GND) + NET_C(IC9D.14, I_V5) + + TTL_74LS163_DIP(IC9E) // Binary Counter (schems say can sub a 74161) + NET_C(IC9E.8, GND) + NET_C(IC9E.16, I_V5) + + TTL_74LS86_DIP(IC10C) // Quad 2-Input XOR Gates + NET_C(IC10C.7, GND) + NET_C(IC10C.14, I_V5) + + TTL_74LS21_DIP(IC10D) // Dual 4-Input AND Gates + NET_C(IC10D.7, GND) + NET_C(IC10D.14, I_V5) + + TTL_74LS393_DIP(IC10E) // Dual 4-Stage Binary Counter + NET_C(IC10E.7, GND) + NET_C(IC10E.14, I_V5) + + // + // Top-left noise generator + // + + NET_C(I_V5, R1.2, IC6D.14, IC6D.4, R3.2) + NET_C(R1.1, IC6D.1, R2.2) + NET_C(R2.1, IC6D.2, IC6D.6, C7.2) + NET_C(C7.1, GND) + NET_C(IC6D.7, GND) + NET_C(IC6D.3, C8.1, R3.1, R4.1) + NET_C(C8.2, GND) + NET_C(R4.2, IC8D.4) + NET_C(IC6D.5, IC8D.8, IC9D.8, IC10E.1, IC9E.2) + + NET_C(IC9E.9, IC9E.7, IC9E.10, I_V5) + NET_C(IC9E.1, I_V5) + NET_C(IC9E.15, IC10E.13, IC8C.8, IC9C.8) + + NET_C(IC10E.2, IC8D.3) + NET_C(IC10E.3, IC10D.1) + NET_C(IC10E.4, IC10D.2) + NET_C(IC10E.5, IC10D.4) + NET_C(IC10E.6, IC10D.5) + + NET_C(IC10D.6, IC10C.5) + NET_C(IC10C.4, IC10C.11) + NET_C(IC10C.6, IC8D.1, IC8D.2) + + NET_C(IC8D.9, I_V5) + NET_C(IC8D.13, IC9D.1, IC9D.2) + NET_C(IC9D.10, IC10C.13) + NET_C(IC9D.12, IC10C.12) + NET_C(IC9D.13, R8.2) + NET_C(IC9D.9, I_V5) + + NET_C(R8.1, C10.2, R9.1) + NET_C(C10.1, GND) + NET_C(R9.2, CR1.K, CR2.A) + + NET_C(IC10E.12, IC8C.3) + NET_C(IC10E.8, IC10D.9) + NET_C(IC10E.9, IC10D.10) + NET_C(IC10E.10, IC10D.12) + NET_C(IC10E.11, IC10D.13) + + NET_C(IC10D.8, IC10C.1) + NET_C(IC10C.2, IC10C.8) + NET_C(IC10C.3, IC8C.1, IC8C.2) + + NET_C(IC8C.9, I_V5) + NET_C(IC8C.13, IC9C.1, IC9C.2) + NET_C(IC9C.10, IC10C.10) + NET_C(IC9C.12, IC10C.9) + NET_C(IC9C.13, R10.1) + NET_C(IC9C.9, I_V5) + + NET_C(R10.2, C11.2, R11.1) + NET_C(C11.1, GND) + NET_C(R11.2, CR2.K, CR1.A, C12.1) + + NET_C(C12.2, IC6B.2, R12.1, C13.1) + NET_C(IC6B.3, GND) + NET_C(IC6B.6, C13.2, R12.2, R13.1) + NET_C(R13.2, C15.1) + NET_C(C15.2, R14.2, IC6A.2) + NET_C(R14.1, GND) + NET_C(IC6A.3, R15.2) + NET_C(R15.1, GND) + NET_C(IC6A.5, R16.2) + + // + // Explosion + // + + NET_C(I_OUT_0, IC6C.11) + NET_C(IC6C.10, R5.1) + NET_C(R5.2, C5.2, IC6D.8) + NET_C(C5.1, GND) + NET_C(IC6D.10, R6.2, I_V5) + NET_C(IC6D.12, IC6D.13, R6.1, C6.1) + NET_C(C6.2, GND) + NET_C(IC6D.9, Q1.E) + NET_C(Q1.B, R7.2) + NET_C(R7.1, GND) + NET_C(Q1.C, R17.2, C17.1, R16.1) + NET_C(R17.1, GND) + NET_C(C17.2, I_VM15) + + // + // On/off switches + // + + NET_C(I_OUT_3, IC3A.5, IC6C.3) + NET_C(I_OUT_4, IC3A.10) + + NET_C(IC3A.1, IC4A.2, R18.1, C14.1) + NET_C(IC4A.3, GND) + NET_C(C14.2, R18.2, IC4A.6, R19.1) + NET_C(R19.2, IC3A.14, IC6A.6) + +#if (HLE_SHIP_VCO) + // + // This VCO is tricky to simulate, as there is both a frequency aspect + // and an envelope aspect. The frequency is relatively straightforward. + // Pick up the voltage from the anode of CR4 and map to a frequency + // with a polynominal derived from the LLE implementation. + // + // Here is the mapping I get for CR4.A vs. IC3A.5 (using a -0.1-0.1 threshold): + // R2 = 0.99832: HP = (-0.000160539*A0) + 0.0000331984 + // R2 = 0.99927: HP = (0.00000397232*A0*A0) - (0.000129210*A0) + 0.000083240 + // R2 = 0.99927: HP = (-0.000000185528*A0*A0*A0) + (0.00000154157*A0*A0) - (0.000138889*A0) + 0.000071961 + // R2 = 0.99929: HP = (-0.000000215021*A0*A0*A0*A0) - (0.00000393775*A0*A0*A0) - (0.0000213646*A0*A0) - (0.000196307*A0) + 0.0000221998 + // R2 = 0.99931: HP = (0.000000153378*A0*A0*A0*A0*A0) + (0.00000317059*A0*A0*A0*A0) + (0.0000244935*A0*A0*A0) + (0.000091436*A0*A0) + (0.0000138241*A0) + 0.000169151 + // + VARCLOCK(SHIPCLK, 1, "max(0.000001,min(0.1,(0.00000397232*A0*A0) - (0.000129210*A0) + 0.000083240))") + NET_C(SHIPCLK.GND, GND) + NET_C(SHIPCLK.VCC, I_V5) + NET_C(SHIPCLK.A0, CR4.A) + // + // The envelope is trickier. When the signal is OFF (3A pin 5 is HIGH), + // the envelope tracks the voltage from CR4. When the signal is ON + // (3A pin 5 is LOW), the raw clock from SHIPCLK is clamped to -1..1 + // and scaled down by a constant factor with a small additional + // envelope from the CR4 anode voltage. + // + AFUNC(SHIPENV, 3, "if(A2>2.5, -A1, (0.07-(0.005*A1))*if(A0>2.5,1,-1))") + NET_C(SHIPENV.A0, SHIPCLK.Q) + NET_C(SHIPENV.A1, CR4.A) + NET_C(SHIPENV.A2, IC3A.5) + NET_C(SHIPENV.Q, IC3A.2) + NET_C(R34.2, R35.1) + NET_C(R35.2, CR4.K) + NET_C(R36.1, IC5B.6, R38.2, CR4.A) + NET_C(GND, R34.1, R36.2, R37.1, R37.2, C9.1, C9.2, CR5.A, CR5.K, IC4B.2, IC4B.3, IC5A.2, IC5A.3) +#else + NET_C(IC3A.2, C9.2) + NET_C(C9.1, IC4B.2, R34.1) + NET_C(IC4B.6, R34.2, R35.1) + NET_C(IC4B.3, R35.2, CR4.K, CR5.A) + NET_C(R36.1, IC5B.6, R38.2, CR4.A) + NET_C(R36.2, IC5A.2, R37.1) + NET_C(IC5A.3, GND) + NET_C(R37.2, IC5A.6, CR5.K) +#endif + + NET_C(IC3A.13, R22.1) + NET_C(R22.2, GND) + ALIAS(OUTPUT, R22.1) + + // + // K exit + // + + NET_C(I_OUT_7, IC7C.1) + NET_C(IC7C.2, R27.1, CR6.A) + NET_C(R27.2, I_V5) + + NET_C(IC6C.4, IC7C.11) + NET_C(IC7C.10, CR3.A, R26.1) + NET_C(R26.2, I_V15, IC5D.14, IC5D.4, R29.2) + NET_C(CR3.K, R28.2) + NET_C(R28.1, CR6.K, C20.1, R33.1) + NET_C(C20.2, GND) + NET_C(R33.2, C27.1, R38.1, IC5B.2) + NET_C(IC5D.1, R29.1, R31.2) + NET_C(IC5D.2, IC5D.6, R31.1, R32.1, C21.1) + NET_C(R32.2, C27.2) + NET_C(C21.2, GND) + NET_C(IC5B.3, GND) + NET_C(IC5D.7, GND) + + // pin 5 (OUTPUT) of the 555 timer is not connected; + // use this kludge to simulate that + RES(RDUMMY, RES_K(100)) + NET_C(IC5D.5, RDUMMY.1) + NET_C(RDUMMY.2, GND) + + // + // Lazer 1 + // + + NET_C(I_OUT_1, IC6C.5) + NET_C(IC6C.6, IC8E.14, IC7C.9) + NET_C(IC7C.8, R39.1) + NET_C(R39.2, C22.2, CR7.K) + NET_C(C22.1, GND) + +#if (HLE_LAZER_VCOS) + // + // This VCO is very difficult to simulate without cranking the speed up + // and killing performance. Even at 1000x frequency, we still get failures + // to converge. Here we clip the circuit at the diode CR7 and substitute + // a VARCLOCK that directly drives the counter at 7E, skipping the analog + // to TTL conversion logic after the VCO. + // + // Here is the mapping I get for C22.2 vs. IC7E.1 half-period: + // + // R2 = 0.97399: HP = (0.00000249069*A0) + 0.00000439991 + // R2 = 0.99638: HP = (0.000000142614*A0*A0) + (0.00000104196*A0) + 0.00000471406 + // R2 = 0.99932: HP = (0.0000000174880*A0*A0*A0) - (0.000000159311*A0*A0) + (0.00000222025*A0) + 0.00000455815 + // R2 = 0.99978: HP = (0.00000000229608*A0*A0*A0*A0) - (0.0000000377974*A0*A0*A0) + (0.000000245492*A0*A0) + (0.00000134883*A0) + 0.00000465357 + // R2 = 0.99985: HP = (0.000000000286259*A0*A0*A0*A0*A0) - (0.00000000650969*A0*A0*A0*A0) + (0.0000000560876*A0*A0*A0) - (0.000000154720*A0*A0) + (0.00000190838*A0) + 0.0000045976 + // + // One additional wrinkle is that when we clip the circuit, the voltage + // input to the VCO changes from a curve to linear, so to compute the + // mapping below, we had to map the C22.2 value from the clipped circuit + // against the frequency. Fortunately, the relationship still held, and + // in fact became almost linear. + // + // Here is the mapping for the clipped C22.2 vs. the original IC7E.1: + // R2 = 0.99947: HP = (0.000226684*A0) - 0.0000178774 + // R2 = 0.99947: HP = (-0.0000111790*A0*A0) + (0.000230333*A0) - 0.0000181329 + // R2 = 0.99958: HP = (-0.00124814*A0*A0*A0) + (0.000641071*A0*A0) + (0.000124020*A0) - 0.0000127688 + // R2 = 0.99976: HP = (0.0197918*A0*A0*A0*A0) - (0.0148601*A0*A0*A0) + (0.00399181*A0*A0) - (0.000225308*A0) + 0.000000287255 + // R2 = 0.99979: HP = (-0.095062*A0*A0*A0*A0*A0) + (0.093556*A0*A0*A0*A0) - (0.0361209*A0*A0*A0) + (0.00677578*A0*A0) - (0.000384926*A0) + 0.00000324102 + // + VARCLOCK(LAZER1CLK, 1, "max(0.000001,min(0.1,(0.000226684*A0) - 0.0000178774))") + NET_C(LAZER1CLK.GND, GND) + NET_C(LAZER1CLK.VCC, I_V5) + NET_C(LAZER1CLK.Q, IC7E.1) + NET_C(LAZER1CLK.A0, C22.2) + NET_C(GND, R40.1, R40.2, R41.1, R41.2, R42.1, R42.2, R43.1, R43.2, R44.1, R44.2, C23.1, C23.2, CR7.A, CR8.A, CR8.K, IC6C.9, IC6F.2, IC6F.3) +#else + NET_C(CR7.A, IC6F.3, CR8.K, R43.1) + NET_C(CR8.A, GND) + NET_C(IC6F.2, C23.2, R40.1) + NET_C(C23.1, GND) + NET_C(IC6F.6, R40.2, R43.2, R41.1) + NET_C(R41.2, R44.2, Q4.B) + NET_C(R44.1, GND) + NET_C(Q4.E, GND) + NET_C(Q4.C, R42.1, IC6C.9) + NET_C(R42.2, I_V5) + NET_C(IC6C.8, IC7E.1) +#endif + + NET_C(IC7E.2, IC7E.12, GND) + NET_C(IC7E.3, IC8E.7) + NET_C(IC7E.4, IC8E.4) + NET_C(IC7E.5, IC8E.6) + NET_C(IC7E.6, IC8E.5, IC7E.13) + NET_C(IC7E.8, IC8E.15) + NET_C(IC7E.10, IC8E.2) + NET_C(IC7E.11, IC8E.3) + + NET_C(IC8E.1, GND) + NET_C(IC8E.13, GND) + NET_C(IC8E.12, R51.1) + NET_C(IC8E.11, R52.1) + NET_C(IC8E.10, R53.1) + NET_C(IC8E.9, R54.1) + NET_C(R51.2, R52.2, R53.2, R54.2, R55.1, R56.2) + NET_C(R56.1, GND) + NET_C(R55.2, C26.1) + NET_C(C26.2, IC6A.6) + + // + // Lazer 2 + // + + NET_C(I_OUT_2, IC6C.1) + NET_C(IC6C.2, IC5E.14, IC7C.13) + NET_C(IC7C.12, R46.1) + NET_C(R46.2, C24.2, CR9.K) + NET_C(C24.1, GND) + +#if (HLE_LAZER_VCOS) + // + // This VCO is identical to the one above, just using different components + // + VARCLOCK(LAZER2CLK, 1, "max(0.000001,min(0.1,(0.000226684*A0) - 0.0000178774))") + NET_C(LAZER2CLK.GND, GND) + NET_C(LAZER2CLK.VCC, I_V5) + NET_C(LAZER2CLK.Q, IC4E.1) + NET_C(LAZER2CLK.A0, C24.2) + NET_C(GND, R45.1, R45.2, R47.1, R47.2, R48.1, R48.2, R49.1, R49.2, R50.1, R50.2, C25.1, C25.2, CR9.A, CR10.A, CR10.K, IC6C.13, IC6E.2, IC6E.3) +#else + NET_C(CR9.A, IC6E.3, CR10.K, R48.1) + NET_C(CR10.A, GND) + NET_C(IC6E.2, C25.2, R45.1) + NET_C(C25.1, GND) + NET_C(IC6E.6, R45.2, R48.2, R47.1) + NET_C(R47.2, R49.2, Q5.B) + NET_C(R49.1, GND) + NET_C(Q5.E, GND) + NET_C(Q5.C, R50.1, IC6C.13) + NET_C(R50.2, I_V5) + NET_C(IC6C.12, IC4E.1) +#endif + + NET_C(IC4E.2, IC4E.12, GND) + NET_C(IC4E.3, IC5E.7) + NET_C(IC4E.4, IC5E.4) + NET_C(IC4E.5, IC5E.6) + NET_C(IC4E.6, IC5E.5, IC4E.13) + NET_C(IC4E.8, IC5E.15) + NET_C(IC4E.10, IC5E.2) + NET_C(IC4E.11, IC5E.3) + + NET_C(IC5E.1, GND) + NET_C(IC5E.13, GND) + NET_C(IC5E.12, R57.1) + NET_C(IC5E.11, R58.1) + NET_C(IC5E.10, R59.1) + NET_C(IC5E.9, R60.1) + NET_C(R57.2, R58.2, R59.2, R60.2, R55.1) + + // + // Unconnected inputs + // + + NET_C(GND, IC5D.8, IC5D.9, IC5D.10, IC5D.12, IC5D.13, IC7C.3, IC7C.5, IC9E.3, IC9E.4, IC9E.5, IC9E.6) + + // + // Unconnected outputs + // + + HINT(IC4E.9, NC) // Q3 +#if (HLE_LAZER_VCOS) + HINT(IC6C.8, NC) // QD + HINT(IC6C.12, NC) // QF +#endif + HINT(IC7C.4, NC) // QB + HINT(IC7C.6, NC) // QC + HINT(IC7E.9, NC) // Q3 + HINT(IC8C.4, NC) // Q1 + HINT(IC8C.5, NC) // Q2 + HINT(IC8C.6, NC) // Q3 + HINT(IC8C.10, NC) // Q4 + HINT(IC8C.11, NC) // Q5 + HINT(IC8C.12, NC) // Q6 + HINT(IC8D.5, NC) // Q2 + HINT(IC8D.6, NC) // Q3 + HINT(IC8D.10, NC) // Q4 + HINT(IC8D.11, NC) // Q5 + HINT(IC8D.12, NC) // Q6 + HINT(IC9C.3, NC) // Q0 + HINT(IC9C.4, NC) // Q1 + HINT(IC9C.5, NC) // Q2 + HINT(IC9C.6, NC) // Q3 + HINT(IC9C.11, NC) // Q5 + HINT(IC9D.3, NC) // Q0 + HINT(IC9D.4, NC) // Q1 + HINT(IC9D.5, NC) // Q2 + HINT(IC9D.6, NC) // Q3 + HINT(IC9D.11, NC) // Q5 + HINT(IC9E.11, NC) // Q3 + HINT(IC9E.12, NC) // Q2 + HINT(IC9E.13, NC) // Q1 + HINT(IC9E.14, NC) // Q0 + +NETLIST_END() diff --git a/src/mame/audio/nl_starhawk.h b/src/mame/audio/nl_starhawk.h new file mode 100644 index 00000000000..65071c7be17 --- /dev/null +++ b/src/mame/audio/nl_starhawk.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_STARHAWK_H +#define MAME_AUDIO_NL_STARHAWK_H + +#pragma once + +NETLIST_EXTERNAL(starhawk) + +#endif // MAME_AUDIO_NL_STARHAWK_H diff --git a/src/mame/audio/nl_sundance.cpp b/src/mame/audio/nl_sundance.cpp new file mode 100644 index 00000000000..1c099080547 --- /dev/null +++ b/src/mame/audio/nl_sundance.cpp @@ -0,0 +1,483 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Sundance +// +// Derived from the schematics in the Sundance manual. +// +// Known problems/issues: +// +// * The "whoosh" sound is close to correct, though there may +// be some missing harmonics in the HLE. +// +// * The "wideband noise generator" is simulated with a generic +// noise source. This seems to work fine and doesn't sound +// too different from recordings. +// +// * The pitch of the pings and bongs seems a little lower than +// some recordings, though it's hard to say if this is due +// to aging as the frequencies are controlled by 555 timers +// and RC networks. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_sundance.h" + + +// +// Optimizations +// + +#define HLE_NOISE_GEN (1) +#define HLE_WHOOSH_MOD (1) + + +// +// Main netlist +// + +NETLIST_START(sundance) + + SOLVER(Solver, 1000) + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 1) // active low + TTL_INPUT(I_OUT_1, 1) // active low + TTL_INPUT(I_OUT_2, 1) // active low + TTL_INPUT(I_OUT_3, 1) // active low + TTL_INPUT(I_OUT_4, 1) // active low + TTL_INPUT(I_OUT_7, 1) // active low + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND, I_OUT_7.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC, I_OUT_7.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_M(1)) + RES(R2, 470) + RES(R3, 470) + RES(R4, RES_K(470)) + RES(R5, 100) + RES(R6, RES_K(470)) + RES(R7, RES_K(10)) + RES(R8, RES_M(1)) + RES(R9, RES_K(10)) + RES(R10, RES_K(47)) + RES(R11, RES_K(100)) + RES(R12, RES_K(220)) + RES(R13, RES_M(3.3)) + RES(R14, RES_K(390)) + RES(R15, RES_K(56)) + RES(R16, RES_M(1)) + RES(R17, RES_K(100)) + RES(R18, RES_K(10)) + RES(R19, RES_K(3.3)) + RES(R20, RES_K(100)) + RES(R21, RES_K(47)) + RES(R22, RES_K(47)) + RES(R23, RES_K(750)) + RES(R24, 470) + RES(R25, RES_K(220)) + RES(R26, 330) + RES(R27, RES_K(10)) + RES(R28, RES_K(47)) + RES(R29, RES_K(330)) + RES(R30, RES_K(30)) + RES(R31, RES_K(10)) + RES(R32, RES_K(2.7)) + RES(R33, RES_K(2.7)) + RES(R34, RES_K(100)) + RES(R35, RES_K(10)) + RES(R36, RES_K(4.7)) + RES(R37, RES_K(8.2)) + RES(R38, RES_K(120)) + RES(R39, RES_M(3.3)) + RES(R40, RES_K(39)) + RES(R41, RES_K(2.7)) + RES(R42, RES_K(2.7)) + RES(R43, RES_K(47)) + RES(R44, RES_K(8.2)) + RES(R45, RES_K(2.7)) + RES(R46, RES_K(2.7)) + RES(R47, RES_M(10)) + RES(R48, RES_M(10)) + RES(R49, RES_K(1)) + RES(R50, 330) + RES(R51, RES_K(510)) + RES(R52, RES_K(15)) + RES(R53, RES_K(20)) + RES(R54, RES_K(47)) + RES(R55, RES_K(2.7)) + RES(R56, RES_K(2.7)) + RES(R57, 330) + RES(R58, RES_K(390)) + RES(R59, RES_K(15)) + RES(R60, RES_K(24)) + RES(R61, RES_K(56)) + RES(R62, RES_K(2.7)) + RES(R63, RES_K(2.7)) + RES(R64, 470) +// RES(R65, 150) -- part of final amp (not emulated) +// RES(R66, RES_K(22)) -- part of final amp (not emulated) +// RES(R67, 150) -- part of final amp (not emulated) + RES(R68, 330) + RES(R69, RES_K(390)) + RES(R70, RES_K(15)) + RES(R71, RES_K(30)) + RES(R72, RES_K(68)) + RES(R73, RES_K(2.7)) + RES(R74, RES_K(2.7)) +// RES(R75, RES_K(10)) -- part of final amp (not emulated) +// POT(R76, RES_K(100)) -- part of final amp (not emulated) +// PARAM(R76.DIAL, 0.500000) -- part of final amp (not emulated) + RES(R77, 330) + RES(R78, RES_K(220)) + + CAP(C1, CAP_U(0.1)) + CAP(C2, CAP_U(100)) + CAP(C3, CAP_U(0.01)) + CAP(C4, CAP_U(0.1)) + CAP(C5, CAP_U(100)) + CAP(C6, CAP_U(1)) + CAP(C7, CAP_U(1)) + CAP(C8, CAP_U(10)) + CAP(C9, CAP_U(0.05)) + CAP(C10, CAP_U(0.1)) + CAP(C11, CAP_U(0.01)) + CAP(C12, CAP_U(0.1)) + CAP(C13, CAP_U(0.001)) + CAP(C14, CAP_U(0.005)) + CAP(C15, CAP_U(10)) +// CAP(C16, CAP_U(3.3)) -- not needed +// CAP(C17, CAP_U(3.3)) -- not needed +// CAP(C18, CAP_U(3.3)) -- not needed +// CAP(C19, CAP_U(3.3)) -- not needed +// CAP(C20, CAP_U(3.3)) -- not needed + CAP(C21, CAP_U(0.1)) + CAP(C22, CAP_U(0.005)) + CAP(C23, CAP_U(0.1)) + CAP(C24, CAP_U(0.1)) + CAP(C25, CAP_U(0.1)) + CAP(C26, CAP_U(0.01)) + CAP(C27, CAP_U(0.1)) + CAP(C28, CAP_U(0.15)) + CAP(C29, CAP_U(0.1)) + CAP(C30, CAP_U(0.01)) + CAP(C31, CAP_U(0.1)) +// CAP(C32, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C33, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C34, CAP_P(470)) -- part of final amp (not emulated) + CAP(C35, CAP_U(0.15)) + CAP(C36, CAP_U(0.1)) + CAP(C37, CAP_U(0.01)) + CAP(C38, CAP_U(0.1)) + CAP(C39, CAP_U(1)) + + D_1N5240(D1) + D_1N914(D2) + D_1N914(D3) + + Q_2N3904(Q1) // NPN + Q_2N3904(Q2) // NPN + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3906(Q5) // PNP + Q_2N3906(Q6) // PNP +// Q_2N6292(Q7) // NPN -- part of final amp (not emulated) +// Q_2N6107(Q9) // PNP -- part of final amp (not emulated) + Q_2N3906(Q8) // PNP + Q_2N3906(Q10) // PNP + + TL081_DIP(IC1) // Op. Amp. +// NET_C(IC1.7, I_V15) // (indirectly via R5) + NET_C(IC1.4, I_VM15) + + TL081_DIP(IC2) // Op. Amp. + NET_C(IC2.7, I_V15) + NET_C(IC2.4, I_VM15) + + TL081_DIP(IC3) // Op. Amp. + NET_C(IC3.7, I_V15) + NET_C(IC3.4, I_VM15) + + LM3900_DIP(IC4) + NET_C(IC4.7, GND) + NET_C(IC4.14, I_V15) + +// TTL_7815_DIP(IC5) // +15V Regulator -- not needed +// TTL_7915_DIP(IC6) // -15V Regulator -- not needed + + LM555_DIP(IC7) + + TL081_DIP(IC8) // Op. Amp. + NET_C(IC8.7, I_V15) + NET_C(IC8.4, I_VM15) + + CA3080_DIP(IC9) + NET_C(IC9.7, I_V15) + NET_C(IC9.4, I_VM15) + + CA3080_DIP(IC10) + NET_C(IC10.7, I_V15) + NET_C(IC10.4, I_VM15) + + LM555_DIP(IC11) + + CA3080_DIP(IC12) + NET_C(IC12.7, I_V15) + NET_C(IC12.4, I_VM15) + + TTL_74LS125_DIP(IC13) // Quad 3-state buffer + NET_C(IC13.7, GND) + NET_C(IC13.14, I_V5) + + LM555_DIP(IC14) + + LM555_DIP(IC15) + + LM555_DIP(IC16) + + CA3080_DIP(IC17) + NET_C(IC17.7, I_V15) + NET_C(IC17.4, I_VM15) + + CA3080_DIP(IC18) + NET_C(IC18.7, I_V15) + NET_C(IC18.4, I_VM15) + + CA3080_DIP(IC19) + NET_C(IC19.7, I_V15) + NET_C(IC19.4, I_VM15) + + TL081_DIP(IC20) // Op. Amp. + NET_C(IC20.7, I_V15) + NET_C(IC20.4, I_VM15) + +#if (HLE_NOISE_GEN) + // + // The "wideband noise gen" relies on properties + // of the components to create noise. Not only + // does this simulate poorly, but it would be too + // slow for realtime, so HLE it with some quality + // noise. + // + // Note that Tail Gunner has the exact same + // circuit. + // + CLOCK(NOISE_CLOCK, 10000) + NET_C(NOISE_CLOCK.GND, GND) + NET_C(NOISE_CLOCK.VCC, I_V5) + + SYS_NOISE_MT_U(NOISE, 3) + NET_C(NOISE.I, NOISE_CLOCK.Q) + NET_C(NOISE.1, GND) + NET_C(NOISE.2, R27.2, R36.1, R43.1) + + NET_C(GND, C1.1, C1.2, C2.1, C2.2, C3.1, C3.2, C4.1, C4.2, C5.1, C5.2) + NET_C(GND, D1.A, D1.K, D2.A, D2.K, D3.A, D3.K) + NET_C(GND, R1.1, R1.2, R3.1, R3.2, R4.1, R4.2, R5.1, R5.2, R6.1, R6.2, R7.1, R7.2, R8.1, R8.2, R9.1, R9.2, R10.1, R10.2) + NET_C(GND, IC1.2, IC1.3, IC1.7, IC2.2, IC2.3, IC3.2, IC3.3) +#else + NET_C(C1.1, C2.2, R1.1, R3.1, C5.2, GND) + NET_C(C1.2, C2.1, D1.K, R5.1, IC1.7) + NET_C(R1.2, C3.1, D1.A) + NET_C(R3.2, R4.1, C4.1) + NET_C(R4.2, C3.2, IC1.3) + NET_C(C4.2, IC1.2, R6.1) + NET_C(R6.2, IC1.6, R7.1) + NET_C(R5.2, C5.1, I_V15) + NET_C(R7.2, IC2.2, R8.1, D3.A, D2.K) + NET_C(IC2.3, GND) + NET_C(IC2.6, R8.2, D3.K, D2.A, R9.1) + NET_C(R9.2, R10.1, IC3.2) + NET_C(IC3.3, GND) + NET_C(IC3.6, R10.2, R43.1, R27.2, R36.1) +#endif + + NET_C(I_OUT_1, R2.1, IC11.2) + NET_C(R2.2, I_V5) + NET_C(IC11.8, IC11.4, I_V5) // -- IC11.4 not documented + NET_C(IC11.3, R35.1) + NET_C(IC11.1, GND) + NET_C(R34.1, I_V5) + NET_C(R34.2, IC11.6, IC11.7, C13.2) + NET_C(C13.1, GND) + + NET_C(R35.2, R17.1, IC4.13) + NET_C(R11.1, R14.1, R17.2, IC4.9) + NET_C(R11.2, IC4.3) + NET_C(R12.1, IC4.2) + NET_C(R12.2, R16.2, R18.2, Q2.C, R22.2, I_V15) + NET_C(IC4.4, R13.1) + NET_C(R13.2, C6.2, IC4.6) + NET_C(R14.2, IC4.1) + NET_C(IC4.5, C6.1, R15.1, Q1.B) + NET_C(R15.2, R16.1, IC4.8) + + NET_C(Q1.C, R18.1, Q2.B) + NET_C(Q1.E, R19.2) + NET_C(R19.1, GND) + NET_C(Q2.E, Q3.B, R20.2) + NET_C(R20.1, I_VM15) + NET_C(Q3.E, R21.1) + NET_C(R21.2, R22.1, R23.2) + NET_C(R23.1, GND) + NET_C(Q3.C, IC12.5) + + NET_C(R36.2, C14.1) + NET_C(C14.2, R37.2, R40.2, C15.1) + NET_C(R37.1, GND) + +#if (HLE_WHOOSH_MOD) + // + // The "whoosh" sound has a noise modulator that is a steady + // clock ~64.5Hz, generated by an LM3900 and an RC network. + // When run at 48kHz, this network does not clock at the + // correct frequency, so HLE this with a basic clock. + // + CLOCK(WHOOSH_CLK, 64.5) + NET_C(WHOOSH_CLK.GND, GND) + NET_C(WHOOSH_CLK.VCC, I_V15) + NET_C(WHOOSH_CLK.Q, R40.1) + NET_C(GND, C21.1, C21.2, R38.1, R38.2, R39.1, R39.2, R47.1, R47.2, R48.1, R48.2, IC4.11, IC4.12) +#else + NET_C(R40.1, R38.2, IC4.10, R48.2) + NET_C(C21.2, R38.1, R39.2) + NET_C(C21.1, GND) + NET_C(R39.1, IC4.11) + NET_C(I_V15, R47.1) + NET_C(R47.2, IC4.12, R48.1) +#endif + + NET_C(C15.2, R41.2, IC12.2) + NET_C(R41.1, R42.1, GND) + NET_C(R42.2, IC12.3) + NET_C(IC12.6, IC10.6, IC9.6, IC17.6, IC18.6, IC19.6, R64.1) + + NET_C(I_OUT_2, R24.1, IC7.2) + NET_C(R25.1, IC7.6, IC7.7, C7.1) + NET_C(C7.2, IC7.1, GND) + NET_C(R24.2, I_V5) + NET_C(R25.2, IC7.8, IC7.4, I_V5) // IC7.4 -- not documented + NET_C(IC7.3, Q4.E) + NET_C(Q4.B, R26.2) + NET_C(R26.1, GND) + NET_C(Q4.C, C8.1, R30.1) + NET_C(C8.2, I_VM15) + NET_C(R30.2, IC10.5) + + NET_C(R27.1, C9.2, R28.1) + NET_C(C9.1, GND) + NET_C(R28.2, C10.1) + NET_C(C10.2, C11.1, R29.1, IC8.2) + NET_C(IC8.3, GND) + NET_C(IC8.6, C11.2, R29.2, R31.1) + NET_C(R31.2, C12.1) + NET_C(C12.2, R32.2, IC10.2) + NET_C(R32.1, R33.1, GND) + NET_C(R33.2, IC10.3) + + NET_C(R43.2, C22.1) + NET_C(C22.2, R44.2, C23.1) + NET_C(R44.1, GND) + NET_C(C23.2, R45.2, IC9.2) + NET_C(R45.1, GND) + NET_C(R46.1, GND) + NET_C(R46.2, IC9.3) + + NET_C(I_OUT_7, IC13.1) + NET_C(I_V5, R49.2) + NET_C(R49.1, IC13.2, IC13.5, IC13.9, IC13.12) + NET_C(IC13.3, Q5.E) + NET_C(Q5.B, R50.2) + NET_C(R50.1, GND) + NET_C(Q5.C, C24.2, R51.1) + NET_C(C24.1, I_VM15) + NET_C(R51.2, IC9.5) + + NET_C(I_OUT_3, IC13.4) + NET_C(IC13.6, Q6.E) + NET_C(Q6.B, R57.2) + NET_C(R57.1, GND) + NET_C(Q6.C, C28.1, R58.1) + NET_C(C28.2, I_VM15) + NET_C(R58.2, IC17.5) + NET_C(IC14.4, IC14.8, I_V5) + NET_C(IC14.3, R52.1) + NET_C(R52.2, C25.1) + NET_C(C25.2, R55.2, IC17.2) + NET_C(IC14.2, IC14.6, R54.1, R53.2, C27.2) + NET_C(R54.2, I_V5) + NET_C(C27.1, GND) + NET_C(IC14.7, R53.1) + NET_C(IC14.5, C26.2) + NET_C(C26.1, GND) + NET_C(IC14.1, GND) + NET_C(R55.1, GND) + NET_C(R56.1, GND) + NET_C(R56.2, IC17.3) + + NET_C(I_OUT_4, IC13.10) + NET_C(IC13.8, Q8.E) + NET_C(Q8.B, R68.2) + NET_C(R68.1, GND) + NET_C(Q8.C, C35.1, R69.1) + NET_C(C35.2, I_VM15) + NET_C(R69.2, IC18.5) + NET_C(IC15.4, IC15.8, I_V5) + NET_C(IC15.3, R59.1) + NET_C(R59.2, C29.1) + NET_C(C29.2, R62.2, IC18.2) + NET_C(IC15.2, IC15.6, R61.1, R60.2, C31.2) + NET_C(R61.2, I_V5) + NET_C(C31.1, GND) + NET_C(IC15.7, R60.1) + NET_C(IC15.5, C30.2) + NET_C(C30.1, GND) + NET_C(IC15.1, GND) + NET_C(R62.1, GND) + NET_C(R63.1, GND) + NET_C(R63.2, IC18.3) + + NET_C(I_OUT_0, IC13.13) + NET_C(IC13.11, Q10.E) + NET_C(Q10.B, R77.2) + NET_C(R77.1, GND) + NET_C(Q10.C, C39.1, R78.1) + NET_C(C39.2, I_VM15) + NET_C(R78.2, IC19.5) + NET_C(IC16.4, IC16.8, I_V5) + NET_C(IC16.3, R70.1) + NET_C(R70.2, C36.1) + NET_C(C36.2, R73.2, IC19.2) + NET_C(IC16.2, IC16.6, R72.1, R71.2, C38.2) + NET_C(R72.2, I_V5) + NET_C(C38.1, GND) + NET_C(IC16.7, R71.1) + NET_C(IC16.5, C37.2) + NET_C(C37.1, GND) + NET_C(IC16.1, GND) + NET_C(R73.1, GND) + NET_C(R74.1, GND) + NET_C(R74.2, IC19.3) + + ALIAS(OUTPUT, R64.1) + NET_C(R64.2, GND) + + + // + // Unconnected pins + // + + NET_C(GND, IC20.2, IC20.3) // part of final amp + +// NET_C(GND, IC6.3, IC28.8, IC28.9, IC28.10, IC28.11) + +NETLIST_END() diff --git a/src/mame/audio/nl_sundance.h b/src/mame/audio/nl_sundance.h new file mode 100644 index 00000000000..0e926c7fea6 --- /dev/null +++ b/src/mame/audio/nl_sundance.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_SUNDANCE_H +#define MAME_AUDIO_NL_SUNDANCE_H + +#pragma once + +NETLIST_EXTERNAL(sundance) + +#endif // MAME_AUDIO_NL_SUNDANCE_H diff --git a/src/mame/audio/nl_tailg.cpp b/src/mame/audio/nl_tailg.cpp new file mode 100644 index 00000000000..c7a24f45215 --- /dev/null +++ b/src/mame/audio/nl_tailg.cpp @@ -0,0 +1,698 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Tail Gunner +// +// Derived from the schematics and parts list in the +// Tail Gunner manual. +// +// Known problems/issues: +// +// * The diodes (D8/D9) connected to LS123 Rext/Cext pins +// cause major performance issues. Snipping them out +// seems to have no effect apart from giving back all +// the lost performance. +// +// * The "wideband noise generator" is simulated with a generic +// noise source. This seems to work fine and doesn't sound +// too different from recordings. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_tailg.h" + + +// +// Optimizations +// + +#define HLE_NOISE_GEN (1) +#define HLE_HYPERSPACE_VCO (1) +#define HLE_LASER_VCO (1) +#define REMOVE_LS123_DIODES (1) +#define ADD_LS125_PULLUPS (1) + + +// +// Main netlist +// + +NETLIST_START(tailg) + +#if (HLE_HYPERSPACE_VCO && HLE_LASER_VCO) + SOLVER(Solver, 1000) +#else + SOLVER(Solver, 48000000) +#endif + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_M(1)) + RES(R2, RES_K(470)) + RES(R3, 470) + RES(R4, RES_K(470)) + RES(R5, 100) + RES(R6, RES_K(10)) + RES(R7, RES_M(1)) + RES(R8, RES_K(10)) + RES(R9, RES_K(47)) + RES(R10, RES_K(1)) + RES(R11, RES_K(330)) + RES(R12, RES_K(9.1)) + RES(R13, RES_M(1)) + RES(R14, RES_K(20)) + RES(R15, RES_K(10)) + RES(R16, RES_K(1)) + RES(R17, RES_K(10)) + RES(R18, RES_K(20)) + RES(R19, RES_K(39)) + RES(R20, RES_K(82)) + RES(R21, RES_K(2.7)) + RES(R22, RES_K(1)) + RES(R23, RES_K(10)) + RES(R24, RES_K(47)) + RES(R25, RES_K(330)) + RES(R26, RES_K(10)) + RES(R27, RES_K(2.7)) + RES(R28, RES_K(2.7)) + RES(R29, 150) + RES(R30, RES_K(10)) + RES(R31, RES_M(1)) + RES(R32, RES_K(20)) + RES(R33, RES_K(10)) + RES(R34, RES_K(1)) + RES(R35, RES_K(10)) + RES(R36, RES_K(20)) + RES(R37, RES_K(39)) + RES(R38, RES_K(82)) + RES(R39, RES_K(100)) + RES(R40, RES_K(68)) + RES(R41, 330) + RES(R42, 330) + RES(R43, RES_K(560)) + RES(R44, RES_K(30)) + RES(R45, RES_K(1)) + RES(R46, 330) + RES(R47, RES_K(220)) + RES(R48, RES_K(2.7)) + RES(R49, RES_K(2.7)) + RES(R50, RES_K(820)) + RES(R51, RES_K(360)) + RES(R52, RES_K(330)) + RES(R53, RES_K(150)) + RES(R54, RES_K(4.7)) + RES(R55, RES_K(390)) + RES(R56, RES_K(910)) + RES(R57, RES_K(4.7)) + RES(R58, RES_K(2)) + RES(R59, RES_K(10)) + RES(R60, RES_K(1)) + RES(R61, RES_K(4.7)) + RES(R62, RES_K(20)) + RES(R63, RES_K(180)) + RES(R64, RES_K(10)) + RES(R65, RES_K(20)) + RES(R66, RES_K(15)) + RES(R67, RES_K(10)) + RES(R68, RES_K(20)) + RES(R69, RES_K(30)) + RES(R70, 470) +// RES(R71, 150) -- part of final amp (not emulated) +// RES(R72, RES_K(22)) -- part of final amp (not emulated) +// RES(R73, 150) -- part of final amp (not emulated) +// RES(R74, RES_K(47)) -- part of final amp (not emulated) +// POT(R75, RES_K(100)) -- part of final amp (not emulated) +// PARAM(R75.DIAL, 0.5) -- part of final amp (not emulated) + RES(R76, RES_K(47)) + RES(R77, RES_K(47)) + RES(R78, RES_K(2.7)) + RES(R79, RES_K(2.7)) + RES(R80, RES_K(100)) + RES(R81, RES_K(1)) + RES(R82, RES_K(330)) + RES(R83, RES_K(10)) + RES(R84, RES_K(91)) + + CAP(C1, CAP_U(100)) + CAP(C2, CAP_U(0.1)) + CAP(C3, CAP_U(0.01)) + CAP(C4, CAP_U(0.1)) + CAP(C5, CAP_U(100)) + CAP(C6, CAP_U(0.68)) + CAP(C7, CAP_U(0.1)) + CAP(C8, CAP_U(1)) + CAP(C9, CAP_U(0.1)) + CAP(C10, CAP_U(0.1)) + CAP(C11, CAP_U(0.005)) + CAP(C12, CAP_U(0.1)) + CAP(C13, CAP_U(0.1)) + CAP(C14, CAP_U(0.05)) + CAP(C15, CAP_U(10)) + CAP(C16, CAP_U(10)) + CAP(C17, CAP_U(0.002)) + CAP(C18, CAP_U(0.01)) + CAP(C19, CAP_U(0.01)) + CAP(C20, CAP_U(0.01)) + CAP(C21, CAP_U(0.1)) + CAP(C22, CAP_U(0.1)) + CAP(C23, CAP_U(0.01)) + CAP(C24, CAP_U(15)) + CAP(C25, CAP_U(0.22)) + CAP(C26, CAP_U(4.7)) + CAP(C27, CAP_U(0.1)) + CAP(C28, CAP_U(0.47)) + CAP(C29, CAP_U(0.47)) + CAP(C30, CAP_U(0.01)) + CAP(C31, CAP_U(0.05)) + CAP(C32, CAP_U(0.1)) + CAP(C33, CAP_U(0.1)) +// CAP(C34, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C35, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C36, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C37, CAP_U(3.3)) +// CAP(C38, CAP_U(3.3)) +// CAP(C39, CAP_U(3.3)) +// CAP(C40, CAP_U(3.3)) + CAP(C41, CAP_U(0.005)) + CAP(C42, CAP_U(0.1)) + CAP(C43, CAP_U(10)) + CAP(C44, CAP_U(2.2)) + + D_1N5240(D1) + D_1N914(D2) + D_1N914(D3) + D_1N914(D4) + D_1N914(D5) + D_1N914(D6) + D_1N914(D7) + D_1N914(D8) + D_1N914(D9) + + Q_2N3904(Q1) // NPN + Q_2N3904(Q2) // NPN + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3906(Q5) // PNP +// Q_2N6292(Q6) // NPN -- part of final amp (not emulated) +// Q_2N6107(Q7) // PNP -- part of final amp (not emulated) + Q_2N3906(Q8) // PNP + + TL081_DIP(IC1) // Op. Amp. +// NET_C(IC1.7, I_V15) // (indirectly via R5) + NET_C(IC1.4, I_VM15) + + TL081_DIP(IC2) // Op. Amp. + NET_C(IC2.4, I_VM15) + NET_C(IC2.7, I_V15) + + TL081_DIP(IC3) // Op. Amp. + NET_C(IC3.4, I_VM15) + NET_C(IC3.7, I_V15) + + TTL_74LS125_DIP(IC4) // Quad 3-state Buffers + NET_C(IC4.7, GND) + NET_C(IC4.14, I_V5) + + TTL_7404_DIP(IC5) // Hex Inverting Gates + NET_C(IC5.7, GND) + NET_C(IC5.14, I_V5) + + TTL_7406_DIP(IC6) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(IC6.7, GND) + NET_C(IC6.14, I_V5) + + TL081_DIP(IC7) // Op. Amp. + NET_C(IC7.4, I_VM15) + NET_C(IC7.7, I_V15) + + TTL_74LS393_DIP(IC8) // Dual 4-Stage Binary Counter + NET_C(IC8.7, GND) + NET_C(IC8.14, I_V5) + + TL081_DIP(IC9) // Op. Amp. + NET_C(IC9.4, I_VM15) + NET_C(IC9.7, I_V15) + + CA3080_DIP(IC10) // Op. Amp. + NET_C(IC10.4, I_VM15) + NET_C(IC10.7, I_V15) + + TL081_DIP(IC11) // Op. Amp. + NET_C(IC11.4, I_VM15) + NET_C(IC11.7, I_V15) + + TTL_74LS123_DIP(IC12) // Retriggerable Monostable Multivibrators + NET_C(IC12.8, GND) + NET_C(IC12.16, I_V5) + + CA3080_DIP(IC13) // Op. Amp. + NET_C(IC13.4, I_VM15) + NET_C(IC13.7, I_V15) + + LM555_DIP(IC14) + + LM555_DIP(IC15) + + LM555_DIP(IC16) + + LM555_DIP(IC17) + + TTL_74LS393_DIP(IC18) // Dual 4-Stage Binary Counter + NET_C(IC18.7, GND) + NET_C(IC18.14, I_V5) + + TL081_DIP(IC19) // Op. Amp. + NET_C(IC19.4, I_VM15) + NET_C(IC19.7, I_V15) + +// TTL_7915_DIP(IC20) // -15V Regulator -- not needed +// TTL_7815_DIP(IC21) // +15V Regulator -- not needed + + CA3080_DIP(IC22) // Op. Amp. + NET_C(IC22.4, I_VM15) + NET_C(IC22.7, I_V15) + + TTL_74LS259_DIP(IC23) + NET_C(IC23.8, GND) + NET_C(IC23.16, I_V5) + +#if (HLE_NOISE_GEN) + // + // The "wideband noise gen" relies on properties + // of the components to create noise. Not only + // does this simulate poorly, but it would be too + // slow for realtime, so HLE it with some quality + // noise. + // + // Note that Sundance has the exact same circuit. + // + CLOCK(NOISE_CLOCK, 10000) + NET_C(NOISE_CLOCK.GND, GND) + NET_C(NOISE_CLOCK.VCC, I_V5) + + SYS_NOISE_MT_U(NOISE, 3) + NET_C(NOISE.I, NOISE_CLOCK.Q) + NET_C(NOISE.1, GND) + NET_C(NOISE.2, R9.2, R23.2, R55.2, R76.1) + + NET_C(GND, C1.1, C1.2, C2.1, C2.2, C3.1, C3.2, C4.1, C4.2, C5.1, C5.2) + NET_C(GND, D1.A, D1.K, D2.A, D2.K, D3.A, D3.K) + NET_C(GND, R1.1, R1.2, R2.1, R2.2, R3.1, R3.2, R4.1, R4.2, R5.1, R5.2, R6.1, R6.2, R7.1, R7.2, R8.1, R8.2, R9.1) + NET_C(GND, IC1.2, IC1.3, IC1.7, IC2.2, IC2.3, IC3.2, IC3.3) +#else + NET_C(C1.1, GND) + NET_C(C1.2, C2.2, D1.K, IC1.7, R5.1) + NET_C(C2.1, GND) + NET_C(D1.A, C3.1, R1.2) + NET_C(R1.1, GND) + NET_C(C3.2, R2.2, IC1.2) + NET_C(R3.1, GND) + NET_C(R2.1, C4.1, R3.2) + NET_C(C4.2, IC1.3, R4.1) + NET_C(R4.2, IC1.6, R6.1) + NET_C(R5.2, C5.1, I_V15) + NET_C(C5.2, GND) + + NET_C(R6.2, IC2.2, R7.1, D3.A, D2.K) + NET_C(IC2.3, GND) + NET_C(IC2.6, R7.2, D3.K, D2.A, R8.1) + NET_C(R8.2, IC3.2, R9.1) + NET_C(IC3.3, GND) + NET_C(IC3.6, R9.2, R23.2, R55.2, R76.1) +#endif + + // + // Input mux + // + + NET_C(I_OUT_0, IC23.1) + NET_C(I_OUT_1, IC23.2) + NET_C(I_OUT_2, IC23.3) + NET_C(I_OUT_3, IC23.13) + NET_C(I_OUT_4, IC23.14) + NET_C(IC23.15, I_V5) + + NET_C(R23.1, R24.1, C9.2) + NET_C(C9.1, GND) + NET_C(R24.2, C10.1) + NET_C(C10.2, IC9.2, R25.1, C11.1) + NET_C(IC9.3, GND) + NET_C(IC9.6, R25.2, C11.2, R26.1) + NET_C(R26.2, C12.1) + NET_C(C12.2, R27.2, IC10.2) + NET_C(R27.1, GND) + NET_C(IC10.3, R28.2) + NET_C(R28.1, GND) + NET_C(IC10.6, R70.1) + + // + // Explosion + // + + NET_C(IC23.4, IC12.1) + NET_C(IC12.14, C15.2) + +#if (REMOVE_LS123_DIODES) + // + // The diodes connected to the Rext/Cext pins on the + // LS123 (monostable multivibrators) absolutely tank + // performance for reasons yet not understood. Their + // purpose is unclear, and removing them seems to have + // no effect on the sound, while fixing the performance + // so we'll just snip them out for now. + // + NET_C(IC12.15, C15.1, R39.1) + NET_C(GND, D8.A, D8.K) +#else + NET_C(IC12.15, D8.K) + NET_C(D8.A, C15.1, R39.1) +#endif + + NET_C(R39.2, IC12.2, IC12.3, I_V5) + NET_C(IC12.13, Q3.E) + NET_C(Q3.B, R42.2) + NET_C(R42.1, GND) + NET_C(Q3.C, R43.2, C16.1, R44.1) + NET_C(C16.2, I_VM15) + NET_C(R44.2, IC10.5) + + // + // Rumble + // + + NET_C(IC23.5, IC6.5) + NET_C(IC6.6, R40.1, Q4.E) + NET_C(R40.2, I_V5) + NET_C(Q4.B, R41.2) + NET_C(R41.1, GND) + NET_C(Q4.C, R43.1) + + // + // Shield + // + + NET_C(IC23.7, IC4.13) + NET_C(I_V5, R45.1) + NET_C(R45.2, IC4.12) + NET_C(IC4.11, Q5.E) + NET_C(Q5.B, R46.2) + NET_C(R46.1, GND) + NET_C(Q5.C, R47.1) + NET_C(R47.2, IC13.5) + NET_C(IC13.6, R70.1) + + NET_C(I_V15, R54.2, IC16.4, IC16.8) + NET_C(R54.1, IC16.7, R56.2) + NET_C(R56.1, IC16.6, IC16.2, C22.2) + NET_C(C22.1, IC16.1, C23.1, GND) + NET_C(C23.2, IC16.5) + NET_C(IC16.3, R57.1) + NET_C(R57.2, C24.1, R58.1) + NET_C(C24.2, GND) + NET_C(R58.2, C26.1, C25.1) + NET_C(C26.2, GND) + NET_C(C25.2, C27.1, R48.2, IC13.2, C21.1) + NET_C(R48.1, GND) + NET_C(IC13.3, R49.2) + NET_C(R49.1, GND) + NET_C(C27.2, R59.1) + NET_C(R59.2, C28.1, R60.1) + NET_C(C28.2, GND) + NET_C(R60.2, C29.1, R62.1) + NET_C(C29.2, GND) + NET_C(R62.2, IC17.3) + NET_C(IC17.7, R61.2, R63.2) + NET_C(R61.1, IC17.4, IC17.8, I_V15) + NET_C(R63.1, IC17.6, IC17.2, C31.2) + NET_C(C31.1, IC17.1, C30.1, GND) + NET_C(C30.2, IC17.5) + NET_C(C21.2, R55.1) + + // + // Hyperspace + // + + NET_C(IC23.10, IC4.1) + NET_C(IC4.2, GND) + +#if (ADD_LS125_PULLUPS) + // + // The 74LS125 is being abuse here, assuming the tristate + // will pull high instead of low. This is not how it is + // modelled, so add a pullup resistor between the output + // and the TTL source. + // + RES(RTEMP1, RES_K(1)) + NET_C(RTEMP1.1, I_V5) + NET_C(IC4.3, RTEMP1.2) +#endif + + NET_C(IC4.3, IC5.5, IC8.12) + NET_C(IC5.6, IC6.1) + NET_C(IC6.2, R10.1, R11.1) + NET_C(R10.2, I_V5) + NET_C(R11.2, D4.K, C6.1) + NET_C(C6.2, GND) + +#if (HLE_HYPERSPACE_VCO) + // + // The hyperspace VCO is troublesome to emulate without + // cranking up the solver frequency, so model it instead. + // Take the voltage at C6.1 and map it to the TTL + // frequency at IC8.13, then remove the circuit in favor + // of a variable clock. + // + // Here is the mapping I get for C6.1 vs IC8.13 half-period: + // R2 = 0.99919: HP = (0.000070760*A0) + 0.0000496821 + // R2 = 0.99991: HP = (0.00000141986*A0*A0) + (0.0000592676*A0) + 0.000067917 + // R2 = 0.99995: HP = (0.000000176200*A0*A0*A0) - (0.000000394224*A0*A0) + (0.000064351*A0) + 0.000063955 + // R2 = 0.99995: HP = (-0.00000000225454*A0*A0*A0*A0) + (0.000000207009*A0*A0*A0) - (0.000000529599*A0*A0) + (0.000064557*A0) + 0.000063885 + // R2 = 0.99995: HP = (0.0000000099503*A0*A0*A0*A0*A0) - (0.000000173841*A0*A0*A0*A0) + (0.00000127300*A0*A0*A0) - (0.00000339043*A0*A0) + (0.000067595*A0) + 0.000063196 + // + // However, when we clip the circuit, the C6.1 values change, + // so here is a mapping for the clipped C6.1 vs. the original + // IC8.13 half-period: + // + // R2 = 0.97319: HP = (0.0000572507*A0) + 0.000194746 + // R2 = 0.97692: HP = (0.00000283778*A0*A0) + (0.0000473318*A0) + 0.000197383 + // R2 = 0.97785: HP = (-0.00000116165*A0*A0*A0) + (0.0000100018*A0*A0) + (0.0000372162*A0) + 0.000199308 + // R2 = 0.97830: HP = (-0.000000661779*A0*A0*A0*A0) + (0.00000465155*A0*A0*A0) - (0.00000545641*A0*A0) + (0.0000499499*A0) + 0.000197353 + // R2 = 0.97930: HP = (-0.000000814292*A0*A0*A0*A0*A0) + (0.0000086074*A0*A0*A0*A0) - (0.0000317523*A0*A0*A0) + (0.0000522027*A0*A0) + (0.0000173329*A0) + 0.000201604 + // + VARCLOCK(HYPERCLK, 1, "max(0.000001,min(0.1,(-0.000000814292*A0*A0*A0*A0*A0) + (0.0000086074*A0*A0*A0*A0) - (0.0000317523*A0*A0*A0) + (0.0000522027*A0*A0) + (0.0000173329*A0) + 0.000201604))") + NET_C(HYPERCLK.GND, GND) + NET_C(HYPERCLK.VCC, I_V5) + NET_C(HYPERCLK.Q, IC8.13) + NET_C(HYPERCLK.A0, C6.1) + NET_C(GND, R12.1, R12.2, R13.1, R13.2, R14.1, R14.2, R15.1, R15.2, R16.1, R16.2, C7.1, C7.2, D4.A, D5.A, D5.K, IC7.2, IC7.3, IC5.1) + HINT(IC5.2, NC) +#else + NET_C(D4.A, IC7.3, D5.K, R13.1) + NET_C(IC7.2, C7.2, R12.1) + NET_C(C7.1, GND) + NET_C(R12.2, IC7.6, R13.2, R14.1) + NET_C(D5.A, GND) + NET_C(R14.2, R15.2, Q1.B) + NET_C(R15.1, GND) + NET_C(Q1.E, GND) + NET_C(Q1.C, R16.1, IC5.1) + NET_C(R16.2, I_V5) + NET_C(IC5.2, IC8.13) +#endif + + NET_C(IC8.9, R17.1) + NET_C(IC8.8, R18.1) + NET_C(IC8.10, R19.1) + NET_C(IC8.11, R20.1) + NET_C(R17.2, R18.2, R19.2, R20.2, R22.2, R21.1) + NET_C(R22.1, GND) + NET_C(R21.2, C8.1) + NET_C(C8.2, R70.1) + + // + // Laser + // + + NET_C(IC23.6, IC4.4) + NET_C(IC4.5, GND) + +#if (ADD_LS125_PULLUPS) + // + // see previous comment about why this is necessary + // + RES(RTEMP2, RES_K(1)) + NET_C(RTEMP2.1, I_V5) + NET_C(IC4.6, RTEMP2.2) +#endif + + NET_C(IC4.6, IC8.2, IC6.3) + NET_C(IC6.4, R29.1) + NET_C(R29.2, D6.K, C13.2) + NET_C(C13.1, GND) + +#if (HLE_LASER_VCO) + // + // The laser VCO is almost identical to the hyperspace VCO, + // apart from the component values. The same approach is used + // for HLE. + // + // Here is the mapping I get for C13.2 vs IC8.1 half-period: + // R2 = 0.99489: HP = (0.0000346649*A0) + 0.0000391143 + // R2 = 0.99489: HP = (0.0000000539278*A0*A0) + (0.0000345904*A0) + 0.0000391217 + // R2 = 0.99491: HP = (0.00000116177*A0*A0*A0) - (0.00000273810*A0*A0) + (0.0000362549*A0) + 0.0000389782 + // R2 = 0.99502: HP = (-0.00000728180*A0*A0*A0*A0) + (0.0000256184*A0*A0*A0) - (0.0000288539*A0*A0) + (0.0000456890*A0) + 0.0000382619 + // R2 = 0.99526: HP = (0.0000241755*A0*A0*A0*A0*A0) - (0.000110184*A0*A0*A0*A0) + (0.000181339*A0*A0*A0) - (0.000128682*A0*A0) + (0.000070619*A0) + 0.0000366068 + // + // And here is the mapping for the clipped C13.2 vs the original + // IC8.1 half-period: + // R2 = 0.10697: HP = (0.000449852*A0) - 0.000000764127 + // R2 = 0.99164: HP = (0.0445612*A0*A0) - (0.00441596*A0) + 0.0000386659 + // R2 = 0.99165: HP = (0.0576325*A0*A0*A0) + (0.0325274*A0*A0) - (0.00378669*A0) + 0.0000384468 + // R2 = 0.99422: HP = (-37.92188*A0*A0*A0*A0) + (11.77137*A0*A0*A0) - (1.173779*A0*A0) + (0.0377702*A0) + 0.0000242577 + // R2 = 0.99536: HP = (-1435.864*A0*A0*A0*A0*A0) + (418.8404*A0*A0*A0*A0) - (37.19112*A0*A0*A0) + (0.653446*A0*A0) + (0.0314777*A0) + 0.0000261637 + // + VARCLOCK(LASERCLK, 1, "max(0.000001,min(0.1,(0.0576325*A0*A0*A0) + (0.0325274*A0*A0) - (0.00378669*A0) + 0.0000384468))") + NET_C(LASERCLK.GND, GND) + NET_C(LASERCLK.VCC, I_V5) + NET_C(LASERCLK.Q, IC8.1) + NET_C(LASERCLK.A0, C13.2) + NET_C(GND, R30.1, R30.2, R31.1, R31.2, R32.1, R32.2, R33.1, R33.2, R34.1, R34.2, C14.1, C14.2, D6.A, D7.A, D7.K, IC11.2, IC11.3, IC5.3) + HINT(IC5.4, NC) +#else + NET_C(D6.A, IC11.3, D7.K, R31.1) + NET_C(D7.A, GND) + NET_C(IC11.2, C14.2, R30.1) + NET_C(C14.1, GND) + NET_C(IC11.6, R30.2, R31.2, R32.1) + NET_C(R32.2, R33.2, Q2.B) + NET_C(R33.1, GND) + NET_C(Q2.E, GND) + NET_C(Q2.C, R34.1, IC5.3) + NET_C(R34.2, I_V5) + NET_C(IC5.4, IC8.1) +#endif + + NET_C(IC8.5, R35.1) + NET_C(IC8.6, R36.1) + NET_C(IC8.4, R37.1) + NET_C(IC8.3, R38.1) + NET_C(R35.2, R36.2, R37.2, R38.2, R21.1) + + // + // Shield Bounce + // + + NET_C(R50.2, I_V5, IC14.4, IC14.8) + NET_C(R50.1, R51.1, IC14.6, IC14.2, C17.2) + NET_C(R51.2, IC14.7) + NET_C(C17.1, IC14.1, C18.1, GND) + NET_C(C18.2, IC14.5) + NET_C(IC14.3, IC18.1) + NET_C(IC18.2, GND) + NET_C(IC18.4, R64.2) + NET_C(R64.1, R65.1, C32.2) + NET_C(IC18.6, R65.2) + NET_C(C32.1, R66.2) + NET_C(R66.1, R69.1, IC22.2, R78.2, C42.2) + + NET_C(R52.2, I_V5, IC15.4, IC15.8) + NET_C(R52.1, R53.1, IC15.6, IC15.2, C19.2) + NET_C(R53.2, IC15.7) + NET_C(C19.1, IC15.1, C20.1, GND) + NET_C(C20.2, IC15.5) + NET_C(IC15.3, IC18.13) + NET_C(IC18.12, GND) + NET_C(IC18.8, R67.2) + NET_C(R67.1, R68.1, C33.2) + NET_C(IC18.11, R68.2) + NET_C(C33.1, R69.2) + + NET_C(C42.1, R77.2, C41.2) + NET_C(R77.1, GND) + NET_C(C41.1, R76.2) + + NET_C(R78.1, GND) + NET_C(IC22.3, R79.2) + NET_C(R79.1, GND) + + NET_C(IC23.9, IC12.9) + NET_C(IC12.6, C43.2) + +#if (REMOVE_LS123_DIODES) + // + // A second instance of problematic diode; see above + // comment for an explanation. + // + NET_C(C43.1, R80.1, IC12.7) + NET_C(GND, D9.A, D9.K) +#else + NET_C(C43.1, D9.A, R80.1) + NET_C(D9.K, IC12.7) +#endif + + NET_C(R80.2, IC12.10, IC12.11, I_V5) + + NET_C(IC12.12, IC4.10) + NET_C(IC4.9, R81.2) + NET_C(R81.1, I_V5) + NET_C(IC4.8, Q8.E) + NET_C(Q8.B, R82.2) + NET_C(R82.1, GND) + NET_C(Q8.C, R83.1) + NET_C(R83.2, C44.1, R84.1) + NET_C(C44.2, I_VM15) + NET_C(R84.2, IC22.5) + NET_C(IC22.6, R70.1) + + // + // Final amp + // + +//NET_C(R70.1, GND) // temp + ALIAS(OUTPUT, R70.1) + NET_C(R70.2, GND) + + // + // Unconnected inputs + // + + NET_C(GND, IC19.2, IC19.3) // part of final amp + NET_C(GND, IC5.9, IC5.11, IC5.13, IC6.9, IC6.11, IC6.13) + + // + // Unconnected outputs + // + + HINT(IC5.8, NC) // QC + HINT(IC5.10, NC) // QD + HINT(IC5.12, NC) // QE + HINT(IC6.8, NC) // QC + HINT(IC6.10, NC) // QD + HINT(IC6.12, NC) // QE + HINT(IC12.4, NC) // /QA + HINT(IC12.5, NC) // QB + HINT(IC18.3, NC) // Q0A + HINT(IC18.5, NC) // Q2A + HINT(IC18.9, NC) // Q2B + HINT(IC18.10, NC) // Q1B + HINT(IC23.11, NC) // Q6 + HINT(IC23.12, NC) // Q7 + +NETLIST_END() diff --git a/src/mame/audio/nl_tailg.h b/src/mame/audio/nl_tailg.h new file mode 100644 index 00000000000..d2bdc2311f8 --- /dev/null +++ b/src/mame/audio/nl_tailg.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_TAILG_H +#define MAME_AUDIO_NL_TAILG_H + +#pragma once + +NETLIST_EXTERNAL(tailg) + +#endif // MAME_AUDIO_NL_TAILG_H diff --git a/src/mame/audio/nl_warrior.cpp b/src/mame/audio/nl_warrior.cpp new file mode 100644 index 00000000000..00c7f351726 --- /dev/null +++ b/src/mame/audio/nl_warrior.cpp @@ -0,0 +1,490 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles + +// +// Netlist for Warrior +// +// Derived from the schematics in the Warrior manual. +// +// Known problems/issues: +// +// * Not yet tested. +// + +#include "netlist/devices/net_lib.h" +#include "nl_cinemat_common.h" +#include "nl_warrior.h" + + +// +// Optimizations +// + +#define HLE_NOISE_GEN (1) +#define HLE_PITFALL_VCO (1) + + + +// +// Main netlist +// + +NETLIST_START(warrior) + +#if (HLE_PITFALL_VCO) + SOLVER(Solver, 1000) +#else + SOLVER(Solver, 48000000) +#endif + PARAM(Solver.DYNAMIC_TS, 1) + PARAM(Solver.DYNAMIC_MIN_TIMESTEP, 2e-5) + + TTL_INPUT(I_OUT_0, 0) // active high + TTL_INPUT(I_OUT_1, 0) // active high + TTL_INPUT(I_OUT_2, 0) // active high + TTL_INPUT(I_OUT_3, 0) // active high + TTL_INPUT(I_OUT_4, 0) // active high + + NET_C(GND, I_OUT_0.GND, I_OUT_1.GND, I_OUT_2.GND, I_OUT_3.GND, I_OUT_4.GND) + NET_C(I_V5, I_OUT_0.VCC, I_OUT_1.VCC, I_OUT_2.VCC, I_OUT_3.VCC, I_OUT_4.VCC) + + CINEMAT_LOCAL_MODELS + + ANALOG_INPUT(I_V5, 5) + ANALOG_INPUT(I_V15, 15) + ANALOG_INPUT(I_VM15, -15) + + RES(R1, RES_K(10)) + RES(R2, RES_K(47)) + RES(R3, RES_K(330)) + RES(R4, RES_K(10)) + RES(R5, RES_K(2.7)) + RES(R6, RES_K(2.7)) + RES(R7, RES_K(4.7)) + RES(R8, RES_K(8.2)) + RES(R9, RES_K(2.7)) + RES(R10, RES_K(2.7)) + RES(R11, 470) + RES(R12, RES_K(470)) + RES(R13, 330) + RES(R14, RES_K(30)) + RES(R15, 100) + RES(R16, RES_M(1)) + RES(R17, RES_M(1)) + RES(R18, RES_K(470)) + RES(R19, 470) + RES(R20, RES_K(470)) + RES(R21, RES_K(10)) + RES(R22, RES_K(10)) + RES(R23, RES_K(47)) + RES(R24, RES_K(1)) + RES(R25, RES_K(510)) + RES(R26, 330) + RES(R27, 330) + RES(R28, RES_K(120)) + RES(R29, RES_K(82)) + RES(R30, 330) + RES(R31, RES_K(4.7)) + RES(R32, RES_K(910)) + RES(R33, RES_K(4.7)) + RES(R34, RES_K(2)) + RES(R35, RES_K(390)) + RES(R36, RES_K(4.7)) + RES(R37, RES_K(180)) + RES(R38, RES_K(20)) + RES(R39, RES_K(1)) + RES(R40, RES_K(10)) + RES(R41, RES_K(2.7)) + RES(R42, RES_K(2.7)) + RES(R43, RES_K(20)) + RES(R44, 150) + RES(R45, RES_K(30)) + RES(R46, RES_K(360)) + RES(R47, RES_K(12)) + RES(R48, RES_M(1)) + RES(R49, RES_K(30)) + RES(R50, RES_K(10)) + RES(R51, RES_K(1)) + RES(R52, RES_K(4.7)) + RES(R53, RES_K(680)) + RES(R54, RES_K(30)) + RES(R55, RES_K(2.7)) + RES(R56, RES_K(2.7)) + RES(R57, RES_K(820)) + RES(R58, 470) +// RES(R59, 150) -- part of final amp (not emulated) +// RES(R60, RES_K(2.2)) -- part of final amp (not emulated) +// RES(R61, 150) -- part of final amp (not emulated) +// RES(R62, RES_K(47)) -- part of final amp (not emulated) +// POT(R63, RES_K(100)) -- part of final amp (not emulated) + + CAP(C1, CAP_U(0.1)) + CAP(C2, CAP_U(0.1)) + CAP(C3, CAP_U(0.01)) + CAP(C4, CAP_U(0.1)) + CAP(C5, CAP_U(0.005)) + CAP(C6, CAP_U(0.1)) + CAP(C7, CAP_U(1)) + CAP(C8, CAP_U(15)) + CAP(C9, CAP_U(100)) + CAP(C10, CAP_U(0.1)) + CAP(C11, CAP_U(0.01)) + CAP(C12, CAP_U(0.1)) + CAP(C13, CAP_U(100)) + CAP(C14, CAP_U(0.33)) + CAP(C15, CAP_U(0.68)) + CAP(C16, CAP_U(0.01)) + CAP(C17, CAP_U(15)) + CAP(C18, CAP_U(4.7)) + CAP(C19, CAP_U(0.22)) // 22? + CAP(C20, CAP_U(0.1)) + CAP(C21, CAP_U(0.1)) +// CAP(C22, CAP_U(3.3)) -- part of voltage converter (not emulated) +// CAP(C23, CAP_U(3.3)) -- part of voltage converter (not emulated) +// CAP(C24, CAP_U(3.3)) -- part of voltage converter (not emulated) +// CAP(C25, CAP_U(3.3)) -- part of voltage converter (not emulated) +// CAP(C26, CAP_U(3.3)) -- part of voltage converter (not emulated) + CAP(C27, CAP_U(0.047)) + CAP(C28, CAP_U(0.01)) + CAP(C29, CAP_U(0.47)) + CAP(C30, CAP_U(0.47)) + CAP(C31, CAP_U(1)) + CAP(C32, CAP_U(0.1)) + CAP(C33, CAP_U(0.47)) + CAP(C34, CAP_U(0.05)) + CAP(C35, CAP_U(0.05)) + CAP(C36, CAP_U(0.01)) + CAP(C37, CAP_U(0.1)) +// CAP(C38, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C39, CAP_P(470)) -- part of final amp (not emulated) +// CAP(C40, CAP_P(470)) -- part of final amp (not emulated) + + D_1N5240(D1) + D_1N914(D2) + D_1N914(D3) + D_1N914(D4) + D_1N914(D5) + + Q_2N3906(Q1) // PNP + Q_2N3906(Q2) // PNP + Q_2N3906(Q3) // PNP + Q_2N3906(Q4) // PNP + Q_2N3904(Q5) // NPN +// Q_2N5878(Q6) // NPN -- part of final amp (not emulated) +// Q_2N5876(Q7) // PNP -- part of final amp (not emulated) + + TL081_DIP(IC1) // Op. Amp. + NET_C(IC1.7, I_V15) + NET_C(IC1.4, I_VM15) + + CA3080_DIP(IC2) // Op. Amp. + NET_C(IC2.4, I_VM15) + NET_C(IC2.7, I_V15) + + CA3080_DIP(IC3) // Op. Amp. + NET_C(IC3.4, I_VM15) + NET_C(IC3.7, I_V15) + + LM555_DIP(IC4) + + TL081_DIP(IC5) // Op. Amp. +// NET_C(IC5.7, I_V15) // (indirectly via R15) + NET_C(IC5.4, I_VM15) + + TL081_DIP(IC6) // Op. Amp. + NET_C(IC6.4, I_VM15) + NET_C(IC6.7, I_V15) + + TL081_DIP(IC7) // Op. Amp. + NET_C(IC7.4, I_VM15) + NET_C(IC7.7, I_V15) + + TTL_74LS125_DIP(IC8) // Quad 3-state Buffers + NET_C(IC8.7, GND) + NET_C(IC8.14, I_V5) + + LM555_DIP(IC9) + +// TTL_7815_DIP(IC10) // +15V Regulator -- not emulated +// TTL_7915_DIP(IC11) // -15V Regulator -- not emulated + + LM555_DIP(IC12) + + CA3080_DIP(IC13) // Op. Amp. + NET_C(IC13.4, I_VM15) + NET_C(IC13.7, I_V15) + + TTL_74121_DIP(IC14) // Monostable multivibrators with Schmitt-trigger inputs + NET_C(IC14.7, GND) + NET_C(IC14.14, I_V5) + + TTL_7406_DIP(IC15) // Hex inverter -- currently using a clone of 7416, no open collector behavior + NET_C(IC15.7, GND) + NET_C(IC15.14, I_V5) + + TL081_DIP(IC16) // Op. Amp. + NET_C(IC16.4, I_VM15) + NET_C(IC16.7, I_V15) + + LM555_DIP(IC17) + + CA3080_DIP(IC18) // Op. Amp. + NET_C(IC18.4, I_VM15) + NET_C(IC18.7, I_V15) + +// TL081_DIP(IC19) // Op. Amp. -- part of final amp (not emulated) +// NET_C(IC19.4, I_VM15) +// NET_C(IC19.7, I_V15) + +#if (HLE_NOISE_GEN) + // + // The "wideband noise gen" relies on properties + // of the components to create noise. Not only + // does this simulate poorly, but it would be too + // slow for realtime, so HLE it with some quality + // noise. + // + // Note that Sundance and Tail Gunner have the + // exact same circuit. + // + CLOCK(NOISE_CLOCK, 10000) + NET_C(NOISE_CLOCK.GND, GND) + NET_C(NOISE_CLOCK.VCC, I_V5) + + SYS_NOISE_MT_U(NOISE, 3) + NET_C(NOISE.I, NOISE_CLOCK.Q) + NET_C(NOISE.1, GND) + NET_C(NOISE.2, R1.2, R7.1, R35.1) + + NET_C(GND, C9.1, C9.2, C10.1, C10.2, C11.1, C11.2, C12.1, C12.2, C13.1, C13.2) + NET_C(GND, D1.A, D1.K, D2.A, D2.K, D3.A, D3.K) + NET_C(GND, R15.1, R15.2, R16.1, R16.2, R17.1, R17.2, R18.1, R18.2, R19.1, R19.2, R20.1, R20.2, R21.1, R21.2, R22.1, R22.2, R23.1, R23.2) + NET_C(GND, IC5.2, IC5.3, IC5.7, IC6.2, IC6.3, IC7.2, IC7.3) +#else + NET_C(C9.2, C10.1, GND) + NET_C(C9.1, C10.2, D1.K, R15.1, IC5.7) + NET_C(R15.2, C13.1, I_V15) + NET_C(C13.2, GND) + NET_C(D1.A, C11.1, R17.2) + NET_C(R17.1, GND) + NET_C(C11.2, R18.2, IC5.3) + NET_C(R18.1, C12.1, R19.2) + NET_C(R19.1, GND) + NET_C(C12.2, IC5.2, R20.1) + NET_C(R20.2, IC5.6, R21.1) + NET_C(R21.2, IC6.2, R16.1, D3.A, D2.K) + NET_C(D2.A, A3.K, R16.2, IC6.6) + NET_C(IC6.3, GND) + NET_C(R22.2, R23.1, IC7.2) + NET_C(IC7.3, GND) + NET_C(R23.2, IC7.6, R1.2, R7.1, R35.1) +#endif + + // + // Explosion + // + + NET_C(I_OUT_2, R11.1, IC4.2) + NET_C(R11.2, R12.2, IC4.8, IC4.4, I_V5) // IC4.4 not listed + NET_C(R12.1, IC4.6, IC4.7, C7.1) + NET_C(C7.2, GND) + NET_C(IC4.1, GND) + NET_C(IC4.3, Q1.E) + NET_C(Q1.B, R13.2) + NET_C(R13.1, GND) + NET_C(Q1.C, C8.1, R14.1) + NET_C(C8.2, I_VM15) + NET_C(R14.2, IC2.5) + + NET_C(C1.1, GND) + NET_C(C1.2, R2.1, R1.1) + NET_C(R2.2, C2.1) + NET_C(C2.2, IC1.2, R3.1, C3.1) + NET_C(IC1.3, GND) + NET_C(C3.2, R3.2, IC1.6, R4.1) + NET_C(R4.2, C4.1) + NET_C(C4.2, R5.2, IC2.2) + NET_C(R5.1, GND) + NET_C(IC2.3, R6.2) + NET_C(R6.1, GND) + NET_C(IC2.6, R58.1) + + // + // Reappearance hiss + // + + NET_C(I_OUT_4, IC8.13) + NET_C(IC8.12, R24.1) + NET_C(R24.2, I_V5) + NET_C(IC8.11, Q2.E) + NET_C(Q2.B, R26.2) + NET_C(R26.1, GND) + NET_C(Q2.C, C14.1, R25.1) + NET_C(C14.2, I_VM15) + NET_C(R25.2, IC3.5) + + NET_C(R7.2, C5.1) + NET_C(C5.2, R8.2, C6.1) + NET_C(R8.1, GND) + NET_C(C6.2, R9.2, IC3.2) + NET_C(R9.1, GND) + NET_C(IC3.3, R10.2) + NET_C(R10.1, GND) + NET_C(IC3.6, R58.1) + + // + // Hi level / Normal level sword hum + // + + NET_C(I_OUT_1, IC8.4) + NET_C(IC8.5, R24.1) + NET_C(IC8.6, Q3.E) + NET_C(Q3.B, R27.2) + NET_C(R27.1, GND) + NET_C(Q3.C, R28.1, R29.1) + NET_C(R28.2, IC13.5) + NET_C(R29.2, Q4.C) + NET_C(Q4.B, R30.2) + NET_C(R30.1, GND) + NET_C(Q4.E, IC8.3) + NET_C(IC8.2, R24.1) + NET_C(I_OUT_0, IC8.1) + + NET_C(R36.2, IC12.4, IC12.8, I_V15) + NET_C(R36.1, IC12.7, R37.2) + NET_C(R37.1, IC12.6, IC12.2, C27.2) + NET_C(C27.1, GND, IC12.1, C28.1) + NET_C(C28.2, IC12.5) + NET_C(IC12.3, R38.1) + NET_C(R38.2, C29.1, R39.1) + NET_C(C29.2, GND) + NET_C(R39.2, C30.1, R40.1) + NET_C(C30.2, GND) + + NET_C(R31.2, IC9.4, IC9.8, I_V15) + NET_C(R31.1, IC9.7, R32.2) + NET_C(R32.1, IC9.6, IC9.2, C15.1) + NET_C(C15.2, IC9.1, GND, C16.1) + NET_C(C16.2, IC9.5) + NET_C(IC9.3, R33.1) + NET_C(R33.2, C17.1, R34.1) + NET_C(C17.2, GND) + NET_C(R34.2, C18.1, C19.1) + NET_C(C18.2, GND) + NET_C(C19.2, C20.2, C21.2, R41.2, IC13.2) + NET_C(R41.1, GND) + NET_C(R35.2, C20.1) + NET_C(C21.1, R40.2) + NET_C(IC13.3, R42.2) + NET_C(R42.1, GND) + NET_C(IC13.6, R58.1) + NET_C(R58.2, GND) + ALIAS(OUTPUT, R58.1) + + // + // Pit fall + // + + NET_C(I_OUT_3, IC8.10, IC14.4) + NET_C(R43.2, I_V5) + NET_C(R43.1, IC14.11, C31.1) + NET_C(C31.2, IC14.10) + NET_C(IC14.5, IC14.3, I_V5) + NET_C(IC14.6, IC15.1) + NET_C(IC15.2, R44.1) + NET_C(R44.2, D4.K, C33.1) + NET_C(C33.2, GND) + NET_C(D4.A, R46.1) + + NET_C(R52.2, IC17.4, IC17.8, I_V15) + NET_C(R52.1, IC17.7, R53.2) + NET_C(R53.1, IC17.6, IC17.2, C35.2) + NET_C(C35.1, IC17.1, C36.1, GND) + NET_C(C36.2, IC17.5) + NET_C(IC17.3, C32.2) + NET_C(C32.1, R45.2) + +#if (HLE_PITFALL_VCO) + // + // This VCO is very tricky to HLE. There is an rising curve + // controlling the VCO that is modulated by a 555 timer. To + // approximate this, the 555 was disconnected from the ciruit + // and full simulation recorded at 1000x rate to find the + // mapping between the input (taken from R46.2) and the final + // TTL output at IC8.9. + // + // Map from original R46.2 to IC8.9 with 555 timer removed: + // R2 = 0.97609: HP = (0.000065653*A0) - 0.000100931 + // R2 = 0.99674: HP = (0.00000448319*A0*A0) - (0.00000588451*A0) + 0.000158263 + // R2 = 0.99695: HP = (0.000000153649*A0*A0*A0) + (0.000000894331*A0*A0) + (0.0000204462*A0) + 0.000098055 + // R2 = 0.99808: HP = (0.000000086668*A0*A0*A0*A0) - (0.00000223815*A0*A0*A0) + (0.0000235819*A0*A0) - (0.000064560*A0) + 0.000198836 + // R2 = 0.99808: HP = (-0.000000000510037*A0*A0*A0*A0*A0) + (0.000000103515*A0*A0*A0*A0) - (0.00000243946*A0*A0*A0) + (0.0000246047*A0*A0) - (0.000066382*A0) + 0.000198653 + // + // As usual this mapping changed once the VCO was removed + // from the ciruit, so this is the mapping that is used: + // + // Map from clipped R46.2 to IC8.9 when the 555 timer is removed: + // R2 = 0.99759: HP = (0.00369938*A0) - 0.000165421 + // R2 = 0.99774: HP = (-0.00117988*A0*A0) + (0.00409590*A0) - 0.000196405 + // R2 = 0.99774: HP = (0.00262450*A0*A0*A0) - (0.00252128*A0*A0) + (0.00431521*A0) - 0.000207837 + // R2 = 0.99774: HP = (-0.00269118*A0*A0*A0*A0) + (0.00447056*A0*A0*A0) - (0.00298272*A0*A0) + (0.00436492*A0) - 0.000209783 + // R2 = 0.99774: HP = (1.393570*A0*A0*A0*A0*A0) - (1.202353*A0*A0*A0*A0) + (0.408585*A0*A0*A0) - (0.069485*A0*A0) + (0.0097063*A0) - 0.000377210 + // + // Then the 555 timer modulation is added back in via an + // AFUNC. This is not 100% perfect, since we are modulating + // the clipped value not the original, but it provides a + // reasonable approximation. + // + AFUNC(PITFALLMOD, 2, "A0 + (A1-7.5)/150") + NET_C(R46.2, PITFALLMOD.A0) + NET_C(R45.1, PITFALLMOD.A1) + VARCLOCK(PITFALLCLK, 1, "max(0.000001,min(0.1,(0.00262450*A0*A0*A0) - (0.00252128*A0*A0) + (0.00431521*A0) - 0.000207837))") + NET_C(PITFALLCLK.GND, GND) + NET_C(PITFALLCLK.VCC, I_V5) + NET_C(PITFALLCLK.Q, IC8.9) + NET_C(PITFALLCLK.A0, PITFALLMOD.Q) + NET_C(GND, R47.1, R47.2, R48.1, R48.2, R49.1, R49.2, R50.1, R50.2, R51.1, R51.2, C34.1, C34.2, D5.A, D5.K, IC16.2, IC16.3) +#else + NET_C(R45.1, D4.K) + NET_C(R46.2, IC16.3, D5.K, R48.1) + NET_C(D5.A, GND) + NET_C(R48.2, IC16.6, R47.2, R49.1) + NET_C(R47.1, IC16.2, C34.2) + NET_C(C34.1, GND) + NET_C(R49.2, R50.2, Q5.B) + NET_C(R50.1, GND) + NET_C(Q5.E, GND) + NET_C(Q5.C, R51.1) + NET_C(Q5.C, IC8.9) + NET_C(R51.2, I_V5) +#endif + + NET_C(IC8.8, C37.1) + NET_C(C37.2, R54.1) + NET_C(R54.2, R55.2, IC18.2) + NET_C(R55.1, GND) + NET_C(IC18.3, R56.2) + NET_C(R56.1, GND) + NET_C(R57.2, IC18.5) + NET_C(R57.1, GND) + NET_C(IC18.6, R58.1) + + // + // Unconnected inputs + // + + NET_C(GND, IC15.3, IC15.5, IC15.9, IC15.11, IC15.13) + + // + // Unconnected outputs + // + +/* + HINT(IC5.4, NC) // Q1 + HINT(IC5.6, NC) // Q2 + HINT(IC5.8, NC) // Q3 + HINT(IC5.10, NC) // Q4 + HINT(IC5.12, NC) // Q5 +*/ + +NETLIST_END() diff --git a/src/mame/audio/nl_warrior.h b/src/mame/audio/nl_warrior.h new file mode 100644 index 00000000000..42142474de9 --- /dev/null +++ b/src/mame/audio/nl_warrior.h @@ -0,0 +1,10 @@ +// license:BSD-3-Clause +// copyright-holders:Aaron Giles +#ifndef MAME_AUDIO_NL_WARRIOR_H +#define MAME_AUDIO_NL_WARRIOR_H + +#pragma once + +NETLIST_EXTERNAL(warrior) + +#endif // MAME_AUDIO_NL_WARRIOR_H diff --git a/src/mame/drivers/cinemat.cpp b/src/mame/drivers/cinemat.cpp index 64a69e92436..a9ad07a9bbe 100644 --- a/src/mame/drivers/cinemat.cpp +++ b/src/mame/drivers/cinemat.cpp @@ -42,6 +42,7 @@ #include "solarq.lh" #include "sundance.lh" #include "tailg.lh" +#include "warrior.lh" #include "wotw.lh" #define MASTER_CLOCK XTAL(19'923'000) @@ -1076,92 +1077,97 @@ void cinemat_state::cinemat_jmi_32k(machine_config &config) void cinemat_state::spacewar(machine_config &config) { cinemat_nojmi_4k(config); - spacewar_sound(config); + SPACE_WARS_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); m_screen->set_screen_update(FUNC(cinemat_state::screen_update_spacewar)); } void cinemat_state::barrier(machine_config &config) { cinemat_jmi_4k(config); - barrier_sound(config); + BARRIER_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); +} + +WRITE_LINE_MEMBER(cinemat_state::speedfrk_start_led_w) +{ + /* start LED is controlled by bit 0x02 */ + m_led = !state; } void cinemat_state::speedfrk(machine_config &config) { cinemat_nojmi_8k(config); - speedfrk_sound(config); + SPEED_FREAK_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); +// m_outlatch->q_out_cb<1>().set(FUNC(cinemat_state::speedfrk_start_led_w)); } void cinemat_state::starhawk(machine_config &config) { cinemat_jmi_4k(config); - starhawk_sound(config); + STAR_HAWK_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_16level_state::sundance(machine_config &config) { cinemat_jmi_8k(config); - sundance_sound(config); + SUNDANCE_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_state::tailg(machine_config &config) { cinemat_nojmi_8k(config); - tailg_sound(config); - + TAIL_GUNNER_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); m_outlatch->q_out_cb<7>().set(FUNC(cinemat_state::mux_select_w)); } void cinemat_state::warrior(machine_config &config) { cinemat_jmi_8k(config); - warrior_sound(config); + WARRIOR_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_state::armora(machine_config &config) { cinemat_jmi_16k(config); - armora_sound(config); + ARMOR_ATTACK_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_state::ripoff(machine_config &config) { cinemat_jmi_8k(config); - ripoff_sound(config); + RIPOFF_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_state::starcas(machine_config &config) { cinemat_jmi_8k(config); - starcas_sound(config); + STAR_CASTLE_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_64level_state::solarq(machine_config &config) { cinemat_jmi_16k(config); - solarq_sound(config); + SOLAR_QUEST_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_color_state::boxingb(machine_config &config) { cinemat_jmi_32k(config); - boxingb_sound(config); + BOXING_BUGS_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); m_screen->set_visarea(0, 1024, 0, 788); - - m_outlatch->q_out_cb<7>().set(FUNC(cinemat_state::mux_select_w)); + m_outlatch->q_out_cb<7>().append(FUNC(cinemat_state::mux_select_w)); } void cinemat_state::wotw(machine_config &config) { cinemat_jmi_16k(config); m_screen->set_visarea(0, 1120, 0, 767); - wotw_sound(config); + WAR_OF_THE_WORLDS_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void cinemat_color_state::wotwc(machine_config &config) { cinemat_jmi_16k(config); - wotw_sound(config); + WAR_OF_THE_WORLDS_AUDIO(config, "soundboard", 0).configure_latch_inputs(*m_outlatch); } void demon_state::demon(machine_config &config) @@ -1254,6 +1260,9 @@ ROM_START( starhawk ) ROM_LOAD16_BYTE( "r7", 0x0001, 0x0800, CRC(bb71144f) SHA1(79591cd3ef8df78ec26e158f7e82ca0dcd72260d) ) CCPU_PROMS + + ROM_REGION( 0x100, "soundboard:sound_nl:2085.5e8e", 0 ) + ROM_LOAD("2085.5e8e", 0x000, 0x100, CRC(9edbf536) SHA1(036ad8a231284e05f44b1106d38fc0c7e041b6e8) ) ROM_END @@ -1525,11 +1534,7 @@ void qb3_state::init_qb3() save_item(NAME(m_qb3_lasty)); } -void cinemat_64level_state::init_solarq() -{ - save_item(NAME(m_target_volume)); - save_item(NAME(m_current_volume)); -} + /************************************* * @@ -1537,28 +1542,28 @@ void cinemat_64level_state::init_solarq() * *************************************/ -GAME( 1977, spacewar, 0, spacewar, spacewar, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Space Wars", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -GAME( 1978, spaceshp, spacewar, spacewar, spaceshp, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Sega license)", "Space Ship", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -GAMEL( 1979, barrier, 0, barrier, barrier, cinemat_state, empty_init, ORIENTATION_FLIP_X ^ ROT270, "Cinematronics (Vectorbeam license)", "Barrier", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_barrier ) // developed by Cinematronics, then (when they noticed it wasn't going to be a successful game) sold to Vectorbeam, and ultimately back in the hands of Cinematronics again after they bought the dying company Vectorbeam -GAME( 1979, speedfrk, 0, speedfrk, speedfrk, cinemat_state, init_speedfrk, ORIENTATION_FLIP_Y, "Vectorbeam", "Speed Freak", MACHINE_NO_SOUND | MACHINE_SUPPORTS_SAVE ) -GAME( 1979, starhawk, 0, starhawk, starhawk, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Hawk", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -GAMEL( 1979, sundance, 0, sundance, sundance, cinemat_16level_state, init_sundance, ORIENTATION_FLIP_X ^ ROT270, "Cinematronics", "Sundance", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_sundance ) -GAMEL( 1979, tailg, 0, tailg, tailg, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Tailgunner", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_tailg ) -GAME( 1979, warrior, 0, warrior, warrior, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Vectorbeam", "Warrior", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -GAMEL( 1980, armora, 0, armora, armora, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Armor Attack", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_armora ) -GAMEL( 1980, armorap, armora, armora, armora, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Armor Attack (prototype)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_armora ) -GAMEL( 1980, armorar, armora, armora, armora, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Rock-Ola license)", "Armor Attack (Rock-Ola)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_armora ) -GAME( 1980, ripoff, 0, ripoff, ripoff, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Rip Off", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -GAMEL( 1980, starcas, 0, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (version 3)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1980, starcas1, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (older)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1980, starcasc, starcas, starcas, starcasc, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (cocktail)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1980, starcasp, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (prototype)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1980, starcase, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Mottoeis license)", "Star Castle (Mottoeis)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1980, stellcas, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "bootleg (Elettronolo)", "Stellar Castle (Elettronolo)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1981, spaceftr, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Zaccaria license)", "Space Fortress (Zaccaria)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_starcas ) -GAMEL( 1981, solarq, 0, solarq, solarq, cinemat_64level_state, init_solarq, ORIENTATION_FLIP_Y ^ ORIENTATION_FLIP_X, "Cinematronics", "Solar Quest (rev 10 8 81)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_solarq ) -GAME( 1981, boxingb, 0, boxingb, boxingb, cinemat_color_state, init_boxingb, ORIENTATION_FLIP_Y, "Cinematronics", "Boxing Bugs", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) -GAMEL( 1981, wotw, 0, wotw, wotw, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "War of the Worlds", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE, layout_wotw ) -GAME( 1981, wotwc, wotw, wotwc, wotw, cinemat_color_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "War of the Worlds (color)", MACHINE_IMPERFECT_SOUND | MACHINE_SUPPORTS_SAVE ) +GAME( 1977, spacewar, 0, spacewar, spacewar, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Space Wars", MACHINE_SUPPORTS_SAVE ) +GAME( 1978, spaceshp, spacewar, spacewar, spaceshp, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Sega license)", "Space Ship", MACHINE_SUPPORTS_SAVE ) +GAMEL( 1979, barrier, 0, barrier, barrier, cinemat_state, empty_init, ORIENTATION_FLIP_X ^ ROT270, "Cinematronics (Vectorbeam license)", "Barrier", MACHINE_SUPPORTS_SAVE, layout_barrier ) // developed by Cinematronics, then (when they noticed it wasn't going to be a successful game) sold to Vectorbeam, and ultimately back in the hands of Cinematronics again after they bought the dying company Vectorbeam +GAME( 1979, speedfrk, 0, speedfrk, speedfrk, cinemat_state, init_speedfrk, ORIENTATION_FLIP_Y, "Vectorbeam", "Speed Freak", MACHINE_SUPPORTS_SAVE ) +GAME( 1979, starhawk, 0, starhawk, starhawk, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Hawk", MACHINE_SUPPORTS_SAVE ) +GAMEL( 1979, sundance, 0, sundance, sundance, cinemat_16level_state, init_sundance, ORIENTATION_FLIP_X ^ ROT270, "Cinematronics", "Sundance", MACHINE_SUPPORTS_SAVE, layout_sundance ) +GAMEL( 1979, tailg, 0, tailg, tailg, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Tailgunner", MACHINE_SUPPORTS_SAVE, layout_tailg ) +GAMEL( 1979, warrior, 0, warrior, warrior, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Vectorbeam", "Warrior", MACHINE_SUPPORTS_SAVE, layout_warrior ) +GAMEL( 1980, armora, 0, armora, armora, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Armor Attack", MACHINE_SUPPORTS_SAVE, layout_armora ) +GAMEL( 1980, armorap, armora, armora, armora, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Armor Attack (prototype)", MACHINE_SUPPORTS_SAVE, layout_armora ) +GAMEL( 1980, armorar, armora, armora, armora, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Rock-Ola license)", "Armor Attack (Rock-Ola)", MACHINE_SUPPORTS_SAVE, layout_armora ) +GAME( 1980, ripoff, 0, ripoff, ripoff, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Rip Off", MACHINE_SUPPORTS_SAVE ) +GAMEL( 1980, starcas, 0, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (version 3)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1980, starcas1, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (older)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1980, starcasc, starcas, starcas, starcasc, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (cocktail)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1980, starcasp, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "Star Castle (prototype)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1980, starcase, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Mottoeis license)", "Star Castle (Mottoeis)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1980, stellcas, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "bootleg (Elettronolo)", "Stellar Castle (Elettronolo)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1981, spaceftr, starcas, starcas, starcas, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics (Zaccaria license)", "Space Fortress (Zaccaria)", MACHINE_SUPPORTS_SAVE, layout_starcas ) +GAMEL( 1981, solarq, 0, solarq, solarq, cinemat_64level_state, empty_init, ORIENTATION_FLIP_Y ^ ORIENTATION_FLIP_X, "Cinematronics", "Solar Quest (rev 10 8 81)", MACHINE_SUPPORTS_SAVE, layout_solarq ) +GAME( 1981, boxingb, 0, boxingb, boxingb, cinemat_color_state, init_boxingb, ORIENTATION_FLIP_Y, "Cinematronics", "Boxing Bugs", MACHINE_SUPPORTS_SAVE ) +GAMEL( 1981, wotw, 0, wotw, wotw, cinemat_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "War of the Worlds", MACHINE_SUPPORTS_SAVE, layout_wotw ) +GAME( 1981, wotwc, wotw, wotwc, wotw, cinemat_color_state, empty_init, ORIENTATION_FLIP_Y, "Cinematronics", "War of the Worlds (color)", MACHINE_SUPPORTS_SAVE ) GAMEL( 1982, demon, 0, demon, demon, demon_state, empty_init, ORIENTATION_FLIP_Y, "Rock-Ola", "Demon", MACHINE_SUPPORTS_SAVE, layout_demon ) GAME( 1982, qb3, 0, qb3, qb3, qb3_state, init_qb3, ORIENTATION_FLIP_Y, "Rock-Ola", "QB-3 (prototype)", MACHINE_IMPERFECT_GRAPHICS | MACHINE_SUPPORTS_SAVE ) diff --git a/src/mame/includes/cinemat.h b/src/mame/includes/cinemat.h index 02642938f5e..450c3cd2939 100644 --- a/src/mame/includes/cinemat.h +++ b/src/mame/includes/cinemat.h @@ -11,6 +11,7 @@ #pragma once #include "cpu/ccpu/ccpu.h" +#include "audio/cinemat.h" #include "machine/74259.h" #include "sound/ay8910.h" #include "sound/samples.h" @@ -25,7 +26,6 @@ public: , m_maincpu(*this, "maincpu") , m_ay1(*this, "ay1") , m_outlatch(*this, "outlatch") - , m_samples(*this, "samples") , m_vector(*this, "vector") , m_screen(*this, "screen") , m_rambase(*this, "rambase") @@ -42,7 +42,6 @@ public: required_device m_maincpu; optional_device m_ay1; required_device m_outlatch; - optional_device m_samples; required_device m_vector; required_device m_screen; optional_shared_ptr m_rambase; @@ -57,11 +56,6 @@ public: output_finder<> m_led; output_finder<10> m_pressed; - uint32_t m_current_shift; - uint32_t m_last_shift; - uint32_t m_last_shift2; - uint32_t m_current_pitch; - uint32_t m_last_frame; uint8_t m_coin_detected; uint8_t m_coin_last_reset; uint8_t m_mux_select; @@ -97,52 +91,8 @@ public: protected: virtual void machine_start() override; virtual void machine_reset() override; - virtual void sound_start() override; - virtual void sound_reset() override; - DECLARE_WRITE_LINE_MEMBER(spacewar_sound0_w); - DECLARE_WRITE_LINE_MEMBER(spacewar_sound1_w); - DECLARE_WRITE_LINE_MEMBER(spacewar_sound2_w); - DECLARE_WRITE_LINE_MEMBER(spacewar_sound3_w); - DECLARE_WRITE_LINE_MEMBER(spacewar_sound4_w); - DECLARE_WRITE_LINE_MEMBER(barrier_sound0_w); - DECLARE_WRITE_LINE_MEMBER(barrier_sound1_w); - DECLARE_WRITE_LINE_MEMBER(barrier_sound2_w); DECLARE_WRITE_LINE_MEMBER(speedfrk_start_led_w); - DECLARE_WRITE_LINE_MEMBER(speedfrk_sound3_w); - DECLARE_WRITE_LINE_MEMBER(speedfrk_sound4_w); - DECLARE_WRITE_LINE_MEMBER(starhawk_sound0_w); - DECLARE_WRITE_LINE_MEMBER(starhawk_sound1_w); - DECLARE_WRITE_LINE_MEMBER(starhawk_sound2_w); - DECLARE_WRITE_LINE_MEMBER(starhawk_sound3_w); - DECLARE_WRITE_LINE_MEMBER(starhawk_sound4_w); - DECLARE_WRITE_LINE_MEMBER(starhawk_sound7_w); - DECLARE_WRITE_LINE_MEMBER(tailg_sound_w); - DECLARE_WRITE_LINE_MEMBER(warrior_sound0_w); - DECLARE_WRITE_LINE_MEMBER(warrior_sound1_w); - DECLARE_WRITE_LINE_MEMBER(warrior_sound2_w); - DECLARE_WRITE_LINE_MEMBER(warrior_sound3_w); - DECLARE_WRITE_LINE_MEMBER(warrior_sound4_w); - DECLARE_WRITE_LINE_MEMBER(armora_sound0_w); - DECLARE_WRITE_LINE_MEMBER(armora_sound1_w); - DECLARE_WRITE_LINE_MEMBER(armora_sound2_w); - DECLARE_WRITE_LINE_MEMBER(armora_sound3_w); - DECLARE_WRITE_LINE_MEMBER(armora_sound4_w); - DECLARE_WRITE_LINE_MEMBER(ripoff_sound1_w); - DECLARE_WRITE_LINE_MEMBER(ripoff_sound2_w); - DECLARE_WRITE_LINE_MEMBER(ripoff_sound3_w); - DECLARE_WRITE_LINE_MEMBER(ripoff_sound4_w); - DECLARE_WRITE_LINE_MEMBER(ripoff_sound7_w); - DECLARE_WRITE_LINE_MEMBER(starcas_sound0_w); - DECLARE_WRITE_LINE_MEMBER(starcas_sound1_w); - DECLARE_WRITE_LINE_MEMBER(starcas_sound2_w); - DECLARE_WRITE_LINE_MEMBER(starcas_sound3_w); - DECLARE_WRITE_LINE_MEMBER(starcas_sound4_w); - DECLARE_WRITE_LINE_MEMBER(wotw_sound0_w); - DECLARE_WRITE_LINE_MEMBER(wotw_sound1_w); - DECLARE_WRITE_LINE_MEMBER(wotw_sound2_w); - DECLARE_WRITE_LINE_MEMBER(wotw_sound3_w); - DECLARE_WRITE_LINE_MEMBER(wotw_sound4_w); void cinemat_nojmi_4k(machine_config &config); void cinemat_jmi_4k(machine_config &config); @@ -151,17 +101,6 @@ protected: void cinemat_jmi_16k(machine_config &config); void cinemat_jmi_32k(machine_config &config); - void spacewar_sound(machine_config &config); - void barrier_sound(machine_config &config); - void speedfrk_sound(machine_config &config); - void starhawk_sound(machine_config &config); - void tailg_sound(machine_config &config); - void warrior_sound(machine_config &config); - void armora_sound(machine_config &config); - void ripoff_sound(machine_config &config); - void starcas_sound(machine_config &config); - void wotw_sound(machine_config &config); - void program_map_4k(address_map &map); void program_map_8k(address_map &map); void program_map_16k(address_map &map); @@ -183,14 +122,6 @@ public: protected: virtual DECLARE_WRITE_LINE_MEMBER(vector_control_w) override; uint8_t sundance_inputs_r(offs_t offset); - DECLARE_WRITE_LINE_MEMBER(sundance_sound0_w); - DECLARE_WRITE_LINE_MEMBER(sundance_sound1_w); - DECLARE_WRITE_LINE_MEMBER(sundance_sound2_w); - DECLARE_WRITE_LINE_MEMBER(sundance_sound3_w); - DECLARE_WRITE_LINE_MEMBER(sundance_sound4_w); - DECLARE_WRITE_LINE_MEMBER(sundance_sound7_w); - - void sundance_sound(machine_config &config); }; @@ -205,15 +136,6 @@ public: protected: virtual DECLARE_WRITE_LINE_MEMBER(vector_control_w) override; - DECLARE_WRITE_LINE_MEMBER(solarq_sound0_w); - DECLARE_WRITE_LINE_MEMBER(solarq_sound1_w); - DECLARE_WRITE_LINE_MEMBER(solarq_sound4_w); - - void solarq_sound(machine_config &config); - -private: - float m_target_volume; - float m_current_volume; }; @@ -230,13 +152,6 @@ public: protected: virtual DECLARE_WRITE_LINE_MEMBER(vector_control_w) override; uint8_t boxingb_dial_r(offs_t offset); - DECLARE_WRITE_LINE_MEMBER(boxingb_sound0_w); - DECLARE_WRITE_LINE_MEMBER(boxingb_sound1_w); - DECLARE_WRITE_LINE_MEMBER(boxingb_sound2_w); - DECLARE_WRITE_LINE_MEMBER(boxingb_sound3_w); - DECLARE_WRITE_LINE_MEMBER(boxingb_sound4_w); - - void boxingb_sound(machine_config &config); }; diff --git a/src/mame/layout/warrior.lay b/src/mame/layout/warrior.lay new file mode 100644 index 00000000000..0b116013efb --- /dev/null +++ b/src/mame/layout/warrior.lay @@ -0,0 +1,69 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +