LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sf3_node<double, exprtk::details::sf00_op<double>>::value() const
inline T value() const exprtk_override
         {
            const T x = trinary_node<T>::branch_[0].first->value();
            const T y = trinary_node<T>::branch_[1].first->value();
            const T z = trinary_node<T>::branch_[2].first->value();

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movsd %xmm0, 0x10(%rsp)
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x267a40
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assert_node<double>::value_type>* exprtk::details::node_allocator::allocate_rrrr<exprtk::details::assert_node<double>, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::assert_check*, exprtk::assert_check::assert_context const>(exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&, exprtk::assert_check*&, exprtk::assert_check::assert_context const&) const
inline expression_node<typename node_type::value_type>* allocate_rrrr(T1& t1, T2& t2, T3& t3, T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movl $0xb8, %edi
callq 0x11b180
movq %rax, (%rsp)
movb $0x1, 0x23(%rsp)
movq 0xb8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0xa0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x528890
jmp 0x5287d6
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
leaq 0x30(%rsp), %r8
callq 0x528950
jmp 0x5287f5
movb $0x0, 0x23(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x528400
movq (%rsp), %rax
movq %rax, 0x98(%rsp)
movq 0x98(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x98(%rsp), %rax
addq $0xc8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x52885e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x528400
testb $0x1, 0x23(%rsp)
jne 0x528867
jmp 0x528875
movq (%rsp), %rdi
movl $0xb8, %esi
callq 0x11b130
jmp 0x528877
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sf4_node<double, exprtk::details::sf48_op<double>>::value() const
inline T value() const exprtk_override
         {
            const T x = quaternary_node<T>::branch_[0].first->value();
            const T y = quaternary_node<T>::branch_[1].first->value();
            const T z = quaternary_node<T>::branch_[2].first->value();
            const T w = quaternary_node<T>::branch_[3].first->value();

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movsd %xmm0, 0x20(%rsp)
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movq 0x58(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x26a310
addq $0x38, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::break_node<double>::value() const
inline T value() const exprtk_override
         {
            const T result = return_.first ?
                             return_.first->value() :
                             std::numeric_limits<T>::quiet_NaN();

            throw break_exception<T>(result);

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x20(%rax)
je 0x50e2b1
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
jmp 0x50e2bc
callq 0x2361c0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movl $0x8, %edi
callq 0x11b320
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x28(%rsp), %rsi
callq 0x50e3b0
jmp 0x50e2e8
movq (%rsp), %rdi
leaq 0x2b808d(%rip), %rsi    # 0x7c6380
xorl %eax, %eax
movl %eax, %edx
callq 0x11b4b0
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x11b640
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_reserved_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_reserved_symbol(const std::string& symbol)
      {
         for (std::size_t i = 0; i < reserved_symbols_size; ++i)
         {
            if (imatch(symbol, reserved_symbols[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x59, (%rsp)
jae 0x50e591
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
leaq 0x2c5328(%rip), %rsi    # 0x7d3890
shlq $0x5, %rax
addq %rax, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x50e57a
jmp 0x50e581
movb $0x1, 0x17(%rsp)
jmp 0x50e596
jmp 0x50e583
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x50e551
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::symbol_exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool symbol_exists(const std::string& symbol) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

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

            return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x50e64f
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x50e60f
jmp 0x50e63f
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x50e636
jmp 0x50e63d
movb $0x1, 0x37(%rsp)
jmp 0x50e654
jmp 0x50e63f
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x50e5d1
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_active_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_active_element(const std::string& var_name,
                                                  const std::size_t index = std::numeric_limits<std::size_t>::max())
         {
            const std::size_t current_depth = parser_.state_.scope_depth;

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

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

            return null_element_;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
movq 0x3b0(%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x374590
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x513d45
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0x374750
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rax
cmpq 0x20(%rsp), %rax
jbe 0x513cf2
jmp 0x513d32
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x513d07
jmp 0x513d2e
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0x513d2e
movq 0x10(%rsp), %rax
testb $0x1, 0x4c(%rax)
je 0x513d2e
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x513d53
jmp 0x513d30
jmp 0x513d32
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x513ca5
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_vector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_vector(const std::string& vector_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         local_data(i).vector_store
                           .symbol_exists(vector_name)
                       )
                  return true;
            }

            return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x513e06
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x513dbf
jmp 0x513df3
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x20(%rsp), %rsi
callq 0x234770
testb $0x1, %al
jne 0x513de8
jmp 0x513def
movb $0x1, 0x37(%rsp)
jmp 0x513e0b
jmp 0x513df1
jmp 0x513df3
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x513d81
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is(exprtk::lexer::token::token_type const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is(const token_t::token_type& ttype,
                              const std::string& value,
                              const token_advance_mode mode = e_advance)
         {
            if (
                 (current_token().type != ttype) ||
                 !exprtk::details::imatch(value,current_token().value)
               )
            {
               return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x373e90
movl (%rax), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x513e78
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x373e90
movq (%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x513e7f
movb $0x0, 0x37(%rsp)
jmp 0x513e92
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4e5b30
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&) const
std::size_t compute_node_depth(const Sequence<node_ptr_t, Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i])
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i]));
                  }
               }

               depth_set = true;
            }

            return depth;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
jne 0x514d8a
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x514d81
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x39d0f0
cmpq $0x0, (%rax)
je 0x514d6c
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x39d0f0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x39e720
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x23da40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x514d6e
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x514ceb
movq 0x10(%rsp), %rax
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_constvalue_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 1) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (single_initialiser_value_ != T(0));
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, 0xf(%rsp)
je 0x51502f
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x39d0d0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x1, %rcx
movb %al, 0xf(%rsp)
jne 0x51502f
movq (%rsp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39d0f0
movq (%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x515013
jmp 0x51502f
movq (%rsp), %rax
movsd 0x48(%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setne %al
setp %cl
orb %cl, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_single_value_node<double>::value() const
inline T value() const exprtk_override
         {
            expression_node<T>& node = *initialiser_list_[0];

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

            return *(vector_base_);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39d0f0
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x51524f
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x515211
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movsd (%rax), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;

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

            return *(vector_base_);
         }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x10(%rsp)
movq $0x0, -0x18(%rsp)
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x515592
movq -0x20(%rsp), %rax
movsd -0x10(%rsp), %xmm0
movq 0x20(%rax), %rax
movq -0x18(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
addq $0x1, %rcx
movq %rcx, -0x18(%rsp)
movsd 0x50(%rax), %xmm0
addsd -0x10(%rsp), %xmm0
movsd %xmm0, -0x10(%rsp)
jmp 0x515543
movq -0x20(%rsp), %rax
movq 0x20(%rax), %rax
movsd (%rax), %xmm0
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constconst_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return vector_base_ &&
                   (initialiser_list_.size() == 2) &&
                   (details::is_constant_node(initialiser_list_[0])) &&
                   (details::is_constant_node(initialiser_list_[1])) ;
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, 0xf(%rsp)
je 0x515631
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x39d0d0
movq %rax, %rcx
xorl %eax, %eax
cmpq $0x2, %rcx
movb %al, 0xf(%rsp)
jne 0x515631
movq (%rsp), %rdi
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39d0f0
movq (%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x515613
jmp 0x515631
movq (%rsp), %rdi
addq $0x30, %rdi
movl $0x1, %esi
callq 0x39d0f0
movq (%rax), %rdi
callq 0x39cbf0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_constnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = base_value_;
            expression_node<T>& increment = *initialiser_list_[1];

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

            return *(vector_base_);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movsd 0x48(%rdi), %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x30, %rdi
movl $0x1, %esi
callq 0x39d0f0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x5158ba
movq (%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x51586c
movq (%rsp), %rax
movq 0x20(%rax), %rax
movsd (%rax), %xmm0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            const T increment = initialiser_list_[1]->value();

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

            return *(vector_base_);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39d0f0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
addq $0x30, %rdi
movl $0x1, %esi
callq 0x39d0f0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x515bb1
movq (%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x515b68
movq (%rsp), %rax
movq 0x20(%rax), %rax
movsd (%rax), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vector_init_iota_nconstnconst_node<double>::value() const
inline T value() const exprtk_override
         {
            T value = initialiser_list_[0]->value();
            expression_node<T>& increment = *initialiser_list_[1];

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

            return *(vector_base_);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x30, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39d0f0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
addq $0x30, %rdi
movl $0x1, %esi
callq 0x39d0f0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x515eaf
movq (%rsp), %rax
movsd 0x18(%rsp), %xmm0
movq 0x20(%rax), %rax
movq 0x8(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x515e61
movq (%rsp), %rax
movq 0x20(%rax), %rax
movsd (%rax), %xmm0
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::stringvar_node<double>::stringvar_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
explicit stringvar_node(std::string& v)
         : value_(&v)
         {
            rp_.n0_c = std::make_pair<bool,std::size_t>(true,0);
            rp_.n1_c = std::make_pair<bool,std::size_t>(true,v.size());
            rp_.cache.first  = rp_.n0_c.second;
            rp_.cache.second = rp_.n1_c.second;
         }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x235e40
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x3a7580
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
callq 0x3a75a0
movq 0x20(%rsp), %rdi
leaq 0x2b793a(%rip), %rax    # 0x7ce028
movq %rax, (%rdi)
leaq 0x2b79a0(%rip), %rax    # 0x7ce098
movq %rax, 0x8(%rdi)
leaq 0x2b79bd(%rip), %rax    # 0x7ce0c0
movq %rax, 0x20(%rdi)
leaq 0x2b79ea(%rip), %rax    # 0x7ce0f8
movq %rax, 0x28(%rdi)
movq 0x78(%rsp), %rax
movq %rax, 0x30(%rdi)
addq $0x38, %rdi
callq 0x43b670
jmp 0x516726
movb $0x1, 0x57(%rsp)
movq $0x0, 0x48(%rsp)
leaq 0x57(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x43b7a0
movq %rdx, 0x10(%rsp)
movb %al, 0x1f(%rsp)
jmp 0x51674e
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movb 0x1f(%rsp), %cl
movb %cl, 0x58(%rsp)
movq %rax, 0x60(%rsp)
addq $0x58, %rdi
leaq 0x58(%rsp), %rsi
callq 0x43b7d0
movb $0x1, 0x37(%rsp)
movq 0x78(%rsp), %rdi
callq 0x11b270
movq %rax, 0x28(%rsp)
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x43b7a0
movq %rdx, (%rsp)
movb %al, 0xf(%rsp)
jmp 0x5167a0
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x38(%rsp)
movq %rax, 0x40(%rsp)
addq $0x38, %rdi
addq $0x30, %rdi
leaq 0x38(%rsp), %rsi
callq 0x43b7d0
movq 0x20(%rsp), %rax
movq 0x60(%rax), %rcx
movq %rcx, 0x78(%rax)
movq 0x70(%rax), %rcx
movq %rcx, 0x80(%rax)
addq $0x88, %rsp
retq
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
addq $0x28, %rdi
callq 0x3a7aa0
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x3a7a80
movq 0x20(%rsp), %rdi
callq 0x236080
movq 0x70(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline variable_ptr get_variable(const std::string& variable_name) const
         {
            if (!valid_symbol(variable_name))
               return reinterpret_cast<variable_ptr>(0);

            variable_ptr result = reinterpret_cast<variable_ptr>(0);

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

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x517c30
testb $0x1, %al
jne 0x517064
movq $0x0, 0x30(%rsp)
jmp 0x5170f9
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x5170ef
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x5170b2
jmp 0x5170df
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x51d390
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x5170dd
jmp 0x5170ef
jmp 0x5170df
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x517076
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_vector_context(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline vector_context get_vector_context(const std::string& vector_name) const
         {
            vector_context result;
            if (!valid_symbol(vector_name))
               return result;

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

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

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

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x517c10
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x517c30
testb $0x1, %al
jne 0x51714a
jmp 0x5171ec
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x5171ea
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x51718f
jmp 0x5171d7
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x18(%rsp), %rsi
callq 0x517c90
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x5171d5
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, 0x28(%rsp)
jmp 0x5171ea
jmp 0x5171d7
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x517153
jmp 0x5171ec
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::vector_holder<double>, exprtk::details::vector_holder<double>>::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline type_ptr get(const std::string& symbol_name) const
         {
            const tm_const_itr_t itr = map.find(symbol_name);

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x235030
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x235000
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x235220
testb $0x1, %al
jne 0x517cdb
jmp 0x517ce6
movq $0x0, 0x30(%rsp)
jmp 0x517cf9
leaq 0x18(%rsp), %rdi
callq 0x3ebb70
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::interval_container_t<void const*, exprtk::parser<double>::halfopen_range_policy<void const*>>::add_interval(void const*, void const*)
bool add_interval(const interval_point_t begin, const interval_point_t end)
         {
            if ((end <= begin) || in_interval(begin) || in_interval(end))
            {
               return false;
            }

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

            return true;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jbe 0x517f0e
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x517f60
testb $0x1, %al
jne 0x517f0e
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x517f60
testb $0x1, %al
jne 0x517f0e
jmp 0x517f15
movb $0x0, 0x37(%rsp)
jmp 0x517f4e
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x517fa0
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x517fe0
movq %rax, %rdi
leaq 0x8(%rsp), %rsi
callq 0x3eae60
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_celem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_     &&
               vector_node_.first &&
               vector_node_.first->valid();
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, 0xf(%rsp)
je 0x51bb82
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, 0xf(%rsp)
je 0x51bb82
movq (%rsp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::rebasevector_elem_rtc_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vector_holder_        &&
               index_.first          &&
               vector_node_.first    &&
               index_.first->valid() &&
               vector_node_.first->valid();
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, 0xf(%rsp)
je 0x51c800
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, 0xf(%rsp)
je 0x51c800
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, 0xf(%rsp)
je 0x51c800
movq (%rsp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x51c7ee
jmp 0x51c800
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::return_node<double>::value() const
inline T value() const exprtk_override
         {
            if (gen_function_t::populate_value_list())
            {
               typedef typename type_store<T>::parameter_list parameter_list_t;

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

               throw return_exception();
            }

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x51ee20
testb $0x1, %al
jne 0x51ed6e
jmp 0x51edb9
movq 0x10(%rsp), %rsi
movq 0xd0(%rsi), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rsi
leaq 0x18(%rsp), %rdi
callq 0x5208f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x520910
movl $0x1, %edi
callq 0x11b320
movq %rax, %rdi
leaq 0x2afcf8(%rip), %rsi    # 0x7ceaa8
xorl %eax, %eax
movl %eax, %edx
callq 0x11b4b0
callq 0x2361c0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_function_node<double, exprtk::details::null_igenfunc<double>>::~generic_function_node()
virtual ~generic_function_node()
         {
            for (std::size_t i = 0; i < vv_list_.size(); ++i)
            {
               vecview_t& vv = vv_list_[i];
               if (vv && typestore_list_[i].vec_data)
               {
                  vv->remove_ref(&typestore_list_[i].vec_data);
                  typestore_list_[i].vec_data = 0;
               }
            }
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x2af8e6(%rip), %rcx    # 0x7cea20
addq $0x10, %rcx
movq %rcx, (%rax)
leaq 0x2af8d8(%rip), %rcx    # 0x7cea20
addq $0x70, %rcx
movq %rcx, 0x8(%rax)
movq $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x70, %rdi
callq 0x51f5e0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x51f21c
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
movq 0x28(%rsp), %rsi
callq 0x51f600
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x51f207
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq 0x28(%rsp), %rsi
callq 0x51f620
cmpq $0x0, (%rax)
je 0x51f207
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
movq 0x28(%rsp), %rsi
callq 0x51f620
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x51f640
jmp 0x51f1ed
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
movq 0x28(%rsp), %rsi
callq 0x51f620
movq $0x0, (%rax)
jmp 0x51f209
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x51f159
movq 0x18(%rsp), %rdi
addq $0xb8, %rdi
callq 0x36fb20
movq 0x18(%rsp), %rdi
addq $0xa0, %rdi
callq 0x51f6f0
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
callq 0x51f750
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
callq 0x51f7b0
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
callq 0x39d590
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
callq 0x37df90
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x2403c0
movq 0x18(%rsp), %rdi
callq 0x236080
addq $0x38, %rsp
retq
movq %rax, %rdi
callq 0x22cbc0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::remove_ref(double**)
void remove_ref(data_ptr_t* data_ref)
      {
         data_ref_.erase(
            std::remove(data_ref_.begin(), data_ref_.end(), data_ref),
            data_ref_.end());
         exprtk_debug(("vector_view::remove_ref() - data_ref: %p data_ref_.size(): %d\n",
                       reinterpret_cast<void*>(data_ref),
                       static_cast<int>(data_ref_.size())));
      }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, (%rsp)
movq %rdi, %rax
addq $0x18, %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
callq 0x51f910
movq (%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x18, %rdi
callq 0x51f940
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x51f8b0
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x51f970
movq (%rsp), %rdi
addq $0x18, %rdi
callq 0x51f940
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x51f970
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x51f810
movq %rax, 0x10(%rsp)
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::assert_call(exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&, exprtk::assert_check::assert_context const&)
inline expression_node_ptr assert_call(expression_node_ptr& assert_condition,
                                                expression_node_ptr& assert_message,
                                                const assert_check::assert_context& context)
         {
            typedef details::assert_node<Type> alloc_type;

            expression_node_ptr result = node_allocator_->allocate_rrrr<alloc_type>
               (assert_condition, assert_message, parser_->assert_check_, context);

            if (result && result->valid())
            {
               parser_->state_.activate_side_effect("assert_call()");
               return result;
            }

            details::free_node(*node_allocator_, result          );
            details::free_node(*node_allocator_, assert_condition);
            details::free_node(*node_allocator_, assert_message  );

            return error_node();
         }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x8(%rax), %rdi
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x68(%rax), %rcx
addq $0x8f0, %rcx            # imm = 0x8F0
movq 0x60(%rsp), %r8
callq 0x528750
movq %rax, 0x58(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x528394
movq 0x58(%rsp), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x52830d
jmp 0x528394
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
addq $0x3a8, %rax            # imm = 0x3A8
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b6f0
movq 0x10(%rsp), %rdx
leaq 0x8213d(%rip), %rsi     # 0x5aa479
leaq 0x38(%rsp), %rdi
callq 0x134520
jmp 0x528348
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3eb500
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x37(%rsp), %rdi
callq 0x11b820
movq 0x58(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x5283da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x5283ea
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x58(%rsp), %rsi
callq 0x284bd0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x70(%rsp), %rsi
callq 0x284bd0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x68(%rsp), %rsi
callq 0x284bd0
callq 0x2821f0
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::assert_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::assert_check*, exprtk::assert_check::assert_context)
assert_node(expression_ptr   assert_condition_node,
                     expression_ptr   assert_message_node,
                     assert_check_ptr assert_check,
                     assert_context_t context)
         : assert_message_str_base_(0)
         , assert_check_(assert_check)
         , context_(context)
         {
            construct_branch_pair(assert_condition_node_, assert_condition_node);
            construct_branch_pair(assert_message_node_  , assert_message_node  );

            #ifndef exprtk_disable_string_capabilities
            if (
                  assert_message_node_.first &&
                  details::is_generally_string_node(assert_message_node_.first)
               )
            {
               assert_message_str_base_ = dynamic_cast<str_base_ptr>(assert_message_node_.first);
            }
            #endif

            assert(valid());
         }

// Assembly:
subq $0x68, %rsp
movq %r8, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x235e40
movq 0x28(%rsp), %rdi
leaq 0x2a613b(%rip), %rax    # 0x7ceac8
movq %rax, (%rdi)
leaq 0x2a6181(%rip), %rax    # 0x7ceb18
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
callq 0x39dfb0
jmp 0x5289a6
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
callq 0x39dfb0
jmp 0x5289b6
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq $0x0, 0x40(%rdi)
movq 0x48(%rsp), %rax
movq %rax, 0x48(%rdi)
addq $0x50, %rdi
movq %rdi, 0x18(%rsp)
callq 0x528890
jmp 0x5289e1
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq 0x58(%rsp), %rsi
callq 0x39d4f0
jmp 0x5289f6
movq 0x28(%rsp), %rdi
addq $0x30, %rdi
movq 0x50(%rsp), %rsi
callq 0x39d4f0
jmp 0x528a0b
movq 0x28(%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x528ab1
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x3a7600
movb %al, 0x17(%rsp)
jmp 0x528a2f
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x528a39
jmp 0x528ab1
movq 0x28(%rsp), %rax
movq 0x30(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x528a9c
movq 0x8(%rsp), %rdi
leaq 0x241787(%rip), %rsi    # 0x76a1e0
leaq 0x273a40(%rip), %rdx    # 0x79c4a0
movq $-0x2, %rcx
callq 0x11b6d0
movq %rax, (%rsp)
jmp 0x528aa4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
jmp 0x528ab6
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0x528400
jmp 0x528ab6
xorl %eax, %eax
movq %rax, (%rsp)
jmp 0x528aa4
movq 0x28(%rsp), %rax
movq (%rsp), %rcx
movq %rcx, 0x40(%rax)
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x236080
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::value() const
inline T value() const exprtk_override
         {
            if (details::is_true(assert_condition_node_.first->value()))
            {
               return T(1);
            }

            #ifndef exprtk_disable_string_capabilities
            if (assert_message_node_.first)
            {
               assert_message_node_.first->value();
               assert(assert_message_str_base_);
               context_.message = assert_message_str_base_->str();
            }
            #endif

            assert_check_->handle_assert(context_);
            return T(0);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x266f30
testb $0x1, %al
jne 0x528ba7
jmp 0x528bb7
movsd 0x72491(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x30(%rsp)
jmp 0x528c1e
movq (%rsp), %rax
cmpq $0x0, 0x30(%rax)
je 0x528c03
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq 0x40(%rax), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *0x10(%rax)
movq (%rsp), %rdi
addq $0x50, %rdi
addq $0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0x11b430
leaq 0x8(%rsp), %rdi
callq 0x11b838
movq (%rsp), %rsi
movq 0x48(%rsi), %rdi
addq $0x50, %rsi
movq (%rdi), %rax
callq *0x10(%rax)
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return (
                     assert_check_ &&
                     assert_condition_node_.first &&
                     assert_condition_node_.first->valid()
                   ) &&
                   (
                     (0 == assert_message_node_.first) ||
                     (
                       assert_message_node_.first &&
                       assert_message_str_base_   &&
                       assert_message_node_.first->valid() &&
                       details::is_generally_string_node(assert_message_node_.first)
                     )
                   );
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
movb %al, 0x1f(%rsp)
je 0x528d0f
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x20(%rcx)
movb %al, 0x1f(%rsp)
je 0x528d0f
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x528c98
jmp 0x528d0f
movq 0x10(%rsp), %rdx
movb $0x1, %al
xorl %ecx, %ecx
cmpq 0x30(%rdx), %rcx
movb %al, 0xf(%rsp)
je 0x528d07
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, 0xe(%rsp)
je 0x528cff
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, 0xe(%rsp)
je 0x528cff
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x528ced
jmp 0x528cff
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
callq 0x3a7600
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_variable_context(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline variable_context get_variable_context(const std::string& variable_name) const
         {
            variable_context result;

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

                  result.variable = local_data(i)
                                       .variable_store.get(variable_name);
                  if (result.variable)
                  {
                     result.symbol_table = &symtab_list_[i];
                     break;
                  }
               }
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x52d1c0
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x517c30
testb $0x1, %al
jne 0x528f2a
jmp 0x528fc5
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x528fc3
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x528f6f
jmp 0x528fb0
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x51d390
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x528fae
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, 0x28(%rsp)
jmp 0x528fc3
jmp 0x528fb0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x528f33
jmp 0x528fc5
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop