LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_vovovov_expression0::id[abi:cxx11](exprtk::parser<double>::expression_generator<double>&, exprtk::details::operator_type, exprtk::details::operator_type, exprtk::details::operator_type)
static inline std::string id(expression_generator<Type>& expr_gen,
                                         const details::operator_type o0,
                                         const details::operator_type o1,
                                         const details::operator_type o2)
            {
               return details::build_string()
                  << "(t" << expr_gen.to_str(o0)
                  << "t)" << expr_gen.to_str(o1)
                  << "(t" << expr_gen.to_str(o2)
                  << "t)";
            }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x14(%rsp)
movl %ecx, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
leaq 0x78(%rsp), %rsi
movq $0x40, (%rsi)
leaq 0x80(%rsp), %r15
movq %r15, %rdi
callq 0x1b3e24
leaq 0x11a904(%rip), %rsi    # 0x2d9bd8
movq %r15, %rdi
callq 0x1b3e5e
movq %rax, %r15
leaq 0x58(%rsp), %rdi
leaq 0x14(%rsp), %rdx
movq %r14, %rsi
callq 0x1b3eb0
leaq 0x58(%rsp), %rsi
movq %r15, %rdi
callq 0x118460
leaq 0x11a457(%rip), %rsi    # 0x2d975c
movq %r15, %rdi
callq 0x1b3e5e
movq %rax, %r15
leaq 0x38(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %r14, %rsi
callq 0x1b3eb0
leaq 0x38(%rsp), %rsi
movq %r15, %rdi
callq 0x118460
leaq 0x11a8a2(%rip), %rsi    # 0x2d9bd8
movq %r15, %rdi
callq 0x1b3e5e
movq %rax, %r15
leaq 0x18(%rsp), %rdi
leaq 0xc(%rsp), %rdx
movq %r14, %rsi
callq 0x1b3eb0
leaq 0x18(%rsp), %rsi
movq %r15, %rdi
callq 0x118460
leaq 0x11a3f5(%rip), %rsi    # 0x2d975c
movq %r15, %rdi
callq 0x1b3e5e
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1182f0
leaq 0x18(%rsp), %rdi
callq 0x118648
leaq 0x38(%rsp), %rdi
callq 0x118648
leaq 0x58(%rsp), %rdi
callq 0x118648
leaq 0x80(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x1bf3c0
jmp 0x1bf3c5
jmp 0x1bf3bb
movq %rax, %rbx
jmp 0x1bf3eb
movq %rax, %rbx
jmp 0x1bf3d7
movq %rax, %rbx
jmp 0x1bf3e1
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x118648
leaq 0x38(%rsp), %rdi
callq 0x118648
leaq 0x58(%rsp), %rdi
callq 0x118648
leaq 0x80(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::sf4_optimisable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::details::operator_type&) const
inline bool sf4_optimisable(const std::string& sf4id, details::operator_type& operation) const
         {
            typename sf4_map_t::const_iterator itr = sf4_map_->find(sf4id);

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

            return true;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x60(%rdi), %rdi
callq 0x1bfc7c
movq 0x60(%r14), %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x1bf425
movl 0x48(%rax), %edx
movl %edx, (%rbx)
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::T0oT1oT2oT3_sf4ext<double, double const&, double const&, double const&, double const&, exprtk::details::sf48_op<double>>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::T0oT1oT2oT3_sf4ext<double, double const&, double const&, double const&, double const&, exprtk::details::sf48_op<double>>, double const&, double const&, double const&, double const&>(double const&, double const&, double const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_type(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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
pushq $0x40
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x29fc92(%rip), %rcx    # 0x45f978
movq %rcx, (%rax)
leaq 0x29fcd8(%rip), %rcx    # 0x45f9c8
movq %rcx, 0x8(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::T0oT1oT2oT3<double, double const&, double const&, double const&, double const, exprtk::details::T0oT1oT20T3process<double>::mode0>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::T0oT1oT2oT3<double, double const&, double const&, double const&, double const, exprtk::details::T0oT1oT20T3process<double>::mode0>, double const&, double const&, double const&, double const, double (*)(double const&, double const&), double (*)(double const&, double const&), double (*)(double const&, double const&)>(double const&, double const&, double const&, double const, double (*)(double const&, double const&), double (*)(double const&, double const&), double (*)(double const&, double const&)) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2,
                                                                               T3 t3, T4 t4,
                                                                               T5 t5, T6 t6,
                                                                               T7 t7) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5, t6, t7));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %r14
movsd %xmm0, (%rsp)
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
movq 0x40(%rsp), %rbp
pushq $0x58
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x29d01c(%rip), %rcx    # 0x469f80
movq %rcx, (%rax)
leaq 0x29d062(%rip), %rcx    # 0x469fd0
movq %rcx, 0x8(%rax)
movq %r13, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %r15, 0x30(%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x38(%rax)
movq %r14, 0x40(%rax)
movq %rbx, 0x48(%rax)
movq %rbp, 0x50(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::cleanup()
inline void cleanup()
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               free_element(element_[i]);
            }

            element_.clear();

            input_param_cnt_             = 0;
            total_local_symb_size_bytes_ = 0;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
xorl %r15d, %r15d
pushq $0x70
popq %r12
xorl %r13d, %r13d
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
subq %rsi, %rax
cqto
idivq %r12
cmpq %rax, %r13
jae 0x1f5e55
addq %r15, %rsi
movq %rbx, %rdi
callq 0x1f7500
incq %r13
addq $0x70, %r15
jmp 0x1f5e2c
movq %r14, %rdi
callq 0x1f7594
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::return_cleanup()
inline void return_cleanup()
      {
         #ifndef exprtk_disable_return_statement
         if (results_context_)
         {
            delete results_context_;
            results_context_ = 0;
         }

         state_.return_stmt_present = false;
         #endif
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x3d0(%rdi), %r14
testq %r14, %r14
je 0x1f5ea1
leaq 0x8(%r14), %rdi
callq 0x198da8
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1180d0
andq $0x0, 0x3d0(%rbx)
movb $0x0, 0x3ab(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser_error::make_error(exprtk::parser_error::error_mode, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline type make_error(const error_mode mode,
                             const std::string& diagnostic   = "",
                             const std::string& src_location = "")
      {
         type t;
         t.mode         = mode;
         t.token.type   = lexer::token::e_error;
         t.diagnostic   = diagnostic;
         t.src_location = src_location;
         exprtk_debug(("%s\n", diagnostic .c_str()));
         return t;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1f79e8
movl %ebp, 0x30(%rbx)
movl $0x1, (%rbx)
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x1185c0
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1185c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f5c4c
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::parser_helper::init(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool init(const std::string& str)
         {
            if (!lexer_.process(str))
            {
               return false;
            }

            lexer_.begin();

            next_token();

            return true;
         }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1f7ae6
movl %eax, %ebp
testb %al, %al
je 0x1f614c
movq (%rbx), %rax
movq %rax, 0x18(%rbx)
movq %rax, 0x20(%rbx)
movq %rbx, %rdi
callq 0x1f6d68
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::dependent_entity_collector::clear()
void clear()
         {
            symbol_name_list_    .clear();
            assignment_name_list_.clear();
            retparam_list_       .clear();
            return_present_    = false;
            final_stmt_return_ = false;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x10, %rdi
callq 0x1f8fa6
leaq 0x28(%rbx), %rdi
callq 0x1f8fa6
leaq 0x40(%rbx), %rdi
callq 0x1f8fae
andw $0x0, 0xb(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::return_envelope(exprtk::details::expression_node<double>*, exprtk::results_context<double>*, bool*&)
inline expression_node_ptr return_envelope(expression_node_ptr body,
                                                    results_context_t* rc,
                                                    bool*& return_invoked)
         {
            typedef details::return_envelope_node<Type> alloc_type;

            expression_node_ptr result = node_allocator_->
                                            allocate_cr<alloc_type>(body,(*rc));

            return_invoked = static_cast<alloc_type*>(result)->retinvk_ptr();

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
leaq 0x8(%rsp), %rax
movq %rsi, (%rax)
movq 0x8(%rdi), %rdi
movq %rax, %rsi
callq 0x2b9d1a
leaq 0x28(%rax), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser_error::make_error(exprtk::parser_error::error_mode, exprtk::lexer::token const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline type make_error(const error_mode mode,
                             const lexer::token& tk,
                             const std::string& diagnostic   = "",
                             const std::string& src_location = "")
      {
         type t;
         t.mode         = mode;
         t.token        = tk;
         t.diagnostic   = diagnostic;
         t.src_location = src_location;
         exprtk_debug(("%s\n", diagnostic .c_str()));
         return t;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %rbx
callq 0x1f79e8
movl %ebp, 0x30(%rbx)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1a06d8
leaq 0x38(%rbx), %rdi
movq %r15, %rsi
callq 0x1185c0
leaq 0x58(%rbx), %rdi
movq %r14, %rsi
callq 0x1185c0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x1f5c4c
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::free_element(exprtk::parser<double>::scope_element&)
inline void free_element(scope_element& se)
         {
            exprtk_debug(("free_element() - se[%s]\n", se.name.c_str()));

            switch (se.type)
            {
               case scope_element::e_literal    : delete reinterpret_cast<T*>(se.data);
                                                  delete se.var_node;
                                                  break;

               case scope_element::e_variable   : delete reinterpret_cast<T*>(se.data);
                                                  delete se.var_node;
                                                  break;

               case scope_element::e_vector     : delete[] reinterpret_cast<T*>(se.data);
                                                  delete se.vec_node;
                                                  break;

               case scope_element::e_vecelem    : delete se.var_node;
                                                  break;

               #ifndef exprtk_disable_string_capabilities
               case scope_element::e_string     : delete reinterpret_cast<std::string*>(se.data);
                                                  delete se.str_node;
                                                  break;
               #endif

               default                          : return;
            }

            se.clear();
         }

// Assembly:
movl 0x48(%rsi), %eax
decl %eax
cmpl $0x4, %eax
ja 0x1f7592
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xd83cc(%rip), %rcx     # 0x2cf8e8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x50(%rbx), %rdi
pushq $0x8
popq %rsi
callq 0x1180d0
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x1f7583
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1f7583
movq 0x50(%rbx), %r14
testq %r14, %r14
je 0x1f7553
movq %r14, %rdi
callq 0x118648
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1180d0
movq 0x68(%rbx), %rdi
movl $0x88, %esi
jmp 0x1f757e
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x1f7577
callq 0x1181d0
movq 0x60(%rbx), %rdi
pushq $0x48
popq %rsi
callq 0x1180d0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f759c
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> exprtk::details::to_str_impl<long long>(long long)
inline std::string to_str_impl(SignedType i)
      {
         if (0 == i)
            return std::string("0");

         std::string result;

         const int sign = (i < 0) ? -1 : 1;

         for ( ; i; i /= 10)
         {
            result += '0' + static_cast<char_t>(sign * (i % 10));
         }

         if (sign < 0)
         {
            result += '-';
         }

         std::reverse(result.begin(), result.end());

         return result;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rsi, %rsi
je 0x1f767b
movq %rsi, %r14
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
pushq $0xa
popq %r12
movq %rsi, %r15
testq %r15, %r15
je 0x1f765a
movq %r15, %rax
cqto
idivq %r12
movl %edx, %ecx
negb %cl
testq %r14, %r14
movzbl %cl, %ecx
cmovnsl %edx, %ecx
addb $0x30, %cl
movsbl %cl, %esi
movq %rax, %r15
movq %rbx, %rdi
callq 0x1185f0
jmp 0x1f762d
testq %r14, %r14
jns 0x1f766a
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x1185f0
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
addq %rdi, %rsi
callq 0x1f76b3
jmp 0x1f768f
leaq 0xdce2b(%rip), %rsi     # 0x2d44ad
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1f76a0
movq %rax, %r14
movq %rbx, %rdi
callq 0x118648
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool process(const std::string& str)
         {
            base_itr_ = str.data();
            s_itr_    = str.data();
            s_end_    = str.data() + str.size();

            eof_token_.set_operator(token_t::e_eof, s_end_, s_end_, base_itr_);
            token_list_.clear();

            while (!is_end(s_itr_))
            {
               scan_token();

               if (!token_list_.empty() && token_list_.back().is_error())
                  return false;
            }

            return true;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %r8
movq %r8, 0x58(%rdi)
movq %r8, 0x60(%rdi)
movq 0x8(%rsi), %rcx
addq %r8, %rcx
movq %rcx, 0x68(%rdi)
addq $0x28, %rdi
pushq $0x6
popq %rsi
movq %rcx, %rdx
callq 0x1f7b50
movq %rbx, %rdi
callq 0x19e540
movq 0x60(%rbx), %r14
movq 0x68(%rbx), %r15
cmpq %r14, %r15
je 0x1f7b43
movq %rbx, %rdi
callq 0x1f7b84
movq 0x8(%rbx), %rax
cmpq %rax, (%rbx)
je 0x1f7b1b
movl -0x30(%rax), %eax
decl %eax
cmpl $0x4, %eax
ja 0x1f7b1b
cmpq %r14, %r15
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_operator<char const*>(exprtk::lexer::token::token_type, char const*, char const*, char const*)
inline token& set_operator(const token_type tt,
                                    const Iterator begin, const Iterator end,
                                    const Iterator base_begin = Iterator(0))
         {
            type = tt;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %r15
movq %rdi, %r14
movl %esi, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1f7cfe
testq %rbx, %rbx
je 0x1f7b7b
subq %rbx, %r15
movq %r15, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::is_comment_start(char const*) const
inline bool is_comment_start(details::char_cptr itr) const
         {
            const char_t c0 = *(itr + 0);
            const char_t c1 = *(itr + 1);

            if ('#' == c0)
               return true;
            else if (!is_end(itr + 1))
            {
               if (('/' == c0) && ('/' == c1)) return true;
               if (('/' == c0) && ('*' == c1)) return true;
            }
            return false;
         }

// Assembly:
movb (%rsi), %cl
movb $0x1, %al
cmpb $0x23, %cl
je 0x1f7d74
leaq 0x1(%rsi), %rdx
cmpq %rdx, 0x68(%rdi)
je 0x1f7d75
movb 0x1(%rsi), %sil
cmpb $0x2f, %sil
sete %dl
cmpb $0x2a, %sil
sete %sil
cmpb $0x2f, %cl
jne 0x1f7d75
orb %sil, %dl
je 0x1f7d75
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::scan_symbol()
inline void scan_symbol()
         {
            details::char_cptr initial_itr = s_itr_;

            while (!is_end(s_itr_))
            {
               if (!details::is_letter_or_digit(*s_itr_) && ('_' != (*s_itr_)))
               {
                  if ('.' != (*s_itr_))
                     break;
                  /*
                     Permit symbols that contain a 'dot'
                     Allowed   : abc.xyz, a123.xyz, abc.123, abc_.xyz a123_.xyz abc._123
                     Disallowed: .abc, abc.<white-space>, abc.<eof>, abc.<operator +,-,*,/...>
                  */
                  if (
                       (s_itr_ != initial_itr)                     &&
                       !is_end(s_itr_ + 1)                         &&
                       !details::is_letter_or_digit(*(s_itr_ + 1)) &&
                       ('_' != (*(s_itr_ + 1)))
                     )
                     break;
               }

               ++s_itr_;
            }

            token_t t;
            t.set_symbol(initial_itr, s_itr_, base_itr_);
            token_list_.push_back(t);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
movq 0x68(%rdi), %rax
leaq 0x1(%r14), %rcx
xorl %edx, %edx
leaq -0x1(%rcx), %rsi
cmpq %rax, %rsi
je 0x1f8139
movzbl (%rsi), %esi
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x1f812d
movl %esi, %edi
andb $-0x21, %dil
addb $-0x41, %dil
cmpb $0x1a, %dil
jb 0x1f812d
cmpl $0x5f, %esi
je 0x1f812d
cmpl $0x2e, %esi
jne 0x1f8139
testq %rdx, %rdx
je 0x1f812d
cmpq %rax, %rcx
je 0x1f812d
movb (%rcx), %sil
cmpb $0x5f, %sil
je 0x1f812d
leal -0x30(%rsi), %edi
cmpb $0xa, %dil
jb 0x1f812d
andb $-0x21, %sil
addb $-0x41, %sil
cmpb $0x19, %sil
ja 0x1f8139
movq %rcx, 0x60(%rbx)
incq %rcx
decq %rdx
jmp 0x1f80d4
movq %rsp, %r15
movq %r15, %rdi
callq 0x19e4ae
movq 0x58(%rbx), %rcx
movq 0x60(%rbx), %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x1f86b2
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x19f258
leaq 0x8(%rsp), %rdi
callq 0x118648
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::scan_special_function()
inline void scan_special_function()
         {
            details::char_cptr initial_itr = s_itr_;
            token_t t;

            // $fdd(x,x,x) = at least 11 chars
            if (std::distance(s_itr_,s_end_) < 11)
            {
               t.set_error(
                  token::e_err_sfunc,
                  initial_itr, std::min(initial_itr + 11, s_end_),
                  base_itr_);
               token_list_.push_back(t);

               return;
            }

            if (
                 !(('$' == *s_itr_)                       &&
                   (details::imatch  ('f',*(s_itr_ + 1))) &&
                   (details::is_digit(*(s_itr_ + 2)))     &&
                   (details::is_digit(*(s_itr_ + 3))))
               )
            {
               t.set_error(
                  token::e_err_sfunc,
                  initial_itr, std::min(initial_itr + 4, s_end_),
                  base_itr_);
               token_list_.push_back(t);

               return;
            }

            s_itr_ += 4; // $fdd = 4chars

            t.set_symbol(initial_itr, s_itr_, base_itr_);
            token_list_.push_back(t);

            return;
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq 0x60(%rdi), %r14
leaq 0x8(%rsp), %rdi
callq 0x19e4ae
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rdx
movq %rdx, %rcx
subq %rax, %rcx
cmpq $0xa, %rcx
jg 0x1f83b5
leaq 0xb(%r14), %rcx
cmpq %rcx, %rdx
cmovbq %rdx, %rcx
movq 0x58(%rbx), %r8
leaq 0x8(%rsp), %rdi
pushq $0x5
popq %rsi
movq %r14, %rdx
callq 0x1f86e4
jmp 0x1f841e
cmpb $0x24, (%rax)
jne 0x1f83fb
movsbl 0x1(%rax), %esi
pushq $0x66
popq %rdi
callq 0x1f87b8
testb %al, %al
je 0x1f83fb
movq 0x60(%rbx), %rdx
movb 0x2(%rdx), %al
addb $-0x30, %al
cmpb $0x9, %al
ja 0x1f83fb
movb 0x3(%rdx), %al
addb $-0x30, %al
cmpb $0xa, %al
jae 0x1f83fb
addq $0x4, %rdx
movq %rdx, 0x60(%rbx)
movq 0x58(%rbx), %rcx
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x1f86b2
jmp 0x1f841e
leaq 0x4(%r14), %rcx
movq 0x58(%rbx), %r8
movq 0x68(%rbx), %rax
cmpq %rcx, %rax
cmovbq %rax, %rcx
leaq 0x8(%rsp), %rdi
pushq $0x5
popq %rsi
movq %r14, %rdx
callq 0x1f86e4
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x19f258
leaq 0x10(%rsp), %rdi
callq 0x118648
addq $0x38, %rsp
popq %rbx
popq %r14
retq
jmp 0x1f8441
jmp 0x1f8441
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_symbol<char const*>(char const*, char const*, char const*)
inline token& set_symbol(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
         {
            type = e_symbol;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x8, (%rdi)
addq $0x8, %rdi
callq 0x1f7cfe
testq %r14, %r14
je 0x1f86db
subq %r14, %r15
movq %r15, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_error<char const*>(exprtk::lexer::token::token_type, char const*, char const*, char const*)
inline token& set_error(const token_type et,
                                 const Iterator begin, const Iterator end,
                                 const Iterator base_begin = Iterator(0))
         {
            if (
                 (e_error      == et) ||
                 (e_err_symbol == et) ||
                 (e_err_number == et) ||
                 (e_err_string == et) ||
                 (e_err_sfunc  == et)
               )
            {
               type = et;
            }
            else
               type = e_error;

            value.assign(begin,end);

            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));

            return (*this);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %r8, %rbx
movq %rdx, %r15
movq %rdi, %r14
leal -0x1(%rsi), %eax
cmpl $0x5, %eax
pushq $0x1
popq %rax
cmovbl %esi, %eax
movl %eax, (%rdi)
addq $0x8, %rdi
movq %rdx, %rsi
movq %rcx, %rdx
callq 0x1f7cfe
testq %rbx, %rbx
je 0x1f871b
subq %rbx, %r15
movq %r15, 0x28(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::skip_comments()::test::comment_start(char, char, int&, int&)
static inline bool comment_start(const char_t c0, const char_t c1, int& mode, int& incr)
               {
                  mode = 0;
                  if      ('#' == c0)    { mode = 1; incr = 1; }
                  else if ('/' == c0)
                  {
                     if      ('/' == c1) { mode = 1; incr = 2; }
                     else if ('*' == c1) { mode = 2; incr = 2; }
                  }
                  return (0 != mode);
               }

// Assembly:
andl $0x0, (%rdx)
pushq $0x1
popq %rax
cmpl $0x23, %edi
je 0x1f8745
cmpl $0x2f, %edi
jne 0x1f874b
movsbl %sil, %esi
cmpl $0x2f, %esi
je 0x1f8752
cmpl $0x2a, %esi
jne 0x1f874b
pushq $0x2
popq %rax
movl %eax, %esi
movl %eax, (%rdx)
movl %esi, (%rcx)
cmpl $0x0, (%rdx)
setne %al
retq
pushq $0x2
popq %rsi
jmp 0x1f8747
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_numeric<char const*>(char const*, char const*, char const*)
inline token& set_numeric(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
         {
            type = e_number;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x7, (%rdi)
addq $0x8, %rdi
callq 0x1f7cfe
testq %r14, %r14
je 0x1f87af
subq %r14, %r15
movq %r15, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token& exprtk::lexer::token::set_string<char const*>(char const*, char const*, char const*)
inline token& set_string(const Iterator begin, const Iterator end, const Iterator base_begin = Iterator(0))
         {
            type = e_string;
            value.assign(begin,end);
            if (base_begin)
               position = static_cast<std::size_t>(std::distance(base_begin,begin));
            return (*this);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x9, (%rdi)
addq $0x8, %rdi
callq 0x1f7cfe
testq %r14, %r14
je 0x1f8853
subq %r14, %r15
movq %r15, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::token::set_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline token& set_string(const std::string& s, const std::size_t p)
         {
            type     = e_string;
            value    = s;
            position = p;
            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl $0x9, (%rdi)
addq $0x8, %rdi
callq 0x1185c0
movq %rbx, 0x28(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_inserters(exprtk::lexer::generator&)
inline bool run_inserters(lexer::generator& g)
            {
               error_token_inserter = reinterpret_cast<lexer::token_inserter*>(0);

               for (std::size_t i = 0; i < token_inserter_list.size(); ++i)
               {
                  lexer::token_inserter& inserter = (*token_inserter_list[i]);

                  inserter.reset();
                  inserter.process(g);

                  if (!inserter.result())
                  {
                     error_token_inserter = token_inserter_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x78(%rdi)
xorl %r12d, %r12d
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq %r13, %r12
jae 0x1f8b84
movq (%rax,%r12,8), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1f8b78
incq %r12
jmp 0x1f8b39
movq 0x48(%rbx), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x78(%rbx)
cmpq %r13, %r12
setae %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_joiners(exprtk::lexer::generator&)
inline bool run_joiners(lexer::generator& g)
            {
               error_token_joiner = reinterpret_cast<lexer::token_joiner*>(0);

               for (std::size_t i = 0; i < token_joiner_list.size(); ++i)
               {
                  lexer::token_joiner& joiner = (*token_joiner_list[i]);

                  joiner.reset();
                  joiner.process(g);

                  if (!joiner.result())
                  {
                     error_token_joiner = token_joiner_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x70(%rdi)
xorl %r12d, %r12d
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq %r13, %r12
jae 0x1f8bf6
movq (%rax,%r12,8), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1f8bea
incq %r12
jmp 0x1f8bab
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x70(%rbx)
cmpq %r13, %r12
setae %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_modifiers(exprtk::lexer::generator&)
inline bool run_modifiers(lexer::generator& g)
            {
               error_token_modifier = reinterpret_cast<lexer::token_modifier*>(0);

               for (std::size_t i = 0; i < token_modifier_list.size(); ++i)
               {
                  lexer::token_modifier& modifier = (*token_modifier_list[i]);

                  modifier.reset();
                  modifier.process(g);

                  if (!modifier.result())
                  {
                     error_token_modifier = token_modifier_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x68(%rdi)
xorl %r12d, %r12d
movq 0x18(%rbx), %rax
movq 0x20(%rbx), %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq %r13, %r12
jae 0x1f8c68
movq (%rax,%r12,8), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1f8c5c
incq %r12
jmp 0x1f8c1d
movq 0x18(%rbx), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x68(%rbx)
cmpq %r13, %r12
setae %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::helper_assembly::run_scanners(exprtk::lexer::generator&)
inline bool run_scanners(lexer::generator& g)
            {
               error_token_scanner = reinterpret_cast<lexer::token_scanner*>(0);

               for (std::size_t i = 0; i < token_scanner_list.size(); ++i)
               {
                  lexer::token_scanner& scanner = (*token_scanner_list[i]);

                  scanner.reset();
                  scanner.process(g);

                  if (!scanner.result())
                  {
                     error_token_scanner = token_scanner_list[i];

                     return false;
                  }
               }

               return true;
            }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x60(%rdi)
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %r13
subq %rax, %r13
sarq $0x3, %r13
cmpq %r13, %r12
jae 0x1f8cd8
movq (%rax,%r12,8), %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
movq %r14, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
testb %al, %al
je 0x1f8ccd
incq %r12
jmp 0x1f8c8f
movq (%rbx), %rax
movq (%rax,%r12,8), %rax
movq %rax, 0x60(%rbx)
cmpq %r13, %r12
setae %al
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::helper::sequence_validator::error(unsigned long)
std::pair<lexer::token,lexer::token> error(const std::size_t index)
            {
               if (index < error_list_.size())
               {
                  return error_list_[index];
               }
               else
               {
                  static const lexer::token error_token;
                  return std::make_pair(error_token,error_token);
               }
            }

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rsi, %rax
movq %rdi, %rbx
movq 0x40(%rsi), %rsi
movq 0x48(%rax), %rax
subq %rsi, %rax
pushq $0x60
popq %rdi
cqto
idivq %rdi
cmpq %rcx, %rax
jbe 0x1f8d1b
imulq $0x60, %rcx, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x1f8e48
jmp 0x1f8d37
movb 0x2cb1f7(%rip), %al     # 0x4c3f18
testb %al, %al
je 0x1f8d3c
leaq 0x2cb1bc(%rip), %rdx    # 0x4c3ee8
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x1a17ec
movq %rbx, %rax
popq %rbx
retq
leaq 0x2cb1d5(%rip), %rdi    # 0x4c3f18
callq 0x1181a0
testl %eax, %eax
je 0x1f8d25
leaq 0x2cb195(%rip), %rdi    # 0x4c3ee8
callq 0x19e4ae
leaq -0x5a885(%rip), %rdi    # 0x19e4da
leaq 0x2cb182(%rip), %rsi    # 0x4c3ee8
leaq 0x2be5bb(%rip), %rdx    # 0x4b7328
callq 0x118490
leaq 0x2cb19f(%rip), %rdi    # 0x4c3f18
callq 0x118300
jmp 0x1f8d25
movq %rax, %rbx
leaq 0x2cb18e(%rip), %rdi    # 0x4c3f18
callq 0x118220
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::construct_subexpr[abi:cxx11](exprtk::lexer::token&, exprtk::lexer::token&, bool)
std::string construct_subexpr(lexer::token& begin_token,
                                    lexer::token& end_token,
                                    const bool cleanup_whitespace = true)
      {
         std::string result = lexer().substr(begin_token.position,end_token.position);
         if (cleanup_whitespace)
         {
            for (std::size_t i = 0; i < result.size(); ++i)
            {
               if (details::is_whitespace(result[i])) result[i] = ' ';
            }
         }

         return result;
      }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %r8d, %ebp
movq %rdi, %rbx
addq $0x28, %rdx
addq $0x28, %rcx
callq 0x2a3832
testl %ebp, %ebp
je 0x1fae64
xorl %eax, %eax
movabsq $0x100003f00, %rcx      # imm = 0x100003F00
cmpq 0x8(%rbx), %rax
jae 0x1fae64
movq (%rbx), %rdx
movzbl (%rdx,%rax), %esi
cmpq $0x20, %rsi
ja 0x1fae5f
btq %rsi, %rcx
jae 0x1fae5f
movb $0x20, (%rdx,%rax)
incq %rax
jmp 0x1fae42
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scoped_vec_delete<exprtk::details::expression_node<double>>::~scoped_vec_delete()
~scoped_vec_delete()
         {
            if (delete_ptr && !vec_.empty())
            {
               for (std::size_t i = 0; i < vec_.size(); ++i)
               {
                  exprtk_debug(("~scoped_vec_delete() - deleting node: %p\n", reinterpret_cast<void*>(vec_[i])));
                  free_node(parser_.node_allocator_,vec_[i]);
               }

               vec_.clear();
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpb $0x1, (%rdi)
jne 0x1fb21f
movq %rdi, %rbx
movq 0x10(%rdi), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
cmpq %rcx, %rsi
je 0x1fb21f
xorl %r14d, %r14d
movl $0x290, %r15d           # imm = 0x290
xorl %r12d, %r12d
movq %rcx, %rdx
subq %rsi, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r12
jae 0x1fb216
movq 0x8(%rbx), %rdi
addq %r15, %rdi
addq %r14, %rsi
callq 0x1ad9c8
incq %r12
movq 0x10(%rbx), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rcx
addq $0x8, %r14
jmp 0x1fb1e4
cmpq %rsi, %rcx
je 0x1fb21f
movq %rsi, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rdi
callq 0x193e66
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::stack_limit_handler::stack_limit_handler(exprtk::parser<double>&)
explicit stack_limit_handler(parser<T>& p)
         : parser_(p)
         , limit_exceeded_(false)
         {
            if (++parser_.state_.stack_depth > parser_.settings_.max_stack_depth_)
            {
               limit_exceeded_ = true;
               parser_.set_error(make_error(
                  parser_error::e_parser,
                  "ERR000 - Current stack depth " + details::to_str(parser_.state_.stack_depth) +
                  " exceeds maximum allowed stack depth of " + details::to_str(parser_.settings_.max_stack_depth_),
                  exprtk_error_location));
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rsi, %rbx
movq %rsi, (%rdi)
movb $0x0, 0x8(%rdi)
movq 0x3b8(%rsi), %rsi
incq %rsi
movq %rsi, 0x3b8(%rbx)
cmpq 0x200(%rbx), %rsi
jbe 0x1fb39f
movq %rdi, %r14
movb $0x1, 0x8(%rdi)
leaq 0xc8(%rsp), %r15
movq %r15, %rdi
callq 0x1f7603
leaq 0xded5d(%rip), %rsi     # 0x2d9ff3
leaq 0x68(%rsp), %rdi
movq %r15, %rdx
callq 0x1b4349
leaq 0xded67(%rip), %rdx     # 0x2da011
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x1b42c3
movq (%r14), %rax
movq 0x200(%rax), %rsi
leaq 0x48(%rsp), %rdi
callq 0x1f7603
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x1b42e2
leaq 0x8(%rsp), %rdi
movl $0x5995, %esi           # imm = 0x5995
callq 0x1f7a3c
leaq 0xde8fb(%rip), %rsi     # 0x2d9bfb
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x1b4349
leaq 0xe8(%rsp), %rdi
pushq $0x9
popq %rsi
leaq 0xa8(%rsp), %rdx
leaq 0x28(%rsp), %rcx
callq 0x1f60ce
addq $0x308, %rbx            # imm = 0x308
leaq 0xe8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1f76ce
leaq 0xe8(%rsp), %rdi
callq 0x1f5c4c
leaq 0x28(%rsp), %rdi
callq 0x118648
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0xa8(%rsp), %rdi
callq 0x118648
leaq 0x48(%rsp), %rdi
callq 0x118648
leaq 0x88(%rsp), %rdi
callq 0x118648
leaq 0x68(%rsp), %rdi
callq 0x118648
leaq 0xc8(%rsp), %rdi
callq 0x118648
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xe8(%rsp), %rdi
callq 0x1f5c4c
jmp 0x1fb3c1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x118648
jmp 0x1fb3d0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x1fb3df
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x118648
jmp 0x1fb3f1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x118648
leaq 0x88(%rsp), %rdi
callq 0x118648
leaq 0x68(%rsp), %rdi
callq 0x118648
leaq 0xc8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
movq %rax, %rbx
jmp 0x1fb3fb
movq %rax, %rbx
jmp 0x1fb408
movq %rax, %rbx
jmp 0x1fb412
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::parse_pending_string_rangesize(exprtk::details::expression_node<double>*&)
inline bool parse_pending_string_rangesize(expression_node_ptr& expression)
      {
         // Allow no more than 100 range calls, eg: s[][][]...[][]
         const std::size_t max_rangesize_parses = 100;

         std::size_t i = 0;

         while
            (
              (0 != expression)                     &&
              (i++ < max_rangesize_parses)          &&
              error_list_.empty()                   &&
              is_generally_string_node(expression)  &&
              token_is(token_t::e_lsqrbracket,prsrhlpr_t::e_hold)
            )
         {
            expression = parse_string_range_statement(expression);
         }

         return (i > 1);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
pushq $0x1
popq %r12
xorl %ebp, %ebp
pushq $0x65
popq %r13
leaq 0x4(%rsp), %r15
testq %rdi, %rdi
je 0x1fbd97
cmpq $0x65, %r12
je 0x1fbda2
movq 0x338(%r14), %rax
cmpq 0x318(%r14), %rax
jne 0x1fbd9a
incq %rbp
callq 0x20b691
testb %al, %al
je 0x1fbd9f
movl $0x5b, 0x4(%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x1fae6e
testb %al, %al
je 0x1fbda5
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2b8792
movq %rax, %rdi
movq %rax, (%rbx)
incq %r12
jmp 0x1fbd41
decq %r12
movq %r12, %r13
jmp 0x1fbda2
movq %rbp, %r13
movq %r13, %r12
cmpq $0x2, %r12
setae %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::operator()(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&)
inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr& b0, expression_node_ptr& b1)
         {
            expression_node_ptr result = error_node();

            if ((0 != b0) && (0 != b1))
            {
               expression_node_ptr branch[2] = { b0, b1 };
               result = expression_generator<Type>::operator()(operation, branch);
               b0 = branch[0];
               b1 = branch[1];
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq (%rdx), %rax
testq %rax, %rax
sete %dl
movq (%rcx), %rcx
testq %rcx, %rcx
sete %r8b
orb %dl, %r8b
je 0x1fbf7d
xorl %eax, %eax
jmp 0x1fbf9c
movq %rsp, %r15
movq %rax, (%r15)
movq %rcx, 0x8(%r15)
movq %r15, %rdx
callq 0x20dd4a
movq (%r15), %rcx
movq %rcx, (%r14)
movq 0x8(%r15), %rcx
movq %rcx, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_logic_opr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_logic_opr(const std::string& lgc_opr)
      {
         for (std::size_t i = 0; i < logic_ops_list_size; ++i)
         {
            if (imatch(lgc_opr, logic_ops_list[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x2bc4a1(%rip), %r14    # 0x4b8a00
xorl %ecx, %ecx
movq %rcx, %r15
cmpq $0x9, %rcx
je 0x1fc581
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fbcc5
leaq 0x1(%r15), %rcx
addq $0x20, %r14
testb %al, %al
je 0x1fc561
cmpq $0x9, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq