LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_collection_destructor<exprtk::details::expression_node<double>>::delete_nodes(exprtk::details::expression_node<double>*&)
static void delete_nodes(node_ptr_t& root)
         {
            std::vector<node_pp_t> node_delete_list;
            node_delete_list.reserve(1000);

            collect_nodes(root, node_delete_list);

            for (std::size_t i = 0; i < node_delete_list.size(); ++i)
            {
               node_ptr_t& node = *node_delete_list[i];
               exprtk_debug(("ncd::delete_nodes() - deleting: %p\n", reinterpret_cast<void*>(node)));
               delete node;
               node = reinterpret_cast<node_ptr_t>(0);
            }
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1ea6e8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1ea784
movq (%rsp), %rdi
cmpq %rdi, 0x8(%rsp)
je 0x1ea6ac
xorl %ebx, %ebx
movq (%rdi,%rbx,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1ea68d
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, (%r14)
incq %rbx
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %rax, %rbx
jb 0x1ea67b
testq %rdi, %rdi
je 0x1ea6be
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11e0c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1ea6df
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::~helper_assembly()
inline bool register_scanner(lexer::token_scanner* scanner)
            {
               if (token_scanner_list.end() != std::find(token_scanner_list.begin(),
                                                         token_scanner_list.end  (),
                                                         scanner))
               {
                  return false;
               }

               token_scanner_list.push_back(scanner);

               return true;
            }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x1f254d
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1f2562
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1f2577
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1f258c
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x11e0c0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::operator_joiner::join(exprtk::lexer::token const&, exprtk::lexer::token const&, exprtk::lexer::token const&, exprtk::lexer::token&)
inline bool join(const lexer::token& t0,
                             const lexer::token& t1,
                             const lexer::token& t2,
                             lexer::token& t) exprtk_override
            {
               // '[ * ]' --> '[*]'
               if (
                    (t0.type == lexer::token::e_lsqrbracket) &&
                    (t1.type == lexer::token::e_mul        ) &&
                    (t2.type == lexer::token::e_rsqrbracket)
                  )
               {
                  t.type     = lexer::token::e_symbol;
                  t.value    = "[*]";
                  t.position = t0.position;

                  return true;
               }
               else
                  return false;
            }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rsi), %eax
xorl $0x5b, %eax
movl (%rdx), %edx
xorl $0x2a, %edx
orl %eax, %edx
movl (%rcx), %eax
xorl $0x5d, %eax
orl %edx, %eax
sete %bpl
jne 0x1f3d30
movq %r8, %rbx
movq %rsi, %r14
movl $0x8, (%r8)
leaq 0x8(%r8), %rdi
movq 0x10(%r8), %rdx
leaq 0x1af122(%rip), %rcx    # 0x3a2e3d
movl $0x3, %r8d
xorl %esi, %esi
callq 0x11e290
movq 0x28(%r14), %rax
movq %rax, 0x28(%rbx)
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token_modifier::process(exprtk::lexer::generator&)
inline std::size_t process(generator& g) exprtk_override
         {
            std::size_t changes = 0;

            for (std::size_t i = 0; i < g.token_list_.size(); ++i)
            {
               if (modify(g.token_list_[i])) changes++;
            }

            return changes;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %rsi
cmpq %rsi, 0x8(%rbx)
je 0x1f42fe
movq %rdi, %r14
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
xorl %ebp, %ebp
xorl %r15d, %r15d
addq %r12, %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movzbl %al, %eax
addq %rax, %r15
incq %rbp
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
imulq %r13, %rax
addq $0x30, %r12
cmpq %rax, %rbp
jb 0x1f42cc
jmp 0x1f4301
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::bracket_checker::reset()
void reset() exprtk_override
            {
               // Why? because msvc doesn't support swap properly.
               stack_ = std::stack<std::pair<char,std::size_t> >();
               state_ = true;
               error_token_.clear();
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movq %rsp, %r14
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, (%r14)
movq %r14, %rdi
xorl %esi, %esi
callq 0x1f49d0
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1f4ba0
movq %r14, %rdi
callq 0x1f4b48
movb $0x1, 0x10(%rbx)
movl $0x0, 0x68(%rbx)
leaq 0x70(%rbx), %rdi
movq 0x78(%rbx), %rdx
leaq 0x1aec3f(%rip), %rcx    # 0x3a31ff
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x11e290
movq $-0x1, 0x90(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::bracket_checker::result()
bool result() exprtk_override
            {
               if (!stack_.empty())
               {
                  lexer::token t;
                  t.value      = stack_.top().first;
                  t.position   = stack_.top().second;
                  error_token_ = t;
                  state_       = false;

                  return false;
               }
               else
                  return state_;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq 0x28(%rdi), %rax
je 0x1f46a8
leaq 0x8(%rsp), %r14
movl $0x0, -0x8(%r14)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq $-0x1, 0x10(%r15)
cmpq 0x50(%rbx), %rax
jne 0x1f4635
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movsbl -0x10(%rax), %r8d
movl $0x1, %ecx
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x11e2d0
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x1f4662
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movl (%rsp), %eax
movl %eax, 0x68(%rbx)
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x11e5a0
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f46a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
xorl %eax, %eax
jmp 0x1f46ab
movb 0x10(%rbx), %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1f46cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::bracket_checker::operator()(exprtk::lexer::token const&)
bool operator() (const lexer::token& t) exprtk_override
            {
               if (
                    !t.value.empty()                       &&
                    (lexer::token::e_string != t.type)     &&
                    (lexer::token::e_symbol != t.type)     &&
                    exprtk::details::is_bracket(t.value[0])
                  )
               {
                  details::char_t c = t.value[0];

                  if      (t.type == lexer::token::e_lbracket   ) stack_.push(std::make_pair(')',t.position));
                  else if (t.type == lexer::token::e_lcrlbracket) stack_.push(std::make_pair('}',t.position));
                  else if (t.type == lexer::token::e_lsqrbracket) stack_.push(std::make_pair(']',t.position));
                  else if (exprtk::details::is_right_bracket(c))
                  {
                     if (stack_.empty())
                     {
                        state_       = false;
                        error_token_ = t;

                        return false;
                     }
                     else if (c != stack_.top().first)
                     {
                        state_       = false;
                        error_token_ = t;

                        return false;
                     }
                     else
                        stack_.pop();
                  }
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movb $0x1, %bl
cmpq $0x0, 0x10(%rsi)
je 0x1f4949
movq %rsi, %r15
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x8, %ecx
je 0x1f4949
movq %rdi, %r14
leaq 0x8(%r15), %rsi
movq (%rsi), %rcx
movzbl (%rcx), %ecx
leal -0x5b(%rcx), %edx
cmpl $0x22, %edx
ja 0x1f48f8
movabsq $0x500000005, %rdi      # imm = 0x500000005
btq %rdx, %rdi
jb 0x1f4900
leal -0x28(%rcx), %edx
cmpl $0x2, %edx
jae 0x1f4949
cmpl $0x7b, %eax
je 0x1f492f
cmpl $0x5b, %eax
je 0x1f491f
cmpl $0x28, %eax
jne 0x1f4955
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x29, (%rsi)
jmp 0x1f493d
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x5d, (%rsi)
jmp 0x1f493d
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x7d, (%rsi)
movq %rax, 0x8(%rsi)
movq %r14, %rdi
callq 0x1f4c5c
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x29, %ecx
je 0x1f4964
cmpl $0x7d, %ecx
je 0x1f4964
cmpl $0x5d, %ecx
jne 0x1f4949
movq 0x48(%r14), %rdx
cmpq 0x28(%r14), %rdx
je 0x1f4994
cmpq 0x50(%r14), %rdx
jne 0x1f4981
movq 0x60(%r14), %rdi
movl $0x200, %edx            # imm = 0x200
addq -0x8(%rdi), %rdx
cmpb -0x10(%rdx), %cl
jne 0x1f4994
addq $0x18, %r14
movq %r14, %rdi
callq 0x1f4ec0
jmp 0x1f4949
movb $0x0, 0x10(%r14)
movl %eax, 0x68(%r14)
leaq 0x70(%r14), %rdi
callq 0x11e5a0
movq 0x28(%r15), %rax
movq %rax, 0x90(%r14)
xorl %ebx, %ebx
jmp 0x1f4949
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::numeric_checker<double>::operator()(exprtk::lexer::token const&)
bool operator() (const lexer::token& t) exprtk_override
            {
               if (token::e_number == t.type)
               {
                  T v;

                  if (!exprtk::details::string_to_real(t.value,v))
                  {
                     error_list_.push_back(current_index_);
                  }
               }

               ++current_index_;

               return true;
            }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
cmpl $0x7, (%rsi)
jne 0x1f4fac
movq 0x8(%rsi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
addq 0x10(%rsi), %rax
movq %rsp, %rdx
movq %rax, %rsi
callq 0x1f4fb8
testb %al, %al
jne 0x1f4fac
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x1f4f9f
movq 0x10(%rbx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x1f4fac
leaq 0x10(%rbx), %rdx
leaq 0x18(%rbx), %rdi
callq 0x1f5498
incq 0x10(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator::operator()(exprtk::lexer::token const&, exprtk::lexer::token const&)
bool operator() (const lexer::token& t0, const lexer::token& t1) exprtk_override
            {
               const set_t::value_type p = std::make_pair(t0.type,t1.type);

               if (invalid_bracket_check(t0.type,t1.type))
               {
                  error_list_.push_back(std::make_pair(t0,t1));
               }
               else if (invalid_comb_.find(p) != invalid_comb_.end())
               {
                  error_list_.push_back(std::make_pair(t0,t1));
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rsi), %esi
movl (%rdx), %edx
movq %rdx, %rax
shlq $0x20, %rax
orq %rsi, %rax
movq %rax, (%rsp)
callq 0x1f5b30
testb %al, %al
je 0x1f587d
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f5ec2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f5c06
jmp 0x1f58b4
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x1f5f54
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x1f58ea
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f5ec2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f5c06
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f58cf
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x11e0c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f58ea
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1f58fa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f5aa8
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator_3tokens::operator()(exprtk::lexer::token const&, exprtk::lexer::token const&, exprtk::lexer::token const&)
bool operator() (const lexer::token& t0, const lexer::token& t1, const lexer::token& t2) exprtk_override
            {
               const set_t::value_type p = std::make_pair(t0.type,std::make_pair(t1.type,t2.type));

               if (invalid_comb_.find(p) != invalid_comb_.end())
               {
                  error_list_.push_back(std::make_pair(t0,t1));
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl (%rdx), %eax
movl (%rcx), %ecx
movq %rcx, %rdx
shlq $0x20, %rdx
orq %rax, %rdx
movl (%rsi), %eax
movl %eax, 0x8(%rsp)
movq %rdx, 0xc(%rsp)
movq 0x8(%rsp), %rax
leaq 0x68(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
addq $0x10, %rdi
callq 0x1f627c
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x1f6089
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f5ec2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1f5c06
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f606e
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x11e0c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f6089
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f5aa8
movq %rbx, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::symbol_replacer::add_replace(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&, exprtk::lexer::token::token_type)
bool add_replace(const std::string& target_symbol,
                             const std::string& replace_symbol,
                             const lexer::token::token_type token_type = lexer::token::e_symbol)
            {
               const replace_map_t::iterator itr = replace_map_.find(target_symbol);

               if (replace_map_.end() != itr)
               {
                  return false;
               }

               replace_map_[target_symbol] = std::make_pair(replace_symbol,token_type);

               return true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rdi), %r12
movq %r12, %rdi
callq 0x1f4390
movq %rax, %r14
addq $0x10, %rbx
cmpq %rax, %rbx
jne 0x1f63b6
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %rsp, %r13
movq %r13, %rdi
callq 0x1e7738
movl %ebp, 0x20(%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1f649e
movq %rax, %r15
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x11e2b0
movl 0x20(%r12), %eax
movl %eax, 0x20(%r15)
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1f63b6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
cmpq %r14, %rbx
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1f63e9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: void exprtk::details::free_node<exprtk::details::node_allocator, double>(exprtk::details::node_allocator&, exprtk::details::expression_node<double>*&)
inline void free_node(NodeAllocator&, expression_node<T>*& node)
      {
         if ((0 == node) || is_variable_node(node) || is_string_node(node))
         {
            return;
         }

         node_collection_destructor<expression_node<T> >
            ::delete_nodes(node);
      }

// Assembly:
pushq %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x205f2a
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x205f2a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x205f2c
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x205f2c
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1ea63e
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf3ext_expression::compile<double const&, double const&, double const>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, double const&, double const, exprtk::details::expression_node<double>*&)
static inline bool compile(expression_generator<Type>& expr_gen, const std::string& id,
                                       T0 t0, T1 t1, T2 t2,
                                       expression_node_ptr& result)
            {
               details::operator_type sf3opr;

               if (!expr_gen.sf3_optimisable(id,sf3opr))
                  return false;
               else
                  result = synthesize_sf3ext_expression::template process<T0, T1, T2>
                              (expr_gen, sf3opr, t0, t1, t2);

               return true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, %rbx
movsd %xmm0, 0x10(%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r13
movq 0x58(%rdi), %rdi
callq 0x2092ce
movq %rax, %r14
movq 0x58(%r13), %r13
addq $0x8, %r13
cmpq %rax, %r13
je 0x20b046
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl 0x48(%r14), %eax
cmpl $0x1e, %eax
ja 0x20b041
movl %eax, %eax
leaq 0x3340a2(%rip), %rcx    # 0x53f098
movq (%rcx,%rax,8), %rcx
movq %rcx, 0x8(%rsp)
leaq 0x33418a(%rip), %rcx    # 0x53f190
movq (%rcx,%rax,8), %rbp
movl $0x38, %edi
callq 0x11e0f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq %rcx, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x30(%rax)
jmp 0x20b043
xorl %eax, %eax
movq %rax, (%rbx)
cmpq %r14, %r13
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf4ext_expression::compile<double const&, double const&, double const&, double const&>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, double const&, double const&, double const&, exprtk::details::expression_node<double>*&)
static inline bool compile(expression_generator<Type>& expr_gen, const std::string& id,
                                       T0 t0, T1 t1, T2 t2, T3 t3,
                                       expression_node_ptr& result)
            {
               details::operator_type sf4opr;

               if (!expr_gen.sf4_optimisable(id,sf4opr))
                  return false;
               else
                  result = synthesize_sf4ext_expression::template process<T0, T1, T2, T3>
                              (expr_gen, sf4opr, t0, t1, t2, t3);

               return true;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x8(%rsp)
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r13
movq %rdi, %rbp
movq 0x60(%rdi), %rdi
callq 0x214ed4
movq %rax, %r12
movq 0x60(%rbp), %rbx
addq $0x8, %rbx
cmpq %rax, %rbx
je 0x214398
movl 0x48(%r12), %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movq %rbp, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %r14, %r8
movq 0x8(%rsp), %r9
callq 0x214716
movq 0x50(%rsp), %rcx
movq %rax, (%rcx)
cmpq %r12, %rbx
setne %al
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
je 0x249392
xorl %r15d, %r15d
movabsq $0x6db6db6db6db6db7, %r12 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r13d, %r13d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x24d160
incq %r13
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
imulq %r12, %rax
addq $0x70, %r15
cmpq %rax, %r13
jb 0x249368
movq %r14, %rdi
callq 0x24d248
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3d0(%rdi), %r14
testq %r14, %r14
je 0x2493ee
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2493d6
movq 0x18(%r14), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movl $0x20, %esi
movq %r14, %rdi
callq 0x11e0c0
movq $0x0, 0x3d0(%rbx)
movb $0x0, 0x3ab(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
movq 0x10(%rbx), %rsi
callq 0x24ed1c
leaq 0x28(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x24ed1c
leaq 0x40(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x24ed6e
movw $0x0, 0xb(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x36ee84
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x28, %rax
movq %rax, (%r14)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %rbx
addq $0x8, %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
movq $-0x1, 0x28(%rbx)
leaq 0x48(%rbx), %rcx
movq %rcx, 0x38(%rbx)
movq %rax, 0x40(%rbx)
movb %al, 0x48(%rbx)
leaq 0x68(%rbx), %rcx
movq %rcx, 0x58(%rbx)
movq %rax, 0x60(%rbx)
movb %al, 0x68(%rbx)
leaq 0x88(%rbx), %rcx
movq %rcx, 0x78(%rbx)
movq %rax, 0x80(%rbx)
movb %al, 0x88(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x98(%rbx)
movl %esi, 0x30(%rbx)
movl (%rdx), %eax
movl %eax, (%rbx)
leaq 0x8(%rdx), %rsi
callq 0x11e5a0
leaq 0x38(%rbx), %rdi
movq 0x28(%r12), %rax
movq %rax, 0x28(%rbx)
movq %r15, %rsi
callq 0x11e5a0
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x11e5a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x249100
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::free_element(exprtk::parser<double>::scope_element&)
inline void free_element(scope_element& se)
         {
            exprtk_debug(("free_element() - se[%s]\n", se.name.c_str()));

            switch (se.type)
            {
               case scope_element::e_literal    : delete reinterpret_cast<T*>(se.data);
                                                  delete se.var_node;
                                                  break;

               case scope_element::e_variable   : delete reinterpret_cast<T*>(se.data);
                                                  delete se.var_node;
                                                  break;

               case scope_element::e_vector     : delete[] reinterpret_cast<T*>(se.data);
                                                  delete se.vec_node;
                                                  break;

               case scope_element::e_vecelem    : delete se.var_node;
                                                  break;

               #ifndef exprtk_disable_string_capabilities
               case scope_element::e_string     : delete reinterpret_cast<std::string*>(se.data);
                                                  delete se.str_node;
                                                  break;
               #endif

               default                          : return;
            }

            se.clear();
         }

// Assembly:
movl 0x48(%rsi), %eax
decl %eax
cmpl $0x4, %eax
ja 0x24d246
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x13d308(%rip), %rcx    # 0x38a484
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%rbx), %rdi
movl $0x8, %esi
callq 0x11e0c0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x24d1f8
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x24d1f8
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x24d1c4
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x24d1c4
movq (%rax), %rsi
incq %rsi
callq 0x11e0c0
movl $0x20, %esi
movq %r14, %rdi
callq 0x11e0c0
movq 0x68(%rbx), %rdi
movl $0x88, %esi
jmp 0x24d1f3
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x24d1ea
callq 0x11e1e0
movq 0x60(%rbx), %rdi
movl $0x48, %esi
callq 0x11e0c0
movq 0x8(%rbx), %rdx
leaq 0x1550bf(%rip), %rcx    # 0x3a22c2
movl $0x3, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11e290
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x20(%rbx)
movq $-0x1, 0x30(%rbx)
pxor %xmm0, %xmm0
movdqu %xmm0, 0x38(%rbx)
movq $0x0, 0x45(%rbx)
movdqu %xmm0, 0x50(%rbx)
movdqu %xmm0, 0x60(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %rax
movq %r14, %r8
cmpq %r14, %rax
je 0x24def9
leaq 0x1(%r14), %rcx
xorl %edx, %edx
movq %r14, %r8
movzbl -0x1(%rcx), %esi
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x24ded8
movl %esi, %edi
andb $-0x21, %dil
addb $-0x41, %dil
cmpb $0x1a, %dil
jb 0x24ded8
cmpl $0x5f, %esi
je 0x24ded8
cmpl $0x2e, %esi
jne 0x24def3
testq %rdx, %rdx
je 0x24ded8
cmpq %rax, %rcx
je 0x24ded8
movb (%rcx), %sil
cmpb $0x5f, %sil
je 0x24ded8
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x24ded8
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x24def9
incq %r8
movq %rcx, 0x60(%rbx)
leaq 0x1(%rcx), %rsi
decq %rdx
cmpq %rax, %rcx
movq %rsi, %rcx
jne 0x24de87
movq %rax, %r8
jmp 0x24def9
decq %rcx
movq %rcx, %r8
leaq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq $-0x1, 0x10(%r15)
movq 0x58(%rbx), %r12
movl $0x8, -0x18(%r15)
subq %r14, %r8
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11e110
testq %r12, %r12
je 0x24df43
subq %r12, %r14
movq %r14, 0x30(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f342a
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x24df67
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x24df8d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::scan_special_function()
inline void scan_special_function()
         {
            details::char_cptr initial_itr = s_itr_;
            token_t t;

            // $fdd(x,x,x) = at least 11 chars
            if (std::distance(s_itr_,s_end_) < 11)
            {
               t.set_error(
                  token::e_err_sfunc,
                  initial_itr, std::min(initial_itr + 11, s_end_),
                  base_itr_);
               token_list_.push_back(t);

               return;
            }

            if (
                 !(('$' == *s_itr_)                       &&
                   (details::imatch  ('f',*(s_itr_ + 1))) &&
                   (details::is_digit(*(s_itr_ + 2)))     &&
                   (details::is_digit(*(s_itr_ + 3))))
               )
            {
               t.set_error(
                  token::e_err_sfunc,
                  initial_itr, std::min(initial_itr + 4, s_end_),
                  base_itr_);
               token_list_.push_back(t);

               return;
            }

            s_itr_ += 4; // $fdd = 4chars

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

            return;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
leaq 0x10(%rsp), %rdi
movl $0x0, -0x8(%rdi)
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movq $-0x1, 0x10(%r13)
movq 0x68(%rbx), %r15
movq %r15, %rax
subq %r14, %rax
cmpq $0xa, %rax
jg 0x24e34e
leaq 0xb(%r14), %r8
cmpq %r8, %r15
cmovbq %r15, %r8
movq 0x58(%rbx), %r12
movl $0x5, 0x8(%rsp)
subq %r14, %r8
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11e110
jmp 0x24e3d9
cmpb $0x24, (%r14)
jne 0x24e3b3
movsbl 0x1(%r14), %ebp
movl $0x66, %edi
callq 0x11e450
movl %eax, %r12d
movl %ebp, %edi
callq 0x11e450
leaq 0x10(%rsp), %rdi
cmpl %eax, %r12d
jne 0x24e3b3
movb 0x2(%r14), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x24e3b3
movb 0x3(%r14), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x24e3b3
leaq 0x4(%r14), %rax
movq %rax, 0x60(%rbx)
movq 0x58(%rbx), %r12
movl $0x8, 0x8(%rsp)
movl $0x4, %r8d
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11e110
jmp 0x24e3d9
leaq 0x4(%r14), %r8
cmpq %r8, %r15
cmovbq %r15, %r8
movq 0x58(%rbx), %r12
movl $0x5, 0x8(%rsp)
subq %r14, %r8
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
callq 0x11e110
testq %r12, %r12
je 0x24e3e6
subq %r12, %r14
movq %r14, 0x30(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f342a
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x24e40a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24e41d
jmp 0x24e41d
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x24e437
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x40(%rsi), %rsi
movq 0x48(%rax), %rax
subq %rsi, %rax
sarq $0x5, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq %rdx, %rcx
jbe 0x24eb56
leaq (%rdx,%rdx,2), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x24ebe4
jmp 0x24eb72
movb 0x2fe39c(%rip), %al     # 0x54cef8
testb %al, %al
je 0x24eb77
leaq 0x2fe361(%rip), %rdx    # 0x54cec8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1f5ec2
movq %rbx, %rax
popq %rbx
retq
callq 0x11e937
jmp 0x24eb60
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq 0x58(%rsi), %rax
movq 0x68(%rsi), %r8
movq 0x28(%rdx), %rsi
addq %rax, %rsi
cmpq %r8, %rsi
cmovaeq %r8, %rsi
movq %rdi, %rbx
addq 0x28(%rcx), %rax
cmpq %r8, %rax
cmovaeq %r8, %rax
leaq 0x10(%rdi), %rcx
movq %rcx, (%rdi)
movq %rax, %rdx
callq 0x1e4740
testl %ebp, %ebp
je 0x253161
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x253161
movq (%rbx), %rcx
xorl %edx, %edx
movzbl (%rcx,%rdx), %esi
leal -0x8(%rsi), %edi
cmpl $0x6, %edi
jae 0x25315a
movb $0x20, (%rcx,%rdx)
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
incq %rdx
cmpq %rax, %rdx
jb 0x253139
jmp 0x253161
cmpl $0x20, %esi
je 0x253145
jmp 0x253150
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
jne 0x2536f1
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %r14
cmpq 0x8(%rax), %r14
je 0x2536f1
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x2536c7
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2536c7
addq %r15, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2536bf
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2536c7
movq %r14, %rdi
callq 0x1ea63e
incq %r12
movq 0x10(%rbx), %rax
movq (%rax), %r14
movq 0x8(%rax), %rcx
movq %rcx, %rdx
subq %r14, %rdx
sarq $0x3, %rdx
addq $0x8, %r15
cmpq %rdx, %r12
jb 0x253695
cmpq %r14, %rcx
je 0x2536f1
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1e4735
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rax
testq %rax, %rax
je 0x254d59
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %r12d
xorl %r15d, %r15d
movabsq $0x388fc0000, %r13      # imm = 0x388FC0000
cmpq $0x65, %r12
je 0x254d5c
movq 0x338(%r14), %rcx
cmpq 0x318(%r14), %rcx
jne 0x254d64
incq %r15
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
cmpl $0x21, %eax
ja 0x254d52
movl %eax, %ecx
btq %rcx, %r13
jae 0x254d52
cmpl $0x5b, 0x70(%r14)
jne 0x254d67
movq %r14, %rdi
movq %rbx, %rsi
callq 0x36d09a
movq %rax, (%rbx)
incq %r12
testq %rax, %rax
jne 0x254d04
jmp 0x254d67
cmpl $0x7b, %eax
je 0x254d33
jmp 0x254d67
xorl %eax, %eax
retq
movl $0x65, %r15d
jmp 0x254d67
movq %r12, %r15
cmpq $0x2, %r15
setae %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq (%rdx), %rax
testq %rax, %rax
sete %dl
movq (%rcx), %rcx
testq %rcx, %rcx
sete %r8b
orb %dl, %r8b
je 0x254fcf
xorl %eax, %eax
jmp 0x254fee
movq %rsp, %r15
movq %rax, (%r15)
movq %rcx, 0x8(%r15)
movq %r15, %rdx
callq 0x27b8f8
movq (%r15), %rcx
movq %rcx, (%r14)
movq 0x8(%r15), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movb $0x1, %al
xorl %r13d, %r13d
movb %al, 0x7(%rsp)
movq %r13, %rax
shlq $0x5, %rax
leaq 0x2eb453(%rip), %rcx    # 0x5419e0
cmpq 0x8(%rax,%rcx), %r15
jne 0x2565cc
testq %r15, %r15
je 0x2565e2
leaq 0x2eb440(%rip), %rcx    # 0x5419e0
addq %rcx, %rax
movq (%rax), %r12
xorl %ebx, %ebx
movsbl (%r14,%rbx), %edi
callq 0x11e450
movl %eax, %ebp
movsbl (%r12,%rbx), %edi
callq 0x11e450
cmpl %eax, %ebp
jne 0x2565cc
incq %rbx
cmpq %rbx, %r15
jne 0x2565a8
jmp 0x2565e2
cmpq $0x8, %r13
leaq 0x1(%r13), %rcx
setb %al
movq %rcx, %r13
cmpq $0x9, %rcx
jne 0x25657b
jmp 0x2565e6
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_handler::~scope_handler()
~scope_handler()
         {
            parser_.sem_.deactivate(parser_.state_.scope_depth);
            parser_.state_.scope_depth--;
            #ifdef exprtk_enable_debugging
            const std::string depth(2 * parser_.state_.scope_depth,'-');
            exprtk_debug(("<%s Scope Depth: %02d\n",
                          depth.c_str(),
                          static_cast<int>(parser_.state_.scope_depth)));
            #endif
         }

// Assembly:
movq (%rdi), %rax
movq 0x540(%rax), %rdi
movq 0x3b0(%rax), %rcx
movq 0x538(%rax), %rdx
subq %rdx, %rdi
je 0x274ab6
sarq $0x4, %rdi
movabsq $0x6db6db6db6db6db7, %rsi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rdi, %rsi
cmpq $0x1, %rsi
adcq $0x0, %rsi
addq $0x4c, %rdx
cmpb $0x1, (%rdx)
jne 0x274aad
cmpq %rcx, -0x1c(%rdx)
jb 0x274aad
movb $0x0, (%rdx)
addq $0x70, %rdx
decq %rsi
jne 0x274a9f
decq %rcx
movq %rcx, 0x3b0(%rax)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r14
movq 0x8(%rsi), %rax
subq %r14, %rax
je 0x274bb3
sarq $0x3, %rax
cmpq $0x1, %rax
movq %rax, %rcx
adcq $0x0, %rcx
cmpq $0x0, (%r14)
je 0x274b12
movl $0x1, %esi
movq %rsi, %rdx
cmpq %rsi, %rcx
je 0x274b0d
leaq 0x1(%rdx), %rsi
cmpq $0x0, (%r14,%rdx,8)
jne 0x274afa
cmpq %rax, %rdx
jae 0x274b75
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x274b4a
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x274b4a
addq %r15, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x274b42
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x274b4a
movq %r14, %rdi
callq 0x1ea63e
incq %r12
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %r14, %rcx
sarq $0x3, %rcx
addq $0x8, %r15
cmpq %rcx, %r12
jb 0x274b18
cmpq %r14, %rax
je 0x274b70
movq %r14, 0x8(%rbx)
xorl %r14d, %r14d
jmp 0x274bef
xorl %r12d, %r12d
movq (%r14,%r12,8), %r14
testq %r14, %r14
je 0x274bc9
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x274b9d
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x274bc9
incq %r12
movq (%rbx), %r14
movq 0x8(%rbx), %rax
subq %r14, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jb 0x274b78
movq %r15, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x274c16
movl $0x38, %edi
callq 0x11e0f0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x274d24
movq %r14, %rdi
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *0x10(%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330