LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_min_op<double>::process<std::pair<exprtk::details::expression_node<double>*, bool>, 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&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return T(0);
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default :
                         {
                            T result = T(value(arg_list[0]));

                            for (std::size_t i = 1; i < arg_list.size(); ++i)
                            {
                               const T v = value(arg_list[i]);

                               if (v < result)
                                  result = v;
                            }

                            return result;
                         }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq $0x5, %rcx
ja 0x20c7a6
leaq 0xc36a7(%rip), %rdx     # 0x2cfde0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
xorpd %xmm0, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20c870
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20c7ee
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20c822
movq (%rax), %rdi
movq (%rdi), %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmpq *0x18(%rax)
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x20c8da
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
pushq $0x1
popq %r14
pushq $0x10
popq %r15
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r14
jae 0x20c746
movq (%rax,%r15), %rdi
movq (%rdi), %rax
movsd %xmm0, 0x8(%rsp)
callq *0x18(%rax)
minsd 0x8(%rsp), %xmm0
incq %r14
addq $0x10, %r15
jmp 0x20c7b7
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_min_op<double>::process_5<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_5(const Sequence& arg_list)
         {
            return std::min<T>(
                   std::min<T>(std::min<T>(value(arg_list[0]), value(arg_list[1])),
                               std::min<T>(value(arg_list[2]), value(arg_list[3]))),
                               value(arg_list[4]));
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
minsd 0x10(%rsp), %xmm0
movsd 0x18(%rsp), %xmm1
minsd 0x8(%rsp), %xmm1
minsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
minsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_max_op<double>::process_5<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_5(const Sequence& arg_list)
         {
            return std::max<T>(
                   std::max<T>(std::max<T>(value(arg_list[0]), value(arg_list[1])),
                               std::max<T>(value(arg_list[2]), value(arg_list[3]))),
                               value(arg_list[4]));
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x18(%rsp)
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x10(%rsp)
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0x18(%rsp), %xmm1
maxsd 0x8(%rsp), %xmm1
maxsd 0x10(%rsp), %xmm0
maxsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movq (%rbx), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
maxsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process<std::pair<exprtk::details::expression_node<double>*, bool>, 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&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default :
                         {
                            for (std::size_t i = 0; i < arg_list.size(); ++i)
                            {
                               if (std::equal_to<T>()(T(0), value(arg_list[i])))
                                  return T(0);
                            }

                            return T(1);
                         }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rax
subq (%rdi), %rax
sarq $0x4, %rax
decq %rax
cmpq $0x4, %rax
ja 0x20ceb3
leaq 0xc2fa7(%rip), %rcx     # 0x2cfe10
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20cefe
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20d046
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20cf66
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20cfc8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x20cf22
pushq $-0x1
popq %r14
xorl %r15d, %r15d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
incq %r14
cmpq %rcx, %r14
jae 0x20cef0
movq (%rax,%r15), %rdi
addq $0x10, %r15
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20ceba
jp 0x20ceba
jmp 0x20cef8
movsd 0xc12c8(%rip), %xmm0    # 0x2ce1c0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_2<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_2(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1]))
                   ) ? T(1) : T(0);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20cf42
jnp 0x20cf64
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0xc1260(%rip), %xmm0    # 0x2ce1c0
andpd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_3<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_3(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[2]))
                   ) ? T(1) : T(0);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20cf86
jnp 0x20cfc5
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20cfa3
jnp 0x20cfc5
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0xc11ff(%rip), %xmm0    # 0x2ce1c0
andpd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_4<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_4(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[2])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[3]))
                   ) ? T(1) : T(0);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20cfe8
jnp 0x20d044
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20d005
jnp 0x20d044
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20d022
jnp 0x20d044
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0xc1180(%rip), %xmm0    # 0x2ce1c0
andpd %xmm1, %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_5<std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>>>(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process_5(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[2])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[3])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[4]))
                   ) ? T(1) : T(0);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20d066
