LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::~control_block()
~control_block()
            {
               if (data && destruct && (0 == ref_count))
               {
                  dump_ptr("~vec_data_store::control_block() data",data);
                  delete[] data;
                  data = reinterpret_cast<data_t>(0);
               }
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rax)
je 0x3b8892
movq 0x10(%rsp), %rax
testb $0x1, 0x18(%rax)
je 0x3b8892
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x3b8892
leaq 0x1f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11b6f0
movq 0x8(%rsp), %rdx
leaq 0x1ef1f6(%rip), %rsi    # 0x5a7a2a
leaq 0x20(%rsp), %rdi
callq 0x134520
jmp 0x3b8840
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
leaq 0x20(%rsp), %rdi
callq 0x3b88a0
jmp 0x3b8855
leaq 0x20(%rsp), %rdi
callq 0x11b838
leaq 0x1f(%rsp), %rdi
callq 0x11b820
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x3b8885
movq (%rsp), %rdi
callq 0x11b300
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
addq $0x48, %rsp
retq
movq %rax, %rdi
callq 0x22cbc0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_invalid_string_op(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            const bool b0_string = is_generally_string_node(branch[0]);
            const bool b1_string = is_generally_string_node(branch[1]);

            bool result = false;

            if (b0_string != b1_string)
               result = true;
            else if (!valid_string_operation(operation) && b0_string && b1_string)
               result = true;

            if (result)
            {
               parser_->set_synthesis_error("Invalid string operation");
            }

            return result;
         }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0x5e(%rsp)
movb $0x0, 0x5d(%rsp)
movb 0x5f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x5e(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x3dc537
movb $0x1, 0x5d(%rsp)
jmp 0x3dc55f
movq 0x18(%rsp), %rdi
movq 0x68(%rsp), %rsi
callq 0x3e7510
testb $0x1, %al
jne 0x3dc55d
testb $0x1, 0x5f(%rsp)
je 0x3dc55d
testb $0x1, 0x5e(%rsp)
je 0x3dc55d
movb $0x1, 0x5d(%rsp)
jmp 0x3dc55f
testb $0x1, 0x5d(%rsp)
je 0x3dc5fa
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b6f0
movq 0x10(%rsp), %rdx
leaq 0x1cb594(%rip), %rsi    # 0x5a7b27
leaq 0x38(%rsp), %rdi
callq 0x134520
jmp 0x3dc59f
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3e7640
jmp 0x3dc5b0
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x3dc5fa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x3dc5ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x3dc605
movb 0x5d(%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>::expression_generator<double>::is_invalid_break_continue_op(exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_invalid_break_continue_op(expression_node_ptr (&branch)[2]) const
         {
            return (
                     details::is_break_node   (branch[0]) ||
                     details::is_break_node   (branch[1]) ||
                     details::is_continue_node(branch[0]) ||
                     details::is_continue_node(branch[1])
                   );
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3af660
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3dc7ef
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3af660
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3dc7ef
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3af6a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3dc7ef
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3af6a0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_assignment_operation(exprtk::details::operator_type const&) const
inline bool is_assignment_operation(const details::operator_type& operation) const
         {
            return (
                     (details::e_addass == operation) ||
                     (details::e_subass == operation) ||
                     (details::e_mulass == operation) ||
                     (details::e_divass == operation) ||
                     (details::e_modass == operation)
                   ) &&
                   parser_->settings_.assignment_enabled(operation);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rcx
movl $0x52, %eax
cmpl (%rcx), %eax
je 0x3dd874
movq 0x18(%rsp), %rcx
movl $0x53, %eax
cmpl (%rcx), %eax
je 0x3dd874
movq 0x18(%rsp), %rcx
movl $0x54, %eax
cmpl (%rcx), %eax
je 0x3dd874
movq 0x18(%rsp), %rcx
movl $0x55, %eax
cmpl (%rcx), %eax
je 0x3dd874
movq 0x18(%rsp), %rdx
xorl %eax, %eax
movl $0x56, %ecx
cmpl (%rdx), %ecx
movb %al, 0xf(%rsp)
jne 0x3dd892
movq 0x10(%rsp), %rax
movq 0x68(%rax), %rdi
addq $0xd0, %rdi
movq 0x18(%rsp), %rsi
callq 0x3f3050
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_vector_eqineq_logic_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_vector_eqineq_logic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1]))
               return false;
            else
               return (
                        (details::e_lt    == operation) ||
                        (details::e_lte   == operation) ||
                        (details::e_gt    == operation) ||
                        (details::e_gte   == operation) ||
                        (details::e_eq    == operation) ||
                        (details::e_ne    == operation) ||
                        (details::e_equal == operation) ||
                        (details::e_and   == operation) ||
                        (details::e_nand  == operation) ||
                        (details::e_or    == operation) ||
                        (details::e_nor   == operation) ||
                        (details::e_xor   == operation) ||
                        (details::e_xnor  == operation)
                      );
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39f460
testb $0x1, %al
jne 0x3df730
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39f460
testb $0x1, %al
jne 0x3df730
movb $0x0, 0x27(%rsp)
jmp 0x3df855
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0xe, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0xf, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x15, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x14, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x10, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x12, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x11, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x16, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x17, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x18, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x19, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x1a, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3df84b
movq 0x10(%rsp), %rcx
movl $0x1b, %eax
cmpl (%rcx), %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_vector_arithmetic_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_vector_arithmetic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1]))
               return false;
            else
               return (
                        (details::e_add == operation) ||
                        (details::e_sub == operation) ||
                        (details::e_mul == operation) ||
                        (details::e_div == operation) ||
                        (details::e_pow == operation)
                      );
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39f460
testb $0x1, %al
jne 0x3e0b3d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39f460
testb $0x1, %al
jne 0x3e0b3d
movb $0x0, 0x27(%rsp)
jmp 0x3e0baa
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x2, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3e0ba0
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x3, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3e0ba0
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x4, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3e0ba0
movq 0x10(%rsp), %rdx
movb $0x1, %al
movl $0x5, %ecx
cmpl (%rdx), %ecx
movb %al, 0x7(%rsp)
je 0x3e0ba0
movq 0x10(%rsp), %rcx
movl $0x7, %eax
cmpl (%rcx), %eax
sete %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_constpow_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_constpow_operation(const details::operator_type& operation, expression_node_ptr(&branch)[2]) const
         {
            if (
                 !details::is_constant_node(branch[1]) ||
                  details::is_constant_node(branch[0]) ||
                  details::is_variable_node(branch[0]) ||
                  details::is_vector_node  (branch[0]) ||
                  details::is_generally_string_node(branch[0])
               )
               return false;

            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();

            return cardinal_pow_optimisable(operation, c);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x3e24f1
jmp 0x3e2537
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x3e2537
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x3e2537
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3b7740
testb $0x1, %al
jne 0x3e2537
movq 0x18(%rsp), %rax
movq (%rax), %rdi
callq 0x3a7600
testb $0x1, %al
jne 0x3e2537
jmp 0x3e253e
movb $0x0, 0x37(%rsp)
jmp 0x3e256c
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x284bc0
movq 0x8(%rsp), %rdi
movsd %xmm0, 0x10(%rsp)
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x286f10
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cardinal_pow_optimisation(exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr (&branch)[2])
         {
            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
            const bool not_recipricol = (c >= T(0));
            const unsigned int p = static_cast<unsigned int>(details::numeric::to_int32(details::numeric::abs(c)));

            node_allocator_->free(branch[1]);

            if (0 == p)
            {
               details::free_all_nodes(*node_allocator_, branch);

               return node_allocator_->allocate_c<literal_node_t>(T(1));
            }
            else if (not_recipricol)
               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipow_node>(branch[0],p);
            else
               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipowinv_node>(branch[0],p);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x284bc0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
setae %al
andb $0x1, %al
movb %al, 0x17(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x2651a0
callq 0x287b30
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x10(%rsp)
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
addq $0x8, %rsi
callq 0x470190
xorl %eax, %eax
cmpl 0x10(%rsp), %eax
jne 0x3e262e
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x3ebbf0
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movsd 0x1b8a29(%rip), %xmm0   # 0x59b040
movsd %xmm0, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x287b60
movq %rax, 0x30(%rsp)
jmp 0x3e2667
testb $0x1, 0x17(%rsp)
je 0x3e264f
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4701d0
movq %rax, 0x30(%rsp)
jmp 0x3e2667
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x4708f0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2], exprtk::details::expression_node<double>*&)
inline bool synthesize_expression(const details::operator_type& operation,
                                           expression_node_ptr (&branch)[2],
                                           expression_node_ptr& result)
         {
            result = error_node();

            if (!operation_optimisable(operation))
               return false;

            const std::string node_id = branch_to_id(branch);

            const typename synthesize_map_t::iterator itr = synthesize_map_.find(node_id);

            if (synthesize_map_.end() != itr)
            {
               result = itr->second((*this), operation, branch);

               return true;
            }
            else
               return false;
         }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x88(%rsp)
movq %rsi, 0x80(%rsp)
movq %rdx, 0x78(%rsp)
movq %rcx, 0x70(%rsp)
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
callq 0x2821f0
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movq 0x70(%rsp), %rax
movq %rcx, (%rax)
movq 0x80(%rsp), %rsi
callq 0x4830d0
testb $0x1, %al
jne 0x3e26e1
movb $0x0, 0x97(%rsp)
jmp 0x3e27c2
movq 0x20(%rsp), %rsi
movq 0x78(%rsp), %rdx
leaq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x483280
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x10, %rdi
callq 0x483410
movq %rax, 0x18(%rsp)
jmp 0x3e2714
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x48(%rsp)
addq $0x10, %rdi
callq 0x283bc0
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x483440
testb $0x1, %al
jne 0x3e2746
jmp 0x3e27a8
leaq 0x48(%rsp), %rdi
callq 0x483460
movq 0x20(%rsp), %rdi
movq 0x20(%rax), %rax
movq 0x80(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq *%rax
movq %rax, 0x8(%rsp)
jmp 0x3e276f
movq 0x8(%rsp), %rcx
movq 0x70(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x97(%rsp)
movl $0x1, 0x2c(%rsp)
jmp 0x3e27b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11b838
jmp 0x3e27d3
movb $0x0, 0x97(%rsp)
movl $0x1, 0x2c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x11b838
movb 0x97(%rsp), %al
andb $0x1, %al
addq $0x98, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cocob_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool cocob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (
                 (details::e_add == operation) ||
                 (details::e_sub == operation) ||
                 (details::e_mul == operation) ||
                 (details::e_div == operation)
               )
            {
               return (details::is_constant_node(branch[0]) && details::is_cob_node(branch[1])) ||
                      (details::is_constant_node(branch[1]) && details::is_cob_node(branch[0])) ;
            }
            else
               return false;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
je 0x3e282b
movq 0x10(%rsp), %rcx
movl $0x3, %eax
cmpl (%rcx), %eax
je 0x3e282b
movq 0x10(%rsp), %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
je 0x3e282b
movq 0x10(%rsp), %rcx
movl $0x5, %eax
cmpl (%rcx), %eax
jne 0x3e289b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x3e283e
jmp 0x3e2859
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x484260
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e288f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x3e2876
jmp 0x3e2887
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x484260
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x3e28a0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::coboc_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool coboc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (
                 (details::e_add == operation) ||
                 (details::e_sub == operation) ||
                 (details::e_mul == operation) ||
                 (details::e_div == operation)
               )
            {
               return (details::is_constant_node(branch[0]) && details::is_boc_node(branch[1])) ||
                      (details::is_constant_node(branch[1]) && details::is_boc_node(branch[0])) ;
            }
            else
               return false;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
je 0x3e387b
movq 0x10(%rsp), %rcx
movl $0x3, %eax
cmpl (%rcx), %eax
je 0x3e387b
movq 0x10(%rsp), %rcx
movl $0x4, %eax
cmpl (%rcx), %eax
je 0x3e387b
movq 0x10(%rsp), %rcx
movl $0x5, %eax
cmpl (%rcx), %eax
jne 0x3e38eb
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x3e388e
jmp 0x3e38a9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x484fb0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e38df
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x6(%rsp)
jne 0x3e38c6
jmp 0x3e38d7
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x484fb0
movb %al, 0x6(%rsp)
movb 0x6(%rsp), %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x3e38f0
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::uvouv_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool uvouv_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!operation_optimisable(operation))
               return false;
            else
               return details::is_uv_node(branch[0]) &&
                      details::is_uv_node(branch[1]) ;
         }

// 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 0x4830d0
testb $0x1, %al
jne 0x3e436d
movb $0x0, 0x27(%rsp)
jmp 0x3e43a5
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x4853d0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e4389
jmp 0x3e439b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x4853d0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::vob_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool vob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!operation_optimisable(operation))
               return false;
            else
               return details::is_variable_node(branch[0]) &&
                     !details::is_variable_node(branch[1]) ;
         }

// 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 0x4830d0
testb $0x1, %al
jne 0x3e462d
movb $0x0, 0x27(%rsp)
jmp 0x3e4667
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c960
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e4649
jmp 0x3e465d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23c960
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::bov_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool bov_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!operation_optimisable(operation))
               return false;
            else
               return !details::is_variable_node(branch[0]) &&
                       details::is_variable_node(branch[1]) ;
         }

// 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 0x4830d0
testb $0x1, %al
jne 0x3e4b6d
movb $0x0, 0x27(%rsp)
jmp 0x3e4ba3
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c960
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e4b99
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23c960
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
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::parser<double>::expression_generator<double>::cob_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool cob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!operation_optimisable(operation))
               return false;
            else
               return details::is_constant_node(branch[0]) &&
                     !details::is_constant_node(branch[1]) ;
         }

// 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 0x4830d0
testb $0x1, %al
jne 0x3e50dd
movb $0x0, 0x27(%rsp)
jmp 0x3e5117
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e50f9
jmp 0x3e510d
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39cbf0
xorb $-0x1, %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::boc_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool boc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!operation_optimisable(operation))
               return false;
            else
               return !details::is_constant_node(branch[0]) &&
                       details::is_constant_node(branch[1]) ;
         }

// 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 0x4830d0
testb $0x1, %al
jne 0x3e5cdd
movb $0x0, 0x27(%rsp)
jmp 0x3e5d13
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e5d09
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x39cbf0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
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::parser<double>::expression_generator<double>::cov_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool cov_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!operation_optimisable(operation))
               return false;
            else
               return details::is_constant_node(branch[0]) &&
                      details::is_variable_node(branch[1]) ;
         }

// 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 0x4830d0
testb $0x1, %al
jne 0x3e66dd
movb $0x0, 0x27(%rsp)
jmp 0x3e6715
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x3e66f9
jmp 0x3e670b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23c960
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::valid_string_operation(exprtk::details::operator_type const&) const
inline bool valid_string_operation(const details::operator_type& operation) const
         {
            return (details::e_add    == operation) ||
                   (details::e_lt     == operation) ||
                   (details::e_lte    == operation) ||
                   (details::e_gt     == operation) ||
                   (details::e_gte    == operation) ||
                   (details::e_eq     == operation) ||
                   (details::e_ne     == operation) ||
                   (details::e_in     == operation) ||
                   (details::e_like   == operation) ||
                   (details::e_ilike  == operation) ||
                   (details::e_assign == operation) ||
                   (details::e_addass == operation) ||
                   (details::e_swap   == operation) ;
         }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x2, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0xe, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0xf, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x15, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x14, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x10, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x12, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x57, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x58, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x59, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x51, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x52, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x3e7635
movq -0x10(%rsp), %rcx
movl $0x5c, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
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*>>::in_interval(void const*, std::pair<void const*, void const*>&) const
bool in_interval(const interval_point_t point, interval_t& interval) const
         {
            interval_map_citr_t itr = RangePolicy::end_inclusive() ?
                                      interval_map_.lower_bound(point):
                                      interval_map_.upper_bound(point);

            for (; itr != interval_map_.end(); ++itr)
            {
               const interval_point_t& begin = itr->second.first;
               const interval_point_t& end   = itr->second.second;

               if (RangePolicy::is_within(point, begin, end))
               {
                  interval = interval_t(begin,end);
                  return true;
               }
               else if (RangePolicy::is_greater(point, end))
               {
                  break;
               }
            }

            return false;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
callq 0x3ead00
testb $0x1, %al
jne 0x3ea327
jmp 0x3ea33c
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3ead10
movq %rax, 0x30(%rsp)
jmp 0x3ea34f
movq (%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x3ead40
movq %rax, 0x30(%rsp)
jmp 0x3ea351
movq (%rsp), %rdi
callq 0x3ead90
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x3ead70
testb $0x1, %al
jne 0x3ea377
jmp 0x3ea40f
leaq 0x30(%rsp), %rdi
callq 0x3eadc0
addq $0x8, %rax
movq %rax, 0x20(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x3eadc0
addq $0x8, %rax
addq $0x8, %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x3eade0
testb $0x1, %al
jne 0x3ea3bb
jmp 0x3ea3e5
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x3eae30
movq 0x38(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3eae60
movb $0x1, 0x57(%rsp)
jmp 0x3ea414
movq 0x18(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x3eae90
testb $0x1, %al
jne 0x3ea3fa
jmp 0x3ea3fc
jmp 0x3ea40f
jmp 0x3ea3fe
jmp 0x3ea400
leaq 0x30(%rsp), %rdi
callq 0x3eaeb0
jmp 0x3ea351
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::dependent_entity_collector::add_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::symbol_type)
inline void add_assignment(const std::string& symbol, const symbol_type st)
         {
            switch (st)
            {
               case e_st_variable       :
               case e_st_vector         :
               case e_st_string         : if (collect_assignments_)
                                             assignment_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               default                  : return;
            }
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x54(%rsp), %eax
movl %eax, 0x18(%rsp)
decl %eax
subl $0x2, %eax
jb 0x3eb698
jmp 0x3eb68d
movl 0x18(%rsp), %eax
subl $0x4, %eax
jne 0x3eb701
jmp 0x3eb698
movq 0x10(%rsp), %rax
testb $0x1, 0xa(%rax)
je 0x3eb6ff
movq 0x10(%rsp), %rax
addq $0x28, %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x54(%rsp), %rdx
callq 0x39e930
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x39e900
jmp 0x3eb6d9
leaq 0x28(%rsp), %rdi
callq 0x371710
jmp 0x3eb6ff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x371710
jmp 0x3eb708
jmp 0x3eb703
jmp 0x3eb703
addq $0x68, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::entity_name<exprtk::details::expression_node<double>*>(exprtk::details::expression_node<double>* const&) const
inline std::string entity_name(const PtrType& ptr) const
         {
            if (map.empty())
               return std::string();

            tm_const_itr_t itr = map.begin();

            while (map.end() != itr)
            {
               if (itr->second.second == ptr)
               {
                  return itr->first;
               }
               else
                  ++itr;
            }

            return std::string();
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x232f20
testb $0x1, %al
jne 0x3eb785
jmp 0x3eb791
movq 0x8(%rsp), %rdi
callq 0x11b2b0
jmp 0x3eb80b
movq 0x18(%rsp), %rdi
callq 0x3eb840
movq %rax, 0x28(%rsp)
movq 0x18(%rsp), %rdi
callq 0x234890
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x234870
testb $0x1, %al
jne 0x3eb7c4
jmp 0x3eb801
leaq 0x28(%rsp), %rdi
callq 0x3eb870
movq 0x28(%rax), %rax
movq 0x30(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x3eb7f5
leaq 0x28(%rsp), %rdi
callq 0x3eb870
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x11b140
jmp 0x3eb80b
leaq 0x28(%rsp), %rdi
callq 0x3eb890
jmp 0x3eb7a0
movq 0x8(%rsp), %rdi
callq 0x11b2b0
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assignment_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::assignment_node<double>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[2])
         {
            expression_node<typename ResultNode::value_type>* result =
               allocate<ResultNode>(operation, branch[0], branch[1]);
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
addq $0x8, %rcx
callq 0x3ebd70
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assignment_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::assignment_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl $0x50, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rcx
callq 0x3ebe10
jmp 0x3ebdb9
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x50, %esi
callq 0x11b130
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::binary_node<double>::value() const
inline T value() const exprtk_override
         {
            return numeric::process<T>
                   (
                      operation_,
                      branch_[0].first->value(),
                      branch_[1].first->value()
                   );
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movl 0x20(%rax), %ecx
movl %ecx, 0x14(%rsp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x14(%rsp), %edi
movaps %xmm0, %xmm1
movsd 0x18(%rsp), %xmm0
callq 0x3ec450
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::numeric::details::root_impl<double>(double, double, exprtk::details::numeric::details::real_type_tag)
inline T root_impl(const T v0, const T v1, real_type_tag)
            {
               if (v0 < T(0))
               {
                  return (v1 == trunc_impl(v1, real_type_tag())) &&
                         (modulus_impl(v1, T(2), real_type_tag()) != T(0)) ?
                         -std::pow(abs_impl(v0, real_type_tag()), T(1) / v1) :
                          std::numeric_limits<double>::quiet_NaN();
               }

               return std::pow(v0, T(1) / v1);
            }

// Assembly:
subq $0x58, %rsp
movsd %xmm0, 0x40(%rsp)
movsd %xmm1, 0x38(%rsp)
xorps %xmm0, %xmm0
ucomisd 0x40(%rsp), %xmm0
jbe 0x3ece57
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x28(%rsp)
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x233dd0
movsd 0x20(%rsp), %xmm0
callq 0x266010
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jne 0x3ece3e
jp 0x3ece3e
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x36(%rsp), %rdi
callq 0x233dd0
movsd 0x18(%rsp), %xmm0
movsd 0x1ae2a7(%rip), %xmm1   # 0x59b080
callq 0x266e70
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3ecdeb
jp 0x3ecdeb
jmp 0x3ece3e
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x35(%rsp), %rdi
callq 0x233dd0
movsd 0x8(%rsp), %xmm0
callq 0x2651d0
movsd 0x1ae22c(%rip), %xmm1   # 0x59b040
divsd 0x38(%rsp), %xmm1
callq 0x11b2d0
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x3ece49
callq 0x2361c0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x3ece76
movsd 0x40(%rsp), %xmm0
movsd 0x1ae1db(%rip), %xmm1   # 0x59b040
divsd 0x38(%rsp), %xmm1
callq 0x11b2d0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::numeric::details::roundn_impl<double>(double, double, exprtk::details::numeric::details::real_type_tag)
inline T roundn_impl(const T v0, const T v1, real_type_tag)
            {
               const int index = std::max<int>(0, std::min<int>(pow10_size - 1, static_cast<int>(std::floor(v1))));
               const T p10 = T(pow10[index]);

               if (v0 < T(0))
                  return T(std::ceil ((v0 * p10) - T(0.5)) / p10);
               else
                  return T(std::floor((v0 * p10) + T(0.5)) / p10);
            }

// Assembly:
subq $0x38, %rsp
movsd %xmm0, 0x20(%rsp)
movsd %xmm1, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movl $0x10, 0xc(%rsp)
movsd 0x18(%rsp), %xmm0
callq 0x11b160
cvttsd2si %xmm0, %eax
movl %eax, 0x8(%rsp)
leaq 0xc(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ecfb0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x3ecf70
movl (%rax), %eax
movl %eax, 0x14(%rsp)
movslq 0x14(%rsp), %rcx
leaq 0x1ed74f(%rip), %rax    # 0x5da640
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, (%rsp)
xorps %xmm0, %xmm0
ucomisd 0x20(%rsp), %xmm0
jbe 0x3ecf33
movsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1ae24b(%rip), %xmm1   # 0x59b168
addsd %xmm1, %xmm0
callq 0x11b750
divsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x3ecf5e
movsd 0x20(%rsp), %xmm0
movsd (%rsp), %xmm1
mulsd %xmm1, %xmm0
movsd 0x1ae126(%rip), %xmm1   # 0x59b070
addsd %xmm1, %xmm0
callq 0x11b160
divsd (%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
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<2ul>(std::pair<exprtk::details::expression_node<double>*, bool> const (&) [2ul]) const
std::size_t compute_node_depth(const nb_pair_t (&branch)[N]) const
         {
            if (!depth_set)
            {
               depth = 0;

               for (std::size_t i = 0; i < N; ++i)
               {
                  if (branch[i].first)
                  {
                     depth = std::max(depth,branch[i].first->node_depth());
                  }
               }

               depth += 1;
               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 0x3ed434
movq 0x10(%rsp), %rax
movq $0x0, 0x10(%rax)
movq $0x0, 0x20(%rsp)
cmpq $0x2, 0x20(%rsp)
jae 0x3ed41f
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq $0x0, (%rax)
je 0x3ed40a
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rsp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x8(%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 0x3ed40c
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x3ed398
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_string_node<double, exprtk::details::asn_assignment>::value() const
inline T value() const exprtk_override
         {
            branch(1)->value();

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

            const range_t& range = (*str1_range_ptr_);

            if (range(r0, r1, str1_base_ptr_->size()))
            {
               AssignmentProcess::execute(
                  str0_node_ptr_->ref(),
                  str1_base_ptr_->base() + r0, (r1 - r0));

               branch(0)->value();
            }

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq $0x1, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x78(%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x30(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x18(%rsp), %rdi
movq %rax, 0x28(%rsp)
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0x3eebb0
testb $0x1, %al
jne 0x3ee8c7
jmp 0x3ee929
movq 0x10(%rsp), %rax
movq 0x70(%rax), %rdi
callq 0x3eed20
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq %rax, %rsi
addq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
subq 0x40(%rsp), %rdx
callq 0x3eecf0
movq 0x10(%rsp), %rdi
movq $0x0, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x2361c0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)