LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scoped_vec_delete<exprtk::details::expression_node<double>>::~scoped_vec_delete()
~scoped_vec_delete()
         {
            if (delete_ptr && !vec_.empty())
            {
               for (std::size_t i = 0; i < vec_.size(); ++i)
               {
                  exprtk_debug(("~scoped_vec_delete() - deleting node: %p\n", reinterpret_cast<void*>(vec_[i])));
                  free_node(parser_.node_allocator_,vec_[i]);
               }

               vec_.clear();
            }
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, (%rax)
je 0x37df6b
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x37d750
testb $0x1, %al
jne 0x37df6b
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x37df5d
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rdi
addq $0x290, %rax            # imm = 0x290
movq %rax, (%rsp)
movq 0x18(%rsp), %rsi
callq 0x39d110
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x284bd0
jmp 0x37df4b
jmp 0x37df4d
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x37def7
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x39d130
addq $0x28, %rsp
retq
movq %rax, %rdi
callq 0x22cbc0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::state_t::set(exprtk::parser<double>::precedence_level const&, exprtk::parser<double>::precedence_level const&, exprtk::details::operator_type const&, exprtk::lexer::token)
inline void set(const precedence_level& l,
                         const precedence_level& r,
                         const details::operator_type& o,
                         const token_t tkn = token_t())
         {
            left      = l;
            right     = r;
            operation = o;
            token     = tkn;
         }

// Assembly:
subq $0x38, %rsp
movq %r8, 0x8(%rsp)
movq %rsi, %rax
movq 0x8(%rsp), %rsi
movq %rdi, 0x30(%rsp)
movq %rax, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movl (%rax), %eax
movl %eax, (%rdi)
movq 0x20(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x4(%rdi)
movq 0x18(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x259470
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::imatch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool imatch(const std::string& s1, const std::string& s2)
      {
         if (s1.size() == s2.size())
         {
            for (std::size_t i = 0; i < s1.size(); ++i)
            {
               if (std::tolower(s1[i]) != std::tolower(s2[i]))
               {
                  return false;
               }
            }

            return true;
         }

         return false;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11b270
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jne 0x37fbde
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x37fbd7
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %edi
callq 0x11b5f0
movl %eax, 0x4(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %edi
callq 0x11b5f0
movl %eax, %ecx
movl 0x4(%rsp), %eax
cmpl %ecx, %eax
je 0x37fbc5
movb $0x0, 0x37(%rsp)
jmp 0x37fbe3
jmp 0x37fbc7
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x37fb61
movb $0x1, 0x37(%rsp)
jmp 0x37fbe3
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::parse_pending_string_rangesize(exprtk::details::expression_node<double>*&)
inline bool parse_pending_string_rangesize(expression_node_ptr& expression)
      {
         // Allow no more than 100 range calls, eg: s[][][]...[][]
         const std::size_t max_rangesize_parses = 100;

         std::size_t i = 0;

         while
            (
              (0 != expression)                     &&
              (i++ < max_rangesize_parses)          &&
              error_list_.empty()                   &&
              is_generally_string_node(expression)  &&
              token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold)
            )
         {
            expression = parse_string_range_statement(expression);
         }

         return (i > 1);
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x64, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rdx
xorl %eax, %eax
xorl %ecx, %ecx
cmpq (%rdx), %rcx
movb %al, 0x7(%rsp)
je 0x37fca2
movq 0x18(%rsp), %rcx
movq %rcx, %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x64, %rcx
movb %al, 0x7(%rsp)
jae 0x37fca2
movq 0x8(%rsp), %rdi
addq $0x308, %rdi            # imm = 0x308
callq 0x3741c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x37fc69
jmp 0x37fca2
movq 0x28(%rsp), %rax
movq (%rax), %rdi
callq 0x3a7600
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x37fc85
jmp 0x37fca2
movq 0x8(%rsp), %rdi
movl $0x5b, 0x14(%rsp)
leaq 0x14(%rsp), %rsi
xorl %edx, %edx
callq 0x37d640
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x37fcac
jmp 0x37fccb
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x556d40
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
jmp 0x37fc1a
cmpq $0x1, 0x18(%rsp)
seta %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::operator()(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&)
inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr& b0, expression_node_ptr& b1)
         {
            expression_node_ptr result = error_node();

            if ((0 != b0) && (0 != b1))
            {
               expression_node_ptr branch[2] = { b0, b1 };
               result = expression_generator<Type>::operator()(operation, branch);
               b0 = branch[0];
               b1 = branch[1];
            }

            return result;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x2821f0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x380a01
movq 0x28(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x380a01
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x3ad9f0
movq %rax, 0x20(%rsp)
movq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_logic_opr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_logic_opr(const std::string& lgc_opr)
      {
         for (std::size_t i = 0; i < logic_ops_list_size; ++i)
         {
            if (imatch(lgc_opr, logic_ops_list[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x9, (%rsp)
jae 0x381951
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
leaq 0x4531c8(%rip), %rsi    # 0x7d4af0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x38193a
jmp 0x381941
movb $0x1, 0x17(%rsp)
jmp 0x381956
jmp 0x381943
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x381911
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::parse_not_statement()
inline expression_node_ptr parse_not_statement()
      {
         if (settings_.logic_disabled("not"))
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR063 - Invalid or disabled logic operation 'not'",
               exprtk_error_location));

            return error_node();
         }

         return parse_base_operation();
      }

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x178(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0xd0, %rax
movq %rax, 0x20(%rsp)
leaq 0x157(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x11b6f0
movq 0x28(%rsp), %rdx
leaq 0x21a930(%rip), %rsi    # 0x5a0555
leaq 0x158(%rsp), %rdi
callq 0x134520
jmp 0x385c34
movq 0x20(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x3aca00
movb %al, 0x17(%rsp)
jmp 0x385c4c
leaq 0x158(%rsp), %rdi
callq 0x11b838
leaq 0x157(%rsp), %rdi
callq 0x11b820
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x385c73
jmp 0x385e3d
movq 0x18(%rsp), %rdi
callq 0x373e90
movq %rax, (%rsp)
leaq 0x77(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11b6f0
movq 0x8(%rsp), %rdx
leaq 0x221b82(%rip), %rsi    # 0x5a781e
leaq 0x78(%rsp), %rdi
callq 0x134520
jmp 0x385ca8
leaq 0x30(%rsp), %rdi
movl $0x680e, %esi           # imm = 0x680E
callq 0x371f20
jmp 0x385cb9
leaq 0x221253(%rip), %rsi    # 0x5a6f13
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x29dd70
jmp 0x385cd1
movq (%rsp), %rdx
leaq 0x98(%rsp), %rdi
movl $0x1, %esi
leaq 0x78(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x3741e0
jmp 0x385cf3
movq 0x18(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x371e40
jmp 0x385d07
leaq 0x98(%rsp), %rdi
callq 0x371330
leaq 0x50(%rsp), %rdi
callq 0x11b838
leaq 0x30(%rsp), %rdi
callq 0x11b838
leaq 0x78(%rsp), %rdi
callq 0x11b838
leaq 0x77(%rsp), %rdi
callq 0x11b820
callq 0x2821f0
movq %rax, 0x180(%rsp)
jmp 0x385e4f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
jmp 0x385d85
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0x158(%rsp), %rdi
callq 0x11b838
leaq 0x157(%rsp), %rdi
callq 0x11b820
jmp 0x385e5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
jmp 0x385e31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
jmp 0x385e27
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
jmp 0x385e1d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
jmp 0x385e13
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x148(%rsp)
movl %eax, 0x144(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x371330
leaq 0x50(%rsp), %rdi
callq 0x11b838
leaq 0x30(%rsp), %rdi
callq 0x11b838
leaq 0x78(%rsp), %rdi
callq 0x11b838
leaq 0x77(%rsp), %rdi
callq 0x11b820
jmp 0x385e5f
movq 0x18(%rsp), %rdi
callq 0x385f30
movq %rax, 0x180(%rsp)
movq 0x180(%rsp), %rax
addq $0x188, %rsp            # imm = 0x188
retq
movq 0x148(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::valid_base_operation(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool valid_base_operation(const std::string& symbol) const
      {
         const std::size_t length = symbol.size();

         if (
              (length < 3) || // Shortest base op symbol length
              (length > 9)    // Longest base op symbol length
            )
            return false;
         else
            return settings_.function_enabled(symbol) &&
                   (base_ops_map_.end() != base_ops_map_.find(symbol));
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x11b270
movq %rax, 0x28(%rsp)
cmpq $0x3, 0x28(%rsp)
jb 0x385ea7
cmpq $0x9, 0x28(%rsp)
jbe 0x385eae
movb $0x0, 0x47(%rsp)
jmp 0x385f21
movq 0x10(%rsp), %rdi
addq $0xd0, %rdi
movq 0x30(%rsp), %rsi
callq 0x3990c0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x385ed3
jmp 0x385f17
movq 0x10(%rsp), %rdi
addq $0x3f0, %rdi            # imm = 0x3F0
callq 0x3acaa0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x3f0, %rdi            # imm = 0x3F0
movq 0x30(%rsp), %rsi
callq 0x3acad0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3aca80
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
movb %al, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::check_block_statement_closure(exprtk::details::expression_node<double>*)
inline expression_node_ptr check_block_statement_closure(expression_node_ptr expression)
      {
         if (
              expression &&
              (
                (current_token().type == token_t::e_symbol) ||
                (current_token().type == token_t::e_number)
              )
            )
         {
            free_node(node_allocator_, expression);

            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR240 - Invalid syntax '" + current_token().value  + "' possible missing operator or context",
               exprtk_error_location));

               return error_node();
         }

         return expression;
      }

// Assembly:
subq $0x168, %rsp            # imm = 0x168
movq %rdi, 0x158(%rsp)
movq %rsi, 0x150(%rsp)
movq 0x158(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x150(%rsp)
je 0x387022
movq 0x10(%rsp), %rdi
callq 0x373e90
cmpl $0x8, (%rax)
je 0x386e85
movq 0x10(%rsp), %rdi
callq 0x373e90
cmpl $0x7, (%rax)
jne 0x387022
movq 0x10(%rsp), %rdi
addq $0x290, %rdi            # imm = 0x290
leaq 0x150(%rsp), %rsi
callq 0x284bd0
movq 0x10(%rsp), %rdi
callq 0x373e90
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
callq 0x373e90
movq %rax, %rdx
addq $0x8, %rdx
leaq 0x22176d(%rip), %rsi    # 0x5a8631
leaq 0x68(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3784f0
movq 0x8(%rsp), %rsi
leaq 0x220278(%rip), %rdx    # 0x5a7157
leaq 0x88(%rsp), %rdi
callq 0x29dc30
jmp 0x386eee
leaq 0x18(%rsp), %rdi
movl $0x7a35, %esi           # imm = 0x7A35
callq 0x371f20
jmp 0x386eff
leaq 0x22000d(%rip), %rsi    # 0x5a6f13
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rdx
callq 0x29dd70
jmp 0x386f17
movq (%rsp), %rdx
leaq 0xa8(%rsp), %rdi
movl $0x1, %esi
leaq 0x88(%rsp), %rcx
leaq 0x38(%rsp), %r8
callq 0x3741e0
jmp 0x386f3c
movq 0x10(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x371e40
jmp 0x386f50
leaq 0xa8(%rsp), %rdi
callq 0x371330
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x18(%rsp), %rdi
callq 0x11b838
leaq 0x88(%rsp), %rdi
callq 0x11b838
leaq 0x68(%rsp), %rdi
callq 0x11b838
callq 0x2821f0
movq %rax, 0x160(%rsp)
jmp 0x387032
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x387016
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x387009
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x386fff
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x386ff5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x371330
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x18(%rsp), %rdi
callq 0x11b838
leaq 0x88(%rsp), %rdi
callq 0x11b838
leaq 0x68(%rsp), %rdi
callq 0x11b838
jmp 0x387042
movq 0x150(%rsp), %rax
movq %rax, 0x160(%rsp)
movq 0x160(%rsp), %rax
addq $0x168, %rsp            # imm = 0x168
retq
movq 0x60(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_valid_sf_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_valid_sf_symbol(const std::string& symbol)
      {
         // Special function: $f12 or $F34
         return (4 == symbol.size())  &&
                ('$' == symbol[0])    &&
                imatch('f',symbol[1]) &&
                is_digit(symbol[2])   &&
                is_digit(symbol[3]);
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11b270
movq %rax, %rdx
xorl %eax, %eax
movl $0x4, %ecx
cmpq %rdx, %rcx
movb %al, 0xf(%rsp)
jne 0x38d316
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11b770
movsbl (%rax), %edx
xorl %eax, %eax
movl $0x24, %ecx
cmpl %edx, %ecx
movb %al, 0xf(%rsp)
jne 0x38d316
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x11b770
movl $0x66, %edi
movsbl (%rax), %esi
callq 0x377870
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x38d2d5
jmp 0x38d316
movq 0x10(%rsp), %rdi
movl $0x2, %esi
callq 0x11b770
movsbl (%rax), %edi
callq 0x2343b0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x38d2fb
jmp 0x38d316
movq 0x10(%rsp), %rdi
movl $0x3, %esi
callq 0x11b770
movsbl (%rax), %edi
callq 0x2343b0
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::valid() const
inline bool valid() const
         {
            if (!empty())
            {
               for (std::size_t i = 0; i < symtab_list_.size(); ++i)
               {
                  if (symtab_list_[i].valid())
                     return true;
               }
            }

            return false;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x528db0
testb $0x1, %al
jne 0x396ebc
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x396eba
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x396ea1
jmp 0x396ea8
movb $0x1, 0x27(%rsp)
jmp 0x396ec1
jmp 0x396eaa
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x396e65
jmp 0x396ebc
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token::seperator_to_str[abi:cxx11](exprtk::lexer::token::token_type)
static inline std::string seperator_to_str(const token_type t)
         {
            switch (t)
            {
               case e_comma : return ",";
               case e_colon : return ":";
               case e_eof   : return ";";
               default      : return "UNKNOWN";
            }

            #if !defined(_MSC_VER) && !defined(__NVCOMPILER)
            return "UNKNOWN";
            #endif
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
movl %eax, 0x34(%rsp)
subl $0x6, %eax
je 0x39c98c
jmp 0x39c8cd
movl 0x34(%rsp), %eax
subl $0x2c, %eax
je 0x39c8e6
jmp 0x39c8d8
movl 0x34(%rsp), %eax
subl $0x3a, %eax
je 0x39c939
jmp 0x39c9d9
leaq 0x4b(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11b6f0
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x20cb76(%rip), %rsi    # 0x5a947c
callq 0x134520
jmp 0x39c90d
leaq 0x4b(%rsp), %rdi
callq 0x11b820
jmp 0x39ca24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4b(%rsp), %rdi
callq 0x11b820
jmp 0x39ca2e
leaq 0x3b(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b6f0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x20a5c4(%rip), %rsi    # 0x5a6f1d
callq 0x134520
jmp 0x39c960
leaq 0x3b(%rsp), %rdi
callq 0x11b820
jmp 0x39ca24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x3b(%rsp), %rdi
callq 0x11b820
jmp 0x39ca2e
leaq 0x3a(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11b6f0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rdx
leaq 0x227341(%rip), %rsi    # 0x5c3ced
callq 0x134520
jmp 0x39c9b3
leaq 0x3a(%rsp), %rdi
callq 0x11b820
jmp 0x39ca24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x3a(%rsp), %rdi
callq 0x11b820
jmp 0x39ca2e
leaq 0x39(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x11b6f0
movq 0x20(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x20a4dc(%rip), %rsi    # 0x5a6ed3
callq 0x134520
jmp 0x39c9fe
leaq 0x39(%rsp), %rdi
callq 0x11b820
jmp 0x39ca24
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x39(%rsp), %rdi
callq 0x11b820
jmp 0x39ca2e
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::deactivate(unsigned long const&)
inline void deactivate(const std::size_t& scope_depth)
         {
            exprtk_debug(("deactivate() - Scope depth: %d\n",
                          static_cast<int>(parser_.state_.scope_depth)));

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

               if (se.active && (se.depth >= scope_depth))
               {
                  exprtk_debug(("deactivate() - element[%02d] '%s'\n",
                                static_cast<int>(i),
                                se.name.c_str()));

                  se.active = false;
               }
            }
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x374590
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x39cbe7
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
callq 0x374750
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
testb $0x1, 0x4c(%rax)
je 0x39cbd5
movq 0x18(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rsp), %rcx
cmpq (%rcx), %rax
jb 0x39cbd5
movq 0x18(%rsp), %rax
movb $0x0, 0x4c(%rax)
jmp 0x39cbd7
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x39cb71
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::multi_switch_statement<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 multi_switch_statement(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            if (!all_nodes_valid(arg_list))
            {
               details::free_all_nodes(*node_allocator_,arg_list);

               return error_node();
            }
            else if (is_constant_foldable(arg_list))
               return const_optimise_mswitch(arg_list);
            else
               return node_allocator_->allocate<details::multi_switch_node<Type> >(arg_list);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x39cd40
testb $0x1, %al
jne 0x39cce5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x39cdc0
callq 0x2821f0
movq %rax, 0x20(%rsp)
jmp 0x39cd28
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x39ce40
testb $0x1, %al
jne 0x39ccfa
jmp 0x39cd10
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x39cee0
movq %rax, 0x20(%rsp)
jmp 0x39cd28
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x39d050
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::is_constant_foldable<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&) const
inline bool is_constant_foldable(const Sequence<NodePtr,Allocator>& b) const
         {
            for (std::size_t i = 0; i < b.size(); ++i)
            {
               if (0 == b[i])
                  return false;
               else if (!details::is_constant_node(b[i]))
                  return false;
            }

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x39cecc
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x39d0f0
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x39ce96
movb $0x0, 0x27(%rsp)
jmp 0x39ced1
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x39ceb8
movb $0x0, 0x27(%rsp)
jmp 0x39ced1
jmp 0x39ceba
jmp 0x39cebc
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x39ce57
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::const_optimise_mswitch<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_mswitch(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 (details::is_true(condition))
               {
                  result = consequent;
               }
            }

            if (0 == result)
            {
               const T zero = T(0);
               result       = node_allocator_->allocate<literal_node_t>(zero);
            }

            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))
               {
                  details::free_node(*node_allocator_,current_expr);
               }
            }

            return result;
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
callq 0x2821f0
movq %rax, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
shrq %rcx
cmpq %rcx, %rax
jae 0x39cf96
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
shlq %rsi
callq 0x39d110
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rsi
shlq %rsi
addq $0x1, %rsi
callq 0x39d110
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x39d260
testb $0x1, %al
jne 0x39cf77
jmp 0x39cf81
movq 0x38(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x39cf83
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x39cf0b
xorl %eax, %eax
cmpq 0x50(%rsp), %rax
jne 0x39cfc0
movq 0x18(%rsp), %rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x8(%rax), %rdi
leaq 0x30(%rsp), %rsi
callq 0x285670
movq %rax, 0x50(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x39d03d
movq 0x58(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x39d110
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq $0x0, (%rax)
je 0x39d02b
movq 0x20(%rsp), %rax
movq (%rax), %rax
cmpq 0x50(%rsp), %rax
je 0x39d02b
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x284bd0
jmp 0x39d02d
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x39cfc9
movq 0x50(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multi_switch_node<double>::multi_switch_node<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
         {
            if (0 != (arg_list.size() & 1))
               return;

            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid())
               {
                  construct_branch_pair(arg_list_[i], arg_list[i]);
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            assert(valid());
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x235e40
movq 0x20(%rsp), %rdi
leaq 0x3fe91f(%rip), %rax    # 0x79bbe8
addq $0x10, %rax
movq %rax, (%rdi)
leaq 0x3fe911(%rip), %rax    # 0x79bbe8
addq $0x60, %rax
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
movq %rdi, 0x28(%rsp)
callq 0x39d440
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
andq $0x1, %rcx
xorl %eax, %eax
cmpq %rcx, %rax
je 0x39d30a
jmp 0x39d422
movq 0x20(%rsp), %rax
addq $0x20, %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x39d450
jmp 0x39d331
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x39d422
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39d0f0
cmpq $0x0, (%rax)
je 0x39d3fd
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movb %al, 0xf(%rsp)
jmp 0x39d399
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x39d3a3
jmp 0x39d3fd
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x30(%rsp), %rsi
callq 0x39d550
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39d0f0
movq (%rsp), %rdi
movq (%rax), %rsi
callq 0x39d4f0
jmp 0x39d3d7
jmp 0x39d40d
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x39d590
movq 0x20(%rsp), %rdi
callq 0x236080
jmp 0x39d427
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x39d570
jmp 0x39d422
jmp 0x39d40f
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x39d33a
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multi_switch_node<double>::value() const
inline T value() const exprtk_override
         {
            const std::size_t upper_bound = (arg_list_.size() - 1);

            T result = T(0);

            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))
               {
                  result = consequent->value();
               }
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
addq $0x20, %rdi
callq 0x39d8c0
subq $0x1, %rax
movq %rax, 0x28(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x39d72d
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 0x39d70a
jmp 0x39d71b
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x20(%rsp)
jmp 0x39d71d
movq 0x18(%rsp), %rax
addq $0x2, %rax
movq %rax, 0x18(%rsp)
jmp 0x39d6b6
movsd 0x20(%rsp), %xmm0
addq $0x38, %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::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>, std::vector>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&) const
std::size_t compute_node_depth(const Sequence<nb_pair_t,Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i].first)
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i].first));
                  }
               }

               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 0x39e70a
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x39d8c0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x39e701
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x39e500
cmpq $0x0, (%rax)
je 0x39e6ec
movq 0x10(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x39e500
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x39e720
movq (%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x23da40
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x10(%rax)
jmp 0x39e6ee
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x39e66b
movq 0x10(%rsp), %rax
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth(exprtk::details::expression_node<double> const* const&) const
std::size_t compute_node_depth(const Node* const& node) const
         {
            if (!depth_set)
            {
               depth = 1 + (node ? node->node_depth() : 0);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
jne 0x39e785
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x39e766
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
jmp 0x39e76f
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x39e76f
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::dependent_entity_collector::add_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::symbol_type)
inline void add_symbol(const std::string& symbol, const symbol_type st)
         {
            switch (st)
            {
               case e_st_variable       :
               case e_st_vector         :
               case e_st_string         :
               case e_st_local_variable :
               case e_st_local_vector   :
               case e_st_local_string   : if (collect_variables_)
                                             symbol_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               case e_st_function       : if (collect_functions_)
                                             symbol_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               default                  : return;
            }
         }

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movl %edx, 0x94(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x94(%rsp), %eax
movl %eax, 0x2c(%rsp)
decl %eax
subl $0x2, %eax
jb 0x39e80b
jmp 0x39e7df
movl 0x2c(%rsp), %eax
subl $0x4, %eax
je 0x39e80b
jmp 0x39e7ea
movl 0x2c(%rsp), %eax
subl $0x5, %eax
je 0x39e87c
jmp 0x39e7f9
movl 0x2c(%rsp), %eax
addl $-0x6, %eax
subl $0x2, %eax
ja 0x39e8eb
jmp 0x39e80b
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x39e87a
movq 0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
movq 0x98(%rsp), %rsi
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
leaq 0x94(%rsp), %rdx
callq 0x39e930
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x39e900
jmp 0x39e854
leaq 0x68(%rsp), %rdi
callq 0x371710
jmp 0x39e87a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x371710
jmp 0x39e8f5
jmp 0x39e8ed
movq 0x20(%rsp), %rax
testb $0x1, 0x9(%rax)
je 0x39e8e9
movq 0x20(%rsp), %rax
addq $0x10, %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x94(%rsp), %rdx
callq 0x39e930
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x39e900
jmp 0x39e8c3
leaq 0x30(%rsp), %rdi
callq 0x371710
jmp 0x39e8e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x371710
jmp 0x39e8f5
jmp 0x39e8ed
jmp 0x39e8ed
addq $0xa8, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::is_ivector_node<double>(exprtk::details::expression_node<double> const*)
inline bool is_ivector_node(const expression_node<T>* node)
      {
         if (node)
         {
            switch (node->type())
            {
               case details::expression_node<T>::e_vector      :
               case details::expression_node<T>::e_vecvalass   :
               case details::expression_node<T>::e_vecvecass   :
               case details::expression_node<T>::e_vecopvalass :
               case details::expression_node<T>::e_vecopvecass :
               case details::expression_node<T>::e_vecvecswap  :
               case details::expression_node<T>::e_vecvecarith :
               case details::expression_node<T>::e_vecvalarith :
               case details::expression_node<T>::e_valvecarith :
               case details::expression_node<T>::e_vecunaryop  :
               case details::expression_node<T>::e_vecondition : return true;
               default                                         : return false;
            }
         }
         else
            return false;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x39f4c7
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
movl %eax, %ecx
movl %ecx, 0x4(%rsp)
subl $0x7c, %eax
je 0x39f4b9
jmp 0x39f48c
movl 0x4(%rsp), %eax
addl $0xffffff79, %eax       # imm = 0xFFFFFF79
subl $0x4, %eax
jb 0x39f4b9
jmp 0x39f49c
movl 0x4(%rsp), %eax
subl $0x8c, %eax
je 0x39f4b9
jmp 0x39f4a9
movl 0x4(%rsp), %eax
addl $0xffffff70, %eax       # imm = 0xFFFFFF70
subl $0x4, %eax
ja 0x39f4c0
jmp 0x39f4b9
movb $0x1, 0x17(%rsp)
jmp 0x39f4cc
movb $0x0, 0x17(%rsp)
jmp 0x39f4cc
movb $0x0, 0x17(%rsp)
movb 0x17(%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>::special_one_parameter_vararg(exprtk::details::operator_type const&) const
inline bool special_one_parameter_vararg(const details::operator_type& operation) const
         {
            return (
                     (details::e_sum  == operation) ||
                     (details::e_prod == operation) ||
                     (details::e_avg  == operation) ||
                     (details::e_min  == operation) ||
                     (details::e_max  == operation)
                   );
         }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0xc, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x39f6cd
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0xd, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x39f6cd
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0xb, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x39f6cd
movq -0x10(%rsp), %rdx
movb $0x1, %al
movl $0x9, %ecx
cmpl (%rdx), %ecx
movb %al, -0x11(%rsp)
je 0x39f6cd
movq -0x10(%rsp), %rcx
movl $0xa, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x11(%rsp)
movb -0x11(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::all_nodes_variables<double, std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
inline bool all_nodes_variables(const Sequence<expression_node<T>*,Allocator>& b)
      {
         for (std::size_t i = 0; i < b.size(); ++i)
         {
            if (0 == b[i])
               return false;
            else if (!is_variable_node(b[i]))
               return false;
         }

         return true;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x39f769
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x39d0f0
movq %rax, %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x39f733
movb $0x0, 0x27(%rsp)
jmp 0x39f76e
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x39f755
movb $0x0, 0x27(%rsp)
jmp 0x39f76e
jmp 0x39f757
jmp 0x39f759
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x39f6f2
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth(std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const nb_pair_t& branch) const
         {
            if (!depth_set)
            {
               depth = 1 + (branch.first ? branch.first->node_depth() : 0);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
jne 0x3a0d75
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x3a0d56
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
jmp 0x3a0d5f
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x3a0d5f
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_min_op<double>::process(exprtk::details::vector_interface<double>*)
static inline T process(const ivector_ptr v)
         {
            const T* vec = v->vec()->vds().data();
            const std::size_t vec_size = v->vec()->size();

            T result = vec[0];

            for (std::size_t i = 1; i < vec_size; ++i)
            {
               const T v_i = vec[i];

               if (v_i < result)
                  result = v_i;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %rdi
callq 0x3a0c40
movq %rax, %rdi
callq 0x3a0c50
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, %rdi
callq 0x3a1990
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x18(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x3a203a
movq 0x28(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x18(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3a2028
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x3a202a
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3a1fe9
movsd 0x18(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vararg_varnode<double, exprtk::details::vararg_add_op<double>>::vararg_varnode<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list)
         : initialised_(false)
         {
            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid() && is_variable_node(arg_list[i]))
               {
                  variable_node<T>* var_node_ptr = static_cast<variable_node<T>*>(arg_list[i]);
                  arg_list_[i] = (&var_node_ptr->ref());
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            initialised_ = (arg_list.size() == arg_list_.size());
            assert(valid());
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x235e40
movq 0x28(%rsp), %rdi
leaq 0x3f97af(%rip), %rax    # 0x79bf68
movq %rax, (%rdi)
leaq 0x3f97ed(%rip), %rax    # 0x79bfb0
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
movq %rdi, 0x30(%rsp)
callq 0x3a2970
movq 0x28(%rsp), %rax
movb $0x0, 0x38(%rax)
movq 0x58(%rsp), %rdi
callq 0x39d0d0
movq 0x30(%rsp), %rdi
movq %rax, %rsi
callq 0x3a2980
jmp 0x3a27f7
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x3a291f
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x39d0f0
cmpq $0x0, (%rax)
je 0x3a28fa
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movb %al, 0x1f(%rsp)
jmp 0x3a285f
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x3a286c
jmp 0x3a28fa
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rdi
callq 0x23c960
movb %al, 0x1e(%rsp)
jmp 0x3a2889
movb 0x1e(%rsp), %al
testb $0x1, %al
jne 0x3a2893
jmp 0x3a28fa
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x235f80
movq 0x28(%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x20, %rdi
movq 0x40(%rsp), %rsi
callq 0x3a2a20
movq 0x10(%rsp), %rcx
movq %rcx, (%rax)
jmp 0x3a290a
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x3a2a80
movq 0x28(%rsp), %rdi
callq 0x236080
jmp 0x3a295a
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x3a2a40
jmp 0x3a2955
jmp 0x3a290c
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x3a2800
movq 0x58(%rsp), %rdi
callq 0x39d0d0
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
addq $0x20, %rdi
callq 0x3a2a60
movq 0x8(%rsp), %rcx
movq %rax, %rdx
movq 0x28(%rsp), %rax
cmpq %rdx, %rcx
sete %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
addq $0x68, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop