LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::const_optimise_switch<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr const_optimise_switch(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            expression_node_ptr result = error_node();

            for (std::size_t i = 0; i < (arg_list.size() / 2); ++i)
            {
               expression_node_ptr condition  = arg_list[(2 * i)    ];
               expression_node_ptr consequent = arg_list[(2 * i) + 1];

               if ((0 == result) && details::is_true(condition))
               {
                  result = consequent;
                  break;
               }
            }

            if (0 == result)
            {
               result = arg_list.back();
            }

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               expression_node_ptr current_expr = arg_list[i];

               if (current_expr && (current_expr != result))
               {
                  free_node(*node_allocator_,current_expr);
               }
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x8
popq %rax
pushq $-0x1
popq %r12
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
sarq $0x3, %rsi
shrq %rsi
incq %r12
cmpq %rsi, %r12
jae 0x28e3bb
leaq 0x10(%rax), %r13
movq -0x8(%rcx,%rax), %rdi
movq (%rcx,%rax), %r15
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3fefd(%rip), %xmm0    # 0x2ce2a8
movq %r13, %rax
jne 0x28e3b2
jnp 0x28e374
testq %r15, %r15
jne 0x28e3bf
movq 0x8(%rbx), %rdx
movq -0x8(%rdx), %r15
xorl %r13d, %r13d
leaq 0x8(%rsp), %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x28e3fe
movq (%rax,%r13,8), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x28e3f9
cmpq %r15, %rax
je 0x28e3f9
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
incq %r13
jmp 0x28e3c7
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::switch_node<double>::value() const
inline T value() const exprtk_override
         {
            const std::size_t upper_bound = (arg_list_.size() - 1);

            for (std::size_t i = 0; i < upper_bound; i += 2)
            {
               expression_ptr condition  = arg_list_[i    ].first;
               expression_ptr consequent = arg_list_[i + 1].first;

               if (is_true(condition))
               {
                  return consequent->value();
               }
            }

            return arg_list_[upper_bound].first->value();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r15
subq 0x20(%rdi), %r15
sarq $0x4, %r15
decq %r15
pushq $0x10
popq %rax
pushq $-0x2
popq %r12
movq 0x20(%rbx), %rcx
addq $0x2, %r12
cmpq %r15, %r12
jae 0x28e76b
leaq 0x20(%rax), %r13
movq -0x10(%rcx,%rax), %rdi
movq (%rcx,%rax), %r14
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3fb46(%rip), %xmm0    # 0x2ce2a8
movq %r13, %rax
jne 0x28e773
jnp 0x28e73a
jmp 0x28e773
shlq $0x4, %r15
movq (%rcx,%r15), %r14
movq (%r14), %rax
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_3::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2)

                  assert(arg.size() == ((2 * 3) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28e8fd
jnp 0x28e903
addq $0x10, %rax
jmp 0x28e949
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f993(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28e91c
jnp 0x28e922
addq $0x30, %rax
jmp 0x28e949
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x28e938
jnp 0x28e941
movq (%rbx), %rax
addq $0x50, %rax
jmp 0x28e949
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_4::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)

                  assert(arg.size() == ((2 * 4) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28e9c7
jnp 0x28e9cd
addq $0x10, %rax
jmp 0x28ea32
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f8c9(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28e9e6
jnp 0x28e9ec
addq $0x30, %rax
jmp 0x28ea32
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ea05
jnp 0x28ea0b
addq $0x50, %rax
jmp 0x28ea32
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f88b(%rip), %xmm0    # 0x2ce2a8
jne 0x28ea21
jnp 0x28ea2a
movq (%rbx), %rax
addq $0x70, %rax
jmp 0x28ea32
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_5::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4)

                  assert(arg.size() == ((2 * 5) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28eaaf
jnp 0x28eab8
addq $0x10, %rax
jmp 0x28eb40
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f7de(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28ead1
jnp 0x28ead7
addq $0x30, %rax
jmp 0x28eb40
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28eaf0
jnp 0x28eaf6
addq $0x50, %rax
jmp 0x28eb40
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f7a0(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28eb0f
jnp 0x28eb15
addq $0x70, %rax
jmp 0x28eb40
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x28eb2e
jnp 0x28eb38
movl $0x90, %eax
addq (%rbx), %rax
jmp 0x28eb40
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_6::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4) case_stmt(5)

                  assert(arg.size() == ((2 * 6) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ebbd
jnp 0x28ebc6
addq $0x10, %rax
jmp 0x28ec75
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f6d0(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28ebdf
jnp 0x28ebe8
addq $0x30, %rax
jmp 0x28ec75
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ec01
jnp 0x28ec07
addq $0x50, %rax
jmp 0x28ec75
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f68f(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28ec20
jnp 0x28ec26
addq $0x70, %rax
jmp 0x28ec75
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ec42
jnp 0x28ec4a
addq $0x90, %rax
jmp 0x28ec75
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f649(%rip), %xmm0    # 0x2ce2a8
jne 0x28ec63
jnp 0x28ec6d
movl $0xb0, %eax
addq (%rbx), %rax
jmp 0x28ec75
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_7::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4) case_stmt(5)
                  case_stmt(6)

                  assert(arg.size() == ((2 * 7) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ed11
jnp 0x28ed1a
addq $0x10, %rax
jmp 0x28edf0
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f57c(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28ed33
jnp 0x28ed3c
addq $0x30, %rax
jmp 0x28edf0
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ed55
jnp 0x28ed5e
addq $0x50, %rax
jmp 0x28edf0
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f538(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28ed77
jnp 0x28ed7d
addq $0x70, %rax
jmp 0x28edf0
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x28ed99
jnp 0x28eda1
addq $0x90, %rax
jmp 0x28edf0
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x3f4f2(%rip), %xmm0    # 0x2ce2a8
movq (%rbx), %rax
jne 0x28edbd
jnp 0x28edc5
addq $0xb0, %rax
jmp 0x28edf0
movq 0xc0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x28edde
jnp 0x28ede8
movl $0xd0, %eax
addq (%rbx), %rax
jmp 0x28edf0
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::all_nodes_variables<3ul, double>(exprtk::details::expression_node<double>* const (&) [3ul])
inline bool all_nodes_variables(expression_node<T>* const (&b)[N])
      {
         for (std::size_t i = 0; i < N; ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }

         return true;
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %ecx, %ecx
movq %rcx, %r14
cmpq $0x3, %rcx
je 0x28fd87
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x28fd87
movq (%rdi), %rax
callq *0x28(%rax)
leaq 0x1(%r14), %rcx
cmpl $0x11, %eax
je 0x28fd66
cmpq $0x3, %r14
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sf4_var_node<double, exprtk::details::sf48_op<double>>::value_type>* exprtk::details::node_allocator::allocate_rrrr<exprtk::details::sf4_var_node<double, exprtk::details::sf48_op<double>>, double const, double const, double const, double const>(double const&, double const&, double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_rrrr(T1& t1, T2& t2, T3& t3, T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
pushq $0x40
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x2187de(%rip), %rcx    # 0x4ae300
movq %rcx, (%rax)
leaq 0x21881c(%rip), %rcx    # 0x4ae348
movq %rcx, 0x8(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sf4_node<double, exprtk::details::sf87_op<double>>::value() const
inline T value() const exprtk_override
         {
            const T x = quaternary_node<T>::branch_[0].first->value();
            const T y = quaternary_node<T>::branch_[1].first->value();
            const T z = quaternary_node<T>::branch_[2].first->value();
            const T w = quaternary_node<T>::branch_[3].first->value();

            return SpecialFunction::process(x, y, z, w);
         }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x20(%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, (%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x10(%rsp)
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd (%rsp), %xmm1
unpcklpd %xmm0, %xmm1            # xmm1 = xmm1[0],xmm0[0]
movapd %xmm1, %xmm0
mulpd %xmm1, %xmm0
mulpd %xmm0, %xmm0
mulpd %xmm1, %xmm0
movapd 0x20(%rsp), %xmm1
unpcklpd 0x10(%rsp), %xmm1       # xmm1 = xmm1[0],mem[0]
mulpd %xmm0, %xmm1
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::break_node<double>::value() const
inline T value() const exprtk_override
         {
            const T result = return_.first ?
                             return_.first->value() :
                             std::numeric_limits<T>::quiet_NaN();

            throw break_exception<T>(result);

            #if !defined(_MSC_VER) && !defined(__NVCOMPILER)
            return std::numeric_limits<T>::quiet_NaN();
            #endif
         }

// Assembly:
pushq %rax
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
jne 0x29b23c
movsd 0x33086(%rip), %xmm0    # 0x2ce2c0
jmp 0x29b242
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
pushq $0x8
popq %rdi
callq 0x1181f0
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
leaq 0x20f271(%rip), %rsi    # 0x4aa4d0
movq %rax, %rdi
xorl %edx, %edx
callq 0x118330
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_reserved_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_reserved_symbol(const std::string& symbol)
      {
         for (std::size_t i = 0; i < reserved_symbols_size; ++i)
         {
            if (imatch(symbol, reserved_symbols[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x21c4a0(%rip), %r14    # 0x4b77a0
xorl %ecx, %ecx
movq %rcx, %r15
cmpq $0x59, %rcx
je 0x29b322
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fbcc5
leaq 0x1(%r15), %rcx
addq $0x20, %r14
testb %al, %al
je 0x29b302
cmpq $0x59, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::symbol_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool symbol_exists(const std::string& symbol) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

               if (symtab_list_[i].symbol_exists(symbol))
               {
                  return true;
               }
            }

            return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x1
popq %rbp
xorl %r12d, %r12d
movq (%r14), %rdi
movq 0x8(%r14), %r13
subq %rdi, %r13
sarq $0x3, %r13
cmpq %r13, %r12
jae 0x29b387
movq (%rdi,%r15), %rax
testq %rax, %rax
je 0x29b37e
cmpq $0x0, 0x8(%rax)
je 0x29b37e
addq %r15, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x1965c8
testb %al, %al
jne 0x29b387
incq %r12
addq $0x8, %r15
jmp 0x29b34a
cmpq %r13, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_active_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_active_element(const std::string& var_name,
                                                  const std::size_t index = std::numeric_limits<std::size_t>::max())
         {
            const std::size_t current_depth = parser_.state_.scope_depth;

            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (se.depth > current_depth)
                  continue;
               else if (
                         details::imatch(se.name, var_name) &&
                         (se.index == index)                &&
                         (se.active)
                       )
                  return se;
            }

            return null_element_;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdi, %r8
movq (%rdi), %rax
movq 0x3b0(%rax), %r13
xorl %r15d, %r15d
pushq $0x70
popq %rbx
xorl %ebp, %ebp
movq %rdi, 0x18(%rsp)
movq 0x8(%r8), %r14
movq 0x10(%r8), %rax
subq %r14, %rax
cqto
idivq %rbx
movq %rax, %r12
cmpq %r12, %rbp
jae 0x29dd2d
cmpq %r13, 0x30(%r14,%r15)
ja 0x29dd1f
leaq (%r14,%r15), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x1fbcc5
movq 0x18(%rsp), %r8
testb %al, %al
je 0x29dd1f
movq 0x8(%rsp), %rax
cmpq %rax, 0x28(%r14,%r15)
jne 0x29dd1f
cmpb $0x0, 0x4c(%r14,%r15)
jne 0x29dd28
incq %rbp
addq $0x70, %r15
jmp 0x29dcd0
movq 0x10(%rsp), %rax
addq $0x20, %r8
cmpq %r12, %rbp
cmovbq %rax, %r8
movq %r8, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_vector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_vector(const std::string& vector_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         local_data(i).vector_store
                           .symbol_exists(vector_name)
                       )
                  return true;
            }

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %r12
subq %rax, %r12
sarq $0x3, %r12
cmpq %r12, %r15
jae 0x29dd98
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x29dd93
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x29dd93
addq $0x150, %rdi            # imm = 0x150
movq %rbx, %rsi
callq 0x1967a8
testb %al, %al
jne 0x29dd98
incq %r15
jmp 0x29dd5b
cmpq %r12, %r15
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is(exprtk::lexer::token::token_type const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is(const token_t::token_type& ttype,
                              const std::string& value,
                              const token_advance_mode mode = e_advance)
         {
            if (
                 (current_token().type != ttype) ||
                 !exprtk::details::imatch(value,current_token().value)
               )
            {
               return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
movl 0x70(%rdi), %eax
cmpl (%rsi), %eax
jne 0x29ddd8
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdi, %r14
leaq 0x78(%rdi), %rsi
movq %rdx, %rdi
callq 0x1fbcc5
testb %al, %al
je 0x29dddb
movq %r14, %rdi
movl %ebx, %esi
callq 0x28ba3e
movb $0x1, %al
jmp 0x29dddd
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&) const
std::size_t compute_node_depth(const Sequence<node_ptr_t, Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i])
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i]));
                  }
               }

               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x29e365
movq %rsi, %r14
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14), %rsi
movq 0x8(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0x29e361
cmpq $0x0, (%rsi,%r15)
je 0x29e358
addq %r15, %rsi
movq %rbx, %rdi
callq 0x20899a
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
cmovaq %rcx, %rax
movq %rax, 0x10(%rbx)
incq %r12
addq $0x8, %r15
jmp 0x29e324
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_constvalue_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 1) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (single_initialiser_value_ != T(0));
         }

// Assembly:
cmpq $0x0, 0x20(%rdi)
je 0x29e484
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x8, %rcx
jne 0x29e480
movq (%rax), %rdi
callq 0x208267
testb %al, %al
je 0x29e480
xorpd %xmm0, %xmm0
cmpneqsd 0x48(%rbx), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0x29e482
xorl %eax, %eax
popq %rbx
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_value_node<double>::value() const
inline T value() const exprtk_override
         {
            expression_node<T>& node = *initialiser_list_[0];

            for (std::size_t i = 0; i < size_; ++i)
            {
               *(vector_base_ + i) = node.value();
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %r14
xorl %r15d, %r15d
cmpq 0x28(%rbx), %r15
jae 0x29e554
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r15,8)
incq %r15
jmp 0x29e536
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;

            for (std::size_t i = 0; i < size_; ++i, value += increment_value_)
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
movsd 0x48(%rdi), %xmm0
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jae 0x29e69d
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
addsd 0x50(%rdi), %xmm0
jmp 0x29e689
movsd (%rax), %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 2) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (details::is_constant_node(initialiser_list_[1])) ;
         }

// Assembly:
pushq %rbx
cmpq $0x0, 0x20(%rdi)
je 0x29e6de
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq 0x38(%rdi), %rcx
subq %rax, %rcx
cmpq $0x10, %rcx
jne 0x29e6de
movq (%rax), %rdi
callq 0x208267
testb %al, %al
je 0x29e6de
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdi
popq %rbx
jmp 0x208267
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;
            expression_node<T>& increment = *initialiser_list_[1];

            for (std::size_t i = 0; i < size_; ++i, value += increment.value())
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsd 0x48(%rdi), %xmm0
movq 0x30(%rdi), %rax
movq 0x8(%rax), %r14
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %r15
jae 0x29e80a
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rax
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
jmp 0x29e7d0
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            const T increment = initialiser_list_[1]->value();

            for (std::size_t i = 0; i < size_; ++i, value += increment)
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
movq 0x20(%rbx), %rax
movq 0x28(%rbx), %rcx
xorl %edx, %edx
cmpq %rcx, %rdx
jae 0x29e946
movsd %xmm1, (%rax,%rdx,8)
incq %rdx
addsd %xmm0, %xmm1
jmp 0x29e933
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            expression_node<T>& increment = *initialiser_list_[1];

            for (std::size_t i = 0; i < size_; ++i, value += increment.value())
            {
               *(vector_base_ + i) = value;
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rax
movq 0x8(%rax), %r14
xorl %r15d, %r15d
movq 0x20(%rbx), %rax
cmpq 0x28(%rbx), %r15
jae 0x29ea8a
movsd %xmm0, (%rax,%r15,8)
incq %r15
movq (%r14), %rax
movq %r14, %rdi
movsd %xmm0, 0x8(%rsp)
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
addsd %xmm0, %xmm1
movsd %xmm1, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
jmp 0x29ea50
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_initialisation_node<double>::vector_initialisation_node(double*, unsigned long const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&, bool)
vector_initialisation_node(T* vector_base,
                                    const std::size_t& size,
                                    const std::vector<expression_ptr>& initialiser_list,
                                    const bool single_value_initialse)
         : vector_base_(vector_base)
         , initialiser_list_(initialiser_list)
         , size_(size)
         , single_value_initialse_(single_value_initialse)
         , zero_value_initialse_(false)
         , const_nonzero_literal_value_initialse_(false)
         , single_initialiser_value_(T(0))
         {
            if (single_value_initialse_)
            {
               if (initialiser_list_.empty())
                  zero_value_initialse_ = true;
               else if (
                         (initialiser_list_.size() == 1) &&
                         details::is_constant_node(initialiser_list_[0]) &&
                         (T(0) == initialiser_list_[0]->value())
                       )
               {
                  zero_value_initialse_ = true;
               }
               else
               {
                  assert(initialiser_list_.size() == 1);

                  if (details::is_constant_node(initialiser_list_[0]))
                  {
                     const_nonzero_literal_value_initialse_ = true;
                     single_initialiser_value_ = initialiser_list_[0]->value();
                     assert(T(0) != single_initialiser_value_);
                  }
               }
            }
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rdx, %r15
leaq 0x2134e2(%rip), %rax    # 0x4b20e8
movq %rax, (%rdi)
leaq 0x213528(%rip), %rax    # 0x4b2138
movq %rax, 0x8(%rdi)
movq %rsi, 0x20(%rdi)
leaq 0x28(%rdi), %r14
movq %r14, %rdi
movq %rcx, %rsi
callq 0x29e17e
movq (%r15), %rax
movq %rax, 0x40(%rbx)
movb %bpl, 0x48(%rbx)
andw $0x0, 0x49(%rbx)
andq $0x0, 0x50(%rbx)
testl %ebp, %ebp
je 0x29eca5
movq 0x28(%rbx), %rcx
movq 0x30(%rbx), %rax
cmpq %rax, %rcx
je 0x29ec7a
subq %rcx, %rax
cmpq $0x8, %rax
jne 0x29ec83
movq (%rcx), %rdi
callq 0x208267
movq (%r14), %rcx
testb %al, %al
je 0x29ec83
movq (%rcx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x29ec80
jp 0x29ec80
movb $0x1, 0x49(%rbx)
jmp 0x29eca5
movq (%r14), %rcx
movq (%rcx), %rdi
callq 0x208267
testb %al, %al
je 0x29eca5
movb $0x1, 0x4a(%rbx)
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x50(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x29e264
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_initialisation_node<double>::value() const
inline T value() const exprtk_override
         {
            if (single_value_initialse_)
            {
               if (zero_value_initialse_)
               {
                  details::set_zero_value(vector_base_, size_);
               }
               else if (const_nonzero_literal_value_initialse_)
               {
                  for (std::size_t i = 0; i < size_; ++i)
                  {
                     *(vector_base_ + i) = single_initialiser_value_;
                  }
               }
               else
               {
                  for (std::size_t i = 0; i < size_; ++i)
                  {
                     *(vector_base_ + i) = initialiser_list_[0]->value();
                  }
               }
            }
            else
            {
               const std::size_t initialiser_list_size = initialiser_list_.size();

               for (std::size_t i = 0; i < initialiser_list_size; ++i)
               {
                  *(vector_base_ + i) = initialiser_list_[i]->value();
               }

               if (initialiser_list_size < size_)
               {
                  details::set_zero_value(
                     vector_base_ + initialiser_list_size,
                     (size_ - initialiser_list_size));
               }
            }

            return *(vector_base_);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, 0x48(%rdi)
jne 0x29ed1d
cmpb $0x1, 0x49(%rbx)
jne 0x29ed80
movq 0x20(%rbx), %r14
movq 0x40(%rbx), %rdx
jmp 0x29ed5e
movq 0x30(%rbx), %r14
subq 0x28(%rbx), %r14
movq %r14, %r15
sarq $0x3, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x29ed51
movq 0x28(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r12,8)
incq %r12
jmp 0x29ed2f
movq 0x40(%rbx), %rdx
subq %r15, %rdx
jbe 0x29ed6c
addq 0x20(%rbx), %r14
shlq $0x3, %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x118180
movq 0x20(%rbx), %rax
movsd (%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
cmpb $0x0, 0x4a(%rbx)
je 0x29eda4
movq 0x20(%rbx), %rax
movq 0x40(%rbx), %rcx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x29ed6c
movsd 0x50(%rbx), %xmm0
movsd %xmm0, (%rax,%rdx,8)
incq %rdx
jmp 0x29ed90
xorl %r14d, %r14d
cmpq 0x40(%rbx), %r14
jae 0x29ed6c
movq 0x28(%rbx), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rbx), %rax
movsd %xmm0, (%rax,%r14,8)
incq %r14
jmp 0x29eda7
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::stringvar_node<double>::stringvar_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
explicit stringvar_node(std::string& v)
         : value_(&v)
         {
            rp_.n0_c = std::make_pair<bool,std::size_t>(true,0);
            rp_.n1_c = std::make_pair<bool,std::size_t>(true,v.size());
            rp_.cache.first  = rp_.n0_c.second;
            rp_.cache.second = rp_.n1_c.second;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movq %rsi, %r14
leaq 0x213356(%rip), %rax    # 0x4b2178
movq %rax, (%rdi)
leaq 0x2133bc(%rip), %rax    # 0x4b21e8
movq %rax, 0x8(%rdi)
leaq 0x2133d9(%rip), %rax    # 0x4b2210
movq %rax, 0x20(%rdi)
leaq 0x213406(%rip), %rax    # 0x4b2248
movq %rax, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
addq $0x38, %rdi
callq 0x252a68
movb $0x1, %al
movb %al, 0x58(%rbx)
andq $0x0, 0x60(%rbx)
movq 0x8(%r14), %rcx
movb %al, 0x68(%rbx)
movq %rcx, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
movq %rcx, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline variable_ptr get_variable(const std::string& variable_name) const
         {
            if (!valid_symbol(variable_name))
               return reinterpret_cast<variable_ptr>(0);

            variable_ptr result = reinterpret_cast<variable_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .variable_store.get(variable_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x29f872
xorl %ebx, %ebx
testb %al, %al
je 0x29f256
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x29f256
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x29f24e
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x29f24e
movq %r14, %rsi
callq 0x2a1894
testq %rax, %rax
jne 0x29f253
incq %r12
jmp 0x29f21c
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_vector_context(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline vector_context get_vector_context(const std::string& vector_name) const
         {
            vector_context result;
            if (!valid_symbol(vector_name))
               return result;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

               result.vector_holder = local_data(i).vector_store.get(vector_name);

               if (result.vector_holder)
               {
                  result.symbol_table = &symtab_list_[i];
                  break;
               }
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x29f872
xorl %ebx, %ebx
testb %al, %al
je 0x29f2c8
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x29f2c8
movq (%rax,%r15), %rax
testq %rax, %rax
je 0x29f2bf
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x29f2bf
addq $0x150, %rdi            # imm = 0x150
movq %r12, %rsi
callq 0x29f88a
testq %rax, %rax
jne 0x29f2db
incq %r13
addq $0x8, %r15
jmp 0x29f286
xorl %r15d, %r15d
movq %r15, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq (%r14), %r15
movq %rax, %rbx
jmp 0x29f2cb
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::valid_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool valid_symbol(const std::string& symbol) const
         {
            if (!symtab_list_.empty())
               return symtab_list_[0].valid_symbol(symbol);
            else
               return false;
         }

// Assembly:
movq %rdi, %rax
movq (%rdi), %rdi
cmpq 0x8(%rax), %rdi
je 0x29f886
pushq $0x1
popq %rdx
jmp 0x196536
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::vector_holder<double>, exprtk::details::vector_holder<double>>::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline type_ptr get(const std::string& symbol_name) const
         {
            const tm_const_itr_t itr = map.find(symbol_name);

            if (map.end() == itr)
               return reinterpret_cast<type_ptr>(0);
            else
               return itr->second.second;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x196978
addq $0x8, %rbx
cmpq %rax, %rbx
je 0x29f8a2
movq 0x48(%rax), %rax
jmp 0x29f8a4
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::interval_container_t<void const*, exprtk::parser<double>::halfopen_range_policy<void const*>>::add_interval(void const*, void const*)
bool add_interval(const interval_point_t begin, const interval_point_t end)
         {
            if ((end <= begin) || in_interval(begin) || in_interval(end))
            {
               return false;
            }

            interval_map_[end] = std::make_pair(begin, end);

            return true;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, 0x8(%rsp)
cmpq %rsi, %rdx
jbe 0x29f940
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x29f964
testb %al, %al
jne 0x29f940
movq %r15, %rdi
movq %rbx, %rsi
callq 0x29f964
testb %al, %al
je 0x29f94c
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x29f97c
movq %r14, (%rax)
movq %rbx, 0x8(%rax)
movb $0x1, %al
jmp 0x29f942
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_celem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_     &&
               vector_node_.first &&
               vector_node_.first->valid();
         }

// Assembly:
cmpq $0x0, 0x30(%rdi)
je 0x2a0f96
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x2a0f96
movq (%rdi), %rax
jmpq *0x30(%rax)
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_elem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_        &&
               index_.first          &&
               vector_node_.first    &&
               index_.first->valid() &&
               vector_node_.first->valid();
         }

// Assembly:
pushq %rbx
cmpq $0x0, 0x28(%rdi)
je 0x2a1426
movq %rdi, %rbx
movq 0x40(%rdi), %rdi
testq %rdi, %rdi
je 0x2a1426
cmpq $0x0, 0x30(%rbx)
je 0x2a1426
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2a1426
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_function_node<double, exprtk::details::null_igenfunc<double>>::~generic_function_node()
virtual ~generic_function_node()
         {
            for (std::size_t i = 0; i < vv_list_.size(); ++i)
            {
               vecview_t& vv = vv_list_[i];
               if (vv && typestore_list_[i].vec_data)
               {
                  vv->remove_ref(&typestore_list_[i].vec_data);
                  typestore_list_[i].vec_data = 0;
               }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x210973(%rip), %rax    # 0x4b2b80
movq %rax, (%rdi)
leaq 0x2109c9(%rip), %rax    # 0x4b2be0
movq %rax, 0x8(%rdi)
leaq 0x70(%rdi), %r15
leaq 0x28(%rdi), %r14
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x70(%rbx), %rax
movq 0x78(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x2a2269
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x2a2260
movq (%r14), %rsi
cmpq $0x0, (%rsi,%r12)
je 0x2a2260
addq %r12, %rsi
callq 0x2a251e
movq (%r14), %rax
andq $0x0, (%rax,%r12)
incq %r13
addq $0x18, %r12
jmp 0x2a2229
leaq 0xb8(%rbx), %rdi
callq 0x1f579a
leaq 0xa0(%rbx), %rdi
callq 0x2a267a
leaq 0x88(%rbx), %rdi
callq 0x2a26b6
movq %r15, %rdi
callq 0x2a26ea
leaq 0x58(%rbx), %rdi
callq 0x208898
addq $0x40, %rbx
movq %rbx, %rdi
callq 0x29e264
movq %r14, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x198da8
movq %rax, %rdi
callq 0x193e66
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::return_node<double>::value() const
inline T value() const exprtk_override
         {
            if (gen_function_t::populate_value_list())
            {
               typedef typename type_store<T>::parameter_list parameter_list_t;

               results_context_->
                  assign(parameter_list_t(gen_function_t::typestore_list_));

               throw return_exception();
            }

            return std::numeric_limits<T>::quiet_NaN();
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x2a2360
testb %al, %al
jne 0x2a230f
movsd 0x2bfb7(%rip), %xmm0    # 0x2ce2c0
addq $0x10, %rsp
popq %rbx
retq
movq 0xd0(%rbx), %rdi
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x2a271e
pushq $0x1
popq %rdi
callq 0x1181f0
leaq 0x2108c2(%rip), %rsi    # 0x4b2bf8
movq %rax, %rdi
xorl %edx, %edx
callq 0x118330
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::remove_ref(double**)
void remove_ref(data_ptr_t* data_ref)
      {
         data_ref_.erase(
            std::remove(data_ref_.begin(), data_ref_.end(), data_ref),
            data_ref_.end());
         exprtk_debug(("vector_view::remove_ref() - data_ref: %p data_ref_.size(): %d\n",
                       reinterpret_cast<void*>(data_ref),
                       static_cast<int>(data_ref_.size())));
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsp, %rdx
movq %rsi, (%rdx)
leaq 0x18(%rdi), %r14
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x2a25a8
movq 0x20(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a2554
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop