LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x391e65
movq (%rbx), %rcx
cmpb $0x3a, 0x1(%rcx)
jne 0x391e65
cmpl $0x20, %eax
jne 0x391ed2
movzbl (%rcx), %eax
cmpl $0x54, %eax
je 0x391e53
cmpl $0x53, %eax
jne 0x391ed2
movl $0x53, %eax
movl %eax, (%r14)
movl $0x2, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x120380
leaq 0x39482(%rip), %rsi     # 0x3cb2ee
xorl %r15d, %r15d
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1201c0
cmpq $-0x1, %rax
jne 0x391ee9
leaq 0x3943b(%rip), %rsi     # 0x3cb2c6
xorl %r15d, %r15d
movl $0x2, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1201c0
cmpq $-0x1, %rax
jne 0x391ee9
leaq 0x2f413(%rip), %rsi     # 0x3c12bd
movl $0x6, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x1203e0
cmpq $-0x1, %rax
je 0x391ed7
leaq 0x35356(%rip), %rsi     # 0x3c721c
movq %rbx, %rdi
callq 0x1204b0
testl %eax, %eax
je 0x391ed7
xorl %r15d, %r15d
jmp 0x391ee9
addq $0x8, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1205a0
movb $0x1, %r15b
movl %r15d, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x392dce
testb %al, %al
je 0x3930dd
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 0x1f12b(%rip), %xmm0    # 0x3b2210
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3927be
leaq 0x1e08eb(%rip), %rax    # 0x574c30
movq %rax, (%rbx)
leaq 0x1e0969(%rip), %rax    # 0x574cb8
movq %rax, 0x8(%rbx)
leaq 0x1e0986(%rip), %rax    # 0x574ce0
movq %rax, 0xd0(%rbx)
leaq 0x1e09b0(%rip), %rax    # 0x574d18
movq %rax, 0xd8(%rbx)
xorl %eax, %eax
movb %al, 0xe0(%rbx)
movq %rax, 0xe8(%rbx)
movb %al, 0xf0(%rbx)
movq %rax, 0xf8(%rbx)
movq %rax, 0x108(%rbx)
movq %rax, 0x128(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x118(%rbx)
leaq 0x140(%rbx), %rcx
movq %rcx, 0x130(%rbx)
movq %rax, 0x138(%rbx)
movb %al, 0x140(%rbx)
movb $0x1, %al
movb %al, 0x100(%rbx)
movb %al, 0x110(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x1df7e6(%rip), %rcx    # 0x575008
movq %rcx, (%rdi)
leaq 0x1df82c(%rip), %rcx    # 0x575058
movq %rcx, 0x8(%rdi)
movb %al, 0x28(%rdi)
movq $0x0, 0x30(%rdi)
testq %rsi, %rsi
je 0x39586b
movq %rsi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x395855
xorl %eax, %eax
jmp 0x395864
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r14, 0x20(%rbx)
movb %al, 0x28(%rbx)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3958bc
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x21, %eax
ja 0x3958c4
movl %eax, %ecx
movabsq $0x388fc0000, %rdx      # imm = 0x388FC0000
btq %rcx, %rdx
jae 0x3958c4
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x3958b6
leaq 0x179b8f(%rip), %rsi    # 0x50f430
leaq 0x1abdc0(%rip), %rdx    # 0x541668
movq $-0x2, %rcx
callq 0x1204f0
jmp 0x3958b8
xorl %eax, %eax
movq %rax, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
cmpl $0x7b, %eax
je 0x395891
jmp 0x3958bc
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c1cf4
testb %al, %al
je 0x395cd8
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 0x2c1cf4
testb %al, %al
je 0x395cd8
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 0x120290
movsd 0x1c530(%rip), %xmm0    # 0x3b2210
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::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 0x395f39
leaq 0x20b10(%rip), %rcx     # 0x3b6a30
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2b37d(%rip), %rsi     # 0x3c12ad
leaq 0x2b379(%rip), %rdx     # 0x3c12b0
jmp 0x395fab
cmpl $0x4b, %edx
jne 0x395f6e
leaq 0x20bf4(%rip), %rsi     # 0x3b6b39
leaq 0x20bf0(%rip), %rdx     # 0x3b6b3c
jmp 0x395fab
leaq 0x20c0c(%rip), %rsi     # 0x3b6b61
leaq 0x20c08(%rip), %rdx     # 0x3b6b64
jmp 0x395fab
leaq 0x20bbe(%rip), %rsi     # 0x3b6b23
leaq 0x20bb9(%rip), %rdx     # 0x3b6b25
jmp 0x395fab
leaq 0x36260(%rip), %rdx     # 0x3cc1d5
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x395fae
leaq 0x20bd9(%rip), %rsi     # 0x3b6b5d
leaq 0x20bd5(%rip), %rdx     # 0x3b6b60
jmp 0x395fab
leaq 0x20ba0(%rip), %rsi     # 0x3b6b34
leaq 0x20b9d(%rip), %rdx     # 0x3b6b38
jmp 0x395fab
leaq 0x20bb8(%rip), %rsi     # 0x3b6b5c
leaq 0x20bb5(%rip), %rdx     # 0x3b6b60
movq %rbx, %rdi
callq 0x1eabb8
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3960dc
leaq 0x209e0(%rip), %rax     # 0x3b6a48
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x35d7b(%rip), %rsi     # 0x3cbdf3
leaq 0x35d75(%rip), %rdx     # 0x3cbdf4
jmp 0x3960cf
leaq 0x20bd5(%rip), %rsi     # 0x3b6c5d
leaq 0x20bcf(%rip), %rdx     # 0x3b6c5e
jmp 0x3960cf
leaq 0x3522f(%rip), %rsi     # 0x3cb2c7
leaq 0x35229(%rip), %rdx     # 0x3cb2c8
jmp 0x3960cf
leaq 0x41466(%rip), %rsi     # 0x3d750e
leaq 0x41460(%rip), %rdx     # 0x3d750f
jmp 0x3960cf
leaq 0x20ba3(%rip), %rsi     # 0x3b6c5b
leaq 0x20b9d(%rip), %rdx     # 0x3b6c5c
jmp 0x3960cf
leaq 0x20b97(%rip), %rsi     # 0x3b6c5f
leaq 0x20b91(%rip), %rdx     # 0x3b6c60
movq %rbx, %rdi
callq 0x1eabb8
movq %rbx, %rax
popq %rbx
retq
leaq 0x360f2(%rip), %rdx     # 0x3cc1d5
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x3960d2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x396234
leaq 0x208c0(%rip), %rax     # 0x3b6a60
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x27a60(%rip), %rsi     # 0x3bdc10
leaq 0x27a5a(%rip), %rdx     # 0x3bdc11
jmp 0x396227
leaq 0x20ab6(%rip), %rsi     # 0x3b6c76
leaq 0x20ab1(%rip), %rdx     # 0x3b6c78
jmp 0x396227
leaq 0x35c2e(%rip), %rsi     # 0x3cbdfe
leaq 0x35c29(%rip), %rdx     # 0x3cbe00
jmp 0x396227
leaq 0x20a97(%rip), %rsi     # 0x3b6c77
leaq 0x20a91(%rip), %rdx     # 0x3b6c78
jmp 0x396227
leaq 0x20a8a(%rip), %rsi     # 0x3b6c7a
leaq 0x20a84(%rip), %rdx     # 0x3b6c7b
jmp 0x396227
leaq 0x20a73(%rip), %rsi     # 0x3b6c73
leaq 0x20a6e(%rip), %rdx     # 0x3b6c75
jmp 0x396227
leaq 0x20a69(%rip), %rsi     # 0x3b6c79
leaq 0x20a64(%rip), %rdx     # 0x3b6c7b
jmp 0x396227
leaq 0x20a5c(%rip), %rsi     # 0x3b6c7c
leaq 0x20a57(%rip), %rdx     # 0x3b6c7e
movq %rbx, %rdi
callq 0x1eabb8
movq %rbx, %rax
popq %rbx
retq
leaq 0x35f9a(%rip), %rdx     # 0x3cc1d5
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x39622a
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x120070
movb $0x1, 0x28(%rbx)
callq 0x1203d0
movsd 0x1b730(%rip), %xmm0    # 0x3b2210
jmp 0x396ac5
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::symbol_table<double>::type_store<exprtk::details::vector_holder<double>, exprtk::details::vector_holder<double>>::add_impl<exprtk::symbol_table<double>::type_store<exprtk::details::vector_holder<double>, exprtk::details::vector_holder<double>>::tie_array, std::pair<double*, unsigned long>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::pair<double*, unsigned long>, bool)
inline bool add_impl(const std::string& symbol_name, RType t, const bool is_const)
         {
            if (symbol_name.size() > 1)
            {
               for (std::size_t i = 0; i < details::reserved_symbols_size; ++i)
               {
                  if (details::imatch(symbol_name, details::reserved_symbols[i]))
                  {
                     return false;
                  }
               }
            }

            const tm_itr_t itr = map.find(symbol_name);

            if (map.end() == itr)
            {
               map[symbol_name] = Tie::make(t,is_const);
               ++size;
            }

            return true;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, 0xc(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rdi, 0x28(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x8(%rsi), %rbx
cmpq $0x2, %rbx
jb 0x397388
movq 0x10(%rsp), %rax
movq (%rax), %r12
xorl %r13d, %r13d
leaq 0x1e348d(%rip), %rcx    # 0x57a780
xorl %r15d, %r15d
movq %r15, %rax
shlq $0x5, %rax
cmpq 0x8(%rax,%rcx), %rbx
jne 0x39736f
addq %rcx, %rax
movq (%rax), %r14
movsbl (%r12), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r14), %edi
callq 0x120450
leaq 0x1e345a(%rip), %rcx    # 0x57a780
cmpl %eax, %ebp
jne 0x39736f
movq %r13, 0x30(%rsp)
movl $0x1, %ecx
movq %rcx, %r13
cmpq %rcx, %rbx
je 0x39735a
movsbl (%r12,%r13), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r14,%r13), %edi
callq 0x120450
leaq 0x1(%r13), %rcx
cmpl %eax, %ebp
je 0x397334
cmpq %rbx, %r13
movq 0x30(%rsp), %rax
leaq 0x1e3417(%rip), %rcx    # 0x57a780
jae 0x397404
cmpq $0x58, %r15
leaq 0x1(%r15), %rax
setae %r13b
movq %rax, %r15
cmpq $0x59, %rax
jne 0x3972f6
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x39755a
leaq 0x8(%r14), %rcx
movb $0x1, %bpl
cmpq %rax, %rcx
jne 0x3973f3
movl $0x48, %edi
callq 0x1200f0
movq %rax, %rbx
addq $0x8, %rax
leaq 0x1ac2ff(%rip), %rcx    # 0x5436c0
movq %rcx, 0x8(%rbx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x10(%rbx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x18(%rbx)
movq %rax, (%rbx)
movq %r14, %rdi
movq %r15, %rsi
callq 0x39740c
movl 0xc(%rsp), %ecx
movb %cl, (%rax)
movq %rbx, 0x8(%rax)
incq 0x30(%r14)
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
testb $0x1, %al
jne 0x397388
xorl %ebp, %ebp
jmp 0x3973f3
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool run_test10<double>()::test::variable(exprtk::symbol_table<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
static inline bool variable(exprtk::symbol_table<T>& symbol_table, const std::string& variable_name, const T& value)
      {
         exprtk::details::variable_node<T>* var = symbol_table.get_variable(variable_name);

         if (var)
            return (!not_equal(var->ref(),value));
         else
            return false;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x39b2f9
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x39b2f9
movq %rsi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x39b2f9
movq (%r14), %rcx
movb (%rcx), %dl
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x39b2f9
movq %rdi, %r15
cmpq $0x1, %rax
je 0x39b2b6
leaq -0x1(%rax), %rsi
movl $0x1, %edi
xorl %edx, %edx
movb (%rcx,%rdi), %r8b
cmpb $0x5f, %r8b
je 0x39b2a6
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
jb 0x39b2a6
movl %r8d, %r9d
andb $-0x21, %r9b
addb $-0x41, %r9b
cmpb $0x1a, %r9b
jb 0x39b2a6
cmpq %rsi, %rdi
jae 0x39b2b1
cmpb $0x2e, %r8b
jne 0x39b2b1
incq %rdi
cmpq %rax, %rdi
setae %dl
jne 0x39b276
testb $0x1, %dl
je 0x39b2d3
leaq 0x1f0(%r12), %rdi
addq $0x1f8, %r12            # imm = 0x1F8
movq %r14, %rsi
callq 0x1ee3b2
cmpq %rax, %r12
sete %dl
testb $0x1, %dl
je 0x39b2f9
movq (%r15), %rax
movq 0x8(%rax), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ee43c
addq $0x8, %r15
cmpq %rax, %r15
je 0x39b2f9
movq 0x48(%rax), %rax
jmp 0x39b2fb
xorl %eax, %eax
testq %rax, %rax
je 0x39b351
movq 0x28(%rax), %rax
movsd (%rax), %xmm1
ucomisd %xmm1, %xmm1
jp 0x39b351
movsd (%rbx), %xmm0
ucomisd %xmm0, %xmm0
jp 0x39b351
movapd %xmm1, %xmm2
subsd %xmm0, %xmm2
movapd 0x17048(%rip), %xmm3    # 0x3b2370
andpd %xmm3, %xmm2
andpd %xmm3, %xmm1
andpd %xmm3, %xmm0
maxsd %xmm1, %xmm0
maxsd 0x16ce0(%rip), %xmm0    # 0x3b2020
mulsd 0x16d10(%rip), %xmm0    # 0x3b2058
ucomisd %xmm0, %xmm2
setbe %al
jmp 0x39b353
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool run_test10<double>()::test::string(exprtk::symbol_table<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static inline bool string(exprtk::symbol_table<T>& symbol_table, const std::string& string_name, const std::string& str)
      {
         exprtk::details::stringvar_node<T>* str_node = symbol_table.get_stringvar(string_name);

         if (str_node)
            return (str_node->ref() == str);
         else
            return false;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x39b446
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x39b446
movq %rsi, %r14
movq 0x8(%rsi), %rax
testq %rax, %rax
je 0x39b446
movq (%r14), %rcx
movb (%rcx), %dl
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x39b446
movq %rdi, %r15
cmpq $0x1, %rax
je 0x39b3fc
leaq -0x1(%rax), %rsi
movl $0x1, %edi
xorl %edx, %edx
movb (%rcx,%rdi), %r8b
cmpb $0x5f, %r8b
je 0x39b3ec
leal -0x30(%r8), %r9d
cmpb $0xa, %r9b
jb 0x39b3ec
movl %r8d, %r9d
andb $-0x21, %r9b
addb $-0x41, %r9b
cmpb $0x1a, %r9b
jb 0x39b3ec
cmpq %rsi, %rdi
jae 0x39b3f7
cmpb $0x2e, %r8b
jne 0x39b3f7
incq %rdi
cmpq %rax, %rdi
setae %dl
jne 0x39b3bc
testb $0x1, %dl
je 0x39b419
leaq 0x1f0(%r12), %rdi
addq $0x1f8, %r12            # imm = 0x1F8
movq %r14, %rsi
callq 0x1ee3b2
cmpq %rax, %r12
sete %dl
testb $0x1, %dl
je 0x39b446
movq (%r15), %rax
movq 0x8(%rax), %r15
leaq 0x188(%r15), %rdi
movq %r14, %rsi
callq 0x1ee67c
addq $0x190, %r15            # imm = 0x190
cmpq %rax, %r15
je 0x39b446
movq 0x48(%rax), %rax
jmp 0x39b448
xorl %eax, %eax
testq %rax, %rax
je 0x39b472
movq 0x30(%rax), %rax
movq 0x8(%rax), %rdx
cmpq 0x8(%rbx), %rdx
jne 0x39b472
testq %rdx, %rdx
je 0x39b480
movq (%rbx), %rsi
movq (%rax), %rdi
callq 0x120370
testl %eax, %eax
sete %al
jmp 0x39b474
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movb $0x1, %al
jmp 0x39b474
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39b540
cmpq $0x0, 0x8(%rax)
je 0x39b540
movq 0x8(%rax), %r13
cmpq $0x0, 0x28(%r13)
je 0x39b540
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r15, %r13
je 0x39b540
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 0x1eda34
movsd (%rbx), %xmm0
movsd %xmm0, 0x30(%rsp)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x39c014
movq 0x10(%rsp), %rdi
movq %rbp, %rbx
cmpq %rbp, %rdi
je 0x39b528
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %r15, %rdi
callq 0x1204c0
movq %rax, %r15
incq %r14
cmpq %rax, %r13
movq %rbx, %rbp
jne 0x39b4d7
jmp 0x39b543
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 0x39b56f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: 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 0x39b75d
cmpb $0x1, 0x9(%r14)
jne 0x39b7db
movq 0x10(%r14), %rax
cmpq 0x18(%r14), %rax
je 0x39b7db
movq %rsi, (%rsp)
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
movq %r12, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
subq %r15, %rax
je 0x39b7e2
xorl %ebp, %ebp
leaq (,%rbp,4), %rax
addq %rbp, %rax
cmpq $0x0, 0x8(%r15,%rax,8)
je 0x39b7bb
leaq (%r15,%rax,8), %r15
xorl %r12d, %r12d
movq (%r15), %rbx
movsbl (%rbx,%r12), %edi
callq 0x120450
movb %al, (%rbx,%r12)
incq %r12
cmpq 0x8(%r15), %r12
jb 0x39b7a1
incq %rbp
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %rbp
jb 0x39b787
jmp 0x39b7ea
xorl %eax, %eax
jmp 0x39b86d
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %r15
je 0x39b812
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x39d14f
movq %r15, %rdi
movq %r12, %rsi
callq 0x39d22c
movq 0x10(%r14), %rdi
movq 0x18(%r14), %rsi
cmpq %rsi, %rdi
movq (%rsp), %rbx
je 0x39b82b
movq %rbx, %rdx
callq 0x39dbb8
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
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39ba1c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x28(%rdi), %rax
cmpq 0x30(%rdi), %rax
je 0x39ba1f
movq %rsi, (%rsp)
movq 0x28(%r14), %r15
movq 0x30(%r14), %r12
movq %r12, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
subq %r15, %rax
je 0x39ba26
xorl %ebp, %ebp
leaq (,%rbp,4), %rax
addq %rbp, %rax
cmpq $0x0, 0x8(%r15,%rax,8)
je 0x39b9fc
leaq (%r15,%rax,8), %r15
xorl %r12d, %r12d
movq (%r15), %rbx
movsbl (%rbx,%r12), %edi
callq 0x120450
movb %al, (%rbx,%r12)
incq %r12
cmpq 0x8(%r15), %r12
jb 0x39b9e2
incq %rbp
movq 0x28(%r14), %r15
movq 0x30(%r14), %r12
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
imulq %r13, %rax
cmpq %rax, %rbp
jb 0x39b9c8
jmp 0x39ba2e
xorl %eax, %eax
retq
xorl %eax, %eax
jmp 0x39bab1
sarq $0x3, %rax
imulq %r13, %rax
cmpq %r12, %r15
je 0x39ba56
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %r12, %rsi
callq 0x39d14f
movq %r15, %rdi
movq %r12, %rsi
callq 0x39d22c
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
cmpq %rsi, %rdi
movq (%rsp), %rbx
je 0x39ba6f
movq %rbx, %rdx
callq 0x39dbb8
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
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x39bb0d
movq %rsi, %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x39bb04
movq (%r15), %rax
testq %rax, %rax
je 0x39bafd
decq %rax
movq %rax, (%r15)
jne 0x39bafd
movq %r15, %rdi
callq 0x396d8c
movl $0x18, %esi
movq %r15, %rdi
callq 0x1200c0
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_O1/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 0x1eb8c4
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 0x39e514
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r9
movq %r14, %rdi
movl $0x1, %edx
xorl %ecx, %ecx
movl $0x1, %r8d
callq 0x39e514
orb %al, %bpl
movq 0x28(%rsp), %r14
cmpq %r14, %r12
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x39bbc9
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x35fd26
movq %r14, %rdi
callq 0x1204c0
movq %rax, %r14
cmpq %rax, %r12
jne 0x39bbad
leaq 0x10(%rsp), %rdi
callq 0x1edac4
leaq 0x8(%rsp), %rdi
callq 0x1ed354
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39bbf0
jmp 0x39bbf0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1edac4
leaq 0x8(%rsp), %rdi
callq 0x1ed354
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::collect_functions<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_functions(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, false, true, false, null_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, false, true,  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 0x1eb8c4
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
xorl %edx, %edx
movl $0x1, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x39e514
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %r9
movq %r14, %rdi
xorl %edx, %edx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0x39e514
orb %al, %bpl
movq 0x28(%rsp), %r14
cmpq %r14, %r12
setne %al
andb %bpl, %al
cmpb $0x1, %al
jne 0x39bcc2
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x35fd26
movq %r14, %rdi
callq 0x1204c0
movq %rax, %r14
cmpq %rax, %r12
jne 0x39bca6
leaq 0x10(%rsp), %rdi
callq 0x1edac4
leaq 0x8(%rsp), %rdi
callq 0x1ed354
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39bce9
jmp 0x39bce9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1edac4
leaq 0x8(%rsp), %rdi
callq 0x1ed354
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x120050
movq (%r15), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x48(%rsp,%rax)
je 0x39fb83
xorl %r14d, %r14d
jmp 0x39fc1b
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 0x120400
xorl %r14d, %r14d
leaq 0x8(%rsp), %r12
movq 0x28(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x120540
movsbl %al, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x120030
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x39fc04
cmpq $0x0, 0x10(%rsp)
je 0x39fbb0
movq 0x8(%rsp), %rax
cmpb $0x23, (%rax)
je 0x39fbb0
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x39c5d6
jmp 0x39fbb0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x39fc1b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
leaq 0x28(%rsp), %rdi
callq 0x120040
movq %r14, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x39fc3d
jmp 0x39fc3d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x39fc57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
leaq 0x28(%rsp), %rdi
callq 0x120040
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpyz<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T roundn_impl(const T v0, const T v1, real_type_tag)
            {
               const int index = std::max<int>(0, std::min<int>(pow10_size - 1, static_cast<int>(std::floor(v1))));
               const T p10 = T(pow10[index]);

               if (v0 < T(0))
                  return T(std::ceil ((v0 * p10) - T(0.5)) / p10);
               else
                  return T(std::floor((v0 * p10) + T(0.5)) / p10);
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdx), %rbp
movq 0x18(%rbp), %r14
movq 0x20(%rbp), %r13
movq 0x30(%rbp), %r15
movq 0x38(%rbp), %rax
cmpq %r13, %rax
cmovbq %rax, %r13
movq 0x48(%rbp), %r12
decq %r13
cmpq $0x1, (%rsi)
jne 0x3a4dbe
movq 0x8(%rdx), %rax
subq %rbp, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x6, %rcx
jb 0x3a4dac
movq 0x60(%rbp), %rbx
movsd (%rbx), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3a4e33
xorl %ebx, %ebx
xorl %eax, %eax
testb %al, %al
jne 0x3a4dc0
movsd 0xd454(%rip), %xmm0     # 0x3b2210
jmp 0x3a4e24
xorl %ebx, %ebx
movsd 0xd448(%rip), %xmm0     # 0x3b2210
cmpq %rbx, %r13
jb 0x3a4e24
movq 0x38(%rbp), %rax
decq %rax
cmpq %rbx, %rax
jb 0x3a4e24
cmpq %r13, %rax
jb 0x3a4e24
movq 0x50(%rbp), %rax
decq %rax
cmpq %rbx, %rax
jb 0x3a4e24
cmpq %r13, %rax
jb 0x3a4e24
movsd 0xd229(%rip), %xmm0     # 0x3b2020
cmpq %r13, %rbx
ja 0x3a4e24
movq (%rdx), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movsd (%r14,%rbx,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r15,%rbx,8), %xmm2
movsd %xmm2, (%r12,%rbx,8)
incq %rbx
cmpq %r13, %rbx
jbe 0x3a4e06
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, 0x8(%rsp)
movsd 0xd1e0(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd3ab(%rip), %xmm0     # 0x3b21f8
jne 0x3a4f0d
jp 0x3a4f0d
movsd (%rbx), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd417(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %rbx
andq %rcx, %rbx
orq %rax, %rbx
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
movq 0x78(%rax), %rax
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a4dae
movq %rax, 0x10(%rsp)
movsd 0xd179(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd344(%rip), %xmm0     # 0x3b21f8
jne 0x3a4f0f
jp 0x3a4f0f
movq 0x10(%rsp), %rax
movsd (%rax), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd3b3(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
movq 0x8(%rsp), %rdx
movq (%rdx), %rax
movq 0x20(%rax), %rax
decq %rax
cmpq %rbx, %rax
setae %cl
cmpq %r13, %rax
setae %sil
andb %cl, %sil
cmpq %r13, %rbx
setbe %al
andb %sil, %al
jmp 0x3a4db0
xorl %ebx, %ebx
xorl %eax, %eax
movq 0x8(%rsp), %rdx
jmp 0x3a4db0
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::assign<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);

         const T assign_value = scalar_t(parameters[1]);

         const std::size_t step_size = (2 != ps_index) ? 1 :
                                       static_cast<std::size_t>(scalar_t(parameters.back())());

         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;

         if (
              ((ps_index == 1) || (ps_index == 2)) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0)
            )
         {
            return T(0);
         }

         for (std::size_t i = r0; i <= r1; i += step_size)
         {
            vec[i] = assign_value;
         }

         return T(1);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %rax
movq 0x18(%rax), %rdx
movq (%rsi), %rcx
movl $0x1, %r14d
cmpq $0x2, %rcx
jne 0x3a430f
movq 0x8(%rbx), %rsi
movq -0x18(%rsi), %rsi
movsd (%rsi), %xmm0
cvttsd2si %xmm0, %rsi
movq %rsi, %rdi
sarq $0x3f, %rdi
subsd 0xdf84(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r14
andq %rdi, %r14
orq %rsi, %r14
movq (%rax), %r15
movsd (%rdx), %xmm1
movq 0x8(%rax), %r12
decq %r12
decq %rcx
cmpq $0x1, %rcx
ja 0x3a4363
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq $0x4, %rdx
jb 0x3a4359
movq 0x30(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
jbe 0x3a436b
xorl %r13d, %r13d
xorl %eax, %eax
jmp 0x3a4435
xorl %r13d, %r13d
jmp 0x3a443d
movsd %xmm1, (%rsp)
movsd 0xdca8(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xde73(%rip), %xmm0     # 0x3b21f8
jne 0x3a442b
jp 0x3a442b
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xdedd(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
movq (%rbx), %rax
movq 0x48(%rax), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a442e
movsd 0xdc4c(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xde17(%rip), %xmm0     # 0x3b21f8
jne 0x3a442e
jp 0x3a442e
movsd (%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xde8a(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq (%rbx), %rax
movq 0x8(%rax), %rax
decq %rax
cmpq %r13, %rax
setae %cl
cmpq %r12, %rax
setae %dl
andb %cl, %dl
cmpq %r12, %r13
setbe %al
andb %dl, %al
jmp 0x3a4430
xorl %r13d, %r13d
xorl %eax, %eax
movsd (%rsp), %xmm1
xorpd %xmm0, %xmm0
testb %al, %al
je 0x3a4455
movsd 0xdbdb(%rip), %xmm0     # 0x3b2020
cmpq %r12, %r13
ja 0x3a4455
movsd %xmm1, (%r15,%r13,8)
addq %r14, %r13
jmp 0x3a4445
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::sumk<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);

         const std::size_t stride = (2 != ps_index) ? 1 :
                                    static_cast<std::size_t>(scalar_t(parameters[3])());

         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;

         if (
              ((1 == ps_index) || (2 == ps_index)) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return std::numeric_limits<T>::quiet_NaN();
         }

         T result = T(0);
         T error  = T(0);

         for (std::size_t i = r0; i <= r1; i += stride)
         {
            details::kahan_sum(result, error, vec[i]);
         }

         return result;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %rax
movq (%rsi), %rcx
movl $0x1, %r14d
cmpq $0x2, %rcx
jne 0x3a47e7
movq 0x48(%rax), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0xdaac(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r14
andq %rsi, %r14
orq %rdx, %r14
movq (%rax), %r15
movq 0x8(%rax), %r12
decq %r12
decq %rcx
cmpq $0x1, %rcx
ja 0x3a48f4
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq $0x3, %rdx
jb 0x3a48f9
movq 0x18(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a48f9
movsd 0xd7df(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd9aa(%rip), %xmm0     # 0x3b21f8
jne 0x3a48f9
jp 0x3a48f9
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xda14(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r13
andq %rcx, %r13
orq %rax, %r13
movq (%rbx), %rax
movq 0x30(%rax), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a48fc
movsd 0xd783(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd94e(%rip), %xmm0     # 0x3b21f8
jne 0x3a48fc
jp 0x3a48fc
movsd (%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd9c1(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq (%rbx), %rax
movq 0x8(%rax), %rax
decq %rax
cmpq %r13, %rax
setae %cl
cmpq %r12, %rax
setae %dl
andb %cl, %dl
cmpq %r12, %r13
setbe %al
andb %dl, %al
jmp 0x3a48fe
xorl %r13d, %r13d
jmp 0x3a4902
xorl %r13d, %r13d
xorl %eax, %eax
testb %al, %al
je 0x3a493b
xorpd %xmm0, %xmm0
cmpq %r12, %r13
ja 0x3a4943
xorpd %xmm1, %xmm1
xorpd %xmm2, %xmm2
movsd (%r15,%r13,8), %xmm3
subsd %xmm1, %xmm3
addsd %xmm3, %xmm0
movapd %xmm0, %xmm1
subsd %xmm2, %xmm1
subsd %xmm3, %xmm1
addq %r14, %r13
movapd %xmm0, %xmm2
cmpq %r12, %r13
jbe 0x3a4913
jmp 0x3a4943
movsd 0xd8cd(%rip), %xmm0     # 0x3b2210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq