LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_node<double>::conditional_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
conditional_node(expression_ptr condition,
                          expression_ptr consequent,
                          expression_ptr alternative)
         {
            construct_branch_pair(condition_  , condition  );
            construct_branch_pair(consequent_ , consequent );
            construct_branch_pair(alternative_, alternative);
            assert(valid());
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x235e40
movq (%rsp), %rdi
leaq 0x2e0fdf(%rip), %rax    # 0x7c5fe0
movq %rax, (%rdi)
leaq 0x2e1025(%rip), %rax    # 0x7c6030
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
callq 0x39dfb0
jmp 0x4e501a
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x39dfb0
jmp 0x4e5029
movq (%rsp), %rdi
addq $0x40, %rdi
callq 0x39dfb0
jmp 0x4e5038
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x28(%rsp), %rsi
callq 0x39d4f0
jmp 0x4e504c
movq (%rsp), %rdi
addq $0x30, %rdi
movq 0x20(%rsp), %rsi
callq 0x39d4f0
jmp 0x4e5060
movq (%rsp), %rdi
addq $0x40, %rdi
movq 0x18(%rsp), %rsi
callq 0x39d4f0
jmp 0x4e5074
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
callq 0x236080
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               condition_  .first && condition_  .first->valid() &&
               consequent_ .first && consequent_ .first->valid() &&
               alternative_.first && alternative_.first->valid() ;
         }

// 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 0x4e524d
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4e51fc
jmp 0x4e524d
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x30(%rcx)
movb %al, 0xf(%rsp)
je 0x4e524d
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4e522a
jmp 0x4e524d
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x40(%rcx)
movb %al, 0xf(%rsp)
je 0x4e524d
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,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::pair<exprtk::details::expression_node<double>*, bool>>(std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const BranchType& n0, const BranchType& n1) const
         {
            if (!depth_set)
            {
               depth = 1 + max_node_depth(n0, n1);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
jne 0x4e55db
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x4e55f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is(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 std::string& value,
                              const token_advance_mode mode = e_advance)
         {
            if (!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)
movl %edx, 0x1c(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x373e90
movq 0x10(%rsp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x4e5697
movb $0x0, 0x37(%rsp)
jmp 0x4e56aa
movq 0x8(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x4e5b30
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is_arithmetic_opr(exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is_arithmetic_opr(const token_advance_mode mode = e_advance)
         {
            switch (current_token().type)
            {
               case token_t::e_add :
               case token_t::e_sub :
               case token_t::e_div :
               case token_t::e_mul :
               case token_t::e_mod :
               case token_t::e_pow : break;
               default             : return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x373e90
movl (%rax), %eax
movl %eax, 0x10(%rsp)
subl $0x25, %eax
je 0x4e59f8
jmp 0x4e59c9
movl 0x10(%rsp), %eax
addl $-0x2a, %eax
subl $0x2, %eax
jb 0x4e59f8
jmp 0x4e59d7
movl 0x10(%rsp), %eax
subl $0x2d, %eax
je 0x4e59f8
jmp 0x4e59e2
movl 0x10(%rsp), %eax
subl $0x2f, %eax
je 0x4e59f8
jmp 0x4e59ed
movl 0x10(%rsp), %eax
subl $0x5e, %eax
jne 0x4e59fa
jmp 0x4e59f8
jmp 0x4e5a01
movb $0x0, 0x27(%rsp)
jmp 0x4e5a14
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4e5b30
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is_right_bracket(exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is_right_bracket(const token_advance_mode mode = e_advance)
         {
            switch (current_token().type)
            {
               case token_t::e_rbracket    :
               case token_t::e_rcrlbracket :
               case token_t::e_rsqrbracket : break;
               default                     : return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x373e90
movl (%rax), %eax
movl %eax, 0x10(%rsp)
subl $0x29, %eax
je 0x4e5a5f
jmp 0x4e5a49
movl 0x10(%rsp), %eax
subl $0x5d, %eax
je 0x4e5a5f
jmp 0x4e5a54
movl 0x10(%rsp), %eax
subl $0x7d, %eax
jne 0x4e5a61
jmp 0x4e5a5f
jmp 0x4e5a68
movb $0x0, 0x27(%rsp)
jmp 0x4e5a7b
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4e5b30
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is_ineq_opr(exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is_ineq_opr(const token_advance_mode mode = e_advance)
         {
            switch (current_token().type)
            {
               case token_t::e_eq  :
               case token_t::e_lte :
               case token_t::e_ne  :
               case token_t::e_gte :
               case token_t::e_lt  :
               case token_t::e_gt  : break;
               default             : return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x373e90
movl (%rax), %eax
movl %eax, 0x10(%rsp)
addl $-0x12, %eax
subl $0x3, %eax
jb 0x4e5aca
jmp 0x4e5abc
movl 0x10(%rsp), %eax
addl $-0x3c, %eax
subl $0x2, %eax
ja 0x4e5acc
jmp 0x4e5aca
jmp 0x4e5ad3
movb $0x0, 0x27(%rsp)
jmp 0x4e5ae6
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x4e5b30
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::get_loop_runtime_check(exprtk::loop_runtime_check::loop_types) const
inline loop_runtime_check_ptr get_loop_runtime_check(const loop_runtime_check::loop_types loop_type) const
         {
            if (
                 parser_->loop_runtime_check_ &&
                 (loop_type == (parser_->loop_runtime_check_->loop_set & loop_type))
               )
            {
               return parser_->loop_runtime_check_;
            }

            return loop_runtime_check_ptr(0);
         }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq 0x68(%rax), %rax
cmpq $0x0, 0x8d8(%rax)
je 0x4e6887
movq -0x20(%rsp), %rcx
movl -0x14(%rsp), %eax
movq 0x68(%rcx), %rcx
movq 0x8d8(%rcx), %rcx
movl 0x8(%rcx), %ecx
andl -0x14(%rsp), %ecx
cmpl %ecx, %eax
jne 0x4e6887
movq -0x20(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x8d8(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x4e6890
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {

            T result = T(0);

            loop_runtime_checker::reset();

            while (is_true(parent_t::condition_) && loop_runtime_checker::check())
            {
               result = parent_t::loop_body_.first->value();
            }

            return result;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e6f20
movq 0x10(%rsp), %rdi
addq $0x20, %rdi
callq 0x4e4d70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4e6ca6
jmp 0x4e6cb8
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x4e6f40
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4e6cc2
jmp 0x4e6cd9
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
jmp 0x4e6c89
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            while (is_true(condition_))
            {
               result = loop_body_.first->value();
            }

            return result;
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rdi
addq $0x20, %rdi
callq 0x4e4d70
testb $0x1, %al
jne 0x4e6e4e
jmp 0x4e6e64
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
jmp 0x4e6e3b
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::loop_runtime_checker::check() const
inline bool check() const
         {
            assert(loop_runtime_check_);

            if (
                 (++iteration_count_ <= max_loop_iterations_) &&
                 loop_runtime_check_->check()
               )
            {
               return true;
            }

            loop_runtime_check::violation_context ctxt;
            ctxt.loop      = loop_type_;
            ctxt.violation = loop_runtime_check::e_iteration_count;

            loop_runtime_check_->handle_runtime_violation(ctxt);

            return false;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq %rcx, (%rsp)
movq (%rcx), %rax
addq $0x1, %rax
movq %rax, (%rcx)
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
ja 0x4e6f7f
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *(%rax)
testb $0x1, %al
jne 0x4e6f78
jmp 0x4e6f7f
movb $0x1, 0x27(%rsp)
jmp 0x4e6fa6
movq (%rsp), %rax
movl 0x18(%rax), %ecx
movl %ecx, 0x8(%rsp)
movl $0x1, 0xc(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0x8(%rax)
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            while (is_true(parent_t::condition_) && loop_runtime_checker::check())
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }

            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e6f20
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x4e4d70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x4e7186
jmp 0x4e7198
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
callq 0x4e6f40
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x4e71a5
jmp 0x4e7237
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movsd %xmm0, 0x8(%rsp)
jmp 0x4e71bf
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x4e7232
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0x4(%rsp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4e7211
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
callq 0x11b560
jmp 0x4e7243
movl 0x4(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4e724e
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x28(%rsp)
callq 0x11b560
jmp 0x4e7169
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            while (is_true(parent_t::condition_))
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }

            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x18(%rsp), %rdi
addq $0x20, %rdi
callq 0x4e4d70
testb $0x1, %al
jne 0x4e7363
jmp 0x4e73f5
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movsd %xmm0, 0x10(%rsp)
jmp 0x4e737d
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x4e73f0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4e73cf
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
callq 0x11b560
jmp 0x4e7401
movl 0xc(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4e740c
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x28(%rsp)
callq 0x11b560
jmp 0x4e734c
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset(1);

            do
            {
               result = parent_t::loop_body_.first->value();
            }
            while (is_false(parent_t::condition_.first) && loop_runtime_checker::check());

            return result;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x40, %rdi
movl $0x1, %esi
callq 0x4e6f20
movq 0x10(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x39cc60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4e7b5c
jmp 0x4e7b6e
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
callq 0x4e6f40
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4e7b2a
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            do
            {
               result = loop_body_.first->value();
            }
            while (is_false(condition_.first));

            return result;
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x39cc60
testb $0x1, %al
jne 0x4e7cdb
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            do
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }
            while (is_false(parent_t::condition_.first) && loop_runtime_checker::check());

            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
addq $0x40, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e6f20
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movsd %xmm0, 0x10(%rsp)
jmp 0x4e7f63
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x4e7fd6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4e7fb5
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
callq 0x11b560
jmp 0x4e801f
movl 0xc(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4e802a
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x28(%rsp)
callq 0x11b560
jmp 0x4e7fd8
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x39cc60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xb(%rsp)
jne 0x4e7ff5
jmp 0x4e8007
movq 0x18(%rsp), %rdi
addq $0x40, %rdi
callq 0x4e6f40
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
testb $0x1, %al
jne 0x4e7f49
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            do
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }
            while (is_false(parent_t::condition_.first));

            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movsd %xmm0, 0x10(%rsp)
jmp 0x4e8146
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x4e81b9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x4e8198
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
callq 0x11b560
jmp 0x4e81dd
movl 0xc(%rsp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x4e81e8
movq 0x38(%rsp), %rdi
callq 0x11b0a0
movq %rax, 0x28(%rsp)
callq 0x11b560
jmp 0x4e81bb
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x39cc60
testb $0x1, %al
jne 0x4e812c
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_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)
                       )
                  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 0x4e836a
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 0x4e8322
jmp 0x4e8357
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x4e8337
jmp 0x4e8353
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rax
cmpq 0x28(%rsp), %rax
jne 0x4e8353
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4e8378
jmp 0x4e8355
jmp 0x4e8357
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4e82d5
movq 0x8(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_variable(const std::string& variable_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().variable_store
                           .symbol_exists(variable_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 0x4e8437
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x4e83ef
jmp 0x4e8424
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x234330
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x234670
testb $0x1, %al
jne 0x4e8419
jmp 0x4e8420
movb $0x1, 0x37(%rsp)
jmp 0x4e843c
jmp 0x4e8422
jmp 0x4e8424
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x4e83b1
movb $0x0, 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>::scope_element::operator<(exprtk::parser<double>::scope_element const&) const
bool operator < (const scope_element& se) const
         {
            if (ip_index < se.ip_index)
               return true;
            else if (ip_index > se.ip_index)
               return false;
            else if (depth < se.depth)
               return true;
            else if (depth > se.depth)
               return false;
            else if (index < se.index)
               return true;
            else if (index > se.index)
               return false;
            else
               return (name < se.name);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jae 0x4ea341
movb $0x1, 0x27(%rsp)
jmp 0x4ea3e0
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x40(%rcx), %rax
jbe 0x4ea35f
movb $0x0, 0x27(%rsp)
jmp 0x4ea3e0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jae 0x4ea37a
movb $0x1, 0x27(%rsp)
jmp 0x4ea3e0
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x30(%rcx), %rax
jbe 0x4ea395
movb $0x0, 0x27(%rsp)
jmp 0x4ea3e0
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jae 0x4ea3b0
movb $0x1, 0x27(%rsp)
jmp 0x4ea3e0
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x28(%rcx), %rax
jbe 0x4ea3cb
movb $0x0, 0x27(%rsp)
jmp 0x4ea3e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x230f70
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::collect_nodes(std::vector<exprtk::details::expression_node<double>**, std::allocator<exprtk::details::expression_node<double>**>>&)
void collect_nodes(typename expression_node<T>::noderef_list_t& node_delete_list) exprtk_override
         {
            expression_node<T>::ndb_t::collect(initialiser_ , node_delete_list);
            expression_node<T>::ndb_t::collect(condition_   , node_delete_list);
            expression_node<T>::ndb_t::collect(incrementor_ , node_delete_list);
            expression_node<T>::ndb_t::collect(loop_body_   , node_delete_list);
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x20, %rsi
movq 0x8(%rsp), %rdx
callq 0x3a0290
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x30, %rsi
movq 0x8(%rsp), %rdx
callq 0x3a0290
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x40, %rsi
movq 0x8(%rsp), %rdx
callq 0x3a0290
movq (%rsp), %rsi
movq %rsi, %rdi
addq $0x8, %rdi
addq $0x50, %rsi
movq 0x8(%rsp), %rdx
callq 0x3a0290
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            if (parent_t::initialiser_.first)
               parent_t::initialiser_.first->value();

            if (parent_t::incrementor_.first)
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  result = parent_t::loop_body_.first->value();
                  parent_t::incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  result = parent_t::loop_body_.first->value();
               }
            }

            return result;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x4e6f20
movq 0x10(%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x4eb324
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4eb393
jmp 0x4eb332
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x4e4d70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4eb34f
jmp 0x4eb361
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x4e6f40
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x4eb36b
jmp 0x4eb391
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rsp)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4eb332
jmp 0x4eb3e7
jmp 0x4eb395
movq 0x10(%rsp), %rdi
addq $0x30, %rdi
callq 0x4e4d70
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xe(%rsp)
jne 0x4eb3b2
jmp 0x4eb3c4
movq 0x10(%rsp), %rdi
addq $0x60, %rdi
callq 0x4e6f40
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x4eb3ce
jmp 0x4eb3e5
movq 0x10(%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
jmp 0x4eb395
jmp 0x4eb3e7
movsd 0x18(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            if (initialiser_.first)
               initialiser_.first->value();

            if (incrementor_.first)
            {
               while (is_true(condition_))
               {
                  result = loop_body_.first->value();
                  incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(condition_))
               {
                  result = loop_body_.first->value();
               }
            }

            return result;
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpq $0x0, 0x20(%rax)
je 0x4eb560
movq (%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
cmpq $0x0, 0x40(%rax)
je 0x4eb5a6
jmp 0x4eb56d
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x4e4d70
testb $0x1, %al
jne 0x4eb580
jmp 0x4eb5a4
movq (%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x4eb56d
jmp 0x4eb5d3
jmp 0x4eb5a8
movq (%rsp), %rdi
addq $0x30, %rdi
callq 0x4e4d70
testb $0x1, %al
jne 0x4eb5bb
jmp 0x4eb5d1
movq (%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
jmp 0x4eb5a8
jmp 0x4eb5d3
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::pair<exprtk::details::expression_node<double>*, bool>>(std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const BranchType& n0, const BranchType& n1,
                                        const BranchType& n2, const BranchType& n3) const
         {
            if (!depth_set)
            {
               depth = 1 + max_node_depth(n0, n1, n2, n3);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x8(%rax)
jne 0x4eb6bf
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x4eb6d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::for_loop_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
for_loop_node(expression_ptr initialiser,
                       expression_ptr condition,
                       expression_ptr incrementor,
                       expression_ptr loop_body)
         {
            construct_branch_pair(initialiser_, initialiser);
            construct_branch_pair(condition_  , condition  );
            construct_branch_pair(incrementor_, incrementor);
            construct_branch_pair(loop_body_  , loop_body  );
            assert(valid());
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x235e40
movq 0x8(%rsp), %rdi
leaq 0x2daf40(%rip), %rax    # 0x7c66f8
movq %rax, (%rdi)
leaq 0x2daf86(%rip), %rax    # 0x7c6748
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
callq 0x39dfb0
jmp 0x4eb7d1
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
callq 0x39dfb0
jmp 0x4eb7e1
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x39dfb0
jmp 0x4eb7f1
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x39dfb0
jmp 0x4eb801
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x38(%rsp), %rsi
callq 0x39d4f0
jmp 0x4eb816
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x30(%rsp), %rsi
callq 0x39d4f0
jmp 0x4eb82b
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
movq 0x28(%rsp), %rsi
callq 0x39d4f0
jmp 0x4eb840
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
movq 0x20(%rsp), %rsi
callq 0x39d4f0
jmp 0x4eb855
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x236080
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::const_optimise_switch<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr const_optimise_switch(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            expression_node_ptr result = error_node();

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

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

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

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

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

            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x2821f0
movq %rax, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
shrq %rcx
cmpq %rcx, %rax
jae 0x4ec8d1
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
shlq %rsi
callq 0x39d110
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
shlq %rsi
addq $0x1, %rsi
callq 0x39d110
movq (%rax), %rax
movq %rax, 0x28(%rsp)
xorl %eax, %eax
cmpq 0x40(%rsp), %rax
jne 0x4ec8bc
movq 0x30(%rsp), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ec8b0
jmp 0x4ec8bc
movq 0x28(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x4ec8d1
jmp 0x4ec8be
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x4ec83b
xorl %eax, %eax
cmpq 0x40(%rsp), %rax
jne 0x4ec8ec
movq 0x48(%rsp), %rdi
callq 0x37d7e0
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x4ec964
movq 0x48(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x39d110
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x4ec952
movq 0x18(%rsp), %rax
cmpq 0x40(%rsp), %rax
je 0x4ec952
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
leaq 0x18(%rsp), %rsi
callq 0x284bd0
jmp 0x4ec954
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x4ec8f5
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::switch_node<double>::value() const
inline T value() const exprtk_override
         {
            const std::size_t upper_bound = (arg_list_.size() - 1);

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

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

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x39d8c0
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x4ed026
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
callq 0x39e500
movq (%rsp), %rdi
movq (%rax), %rax
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
movq 0x18(%rsp), %rsi
addq $0x1, %rsi
callq 0x39e500
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ed001
jmp 0x4ed014
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x30(%rsp)
jmp 0x4ed047
jmp 0x4ed016
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0x4ecfad
movq (%rsp), %rdi
addq $0x20, %rdi
movq 0x20(%rsp), %rsi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_5::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4)

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

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ed7c5
jmp 0x4ed7e8
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ed8fb
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ed805
jmp 0x4ed828
movq 0x8(%rsp), %rdi
movl $0x3, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ed8fb
movq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ed845
jmp 0x4ed868
movq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ed8fb
movq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ed885
jmp 0x4ed8a5
movq 0x8(%rsp), %rdi
movl $0x7, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ed8fb
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ed8c2
jmp 0x4ed8e2
movq 0x8(%rsp), %rdi
movl $0x9, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ed8fb
movq 0x8(%rsp), %rdi
callq 0x3a8490
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_6::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4) case_stmt(5)

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

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4eda25
jmp 0x4eda48
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4edb9b
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4eda65
jmp 0x4eda88
movq 0x8(%rsp), %rdi
movl $0x3, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4edb9b
movq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edaa5
jmp 0x4edac8
movq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4edb9b
movq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edae5
jmp 0x4edb08
movq 0x8(%rsp), %rdi
movl $0x7, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4edb9b
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edb25
jmp 0x4edb45
movq 0x8(%rsp), %rdi
movl $0x9, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4edb9b
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edb62
jmp 0x4edb82
movq 0x8(%rsp), %rdi
movl $0xb, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4edb9b
movq 0x8(%rsp), %rdi
callq 0x3a8490
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_7::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4) case_stmt(5)
                  case_stmt(6)

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

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edcc5
jmp 0x4edce8
movq 0x8(%rsp), %rdi
movl $0x1, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
movl $0x2, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edd05
jmp 0x4edd28
movq 0x8(%rsp), %rdi
movl $0x3, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
movl $0x4, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edd45
jmp 0x4edd68
movq 0x8(%rsp), %rdi
movl $0x5, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
movl $0x6, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4edd85
jmp 0x4edda8
movq 0x8(%rsp), %rdi
movl $0x7, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
movl $0x8, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4eddc5
jmp 0x4edde8
movq 0x8(%rsp), %rdi
movl $0x9, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ede05
jmp 0x4ede25
movq 0x8(%rsp), %rdi
movl $0xb, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
movl $0xc, %esi
callq 0x39e500
movq (%rax), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x4ede42
jmp 0x4ede62
movq 0x8(%rsp), %rdi
movl $0xd, %esi
callq 0x39e500
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
jmp 0x4ede7b
movq 0x8(%rsp), %rdi
callq 0x3a8490
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::all_nodes_variables<3ul, double>(exprtk::details::expression_node<double>* const (&) [3ul])
inline bool all_nodes_variables(expression_node<T>* const (&b)[N])
      {
         for (std::size_t i = 0; i < N; ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }

         return true;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x3, (%rsp)
jae 0x4eff8f
movq 0x8(%rsp), %rcx
movq (%rsp), %rdx
xorl %eax, %eax
cmpq (%rcx,%rdx,8), %rax
jne 0x4eff60
movb $0x0, 0x17(%rsp)
jmp 0x4eff94
movq 0x8(%rsp), %rax
movq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x4eff7d
movb $0x0, 0x17(%rsp)
jmp 0x4eff94
jmp 0x4eff7f
jmp 0x4eff81
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x4eff41
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop