LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x235e40
movq 0x20(%rsp), %rdi
leaq 0x2788df(%rip), %rax    # 0x7cfe98
movq %rax, (%rdi)
leaq 0x278925(%rip), %rax    # 0x7cfee8
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
callq 0x39dfb0
jmp 0x5575d2
movq 0x20(%rsp), %rdi
movq $0x0, 0x30(%rdi)
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
callq 0x39d4f0
jmp 0x5575ef
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x3a7600
movb %al, 0x1f(%rsp)
jmp 0x557603
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x55760d
jmp 0x557678
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x557661
movq 0x10(%rsp), %rdi
leaq 0x212bb3(%rip), %rsi    # 0x76a1e0
leaq 0x244e6c(%rip), %rdx    # 0x79c4a0
movq $-0x2, %rcx
callq 0x11b6d0
movq %rax, 0x8(%rsp)
jmp 0x55766a
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x236080
jmp 0x55767d
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x55766a
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x30(%rax)
addq $0x48, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdx
leaq 0x30(%rsp), %rcx
callq 0x3eebb0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x557d74
jmp 0x557da4
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
movq 0x30(%rsp), %rax
subq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0x3eebb0
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x557dae
jmp 0x557e11
movq 0x10(%rsp), %rax
movq 0x40(%rsp), %rcx
subq 0x48(%rsp), %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0xe0(%rax)
movq 0xe0(%rax), %rcx
movq %rcx, 0xf0(%rax)
movq %rax, %rcx
addq $0xf8, %rcx
movq %rcx, 0x8(%rsp)
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq 0x58(%rsp), %rsi
addq 0x48(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x11b410
callq 0x2361c0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::logic_disabled(exprtk::details::operator_type) const
bool logic_disabled(const details::operator_type logic_operation) const
         {
            if (disabled_logic_set_.empty())
               return false;
            else
               return disabled_logic_set_.end() != disabled_logic_set_
                                                           .find(logic_opr_to_string(logic_operation));
         }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x70, %rdi
callq 0x399140
testb $0x1, %al
jne 0x5580f6
jmp 0x558100
movb $0x0, 0x77(%rsp)
jmp 0x558189
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
movq %rdi, (%rsp)
callq 0x256550
movq 0x18(%rsp), %rsi
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x5581a0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x399160
movq %rax, 0x10(%rsp)
jmp 0x558144
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2343f0
andb $0x1, %al
movb %al, 0x77(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x558189
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x558194
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::arithmetic_disabled(exprtk::details::operator_type) const
bool arithmetic_disabled(const details::operator_type arithmetic_operation) const
         {
            if (disabled_arithmetic_set_.empty())
               return false;
            else
               return disabled_arithmetic_set_.end() != disabled_arithmetic_set_
                                                           .find(arith_opr_to_string(arithmetic_operation));
         }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0xa0, %rdi
callq 0x399140
testb $0x1, %al
jne 0x5584c9
jmp 0x5584d3
movb $0x0, 0x77(%rsp)
jmp 0x55855f
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
movq %rdi, (%rsp)
callq 0x256550
movq 0x18(%rsp), %rsi
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x558580
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x399160
movq %rax, 0x10(%rsp)
jmp 0x55851a
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2343f0
andb $0x1, %al
movb %al, 0x77(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x55855f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x55856a
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::inequality_disabled(exprtk::details::operator_type const&) const
bool inequality_disabled(const details::operator_type& inequality) const
         {
            if (disabled_inequality_set_.empty())
               return false;
            else
               return disabled_inequality_set_.end() != disabled_inequality_set_
                                                           .find(inequality_opr_to_string(inequality));
         }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0x100, %rdi            # imm = 0x100
callq 0x399140
testb $0x1, %al
jne 0x55885a
jmp 0x558864
movb $0x0, 0x77(%rsp)
jmp 0x5588f3
movq 0x18(%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq %rdi, (%rsp)
callq 0x256550
movq 0x18(%rsp), %rsi
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x558910
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x399160
movq %rax, 0x10(%rsp)
jmp 0x5588ae
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2343f0
andb $0x1, %al
movb %al, 0x77(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x5588f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x5588fe
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::assignment_disabled(exprtk::details::operator_type) const
bool assignment_disabled(const details::operator_type assignment_operation) const
         {
            if (disabled_assignment_set_.empty())
               return false;
            else
               return disabled_assignment_set_.end() != disabled_assignment_set_
                                                           .find(assign_opr_to_string(assignment_operation));
         }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movl %esi, 0x64(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0xd0, %rdi
callq 0x399140
testb $0x1, %al
jne 0x558c99
jmp 0x558ca3
movb $0x0, 0x77(%rsp)
jmp 0x558d2f
movq 0x18(%rsp), %rdi
addq $0xd0, %rdi
movq %rdi, (%rsp)
callq 0x256550
movq 0x18(%rsp), %rsi
movq %rax, 0x58(%rsp)
movl 0x64(%rsp), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3f3130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x399160
movq %rax, 0x10(%rsp)
jmp 0x558cea
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x2343f0
andb $0x1, %al
movb %al, 0x77(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x558d2f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x558d3a
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x28(%rax)
movq 0x20(%rax), %rdi
callq 0x55bd60
jmp 0x55bc02
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movsd %xmm0, (%rsp)
jmp 0x55bc1b
movsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x55bc6e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x55bc79
movq 0x20(%rsp), %rdi
callq 0x11b0a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movb $0x1, 0x28(%rax)
callq 0x2361c0
movsd %xmm0, 0x30(%rsp)
callq 0x11b560
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x55be63
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55be61
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movl $0x1, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x55bfe0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x55bfb0
jmp 0x55be63
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x55bf37
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55bf35
movl $0x3, 0x34(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0x55bee0
jmp 0x55bec6
movq 0x8(%rsp), %rax
subq $0x1, %rax
je 0x55beea
jmp 0x55bed3
movq 0x8(%rsp), %rax
subq $0x2, %rax
je 0x55bef4
jmp 0x55befc
movl $0x3, 0x34(%rsp)
jmp 0x55befc
movl $0x4, 0x34(%rsp)
jmp 0x55befc
movl $0x5, 0x34(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x40(%rsp), %rax
movq (%rax), %rcx
leaq 0x18(%rsp), %rdi
callq 0x55bfe0
movq (%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x55bfb0
jmp 0x55bf37
addq $0x58, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x55bfa3
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55bfa1
movq 0x8(%rsp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movl $0x2, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x55bfe0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x55bfb0
jmp 0x55bfa3
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movq 0x38(%rsp), %rax
ucomisd (%rax), %xmm0
jne 0x55cb5b
jp 0x55cb5b
jmp 0x55cb65
movb $0x1, 0x47(%rsp)
jmp 0x55cc1b
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
ucomisd (%rax), %xmm0
jne 0x55cb7d
jp 0x55cb7d
jmp 0x55cb87
movb $0x1, 0x47(%rsp)
jmp 0x55cc1b
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movq 0x30(%rsp), %rax
subsd (%rax), %xmm0
callq 0x265900
movsd %xmm0, 0x20(%rsp)
movsd 0x3e494(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x10(%rsp)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
callq 0x265900
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
callq 0x265900
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
movq %rsp, %rsi
callq 0x3a55d0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x3a55d0
movsd (%rax), %xmm0
movq 0x28(%rsp), %rax
mulsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x20(%rsp), %xmm0
ucomisd 0x18(%rsp), %xmm0
seta %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55cca6
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x55cc9a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x55cc9a
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x55cc98
movq 0x8(%rsp), %rdi
callq 0x23c540
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x11b130
jmp 0x55cc9a
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x55cd3a
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x55cd2e
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x55cd2e
cmpq $0x0, 0x8(%rsp)
je 0x55cd03
movq 0x8(%rsp), %rdi
callq 0x22fd50
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x55cd2c
movq (%rsp), %rdi
callq 0x55cd40
movq (%rsp), %rdi
movl $0x18, %esi
callq 0x11b130
jmp 0x55cd2e
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::symbol_table<double>::add_vector<6ul>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double (&) [6ul])
inline bool add_vector(const std::string& vector_name, T (&v)[N])
      {
         if (!valid())
            return false;
         else if (!valid_symbol(vector_name))
            return false;
         else if (symbol_exists(vector_name))
            return false;
         else
            return local_data().vector_store.add(vector_name,v);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x55dc2c
movb $0x0, 0x27(%rsp)
jmp 0x55dc94
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x55dc4a
movb $0x0, 0x27(%rsp)
jmp 0x55dc94
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x55dc63
jmp 0x55dc6a
movb $0x0, 0x27(%rsp)
jmp 0x55dc94
movq (%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x55ddd0
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_vector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::vector_view<double>&)
inline bool add_vector(const std::string& vector_name, exprtk::vector_view<T>& v)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(vector_name))
            return false;
         else if (symbol_exists(vector_name))
            return false;
         else if (0 == v.size())
            return false;
         else
            return local_data().vector_store.add(vector_name,v);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x55dd1f
movb $0x0, 0x27(%rsp)
jmp 0x55dda2
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x55dd3d
movb $0x0, 0x27(%rsp)
jmp 0x55dda2
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x55dd56
jmp 0x55dd5d
movb $0x0, 0x27(%rsp)
jmp 0x55dda2
movq 0x8(%rsp), %rdi
callq 0x3b8d20
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x55dd78
movb $0x0, 0x27(%rsp)
jmp 0x55dda2
movq (%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x55f5f0
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movb %r8b, %al
movq %rdx, 0x60(%rsp)
movq %rcx, 0x68(%rsp)
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
andb $0x1, %al
movb %al, 0x4f(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x11b270
cmpq $0x1, %rax
jbe 0x55dedd
movq $0x0, 0x40(%rsp)
cmpq $0x59, 0x40(%rsp)
jae 0x55dedb
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rax
leaq 0x2759e3(%rip), %rsi    # 0x7d3890
shlq $0x5, %rax
addq %rax, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x55debf
jmp 0x55dec9
movb $0x0, 0x77(%rsp)
jmp 0x55df7c
jmp 0x55decb
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x55de94
jmp 0x55dedd
movq 0x8(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x55dfd0
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
callq 0x2338c0
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x55e000
testb $0x1, %al
jne 0x55df15
jmp 0x55df77
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x18(%rsp)
movb 0x4f(%rsp), %al
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
andb $0x1, %al
movzbl %al, %edx
callq 0x55e020
movq 0x8(%rsp), %rdi
movb %al, 0x20(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x50(%rsp), %rsi
callq 0x55e0c0
movq %rax, %rdi
leaq 0x20(%rsp), %rsi
callq 0x55e1b0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x30(%rax)
movb $0x1, 0x77(%rsp)
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_stringvar(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>>&, bool)
inline bool add_stringvar(const std::string& stringvar_name, std::string& s, const bool is_constant = false)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(stringvar_name))
            return false;
         else if (symbol_exists(stringvar_name))
            return false;
         else
            return local_data().stringvar_store.add(stringvar_name, s, is_constant);
      }

// Assembly:
subq $0x38, %rsp
movb %cl, %al
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x55fbc5
movb $0x0, 0x37(%rsp)
jmp 0x55fc37
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x55fbe4
movb $0x0, 0x37(%rsp)
jmp 0x55fc37
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x55fbfe
jmp 0x55fc05
movb $0x0, 0x37(%rsp)
jmp 0x55fc37
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movb 0x17(%rsp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0x55fc80
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::symbol_table<double>::add_vector<std::allocator<double>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<double, std::allocator<double>>&)
inline bool add_vector(const std::string& vector_name, std::vector<T,Allocator>& v)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(vector_name))
            return false;
         else if (symbol_exists(vector_name))
            return false;
         else if (0 == v.size())
            return false;
         else
            return local_data().vector_store.add(vector_name,v);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x560ecf
movb $0x0, 0x27(%rsp)
jmp 0x560f52
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x560eed
movb $0x0, 0x27(%rsp)
jmp 0x560f52
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x560f06
jmp 0x560f0d
movb $0x0, 0x27(%rsp)
jmp 0x560f52
movq 0x8(%rsp), %rdi
callq 0x521ce0
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x560f28
movb $0x0, 0x27(%rsp)
jmp 0x560f52
movq (%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x561600
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x48(%rsp), %rax
movsd (%rax), %xmm0
movq 0x40(%rsp), %rax
ucomisd (%rax), %xmm0
jbe 0x56318f
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x563325
movq 0x40(%rsp), %rax
movsd (%rax), %xmm0
movq 0x48(%rsp), %rax
movsd (%rax), %xmm1
subsd %xmm1, %xmm0
movaps 0x37ff4(%rip), %xmm1    # 0x59b1a0
movq 0x38(%rsp), %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
movapd 0x37ff2(%rip), %xmm1    # 0x59b1b0
subpd %xmm1, %xmm2
movaps %xmm2, %xmm1
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm1, %xmm2
movsd 0x37eab(%rip), %xmm1    # 0x59b080
mulsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jae 0x563319
movq 0x48(%rsp), %rax
movsd (%rax), %xmm1
movaps 0x37f8b(%rip), %xmm0    # 0x59b1a0
movq 0x20(%rsp), %xmm2
punpckldq %xmm0, %xmm2    # xmm2 = xmm2[0],xmm0[0],xmm2[1],xmm0[1]
movapd 0x37f89(%rip), %xmm0    # 0x59b1b0
subpd %xmm0, %xmm2
movaps %xmm2, %xmm0
unpckhpd %xmm2, %xmm2            # xmm2 = xmm2[1,1]
addsd %xmm0, %xmm2
movsd 0x37e42(%rip), %xmm0    # 0x59b080
mulsd %xmm2, %xmm0
movsd 0x30(%rsp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x50(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x58(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x50(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x58(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x10(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x50(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movq 0x58(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x8(%rsp)
movsd 0x30(%rsp), %xmm0
movq 0x50(%rsp), %rax
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd 0x30(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
movsd 0x10(%rsp), %xmm1
movsd 0x37d4c(%rip), %xmm3    # 0x59b028
mulsd %xmm3, %xmm1
addsd %xmm2, %xmm1
addsd 0x8(%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x37d22(%rip), %xmm1    # 0x59b018
divsd %xmm1, %xmm0
addsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x5631f5
movsd 0x28(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x58(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x563420
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x232d30
testb $0x1, %al
jne 0x563388
callq 0x2361c0
movsd %xmm0, 0x60(%rsp)
jmp 0x56340e
movq 0x30(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x563450
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x563403
movq 0x20(%rsp), %rdi
callq 0x235f80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x563150
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x56340e
callq 0x2361c0
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::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())
            return reinterpret_cast<variable_ptr>(0);
         else if (!valid_symbol(variable_name))
            return reinterpret_cast<variable_ptr>(0);
         else
            return local_data().variable_store.get(variable_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x56347c
movq $0x0, 0x20(%rsp)
jmp 0x5634bb
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x56349f
movq $0x0, 0x20(%rsp)
jmp 0x5634bb
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
movq 0x10(%rsp), %rsi
callq 0x51d390
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movsd 0x37b81(%rip), %xmm0    # 0x59b080
mulsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x30(%rsp), %rax
addsd (%rax), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x30(%rsp), %rax
subsd (%rax), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm1
movsd 0x10(%rsp), %xmm0
subsd 0x8(%rsp), %xmm0
movsd 0x37b96(%rip), %xmm2    # 0x59b178
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd (%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd 0x37b74(%rip), %xmm1    # 0x59b170
mulsd (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x563420
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x232d30
testb $0x1, %al
jne 0x56365b
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
jmp 0x5636d7
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x563450
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x5636cc
movq 0x20(%rsp), %rdi
callq 0x235f80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x5634d0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x5636d7
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rax
movsd 0x37961(%rip), %xmm0    # 0x59b080
mulsd (%rax), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x50(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
addsd 0x30(%rsp), %xmm0
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x20(%rsp)
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
addsd (%rax), %xmm0
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x18(%rsp)
movsd 0x38(%rsp), %xmm0
movq 0x40(%rsp), %rax
subsd (%rax), %xmm0
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x10(%rsp)
movsd 0x38(%rsp), %xmm0
subsd 0x30(%rsp), %xmm0
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x8(%rsp)
movsd 0x38(%rsp), %xmm0
movq 0x48(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x20(%rsp), %xmm0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd 0x18(%rsp), %xmm1
addsd 0x10(%rsp), %xmm1
movsd 0x37975(%rip), %xmm2    # 0x59b188
mulsd %xmm2, %xmm1
addsd %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
movsd 0x37957(%rip), %xmm2    # 0x59b180
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
subsd 0x8(%rsp), %xmm0
movq 0x40(%rsp), %rax
movsd 0x3792c(%rip), %xmm1    # 0x59b170
mulsd (%rax), %xmm1
movq 0x40(%rsp), %rax
mulsd (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x563420
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x232d30
testb $0x1, %al
jne 0x5638ab
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
jmp 0x563927
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x563450
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x56391c
movq 0x20(%rsp), %rdi
callq 0x235f80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x5636f0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x563927
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rax
movsd 0x37711(%rip), %xmm0    # 0x59b080
mulsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x28(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x18(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x30(%rsp), %rax
addsd (%rax), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x30(%rsp), %rax
subsd (%rax), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x8(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x40(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x18(%rsp), %xmm1
movsd 0x8(%rsp), %xmm0
subsd 0x10(%rsp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
subsd (%rsp), %xmm0
movq 0x30(%rsp), %rax
movsd 0x37633(%rip), %xmm1    # 0x59b080
mulsd (%rax), %xmm1
movq 0x30(%rsp), %rax
mulsd (%rax), %xmm1
movq 0x30(%rsp), %rax
mulsd (%rax), %xmm1
divsd %xmm1, %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x563420
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x232d30
testb $0x1, %al
jne 0x563abb
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
jmp 0x563b37
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x563450
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x563b2c
movq 0x20(%rsp), %rdi
callq 0x235f80
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x563940
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x563b37
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x563450
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x5651c3
movq 0x10(%rsp), %rdi
callq 0x235f80
movq %rax, %rdi
movq 0x18(%rsp), %rsi
movsd 0x35f57(%rip), %xmm0    # 0x59b100
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rsp), %rdx
callq 0x22fb30
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x5651c8
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x566540
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x5652eb
movq (%rsp), %rdi
callq 0x3eed20
movq %rax, %rdi
movq 0x8(%rsp), %rsi
callq 0x43e9b0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x5652f0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)