LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::assert_call(exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&, exprtk::assert_check::assert_context const&)
inline expression_node_ptr assert_call(expression_node_ptr& assert_condition,
                                                expression_node_ptr& assert_message,
                                                const assert_check::assert_context& context)
         {
            typedef details::assert_node<Type> alloc_type;

            expression_node_ptr result = node_allocator_->allocate_rrrr<alloc_type>
               (assert_condition, assert_message, parser_->assert_check_, context);

            if (result && result->valid())
            {
               parser_->state_.activate_side_effect("assert_call()");
               return result;
            }

            details::free_node(*node_allocator_, result          );
            details::free_node(*node_allocator_, assert_condition);
            details::free_node(*node_allocator_, assert_message  );

            return error_node();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movl $0x8f0, %ecx            # imm = 0x8F0
addq 0x68(%r15), %rcx
callq 0x2a39de
movq %rax, 0x10(%rsp)
testq %rax, %rax
je 0x2a38e3
movq %rax, %r14
movq (%rax), %rax
movq %r14, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x2a38e3
movq 0x68(%r15), %rbx
leaq 0x39882(%rip), %rsi     # 0x2dd13a
leaq 0x18(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x127016
cmpb $0x0, 0x3ac(%rbx)
jne 0x2a38d7
movb $0x1, 0x3ac(%rbx)
leaq 0x18(%rsp), %rdi
callq 0x118648
jmp 0x2a390c
movq 0x8(%r15), %rdi
leaq 0x10(%rsp), %rsi
callq 0x1ad9c8
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1ad9c8
movq 0x8(%r15), %rdi
movq %rbx, %rsi
callq 0x1ad9c8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::assert_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::assert_check*, exprtk::assert_check::assert_context)
assert_node(expression_ptr   assert_condition_node,
                     expression_ptr   assert_message_node,
                     assert_check_ptr assert_check,
                     assert_context_t context)
         : assert_message_str_base_(0)
         , assert_check_(assert_check)
         , context_(context)
         {
            construct_branch_pair(assert_condition_node_, assert_condition_node);
            construct_branch_pair(assert_message_node_  , assert_message_node  );

            #ifndef exprtk_disable_string_capabilities
            if (
                  assert_message_node_.first &&
                  details::is_generally_string_node(assert_message_node_.first)
               )
            {
               assert_message_str_base_ = dynamic_cast<str_base_ptr>(assert_message_node_.first);
            }
            #endif

            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x20f118(%rip), %rdx    # 0x4b2c18
movq %rdx, (%rdi)
leaq 0x20f15e(%rip), %rdx    # 0x4b2c68
movq %rdx, 0x8(%rdi)
movb %al, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
movb %al, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq %rsi, %r12
leaq 0x20(%rdi), %r13
movq %rcx, 0x48(%rdi)
leaq 0x50(%rdi), %r14
movq %r14, %rdi
movq %r8, %rsi
callq 0x2a3a82
movq %r13, %rdi
movq %r12, %rsi
callq 0x2085be
leaq 0x30(%rbx), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x2085be
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2a3b8b
callq 0x20b691
testb %al, %al
je 0x2a3b8b
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2a3b85
leaq 0x1ab55c(%rip), %rsi    # 0x44f0d0
leaq 0x1dcf0d(%rip), %rdx    # 0x480a88
pushq $-0x2
popq %rcx
callq 0x118510
jmp 0x2a3b87
xorl %eax, %eax
movq %rax, 0x40(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r14, %rdi
callq 0x2a391c
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::value() const
inline T value() const exprtk_override
         {
            if (details::is_true(assert_condition_node_.first->value()))
            {
               return T(1);
            }

            #ifndef exprtk_disable_string_capabilities
            if (assert_message_node_.first)
            {
               assert_message_node_.first->value();
               assert(assert_message_str_base_);
               context_.message = assert_message_str_base_->str();
            }
            #endif

            assert_check_->handle_assert(context_);
            return T(0);
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x2a3c24
jnp 0x2a3c2e
movsd 0x2a594(%rip), %xmm0    # 0x2ce1c0
jmp 0x2a3c78
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2a3c63
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq *0x10(%rax)
leaq 0x70(%rbx), %rdi
movq %r14, %rsi
callq 0x1182d0
movq %r14, %rdi
callq 0x118648
movq 0x48(%rbx), %rdi
addq $0x50, %rbx
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
xorpd %xmm0, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assert_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return (
                     assert_check_ &&
                     assert_condition_node_.first &&
                     assert_condition_node_.first->valid()
                   ) &&
                   (
                     (0 == assert_message_node_.first) ||
                     (
                       assert_message_node_.first &&
                       assert_message_str_base_   &&
                       assert_message_node_.first->valid() &&
                       details::is_generally_string_node(assert_message_node_.first)
                     )
                   );
         }

// Assembly:
pushq %rbx
cmpq $0x0, 0x48(%rdi)
je 0x2a3cc8
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x2a3cc8
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2a3cc8
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x2a3ccc
cmpq $0x0, 0x40(%rbx)
je 0x2a3cc8
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2a3cc8
movq 0x30(%rbx), %rdi
popq %rbx
jmp 0x20b691
xorl %eax, %eax
popq %rbx
retq
movb $0x1, %al
jmp 0x2a3cca
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_variable_context(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline variable_context get_variable_context(const std::string& variable_name) const
         {
            variable_context result;

            if (valid_symbol(variable_name))
            {
               for (std::size_t i = 0; i < symtab_list_.size(); ++i)
               {
                  if (!symtab_list_[i].valid())
                  {
                     continue;
                  }

                  result.variable = local_data(i)
                                       .variable_store.get(variable_name);
                  if (result.variable)
                  {
                     result.symbol_table = &symtab_list_[i];
                     break;
                  }
               }
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x29f872
xorl %ebx, %ebx
testb %al, %al
je 0x2a3d5d
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x2a3d5d
movq (%rax,%r15), %rax
testq %rax, %rax
je 0x2a3d54
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a3d54
movq %r12, %rsi
callq 0x2a1894
testq %rax, %rax
jne 0x2a3d70
incq %r13
addq $0x8, %r15
jmp 0x2a3d22
xorl %r15d, %r15d
movq %r15, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq (%r14), %r15
movq %rax, %rbx
jmp 0x2a3d60
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_constant_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_constant_node(const std::string& symbol_name) const
         {
            if (!valid_symbol(symbol_name))
               return false;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

               if (local_data(i).variable_store.is_constant(symbol_name))
               {
                  return true;
               }
            }

            return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29f872
testb %al, %al
je 0x2a3dcb
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
setb %bpl
jae 0x2a3dcd
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x2a3dc6
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a3dc6
movq %rbx, %rsi
callq 0x2a5d38
testb %al, %al
jne 0x2a3dcd
incq %r15
jmp 0x2a3d91
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::post_variable_process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool post_variable_process(const std::string& symbol)
      {
         if (
              peek_token_is(token_t::e_lbracket   ) ||
              peek_token_is(token_t::e_lcrlbracket) ||
              peek_token_is(token_t::e_lsqrbracket)
            )
         {
            if (!settings_.commutative_check_enabled())
            {
               set_error(make_error(
                  parser_error::e_syntax,
                  current_token(),
                  "ERR229 - Invalid sequence of variable '" + symbol + "' and bracket",
                  exprtk_error_location));

               return false;
            }

            lexer().insert_front(token_t::e_mul);
         }

         return true;
      }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x130, %rsp            # imm = 0x130
movq %rdi, %rbx
movq 0x18(%rdi), %rax
leaq 0x28(%rdi), %rcx
cmpq %rax, 0x8(%rdi)
cmovneq %rax, %rcx
movq %rsi, %rdx
movl (%rcx), %eax
movb $0x1, %bpl
cmpl $0x28, %eax
je 0x2a3e13
cmpl $0x7b, %eax
je 0x2a3e13
cmpl $0x5b, %eax
jne 0x2a3ee5
cmpb $0x0, 0xd5(%rbx)
je 0x2a3e2c
pushq $0x2a
popq %rsi
movq %rbx, %rdi
callq 0x2a5d5e
jmp 0x2a3ee5
leaq 0x394bb(%rip), %rsi     # 0x2dd2ee
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x1f8aab
leaq 0x394cf(%rip), %rdx     # 0x2dd316
leaq 0x48(%rsp), %rdi
movq %r14, %rsi
callq 0x1b42c3
leaq 0x8(%rsp), %rdi
movl $0x787d, %esi           # imm = 0x787D
callq 0x1f7a3c
leaq 0x35d91(%rip), %rsi     # 0x2d9bfb
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b4349
leaq 0x70(%rbx), %rdx
leaq 0x88(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x48(%rsp), %rcx
leaq 0x28(%rsp), %r8
callq 0x1f7341
addq $0x308, %rbx            # imm = 0x308
leaq 0x88(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f76ce
leaq 0x88(%rsp), %rdi
callq 0x1f5c4c
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0x48(%rsp), %rdi
callq 0x118648
leaq 0x68(%rsp), %rdi
callq 0x118648
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x1f5c4c
jmp 0x2a3f08
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x118648
jmp 0x2a3f17
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x2a3f26
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x118648
jmp 0x2a3f35
movq %rax, %rbx
leaq 0x68(%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>::symtab_store::is_stringvar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_stringvar(const std::string& stringvar_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().stringvar_store
                           .symbol_exists(stringvar_name)
                       )
                  return true;
            }

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %r12
subq %rax, %r12
sarq $0x3, %r12
cmpq %r12, %r15
jae 0x2a4356
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x2a4351
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a4351
addq $0x188, %rdi            # imm = 0x188
movq %rbx, %rsi
callq 0x19678c
testb %al, %al
jne 0x2a4356
incq %r15
jmp 0x2a4319
cmpq %r12, %r15
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline function_ptr get_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<function_ptr>(0);

            function_ptr result = reinterpret_cast<function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2a69f8
xorl %ebx, %ebx
testb %al, %al
je 0x2a43c2
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x2a43c2
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2a43ba
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a43ba
addq $0x38, %rdi
movq %r14, %rsi
callq 0x2a6a0c
testq %rax, %rax
jne 0x2a43bf
incq %r12
jmp 0x2a4384
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_vararg_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline vararg_function_ptr get_vararg_function(const std::string& vararg_function_name) const
         {
            if (!valid_function_name(vararg_function_name))
               return reinterpret_cast<vararg_function_ptr>(0);

            vararg_function_ptr result = reinterpret_cast<vararg_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .vararg_function_store.get(vararg_function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2a69f8
xorl %ebx, %ebx
testb %al, %al
je 0x2a4752
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x2a4752
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2a474a
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a474a
addq $0x70, %rdi
movq %r14, %rsi
callq 0x2b533e
testq %rax, %rax
jne 0x2a474f
incq %r12
jmp 0x2a4714
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_generic_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_generic_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);

            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .generic_function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2a69f8
xorl %ebx, %ebx
testb %al, %al
je 0x2a4ecf
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x2a4ecf
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2a4ec7
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a4ec7
addq $0xa8, %rdi
movq %r14, %rsi
callq 0x2b5848
testq %rax, %rax
jne 0x2a4ecc
incq %r12
jmp 0x2a4e8e
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_string_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_string_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);

            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result =
                     local_data(i).string_function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2a69f8
xorl %ebx, %ebx
testb %al, %al
je 0x2a559f
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x2a559f
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2a5597
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a5597
addq $0xe0, %rdi
movq %r14, %rsi
callq 0x2b5848
testq %rax, %rax
jne 0x2a559c
incq %r12
jmp 0x2a555e
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_overload_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_overload_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);

            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result =
                     local_data(i).overload_function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
callq 0x2a69f8
xorl %ebx, %ebx
testb %al, %al
je 0x2a5899
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
jae 0x2a5899
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x2a5891
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a5891
addq $0x118, %rdi            # imm = 0x118
movq %r14, %rsi
callq 0x2b5848
testq %rax, %rax
jne 0x2a5896
incq %r12
jmp 0x2a5858
movq %rax, %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_base_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_base_function(const std::string& function_name)
      {
         for (std::size_t i = 0; i < base_function_list_size; ++i)
         {
            if (imatch(function_name, base_function_list[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x212633(%rip), %r14    # 0x4b82c0
xorl %ecx, %ecx
movq %rcx, %r15
cmpq $0x3a, %rcx
je 0x2a5caf
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fbcc5
leaq 0x1(%r15), %rcx
addq $0x20, %r14
testb %al, %al
je 0x2a5c8f
cmpq $0x3a, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_string_context(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline string_context get_string_context(const std::string& string_name) const
         {
            string_context result;

            if (!valid_symbol(string_name))
               return result;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

               result.str_var = local_data(i).stringvar_store.get(string_name);

               if (result.str_var)
               {
                  result.symbol_table = &symtab_list_[i];
                  break;
               }
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0x29f872
xorl %ebx, %ebx
testb %al, %al
je 0x2a5f78
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
jae 0x2a5f78
movq (%rax,%r15), %rax
testq %rax, %rax
je 0x2a5f6f
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a5f6f
addq $0x188, %rdi            # imm = 0x188
movq %r12, %rsi
callq 0x2a680c
testq %rax, %rax
jne 0x2a5f8b
incq %r13
addq $0x8, %r15
jmp 0x2a5f36
xorl %r15d, %r15d
movq %r15, %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
addq (%r14), %r15
movq %rax, %rbx
jmp 0x2a5f7b
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_conststr_stringvar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_conststr_stringvar(const std::string& symbol_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().stringvar_store
                           .symbol_exists(symbol_name)
                       )
               {
                  return (
                           local_data(i).stringvar_store.symbol_exists(symbol_name) ||
                           local_data(i).stringvar_store.is_constant  (symbol_name)
                         );

               }
            }

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
movq (%r14), %rcx
movq 0x8(%r14), %r13
subq %rcx, %r13
sarq $0x3, %r13
cmpq %r13, %r12
jae 0x2a601d
movq (%rcx,%r12,8), %rax
testq %rax, %rax
je 0x2a5fde
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a5fde
addq $0x188, %rdi            # imm = 0x188
movq %rbx, %rsi
callq 0x19678c
testb %al, %al
jne 0x2a5fe3
incq %r12
jmp 0x2a5fa6
movq (%r14), %rax
movq (%rax,%r12,8), %rax
movl $0x188, %r15d           # imm = 0x188
movq 0x8(%rax), %rdi
addq %r15, %rdi
movq %rbx, %rsi
callq 0x19678c
movl %eax, %ecx
movb $0x1, %al
testb %cl, %cl
jne 0x2a601d
movq (%r14), %rax
movq (%rax,%r12,8), %rax
addq 0x8(%rax), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x2a6828
cmpq %r13, %r12
setb %cl
andb %al, %cl
movl %ecx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_constant_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_constant_string(const std::string& symbol_name) const
         {
            if (!valid_symbol(symbol_name))
               return false;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (!local_data(i).stringvar_store.symbol_exists(symbol_name))
                  continue;
               else if (local_data(i).stringvar_store.is_constant(symbol_name))
                  return true;
            }

            return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0x29f872
testb %al, %al
je 0x2a60ad
xorl %r15d, %r15d
movl $0x188, %r12d           # imm = 0x188
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r15
setb %bpl
jae 0x2a60af
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x2a60a8
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x2a60a8
addq $0x188, %rdi            # imm = 0x188
movq %rbx, %rsi
callq 0x19678c
testb %al, %al
je 0x2a60a8
movq (%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rdi
addq %r12, %rdi
movq %rbx, %rsi
callq 0x2a6828
testb %al, %al
jne 0x2a60af
incq %r15
jmp 0x2a6052
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// 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<exprtk::details::string_literal_node<double>, char, std::char_traits<char>, std::__cxx11::basic_string>(std::__cxx11::basic_string<char, std::char_traits<char>> const&) const
inline expression_node<typename node_type::value_type>* allocate(const Sequence<Type,Allocator>& seq) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(seq));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0xa0, %edi
callq 0x118100
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x25882c
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
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>::parse_function_call_0(exprtk::ifunction<double>*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline expression_node_ptr parse_function_call_0(ifunction<T>* function, const std::string& function_name)
      {
         expression_node_ptr result = expression_generator_.function(function);

         state_.side_effect_present = function->has_side_effects();

         next_token();

         if (
               token_is(token_t::e_lbracket) &&
              !token_is(token_t::e_rbracket)
            )
         {
            set_error(make_error(
               parser_error::e_syntax,
               current_token(),
               "ERR028 - Expecting '()' to proceed call to function: '" + function_name + "'",
               exprtk_error_location));

            free_node(node_allocator_, result);

            return error_node();
         }
         else
            return result;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x138, %rsp            # imm = 0x138
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
addq $0x220, %rdi            # imm = 0x220
callq 0x2ad5c6
movq %rax, %r15
movq %rax, 0x8(%rsp)
movb 0x9(%r12), %al
movb %al, 0x3ac(%rbx)
movq %rbx, %rdi
callq 0x1f6d68
leaq 0x90(%rsp), %rsi
movl $0x28, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1fae6e
testb %al, %al
je 0x2a6bd9
leaq 0x10(%rsp), %rsi
movl $0x29, (%rsi)
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x1fae6e
testb %al, %al
jne 0x2a6bd9
leaq 0x36a16(%rip), %rsi     # 0x2dd528
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %r14, %rdx
callq 0x1f8aab
leaq 0x35c49(%rip), %rdx     # 0x2dc772
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1b42c3
leaq 0x30(%rsp), %rdi
movl $0x6563, %esi           # imm = 0x6563
callq 0x1f7a3c
leaq 0x330af(%rip), %rsi     # 0x2d9bfb
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x1b4349
leaq 0x70(%rbx), %rdx
leaq 0x90(%rsp), %rdi
pushq $0x1
popq %rsi
leaq 0x10(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x1f7341
leaq 0x308(%rbx), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1f76ce
leaq 0x90(%rsp), %rdi
callq 0x1f5c4c
leaq 0x50(%rsp), %rdi
callq 0x118648
leaq 0x30(%rsp), %rdi
callq 0x118648
leaq 0x10(%rsp), %rdi
callq 0x118648
leaq 0x70(%rsp), %rdi
callq 0x118648
addq $0x290, %rbx            # imm = 0x290
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1ad9c8
xorl %r15d, %r15d
movq %r15, %rax
addq $0x138, %rsp            # imm = 0x138
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x1f5c4c
jmp 0x2a6c00
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
jmp 0x2a6c0f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x118648
jmp 0x2a6c1e
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x118648
jmp 0x2a6c2d
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::synthesize_expression<exprtk::details::function_N_node<double, exprtk::ifunction<double>, 1ul>, 1ul>(exprtk::ifunction<double>*, exprtk::details::expression_node<double>* (&) [1ul])
inline expression_node_ptr synthesize_expression(F* f, expression_node_ptr (&branch)[N])
         {
            if (!details::all_nodes_valid<N>(branch))
            {
               free_all_nodes(*node_allocator_,branch);

               return error_node();
            }

            typedef typename details::function_N_node<T,ifunction_t,N> function_N_node_t;

            // Attempt simple constant folding optimisation.

            expression_node_ptr expression_point = node_allocator_->allocate<NodeType>(f);
            function_N_node_t* func_node_ptr = dynamic_cast<function_N_node_t*>(expression_point);

            if (0 == func_node_ptr)
            {
               free_all_nodes(*node_allocator_,branch);

               return error_node();
            }
            else
               func_node_ptr->init_branches(branch);

            if (is_constant_foldable<N>(branch) && !f->has_side_effects())
            {
               Type v = expression_point->value();
               details::free_node(*node_allocator_,expression_point);

               return node_allocator_->allocate<literal_node_t>(v);
            }

            parser_->state_.activate_side_effect("synthesize_expression(function<NT,N>)");

            return expression_point;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r15
movq %rdi, %r14
movq %rsi, 0x10(%rsp)
cmpq $0x0, (%rdx)
je 0x2ad863
movq 0x8(%r14), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2ad956
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2ad863
movq %rax, %rbx
leaq 0x2056a2(%rip), %rax    # 0x4b2f00
cmpq %rax, (%rbx)
je 0x2ad87e
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x1ad9c8
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2ad910
movq %r14, %rdi
movq %r15, %rsi
callq 0x20f038
testb %al, %al
je 0x2ad8a3
movq 0x10(%rsp), %rax
cmpb $0x0, 0x9(%rax)
je 0x2ad8db
movq 0x68(%r14), %r14
leaq 0x2fda5(%rip), %rsi     # 0x2dd653
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x127016
cmpb $0x0, 0x3ac(%r14)
jne 0x2ad8cf
movb $0x1, 0x3ac(%r14)
leaq 0x20(%rsp), %rdi
callq 0x118648
jmp 0x2ad871
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x18(%rax)
leaq 0x20(%rsp), %rbx
movsd %xmm0, (%rbx)
movq 0x8(%r14), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1ad9c8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2ad9a2
movq %rax, %rbx
jmp 0x2ad871
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 1ul>::value() const
inline T value() const exprtk_override
         {
            // Needed for incompetent and broken msvc compiler versions
            #ifdef _MSC_VER
             #pragma warning(push)
             #pragma warning(disable: 4127)
            #endif

            T v[N];
            evaluate_branches<T,N>::execute(v,branch_);
            return invoke<T,N>::execute(*function_,v);

            #ifdef _MSC_VER
             #pragma warning(pop)
            #endif
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::function_N_node<double, exprtk::ifunction<double>, 2ul>::init_branches<2ul>(exprtk::details::expression_node<double>* (&) [2ul])
bool init_branches(expression_ptr (&b)[NumBranches])
         {
            // Needed for incompetent and broken msvc compiler versions
            #ifdef _MSC_VER
             #pragma warning(push)
             #pragma warning(disable: 4127)
            #endif

            if (N != NumBranches)
            {
               return false;
            }

            for (std::size_t i = 0; i < NumBranches; ++i)
            {
               if (b[i] && b[i]->valid())
                  branch_[i] = std::make_pair(b[i],branch_deletable(b[i]));
               else
                  return false;
            }

            initialised_ = function_;
            assert(valid());
            return initialised_;

            #ifdef _MSC_VER
             #pragma warning(pop)
            #endif
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq $0x10, %r15
je 0x2ade28
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x2ade24
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2ade24
movq (%r14,%r15), %rdi
callq 0x1982f4
movq (%r14,%r15), %rcx
movq %rcx, 0x30(%rbx,%r15,2)
movb %al, 0x38(%rbx,%r15,2)
addq $0x8, %r15
jmp 0x2addee
xorl %eax, %eax
jmp 0x2ade34
cmpq $0x0, 0x20(%rbx)
setne %al
setne 0x50(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 4ul>::evaluate_branches<double, 4ul>::execute(double (&) [4], std::pair<exprtk::details::expression_node<double>*, bool> const (&) [4])
static inline void execute(T_ (&v)[4], const branch_t (&b)[4])
            {
               v[0] = b[0].first->value();
               v[1] = b[1].first->value();
               v[2] = b[2].first->value();
               v[3] = b[3].first->value();
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rbx)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rbx)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 5ul>::evaluate_branches<double, 5ul>::execute(double (&) [5], std::pair<exprtk::details::expression_node<double>*, bool> const (&) [5])
static inline void execute(T_ (&v)[5], const branch_t (&b)[5])
            {
               v[0] = b[0].first->value();
               v[1] = b[1].first->value();
               v[2] = b[2].first->value();
               v[3] = b[3].first->value();
               v[4] = b[4].first->value();
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rbx)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rbx)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rbx)
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x20(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 6ul>::evaluate_branches<double, 6ul>::execute(double (&) [6], std::pair<exprtk::details::expression_node<double>*, bool> const (&) [6])
static inline void execute(T_ (&v)[6], const branch_t (&b)[6])
            {
               v[0] = b[0].first->value();
               v[1] = b[1].first->value();
               v[2] = b[2].first->value();
               v[3] = b[3].first->value();
               v[4] = b[4].first->value();
               v[5] = b[5].first->value();
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rbx)
movq 0x10(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rbx)
movq 0x20(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rbx)
movq 0x30(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rbx)
movq 0x40(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x20(%rbx)
movq 0x50(%r14), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::type_checker::allow_zero_parameters() const
bool allow_zero_parameters() const
         {

            for (std::size_t i = 0; i < function_definition_list_.size(); ++i)
            {
               if (std::string::npos != function_definition_list_[i].param_seq.find("Z"))
               {
                  return true;
               }
            }

            return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x8
popq %r13
pushq $-0x1
popq %r12
pushq $0x28
popq %rbp
leaq 0x2dfc6(%rip), %r14     # 0x2e3950
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rax
subq %rdi, %rax
cqto
idivq %rbp
movq %rax, %r15
incq %r12
cmpq %rax, %r12
jae 0x2b59bc
addq %r13, %rdi
addq $0x28, %r13
movq %r14, %rsi
xorl %edx, %edx
callq 0x118030
cmpq $-0x1, %rax
je 0x2b598a
cmpq %r15, %r12
setb %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::type_checker::split_param_seq(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, char) const
std::vector<std::string> split_param_seq(const std::string& param_seq, const details::char_t delimiter = '|') const
         {
             std::string::const_iterator current_begin = param_seq.begin();
             std::string::const_iterator iter          = param_seq.begin();

             std::vector<std::string> result;

             while (iter != param_seq.end())
             {
                 if (*iter == delimiter)
                 {
                     result.push_back(std::string(current_begin, iter));
                     current_begin = ++iter;
                 }
                 else
                     ++iter;
             }

             if (current_begin != iter)
             {
                 result.push_back(std::string(current_begin, iter));
             }

             return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movq %rdx, %r14
movq %rdi, %rbx
movq (%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %rax, %rsi
movq %rax, %r15
addq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpq %rax, %r15
je 0x2b68a6
cmpb %bpl, (%r15)
je 0x2b6878
incq %r15
decq %rcx
jmp 0x2b6866
movq %r13, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rdx
callq 0x2b6af8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2b6a02
movq %r12, %rdi
callq 0x118648
incq %r15
movq (%r14), %rax
movq %r15, %rsi
jmp 0x2b6860
testq %rcx, %rcx
je 0x2b68d2
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r15, %rdx
callq 0x2b6af8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2b6a02
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2b68e8
jmp 0x2b68f7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x2b68fa
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f5c78
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::type_checker::is_valid_token(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::type_checker::function_prototype_t&) const
inline bool is_valid_token(std::string param_seq,
                                    function_prototype_t& funcproto) const
         {
            // Determine return type
            funcproto.return_type = default_return_type_;

            if (param_seq.size() > 2)
            {
               if (':' == param_seq[1])
               {
                  // Note: Only overloaded igeneric functions can have return
                  // type definitions.
                  if (type_checker::e_overload != default_return_type_)
                     return false;

                  switch (param_seq[0])
                  {
                     case 'T' : funcproto.return_type = type_checker::e_numeric;
                                break;

                     case 'S' : funcproto.return_type = type_checker::e_string;
                                break;

                     default  : return false;
                  }

                  param_seq.erase(0,2);
               }
            }

            if (
                 (std::string::npos != param_seq.find("?*")) ||
                 (std::string::npos != param_seq.find("**"))
               )
            {
               return false;
            }
            else if (
                      (std::string::npos == param_seq.find_first_not_of("STV*?|")) ||
                      ("Z" == param_seq)
                    )
            {
               funcproto.param_seq = param_seq;
               return true;
            }

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movl 0x30(%rdi), %eax
movl %eax, (%rdx)
cmpq $0x3, 0x8(%rsi)
jb 0x2b6957
movq (%rbx), %rcx
cmpb $0x3a, 0x1(%rcx)
jne 0x2b6957
cmpl $0x20, %eax
jne 0x2b69c9
movzbl (%rcx), %eax
cmpl $0x54, %eax
je 0x2b6947
cmpl $0x53, %eax
jne 0x2b69c9
pushq $0x53
popq %rax
movl %eax, (%r14)
pushq $0x2
popq %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x118390
leaq 0x310c4(%rip), %rsi     # 0x2e7a22
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x118030
cmpq $-0x1, %rax
jne 0x2b69cc
leaq 0x31082(%rip), %rsi     # 0x2e79fa
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %edx, %edx
callq 0x118030
cmpq $-0x1, %rax
jne 0x2b69cc
leaq 0x2705f(%rip), %rsi     # 0x2dd9f1
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1184b0
cmpq $-0x1, %rax
je 0x2b69b5
leaq 0x2cfa7(%rip), %rdi     # 0x2e3950
movq %rbx, %rsi
callq 0x2b6b71
testb %al, %al
je 0x2b69c9
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1185c0
movb $0x1, %r15b
jmp 0x2b69cc
xorl %r15d, %r15d
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multimode_genfunction_node<double, exprtk::igeneric_function<double>>::value() const
inline T value() const exprtk_override
         {
            assert(gen_function_t::valid());

            if (gen_function_t::populate_value_list())
            {
               typedef typename GenericFunction::parameter_list_t parameter_list_t;

               return
                  (*gen_function_t::function_)
                  (
                     param_seq_index_,
                     parameter_list_t(gen_function_t::typestore_list_)
                  );
            }

            return std::numeric_limits<T>::quiet_NaN();
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x2b778e
testb %al, %al
je 0x2b7a2b
movq 0x20(%rbx), %rdi
leaq 0xd0(%rbx), %rsi
addq $0x28, %rbx
movq (%rdi), %rax
movq 0x20(%rax), %rax
movq %rbx, %rdx
popq %rbx
jmpq *%rax
movsd 0x1688d(%rip), %xmm0    # 0x2ce2c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_function_node<double, exprtk::igeneric_function<double>>::string_function_node(exprtk::igeneric_function<double>*, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
string_function_node(StringFunction* func,
                              const std::vector<typename gen_function_t::expression_ptr>& arg_list)
         : gen_function_t(arg_list,func)
         {
            range_.n0_c = std::make_pair<bool,std::size_t>(true,0);
            range_.n1_c = std::make_pair<bool,std::size_t>(true,0);
            range_.cache.first  = range_.n0_c.second;
            range_.cache.second = range_.n1_c.second;
            assert(valid());
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x2b7278
leaq 0x1fbad2(%rip), %rax    # 0x4b3c10
movq %rax, (%rbx)
leaq 0x1fbb50(%rip), %rax    # 0x4b3c98
movq %rax, 0x8(%rbx)
leaq 0x1fbb6d(%rip), %rax    # 0x4b3cc0
movq %rax, 0xd0(%rbx)
leaq 0x1fbb97(%rip), %rax    # 0x4b3cf8
movq %rax, 0xd8(%rbx)
leaq 0xe0(%rbx), %rdi
callq 0x252a68
leaq 0x140(%rbx), %rax
movq %rax, 0x130(%rbx)
andq $0x0, 0x138(%rbx)
movb $0x0, 0x140(%rbx)
movb $0x1, %al
movb %al, 0x100(%rbx)
andq $0x0, 0x108(%rbx)
movb %al, 0x110(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
andq $0x0, 0x128(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x2b7920
movq %r14, %rdi
callq 0x118360