LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_vector_name[abi:cxx11](double const*)
inline std::string get_vector_name(const T* data)
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (
                    se.active   &&
                    se.vec_node &&
                    (se.vec_node->data() == data)
                  )
               {
                  return se.name;
               }
            }

            return "neo-vector";
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x10(%rsp)
xorl %r13d, %r13d
pushq $0x70
popq %rbp
xorl %ebx, %ebx
movq 0x8(%r15), %r12
movq 0x10(%r15), %rax
subq %r12, %rax
cqto
idivq %rbp
cmpq %rax, %rbx
jae 0x2b8649
cmpb $0x1, 0x4c(%r12,%r13)
jne 0x2b8640
movq 0x60(%r12,%r13), %rdi
testq %rdi, %rdi
je 0x2b8640
callq 0x22b516
cmpq %r14, %rax
je 0x2b8664
incq %rbx
addq $0x70, %r13
jmp 0x2b860f
leaq 0x256f7(%rip), %rsi     # 0x2ddd47
leaq 0xf(%rsp), %rdx
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x127016
jmp 0x2b8677
addq %r13, %r12
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1182f0
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_variable(double const&) const
inline variable_ptr get_variable(const T& var_ref) const
         {
            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_from_varptr(reinterpret_cast<const void*>(&var_ref));

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
xorl %ebx, %ebx
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x2b86d7
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2b86cf
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2b86cf
movq %r14, %rsi
callq 0x2b875a
testq %rax, %rax
jne 0x2b86d4
incq %r12
jmp 0x2b869d
movq %rax, %rbx
movq %rbx, %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::parser<double>::scope_element_manager::get_variable(double const&)
inline expression_node_ptr get_variable(const T& v)
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (
                    se.active   &&
                    se.var_node &&
                    details::is_variable_node(se.var_node)
                  )
               {
                  variable_node_ptr vn = reinterpret_cast<variable_node_ptr>(se.var_node);

                  if (&(vn->ref()) == (&v))
                  {
                     return se.var_node;
                  }
               }
            }

            return expression_node_ptr(0);
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x58
popq %r15
xorl %r12d, %r12d
pushq $0x70
popq %r13
movq 0x8(%r14), %rbp
movq 0x10(%r14), %rax
subq %rbp, %rax
cqto
idivq %r13
cmpq %rax, %r12
jae 0x2b8748
cmpb $0x1, -0xc(%rbp,%r15)
jne 0x2b873f
movq (%rbp,%r15), %rdi
testq %rdi, %rdi
je 0x2b873f
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x2b873f
movq (%rbp,%r15), %rax
cmpq %rbx, 0x28(%rax)
je 0x2b874a
incq %r12
addq $0x70, %r15
jmp 0x2b8702
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::get_from_varptr(void const*) const
inline type_ptr get_from_varptr(const void* ptr) const
         {
            tm_const_itr_t itr = map.begin();

            while (map.end() != itr)
            {
               type_ptr ret_ptr = itr->second.second;

               if (ptr_match<Type,RawType,type_ptr>::test(ret_ptr,ptr))
               {
                  return ret_ptr;
               }

               ++itr;
            }

            return type_ptr(0);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rax
addq $0x8, %r14
cmpq %rax, %r14
je 0x2b8785
movq 0x48(%rax), %rcx
cmpq %rbx, 0x28(%rcx)
je 0x2b8787
movq %rax, %rdi
callq 0x1184e0
jmp 0x2b876c
xorl %ecx, %ecx
movq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_size_node<double>::string_size_node(exprtk::details::expression_node<double>*)
explicit string_size_node(expression_ptr branch)
         : str_base_ptr_(0)
         {
            construct_branch_pair(branch_, branch);

            if (is_generally_string_node(branch_.first))
            {
               str_base_ptr_ = dynamic_cast<str_base_ptr>(branch_.first);
            }

            assert(valid());
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x1fb38c(%rip), %rcx    # 0x4b3fe8
movq %rcx, (%rdi)
leaq 0x1fb3d2(%rip), %rcx    # 0x4b4038
movq %rcx, 0x8(%rdi)
leaq 0x20(%rdi), %r14
movb %al, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movq %r14, %rdi
callq 0x2085be
movq 0x20(%rbx), %rdi
callq 0x20b691
testb %al, %al
je 0x2b8cb1
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2b8cab
leaq 0x196436(%rip), %rsi    # 0x44f0d0
leaq 0x1c7de7(%rip), %rdx    # 0x480a88
pushq $-0x2
popq %rcx
callq 0x118510
jmp 0x2b8cad
xorl %eax, %eax
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_string_range_node<double>::generic_string_range_node(exprtk::details::expression_node<double>*, exprtk::details::range_pack<double> const&)
generic_string_range_node(expression_ptr str_branch, const range_t& brange)
         : initialised_(false)
         , str_base_ptr_ (0)
         , str_range_ptr_(0)
         , base_range_(brange)
         {
            range_.n0_c = std::make_pair<bool,std::size_t>(true,0);
            range_.n1_c = std::make_pair<bool,std::size_t>(true,0);
            range_.cache.first  = range_.n0_c.second;
            range_.cache.second = range_.n1_c.second;

            construct_branch_pair(branch_, str_branch);

            if (is_generally_string_node(branch_.first))
            {
               str_base_ptr_ = dynamic_cast<str_base_ptr>(branch_.first);

               if (0 == str_base_ptr_)
                  return;

               str_range_ptr_ = dynamic_cast<irange_ptr>(branch_.first);

               if (0 == str_range_ptr_)
                  return;
            }

            initialised_ = (str_base_ptr_ && str_range_ptr_);
            assert(valid());
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %ebp, %ebp
movb %bpl, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x1fb2bf(%rip), %rax    # 0x4b4078
movq %rax, (%rdi)
leaq 0x1fb32d(%rip), %rax    # 0x4b40f0
movq %rax, 0x8(%rdi)
leaq 0x1fb34a(%rip), %rax    # 0x4b4118
movq %rax, 0x20(%rdi)
leaq 0x1fb377(%rip), %rax    # 0x4b4150
movq %rax, 0x28(%rdi)
movb %bpl, 0x30(%rdi)
andq $0x0, 0x38(%rdi)
movq %rsi, %r15
leaq 0x38(%rdi), %r14
movb %bpl, 0x40(%rdi)
addq $0x58, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x48(%rbx)
pushq $0xa
popq %rcx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa8(%rbx), %rdi
callq 0x252a68
leaq 0x108(%rbx), %rax
movq %rax, 0xf8(%rbx)
andq $0x0, 0x100(%rbx)
leaq 0xf8(%rbx), %r12
movb %bpl, 0x108(%rbx)
movb $0x1, %al
movb %al, 0xc8(%rbx)
andq $0x0, 0xd0(%rbx)
movb %al, 0xd8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0xe0(%rbx)
andq $0x0, 0xf0(%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2085be
movq (%r14), %rdi
callq 0x20b691
testb %al, %al
je 0x2b8ec7
leaq 0x48(%rbx), %r15
movq (%r14), %r14
testq %r14, %r14
je 0x2b8ede
leaq 0x196249(%rip), %rsi    # 0x44f0d0
leaq 0x1c7bfa(%rip), %rdx    # 0x480a88
pushq $-0x2
popq %rcx
movq %r14, %rdi
callq 0x118510
movq %rax, (%r15)
testq %rax, %rax
je 0x2b8ee2
leaq 0x196228(%rip), %rsi    # 0x44f0d0
leaq 0x1c7be9(%rip), %rdx    # 0x480a98
pushq $-0x2
popq %rcx
movq %r14, %rdi
callq 0x118510
movq %rax, 0x50(%rbx)
movb $0x1, %cl
testq %rax, %rax
jne 0x2b8ed9
jmp 0x2b8ee2
cmpq $0x0, 0x48(%rbx)
setne %al
cmpq $0x0, 0x50(%rbx)
setne %cl
andb %al, %cl
movb %cl, 0x30(%rbx)
jmp 0x2b8ee2
andq $0x0, (%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_string_range_node<double>::value() const
inline T value() const exprtk_override
         {
            branch_.first->value();

            std::size_t str_r0 = 0;
            std::size_t str_r1 = 0;

            std::size_t r0 = 0;
            std::size_t r1 = 0;

            const range_t& range = str_range_ptr_->range_ref();

            const std::size_t base_str_size = str_base_ptr_->size();

            if (
                  range      (str_r0, str_r1, base_str_size         ) &&
                  base_range_(r0    , r1    , base_str_size - str_r0)
               )
            {
               const std::size_t size = r1 - r0;

               range_.n1_c.second  = size;
               range_.cache.second = range_.n1_c.second;

               value_.assign(str_base_ptr_->base() + str_r0 + r0, size);
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x18(%rsp), %r14
andq $0x0, (%r14)
leaq 0x30(%rsp), %r15
andq $0x0, (%r15)
andq $0x0, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r12
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x22cc40
testb %al, %al
je 0x2b9021
leaq 0x58(%rbx), %rdi
movq 0x20(%rsp), %rax
subq 0x18(%rsp), %rax
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x22cc40
testb %al, %al
je 0x2b9021
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
movq %r14, 0xe0(%rbx)
movq %r14, 0xf0(%rbx)
movq 0x48(%rbx), %rdi
addq $0xf8, %rbx
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x1182b0
movsd 0x15297(%rip), %xmm0    # 0x2ce2c0
addq $0x38, %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>::settings_store::logic_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string logic_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               case details::e_and  : return "and" ;
               case details::e_or   : return "or"  ;
               case details::e_xor  : return "xor" ;
               case details::e_nand : return "nand";
               case details::e_nor  : return "nor" ;
               case details::e_xnor : return "xnor";
               case details::e_notl : return "not" ;
               default              : return ""    ;
            }
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leal -0x16(%rdx), %eax
cmpl $0x5, %eax
ja 0x2b91a0
leaq 0x19faf(%rip), %rcx     # 0x2d3138
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x24848(%rip), %rsi     # 0x2dd9e1
leaq 0xf(%rsp), %rdx
jmp 0x2b9205
cmpl $0x4b, %edx
jne 0x2b91cf
leaq 0x1a095(%rip), %rsi     # 0x2d3241
leaq 0x9(%rsp), %rdx
jmp 0x2b9205
leaq 0x1a0af(%rip), %rsi     # 0x2d3269
leaq 0xd(%rsp), %rdx
jmp 0x2b9205
leaq 0x1a063(%rip), %rsi     # 0x2d322b
leaq 0xe(%rsp), %rdx
jmp 0x2b9205
leaq 0x2f733(%rip), %rsi     # 0x2e8909
leaq 0x8(%rsp), %rdx
jmp 0x2b9205
leaq 0x1a081(%rip), %rsi     # 0x2d3265
leaq 0xb(%rsp), %rdx
jmp 0x2b9205
leaq 0x1a04a(%rip), %rsi     # 0x2d323c
leaq 0xc(%rsp), %rdx
jmp 0x2b9205
leaq 0x1a064(%rip), %rsi     # 0x2d3264
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::arith_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string arith_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               case details::e_add : return "+";
               case details::e_sub : return "-";
               case details::e_mul : return "*";
               case details::e_div : return "/";
               case details::e_mod : return "%";
               case details::e_pow : return "^";
               default             : return "" ;
            }
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addl $-0x2, %edx
cmpl $0x5, %edx
ja 0x2b92fa
leaq 0x19eb3(%rip), %rax     # 0x2d3150
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x2f27a(%rip), %rsi     # 0x2e8527
leaq 0xf(%rsp), %rdx
jmp 0x2b9306
leaq 0x1a0aa(%rip), %rsi     # 0x2d3365
leaq 0xb(%rsp), %rdx
jmp 0x2b9306
leaq 0x2e732(%rip), %rsi     # 0x2e79fb
leaq 0xd(%rsp), %rdx
jmp 0x2b9306
leaq 0x3a96b(%rip), %rsi     # 0x2f3c42
leaq 0xc(%rsp), %rdx
jmp 0x2b9306
leaq 0x1a07e(%rip), %rsi     # 0x2d3363
leaq 0xe(%rsp), %rdx
jmp 0x2b9306
leaq 0x1a074(%rip), %rsi     # 0x2d3367
leaq 0xa(%rsp), %rdx
jmp 0x2b9306
leaq 0x2f608(%rip), %rsi     # 0x2e8909
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::inequality_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string inequality_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               case details::e_lt    : return "<" ;
               case details::e_lte   : return "<=";
               case details::e_eq    : return "==";
               case details::e_equal : return "=" ;
               case details::e_ne    : return "!=";
               case details::e_nequal: return "<>";
               case details::e_gte   : return ">=";
               case details::e_gt    : return ">" ;
               default               : return ""  ;
            }
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addl $-0xe, %edx
cmpl $0x7, %edx
ja 0x2b941c
leaq 0x19dc5(%rip), %rax     # 0x2d3168
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x20f91(%rip), %rsi     # 0x2da344
leaq 0xf(%rsp), %rdx
jmp 0x2b9428
leaq 0x19fbd(%rip), %rsi     # 0x2d337e
leaq 0xb(%rsp), %rdx
jmp 0x2b9428
leaq 0x2f163(%rip), %rsi     # 0x2e8532
leaq 0xd(%rsp), %rdx
jmp 0x2b9428
leaq 0x19fa2(%rip), %rsi     # 0x2d337f
leaq 0xc(%rsp), %rdx
jmp 0x2b9428
leaq 0x19f97(%rip), %rsi     # 0x2d3382
leaq 0x8(%rsp), %rdx
jmp 0x2b9428
leaq 0x19f82(%rip), %rsi     # 0x2d337b
leaq 0xe(%rsp), %rdx
jmp 0x2b9428
leaq 0x19f7a(%rip), %rsi     # 0x2d3381
leaq 0xa(%rsp), %rdx
jmp 0x2b9428
leaq 0x19f6f(%rip), %rsi     # 0x2d3384
leaq 0x9(%rsp), %rdx
jmp 0x2b9428
leaq 0x2f4e6(%rip), %rsi     # 0x2e8909
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::return_envelope_node<double>::value() const
inline T value() const exprtk_override
         {
            try
            {
               return_invoked_ = false;
               results_context_->clear();

               return body_.first->value();
            }
            catch(const return_exception&)
            {
               return_invoked_ = true;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0x28(%rdi)
movq 0x20(%rdi), %rcx
movb %al, (%rcx)
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x118070
movb $0x1, 0x28(%rbx)
callq 0x1183d0
movsd 0x144c8(%rip), %xmm0    # 0x2ce2c0
jmp 0x2b9ddd
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::register_local_var(exprtk::details::expression_node<double>*)
inline void register_local_var(expression_ptr expr)
      {
         if (expr)
         {
            if (control_block_)
            {
               control_block_->
                  local_data_list.push_back(
                     typename expression<T>::control_block::
                        data_pack(reinterpret_cast<void*>(expr),
                                  control_block::e_expr));
            }
         }
      }

// Assembly:
testq %rsi, %rsi
je 0x2b9e6b
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2b9e6b
subq $0x18, %rsp
addq $0x10, %rdi
movq %rsp, %rax
movq %rsi, (%rax)
movl $0x1, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rax, %rsi
callq 0x2b9ef0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::register_local_data(void*, unsigned long const&, unsigned long)
inline void register_local_data(void* data, const std::size_t& size = 0, const std::size_t data_mode = 0)
      {
         if (data)
         {
            if (control_block_)
            {
               typename control_block::data_type dt = control_block::e_data;

               switch (data_mode)
               {
                  case 0 : dt = control_block::e_data;    break;
                  case 1 : dt = control_block::e_vecdata; break;
                  case 2 : dt = control_block::e_string;  break;
               }

               control_block_->
                  local_data_list.push_back(
                     typename expression<T>::control_block::
                        data_pack(reinterpret_cast<void*>(data), dt, size));
            }
         }
      }

// Assembly:
testq %rsi, %rsi
sete %al
movq (%rdi), %rdi
testq %rdi, %rdi
sete %r8b
orb %al, %r8b
jne 0x2b9ebb
subq $0x18, %rsp
xorl %eax, %eax
cmpq $0x1, %rcx
sete %al
addl $0x3, %eax
cmpq $0x2, %rcx
pushq $0x5
popq %rcx
cmovnel %eax, %ecx
addq $0x10, %rdi
movq (%rdx), %rdx
movq %rsp, %rax
movq %rsi, (%rax)
movl %ecx, 0x8(%rax)
movq %rdx, 0x10(%rax)
movq %rax, %rsi
callq 0x2b9ef0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::register_local_var(exprtk::details::vector_holder<double>*)
inline void register_local_var(vector_holder_ptr vec_holder)
      {
         if (vec_holder)
         {
            if (control_block_)
            {
               control_block_->
                  local_data_list.push_back(
                     typename expression<T>::control_block::
                        data_pack(reinterpret_cast<void*>(vec_holder),
                                  control_block::e_vecholder));
            }
         }
      }

// Assembly:
testq %rsi, %rsi
je 0x2b9eef
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x2b9eef
subq $0x18, %rsp
addq $0x10, %rdi
movq %rsp, %rax
movq %rsi, (%rax)
movl $0x2, 0x8(%rax)
andq $0x0, 0x10(%rax)
movq %rax, %rsi
callq 0x2b9ef0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool not_equal_impl<double>(double const&, double const&, double const&)
inline bool not_equal_impl(const T& t1,
                           const T& t2,
                           const T& epsilon = 0.0000000001/*std::numeric_limits<T>::epsilon()*/)
{
   if (t1 != t1) return true;
   if (t2 != t2) return true;
   T diff = std::abs(t1 - t2);
   T eps_norm = (std::max(T(1),std::max(std::abs(t1),std::abs(t2))) * epsilon);
   return diff > eps_norm;
}

// Assembly:
movsd (%rdi), %xmm0
movb $0x1, %al
ucomisd %xmm0, %xmm0
jp 0x2ba1ac
movsd (%rsi), %xmm1
ucomisd %xmm1, %xmm1
jp 0x2ba1ac
movapd %xmm0, %xmm2
subsd %xmm1, %xmm2
movapd 0x14007(%rip), %xmm3    # 0x2ce190
andpd %xmm3, %xmm2
andpd %xmm3, %xmm0
andpd %xmm3, %xmm1
maxsd %xmm0, %xmm1
maxsd 0x1401f(%rip), %xmm1    # 0x2ce1c0
mulsd (%rdx), %xmm1
ucomisd %xmm1, %xmm2
seta %al
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::control_block::destroy(exprtk::expression<double>::control_block*&)
static inline void destroy(cntrl_blck_ptr_t& cntrl_blck)
         {
            if (cntrl_blck)
            {
               if (
                    (0 !=   cntrl_blck->ref_count) &&
                    (0 == --cntrl_blck->ref_count)
                  )
               {
                  delete cntrl_blck;
               }

               cntrl_blck = 0;
            }
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2ba1e4
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x2ba1e0
decq %rax
movq %rax, (%r14)
jne 0x2ba1e0
movq %r14, %rdi
callq 0x1981bc
pushq $0x40
popq %rsi
movq %r14, %rdi
callq 0x1180d0
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: void exprtk::symbol_table<double>::control_block::destroy<exprtk::symbol_table<double>>(exprtk::symbol_table<double>::control_block*&, exprtk::symbol_table<double>*)
static inline void destroy(control_block*& cntrl_blck, SymTab* sym_tab)
         {
            if (cntrl_blck)
            {
               if (
                    (0 !=   cntrl_blck->ref_count) &&
                    (0 == --cntrl_blck->ref_count)
                  )
               {
                  if (sym_tab)
                     sym_tab->clear();

                  delete cntrl_blck;
               }

               cntrl_blck = 0;
            }
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x2ba23c
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x2ba238
decq %rax
movq %rax, (%r14)
jne 0x2ba238
testq %rsi, %rsi
je 0x2ba220
movq %rsi, %rdi
callq 0x19580a
movq (%rbx), %r14
testq %r14, %r14
je 0x2ba22a
movq %r14, %rdi
callq 0x2ba244
jmp 0x2ba22d
xorl %r14d, %r14d
pushq $0x18
popq %rsi
movq %r14, %rdi
callq 0x1180d0
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::symbol_table<double>::type_store<exprtk::details::vector_holder<double>, exprtk::details::vector_holder<double>>::add_impl<exprtk::symbol_table<double>::type_store<exprtk::details::vector_holder<double>, exprtk::details::vector_holder<double>>::tie_array, std::pair<double*, unsigned long>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::pair<double*, unsigned long>, bool)
inline bool add_impl(const std::string& symbol_name, RType t, const bool is_const)
         {
            if (symbol_name.size() > 1)
            {
               for (std::size_t i = 0; i < details::reserved_symbols_size; ++i)
               {
                  if (details::imatch(symbol_name, details::reserved_symbols[i]))
                  {
                     return false;
                  }
               }
            }

            const tm_itr_t itr = map.find(symbol_name);

            if (map.end() == itr)
            {
               map[symbol_name] = Tie::make(t,is_const);
               ++size;
            }

            return true;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x2, 0x8(%rsi)
jb 0x2ba707
xorl %esi, %esi
leaq 0x1fd0bd(%rip), %r13    # 0x4b77a0
leaq 0x20(%rsi), %r15
cmpq $0xb40, %r15            # imm = 0xB40
je 0x2ba707
addq %r13, %rsi
movq %r14, %rdi
callq 0x1fbcc5
movq %r15, %rsi
testb %al, %al
je 0x2ba6e3
xorl %r13d, %r13d
jmp 0x2ba749
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ba802
leaq 0x8(%rbx), %rcx
movb $0x1, %r13b
cmpq %rax, %rcx
jne 0x2ba749
movzbl %bpl, %edx
movq %r12, %rdi
movq (%rsp), %rsi
callq 0x2ba75c
movl %eax, %ebp
movq %rdx, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2ba796
movb %bpl, (%rax)
movq %r15, 0x8(%rax)
incq 0x30(%rbx)
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::integrate<double>(exprtk::expression<double> const&, double&, double const&, double const&, unsigned long)
inline T integrate(const expression<T>& e,
                      T& x,
                      const T& r0, const T& r1,
                      const std::size_t number_of_intervals = 1000000)
   {
      if (r0 > r1)
         return T(0);

      const T h = (r1 - r0) / (T(2) * number_of_intervals);
      T total_area = T(0);

      for (std::size_t i = 0; i < number_of_intervals; ++i)
      {
         x = r0 + T(2) * i * h;
         const T y0 = e.value(); x += h;
         const T y1 = e.value(); x += h;
         const T y2 = e.value(); x += h;
         total_area += h * (y0 + T(4) * y1 + y2) / T(3);
      }

      return total_area;
   }

// Assembly:
movsd (%rdx), %xmm0
movsd (%rcx), %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm2, %xmm0
ja 0x2bbff3
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %r8, %xmm1
punpckldq 0x12135(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x1213d(%rip), %xmm1    # 0x2ce020
subsd %xmm0, %xmm2
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
addsd %xmm0, %xmm0
divsd %xmm0, %xmm2
xorpd %xmm1, %xmm1
xorl %r13d, %r13d
movsd %xmm2, (%rsp)
cmpq %r13, %rbx
je 0x2bbfe6
movq %r13, %xmm0
punpckldq 0x120f3(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x120fb(%rip), %xmm0    # 0x2ce020
movsd %xmm1, 0x18(%rsp)
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
addsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
addsd (%r14), %xmm1
movsd %xmm1, (%r15)
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd (%r15), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%r15)
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movsd (%r15), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%r15)
movq (%r12), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd (%rsp), %xmm2
movsd (%r15), %xmm1
addsd %xmm2, %xmm1
movsd %xmm1, (%r15)
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm3
mulsd 0x122b4(%rip), %xmm3    # 0x2ce278
addsd 0x10(%rsp), %xmm3
addsd %xmm0, %xmm3
mulsd %xmm2, %xmm3
divsd 0x12206(%rip), %xmm3    # 0x2ce1e0
addsd %xmm3, %xmm1
incq %r13
jmp 0x2bbf07
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
movapd %xmm1, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::integrate<double>(exprtk::expression<double> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, double const&, unsigned long)
inline T integrate(const expression<T>& e,
                      const std::string& variable_name,
                      const T& r0, const T& r1,
                      const std::size_t number_of_intervals = 1000000)
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();

      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }

      details::variable_node<T>* var = sym_table.get_variable(variable_name);

      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = integrate(e, x, r0, r1, number_of_intervals);
         x = x_original;

         return result;
      }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x2bc060
cmpq $0x0, 0x8(%rax)
je 0x2bc060
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
callq 0x2bc076
testq %rax, %rax
je 0x2bc060
movq 0x28(%rax), %r13
movsd (%r13), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x2bbe9f
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%r13)
jmp 0x2bc068
movsd 0x12258(%rip), %xmm0    # 0x2ce2c0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::derivative<double>(exprtk::expression<double> const&, double&, double const&)
inline T derivative(const expression<T>& e,
                       T& x,
                       const T& h = T(0.00000001))
   {
      const T x_init = x;
      const T _2h    = T(2) * h;

      x = x_init + _2h;
      const T y0 = e.value();
      x = x_init + h;
      const T y1 = e.value();
      x = x_init - h;
      const T y2 = e.value();
      x = x_init - _2h;
      const T y3 = e.value();
      x = x_init;

      return (-y0 + T(8) * (y1 - y2) + y3) / (T(12) * h);
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rdx), %xmm1
addsd %xmm1, %xmm1
movsd %xmm1, 0x20(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x28(%rsp)
movsd (%rbx), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x18(%rsp), %xmm2
subsd 0x10(%rsp), %xmm2
mulsd 0x121d2(%rip), %xmm2    # 0x2ce348
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%r14)
subsd 0x28(%rsp), %xmm2
addsd %xmm2, %xmm0
movsd (%rbx), %xmm1
mulsd 0x121b9(%rip), %xmm1    # 0x2ce350
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::derivative<double>(exprtk::expression<double> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
inline T derivative(const expression<T>& e,
                       const std::string& variable_name,
                       const T& h = T(0.00000001))
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();

      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }

      details::variable_node<T>* var = sym_table.get_variable(variable_name);

      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = derivative(e, x, h);
         x = x_original;

         return result;
      }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x2bc1fb
cmpq $0x0, 0x8(%rax)
je 0x2bc1fb
movq %rdx, %rbx
callq 0x2bc076
testq %rax, %rax
je 0x2bc1fb
movq 0x28(%rax), %r15
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2bc0bb
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%r15)
jmp 0x2bc203
movsd 0x120bd(%rip), %xmm0    # 0x2ce2c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::second_derivative<double>(exprtk::expression<double> const&, double&, double const&)
inline T second_derivative(const expression<T>& e,
                              T& x,
                              const T& h = T(0.00001))
   {
      const T x_init = x;
      const T _2h    = T(2) * h;

      const T y = e.value();
      x = x_init + _2h;
      const T y0 = e.value();
      x = x_init + h;
      const T y1 = e.value();
      x = x_init - h;
      const T y2 = e.value();
      x = x_init - _2h;
      const T y3 = e.value();
      x = x_init;

      return (-y0 + T(16) * (y1 + y2) - T(30) * y - y3) / (T(12) * h * h);
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rsi), %xmm0
movsd %xmm0, (%rsp)
movsd (%rdx), %xmm0
addsd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x28(%rsp)
movsd (%rsp), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x20(%rsp)
movsd (%rbx), %xmm0
addsd (%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
movsd (%rsp), %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd (%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x10(%rsp), %xmm2
addsd 0x18(%rsp), %xmm2
mulsd 0x12079(%rip), %xmm2    # 0x2ce358
movsd (%rsp), %xmm1
movsd %xmm1, (%r14)
subsd 0x20(%rsp), %xmm2
movsd 0x28(%rsp), %xmm1
mulsd 0x12063(%rip), %xmm1    # 0x2ce360
addsd %xmm2, %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd (%rbx), %xmm2
movsd 0x1203b(%rip), %xmm1    # 0x2ce350
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::second_derivative<double>(exprtk::expression<double> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
inline T second_derivative(const expression<T>& e,
                              const std::string& variable_name,
                              const T& h = T(0.00001))
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();

      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }

      details::variable_node<T>* var = sym_table.get_variable(variable_name);

      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = second_derivative(e, x, h);
         x = x_original;

         return result;
      }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x2bc381
cmpq $0x0, 0x8(%rax)
je 0x2bc381
movq %rdx, %rbx
callq 0x2bc076
testq %rax, %rax
je 0x2bc381
movq 0x28(%rax), %r15
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2bc20d
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%r15)
jmp 0x2bc389
movsd 0x11f37(%rip), %xmm0    # 0x2ce2c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::third_derivative<double>(exprtk::expression<double> const&, double&, double const&)
inline T third_derivative(const expression<T>& e,
                             T& x,
                             const T& h = T(0.0001))
   {
      const T x_init = x;
      const T _2h    = T(2) * h;

      x = x_init + _2h;
      const T y0 = e.value();
      x = x_init + h;
      const T y1 = e.value();
      x = x_init - h;
      const T y2 = e.value();
      x = x_init - _2h;
      const T y3 = e.value();
      x = x_init;

      return (y0 + T(2) * (y2 - y1) - y3) / (T(2) * h * h * h);
   }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movsd (%rsi), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rdx), %xmm1
addsd %xmm1, %xmm1
movsd %xmm1, 0x20(%rsp)
addsd %xmm1, %xmm0
movsd %xmm0, (%rsi)
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x28(%rsp)
movsd (%rbx), %xmm0
addsd 0x8(%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
movsd 0x8(%rsp), %xmm0
subsd (%rbx), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, (%r14)
movq (%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%r14)
movsd 0x10(%rsp), %xmm1
subsd 0x18(%rsp), %xmm1
addsd %xmm1, %xmm1
addsd 0x28(%rsp), %xmm1
subsd %xmm0, %xmm1
movapd %xmm1, %xmm0
movsd (%rbx), %xmm2
movapd %xmm2, %xmm1
addsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::third_derivative<double>(exprtk::expression<double> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
inline T third_derivative(const expression<T>& e,
                             const std::string& variable_name,
                             const T& h = T(0.0001))
   {
      const symbol_table<T>& sym_table = e.get_symbol_table();

      if (!sym_table.valid())
      {
         return std::numeric_limits<T>::quiet_NaN();
      }

      details::variable_node<T>* var = sym_table.get_variable(variable_name);

      if (var)
      {
         T& x = var->ref();
         const T x_original = x;
         const T result = third_derivative(e, x, h);
         x = x_original;

         return result;
      }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
testq %rax, %rax
je 0x2bc4db
cmpq $0x0, 0x8(%rax)
je 0x2bc4db
movq %rdx, %rbx
callq 0x2bc076
testq %rax, %rax
je 0x2bc4db
movq 0x28(%rax), %r15
movsd (%r15), %xmm0
movsd %xmm0, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2bc393
movsd 0x8(%rsp), %xmm1
movsd %xmm1, (%r15)
jmp 0x2bc4e3
movsd 0x11ddd(%rip), %xmm0    # 0x2ce2c0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool run_test10<double>()::test::variable(exprtk::symbol_table<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
static inline bool variable(exprtk::symbol_table<T>& symbol_table, const std::string& variable_name, const T& value)
      {
         exprtk::details::variable_node<T>* var = symbol_table.get_variable(variable_name);

         if (var)
            return (!not_equal(var->ref(),value));
         else
            return false;
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
callq 0x2bc076
testq %rax, %rax
je 0x2bcbd8
movq 0x28(%rax), %rdi
movabsq $0x3ddb7cdfd9d7bdbb, %rax # imm = 0x3DDB7CDFD9D7BDBB
leaq 0x8(%rsp), %rdx
movq %rax, (%rdx)
movq %rbx, %rsi
callq 0x2ba163
xorb $0x1, %al
jmp 0x2bcbda
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool run_test10<double>()::test::string(exprtk::symbol_table<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline bool string(exprtk::symbol_table<T>& symbol_table, const std::string& string_name, const std::string& str)
      {
         exprtk::details::stringvar_node<T>* str_node = symbol_table.get_stringvar(string_name);

         if (str_node)
            return (str_node->ref() == str);
         else
            return false;
      }

// Assembly:
pushq %rbx
movq %rdx, %rbx
callq 0x2bd33c
testq %rax, %rax
je 0x2bcc37
movq 0x30(%rax), %rdi
movq %rbx, %rsi
popq %rbx
jmp 0x253fc9
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::parser<double>::dependent_entity_collector::symbols<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>>&)
inline std::size_t symbols(Sequence<symbol_t,Allocator>& symbols_list)
         {
            if (!collect_variables_ && !collect_functions_)
               return 0;
            else if (symbol_name_list_.empty())
               return 0;

            for (std::size_t i = 0; i < symbol_name_list_.size(); ++i)
            {
               details::case_normalise(symbol_name_list_[i].first);
            }

            std::sort(symbol_name_list_.begin(), symbol_name_list_.end());

            std::unique_copy
            (
               symbol_name_list_.begin(),
               symbol_name_list_.end  (),
               std::back_inserter(symbols_list)
            );

            return symbols_list.size();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
cmpb $0x0, 0x8(%rdi)
jne 0x2bce00
cmpb $0x1, 0x9(%r14)
jne 0x2bce40
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
cmpq %rsi, %rdi
je 0x2bce40
xorl %r15d, %r15d
pushq $0x28
popq %r12
xorl %r13d, %r13d
movq %rsi, %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x2bce4c
addq %r15, %rdi
callq 0x2be980
incq %r13
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
addq $0x28, %r15
jmp 0x2bce17
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2be9ba
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
movq %rbx, %rdx
callq 0x2be9ad
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2bceb6
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::parser<double>::dependent_entity_collector::assignment_symbols<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>>&)
inline std::size_t assignment_symbols(Sequence<symbol_t,Allocator>& assignment_list)
         {
            if (!collect_assignments_)
               return 0;
            else if (assignment_name_list_.empty())
               return 0;

            for (std::size_t i = 0; i < assignment_name_list_.size(); ++i)
            {
               details::case_normalise(assignment_name_list_[i].first);
            }

            std::sort(assignment_name_list_.begin(),assignment_name_list_.end());

            std::unique_copy
            (
               assignment_name_list_.begin(),
               assignment_name_list_.end  (),
               std::back_inserter(assignment_list)
            );

            return assignment_list.size();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
cmpb $0x1, 0xa(%rdi)
jne 0x2bcfb7
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq 0x30(%r14), %rsi
cmpq %rsi, %rdi
je 0x2bcfb7
xorl %r15d, %r15d
pushq $0x28
popq %r12
xorl %r13d, %r13d
movq %rsi, %rax
subq %rdi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x2bcfc3
addq %r15, %rdi
callq 0x2be980
incq %r13
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
addq $0x28, %r15
jmp 0x2bcf8e
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x2be9ba
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rbx, %rdx
callq 0x2be9ad
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2bceb6
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::operator=(exprtk::symbol_table<double> const&)
inline symbol_table<T>& operator=(const symbol_table<T>& st)
      {
         if (this != &st)
         {
            control_block::destroy(control_block_,reinterpret_cast<symbol_table<T>*>(0));

            control_block_ = st.control_block_;
            control_block_->ref_count++;
         }

         return (*this);
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2bd00c
movq %rsi, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2ba1ec
movq (%r14), %rax
movq %rax, (%rbx)
incq (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq