LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f173a
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x1f17d0
movq (%rsp), %rdi
cmpq %rdi, 0x8(%rsp)
je 0x1f16fe
xorl %ebx, %ebx
movq (%rdi,%rbx,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x1f16df
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 0x1f16cd
testq %rdi, %rdi
je 0x1f1710
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1200c0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x1f1731
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::load_compile_options(unsigned long)
void load_compile_options(const std::size_t compile_options)
         {
            enable_replacer_           = (compile_options & e_replacer            ) == e_replacer;
            enable_joiner_             = (compile_options & e_joiner              ) == e_joiner;
            enable_numeric_check_      = (compile_options & e_numeric_check       ) == e_numeric_check;
            enable_bracket_check_      = (compile_options & e_bracket_check       ) == e_bracket_check;
            enable_sequence_check_     = (compile_options & e_sequence_check      ) == e_sequence_check;
            enable_commutative_check_  = (compile_options & e_commutative_check   ) == e_commutative_check;
            enable_strength_reduction_ = (compile_options & e_strength_reduction  ) == e_strength_reduction;
            enable_collect_vars_       = (compile_options & e_collect_vars        ) == e_collect_vars;
            enable_collect_funcs_      = (compile_options & e_collect_funcs       ) == e_collect_funcs;
            enable_collect_assings_    = (compile_options & e_collect_assings     ) == e_collect_assings;
            disable_vardef_            = (compile_options & e_disable_vardef      ) == e_disable_vardef;
            disable_rsrvd_sym_usr_     = (compile_options & e_disable_usr_on_rsrvd) == e_disable_usr_on_rsrvd;
            disable_zero_return_       = (compile_options & e_disable_zero_return ) == e_disable_zero_return;
         }

// Assembly:
movl %esi, %eax
andb $0x1, %al
movb %al, (%rdi)
movl %esi, %eax
shrb %al
andb $0x1, %al
movb %al, 0x1(%rdi)
movl %esi, %eax
shrb $0x2, %al
andb $0x1, %al
movb %al, 0x2(%rdi)
movl %esi, %eax
shrb $0x3, %al
andb $0x1, %al
movb %al, 0x3(%rdi)
movl %esi, %eax
shrb $0x4, %al
andb $0x1, %al
movb %al, 0x4(%rdi)
movl %esi, %eax
shrb $0x5, %al
andb $0x1, %al
movb %al, 0x5(%rdi)
movl %esi, %eax
shrb $0x6, %al
andb $0x1, %al
movb %al, 0x6(%rdi)
movl %esi, %eax
shrl $0x8, %eax
andb $0x1, %al
movb %al, 0x7(%rdi)
movl %esi, %eax
shrl $0x9, %eax
andb $0x1, %al
movb %al, 0x8(%rdi)
movl %esi, %eax
shrl $0xa, %eax
andb $0x1, %al
movb %al, 0x9(%rdi)
movl %esi, %eax
shrb $0x7, %al
movb %al, 0xa(%rdi)
movl %esi, %eax
shrl $0xb, %eax
andb $0x1, %al
movb %al, 0xb(%rdi)
shrl $0xc, %esi
andb $0x1, %sil
movb %sil, 0xc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1f95ef
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x1f9604
movq 0x40(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x1f9619
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1f962e
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
popq %rbx
jmp 0x1200c0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1faeae
movq %r8, %rbx
movq %rsi, %r14
movl $0x8, (%r8)
leaq 0x8(%r8), %rdi
movq 0x10(%r8), %rdx
leaq 0x1d0f7a(%rip), %rcx    # 0x3cbe13
movl $0x3, %r8d
xorl %esi, %esi
callq 0x120290
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_O1/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 0x1fb47c
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 0x1fb44a
jmp 0x1fb47f
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_O1/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 0x1fbc40
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1fbe08
movq %r14, %rdi
callq 0x1fbdb8
movb $0x1, 0x10(%rbx)
movl $0x0, 0x68(%rbx)
leaq 0x70(%rbx), %rdi
movq 0x78(%rbx), %rdx
leaq 0x1d09bf(%rip), %rcx    # 0x3cc1d5
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x120290
movq $-0x1, 0x90(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fb8fe
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 0x1fb88b
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 0x1202d0
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x1fb8b8
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 0x1205a0
movq 0x28(%rsp), %rax
movq %rax, 0x90(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x1fb8fa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
xorl %eax, %eax
jmp 0x1fb901
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 0x1fb925
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fbbb9
movq %rsi, %r15
movl (%rsi), %eax
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x8, %ecx
je 0x1fbbb9
movq %rdi, %r14
leaq 0x8(%r15), %rsi
movq (%rsi), %rcx
movzbl (%rcx), %ecx
leal -0x5b(%rcx), %edx
cmpl $0x22, %edx
ja 0x1fbb68
movabsq $0x500000005, %rdi      # imm = 0x500000005
btq %rdx, %rdi
jb 0x1fbb70
leal -0x28(%rcx), %edx
cmpl $0x2, %edx
jae 0x1fbbb9
cmpl $0x7b, %eax
je 0x1fbb9f
cmpl $0x5b, %eax
je 0x1fbb8f
cmpl $0x28, %eax
jne 0x1fbbc5
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x29, (%rsi)
jmp 0x1fbbad
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x5d, (%rsi)
jmp 0x1fbbad
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x7d, (%rsi)
movq %rax, 0x8(%rsi)
movq %r14, %rdi
callq 0x1fbec4
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
cmpl $0x29, %ecx
je 0x1fbbd4
cmpl $0x7d, %ecx
je 0x1fbbd4
cmpl $0x5d, %ecx
jne 0x1fbbb9
movq 0x48(%r14), %rdx
cmpq 0x28(%r14), %rdx
je 0x1fbc04
cmpq 0x50(%r14), %rdx
jne 0x1fbbf1
movq 0x60(%r14), %rdi
movl $0x200, %edx            # imm = 0x200
addq -0x8(%rdi), %rdx
cmpb -0x10(%rdx), %cl
jne 0x1fbc04
addq $0x18, %r14
movq %r14, %rdi
callq 0x1fc122
jmp 0x1fbbb9
movb $0x0, 0x10(%r14)
movl %eax, 0x68(%r14)
leaq 0x70(%r14), %rdi
callq 0x1205a0
movq 0x28(%r15), %rax
movq %rax, 0x90(%r14)
xorl %ebx, %ebx
jmp 0x1fbbb9
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fc20e
movq 0x8(%rsi), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
addq 0x10(%rsi), %rax
movq %rsp, %rdx
movq %rax, %rsi
callq 0x1fc21a
testb %al, %al
jne 0x1fc20e
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x1fc201
movq 0x10(%rbx), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x1fc20e
leaq 0x10(%rbx), %rdx
leaq 0x18(%rbx), %rdi
callq 0x1fc7da
incq 0x10(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fce86
testb %al, %al
je 0x1fcbbf
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fd212
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1fcf5c
jmp 0x1fcbf6
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x1fd2a4
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x1fcc2c
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fd212
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1fcf5c
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fcc11
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1200c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fcc2c
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1fcc3c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fcdfe
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
shlq $0x20, %rcx
orq %rax, %rcx
movl (%rsi), %eax
movl %eax, 0x8(%rsp)
movq %rcx, 0xc(%rsp)
movq 0x8(%rsp), %rax
movl 0x10(%rsp), %ecx
leaq 0x68(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
addq $0x10, %rdi
callq 0x1fd5e6
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x1fd3e4
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1fd212
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1fcf5c
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fd3c9
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x1200c0
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1fd3e4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1fcdfe
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1fb50e
movq %rax, %r14
addq $0x10, %rbx
cmpq %rax, %rbx
jne 0x1fd720
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 0x1eda34
movl %ebp, 0x20(%r13)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1fd808
movq %rax, %r15
movq %rsp, %r12
movq %rax, %rdi
movq %r12, %rsi
callq 0x1202b0
movl 0x20(%r12), %eax
movl %eax, 0x20(%r15)
movq (%r12), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x1fd720
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
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 0x1fd753
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::vov_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_rr<exprtk::details::vov_node<double, exprtk::details::add_op<double>>, double const, double const>(double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_rr(T1& t1, T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x30, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x3039c3(%rip), %rcx    # 0x5106a8
movq %rcx, (%rax)
leaq 0x303a19(%rip), %rcx    # 0x510708
movq %rcx, 0x8(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x20d72c
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x20d72c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20d72e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x20d72e
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x1f1690
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::cov_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_cr<exprtk::details::cov_node<double, exprtk::details::add_op<double>>, double, double const>(double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_cr(const T1& t1, T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x30, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x303bb1(%rip), %rcx    # 0x511310
movq %rcx, (%rax)
leaq 0x303c07(%rip), %rcx    # 0x511370
movq %rcx, 0x8(%rax)
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::voc_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_rc<exprtk::details::voc_node<double, exprtk::details::add_op<double>>, double const, double>(double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_rc(T1& t1, const T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movl $0x30, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x307c33(%rip), %rcx    # 0x515eb0
movq %rcx, (%rax)
leaq 0x307c89(%rip), %rcx    # 0x515f10
movq %rcx, 0x8(%rax)
movq %r14, 0x20(%rax)
movsd (%rbx), %xmm0
movsd %xmm0, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x8(%rsp)
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r13
movq 0x58(%rdi), %rdi
callq 0x2115d4
movq %rax, %r12
movq 0x58(%r13), %rbp
addq $0x8, %rbp
cmpq %rax, %rbp
je 0x21330c
movl 0x48(%r12), %eax
leaq 0x14(%rsp), %rsi
movl %eax, (%rsi)
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
movsd 0x8(%rsp), %xmm0
callq 0x213596
movq %rax, (%rbx)
cmpq %r12, %rbp
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_O1/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 0x21d4c8
movq %rax, %r12
movq 0x60(%rbp), %rbx
addq $0x8, %rbx
cmpq %rax, %rbx
je 0x21c902
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 0x21cc80
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_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
cmpq %rsi, 0x10(%rdi)
je 0x266e1f
xorl %r14d, %r14d
movabsq $0x6db6db6db6db6db7, %r15 # imm = 0x6DB6DB6DB6DB6DB7
xorl %r12d, %r12d
addq %r14, %rsi
movq %rbx, %rdi
callq 0x26aef2
incq %r12
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
sarq $0x4, %rax
imulq %r15, %rax
addq $0x70, %r14
cmpq %rax, %r12
jb 0x266df5
leaq 0x8(%rbx), %rdi
callq 0x26afe8
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x266e7e
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x266e66
movq 0x18(%r14), %rsi
subq %rdi, %rsi
callq 0x1200c0
movl $0x20, %esi
movq %r14, %rdi
callq 0x1200c0
movq $0x0, 0x3d0(%rbx)
movb $0x0, 0x3ab(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rsi), %r15
movq %r15, 0x58(%rdi)
movq %r15, 0x60(%rdi)
movq 0x8(%rsi), %r14
leaq (%r15,%r14), %rcx
movq %rcx, 0x68(%rdi)
movl $0x6, 0x28(%rdi)
addq $0x30, %rdi
movq 0x38(%rbx), %rdx
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x120110
testq %r15, %r15
je 0x267833
movq %r14, 0x50(%rbx)
movq (%rbx), %rsi
movq %rbx, %rdi
callq 0x1f97fa
movq 0x68(%rbx), %rax
cmpq 0x60(%rbx), %rax
sete %bpl
je 0x267877
xorl %ebp, %ebp
movq %rbx, %rdi
callq 0x26b518
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
je 0x267869
movl -0x30(%rax), %eax
decl %eax
cmpl $0x5, %eax
jb 0x267877
movq 0x68(%rbx), %rax
cmpq 0x60(%rbx), %rax
sete %bpl
jne 0x26784e
testb $0x1, %bpl
je 0x2678bd
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %r14, 0x18(%rbx)
movq %r14, 0x20(%rbx)
cmpq %r14, %rax
je 0x26789b
leaq 0x30(%r14), %rax
movq %rax, 0x18(%rbx)
jmp 0x26789f
leaq 0x28(%rbx), %r14
movl (%r14), %eax
movl %eax, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0x1205a0
movq 0x28(%r14), %rax
movq %rax, 0x98(%rbx)
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26cbae
leaq 0x28(%rbx), %rdi
movq 0x28(%rbx), %rsi
callq 0x26cbae
leaq 0x40(%rbx), %rdi
movq 0x40(%rbx), %rsi
callq 0x26cc00
movw $0x0, 0xb(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x396a0c
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 0x1200c0
movq %r14, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rdi)
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 0x1205a0
leaq 0x38(%rbx), %rdi
movq 0x28(%r12), %rax
movq %rax, 0x28(%rbx)
movq %r15, %rsi
callq 0x1205a0
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1205a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x266b98
movq %r14, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26afe7
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x14851e(%rip), %rcx    # 0x3b342c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x26af2a
movl $0x8, %esi
callq 0x1200c0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x26af99
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x26af99
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x26af68
movq (%r14), %rdi
leaq 0x10(%r14), %rax
cmpq %rax, %rdi
je 0x26af5b
movq (%rax), %rsi
incq %rsi
callq 0x1200c0
movl $0x20, %esi
movq %r14, %rdi
callq 0x1200c0
movq 0x68(%rbx), %rdi
testq %rdi, %rdi
je 0x26af99
movl $0x88, %esi
jmp 0x26af94
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x26af86
callq 0x1201e0
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x26af99
movl $0x48, %esi
callq 0x1200c0
movq 0x8(%rbx), %rdx
leaq 0x1602f4(%rip), %rcx    # 0x3cb298
movl $0x3, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x120290
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
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26bd56
leaq 0x1(%r14), %rsi
xorl %ecx, %ecx
movq %r14, %r8
movq %rsi, %rdx
movzbl -0x1(%rsi), %esi
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x26bd3d
movl %esi, %edi
andb $-0x21, %dil
addb $-0x41, %dil
cmpb $0x1a, %dil
jb 0x26bd3d
cmpl $0x5f, %esi
je 0x26bd3d
cmpl $0x2e, %esi
jne 0x26bd56
testq %rcx, %rcx
je 0x26bd3d
cmpq %rax, %rdx
je 0x26bd3d
movb (%rdx), %sil
cmpb $0x5f, %sil
je 0x26bd3d
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x26bd3d
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x26bdd7
incq %r8
movq %rdx, 0x60(%rbx)
leaq 0x1(%rdx), %rsi
decq %rcx
cmpq %rax, %rdx
jne 0x26bce5
decq %rsi
movq %rsi, %r8
leaq 0x10(%rsp), %rdi
movl $0x0, -0x8(%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 0x120110
testq %r12, %r12
je 0x26bda7
subq %r12, %r14
movq %r14, 0x30(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1fa4a4
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x26bdcb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
decq %rdx
movq %rdx, %r8
jmp 0x26bd56
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r15, %rdi
je 0x26bdfc
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26c14f
leaq 0xb(%r14), %r8
cmpq %r8, %r15
cmovbq %r15, %r8
movq 0x58(%rbx), %r12
movl $0x5, 0x8(%rsp)
movq 0x18(%rsp), %rdx
subq %r14, %r8
xorl %esi, %esi
movq %r14, %rcx
callq 0x120110
jmp 0x26c1e0
cmpb $0x24, (%r14)
jne 0x26c1b7
movsbl 0x1(%r14), %ebp
movl $0x66, %edi
callq 0x120450
movl %eax, %r12d
movl %ebp, %edi
callq 0x120450
leaq 0x10(%rsp), %rdi
cmpl %eax, %r12d
jne 0x26c1b7
movb 0x2(%r14), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x26c1b7
movb 0x3(%r14), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x26c1b7
leaq 0x4(%r14), %rax
movq %rax, 0x60(%rbx)
movq 0x58(%rbx), %r12
movl $0x8, 0x8(%rsp)
movq 0x18(%rsp), %rdx
movl $0x4, %r8d
xorl %esi, %esi
movq %r14, %rcx
callq 0x120110
jmp 0x26c1e0
leaq 0x4(%r14), %r8
cmpq %r8, %r15
cmovbq %r15, %r8
movq 0x58(%rbx), %r12
movl $0x5, 0x8(%rsp)
movq 0x18(%rsp), %rdx
subq %r14, %r8
xorl %esi, %esi
movq %r14, %rcx
callq 0x120110
testq %r12, %r12
je 0x26c1ed
subq %r12, %r14
movq %r14, 0x30(%rsp)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1fa4a4
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x26c211
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26c224
jmp 0x26c224
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x26c23e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x26c988
leaq (%rdx,%rdx,2), %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x26ca16
jmp 0x26c9a4
movb 0x31a56a(%rip), %al     # 0x586ef8
testb %al, %al
je 0x26c9a9
leaq 0x31a52f(%rip), %rdx    # 0x586ec8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1fd212
movq %rbx, %rax
popq %rbx
retq
callq 0x120983
jmp 0x26c992
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1eabb8
testl %ebp, %ebp
je 0x271199
cmpq $0x0, 0x8(%rbx)
je 0x271199
xorl %eax, %eax
movq (%rbx), %rcx
movzbl (%rcx,%rax), %edx
leal -0x8(%rdx), %esi
cmpl $0x6, %esi
jae 0x271192
movb $0x20, (%rcx,%rax)
incq %rax
cmpq 0x8(%rbx), %rax
jb 0x271174
jmp 0x271199
cmpl $0x20, %edx
je 0x271183
jmp 0x271187
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x27174d
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %rcx
cmpq 0x8(%rax), %rcx
je 0x27174d
movq 0x10(%rbx), %rax
movq (%rax), %r14
movq 0x8(%rax), %rcx
cmpq %r14, %rcx
je 0x271744
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x271723
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x271723
addq %r15, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x27171b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x271723
movq %r14, %rdi
callq 0x1f1690
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 0x2716f1
cmpq %r14, %rcx
je 0x27174d
movq %r14, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x1eabad
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x272e24
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 0x272e27
incq %r15
movq 0x338(%r14), %rcx
cmpq 0x318(%r14), %rcx
jne 0x272e2d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
cmpl $0x21, %eax
ja 0x272e1a
movl %eax, %ecx
btq %rcx, %r13
jae 0x272e1a
cmpl $0x5b, 0x70(%r14)
jne 0x272e2d
movq %r14, %rdi
movq %rbx, %rsi
callq 0x394bd8
movq %rax, (%rbx)
incq %r12
testq %rax, %rax
jne 0x272dcc
jmp 0x272e2d
cmpl $0x7b, %eax
je 0x272dfb
movq %r12, %r15
jmp 0x272e2d
xorl %eax, %eax
retq
movl $0x65, %r15d
cmpq $0x2, %r15
setae %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq