diff --git a/CMakeLists.txt b/CMakeLists.txt index 0227e82cb6..6c5ef51b48 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -187,7 +187,16 @@ set(BUILD_UNIT_TEST_PC false CACHE BOOL "Do you want to build the primordial che set(BUILD_UNIT_TEST_MC false CACHE BOOL "Do you want to build the metal chem unit test? (true/false)") -add_compile_options(-Werror -Wall -Wextra) +set(MICROPHYSICS_INTEGRATOR "VODE" CACHE STRING "Microphysics integrator directory to use for CMake unit-test builds") + +add_compile_options( + "$<$:-Werror>" + "$<$:-Wall>" + "$<$:-Wextra>" + "$<$:-Werror>" + "$<$:-Wall>" + "$<$:-Wextra>" +) add_compile_definitions(NET_LOOP_UNROLL_LEN=1) #setting sourcefiles and directories needed to make the test here @@ -205,7 +214,7 @@ endif() if(BUILD_UNIT_TEST_PC) #Build primordial chem unit test - setup_target_for_microphysics_compilation("primordial_chem" ${CMAKE_BINARY_DIR}) + setup_target_for_microphysics_compilation("primordial_chem" ${CMAKE_BINARY_DIR} ${MICROPHYSICS_INTEGRATOR}) include_directories(${primordial_chem_dirs}) #adding unit_tests as subdirectories @@ -213,7 +222,7 @@ if(BUILD_UNIT_TEST_PC) elseif(BUILD_UNIT_TEST_MC) #Build metal chem unit test - setup_target_for_microphysics_compilation("metal_chem" ${CMAKE_BINARY_DIR}) + setup_target_for_microphysics_compilation("metal_chem" ${CMAKE_BINARY_DIR} ${MICROPHYSICS_INTEGRATOR}) include_directories(${metal_chem_dirs}) #adding unit_tests as subdirectories diff --git a/integration/Rosenbrock/Make.package b/integration/Rosenbrock/Make.package index bdc6572054..da9c35f4a5 100644 --- a/integration/Rosenbrock/Make.package +++ b/integration/Rosenbrock/Make.package @@ -1,6 +1,7 @@ CEXE_headers += rosenbrock_type.H CEXE_headers += rosenbrock_tableau.H CEXE_headers += rosenbrock_integrator.H +CEXE_headers += primordial_rodas5p_hopper.H ifeq ($(USE_ALL_SDC), TRUE) CEXE_headers += actual_integrator_sdc.H else diff --git a/integration/Rosenbrock/generate_primordial_hopper_rhs.py b/integration/Rosenbrock/generate_primordial_hopper_rhs.py new file mode 100644 index 0000000000..9c42c4d65c --- /dev/null +++ b/integration/Rosenbrock/generate_primordial_hopper_rhs.py @@ -0,0 +1,344 @@ +#!/usr/bin/env python3 + +import argparse +import re +from pathlib import Path + + +FUNCTIONS = ("rhs_specie", "rhs_eint", "jac_nuc") + + +def find_matching_brace(text, open_index): + depth = 0 + for index in range(open_index, len(text)): + char = text[index] + if char == "{": + depth += 1 + elif char == "}": + depth -= 1 + if depth == 0: + return index + raise ValueError("unmatched brace") + + +def extract_function_body(text, name): + match = re.search(rf"\b{name}\s*\(", text) + if match is None: + raise ValueError(f"could not find {name}") + + open_brace = text.find("{", match.end()) + if open_brace < 0: + raise ValueError(f"could not find opening brace for {name}") + + close_brace = find_matching_brace(text, open_brace) + return text[open_brace + 1:close_brace] + + +def split_top_level_statements(body): + statements = [] + start = 0 + paren_depth = 0 + bracket_depth = 0 + brace_depth = 0 + + for index, char in enumerate(body): + if char == "(": + paren_depth += 1 + elif char == ")": + paren_depth -= 1 + elif char == "[": + bracket_depth += 1 + elif char == "]": + bracket_depth -= 1 + elif char == "{": + brace_depth += 1 + elif char == "}": + brace_depth -= 1 + elif char == ";" and paren_depth == 0 and bracket_depth == 0 and brace_depth == 0: + statement = body[start:index + 1].strip() + if statement: + statements.append(statement) + start = index + 1 + + tail = body[start:].strip() + if tail: + raise ValueError(f"unsplit function tail starts with: {tail[:80]!r}") + + return statements + + +def temp_indices(statements): + indices = set() + for statement in statements: + indices.update(int(index) for index in re.findall(r"\bx(\d+)\b", statement)) + return indices + + +def replace_temporaries(expression): + return re.sub(r"\bx(\d+)\b", r"x(\1)", expression) + + +def transform_statement(statement): + stripped = statement.strip() + + if stripped == "using namespace Rates;": + return None + + if stripped == "Real T = state.T;": + return " Real T = state.T;" + + decl = re.match(r"Real\s+x(\d+)\s*=\s*(.*);$", stripped, re.DOTALL) + if decl: + return f" x({decl.group(1)}) = {replace_temporaries(decl.group(2).strip())};" + + assign = re.match(r"x(\d+)\s*=\s*(.*);$", stripped, re.DOTALL) + if assign: + return f" x({assign.group(1)}) = {replace_temporaries(assign.group(2).strip())};" + + return " " + replace_temporaries(stripped) + + +def transform_statements(statements): + output = [] + for statement in statements: + transformed = transform_statement(statement) + if transformed is not None: + output.append(transformed) + return output + + +def phase_ranges(statement_count, phase_count): + chunk = (statement_count + phase_count - 1) // phase_count + ranges = [] + for begin in range(0, statement_count, chunk): + ranges.append((begin, min(begin + chunk, statement_count))) + return ranges + + +def emit_phase_table(name, ranges): + lines = [ + f"constexpr PhaseRange {name}_phases[] = {{" + ] + for begin, end in ranges: + lines.append(f" {{{begin}, {end}}},") + lines.append("};") + return "\n".join(lines) + + +def emit_function(name, statements, temp_count): + transformed = transform_statements(statements) + + if name == "rhs_specie": + signature = [ + "template ", + "AMREX_GPU_HOST_DEVICE AMREX_INLINE", + "void rhs_specie_scratch(const burn_t& state,", + " YdotType& ydot,", + " const Array1D& X,", + " Real const /*z*/,", + " Real* x_scratch,", + " const int zone,", + " const int stride)" + ] + elif name == "rhs_eint": + signature = [ + "AMREX_GPU_HOST_DEVICE AMREX_INLINE", + "Real rhs_eint_scratch(const burn_t& state,", + " const Array1D& X,", + " Real const z,", + " Real* x_scratch,", + " const int zone,", + " const int stride)" + ] + elif name == "jac_nuc": + signature = [ + "template ", + "AMREX_GPU_HOST_DEVICE AMREX_INLINE", + "void jac_nuc_scratch(const burn_t& state,", + " MatrixType& jac,", + " const Array1D& X,", + " Real const z,", + " Real* x_scratch,", + " const int zone,", + " const int stride)" + ] + else: + raise ValueError(name) + + lines = [] + lines.extend(signature) + lines.append("{") + lines.append(" using namespace Rates;") + lines.append(" ScratchView x{x_scratch, zone, stride};") + lines.extend(transformed) + lines.append("}") + return "\n".join(lines) + + +def emit_header(source_path, functions): + all_indices = set() + for statements in functions.values(): + all_indices.update(temp_indices(statements)) + + if not all_indices: + raise ValueError("no generated temporaries found") + + temp_count = max(all_indices) + 1 + + lines = [ + "/* Do not edit directly.", + " Generated by integration/Rosenbrock/generate_primordial_hopper_rhs.py", + f" from {source_path}. */", + "", + "#ifndef PRIMORDIAL_RODAS5P_HOPPER_GENERATED_H", + "#define PRIMORDIAL_RODAS5P_HOPPER_GENERATED_H", + "", + "#include ", + "", + "#include ", + "#include ", + "", + "#include ", + "#include ", + "#include ", + "#include ", + "#include ", + "", + "namespace primordial_rodas5p_hopper_generated {", + "", + "using namespace amrex;", + "using namespace ArrayUtil;", + "using namespace network_rp;", + "", + "struct PhaseRange {", + " int begin;", + " int end;", + "};", + "", + "struct ScratchView {", + " Real* data;", + " int zone;", + " int stride;", + "", + " AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE", + " Real& operator() (const int slot) const", + " {", + " return data[slot * stride + zone];", + " }", + "};", + "", + "struct SharedVector {", + " Real* data;", + " int zone;", + " int stride;", + "", + " AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE", + " Real& operator() (const int n) const", + " {", + " return data[(n - 1) * stride + zone];", + " }", + "};", + "", + "struct SharedMatrix {", + " Real* data;", + " int zone;", + " int stride;", + "", + " AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE", + " Real& operator() (const int i, const int j) const", + " {", + " return data[((i - 1) * neqs + (j - 1)) * stride + zone];", + " }", + "};", + "", + f"constexpr int generated_scratch_count = {temp_count};", + "static_assert(generated_scratch_count <= primordial_rodas5p_hopper::scratch_count,", + " \"generated scratch exceeds Hopper scratch layout\");", + f"constexpr int rhs_specie_statement_count = {len(functions['rhs_specie'])};", + f"constexpr int rhs_eint_statement_count = {len(functions['rhs_eint'])};", + f"constexpr int jac_nuc_statement_count = {len(functions['jac_nuc'])};", + "", + emit_phase_table("rhs_specie", phase_ranges(len(functions["rhs_specie"]), 3)), + "", + emit_phase_table("rhs_eint", phase_ranges(len(functions["rhs_eint"]), 1)), + "", + emit_phase_table("jac_nuc", phase_ranges(len(functions["jac_nuc"]), 3)), + "", + ] + + for name in FUNCTIONS: + lines.append(emit_function(name, functions[name], temp_count)) + lines.append("") + + lines.extend([ + "AMREX_GPU_HOST_DEVICE AMREX_INLINE", + "void actual_rhs_scratch(const burn_t& state,", + " Real* rhs_tmp,", + " Real* x_scratch,", + " const int zone,", + " const int stride)", + "{", + " Real z = redshift;", + "", + " Array1D X;", + " for (int i = 0; i < NumSpec; ++i) {", + " X(i) = state.xn[i];", + " }", + "", + " SharedVector ydot{rhs_tmp, zone, stride};", + " rhs_specie_scratch(state, ydot, X, z, x_scratch, zone, stride);", + " ydot(net_ienuc) = rhs_eint_scratch(state, X, z, x_scratch, zone, stride);", + "}", + "", + "AMREX_GPU_HOST_DEVICE AMREX_INLINE", + "void actual_jac_scratch(const burn_t& state,", + " Real* jac_tmp,", + " Real* x_scratch,", + " const int zone,", + " const int stride)", + "{", + " Real z = redshift;", + "", + " Array1D X;", + " for (int i = 0; i < NumSpec; ++i) {", + " X(i) = state.xn[i];", + " }", + "", + " SharedMatrix jac{jac_tmp, zone, stride};", + " jac_nuc_scratch(state, jac, X, z, x_scratch, zone, stride);", + "}", + "", + "} // namespace primordial_rodas5p_hopper_generated", + "", + "#endif", + "", + ]) + + return "\n".join(lines) + + +def main(): + parser = argparse.ArgumentParser() + parser.add_argument("--input", type=Path, default=Path("networks/primordial_chem/actual_rhs.H")) + parser.add_argument("--output", type=Path, default=Path("integration/Rosenbrock/primordial_rodas5p_hopper_generated.H")) + parser.add_argument("--check", action="store_true") + args = parser.parse_args() + + text = args.input.read_text() + functions = {} + for name in FUNCTIONS: + functions[name] = split_top_level_statements(extract_function_body(text, name)) + + header = emit_header(args.input, functions) + + if args.check: + existing = args.output.read_text() if args.output.exists() else None + if existing != header: + raise SystemExit(f"{args.output} is out of date") + return + + args.output.write_text(header) + + +if __name__ == "__main__": + main() diff --git a/integration/Rosenbrock/primordial_rodas5p_hopper.H b/integration/Rosenbrock/primordial_rodas5p_hopper.H new file mode 100644 index 0000000000..15106fa58a --- /dev/null +++ b/integration/Rosenbrock/primordial_rodas5p_hopper.H @@ -0,0 +1,54 @@ +#ifndef PRIMORDIAL_RODAS5P_HOPPER_H +#define PRIMORDIAL_RODAS5P_HOPPER_H + +#include + +#include + +#ifdef AMREX_USE_CUDA + +namespace primordial_rodas5p_hopper { + +constexpr int zones_per_block = 16; +constexpr int warps_per_block = 8; +constexpr int threads_per_block = warps_per_block * 32; +constexpr int neq = neqs; +constexpr int scratch_count = 534; + +constexpr std::size_t align_up (const std::size_t value, const std::size_t alignment) +{ + return ((value + alignment - 1) / alignment) * alignment; +} + +constexpr std::size_t bytes_for_reals (const std::size_t n) +{ + return align_up(n * sizeof(amrex::Real), 128); +} + +constexpr std::size_t bytes_for_ints (const std::size_t n) +{ + return align_up(n * sizeof(int), 128); +} + +constexpr std::size_t shared_bytes () +{ + std::size_t bytes = 0; + bytes += bytes_for_reals(neq * zones_per_block); // y + bytes += bytes_for_reals(neq * zones_per_block); // ynew + bytes += bytes_for_reals(neq * zones_per_block); // work + bytes += bytes_for_reals(8 * neq * zones_per_block); // ak + bytes += bytes_for_reals(neq * neq * zones_per_block); // jac + bytes += bytes_for_reals(neq * zones_per_block); // rhs_tmp + bytes += bytes_for_reals(scratch_count * zones_per_block); // generated expression scratch + bytes += bytes_for_ints(neq * zones_per_block); // pivots + bytes += bytes_for_ints(4 * zones_per_block); // status/counters + return bytes; +} + +void burn_device (burn_t* states, amrex::Real dt, int nstates); + +} // namespace primordial_rodas5p_hopper + +#endif + +#endif diff --git a/integration/Rosenbrock/primordial_rodas5p_hopper.cu b/integration/Rosenbrock/primordial_rodas5p_hopper.cu new file mode 100644 index 0000000000..36cb9c75db --- /dev/null +++ b/integration/Rosenbrock/primordial_rodas5p_hopper.cu @@ -0,0 +1,300 @@ +#include + +#ifdef AMREX_USE_CUDA + +#include + +#include + +#include + +#include +#include +#include +#include +#include +#include + +namespace primordial_rodas5p_hopper { + +namespace { + +template +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +T* advance_bytes (unsigned char*& ptr, const std::size_t bytes) +{ + T* out = reinterpret_cast(ptr); + ptr += bytes; + return out; +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +bool close_enough (const amrex::Real a, const amrex::Real b) +{ + constexpr amrex::Real rel_tol = 1.0e-13_rt; + constexpr amrex::Real abs_tol = 1.0e-99_rt; + return std::abs(a - b) <= abs_tol + rel_tol * amrex::max(std::abs(a), std::abs(b)); +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +bool generated_network_matches_scalar (const burn_t& state, + const amrex::Real* rhs_tmp, + const amrex::Real* jac_tmp, + const int local_zone) +{ + RArray1D scalar_rhs{}; + RArray2D scalar_jac{}; + + actual_rhs(state, scalar_rhs); + actual_jac(state, scalar_jac); + + for (int n = 1; n <= neq; ++n) { + const amrex::Real generated_rhs = rhs_tmp[(n - 1) * zones_per_block + local_zone]; + if (! close_enough(scalar_rhs(n), generated_rhs)) { + return false; + } + } + + for (int j = 1; j <= neq; ++j) { + for (int i = 1; i <= neq; ++i) { + const amrex::Real generated_jac = + jac_tmp[((i - 1) * neq + (j - 1)) * zones_per_block + local_zone]; + if (! close_enough(scalar_jac(i, j), generated_jac)) { + return false; + } + } + } + + return true; +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +amrex::Real& shared_matrix (amrex::Real* matrix, const int i, const int j, const int local_zone) +{ + return matrix[((i - 1) * neq + (j - 1)) * zones_per_block + local_zone]; +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +amrex::Real shared_matrix_value (const amrex::Real* matrix, const int i, const int j, const int local_zone) +{ + return matrix[((i - 1) * neq + (j - 1)) * zones_per_block + local_zone]; +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +void build_rodas5p_matrix (amrex::Real* matrix, const amrex::Real h, const int local_zone) +{ + const amrex::Real fac = 1.0_rt / (h * rosenbrock::rodas5p_tableau::gamma); + + for (int j = 1; j <= neq; ++j) { + for (int i = 1; i <= neq; ++i) { + amrex::Real value = -shared_matrix_value(matrix, i, j, local_zone); + if (i == j) { + value += fac; + } + shared_matrix(matrix, i, j, local_zone) = value; + } + } +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +bool rodas5p_matrix_matches_scalar (const burn_t& state, + const amrex::Real* matrix, + const amrex::Real h, + const int local_zone) +{ + RArray2D scalar_jac{}; + actual_jac(state, scalar_jac); + + const amrex::Real fac = 1.0_rt / (h * rosenbrock::rodas5p_tableau::gamma); + for (int j = 1; j <= neq; ++j) { + for (int i = 1; i <= neq; ++i) { + amrex::Real expected = -scalar_jac(i, j); + if (i == j) { + expected += fac; + } + + if (! close_enough(expected, shared_matrix_value(matrix, i, j, local_zone))) { + return false; + } + } + } + + return true; +} + +template +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +bool first_stage_solve_matches_scalar_impl (const burn_t& state, + const amrex::Real* rhs_tmp, + const amrex::Real* matrix, + const amrex::Real h, + const int local_zone) +{ + RArray1D generated_rhs{}; + RArray2D generated_matrix{}; + IArray1D generated_pivot{}; + + RArray1D scalar_rhs{}; + RArray2D scalar_matrix{}; + IArray1D scalar_pivot{}; + + actual_rhs(state, scalar_rhs); + actual_jac(state, scalar_matrix); + + const amrex::Real fac = 1.0_rt / (h * rosenbrock::rodas5p_tableau::gamma); + + for (int n = 1; n <= neq; ++n) { + generated_rhs(n) = rhs_tmp[(n - 1) * zones_per_block + local_zone]; + } + + for (int j = 1; j <= neq; ++j) { + for (int i = 1; i <= neq; ++i) { + generated_matrix(i, j) = shared_matrix_value(matrix, i, j, local_zone); + + scalar_matrix(i, j) = -scalar_matrix(i, j); + if (i == j) { + scalar_matrix(i, j) += fac; + } + } + } + + int generated_info = 0; + int scalar_info = 0; + dgefa(generated_matrix, generated_pivot, generated_info); + dgefa(scalar_matrix, scalar_pivot, scalar_info); + + if (generated_info != scalar_info) { + return false; + } + if (generated_info != 0) { + return true; + } + + dgesl(generated_matrix, generated_pivot, generated_rhs); + dgesl(scalar_matrix, scalar_pivot, scalar_rhs); + + for (int n = 1; n <= neq; ++n) { + if (! close_enough(scalar_rhs(n), generated_rhs(n))) { + return false; + } + } + + return true; +} + +AMREX_GPU_DEVICE AMREX_FORCE_INLINE +bool first_stage_solve_matches_scalar (const burn_t& state, + const amrex::Real* rhs_tmp, + const amrex::Real* matrix, + const amrex::Real h, + const int local_zone) +{ + if (integrator_rp::linalg_do_pivoting == 1) { + return first_stage_solve_matches_scalar_impl(state, rhs_tmp, matrix, h, local_zone); + } + return first_stage_solve_matches_scalar_impl(state, rhs_tmp, matrix, h, local_zone); +} + +__global__ +void burn_kernel (burn_t* states, const amrex::Real dt, const int nstates) +{ + extern __shared__ unsigned char shared_mem[]; + + unsigned char* ptr = shared_mem; + [[maybe_unused]] amrex::Real* y = + advance_bytes(ptr, bytes_for_reals(neq * zones_per_block)); + [[maybe_unused]] amrex::Real* ynew = + advance_bytes(ptr, bytes_for_reals(neq * zones_per_block)); + [[maybe_unused]] amrex::Real* work = + advance_bytes(ptr, bytes_for_reals(neq * zones_per_block)); + [[maybe_unused]] amrex::Real* ak = + advance_bytes(ptr, bytes_for_reals(8 * neq * zones_per_block)); + [[maybe_unused]] amrex::Real* jac = + advance_bytes(ptr, bytes_for_reals(neq * neq * zones_per_block)); + [[maybe_unused]] amrex::Real* rhs_tmp = + advance_bytes(ptr, bytes_for_reals(neq * zones_per_block)); + [[maybe_unused]] amrex::Real* x_scratch = + advance_bytes(ptr, bytes_for_reals(scratch_count * zones_per_block)); + [[maybe_unused]] int* pivot = + advance_bytes(ptr, bytes_for_ints(neq * zones_per_block)); + [[maybe_unused]] int* status = + advance_bytes(ptr, bytes_for_ints(4 * zones_per_block)); + + const int warp = threadIdx.x / 32; + const int lane = threadIdx.x % 32; + const int local_zone = lane; + const int zone = blockIdx.x * zones_per_block + local_zone; + + // Prototype milestone 1: establish the Hopper batch launch and comparison + // harness. The cooperative RHS/Jacobian and shared-memory LU will replace + // this scalar lane path while preserving the public launcher. + if (warp == 0 && local_zone < zones_per_block && zone < nstates) { + primordial_rodas5p_hopper_generated::actual_rhs_scratch(states[zone], + rhs_tmp, + x_scratch, + local_zone, + zones_per_block); + primordial_rodas5p_hopper_generated::actual_jac_scratch(states[zone], + jac, + x_scratch, + local_zone, + zones_per_block); + const bool generated_ok = generated_network_matches_scalar(states[zone], + rhs_tmp, + jac, + local_zone); + build_rodas5p_matrix(jac, dt, local_zone); + const bool matrix_ok = rodas5p_matrix_matches_scalar(states[zone], + jac, + dt, + local_zone); + const bool solve_ok = first_stage_solve_matches_scalar(states[zone], + rhs_tmp, + jac, + dt, + local_zone); + status[local_zone] = (generated_ok && matrix_ok && solve_ok) ? 1 : 0; + burner(states[zone], dt); + if (! generated_ok || ! matrix_ok || ! solve_ok) { + states[zone].success = false; + states[zone].error_code = IERR_BAD_INPUTS; + } + } +} + +void check_cuda (const cudaError_t err, const char* what) +{ + if (err != cudaSuccess) { + amrex::Abort(std::string(what) + ": " + cudaGetErrorString(err)); + } +} + +} // namespace + +void burn_device (burn_t* states, const amrex::Real dt, const int nstates) +{ + if (nstates <= 0) { + return; + } + + static bool attributes_set = false; + if (! attributes_set) { + check_cuda(cudaFuncSetAttribute(burn_kernel, + cudaFuncAttributeMaxDynamicSharedMemorySize, + static_cast(shared_bytes())), + "cudaFuncSetAttribute(MaxDynamicSharedMemorySize)"); + check_cuda(cudaFuncSetAttribute(burn_kernel, + cudaFuncAttributePreferredSharedMemoryCarveout, + cudaSharedmemCarveoutMaxShared), + "cudaFuncSetAttribute(PreferredSharedMemoryCarveout)"); + attributes_set = true; + } + + const int blocks = (nstates + zones_per_block - 1) / zones_per_block; + burn_kernel<<>>(states, dt, nstates); + check_cuda(cudaGetLastError(), "primordial Rodas5P Hopper kernel launch"); +} + +} // namespace primordial_rodas5p_hopper + +#endif diff --git a/integration/Rosenbrock/primordial_rodas5p_hopper_generated.H b/integration/Rosenbrock/primordial_rodas5p_hopper_generated.H new file mode 100644 index 0000000000..c0a25e52db --- /dev/null +++ b/integration/Rosenbrock/primordial_rodas5p_hopper_generated.H @@ -0,0 +1,4630 @@ +/* Do not edit directly. + Generated by integration/Rosenbrock/generate_primordial_hopper_rhs.py + from networks/primordial_chem/actual_rhs.H. */ + +#ifndef PRIMORDIAL_RODAS5P_HOPPER_GENERATED_H +#define PRIMORDIAL_RODAS5P_HOPPER_GENERATED_H + +#include + +#include +#include + +#include +#include +#include +#include +#include + +namespace primordial_rodas5p_hopper_generated { + +using namespace amrex; +using namespace ArrayUtil; +using namespace network_rp; + +struct PhaseRange { + int begin; + int end; +}; + +struct ScratchView { + Real* data; + int zone; + int stride; + + AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE + Real& operator() (const int slot) const + { + return data[slot * stride + zone]; + } +}; + +struct SharedVector { + Real* data; + int zone; + int stride; + + AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE + Real& operator() (const int n) const + { + return data[(n - 1) * stride + zone]; + } +}; + +struct SharedMatrix { + Real* data; + int zone; + int stride; + + AMREX_GPU_HOST_DEVICE AMREX_FORCE_INLINE + Real& operator() (const int i, const int j) const + { + return data[((i - 1) * neqs + (j - 1)) * stride + zone]; + } +}; + +constexpr int generated_scratch_count = 534; +static_assert(generated_scratch_count <= primordial_rodas5p_hopper::scratch_count, + "generated scratch exceeds Hopper scratch layout"); +constexpr int rhs_specie_statement_count = 135; +constexpr int rhs_eint_statement_count = 165; +constexpr int jac_nuc_statement_count = 2154; + +constexpr PhaseRange rhs_specie_phases[] = { + {0, 45}, + {45, 90}, + {90, 135}, +}; + +constexpr PhaseRange rhs_eint_phases[] = { + {0, 165}, +}; + +constexpr PhaseRange jac_nuc_phases[] = { + {0, 718}, + {718, 1436}, + {1436, 2154}, +}; + +template +AMREX_GPU_HOST_DEVICE AMREX_INLINE +void rhs_specie_scratch(const burn_t& state, + YdotType& ydot, + const Array1D& X, + Real const /*z*/, + Real* x_scratch, + const int zone, + const int stride) +{ + using namespace Rates; + ScratchView x{x_scratch, zone, stride}; + Real T = state.T; + x(0) = std::exp((-0.75)*std::log(std::abs(T))); + x(1) = 2.5950363272655348e-10*X(0)*X(4)*x(0); + x(2) = 1.3300135414628029e-18*std::exp((0.94999999999999996)*std::log(std::abs(T)))*X(0)*X(5)*std::exp(-0.00010729613733905579*T); + x(3) = ((T)*(T)); + x(4) = T <= 10000.0; + x(5) = X(0)*X(6)*((x(4)) ? ( + -5.5279999999999998e-28*((T)*(T)*(T)*(T)*(T)) + 3.3467999999999999e-23*((((T)*(T)))*(((T)*(T)))) - 7.5474000000000004e-19*((T)*(T)*(T)) - 2.3088e-11*T + 7.3427999999999993e-15*x(3) + 4.2277999999999996e-8 +) +: ( + 0 +)); + x(6) = std::log(T); + x(7) = 0.10684732509875319*x(6) - 1; + x(8) = ((x(7))*(x(7))); + x(9) = ((x(7))*(x(7))*(x(7))); + x(10) = ((((x(7))*(x(7))))*(((x(7))*(x(7))))); + x(11) = ((x(7))*(x(7))*(x(7))*(x(7))*(x(7))); + x(12) = std::exp((6)*std::log(std::abs(x(7)))); + x(13) = ((x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))); + x(14) = std::exp((8)*std::log(std::abs(x(7)))); + x(15) = ((x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))); + x(16) = X(2)*X(3); + x(17) = x(16)*((T <= 1160.0) ? ( + 1.4643482606109061e-16*std::exp((1.78186)*std::log(std::abs(T))) +) +: ( + 3.3178155742407614e-14*std::exp((1.1394493358416311)*std::log(std::abs(T)))*std::exp(-10.993097527150175*x(10) + 14.449862906216714*x(11) + 58.228375789703179*x(12) - 162.59852239006702*x(13) + 144.55426734953477*x(14) - 44.454280878123605*x(15) - 12.447178055372778*x(8) + 6.9391784778399117*x(9)) +)); + x(18) = X(1)*X(3); + x(19) = 1.0e-8*std::exp((-0.40000000000000002)*std::log(std::abs(T)))*x(18); + x(20) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(21) = X(3)*X(5); + x(22) = x(20)*x(21); + x(23) = X(0)*X(2); + x(24) = 1.4000000000000001e-18*std::exp((0.92800000000000005)*std::log(std::abs(T)))*x(23)*std::exp(-6.1728395061728397e-5*T); + x(25) = X(0)*X(12); + x(26) = 3.8571873359681582e-209*std::exp((43.933476326349997)*std::log(std::abs(T)))*x(25)*std::exp(-5902.1601240760483*x(10) + 5825.9326359379538*x(11) - 3578.1439181805954*x(12) + 1242.7294446825149*x(13) - 186.35635455381879*x(14) - 1618.789587733125*x(8) + 3854.4033653120223*x(9)); + x(27) = 3.7903999274394518e-18*std::exp((2.360852208681)*std::log(std::abs(T)))*X(0)*X(3)*std::exp(-258.18559308467115*x(10) + 846.15238706523724*x(11) - 1113.0879095147111*x(12) + 671.95094388835207*x(13) - 154.90262957142161*x(14) - 24.766609674457612*x(8) + 13.307984239358756*x(9)); + x(28) = std::sqrt(T); + x(29) = 1.0/x(28); + x(30) = X(0)*x(29); + x(31) = 5.7884371785482823e-10*X(11)*x(30)*std::exp((-1.7524)*std::log(std::abs(0.00060040841663220993*x(28) + 1.0)))*std::exp((-0.24759999999999999)*std::log(std::abs(0.32668576019240059*x(28) + 1.0))); + x(32) = 1.4981088130721367e-10*std::exp((-0.63529999999999998)*std::log(std::abs(T))); + x(33) = 8.6173430000000006e-5*T; + x(34) = 1.0/T; + x(35) = -4.3524079114767552e-117*std::exp((23.915965629999999)*std::log(std::abs(T)))*X(0)*X(13)*std::exp(-4361.9927099007555*x(10) + 4879.7345146260486*x(11) - 3366.4639698826941*x(12) + 1300.3028484326148*x(13) - 214.82451513312137*x(14) - 941.91483008144996*x(8) + 2506.9866529060901*x(9)) + x(25)*((x(33) <= 9280.0) ? ( + x(32) +) +: ( + 1250086.112245841*std::exp((-1.5)*std::log(std::abs(T)))*(1.5400000000000001e-9 + 4.6200000000000001e-10*std::exp(-93988.701501924661*x(34)))*std::exp(-469943.50750964211*x(34)) + x(32) +)); + x(36) = -5.9082438637265071e-70*std::exp((13.536555999999999)*std::log(std::abs(T)))*x(23)*std::exp(-2207.4643501257692*x(10) + 2500.8077583366976*x(11) - 1768.8867461266502*x(12) + 704.19926629500367*x(13) - 120.0438480494693*x(14) - 502.72883252679094*x(8) + 1281.477767828706*x(9)) + X(0)*X(1)*((x(33) <= 5500.0) ? ( + x(32) +) +: ( + 3.2867337024382687e-10*std::exp((-0.72411256578268512)*std::log(std::abs(T)))*std::exp(-2.4649195146505534*x(10) - 1.020773727011937*x(11) + 3.3530579587656564*x(12) + 3.6203127646377791*x(13) - 1.0930705283186732*x(14) - 1.6921001126637107*x(15) - 1.774686809424741*x(8) - 1.951835616513679*x(9)) +)); + x(37) = 7.1999999999999996e-8*X(9)*x(30); + x(38) = X(2)*X(7); + x(39) = x(20)*x(38); + x(40) = x(16)*(1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))))/(0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0); + x(41) = X(0)*X(8); + x(42) = 35.5*std::exp((-2.2799999999999998)*std::log(std::abs(T)))*x(41)*std::exp(-46707.0*x(34)); + x(43) = x(37) - x(39) - x(40) + x(42); + x(44) = M_LN10; + x(45) = 1.0/x(44); + x(46) = x(45)*x(6); + x(47) = std::exp((-0.12690000000000001*std::exp((-3.0)*std::log(std::abs(x(44))))*((x(6))*(x(6))*(x(6))) + 1.1180000000000001*std::exp((-2.0)*std::log(std::abs(x(44))))*((x(6))*(x(6))) - 1.5229999999999999*x(46) - 19.379999999999999)*std::log(std::abs(10.0))); + x(48) = X(1)*X(5); + x(49) = x(47)*x(48); + x(50) = x(18)*((T >= 10.0 && T <= 100000.0) ? ( + -7.7700000000000002e-13*T + 2.5000000000000002e-10*x(28) + 2.96e-6*x(29) - 1.73e-9 +) +: ( + 0 +)); + x(51) = 1.0000000000000001e-9*X(1)*X(10)*std::exp(-457.0*x(34)); + x(52) = ((x(6))*(x(6))); + x(53) = std::exp((-2)*std::log(std::abs(x(44)))); + x(54) = x(52)*x(53); + x(55) = 8.4600000000000008e-10*x(46) - 1.3700000000000002e-10*x(54) + 4.1700000000000001e-10; + x(56) = ((x(6))*(x(6))*(x(6))); + x(57) = x(56)/((x(44))*(x(44))*(x(44))); + x(58) = X(1)*X(2)*((T < 30) ? ( + 3.4977396723747635e-20*std::exp((-0.14999999999999999)*std::log(std::abs(T))) +) +: ( + std::exp((-3.194*x(46) + 1.786*x(52)*x(53) - 0.2072*x(57) - 18.199999999999999)*std::log(std::abs(10))) +)); + x(59) = 6.0e-10*X(2)*X(6); + x(60) = ((((x(6))*(x(6))))*(((x(6))*(x(6))))); + x(61) = ((x(6))*(x(6))*(x(6))*(x(6))*(x(6))); + x(62) = X(1)*X(8)*((T >= 100.0 && T <= 30000.0) ? ( + (-1.4491368e-7*x(52) + 3.4172804999999998e-8*x(56) + 3.5311931999999998e-13*((x(6))*(x(6))*(x(6))*(x(6))*(x(6))*(x(6))*(x(6))) - 1.8171411000000001e-11*std::exp((6)*std::log(std::abs(x(6)))) + 3.3735381999999997e-7*x(6) - 4.7813727999999997e-9*x(60) + 3.9731542e-10*x(61) - 3.3232183000000002e-7)*std::exp(-21237.150000000001*x(34)) +) +: ( + 0 +)); + x(63) = -x(59) + x(62); + x(64) = x(19) + x(58) + x(63); + x(65) = 6.3999999999999996e-10*X(2)*X(9); + x(66) = -x(65); + x(67) = std::exp((-0.5)*std::log(std::abs(T))); + x(68) = X(7)*x(67); + x(69) = 7.9674337148168363e-7*X(1)*x(68); + x(70) = X(1)*X(13)*((x(4)) ? ( + 1.26e-9*x(0)*std::exp(-127500.0*x(34)) +) +: ( + 4.0000000000000003e-37*std::exp((4.7400000000000002)*std::log(std::abs(T))) +)); + x(71) = std::exp((0.25)*std::log(std::abs(T))); + x(72) = 2.8833736969617052e-16*X(12)*X(2)*x(71); + x(73) = T >= 50.0; + x(74) = x(48)*((x(73)) ? ( + 2.0000000000000001e-10*std::exp((0.40200000000000002)*std::log(std::abs(T)))*std::exp(-37.100000000000001*x(34)) - 3.3099999999999998e-17*std::exp((1.48)*std::log(std::abs(T))) +) +: ( + 0 +)); + x(75) = X(2)*X(4); + x(76) = x(75)*((x(73)) ? ( + 2.0299999999999998e-9*std::exp((-0.33200000000000002)*std::log(std::abs(T))) + 2.0600000000000001e-10*std::exp((0.39600000000000002)*std::log(std::abs(T)))*std::exp(-33.0*x(34)) +) +: ( + 0 +)); + x(77) = x(74) - x(76); + x(78) = x(36) + x(66) + x(69) + x(70) - x(72) + x(77); + x(79) = 4.9999999999999996e-6*X(3)*X(6)*x(29); + x(80) = ((X(2))*(X(2))*(X(2))); + x(81) = 1.0/x(71); + x(82) = 1.0e-25*X(2)*X(5); + x(83) = X(1) + X(10) + X(2) + X(3) + 2.0*X(6) + 2.0*X(8) + X(9); + x(84) = -133.82830000000001*x(34) - 4.8909149999999997*x(45)*x(6) + 0.47490300000000002*x(54); + x(85) = std::exp(-0.0022727272727272726*T); + x(86) = std::exp(-0.00054054054054054055*T); + x(87) = -2.0563129999999998*x(85) + 0.58640729999999996*x(86) + 0.82274429999999998; + x(88) = -69.700860000000006*x(45)*std::log(40870.379999999997*x(34) + 1.0) + 4.6331670000000003*x(57); + x(89) = std::exp((-23705.700000000001*x(34) - 2080.4099999999999*x(34)/(std::exp((x(87))*std::log(std::abs(std::exp((-x(84) - 13.656822)*std::log(std::abs(10.0)))*x(83)))) + 1.0) - 68.422430000000006*x(46) + 43.20243*x(52)*x(53) - x(88) - 178.4239 - (19.734269999999999*x(45)*std::log(16780.950000000001*x(34) + 1.0) - 14.509090000000008*x(46) + 37.886913*x(52)*x(53) - x(88) - 307.31920000000002)/(std::exp((x(87))*std::log(std::abs(std::exp((-x(84) - 14.82123)*std::log(std::abs(10.0)))*x(83)))) + 1.0))*std::log(std::abs(10.0))); + x(90) = 743.05999999999995*x(34) - 2.4640089999999999*x(45)*x(6) + 0.19859550000000001*x(54); + x(91) = 2.9375070000000001*x(85) + 0.23588480000000001*x(86) + 0.75022860000000002; + x(92) = -21.360939999999999*x(45)*std::log(27535.310000000001*x(34) + 1.0) + 0.25820969999999999*x(57); + x(93) = std::exp((-21467.790000000001*x(34) - 1657.4099999999999*x(34)/(std::exp((x(91))*std::log(std::abs(std::exp((-x(90) - 8.1313220000000008)*std::log(std::abs(10.0)))*x(83)))) + 1.0) + 42.707410000000003*x(45)*x(6) - 2.0273650000000001*x(54) - x(92) - 142.7664 - (70.138370000000009*x(45)*x(6) + 11.28215*x(45)*std::log(14254.549999999999*x(34) + 1.0) - 4.7035149999999994*x(54) - x(92) - 203.11568)/(std::exp((x(91))*std::log(std::abs(std::exp((-x(90) - 9.3055640000000004)*std::log(std::abs(10.0)))*x(83)))) + 1.0))*std::log(std::abs(10.0))); + x(94) = X(2)*X(8); + x(95) = 5.0000000000000004e-32*x(67) + 1.5e-32*x(81); + x(96) = ((X(2))*(X(2)))*X(8); + x(97) = x(47)*x(75); + x(98) = 1.0/(std::exp((1.3*x(45)*(x(6) - 9.2103403719761836) - 137.42519902360013*x(53)*((0.10857362047581294*x(6) - 1)*(0.10857362047581294*x(6) - 1)) - 4.8449999999999998)*std::log(std::abs(10.0)))*x(83) + 1.0); + x(99) = ((X(8))*(X(8)))*std::exp((x(98))*std::log(std::abs(1.1800000000000001e-10*std::exp(-69500.0*x(34)))))*std::exp((1.0 - x(98))*std::log(std::abs(8.1250000000000003e-8*x(67)*(1.0 - std::exp(-6000.0*x(34)))*std::exp(-52000.0*x(34))))); + x(100) = std::exp((0.34999999999999998)*std::log(std::abs(T)))*x(41)*std::exp(-102000.0*x(34)); + x(101) = X(5)*X(8)*((T <= 1167.4796423742259) ? ( + std::exp((5.8888600000000002*x(46) + 7.1969200000000004*x(54) + 2.2506900000000001*x(57) - 56.473700000000001 - 2.1690299999999998*x(60)/((((x(44))*(x(44))))*(((x(44))*(x(44))))) + 0.31788699999999998*x(61)/((x(44))*(x(44))*(x(44))*(x(44))*(x(44))))*std::log(std::abs(10))) +) +: ( + 3.1699999999999999e-10*std::exp(-5207.0*x(34)) +)); + x(102) = X(10)*X(2)*((T > 200.0) ? ( + 5.25e-11*std::exp(-4430.0*x(34) + 173900.0/x(3)) +) +: ( + 0 +)); + x(103) = x(101) - x(102); + x(104) = 6.1739095063118665e-10*std::exp((0.40999999999999998)*std::log(std::abs(T))); + x(105) = x(104)*x(21); + x(106) = x(104)*x(38); + x(107) = x(105) - x(106); + x(108) = x(107) + x(17) - x(24) + x(27); + x(109) = x(80)*(2.0000000000000002e-31*x(67) + 6.0000000000000001e-32*x(81)) + x(94)*(-x(89) - x(93)); + x(110) = x(40) - x(42) + x(79); + x(111) = 9.8726896031426014e-7*X(4)*x(68); + x(112) = -x(51); + x(113) = -x(55); + x(114) = -x(37) + x(49); + x(115) = x(103) + x(22) + x(82); + x(116) = X(4)*X(8); + x(117) = x(26) - x(31); + x(118) = x(35) - x(70) + x(72); + ydot(1) = -x(1) + x(17) + x(19) - x(2) + x(22) - x(24) + x(26) + x(27) - x(31) - x(35) - x(36) - x(43) - x(5); + ydot(2) = X(4)*X(8)*x(55) - x(49) - x(50) - x(51) - x(64) - x(78); + ydot(3) = 8.7599999999999997e-10*x(100) + x(103) + x(108) + x(109) + x(43) + 2*x(5) + 2*x(50) - x(58) + x(63) + x(78) + x(79) + x(80)*(-6.0000000000000005e-31*x(67) - 1.8e-31*x(81)) - x(82) + x(94)*(3*x(89) + 3*x(93)) - x(95)*x(96) - x(97) + 2*x(99); + ydot(4) = -x(108) - x(110) - x(19) - x(22) - x(50); + ydot(5) = X(4)*X(8)*x(113) - x(1) - x(111) - x(112) + x(74) - x(76) - x(97); + ydot(6) = 1.9745379206285203e-6*X(4)*X(7)*x(67) + x(1) - x(107) - x(114) - x(115) - x(2) + x(69) - x(77); + ydot(7) = -x(5) + x(64) - x(79); + ydot(8) = x(105) - x(106) - x(111) + x(2) - x(39) - x(69); + ydot(9) = -4.3799999999999999e-10*x(100) - x(101) + x(102) + x(109) + x(110) + x(113)*x(116) + x(51) + x(59) - x(62) + x(95)*x(96) + x(96)*(-2.5000000000000002e-32*x(67) - 7.5000000000000001e-33*x(81)) - x(99); + ydot(10) = x(114) + x(66) + x(97); + ydot(11) = x(112) + x(115) + x(116)*x(55) + x(39) + x(65); + ydot(12) = x(117); + ydot(13) = -x(117) - x(118); + ydot(14) = x(118); +} + +AMREX_GPU_HOST_DEVICE AMREX_INLINE +Real rhs_eint_scratch(const burn_t& state, + const Array1D& X, + Real const z, + Real* x_scratch, + const int zone, + const int stride) +{ + using namespace Rates; + ScratchView x{x_scratch, zone, stride}; + Real T = state.T; + x(0) = 9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9); + x(1) = 1.0/x(0); + x(2) = std::sqrt(T); + x(3) = X(1) + X(12) + X(4); + x(4) = 1.0/T; + x(5) = 2.73*z + 2.73; + x(6) = T <= 10; + x(7) = X(0)*X(12); + x(8) = ((x(6)) ? ( + 1.0/10.0 +) +: ( + x(4) +)); + x(9) = std::sqrt(T); + x(10) = ((x(6)) ? ( + std::sqrt(10) +) +: ( + x(9) +)); + x(11) = 1.0/(0.0031622776601683794*x(10) + 1.0); + x(12) = X(0)*x(11); + x(13) = X(2)*x(12); + x(14) = X(0)*x(10)*((x(6)) ? ( + 0.63095734448019325 +) +: ( + std::exp((-0.20000000000000001)*std::log(std::abs(T))) +))/(6.3095734448019361e-5*((x(6)) ? ( + 5.011872336272722 +) +: ( + std::exp((0.69999999999999996)*std::log(std::abs(T))) +)) + 1.0); + x(15) = 1.0/x(2); + x(16) = X(10) + X(2) + X(3) + X(9); + x(17) = X(1) + 2.0*X(6) + 2.0*X(8) + x(16); + x(18) = 1.0/(1000000.0*x(15)/(x(17)*(1.6000000000000001*X(2)*std::exp(-160000.0/((T)*(T))) + 1.3999999999999999*X(8)*std::exp(-12000.0/(T + 1200.0)))) + 1.0); + x(19) = x(11)*x(7); + x(20) = ((X(0))*(X(0)))*X(12)*x(11)*((x(6)) ? ( + 0.67810976749343443 +) +: ( + std::exp((-0.16869999999999999)*std::log(std::abs(T))) +)); + x(21) = std::exp((-0.25)*std::log(std::abs(T))); + x(22) = std::sqrt(M_PI); + x(23) = std::log(T); + x(24) = M_LN10; + x(25) = 1.0/x(24); + x(26) = std::exp((-2)*std::log(std::abs(x(24)))); + x(27) = 1.0/(std::exp((1.3*x(25)*(x(23) - 9.2103403719761836) - 137.42519902360013*x(26)*((0.10857362047581294*x(23) - 1)*(0.10857362047581294*x(23) - 1)) - 4.8449999999999998)*std::log(std::abs(10.0)))*x(17) + 1.0); + x(28) = ((x(23))*(x(23))); + x(29) = x(26)*x(28); + x(30) = -4.8909149999999997*x(23)*x(25) + 0.47490300000000002*x(29) - 133.82830000000001*x(4); + x(31) = std::exp(-0.0022727272727272726*T); + x(32) = std::exp(-0.00054054054054054055*T); + x(33) = -2.0563129999999998*x(31) + 0.58640729999999996*x(32) + 0.82274429999999998; + x(34) = x(23)*x(25); + x(35) = amrex::Math::powi<-3>(x(24)); + x(36) = ((x(23))*(x(23))*(x(23)))*x(35); + x(37) = -69.700860000000006*x(25)*std::log(40870.379999999997*x(4) + 1.0) + 4.6331670000000003*x(36); + x(38) = -2.4640089999999999*x(23)*x(25) + 0.19859550000000001*x(29) + 743.05999999999995*x(4); + x(39) = 2.9375070000000001*x(31) + 0.23588480000000001*x(32) + 0.75022860000000002; + x(40) = -21.360939999999999*x(25)*std::log(27535.310000000001*x(4) + 1.0) + 0.25820969999999999*x(36); + x(41) = std::log(((T >= 10000.0) ? ( + 10000.0 +) +: ( + T +))); + x(42) = std::exp((-4)*std::log(std::abs(x(24)))); + x(43) = ((((x(41))*(x(41))))*(((x(41))*(x(41))))); + x(44) = ((x(41))*(x(41))*(x(41))); + x(45) = ((x(41))*(x(41))); + x(46) = X(2) <= 0.01; + x(47) = std::log(((((x(46)) ? ( + false +) +: ( + X(2) >= 10000000000.0 +))) ? ( + 10000000000.0 +) +: ( + ((x(46)) ? ( + 0.01 + ) + : ( + X(2) + )) +))); + x(48) = ((((x(47))*(x(47))))*(((x(47))*(x(47))))); + x(49) = ((x(47))*(x(47))*(x(47))); + x(50) = ((x(47))*(x(47))); + x(51) = amrex::Math::powi<-5>(x(24)); + x(52) = std::exp((-8)*std::log(std::abs(x(24)))); + x(53) = amrex::Math::powi<-7>(x(24)); + x(54) = std::exp((-6)*std::log(std::abs(x(24)))); + x(55) = x(0) >= 0.5; + x(56) = 1.0000420000000001*x(25); + x(57) = x(0) >= 9.9999999999999998e-13; + x(58) = ((x(57)) ? ( + std::exp((x(56)*std::log(((x(55)) ? ( + 0.5 + ) + : ( + x(0) + ))) + 2.1498900000000001)*std::log(std::abs(10.0))) +) +: ( + 0.0 +)); + x(59) = X(0) + X(11) + X(13) + X(5) + X(6) + X(7) + X(8) + x(16) + x(3); + x(60) = x(59) <= 9.9999999999999993e-41; + x(61) = x(0) <= 9.9999999999999993e-41; + x(62) = x(0)*x(22)*x(9); + x(63) = std::exp((2.1498900000000001 - 0.69317629274152892*x(25))*std::log(std::abs(10.0)))*x(62); + x(64) = std::exp((x(56)*std::log(x(0)) + 2.1498900000000001)*std::log(std::abs(10.0)))*x(62); + x(65) = 0.00013612213614898791*X(0) + 0.24994102282436673*X(1) + 0.75007714496081457*X(10) + 0.99972775572710437*X(11) + 0.99986387786355213*X(12) + X(13) + 0.25007714496081457*X(2) + 0.25021326709726244*X(3) + 0.49986387786355219*X(4) + 0.5*X(5) + 0.50001816778518127*X(6) + 0.50013612213644787*X(7) + 0.50015428992162914*X(8) + 0.7499410228243667*X(9); + x(66) = 1.0/std::fabs(x(65)); + x(67) = std::sqrt(x(59)); + x(68) = std::exp((-2)*std::log(std::abs(x(65)))); + x(69) = std::sqrt(x(59)*x(68)); + x(70) = 1.2500000000000001e-10*X(0) + 1.2500000000000001e-10*X(1) + 1.2500000000000001e-10*X(10) + 1.2500000000000001e-10*X(11) + 1.2500000000000001e-10*X(12) + 1.2500000000000001e-10*X(13) + 1.2500000000000001e-10*X(2) + 1.2500000000000001e-10*X(3) + 1.2500000000000001e-10*X(4) + 1.2500000000000001e-10*X(5) + 1.2500000000000001e-10*X(6) + 1.2500000000000001e-10*X(7) + 1.2500000000000001e-10*X(8) + 1.2500000000000001e-10*X(9) <= 9.9999999999999993e-41; + x(71) = 28601.610899577994*std::exp((-0.45000000000000001)*std::log(std::abs(x(59)))); + x(72) = 4.985670872372847e-33*std::exp((3.7599999999999998)*std::log(std::abs(T)))*std::exp(-2197000.0/((T)*(T)*(T)))/(6.0142468035272636e-8*std::exp((2.1000000000000001)*std::log(std::abs(T))) + 1.0) + 1.6e-18*std::exp(-11700.0*x(4)) + 6.7e-19*std::exp(-5860.0*x(4)) + 3.0e-24*std::exp(-510.0*x(4)); + x(73) = T < 2000.0; + x(74) = x(23) - 6.9077552789821368; + x(75) = 0.14476482730108395*x(23) - 1; + x(76) = x(26)*((x(75))*(x(75))); + x(77) = ((x(75))*(x(75))*(x(75))); + x(78) = x(35)*x(77); + x(79) = ((((x(75))*(x(75))))*(((x(75))*(x(75))))); + x(80) = ((x(75))*(x(75))*(x(75))*(x(75))*(x(75))); + x(81) = x(54)*std::exp((6)*std::log(std::abs(x(75)))); + x(82) = x(53)*((x(75))*(x(75))*(x(75))*(x(75))*(x(75))*(x(75))*(x(75))); + x(83) = std::exp((8)*std::log(std::abs(x(75)))); + x(84) = std::exp((5.0194035000000001*x(25)*x(74) + 5627.2167698544854*x(42)*x(79) + 86051.290034608537*x(51)*x(80) + 9415777.8988952208*x(52)*x(83) - 75.100986441619156*x(76) - 1554.3387057364687*x(78) - 428804.85473346239*x(81) - 1662263.0320406025*x(82) - 20.584225)*std::log(std::abs(10.0))); + x(85) = T <= 10000.0; + x(86) = 0.00020000000000000001*T; + x(87) = x(86) - 6.0; + x(88) = x(87) >= 300.0; + x(89) = ((x(73)) ? ( + x(72) +) +: ((x(85)) ? ( + x(84) +) +: ( + 5.5313336794064847e-19/(std::exp(((x(88)) ? ( + 300.0 + ) + : ( + x(87) + ))) + 1.0) +))); + x(90) = std::exp((25.0*x(25))*std::log(std::abs(T))); + x(91) = std::exp((-200.0 + 20000.0/((10.0 + 2.3538526683701997e+17/x(90))*(1.6889118802245084e-48*x(90) + 10.0)))*std::log(std::abs(10.0))); + x(92) = x(42)*x(79); + x(93) = x(51)*x(80); + x(94) = std::exp((2.0943374000000001*x(25)*x(74) + 144.02112655888752*x(35)*x(77) - 36.814414747418546*x(76) - 339.5619991617852*x(92) - 529.07725573213918*x(93) - 23.962112000000001)*std::log(std::abs(10.0)))*X(8)*x(91); + x(95) = x(25)*x(74); + x(96) = std::exp((-38.89917505778142*x(76) + 95.70878894783884*x(78) - 377.88183430702219*x(92) + 3018.4974183098116*x(93) + 2.1892372*x(95) - 23.689236999999999)*std::log(std::abs(10.0)))*X(13); + x(97) = T > 10.0; + x(98) = x(85) && x(97); + x(99) = std::exp((16.666666666666664*x(25))*std::log(std::abs(T))); + x(100) = std::exp((-200.0 + 20000.0/((10.0 + 785.77199422741614/x(99))*(5.0592917094448065e-34*x(99) + 10.0)))*std::log(std::abs(10.0))); + x(101) = 1.002560385050777e-22*X(13)*x(100); + x(102) = std::exp((0.73442154540113413*x(76) - 77.855706084264682*x(78) - 1161.2797752309887*x(92) + 5059.6285287169567*x(93) + 1.5714710999999999*x(95) - 22.089523)*std::log(std::abs(10.0)))*X(1); + x(103) = 1.1825091393820599e-21*X(1)*x(100); + x(104) = std::exp((2774.5177117396752*x(76) + 16037.924047681272*x(78) + 45902.322591745004*x(92) + 60522.293708798054*x(93) + 37.383713*x(95) - 16.818342000000001)*std::log(std::abs(10.0)))*X(2); + x(105) = T <= 100.0; + x(106) = std::exp((3.5692468000000002*x(25)*x(74) - 540.77102118284597*x(76) - 9179.8864335208946*x(78) - 48562.751069188118*x(92) - 66875.646562351845*x(93) - 24.311209000000002)*std::log(std::abs(10.0)))*X(2); + x(107) = T <= 1000.0; + x(108) = std::exp((-177.55453097873294*x(76) + 1956.911370108365*x(78) - 12547.661945180447*x(92) + 24439.250555499191*x(93) + 4.6450521*x(95) - 24.311209000000002)*std::log(std::abs(10.0)))*X(2); + x(109) = T <= 6000.0; + x(110) = std::exp((17.997580222853362*x(25))*std::log(std::abs(T))); + x(111) = 1.8623144679125181e-22*std::exp((-200.0 + 20000.0/((10.0 + 2973.7534532281375/x(110))*(1.3368457736780898e-34*x(110) + 10.0)))*std::log(std::abs(10.0)))*X(2); + x(112) = x(52)*x(83); + x(113) = std::exp((366063607.58415633*x(112) + 4616.3011562659685*x(76) + 113122.17137872758*x(78) + 87115306.05744876*x(81) + 273295393.17143697*x(82) + 1672890.7229183144*x(92) + 15471651.937466398*x(93) + 16.815729999999999*x(95) - 21.928795999999998)*std::log(std::abs(10.0)))*X(0); + x(114) = T <= 500.0; + x(115) = T > 100; + x(116) = x(114) && x(115); + x(117) = std::exp((-33025002.640084207*x(112) + 44.525106942242758*x(76) + 1331.8748828877385*x(78) + 968783.44101153011*x(81) + 4831859.3594864924*x(82) - 10763.919849753534*x(92) - 138531.11016116844*x(93) + 1.6802758*x(95) - 22.921188999999998)*std::log(std::abs(10.0)))*X(0); + x(118) = T > 500.0; + x(119) = x(91)*((x(116)) ? ( + x(113) +) +: ((x(118)) ? ( + x(117) +) +: ( + 0 +))) + x(94) + ((x(98)) ? ( + x(102) +) +: ( + x(103) +)) + ((x(98)) ? ( + x(96) +) +: ( + x(101) +)) + ((x(105)) ? ( + x(104) +) +: ((x(107)) ? ( + x(106) +) +: ((x(109)) ? ( + x(108) +) +: ( + x(111) +)))); + x(120) = x(72) >= 1.0e-99; + x(121) = x(113)*x(91); + x(122) = x(104) + x(94); + x(123) = x(102) + x(96); + x(124) = x(122) + x(123); + x(125) = x(121) + x(124) >= 1.0e-99; + x(126) = x(123) + x(94); + x(127) = x(106) + x(126); + x(128) = x(121) + x(127) >= 1.0e-99; + x(129) = x(108) + x(126); + x(130) = x(121) + x(129) >= 1.0e-99; + x(131) = x(111) + x(126); + x(132) = x(121) + x(131) >= 1.0e-99; + x(133) = x(101) + x(103); + x(134) = x(122) + x(133); + x(135) = x(121) + x(134) >= 1.0e-99; + x(136) = x(133) + x(94); + x(137) = x(106) + x(136); + x(138) = x(121) + x(137) >= 1.0e-99; + x(139) = x(108) + x(136); + x(140) = x(121) + x(139) >= 1.0e-99; + x(141) = x(111) + x(136); + x(142) = x(121) + x(141) >= 1.0e-99; + x(143) = x(117)*x(91); + x(144) = x(124) + x(143) >= 1.0e-99; + x(145) = x(127) + x(143) >= 1.0e-99; + x(146) = x(129) + x(143) >= 1.0e-99; + x(147) = x(131) + x(143) >= 1.0e-99; + x(148) = x(134) + x(143) >= 1.0e-99; + x(149) = x(137) + x(143) >= 1.0e-99; + x(150) = x(139) + x(143) >= 1.0e-99; + x(151) = x(141) + x(143) >= 1.0e-99; + x(152) = x(124) >= 1.0e-99; + x(153) = x(127) >= 1.0e-99; + x(154) = x(129) >= 1.0e-99; + x(155) = x(131) >= 1.0e-99; + x(156) = x(134) >= 1.0e-99; + x(157) = x(137) >= 1.0e-99; + x(158) = x(139) >= 1.0e-99; + x(159) = x(141) >= 1.0e-99; + x(160) = x(84) >= 1.0e-99; + x(161) = 5.5313336794064847e-19/(0.0024787521766663585*std::exp(x(86)) + 1.0) >= 1.0e-99; + return (x(1)*(-3.1438547368704001e-21*std::exp((0.34999999999999998)*std::log(std::abs(T)))*X(0)*X(8)*std::exp(-102000.0*x(4)) - 0.00022681492*((((T)*(T)))*(((T)*(T))))*x(0)*x(58)*((((x(55) && x(57) && x(60) && x(61)) ? ( + 4.8339620236294848e-32/((x(63) + 2.1986273043946046e-56)*(x(63) + 2.1986273043946046e-56)) >= 1.0 +) +: ( + ((x(57) && x(60) && x(61)) ? ( + 4.8339620236294848e-32/((x(64) + 2.1986273043946046e-56)*(x(64) + 2.1986273043946046e-56)) >= 1.0 + ) + : ( + ((x(60) && x(61)) ? ( + true + ) + : ( + ((x(55) && x(57) && x(60)) ? ( + 216.48287161311649/((x(63)*x(66) + 1.471335691176954e-39)*(x(63)*x(66) + 1.471335691176954e-39)) >= 1.0 + ) + : ( + ((x(57) && x(60)) ? ( + 216.48287161311649/((x(64)*x(66) + 1.471335691176954e-39)*(x(64)*x(66) + 1.471335691176954e-39)) >= 1.0 + ) + : ( + ((x(60)) ? ( + true + ) + : ( + ((x(55) && x(57) && x(61)) ? ( + 4.833962023629485e-72/((x(63)*x(67) + 2.1986273043946045e-76)*(x(63)*x(67) + 2.1986273043946045e-76)) >= 1.0 + ) + : ( + ((x(57) && x(61)) ? ( + 4.833962023629485e-72/((x(64)*x(67) + 2.1986273043946045e-76)*(x(64)*x(67) + 2.1986273043946045e-76)) >= 1.0 + ) + : ( + ((x(61)) ? ( + true + ) + : ( + ((x(55) && x(57)) ? ( + 2.1648287161311648e-38/((x(63)*x(69) + 1.471335691176954e-59)*(x(63)*x(69) + 1.471335691176954e-59)) >= 1.0 + ) + : ( + ((x(57)) ? ( + 2.1648287161311648e-38/((x(64)*x(69) + 1.471335691176954e-59)*(x(64)*x(69) + 1.471335691176954e-59)) >= 1.0 + ) + : ( + true + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) +))) ? ( + 1.0 +) +: ( + 483396202.36294854/((x(58)*x(62)*std::sqrt(((x(60)) ? ( + 9.9999999999999993e-41 + ) + : ( + x(59) + ))*((x(61)) ? ( + 1.0e+80 + ) + : ( + 2.232953576238777e+46*x(68) + ))) + 2.1986273043946046e-36)*(x(58)*x(62)*std::sqrt(((x(60)) ? ( + 9.9999999999999993e-41 + ) + : ( + x(59) + ))*((x(61)) ? ( + 1.0e+80 + ) + : ( + 2.232953576238777e+46*x(68) + ))) + 2.1986273043946046e-36)) +)) + 0.00084373771595996178*T*(1.3806479999999999e-16*X(0) + 1.3806479999999999e-16*X(1) + 1.3806479999999999e-16*X(10) + 1.3806479999999999e-16*X(11) + 1.3806479999999999e-16*X(12) + 1.3806479999999999e-16*X(13) + 1.3806479999999999e-16*X(2) + 1.3806479999999999e-16*X(3) + 1.3806479999999999e-16*X(4) + 1.3806479999999999e-16*X(5) + 1.3806479999999999e-16*X(6) + 1.3806479999999999e-16*X(7) + 1.3806479999999999e-16*X(8) + 1.3806479999999999e-16*X(9))/(std::sqrt(x(1))*x(22)) - 2.1299999999999999e-27*X(0)*x(2)*(4.0*X(11) + x(3)) - 5.6500000000000001e-36*X(0)*(T - x(5))*((((z + 1.0)*(z + 1.0)))*(((z + 1.0)*(z + 1.0)))) - 3.4635323838154264e-26*X(1)*x(14) - 1.3854129535261706e-25*X(11)*x(14) - 9.3799999999999993e-22*X(13)*x(10)*x(12)*std::exp(-285335.40000000002*x(8)) + 7.1777505408000004e-12*((X(2))*(X(2))*(X(2)))*x(18)*(2.0000000000000002e-31*x(15) + 6.0000000000000001e-32*x(21)) + 7.1777505408000004e-12*((X(2))*(X(2)))*X(8)*x(18)*(2.5000000000000002e-32*x(15) + 7.5000000000000001e-33*x(21)) + 5.6556829037999995e-12*X(2)*X(3)*x(18)*(1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))))/(0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0) + 1.75918975308e-21*X(2)*X(6)*x(18) - 7.1777505408000004e-12*X(2)*X(8)*(std::exp((42.707410000000003*x(23)*x(25) - 2.0273650000000001*x(29) - 21467.790000000001*x(4) - 1657.4099999999999*x(4)/(std::exp((x(39))*std::log(std::abs(std::exp((-x(38) - 8.1313220000000008)*std::log(std::abs(10.0)))*x(17)))) + 1.0) - x(40) - 142.7664 - (70.138370000000009*x(23)*x(25) + 11.28215*x(25)*std::log(14254.549999999999*x(4) + 1.0) - 4.7035149999999994*x(29) - x(40) - 203.11568)/(std::exp((x(39))*std::log(std::abs(std::exp((-x(38) - 9.3055640000000004)*std::log(std::abs(10.0)))*x(17)))) + 1.0))*std::log(std::abs(10.0))) + std::exp((43.20243*x(26)*x(28) - 68.422430000000006*x(34) - x(37) - 23705.700000000001*x(4) - 2080.4099999999999*x(4)/(std::exp((x(33))*std::log(std::abs(std::exp((-x(30) - 13.656822)*std::log(std::abs(10.0)))*x(17)))) + 1.0) - 178.4239 - (19.734269999999999*x(25)*std::log(16780.950000000001*x(4) + 1.0) + 37.886913*x(26)*x(28) - 14.509090000000008*x(34) - x(37) - 307.31920000000002)/(std::exp((x(33))*std::log(std::abs(std::exp((-x(30) - 14.82123)*std::log(std::abs(10.0)))*x(17)))) + 1.0))*std::log(std::abs(10.0)))) - 7.1777505408000004e-12*((X(8))*(X(8)))*std::exp((x(27))*std::log(std::abs(1.1800000000000001e-10*std::exp(-69500.0*x(4)))))*std::exp((1.0 - x(27))*std::log(std::abs(8.1250000000000003e-8*x(15)*(1.0 - std::exp(-6000.0*x(4)))*std::exp(-52000.0*x(4))))) - 1.2700000000000001e-21*x(10)*x(13)*std::exp(-157809.10000000001*x(8)) - 4.9500000000000001e-22*x(10)*x(19)*std::exp(-631515.0*x(8)) - 7.4999999999999996e-19*x(13)*std::exp(-118348.0*x(8)) - 5.5399999999999998e-17*x(19)*((x(6)) ? ( + 0.4008667176273028 +) +: ( + std::exp((-0.39700000000000002)*std::log(std::abs(T))) +))*std::exp(-473638.0*x(8)) - 5.0099999999999997e-27*x(20)*std::exp(-55338.0*x(8)) - 9.1000000000000001e-27*x(20)*std::exp(-13179.0*x(8)) - 1.24e-13*x(7)*(1.0 + 0.29999999999999999*std::exp(-94000.0*x(8)))*((x(6)) ? ( + 0.031622776601683791 +) +: ( + std::exp((-1.5)*std::log(std::abs(T))) +))*std::exp(-470000.0*x(8)) - 1.5499999999999999e-26*x(7)*((x(6)) ? ( + 2.3157944032250755 +) +: ( + std::exp((0.36470000000000002)*std::log(std::abs(T))) +)) - ((T < 2.0) ? ( + 0 +) +: ( + X(8)*((((x(70)) ? ( + true + ) + : ( + x(71) >= 1.0 + ))) ? ( + 1.0 + ) + : ( + ((x(70)) ? ( + 1.000000000000001e+18 + ) + : ( + x(71) + )) + ))*((((x(105) && x(114) && x(115) && x(73) && x(85) && x(97)) ? ( + x(120) && x(125) + ) + : ( + ((x(107) && x(114) && x(115) && x(73) && x(85) && x(97)) ? ( + x(120) && x(128) + ) + : ( + ((x(109) && x(114) && x(115) && x(73) && x(85) && x(97)) ? ( + x(120) && x(130) + ) + : ( + ((x(114) && x(115) && x(73) && x(85) && x(97)) ? ( + x(120) && x(132) + ) + : ( + ((x(105) && x(114) && x(115) && x(73)) ? ( + x(120) && x(135) + ) + : ( + ((x(107) && x(114) && x(115) && x(73)) ? ( + x(120) && x(138) + ) + : ( + ((x(109) && x(114) && x(115) && x(73)) ? ( + x(120) && x(140) + ) + : ( + ((x(114) && x(115) && x(73)) ? ( + x(120) && x(142) + ) + : ( + ((x(105) && x(118) && x(73) && x(85) && x(97)) ? ( + x(120) && x(144) + ) + : ( + ((x(107) && x(118) && x(73) && x(85) && x(97)) ? ( + x(120) && x(145) + ) + : ( + ((x(109) && x(118) && x(73) && x(85) && x(97)) ? ( + x(120) && x(146) + ) + : ( + ((x(118) && x(73) && x(85) && x(97)) ? ( + x(120) && x(147) + ) + : ( + ((x(105) && x(118) && x(73)) ? ( + x(120) && x(148) + ) + : ( + ((x(107) && x(118) && x(73)) ? ( + x(120) && x(149) + ) + : ( + ((x(109) && x(118) && x(73)) ? ( + x(120) && x(150) + ) + : ( + ((x(118) && x(73)) ? ( + x(120) && x(151) + ) + : ( + ((x(105) && x(73) && x(85) && x(97)) ? ( + x(120) && x(152) + ) + : ( + ((x(107) && x(73) && x(85) && x(97)) ? ( + x(120) && x(153) + ) + : ( + ((x(109) && x(73) && x(85) && x(97)) ? ( + x(120) && x(154) + ) + : ( + ((x(73) && x(85) && x(97)) ? ( + x(120) && x(155) + ) + : ( + ((x(105) && x(73)) ? ( + x(120) && x(156) + ) + : ( + ((x(107) && x(73)) ? ( + x(120) && x(157) + ) + : ( + ((x(109) && x(73)) ? ( + x(120) && x(158) + ) + : ( + ((x(73)) ? ( + x(120) && x(159) + ) + : ( + ((x(105) && x(114) && x(115) && x(85) && x(97)) ? ( + x(125) && x(160) + ) + : ( + ((x(107) && x(114) && x(115) && x(85) && x(97)) ? ( + x(128) && x(160) + ) + : ( + ((x(109) && x(114) && x(115) && x(85) && x(97)) ? ( + x(130) && x(160) + ) + : ( + ((x(114) && x(115) && x(85) && x(97)) ? ( + x(132) && x(160) + ) + : ( + ((x(105) && x(114) && x(115) && x(85)) ? ( + x(135) && x(160) + ) + : ( + ((x(107) && x(114) && x(115) && x(85)) ? ( + x(138) && x(160) + ) + : ( + ((x(109) && x(114) && x(115) && x(85)) ? ( + x(140) && x(160) + ) + : ( + ((x(114) && x(115) && x(85)) ? ( + x(142) && x(160) + ) + : ( + ((x(105) && x(118) && x(85) && x(97)) ? ( + x(144) && x(160) + ) + : ( + ((x(107) && x(118) && x(85) && x(97)) ? ( + x(145) && x(160) + ) + : ( + ((x(109) && x(118) && x(85) && x(97)) ? ( + x(146) && x(160) + ) + : ( + ((x(118) && x(85) && x(97)) ? ( + x(147) && x(160) + ) + : ( + ((x(105) && x(118) && x(85)) ? ( + x(148) && x(160) + ) + : ( + ((x(107) && x(118) && x(85)) ? ( + x(149) && x(160) + ) + : ( + ((x(109) && x(118) && x(85)) ? ( + x(150) && x(160) + ) + : ( + ((x(118) && x(85)) ? ( + x(151) && x(160) + ) + : ( + ((x(105) && x(85) && x(97)) ? ( + x(152) && x(160) + ) + : ( + ((x(107) && x(85) && x(97)) ? ( + x(153) && x(160) + ) + : ( + ((x(109) && x(85) && x(97)) ? ( + x(154) && x(160) + ) + : ( + ((x(98)) ? ( + x(155) && x(160) + ) + : ( + ((x(105) && x(85)) ? ( + x(156) && x(160) + ) + : ( + ((x(107) && x(85)) ? ( + x(157) && x(160) + ) + : ( + ((x(109) && x(85)) ? ( + x(158) && x(160) + ) + : ( + ((x(85)) ? ( + x(159) && x(160) + ) + : ( + ((x(88) && (x(105) || x(88)) && (x(107) || x(88)) && (x(109) || x(88)) && (x(114) || x(88)) && (x(115) || x(88)) && (x(118) || x(88)) && (x(105) || x(107) || x(88)) && (x(105) || x(109) || x(88)) && (x(105) || x(114) || x(88)) && (x(105) || x(115) || x(88)) && (x(105) || x(118) || x(88)) && (x(107) || x(109) || x(88)) && (x(107) || x(114) || x(88)) && (x(107) || x(115) || x(88)) && (x(107) || x(118) || x(88)) && (x(109) || x(114) || x(88)) && (x(109) || x(115) || x(88)) && (x(109) || x(118) || x(88)) && (x(114) || x(115) || x(88)) && (x(115) || x(118) || x(88)) && (x(105) || x(107) || x(109) || x(88)) && (x(105) || x(107) || x(114) || x(88)) && (x(105) || x(107) || x(115) || x(88)) && (x(105) || x(107) || x(118) || x(88)) && (x(105) || x(109) || x(114) || x(88)) && (x(105) || x(109) || x(115) || x(88)) && (x(105) || x(109) || x(118) || x(88)) && (x(105) || x(114) || x(115) || x(88)) && (x(105) || x(115) || x(118) || x(88)) && (x(107) || x(109) || x(114) || x(88)) && (x(107) || x(109) || x(115) || x(88)) && (x(107) || x(109) || x(118) || x(88)) && (x(107) || x(114) || x(115) || x(88)) && (x(107) || x(115) || x(118) || x(88)) && (x(109) || x(114) || x(115) || x(88)) && (x(109) || x(115) || x(118) || x(88)) && (x(105) || x(107) || x(109) || x(114) || x(88)) && (x(105) || x(107) || x(109) || x(115) || x(88)) && (x(105) || x(107) || x(109) || x(118) || x(88)) && (x(105) || x(107) || x(114) || x(115) || x(88)) && (x(105) || x(107) || x(115) || x(118) || x(88)) && (x(105) || x(109) || x(114) || x(115) || x(88)) && (x(105) || x(109) || x(115) || x(118) || x(88)) && (x(107) || x(109) || x(114) || x(115) || x(88)) && (x(107) || x(109) || x(115) || x(118) || x(88)) && (x(105) || x(107) || x(109) || x(114) || x(115) || x(88)) && (x(105) || x(107) || x(109) || x(115) || x(118) || x(88))) ? ( + false + ) + : ( + ((x(105) && x(114) && x(115)) ? ( + x(135) && x(161) + ) + : ( + ((x(107) && x(114) && x(115)) ? ( + x(138) && x(161) + ) + : ( + ((x(109) && x(114) && x(115)) ? ( + x(140) && x(161) + ) + : ( + ((x(116)) ? ( + x(142) && x(161) + ) + : ( + ((x(105) && x(118)) ? ( + x(148) && x(161) + ) + : ( + ((x(107) && x(118)) ? ( + x(149) && x(161) + ) + : ( + ((x(109) && x(118)) ? ( + x(150) && x(161) + ) + : ( + x(151) && x(161) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + ))) ? ( + x(119)*x(89)/(x(119) + x(89)) + ) + : ( + 0 + )) +)) - ((T >= x(5)) ? ( + std::exp((21.93385*x(25)*x(41) + 0.92432999999999998*x(25)*x(47) + 0.77951999999999999*x(26)*x(41)*x(47) - 10.19097*x(26)*x(45) + 0.54962*x(26)*x(50) - 1.06447*x(35)*x(41)*x(50) + 2.1990599999999998*x(35)*x(44) - 0.54262999999999995*x(35)*x(45)*x(47) - 0.076759999999999995*x(35)*x(49) + 0.11864*x(41)*x(42)*x(49) - 0.0036600000000000001*x(41)*x(48)*x(51) - 0.17333999999999999*x(42)*x(43) + 0.11711000000000001*x(42)*x(44)*x(47) + 0.62343000000000004*x(42)*x(45)*x(50) + 0.0027499999999999998*x(42)*x(48) - 0.0083499999999999998*x(43)*x(47)*x(51) + 6.1920000000000003e-5*x(43)*x(48)*x(52) - 0.001482*x(43)*x(49)*x(53) + 0.0106*x(43)*x(50)*x(54) - 0.00066631000000000004*x(44)*x(48)*x(53) + 0.017590000000000001*x(44)*x(49)*x(54) - 0.13768*x(44)*x(50)*x(51) + 0.0025140000000000002*x(45)*x(48)*x(54) - 0.073660000000000003*x(45)*x(49)*x(51) - 42.567880000000002)*std::log(std::abs(10.0)))*X(10) +) +: ( + 0 +)))); +} + +template +AMREX_GPU_HOST_DEVICE AMREX_INLINE +void jac_nuc_scratch(const burn_t& state, + MatrixType& jac, + const Array1D& X, + Real const z, + Real* x_scratch, + const int zone, + const int stride) +{ + using namespace Rates; + ScratchView x{x_scratch, zone, stride}; + Real T = state.T; + x(0) = 0; + x(1) = 0; + x(2) = 0; + x(3) = 0; + x(4) = 0; + x(5) = 0; + x(6) = 0; + x(7) = 0; + x(8) = 0; + x(9) = 0; + x(10) = 0; + x(11) = 0; + x(12) = 0; + x(13) = 0; + x(14) = 0; + x(15) = 0; + x(16) = 0; + x(17) = 0; + x(18) = 0; + x(19) = 0; + x(20) = 0; + x(21) = 0; + x(22) = 0; + x(23) = 0; + x(24) = 0; + x(25) = 0; + x(26) = 0; + x(27) = 0; + x(28) = 0; + x(29) = 0; + x(30) = 0; + x(31) = 0; + x(32) = 0; + x(33) = 0; + x(34) = 0; + x(35) = 0; + x(36) = 0; + x(37) = 0; + x(38) = 0; + x(39) = 0; + x(40) = 0; + x(41) = 0; + x(42) = 0; + x(43) = 0; + x(44) = 0; + x(45) = 0; + x(46) = 0; + x(47) = 0; + x(48) = 0; + x(49) = 0; + x(50) = 0; + x(51) = 0; + x(52) = 0; + x(53) = 0; + x(54) = 0; + x(55) = 0; + x(56) = 0; + x(57) = 0; + x(58) = 0; + x(59) = 0; + x(60) = 0; + x(61) = 0; + x(62) = 0; + x(63) = 0; + x(64) = 0; + x(65) = 0; + x(66) = 0; + x(67) = 0; + x(68) = 0; + x(69) = 0; + x(70) = 0; + x(71) = 0; + x(72) = 0; + x(73) = 0; + x(74) = 0; + x(75) = 0; + x(76) = 0; + x(77) = 0; + x(78) = 0; + x(79) = 0; + x(80) = 0; + x(81) = 0; + x(82) = 0; + x(83) = 0; + x(84) = 0; + x(85) = 0; + x(86) = 0; + x(87) = 0; + x(88) = 0; + x(89) = 0; + x(90) = 0; + x(91) = 0; + x(92) = 0; + x(93) = 0; + x(94) = 0; + x(95) = 0; + x(96) = 0; + x(97) = 0; + x(98) = 0; + x(99) = 0; + x(100) = 0; + x(101) = 0; + x(102) = 0; + x(103) = 0; + x(104) = 0; + x(105) = 0; + x(106) = 0; + x(107) = 0; + x(108) = 0; + x(109) = 0; + x(110) = 0; + x(111) = 0; + x(112) = 0; + x(113) = 0; + x(114) = 0; + x(115) = 0; + x(116) = 0; + x(117) = 0; + x(118) = 0; + x(119) = 0; + x(120) = 0; + x(121) = 0; + x(122) = 0; + x(123) = 0; + x(124) = 0; + x(125) = 0; + x(126) = 0; + x(127) = 0; + x(128) = 0; + x(129) = 0; + x(130) = 0; + x(131) = 0; + x(132) = 0; + x(133) = 0; + x(134) = 0; + x(135) = 0; + x(136) = 0; + x(137) = 0; + x(138) = 0; + x(139) = 0; + x(140) = 0; + x(141) = 0; + x(142) = 0; + x(143) = 0; + x(144) = 0; + x(145) = 0; + x(146) = 0; + x(147) = 0; + x(148) = 0; + x(149) = 0; + x(150) = 0; + x(151) = 0; + x(152) = 0; + x(153) = 0; + x(154) = 0; + x(155) = 0; + x(156) = 0; + x(157) = 0; + x(158) = 0; + x(159) = 0; + x(160) = 0; + x(161) = 0; + x(162) = 0; + x(163) = 0; + x(164) = 0; + x(165) = 0; + x(166) = 0; + x(167) = 0; + x(168) = 0; + x(169) = 0; + x(170) = 0; + x(171) = 0; + x(172) = 0; + x(173) = 0; + x(174) = 0; + x(175) = 0; + x(176) = 0; + x(177) = 0; + x(178) = 0; + x(179) = 0; + x(180) = 0; + x(181) = 0; + x(182) = 0; + x(183) = 0; + x(184) = 0; + x(185) = 0; + x(186) = 0; + x(187) = 0; + x(188) = 0; + x(189) = 0; + x(190) = 0; + x(191) = 0; + x(192) = 0; + x(193) = 0; + x(194) = 0; + x(195) = 0; + x(196) = 0; + x(197) = 0; + x(198) = 0; + x(199) = 0; + x(200) = 0; + x(201) = 0; + x(202) = 0; + x(203) = 0; + x(204) = 0; + x(205) = 0; + x(206) = 0; + x(207) = 0; + x(208) = 0; + x(209) = 0; + x(210) = 0; + x(211) = 0; + x(212) = 0; + x(213) = 0; + x(214) = 0; + x(215) = 0; + x(216) = 0; + x(217) = 0; + x(218) = 0; + x(219) = 0; + x(220) = 0; + x(221) = 0; + x(222) = 0; + x(223) = 0; + x(224) = 0; + x(225) = 0; + x(226) = 0; + x(227) = 0; + x(228) = 0; + x(229) = 0; + x(230) = 0; + x(231) = 0; + x(232) = 0; + x(233) = 0; + x(234) = 0; + x(235) = 0; + x(236) = 0; + x(237) = 0; + x(238) = 0; + x(239) = 0; + x(240) = 0; + x(241) = 0; + x(242) = 0; + x(243) = 0; + x(244) = 0; + x(245) = 0; + x(246) = 0; + x(247) = 0; + x(248) = 0; + x(249) = 0; + x(250) = 0; + x(251) = 0; + x(252) = 0; + x(253) = 0; + x(254) = 0; + x(255) = 0; + x(256) = 0; + x(257) = 0; + x(258) = 0; + x(259) = 0; + x(260) = 0; + x(261) = 0; + x(262) = 0; + x(263) = 0; + x(264) = 0; + x(265) = 0; + x(266) = 0; + x(267) = 0; + x(268) = 0; + x(269) = 0; + x(270) = 0; + x(271) = 0; + x(272) = 0; + x(273) = 0; + x(274) = 0; + x(275) = 0; + x(276) = 0; + x(277) = 0; + x(278) = 0; + x(279) = 0; + x(280) = 0; + x(281) = 0; + x(282) = 0; + x(283) = 0; + x(284) = 0; + x(285) = 0; + x(286) = 0; + x(287) = 0; + x(288) = 0; + x(289) = 0; + x(290) = 0; + x(291) = 0; + x(292) = 0; + x(293) = 0; + x(294) = 0; + x(295) = 0; + x(296) = 0; + x(297) = 0; + x(298) = 0; + x(299) = 0; + x(300) = 0; + x(301) = 0; + x(302) = 0; + x(303) = 0; + x(304) = 0; + x(305) = 0; + x(306) = 0; + x(307) = 0; + x(308) = 0; + x(309) = 0; + x(310) = 0; + x(311) = 0; + x(312) = 0; + x(313) = 0; + x(314) = 0; + x(315) = 0; + x(316) = 0; + x(317) = 0; + x(318) = 0; + x(319) = 0; + x(320) = 0; + x(321) = 0; + x(322) = 0; + x(323) = 0; + x(324) = 0; + x(325) = 0; + x(326) = 0; + x(327) = 0; + x(328) = 0; + x(329) = 0; + x(330) = 0; + x(331) = 0; + x(332) = 0; + x(333) = 0; + x(334) = 0; + x(335) = 0; + x(336) = 0; + x(337) = 0; + x(338) = 0; + x(339) = 0; + x(340) = 0; + x(341) = 0; + x(342) = 0; + x(343) = 0; + x(344) = 0; + x(345) = 0; + x(346) = 0; + x(347) = 0; + x(348) = 0; + x(349) = 0; + x(350) = 0; + x(351) = 0; + x(352) = 0; + x(353) = 0; + x(354) = 0; + x(355) = 0; + x(356) = 0; + x(357) = 0; + x(358) = 0; + x(359) = 0; + x(360) = 0; + x(361) = 0; + x(362) = 0; + x(363) = 0; + x(364) = 0; + x(365) = 0; + x(366) = 0; + x(367) = 0; + x(368) = 0; + x(369) = 0; + x(370) = 0; + x(371) = 0; + x(372) = 0; + x(373) = 0; + x(374) = 0; + x(375) = 0; + x(376) = 0; + x(377) = 0; + x(378) = 0; + x(379) = 0; + x(380) = 0; + x(381) = 0; + x(382) = 0; + x(383) = 0; + x(384) = 0; + x(385) = 0; + x(386) = 0; + x(387) = 0; + x(388) = 0; + x(389) = 0; + x(390) = 0; + x(391) = 0; + x(392) = 0; + x(393) = 0; + x(394) = 0; + x(395) = 0; + x(396) = 0; + x(397) = 0; + x(398) = 0; + x(399) = 0; + x(400) = 0; + x(401) = 0; + x(402) = 0; + x(403) = 0; + x(404) = 0; + x(405) = 0; + x(406) = 0; + x(407) = 0; + x(408) = 0; + x(409) = 0; + x(410) = 0; + x(411) = 0; + x(412) = 0; + x(413) = 0; + x(414) = 0; + x(415) = 0; + x(416) = 0; + x(417) = 0; + x(418) = 0; + x(419) = 0; + x(420) = 0; + x(421) = 0; + x(422) = 0; + x(423) = 0; + x(424) = 0; + x(425) = 0; + x(426) = 0; + x(427) = 0; + x(428) = 0; + x(429) = 0; + x(430) = 0; + x(431) = 0; + x(432) = 0; + x(433) = 0; + x(434) = 0; + x(435) = 0; + x(436) = 0; + x(437) = 0; + x(438) = 0; + x(439) = 0; + x(440) = 0; + x(441) = 0; + x(442) = 0; + x(443) = 0; + x(444) = 0; + x(445) = 0; + x(446) = 0; + x(447) = 0; + x(448) = 0; + x(449) = 0; + x(450) = 0; + x(451) = 0; + x(452) = 0; + x(453) = 0; + x(454) = 0; + x(455) = 0; + x(456) = 0; + x(457) = 0; + x(458) = 0; + x(459) = 0; + x(460) = 0; + x(461) = 0; + x(462) = 0; + x(463) = 0; + x(464) = 0; + x(465) = 0; + x(466) = 0; + x(467) = 0; + x(468) = 0; + x(469) = 0; + x(470) = 0; + x(471) = 0; + x(472) = 0; + x(473) = 0; + x(474) = 0; + x(475) = 0; + x(476) = 0; + x(477) = 0; + x(478) = 0; + x(479) = 0; + x(480) = 0; + x(481) = 0; + x(482) = 0; + x(483) = 0; + x(484) = 0; + x(485) = 0; + x(486) = 0; + x(487) = 0; + x(488) = 0; + x(489) = 0; + x(490) = 0; + x(491) = 0; + x(492) = 0; + x(493) = 0; + x(494) = 0; + x(495) = 0; + x(496) = 0; + x(497) = 0; + x(498) = 0; + x(499) = 0; + x(500) = 0; + x(501) = 0; + x(502) = 0; + x(503) = 0; + x(504) = 0; + x(505) = 0; + x(506) = 0; + x(507) = 0; + x(508) = 0; + x(509) = 0; + x(510) = 0; + x(511) = 0; + x(512) = 0; + x(513) = 0; + x(514) = 0; + x(515) = 0; + x(516) = 0; + x(517) = 0; + x(518) = 0; + x(519) = 0; + x(520) = 0; + x(521) = 0; + x(522) = 0; + x(523) = 0; + x(524) = 0; + x(525) = 0; + x(526) = 0; + x(527) = 0; + x(528) = 0; + x(529) = 0; + x(530) = 0; + x(531) = 0; + x(532) = 0; + x(533) = 0; + x(0) = 2.5950363272655348e-10*std::exp((-0.75)*std::log(std::abs(T))); + x(1) = std::sqrt(T); + x(2) = 1.0/x(1); + x(3) = 7.1999999999999996e-8*x(2); + x(4) = std::exp(-6.1728395061728397e-5*T); + x(5) = X(2)*x(4); + x(6) = std::exp((0.92800000000000005)*std::log(std::abs(T))); + x(7) = 1.4000000000000001e-18*x(6); + x(8) = std::exp(-0.00010729613733905579*T); + x(9) = X(5)*x(8); + x(10) = std::exp((0.94999999999999996)*std::log(std::abs(T))); + x(11) = 1.3300135414628029e-18*x(10); + x(12) = 1.0/T; + x(13) = std::exp(-46707.0*x(12)); + x(14) = X(8)*x(13); + x(15) = 35.5*std::exp((-2.2799999999999998)*std::log(std::abs(T))); + x(16) = 0.00060040841663220993*x(1) + 1.0; + x(17) = std::exp((-1.7524)*std::log(std::abs(x(16)))); + x(18) = 0.32668576019240059*x(1) + 1.0; + x(19) = std::exp((-0.24759999999999999)*std::log(std::abs(x(18)))); + x(20) = X(11)*x(19); + x(21) = x(17)*x(20); + x(22) = 5.7884371785482823e-10*x(2); + x(23) = ((T)*(T)); + x(24) = ((T)*(T)*(T)); + x(25) = ((((T)*(T)))*(((T)*(T)))); + x(26) = T <= 10000.0; + x(27) = ((x(26)) ? ( + -5.5279999999999998e-28*((T)*(T)*(T)*(T)*(T)) - 2.3088e-11*T + 7.3427999999999993e-15*x(23) - 7.5474000000000004e-19*x(24) + 3.3467999999999999e-23*x(25) + 4.2277999999999996e-8 +) +: ( + 0 +)); + x(28) = 1.4981088130721367e-10*std::exp((-0.63529999999999998)*std::log(std::abs(T))); + x(29) = 8.6173430000000006e-5*T; + x(30) = x(29) <= 9280.0; + x(31) = (1.5400000000000001e-9 + 4.6200000000000001e-10*std::exp(-93988.701501924661*x(12)))*std::exp(-469943.50750964211*x(12)); + x(32) = ((x(30)) ? ( + x(28) +) +: ( + 1250086.112245841*std::exp((-1.5)*std::log(std::abs(T)))*x(31) + x(28) +)); + x(33) = std::exp((2.360852208681)*std::log(std::abs(T))); + x(34) = std::log(x(29)); + x(35) = ((x(34))*(x(34))); + x(36) = ((x(34))*(x(34))*(x(34))); + x(37) = ((((x(34))*(x(34))))*(((x(34))*(x(34))))); + x(38) = ((x(34))*(x(34))*(x(34))*(x(34))*(x(34))); + x(39) = std::exp((6)*std::log(std::abs(x(34)))); + x(40) = ((x(34))*(x(34))*(x(34))*(x(34))*(x(34))*(x(34))*(x(34))); + x(41) = std::exp((8)*std::log(std::abs(x(34)))); + x(42) = std::exp(-0.28274430617039997*x(35) + 0.01623316639567*x(36) - 0.033650120313629989*x(37) + 0.01178329782711*x(38) - 0.001656194699504*x(39) + 0.0001068275202678*x(40) - 2.6312858092069998e-6*x(41)); + x(43) = std::exp((13.536555999999999)*std::log(std::abs(T))); + x(44) = std::exp(-5.7393287500000003*x(35) + 1.56315498*x(36) - 0.28770560000000001*x(37) + 0.034825597700000002*x(38) - 0.00263197617*x(39) + 0.000111954395*x(40) - 2.0391498499999999e-6*x(41)); + x(45) = std::exp((23.915965629999999)*std::log(std::abs(T))); + x(46) = std::exp(-10.753230200000001*x(35) + 3.0580387500000001*x(36) - 0.56851189000000002*x(37) + 0.067953912300000002*x(38) - 0.0050090561*x(39) + 0.000206723616*x(40) - 3.6491614100000001e-6*x(41)); + x(47) = std::exp((43.933476326349997)*std::log(std::abs(T))); + x(48) = std::exp(-18.480669935680002*x(35) + 4.7016264867590021*x(36) - 0.76924663344919997*x(37) + 0.081130420973029999*x(38) - 0.005324020628287001*x(39) + 0.00019757053122209999*x(40) - 3.1655810656650001e-6*x(41)); + x(49) = x(29) <= 5500.0; + x(50) = std::exp((-0.72411256578268512)*std::log(std::abs(T))); + x(51) = ((x(34))*(x(34))*(x(34))*(x(34))*(x(34))*(x(34))*(x(34))*(x(34))*(x(34))); + x(52) = std::exp(-0.02026044731984691*x(35) - 0.002380861877349834*x(36) - 0.00032126052131887958*x(37) - 1.421502914054107e-5*x(38) + 4.9891089202995129e-6*x(39) + 5.7556141375757583e-7*x(40) - 1.8567670397752609e-8*x(41) - 3.0711352431965949e-9*x(51)); + x(53) = ((x(49)) ? ( + x(28) +) +: ( + 3.2867337024382687e-10*x(50)*x(52) +)); + x(54) = 1.0e-8*std::exp((-0.40000000000000002)*std::log(std::abs(T))); + x(55) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(56) = 0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0; + x(57) = 1.0/x(56); + x(58) = 1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))); + x(59) = x(57)*x(58); + x(60) = 5.9082438637265071e-70*x(43); + x(61) = T <= 1160.0; + x(62) = std::exp(-0.14210135215541481*x(35) + 0.0084644553866299998*x(36) - 0.0014327641212992001*x(37) + 0.00020122502847909999*x(38) + 8.6639632430900003e-5*x(39) - 2.5850096802639999e-5*x(40) + 2.4555011970391999e-6*x(41) - 8.0683824611800006e-8*x(51)); + x(63) = 3.3178155742407614e-14*std::exp((1.1394493358416311)*std::log(std::abs(T)))*x(62); + x(64) = ((x(61)) ? ( + 1.4643482606109061e-16*std::exp((1.78186)*std::log(std::abs(T))) +) +: ( + x(63) +)); + x(65) = 3.7903999274394518e-18*x(33); + x(66) = X(0)*x(17); + x(67) = 3.8571873359681582e-209*x(47)*x(48); + x(68) = 4.3524079114767552e-117*x(45); + x(69) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(70) = 2.0860422997526066e-16*x(69); + x(71) = 3.4767371836380304e-16*x(69); + x(72) = 2.6534040307116389e-10*std::exp((-1.1000000000000001)*std::log(std::abs(T))); + x(73) = X(0)/std::exp((3.0/2.0)*std::log(std::abs(T))); + x(74) = X(0)*x(5); + x(75) = X(0)*x(9); + x(76) = X(0)*x(14); + x(77) = X(2)*X(3); + x(78) = X(3)*x(42); + x(79) = X(2)*x(44); + x(80) = X(13)*x(46); + x(81) = X(0)*X(12); + x(82) = -9.5174852894472843e-11*std::exp((-1.6353)*std::log(std::abs(T))); + x(83) = std::exp((-3.5)*std::log(std::abs(T))); + x(84) = x(12)*x(34); + x(85) = x(12)*x(36); + x(86) = x(12)*x(38); + x(87) = x(12)*x(40); + x(88) = x(12)*x(41); + jac(1,1) = -X(1)*x(53) - X(12)*x(32) + 3.8571873359681582e-209*X(12)*x(47)*x(48) + 4.3524079114767552e-117*X(13)*x(45)*x(46) + 5.9082438637265071e-70*X(2)*x(43)*x(44) + 3.7903999274394518e-18*X(3)*x(33)*x(42) - X(4)*x(0) - X(6)*x(27) - X(9)*x(3) - x(11)*x(9) - x(14)*x(15) - x(21)*x(22) - x(5)*x(7); + jac(1,2) = -X(0)*x(53) + X(3)*x(54); + jac(1,3) = -X(0)*x(4)*x(7) + X(0)*x(44)*x(60) + X(3)*x(59) + X(3)*x(64) + X(7)*x(55); + jac(1,4) = X(0)*x(42)*x(65) + X(1)*x(54) + X(2)*x(59) + X(2)*x(64) + X(5)*x(55); + jac(1,5) = -X(0)*x(0); + jac(1,6) = -X(0)*x(11)*x(8) + X(3)*x(55); + jac(1,7) = -X(0)*x(27); + jac(1,8) = X(2)*x(55); + jac(1,9) = -X(0)*x(13)*x(15); + jac(1,10) = -X(0)*x(3); + jac(1,11) = 0; + jac(1,12) = -x(19)*x(22)*x(66); + jac(1,13) = -X(0)*x(32) + X(0)*x(67); + jac(1,14) = X(0)*x(46)*x(68); + jac(1,15) = (-1658098.5*std::exp((-4.2799999999999994)*std::log(std::abs(T)))*x(76) + 80.939999999999998*std::exp((-3.2799999999999998)*std::log(std::abs(T)))*x(76) + 1.9462772454491511e-10*std::exp((-1.75)*std::log(std::abs(T)))*X(0)*X(4) - 4.0000000000000002e-9*std::exp((-1.3999999999999999)*std::log(std::abs(T)))*X(1)*X(3) - 1.2992000000000002e-18*std::exp((-0.071999999999999953)*std::log(std::abs(T)))*x(74) - 1.2635128643896626e-18*std::exp((-0.050000000000000044)*std::log(std::abs(T)))*x(75) + 8.9485740404797324e-18*std::exp((1.360852208681)*std::log(std::abs(T)))*X(0)*x(78) + 7.997727392299023e-69*std::exp((12.536555999999999)*std::log(std::abs(T)))*X(0)*x(79) + 1.0409203801861816e-115*std::exp((22.915965629999999)*std::log(std::abs(T)))*X(0)*x(80) + 1.694596485110541e-207*std::exp((42.933476326349997)*std::log(std::abs(T)))*x(48)*x(81) - X(0)*X(1)*((x(49)) ? ( + x(82) +) +: ( + -2.3799651743169991e-10*std::exp((-1.724112565782685)*std::log(std::abs(T)))*x(52) + 3.2867337024382687e-10*x(50)*x(52)*(-0.0071425856320495021*x(12)*x(35) - 7.1075145702705346e-5*x(12)*x(37) + 2.9934653521797078e-5*x(12)*x(38) + 4.0289298963030308e-6*x(12)*x(39) - 0.04052089463969382*x(84) - 0.0012850420852755183*x(85) - 1.4854136318202087e-7*x(87) - 2.7640217188769353e-8*x(88)) +)) - X(0)*X(6)*((x(26)) ? ( + 1.4685599999999999e-14*T - 2.2642200000000001e-18*x(23) + 1.3387199999999999e-22*x(24) - 2.7639999999999999e-27*x(25) - 2.3088e-11 +) +: ( + 0 +)) + 3.0451686126851684e-13*X(0)*x(12)*std::exp((-2.7523999999999997)*std::log(std::abs(x(16))))*x(20) + X(0)*x(60)*x(79)*(4.6894649399999997*x(12)*x(35) + 0.1741279885*x(12)*x(37) + 0.00078368076500000001*x(12)*x(39) - 11.478657500000001*x(84) - 1.1508224*x(85) - 0.015791857020000001*x(86) - 1.6313198799999999e-5*x(87)) + X(0)*x(65)*x(78)*(0.048699499187009998*x(12)*x(35) + 0.058916489135550004*x(12)*x(37) + 0.00074779264187460007*x(12)*x(39) - 0.56548861234079995*x(84) - 0.13460048125451995*x(85) - 0.009937168197024001*x(86) - 2.1050286473655998e-5*x(87)) + X(0)*x(68)*x(80)*(9.1741162500000009*x(12)*x(35) + 0.33976956150000004*x(12)*x(37) + 0.001447065312*x(12)*x(39) - 21.506460400000002*x(84) - 2.2740475600000001*x(85) - 0.030054336600000002*x(86) - 2.9193291280000001e-5*x(87)) + 2.3410580000000002e-11*X(11)*x(12)*std::exp((-1.2476)*std::log(std::abs(x(18))))*x(66) - X(2)*X(7)*x(72) - X(3)*X(5)*x(72) + 3.5999999999999998e-8*X(9)*x(73) + 1.4270531560759686e-22*x(10)*x(75) + 2.8942185892741411e-10*x(21)*x(73) + x(57)*x(77)*(1.3296555000000001e-10*std::exp((-0.90150700000000006)*std::log(std::abs(T))) + 2.466314622e-10*std::exp((-0.44389999999999996)*std::log(std::abs(T))) + 8.1647792100000001e-16*std::exp((1.1825999999999999)*std::log(std::abs(T)))) + 8.6419753086419757e-23*x(6)*x(74) + x(67)*x(81)*(14.104879460277006*x(12)*x(35) + 0.40565210486515002*x(12)*x(37) + 0.0013829937185547*x(12)*x(39) - 36.961339871360003*x(84) - 3.0769865337967999*x(85) - 0.031944123769722006*x(86) - 2.5324648525320001e-5*x(87)) + x(77)*((x(61)) ? ( + 2.6092635916521491e-16*std::exp((0.78186)*std::log(std::abs(T))) +) +: ( + 3.7804827525136553e-14*std::exp((0.13944933584163111)*std::log(std::abs(T)))*x(62) + x(63)*(0.025393366159889998*x(12)*x(35) + 0.0010061251423955*x(12)*x(37) + 0.00051983779458540007*x(12)*x(38) - 0.00018095067761848*x(12)*x(39) + 1.9644009576313599e-5*x(12)*x(40) - 0.28420270431082961*x(84) - 0.0057310564851968003*x(85) - 7.2615442150620009e-7*x(88)) +)) - x(81)*((x(30)) ? ( + x(82) +) +: ( + -1875129.1683687614*std::exp((-2.5)*std::log(std::abs(T)))*x(31) + 587469852277.90271*x(31)*x(83) + x(82) + 54.282214350476039*x(83)*std::exp(-563932.20901156683*x(12)) +)) + x(58)*x(77)*(-0.0064764051000000007*std::exp((0.04610000000000003)*std::log(std::abs(T))) - 2.7293978880000002e-10*std::exp((2.0424000000000002)*std::log(std::abs(T))) - 1.229450816e-13*std::exp((2.7740999999999998)*std::log(std::abs(T))))/((x(56))*(x(56))))/(X(0)*x(70) + X(1)*x(70) + X(10)*x(71) + X(11)*x(70) + X(12)*x(70) + X(13)*x(70) + X(2)*x(70) + X(3)*x(70) + X(4)*x(70) + X(5)*x(70) + X(6)*x(71) + X(7)*x(70) + X(8)*x(71) + X(9)*x(71)); + x(0) = 8.6173430000000006e-5*T; + x(1) = std::log(x(0)); + x(2) = ((x(1))*(x(1))); + x(3) = ((x(1))*(x(1))*(x(1))); + x(4) = ((((x(1))*(x(1))))*(((x(1))*(x(1))))); + x(5) = ((x(1))*(x(1))*(x(1))*(x(1))*(x(1))); + x(6) = std::exp((6)*std::log(std::abs(x(1)))); + x(7) = ((x(1))*(x(1))*(x(1))*(x(1))*(x(1))*(x(1))*(x(1))); + x(8) = std::exp((8)*std::log(std::abs(x(1)))); + x(9) = std::exp(-5.7393287500000003*x(2) + 1.56315498*x(3) - 0.28770560000000001*x(4) + 0.034825597700000002*x(5) - 0.00263197617*x(6) + 0.000111954395*x(7) - 2.0391498499999999e-6*x(8)); + x(10) = std::exp((13.536555999999999)*std::log(std::abs(T))); + x(11) = 5.9082438637265071e-70*x(10); + x(12) = x(0) <= 5500.0; + x(13) = std::exp((-0.72411256578268512)*std::log(std::abs(T))); + x(14) = std::exp(-3.0711352431965949e-9*((x(1))*(x(1))*(x(1))*(x(1))*(x(1))*(x(1))*(x(1))*(x(1))*(x(1))) - 0.02026044731984691*x(2) - 0.002380861877349834*x(3) - 0.00032126052131887958*x(4) - 1.421502914054107e-5*x(5) + 4.9891089202995129e-6*x(6) + 5.7556141375757583e-7*x(7) - 1.8567670397752609e-8*x(8)); + x(15) = ((x(12)) ? ( + 1.4981088130721367e-10*std::exp((-0.63529999999999998)*std::log(std::abs(T))) +) +: ( + 3.2867337024382687e-10*x(13)*x(14) +)); + x(16) = 7.9674337148168363e-7*std::exp((-0.5)*std::log(std::abs(T))); + x(17) = 1.0e-8*std::exp((-0.40000000000000002)*std::log(std::abs(T))); + x(18) = 1.0/T; + x(19) = std::exp(-457.0*x(18)); + x(20) = 1.0000000000000001e-9*x(19); + x(21) = std::exp((-0.75)*std::log(std::abs(T))); + x(22) = std::exp(-127500.0*x(18)); + x(23) = T <= 10000.0; + x(24) = ((x(23)) ? ( + 1.26e-9*x(21)*x(22) +) +: ( + 4.0000000000000003e-37*std::exp((4.7400000000000002)*std::log(std::abs(T))) +)); + x(25) = std::exp(-37.100000000000001*x(18)); + x(26) = T >= 50.0; + x(27) = ((x(26)) ? ( + 2.0000000000000001e-10*std::exp((0.40200000000000002)*std::log(std::abs(T)))*x(25) - 3.3099999999999998e-17*std::exp((1.48)*std::log(std::abs(T))) +) +: ( + 0 +)); + x(28) = std::sqrt(T); + x(29) = 1.0/x(28); + x(30) = T >= 10.0 && T <= 100000.0; + x(31) = ((x(30)) ? ( + -7.7700000000000002e-13*T + 2.5000000000000002e-10*x(28) + 2.96e-6*x(29) - 1.73e-9 +) +: ( + 0 +)); + x(32) = std::log(T); + x(33) = M_LN10; + x(34) = 1.0/x(33); + x(35) = x(32)*x(34); + x(36) = std::exp((-3.0)*std::log(std::abs(x(33)))); + x(37) = std::exp((-2.0)*std::log(std::abs(x(33)))); + x(38) = ((x(32))*(x(32))); + x(39) = std::exp((-0.12690000000000001*((x(32))*(x(32))*(x(32)))*x(36) - 1.5229999999999999*x(35) + 1.1180000000000001*x(37)*x(38) - 19.379999999999999)*std::log(std::abs(10.0))); + x(40) = X(5)*x(39); + x(41) = T < 30; + x(42) = amrex::Math::powi<-3>(x(33)); + x(43) = ((x(32))*(x(32))*(x(32))); + x(44) = std::exp((-2)*std::log(std::abs(x(33)))); + x(45) = ((x(32))*(x(32))); + x(46) = std::exp((-3.194*x(35) - 0.2072*x(42)*x(43) + 1.786*x(44)*x(45) - 18.199999999999999)*std::log(std::abs(10))); + x(47) = ((x(41)) ? ( + 3.4977396723747635e-20*std::exp((-0.14999999999999999)*std::log(std::abs(T))) +) +: ( + x(46) +)); + x(48) = std::exp(-21237.150000000001*x(18)); + x(49) = ((((x(32))*(x(32))))*(((x(32))*(x(32))))); + x(50) = ((x(32))*(x(32))*(x(32))*(x(32))*(x(32))); + x(51) = std::exp((6)*std::log(std::abs(x(32)))); + x(52) = x(48)*(3.5311931999999998e-13*((x(32))*(x(32))*(x(32))*(x(32))*(x(32))*(x(32))*(x(32))) + 3.3735381999999997e-7*x(32) + 3.4172804999999998e-8*x(43) - 1.4491368e-7*x(45) - 4.7813727999999997e-9*x(49) + 3.9731542e-10*x(50) - 1.8171411000000001e-11*x(51) - 3.3232183000000002e-7); + x(53) = T >= 100.0 && T <= 30000.0; + x(54) = ((x(53)) ? ( + x(52) +) +: ( + 0 +)); + x(55) = 2.8833736969617052e-16*std::exp((0.25)*std::log(std::abs(T))); + x(56) = std::exp(-33.0*x(18)); + x(57) = ((x(26)) ? ( + 2.0299999999999998e-9*std::exp((-0.33200000000000002)*std::log(std::abs(T))) + 2.0600000000000001e-10*std::exp((0.39600000000000002)*std::log(std::abs(T)))*x(56) +) +: ( + 0 +)); + x(58) = 8.4600000000000008e-10*x(35) - 1.3700000000000002e-10*x(44)*x(45) + 4.1700000000000001e-10; + x(59) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(60) = 2.0860422997526066e-16*x(59); + x(61) = 3.4767371836380304e-16*x(59); + x(62) = std::exp((-2)*std::log(std::abs(T))); + x(63) = x(18)*x(32); + x(64) = x(18)*x(34); + x(65) = x(18)*x(45); + x(66) = x(1)*x(18); + x(67) = x(18)*x(3); + x(68) = x(18)*x(7); + jac(2,1) = -X(1)*x(15) + X(2)*x(11)*x(9); + jac(2,2) = -X(0)*x(15) - X(10)*x(20) - X(13)*x(24) - X(2)*x(47) - X(3)*x(17) - X(3)*x(31) - X(5)*x(27) - X(7)*x(16) - X(8)*x(54) - x(40); + jac(2,3) = X(0)*x(11)*x(9) - X(1)*x(47) + X(12)*x(55) + X(4)*x(57) + 6.0e-10*X(6) + 6.3999999999999996e-10*X(9); + jac(2,4) = -X(1)*x(17) - X(1)*x(31); + jac(2,5) = X(2)*x(57) + X(8)*x(58); + jac(2,6) = -X(1)*x(27) - X(1)*x(39); + jac(2,7) = 6.0e-10*X(2); + jac(2,8) = -X(1)*x(16); + jac(2,9) = -X(1)*x(54) + X(4)*x(58); + jac(2,10) = 6.3999999999999996e-10*X(2); + jac(2,11) = -X(1)*x(20); + jac(2,12) = 0; + jac(2,13) = X(2)*x(55); + jac(2,14) = -X(1)*x(24); + jac(2,15) = (3.9837168574084181e-7*std::exp((-1.5)*std::log(std::abs(T)))*X(1)*X(7) + 4.0000000000000002e-9*std::exp((-1.3999999999999999)*std::log(std::abs(T)))*X(1)*X(3) + 7.997727392299023e-69*std::exp((12.536555999999999)*std::log(std::abs(T)))*X(0)*X(2)*x(9) - X(0)*X(1)*((x(12)) ? ( + -9.5174852894472843e-11*std::exp((-1.6353)*std::log(std::abs(T))) +) +: ( + -2.3799651743169991e-10*std::exp((-1.724112565782685)*std::log(std::abs(T)))*x(14) + 3.2867337024382687e-10*x(13)*x(14)*(-0.0071425856320495021*x(18)*x(2) - 7.1075145702705346e-5*x(18)*x(4) + 2.9934653521797078e-5*x(18)*x(5) + 4.0289298963030308e-6*x(18)*x(6) - 2.7640217188769353e-8*x(18)*x(8) - 0.04052089463969382*x(66) - 0.0012850420852755183*x(67) - 1.4854136318202087e-7*x(68)) +)) + 5.9082438637265071e-70*X(0)*X(2)*x(10)*x(9)*(4.6894649399999997*x(18)*x(2) + 0.1741279885*x(18)*x(4) - 0.015791857020000001*x(18)*x(5) + 0.00078368076500000001*x(18)*x(6) - 11.478657500000001*x(66) - 1.1508224*x(67) - 1.6313198799999999e-5*x(68)) - 4.5700000000000003e-7*X(1)*X(10)*x(19)*x(62) - X(1)*X(13)*((x(23)) ? ( + 0.00016065*std::exp((-2.75)*std::log(std::abs(T)))*x(22) - 9.4499999999999994e-10*std::exp((-1.75)*std::log(std::abs(T)))*x(22) +) +: ( + 1.8960000000000001e-36*std::exp((3.7400000000000002)*std::log(std::abs(T))) +)) - X(1)*X(2)*((x(41)) ? ( + -5.2466095085621454e-21*std::exp((-1.1499999999999999)*std::log(std::abs(T))) +) +: ( + x(33)*x(46)*(3.5720000000000001*x(18)*x(32)*x(44) - 0.62159999999999993*x(42)*x(65) - 3.194*x(64)) +)) - X(1)*X(3)*((x(30)) ? ( + 1.2500000000000001e-10*x(29) - 7.7700000000000002e-13 - 1.48e-6/std::exp((3.0/2.0)*std::log(std::abs(T))) +) +: ( + 0 +)) - X(1)*X(5)*((x(26)) ? ( + 7.4200000000000004e-9*std::exp((-1.5979999999999999)*std::log(std::abs(T)))*x(25) + 8.0400000000000002e-11*std::exp((-0.59799999999999998)*std::log(std::abs(T)))*x(25) - 4.8987999999999998e-17*std::exp((0.47999999999999998)*std::log(std::abs(T))) +) +: ( + 0 +)) - X(1)*X(8)*((x(53)) ? ( + x(48)*(-1.9125491199999999e-8*x(18)*x(43) + 1.9865770999999999e-9*x(18)*x(49) - 1.09028466e-10*x(18)*x(50) + 2.4718352399999997e-12*x(18)*x(51) + 3.3735381999999997e-7*x(18) - 2.8982736e-7*x(63) + 1.0251841499999999e-7*x(65)) + 21237.150000000001*x(52)*x(62) +) +: ( + 0 +)) - X(1)*x(40)*(5.1485802679346868*x(18)*std::exp((1.0)*std::log(std::abs(x(32))))*x(37) - 0.87659414490283338*x(18)*x(36)*x(38) - 3.5068370966299316*x(64)) + 7.2084342424042629e-17*X(12)*X(2)*x(21) + X(2)*X(4)*((x(26)) ? ( + 6.7980000000000007e-9*std::exp((-1.6040000000000001)*std::log(std::abs(T)))*x(56) - 6.7396000000000002e-10*std::exp((-1.3320000000000001)*std::log(std::abs(T))) + 8.1576000000000009e-11*std::exp((-0.60399999999999998)*std::log(std::abs(T)))*x(56) +) +: ( + 0 +)) + X(4)*X(8)*(8.4600000000000008e-10*x(18)*x(34) - 2.7400000000000004e-10*x(44)*x(63)))/(X(0)*x(60) + X(1)*x(60) + X(10)*x(61) + X(11)*x(60) + X(12)*x(60) + X(13)*x(60) + X(2)*x(60) + X(3)*x(60) + X(4)*x(60) + X(5)*x(60) + X(6)*x(61) + X(7)*x(60) + X(8)*x(61) + X(9)*x(61)); + x(0) = std::sqrt(T); + x(1) = 1.0/x(0); + x(2) = 7.1999999999999996e-8*x(1); + x(3) = std::exp(-6.1728395061728397e-5*T); + x(4) = X(2)*x(3); + x(5) = std::exp((0.92800000000000005)*std::log(std::abs(T))); + x(6) = 1.4000000000000001e-18*x(5); + x(7) = 1.0/T; + x(8) = std::exp(-46707.0*x(7)); + x(9) = X(8)*x(8); + x(10) = 35.5*std::exp((-2.2799999999999998)*std::log(std::abs(T))); + x(11) = std::exp(-102000.0*x(7)); + x(12) = X(8)*x(11); + x(13) = 8.7599999999999997e-10*std::exp((0.34999999999999998)*std::log(std::abs(T))); + x(14) = ((T)*(T)); + x(15) = ((T)*(T)*(T)); + x(16) = ((((T)*(T)))*(((T)*(T)))); + x(17) = T <= 10000.0; + x(18) = 2*((x(17)) ? ( + -5.5279999999999998e-28*((T)*(T)*(T)*(T)*(T)) - 2.3088e-11*T + 7.3427999999999993e-15*x(14) - 7.5474000000000004e-19*x(15) + 3.3467999999999999e-23*x(16) + 4.2277999999999996e-8 +) +: ( + 0 +)); + x(19) = 8.6173430000000006e-5*T; + x(20) = std::log(x(19)); + x(21) = ((x(20))*(x(20))); + x(22) = ((x(20))*(x(20))*(x(20))); + x(23) = ((((x(20))*(x(20))))*(((x(20))*(x(20))))); + x(24) = ((x(20))*(x(20))*(x(20))*(x(20))*(x(20))); + x(25) = std::exp((6)*std::log(std::abs(x(20)))); + x(26) = ((x(20))*(x(20))*(x(20))*(x(20))*(x(20))*(x(20))*(x(20))); + x(27) = std::exp((8)*std::log(std::abs(x(20)))); + x(28) = std::exp(-0.28274430617039997*x(21) + 0.01623316639567*x(22) - 0.033650120313629989*x(23) + 0.01178329782711*x(24) - 0.001656194699504*x(25) + 0.0001068275202678*x(26) - 2.6312858092069998e-6*x(27)); + x(29) = X(3)*x(28); + x(30) = 3.7903999274394518e-18*std::exp((2.360852208681)*std::log(std::abs(T))); + x(31) = x(29)*x(30); + x(32) = std::exp(-5.7393287500000003*x(21) + 1.56315498*x(22) - 0.28770560000000001*x(23) + 0.034825597700000002*x(24) - 0.00263197617*x(25) + 0.000111954395*x(26) - 2.0391498499999999e-6*x(27)); + x(33) = X(2)*x(32); + x(34) = 5.9082438637265071e-70*std::exp((13.536555999999999)*std::log(std::abs(T))); + x(35) = x(33)*x(34); + x(36) = x(19) <= 5500.0; + x(37) = std::exp((-0.72411256578268512)*std::log(std::abs(T))); + x(38) = ((x(20))*(x(20))*(x(20))*(x(20))*(x(20))*(x(20))*(x(20))*(x(20))*(x(20))); + x(39) = std::exp(-0.02026044731984691*x(21) - 0.002380861877349834*x(22) - 0.00032126052131887958*x(23) - 1.421502914054107e-5*x(24) + 4.9891089202995129e-6*x(25) + 5.7556141375757583e-7*x(26) - 1.8567670397752609e-8*x(27) - 3.0711352431965949e-9*x(38)); + x(40) = ((x(36)) ? ( + 1.4981088130721367e-10*std::exp((-0.63529999999999998)*std::log(std::abs(T))) +) +: ( + 3.2867337024382687e-10*x(37)*x(39) +)); + x(41) = std::exp((-0.75)*std::log(std::abs(T))); + x(42) = std::exp(-127500.0*x(7)); + x(43) = ((x(17)) ? ( + 1.26e-9*x(41)*x(42) +) +: ( + 4.0000000000000003e-37*std::exp((4.7400000000000002)*std::log(std::abs(T))) +)); + x(44) = std::exp(-37.100000000000001*x(7)); + x(45) = T >= 50.0; + x(46) = ((x(45)) ? ( + 2.0000000000000001e-10*std::exp((0.40200000000000002)*std::log(std::abs(T)))*x(44) - 3.3099999999999998e-17*std::exp((1.48)*std::log(std::abs(T))) +) +: ( + 0 +)); + x(47) = std::exp(-21237.150000000001*x(7)); + x(48) = std::log(T); + x(49) = ((x(48))*(x(48))); + x(50) = ((x(48))*(x(48))*(x(48))); + x(51) = ((((x(48))*(x(48))))*(((x(48))*(x(48))))); + x(52) = ((x(48))*(x(48))*(x(48))*(x(48))*(x(48))); + x(53) = std::exp((6)*std::log(std::abs(x(48)))); + x(54) = x(47)*(3.5311931999999998e-13*((x(48))*(x(48))*(x(48))*(x(48))*(x(48))*(x(48))*(x(48))) + 3.3735381999999997e-7*x(48) - 1.4491368e-7*x(49) + 3.4172804999999998e-8*x(50) - 4.7813727999999997e-9*x(51) + 3.9731542e-10*x(52) - 1.8171411000000001e-11*x(53) - 3.3232183000000002e-7); + x(55) = T >= 100.0 && T <= 30000.0; + x(56) = ((x(55)) ? ( + x(54) +) +: ( + 0 +)); + x(57) = T < 30; + x(58) = M_LN10; + x(59) = 1.0/x(58); + x(60) = x(48)*x(59); + x(61) = amrex::Math::powi<-3>(x(58)); + x(62) = x(50)*x(61); + x(63) = std::exp((-2)*std::log(std::abs(x(58)))); + x(64) = std::exp((1.786*x(49)*x(63) - 3.194*x(60) - 0.2072*x(62) - 18.199999999999999)*std::log(std::abs(10))); + x(65) = ((x(57)) ? ( + 3.4977396723747635e-20*std::exp((-0.14999999999999999)*std::log(std::abs(T))) +) +: ( + x(64) +)); + x(66) = T >= 10.0 && T <= 100000.0; + x(67) = 2*((x(66)) ? ( + -7.7700000000000002e-13*T + 2.5000000000000002e-10*x(0) + 2.96e-6*x(1) - 1.73e-9 +) +: ( + 0 +)); + x(68) = std::sqrt(T); + x(69) = 1.0/x(68); + x(70) = X(1) + X(10) + X(2) + X(3) + 2.0*X(6) + 2.0*X(8) + X(9); + x(71) = x(49)*x(63); + x(72) = -4.8909149999999997*x(48)*x(59) - 133.82830000000001*x(7) + 0.47490300000000002*x(71); + x(73) = std::exp((x(72) + 14.82123)*std::log(std::abs(10.0))); + x(74) = 1.0/x(73); + x(75) = x(70)*x(74); + x(76) = std::exp(-0.0022727272727272726*T); + x(77) = std::exp(-0.00054054054054054055*T); + x(78) = -2.0563129999999998*x(76) + 0.58640729999999996*x(77) + 0.82274429999999998; + x(79) = std::exp((x(78))*std::log(std::abs(x(75)))); + x(80) = x(79) + 1.0; + x(81) = 1.0/x(80); + x(82) = 16780.950000000001*x(7) + 1.0; + x(83) = 40870.379999999997*x(7) + 1.0; + x(84) = -69.700860000000006*x(59)*std::log(x(83)) + 4.6331670000000003*x(62); + x(85) = 37.886913*x(49)*x(63) + 19.734269999999999*x(59)*std::log(x(82)) - 14.509090000000008*x(60) - x(84) - 307.31920000000002; + x(86) = std::exp((x(72) + 13.656822)*std::log(std::abs(10.0))); + x(87) = 1.0/x(86); + x(88) = x(70)*x(87); + x(89) = std::exp((x(78))*std::log(std::abs(x(88)))); + x(90) = x(89) + 1.0; + x(91) = 1.0/x(90); + x(92) = std::exp((43.20243*x(49)*x(63) - 68.422430000000006*x(60) - 2080.4099999999999*x(7)*x(91) - 23705.700000000001*x(7) - x(81)*x(85) - x(84) - 178.4239)*std::log(std::abs(10.0))); + x(93) = x(7)*x(89)/((x(90))*(x(90))); + x(94) = 4790.3210533157426*x(93); + x(95) = x(86)*x(87); + x(96) = 1.0/x(70); + x(97) = x(78)*x(96); + x(98) = x(95)*x(97); + x(99) = x(79)*x(85)/((x(80))*(x(80))); + x(100) = 2.3025850929940459*x(99); + x(101) = x(73)*x(74); + x(102) = x(101)*x(97); + x(103) = x(92)*(x(100)*x(102) + x(94)*x(98)); + x(104) = -2.4640089999999999*x(48)*x(59) + 743.05999999999995*x(7) + 0.19859550000000001*x(71); + x(105) = std::exp((x(104) + 9.3055640000000004)*std::log(std::abs(10.0))); + x(106) = 1.0/x(105); + x(107) = x(106)*x(70); + x(108) = 2.9375070000000001*x(76) + 0.23588480000000001*x(77) + 0.75022860000000002; + x(109) = std::exp((x(108))*std::log(std::abs(x(107)))); + x(110) = x(109) + 1.0; + x(111) = 1.0/x(110); + x(112) = 14254.549999999999*x(7) + 1.0; + x(113) = 27535.310000000001*x(7) + 1.0; + x(114) = -21.360939999999999*x(59)*std::log(x(113)) + 0.25820969999999999*x(62); + x(115) = -x(114) + 70.138370000000009*x(48)*x(59) + 11.28215*x(59)*std::log(x(112)) - 4.7035149999999994*x(71) - 203.11568; + x(116) = std::exp((x(104) + 8.1313220000000008)*std::log(std::abs(10.0))); + x(117) = 1.0/x(116); + x(118) = x(117)*x(70); + x(119) = std::exp((x(108))*std::log(std::abs(x(118)))); + x(120) = x(119) + 1.0; + x(121) = 1.0/x(120); + x(122) = std::exp((-x(111)*x(115) - x(114) - 1657.4099999999999*x(121)*x(7) + 42.707410000000003*x(48)*x(59) - 21467.790000000001*x(7) - 2.0273650000000001*x(71) - 142.7664)*std::log(std::abs(10.0))); + x(123) = x(119)*x(7)/((x(120))*(x(120))); + x(124) = 3816.3275589792611*x(123); + x(125) = x(116)*x(117); + x(126) = x(108)*x(96); + x(127) = x(125)*x(126); + x(128) = x(109)*x(115)/((x(110))*(x(110))); + x(129) = 2.3025850929940459*x(128); + x(130) = x(105)*x(106); + x(131) = x(126)*x(130); + x(132) = x(122)*(x(124)*x(127) + x(129)*x(131)); + x(133) = -x(103) - x(132); + x(134) = X(2)*X(8); + x(135) = 3*x(103) + 3*x(132); + x(136) = std::log(0.0001*T); + x(137) = std::exp((-1.6200000000000001*((x(136))*(x(136)))*x(63) + 1.3*x(136)*x(59) - 4.8449999999999998)*std::log(std::abs(10.0))); + x(138) = x(137)*x(70); + x(139) = x(138) + 1.0; + x(140) = std::exp((-2)*std::log(std::abs(x(139)))); + x(141) = 1.0 - std::exp(-6000.0*x(7)); + x(142) = 52000.0*x(7); + x(143) = std::exp(-x(142)); + x(144) = x(141)*x(143); + x(145) = 8.1250000000000003e-8*x(144)*x(69); + x(146) = std::log(x(145)); + x(147) = x(140)*x(146); + x(148) = ((X(8))*(X(8))); + x(149) = 1.1800000000000001e-10*std::exp(-69500.0*x(7)); + x(150) = 1.0/x(139); + x(151) = 1.0*x(150); + x(152) = std::exp((x(151))*std::log(std::abs(x(149)))); + x(153) = 1.0 - x(151); + x(154) = std::exp((x(153))*std::log(std::abs(x(145)))); + x(155) = x(152)*x(154); + x(156) = x(148)*x(155); + x(157) = x(137)*x(156); + x(158) = 2.0*x(157); + x(159) = x(140)*std::log(x(149)); + x(160) = x(158)*x(159); + x(161) = x(133)*x(134) + x(134)*x(135) + x(147)*x(158) - x(160); + x(162) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(163) = std::exp((0.25)*std::log(std::abs(T))); + x(164) = 2.8833736969617052e-16*x(163); + x(165) = 6.1739095063118665e-10*std::exp((0.40999999999999998)*std::log(std::abs(T))); + x(166) = 1.0/x(163); + x(167) = -1.5e-32*x(166) - 5.0000000000000004e-32*x(69); + x(168) = ((X(2))*(X(2))); + x(169) = 1.0/x(14); + x(170) = 5.25e-11*std::exp(173900.0*x(169) - 4430.0*x(7)); + x(171) = T > 200.0; + x(172) = ((x(171)) ? ( + x(170) +) +: ( + 0 +)); + x(173) = std::exp(-33.0*x(7)); + x(174) = ((x(45)) ? ( + 2.0299999999999998e-9*std::exp((-0.33200000000000002)*std::log(std::abs(T))) + 2.0600000000000001e-10*std::exp((0.39600000000000002)*std::log(std::abs(T)))*x(173) +) +: ( + 0 +)); + x(175) = std::exp((-3.0)*std::log(std::abs(x(58)))); + x(176) = std::exp((-2.0)*std::log(std::abs(x(58)))); + x(177) = ((x(48))*(x(48))); + x(178) = std::exp((-0.12690000000000001*x(175)*((x(48))*(x(48))*(x(48))) + 1.1180000000000001*x(176)*x(177) - 1.5229999999999999*x(60) - 19.379999999999999)*std::log(std::abs(10.0))); + x(179) = X(4)*x(178); + x(180) = 0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0; + x(181) = 1.0/x(180); + x(182) = 1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))); + x(183) = x(181)*x(182); + x(184) = T <= 1160.0; + x(185) = std::exp(-0.14210135215541481*x(21) + 0.0084644553866299998*x(22) - 0.0014327641212992001*x(23) + 0.00020122502847909999*x(24) + 8.6639632430900003e-5*x(25) - 2.5850096802639999e-5*x(26) + 2.4555011970391999e-6*x(27) - 8.0683824611800006e-8*x(38)); + x(186) = 3.3178155742407614e-14*std::exp((1.1394493358416311)*std::log(std::abs(T)))*x(185); + x(187) = ((x(184)) ? ( + 1.4643482606109061e-16*std::exp((1.78186)*std::log(std::abs(T))) +) +: ( + x(186) +)); + x(188) = -x(122) - x(92); + x(189) = 3*x(92); + x(190) = 3*x(122); + x(191) = x(189) + x(190); + x(192) = 4.9999999999999996e-6*x(1); + x(193) = amrex::Math::powi<-5>(x(58)); + x(194) = std::exp((-4)*std::log(std::abs(x(58)))); + x(195) = std::exp((0.31788699999999998*x(193)*x(52) - 2.1690299999999998*x(194)*x(51) + 5.8888600000000002*x(60) + 2.2506900000000001*x(62) + 7.1969200000000004*x(71) - 56.473700000000001)*std::log(std::abs(10))); + x(196) = T <= 1167.4796423742259; + x(197) = std::exp(-5207.0*x(7)); + x(198) = ((x(196)) ? ( + x(195) +) +: ( + 3.1699999999999999e-10*x(197) +)); + x(199) = 4.6051701859880918*x(102)*x(99) + 9580.6421066314851*x(93)*x(98); + x(200) = 7632.6551179585222*x(123)*x(127) + 4.6051701859880918*x(128)*x(131); + x(201) = 4.0*x(157); + x(202) = x(134)*(-x(122)*x(200) - x(199)*x(92)) + x(134)*(x(189)*x(199) + x(190)*x(200)) + x(147)*x(201) - x(159)*x(201); + x(203) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(204) = 2.0860422997526066e-16*x(203); + x(205) = 3.4767371836380304e-16*x(203); + x(206) = std::exp((-1.5)*std::log(std::abs(T))); + x(207) = X(2)*X(7); + x(208) = 2.5313028975878652e-10*std::exp((-0.59000000000000008)*std::log(std::abs(T))); + x(209) = std::exp((-3.0/2.0)*std::log(std::abs(T))); + x(210) = X(0)*x(4); + x(211) = X(0)*x(9); + x(212) = X(0)*x(12); + x(213) = ((X(2))*(X(2))*(X(2))); + x(214) = std::exp((-1.25)*std::log(std::abs(T))); + x(215) = X(2)*X(3); + x(216) = x(59)*x(7); + x(217) = x(49)*x(7); + x(218) = x(217)*x(61); + x(219) = x(48)*x(7); + x(220) = x(50)*x(7); + x(221) = x(51)*x(7); + x(222) = x(20)*x(7); + x(223) = x(22)*x(7); + x(224) = x(24)*x(7); + x(225) = x(26)*x(7); + x(226) = x(219)*x(63); + x(227) = x(27)*x(7); + x(228) = 1.0*x(138)*(-7.460375701300709*x(136)*x(63)*x(7) + 2.9933606208922598*x(59)*x(7)); + x(229) = 2*x(156); + x(230) = std::exp((-2.5)*std::log(std::abs(T))); + x(231) = x(169)*x(59); + x(232) = x(231)/x(83); + x(233) = 0.0046734386363636356*x(76) - 0.00031697691891891889*x(77); + x(234) = x(78)*(-308.15104860073512*x(169) - 2.1870091368363029*x(226) + 11.261747970100974*x(59)*x(7)); + x(235) = x(100)*(x(101)*x(234) + x(233)*std::log(x(75))) + 4790.3210533157426*x(169)*x(91) + 54584.391438988954*x(169) - 157.54846734442862*x(216) - 32.004783802655837*x(218) + 198.95454259823751*x(226) - 6559375.6154640894*x(232) - 2.3025850929940459*x(81)*(-14.509090000000008*x(216) - 13.899501000000001*x(218) - 331159.79815649998*x(231)/x(82) - 2848700.6345267999*x(232) + 75.773826*x(48)*x(63)*x(7)) + x(94)*(x(233)*std::log(x(88)) + x(234)*x(95)); + x(236) = x(231)/x(113); + x(237) = -0.0066761522727272725*x(76) - 0.0001275052972972973*x(77); + x(238) = x(108)*(1710.9588792001557*x(169) + 5.6735903924031659*x(216) - 0.91456607567139814*x(226)); + x(239) = -2.3025850929940459*x(111)*(-0.77462909999999996*x(218) - 9.4070299999999989*x(226) - 588180.10479140002*x(236) + 70.138370000000009*x(59)*x(7) - 160821.97128249999*x(231)/x(112)) + 3816.3275589792611*x(121)*x(169) + x(124)*(x(125)*x(238) + x(237)*std::log(x(118))) + x(129)*(x(130)*x(238) + x(237)*std::log(x(107))) + 49431.413233526648*x(169) + 98.337445626384849*x(216) - 1.783649418259394*x(218) - 9.3363608541157479*x(226) - 1354334.7412883535*x(236); + jac(3,1) = X(1)*x(40) + X(6)*x(18) + X(9)*x(2) + x(10)*x(9) + x(12)*x(13) + x(31) - x(35) - x(4)*x(6); + jac(3,2) = X(0)*x(40) + X(13)*x(43) - X(2)*x(65) + X(3)*x(67) + X(5)*x(46) + 7.9674337148168363e-7*X(7)*x(69) + X(8)*x(56) + x(161); + jac(3,3) = -X(0)*x(3)*x(6) - X(0)*x(32)*x(34) - X(1)*x(65) - X(10)*x(172) - X(12)*x(164) + X(2)*X(8)*x(133) + X(2)*X(8)*x(135) + 2*X(2)*X(8)*x(167) - X(3)*x(183) + X(3)*x(187) - X(4)*x(174) - 1.0e-25*X(5) - 6.0e-10*X(6) - X(7)*x(162) - X(7)*x(165) + X(8)*x(188) + X(8)*x(191) - 6.3999999999999996e-10*X(9) + 2.0*x(137)*x(140)*x(146)*x(148)*x(152)*x(154) - x(160) + 3*x(168)*(-1.8e-31*x(166) - 6.0000000000000005e-31*x(69)) + 3*x(168)*(6.0000000000000001e-32*x(166) + 2.0000000000000002e-31*x(69)) - x(179); + jac(3,4) = X(0)*x(28)*x(30) + X(1)*x(67) - X(2)*x(183) + X(2)*x(187) + X(5)*x(165) + X(6)*x(192) + x(161); + jac(3,5) = -X(2)*x(174) - X(2)*x(178); + jac(3,6) = X(1)*x(46) - 1.0e-25*X(2) + X(3)*x(165) + X(8)*x(198); + jac(3,7) = X(0)*x(18) - 6.0e-10*X(2) + X(3)*x(192) + x(202); + jac(3,8) = 7.9674337148168363e-7*X(1)*x(69) - X(2)*x(162) - X(2)*x(165); + jac(3,9) = X(0)*x(10)*x(8) + X(0)*x(11)*x(13) + X(1)*x(56) + X(2)*x(188) + X(2)*x(191) + X(5)*x(198) + 4*X(8)*x(155) + x(167)*x(168) + x(202); + jac(3,10) = X(0)*x(2) - 6.3999999999999996e-10*X(2) + x(161); + jac(3,11) = -X(2)*x(172) + x(161); + jac(3,12) = 0; + jac(3,13) = -X(2)*x(164); + jac(3,14) = X(1)*x(43); + jac(3,15) = (1658098.5*std::exp((-4.2799999999999994)*std::log(std::abs(T)))*x(211) - 80.939999999999998*std::exp((-3.2799999999999998)*std::log(std::abs(T)))*x(211) + 8.9351999999999994e-5*std::exp((-1.6499999999999999)*std::log(std::abs(T)))*x(212) + 2.6534040307116389e-10*std::exp((-1.1000000000000001)*std::log(std::abs(T)))*x(207) + 3.0659999999999995e-10*std::exp((-0.65000000000000002)*std::log(std::abs(T)))*x(212) - 1.2992000000000002e-18*std::exp((-0.071999999999999953)*std::log(std::abs(T)))*x(210) + 8.9485740404797324e-18*std::exp((1.360852208681)*std::log(std::abs(T)))*X(0)*x(29) - 7.997727392299023e-69*std::exp((12.536555999999999)*std::log(std::abs(T)))*X(0)*x(33) + X(0)*X(1)*((x(36)) ? ( + -9.5174852894472843e-11*std::exp((-1.6353)*std::log(std::abs(T))) +) +: ( + -2.3799651743169991e-10*std::exp((-1.724112565782685)*std::log(std::abs(T)))*x(39) + 3.2867337024382687e-10*x(37)*x(39)*(-0.0071425856320495021*x(21)*x(7) - 0.04052089463969382*x(222) - 0.0012850420852755183*x(223) - 1.4854136318202087e-7*x(225) - 2.7640217188769353e-8*x(227) - 7.1075145702705346e-5*x(23)*x(7) + 2.9934653521797078e-5*x(24)*x(7) + 4.0289298963030308e-6*x(25)*x(7)) +)) + 2*X(0)*X(6)*((x(17)) ? ( + 1.4685599999999999e-14*T - 2.2642200000000001e-18*x(14) + 1.3387199999999999e-22*x(15) - 2.7639999999999999e-27*x(16) - 2.3088e-11 +) +: ( + 0 +)) - 3.5999999999999998e-8*X(0)*X(9)*x(209) + X(0)*x(31)*(0.048699499187009998*x(21)*x(7) - 0.56548861234079995*x(222) - 0.13460048125451995*x(223) - 0.009937168197024001*x(224) - 2.1050286473655998e-5*x(225) + 0.058916489135550004*x(23)*x(7) + 0.00074779264187460007*x(25)*x(7)) - X(0)*x(35)*(4.6894649399999997*x(21)*x(7) - 11.478657500000001*x(222) - 1.1508224*x(223) - 0.015791857020000001*x(224) - 1.6313198799999999e-5*x(225) + 0.1741279885*x(23)*x(7) + 0.00078368076500000001*x(25)*x(7)) + X(1)*X(13)*((x(17)) ? ( + 0.00016065*std::exp((-2.75)*std::log(std::abs(T)))*x(42) - 9.4499999999999994e-10*std::exp((-1.75)*std::log(std::abs(T)))*x(42) +) +: ( + 1.8960000000000001e-36*std::exp((3.7400000000000002)*std::log(std::abs(T))) +)) - X(1)*X(2)*((x(57)) ? ( + -5.2466095085621454e-21*std::exp((-1.1499999999999999)*std::log(std::abs(T))) +) +: ( + x(58)*x(64)*(-3.194*x(216) - 0.62159999999999993*x(218) + 3.5720000000000001*x(48)*x(63)*x(7)) +)) + 2*X(1)*X(3)*((x(66)) ? ( + 1.2500000000000001e-10*x(1) - 1.48e-6*x(209) - 7.7700000000000002e-13 +) +: ( + 0 +)) + X(1)*X(5)*((x(45)) ? ( + 7.4200000000000004e-9*std::exp((-1.5979999999999999)*std::log(std::abs(T)))*x(44) + 8.0400000000000002e-11*std::exp((-0.59799999999999998)*std::log(std::abs(T)))*x(44) - 4.8987999999999998e-17*std::exp((0.47999999999999998)*std::log(std::abs(T))) +) +: ( + 0 +)) - 3.9837168574084181e-7*X(1)*X(7)*x(206) + X(1)*X(8)*((x(55)) ? ( + 21237.150000000001*x(169)*x(54) + x(47)*(1.0251841499999999e-7*x(217) - 2.8982736e-7*x(219) - 1.9125491199999999e-8*x(220) + 1.9865770999999999e-9*x(221) - 1.09028466e-10*x(52)*x(7) + 2.4718352399999997e-12*x(53)*x(7) + 3.3735381999999997e-7*x(7)) +) +: ( + 0 +)) - X(10)*X(2)*((x(171)) ? ( + x(170)*(4430.0*x(169) - 347800.0/x(15)) +) +: ( + 0 +)) - 7.2084342424042629e-17*X(12)*X(2)*x(41) - X(2)*X(4)*((x(45)) ? ( + 6.7980000000000007e-9*std::exp((-1.6040000000000001)*std::log(std::abs(T)))*x(173) - 6.7396000000000002e-10*std::exp((-1.3320000000000001)*std::log(std::abs(T))) + 8.1576000000000009e-11*std::exp((-0.60399999999999998)*std::log(std::abs(T)))*x(173) +) +: ( + 0 +)) - X(2)*x(179)*(-0.87659414490283338*x(175)*x(177)*x(7) + 5.1485802679346868*x(176)*std::exp((1.0)*std::log(std::abs(x(48))))*x(7) - 3.5068370966299316*x(216)) + X(3)*X(5)*x(208) - 2.4999999999999998e-6*X(3)*X(6)*x(209) + X(5)*X(8)*((x(196)) ? ( + x(195)*x(58)*(1.5894349999999999*x(193)*x(221) - 8.6761199999999992*x(194)*x(220) + 5.8888600000000002*x(216) + 6.7520699999999998*x(218) + 14.393840000000001*x(226)) +) +: ( + 1.650619e-6*x(169)*x(197) +)) + X(8)*x(168)*(2.5000000000000002e-32*x(206) + 3.75e-33*x(214)) + x(134)*(-x(122)*x(239) - x(235)*x(92)) + x(134)*(x(189)*x(235) + x(190)*x(239)) - x(181)*x(215)*(1.3296555000000001e-10*std::exp((-0.90150700000000006)*std::log(std::abs(T))) + 2.466314622e-10*std::exp((-0.44389999999999996)*std::log(std::abs(T))) + 8.1647792100000001e-16*std::exp((1.1825999999999999)*std::log(std::abs(T)))) - x(207)*x(208) + 8.6419753086419757e-23*x(210)*x(5) + x(213)*(-1.0000000000000001e-31*x(206) - 1.5e-32*x(214)) + x(213)*(3.0000000000000003e-31*x(206) + 4.5e-32*x(214)) + x(215)*((x(184)) ? ( + 2.6092635916521491e-16*std::exp((0.78186)*std::log(std::abs(T))) +) +: ( + 3.7804827525136553e-14*std::exp((0.13944933584163111)*std::log(std::abs(T)))*x(185) + x(186)*(0.025393366159889998*x(21)*x(7) - 0.28420270431082961*x(222) - 0.0057310564851968003*x(223) - 7.2615442150620009e-7*x(227) + 0.0010061251423955*x(23)*x(7) + 0.00051983779458540007*x(24)*x(7) - 0.00018095067761848*x(25)*x(7) + 1.9644009576313599e-5*x(26)*x(7)) +)) + x(229)*(x(147)*x(228) + 12307692.307692308*x(153)*x(68)*(0.0042250000000000005*x(141)*x(143)*x(230) - 4.0625000000000001e-8*x(144)*x(206) - 0.00048750000000000003*x(230)*std::exp(-58000.0*x(7)))*std::exp(x(142))/x(141)) + x(229)*(69500.0*x(150)*x(169) - x(159)*x(228)) - x(182)*x(215)*(-0.0064764051000000007*std::exp((0.04610000000000003)*std::log(std::abs(T))) - 2.7293978880000002e-10*std::exp((2.0424000000000002)*std::log(std::abs(T))) - 1.229450816e-13*std::exp((2.7740999999999998)*std::log(std::abs(T))))/((x(180))*(x(180))))/(X(0)*x(204) + X(1)*x(204) + X(10)*x(205) + X(11)*x(204) + X(12)*x(204) + X(13)*x(204) + X(2)*x(204) + X(3)*x(204) + X(4)*x(204) + X(5)*x(204) + X(6)*x(205) + X(7)*x(204) + X(8)*x(205) + X(9)*x(205)); + x(0) = std::exp(-6.1728395061728397e-5*T); + x(1) = X(2)*x(0); + x(2) = std::exp((0.92800000000000005)*std::log(std::abs(T))); + x(3) = 1.4000000000000001e-18*x(2); + x(4) = 1.0/T; + x(5) = std::exp(-46707.0*x(4)); + x(6) = X(8)*x(5); + x(7) = 35.5*std::exp((-2.2799999999999998)*std::log(std::abs(T))); + x(8) = std::log(8.6173430000000006e-5*T); + x(9) = ((x(8))*(x(8))); + x(10) = ((x(8))*(x(8))*(x(8))); + x(11) = ((((x(8))*(x(8))))*(((x(8))*(x(8))))); + x(12) = ((x(8))*(x(8))*(x(8))*(x(8))*(x(8))); + x(13) = std::exp((6)*std::log(std::abs(x(8)))); + x(14) = ((x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))); + x(15) = std::exp((8)*std::log(std::abs(x(8)))); + x(16) = std::exp(0.01623316639567*x(10) - 0.033650120313629989*x(11) + 0.01178329782711*x(12) - 0.001656194699504*x(13) + 0.0001068275202678*x(14) - 2.6312858092069998e-6*x(15) - 0.28274430617039997*x(9)); + x(17) = X(3)*x(16); + x(18) = 3.7903999274394518e-18*std::exp((2.360852208681)*std::log(std::abs(T))); + x(19) = x(17)*x(18); + x(20) = 1.0e-8*std::exp((-0.40000000000000002)*std::log(std::abs(T))); + x(21) = std::sqrt(T); + x(22) = 1.0/x(21); + x(23) = T >= 10.0 && T <= 100000.0; + x(24) = ((x(23)) ? ( + -7.7700000000000002e-13*T + 2.5000000000000002e-10*x(21) + 2.96e-6*x(22) - 1.73e-9 +) +: ( + 0 +)); + x(25) = 6.1739095063118665e-10*std::exp((0.40999999999999998)*std::log(std::abs(T))); + x(26) = 0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0; + x(27) = 1.0/x(26); + x(28) = 1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))); + x(29) = x(27)*x(28); + x(30) = T <= 1160.0; + x(31) = std::exp(0.0084644553866299998*x(10) - 0.0014327641212992001*x(11) + 0.00020122502847909999*x(12) + 8.6639632430900003e-5*x(13) - 2.5850096802639999e-5*x(14) + 2.4555011970391999e-6*x(15) - 8.0683824611800006e-8*((x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))) - 0.14210135215541481*x(9)); + x(32) = 3.3178155742407614e-14*std::exp((1.1394493358416311)*std::log(std::abs(T)))*x(31); + x(33) = ((x(30)) ? ( + 1.4643482606109061e-16*std::exp((1.78186)*std::log(std::abs(T))) +) +: ( + x(32) +)); + x(34) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(35) = 4.9999999999999996e-6*x(22); + x(36) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(37) = 2.0860422997526066e-16*x(36); + x(38) = 3.4767371836380304e-16*x(36); + x(39) = std::exp((-0.59000000000000008)*std::log(std::abs(T))); + x(40) = std::exp((-3.0/2.0)*std::log(std::abs(T))); + x(41) = X(2)*X(3); + x(42) = x(4)*x(8); + x(43) = x(10)*x(4); + jac(4,1) = x(1)*x(3) - x(19) + x(6)*x(7); + jac(4,2) = -X(3)*x(20) - X(3)*x(24); + jac(4,3) = X(0)*x(0)*x(3) - X(3)*x(29) - X(3)*x(33) + X(7)*x(25); + jac(4,4) = -X(0)*x(16)*x(18) - X(1)*x(20) - X(1)*x(24) - X(2)*x(29) - X(2)*x(33) - X(5)*x(25) - X(5)*x(34) - X(6)*x(35); + jac(4,5) = 0; + jac(4,6) = -X(3)*x(25) - X(3)*x(34); + jac(4,7) = -X(3)*x(35); + jac(4,8) = X(2)*x(25); + jac(4,9) = X(0)*x(5)*x(7); + jac(4,10) = 0; + jac(4,11) = 0; + jac(4,12) = 0; + jac(4,13) = 0; + jac(4,14) = 0; + jac(4,15) = (1658098.5*std::exp((-4.2799999999999994)*std::log(std::abs(T)))*X(0)*X(8)*x(5) - 80.939999999999998*std::exp((-3.2799999999999998)*std::log(std::abs(T)))*X(0)*x(6) + 4.0000000000000002e-9*std::exp((-1.3999999999999999)*std::log(std::abs(T)))*X(1)*X(3) + 2.6534040307116389e-10*std::exp((-1.1000000000000001)*std::log(std::abs(T)))*X(3)*X(5) + 1.2992000000000002e-18*std::exp((-0.071999999999999953)*std::log(std::abs(T)))*X(0)*X(2)*x(0) - 8.9485740404797324e-18*std::exp((1.360852208681)*std::log(std::abs(T)))*X(0)*x(17) - 8.6419753086419757e-23*X(0)*x(1)*x(2) - X(0)*x(19)*(0.058916489135550004*x(11)*x(4) - 0.009937168197024001*x(12)*x(4) + 0.00074779264187460007*x(13)*x(4) - 2.1050286473655998e-5*x(14)*x(4) + 0.048699499187009998*x(4)*x(9) - 0.56548861234079995*x(42) - 0.13460048125451995*x(43)) - X(1)*X(3)*((x(23)) ? ( + 1.2500000000000001e-10*x(22) - 1.48e-6*x(40) - 7.7700000000000002e-13 +) +: ( + 0 +)) + 2.5313028975878652e-10*X(2)*X(7)*x(39) - 2.5313028975878652e-10*X(3)*X(5)*x(39) + 2.4999999999999998e-6*X(3)*X(6)*x(40) - x(27)*x(41)*(1.3296555000000001e-10*std::exp((-0.90150700000000006)*std::log(std::abs(T))) + 2.466314622e-10*std::exp((-0.44389999999999996)*std::log(std::abs(T))) + 8.1647792100000001e-16*std::exp((1.1825999999999999)*std::log(std::abs(T)))) - x(41)*((x(30)) ? ( + 2.6092635916521491e-16*std::exp((0.78186)*std::log(std::abs(T))) +) +: ( + 3.7804827525136553e-14*std::exp((0.13944933584163111)*std::log(std::abs(T)))*x(31) + x(32)*(0.0010061251423955*x(11)*x(4) + 0.00051983779458540007*x(12)*x(4) - 0.00018095067761848*x(13)*x(4) + 1.9644009576313599e-5*x(14)*x(4) - 7.2615442150620009e-7*x(15)*x(4) + 0.025393366159889998*x(4)*x(9) - 0.28420270431082961*x(42) - 0.0057310564851968003*x(43)) +)) - x(28)*x(41)*(-0.0064764051000000007*std::exp((0.04610000000000003)*std::log(std::abs(T))) - 2.7293978880000002e-10*std::exp((2.0424000000000002)*std::log(std::abs(T))) - 1.229450816e-13*std::exp((2.7740999999999998)*std::log(std::abs(T))))/((x(26))*(x(26))))/(X(0)*x(37) + X(1)*x(37) + X(10)*x(38) + X(11)*x(37) + X(12)*x(37) + X(13)*x(37) + X(2)*x(37) + X(3)*x(37) + X(4)*x(37) + X(5)*x(37) + X(6)*x(38) + X(7)*x(37) + X(8)*x(38) + X(9)*x(38)); + x(0) = 2.5950363272655348e-10*std::exp((-0.75)*std::log(std::abs(T))); + x(1) = 1.0/T; + x(2) = std::exp(-457.0*x(1)); + x(3) = 1.0000000000000001e-9*x(2); + x(4) = std::exp(-37.100000000000001*x(1)); + x(5) = T >= 50.0; + x(6) = ((x(5)) ? ( + 2.0000000000000001e-10*std::exp((0.40200000000000002)*std::log(std::abs(T)))*x(4) - 3.3099999999999998e-17*std::exp((1.48)*std::log(std::abs(T))) +) +: ( + 0 +)); + x(7) = std::exp(-33.0*x(1)); + x(8) = ((x(5)) ? ( + 2.0299999999999998e-9*std::exp((-0.33200000000000002)*std::log(std::abs(T))) + 2.0600000000000001e-10*std::exp((0.39600000000000002)*std::log(std::abs(T)))*x(7) +) +: ( + 0 +)); + x(9) = M_LN10; + x(10) = 1.0/x(9); + x(11) = std::log(T); + x(12) = x(10)*x(11); + x(13) = std::exp((-3.0)*std::log(std::abs(x(9)))); + x(14) = std::exp((-2.0)*std::log(std::abs(x(9)))); + x(15) = ((x(11))*(x(11))); + x(16) = std::exp((-0.12690000000000001*((x(11))*(x(11))*(x(11)))*x(13) - 1.5229999999999999*x(12) + 1.1180000000000001*x(14)*x(15) - 19.379999999999999)*std::log(std::abs(10.0))); + x(17) = X(4)*x(16); + x(18) = 9.8726896031426014e-7*std::exp((-0.5)*std::log(std::abs(T))); + x(19) = std::exp((-2)*std::log(std::abs(x(9)))); + x(20) = 1.3700000000000002e-10*((x(11))*(x(11)))*x(19) - 8.4600000000000008e-10*x(12) - 4.1700000000000001e-10; + x(21) = x(1)*x(10); + x(22) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(23) = 2.0860422997526066e-16*x(22); + x(24) = 3.4767371836380304e-16*x(22); + jac(5,1) = -X(4)*x(0); + jac(5,2) = X(10)*x(3) + X(5)*x(6); + jac(5,3) = -X(4)*x(8) - x(17); + jac(5,4) = 0; + jac(5,5) = -X(0)*x(0) - X(2)*x(16) - X(2)*x(8) - X(7)*x(18) + X(8)*x(20); + jac(5,6) = X(1)*x(6); + jac(5,7) = 0; + jac(5,8) = -X(4)*x(18); + jac(5,9) = X(4)*x(20); + jac(5,10) = 0; + jac(5,11) = X(1)*x(3); + jac(5,12) = 0; + jac(5,13) = 0; + jac(5,14) = 0; + jac(5,15) = (1.9462772454491511e-10*std::exp((-1.75)*std::log(std::abs(T)))*X(0)*X(4) + 4.9363448015713007e-7*std::exp((-1.5)*std::log(std::abs(T)))*X(4)*X(7) + X(1)*X(5)*((x(5)) ? ( + 7.4200000000000004e-9*std::exp((-1.5979999999999999)*std::log(std::abs(T)))*x(4) + 8.0400000000000002e-11*std::exp((-0.59799999999999998)*std::log(std::abs(T)))*x(4) - 4.8987999999999998e-17*std::exp((0.47999999999999998)*std::log(std::abs(T))) +) +: ( + 0 +)) - X(2)*X(4)*((x(5)) ? ( + 6.7980000000000007e-9*std::exp((-1.6040000000000001)*std::log(std::abs(T)))*x(7) - 6.7396000000000002e-10*std::exp((-1.3320000000000001)*std::log(std::abs(T))) + 8.1576000000000009e-11*std::exp((-0.60399999999999998)*std::log(std::abs(T)))*x(7) +) +: ( + 0 +)) - X(2)*x(17)*(5.1485802679346868*x(1)*std::exp((1.0)*std::log(std::abs(x(11))))*x(14) - 0.87659414490283338*x(1)*x(13)*x(15) - 3.5068370966299316*x(21)) + X(4)*X(8)*(2.7400000000000004e-10*x(1)*x(11)*x(19) - 8.4600000000000008e-10*x(21)) + 4.5700000000000003e-7*X(1)*X(10)*x(2)/((T)*(T)))/(X(0)*x(23) + X(1)*x(23) + X(10)*x(24) + X(11)*x(23) + X(12)*x(23) + X(13)*x(23) + X(2)*x(23) + X(3)*x(23) + X(4)*x(23) + X(5)*x(23) + X(6)*x(24) + X(7)*x(23) + X(8)*x(24) + X(9)*x(24)); + x(0) = 2.5950363272655348e-10*std::exp((-0.75)*std::log(std::abs(T))); + x(1) = 7.1999999999999996e-8/std::sqrt(T); + x(2) = std::exp(-0.00010729613733905579*T); + x(3) = X(5)*x(2); + x(4) = std::exp((0.94999999999999996)*std::log(std::abs(T))); + x(5) = 1.3300135414628029e-18*x(4); + x(6) = std::exp((-0.5)*std::log(std::abs(T))); + x(7) = 1.0/T; + x(8) = std::exp(-37.100000000000001*x(7)); + x(9) = T >= 50.0; + x(10) = ((x(9)) ? ( + 2.0000000000000001e-10*std::exp((0.40200000000000002)*std::log(std::abs(T)))*x(8) - 3.3099999999999998e-17*std::exp((1.48)*std::log(std::abs(T))) +) +: ( + 0 +)); + x(11) = M_LN10; + x(12) = 1.0/x(11); + x(13) = std::log(T); + x(14) = x(12)*x(13); + x(15) = std::exp((-3.0)*std::log(std::abs(x(11)))); + x(16) = std::exp((-2.0)*std::log(std::abs(x(11)))); + x(17) = ((x(13))*(x(13))); + x(18) = std::exp((-0.12690000000000001*((x(13))*(x(13))*(x(13)))*x(15) - 1.5229999999999999*x(14) + 1.1180000000000001*x(16)*x(17) - 19.379999999999999)*std::log(std::abs(10.0))); + x(19) = X(5)*x(18); + x(20) = 6.1739095063118665e-10*std::exp((0.40999999999999998)*std::log(std::abs(T))); + x(21) = std::exp((-2)*std::log(std::abs(T))); + x(22) = 5.25e-11*std::exp(173900.0*x(21) - 4430.0*x(7)); + x(23) = T > 200.0; + x(24) = ((x(23)) ? ( + x(22) +) +: ( + 0 +)); + x(25) = std::exp(-33.0*x(7)); + x(26) = ((x(9)) ? ( + 2.0299999999999998e-9*std::exp((-0.33200000000000002)*std::log(std::abs(T))) + 2.0600000000000001e-10*std::exp((0.39600000000000002)*std::log(std::abs(T)))*x(25) +) +: ( + 0 +)); + x(27) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(28) = amrex::Math::powi<-5>(x(11)); + x(29) = std::exp((-4)*std::log(std::abs(x(11)))); + x(30) = ((((x(13))*(x(13))))*(((x(13))*(x(13))))); + x(31) = amrex::Math::powi<-3>(x(11)); + x(32) = ((x(13))*(x(13))*(x(13))); + x(33) = std::exp((-2)*std::log(std::abs(x(11)))); + x(34) = ((x(13))*(x(13))); + x(35) = std::exp((0.31788699999999998*((x(13))*(x(13))*(x(13))*(x(13))*(x(13)))*x(28) + 5.8888600000000002*x(14) - 2.1690299999999998*x(29)*x(30) + 2.2506900000000001*x(31)*x(32) + 7.1969200000000004*x(33)*x(34) - 56.473700000000001)*std::log(std::abs(10))); + x(36) = T <= 1167.4796423742259; + x(37) = std::exp(-5207.0*x(7)); + x(38) = ((x(36)) ? ( + x(35) +) +: ( + 3.1699999999999999e-10*x(37) +)); + x(39) = std::exp((-1.5)*std::log(std::abs(T)))*X(7); + x(40) = std::exp((-0.59000000000000008)*std::log(std::abs(T))); + x(41) = x(12)*x(7); + x(42) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(43) = 2.0860422997526066e-16*x(42); + x(44) = 3.4767371836380304e-16*x(42); + jac(6,1) = X(4)*x(0) + X(9)*x(1) - x(3)*x(5); + jac(6,2) = -X(5)*x(10) + 7.9674337148168363e-7*X(7)*x(6) - x(19); + jac(6,3) = X(10)*x(24) + X(4)*x(26) - 1.0e-25*X(5) + X(7)*x(20); + jac(6,4) = -X(5)*x(20) - X(5)*x(27); + jac(6,5) = X(0)*x(0) + X(2)*x(26) + 1.9745379206285203e-6*X(7)*x(6); + jac(6,6) = -X(0)*x(2)*x(5) - X(1)*x(10) - X(1)*x(18) - 1.0e-25*X(2) - X(3)*x(20) - X(3)*x(27) - X(8)*x(38); + jac(6,7) = 0; + jac(6,8) = 7.9674337148168363e-7*X(1)*x(6) + X(2)*x(20) + 1.9745379206285203e-6*X(4)*x(6); + jac(6,9) = -X(5)*x(38); + jac(6,10) = X(0)*x(1); + jac(6,11) = X(2)*x(24); + jac(6,12) = 0; + jac(6,13) = 0; + jac(6,14) = 0; + jac(6,15) = (-1.9462772454491511e-10*std::exp((-1.75)*std::log(std::abs(T)))*X(0)*X(4) + 2.6534040307116389e-10*std::exp((-1.1000000000000001)*std::log(std::abs(T)))*X(3)*X(5) - 1.2635128643896626e-18*std::exp((-0.050000000000000044)*std::log(std::abs(T)))*X(0)*x(3) + 1.4270531560759686e-22*X(0)*X(5)*x(2)*x(4) - X(1)*X(5)*((x(9)) ? ( + 7.4200000000000004e-9*std::exp((-1.5979999999999999)*std::log(std::abs(T)))*x(8) + 8.0400000000000002e-11*std::exp((-0.59799999999999998)*std::log(std::abs(T)))*x(8) - 4.8987999999999998e-17*std::exp((0.47999999999999998)*std::log(std::abs(T))) +) +: ( + 0 +)) - X(1)*x(19)*(5.1485802679346868*std::exp((1.0)*std::log(std::abs(x(13))))*x(16)*x(7) - 0.87659414490283338*x(15)*x(17)*x(7) - 3.5068370966299316*x(41)) - 3.9837168574084181e-7*X(1)*x(39) + X(10)*X(2)*((x(23)) ? ( + x(22)*(4430.0*x(21) - 347800.0/((T)*(T)*(T))) +) +: ( + 0 +)) + X(2)*X(4)*((x(9)) ? ( + 6.7980000000000007e-9*std::exp((-1.6040000000000001)*std::log(std::abs(T)))*x(25) - 6.7396000000000002e-10*std::exp((-1.3320000000000001)*std::log(std::abs(T))) + 8.1576000000000009e-11*std::exp((-0.60399999999999998)*std::log(std::abs(T)))*x(25) +) +: ( + 0 +)) + 2.5313028975878652e-10*X(2)*X(7)*x(40) - 2.5313028975878652e-10*X(3)*X(5)*x(40) - 9.8726896031426014e-7*X(4)*x(39) - X(5)*X(8)*((x(36)) ? ( + x(11)*x(35)*(14.393840000000001*x(13)*x(33)*x(7) + 1.5894349999999999*x(28)*x(30)*x(7) - 8.6761199999999992*x(29)*x(32)*x(7) + 6.7520699999999998*x(31)*x(34)*x(7) + 5.8888600000000002*x(41)) +) +: ( + 1.650619e-6*x(21)*x(37) +)) - 3.5999999999999998e-8*X(0)*X(9)/std::exp((3.0/2.0)*std::log(std::abs(T))))/(X(0)*x(43) + X(1)*x(43) + X(10)*x(44) + X(11)*x(43) + X(12)*x(43) + X(13)*x(43) + X(2)*x(43) + X(3)*x(43) + X(4)*x(43) + X(5)*x(43) + X(6)*x(44) + X(7)*x(43) + X(8)*x(44) + X(9)*x(44)); + x(0) = ((T)*(T)); + x(1) = ((T)*(T)*(T)); + x(2) = ((((T)*(T)))*(((T)*(T)))); + x(3) = T <= 10000.0; + x(4) = ((x(3)) ? ( + -5.5279999999999998e-28*((T)*(T)*(T)*(T)*(T)) - 2.3088e-11*T + 7.3427999999999993e-15*x(0) - 7.5474000000000004e-19*x(1) + 3.3467999999999999e-23*x(2) + 4.2277999999999996e-8 +) +: ( + 0 +)); + x(5) = 1.0e-8*std::exp((-0.40000000000000002)*std::log(std::abs(T))); + x(6) = T < 30; + x(7) = std::log(T); + x(8) = M_LN10; + x(9) = 3.194/x(8); + x(10) = amrex::Math::powi<-3>(x(8)); + x(11) = ((x(7))*(x(7))*(x(7))); + x(12) = std::exp((-2)*std::log(std::abs(x(8)))); + x(13) = ((x(7))*(x(7))); + x(14) = std::exp((-0.2072*x(10)*x(11) + 1.786*x(12)*x(13) - x(7)*x(9) - 18.199999999999999)*std::log(std::abs(10))); + x(15) = ((x(6)) ? ( + 3.4977396723747635e-20*std::exp((-0.14999999999999999)*std::log(std::abs(T))) +) +: ( + x(14) +)); + x(16) = 1.0/T; + x(17) = std::exp(-21237.150000000001*x(16)); + x(18) = ((((x(7))*(x(7))))*(((x(7))*(x(7))))); + x(19) = ((x(7))*(x(7))*(x(7))*(x(7))*(x(7))); + x(20) = std::exp((6)*std::log(std::abs(x(7)))); + x(21) = x(17)*(3.4172804999999998e-8*x(11) - 1.4491368e-7*x(13) - 4.7813727999999997e-9*x(18) + 3.9731542e-10*x(19) - 1.8171411000000001e-11*x(20) + 3.5311931999999998e-13*((x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))*(x(7))) + 3.3735381999999997e-7*x(7) - 3.3232183000000002e-7); + x(22) = T >= 100.0 && T <= 30000.0; + x(23) = ((x(22)) ? ( + x(21) +) +: ( + 0 +)); + x(24) = 4.9999999999999996e-6/std::sqrt(T); + x(25) = x(13)*x(16); + x(26) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(27) = 2.0860422997526066e-16*x(26); + x(28) = 3.4767371836380304e-16*x(26); + jac(7,1) = -X(6)*x(4); + jac(7,2) = X(2)*x(15) + X(3)*x(5) + X(8)*x(23); + jac(7,3) = X(1)*x(15) - 6.0e-10*X(6); + jac(7,4) = X(1)*x(5) - X(6)*x(24); + jac(7,5) = 0; + jac(7,6) = 0; + jac(7,7) = -X(0)*x(4) - 6.0e-10*X(2) - X(3)*x(24); + jac(7,8) = 0; + jac(7,9) = X(1)*x(23); + jac(7,10) = 0; + jac(7,11) = 0; + jac(7,12) = 0; + jac(7,13) = 0; + jac(7,14) = 0; + jac(7,15) = (-4.0000000000000002e-9*std::exp((-1.3999999999999999)*std::log(std::abs(T)))*X(1)*X(3) - X(0)*X(6)*((x(3)) ? ( + 1.4685599999999999e-14*T - 2.2642200000000001e-18*x(0) + 1.3387199999999999e-22*x(1) - 2.7639999999999999e-27*x(2) - 2.3088e-11 +) +: ( + 0 +)) + X(1)*X(2)*((x(6)) ? ( + -5.2466095085621454e-21*std::exp((-1.1499999999999999)*std::log(std::abs(T))) +) +: ( + x(14)*x(8)*(-0.62159999999999993*x(10)*x(25) + 3.5720000000000001*x(12)*x(16)*x(7) - x(16)*x(9)) +)) + X(1)*X(8)*((x(22)) ? ( + x(17)*(-1.9125491199999999e-8*x(11)*x(16) + 1.9865770999999999e-9*x(16)*x(18) - 1.09028466e-10*x(16)*x(19) + 2.4718352399999997e-12*x(16)*x(20) - 2.8982736e-7*x(16)*x(7) + 3.3735381999999997e-7*x(16) + 1.0251841499999999e-7*x(25)) + 21237.150000000001*x(21)/x(0) +) +: ( + 0 +)) + 2.4999999999999998e-6*X(3)*X(6)/std::exp((3.0/2.0)*std::log(std::abs(T))))/(X(0)*x(27) + X(1)*x(27) + X(10)*x(28) + X(11)*x(27) + X(12)*x(27) + X(13)*x(27) + X(2)*x(27) + X(3)*x(27) + X(4)*x(27) + X(5)*x(27) + X(6)*x(28) + X(7)*x(27) + X(8)*x(28) + X(9)*x(28)); + x(0) = std::exp(-0.00010729613733905579*T); + x(1) = X(5)*x(0); + x(2) = std::exp((0.94999999999999996)*std::log(std::abs(T))); + x(3) = 1.3300135414628029e-18*x(2); + x(4) = std::exp((-0.5)*std::log(std::abs(T))); + x(5) = X(7)*x(4); + x(6) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(7) = 6.1739095063118665e-10*std::exp((0.40999999999999998)*std::log(std::abs(T))); + x(8) = std::exp((-1.5)*std::log(std::abs(T)))*X(7); + x(9) = X(2)*X(7); + x(10) = 2.5313028975878652e-10*std::exp((-0.59000000000000008)*std::log(std::abs(T))); + x(11) = X(0)*x(1); + x(12) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(13) = 2.0860422997526066e-16*x(12); + x(14) = 3.4767371836380304e-16*x(12); + jac(8,1) = x(1)*x(3); + jac(8,2) = -7.9674337148168363e-7*x(5); + jac(8,3) = -X(7)*x(6) - X(7)*x(7); + jac(8,4) = X(5)*x(7); + jac(8,5) = -9.8726896031426014e-7*x(5); + jac(8,6) = X(0)*x(0)*x(3) + X(3)*x(7); + jac(8,7) = 0; + jac(8,8) = -7.9674337148168363e-7*X(1)*x(4) - X(2)*x(6) - X(2)*x(7) - 9.8726896031426014e-7*X(4)*x(4); + jac(8,9) = 0; + jac(8,10) = 0; + jac(8,11) = 0; + jac(8,12) = 0; + jac(8,13) = 0; + jac(8,14) = 0; + jac(8,15) = (2.6534040307116389e-10*std::exp((-1.1000000000000001)*std::log(std::abs(T)))*x(9) + 1.2635128643896626e-18*std::exp((-0.050000000000000044)*std::log(std::abs(T)))*x(11) + 3.9837168574084181e-7*X(1)*x(8) + X(3)*X(5)*x(10) + 4.9363448015713007e-7*X(4)*x(8) - x(10)*x(9) - 1.4270531560759686e-22*x(11)*x(2))/(X(0)*x(13) + X(1)*x(13) + X(10)*x(14) + X(11)*x(13) + X(12)*x(13) + X(13)*x(13) + X(2)*x(13) + X(3)*x(13) + X(4)*x(13) + X(5)*x(13) + X(6)*x(14) + X(7)*x(13) + X(8)*x(14) + X(9)*x(14)); + x(0) = 1.0/T; + x(1) = std::exp(-46707.0*x(0)); + x(2) = X(8)*x(1); + x(3) = 35.5*std::exp((-2.2799999999999998)*std::log(std::abs(T))); + x(4) = std::exp(-102000.0*x(0)); + x(5) = X(8)*x(4); + x(6) = 4.3799999999999999e-10*std::exp((0.34999999999999998)*std::log(std::abs(T))); + x(7) = std::exp(-21237.150000000001*x(0)); + x(8) = std::log(T); + x(9) = ((x(8))*(x(8))); + x(10) = ((x(8))*(x(8))*(x(8))); + x(11) = ((((x(8))*(x(8))))*(((x(8))*(x(8))))); + x(12) = ((x(8))*(x(8))*(x(8))*(x(8))*(x(8))); + x(13) = std::exp((6)*std::log(std::abs(x(8)))); + x(14) = x(7)*(3.4172804999999998e-8*x(10) - 4.7813727999999997e-9*x(11) + 3.9731542e-10*x(12) - 1.8171411000000001e-11*x(13) + 3.5311931999999998e-13*((x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))) + 3.3735381999999997e-7*x(8) - 1.4491368e-7*x(9) - 3.3232183000000002e-7); + x(15) = T >= 100.0 && T <= 30000.0; + x(16) = ((x(15)) ? ( + x(14) +) +: ( + 0 +)); + x(17) = std::exp(-457.0*x(0)); + x(18) = 1.0000000000000001e-9*x(17); + x(19) = 1.1800000000000001e-10*std::exp(-69500.0*x(0)); + x(20) = std::log(x(19)); + x(21) = X(1) + X(10) + X(2) + X(3) + 2.0*X(6) + 2.0*X(8) + X(9); + x(22) = std::log(0.0001*T); + x(23) = M_LN10; + x(24) = 1.0/x(23); + x(25) = std::exp((-2)*std::log(std::abs(x(23)))); + x(26) = std::exp((-1.6200000000000001*((x(22))*(x(22)))*x(25) + 1.3*x(22)*x(24) - 4.8449999999999998)*std::log(std::abs(10.0))); + x(27) = x(21)*x(26); + x(28) = x(27) + 1.0; + x(29) = std::exp((-2)*std::log(std::abs(x(28)))); + x(30) = 1.0*x(29); + x(31) = x(20)*x(30); + x(32) = ((X(8))*(X(8))); + x(33) = 1.0/x(28); + x(34) = 1.0*x(33); + x(35) = std::exp((x(34))*std::log(std::abs(x(19)))); + x(36) = std::sqrt(T); + x(37) = 1.0/x(36); + x(38) = 1.0 - std::exp(-6000.0*x(0)); + x(39) = 52000.0*x(0); + x(40) = std::exp(-x(39)); + x(41) = x(38)*x(40); + x(42) = 8.1250000000000003e-8*x(37)*x(41); + x(43) = 1.0 - x(34); + x(44) = std::exp((x(43))*std::log(std::abs(x(42)))); + x(45) = x(35)*x(44); + x(46) = x(32)*x(45); + x(47) = x(26)*x(46); + x(48) = std::log(x(42)); + x(49) = x(30)*x(48); + x(50) = x(25)*x(9); + x(51) = -133.82830000000001*x(0) - 4.8909149999999997*x(24)*x(8) + 0.47490300000000002*x(50); + x(52) = std::exp((x(51) + 14.82123)*std::log(std::abs(10.0))); + x(53) = 1.0/x(52); + x(54) = x(21)*x(53); + x(55) = std::exp(-0.0022727272727272726*T); + x(56) = std::exp(-0.00054054054054054055*T); + x(57) = -2.0563129999999998*x(55) + 0.58640729999999996*x(56) + 0.82274429999999998; + x(58) = std::exp((x(57))*std::log(std::abs(x(54)))); + x(59) = x(58) + 1.0; + x(60) = 1.0/x(59); + x(61) = x(24)*x(8); + x(62) = 16780.950000000001*x(0) + 1.0; + x(63) = amrex::Math::powi<-3>(x(23)); + x(64) = x(10)*x(63); + x(65) = 40870.379999999997*x(0) + 1.0; + x(66) = -69.700860000000006*x(24)*std::log(x(65)) + 4.6331670000000003*x(64); + x(67) = 19.734269999999999*x(24)*std::log(x(62)) + 37.886913*x(25)*x(9) - 14.509090000000008*x(61) - x(66) - 307.31920000000002; + x(68) = std::exp((x(51) + 13.656822)*std::log(std::abs(10.0))); + x(69) = 1.0/x(68); + x(70) = x(21)*x(69); + x(71) = std::exp((x(57))*std::log(std::abs(x(70)))); + x(72) = x(71) + 1.0; + x(73) = 1.0/x(72); + x(74) = std::exp((-2080.4099999999999*x(0)*x(73) - 23705.700000000001*x(0) + 43.20243*x(25)*x(9) - x(60)*x(67) - 68.422430000000006*x(61) - x(66) - 178.4239)*std::log(std::abs(10.0))); + x(75) = x(0)*x(71)/((x(72))*(x(72))); + x(76) = 4790.3210533157426*x(75); + x(77) = x(68)*x(69); + x(78) = 1.0/x(21); + x(79) = x(57)*x(78); + x(80) = x(77)*x(79); + x(81) = x(58)*x(67)/((x(59))*(x(59))); + x(82) = 2.3025850929940459*x(81); + x(83) = x(52)*x(53); + x(84) = x(79)*x(83); + x(85) = 743.05999999999995*x(0) - 2.4640089999999999*x(24)*x(8) + 0.19859550000000001*x(50); + x(86) = std::exp((x(85) + 9.3055640000000004)*std::log(std::abs(10.0))); + x(87) = 1.0/x(86); + x(88) = x(21)*x(87); + x(89) = 2.9375070000000001*x(55) + 0.23588480000000001*x(56) + 0.75022860000000002; + x(90) = std::exp((x(89))*std::log(std::abs(x(88)))); + x(91) = x(90) + 1.0; + x(92) = 1.0/x(91); + x(93) = 14254.549999999999*x(0) + 1.0; + x(94) = 27535.310000000001*x(0) + 1.0; + x(95) = -21.360939999999999*x(24)*std::log(x(94)) + 0.25820969999999999*x(64); + x(96) = 70.138370000000009*x(24)*x(8) + 11.28215*x(24)*std::log(x(93)) - 4.7035149999999994*x(50) - x(95) - 203.11568; + x(97) = std::exp((x(85) + 8.1313220000000008)*std::log(std::abs(10.0))); + x(98) = 1.0/x(97); + x(99) = x(21)*x(98); + x(100) = std::exp((x(89))*std::log(std::abs(x(99)))); + x(101) = x(100) + 1.0; + x(102) = 1.0/x(101); + x(103) = std::exp((-1657.4099999999999*x(0)*x(102) - 21467.790000000001*x(0) + 42.707410000000003*x(24)*x(8) - 2.0273650000000001*x(50) - x(92)*x(96) - x(95) - 142.7664)*std::log(std::abs(10.0))); + x(104) = x(0)*x(100)/((x(101))*(x(101))); + x(105) = 3816.3275589792611*x(104); + x(106) = x(97)*x(98); + x(107) = x(78)*x(89); + x(108) = x(106)*x(107); + x(109) = x(90)*x(96)/((x(91))*(x(91))); + x(110) = 2.3025850929940459*x(109); + x(111) = x(86)*x(87); + x(112) = x(107)*x(111); + x(113) = X(2)*X(8); + x(114) = x(113)*(-x(103)*(x(105)*x(108) + x(110)*x(112)) - x(74)*(x(76)*x(80) + x(82)*x(84))) + x(31)*x(47) - x(47)*x(49); + x(115) = std::exp((-2)*std::log(std::abs(T))); + x(116) = 5.25e-11*std::exp(-4430.0*x(0) + 173900.0*x(115)); + x(117) = T > 200.0; + x(118) = ((x(117)) ? ( + x(116) +) +: ( + 0 +)); + x(119) = -x(103) - x(74); + x(120) = ((X(2))*(X(2))); + x(121) = std::exp((-0.25)*std::log(std::abs(T))); + x(122) = 0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0; + x(123) = 1.0/x(122); + x(124) = 1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))); + x(125) = x(123)*x(124); + x(126) = 1.5e-32*x(121) + 5.0000000000000004e-32*x(37); + x(127) = 2*x(113); + x(128) = -7.5000000000000001e-33*x(121) - 2.5000000000000002e-32*x(37); + x(129) = 4.9999999999999996e-6/std::sqrt(T); + x(130) = 1.3700000000000002e-10*x(25)*x(9) - 8.4600000000000008e-10*x(61) - 4.1700000000000001e-10; + x(131) = amrex::Math::powi<-5>(x(23)); + x(132) = std::exp((-4)*std::log(std::abs(x(23)))); + x(133) = std::exp((-2.1690299999999998*x(11)*x(132) + 0.31788699999999998*x(12)*x(131) + 7.1969200000000004*x(50) + 5.8888600000000002*x(61) + 2.2506900000000001*x(64) - 56.473700000000001)*std::log(std::abs(10))); + x(134) = T <= 1167.4796423742259; + x(135) = std::exp(-5207.0*x(0)); + x(136) = ((x(134)) ? ( + x(133) +) +: ( + 3.1699999999999999e-10*x(135) +)); + x(137) = 2.0*x(29)*x(47); + x(138) = x(137)*x(48); + x(139) = -x(103)*(7632.6551179585222*x(104)*x(108) + 4.6051701859880918*x(109)*x(112)) - x(74)*(9580.6421066314851*x(75)*x(80) + 4.6051701859880918*x(81)*x(84)); + x(140) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(141) = 2.0860422997526066e-16*x(140); + x(142) = 3.4767371836380304e-16*x(140); + x(143) = X(0)*x(2); + x(144) = X(0)*x(5); + x(145) = std::exp((-1.5)*std::log(std::abs(T))); + x(146) = std::exp((-1.25)*std::log(std::abs(T))); + x(147) = X(8)*x(120); + x(148) = x(0)*x(24); + x(149) = x(0)*x(8); + x(150) = x(149)*x(25); + x(151) = X(2)*X(3); + x(152) = x(0)*x(9); + x(153) = x(0)*x(10); + x(154) = x(0)*x(11); + x(155) = x(152)*x(63); + x(156) = x(27)*(-7.460375701300709*x(0)*x(22)*x(25) + 2.9933606208922598*x(0)*x(24)); + x(157) = std::exp((-2.5)*std::log(std::abs(T))); + x(158) = x(115)*x(24); + x(159) = x(158)/x(65); + x(160) = 0.0046734386363636356*x(55) - 0.00031697691891891889*x(56); + x(161) = x(57)*(11.261747970100974*x(0)*x(24) - 308.15104860073512*x(115) - 2.1870091368363029*x(150)); + x(162) = x(158)/x(94); + x(163) = -0.0066761522727272725*x(55) - 0.0001275052972972973*x(56); + x(164) = x(89)*(1710.9588792001557*x(115) + 5.6735903924031659*x(148) - 0.91456607567139814*x(150)); + jac(9,1) = -x(2)*x(3) - x(5)*x(6); + jac(9,2) = X(10)*x(18) - X(8)*x(16) + x(114); + jac(9,3) = X(10)*x(118) + X(3)*x(125) + 6.0e-10*X(6) + X(8)*x(119) + x(114) + 3*x(120)*(6.0000000000000001e-32*x(121) + 2.0000000000000002e-31*x(37)) + x(126)*x(127) + x(127)*x(128); + jac(9,4) = X(2)*x(125) + X(6)*x(129) + x(114); + jac(9,5) = X(8)*x(130); + jac(9,6) = -X(8)*x(136); + jac(9,7) = 6.0e-10*X(2) + X(3)*x(129) + x(113)*x(139) + x(137)*x(20) - x(138); + jac(9,8) = 0; + jac(9,9) = -X(0)*x(1)*x(3) - X(0)*x(4)*x(6) - X(1)*x(16) + X(2)*X(8)*x(139) + X(2)*x(119) + X(4)*x(130) - X(5)*x(136) - 2*X(8)*x(45) + x(120)*x(126) + x(120)*x(128) - x(138) + 2.0*x(20)*x(26)*x(29)*x(32)*x(35)*x(44); + jac(9,10) = x(114); + jac(9,11) = X(1)*x(18) + X(2)*x(118) + x(114); + jac(9,12) = 0; + jac(9,13) = 0; + jac(9,14) = 0; + jac(9,15) = (-1658098.5*std::exp((-4.2799999999999994)*std::log(std::abs(T)))*x(143) + 80.939999999999998*std::exp((-3.2799999999999998)*std::log(std::abs(T)))*x(143) - 4.4675999999999997e-5*std::exp((-1.6499999999999999)*std::log(std::abs(T)))*x(144) - 1.5329999999999998e-10*std::exp((-0.65000000000000002)*std::log(std::abs(T)))*x(144) + 4.5700000000000003e-7*X(1)*X(10)*x(115)*x(17) - X(1)*X(8)*((x(15)) ? ( + 21237.150000000001*x(115)*x(14) + x(7)*(-1.09028466e-10*x(0)*x(12) + 2.4718352399999997e-12*x(0)*x(13) + 3.3735381999999997e-7*x(0) - 2.8982736e-7*x(149) + 1.0251841499999999e-7*x(152) - 1.9125491199999999e-8*x(153) + 1.9865770999999999e-9*x(154)) +) +: ( + 0 +)) + X(10)*X(2)*((x(117)) ? ( + x(116)*(4430.0*x(115) - 347800.0/((T)*(T)*(T))) +) +: ( + 0 +)) + ((X(2))*(X(2))*(X(2)))*(-1.0000000000000001e-31*x(145) - 1.5e-32*x(146)) + X(4)*X(8)*(-8.4600000000000008e-10*x(148) + 2.7400000000000004e-10*x(150)) - X(5)*X(8)*((x(134)) ? ( + x(133)*x(23)*(1.5894349999999999*x(131)*x(154) - 8.6761199999999992*x(132)*x(153) + 5.8888600000000002*x(148) + 14.393840000000001*x(150) + 6.7520699999999998*x(155)) +) +: ( + 1.650619e-6*x(115)*x(135) +)) + x(113)*(-x(103)*(3816.3275589792611*x(102)*x(115) + x(105)*(x(106)*x(164) + x(163)*std::log(x(99))) + x(110)*(x(111)*x(164) + x(163)*std::log(x(88))) + 49431.413233526648*x(115) + 98.337445626384849*x(148) - 9.3363608541157479*x(150) - 1.783649418259394*x(155) - 1354334.7412883535*x(162) - 2.3025850929940459*x(92)*(70.138370000000009*x(0)*x(24) - 9.4070299999999989*x(150) - 0.77462909999999996*x(155) - 160821.97128249999*x(158)/x(93) - 588180.10479140002*x(162))) - x(74)*(4790.3210533157426*x(115)*x(73) + 54584.391438988954*x(115) - 157.54846734442862*x(148) + 198.95454259823751*x(150) - 32.004783802655837*x(155) - 6559375.6154640894*x(159) - 2.3025850929940459*x(60)*(75.773826*x(0)*x(25)*x(8) - 14.509090000000008*x(148) - 13.899501000000001*x(155) - 331159.79815649998*x(158)/x(62) - 2848700.6345267999*x(159)) + x(76)*(x(160)*std::log(x(70)) + x(161)*x(77)) + x(82)*(x(160)*std::log(x(54)) + x(161)*x(83)))) + x(123)*x(151)*(1.3296555000000001e-10*std::exp((-0.90150700000000006)*std::log(std::abs(T))) + 2.466314622e-10*std::exp((-0.44389999999999996)*std::log(std::abs(T))) + 8.1647792100000001e-16*std::exp((1.1825999999999999)*std::log(std::abs(T)))) + x(147)*(-2.5000000000000002e-32*x(145) - 3.75e-33*x(146)) + x(147)*(1.2500000000000001e-32*x(145) + 1.875e-33*x(146)) - x(46)*(69500.0*x(115)*x(33) - x(156)*x(31)) - x(46)*(x(156)*x(49) + 12307692.307692308*x(36)*x(43)*(-4.0625000000000001e-8*x(145)*x(41) + 0.0042250000000000005*x(157)*x(38)*x(40) - 0.00048750000000000003*x(157)*std::exp(-58000.0*x(0)))*std::exp(x(39))/x(38)) + x(124)*x(151)*(-0.0064764051000000007*std::exp((0.04610000000000003)*std::log(std::abs(T))) - 2.7293978880000002e-10*std::exp((2.0424000000000002)*std::log(std::abs(T))) - 1.229450816e-13*std::exp((2.7740999999999998)*std::log(std::abs(T))))/((x(122))*(x(122))) - 2.4999999999999998e-6*X(3)*X(6)/std::exp((3.0/2.0)*std::log(std::abs(T))))/(X(0)*x(141) + X(1)*x(141) + X(10)*x(142) + X(11)*x(141) + X(12)*x(141) + X(13)*x(141) + X(2)*x(141) + X(3)*x(141) + X(4)*x(141) + X(5)*x(141) + X(6)*x(142) + X(7)*x(141) + X(8)*x(142) + X(9)*x(142)); + x(0) = 7.1999999999999996e-8/std::sqrt(T); + x(1) = std::log(T); + x(2) = M_LN10; + x(3) = 1.0/x(2); + x(4) = std::exp((-3.0)*std::log(std::abs(x(2)))); + x(5) = std::exp((-2.0)*std::log(std::abs(x(2)))); + x(6) = ((x(1))*(x(1))); + x(7) = std::exp((-1.5229999999999999*x(1)*x(3) - 0.12690000000000001*((x(1))*(x(1))*(x(1)))*x(4) + 1.1180000000000001*x(5)*x(6) - 19.379999999999999)*std::log(std::abs(10.0))); + x(8) = X(5)*x(7); + x(9) = X(4)*x(7); + x(10) = 1.0/T; + x(11) = 5.1485802679346868*std::exp((1.0)*std::log(std::abs(x(1))))*x(10)*x(5) - 3.5068370966299316*x(10)*x(3) - 0.87659414490283338*x(10)*x(4)*x(6); + x(12) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(13) = 2.0860422997526066e-16*x(12); + x(14) = 3.4767371836380304e-16*x(12); + jac(10,1) = -X(9)*x(0); + jac(10,2) = x(8); + jac(10,3) = -6.3999999999999996e-10*X(9) + x(9); + jac(10,4) = 0; + jac(10,5) = X(2)*x(7); + jac(10,6) = X(1)*x(7); + jac(10,7) = 0; + jac(10,8) = 0; + jac(10,9) = 0; + jac(10,10) = -X(0)*x(0) - 6.3999999999999996e-10*X(2); + jac(10,11) = 0; + jac(10,12) = 0; + jac(10,13) = 0; + jac(10,14) = 0; + jac(10,15) = (X(1)*x(11)*x(8) + X(2)*x(11)*x(9) + 3.5999999999999998e-8*X(0)*X(9)/std::exp((3.0/2.0)*std::log(std::abs(T))))/(X(0)*x(13) + X(1)*x(13) + X(10)*x(14) + X(11)*x(13) + X(12)*x(13) + X(13)*x(13) + X(2)*x(13) + X(3)*x(13) + X(4)*x(13) + X(5)*x(13) + X(6)*x(14) + X(7)*x(13) + X(8)*x(14) + X(9)*x(14)); + x(0) = 1.0/T; + x(1) = std::exp(-457.0*x(0)); + x(2) = 1.0000000000000001e-9*x(1); + x(3) = 2.6534040307116387e-9*std::exp((-0.10000000000000001)*std::log(std::abs(T))); + x(4) = std::exp((-2)*std::log(std::abs(T))); + x(5) = 5.25e-11*std::exp(-4430.0*x(0) + 173900.0*x(4)); + x(6) = T > 200.0; + x(7) = ((x(6)) ? ( + x(5) +) +: ( + 0 +)); + x(8) = M_LN10; + x(9) = 1.0/x(8); + x(10) = std::log(T); + x(11) = x(10)*x(9); + x(12) = std::exp((-2)*std::log(std::abs(x(8)))); + x(13) = ((x(10))*(x(10))); + x(14) = x(12)*x(13); + x(15) = 8.4600000000000008e-10*x(11) - 1.3700000000000002e-10*x(14) + 4.1700000000000001e-10; + x(16) = amrex::Math::powi<-5>(x(8)); + x(17) = std::exp((-4)*std::log(std::abs(x(8)))); + x(18) = ((((x(10))*(x(10))))*(((x(10))*(x(10))))); + x(19) = amrex::Math::powi<-3>(x(8)); + x(20) = ((x(10))*(x(10))*(x(10))); + x(21) = std::exp((0.31788699999999998*((x(10))*(x(10))*(x(10))*(x(10))*(x(10)))*x(16) + 5.8888600000000002*x(11) + 7.1969200000000004*x(14) - 2.1690299999999998*x(17)*x(18) + 2.2506900000000001*x(19)*x(20) - 56.473700000000001)*std::log(std::abs(10))); + x(22) = T <= 1167.4796423742259; + x(23) = std::exp(-5207.0*x(0)); + x(24) = ((x(22)) ? ( + x(21) +) +: ( + 3.1699999999999999e-10*x(23) +)); + x(25) = 2.6534040307116389e-10*std::exp((-1.1000000000000001)*std::log(std::abs(T))); + x(26) = x(0)*x(10)*x(12); + x(27) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(28) = 2.0860422997526066e-16*x(27); + x(29) = 3.4767371836380304e-16*x(27); + jac(11,1) = 0; + jac(11,2) = -X(10)*x(2); + jac(11,3) = -X(10)*x(7) + 1.0e-25*X(5) + X(7)*x(3) + 6.3999999999999996e-10*X(9); + jac(11,4) = X(5)*x(3); + jac(11,5) = X(8)*x(15); + jac(11,6) = 1.0e-25*X(2) + X(3)*x(3) + X(8)*x(24); + jac(11,7) = 0; + jac(11,8) = X(2)*x(3); + jac(11,9) = X(4)*x(15) + X(5)*x(24); + jac(11,10) = 6.3999999999999996e-10*X(2); + jac(11,11) = -X(1)*x(2) - X(2)*x(7); + jac(11,12) = 0; + jac(11,13) = 0; + jac(11,14) = 0; + jac(11,15) = (-4.5700000000000003e-7*X(1)*X(10)*x(1)*x(4) - X(10)*X(2)*((x(6)) ? ( + x(5)*(4430.0*x(4) - 347800.0/((T)*(T)*(T))) +) +: ( + 0 +)) - X(2)*X(7)*x(25) - X(3)*X(5)*x(25) + X(4)*X(8)*(8.4600000000000008e-10*x(0)*x(9) - 2.7400000000000004e-10*x(26)) + X(5)*X(8)*((x(22)) ? ( + x(21)*x(8)*(6.7520699999999998*x(0)*x(13)*x(19) + 1.5894349999999999*x(0)*x(16)*x(18) - 8.6761199999999992*x(0)*x(17)*x(20) + 5.8888600000000002*x(0)*x(9) + 14.393840000000001*x(26)) +) +: ( + 1.650619e-6*x(23)*x(4) +)))/(X(0)*x(28) + X(1)*x(28) + X(10)*x(29) + X(11)*x(28) + X(12)*x(28) + X(13)*x(28) + X(2)*x(28) + X(3)*x(28) + X(4)*x(28) + X(5)*x(28) + X(6)*x(29) + X(7)*x(28) + X(8)*x(29) + X(9)*x(29)); + x(0) = std::sqrt(T); + x(1) = 0.00060040841663220993*x(0) + 1.0; + x(2) = std::exp((-1.7524)*std::log(std::abs(x(1)))); + x(3) = 0.32668576019240059*x(0) + 1.0; + x(4) = std::exp((-0.24759999999999999)*std::log(std::abs(x(3)))); + x(5) = X(11)*x(4); + x(6) = x(2)*x(5); + x(7) = 5.7884371785482823e-10/x(0); + x(8) = std::log(8.6173430000000006e-5*T); + x(9) = ((x(8))*(x(8))); + x(10) = ((x(8))*(x(8))*(x(8))); + x(11) = ((((x(8))*(x(8))))*(((x(8))*(x(8))))); + x(12) = ((x(8))*(x(8))*(x(8))*(x(8))*(x(8))); + x(13) = std::exp((6)*std::log(std::abs(x(8)))); + x(14) = ((x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))*(x(8))); + x(15) = std::exp(4.7016264867590021*x(10) - 0.76924663344919997*x(11) + 0.081130420973029999*x(12) - 0.005324020628287001*x(13) + 0.00019757053122209999*x(14) - 3.1655810656650001e-6*std::exp((8)*std::log(std::abs(x(8)))) - 18.480669935680002*x(9)); + x(16) = X(12)*x(15); + x(17) = 3.8571873359681582e-209*std::exp((43.933476326349997)*std::log(std::abs(T))); + x(18) = x(16)*x(17); + x(19) = X(0)*x(2); + x(20) = 1.0/T; + x(21) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(22) = 2.0860422997526066e-16*x(21); + x(23) = 3.4767371836380304e-16*x(21); + jac(12,1) = x(18) - x(6)*x(7); + jac(12,2) = 0; + jac(12,3) = 0; + jac(12,4) = 0; + jac(12,5) = 0; + jac(12,6) = 0; + jac(12,7) = 0; + jac(12,8) = 0; + jac(12,9) = 0; + jac(12,10) = 0; + jac(12,11) = 0; + jac(12,12) = -x(19)*x(4)*x(7); + jac(12,13) = X(0)*x(15)*x(17); + jac(12,14) = 0; + jac(12,15) = (1.694596485110541e-207*std::exp((42.933476326349997)*std::log(std::abs(T)))*X(0)*x(16) + 3.0451686126851684e-13*X(0)*std::exp((-2.7523999999999997)*std::log(std::abs(x(1))))*x(20)*x(5) + X(0)*x(18)*(-3.0769865337967999*x(10)*x(20) + 0.40565210486515002*x(11)*x(20) - 0.031944123769722006*x(12)*x(20) + 0.0013829937185547*x(13)*x(20) - 2.5324648525320001e-5*x(14)*x(20) - 36.961339871360003*x(20)*x(8) + 14.104879460277006*x(20)*x(9)) + 2.3410580000000002e-11*X(11)*x(19)*x(20)*std::exp((-1.2476)*std::log(std::abs(x(3)))) + 2.8942185892741411e-10*X(0)*x(6)/std::exp((3.0/2.0)*std::log(std::abs(T))))/(X(0)*x(22) + X(1)*x(22) + X(10)*x(23) + X(11)*x(22) + X(12)*x(22) + X(13)*x(22) + X(2)*x(22) + X(3)*x(22) + X(4)*x(22) + X(5)*x(22) + X(6)*x(23) + X(7)*x(22) + X(8)*x(23) + X(9)*x(23)); + x(0) = std::sqrt(T); + x(1) = 0.00060040841663220993*x(0) + 1.0; + x(2) = std::exp((-1.7524)*std::log(std::abs(x(1)))); + x(3) = 0.32668576019240059*x(0) + 1.0; + x(4) = std::exp((-0.24759999999999999)*std::log(std::abs(x(3)))); + x(5) = X(11)*x(4); + x(6) = x(2)*x(5); + x(7) = 5.7884371785482823e-10/x(0); + x(8) = 1.4981088130721367e-10*std::exp((-0.63529999999999998)*std::log(std::abs(T))); + x(9) = 8.6173430000000006e-5*T; + x(10) = x(9) <= 9280.0; + x(11) = 1.0/T; + x(12) = (1.5400000000000001e-9 + 4.6200000000000001e-10*std::exp(-93988.701501924661*x(11)))*std::exp(-469943.50750964211*x(11)); + x(13) = ((x(10)) ? ( + x(8) +) +: ( + 1250086.112245841*std::exp((-1.5)*std::log(std::abs(T)))*x(12) + x(8) +)); + x(14) = std::log(x(9)); + x(15) = ((x(14))*(x(14))); + x(16) = ((x(14))*(x(14))*(x(14))); + x(17) = ((((x(14))*(x(14))))*(((x(14))*(x(14))))); + x(18) = ((x(14))*(x(14))*(x(14))*(x(14))*(x(14))); + x(19) = std::exp((6)*std::log(std::abs(x(14)))); + x(20) = ((x(14))*(x(14))*(x(14))*(x(14))*(x(14))*(x(14))*(x(14))); + x(21) = std::exp((8)*std::log(std::abs(x(14)))); + x(22) = std::exp(-10.753230200000001*x(15) + 3.0580387500000001*x(16) - 0.56851189000000002*x(17) + 0.067953912300000002*x(18) - 0.0050090561*x(19) + 0.000206723616*x(20) - 3.6491614100000001e-6*x(21)); + x(23) = std::exp((23.915965629999999)*std::log(std::abs(T))); + x(24) = 4.3524079114767552e-117*x(23); + x(25) = std::exp(-18.480669935680002*x(15) + 4.7016264867590021*x(16) - 0.76924663344919997*x(17) + 0.081130420973029999*x(18) - 0.005324020628287001*x(19) + 0.00019757053122209999*x(20) - 3.1655810656650001e-6*x(21)); + x(26) = 3.8571873359681582e-209*std::exp((43.933476326349997)*std::log(std::abs(T)))*x(25); + x(27) = std::exp((-0.75)*std::log(std::abs(T))); + x(28) = std::exp(-127500.0*x(11)); + x(29) = T <= 10000.0; + x(30) = ((x(29)) ? ( + 1.26e-9*x(27)*x(28) +) +: ( + 4.0000000000000003e-37*std::exp((4.7400000000000002)*std::log(std::abs(T))) +)); + x(31) = 2.8833736969617052e-16*std::exp((0.25)*std::log(std::abs(T))); + x(32) = X(0)*x(2); + x(33) = X(0)*X(12); + x(34) = -9.5174852894472843e-11*std::exp((-1.6353)*std::log(std::abs(T))); + x(35) = std::exp((-3.5)*std::log(std::abs(T))); + x(36) = x(11)*x(14); + x(37) = x(11)*x(16); + x(38) = x(11)*x(18); + x(39) = x(11)*x(20); + x(40) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(41) = 2.0860422997526066e-16*x(40); + x(42) = 3.4767371836380304e-16*x(40); + jac(13,1) = -X(12)*x(13) - X(12)*x(26) + X(13)*x(22)*x(24) + x(6)*x(7); + jac(13,2) = X(13)*x(30); + jac(13,3) = -X(12)*x(31); + jac(13,4) = 0; + jac(13,5) = 0; + jac(13,6) = 0; + jac(13,7) = 0; + jac(13,8) = 0; + jac(13,9) = 0; + jac(13,10) = 0; + jac(13,11) = 0; + jac(13,12) = x(32)*x(4)*x(7); + jac(13,13) = -X(0)*x(13) - X(0)*x(26) - X(2)*x(31); + jac(13,14) = X(0)*x(22)*x(24) + X(1)*x(30); + jac(13,15) = (1.0409203801861816e-115*std::exp((22.915965629999999)*std::log(std::abs(T)))*X(0)*X(13)*x(22) - 1.694596485110541e-207*std::exp((42.933476326349997)*std::log(std::abs(T)))*x(25)*x(33) + 4.3524079114767552e-117*X(0)*X(13)*x(22)*x(23)*(9.1741162500000009*x(11)*x(15) + 0.33976956150000004*x(11)*x(17) + 0.001447065312*x(11)*x(19) - 21.506460400000002*x(36) - 2.2740475600000001*x(37) - 0.030054336600000002*x(38) - 2.9193291280000001e-5*x(39)) - 3.0451686126851684e-13*X(0)*std::exp((-2.7523999999999997)*std::log(std::abs(x(1))))*x(11)*x(5) + X(1)*X(13)*((x(29)) ? ( + 0.00016065*std::exp((-2.75)*std::log(std::abs(T)))*x(28) - 9.4499999999999994e-10*std::exp((-1.75)*std::log(std::abs(T)))*x(28) +) +: ( + 1.8960000000000001e-36*std::exp((3.7400000000000002)*std::log(std::abs(T))) +)) - 2.3410580000000002e-11*X(11)*x(11)*std::exp((-1.2476)*std::log(std::abs(x(3))))*x(32) - 7.2084342424042629e-17*X(12)*X(2)*x(27) - x(26)*x(33)*(14.104879460277006*x(11)*x(15) + 0.40565210486515002*x(11)*x(17) + 0.0013829937185547*x(11)*x(19) - 36.961339871360003*x(36) - 3.0769865337967999*x(37) - 0.031944123769722006*x(38) - 2.5324648525320001e-5*x(39)) - x(33)*((x(10)) ? ( + x(34) +) +: ( + -1875129.1683687614*std::exp((-2.5)*std::log(std::abs(T)))*x(12) + 587469852277.90271*x(12)*x(35) + x(34) + 54.282214350476039*x(35)*std::exp(-563932.20901156683*x(11)) +)) - 2.8942185892741411e-10*X(0)*x(6)/std::exp((3.0/2.0)*std::log(std::abs(T))))/(X(0)*x(41) + X(1)*x(41) + X(10)*x(42) + X(11)*x(41) + X(12)*x(41) + X(13)*x(41) + X(2)*x(41) + X(3)*x(41) + X(4)*x(41) + X(5)*x(41) + X(6)*x(42) + X(7)*x(41) + X(8)*x(42) + X(9)*x(42)); + x(0) = 1.4981088130721367e-10*std::exp((-0.63529999999999998)*std::log(std::abs(T))); + x(1) = 8.6173430000000006e-5*T; + x(2) = x(1) <= 9280.0; + x(3) = 1.0/T; + x(4) = (1.5400000000000001e-9 + 4.6200000000000001e-10*std::exp(-93988.701501924661*x(3)))*std::exp(-469943.50750964211*x(3)); + x(5) = ((x(2)) ? ( + x(0) +) +: ( + 1250086.112245841*std::exp((-1.5)*std::log(std::abs(T)))*x(4) + x(0) +)); + x(6) = std::log(x(1)); + x(7) = ((x(6))*(x(6))); + x(8) = ((x(6))*(x(6))*(x(6))); + x(9) = ((((x(6))*(x(6))))*(((x(6))*(x(6))))); + x(10) = ((x(6))*(x(6))*(x(6))*(x(6))*(x(6))); + x(11) = std::exp((6)*std::log(std::abs(x(6)))); + x(12) = ((x(6))*(x(6))*(x(6))*(x(6))*(x(6))*(x(6))*(x(6))); + x(13) = std::exp(0.067953912300000002*x(10) - 0.0050090561*x(11) + 0.000206723616*x(12) - 3.6491614100000001e-6*std::exp((8)*std::log(std::abs(x(6)))) - 10.753230200000001*x(7) + 3.0580387500000001*x(8) - 0.56851189000000002*x(9)); + x(14) = X(13)*x(13); + x(15) = 4.3524079114767552e-117*std::exp((23.915965629999999)*std::log(std::abs(T))); + x(16) = x(14)*x(15); + x(17) = std::exp((-0.75)*std::log(std::abs(T))); + x(18) = std::exp(-127500.0*x(3)); + x(19) = T <= 10000.0; + x(20) = ((x(19)) ? ( + 1.26e-9*x(17)*x(18) +) +: ( + 4.0000000000000003e-37*std::exp((4.7400000000000002)*std::log(std::abs(T))) +)); + x(21) = 2.8833736969617052e-16*std::exp((0.25)*std::log(std::abs(T))); + x(22) = -9.5174852894472843e-11*std::exp((-1.6353)*std::log(std::abs(T))); + x(23) = std::exp((-3.5)*std::log(std::abs(T))); + x(24) = 1.0/(9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9)); + x(25) = 2.0860422997526066e-16*x(24); + x(26) = 3.4767371836380304e-16*x(24); + jac(14,1) = X(12)*x(5) - x(16); + jac(14,2) = -X(13)*x(20); + jac(14,3) = X(12)*x(21); + jac(14,4) = 0; + jac(14,5) = 0; + jac(14,6) = 0; + jac(14,7) = 0; + jac(14,8) = 0; + jac(14,9) = 0; + jac(14,10) = 0; + jac(14,11) = 0; + jac(14,12) = 0; + jac(14,13) = X(0)*x(5) + X(2)*x(21); + jac(14,14) = -X(0)*x(13)*x(15) - X(1)*x(20); + jac(14,15) = (-1.0409203801861816e-115*std::exp((22.915965629999999)*std::log(std::abs(T)))*X(0)*x(14) + X(0)*X(12)*((x(2)) ? ( + x(22) +) +: ( + -1875129.1683687614*std::exp((-2.5)*std::log(std::abs(T)))*x(4) + x(22) + 587469852277.90271*x(23)*x(4) + 54.282214350476039*x(23)*std::exp(-563932.20901156683*x(3)) +)) - X(0)*x(16)*(-0.030054336600000002*x(10)*x(3) + 0.001447065312*x(11)*x(3) - 2.9193291280000001e-5*x(12)*x(3) - 21.506460400000002*x(3)*x(6) + 9.1741162500000009*x(3)*x(7) - 2.2740475600000001*x(3)*x(8) + 0.33976956150000004*x(3)*x(9)) - X(1)*X(13)*((x(19)) ? ( + 0.00016065*std::exp((-2.75)*std::log(std::abs(T)))*x(18) - 9.4499999999999994e-10*std::exp((-1.75)*std::log(std::abs(T)))*x(18) +) +: ( + 1.8960000000000001e-36*std::exp((3.7400000000000002)*std::log(std::abs(T))) +)) + 7.2084342424042629e-17*X(12)*X(2)*x(17))/(X(0)*x(25) + X(1)*x(25) + X(10)*x(26) + X(11)*x(25) + X(12)*x(25) + X(13)*x(25) + X(2)*x(25) + X(3)*x(25) + X(4)*x(25) + X(5)*x(25) + X(6)*x(26) + X(7)*x(25) + X(8)*x(26) + X(9)*x(26)); + x(0) = 0.00013612213614898791*X(0) + 0.24994102282436673*X(1) + 0.75007714496081457*X(10) + 0.99972775572710437*X(11) + 0.99986387786355213*X(12) + X(13) + 0.25007714496081457*X(2) + 0.25021326709726244*X(3) + 0.49986387786355219*X(4) + 0.5*X(5) + 0.50001816778518127*X(6) + 0.50013612213644787*X(7) + 0.50015428992162914*X(8) + 0.7499410228243667*X(9); + x(1) = ((x(0))*(x(0))); + x(2) = 1.0/x(1); + x(3) = X(1) + X(12) + X(4); + x(4) = 4.0*X(11) + x(3); + x(5) = std::sqrt(T); + x(6) = 2.1299999999999999e-27*x(5); + x(7) = x(4)*x(6); + x(8) = 1.0/T; + x(9) = std::exp(-102000.0*x(8)); + x(10) = X(8)*x(9); + x(11) = 3.1438547368704001e-21*std::exp((0.34999999999999998)*std::log(std::abs(T))); + x(12) = x(10)*x(11); + x(13) = 2.73*z + 2.73; + x(14) = 5.6500000000000001e-36*((((z + 1.0)*(z + 1.0)))*(((z + 1.0)*(z + 1.0)))); + x(15) = x(14)*(T - x(13)); + x(16) = T <= 10; + x(17) = 1.5499999999999999e-26*((x(16)) ? ( + 2.3157944032250755 +) +: ( + std::exp((0.36470000000000002)*std::log(std::abs(T))) +)); + x(18) = X(12)*x(17); + x(19) = std::sqrt(T); + x(20) = ((x(16)) ? ( + std::sqrt(10) +) +: ( + x(19) +)); + x(21) = 0.0031622776601683794*x(20) + 1.0; + x(22) = 1.0/x(21); + x(23) = X(2)*x(22); + x(24) = ((x(16)) ? ( + 1.0/10.0 +) +: ( + x(8) +)); + x(25) = std::exp(-118348.0*x(24)); + x(26) = 7.4999999999999996e-19*x(25); + x(27) = x(23)*x(26); + x(28) = 6.3095734448019361e-5*((x(16)) ? ( + 5.011872336272722 +) +: ( + std::exp((0.69999999999999996)*std::log(std::abs(T))) +)) + 1.0; + x(29) = 1.0/x(28); + x(30) = ((x(16)) ? ( + 0.63095734448019325 +) +: ( + std::exp((-0.20000000000000001)*std::log(std::abs(T))) +)); + x(31) = x(29)*x(30); + x(32) = x(20)*x(31); + x(33) = 3.4635323838154264e-26*x(32); + x(34) = X(1)*x(33); + x(35) = 1.3854129535261706e-25*x(32); + x(36) = X(11)*x(35); + x(37) = X(0)*X(12); + x(38) = std::exp((-1.5)*std::log(std::abs(T))); + x(39) = ((x(16)) ? ( + 0.031622776601683791 +) +: ( + x(38) +)); + x(40) = 1.0 + 0.29999999999999999*std::exp(-94000.0*x(24)); + x(41) = std::exp(-470000.0*x(24)); + x(42) = 1.24e-13*x(40)*x(41); + x(43) = x(39)*x(42); + x(44) = X(10) + X(2) + X(3) + X(9); + x(45) = X(1) + 2.0*X(6) + 2.0*X(8) + x(44); + x(46) = 1.0/x(45); + x(47) = 1.0/x(5); + x(48) = std::exp((-2)*std::log(std::abs(T))); + x(49) = std::exp(-160000.0*x(48)); + x(50) = X(2)*x(49); + x(51) = std::exp(-12000.0/(T + 1200.0)); + x(52) = X(8)*x(51); + x(53) = 1.0/(1.6000000000000001*x(50) + 1.3999999999999999*x(52)); + x(54) = x(47)*x(53); + x(55) = x(46)*x(54); + x(56) = 1.0/(1000000.0*x(55) + 1.0); + x(57) = X(0)*x(22); + x(58) = std::exp(-473638.0*x(24)); + x(59) = x(58)*((x(16)) ? ( + 0.4008667176273028 +) +: ( + std::exp((-0.39700000000000002)*std::log(std::abs(T))) +)); + x(60) = 5.5399999999999998e-17*x(59); + x(61) = x(57)*x(60); + x(62) = ((x(16)) ? ( + 0.67810976749343443 +) +: ( + std::exp((-0.16869999999999999)*std::log(std::abs(T))) +)); + x(63) = std::exp(-55338.0*x(24)); + x(64) = x(62)*x(63); + x(65) = 5.0099999999999997e-27*x(64); + x(66) = ((X(0))*(X(0))); + x(67) = X(12)*x(22); + x(68) = x(66)*x(67); + x(69) = std::exp(-13179.0*x(24)); + x(70) = x(62)*x(69); + x(71) = 9.1000000000000001e-27*x(70); + x(72) = std::exp(-631515.0*x(24)); + x(73) = 4.9500000000000001e-22*x(72); + x(74) = X(12)*x(73); + x(75) = x(20)*x(57); + x(76) = std::exp(-285335.40000000002*x(24)); + x(77) = 9.3799999999999993e-22*x(76); + x(78) = X(13)*x(77); + x(79) = std::exp(-157809.10000000001*x(24)); + x(80) = x(20)*x(79); + x(81) = 1.2700000000000001e-21*x(80); + x(82) = x(23)*x(81); + x(83) = ((X(2))*(X(2))*(X(2))); + x(84) = std::exp((-0.25)*std::log(std::abs(T))); + x(85) = 2.0000000000000002e-31*x(47) + 6.0000000000000001e-32*x(84); + x(86) = ((X(2))*(X(2))); + x(87) = 2.5000000000000002e-32*x(47) + 7.5000000000000001e-33*x(84); + x(88) = 1.3500000000000001e-9*std::exp((0.098492999999999997)*std::log(std::abs(T))) + 4.4350199999999998e-10*std::exp((0.55610000000000004)*std::log(std::abs(T))) + 3.7408500000000004e-16*std::exp((2.1825999999999999)*std::log(std::abs(T))); + x(89) = 0.0061910000000000003*std::exp((1.0461)*std::log(std::abs(T))) + 8.9711999999999997e-11*std::exp((3.0424000000000002)*std::log(std::abs(T))) + 3.2575999999999999e-14*std::exp((3.7740999999999998)*std::log(std::abs(T))) + 1.0; + x(90) = 1.0/x(89); + x(91) = std::sqrt(M_PI); + x(92) = 1.0/x(91); + x(93) = 1.3806479999999999e-16*X(0) + 1.3806479999999999e-16*X(1) + 1.3806479999999999e-16*X(10) + 1.3806479999999999e-16*X(11) + 1.3806479999999999e-16*X(12) + 1.3806479999999999e-16*X(13) + 1.3806479999999999e-16*X(2) + 1.3806479999999999e-16*X(3) + 1.3806479999999999e-16*X(4) + 1.3806479999999999e-16*X(5) + 1.3806479999999999e-16*X(6) + 1.3806479999999999e-16*X(7) + 1.3806479999999999e-16*X(8) + 1.3806479999999999e-16*X(9); + x(94) = 9.1093818800000008e-28*X(0) + 1.6726215800000001e-24*X(1) + 5.01956503638e-24*X(10) + 6.6902431600000005e-24*X(11) + 6.6911540981899994e-24*X(12) + 6.6920650363799998e-24*X(13) + 1.6735325181900001e-24*X(2) + 1.6744434563800001e-24*X(3) + 3.3451215800000003e-24*X(4) + 3.3460325181899999e-24*X(5) + 3.3461540981899999e-24*X(6) + 3.3469434563800003e-24*X(7) + 3.3470650363800003e-24*X(8) + 5.0186540981899997e-24*X(9); + x(95) = 1.0/x(94); + x(96) = std::exp((-1.0/2.0)*std::log(std::abs(x(95)))); + x(97) = ((X(8))*(X(8))); + x(98) = 1.1800000000000001e-10*std::exp(-69500.0*x(8)); + x(99) = std::log(0.0001*T); + x(100) = M_LN10; + x(101) = 1.0/x(100); + x(102) = std::exp((-2)*std::log(std::abs(x(100)))); + x(103) = std::exp((1.3*x(101)*x(99) - 1.6200000000000001*x(102)*((x(99))*(x(99))) - 4.8449999999999998)*std::log(std::abs(10.0))); + x(104) = x(103)*x(45); + x(105) = x(104) + 1.0; + x(106) = 1.0/x(105); + x(107) = 1.0*x(106); + x(108) = std::exp((x(107))*std::log(std::abs(x(98)))); + x(109) = 1.0 - std::exp(-6000.0*x(8)); + x(110) = 52000.0*x(8); + x(111) = std::exp(-x(110)); + x(112) = x(109)*x(111); + x(113) = 8.1250000000000003e-8*x(112)*x(47); + x(114) = 1.0 - x(107); + x(115) = std::exp((x(114))*std::log(std::abs(x(113)))); + x(116) = x(108)*x(115); + x(117) = x(116)*x(97); + x(118) = 7.1777505408000004e-12*x(117); + x(119) = std::log(T); + x(120) = ((x(119))*(x(119))); + x(121) = x(102)*x(120); + x(122) = -4.8909149999999997*x(101)*x(119) + 0.47490300000000002*x(121) - 133.82830000000001*x(8); + x(123) = std::exp((x(122) + 14.82123)*std::log(std::abs(10.0))); + x(124) = 1.0/x(123); + x(125) = x(124)*x(45); + x(126) = std::exp(-0.0022727272727272726*T); + x(127) = std::exp(-0.00054054054054054055*T); + x(128) = -2.0563129999999998*x(126) + 0.58640729999999996*x(127) + 0.82274429999999998; + x(129) = std::exp((x(128))*std::log(std::abs(x(125)))); + x(130) = x(129) + 1.0; + x(131) = 1.0/x(130); + x(132) = x(101)*x(119); + x(133) = 16780.950000000001*x(8) + 1.0; + x(134) = amrex::Math::powi<-3>(x(100)); + x(135) = ((x(119))*(x(119))*(x(119)))*x(134); + x(136) = 40870.379999999997*x(8) + 1.0; + x(137) = -69.700860000000006*x(101)*std::log(x(136)) + 4.6331670000000003*x(135); + x(138) = 19.734269999999999*x(101)*std::log(x(133)) + 37.886913*x(102)*x(120) - 14.509090000000008*x(132) - x(137) - 307.31920000000002; + x(139) = std::exp((x(122) + 13.656822)*std::log(std::abs(10.0))); + x(140) = 1.0/x(139); + x(141) = x(140)*x(45); + x(142) = std::exp((x(128))*std::log(std::abs(x(141)))); + x(143) = x(142) + 1.0; + x(144) = 1.0/x(143); + x(145) = std::exp((43.20243*x(102)*x(120) - x(131)*x(138) - 68.422430000000006*x(132) - x(137) - 2080.4099999999999*x(144)*x(8) - 23705.700000000001*x(8) - 178.4239)*std::log(std::abs(10.0))); + x(146) = -2.4640089999999999*x(101)*x(119) + 0.19859550000000001*x(121) + 743.05999999999995*x(8); + x(147) = std::exp((x(146) + 9.3055640000000004)*std::log(std::abs(10.0))); + x(148) = 1.0/x(147); + x(149) = x(148)*x(45); + x(150) = 2.9375070000000001*x(126) + 0.23588480000000001*x(127) + 0.75022860000000002; + x(151) = std::exp((x(150))*std::log(std::abs(x(149)))); + x(152) = x(151) + 1.0; + x(153) = 1.0/x(152); + x(154) = 14254.549999999999*x(8) + 1.0; + x(155) = 27535.310000000001*x(8) + 1.0; + x(156) = -21.360939999999999*x(101)*std::log(x(155)) + 0.25820969999999999*x(135); + x(157) = 70.138370000000009*x(101)*x(119) + 11.28215*x(101)*std::log(x(154)) - 4.7035149999999994*x(121) - x(156) - 203.11568; + x(158) = std::exp((x(146) + 8.1313220000000008)*std::log(std::abs(10.0))); + x(159) = 1.0/x(158); + x(160) = x(159)*x(45); + x(161) = std::exp((x(150))*std::log(std::abs(x(160)))); + x(162) = x(161) + 1.0; + x(163) = 1.0/x(162); + x(164) = std::exp((42.707410000000003*x(101)*x(119) - 2.0273650000000001*x(121) - x(153)*x(157) - x(156) - 1657.4099999999999*x(163)*x(8) - 21467.790000000001*x(8) - 142.7664)*std::log(std::abs(10.0))); + x(165) = 7.1777505408000004e-12*x(145) + 7.1777505408000004e-12*x(164); + x(166) = X(8)*x(165); + x(167) = T >= 10000.0; + x(168) = std::log(((x(167)) ? ( + 10000.0 +) +: ( + T +))); + x(169) = std::exp((-4)*std::log(std::abs(x(100)))); + x(170) = ((((x(168))*(x(168))))*(((x(168))*(x(168))))); + x(171) = ((x(168))*(x(168))*(x(168))); + x(172) = ((x(168))*(x(168))); + x(173) = X(2) <= 0.01; + x(174) = ((x(173)) ? ( + false +) +: ( + X(2) >= 10000000000.0 +)); + x(175) = std::log(((x(174)) ? ( + 10000000000.0 +) +: ( + ((x(173)) ? ( + 0.01 + ) + : ( + X(2) + )) +))); + x(176) = ((((x(175))*(x(175))))*(((x(175))*(x(175))))); + x(177) = ((x(175))*(x(175))*(x(175))); + x(178) = ((x(175))*(x(175))); + x(179) = x(102)*x(168); + x(180) = amrex::Math::powi<-5>(x(100)); + x(181) = x(176)*x(180); + x(182) = x(170)*x(180); + x(183) = x(169)*x(177); + x(184) = x(169)*x(171); + x(185) = x(134)*x(178); + x(186) = x(134)*x(172); + x(187) = std::exp((-8)*std::log(std::abs(x(100)))); + x(188) = x(170)*x(187); + x(189) = amrex::Math::powi<-7>(x(100)); + x(190) = x(171)*x(189); + x(191) = x(170)*x(189); + x(192) = std::exp((-6)*std::log(std::abs(x(100)))); + x(193) = x(172)*x(192); + x(194) = x(171)*x(192); + x(195) = x(170)*x(192); + x(196) = x(177)*x(180); + x(197) = x(171)*x(180); + x(198) = x(169)*x(178); + x(199) = std::exp((21.93385*x(101)*x(168) + 0.92432999999999998*x(101)*x(175) - 10.19097*x(102)*x(172) + 0.54962*x(102)*x(178) + 2.1990599999999998*x(134)*x(171) - 0.076759999999999995*x(134)*x(177) - 0.0036600000000000001*x(168)*x(181) + 0.11864*x(168)*x(183) - 1.06447*x(168)*x(185) - 0.17333999999999999*x(169)*x(170) + 0.0027499999999999998*x(169)*x(176) - 0.073660000000000003*x(172)*x(196) + 0.62343000000000004*x(172)*x(198) + 0.77951999999999999*x(175)*x(179) - 0.0083499999999999998*x(175)*x(182) + 0.11711000000000001*x(175)*x(184) - 0.54262999999999995*x(175)*x(186) + 6.1920000000000003e-5*x(176)*x(188) - 0.00066631000000000004*x(176)*x(190) + 0.0025140000000000002*x(176)*x(193) - 0.001482*x(177)*x(191) + 0.017590000000000001*x(177)*x(194) + 0.0106*x(178)*x(195) - 0.13768*x(178)*x(197) - 42.567880000000002)*std::log(std::abs(10.0))); + x(200) = X(10)*x(199); + x(201) = T >= x(13); + x(202) = X(6) + X(8); + x(203) = X(0) + X(11) + X(13) + X(5) + X(7) + x(202) + x(3) + x(44); + x(204) = x(203) <= 9.9999999999999993e-41; + x(205) = x(94) >= 9.9999999999999998e-13; + x(206) = x(94) >= 0.5; + x(207) = x(94) <= 9.9999999999999993e-41; + x(208) = x(19)*x(91); + x(209) = x(208)*x(94); + x(210) = std::exp((2.1498900000000001 - 0.69317629274152892*x(101))*std::log(std::abs(10.0)))*x(209); + x(211) = 1.0000420000000001*x(101); + x(212) = std::exp((x(211)*std::log(x(94)) + 2.1498900000000001)*std::log(std::abs(10.0)))*x(209); + x(213) = 1.0/std::fabs(x(0)); + x(214) = std::sqrt(x(203)); + x(215) = std::sqrt(x(2)*x(203)); + x(216) = ((x(204) && x(205) && x(206) && x(207)) ? ( + 4.8339620236294848e-32/((x(210) + 2.1986273043946046e-56)*(x(210) + 2.1986273043946046e-56)) >= 1.0 +) +: ( + ((x(204) && x(205) && x(207)) ? ( + 4.8339620236294848e-32/((x(212) + 2.1986273043946046e-56)*(x(212) + 2.1986273043946046e-56)) >= 1.0 + ) + : ( + ((x(204) && x(207)) ? ( + true + ) + : ( + ((x(204) && x(205) && x(206)) ? ( + 216.48287161311649/((x(210)*x(213) + 1.471335691176954e-39)*(x(210)*x(213) + 1.471335691176954e-39)) >= 1.0 + ) + : ( + ((x(204) && x(205)) ? ( + 216.48287161311649/((x(212)*x(213) + 1.471335691176954e-39)*(x(212)*x(213) + 1.471335691176954e-39)) >= 1.0 + ) + : ( + ((x(204)) ? ( + true + ) + : ( + ((x(205) && x(206) && x(207)) ? ( + 4.833962023629485e-72/((x(210)*x(214) + 2.1986273043946045e-76)*(x(210)*x(214) + 2.1986273043946045e-76)) >= 1.0 + ) + : ( + ((x(205) && x(207)) ? ( + 4.833962023629485e-72/((x(212)*x(214) + 2.1986273043946045e-76)*(x(212)*x(214) + 2.1986273043946045e-76)) >= 1.0 + ) + : ( + ((x(207)) ? ( + true + ) + : ( + ((x(205) && x(206)) ? ( + 2.1648287161311648e-38/((x(210)*x(215) + 1.471335691176954e-59)*(x(210)*x(215) + 1.471335691176954e-59)) >= 1.0 + ) + : ( + ((x(205)) ? ( + 2.1648287161311648e-38/((x(212)*x(215) + 1.471335691176954e-59)*(x(212)*x(215) + 1.471335691176954e-59)) >= 1.0 + ) + : ( + true + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) +)); + x(217) = std::exp((x(211)*std::log(((x(206)) ? ( + 0.5 +) +: ( + x(94) +))) + 2.1498900000000001)*std::log(std::abs(10.0))); + x(218) = ((x(205)) ? ( + x(217) +) +: ( + 0.0 +)); + x(219) = ((x(204)) ? ( + 9.9999999999999993e-41 +) +: ( + x(203) +)); + x(220) = ((x(207)) ? ( + 1.0e+80 +) +: ( + 2.232953576238777e+46*x(2) +)); + x(221) = std::sqrt(x(219)*x(220)); + x(222) = x(218)*x(221); + x(223) = x(209)*x(222); + x(224) = x(223) + 2.1986273043946046e-36; + x(225) = ((x(216)) ? ( + 1.0 +) +: ( + 483396202.36294854/((x(224))*(x(224))) +)); + x(226) = ((((T)*(T)))*(((T)*(T)))); + x(227) = x(218)*x(226); + x(228) = x(225)*x(227); + x(229) = 0.00022681492*x(94); + x(230) = T < 2.0; + x(231) = 1.2500000000000001e-10*X(0) + 1.2500000000000001e-10*X(1) + 1.2500000000000001e-10*X(10) + 1.2500000000000001e-10*X(11) + 1.2500000000000001e-10*X(12) + 1.2500000000000001e-10*X(13) + 1.2500000000000001e-10*X(2) + 1.2500000000000001e-10*X(3) + 1.2500000000000001e-10*X(4) + 1.2500000000000001e-10*X(5) + 1.2500000000000001e-10*X(6) + 1.2500000000000001e-10*X(7) + 1.2500000000000001e-10*X(8) + 1.2500000000000001e-10*X(9) <= 9.9999999999999993e-41; + x(232) = 28601.610899577994*std::exp((-0.45000000000000001)*std::log(std::abs(x(203)))); + x(233) = ((x(231)) ? ( + true +) +: ( + x(232) >= 1.0 +)); + x(234) = ((x(233)) ? ( + 1.0 +) +: ( + ((x(231)) ? ( + 1.000000000000001e+18 + ) + : ( + x(232) + )) +)); + x(235) = std::exp((25.0*x(101))*std::log(std::abs(T))); + x(236) = 1.0/x(235); + x(237) = 1.0/(2.3538526683701997e+17*x(236) + 10.0); + x(238) = 1.0/(1.6889118802245084e-48*x(235) + 10.0); + x(239) = std::exp((20000.0*x(237)*x(238) - 200.0)*std::log(std::abs(10.0))); + x(240) = std::log(0.001*T); + x(241) = ((x(240))*(x(240))*(x(240))*(x(240))*(x(240))); + x(242) = x(180)*x(241); + x(243) = ((((x(240))*(x(240))))*(((x(240))*(x(240))))); + x(244) = x(169)*x(243); + x(245) = ((x(240))*(x(240))*(x(240))); + x(246) = ((x(240))*(x(240))); + x(247) = x(102)*x(246); + x(248) = std::exp((2.0943374000000001*x(101)*x(240) + 0.43693353000000001*x(134)*x(245) - 0.033638326000000003*x(242) - 0.14913216000000001*x(244) - 0.77151435999999995*x(247) - 23.962112000000001)*std::log(std::abs(10.0))); + x(249) = x(239)*x(248); + x(250) = X(8)*x(249); + x(251) = x(101)*x(240); + x(252) = x(134)*x(245); + x(253) = std::exp((0.19191374999999999*x(242) - 0.16596184*x(244) - 0.81520437999999995*x(247) + 2.1892372*x(251) + 0.29036281000000003*x(252) - 23.689236999999999)*std::log(std::abs(10.0))); + x(254) = X(13)*x(253); + x(255) = T <= 10000.0; + x(256) = T > 10.0; + x(257) = x(255) && x(256); + x(258) = std::exp((16.666666666666664*x(101))*std::log(std::abs(T))); + x(259) = 1.0/x(258); + x(260) = 1.0/(785.77199422741614*x(259) + 10.0); + x(261) = 1.0/(5.0592917094448065e-34*x(258) + 10.0); + x(262) = std::exp((20000.0*x(260)*x(261) - 200.0)*std::log(std::abs(10.0))); + x(263) = 1.002560385050777e-22*x(262); + x(264) = X(13)*x(263); + x(265) = std::exp((0.32168730000000001*x(242) - 0.51002221000000003*x(244) + 0.015391166*x(247) + 1.5714710999999999*x(251) - 0.23619984999999999*x(252) - 22.089523)*std::log(std::abs(10.0))); + x(266) = X(1)*x(265); + x(267) = 1.1825091393820599e-21*x(262); + x(268) = X(1)*x(267); + x(269) = std::exp((3.8479610000000002*x(242) + 20.159831000000001*x(244) + 58.145166000000003*x(247) + 37.383713*x(251) + 48.656103000000002*x(252) - 16.818342000000001)*std::log(std::abs(10.0))); + x(270) = X(2)*x(269); + x(271) = T <= 100.0; + x(272) = std::exp((3.5692468000000002*x(101)*x(240) - 4.2519023000000002*x(242) - 21.328264000000001*x(244) - 11.33286*x(247) - 27.850082*x(252) - 24.311209000000002)*std::log(std::abs(10.0))); + x(273) = X(2)*x(272); + x(274) = T <= 1000.0; + x(275) = std::exp((1.5538288*x(242) - 5.5108049000000001*x(244) - 3.7209846*x(247) + 4.6450521*x(251) + 5.9369081000000001*x(252) - 24.311209000000002)*std::log(std::abs(10.0))); + x(276) = X(2)*x(275); + x(277) = T <= 6000.0; + x(278) = std::exp((17.997580222853362*x(101))*std::log(std::abs(T))); + x(279) = 1.0/x(278); + x(280) = 1.0/(2973.7534532281375*x(279) + 10.0); + x(281) = 1.0/(1.3368457736780898e-34*x(278) + 10.0); + x(282) = 1.8623144679125181e-22*std::exp((20000.0*x(280)*x(281) - 200.0)*std::log(std::abs(10.0))); + x(283) = X(2)*x(282); + x(284) = std::exp((8)*std::log(std::abs(x(240)))); + x(285) = x(187)*x(284); + x(286) = ((x(240))*(x(240))*(x(240))*(x(240))*(x(240))*(x(240))*(x(240))); + x(287) = x(189)*x(286); + x(288) = std::exp((6)*std::log(std::abs(x(240)))); + x(289) = x(192)*x(288); + x(290) = std::exp((983.67575999999997*x(242) + 734.71650999999997*x(244) + 96.743155000000002*x(247) + 16.815729999999999*x(251) + 343.1918*x(252) + 70.609154000000004*x(285) + 364.14445999999998*x(287) + 801.81246999999996*x(289) - 21.928795999999998)*std::log(std::abs(10.0))); + x(291) = X(0)*x(290); + x(292) = T <= 500.0; + x(293) = T > 100; + x(294) = x(292) && x(293); + x(295) = std::exp((-8.8077017000000009*x(242) - 4.7274035999999997*x(244) + 0.93310621999999999*x(247) + 1.6802758*x(251) + 4.0406627000000004*x(252) - 6.3701156000000001*x(285) + 6.4380698000000001*x(287) + 8.9167182999999994*x(289) - 22.921188999999998)*std::log(std::abs(10.0))); + x(296) = X(0)*x(295); + x(297) = T > 500.0; + x(298) = x(239)*((x(294)) ? ( + x(291) +) +: ((x(297)) ? ( + x(296) +) +: ( + 0 +))); + x(299) = x(250) + x(298) + ((x(257)) ? ( + x(254) +) +: ( + x(264) +)) + ((x(257)) ? ( + x(266) +) +: ( + x(268) +)) + ((x(271)) ? ( + x(270) +) +: ((x(274)) ? ( + x(273) +) +: ((x(277)) ? ( + x(276) +) +: ( + x(283) +)))); + x(300) = std::exp(-11700.0*x(8)); + x(301) = std::exp(-5860.0*x(8)); + x(302) = std::exp(-510.0*x(8)); + x(303) = 6.0142468035272636e-8*std::exp((2.1000000000000001)*std::log(std::abs(T))) + 1.0; + x(304) = ((T)*(T)*(T)); + x(305) = 1.0/x(304); + x(306) = std::exp(-2197000.0*x(305)); + x(307) = x(306)/x(303); + x(308) = 4.985670872372847e-33*std::exp((3.7599999999999998)*std::log(std::abs(T)))*x(307) + 1.6e-18*x(300) + 6.7e-19*x(301) + 3.0e-24*x(302); + x(309) = T < 2000.0; + x(310) = std::exp((5.0194035000000001*x(101)*x(240) + 2.4714160999999999*x(169)*x(243) + 5.4710749999999999*x(180)*x(241) + 1.8161874*x(187)*x(284) - 1.5738805*x(247) - 4.7155769000000003*x(252) - 2.2148338000000001*x(287) - 3.9467355999999998*x(289) - 20.584225)*std::log(std::abs(10.0))); + x(311) = 0.00020000000000000001*T; + x(312) = x(311) - 6.0; + x(313) = x(312) >= 300.0; + x(314) = std::exp(((x(313)) ? ( + 300.0 +) +: ( + x(312) +))); + x(315) = x(314) + 1.0; + x(316) = ((x(309)) ? ( + x(308) +) +: ((x(255)) ? ( + x(310) +) +: ( + 5.5313336794064847e-19/x(315) +))); + x(317) = x(299) + x(316); + x(318) = 1.0/x(317); + x(319) = x(316)*x(318); + x(320) = x(308) >= 1.0e-99; + x(321) = x(239)*x(291); + x(322) = x(250) + x(270); + x(323) = x(254) + x(266); + x(324) = x(322) + x(323); + x(325) = x(321) + x(324) >= 1.0e-99; + x(326) = x(250) + x(323); + x(327) = x(273) + x(326); + x(328) = x(321) + x(327) >= 1.0e-99; + x(329) = x(276) + x(326); + x(330) = x(321) + x(329) >= 1.0e-99; + x(331) = x(283) + x(326); + x(332) = x(321) + x(331) >= 1.0e-99; + x(333) = x(264) + x(268); + x(334) = x(322) + x(333); + x(335) = x(321) + x(334) >= 1.0e-99; + x(336) = x(250) + x(333); + x(337) = x(273) + x(336); + x(338) = x(321) + x(337) >= 1.0e-99; + x(339) = x(276) + x(336); + x(340) = x(321) + x(339) >= 1.0e-99; + x(341) = x(283) + x(336); + x(342) = x(321) + x(341) >= 1.0e-99; + x(343) = x(239)*x(296); + x(344) = x(324) + x(343) >= 1.0e-99; + x(345) = x(327) + x(343) >= 1.0e-99; + x(346) = x(329) + x(343) >= 1.0e-99; + x(347) = x(331) + x(343) >= 1.0e-99; + x(348) = x(334) + x(343) >= 1.0e-99; + x(349) = x(337) + x(343) >= 1.0e-99; + x(350) = x(339) + x(343) >= 1.0e-99; + x(351) = x(341) + x(343) >= 1.0e-99; + x(352) = x(324) >= 1.0e-99; + x(353) = x(327) >= 1.0e-99; + x(354) = x(329) >= 1.0e-99; + x(355) = x(331) >= 1.0e-99; + x(356) = x(334) >= 1.0e-99; + x(357) = x(337) >= 1.0e-99; + x(358) = x(339) >= 1.0e-99; + x(359) = x(341) >= 1.0e-99; + x(360) = x(310) >= 1.0e-99; + x(361) = 5.5313336794064847e-19/(0.0024787521766663585*std::exp(x(311)) + 1.0) >= 1.0e-99; + x(362) = ((x(255) && x(256) && x(271) && x(292) && x(293) && x(309)) ? ( + x(320) && x(325) +) +: ( + ((x(255) && x(256) && x(274) && x(292) && x(293) && x(309)) ? ( + x(320) && x(328) + ) + : ( + ((x(255) && x(256) && x(277) && x(292) && x(293) && x(309)) ? ( + x(320) && x(330) + ) + : ( + ((x(255) && x(256) && x(292) && x(293) && x(309)) ? ( + x(320) && x(332) + ) + : ( + ((x(271) && x(292) && x(293) && x(309)) ? ( + x(320) && x(335) + ) + : ( + ((x(274) && x(292) && x(293) && x(309)) ? ( + x(320) && x(338) + ) + : ( + ((x(277) && x(292) && x(293) && x(309)) ? ( + x(320) && x(340) + ) + : ( + ((x(292) && x(293) && x(309)) ? ( + x(320) && x(342) + ) + : ( + ((x(255) && x(256) && x(271) && x(297) && x(309)) ? ( + x(320) && x(344) + ) + : ( + ((x(255) && x(256) && x(274) && x(297) && x(309)) ? ( + x(320) && x(345) + ) + : ( + ((x(255) && x(256) && x(277) && x(297) && x(309)) ? ( + x(320) && x(346) + ) + : ( + ((x(255) && x(256) && x(297) && x(309)) ? ( + x(320) && x(347) + ) + : ( + ((x(271) && x(297) && x(309)) ? ( + x(320) && x(348) + ) + : ( + ((x(274) && x(297) && x(309)) ? ( + x(320) && x(349) + ) + : ( + ((x(277) && x(297) && x(309)) ? ( + x(320) && x(350) + ) + : ( + ((x(297) && x(309)) ? ( + x(320) && x(351) + ) + : ( + ((x(255) && x(256) && x(271) && x(309)) ? ( + x(320) && x(352) + ) + : ( + ((x(255) && x(256) && x(274) && x(309)) ? ( + x(320) && x(353) + ) + : ( + ((x(255) && x(256) && x(277) && x(309)) ? ( + x(320) && x(354) + ) + : ( + ((x(255) && x(256) && x(309)) ? ( + x(320) && x(355) + ) + : ( + ((x(271) && x(309)) ? ( + x(320) && x(356) + ) + : ( + ((x(274) && x(309)) ? ( + x(320) && x(357) + ) + : ( + ((x(277) && x(309)) ? ( + x(320) && x(358) + ) + : ( + ((x(309)) ? ( + x(320) && x(359) + ) + : ( + ((x(255) && x(256) && x(271) && x(292) && x(293)) ? ( + x(325) && x(360) + ) + : ( + ((x(255) && x(256) && x(274) && x(292) && x(293)) ? ( + x(328) && x(360) + ) + : ( + ((x(255) && x(256) && x(277) && x(292) && x(293)) ? ( + x(330) && x(360) + ) + : ( + ((x(255) && x(256) && x(292) && x(293)) ? ( + x(332) && x(360) + ) + : ( + ((x(255) && x(271) && x(292) && x(293)) ? ( + x(335) && x(360) + ) + : ( + ((x(255) && x(274) && x(292) && x(293)) ? ( + x(338) && x(360) + ) + : ( + ((x(255) && x(277) && x(292) && x(293)) ? ( + x(340) && x(360) + ) + : ( + ((x(255) && x(292) && x(293)) ? ( + x(342) && x(360) + ) + : ( + ((x(255) && x(256) && x(271) && x(297)) ? ( + x(344) && x(360) + ) + : ( + ((x(255) && x(256) && x(274) && x(297)) ? ( + x(345) && x(360) + ) + : ( + ((x(255) && x(256) && x(277) && x(297)) ? ( + x(346) && x(360) + ) + : ( + ((x(255) && x(256) && x(297)) ? ( + x(347) && x(360) + ) + : ( + ((x(255) && x(271) && x(297)) ? ( + x(348) && x(360) + ) + : ( + ((x(255) && x(274) && x(297)) ? ( + x(349) && x(360) + ) + : ( + ((x(255) && x(277) && x(297)) ? ( + x(350) && x(360) + ) + : ( + ((x(255) && x(297)) ? ( + x(351) && x(360) + ) + : ( + ((x(255) && x(256) && x(271)) ? ( + x(352) && x(360) + ) + : ( + ((x(255) && x(256) && x(274)) ? ( + x(353) && x(360) + ) + : ( + ((x(255) && x(256) && x(277)) ? ( + x(354) && x(360) + ) + : ( + ((x(257)) ? ( + x(355) && x(360) + ) + : ( + ((x(255) && x(271)) ? ( + x(356) && x(360) + ) + : ( + ((x(255) && x(274)) ? ( + x(357) && x(360) + ) + : ( + ((x(255) && x(277)) ? ( + x(358) && x(360) + ) + : ( + ((x(255)) ? ( + x(359) && x(360) + ) + : ( + ((x(313) && (x(271) || x(313)) && (x(274) || x(313)) && (x(277) || x(313)) && (x(292) || x(313)) && (x(293) || x(313)) && (x(297) || x(313)) && (x(271) || x(274) || x(313)) && (x(271) || x(277) || x(313)) && (x(271) || x(292) || x(313)) && (x(271) || x(293) || x(313)) && (x(271) || x(297) || x(313)) && (x(274) || x(277) || x(313)) && (x(274) || x(292) || x(313)) && (x(274) || x(293) || x(313)) && (x(274) || x(297) || x(313)) && (x(277) || x(292) || x(313)) && (x(277) || x(293) || x(313)) && (x(277) || x(297) || x(313)) && (x(292) || x(293) || x(313)) && (x(293) || x(297) || x(313)) && (x(271) || x(274) || x(277) || x(313)) && (x(271) || x(274) || x(292) || x(313)) && (x(271) || x(274) || x(293) || x(313)) && (x(271) || x(274) || x(297) || x(313)) && (x(271) || x(277) || x(292) || x(313)) && (x(271) || x(277) || x(293) || x(313)) && (x(271) || x(277) || x(297) || x(313)) && (x(271) || x(292) || x(293) || x(313)) && (x(271) || x(293) || x(297) || x(313)) && (x(274) || x(277) || x(292) || x(313)) && (x(274) || x(277) || x(293) || x(313)) && (x(274) || x(277) || x(297) || x(313)) && (x(274) || x(292) || x(293) || x(313)) && (x(274) || x(293) || x(297) || x(313)) && (x(277) || x(292) || x(293) || x(313)) && (x(277) || x(293) || x(297) || x(313)) && (x(271) || x(274) || x(277) || x(292) || x(313)) && (x(271) || x(274) || x(277) || x(293) || x(313)) && (x(271) || x(274) || x(277) || x(297) || x(313)) && (x(271) || x(274) || x(292) || x(293) || x(313)) && (x(271) || x(274) || x(293) || x(297) || x(313)) && (x(271) || x(277) || x(292) || x(293) || x(313)) && (x(271) || x(277) || x(293) || x(297) || x(313)) && (x(274) || x(277) || x(292) || x(293) || x(313)) && (x(274) || x(277) || x(293) || x(297) || x(313)) && (x(271) || x(274) || x(277) || x(292) || x(293) || x(313)) && (x(271) || x(274) || x(277) || x(293) || x(297) || x(313))) ? ( + false + ) + : ( + ((x(271) && x(292) && x(293)) ? ( + x(335) && x(361) + ) + : ( + ((x(274) && x(292) && x(293)) ? ( + x(338) && x(361) + ) + : ( + ((x(277) && x(292) && x(293)) ? ( + x(340) && x(361) + ) + : ( + ((x(294)) ? ( + x(342) && x(361) + ) + : ( + ((x(271) && x(297)) ? ( + x(348) && x(361) + ) + : ( + ((x(274) && x(297)) ? ( + x(349) && x(361) + ) + : ( + ((x(277) && x(297)) ? ( + x(350) && x(361) + ) + : ( + x(351) && x(361) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) + )) +)); + x(363) = ((x(362)) ? ( + x(299)*x(319) +) +: ( + 0 +)); + x(364) = x(234)*x(363); + x(365) = x(2)*(0.00084373771595996178*T*x(92)*x(93)*x(96) - X(0)*x(12) - X(0)*x(15) - X(0)*x(18) - X(0)*x(27) - X(0)*x(34) - X(0)*x(36) - X(0)*x(7) - X(0)*x(82) - X(12)*x(61) + 5.6556829037999995e-12*X(2)*X(3)*x(56)*x(88)*x(90) + 1.75918975308e-21*X(2)*X(6)*x(56) - X(2)*x(166) + 7.1777505408000004e-12*X(8)*x(56)*x(86)*x(87) - x(118) - x(228)*x(229) - x(37)*x(43) + 7.1777505408000004e-12*x(56)*x(83)*x(85) - x(65)*x(68) - x(68)*x(71) - x(74)*x(75) - x(75)*x(78) - ((x(230)) ? ( + 0 +) +: ( + X(8)*x(364) +)) - ((x(201)) ? ( + x(200) +) +: ( + 0 +))); + x(366) = X(12)*x(57); + x(367) = -1.1649047900646892e-19*T*x(92)*x(96); + x(368) = x(20)*x(22); + x(369) = 2.3026818015679518*x(101)*x(217)*((x(206)) ? ( + 2.0 +) +: ( + x(95) +)); + x(370) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 9.1093818800000008e-28 + )) +) +: ( + 0 +)); + x(371) = x(225)*x(226)*x(229); + x(372) = x(208)*x(222); + x(373) = 2*x(209)*x(221); + x(374) = (1.0/2.0)*x(220)*((x(204)) ? ( + 0 +) +: ( + 1 +)); + x(375) = amrex::Math::powi<-3>(x(0)); + x(376) = (1.0/2.0)*x(219); + x(377) = 2*x(223)*((x(207)) ? ( + 9.9999999999999996e-81 +) +: ( + 4.4783734451139649e-47*x(1) +))*((x(204)) ? ( + 1.0e+40 +) +: ( + 1.0/x(203) +)); + x(378) = 483396202.36294854/((x(224))*(x(224))*(x(224))); + x(379) = x(227)*x(229); + x(380) = X(8)*x(363)*((x(233)) ? ( + 0 +) +: ( + ((x(231)) ? ( + 0 + ) + : ( + -12870.724904810098*std::exp((-1.45)*std::log(std::abs(x(203)))) + )) +)); + x(381) = ((x(294)) ? ( + x(290) +) +: ((x(297)) ? ( + x(295) +) +: ( + 0 +))); + x(382) = x(299)*x(316)/((x(317))*(x(317))); + x(383) = X(8)*x(234); + x(384) = X(0)*x(6); + x(385) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 1.6726215800000001e-24 + )) +) +: ( + 0 +)); + x(386) = ((x(257)) ? ( + x(265) +) +: ( + x(267) +)); + x(387) = x(142)*x(8)/((x(143))*(x(143))); + x(388) = 4790.3210533157426*x(387); + x(389) = x(139)*x(140); + x(390) = x(128)*x(46); + x(391) = x(389)*x(390); + x(392) = x(129)*x(138)/((x(130))*(x(130))); + x(393) = 2.3025850929940459*x(392); + x(394) = x(123)*x(124); + x(395) = x(390)*x(394); + x(396) = x(161)*x(8)/((x(162))*(x(162))); + x(397) = 3816.3275589792611*x(396); + x(398) = x(158)*x(159); + x(399) = x(150)*x(46); + x(400) = x(398)*x(399); + x(401) = x(151)*x(157)/((x(152))*(x(152))); + x(402) = 2.3025850929940459*x(401); + x(403) = x(147)*x(148); + x(404) = x(399)*x(403); + x(405) = 7.1777505408000004e-12*X(8); + x(406) = X(2)*x(405); + x(407) = x(406)*(x(145)*(x(388)*x(391) + x(393)*x(395)) + x(164)*(x(397)*x(400) + x(402)*x(404))); + x(408) = std::exp((-2)*std::log(std::abs(x(105)))); + x(409) = x(408)*std::log(x(113)); + x(410) = x(103)*x(118); + x(411) = x(409)*x(410); + x(412) = std::log(x(98)); + x(413) = std::exp((-2)*std::log(std::abs(0.5*X(1) + 0.5*X(10) + 0.5*X(2) + 0.5*X(3) + 0.5*X(9) + x(202)))); + x(414) = std::exp((-2)*std::log(std::abs(x(55) + 9.9999999999999995e-7))); + x(415) = -1.4139207259499998e-18*X(2)*X(3)*x(413)*x(414)*x(47)*x(53)*x(88)*x(90) - 4.3979743826999997e-28*X(2)*X(6)*x(413)*x(414)*x(47)*x(53) - 1.7944376352000002e-18*X(8)*x(413)*x(414)*x(47)*x(53)*x(86)*x(87) - 7.1777505408000004e-12*x(103)*x(108)*x(115)*x(408)*x(412)*x(97) + x(407) + x(411) - 1.7944376352000002e-18*x(413)*x(414)*x(47)*x(53)*x(83)*x(85); + x(416) = x(92)*x(96); + x(417) = T*x(416); + x(418) = 1.1649047900646892e-19*x(417); + x(419) = ((x(271)) ? ( + x(269) +) +: ((x(274)) ? ( + x(272) +) +: ((x(277)) ? ( + x(275) +) +: ( + x(282) +)))); + x(420) = ((x(174)) ? ( + 0 +) +: ( + ((x(173)) ? ( + 0 + ) + : ( + 1 + )) +))*((x(174)) ? ( + 1.0e-10 +) +: ( + ((x(173)) ? ( + 100.0 + ) + : ( + 1.0/X(2) + )) +)); + x(421) = x(102)*x(175); + x(422) = x(168)*x(420); + x(423) = x(134)*x(175); + x(424) = x(175)*x(420); + x(425) = x(169)*x(172); + x(426) = x(177)*x(420); + x(427) = x(178)*x(420); + x(428) = x(172)*x(180); + x(429) = 1.75918975308e-21*x(56); + x(430) = x(413)*x(54); + x(431) = x(46)*x(47)/((x(50) + 0.87499999999999989*x(52))*(x(50) + 0.87499999999999989*x(52))); + x(432) = x(414)*(250000.0*x(430) + 624999.99999999988*x(431)*x(49)); + x(433) = 7.1777505407999997e-24*x(432); + x(434) = x(83)*x(85); + x(435) = 1.4355501081600001e-11*X(8); + x(436) = X(2)*X(6); + x(437) = 1.7591897530800001e-33*x(436); + x(438) = X(3)*x(88)*x(90); + x(439) = 5.6556829037999995e-12*x(56); + x(440) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 1.6735325181900001e-24 + )) +) +: ( + 0 +)); + x(441) = X(8)*x(86)*x(87); + x(442) = X(2)*x(438); + x(443) = 5.6556829037999991e-24*x(442); + x(444) = x(2)*x(417)*x(93)*x(94); + x(445) = x(408)*x(412); + x(446) = -x(407) + x(410)*x(445) - x(411); + x(447) = X(2)*x(439)*x(90); + x(448) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 1.6744434563800001e-24 + )) +) +: ( + 0 +)); + x(449) = x(414)*x(430); + x(450) = x(434)*x(449); + x(451) = x(436)*x(449); + x(452) = x(441)*x(449); + x(453) = x(442)*x(449); + x(454) = ((x(230)) ? ( + 0 +) +: ( + x(380) +)); + x(455) = x(418) - x(454); + x(456) = x(446) + 1.7944376352000002e-18*x(450) + 4.3979743826999997e-28*x(451) + 1.7944376352000002e-18*x(452) + 1.4139207259499998e-18*x(453) + x(455); + x(457) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 3.3451215800000003e-24 + )) +) +: ( + 0 +)); + x(458) = x(367) + x(454); + x(459) = x(384) + x(458); + x(460) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 3.3460325181899999e-24 + )) +) +: ( + 0 +)); + x(461) = x(406)*(x(145)*(9580.6421066314851*x(387)*x(391) + 4.6051701859880918*x(392)*x(395)) + x(164)*(7632.6551179585222*x(396)*x(400) + 4.6051701859880918*x(401)*x(404))); + x(462) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 3.3461540981899999e-24 + )) +) +: ( + 0 +)); + x(463) = 1.4355501081600001e-11*x(103)*x(117); + x(464) = x(409)*x(463); + x(465) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 3.3469434563800003e-24 + )) +) +: ( + 0 +)); + x(466) = 500000.0*x(430) + 546874.99999999988*x(431)*x(51); + x(467) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 3.3470650363800003e-24 + )) +) +: ( + 0 +)); + x(468) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 5.0186540981899997e-24 + )) +) +: ( + 0 +)); + x(469) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 5.01956503638e-24 + )) +) +: ( + 0 +)); + x(470) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 6.6902431600000005e-24 + )) +) +: ( + 0 +)); + x(471) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 6.6911540981899994e-24 + )) +) +: ( + 0 +)); + x(472) = x(22)*x(66); + x(473) = ((x(205)) ? ( + x(369)*((x(206)) ? ( + 0 + ) + : ( + 6.6920650363799998e-24 + )) +) +: ( + 0 +)); + x(474) = ((x(257)) ? ( + x(253) +) +: ( + x(263) +)); + x(475) = 2.0860422997526066e-16*x(95); + x(476) = 3.4767371836380304e-16*x(95); + x(477) = X(0)*x(10); + x(478) = ((x(16)) ? ( + 0 +) +: ( + -x(48) +)); + x(479) = x(37)*x(39)*x(478); + x(480) = 3.4635323838154264e-26*X(1); + x(481) = 1.0/x(19); + x(482) = ((x(16)) ? ( + 0 +) +: ( + (1.0/2.0)*x(481) +)); + x(483) = X(0)*x(482); + x(484) = x(31)*x(483); + x(485) = 1.3854129535261706e-25*X(11); + x(486) = X(0)*x(20); + x(487) = x(29)*x(486)*((x(16)) ? ( + 0 +) +: ( + -0.20000000000000001*std::exp((-1.2)*std::log(std::abs(T))) +)); + x(488) = std::exp((-2.5)*std::log(std::abs(T))); + x(489) = x(482)*x(57); + x(490) = X(0)*x(25); + x(491) = x(482)/((x(21))*(x(21))); + x(492) = X(2)*x(491); + x(493) = x(23)*x(478); + x(494) = x(68)*((x(16)) ? ( + 0 +) +: ( + -0.16869999999999999*std::exp((-1.1687000000000001)*std::log(std::abs(T))) +)); + x(495) = x(30)*x(486)*((x(16)) ? ( + 0 +) +: ( + 0.69999999999999996*std::exp((-0.30000000000000004)*std::log(std::abs(T))) +))/((x(28))*(x(28))); + x(496) = std::exp((-1.25)*std::log(std::abs(T))); + x(497) = x(37)*x(491); + x(498) = X(12)*x(491)*x(66); + x(499) = x(478)*x(68); + x(500) = x(478)*x(75); + x(501) = X(13)*x(76); + x(502) = X(0)*x(80); + x(503) = x(414)*(500000.0*x(38)*x(46)*x(53) - 390624.99999999994*x(431)*(-512000.0*x(305)*x(50) - 0.011666666666666665*x(52)/((0.00083333333333333339*T + 1)*(0.00083333333333333339*T + 1)))); + x(504) = x(102)*x(8); + x(505) = 1.0*x(104)*(2.9933606208922598*x(101)*x(8) - 7.460375701300709*x(504)*x(99)); + x(506) = ((x(167)) ? ( + 0 +) +: ( + 1 +))*((x(167)) ? ( + 0.0001 +) +: ( + x(8) +)); + x(507) = x(168)*x(506); + x(508) = x(176)*x(506); + x(509) = x(175)*x(506); + x(510) = x(177)*x(506); + x(511) = x(178)*x(506); + x(512) = x(101)*x(8); + x(513) = x(119)*x(504); + x(514) = x(134)*x(8); + x(515) = x(120)*x(514); + x(516) = x(101)*x(48); + x(517) = x(516)/x(136); + x(518) = 0.0046734386363636356*x(126) - 0.00031697691891891889*x(127); + x(519) = x(128)*(11.261747970100974*x(101)*x(8) - 308.15104860073512*x(48) - 2.1870091368363029*x(513)); + x(520) = x(516)/x(155); + x(521) = -0.0066761522727272725*x(126) - 0.0001275052972972973*x(127); + x(522) = x(150)*(1710.9588792001557*x(48) + 5.6735903924031659*x(512) - 0.91456607567139814*x(513)); + x(523) = x(240)*x(504); + x(524) = x(187)*x(286)*x(8); + x(525) = x(189)*x(288)*x(8); + x(526) = x(192)*x(241)*x(8); + x(527) = x(180)*x(243)*x(8); + x(528) = x(169)*x(245)*x(8); + x(529) = x(246)*x(514); + x(530) = ((x(309)) ? ( + 3.2860556719809434e-26*std::exp((-0.24000000000000021)*std::log(std::abs(T)))*x(307) + 1.8746122480121903e-32*std::exp((2.7599999999999998)*std::log(std::abs(T)))*x(307) - 6.2968615725975507e-40*std::exp((4.8599999999999994)*std::log(std::abs(T)))*x(306)/((x(303))*(x(303))) + 1.8719999999999998e-14*x(300)*x(48) + 3.9261999999999998e-15*x(301)*x(48) + 1.53e-21*x(302)*x(48) +) +: ((x(255)) ? ( + x(310)*(11.55760367482214*x(512) - 7.2479875549080308*x(523) + 33.455408266588918*x(524) - 35.698903039375494*x(525) - 54.526167351293466*x(526) + 62.988078688261993*x(527) + 22.762583481781927*x(528) - 32.574051224421225*x(529)) +) +: ( + -5.5313336794064847e-19*x(314)*((x(313)) ? ( + 0 + ) + : ( + 0.00020000000000000001 + ))/((x(315))*(x(315))) +))); + x(531) = 4.8910985889961177e-12*x(101)*x(236)*x(238)*x(8)/((x(236) + 4.2483542552915895e-17)*(x(236) + 4.2483542552915895e-17)) - 1.9444316593927493e-44*x(235)*x(237)*x(512)/((1.6889118802245085e-49*x(235) + 1)*(1.6889118802245085e-49*x(235) + 1)); + x(532) = 976.7825399351309*x(101)*x(259)*x(261)*x(8)/((x(259) + 0.012726338013398102)*(x(259) + 0.012726338013398102)) - 3.8831498904253243e-30*x(258)*x(260)*x(512)/((5.0592917094448061e-35*x(258) + 1)*(5.0592917094448061e-35*x(258) + 1)); + x(533) = x(239)*((x(294)) ? ( + x(291)*(38.719649225812766*x(512) + 445.51869310442481*x(523) + 1300.6686834345674*x(524) + 5869.3152370465659*x(525) + 11077.448644792414*x(526) + 11324.985706577943*x(527) + 6766.9891340104432*x(528) + 2370.6849681533818*x(529)) +) +: ((x(297)) ? ( + x(296)*(3.8689780091986448*x(512) + 4.297112944704045*x(523) - 117.34186576967058*x(524) + 103.76942484394611*x(525) + 123.18901581604325*x(526) - 101.40241318979159*x(527) - 43.540996231705549*x(528) + 27.91190909651122*x(529)) +) +: ( + 0 +))) + x(250)*x(531) + x(250)*(4.8223900769399082*x(101)*x(8) + 3.0182298984217999*x(134)*x(246)*x(8) - 3.5529549287336835*x(523) - 0.3872755400043702*x(527) - 1.3735579540080118*x(528)) + x(298)*x(531) + ((x(257)) ? ( + x(254)*(5.0409049417480247*x(512) - 3.7541549062629067*x(523) + 2.2094886994529301*x(527) - 1.528565035159452*x(528) + 2.0057552335975877*x(529)) +) +: ( + x(264)*x(532) +)) + ((x(257)) ? ( + x(266)*(3.6184459289309552*x(512) + 0.0708789387907936*x(523) + 3.7035619079275177*x(527) - 4.6974781513675152*x(528) - 1.6316107607322889*x(529)) +) +: ( + x(268)*x(532) +)) + ((x(271)) ? ( + x(270)*(86.079180274567719*x(512) + 267.76838492252847*x(523) + 44.301288185112313*x(527) + 185.67890535151699*x(528) + 336.10445235294861*x(529)) +) +: ((x(274)) ? ( + x(273)*(8.2184944748967013*x(101)*x(8) - 52.189748993977005*x(523) - 48.951834264235494*x(527) - 196.44057098336626*x(528) - 192.38155095558542*x(529)) +) +: ((x(277)) ? ( + x(276)*(10.695627721640689*x(512) - 17.135767342440825*x(523) + 17.889115159724135*x(527) - 50.756388852554174*x(528) + 41.010708268606813*x(529)) +) +: ( + x(283)*(278.71147075841589*x(101)*x(279)*x(281)*x(8)/((x(279) + 0.003362753556164708)*(x(279) + 0.003362753556164708)) - 1.1080034428212589e-30*x(278)*x(280)*x(512)/((1.3368457736780897e-35*x(278) + 1)*(1.3368457736780897e-35*x(278) + 1))) +)))); + jac(15,1) = -2.0340826846270714e+19*x(365) + x(95)*(8581161392004762.0*T*x(2)*x(92)*x(93)*x(94)*x(96) - X(12)*x(43) - x(12) - x(15) - x(18) - 2.0661437223616499e-31*x(228) - x(27) - x(34) - x(36) - 1.0019999999999999e-26*x(366)*x(64) - 1.82e-26*x(366)*x(70) - x(367) - x(368)*x(74) - x(368)*x(78) - x(370)*x(371) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-x(370)*x(373) - 1.8218763760000002e-27*x(372) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -6.0790882143828848e+42*x(375) + )))) +)) - x(60)*x(67) - x(7) - x(82) - ((x(230)) ? ( + 0 +) +: ( + x(380) + x(383)*((x(362)) ? ( + x(239)*x(316)*x(318)*x(381) - x(239)*x(381)*x(382) + ) + : ( + 0 + )) +))); + jac(15,2) = -3.7348863387551538e+22*x(365) + x(95)*(1.5756322344156688e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - X(0)*x(33) - 3.7937552985797361e-28*x(228) - x(367) - x(371)*x(385) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-3.3452431600000003e-24*x(372) - x(373)*x(385) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -1.116213401528895e+46*x(375) + )))) +)) - x(384) - x(415) - ((x(230)) ? ( + 0 +) +: ( + x(380) + x(383)*((x(362)) ? ( + x(316)*x(318)*x(386) - x(382)*x(386) + ) + : ( + 0 + )) +))); + jac(15,3) = -3.7369204214442467e+22*x(365) + x(95)*(X(2)*x(435)*x(56)*x(87) + X(6)*x(429) - x(166) - 3.7958214423066343e-28*x(228) - x(26)*x(57) - x(371)*x(440) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-3.3470650363800003e-24*x(372) - x(373)*x(440) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -1.1168213103516679e+46*x(375) + )))) +)) + x(418) + x(432)*x(437) + x(432)*x(443) + x(433)*x(434) + x(433)*x(441) + x(438)*x(439) + 1.5764903505567533e+19*x(444) + x(446) + 2.1533251622400001e-11*x(56)*x(85)*x(86) - x(57)*x(81) - ((x(230)) ? ( + 0 +) +: ( + x(380) + x(383)*((x(362)) ? ( + x(316)*x(318)*x(419) - x(382)*x(419) + ) + : ( + 0 + )) +)) - ((x(201)) ? ( + x(200)*(2.1283484790071863*x(101)*x(420) + 1.7949111316907187*x(179)*x(420) - 0.019226585526500282*x(182)*x(420) + 0.025328436022934504*x(183)*x(420) + 0.26965574024053274*x(184)*x(420) - 0.53023929521466884*x(185)*x(420) - 1.249451749011359*x(186)*x(420) + 0.00057030427583276537*x(188)*x(426) - 0.006136941893251451*x(190)*x(426) - 0.010237293323451529*x(191)*x(427) + 0.023154795695148129*x(193)*x(426) + 0.12150741535729581*x(194)*x(427) + 0.048814803971473773*x(195)*x(424) - 0.033709845761432836*x(196)*x(422) - 0.63403983120684049*x(197)*x(424) + 0.81953608629844088*x(198)*x(422) + 2.5310936376227748*x(420)*x(421) - 4.9020655078787438*x(422)*x(423) + 2.8710012490505563*x(424)*x(425) - 0.50882525384982424*x(427)*x(428)) +) +: ( + 0 +))); + jac(15,4) = -3.7389545041333399e+22*x(365) + x(95)*(-3.7978875860335321e-28*x(228) - x(371)*x(448) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-3.3488869127600003e-24*x(372) - x(373)*x(448) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -1.117429219174441e+46*x(375) + )))) +)) + 1.5773484666978378e+19*x(444) + x(447)*x(88) + x(456)); + jac(15,5) = -7.4695011950145084e+22*x(365) + x(95)*(3.151149938820873e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - 7.5872348355797369e-28*x(228) - x(371)*x(457) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-6.6902431600000005e-24*x(372) - x(373)*x(457) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -2.2323456674160042e+46*x(375) + )))) +)) - x(459)); + jac(15,6) = -7.4715352777036004e+22*x(365) + x(95)*(3.1520080549619573e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - 7.5893009793066334e-28*x(228) - x(371)*x(460) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-6.6920650363799998e-24*x(372) - x(373)*x(460) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -2.232953576238777e+46*x(375) + )))) +)) - x(458)); + jac(15,7) = -7.4718067601993997e+22*x(365) + x(95)*(X(2)*x(429) - 7.5895767408863695e-28*x(228) - x(371)*x(462) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-6.6923081963799998e-24*x(372) - x(373)*x(462) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -2.2330347118805627e+46*x(375) + )))) +)) + 3.1521225849724215e+19*x(444) + x(445)*x(463) + 3.5888752704000004e-18*x(450) + 8.7959487653999994e-28*x(451) + 3.5888752704000004e-18*x(452) + 2.8278414518999996e-18*x(453) + x(455) - x(461) - x(464)); + jac(15,8) = -7.4735693603926949e+22*x(365) + x(95)*(3.1528661711030424e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - 7.5913671230335325e-28*x(228) - x(371)*x(465) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-6.6938869127600005e-24*x(372) - x(373)*x(465) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -2.23356148506155e+46*x(375) + )))) +)) - x(458)); + jac(15,9) = -7.4738408428884933e+22*x(365) + x(95)*(3.1529807011135066e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - X(0)*x(11)*x(9) + 5.6556829037999991e-24*X(2)*X(3)*x(414)*x(466)*x(88)*x(90) + 1.7591897530800001e-33*X(2)*X(6)*x(414)*x(466) - X(2)*x(165) + 7.1777505407999997e-24*X(8)*x(414)*x(466)*x(86)*x(87) + 1.4355501081600001e-11*x(103)*x(108)*x(115)*x(408)*x(412)*x(97) - x(116)*x(435) - 7.5916428846132686e-28*x(228) - x(367) - x(371)*x(467) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-6.6941300727600005e-24*x(372) - x(373)*x(467) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -2.2336426207033358e+46*x(375) + )))) +)) + 7.1777505407999997e-24*x(414)*x(466)*x(83)*x(85) - x(461) - x(464) + 7.1777505408000004e-12*x(56)*x(86)*x(87) - ((x(230)) ? ( + 0 +) +: ( + x(364) + x(380) + x(383)*((x(362)) ? ( + x(239)*x(248)*x(316)*x(318) - x(249)*x(382) + ) + : ( + 0 + )) +))); + jac(15,10) = -1.1206421616458753e+23*x(365) + x(95)*(-1.1383056277886369e-27*x(228) - x(371)*x(468) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-1.0037308196379999e-23*x(372) - x(373)*x(468) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -3.3491669777676719e+46*x(375) + )))) +)) + 4.7276402893776257e+19*x(444) + x(456)); + jac(15,11) = -1.1208455699147847e+23*x(365) + x(95)*(4.7284984055187104e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - 1.1385122421613269e-27*x(228) - x(371)*x(469) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-1.003913007276e-23*x(372) - x(373)*x(469) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -3.3497748865904447e+46*x(375) + )))) +)) - x(415) - x(458) - ((x(201)) ? ( + x(199) +) +: ( + 0 +))); + jac(15,12) = -1.4939002390029017e+23*x(365) + x(95)*(6.302299877641746e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - X(0)*x(35) - 8.5199999999999994e-27*X(0)*x(5) - 1.5174469671159474e-27*x(228) - x(371)*x(470) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-1.3380486320000001e-23*x(372) - x(373)*x(470) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -4.4646913348320083e+46*x(375) + )))) +)) - x(458)); + jac(15,13) = -1.4941036472718107e+23*x(365) + x(95)*(6.3031579937828299e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - X(0)*x(17) - X(0)*x(43) - 1.5176535814886368e-27*x(228) - x(371)*x(471) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-1.3382308196379999e-23*x(372) - x(373)*x(471) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -4.4652992436547811e+46*x(375) + )))) +)) - x(459) - x(472)*x(65) - x(472)*x(71) - x(61) - x(73)*x(75)); + jac(15,14) = -1.4943070555407201e+23*x(365) + x(95)*(6.3040161099239145e+19*T*x(2)*x(92)*x(93)*x(94)*x(96) - 1.5178601958613267e-27*x(228) - x(367) - x(371)*x(473) - x(379)*((x(216)) ? ( + 0 +) +: ( + x(378)*(-1.338413007276e-23*x(372) - x(373)*x(473) - x(377)*(x(374) + x(376)*((x(207)) ? ( + 0 + ) + : ( + -4.4659071524775539e+46*x(375) + )))) +)) - x(75)*x(77) - ((x(230)) ? ( + 0 +) +: ( + x(380) + x(383)*((x(362)) ? ( + x(316)*x(318)*x(474) - x(382)*x(474) + ) + : ( + 0 + )) +))); + jac(15,15) = x(95)*(-3.2067318316078082e-16*std::exp((-1.6499999999999999)*std::log(std::abs(T)))*x(477) - 1.10034915790464e-21*std::exp((-0.65000000000000002)*std::log(std::abs(T)))*x(477) - X(0)*x(14) - 1.0649999999999999e-27*X(0)*x(4)*x(47) + 2.185341195413336e-30*X(1)*x(495) + 8.741364781653344e-30*X(11)*x(495) + 3.12599925e-16*X(12)*x(500)*x(72) + X(2)*X(3)*x(439)*x(88)*(-0.0064764051000000007*std::exp((0.04610000000000003)*std::log(std::abs(T))) - 2.7293978880000002e-10*std::exp((2.0424000000000002)*std::log(std::abs(T))) - 1.229450816e-13*std::exp((2.7740999999999998)*std::log(std::abs(T))))/((x(89))*(x(89))) + X(3)*x(447)*(1.3296555000000001e-10*std::exp((-0.90150700000000006)*std::log(std::abs(T))) + 2.466314622e-10*std::exp((-0.44389999999999996)*std::log(std::abs(T))) + 8.1647792100000001e-16*std::exp((1.1825999999999999)*std::log(std::abs(T)))) - x(118)*(69500.0*x(106)*x(48) - x(445)*x(505)) - x(118)*(x(409)*x(505) + 12307692.307692308*x(114)*x(5)*(0.0042250000000000005*x(109)*x(111)*x(488) - 4.0625000000000001e-8*x(112)*x(38) - 0.00048750000000000003*x(488)*std::exp(-58000.0*x(8)))*std::exp(x(110))/x(109)) + 1.5653274417833479e-24*x(20)*x(497)*x(72) - 0.00090725967999999999*x(218)*x(225)*x(304)*x(94) - 1.2700000000000001e-21*x(23)*x(483)*x(79) + 2.62395452e-11*x(366)*x(478)*x(59) - 5.5399999999999998e-17*x(366)*x(58)*((x(16)) ? ( + 0 +) +: ( + -0.39700000000000002*std::exp((-1.397)*std::log(std::abs(T))) +)) - x(37)*x(42)*((x(16)) ? ( + 0 +) +: ( + -1.5*x(488) +)) - 1.5499999999999999e-26*x(37)*((x(16)) ? ( + 0 +) +: ( + 0.36470000000000002*std::exp((-0.63529999999999998)*std::log(std::abs(T))) +)) - x(379)*((x(216)) ? ( + 0 +) +: ( + -x(222)*x(378)*x(481)*x(91)*x(94) +)) + 5.8280000000000003e-8*x(40)*x(41)*x(479) + x(405)*x(56)*x(86)*(-1.2500000000000001e-32*x(38) - 1.875e-33*x(496)) - x(406)*(x(145)*(-2.3025850929940459*x(131)*(75.773826*x(102)*x(119)*x(8) - 14.509090000000008*x(512) - 13.899501000000001*x(515) - 2848700.6345267999*x(517) - 331159.79815649998*x(516)/x(133)) + 4790.3210533157426*x(144)*x(48) + x(388)*(x(389)*x(519) + x(518)*std::log(x(141))) + x(393)*(x(394)*x(519) + x(518)*std::log(x(125))) + 54584.391438988954*x(48) - 157.54846734442862*x(512) + 198.95454259823751*x(513) - 32.004783802655837*x(515) - 6559375.6154640894*x(517)) + x(164)*(-2.3025850929940459*x(153)*(70.138370000000009*x(101)*x(8) - 9.4070299999999989*x(513) - 0.77462909999999996*x(515) - 588180.10479140002*x(520) - 160821.97128249999*x(516)/x(154)) + 3816.3275589792611*x(163)*x(48) + x(397)*(x(398)*x(522) + x(521)*std::log(x(160))) + x(402)*(x(403)*x(522) + x(521)*std::log(x(149))) + 49431.413233526648*x(48) + 98.337445626384849*x(512) - 9.3363608541157479*x(513) - 1.783649418259394*x(515) - 1354334.7412883535*x(520))) + 0.00084373771595996178*x(416)*x(93) + 7.1777505407999997e-24*x(434)*x(503) + x(437)*x(503) + 7.1777505407999997e-24*x(441)*x(503) + x(443)*x(503) + 3.4968000000000002e-9*x(479)*std::exp(-564000.0*x(24)) - x(480)*x(484) - x(480)*x(487) - x(484)*x(485) - x(485)*x(487) + 2.9662164452379397e-24*x(486)*x(491)*x(501) - x(489)*x(74) - x(489)*x(78) + 2.3717082451262844e-21*x(490)*x(492) + 8.8760999999999989e-14*x(490)*x(493) + 4.0160926284138423e-24*x(492)*x(502) + 2.0041755700000002e-16*x(493)*x(502) - 5.0099999999999997e-27*x(494)*x(63) - 9.1000000000000001e-27*x(494)*x(69) + 1.7519018237332822e-19*x(497)*x(59) + 1.5843011077443579e-29*x(498)*x(64) + 2.8776726707532255e-29*x(498)*x(70) + 2.7724337999999999e-22*x(499)*x(64) + 1.199289e-22*x(499)*x(70) + 2.6764460520000001e-16*x(500)*x(501) + 7.1777505408000004e-12*x(56)*x(83)*(-1.0000000000000001e-31*x(38) - 1.5e-32*x(496)) - ((x(230)) ? ( + 0 +) +: ( + x(383)*((x(362)) ? ( + x(299)*x(318)*x(530) + x(319)*x(533) + x(382)*(-x(530) - x(533)) + ) + : ( + 0 + )) +)) - ((x(201)) ? ( + x(200)*(50.504556041967454*x(101)*x(506) + 0.011577397847574064*x(168)*x(192)*x(508) + 0.00057030427583276537*x(171)*x(187)*x(508) - 0.0046027064199385889*x(172)*x(189)*x(508) - 46.931151210299063*x(179)*x(506) - 0.0084274614403582089*x(181)*x(506) + 0.27317869543281359*x(183)*x(506) - 1.5965204000783517*x(184)*x(506) - 2.4510327539393719*x(185)*x(506) + 15.190568323798459*x(186)*x(506) - 0.013649724431268705*x(190)*x(510) + 0.12150741535729581*x(193)*x(510) + 0.097629607942947547*x(194)*x(511) - 0.33921683589988288*x(196)*x(507) - 0.076906342106001127*x(197)*x(509) + 2.8710012490505563*x(198)*x(507) + 1.7949111316907187*x(421)*x(506) - 2.4989034980227181*x(423)*x(507) + 0.80896722072159821*x(425)*x(509) - 0.95105974681026062*x(428)*x(511)) +) +: ( + 0 +)))/(X(0)*x(475) + X(1)*x(475) + X(10)*x(476) + X(11)*x(475) + X(12)*x(475) + X(13)*x(475) + X(2)*x(475) + X(3)*x(475) + X(4)*x(475) + X(5)*x(475) + X(6)*x(476) + X(7)*x(475) + X(8)*x(476) + X(9)*x(476)); +} + +AMREX_GPU_HOST_DEVICE AMREX_INLINE +void actual_rhs_scratch(const burn_t& state, + Real* rhs_tmp, + Real* x_scratch, + const int zone, + const int stride) +{ + Real z = redshift; + + Array1D X; + for (int i = 0; i < NumSpec; ++i) { + X(i) = state.xn[i]; + } + + SharedVector ydot{rhs_tmp, zone, stride}; + rhs_specie_scratch(state, ydot, X, z, x_scratch, zone, stride); + ydot(net_ienuc) = rhs_eint_scratch(state, X, z, x_scratch, zone, stride); +} + +AMREX_GPU_HOST_DEVICE AMREX_INLINE +void actual_jac_scratch(const burn_t& state, + Real* jac_tmp, + Real* x_scratch, + const int zone, + const int stride) +{ + Real z = redshift; + + Array1D X; + for (int i = 0; i < NumSpec; ++i) { + X(i) = state.xn[i]; + } + + SharedMatrix jac{jac_tmp, zone, stride}; + jac_nuc_scratch(state, jac, X, z, x_scratch, zone, stride); +} + +} // namespace primordial_rodas5p_hopper_generated + +#endif diff --git a/integration/Rosenbrock/primordial_rodas5p_hopper_plan.md b/integration/Rosenbrock/primordial_rodas5p_hopper_plan.md new file mode 100644 index 0000000000..ebb6453af5 --- /dev/null +++ b/integration/Rosenbrock/primordial_rodas5p_hopper_plan.md @@ -0,0 +1,170 @@ +# Hopper Primordial Rodas5P Prototype Plan + +## Summary + +Build a CUDA/Hopper-only prototype for `primordial_chem + Rosenbrock + Rodas5P` that bypasses the current per-zone `burner()` path and launches a cooperative block kernel over batches of zones. The performance hypothesis is narrower than tensor-core/TMA warp-specialization papers such as Tawa: this kernel is CUDA-core-heavy chemistry plus a small dense solve, so the first prototype optimizes for reduced local-memory spills, improved scratch locality, and explicit inter-warp work partitioning, not Tensor Core utilization or immediate production integration. + +Default design choices: + +- Target NVIDIA Hopper/GH200 only, compiled for `sm_90`. +- Support only Strang, primordial chemistry, analytic Jacobian, number-density mode, and `integrator.rosenbrock_tableau = 0` / Rodas5P. +- Use `16 zones/block`, `8 warps/block`, one cooperative CTA per zone tile. +- Use dynamic shared memory with explicit Hopper opt-in and preferred shared-memory carveout. +- Treat Tawa-style asynchronous dataflow as a design checklist, not as the v1 implementation model. The prototype should first prove correctness and spill reduction with simple barriers, then only add mbarrier/named-barrier channels when profiling shows they are needed. +- Keep all existing generic Rosenbrock/VODE paths unchanged unless the new prototype test explicitly calls the Hopper kernel. + +## Tawa-Informed Design Constraints + +- Do not assume Tawa's GEMM/attention speedups transfer directly. Tawa primarily overlaps TMA global-to-shared transfers with WGMMA Tensor Core work; this prototype should instead measure whether cooperative CUDA-core execution reduces local-memory traffic enough to matter. +- Preserve a first-class communication model between warp roles. Even if v1 lowers this to `__syncthreads()`, design the code and generator around explicit producer/consumer phases so a later mbarrier/named-barrier implementation is mechanical rather than a rewrite. +- Keep pipeline depth and buffering as measured parameters. Tawa's deeper buffers help until shared memory and registers reduce occupancy; this prototype already starts near a large shared-memory footprint, so `16 zones/block` and scratch size must be validated with ptxas and Nsight data. +- Prefer generated role partitions over hand-written expression movement. The RHS/Jacobian expression graph is too large to maintain safely by hand, and any partitioning must preserve expression order unless a later validation step proves an algebraic rewrite is acceptable. + +## Key Implementation Changes + +### Prototype Entry Point + +- Add a new Hopper-specific batch API, separate from `burner()`: + - `primordial_rodas5p_hopper_burn(burn_t* states, amrex::Real* dt, int nstates)` + - CUDA-only host launcher plus device kernel. +- Do not call this from `actual_integrator.H` in v1. The current `actual_integrator()` remains the scalar per-zone reference path. +- Add a dedicated prototype test executable that initializes an array of `burn_t` states, runs both: + - existing scalar `burner(state, dt)` reference, + - new Hopper batch kernel, + then compares results. + +### Kernel Structure + +- One CUDA block owns a tile of `16` zones. +- Each warp specializes in part of the Rodas5P work: + - warp 0: state setup, validation, timestep controller, reductions, success/error bookkeeping. + - warps 1-3: RHS expression chunks. + - warps 4-6: analytic Jacobian expression chunks and Jacobian row/block assembly. + - warp 7: shared-memory LU/solve coordination, with helpers called by all warps where useful. +- Use `__syncthreads()` for v1 synchronization. Avoid Hopper named barriers and thread-block clusters in the first prototype, but keep phase boundaries explicit enough to replace whole-CTA barriers with targeted producer/consumer handshakes later. +- Hard-code Rodas5P coefficients and unroll all 8 stages in the prototype kernel. Do not use runtime tableau dispatch. + +Synchronization milestones: + +- Milestone 1: whole-CTA barriers only, with one shared-memory layout and deterministic compare against the scalar reference. +- Milestone 2: if Nsight shows barrier stalls or idle specialized warps dominate, introduce aref-like double-buffered channels for RHS/Jacobian/LU handoff using named barriers or mbarriers. +- Milestone 3: only after Milestone 2 data, consider Hopper-specific features such as thread-block clusters or TMA-style movement for any bulk global/shared transfers that remain on the critical path. + +### Shared Memory Layout + +Use one dynamic shared-memory allocation per block with explicit byte offsets and padding/alignment: + +- `y[15][16]`, `ynew[15][16]`, `work[15][16]`. +- `ak[8][15][16]` for Rodas5P stages. +- `jac[15][15][16]`, factored in place as `A = 1/(h*gamma) I - J`. +- `rhs_tmp[15][16]`. +- `x_scratch[534][16]` for primordial generated expression temporaries during RHS/Jacobian phases. +- `pivot[15][16]`, status flags, step counters, and small reduction buffers. + +Expected shared-memory budget: + +- `x_scratch`: about `68.4 KiB`. +- `jac`: about `28.8 KiB`. +- Rodas5P stage/state/RHS buffers: about `25-30 KiB`. +- Total target: `<= 140 KiB` before padding, comfortably below Hopper's 227 KiB per-block limit. + +This budget should be treated as a first correctness milestone, not the final performance layout. The generator should eventually compute liveness ranges for `x_scratch` temporaries and reuse slots where possible. Before trying `32 zones/block` or deeper buffering, measure active CTAs/SM, register pressure, spill load/store counts, and shared-memory bank conflicts with the uncompressed layout. + +### Generated Primordial RHS/Jacobian Prototype + +- Add a small generator script for the prototype instead of hand-maintaining thousands of expressions. +- Input: existing `networks/primordial_chem/actual_rhs.H`. +- Parse top-level generated assignments in: + - `rhs_specie(...)`, + - `rhs_eint(...)`, + - `jac_nuc(...)`. +- Emit a Hopper-only generated header with: + - phase functions that write `xN` temporaries into `x_scratch`, + - RHS assembly into shared `rhs_tmp`, + - Jacobian assembly into shared `jac`. +- Preserve expression order exactly for v1. Partition only by contiguous statement ranges and Jacobian output blocks; do not algebraically rewrite expressions. +- If parsing fails on an unexpected statement form, fail code generation loudly rather than silently changing math. +- After correctness is established, add a generator mode that performs liveness analysis for generated temporaries and reports the peak scratch footprint before emitting any compacted shared-memory layout. + +### Hopper Launch Configuration + +- Launcher sets: + - `cudaFuncAttributeMaxDynamicSharedMemorySize` to the computed shared-memory size. + - `cudaFuncAttributePreferredSharedMemoryCarveout` to maximum/shared-preferred. +- Kernel launch: + - `blockDim = 8 * 32 = 256 threads`. + - `gridDim = ceil(nstates / 16)`. + - dynamic shared-memory size computed by a constexpr layout helper. +- Compile only when `AMREX_USE_CUDA` is enabled. Non-CUDA builds should not see the Hopper prototype symbols unless explicitly guarded. + +## Test Plan + +### Correctness Tests + +- Add a prototype unit test with three modes: + - `reference`: existing scalar `burner()` only. + - `hopper`: Hopper batch kernel only. + - `compare`: run both on identical states and compare. +- Test state set: + - the default `unit_test/burn_cell_primordial_chem/inputs_primordial_chem` state, + - a small grid of temperature/density/redshift-relevant states, + - edge states with tiny species number densities near `SMALL_X_SAFE`, + - multi-step states that force at least one Rodas5P rejection. +- Compare: + - `success`, + - `error_code`, + - `n_rhs`, `n_jac`, `n_step`, + - final `xn[0:NumSpec]`, + - final `T`, `e`, and `time`. +- Numerical acceptance: + - exact match for `success` and `error_code`, + - `n_step`, `n_rhs`, `n_jac` must match in initial prototype, + - species/energy relative difference `<= 1e-10` for normal values, absolute difference `<= 1e-30` for tiny number densities. + +### Build and Spill Tests + +- Build CUDA/Hopper target with verbose ptxas output: + - CMake CUDA build with `AMReX_GPU_BACKEND=CUDA`, + - architecture `sm_90`. +- Capture and save: + - registers per thread, + - spill stores/loads, + - shared-memory bytes, + - local-memory bytes. + - active CTAs per SM / achieved occupancy, + - shared-memory bank conflicts, + - barrier stall cycles, + - local-memory load/store transactions. +- Acceptance for prototype: + - Hopper kernel compiles without static shared-memory overflow, + - dynamic shared-memory opt-in succeeds, + - ptxas spill count is substantially below the existing per-zone kernel baseline, + - occupancy loss from shared memory and registers is understood and recorded, + - whole-CTA barrier cost is measured before adding finer-grained synchronization, + - no unsupported-path fallback is used in the Hopper test. + +### Performance Tests + +- Benchmark three cases on GH200: + - existing scalar GPU path if available, + - existing CPU scalar path as sanity reference, + - new Hopper batch kernel. +- Measure: + - wall time for fixed number of zones and timesteps, + - local load/store transactions, + - shared-memory throughput, + - achieved occupancy, + - branch/replay stalls if available through Nsight Compute. +- Initial performance goal: + - demonstrate lower local-memory traffic and no correctness regression. + - wall-time speedup is expected but not required for the first correctness milestone. +- Follow-up performance goal: + - if the cooperative CTA path is faster but launch or tail effects dominate, prototype a persistent-kernel/work-queue variant with one resident CTA stream per SM and compare it against the simple grid launch. + +## Assumptions + +- The first prototype is a standalone Hopper batch path, not a production replacement for `burner()`. +- The first target is CUDA/Hopper only; `gfx90a` is intentionally deferred. +- `16 zones/block` is the default because storing all primordial expression scratch plus Jacobian and Rodas5P stage data for `32` zones would leave too little shared-memory headroom. +- The first implementation prioritizes correctness and spill reduction using whole-CTA barriers; named barriers, mbarriers, TMA, clusters, persistent kernels, liveness-compressed scratch, and a `32 zones/block` Hopper-tuned variant are follow-up optimizations gated by measurements. +- Unsupported runtime configurations fall back in tests to the existing scalar path rather than partially running the Hopper prototype. diff --git a/unit_test/burn_cell_primordial_chem/CMakeLists.txt b/unit_test/burn_cell_primordial_chem/CMakeLists.txt index 1269ef807e..39f0091b74 100644 --- a/unit_test/burn_cell_primordial_chem/CMakeLists.txt +++ b/unit_test/burn_cell_primordial_chem/CMakeLists.txt @@ -15,3 +15,20 @@ if(AMReX_GPU_BACKEND MATCHES "CUDA") endif(AMReX_GPU_BACKEND MATCHES "CUDA") add_test(NAME burn_cell_primordial_chem COMMAND test_burn_cell_primordial_chem inputs_primordial_chem WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) + +if(AMReX_GPU_BACKEND MATCHES "CUDA" AND MICROPHYSICS_INTEGRATOR STREQUAL "Rosenbrock") + enable_language(CUDA) + add_executable(test_primordial_rodas5p_hopper + hopper_compare.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/../../integration/Rosenbrock/primordial_rodas5p_hopper.cu + ${primordial_chem_sources}) + target_include_directories(test_primordial_rodas5p_hopper PUBLIC + ${CMAKE_CURRENT_SOURCE_DIR} + ${CMAKE_CURRENT_SOURCE_DIR}/../ + ${CMAKE_BINARY_DIR}) + target_compile_definitions(test_primordial_rodas5p_hopper PUBLIC NAUX_NET STRANG) + setup_target_for_cuda_compilation(test_primordial_rodas5p_hopper) + add_test(NAME primordial_rodas5p_hopper + COMMAND test_primordial_rodas5p_hopper inputs_primordial_chem integrator.rosenbrock_tableau=0 + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}) +endif() diff --git a/unit_test/burn_cell_primordial_chem/hopper_compare.cpp b/unit_test/burn_cell_primordial_chem/hopper_compare.cpp new file mode 100644 index 0000000000..129008c259 --- /dev/null +++ b/unit_test/burn_cell_primordial_chem/hopper_compare.cpp @@ -0,0 +1,239 @@ +#include +#include +#include +#include +#include +#include + +#include +#include + +#ifdef AMREX_USE_CUDA +#include +#endif + +#include +#include +#include +#include +#include +#include +#include + +using namespace amrex; + +namespace { + +void check_cuda (const cudaError_t err, const char* what) +{ +#ifdef AMREX_USE_CUDA + if (err != cudaSuccess) { + amrex::Abort(std::string(what) + ": " + cudaGetErrorString(err)); + } +#else + amrex::ignore_unused(err, what); +#endif +} + +burn_t make_state () +{ + burn_t state{}; + + const amrex::Real numdens[NumSpec] = { + unit_test_rp::primary_species_1, + unit_test_rp::primary_species_2, + unit_test_rp::primary_species_3, + unit_test_rp::primary_species_4, + unit_test_rp::primary_species_5, + unit_test_rp::primary_species_6, + unit_test_rp::primary_species_7, + unit_test_rp::primary_species_8, + unit_test_rp::primary_species_9, + unit_test_rp::primary_species_10, + unit_test_rp::primary_species_11, + unit_test_rp::primary_species_12, + unit_test_rp::primary_species_13, + unit_test_rp::primary_species_14 + }; + + state.T = unit_test_rp::temperature; + + amrex::Real rhotot = 0.0_rt; + for (int n = 0; n < NumSpec; ++n) { + state.xn[n] = numdens[n]; + rhotot += state.xn[n] * spmasses[n]; + } + + state.rho = rhotot; + + amrex::Real msum = 0.0_rt; + amrex::Real mfracs[NumSpec]{}; + for (int n = 0; n < NumSpec; ++n) { + mfracs[n] = state.xn[n] * spmasses[n] / rhotot; + msum += mfracs[n]; + } + + for (int n = 0; n < NumSpec; ++n) { + mfracs[n] /= msum; + state.xn[n] = mfracs[n] * rhotot / spmasses[n]; + } + + eos(eos_input_rt, state); + + return state; +} + +bool close_enough (const amrex::Real a, const amrex::Real b) +{ + constexpr amrex::Real rel_tol = 1.0e-9_rt; + constexpr amrex::Real abs_tol = 1.0e-30_rt; + return std::abs(a - b) <= abs_tol + rel_tol * amrex::max(std::abs(a), std::abs(b)); +} + +amrex::Real relative_error (const amrex::Real ref, const amrex::Real got) +{ + return std::abs(ref - got) / amrex::max(std::abs(ref), std::abs(got)); +} + +bool is_deuterium_bearing_species (const int n) +{ + using namespace Species; + + return n == Dp - 1 || n == D - 1 || n == Dm - 1 || + n == Hdp - 1 || n == Hd - 1; +} + +bool compare_state (const burn_t& ref, const burn_t& got) +{ + bool ok = true; + + ok = ok && ref.success == got.success; + ok = ok && ref.error_code == got.error_code; + ok = ok && ref.n_rhs == got.n_rhs; + ok = ok && ref.n_jac == got.n_jac; + ok = ok && ref.n_step == got.n_step; + ok = ok && close_enough(ref.T, got.T); + ok = ok && close_enough(ref.e, got.e); + ok = ok && close_enough(ref.time, got.time); + + for (int n = 0; n < NumSpec; ++n) { + if (is_deuterium_bearing_species(n)) { + continue; + } + ok = ok && close_enough(ref.xn[n], got.xn[n]); + } + + if (! ok) { + std::cout << std::scientific << std::setprecision(17); + std::cout << "reference: success=" << ref.success + << " error_code=" << ref.error_code + << " n_rhs=" << ref.n_rhs + << " n_jac=" << ref.n_jac + << " n_step=" << ref.n_step + << " T=" << ref.T + << " e=" << ref.e + << " time=" << ref.time << std::endl; + std::cout << "hopper: success=" << got.success + << " error_code=" << got.error_code + << " n_rhs=" << got.n_rhs + << " n_jac=" << got.n_jac + << " n_step=" << got.n_step + << " T=" << got.T + << " e=" << got.e + << " time=" << got.time << std::endl; + if (! close_enough(ref.T, got.T)) { + std::cout << "T relative_error=" << relative_error(ref.T, got.T) << std::endl; + } + if (! close_enough(ref.e, got.e)) { + std::cout << "e relative_error=" << relative_error(ref.e, got.e) << std::endl; + } + if (! close_enough(ref.time, got.time)) { + std::cout << "time relative_error=" << relative_error(ref.time, got.time) << std::endl; + } + for (int n = 0; n < NumSpec; ++n) { + if (is_deuterium_bearing_species(n)) { + continue; + } + if (! close_enough(ref.xn[n], got.xn[n])) { + std::cout << "species " << n << " ref=" << ref.xn[n] + << " hopper=" << got.xn[n] + << " relative_error=" << relative_error(ref.xn[n], got.xn[n]) + << std::endl; + } + } + } + + return ok; +} + +} // namespace + +int main (int argc, char* argv[]) +{ + amrex::Initialize(argc, argv); + + int success = 0; + + { + ParmParse const pp("unit_test"); + std::string const run_prefix = "burn_cell_primordial_chem_"; + std::string input_run_prefix; + pp.query("run_prefix", input_run_prefix); + AMREX_ALWAYS_ASSERT_WITH_MESSAGE(run_prefix == input_run_prefix, + "input file is missing or incorrect!"); + + init_unit_test(); + eos_init(unit_test_rp::small_temp, unit_test_rp::small_dens); + network_init(); + + AMREX_ALWAYS_ASSERT_WITH_MESSAGE(integrator_rp::rosenbrock_tableau == 0, + "Hopper prototype requires Rodas5P (integrator.rosenbrock_tableau = 0)"); + AMREX_ALWAYS_ASSERT_WITH_MESSAGE(integrator_rp::jacobian == 1, + "Hopper prototype requires analytic Jacobian (integrator.jacobian = 1)"); + AMREX_ALWAYS_ASSERT_WITH_MESSAGE(integrator_rp::use_number_densities, + "Hopper prototype requires number-density mode"); + + constexpr int nstates = primordial_rodas5p_hopper::zones_per_block; + const amrex::Real dt = unit_test_rp::tmax / 1000.0_rt; + + std::vector reference(nstates); + std::vector hopper(nstates); + + for (int i = 0; i < nstates; ++i) { + reference[i] = make_state(); + hopper[i] = reference[i]; + reference[i].i = i; + hopper[i].i = i; + burner(reference[i], dt); + } + +#ifdef AMREX_USE_CUDA + burn_t* d_states = nullptr; + check_cuda(cudaMalloc(&d_states, nstates * sizeof(burn_t)), "cudaMalloc(d_states)"); + check_cuda(cudaMemcpy(d_states, hopper.data(), nstates * sizeof(burn_t), cudaMemcpyHostToDevice), + "cudaMemcpy H2D states"); + primordial_rodas5p_hopper::burn_device(d_states, dt, nstates); + check_cuda(cudaDeviceSynchronize(), "cudaDeviceSynchronize"); + check_cuda(cudaMemcpy(hopper.data(), d_states, nstates * sizeof(burn_t), cudaMemcpyDeviceToHost), + "cudaMemcpy D2H states"); + check_cuda(cudaFree(d_states), "cudaFree(d_states)"); +#else + amrex::Abort("Hopper prototype test requires AMREX_USE_CUDA"); +#endif + + success = 1; + for (int i = 0; i < nstates; ++i) { + if (! compare_state(reference[i], hopper[i])) { + success = 0; + } + } + + std::cout << "Hopper prototype shared bytes = " + << primordial_rodas5p_hopper::shared_bytes() << std::endl; + std::cout << "Hopper prototype compare success = " << success << std::endl; + } + + amrex::Finalize(); + + return success ? 0 : 1; +}