LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::return_node<double>::value() const
inline T value() const exprtk_override
         {
            if (gen_function_t::populate_value_list())
            {
               typedef typename type_store<T>::parameter_list parameter_list_t;

               results_context_->
                  assign(parameter_list_t(gen_function_t::typestore_list_));

               throw return_exception();
            }

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

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x33b1e2
testb %al, %al
jne 0x33b18d
movsd 0x4e081(%rip), %xmm0    # 0x389208
addq $0x10, %rsp
popq %rbx
retq
movq 0xd0(%rbx), %rdi
addq $0x28, %rbx
leaq 0x8(%rsp), %rsi
movq %rbx, (%rsi)
callq 0x33b4f0
movl $0x1, %edi
callq 0x11e1f0
leaq 0x1fea62(%rip), %rsi    # 0x539c18
movq %rax, %rdi
xorl %edx, %edx
callq 0x11e310
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::remove_ref(double**)
void remove_ref(data_ptr_t* data_ref)
      {
         data_ref_.erase(
            std::remove(data_ref_.begin(), data_ref_.end(), data_ref),
            data_ref_.end());
         exprtk_debug(("vector_view::remove_ref() - data_ref: %p data_ref_.size(): %d\n",
                       reinterpret_cast<void*>(data_ref),
                       static_cast<int>(data_ref_.size())));
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq %rsi, (%rdx)
movq 0x18(%rdi), %rdi
movq 0x20(%rbx), %rsi
callq 0x33b3fd
cmpq 0x20(%rbx), %rax
je 0x33b3f7
movq %rax, 0x20(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::set_ref(double**)
void set_ref(data_ptr_t* data_ref)
      {
         data_ref_.push_back(data_ref);
         exprtk_debug(("vector_view::set_ref() - data_ref: %p data_ref_.size(): %d\n",
                       reinterpret_cast<void*>(data_ref),
                       static_cast<int>(data_ref_.size())));
      }

// Assembly:
pushq %rax
movq %rsi, %rax
movq %rsi, (%rsp)
movq 0x20(%rdi), %rsi
cmpq 0x28(%rdi), %rsi
je 0x33b780
movq %rax, (%rsi)
addq $0x8, 0x20(%rdi)
jmp 0x33b78c
addq $0x18, %rdi
movq %rsp, %rdx
callq 0x33c8bc
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x28, %rsp
movq %rcx, %r8
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq 0x8(%rdi), %rdi
movl $0x8f0, %ecx            # imm = 0x8F0
addq 0x68(%r12), %rcx
callq 0x33cc02
movq %rax, (%rsp)
testq %rax, %rax
je 0x33cabb
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x30(%rax)
testb %al, %al
je 0x33ca97
movq 0x68(%r12), %r14
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x5afdc(%rip), %rsi     # 0x397a30
leaq 0x5afe2(%rip), %rdx     # 0x397a3d
leaq 0x8(%rsp), %rdi
callq 0x1e4740
cmpb $0x0, 0x3ac(%r14)
jne 0x33ca77
movb $0x1, 0x3ac(%r14)
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0x33cb1a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x33cb1a
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x33cabb
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x33cabb
movq %rsp, %rdi
callq 0x1ea63e
movq (%r14), %rdi
testq %rdi, %rdi
je 0x33cae9
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x33cae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x33cae1
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x33cae9
movq %r14, %rdi
callq 0x1ea63e
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x33cb17
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x33cb17
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x33cb0f
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x33cb17
movq %rbx, %rdi
callq 0x1ea63e
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assert_node<double>::value_type>* exprtk::details::node_allocator::allocate_rrrr<exprtk::details::assert_node<double>, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::assert_check*, exprtk::assert_check::assert_context const>(exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&, exprtk::assert_check*&, exprtk::assert_check::assert_context const&) const
inline expression_node<typename node_type::value_type>* allocate_rrrr(T1& t1, T2& t2, T3& t3, T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %r8, %r14
movq %rcx, %r13
movq %rdx, %r12
movq %rsi, %r15
movl $0xb8, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r15), %r15
movq (%r12), %r12
movq (%r13), %r13
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1e7738
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
movq %rax, -0x10(%rax)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x1e7738
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x40(%r14), %rsi
movq 0x48(%r14), %rdx
addq %rsi, %rdx
callq 0x1e7738
movq 0x60(%r14), %rax
movq %rsp, %r8
movq %rax, 0x60(%r8)
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x33cd7c
movq 0x40(%rsp), %rdi
cmpq %rbp, %rdi
je 0x33ccbe
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
leaq 0x10(%rsp), %r14
je 0x33ccdf
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x33ccf5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x33cb2a
jmp 0x33cd66
movq %rax, %r14
movq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0x33cd46
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x33cd46
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x33cd66
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x33cd66
movq %rax, %r14
movl $0xb8, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x33d088
jnp 0x33d092
movsd 0x4bf90(%rip), %xmm0    # 0x389020
jmp 0x33d0ee
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x33d0d9
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 0x11e2b0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x33d0d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
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_O3/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 %r14
pushq %rbx
pushq %rax
cmpq $0x0, 0x48(%rdi)
je 0x33d164
movq %rdi, %r14
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x33d164
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x33d164
movq 0x30(%r14), %rdi
movb $0x1, %bl
testq %rdi, %rdi
je 0x33d166
cmpq $0x0, 0x40(%r14)
je 0x33d164
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x33d164
movq 0x30(%r14), %rdi
testq %rdi, %rdi
je 0x33d164
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x21, %eax
ja 0x33d15f
movl %eax, %ecx
movabsq $0x388fc0000, %rdx      # imm = 0x388FC0000
btq %rcx, %rdx
jb 0x33d166
cmpl $0x7b, %eax
je 0x33d166
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq 0x8(%rdi), %r15
movb $0x1, %al
xorl %r13d, %r13d
movb %al, 0x7(%rsp)
movq %r13, %rax
shlq $0x5, %rax
leaq 0x1fea7b(%rip), %rcx    # 0x5412a0
cmpq 0x8(%rax,%rcx), %r15
jne 0x342864
testq %r15, %r15
je 0x34287a
leaq 0x1fea68(%rip), %rcx    # 0x5412a0
addq %rcx, %rax
movq (%rax), %r12
xorl %ebx, %ebx
movsbl (%r14,%rbx), %edi
callq 0x11e450
movl %eax, %ebp
movsbl (%r12,%rbx), %edi
callq 0x11e450
cmpl %eax, %ebp
jne 0x342864
incq %rbx
cmpq %rbx, %r15
jne 0x342840
jmp 0x34287a
cmpq $0x39, %r13
leaq 0x1(%r13), %rcx
setb %al
movq %rcx, %r13
cmpq $0x3a, %rcx
jne 0x342813
jmp 0x34287e
movb 0x7(%rsp), %al
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::function_N_node<double, exprtk::ifunction<double>, 1ul>::init_branches<1ul>(exprtk::details::expression_node<double>* (&) [1ul])
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 %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x35aeb9
movq %rsi, %r14
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x35aeb9
movq (%r14), %r15
testq %r15, %r15
je 0x35aeb5
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x35aebd
xorl %eax, %eax
jmp 0x35aecc
xorl %eax, %eax
jmp 0x35aee2
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq (%r14), %rcx
movq %rcx, 0x30(%rbx)
movb %al, 0x38(%rbx)
cmpq $0x0, 0x20(%rbx)
setne %al
setne 0x40(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
cmpq %rdi, 0x40(%rbx)
je 0x367864
movl $0x8, %r15d
xorl %r12d, %r12d
leaq 0x36a28(%rip), %r14     # 0x39e246
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
addq %r15, %rdi
movl $0x1, %ecx
movq %r14, %rsi
xorl %edx, %edx
callq 0x11e1c0
cmpq $-0x1, %rax
setne %al
jne 0x367866
incq %r12
movq 0x38(%rbx), %rdi
movq 0x40(%rbx), %rcx
subq %rdi, %rcx
sarq $0x3, %rcx
imulq %r13, %rcx
addq $0x28, %r15
cmpq %rcx, %r12
jb 0x367828
jmp 0x367866
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::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 %rdi, %rbx
movq (%rdx), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0x36a32d
movq %rdx, %r14
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r12
movq %rax, %rsi
movq %rax, %r15
cmpb %bpl, (%r15)
jne 0x36a2e8
movq %r13, 0x8(%rsp)
movq %r12, %rdi
movq %r15, %rdx
callq 0x36a6a2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x36a492
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x36a2d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
incq %r15
movq (%r14), %rax
movq 0x8(%r14), %rcx
movq %r15, %rsi
jmp 0x36a2eb
incq %r15
leaq (%rax,%rcx), %rdx
cmpq %rdx, %r15
jne 0x36a2a2
cmpq %r15, %rsi
je 0x36a32d
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
movq %r15, %rdx
callq 0x36a6a2
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36a492
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x36a32d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36a348
jmp 0x36a343
movq %rax, %r14
jmp 0x36a362
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x36a362
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x24916a
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36a3c3
movq (%rbx), %rcx
cmpb $0x3a, 0x1(%rcx)
jne 0x36a3c3
cmpl $0x20, %eax
jne 0x36a430
movzbl (%rcx), %eax
cmpl $0x54, %eax
je 0x36a3b1
cmpl $0x53, %eax
jne 0x36a430
movl $0x53, %eax
movl %eax, (%r14)
movl $0x2, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11e380
leaq 0x37f4e(%rip), %rsi     # 0x3a2318
xorl %r15d, %r15d
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11e1c0
cmpq $-0x1, %rax
jne 0x36a447
leaq 0x37f07(%rip), %rsi     # 0x3a22f0
xorl %r15d, %r15d
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11e1c0
cmpq $-0x1, %rax
jne 0x36a447
leaq 0x2dedf(%rip), %rsi     # 0x3982e7
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x11e3e0
cmpq $-0x1, %rax
je 0x36a435
leaq 0x33e22(%rip), %rsi     # 0x39e246
movq %rbx, %rdi
callq 0x11e4b0
testl %eax, %eax
je 0x36a435
xorl %r15d, %r15d
jmp 0x36a447
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11e5a0
movb $0x1, %r15b
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x36b2ba
testb %al, %al
je 0x36b59d
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 0x1dc63(%rip), %xmm0    # 0x389208
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rsi, %rax
movq %rdi, %rbx
movq %rdx, %rsi
movq %rax, %rdx
callq 0x36acd2
leaq 0x1ce53d(%rip), %rax    # 0x53ac30
movq %rax, (%rbx)
leaq 0x1ce5bb(%rip), %rax    # 0x53acb8
movq %rax, 0x8(%rbx)
leaq 0x1ce5d8(%rip), %rax    # 0x53ace0
movq %rax, 0xd0(%rbx)
leaq 0x1ce602(%rip), %rax    # 0x53ad18
movq %rax, 0xd8(%rbx)
xorl %eax, %eax
movb %al, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
movb %al, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
leaq 0x140(%rbx), %rcx
movq %rcx, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movb %al, 0x140(%rbx)
movb $0x1, %cl
movb %cl, 0x100(%rbx)
movq %rax, 0x108(%rbx)
movb %cl, 0x110(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
movq %rax, 0x128(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_size_node<double>::string_size_node(exprtk::details::expression_node<double>*)
explicit string_size_node(expression_ptr branch)
         : str_base_ptr_(0)
         {
            construct_branch_pair(branch_, branch);

            if (is_generally_string_node(branch_.first))
            {
               str_base_ptr_ = dynamic_cast<str_base_ptr>(branch_.first);
            }

            assert(valid());
         }

// Assembly:
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x1cd339(%rip), %rcx    # 0x53b008
movq %rcx, (%rdi)
leaq 0x1cd37f(%rip), %rcx    # 0x53b058
movq %rcx, 0x8(%rdi)
movb %al, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
testq %rsi, %rsi
je 0x36dd75
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x36dd0d
xorl %eax, %eax
jmp 0x36dd1c
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r14, 0x20(%rbx)
movb %al, 0x28(%rbx)
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x21, %eax
ja 0x36dd76
movl %eax, %ecx
movabsq $0x388fc0000, %rdx      # imm = 0x388FC0000
btq %rcx, %rdx
jae 0x36dd76
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x36dd68
leaq 0x16839d(%rip), %rsi    # 0x4d60f0
leaq 0x199d4e(%rip), %rdx    # 0x507aa8
movq $-0x2, %rcx
callq 0x11e4f0
jmp 0x36dd6a
xorl %eax, %eax
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x7b, %eax
je 0x36dd43
jmp 0x36dd6e
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::generic_string_range_node<double>::value() const
inline T value() const exprtk_override
         {
            branch_.first->value();

            std::size_t str_r0 = 0;
            std::size_t str_r1 = 0;

            std::size_t r0 = 0;
            std::size_t r1 = 0;

            const range_t& range = str_range_ptr_->range_ref();

            const std::size_t base_str_size = str_base_ptr_->size();

            if (
                  range      (str_r0, str_r1, base_str_size         ) &&
                  base_range_(r0    , r1    , base_str_size - str_r0)
               )
            {
               const std::size_t size = r1 - r0;

               range_.n1_c.second  = size;
               range_.cache.second = range_.n1_c.second;

               value_.assign(str_base_ptr_->base() + str_r0 + r0, size);
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
leaq 0x18(%rsp), %r14
movq %rax, (%r14)
leaq 0x30(%rsp), %r15
movq %rax, (%r15)
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r12
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2a4b56
testb %al, %al
je 0x36e184
leaq 0x58(%rbx), %rdi
movq 0x20(%rsp), %rax
subq 0x18(%rsp), %rax
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x2a4b56
testb %al, %al
je 0x36e184
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
movq %r14, 0xe0(%rbx)
movq %r14, 0xf0(%rbx)
leaq 0xf8(%rbx), %r15
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x18(%rsp), %rax
addq 0x8(%rsp), %rax
movq 0x100(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r8
callq 0x11e290
movsd 0x1b07c(%rip), %xmm0    # 0x389208
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::logic_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string logic_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               case details::e_and  : return "and" ;
               case details::e_or   : return "or"  ;
               case details::e_xor  : return "xor" ;
               case details::e_nand : return "nand";
               case details::e_nor  : return "nor" ;
               case details::e_xnor : return "xnor";
               case details::e_notl : return "not" ;
               default              : return ""    ;
            }
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
leal -0x16(%rdx), %eax
cmpl $0x5, %eax
ja 0x36e3e9
leaq 0x1f6b8(%rip), %rcx     # 0x38da88
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x29ef7(%rip), %rsi     # 0x3982d7
leaq 0x29ef3(%rip), %rdx     # 0x3982da
jmp 0x36e45b
cmpl $0x4b, %edx
jne 0x36e41e
leaq 0x1f79c(%rip), %rsi     # 0x38db91
leaq 0x1f798(%rip), %rdx     # 0x38db94
jmp 0x36e45b
leaq 0x1f7b4(%rip), %rsi     # 0x38dbb9
leaq 0x1f7b0(%rip), %rdx     # 0x38dbbc
jmp 0x36e45b
leaq 0x1f766(%rip), %rsi     # 0x38db7b
leaq 0x1f761(%rip), %rdx     # 0x38db7d
jmp 0x36e45b
leaq 0x34dda(%rip), %rdx     # 0x3a31ff
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x36e45e
leaq 0x1f781(%rip), %rsi     # 0x38dbb5
leaq 0x1f77d(%rip), %rdx     # 0x38dbb8
jmp 0x36e45b
leaq 0x1f748(%rip), %rsi     # 0x38db8c
leaq 0x1f745(%rip), %rdx     # 0x38db90
jmp 0x36e45b
leaq 0x1f760(%rip), %rsi     # 0x38dbb4
leaq 0x1f75d(%rip), %rdx     # 0x38dbb8
movq %rbx, %rdi
callq 0x1e4740
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::arith_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string arith_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               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 "^";
               default             : return "" ;
            }
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
addl $-0x2, %edx
cmpl $0x5, %edx
ja 0x36e58c
leaq 0x1f588(%rip), %rax     # 0x38daa0
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x348f5(%rip), %rsi     # 0x3a2e1d
leaq 0x348ef(%rip), %rdx     # 0x3a2e1e
jmp 0x36e57f
leaq 0x1f77d(%rip), %rsi     # 0x38dcb5
leaq 0x1f777(%rip), %rdx     # 0x38dcb6
jmp 0x36e57f
leaq 0x33da9(%rip), %rsi     # 0x3a22f1
leaq 0x33da3(%rip), %rdx     # 0x3a22f2
jmp 0x36e57f
leaq 0x3ffe0(%rip), %rsi     # 0x3ae538
leaq 0x3ffda(%rip), %rdx     # 0x3ae539
jmp 0x36e57f
leaq 0x1f74b(%rip), %rsi     # 0x38dcb3
leaq 0x1f745(%rip), %rdx     # 0x38dcb4
jmp 0x36e57f
leaq 0x1f73f(%rip), %rsi     # 0x38dcb7
leaq 0x1f739(%rip), %rdx     # 0x38dcb8
movq %rbx, %rdi
callq 0x1e4740
movq %rbx, %rax
popq %rbx
retq
leaq 0x34c6c(%rip), %rdx     # 0x3a31ff
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x36e582
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::inequality_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string inequality_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               case details::e_lt    : return "<" ;
               case details::e_lte   : return "<=";
               case details::e_eq    : return "==";
               case details::e_equal : return "=" ;
               case details::e_ne    : return "!=";
               case details::e_nequal: return "<>";
               case details::e_gte   : return ">=";
               case details::e_gt    : return ">" ;
               default               : return ""  ;
            }
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
addl $-0xe, %edx
cmpl $0x7, %edx
ja 0x36e6e4
leaq 0x1f468(%rip), %rax     # 0x38dab8
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x26608(%rip), %rsi     # 0x394c68
leaq 0x26602(%rip), %rdx     # 0x394c69
jmp 0x36e6d7
leaq 0x1f65e(%rip), %rsi     # 0x38dcce
leaq 0x1f659(%rip), %rdx     # 0x38dcd0
jmp 0x36e6d7
leaq 0x347a8(%rip), %rsi     # 0x3a2e28
leaq 0x347a3(%rip), %rdx     # 0x3a2e2a
jmp 0x36e6d7
leaq 0x1f63f(%rip), %rsi     # 0x38dccf
leaq 0x1f639(%rip), %rdx     # 0x38dcd0
jmp 0x36e6d7
leaq 0x1f632(%rip), %rsi     # 0x38dcd2
leaq 0x1f62c(%rip), %rdx     # 0x38dcd3
jmp 0x36e6d7
leaq 0x1f61b(%rip), %rsi     # 0x38dccb
leaq 0x1f616(%rip), %rdx     # 0x38dccd
jmp 0x36e6d7
leaq 0x1f611(%rip), %rsi     # 0x38dcd1
leaq 0x1f60c(%rip), %rdx     # 0x38dcd3
jmp 0x36e6d7
leaq 0x1f604(%rip), %rsi     # 0x38dcd4
leaq 0x1f5ff(%rip), %rdx     # 0x38dcd6
movq %rbx, %rdi
callq 0x1e4740
movq %rbx, %rax
popq %rbx
retq
leaq 0x34b14(%rip), %rdx     # 0x3a31ff
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x36e6da
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::return_envelope_node<double>::value() const
inline T value() const exprtk_override
         {
            try
            {
               return_invoked_ = false;
               results_context_->clear();

               return body_.first->value();
            }
            catch(const return_exception&)
            {
               return_invoked_ = true;

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0x28(%rdi)
movq 0x20(%rdi), %rcx
movb %al, (%rcx)
movq 0x30(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
popq %rbx
retq
movq %rax, %rdi
callq 0x11e070
movb $0x1, 0x28(%rbx)
callq 0x11e3d0
movsd 0x1a2b0(%rip), %xmm0    # 0x389208
jmp 0x36ef3d
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::symbol_table<double>::get_variable_list<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>>>&) const
inline std::size_t get_variable_list(Sequence<std::pair<std::string,T>,Allocator>& vlist) const
      {
         if (!valid())
            return 0;
         else
            return local_data().variable_store.get_list(vlist);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq (%rdi), %rax
testq %rax, %rax
je 0x372dea
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x372dea
cmpq $0x0, 0x28(%r13)
je 0x372dea
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r15, %r13
je 0x372dea
leaq 0x20(%rsp), %rbp
xorl %r14d, %r14d
leaq 0x10(%rsp), %r12
movq 0x48(%r15), %rax
movq 0x28(%rax), %rbx
movq %rbp, 0x10(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x1e7738
movsd (%rbx), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x3738a0
movq 0x10(%rsp), %rdi
movq %rbp, %rbx
cmpq %rbp, %rdi
je 0x372dd2
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %r15, %rdi
callq 0x11e4c0
movq %rax, %r15
incq %r14
cmpq %rax, %r13
movq %rbx, %rbp
jne 0x372d81
jmp 0x372ded
xorl %r14d, %r14d
movq %r14, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x372e19
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::parser<double>::dependent_entity_collector::symbols<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>>&)
inline std::size_t symbols(Sequence<symbol_t,Allocator>& symbols_list)
         {
            if (!collect_variables_ && !collect_functions_)
               return 0;
            else if (symbol_name_list_.empty())
               return 0;

            for (std::size_t i = 0; i < symbol_name_list_.size(); ++i)
            {
               details::case_normalise(symbol_name_list_[i].first);
            }

            std::sort(symbol_name_list_.begin(), symbol_name_list_.end());

            std::unique_copy
            (
               symbol_name_list_.begin(),
               symbol_name_list_.end  (),
               std::back_inserter(symbols_list)
            );

            return symbols_list.size();
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
cmpb $0x0, 0x8(%rdi)
jne 0x373009
cmpb $0x1, 0x9(%r14)
jne 0x373107
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
cmpq %r12, %r15
je 0x373107
movq %rsi, (%rsp)
xorl %ebp, %ebp
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
leaq (,%rbp,4), %rax
addq %rbp, %rax
cmpq $0x0, 0x8(%r15,%rax,8)
je 0x373066
leaq (%r15,%rax,8), %r15
xorl %r12d, %r12d
movq (%r15), %rbx
movsbl (%rbx,%r12), %edi
callq 0x11e450
movb %al, (%rbx,%r12)
incq %r12
cmpq 0x8(%r15), %r12
jb 0x373044
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
incq %rbp
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %rbp
jb 0x37302a
cmpq %r12, %r15
je 0x3730ac
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x374a13
movq %r15, %rdi
movq %r12, %rsi
callq 0x374af0
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
movq (%rsp), %rbx
cmpq %r12, %r15
je 0x3730c3
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x375454
movq 0x48(%rbx), %rax
movq %rax, %rcx
subq 0x28(%rbx), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rdx
subq 0x38(%rbx), %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
subq 0x10(%rbx), %rax
leaq (%rdx,%rcx,4), %rcx
sarq $0x3, %rax
imulq %r13, %rax
addq %rcx, %rax
jmp 0x373109
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::parser<double>::dependent_entity_collector::assignment_symbols<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>>&)
inline std::size_t assignment_symbols(Sequence<symbol_t,Allocator>& assignment_list)
         {
            if (!collect_assignments_)
               return 0;
            else if (assignment_name_list_.empty())
               return 0;

            for (std::size_t i = 0; i < assignment_name_list_.size(); ++i)
            {
               details::case_normalise(assignment_name_list_[i].first);
            }

            std::sort(assignment_name_list_.begin(),assignment_name_list_.end());

            std::unique_copy
            (
               assignment_name_list_.begin(),
               assignment_name_list_.end  (),
               std::back_inserter(assignment_list)
            );

            return assignment_list.size();
         }

// Assembly:
cmpb $0x1, 0xa(%rdi)
jne 0x373338
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %r15
movq 0x30(%rdi), %r12
cmpq %r12, %r15
je 0x37333b
movq %rsi, (%rsp)
xorl %ebp, %ebp
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
leaq (,%rbp,4), %rax
addq %rbp, %rax
cmpq $0x0, 0x8(%r15,%rax,8)
je 0x373297
leaq (%r15,%rax,8), %r15
xorl %r12d, %r12d
movq (%r15), %rbx
movsbl (%rbx,%r12), %edi
callq 0x11e450
movb %al, (%rbx,%r12)
incq %r12
cmpq 0x8(%r15), %r12
jb 0x373275
movq 0x28(%r14), %r15
movq 0x30(%r14), %r12
incq %rbp
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %rbp
jb 0x37325b
cmpq %r12, %r15
je 0x3732dd
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x374a13
movq %r15, %rdi
movq %r12, %rsi
callq 0x374af0
movq 0x28(%r14), %r15
movq 0x30(%r14), %r12
movq (%rsp), %rbx
cmpq %r12, %r15
je 0x3732f4
movq %r15, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x375454
movq 0x48(%rbx), %rax
movq %rax, %rcx
subq 0x28(%rbx), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,2), %rcx
movq 0x20(%rbx), %rax
movq 0x30(%rbx), %rdx
subq 0x38(%rbx), %rdx
sarq $0x3, %rdx
imulq %r13, %rdx
subq 0x10(%rbx), %rax
leaq (%rdx,%rcx,4), %rcx
sarq $0x3, %rax
imulq %r13, %rax
addq %rcx, %rax
jmp 0x37333d
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::operator=(exprtk::symbol_table<double> const&)
inline symbol_table<T>& operator=(const symbol_table<T>& st)
      {
         if (this != &st)
         {
            control_block::destroy(control_block_,reinterpret_cast<symbol_table<T>*>(0));

            control_block_ = st.control_block_;
            control_block_->ref_count++;
         }

         return (*this);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x373399
movq %rsi, %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x373390
movq (%r15), %rax
testq %rax, %rax
je 0x373389
decq %rax
movq %rax, (%r15)
jne 0x373389
movq %r15, %rdi
callq 0x36f204
movl $0x18, %esi
movq %r15, %rdi
callq 0x11e0c0
movq $0x0, (%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
incq (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::collect_variables<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool collect_variables(const std::string& expression,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef double T;
      typedef details::collector_helper<T> collect_t;

      collect_t::symbol_table_t null_symbol_table;

      std::set<std::string> symbol_set;

      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, true, false, false, null_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, true, false,  true, null_symbol_table);

      if (!variable_pass && !vector_pass)
         return false;

      std::set<std::string>::iterator itr = symbol_set.begin();

      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }

      return true;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x1, %esi
callq 0x1e5424
leaq 0x18(%rsp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x375d5c
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r9
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x375d5c
orb %al, %bpl
movq 0x28(%rsp), %r14
cmpq %r14, %r12
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x373455
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x33a20a
movq %r14, %rdi
callq 0x11e4c0
movq %rax, %r14
cmpq %rax, %r12
jne 0x373439
leaq 0x10(%rsp), %rdi
callq 0x1e77ce
leaq 0x8(%rsp), %rdi
callq 0x1e7056
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x37347c
jmp 0x37347c
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1e77ce
leaq 0x8(%rsp), %rdi
callq 0x1e7056
movq %rbx, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: unsigned long load_expressions<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::deque>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline std::size_t load_expressions(const std::string& file_name,
                                    Sequence<std::string,Allocator>& sequence)
{
   std::ifstream stream(file_name.c_str());

   if (!stream) return 0;

   std::string buffer;
   buffer.reserve(1024);

   std::size_t line_count = 0;

   while (std::getline(stream,(buffer)))
   {
      if (buffer.empty())
         continue;
      else if ('#' == buffer[0])
         continue;

      ++line_count;
      sequence.push_back(buffer);
   }

   return line_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
movl $0x8, %edx
callq 0x11e050
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
je 0x3773fd
xorl %r14d, %r14d
jmp 0x377495
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
leaq 0x8(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x11e400
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x11e540
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x11e030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x37747e
cmpq $0x0, 0x10(%rsp)
je 0x37742a
movq 0x8(%rsp), %rax
cmpb $0x23, (%rax)
je 0x37742a
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x373e76
jmp 0x37742a
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x377495
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
leaq 0x28(%rsp), %rdi
callq 0x11e040
movq %r14, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3774b7
jmp 0x3774b7
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3774d1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
leaq 0x28(%rsp), %rdi
callq 0x11e040
movq %rbx, %rdi
callq 0x11e330
nop