jnp 0x20d0df
movq (%rbx), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20d083
jnp 0x20d0df
movq (%rbx), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20d0a0
jnp 0x20d0df
movq (%rbx), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x20d0bd
jnp 0x20d0df
movq (%rbx), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0xc10e5(%rip), %xmm0    # 0x2ce1c0
andpd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::operator()(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [1])
inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr (&branch)[1])
         {
            if (0 == branch[0])
            {
               return error_node();
            }
            else if (details::is_null_node(branch[0]))
            {
               return branch[0];
            }
            else if (details::is_break_node(branch[0]))
            {
               return error_node();
            }
            else if (details::is_continue_node(branch[0]))
            {
               return error_node();
            }
            else if (details::is_constant_node(branch[0]))
            {
               return synthesize_expression<unary_node_t,1>(operation,branch);
            }
            else if (unary_optimisable(operation) && details::is_variable_node(branch[0]))
            {
               return synthesize_uv_expression(operation,branch);
            }
            else if (unary_optimisable(operation) && details::is_ivector_node(branch[0]))
            {
               return synthesize_uvec_expression(operation,branch);
            }
            else
               return synthesize_unary_expression(operation,branch);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x20dc7d
movq %rdx, %rbx
movq %rsi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movq (%rbx), %rax
cmpl $0x1, %ecx
je 0x20dc7f
testq %rax, %rax
je 0x20dc8b
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
cmpl $0x95, %eax
je 0x20dc7d
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20dc8b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x96, %eax
jne 0x20dcf6
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x208267
testb %al, %al
je 0x20dcaf
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20e936
movl (%r14), %eax
leal -0x22(%rax), %ecx
movabsq $0x7ef8ff9dffff, %r12   # imm = 0x7EF8FF9DFFFF
cmpl $0x2e, %ecx
ja 0x20dcfe
btq %rcx, %r12
jae 0x20dcfe
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x20dcfe
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x20dcfb
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20eb02
movq (%rbx), %rdi
jmp 0x20dc8d
movl (%r14), %eax
addl $-0x22, %eax
cmpl $0x2e, %eax
ja 0x20dd31
btq %rax, %r12
jae 0x20dd31
movq (%rbx), %rdi
callq 0x208d51
testb %al, %al
je 0x20dd31
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20ec92
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x20ee1c
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::swap_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::swap_node<double>, exprtk::details::variable_node<double>*, exprtk::details::variable_node<double>*>(exprtk::details::variable_node<double>* const&, exprtk::details::variable_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
pushq $0x30
popq %rdi
callq 0x118100
movq (%r14), %rcx
movq (%rbx), %rdx
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x259f92(%rip), %rsi    # 0x487a48
movq %rsi, (%rax)
leaq 0x259fd0(%rip), %rsi    # 0x487a90
movq %rsi, 0x8(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2112bf
movq %rsi, %r14
movq (%rbx), %rax
movq (%rsi), %rcx
movq 0x8(%rax), %rdx
movq 0x8(%rcx), %rsi
cmpq %rdx, %rsi
movq %rdx, %rdi
cmovbq %rsi, %rdi
testq %rsi, %rsi
cmoveq %rdx, %rdi
testq %rdx, %rdx
cmoveq %rsi, %rdi
movq %rdi, 0x8(%rcx)
movq %rdi, 0x8(%rax)
cmpb $0x0, 0x18(%rax)
jne 0x2112ae
cmpq $0x0, 0x10(%rax)
jne 0x2112bf
movq %rbx, %rdi
callq 0x211a7c
movq (%r14), %rax
movq %rax, (%rbx)
incq (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x48
popq %rdi
callq 0x118100
movq %rax, %r14
testb %bpl, %bpl
je 0x211326
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x211b24
jmp 0x21134e
movq %r14, %rax
addq $0x8, %rax
movq (%rbx), %rcx
movq 0x8(%rcx), %rdx
movq 0x10(%rcx), %rcx
leaq 0x271661(%rip), %rsi    # 0x4829a0
movq %rsi, 0x8(%r14)
movq %rcx, 0x10(%r14)
movq %rdx, 0x18(%r14)
movq %rax, (%r14)
pushq $0x38
popq %rdi
callq 0x118100
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x211b66
movq %r14, %rax
movq %r15, %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r14, %rdi
jmp 0x21138c
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x1180d0
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::create(unsigned long const&, double*, bool)
static inline control_block* create(const std::size_t& dsize, data_t data_ptr = data_t(0), bool dstrct = false)
            {
               if (dsize)
               {
                  if (0 == data_ptr)
                     return (new control_block(dsize));
                  else
                     return (new control_block(dsize, data_ptr, dstrct));
               }
               else
                  return (new control_block);
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x211977
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r15
pushq $0x20
popq %rdi
callq 0x118100
movq %rax, %rbx
testq %r14, %r14
je 0x211996
movq $0x1, (%rbx)
movq %r12, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movb %bpl, 0x18(%rbx)
jmp 0x2119a1
pushq $0x20
popq %rdi
callq 0x118100
movq %rax, %rbx
movq $0x1, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movb $0x1, 0x18(%rax)
jmp 0x2119a1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2119c4
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::create_data()
inline void create_data()
            {
               destruct = true;
               data     = new T[size];
               std::fill_n(data, size, T(0));
               dump_ptr("control_block::create_data() - data", data, size);
            }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb $0x1, 0x18(%rdi)
movq 0x8(%rdi), %r14
movq %r14, %rax
shrq $0x3d, %rax
leaq (,%r14,8), %rcx
xorl %edi, %edi
negq %rax
sbbq %rdi, %rdi
orq %rcx, %rdi
callq 0x118240
movq %rax, 0x10(%rbx)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
movq %rax, %rdi
movq %r14, %rsi
callq 0x211a52
leaq 0xc8cbe(%rip), %rsi     # 0x2da6ee
leaq 0x8(%rsp), %rbx
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rdi
callq 0x118648
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::destroy(exprtk::details::vec_data_store<double>::control_block*&)
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 0x211ab2
movq %rdi, %rbx
movq (%r14), %rax
testq %rax, %rax
je 0x211aae
decq %rax
movq %rax, (%r14)
jne 0x211aae
movq %r14, %rdi
callq 0x211aba
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x1180d0
andq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x30, %rsp
cmpq $0x0, 0x10(%rdi)
je 0x211b08
movq %rdi, %rbx
cmpb $0x1, 0x18(%rdi)
jne 0x211b08
cmpq $0x0, (%rbx)
jne 0x211b08
leaq 0xc8c36(%rip), %rsi     # 0x2da712
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x127016
leaq 0x10(%rsp), %rdi
callq 0x118648
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x211b03
callq 0x1181d0
andq $0x0, 0x10(%rbx)
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rdi
callq 0x193e66
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x20b691
movl %eax, %ebp
movq 0x8(%r15), %rdi
callq 0x20b691
cmpb %al, %bpl
jne 0x224963
movl %eax, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x229d58
xorb $0x1, %al
andb %al, %bpl
andb %bpl, %r15b
cmpb $0x1, %r15b
jne 0x224999
movq 0x68(%rbx), %rbx
leaq 0xb5ea1(%rip), %rsi     # 0x2da80f
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x127016
movq %rbx, %rdi
movq %r14, %rsi
callq 0x229d82
leaq 0x8(%rsp), %rdi
callq 0x118648
movb $0x1, %al
jmp 0x22499b
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_invalid_break_continue_op(exprtk::details::expression_node<double>* (&) [2]) const
inline bool is_invalid_break_continue_op(expression_node_ptr (&branch)[2]) const
         {
            return (
                     details::is_break_node   (branch[0]) ||
                     details::is_break_node   (branch[1]) ||
                     details::is_continue_node(branch[0]) ||
                     details::is_continue_node(branch[1])
                   );
         }

// Assembly:
pushq %rbx
movq %rsi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x224b2a
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x95, %ecx
je 0x224b7a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x224b45
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x95, %ecx
je 0x224b7a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x224b5f
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movb $0x1, %al
cmpl $0x96, %ecx
je 0x224b7a
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x224b78
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x96, %eax
sete %al
jmp 0x224b7a
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdx), %rdi
callq 0x208267
testb %al, %al
je 0x227d1d
movq (%r15), %rdi
callq 0x208267
testb %al, %al
jne 0x227d1d
movq (%r15), %rdi
testq %rdi, %rdi
je 0x227d12
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x227d1d
movq (%r15), %rdi
testq %rdi, %rdi
je 0x227d12
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
je 0x227d1d
movq (%r15), %rdi
jmp 0x227d14
xorl %edi, %edi
callq 0x20b691
testb %al, %al
je 0x227d29
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq 0x8(%r15), %rax
movsd 0x20(%rax), %xmm0
leaq 0x8(%rsp), %rdx
movsd %xmm0, (%rdx)
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ae42a
jmp 0x227d1f
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rsi), %rdi
movsd 0x20(%rdi), %xmm1
movapd 0xa6419(%rip), %xmm0    # 0x2ce180
xorpd %xmm1, %xmm0
movapd %xmm1, 0x10(%rsp)
maxsd %xmm1, %xmm0
cvttsd2si %xmm0, %ebp
movl %ebp, 0xc(%rsp)
movq (%rdi), %rax
callq *0x8(%rax)
andq $0x0, 0x8(%r14)
testl %ebp, %ebp
je 0x227dae
xorpd %xmm0, %xmm0
movapd 0x10(%rsp), %xmm1
leaq 0xc(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
ucomisd %xmm0, %xmm1
jae 0x227dd7
callq 0x2658c6
jmp 0x227ddc
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x22bbb4
movq 0x8(%rbx), %rdi
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
callq 0x1ae9f6
jmp 0x227ddc
callq 0x26568a
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
andq $0x0, (%rcx)
movl (%rsi), %eax
xorl %ebp, %ebp
cmpl $0x1b, %eax
ja 0x227e5b
movq %rcx, %rbx
movl $0xff5c0fc, %ecx        # imm = 0xFF5C0FC
btl %eax, %ecx
jae 0x227e5b
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x26ca36
leaq 0x10(%r12), %rdi
movq %r13, %rsi
callq 0x26d28a
leaq 0x18(%r12), %rcx
cmpq %rax, %rcx
setne %bpl
je 0x227e51
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq *0x40(%rax)
movq %rax, (%rbx)
leaq 0x8(%rsp), %rdi
callq 0x118648
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::vob_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 0x2289c8
pushq %rbx
movq %rdx, %rbx
movl $0xff5c0fc, %edx        # imm = 0xFF5C0FC
btl %ecx, %edx
jae 0x2289c7
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2289c5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x2289c5
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2289c9
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
setne %al
jmp 0x2289c7
xorl %eax, %eax
popq %rbx
retq
movb $0x1, %al
jmp 0x2289c7
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::interval_container_t<void const*, exprtk::parser<double>::halfopen_range_policy<void const*>>::in_interval(void const*, std::pair<void const*, void const*>&) const
bool in_interval(const interval_point_t point, interval_t& interval) const
         {
            interval_map_citr_t itr = RangePolicy::end_inclusive() ?
                                      interval_map_.lower_bound(point):
                                      interval_map_.upper_bound(point);

            for (; itr != interval_map_.end(); ++itr)
            {
               const interval_point_t& begin = itr->second.first;
               const interval_point_t& end   = itr->second.second;

               if (RangePolicy::is_within(point, begin, end))
               {
                  interval = interval_t(begin,end);
                  return true;
               }
               else if (RangePolicy::is_greater(point, end))
               {
                  break;
               }
            }

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %rsi, (%r15)
movq %r15, %rsi
callq 0x22b920
addq $0x8, %r14
movq (%r15), %r15
cmpq %r14, %rax
je 0x22b4a7
movq 0x28(%rax), %rdx
movq 0x30(%rax), %rcx
cmpq %r15, %rdx
setbe %sil
cmpq %rcx, %r15
setb %dil
andb %sil, %dil
cmpb $0x1, %dil
je 0x22b4ab
cmpq %rcx, %r15
jae 0x22b4a7
movq %rax, %rdi
callq 0x1184e0
jmp 0x22b474
xorl %eax, %eax
jmp 0x22b4b4
movq %rdx, (%rbx)
movq %rcx, 0x8(%rbx)
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::dependent_entity_collector::add_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::symbol_type)
inline void add_assignment(const std::string& symbol, const symbol_type st)
         {
            switch (st)
            {
               case e_st_variable       :
               case e_st_vector         :
               case e_st_string         : if (collect_assignments_)
                                             assignment_name_list_
                                                .push_back(std::make_pair(symbol, st));
                                          break;

               default                  : return;
            }
         }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x4, %edx
ja 0x22ba82
movl %edx, %ebp
pushq $0x16
popq %rax
btl %edx, %eax
jae 0x22ba82
movq %rdi, %rbx
cmpb $0x1, 0xa(%rdi)
jne 0x22ba82
addq $0x28, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x1182f0
movl %ebp, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x208a6e
leaq 0x8(%rsp), %rdi
callq 0x118648
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::entity_name<exprtk::details::expression_node<double>*>(exprtk::details::expression_node<double>* const&) const
inline std::string entity_name(const PtrType& ptr) const
         {
            if (map.empty())
               return std::string();

            tm_const_itr_t itr = map.begin();

            while (map.end() != itr)
            {
               if (itr->second.second == ptr)
               {
                  return itr->first;
               }
               else
                  ++itr;
            }

            return std::string();
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x28(%rsi)
je 0x22bad2
movq %rsi, %r14
movq 0x18(%rsi), %rax
addq $0x8, %r14
movq (%rdx), %r15
cmpq %rax, %r14
je 0x22bad2
cmpq %r15, 0x48(%rax)
je 0x22bae4
movq %rax, %rdi
callq 0x1184e0
jmp 0x22babd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
jmp 0x22baf3
addq $0x20, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1182f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::is_constant_foldable<2ul, exprtk::details::expression_node<double>*>(exprtk::details::expression_node<double>* (&) [2ul]) const
inline bool is_constant_foldable(NodePtr (&b)[N]) const
         {
            for (std::size_t i = 0; i < N; ++i)
            {
               if (0 == b[i])
                  return false;
               else if (!details::is_constant_node(b[i]))
                  return false;
            }

            return true;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
xorl %ecx, %ecx
movq %rcx, %r14
cmpq $0x2, %rcx
je 0x22bc26
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0x22bc26
callq 0x208267
leaq 0x1(%r14), %rcx
testb %al, %al
jne 0x22bc07
cmpq $0x2, %r14
setae %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assignment_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::assignment_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
pushq $0x50
popq %rdi
callq 0x118100
movq %rax, %rbx
movq (%r15), %rdx
movq (%r14), %rcx
movq %rax, %rdi
movq %r12, %rsi
callq 0x22bc96
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::numeric::details::root_impl<double>(double, double, exprtk::details::numeric::details::real_type_tag)
inline T root_impl(const T v0, const T v1, real_type_tag)
            {
               if (v0 < T(0))
               {
                  return (v1 == trunc_impl(v1, real_type_tag())) &&
                         (modulus_impl(v1, T(2), real_type_tag()) != T(0)) ?
                         -std::pow(abs_impl(v0, real_type_tag()), T(1) / v1) :
                          std::numeric_limits<double>::quiet_NaN();
               }

               return std::pow(v0, T(1) / v1);
            }

// Assembly:
movapd %xmm1, %xmm2
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x22c183
subq $0x28, %rsp
movapd %xmm0, 0x10(%rsp)
movapd %xmm2, %xmm0
movsd %xmm2, 0x8(%rsp)
callq 0x1183a0
movsd 0x8(%rsp), %xmm2
movsd 0xa21a0(%rip), %xmm1    # 0x2ce2c0
ucomisd %xmm2, %xmm0
jne 0x22c17a
jp 0x22c17a
movsd 0xa20b8(%rip), %xmm1    # 0x2ce1e8
movapd %xmm2, %xmm0
callq 0x118470
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movsd 0xa2177(%rip), %xmm1    # 0x2ce2c0
jne 0x22c14d
jnp 0x22c17a
movapd 0x10(%rsp), %xmm0
xorpd 0xa2025(%rip), %xmm0    # 0x2ce180
movsd 0xa205d(%rip), %xmm1    # 0x2ce1c0
divsd 0x8(%rsp), %xmm1
callq 0x1181b0
movapd %xmm0, %xmm1
xorpd 0xa2006(%rip), %xmm1    # 0x2ce180
movapd %xmm1, %xmm0
addq $0x28, %rsp
retq
movsd 0xa2035(%rip), %xmm1    # 0x2ce1c0
divsd %xmm2, %xmm1
jmp 0x1181b0
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::numeric::details::roundn_impl<double>(double, double, exprtk::details::numeric::details::real_type_tag)
inline T roundn_impl(const T v0, const T v1, real_type_tag)
            {
               const int index = std::max<int>(0, std::min<int>(pow10_size - 1, static_cast<int>(std::floor(v1))));
               const T p10 = T(pow10[index]);

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

// Assembly:
subq $0x18, %rsp
movsd %xmm0, 0x8(%rsp)
movapd %xmm1, %xmm0
callq 0x1180e0
cvttsd2si %xmm0, %eax
cmpl $0x10, %eax
pushq $0x10
popq %rcx
cmovll %eax, %ecx
xorl %eax, %eax
testl %ecx, %ecx
cmovgl %ecx, %eax
leaq 0xf978e(%rip), %rcx     # 0x325950
movsd (%rcx,%rax,8), %xmm1
xorpd %xmm0, %xmm0
movsd 0x8(%rsp), %xmm2
ucomisd %xmm2, %xmm0
movapd %xmm2, %xmm0
movsd %xmm1, 0x10(%rsp)
mulsd %xmm1, %xmm0
jbe 0x22c1f4
addsd 0xa20f3(%rip), %xmm0    # 0x2ce2e0
callq 0x118590
jmp 0x22c201
addsd 0xa201c(%rip), %xmm0    # 0x2ce218
callq 0x1180e0
divsd 0x10(%rsp), %xmm0
addq $0x18, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x8(%rdi)
jne 0x22c356
movq 0x10(%rbx), %rax
jmp 0x22c3a1
movq %rsi, %r14
andq $0x0, 0x10(%rbx)
xorl %r15d, %r15d
xorl %eax, %eax
cmpq $0x20, %r15
je 0x22c396
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x22c390
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rbx), %rax
cmpq %rcx, %rax
ja 0x22c38c
movq %rcx, %rax
movq %rax, 0x10(%rbx)
addq $0x10, %r15
jmp 0x22c363
incq %rax
movq %rax, 0x10(%rbx)
movb $0x1, 0x8(%rbx)
popq %rbx
popq %r14
popq %r15
retq
nop