LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rsi), %r15
movq 0x8(%rsi), %r12
movq %r12, %rax
subq %r15, %rax
cmpq $0x9, %rax
jb 0x274c86
movl $0x8, %r13d
xorl %r14d, %r14d
xorl %ebp, %ebp
movq -0x8(%r15,%r13), %rdi
movq (%r15,%r13), %r15
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x114597(%rip), %xmm0   # 0x3891f0
cmovneq %r15, %r14
cmovpq %r15, %r14
incq %rbp
movq (%rbx), %r15
movq 0x8(%rbx), %r12
movq %r12, %rax
subq %r15, %rax
sarq $0x3, %rax
shrq %rax
addq $0x10, %r13
cmpq %rax, %rbp
jb 0x274c42
testq %r14, %r14
jne 0x274cb5
movl $0x28, %edi
callq 0x11e0f0
movq %rax, %r14
movb $0x0, 0x10(%rax)
xorpd %xmm0, %xmm0
movupd %xmm0, 0x18(%rax)
leaq 0x263011(%rip), %rax    # 0x4d7cb8
movq %rax, (%r14)
leaq 0x26304f(%rip), %rax    # 0x4d7d00
movq %rax, 0x8(%r14)
cmpq %r15, %r12
je 0x274d11
xorl %r12d, %r12d
xorl %r13d, %r13d
movq (%r15,%r12), %rdi
testq %rdi, %rdi
je 0x274cf7
cmpq %r14, %rdi
je 0x274cf7
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x274cf7
addq %r12, %r15
movq (%r15), %rdi
testq %rdi, %rdi
je 0x274cef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x274cf7
movq %r15, %rdi
callq 0x1ea63e
incq %r13
movq (%rbx), %r15
movq 0x8(%rbx), %rax
subq %r15, %rax
sarq $0x3, %rax
addq $0x8, %r12
cmpq %rax, %r13
jb 0x274cc0
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: 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 0x2924bd(%rip), %rcx    # 0x507200
movq %rcx, (%rdi)
leaq 0x292503(%rip), %rcx    # 0x507250
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 0x274e15
movq %rdi, %rbx
addq $0x20, %rdi
sarq $0x3, %rsi
movq %rdi, (%rsp)
callq 0x274e4a
movq (%r14), %rax
cmpq %rax, 0x8(%r14)
je 0x274e15
movl $0x8, %r13d
xorl %ebp, %ebp
movq (%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x274e04
movq (%rdi), %rax
callq *0x30(%rax)
movq (%rsp), %rcx
movq (%rcx), %r15
testb %al, %al
je 0x274e0b
movq (%r14), %rax
movq (%rax,%rbp,8), %r12
testq %r12, %r12
je 0x274deb
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x274dcf
xorl %eax, %eax
jmp 0x274ddf
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, -0x8(%r15,%r13)
movb %al, (%r15,%r13)
movq (%r14), %rax
incq %rbp
movq 0x8(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x10, %r13
cmpq %rcx, %rbp
jb 0x274d96
jmp 0x274e15
movq (%rsp), %rax
movq (%rax), %r15
cmpq %r15, 0x28(%rbx)
je 0x274e15
movq %r15, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x274e26
movq %rax, %r14
movq (%rsp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0x274e41
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movb 0x8(%rdi), %cl
testb %cl, %cl
jne 0x275228
movq %rsi, %r14
movq (%rsi), %rdx
movq 0x8(%rsi), %rsi
cmpq %rdx, %rsi
je 0x275224
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rdx,%r15), %rdi
testq %rdi, %rdi
je 0x27520e
testb $0x1, %cl
je 0x2751ef
movq 0x10(%rbx), %rax
jmp 0x27520a
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
incq %rax
movb $0x1, 0x8(%rbx)
movq (%r14), %rdx
movq 0x8(%r14), %rsi
movb $0x1, %cl
movq %rax, 0x10(%rbx)
incq %r12
movq %rsi, %rax
subq %rdx, %rax
sarq $0x4, %rax
addq $0x10, %r15
cmpq %rax, %r12
jb 0x2751db
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_O3/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 0x2752a6
movl %edx, %ebp
movq %rdi, %rbx
movl $0x1d6, %eax            # imm = 0x1D6
btl %edx, %eax
jae 0x2752b1
cmpb $0x1, 0x8(%rbx)
jne 0x2752a6
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 0x1e7738
movl %ebp, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27531a
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2752a6
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x5, %ebp
jne 0x2752a6
cmpb $0x1, 0x9(%rbx)
jne 0x2752a6
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 0x1e7738
movl $0x5, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x27531a
jmp 0x275290
jmp 0x2752f8
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x275311
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: 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 0x2758e1
addl $-0x9, %eax
cmpl $0x4, %eax
ja 0x2759b9
leaq 0x114e7d(%rip), %rcx    # 0x38a738
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x277484
jmp 0x2759ae
cmpl $0x1c, %eax
je 0x275911
cmpl $0x1d, %eax
je 0x275962
cmpl $0x5a, %eax
jne 0x2759b9
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x277f8a
jmp 0x2759ae
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x277968
jmp 0x2759ae
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276f82
jmp 0x2759ae
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2771d6
jmp 0x2759ae
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x277c5e
jmp 0x2759ae
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x276b92
jmp 0x2759ae
movl $0x40, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x2776f4
leaq 0x8(%rbx), %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2759d2
jmp 0x2759d2
jmp 0x2759d2
jmp 0x2759d2
jmp 0x2759d2
jmp 0x2759d2
jmp 0x2759d2
movq %rax, %r14
movl $0x40, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::switch_n_node<double, exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_1>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::switch_n_node<double, exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_1>, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>>>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl $0x38, %edi
callq 0x11e0f0
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0x32151e
leaq 0x2112a4(%rip), %rax    # 0x531a20
movq %rax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x2112e6(%rip), %rax    # 0x531a70
movq %rax, 0x8(%rbx)
movq %rbx, %rsi
addq $0x20, %rsi
callq 0x2751b4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x2909bd(%rip), %rax    # 0x507570
movq %rax, (%rdi)
leaq 0x2909fb(%rip), %rax    # 0x5075b8
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x29(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x276c94
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x276c56
xorl %r12d, %r12d
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x276c46
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x276c46
movq (%r15), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x276c46
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x276c46
movq (%r15), %rax
movq (%rax,%r12,8), %rax
movq 0x28(%rax), %rax
movq (%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movq (%r15), %rax
movq 0x8(%r15), %rcx
subq %rax, %rcx
movq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rdx, %r12
jb 0x276bef
jmp 0x276c58
movq 0x20(%rbx), %rax
cmpq %rax, 0x28(%rbx)
je 0x276c67
movq %rax, 0x28(%rbx)
jmp 0x276c67
xorl %ecx, %ecx
movq 0x28(%rbx), %rax
subq 0x20(%rbx), %rax
cmpq %rax, %rcx
sete 0x38(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x276c75
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x276c8c
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq %r15, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x278499
leaq 0x58(%rbx), %rdi
callq 0x27867c
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x110d5d(%rip), %xmm0   # 0x389208
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15
movb $0x0, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
leaq 0x28f253(%rip), %rax    # 0x507b20
movq %rax, (%rdi)
leaq 0x28f299(%rip), %rax    # 0x507b70
movq %rax, 0x8(%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movq %rdi, (%rsp)
movups %xmm0, 0x29(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
sarq $0x3, %rsi
movq %r14, %rdi
callq 0x274e4a
movq (%r15), %rax
cmpq %rax, 0x8(%r15)
je 0x27897c
movl $0x8, %r13d
xorl %ebp, %ebp
movq (%rax,%rbp,8), %rdi
testq %rdi, %rdi
je 0x278997
movq (%rdi), %rax
callq *0x30(%rax)
movq (%r14), %rbx
testb %al, %al
je 0x27899a
movq (%r15), %rax
movq (%rax,%rbp,8), %r12
testq %r12, %r12
je 0x278963
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x278947
xorl %eax, %eax
jmp 0x278957
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, -0x8(%rbx,%r13)
movb %al, (%rbx,%r13)
movq (%r15), %rax
incq %rbp
movq 0x8(%r15), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
addq $0x10, %r13
cmpq %rcx, %rbp
jb 0x278912
jmp 0x27897e
xorl %ecx, %ecx
movq (%rsp), %rdx
movq 0x28(%rdx), %rax
subq 0x20(%rdx), %rax
sarq $0x4, %rax
cmpq %rcx, %rax
sete 0x38(%rdx)
jmp 0x2789a8
movq (%r14), %rbx
movq (%rsp), %rax
cmpq %rbx, 0x28(%rax)
je 0x2789a8
movq %rbx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2789b9
movq %rax, %r15
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2789d4
movq (%rsp), %rax
movq 0x30(%rax), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq %r15, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27e159
movabsq $0x7ef8ff9dffff, %rcx   # imm = 0x7EF8FF9DFFFF
btq %rax, %rcx
jae 0x27e159
pushq %r15
pushq %r14
pushq %rbx
movq (%rdx), %rcx
movq 0x28(%rcx), %rbx
movl %eax, %eax
leaq 0x2c1355(%rip), %rcx    # 0x53f478
movq (%rcx,%rax,8), %r14
leaq 0x2c14c2(%rip), %rcx    # 0x53f5f0
movq (%rcx,%rax,8), %r15
movl $0x28, %edi
callq 0x11e0f0
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_O3/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 0x27fda1
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 0x27fd6c
cmpq $0x0, 0x10(%r15)
jne 0x27fda1
movq (%r15), %rax
testq %rax, %rax
je 0x27fd91
decq %rax
movq %rax, (%r15)
jne 0x27fd91
movq %r15, %rdi
callq 0x2804ac
movl $0x20, %esi
movq %r15, %rdi
callq 0x11e0c0
movq $0x0, (%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
incq (%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: 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 0x27fe5d
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x27fe56
decq %rax
movq %rax, (%r14)
jne 0x27fe56
movq %r14, %rdi
callq 0x2804ac
movl $0x20, %esi
movq %r14, %rdi
callq 0x11e0c0
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x280517
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdi)
jne 0x280517
cmpq $0x0, (%rbx)
jne 0x280517
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x114b2f(%rip), %rsi    # 0x395008
leaq 0x114b4d(%rip), %rdx    # 0x39502d
leaq 0x8(%rsp), %rdi
callq 0x1e4740
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x280501
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x28050f
callq 0x11e1e0
movq $0x0, 0x10(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x1e4735
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movabsq $0x388fc0000, %r12      # imm = 0x388FC0000
testq %rdi, %rdi
je 0x296988
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
cmpl $0x21, %eax
ja 0x296983
movl %eax, %ecx
btq %rcx, %r12
jb 0x29698a
cmpl $0x7b, %eax
je 0x29698a
xorl %ebp, %ebp
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x2969b4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x21, %eax
ja 0x2969af
movl %eax, %ecx
btq %rcx, %r12
jae 0x2969af
movb $0x1, %cl
testb %bpl, %bpl
je 0x2969b9
jmp 0x296a14
cmpl $0x7b, %eax
je 0x2969a6
testb %bpl, %bpl
je 0x296a12
movq 0x68(%rbx), %rbx
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0xfe738(%rip), %rsi     # 0x395105
leaq 0xfe749(%rip), %rdx     # 0x39511d
movq %rsp, %rdi
callq 0x1e4740
cmpq $0x0, 0x518(%rbx)
jne 0x2969f8
addq $0x510, %rbx            # imm = 0x510
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x11e5a0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x296a0e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movb $0x1, %al
jmp 0x296a3a
xorl %ecx, %ecx
movl (%r14), %edx
xorl %eax, %eax
cmpl $0x15, %edx
ja 0x296a28
movl $0x35c004, %esi         # imm = 0x35C004
btl %edx, %esi
jb 0x296a3a
addl $-0x51, %edx
cmpl $0xb, %edx
ja 0x296a47
movl $0x9c3, %esi            # imm = 0x9C3
btl %edx, %esi
jae 0x296a47
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
andb %cl, %bpl
cmpb $0x1, %bpl
je 0x2969b9
xorl %eax, %eax
jmp 0x296a3a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x296a71
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: 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 0x296aed
movq %rdx, %r14
movl $0xd0, %eax
addq 0x68(%rdi), %rax
movq %rax, %rdi
callq 0x2a6776
testb %al, %al
je 0x296aed
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x296ace
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
cmpl $0x21, %eax
ja 0x296ac9
movl %eax, %ecx
movabsq $0x388fc0000, %rdx      # imm = 0x388FC0000
btq %rcx, %rdx
jb 0x296ad0
cmpl $0x7b, %eax
je 0x296ad0
xorl %ebp, %ebp
movq (%r14), %rdi
movb $0x1, %bl
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x296af6
xorb $0x1, %bpl
movl %ebp, %ebx
jmp 0x296aef
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x296aef
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7e, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7f, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x80, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x81, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x82, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x84, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x83, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x85, %eax
je 0x296ae9
movq (%r14), %rdi
testq %rdi, %rdi
je 0x296aef
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
je 0x296ae9
jmp 0x296aef
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2992fa
movq (%rdi), %rax
callq *0x28(%rax)
addl $-0x7c, %eax
cmpl $0x18, %eax
ja 0x2992fa
movl $0x1f17801, %ecx        # imm = 0x1F17801
btl %eax, %ecx
jb 0x29931f
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x29932f
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
addl $-0x7c, %ecx
cmpl $0x18, %ecx
ja 0x299331
movl $0x1f17801, %edx        # imm = 0x1F17801
btl %ecx, %edx
jae 0x299331
movl (%rbx), %ecx
cmpl $0x1b, %ecx
ja 0x29932f
movl $0xff7c000, %eax        # imm = 0xFF7C000
shrl %cl, %eax
jmp 0x299331
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29a1b2
movq (%rdi), %rax
callq *0x28(%rax)
addl $-0x7c, %eax
cmpl $0x18, %eax
ja 0x29a1b2
movl $0x1f17801, %ecx        # imm = 0x1F17801
btl %eax, %ecx
jb 0x29a1d7
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x29a1e4
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
addl $-0x7c, %ecx
cmpl $0x18, %ecx
ja 0x29a1e6
movl $0x1f17801, %edx        # imm = 0x1F17801
btl %ecx, %edx
jae 0x29a1e6
movl (%rbx), %ecx
cmpl $0x7, %ecx
ja 0x29a1e4
movb $-0x44, %al
shrb %cl, %al
jmp 0x29a1e6
xorl %eax, %eax
andb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x29bafd
movq %rdx, %rbx
movq %rsi, %r14
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29ba50
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x29bafd
movq (%rbx), %r15
testq %r15, %r15
je 0x29bad0
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29bafd
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
je 0x29bafd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29bad0
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29bafd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29bad0
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
je 0x29bafd
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29bad0
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
xorl %eax, %eax
cmpl $0x21, %ecx
ja 0x29bacb
movl %ecx, %edx
movabsq $0x388fc0000, %rsi      # imm = 0x388FC0000
btq %rdx, %rsi
jb 0x29baff
cmpl $0x7b, %ecx
je 0x29baff
cmpl $0x7, (%r14)
jne 0x29bafd
movq 0x8(%rbx), %rax
movsd 0x20(%rax), %xmm0
movapd 0xed949(%rip), %xmm1    # 0x389430
xorpd %xmm0, %xmm1
maxsd %xmm0, %xmm1
movsd 0xed771(%rip), %xmm2    # 0x389268
ucomisd %xmm1, %xmm2
jae 0x29bb05
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movsd 0xed513(%rip), %xmm1    # 0x389020
callq 0x11e460
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %rax
andl $0x1, %eax
jmp 0x29baff
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rdi
movsd 0x20(%rdi), %xmm1
movapd 0xed8eb(%rip), %xmm0    # 0x389430
xorpd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %ebp
movl %ebp, 0xc(%rsp)
movq (%rdi), %rax
callq *0x8(%rax)
movq $0x0, 0x8(%rbx)
testl %ebp, %ebp
je 0x29bb96
xorpd %xmm0, %xmm0
movapd 0x10(%rsp), %xmm1
leaq 0xc(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
ucomisd %xmm0, %xmm1
jae 0x29bc1b
callq 0x2eee92
jmp 0x29bc20
movb $0x1, %bpl
xorl %r14d, %r14d
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x29bbcf
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x29bbcf
leaq (%rbx,%r14,8), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x29bbc7
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x29bbcf
movq %r14, %rdi
callq 0x1ea63e
movl $0x1, %r14d
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x29bb9c
movl $0x28, %edi
callq 0x11e0f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
leaq 0x23c0bb(%rip), %rcx    # 0x4d7cb8
movq %rcx, (%rax)
leaq 0x23c0f9(%rip), %rcx    # 0x4d7d00
movq %rcx, 0x8(%rax)
movabsq $0x3ff0000000000000, %rcx # imm = 0x3FF0000000000000
movq %rcx, 0x20(%rax)
jmp 0x29bc20
callq 0x2eec56
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2], exprtk::details::expression_node<double>*&)
inline bool synthesize_expression(const details::operator_type& operation,
                                           expression_node_ptr (&branch)[2],
                                           expression_node_ptr& result)
         {
            result = error_node();

            if (!operation_optimisable(operation))
               return false;

            const std::string node_id = branch_to_id(branch);

            const typename synthesize_map_t::iterator itr = synthesize_map_.find(node_id);

            if (synthesize_map_.end() != itr)
            {
               result = itr->second((*this), operation, branch);

               return true;
            }
            else
               return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq $0x0, (%rcx)
movl (%rsi), %eax
xorl %ebp, %ebp
cmpl $0x1b, %eax
ja 0x29bcb3
movq %rcx, %rbx
movl $0xff5c0fc, %ecx        # imm = 0xFF5C0FC
btl %eax, %ecx
jae 0x29bcb3
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2fbd22
leaq 0x10(%r12), %rdi
movq %r13, %rsi
callq 0x2fc7fe
leaq 0x18(%r12), %rcx
cmpq %rax, %rcx
setne %bpl
je 0x29bc98
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x40(%rax)
movq %rax, (%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29bcb3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x29bce2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cocob_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool cocob_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (
                 (details::e_add == operation) ||
                 (details::e_sub == operation) ||
                 (details::e_mul == operation) ||
                 (details::e_div == operation)
               )
            {
               return (details::is_constant_node(branch[0]) && details::is_cob_node(branch[1])) ||
                      (details::is_constant_node(branch[1]) && details::is_cob_node(branch[0])) ;
            }
            else
               return false;
         }

// Assembly:
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x29bd95
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r14
testq %r14, %r14
je 0x29bd4b
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29bd23
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x29bd4b
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29bd4b
leaq 0x23a3bd(%rip), %rsi    # 0x4d60f0
leaq 0x2837ce(%rip), %rdx    # 0x51f508
xorl %ecx, %ecx
callq 0x11e4f0
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x29bd9a
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x29bd98
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29bd70
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x29bd98
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29bd98
leaq 0x23a371(%rip), %rsi    # 0x4d60f0
leaq 0x283782(%rip), %rdx    # 0x51f508
xorl %ecx, %ecx
callq 0x11e4f0
testq %rax, %rax
setne %al
jmp 0x29bd9a
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::coboc_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool coboc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (
                 (details::e_add == operation) ||
                 (details::e_sub == operation) ||
                 (details::e_mul == operation) ||
                 (details::e_div == operation)
               )
            {
               return (details::is_constant_node(branch[0]) && details::is_boc_node(branch[1])) ||
                      (details::is_constant_node(branch[1]) && details::is_boc_node(branch[0])) ;
            }
            else
               return false;
         }

// Assembly:
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x29c4d7
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r14
testq %r14, %r14
je 0x29c48d
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29c465
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x29c48d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x29c48d
leaq 0x239c7b(%rip), %rsi    # 0x4d60f0
leaq 0x283364(%rip), %rdx    # 0x51f7e0
xorl %ecx, %ecx
callq 0x11e4f0
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x29c4dc
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x29c4da
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29c4b2
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x29c4da
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x29c4da
leaq 0x239c2f(%rip), %rsi    # 0x4d60f0
leaq 0x283318(%rip), %rdx    # 0x51f7e0
xorl %ecx, %ecx
callq 0x11e4f0
testq %rax, %rax
setne %al
jmp 0x29c4dc
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cob_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool operation_optimisable(const details::operator_type& operation) const
         {
            return (details::e_add  == operation) ||
                   (details::e_sub  == operation) ||
                   (details::e_mul  == operation) ||
                   (details::e_div  == operation) ||
                   (details::e_mod  == operation) ||
                   (details::e_pow  == operation) ||
                   (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_and  == operation) ||
                   (details::e_nand == operation) ||
                   (details::e_or   == operation) ||
                   (details::e_nor  == operation) ||
                   (details::e_xor  == operation) ||
                   (details::e_xnor == operation) ;
         }

// Assembly:
movl (%rsi), %ecx
xorl %eax, %eax
cmpl $0x1b, %ecx
ja 0x29d7c9
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0xff5c0fc, %edx        # imm = 0xFF5C0FC
btl %ecx, %edx
jae 0x29d7c2
movq (%rbx), %r14
testq %r14, %r14
je 0x29d7ab
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x29d794
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x29d7ab
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x29d7af
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x29d7b3
xorl %eax, %eax
jmp 0x29d7c2
movb $0x1, %al
jmp 0x29d7c2
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<2ul>(std::pair<exprtk::details::expression_node<double>*, bool> const (&) [2ul]) const
std::size_t compute_node_depth(const nb_pair_t (&branch)[N]) const
         {
            if (!depth_set)
            {
               depth = 0;

               for (std::size_t i = 0; i < N; ++i)
               {
                  if (branch[i].first)
                  {
                     depth = std::max(depth,branch[i].first->node_depth());
                  }
               }

               depth += 1;
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x2a427d
movq 0x10(%rbx), %rax
jmp 0x2a42d5
movq %rsi, %r14
movq $0x0, 0x10(%rbx)
movb $0x1, %bpl
xorl %eax, %eax
xorl %ecx, %ecx
shlq $0x4, %rcx
movq (%r14,%rcx), %rdi
testq %rdi, %rdi
je 0x2a42ba
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
ja 0x2a42b6
movq %rcx, %rax
movq %rax, 0x10(%rbx)
movl $0x1, %ecx
testb $0x1, %bpl
movl $0x0, %ebp
jne 0x2a428f
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq