LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x273095
xorl %eax, %eax
jmp 0x2730b4
movq %rsp, %r15
movq %rax, (%r15)
movq %rcx, 0x8(%r15)
movq %r15, %rdx
callq 0x29b4d6
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_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq (%rdi), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rdi), %r15
testq %r15, %r15
sete %r14b
movb $0x1, %bl
xorl %r12d, %r12d
leaq 0x3072a7(%rip), %rdx    # 0x57b9e0
movb %r14b, 0xf(%rsp)
movq %r12, %rax
shlq $0x5, %rax
cmpq 0x8(%rax,%rdx), %r15
jne 0x2747c5
movl %r14d, %ecx
testq %r15, %r15
je 0x2747c1
addq %rdx, %rax
movq (%rax), %r13
movq 0x10(%rsp), %rax
movsbl (%rax), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x120450
leaq 0x307266(%rip), %rdx    # 0x57b9e0
cmpl %eax, %ebp
jne 0x2747c5
movl $0x1, %ecx
movq %rcx, %r14
cmpq %rcx, %r15
je 0x2747af
movq 0x10(%rsp), %rax
movsbl (%rax,%r14), %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13,%r14), %edi
callq 0x120450
leaq 0x1(%r14), %rcx
cmpl %eax, %ebp
je 0x274783
cmpq %r15, %r14
setae %cl
movb 0xf(%rsp), %r14b
leaq 0x30721f(%rip), %rdx    # 0x57b9e0
testb %cl, %cl
jne 0x2747de
cmpq $0x8, %r12
leaq 0x1(%r12), %rax
setb %bl
movq %rax, %r12
cmpq $0x9, %rax
jne 0x27473e
andb $0x1, %bl
movl %ebx, %eax
addq $0x18, %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::parser<double>::scope_handler::~scope_handler()
~scope_handler()
         {
            parser_.sem_.deactivate(parser_.state_.scope_depth);
            parser_.state_.scope_depth--;
            #ifdef exprtk_enable_debugging
            const std::string depth(2 * parser_.state_.scope_depth,'-');
            exprtk_debug(("<%s Scope Depth: %02d\n",
                          depth.c_str(),
                          static_cast<int>(parser_.state_.scope_depth)));
            #endif
         }

// Assembly:
movq (%rdi), %rax
movq 0x538(%rax), %rcx
movq 0x540(%rax), %rsi
subq %rcx, %rsi
je 0x294358
sarq $0x4, %rsi
movabsq $0x6db6db6db6db6db7, %rdx # imm = 0x6DB6DB6DB6DB6DB7
imulq %rsi, %rdx
movq 0x3b0(%rax), %rsi
cmpq $0x1, %rdx
adcq $0x0, %rdx
addq $0x4c, %rcx
cmpb $0x1, (%rcx)
jne 0x29434f
cmpq %rsi, -0x1c(%rcx)
jb 0x29434f
movb $0x0, (%rcx)
addq $0x70, %rcx
decq %rdx
jne 0x294341
decq 0x3b0(%rax)
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::multi_switch_statement<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr multi_switch_statement(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            if (!all_nodes_valid(arg_list))
            {
               details::free_all_nodes(*node_allocator_,arg_list);

               return error_node();
            }
            else if (is_constant_foldable(arg_list))
               return const_optimise_mswitch(arg_list);
            else
               return node_allocator_->allocate<details::multi_switch_node<Type> >(arg_list);
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq (%rsi), %r14
movq 0x8(%rsi), %rax
movq %rax, %rcx
subq %r14, %rcx
sete %bpl
movl %ebp, %edx
je 0x2943ba
sarq $0x3, %rcx
cmpq $0x1, %rcx
movq %rcx, %rdx
adcq $0x0, %rdx
cmpq $0x0, (%r14)
je 0x294429
movl $0x1, %edi
movq %rdi, %rsi
cmpq %rdi, %rdx
je 0x2943b4
leaq 0x1(%rsi), %rdi
cmpq $0x0, (%r14,%rsi,8)
jne 0x2943a1
cmpq %rcx, %rsi
setae %dl
testb %dl, %dl
je 0x294429
cmpq %r14, %rax
je 0x294410
movq (%r14), %r14
testq %r14, %r14
je 0x294410
movl $0x1, %r12d
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2943ed
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x294410
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
setae %bpl
jae 0x294410
movq (%rax,%r12,8), %r14
incq %r12
testq %r14, %r14
jne 0x2943d1
testb $0x1, %bpl
je 0x294491
movq %r15, %rdi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2944dc
cmpq %r14, %rax
je 0x294483
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x294466
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x294466
addq %r15, %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x29445e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x294466
movq %r14, %rdi
callq 0x1f1690
incq %r12
movq (%rbx), %r14
movq 0x8(%rbx), %rax
movq %rax, %rcx
subq %r14, %rcx
sarq $0x3, %rcx
addq $0x8, %r15
cmpq %rcx, %r12
jb 0x294434
cmpq %r14, %rax
je 0x29448c
movq %r14, 0x8(%rbx)
xorl %r14d, %r14d
jmp 0x2944b7
movl $0x38, %edi
callq 0x1200f0
movq %rax, %r14
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2945e6
movq %r14, %rdi
addq $0x8, %rdi
movq 0x8(%r14), %rax
callq *0x10(%rax)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x38, %esi
movq %r14, %rdi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::const_optimise_mswitch<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr const_optimise_mswitch(Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            expression_node_ptr result = error_node();

            for (std::size_t i = 0; i < (arg_list.size() / 2); ++i)
            {
               expression_node_ptr condition  = arg_list[(2 * i)    ];
               expression_node_ptr consequent = arg_list[(2 * i) + 1];

               if (details::is_true(condition))
               {
                  result = consequent;
               }
            }

            if (0 == result)
            {
               const T zero = T(0);
               result       = node_allocator_->allocate<literal_node_t>(zero);
            }

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               expression_node_ptr& current_expr = arg_list[i];

               if (current_expr && (current_expr != result))
               {
                  details::free_node(*node_allocator_,current_expr);
               }
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
cmpq $0x9, %rcx
jae 0x2944fd
xorl %r14d, %r14d
jmp 0x294545
movl $0x8, %r15d
xorl %r14d, %r14d
xorl %r12d, %r12d
movq -0x8(%rax,%r15), %rdi
movq (%rax,%r15), %r13
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x11dcd8(%rip), %xmm0   # 0x3b21f8
cmovneq %r13, %r14
cmovpq %r13, %r14
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
shrq %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jb 0x294509
testq %r14, %r14
jne 0x294579
movl $0x28, %edi
callq 0x1200f0
movq %rax, %r14
movb $0x0, 0x10(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rax)
leaq 0x27cd1d(%rip), %rax    # 0x511288
movq %rax, (%r14)
leaq 0x27cd5b(%rip), %rax    # 0x5112d0
movq %rax, 0x8(%r14)
movq (%rbx), %r15
cmpq %r15, 0x8(%rbx)
je 0x2945d9
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15,%r12), %rdi
testq %rdi, %rdi
je 0x2945bf
cmpq %r14, %rdi
je 0x2945bf
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2945bf
addq %r12, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x2945b7
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2945bf
movq %r15, %rdi
callq 0x1f1690
incq %r13
movq (%rbx), %r15
movq 0x8(%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x294588
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multi_switch_node<double>::multi_switch_node<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit multi_switch_node(const Sequence<expression_ptr,Allocator>& arg_list)
         {
            if (0 != (arg_list.size() & 1))
               return;

            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid())
               {
                  construct_branch_pair(arg_list_[i], arg_list[i]);
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            assert(valid());
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
leaq 0x2ac7bb(%rip), %rcx    # 0x540dc0
movq %rcx, (%rdi)
leaq 0x2ac801(%rip), %rcx    # 0x540e10
movq %rcx, 0x8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rax, 0x30(%rdi)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
testb $0x8, %sil
jne 0x2946d4
movq %rdi, %rbx
addq $0x20, %rdi
sarq $0x3, %rsi
movq %rdi, (%rsp)
callq 0x294708
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x2946d4
movl $0x8, %r13d
xorl %ebp, %ebp
movq (%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x2946c6
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2946c6
movq (%r14), %rax
movq (%rax,%rbp,8), %r12
testq %r12, %r12
je 0x2946aa
movq (%rsp), %rax
movq (%rax), %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x294691
xorl %eax, %eax
jmp 0x2946a1
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, -0x8(%r15,%r13)
movb %al, (%r15,%r13)
incq %rbp
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x10, %r13
cmpq %rcx, %rbp
jb 0x294658
jmp 0x2946d4
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x2946d4
movq %rax, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2946e5
movq %rax, %r14
movq (%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x294700
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>, std::vector>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&) const
std::size_t compute_node_depth(const Sequence<nb_pair_t,Allocator>& branch_list) const
         {
            if (!depth_set)
            {
               for (std::size_t i = 0; i < branch_list.size(); ++i)
               {
                  if (branch_list[i].first)
                  {
                     depth = std::max(depth, compute_node_depth(branch_list[i].first));
                  }
               }

               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x294ad2
movq %rsi, %r14
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x294ace
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rax,%r15), %rdi
testq %rdi, %rdi
je 0x294ab4
cmpb $0x0, 0x8(%rbx)
jne 0x294ab4
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
addq $0x10, %r15
cmpq %rcx, %r12
jb 0x294a8f
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rax
addq $0x8, %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>::dependent_entity_collector::add_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::symbol_type)
inline void add_symbol(const std::string& symbol, const symbol_type st)
         {
            switch (st)
            {
               case e_st_variable       :
               case e_st_vector         :
               case e_st_string         :
               case e_st_local_variable :
               case e_st_local_vector   :
               case e_st_local_string   : if (collect_variables_)
                                             symbol_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               case e_st_function       : if (collect_functions_)
                                             symbol_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               default                  : return;
            }
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x8, %edx
ja 0x294b50
movl %edx, %ebp
movq %rdi, %rbx
movl $0x1d6, %eax            # imm = 0x1D6
btl %edx, %eax
jae 0x294b5b
cmpb $0x1, 0x8(%rbx)
jne 0x294b50
addq $0x10, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1eda34
movl %ebp, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x294bc0
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x294b50
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x5, %ebp
jne 0x294b50
cmpb $0x1, 0x9(%rbx)
jne 0x294b50
addq $0x10, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x1eda34
movl %ebp, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x294bc0
jmp 0x294b3a
jmp 0x294b9e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x294bb7
movq 0x10(%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: exprtk::details::expression_node<double>* exprtk::parser<double>::expression_generator<double>::varnode_optimise_varargfunc<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(exprtk::details::operator_type const&, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>&)
inline expression_node_ptr varnode_optimise_varargfunc(const details::operator_type& operation,
                                                                Sequence<expression_node_ptr,Allocator>& arg_list)
         {
            switch (operation)
            {
               #define case_stmt(op0, op1)                                                  \
               case op0 : return node_allocator_->                                          \
                             allocate<details::vararg_varnode<Type,op1<Type> > >(arg_list); \

               case_stmt(details::e_sum   , details::vararg_add_op  )
               case_stmt(details::e_prod  , details::vararg_mul_op  )
               case_stmt(details::e_avg   , details::vararg_avg_op  )
               case_stmt(details::e_min   , details::vararg_min_op  )
               case_stmt(details::e_max   , details::vararg_max_op  )
               case_stmt(details::e_mand  , details::vararg_mand_op )
               case_stmt(details::e_mor   , details::vararg_mor_op  )
               case_stmt(details::e_multi , details::vararg_multi_op)
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movl (%rsi), %eax
xorl %ebx, %ebx
cmpl $0x1b, %eax
jg 0x295197
addl $-0x9, %eax
cmpl $0x4, %eax
ja 0x29526f
leaq 0x11e56f(%rip), %rcx    # 0x3b36e0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x296d72
jmp 0x295264
cmpl $0x1c, %eax
je 0x2951c7
cmpl $0x1d, %eax
je 0x295218
cmpl $0x5a, %eax
jne 0x29526f
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x297928
jmp 0x295264
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x297286
jmp 0x295264
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x296840
jmp 0x295264
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x296aac
jmp 0x295264
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2975cc
jmp 0x295264
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x29643e
jmp 0x295264
movl $0x40, %edi
callq 0x1200f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x296ffa
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x295288
jmp 0x295288
jmp 0x295288
jmp 0x295288
jmp 0x295288
jmp 0x295288
jmp 0x295288
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::variable_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::variable_node<double>, double>(double&) const
inline expression_node<typename node_type::value_type>* allocate(T1& t1) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movl $0x30, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x1cb8cd(%rip), %rcx    # 0x50f370
movq %rcx, (%rax)
leaq 0x1cb91b(%rip), %rcx    # 0x50f3c8
movq %rcx, 0x8(%rax)
leaq 0x1cb938(%rip), %rcx    # 0x50f3f0
movq %rcx, 0x20(%rax)
movq %rbx, 0x28(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vararg_varnode<double, exprtk::details::vararg_add_op<double>>::vararg_varnode<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit vararg_varnode(const Sequence<expression_ptr,Allocator>& arg_list)
         : initialised_(false)
         {
            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid() && is_variable_node(arg_list[i]))
               {
                  variable_node<T>* var_node_ptr = static_cast<variable_node<T>*>(arg_list[i]);
                  arg_list_[i] = (&var_node_ptr->ref());
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            initialised_ = (arg_list.size() == arg_list_.size());
            assert(valid());
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x2aacd1(%rip), %rax    # 0x541130
movq %rax, (%rdi)
leaq 0x2aad0f(%rip), %rax    # 0x541178
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x29(%rdi)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %r15, %rdi
callq 0x296558
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
setne %bpl
je 0x296517
movq (%rax), %rdi
testq %rdi, %rdi
je 0x296503
movl $0x1, %r12d
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x296503
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x296503
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x296503
movq (%r14), %rax
movq -0x8(%rax,%r12,8), %rax
movq 0x28(%rax), %rax
movq (%r15), %rcx
movq %rax, -0x8(%rcx,%r12,8)
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r12
setb %bpl
jae 0x296517
movq (%rax,%r12,8), %rdi
incq %r12
testq %rdi, %rdi
jne 0x2964aa
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x296511
movq %rax, 0x28(%rbx)
testb $0x1, %bpl
jne 0x29652d
movq 0x8(%r14), %rax
subq (%r14), %rax
movq 0x28(%rbx), %rcx
subq 0x20(%rbx), %rcx
cmpq %rcx, %rax
sete 0x38(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x296538
movq %rax, %r14
movq (%r15), %rdi
testq %rdi, %rdi
je 0x29654f
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_vararg_node<double, exprtk::details::vararg_multi_op<double>>::value() const
inline T value() const exprtk_override
         {
            if (!arg_list_.empty())
            {
               VarArgFunction::process(arg_list_);
            }

            final_node_.first->value();

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x58(%rdi), %rax
cmpq 0x60(%rdi), %rax
je 0x297e9b
leaq 0x58(%rbx), %rdi
callq 0x29807c
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x11a363(%rip), %xmm0   # 0x3b2210
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vararg_node<double, exprtk::details::vararg_add_op<double>>::vararg_node<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
         : initialised_(false)
         {
            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid())
               {
                  construct_branch_pair(arg_list_[i],arg_list[i]);
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            initialised_ = (arg_list_.size() == arg_list.size());
            assert(valid());
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x2a9474(%rip), %rax    # 0x541748
movq %rax, (%rdi)
leaq 0x2a94ba(%rip), %rax    # 0x541798
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rbx)
movups %xmm0, 0x29(%rbx)
movq 0x8(%rsi), %rsi
subq (%r14), %rsi
sarq $0x3, %rsi
movq %rdi, (%rsp)
callq 0x294708
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
setne %r12b
je 0x2983ab
movq (%rax), %rdi
testq %rdi, %rdi
je 0x298397
movl $0x1, %r13d
xorl %ebp, %ebp
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x298397
movq (%r14), %rax
movq (%rax,%rbp), %r12
testq %r12, %r12
je 0x29836f
movq (%rsp), %rax
movq (%rax), %r15
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x298356
xorl %eax, %eax
jmp 0x298366
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, (%r15,%rbp,2)
movb %al, 0x8(%r15,%rbp,2)
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rcx, %r13
setb %r12b
jae 0x2983ab
movq 0x8(%rax,%rbp), %rdi
addq $0x8, %rbp
incq %r13
testq %rdi, %rdi
jne 0x298326
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x2983a5
movq %rax, 0x28(%rbx)
testb $0x1, %r12b
jne 0x2983c9
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
sarq $0x4, %rax
movq 0x8(%r14), %rcx
subq (%r14), %rcx
sarq $0x3, %rcx
cmpq %rcx, %rax
sete 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2983da
movq %rax, %r14
movq (%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x2983f5
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_uv_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [1])
inline expression_node_ptr synthesize_uv_expression(const details::operator_type& operation,
                                                             expression_node_ptr (&branch)[1])
         {
            T& v = static_cast<details::variable_node<T>*>(branch[0])->ref();

            switch (operation)
            {
               #define case_stmt(op0, op1)                                                         \
               case op0 : return node_allocator_->                                                 \
                             allocate<typename details::unary_variable_node<Type,op1<Type> > >(v); \

               unary_opr_switch_statements
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
movl (%rsi), %eax
addl $-0x22, %eax
cmpl $0x2e, %eax
ja 0x29df93
movabsq $0x7ef8ff9dffff, %rcx   # imm = 0x7EF8FF9DFFFF
btq %rax, %rcx
jae 0x29df93
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %rcx
movq 0x28(%rcx), %rbx
movl %eax, %eax
leaq 0x2db51b(%rip), %rcx    # 0x579478
movq (%rcx,%rax,8), %r14
leaq 0x2db688(%rip), %rcx    # 0x5795f0
movq (%rcx,%rax,8), %r15
movl $0x28, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r14, (%rax)
movq %r15, 0x8(%rax)
movq %rbx, 0x20(%rax)
popq %rbx
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::operator=(exprtk::details::vec_data_store<double> const&)
type& operator=(const type& vds)
         {
            if (this != &vds)
            {
               const std::size_t final_size = min_size(control_block_, vds.control_block_);

               vds.control_block_->size = final_size;
                   control_block_->size = final_size;

               if (control_block_->destruct || (0 == control_block_->data))
               {
                  control_block::destroy(control_block_);

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

            return (*this);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x29fafe
movq %rsi, %r14
movq (%rbx), %r15
movq (%rsi), %rax
movq 0x8(%r15), %rcx
movq 0x8(%rax), %rdx
cmpq %rcx, %rdx
movq %rcx, %rsi
cmovbq %rdx, %rsi
testq %rdx, %rdx
cmoveq %rcx, %rsi
testq %rcx, %rcx
cmoveq %rdx, %rsi
movq %rsi, 0x8(%rax)
movq %rsi, 0x8(%r15)
cmpb $0x0, 0x18(%r15)
jne 0x29fac4
cmpq $0x0, 0x10(%r15)
jne 0x29fafe
testq %r15, %r15
je 0x29faf5
movq (%r15), %rax
testq %rax, %rax
je 0x29faee
decq %rax
movq %rax, (%r15)
jne 0x29faee
movq %r15, %rdi
callq 0x2a02ec
movl $0x20, %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
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::~vec_data_store()
static inline void destroy(control_block*& cntrl_blck)
            {
               if (cntrl_blck)
               {
                  if (
                       (0 !=   cntrl_blck->ref_count) &&
                       (0 == --cntrl_blck->ref_count)
                     )
                  {
                     delete cntrl_blck;
                  }

                  cntrl_blck = 0;
               }
            }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
testq %r14, %r14
je 0x29fbbb
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x29fbb4
decq %rax
movq %rax, (%r14)
jne 0x29fbb4
movq %r14, %rdi
callq 0x2a02ec
movl $0x20, %esi
movq %r14, %rdi
callq 0x1200c0
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::memory_context_t<double> exprtk::details::make_memory_context<double>(exprtk::details::vector_holder<double>&, exprtk::details::vec_data_store<double>&)
inline memory_context_t<T> make_memory_context(vector_holder<T>& vec_holder,
                                                     vec_data_store<T>& vds)
      {
         memory_context_t<T> result_ctxt;

         result_ctxt.temp_  = (vec_holder.rebaseable()) ?
                              new vector_holder<T>(vec_holder,vds) :
                              new vector_holder<T>(vds) ;

         result_ctxt.temp_vec_node_ = new vector_node<T>(vds,result_ctxt.temp_);

         return result_ctxt;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movl %eax, %ebp
movl $0x48, %edi
callq 0x1200f0
movq %rax, %r14
movq (%rbx), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
testb %bpl, %bpl
je 0x29fc1a
leaq 0x2a3a41(%rip), %rdx    # 0x543640
movq %rdx, 0x8(%r14)
movq %rcx, 0x10(%r14)
movq %rax, 0x18(%r14)
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movq %rax, 0x20(%r14)
jmp 0x29fc2d
leaq 0x2a3a9f(%rip), %rdx    # 0x5436c0
movq %rdx, 0x8(%r14)
movq %rcx, 0x10(%r14)
movq %rax, 0x18(%r14)
movq %r14, %rax
addq $0x8, %rax
movq %rax, (%r14)
movl $0x38, %edi
callq 0x1200f0
movq %rax, %rdx
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x2a3ad9(%rip), %rax    # 0x543730
movq %rax, (%rdx)
leaq 0x2a3b47(%rip), %rax    # 0x5437a8
movq %rax, 0x8(%rdx)
leaq 0x2a3b64(%rip), %rax    # 0x5437d0
movq %rax, 0x20(%rdx)
movq %r14, 0x28(%rdx)
movq (%rbx), %rax
movq %rax, 0x30(%rdx)
incq (%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x48, %esi
movq %r14, %rdi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::~control_block()
~control_block()
            {
               if (data && destruct && (0 == ref_count))
               {
                  dump_ptr("~vec_data_store::control_block() data",data);
                  delete[] data;
                  data = reinterpret_cast<data_t>(0);
               }
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpq $0x0, 0x10(%rdi)
je 0x2a0357
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdi)
jne 0x2a0357
cmpq $0x0, (%rbx)
jne 0x2a0357
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x11dcc5(%rip), %rsi    # 0x3bdfde
leaq 0x11dce3(%rip), %rdx    # 0x3be003
leaq 0x8(%rsp), %rdi
callq 0x1eabb8
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2a0341
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x2a034f
callq 0x1201e0
movq $0x0, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1eabad
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_invalid_string_op(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            const bool b0_string = is_generally_string_node(branch[0]);
            const bool b1_string = is_generally_string_node(branch[1]);

            bool result = false;

            if (b0_string != b1_string)
               result = true;
            else if (!valid_string_operation(operation) && b0_string && b1_string)
               result = true;

            if (result)
            {
               parser_->set_synthesis_error("Invalid string operation");
            }

            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movabsq $0x388fc0000, %r13      # imm = 0x388FC0000
testq %rdi, %rdi
je 0x2b4480
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %r12b
cmpl $0x21, %eax
ja 0x2b447b
movl %eax, %ecx
btq %rcx, %r13
jb 0x2b4483
cmpl $0x7b, %eax
je 0x2b4483
xorl %r12d, %r12d
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2b44a6
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %cl
cmpl $0x21, %eax
ja 0x2b44a1
movl %eax, %edx
btq %rdx, %r13
jb 0x2b44a8
cmpl $0x7b, %eax
je 0x2b44a8
xorl %ecx, %ecx
movb $0x1, %bpl
cmpb %cl, %r12b
jne 0x2b44e2
movl (%r14), %edx
xorl %eax, %eax
cmpl $0x15, %edx
ja 0x2b44c4
movl $0x35c004, %esi         # imm = 0x35C004
btl %edx, %esi
jb 0x2b44da
addl $-0x51, %edx
cmpl $0xb, %edx
ja 0x2b4552
movl $0x9c3, %esi            # imm = 0x9C3
btl %edx, %esi
jae 0x2b4552
andb %al, %r12b
andb %r12b, %cl
movl %ecx, %ebp
testb %bpl, %bpl
je 0x2b4541
movq 0x68(%rbx), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x109be0(%rip), %rsi    # 0x3be0db
leaq 0x109bf1(%rip), %rdx    # 0x3be0f3
leaq 0x8(%rsp), %rdi
callq 0x1eabb8
cmpq $0x0, 0x518(%rbx)
jne 0x2b452a
addq $0x510, %rbx            # imm = 0x510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1205a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b4541
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movb $0x1, %al
jmp 0x2b44da
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x2b4570
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_invalid_assignment_op(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_assignment_operation(const details::operator_type& operation) const
         {
            return (
                     (details::e_addass == operation) ||
                     (details::e_subass == operation) ||
                     (details::e_mulass == operation) ||
                     (details::e_divass == operation) ||
                     (details::e_modass == operation)
                   ) &&
                   parser_->settings_.assignment_enabled(operation);
         }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl (%rsi), %eax
addl $-0x52, %eax
cmpl $0x4, %eax
ja 0x2b45eb
movq %rdx, %rbx
movl $0xd0, %eax
addq 0x68(%rdi), %rax
movq %rax, %rdi
callq 0x2c391c
testb %al, %al
je 0x2b45eb
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b45cc
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %r14b
cmpl $0x21, %eax
ja 0x2b45c7
movl %eax, %ecx
movabsq $0x388fc0000, %rdx      # imm = 0x388FC0000
btq %rcx, %rdx
jb 0x2b45cf
cmpl $0x7b, %eax
je 0x2b45cf
xorl %r14d, %r14d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b45f2
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x2b45f2
xorb $0x1, %r14b
jmp 0x2b46e5
xorl %ebp, %ebp
jmp 0x2b46e8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b460c
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
cmpl $0x2, %eax
je 0x2b46e8
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b4623
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b463a
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7e, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b4651
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7f, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b4666
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x80, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b467b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x81, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b4690
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x82, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b46a5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x84, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b46ba
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x83, %eax
je 0x2b46e5
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b46cf
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x85, %eax
je 0x2b46e5
movq (%rbx), %rdi
movb $0x1, %bpl
testq %rdi, %rdi
je 0x2b46e8
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
jne 0x2b46e8
movl %r14d, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_vector_eqineq_logic_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_vector_eqineq_logic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1]))
               return false;
            else
               return (
                        (details::e_lt    == operation) ||
                        (details::e_lte   == operation) ||
                        (details::e_gt    == operation) ||
                        (details::e_gte   == operation) ||
                        (details::e_eq    == operation) ||
                        (details::e_ne    == operation) ||
                        (details::e_equal == operation) ||
                        (details::e_and   == operation) ||
                        (details::e_nand  == operation) ||
                        (details::e_or    == operation) ||
                        (details::e_nor   == operation) ||
                        (details::e_xor   == operation) ||
                        (details::e_xnor  == operation)
                      );
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2b683a
movq (%rdi), %rax
callq *0x28(%rax)
addl $-0x7c, %eax
cmpl $0x18, %eax
ja 0x2b683a
movl $0x1f17801, %ecx        # imm = 0x1F17801
btl %eax, %ecx
jb 0x2b685f
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2b686f
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
addl $-0x7c, %ecx
cmpl $0x18, %ecx
ja 0x2b6871
movl $0x1f17801, %edx        # imm = 0x1F17801
btl %ecx, %edx
jae 0x2b6871
movl (%rbx), %ecx
cmpl $0x1b, %ecx
ja 0x2b686f
movl $0xff7c000, %eax        # imm = 0xFF7C000
shrl %cl, %eax
jmp 0x2b6871
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_vector_arithmetic_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_vector_arithmetic_operation(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (!is_ivector_node(branch[0]) && !is_ivector_node(branch[1]))
               return false;
            else
               return (
                        (details::e_add == operation) ||
                        (details::e_sub == operation) ||
                        (details::e_mul == operation) ||
                        (details::e_div == operation) ||
                        (details::e_pow == operation)
                      );
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2b72f0
movq (%rdi), %rax
callq *0x28(%rax)
addl $-0x7c, %eax
cmpl $0x18, %eax
ja 0x2b72f0
movl $0x1f17801, %ecx        # imm = 0x1F17801
btl %eax, %ecx
jb 0x2b7315
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x2b7322
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
addl $-0x7c, %ecx
cmpl $0x18, %ecx
ja 0x2b7324
movl $0x1f17801, %edx        # imm = 0x1F17801
btl %ecx, %edx
jae 0x2b7324
movl (%rbx), %ecx
cmpl $0x7, %ecx
ja 0x2b7322
movb $-0x44, %al
shrb %cl, %al
jmp 0x2b7324
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_constpow_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_constpow_operation(const details::operator_type& operation, expression_node_ptr(&branch)[2]) const
         {
            if (
                 !details::is_constant_node(branch[1]) ||
                  details::is_constant_node(branch[0]) ||
                  details::is_variable_node(branch[0]) ||
                  details::is_vector_node  (branch[0]) ||
                  details::is_generally_string_node(branch[0])
               )
               return false;

            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();

            return cardinal_pow_optimisable(operation, c);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x8(%rdx), %r15
testq %r15, %r15
je 0x2b8921
movq %rdx, %rbx
movq %rsi, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2b8874
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x2b8921
movq (%rbx), %r15
testq %r15, %r15
je 0x2b88a0
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2b8921
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
je 0x2b8921
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b88b3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b8921
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b88c6
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
je 0x2b8921
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b88f4
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x21, %ecx
ja 0x2b88ef
movl %ecx, %edx
movabsq $0x388fc0000, %rsi      # imm = 0x388FC0000
btq %rdx, %rsi
jb 0x2b8923
cmpl $0x7b, %ecx
je 0x2b8923
cmpl $0x7, (%r14)
jne 0x2b8921
movq 0x8(%rbx), %rax
movsd 0x20(%rax), %xmm0
movapd 0xf9b35(%rip), %xmm1    # 0x3b2440
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
movsd 0xf9955(%rip), %xmm2    # 0x3b2270
ucomisd %xmm1, %xmm2
jae 0x2b8929
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movsd 0xf96ef(%rip), %xmm1    # 0x3b2020
callq 0x120460
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
jmp 0x2b8923
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cardinal_pow_optimisation(exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr cardinal_pow_optimisation(expression_node_ptr (&branch)[2])
         {
            const Type c = static_cast<details::literal_node<Type>*>(branch[1])->value();
            const bool not_recipricol = (c >= T(0));
            const unsigned int p = static_cast<unsigned int>(details::numeric::to_int32(details::numeric::abs(c)));

            node_allocator_->free(branch[1]);

            if (0 == p)
            {
               details::free_all_nodes(*node_allocator_, branch);

               return node_allocator_->allocate_c<literal_node_t>(T(1));
            }
            else if (not_recipricol)
               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipow_node>(branch[0],p);
            else
               return cardinal_pow_optimisation_impl<expression_node_ptr,details::bipowinv_node>(branch[0],p);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
movsd 0x20(%rdi), %xmm1
movapd 0xf9ad6(%rip), %xmm0    # 0x3b2440
xorpd %xmm1, %xmm0
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
movl %eax, 0xc(%rsp)
testq %rdi, %rdi
je 0x2b8991
movq (%rdi), %rax
movapd %xmm1, 0x10(%rsp)
callq *0x8(%rax)
movapd 0x10(%rsp), %xmm1
movq $0x0, 0x8(%rbx)
cmpl $0x0, 0xc(%rsp)
je 0x2b89c3
xorpd %xmm0, %xmm0
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
ucomisd %xmm0, %xmm1
jae 0x2b8a3e
callq 0x30a450
jmp 0x2b8a43
xorl %r15d, %r15d
movq (%rbx,%r15), %rdi
testq %rdi, %rdi
je 0x2b89f9
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2b89f9
leaq (%rbx,%r15), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2b89f1
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2b89f9
movq %r14, %rdi
callq 0x1f1690
addq $0x8, %r15
cmpq $0x8, %r15
je 0x2b89c6
movl $0x28, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x258868(%rip), %rcx    # 0x511288
movq %rcx, (%rax)
leaq 0x2588a6(%rip), %rcx    # 0x5112d0
movq %rcx, 0x8(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x20(%rax)
jmp 0x2b8a43
callq 0x30a214
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop