LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::T0oT1oT2oT3<double, double const&, double const&, double const&, double const&, exprtk::details::T0oT1oT20T3process<double>::mode0>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::T0oT1oT2oT3<double, double const&, double const&, double const&, double const&, exprtk::details::T0oT1oT20T3process<double>::mode0>, double const&, double const&, double const&, double const&, double (*)(double const&, double const&), double (*)(double const&, double const&), double (*)(double const&, double const&)>(double const&, double const&, double const&, double const&, double (*)(double const&, double const&), double (*)(double const&, double const&), double (*)(double const&, double const&)) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2,
                                                                               T3 t3, T4 t4,
                                                                               T5 t5, T6 t6,
                                                                               T7 t7) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x68, %rsp
movq 0x78(%rsp), %rax
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movl $0x58, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x38(%rsp), %r9
movq 0x70(%rsp), %r10
movq 0x78(%rsp), %r11
movq %rsp, %rax
movq %r11, 0x8(%rax)
movq %r10, (%rax)
callq 0x2d2d90
jmp 0x2d2d35
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
movl $0x58, %esi
callq 0x11b130
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::cleanup()
inline void cleanup()
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               free_element(element_[i]);
            }

            element_.clear();

            input_param_cnt_             = 0;
            total_local_symb_size_bytes_ = 0;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x374590
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x371a21
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
callq 0x374750
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3745b0
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3719cc
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x374770
movq 0x10(%rsp), %rax
movq $0x0, 0x90(%rax)
movq $0x0, 0x98(%rax)
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::return_cleanup()
inline void return_cleanup()
      {
         #ifndef exprtk_disable_return_statement
         if (results_context_)
         {
            delete results_context_;
            results_context_ = 0;
         }

         state_.return_stmt_present = false;
         #endif
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x3d0(%rax)
je 0x371aaa
movq 0x8(%rsp), %rax
movq 0x3d0(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x371a9a
movq (%rsp), %rdi
callq 0x23c8e0
movq (%rsp), %rdi
movl $0x20, %esi
callq 0x11b130
movq 0x8(%rsp), %rax
movq $0x0, 0x3d0(%rax)
movq 0x8(%rsp), %rax
movb $0x0, 0x3ab(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser_error::make_error(exprtk::parser_error::error_mode, 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 type make_error(const error_mode mode,
                             const std::string& diagnostic   = "",
                             const std::string& src_location = "")
      {
         type t;
         t.mode         = mode;
         t.token.type   = lexer::token::e_error;
         t.diagnostic   = diagnostic;
         t.src_location = src_location;
         exprtk_debug(("%s\n", diagnostic .c_str()));
         return t;
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movb $0x0, 0x27(%rsp)
callq 0x3756d0
movq 0x8(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0x30(%rdi)
movl $0x1, (%rdi)
movq 0x30(%rsp), %rsi
addq $0x38, %rdi
callq 0x11b7c0
jmp 0x371ebf
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
addq $0x58, %rdi
callq 0x11b7c0
jmp 0x371ed4
movb $0x1, 0x27(%rsp)
testb $0x1, 0x27(%rsp)
jne 0x371f06
jmp 0x371efc
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x371330
jmp 0x371f0f
movq 0x8(%rsp), %rdi
callq 0x371330
movq (%rsp), %rax
addq $0x48, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool init(const std::string& str)
         {
            if (!lexer_.process(str))
            {
               return false;
            }

            lexer_.begin();

            next_token();

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %rsi
callq 0x3758d0
testb $0x1, %al
jne 0x371f7d
movb $0x0, 0x27(%rsp)
jmp 0x371f96
movq 0x8(%rsp), %rdi
callq 0x373640
movq 0x8(%rsp), %rdi
callq 0x373690
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>::dependent_entity_collector::clear()
void clear()
         {
            symbol_name_list_    .clear();
            assignment_name_list_.clear();
            retparam_list_       .clear();
            return_present_    = false;
            final_stmt_return_ = false;
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x10, %rdi
callq 0x3796a0
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
callq 0x3796a0
movq 0x8(%rsp), %rdi
addq $0x40, %rdi
callq 0x3796c0
movq 0x8(%rsp), %rax
movb $0x0, 0xb(%rax)
movb $0x0, 0xc(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::return_envelope(exprtk::details::expression_node<double>*, exprtk::results_context<double>*, bool*&)
inline expression_node_ptr return_envelope(expression_node_ptr body,
                                                    results_context_t* rc,
                                                    bool*& return_invoked)
         {
            typedef details::return_envelope_node<Type> alloc_type;

            expression_node_ptr result = node_allocator_->
                                            allocate_cr<alloc_type>(body,(*rc));

            return_invoked = static_cast<alloc_type*>(result)->retinvk_ptr();

            return result;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rdx
leaq 0x18(%rsp), %rsi
callq 0x55ba40
movq %rax, (%rsp)
movq (%rsp), %rdi
callq 0x55bad0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser_error::make_error(exprtk::parser_error::error_mode, exprtk::lexer::token const&, 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 type make_error(const error_mode mode,
                             const lexer::token& tk,
                             const std::string& diagnostic   = "",
                             const std::string& src_location = "")
      {
         type t;
         t.mode         = mode;
         t.token        = tk;
         t.diagnostic   = diagnostic;
         t.src_location = src_location;
         exprtk_debug(("%s\n", diagnostic .c_str()));
         return t;
      }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movb $0x0, 0x2f(%rsp)
callq 0x3756d0
movq 0x10(%rsp), %rdi
movl 0x4c(%rsp), %eax
movl %eax, 0x30(%rdi)
movq 0x40(%rsp), %rsi
callq 0x259470
jmp 0x37422b
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x38, %rdi
callq 0x11b7c0
jmp 0x374240
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x58, %rdi
callq 0x11b7c0
jmp 0x374255
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x374287
jmp 0x37427d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x371330
jmp 0x374291
movq 0x10(%rsp), %rdi
callq 0x371330
movq 0x8(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element::clear()
void clear()
         {
            name   = "???";
            size   = std::numeric_limits<std::size_t>::max();
            index  = std::numeric_limits<std::size_t>::max();
            depth  = std::numeric_limits<std::size_t>::max();
            type   = e_none;
            active = false;
            ref_count = 0;
            ip_index  = 0;
            data      = 0;
            var_node  = 0;
            vec_node  = 0;
            #ifndef exprtk_disable_string_capabilities
            str_node  = 0;
            #endif
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
leaq 0x240561(%rip), %rsi    # 0x5b4d0b
callq 0x11b340
callq 0x237af0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
callq 0x237af0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
callq 0x237af0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0x0, 0x48(%rax)
movb $0x0, 0x4c(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> exprtk::details::to_str_impl<long long>(long long)
inline std::string to_str_impl(SignedType i)
      {
         if (0 == i)
            return std::string("0");

         std::string result;

         const int sign = (i < 0) ? -1 : 1;

         for ( ; i; i /= 10)
         {
            result += '0' + static_cast<char_t>(sign * (i % 10));
         }

         if (sign < 0)
         {
            result += '-';
         }

         std::reverse(result.begin(), result.end());

         return result;
      }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
xorl %eax, %eax
cmpq 0x58(%rsp), %rax
jne 0x3749a7
leaq 0x57(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b6f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x22ce63(%rip), %rsi    # 0x5a17d7
callq 0x134520
jmp 0x37497b
leaq 0x57(%rsp), %rdi
callq 0x11b820
jmp 0x374abe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x57(%rsp), %rdi
callq 0x11b820
jmp 0x374ac8
movq 0x18(%rsp), %rdi
movb $0x0, 0x43(%rsp)
callq 0x11b2b0
movq 0x58(%rsp), %rdx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq $0x0, %rdx
cmovll %ecx, %eax
movl %eax, 0x3c(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x374a5d
movq 0x18(%rsp), %rdi
movl 0x3c(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x58(%rsp), %rcx
movabsq $0x6666666666666667, %rdx # imm = 0x6666666666666667
movq %rcx, %rax
imulq %rdx
movl 0xc(%rsp), %eax
movq %rdx, %rsi
movq %rsi, %rdx
shrq $0x3f, %rdx
shrq $0x2, %rsi
addl %edx, %esi
addl %esi, %esi
movl %esi, %edx
leal (%rdx,%rdx,4), %edx
subl %edx, %ecx
imull %ecx, %eax
addl $0x30, %eax
movsbl %al, %esi
callq 0x11b510
jmp 0x374a2b
jmp 0x374a2d
movq 0x58(%rsp), %rax
movl $0xa, %ecx
cqto
idivq %rcx
movq %rax, 0x58(%rsp)
jmp 0x3749d0
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x11b838
jmp 0x374ac8
cmpl $0x0, 0x3c(%rsp)
jge 0x374a77
movq 0x18(%rsp), %rdi
movl $0x2d, %esi
callq 0x11b510
jmp 0x374a75
jmp 0x374a77
movq 0x18(%rsp), %rdi
callq 0x11b3a0
movq 0x18(%rsp), %rdi
movq %rax, 0x30(%rsp)
callq 0x11b440
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x374ae0
jmp 0x374aa6
movb $0x1, 0x43(%rsp)
testb $0x1, 0x43(%rsp)
jne 0x374abc
movq 0x18(%rsp), %rdi
callq 0x11b838
jmp 0x374abe
movq 0x20(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool process(const std::string& str)
         {
            base_itr_ = str.data();
            s_itr_    = str.data();
            s_end_    = str.data() + str.size();

            eof_token_.set_operator(token_t::e_eof, s_end_, s_end_, base_itr_);
            token_list_.clear();

            while (!is_end(s_itr_))
            {
               scan_token();

               if (!token_list_.empty() && token_list_.back().is_error())
                  return false;
            }

            return true;
         }

// 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 0x11b230
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rax)
movq 0x10(%rsp), %rdi
callq 0x11b230
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x10(%rsp), %rdi
callq 0x11b230
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x11b270
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x8(%rsp), %rax
addq %rdx, %rcx
movq %rcx, 0x68(%rax)
movq %rax, %rdi
addq $0x28, %rdi
movq 0x68(%rax), %rdx
movq 0x68(%rax), %rcx
movq 0x58(%rax), %r8
movl $0x6, %esi
callq 0x3759d0
movq 0x8(%rsp), %rdi
callq 0x251490
movq 0x8(%rsp), %rdi
movq 0x60(%rdi), %rsi
callq 0x375a40
xorb $-0x1, %al
testb $0x1, %al
jne 0x37597c
jmp 0x3759b5
movq 0x8(%rsp), %rdi
callq 0x375a60
movq 0x8(%rsp), %rdi
callq 0x254a30
testb $0x1, %al
jne 0x3759b3
movq 0x8(%rsp), %rdi
callq 0x257650
movq %rax, %rdi
callq 0x375ce0
testb $0x1, %al
jne 0x3759ac
jmp 0x3759b3
movb $0x0, 0x27(%rsp)
jmp 0x3759ba
jmp 0x375966
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_operator<char const*>(exprtk::lexer::token::token_type, char const*, char const*, char const*)
inline token& set_operator(const token_type tt,
                                    const Iterator begin, const Iterator end,
                                    const Iterator base_begin = Iterator(0))
         {
            type = tt;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl 0x2c(%rsp), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x375d60
cmpq $0x0, 0x10(%rsp)
je 0x375a32
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x22cb80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token::is_error() const
inline bool is_error() const
         {
            return (e_error      == type) ||
                   (e_err_symbol == type) ||
                   (e_err_number == type) ||
                   (e_err_string == type) ||
                   (e_err_sfunc  == type) ;
         }

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rdx
movq %rdx, -0x18(%rsp)
movb $0x1, %al
movl $0x1, %ecx
cmpl (%rdx), %ecx
movb %al, -0x9(%rsp)
je 0x375d4d
movq -0x18(%rsp), %rdx
movb $0x1, %al
movl $0x2, %ecx
cmpl (%rdx), %ecx
movb %al, -0x9(%rsp)
je 0x375d4d
movq -0x18(%rsp), %rdx
movb $0x1, %al
movl $0x3, %ecx
cmpl (%rdx), %ecx
movb %al, -0x9(%rsp)
je 0x375d4d
movq -0x18(%rsp), %rdx
movb $0x1, %al
movl $0x4, %ecx
cmpl (%rdx), %ecx
movb %al, -0x9(%rsp)
je 0x375d4d
movq -0x18(%rsp), %rcx
movl $0x5, %eax
cmpl (%rcx), %eax
sete %al
movb %al, -0x9(%rsp)
movb -0x9(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_whitespace(char)
inline bool is_whitespace(const char_t c)
      {
         return (' '  == c) || ('\n' == c) ||
                ('\r' == c) || ('\t' == c) ||
                ('\b' == c) || ('\v' == c) ||
                ('\f' == c) ;
      }

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x20, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x375eb2
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0xa, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x375eb2
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0xd, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x375eb2
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x9, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x375eb2
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x8, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x375eb2
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0xb, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x375eb2
movsbl -0x1(%rsp), %ecx
movl $0xc, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x2(%rsp)
movb -0x2(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::is_comment_start(char const*) const
inline bool is_comment_start(details::char_cptr itr) const
         {
            const char_t c0 = *(itr + 0);
            const char_t c1 = *(itr + 1);

            if ('#' == c0)
               return true;
            else if (!is_end(itr + 1))
            {
               if (('/' == c0) && ('/' == c1)) return true;
               if (('/' == c0) && ('*' == c1)) return true;
            }
            return false;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movb (%rax), %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movb 0x1(%rax), %al
movb %al, 0xe(%rsp)
movsbl 0xf(%rsp), %ecx
movl $0x23, %eax
cmpl %ecx, %eax
jne 0x375f73
movb $0x1, 0x27(%rsp)
jmp 0x375fd8
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
addq $0x1, %rsi
callq 0x375a40
testb $0x1, %al
jne 0x375fd1
movsbl 0xf(%rsp), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
jne 0x375fac
movsbl 0xe(%rsp), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
jne 0x375fac
movb $0x1, 0x27(%rsp)
jmp 0x375fd8
movsbl 0xf(%rsp), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
jne 0x375fcf
movsbl 0xe(%rsp), %ecx
movl $0x2a, %eax
cmpl %ecx, %eax
jne 0x375fcf
movb $0x1, 0x27(%rsp)
jmp 0x375fd8
jmp 0x375fd1
jmp 0x375fd3
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_operator_char(char)
inline bool is_operator_char(const char_t c)
      {
         return ('+' == c) || ('-' == c) ||
                ('*' == c) || ('/' == c) ||
                ('^' == c) || ('<' == c) ||
                ('>' == c) || ('=' == c) ||
                (',' == c) || ('!' == c) ||
                ('(' == c) || (')' == c) ||
                ('[' == c) || (']' == c) ||
                ('{' == c) || ('}' == c) ||
                ('%' == c) || (':' == c) ||
                ('?' == c) || ('&' == c) ||
                ('|' == c) || (';' == c) ;
      }

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x2b, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x2d, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x2a, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x2f, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x5e, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x3c, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x3e, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x3d, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x2c, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x21, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x28, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x29, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x5b, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x5d, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x7b, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x7d, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x25, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x3a, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x3f, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x26, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %edx
movb $0x1, %al
movl $0x7c, %ecx
cmpl %edx, %ecx
movb %al, -0x2(%rsp)
je 0x3763ca
movsbl -0x1(%rsp), %ecx
movl $0x3b, %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x2(%rsp)
movb -0x2(%rsp), %al
andb $0x1, %al
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::scan_symbol()
inline void scan_symbol()
         {
            details::char_cptr initial_itr = s_itr_;

            while (!is_end(s_itr_))
            {
               if (!details::is_letter_or_digit(*s_itr_) && ('_' != (*s_itr_)))
               {
                  if ('.' != (*s_itr_))
                     break;
                  /*
                     Permit symbols that contain a 'dot'
                     Allowed   : abc.xyz, a123.xyz, abc.123, abc_.xyz a123_.xyz abc._123
                     Disallowed: .abc, abc.<white-space>, abc.<eof>, abc.<operator +,-,*,/...>
                  */
                  if (
                       (s_itr_ != initial_itr)                     &&
                       !is_end(s_itr_ + 1)                         &&
                       !details::is_letter_or_digit(*(s_itr_ + 1)) &&
                       ('_' != (*(s_itr_ + 1)))
                     )
                     break;
               }

               ++s_itr_;
            }

            token_t t;
            t.set_symbol(initial_itr, s_itr_, base_itr_);
            token_list_.push_back(t);
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x60(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x10(%rsp), %rdi
movq 0x60(%rdi), %rsi
callq 0x375a40
xorb $-0x1, %al
testb $0x1, %al
jne 0x3768b5
jmp 0x376966
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movsbl (%rax), %edi
callq 0x2342f0
testb $0x1, %al
jne 0x376950
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movsbl (%rax), %ecx
movl $0x5f, %eax
cmpl %ecx, %eax
je 0x376950
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movsbl (%rax), %ecx
movl $0x2e, %eax
cmpl %ecx, %eax
je 0x3768fa
jmp 0x376966
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
cmpq 0x58(%rsp), %rax
je 0x37694e
movq 0x10(%rsp), %rdi
movq 0x60(%rdi), %rsi
addq $0x1, %rsi
callq 0x375a40
testb $0x1, %al
jne 0x37694e
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movsbl 0x1(%rax), %edi
callq 0x2342f0
testb $0x1, %al
jne 0x37694e
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rax
movsbl 0x1(%rax), %ecx
movl $0x5f, %eax
cmpl %ecx, %eax
je 0x37694e
jmp 0x376966
jmp 0x376950
movq 0x10(%rsp), %rax
movq 0x60(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x60(%rax)
jmp 0x37689c
leaq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x251250
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x58(%rax), %rcx
movq 0x60(%rax), %rdx
callq 0x377510
jmp 0x376993
movq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x254cc0
jmp 0x3769a4
leaq 0x28(%rsp), %rdi
callq 0x2512e0
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x2512e0
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_symbol<char const*>(char const*, char const*, char const*)
inline token& set_symbol(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
         {
            type = e_symbol;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x8, (%rdi)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x375d60
cmpq $0x0, 0x8(%rsp)
je 0x37756c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x22cb80
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_error<char const*>(exprtk::lexer::token::token_type, char const*, char const*, char const*)
inline token& set_error(const token_type et,
                                 const Iterator begin, const Iterator end,
                                 const Iterator base_begin = Iterator(0))
         {
            if (
                 (e_error      == et) ||
                 (e_err_symbol == et) ||
                 (e_err_number == et) ||
                 (e_err_string == et) ||
                 (e_err_sfunc  == et)
               )
            {
               type = et;
            }
            else
               type = e_error;

            value.assign(begin,end);

            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));

            return (*this);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x1, %eax
cmpl 0x2c(%rsp), %eax
je 0x3775dd
movl $0x2, %eax
cmpl 0x2c(%rsp), %eax
je 0x3775dd
movl $0x3, %eax
cmpl 0x2c(%rsp), %eax
je 0x3775dd
movl $0x4, %eax
cmpl 0x2c(%rsp), %eax
je 0x3775dd
movl $0x5, %eax
cmpl 0x2c(%rsp), %eax
jne 0x3775ea
movq 0x8(%rsp), %rax
movl 0x2c(%rsp), %ecx
movl %ecx, (%rax)
jmp 0x3775f5
movq 0x8(%rsp), %rax
movl $0x1, (%rax)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x375d60
cmpq $0x0, 0x10(%rsp)
je 0x377630
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x22cb80
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::skip_comments()::test::comment_start(char, char, int&, int&)
static inline bool comment_start(const char_t c0, const char_t c1, int& mode, int& incr)
               {
                  mode = 0;
                  if      ('#' == c0)    { mode = 1; incr = 1; }
                  else if ('/' == c0)
                  {
                     if      ('/' == c1) { mode = 1; incr = 2; }
                     else if ('*' == c1) { mode = 2; incr = 2; }
                  }
                  return (0 != mode);
               }

// Assembly:
movb %sil, %al
movb %dil, %sil
movb %sil, -0x1(%rsp)
movb %al, -0x2(%rsp)
movq %rdx, -0x10(%rsp)
movq %rcx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movl $0x0, (%rax)
movsbl -0x1(%rsp), %ecx
movl $0x23, %eax
cmpl %ecx, %eax
jne 0x37768a
movq -0x10(%rsp), %rax
movl $0x1, (%rax)
movq -0x18(%rsp), %rax
movl $0x1, (%rax)
jmp 0x3776e8
movsbl -0x1(%rsp), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
jne 0x3776e6
movsbl -0x2(%rsp), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
jne 0x3776be
movq -0x10(%rsp), %rax
movl $0x1, (%rax)
movq -0x18(%rsp), %rax
movl $0x2, (%rax)
jmp 0x3776e4
movsbl -0x2(%rsp), %ecx
movl $0x2a, %eax
cmpl %ecx, %eax
jne 0x3776e2
movq -0x10(%rsp), %rax
movl $0x2, (%rax)
movq -0x18(%rsp), %rax
movl $0x2, (%rax)
jmp 0x3776e4
jmp 0x3776e6
jmp 0x3776e8
movq -0x10(%rsp), %rcx
xorl %eax, %eax
cmpl (%rcx), %eax
setne %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::skip_comments()::test::comment_end(char, char, int&)
static inline bool comment_end(const char_t c0, const char_t c1, int& mode)
               {
                  if (
                       ((1 == mode) && ('\n' == c0)) ||
                       ((2 == mode) && ( '*' == c0) && ('/' == c1))
                     )
                  {
                     mode = 0;
                     return true;
                  }
                  else
                     return false;
               }

// Assembly:
movb %sil, %al
movb %dil, %cl
movb %cl, -0x2(%rsp)
movb %al, -0x3(%rsp)
movq %rdx, -0x10(%rsp)
movq -0x10(%rsp), %rcx
movl $0x1, %eax
cmpl (%rcx), %eax
jne 0x37772f
movsbl -0x2(%rsp), %ecx
movl $0xa, %eax
cmpl %ecx, %eax
je 0x377759
movq -0x10(%rsp), %rcx
movl $0x2, %eax
cmpl (%rcx), %eax
jne 0x37776b
movsbl -0x2(%rsp), %ecx
movl $0x2a, %eax
cmpl %ecx, %eax
jne 0x37776b
movsbl -0x3(%rsp), %ecx
movl $0x2f, %eax
cmpl %ecx, %eax
jne 0x37776b
movq -0x10(%rsp), %rax
movl $0x0, (%rax)
movb $0x1, -0x1(%rsp)
jmp 0x377770
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_numeric<char const*>(char const*, char const*, char const*)
inline token& set_numeric(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
         {
            type = e_number;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x7, (%rdi)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x375d60
cmpq $0x0, 0x8(%rsp)
je 0x37781c
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x22cb80
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_string<char const*>(char const*, char const*, char const*)
inline token& set_string(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
         {
            type = e_string;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movl $0x9, (%rdi)
addq $0x8, %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x375d60
cmpq $0x0, 0x8(%rsp)
je 0x3779cc
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x22cb80
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x28(%rax)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token::set_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline token& set_string(const std::string& s, const std::size_t p)
         {
            type     = e_string;
            value    = s;
            position = p;
            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x9, (%rdi)
movq 0x18(%rsp), %rsi
addq $0x8, %rdi
callq 0x11b7c0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x28(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_inserters(exprtk::lexer::generator&)
inline bool run_inserters(lexer::generator& g)
            {
               error_token_inserter = reinterpret_cast<lexer::token_inserter*>(0);

               for (std::size_t i = 0; i < token_inserter_list.size(); ++i)
               {
                  lexer::token_inserter& inserter = (*token_inserter_list[i]);

                  inserter.reset();
                  inserter.process(g);

                  if (!inserter.result())
                  {
                     error_token_inserter = token_inserter_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x78(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x48, %rdi
callq 0x261cf0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x378763
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movq 0x18(%rsp), %rsi
callq 0x378da0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x37874e
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
movq 0x18(%rsp), %rsi
callq 0x378da0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x78(%rax)
movb $0x0, 0x37(%rsp)
jmp 0x378768
jmp 0x378750
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3786b9
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_joiners(exprtk::lexer::generator&)
inline bool run_joiners(lexer::generator& g)
            {
               error_token_joiner = reinterpret_cast<lexer::token_joiner*>(0);

               for (std::size_t i = 0; i < token_joiner_list.size(); ++i)
               {
                  lexer::token_joiner& joiner = (*token_joiner_list[i]);

                  joiner.reset();
                  joiner.process(g);

                  if (!joiner.result())
                  {
                     error_token_joiner = token_joiner_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x70(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x30, %rdi
callq 0x2629d0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x378853
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
callq 0x378dc0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x37883e
movq 0x8(%rsp), %rdi
addq $0x30, %rdi
movq 0x18(%rsp), %rsi
callq 0x378dc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x70(%rax)
movb $0x0, 0x37(%rsp)
jmp 0x378858
jmp 0x378840
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3787a9
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_modifiers(exprtk::lexer::generator&)
inline bool run_modifiers(lexer::generator& g)
            {
               error_token_modifier = reinterpret_cast<lexer::token_modifier*>(0);

               for (std::size_t i = 0; i < token_modifier_list.size(); ++i)
               {
                  lexer::token_modifier& modifier = (*token_modifier_list[i]);

                  modifier.reset();
                  modifier.process(g);

                  if (!modifier.result())
                  {
                     error_token_modifier = token_modifier_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x68(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
addq $0x18, %rdi
callq 0x260c40
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x378943
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x378de0
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x37892e
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
movq 0x18(%rsp), %rsi
callq 0x378de0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x68(%rax)
movb $0x0, 0x37(%rsp)
jmp 0x378948
jmp 0x378930
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x378899
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_scanners(exprtk::lexer::generator&)
inline bool run_scanners(lexer::generator& g)
            {
               error_token_scanner = reinterpret_cast<lexer::token_scanner*>(0);

               for (std::size_t i = 0; i < token_scanner_list.size(); ++i)
               {
                  lexer::token_scanner& scanner = (*token_scanner_list[i]);

                  scanner.reset();
                  scanner.process(g);

                  if (!scanner.result())
                  {
                     error_token_scanner = token_scanner_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x60(%rax)
movq $0x0, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
callq 0x2636b0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x378a23
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x378e00
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testb $0x1, %al
jne 0x378a0e
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x378e00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x60(%rax)
movb $0x0, 0x37(%rsp)
jmp 0x378a28
jmp 0x378a10
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x378989
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator::error(unsigned long)
std::pair<lexer::token,lexer::token> error(const std::size_t index)
            {
               if (index < error_list_.size())
               {
                  return error_list_[index];
               }
               else
               {
                  static const lexer::token error_token;
                  return std::make_pair(error_token,error_token);
               }
            }

// Assembly:
subq $0x48, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x40, %rdi
callq 0x25d510
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x378baa
movq 0x10(%rsp), %rdi
addq $0x40, %rdi
movq 0x30(%rsp), %rsi
callq 0x378e40
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x378e60
jmp 0x378c29
cmpb $0x0, 0x467457(%rip)    # 0x7e0008
jne 0x378bf8
leaq 0x46744e(%rip), %rdi    # 0x7e0008
callq 0x11b2c0
cmpl $0x0, %eax
je 0x378bf8
leaq 0x46740d(%rip), %rdi    # 0x7dffd8
callq 0x251250
jmp 0x378bd2
leaq -0x1278f9(%rip), %rdi   # 0x2512e0
leaq 0x4673f8(%rip), %rsi    # 0x7dffd8
leaq 0x45a839(%rip), %rdx    # 0x7d3420
callq 0x11b630
leaq 0x467415(%rip), %rdi    # 0x7e0008
callq 0x11b470
movq (%rsp), %rdi
leaq 0x4673d5(%rip), %rdx    # 0x7dffd8
movq %rdx, %rsi
callq 0x25cec0
jmp 0x378c29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x4673e6(%rip), %rdi    # 0x7e0008
callq 0x11b360
jmp 0x378c33
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::construct_subexpr[abi:cxx11](exprtk::lexer::token&, exprtk::lexer::token&, bool)
std::string construct_subexpr(lexer::token& begin_token,
                                    lexer::token& end_token,
                                    const bool cleanup_whitespace = true)
      {
         std::string result = lexer().substr(begin_token.position,end_token.position);
         if (cleanup_whitespace)
         {
            for (std::size_t i = 0; i < result.size(); ++i)
            {
               if (details::is_whitespace(result[i])) result[i] = ' ';
            }
         }

         return result;
      }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x20(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
andb $0x1, %al
movb %al, 0x47(%rsp)
movq 0x58(%rsp), %rdi
movb $0x0, 0x46(%rsp)
callq 0x3723b0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x50(%rsp), %rdx
addq $0x28, %rdx
movq 0x48(%rsp), %rcx
addq $0x28, %rcx
callq 0x528120
testb $0x1, 0x47(%rsp)
je 0x37d609
movq $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x11b270
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x37d607
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x11b7a0
movq %rax, 0x8(%rsp)
jmp 0x37d5a7
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
callq 0x375e20
testb $0x1, %al
jne 0x37d5ba
jmp 0x37d5f2
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x11b7a0
movq %rax, (%rsp)
jmp 0x37d5cf
movq (%rsp), %rax
movb $0x20, (%rax)
jmp 0x37d5f2
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x11b838
jmp 0x37d629
jmp 0x37d5f4
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x37d570
jmp 0x37d609
movb $0x1, 0x46(%rsp)
testb $0x1, 0x46(%rsp)
jne 0x37d61f
movq 0x20(%rsp), %rdi
callq 0x11b838
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::token_is(exprtk::lexer::token::token_type const&, exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is(const token_t::token_type& ttype, const token_advance_mode mode = e_advance)
         {
            if (current_token().type != ttype)
            {
               return false;
            }

            advance_token(mode);

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x373e90
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
je 0x37d672
movb $0x0, 0x27(%rsp)
jmp 0x37d684
movq (%rsp), %rdi
movl 0xc(%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_bracket(exprtk::lexer::parser_helper::token_advance_mode)
inline bool token_is_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 :
               case token_t::e_lbracket    :
               case token_t::e_lcrlbracket :
               case token_t::e_lsqrbracket : 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 $-0x28, %eax
subl $0x2, %eax
jb 0x37d728
jmp 0x37d6fc
movl 0x10(%rsp), %eax
subl $0x5b, %eax
je 0x37d728
jmp 0x37d707
movl 0x10(%rsp), %eax
subl $0x5d, %eax
je 0x37d728
jmp 0x37d712
movl 0x10(%rsp), %eax
subl $0x7b, %eax
je 0x37d728
jmp 0x37d71d
movl 0x10(%rsp), %eax
subl $0x7d, %eax
jne 0x37d72a
jmp 0x37d728
jmp 0x37d731
movb $0x0, 0x27(%rsp)
jmp 0x37d744
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