LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::node_collection_destructor<exprtk::details::expression_node<double>>::collect_nodes(exprtk::details::expression_node<double>*&, std::vector<exprtk::details::expression_node<double>**, std::allocator<exprtk::details::expression_node<double>**>>&)
static void collect_nodes(node_ptr_t& root, noderef_list_t& node_delete_list)
         {
            std::deque<node_ptr_t> node_list;
            node_list.push_back(root);
            node_delete_list.push_back(&root);

            noderef_list_t child_node_delete_list;
            child_node_delete_list.reserve(1000);

            while (!node_list.empty())
            {
               node_list.front()->collect_nodes(child_node_delete_list);

               if (!child_node_delete_list.empty())
               {
                  for (std::size_t i = 0; i < child_node_delete_list.size(); ++i)
                  {
                     node_pp_t& node = child_node_delete_list[i];

                     if (0 == (*node))
                     {
                        exprtk_debug(("ncd::collect_nodes() - null node encountered.\n"));
                     }

                     node_list.push_back(*node);
                  }

                  node_delete_list.insert(
                     node_delete_list.end(),
                     child_node_delete_list.begin(), child_node_delete_list.end());

                  child_node_delete_list.clear();
               }

               node_list.pop_front();
            }

            std::reverse(node_delete_list.begin(), node_delete_list.end());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, %rdi
callq 0x19862a
movq %r15, %rdi
movq %r14, %rsi
callq 0x1985ca
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x198a14
xorps %xmm0, %xmm0
movq %rsp, %rdi
movaps %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x1983be
movq %rsp, %r14
leaq 0x18(%rsp), %r15
movq 0x28(%rsp), %rax
cmpq %rax, 0x48(%rsp)
je 0x198523
movq (%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
cmpq %rcx, %rdx
je 0x198519
xorl %r12d, %r12d
movq %rcx, %rax
subq %rdx, %rax
sarq $0x3, %rax
cmpq %rax, %r12
jae 0x1984fd
movq (%rdx,%r12,8), %rsi
movq %r15, %rdi
callq 0x1985ca
incq %r12
movq (%rsp), %rdx
movq 0x8(%rsp), %rcx
jmp 0x1984d4
movq 0x8(%rbx), %rsi
movq %rbx, %rdi
callq 0x1985ec
movq (%rsp), %rax
cmpq %rax, 0x8(%rsp)
je 0x198519
movq %rax, 0x8(%rsp)
movq %r15, %rdi
callq 0x19860c
jmp 0x1984ab
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x198d3b
movq %rsp, %rdi
callq 0x198d8a
leaq 0x18(%rsp), %rdi
callq 0x198d5c
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x19854f
movq %rax, %rbx
jmp 0x198565
jmp 0x19855a
jmp 0x19855a
jmp 0x19855a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x198d8a
leaq 0x18(%rsp), %rdi
callq 0x198d5c
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::clear()
inline void clear()
         {
            base_itr_ = 0;
            s_itr_    = 0;
            s_end_    = 0;
            token_list_.clear();
            token_itr_ = token_list_.end();
            store_token_itr_ = token_list_.end();
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rdi)
andq $0x0, 0x68(%rdi)
callq 0x19e540
movq 0x8(%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19f9dc
movq %r8, %rbx
movq %rsi, %r14
movl $0x8, (%r8)
leaq 0x8(%r8), %rdi
leaq 0x148b78(%rip), %rsi    # 0x2e8547
callq 0x118600
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_O2/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 %rdi, %r14
xorl %r12d, %r12d
pushq $0x30
popq %r13
xorl %r15d, %r15d
xorl %ebp, %ebp
movq (%rbx), %rsi
movq 0x8(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r13
cmpq %rax, %rbp
jae 0x19fe8a
addq %r12, %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
movzbl %al, %eax
addq %rax, %r15
incq %rbp
addq $0x30, %r12
jmp 0x19fe5b
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1a0012
leaq 0x18(%rbx), %rdi
movq %r14, %rsi
callq 0x1a05e2
movq %r14, %rdi
callq 0x1a0596
movb $0x1, 0x10(%rbx)
addq $0x68, %rbx
movq %rbx, %rdi
callq 0x1a05c4
addq $0x58, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq 0x28(%rdi), %rax
je 0x1a00f5
leaq 0x8(%rsp), %rdi
callq 0x19e4ae
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x1a00a7
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movsbl -0x10(%rax), %esi
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x118560
movq 0x48(%rbx), %rax
cmpq 0x50(%rbx), %rax
jne 0x1a00cf
movq 0x60(%rbx), %rcx
movl $0x200, %eax            # imm = 0x200
addq -0x8(%rcx), %rax
movq -0x8(%rax), %rax
leaq 0x8(%rsp), %rsi
movq %rax, 0x28(%rsi)
leaq 0x68(%rbx), %rdi
callq 0x1a06d8
movb $0x0, 0x10(%rbx)
movq %r14, %rdi
callq 0x118648
xorl %eax, %eax
jmp 0x1a00f8
movb 0x10(%rbx), %al
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a0308
movq %rsi, %r15
movl (%rsi), %eax
andl $-0x2, %eax
cmpl $0x8, %eax
je 0x1a0308
movq %rdi, %r14
movq 0x8(%r15), %rax
movsbl (%rax), %edi
callq 0x1a0706
testb %al, %al
je 0x1a0308
movl (%r15), %eax
cmpl $0x7b, %eax
je 0x1a02ee
cmpl $0x5b, %eax
je 0x1a02de
cmpl $0x28, %eax
jne 0x1a0314
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x29, (%rsi)
jmp 0x1a02fc
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x5d, (%rsi)
jmp 0x1a02fc
addq $0x18, %r14
movq 0x28(%r15), %rax
movq %rsp, %rsi
movb $0x7d, (%rsi)
movq %rax, 0x8(%rsi)
movq %r14, %rdi
callq 0x1a072c
movl %ebx, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rax
movzbl (%rax), %eax
cmpl $0x29, %eax
je 0x1a032a
cmpl $0x7d, %eax
je 0x1a032a
cmpl $0x5d, %eax
jne 0x1a0308
movq 0x48(%r14), %rcx
cmpq 0x28(%r14), %rcx
je 0x1a035a
cmpq 0x50(%r14), %rcx
jne 0x1a0347
movq 0x60(%r14), %rdx
movl $0x200, %ecx            # imm = 0x200
addq -0x8(%rdx), %rcx
cmpb -0x10(%rcx), %al
jne 0x1a035a
addq $0x18, %r14
movq %r14, %rdi
callq 0x1a098e
jmp 0x1a0308
movb $0x0, 0x10(%r14)
addq $0x68, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x1a06d8
xorl %ebx, %ebx
jmp 0x1a0308
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a0a50
addq $0x8, %rsi
leaq 0x8(%rsp), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1a0a5c
testb %al, %al
jne 0x1a0a50
leaq 0x18(%rbx), %rdi
leaq 0x10(%rbx), %rsi
callq 0x1a0a78
incq 0x10(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::string_to_real<double>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double&)
inline bool string_to_real(const std::string& s, T& t)
      {
         const typename numeric::details::number_type<T>::type num_type;

         char_cptr begin = s.data();
         char_cptr end   = s.data() + s.size();

         return string_to_real(begin, end, t, num_type);
      }

// Assembly:
pushq %rax
movq %rsi, %rdx
movq (%rdi), %rsi
movq %rsp, %rax
movq %rsi, (%rax)
addq 0x8(%rdi), %rsi
movq %rax, %rdi
callq 0x1a0a98
popq %rcx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator::add_invalid_set1(exprtk::lexer::token::token_type)
void add_invalid_set1(const lexer::token::token_type t)
            {
               add_invalid(t, lexer::token::e_assign);
               add_invalid(t, lexer::token::e_shr   );
               add_invalid(t, lexer::token::e_shl   );
               add_invalid(t, lexer::token::e_lte   );
               add_invalid(t, lexer::token::e_ne    );
               add_invalid(t, lexer::token::e_gte   );
               add_invalid(t, lexer::token::e_lt    );
               add_invalid(t, lexer::token::e_gt    );
               add_invalid(t, lexer::token::e_eq    );
               add_invalid(t, lexer::token::e_comma );
               add_invalid(t, lexer::token::e_div   );
               add_invalid(t, lexer::token::e_mul   );
               add_invalid(t, lexer::token::e_mod   );
               add_invalid(t, lexer::token::e_pow   );
               add_invalid(t, lexer::token::e_colon );
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0xa
popq %rdx
callq 0x1a10ae
pushq $0x10
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x11
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x12
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x13
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x14
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x3c
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x3e
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x3d
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x2c
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x2f
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x2a
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x25
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x5e
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0x1a10ae
pushq $0x3a
popq %rdx
movq %r14, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1a10ae
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1a1514
testb %al, %al
je 0x1a122f
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a17ec
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a15dc
jmp 0x1a1266
leaq 0x10(%rbx), %rdi
movq %rsp, %rsi
callq 0x1a1826
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x1a1270
addq $0x40, %rbx
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a17ec
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a15dc
leaq 0x8(%rsp), %rdi
callq 0x1a148c
movb $0x1, %al
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1a1280
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1a148c
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, 0x18(%rsp)
movq %rdx, 0x1c(%rsp)
movq 0x18(%rsp), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl %ecx, 0x8(%rsi)
addq $0x10, %rdi
callq 0x1a1b98
leaq 0x18(%rbx), %rcx
cmpq %rcx, %rax
je 0x1a196f
addq $0x40, %rbx
leaq 0x18(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1a17ec
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a15dc
leaq 0x18(%rsp), %rdi
callq 0x1a148c
movb $0x1, %al
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1a148c
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19ff16
movq %rax, %r14
addq $0x10, %rbx
cmpq %rax, %rbx
jne 0x1a1c71
movq %rsp, %rdi
movq %r13, %rsi
callq 0x1182f0
movq %rsp, %rax
movl %ebp, 0x20(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x1a1e60
movq %rsp, %r15
movq %rax, %rdi
movq %r15, %rsi
callq 0x1a1ecc
movq %r15, %rdi
callq 0x118648
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
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_modifier(exprtk::lexer::token_modifier*)
inline bool register_modifier(lexer::token_modifier* modifier)
            {
               if (token_modifier_list.end() != std::find(token_modifier_list.begin(),
                                                          token_modifier_list.end  (),
                                                          modifier))
               {
                  return false;
               }

               token_modifier_list.push_back(modifier);

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x18(%rdi), %rdi
movq 0x20(%r14), %rbx
movq %rbx, %rsi
callq 0x1a22a9
movq %rax, %r15
cmpq %rax, %rbx
jne 0x1a1cd7
addq $0x18, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a228c
cmpq %r15, %rbx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_inserter(exprtk::lexer::token_inserter*)
inline bool register_inserter(lexer::token_inserter* inserter)
            {
               if (token_inserter_list.end() != std::find(token_inserter_list.begin(),
                                                          token_inserter_list.end  (),
                                                          inserter))
               {
                  return false;
               }

               token_inserter_list.push_back(inserter);

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x48(%rdi), %rdi
movq 0x50(%r14), %rbx
movq %rbx, %rsi
callq 0x1a25e9
movq %rax, %r15
cmpq %rax, %rbx
jne 0x1a1d25
addq $0x48, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a25cc
cmpq %r15, %rbx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_joiner(exprtk::lexer::token_joiner*)
inline bool register_joiner(lexer::token_joiner* joiner)
            {
               if (token_joiner_list.end() != std::find(token_joiner_list.begin(),
                                                        token_joiner_list.end  (),
                                                        joiner))
               {
                  return false;
               }

               token_joiner_list.push_back(joiner);

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x30(%rdi), %rdi
movq 0x38(%r14), %rbx
movq %rbx, %rsi
callq 0x1a27ed
movq %rax, %r15
cmpq %rax, %rbx
jne 0x1a1d73
addq $0x30, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a27d0
cmpq %r15, %rbx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::register_scanner(exprtk::lexer::token_scanner*)
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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq (%rdi), %rdi
movq 0x8(%r14), %rbx
movq %rbx, %rsi
callq 0x1a29f1
movq %rax, %r15
cmpq %rax, %rbx
jne 0x1a1dbc
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1a29d4
cmpq %r15, %rbx
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_vov_expression::process(exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
static inline expression_node_ptr process(expression_generator<Type>& expr_gen,
                                                      const details::operator_type& operation,
                                                      expression_node_ptr (&branch)[2])
            {
               const Type& v1 = static_cast<details::variable_node<Type>*>(branch[0])->ref();
               const Type& v2 = static_cast<details::variable_node<Type>*>(branch[1])->ref();

               switch (operation)
               {
                  #define case_stmt(op0, op1)                                                      \
                  case op0 : return expr_gen.node_allocator_->                                     \
                                template allocate_rr<typename details::vov_node<Type,op1<Type> > > \
                                   (v1, v2);                                                       \

                  basic_opr_switch_statements
                  extended_opr_switch_statements
                  #undef case_stmt
                  default : return error_node();
               }
            }

// Assembly:
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x19, %eax
ja 0x1a59ce
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq 0x28(%rcx), %rsi
movq 0x28(%rdx), %rdx
leaq 0x128a4c(%rip), %rcx    # 0x2ce3c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
jmp 0x1acc66
movq 0x8(%rdi), %rdi
jmp 0x1acfa6
movq 0x8(%rdi), %rdi
jmp 0x1acea6
movq 0x8(%rdi), %rdi
jmp 0x1acd66
movq 0x8(%rdi), %rdi
jmp 0x1acf66
movq 0x8(%rdi), %rdi
jmp 0x1acca6
movq 0x8(%rdi), %rdi
jmp 0x1acda6
movq 0x8(%rdi), %rdi
jmp 0x1ace66
movq 0x8(%rdi), %rdi
jmp 0x1acd26
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdi
jmp 0x1acce6
movq 0x8(%rdi), %rdi
jmp 0x1acde6
movq 0x8(%rdi), %rdi
jmp 0x1ace26
movq 0x8(%rdi), %rdi
jmp 0x1acfe6
movq 0x8(%rdi), %rdi
jmp 0x1ad026
movq 0x8(%rdi), %rdi
jmp 0x1acf26
movq 0x8(%rdi), %rdi
jmp 0x1acee6
movq 0x8(%rdi), %rdi
jmp 0x1ad0a6
movq 0x8(%rdi), %rdi
jmp 0x1ad066
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x2a34b8(%rip), %rcx    # 0x450140
movq %rcx, (%rax)
leaq 0x2a350e(%rip), %rcx    # 0x4501a0
movq %rcx, 0x8(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1ad9f2
movq %rsi, %rbx
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x1ad9f2
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1ad9f4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x1ad9f4
popq %rbx
retq
movq %rbx, %rdi
popq %rbx
jmp 0x19833c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x2a32f6(%rip), %rcx    # 0x450d20
movq %rcx, (%rax)
leaq 0x2a334c(%rip), %rcx    # 0x450d80
movq %rcx, 0x8(%rax)
movsd (%r14), %xmm0
movsd %xmm0, 0x20(%rax)
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::literal_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::literal_node<double>, double const>(double const&) const
inline expression_node<typename node_type::value_type>* allocate(T1& t1) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %rbx
movq %rsi, %rbx
pushq $0x28
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x2a2d88(%rip), %rcx    # 0x450c98
movq %rcx, (%rax)
leaq 0x2a2dc6(%rip), %rcx    # 0x450ce0
movq %rcx, 0x8(%rax)
movsd (%rbx), %xmm0
movsd %xmm0, 0x20(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cardinal_pow_optimisation(double const&, double const&)
inline expression_node_ptr cardinal_pow_optimisation(const T& v, const T& c)
         {
            const bool not_recipricol = (c >= T(0));
            const unsigned int p = static_cast<unsigned int>(details::numeric::to_int32(details::numeric::abs(c)));

            if (0 == p)
               return node_allocator_->allocate_c<literal_node_t>(T(1));
            else if (std::equal_to<T>()(T(2),c))
            {
               return node_allocator_->
                  template allocate_rr<typename details::vov_node<Type,details::mul_op<Type> > >(v,v);
            }
            else
            {
               if (not_recipricol)
                  return cardinal_pow_optimisation_impl<T,details::ipow_node>(v,p);
               else
                  return cardinal_pow_optimisation_impl<T,details::ipowinv_node>(v,p);
            }
         }

// Assembly:
subq $0x18, %rsp
movsd (%rdx), %xmm0
movapd 0x11fd18(%rip), %xmm1   # 0x2ce180
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x1ae498
ucomisd 0x11fd64(%rip), %xmm0   # 0x2ce1e8
jne 0x1ae4b5
jp 0x1ae4b5
movq 0x8(%rdi), %rdi
movq %rsi, %rdx
addq $0x18, %rsp
jmp 0x1acce6
movq 0x8(%rdi), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
callq 0x1ae9f6
jmp 0x1ae4d0
xorpd %xmm1, %xmm1
leaq 0xc(%rsp), %rdx
ucomisd %xmm1, %xmm0
jae 0x1ae4cb
callq 0x1aec68
jmp 0x1ae4d0
callq 0x1aea2c
addq $0x18, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x30
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x2a7340(%rip), %rcx    # 0x455838
movq %rcx, (%rax)
leaq 0x2a7396(%rip), %rcx    # 0x455898
movq %rcx, 0x8(%rax)
movq %r14, 0x20(%rax)
movsd (%rbx), %xmm0
movsd %xmm0, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::string_literal_node<double>::value_type>* exprtk::details::node_allocator::allocate_c<exprtk::details::string_literal_node<double>, char [1]>(char const (&) [1]) const
inline expression_node<typename node_type::value_type>* allocate_c(const T1& t1) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movl $0xa0, %edi
callq 0x118100
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %r14, %rsi
callq 0x127016
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x25882c
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x28aacf
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_vovov_expression0::id[abi:cxx11](exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type, exprtk::details::operator_type)
static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "t";
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x4(%rsp)
movl %ecx, (%rsp)
leaq 0x48(%rsp), %rsi
movq $0x40, (%rsi)
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x1b3e24
leaq 0x12740c(%rip), %rsi    # 0x2d9bd8
movq %r15, %rdi
callq 0x1b3e5e
movq %rax, %r15
leaq 0x28(%rsp), %rdi
leaq 0x4(%rsp), %rdx
movq %r14, %rsi
callq 0x1b3eb0
leaq 0x28(%rsp), %rsi
movq %r15, %rdi
callq 0x118460
leaq 0x126f5f(%rip), %rsi    # 0x2d975c
movq %r15, %rdi
callq 0x1b3e5e
movq %rax, %r15
leaq 0x8(%rsp), %rdi
movq %rsp, %rdx
movq %r14, %rsi
callq 0x1b3eb0
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x118460
leaq 0x132a71(%rip), %rsi    # 0x2e529d
movq %r15, %rdi
callq 0x1b3e5e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1182f0
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x50(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1b2873
jmp 0x1b286e
movq %rax, %rbx
jmp 0x1b288f
movq %rax, %rbx
jmp 0x1b2885
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x50(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::valid_operator(exprtk::details::operator_type const&, double (*&)(double const&, double const&))
inline bool valid_operator(const details::operator_type& operation, binary_functor_t& bop)
         {
            typename binary_op_map_t::iterator bop_itr = binary_op_map_->find(operation);

            if (binary_op_map_->end() == bop_itr)
               return false;

            bop = bop_itr->second;

            return true;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x48(%rdi), %rdi
callq 0x1b3f9e
movq 0x48(%r14), %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x1b28c9
movq 0x28(%rax), %rdx
movq %rdx, (%rbx)
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::sf3_optimisable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::details::operator_type&) const
inline bool sf3_optimisable(const std::string& sf3id, details::operator_type& operation) const
         {
            typename sf3_map_t::const_iterator itr = sf3_map_->find(sf3id);

            if (sf3_map_->end() == itr)
               return false;
            else
               operation = itr->second.second;

            return true;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rdi
callq 0x1b2b5e
movq 0x58(%r14), %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x1b28fd
movl 0x48(%rax), %edx
movl %edx, (%rbx)
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2, T3 t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
pushq $0x68
popq %rdi
callq 0x118100
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x1182f0
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1182f0
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x287f06
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x287cd5
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x118648
jmp 0x287ce4
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::to_str[abi:cxx11](exprtk::details::operator_type const&) const
inline std::string to_str(const details::operator_type& operation) const
         {
            switch (operation)
            {
               case details::e_add  : return "+"      ;
               case details::e_sub  : return "-"      ;
               case details::e_mul  : return "*"      ;
               case details::e_div  : return "/"      ;
               case details::e_mod  : return "%"      ;
               case details::e_pow  : return "^"      ;
               case details::e_lt   : return "<"      ;
               case details::e_lte  : return "<="     ;
               case details::e_gt   : return ">"      ;
               case details::e_gte  : return ">="     ;
               case details::e_eq   : return "=="     ;
               case details::e_ne   : return "!="     ;
               case details::e_and  : return "and"    ;
               case details::e_nand : return "nand"   ;
               case details::e_or   : return "or"     ;
               case details::e_nor  : return "nor"    ;
               case details::e_xor  : return "xor"    ;
               case details::e_xnor : return "xnor"   ;
               default              : return "UNKNOWN";
            }
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdx), %eax
addl $-0x2, %eax
cmpl $0x19, %eax
ja 0x1b3f2f
leaq 0x11a8f3(%rip), %rcx    # 0x2ce7bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x13464e(%rip), %rsi    # 0x2e8527
jmp 0x1b3f87
leaq 0x11f357(%rip), %rsi    # 0x2d323c
jmp 0x1b3f87
leaq 0x11f493(%rip), %rsi    # 0x2d3384
jmp 0x1b3f87
leaq 0x11f468(%rip), %rsi    # 0x2d3365
jmp 0x1b3f87
leaq 0x129ad8(%rip), %rsi    # 0x2dd9e1
jmp 0x1b3f87
leaq 0x11f451(%rip), %rsi    # 0x2d3363
jmp 0x1b3f87
leaq 0x11f44c(%rip), %rsi    # 0x2d3367
jmp 0x1b3f87
leaq 0x11f45e(%rip), %rsi    # 0x2d3382
jmp 0x1b3f87
leaq 0x13fd15(%rip), %rsi    # 0x2f3c42
jmp 0x1b3f87
leaq 0x125c85(%rip), %rsi    # 0x2d9bbb
jmp 0x1b3f87
leaq 0x133abc(%rip), %rsi    # 0x2e79fb
jmp 0x1b3f87
leaq 0x1263fc(%rip), %rsi    # 0x2da344
jmp 0x1b3f87
leaq 0x11f42a(%rip), %rsi    # 0x2d337b
jmp 0x1b3f87
leaq 0x11f2d1(%rip), %rsi    # 0x2d322b
jmp 0x1b3f87
leaq 0x11f302(%rip), %rsi    # 0x2d3265
jmp 0x1b3f87
leaq 0x11f412(%rip), %rsi    # 0x2d337e
jmp 0x1b3f87
leaq 0x1345bd(%rip), %rsi    # 0x2e8532
jmp 0x1b3f87
leaq 0x11f2e6(%rip), %rsi    # 0x2d3264
jmp 0x1b3f87
leaq 0x11f2e2(%rip), %rsi    # 0x2d3269
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::T0oT1oT2<double, double const&, double const&, double const&, exprtk::details::T0oT1oT2process<double>::mode0>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::T0oT1oT2<double, double const&, double const&, double const&, exprtk::details::T0oT1oT2process<double>::mode0>, double const&, double const&, double const&, double (*)(double const&, double const&), double (*)(double const&, double const&)>(double const&, double const&, double const&, double (*)(double const&, double const&), double (*)(double const&, double const&)) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2,
                                                                               T3 t3, T4 t4,
                                                                               T5 t5) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
pushq $0x48
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x2a37f8(%rip), %rcx    # 0x457818
movq %rcx, (%rax)
leaq 0x2a383e(%rip), %rcx    # 0x457868
movq %rcx, 0x8(%rax)
movq %r13, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %r15, 0x30(%rax)
movq %r14, 0x38(%rax)
movq %rbx, 0x40(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> exprtk::details::T0oT1oT2process<double>::mode0::id<double const&, double const&, double const&>()
static inline std::string id()
            {
               static const std::string result = "(" + exprtk_crtype(T0) + "o"   +
                                                       exprtk_crtype(T1) + ")o(" +
                                                       exprtk_crtype(T2) + ")"   ;
               return result;
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %rbx
movb 0x30f56b(%rip), %al     # 0x4c3620
testb %al, %al
je 0x1b40d6
leaq 0x30f540(%rip), %rsi    # 0x4c3600
movq %rbx, %rdi
callq 0x1182f0
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
leaq 0x30f543(%rip), %rdi    # 0x4c3620
callq 0x1181a0
testl %eax, %eax
je 0x1b40b9
leaq 0x48(%rsp), %rdi
callq 0x1b436e
leaq 0x125ade(%rip), %rsi    # 0x2d9bd5
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x1b4349
leaq 0x125ac3(%rip), %rdx    # 0x2d9bd0
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1b42c3
leaq 0x28(%rsp), %rdi
callq 0x1b436e
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x1b42e2
leaq 0x125a92(%rip), %rdx    # 0x2d9bdc
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x1b42c3
leaq 0x8(%rsp), %rdi
callq 0x1b436e
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x1b42e2
leaq 0x30f476(%rip), %rdi    # 0x4c3600
leaq 0x13412e(%rip), %rdx    # 0x2e82bf
leaq 0xe8(%rsp), %rsi
callq 0x1b42c3
leaq 0xe8(%rsp), %rdi
callq 0x118648
movq 0x302e36(%rip), %r14    # 0x4b6fe8
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0xc8(%rsp), %rdi
callq 0x118648
leaq 0xa8(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x88(%rsp), %rdi
callq 0x118648
leaq 0x68(%rsp), %rdi
callq 0x118648
leaq 0x48(%rsp), %rdi
callq 0x118648
leaq 0x30f3f8(%rip), %rsi    # 0x4c3600
leaq 0x303119(%rip), %rdx    # 0x4b7328
movq %r14, %rdi
callq 0x118490
leaq 0x30f402(%rip), %rdi    # 0x4c3620
callq 0x118300
jmp 0x1b40b9
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x118648
jmp 0x1b423d
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x1b424c
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x118648
jmp 0x1b425e
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x118648
jmp 0x1b4270
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x88(%rsp), %rdi
callq 0x118648
leaq 0x68(%rsp), %rdi
callq 0x118648
leaq 0x48(%rsp), %rdi
callq 0x118648
leaq 0x30f37e(%rip), %rdi    # 0x4c3620
callq 0x118220
movq %rbx, %rdi
callq 0x118360
movq %rax, %rbx
jmp 0x1b427a
movq %rax, %rbx
jmp 0x1b4287
movq %rax, %rbx
jmp 0x1b4291
movq %rax, %rbx
jmp 0x1b429b