LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_string_node<double, exprtk::details::asn_assignment>::value() const
inline T value() const exprtk_override
         {
            branch(1)->value();

            std::size_t r0 = 0;
            std::size_t r1 = 0;

            const range_t& range = (*str1_range_ptr_);

            if (range(r0, r1, str1_base_ptr_->size()))
            {
               AssignmentProcess::execute(
                  str0_node_ptr_->ref(),
                  str1_base_ptr_->base() + r0, (r1 - r0));

               branch(0)->value();
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x38(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movq %rsp, %r15
movq %rax, (%r15)
movq 0x78(%rbx), %r12
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x10(%rsp), %rcx
movq %rax, (%rcx)
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2a4b56
testb %al, %al
je 0x2a4a2e
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rax
movq 0x30(%rax), %r14
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdx
leaq (%rax,%rdx), %rcx
movq (%rsp), %r8
subq %rdx, %r8
movq 0x8(%r14), %rdx
movq %r14, %rdi
xorl %esi, %esi
callq 0x11e290
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0xe47d2(%rip), %xmm0    # 0x389208
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::range_pack<double>::operator()(unsigned long&, unsigned long&, unsigned long const&) const
bool operator() (std::size_t& r0, std::size_t& r1,
                          const std::size_t& size = std::numeric_limits<std::size_t>::max()) const
         {
            if (n0_c.first)
               r0 = n0_c.second;
            else if (n0_e.first)
            {
               r0 = static_cast<std::size_t>(details::numeric::to_int64(n0_e.second->value()));
            }
            else
               return false;

            if (n1_c.first)
               r1 = n1_c.second;
            else if (n1_e.first)
            {
               r1 = static_cast<std::size_t>(details::numeric::to_int64(n1_e.second->value()));
            }
            else
               return false;

            if (
                 (std::numeric_limits<std::size_t>::max() != size) &&
                 (std::numeric_limits<std::size_t>::max() == r1  )
               )
            {
               r1 = size;
            }

            cache.first  = r0;
            cache.second = r1;

            #ifndef exprtk_enable_range_runtime_checks
            return (r0 <= r1);
            #else
            return range_runtime_check(r0, r1, size);
            #endif
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
cmpb $0x1, 0x20(%rdi)
jne 0x2a4b76
movq 0x28(%r15), %rax
jmp 0x2a4b8b
cmpb $0x1, (%r15)
jne 0x2a4be4
movq 0x8(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cvttsd2si %xmm0, %rax
movq %rax, (%rbx)
cmpb $0x1, 0x30(%r15)
jne 0x2a4b9b
movq 0x38(%r15), %rax
jmp 0x2a4bb1
cmpb $0x1, 0x10(%r15)
jne 0x2a4be4
movq 0x18(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cvttsd2si %xmm0, %rax
movq %rax, (%r14)
movq (%r12), %rcx
cmpq $-0x1, %rax
movq %rax, %rdx
cmoveq %rcx, %rdx
cmpq $-0x1, %rcx
cmoveq %rax, %rdx
movq %rdx, (%r14)
movq (%rbx), %rax
movq %rax, 0x40(%r15)
movq (%r14), %rax
movq %rax, 0x48(%r15)
cmpq %rax, (%rbx)
setbe %al
jmp 0x2a4be6
xorl %eax, %eax
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::details::assignment_string_range_node<double, exprtk::details::asn_assignment>::value() const
inline T value() const exprtk_override
         {
            branch(0)->value();
            branch(1)->value();

            std::size_t s0_r0 = 0;
            std::size_t s0_r1 = 0;

            std::size_t s1_r0 = 0;
            std::size_t s1_r1 = 0;

            const range_t& range0 = (*str0_range_ptr_);
            const range_t& range1 = (*str1_range_ptr_);

            if (
                  range0(s0_r0, s0_r1, str0_base_ptr_->size()) &&
                  range1(s1_r0, s1_r1, str1_base_ptr_->size())
               )
            {
               const std::size_t size = std::min((s0_r1 - s0_r0), (s1_r1 - s1_r0));

               std::copy(
                  str1_base_ptr_->base() + s1_r0,
                  str1_base_ptr_->base() + s1_r0 + size,
                  const_cast<char_ptr>(base() + s0_r0));
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x78(%rbx), %r13
movq 0x80(%rbx), %r14
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a4b56
testb %al, %al
je 0x2a4f28
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2a4b56
testb %al, %al
je 0x2a4f28
movq 0x18(%rsp), %rax
subq 0x10(%rsp), %rax
movq 0x8(%rsp), %r12
subq (%rsp), %r12
cmpq %rax, %r12
cmovaeq %rax, %r12
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r14
addq (%rsp), %r14
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %r15
addq (%rsp), %r15
addq %r12, %r15
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
subq %r14, %r15
je 0x2a4f28
addq 0x10(%rsp), %rax
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x11e100
movsd 0xe42d8(%rip), %xmm0    # 0x389208
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_vec_node<double>::assignment_vec_node(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
assignment_vec_node(const operator_type& opr,
                             expression_ptr branch0,
                             expression_ptr branch1)
         : binary_node<T>(opr, branch0, branch1)
         , vec_node_ptr_(0)
         {
            if (is_vector_node(branch(0)))
            {
               vec_node_ptr_ = static_cast<vector_node<T>*>(branch(0));
               vds()         = vec_node_ptr_->vds();
            }

            assert(valid());
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x313562
leaq 0x269209(%rip), %rax    # 0x50e930
movq %rax, (%rbx)
leaq 0x26927f(%rip), %rax    # 0x50e9b0
movq %rax, 0x8(%rbx)
leaq 0x26929c(%rip), %rax    # 0x50e9d8
movq %rax, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
movl $0x20, %edi
callq 0x11e0f0
movq $0x1, (%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rax)
movb $0x1, 0x18(%rax)
movq %rax, 0x58(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2a5794
leaq 0x58(%rbx), %r14
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
jne 0x2a5794
movq 0x28(%rbx), %rsi
movq %rsi, 0x50(%rbx)
addq $0x30, %rsi
movq %r14, %rdi
callq 0x27fd20
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2a579e
movq %rax, %rbx
movq %r14, %rdi
callq 0x27fe22
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_vec_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec_node_ptr_ &&
               (vds().size() <= vec_node_ptr_->vec_holder().base_size()) &&
               binary_node<T>::valid();
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2a597b
movq %rdi, %rbx
movq 0x58(%rdi), %rcx
movq 0x8(%rcx), %r14
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %rax, %r14
ja 0x2a597b
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2a597b
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2a597b
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2a597b
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x30(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::swap_generic_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::swap_generic_node<double>, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(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
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x58, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r15), %rsi
movq (%r14), %rdx
movq %rax, %rdi
callq 0x2a5adc
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %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::swap_string_node<double>::swap_string_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
swap_string_node(expression_ptr branch0, expression_ptr branch1)
         : binary_node<T>(details::e_swap, branch0, branch1)
         , initialised_(false)
         , str0_node_ptr_(0)
         , str1_node_ptr_(0)
         {
            if (is_string_node(branch(0)))
            {
               str0_node_ptr_ = static_cast<strvar_node_ptr>(branch(0));
            }

            if (is_string_node(branch(1)))
            {
               str1_node_ptr_ = static_cast<strvar_node_ptr>(branch(1));
            }

            initialised_ = (str0_node_ptr_ && str1_node_ptr_);
            assert(valid());
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %rbx
leaq 0xc(%rsp), %rsi
movl $0x5c, (%rsi)
callq 0x313562
leaq 0x268c7d(%rip), %rax    # 0x50ecb8
movq %rax, (%rbx)
leaq 0x268ceb(%rip), %rax    # 0x50ed30
movq %rax, 0x8(%rbx)
leaq 0x268d08(%rip), %rax    # 0x50ed58
movq %rax, 0x48(%rbx)
leaq 0x268d35(%rip), %rax    # 0x50ed90
movq %rax, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2a6086
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x2a6086
movq 0x28(%rbx), %rax
movq %rax, 0x60(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2a60a2
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x2a60a2
movq 0x38(%rbx), %rax
movq %rax, 0x68(%rbx)
cmpq $0x0, 0x60(%rbx)
setne %al
cmpq $0x0, 0x68(%rbx)
setne %cl
andb %al, %cl
movb %cl, 0x58(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::swap_string_node<double>::value() const
inline T value() const exprtk_override
         {
            branch(0)->value();
            branch(1)->value();

            std::swap(str0_node_ptr_->ref(), str1_node_ptr_->ref());

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

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x60(%rbx), %rax
movq 0x68(%rbx), %rcx
movq 0x30(%rax), %rdi
movq 0x30(%rcx), %rsi
callq 0x11e5f0
movsd 0xe3109(%rip), %xmm0    # 0x389208
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::assign_opr_to_string[abi:cxx11](exprtk::details::operator_type) const
std::string assign_opr_to_string(details::operator_type opr) const
         {
            switch (opr)
            {
               case details::e_assign : return ":=";
               case details::e_addass : return "+=";
               case details::e_subass : return "-=";
               case details::e_mulass : return "*=";
               case details::e_divass : return "/=";
               case details::e_modass : return "%=";
               default                : return ""  ;
            }
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
addl $-0x51, %edx
cmpl $0x5, %edx
ja 0x2a689a
leaq 0xe53ea(%rip), %rax     # 0x38bc10
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xe7483(%rip), %rsi     # 0x38dcb9
leaq 0xe747e(%rip), %rdx     # 0x38dcbb
jmp 0x2a688d
leaq 0xe747f(%rip), %rsi     # 0x38dcc5
leaq 0xe747a(%rip), %rdx     # 0x38dcc7
jmp 0x2a688d
leaq 0xe7469(%rip), %rsi     # 0x38dcbf
leaq 0xe7464(%rip), %rdx     # 0x38dcc1
jmp 0x2a688d
leaq 0xe745c(%rip), %rsi     # 0x38dcc2
leaq 0xe7457(%rip), %rdx     # 0x38dcc4
jmp 0x2a688d
leaq 0xe7446(%rip), %rsi     # 0x38dcbc
leaq 0xe7441(%rip), %rdx     # 0x38dcbe
jmp 0x2a688d
leaq 0xe7442(%rip), %rsi     # 0x38dcc8
leaq 0xe743d(%rip), %rdx     # 0x38dcca
movq %rbx, %rdi
callq 0x1e4740
movq %rbx, %rax
popq %rbx
retq
leaq 0xfc95e(%rip), %rdx     # 0x3a31ff
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x2a6890
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::assignment_vec_elem_op_rtc_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_rrr<exprtk::details::assignment_vec_elem_op_rtc_node<double, exprtk::details::add_op<double>>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&) const
inline expression_node<typename node_type::value_type>* allocate_rrr(T1& t1, T2& t2, 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
movl $0x50, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r15), %rdx
movq (%r14), %rcx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2a867c
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
movl $0x50, %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::assignment_vec_op_node<double, exprtk::details::add_op<double>>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec_node_ptr_           &&
               (size() <= base_size()) &&
               binary_node<T>::valid() ;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2ad249
movq %rdi, %rbx
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r14
movq 0x50(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %rax, %r14
ja 0x2ad249
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2ad249
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2ad249
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2ad249
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x30(%rax)
xorl %eax, %eax
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_binop_vecval_node<double, exprtk::details::lt_op<double>>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec0_node_ptr_          &&
               (size() <= base_size()) &&
               binary_node<T>::valid();
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2b8e4f
movq %rdi, %rbx
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r14
movq 0x50(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %rax, %r14
ja 0x2b8e4f
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2b8e4f
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2b8e4f
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2b8e4f
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x30(%rax)
xorl %eax, %eax
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_binop_valvec_node<double, exprtk::details::lt_op<double>>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec1_node_ptr_               &&
               (size() <= base_size())      &&
               (vds_.size() <= base_size()) &&
               binary_node<T>::valid();
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq 0x50(%rdi), %rax
testq %rax, %rax
je 0x2c0a73
movq %rdi, %rbx
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r14
movq 0x50(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %rax, %r14
ja 0x2c0a73
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq 0x8(%rcx), %r14
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %rax, %r14
ja 0x2c0a73
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2c0a73
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2c0a73
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2c0a73
movq (%rdi), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
jmpq *0x30(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::scand_node<double>::value() const
inline T value() const exprtk_override
         {
            return (
                     std::not_equal_to<T>()
                        (T(0),branch(0)->value()) &&
                     std::not_equal_to<T>()
                        (T(0),branch(1)->value())
                   ) ? T(1) : T(0);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x2d0e50
jnp 0x2d0e6f
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0xb81b5(%rip), %xmm0    # 0x389020
andpd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_socs_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_socs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string& s0 = static_cast<     details::stringvar_node<Type>*>(branch[0])->ref();
            std::string  s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str();

            details::free_node(*node_allocator_,branch[1]);

            return synthesize_sos_expression_impl<std::string&, const std::string>(opr, s0, s1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rax
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1e7738
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x2d17ac
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d17ac
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d17a4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d17ac
movq %r12, %rdi
callq 0x1ea63e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x1e7738
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2d66a6
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d17f9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d180f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d183f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2d183f
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d1855
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>::synthesize_sosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_sosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::stringvar_node<Type>*>   (branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();

            static_cast<details::string_range_node<Type>*>(branch[1])->range_ref().clear();

            details::free_node(*node_allocator_,branch[1]);

            return synthesize_str_xoxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
movq 0x30(%rax), %r15
movq 0x30(%rdx), %r12
leaq 0x38(%rdx), %rsi
leaq 0x50(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %eax, %eax
movb %al, 0x38(%rdx)
movq %rax, 0x40(%rdx)
movb %al, 0x48(%rdx)
movq %rax, 0x50(%rdx)
movb %al, 0x58(%rdx)
movq %rax, 0x60(%rdx)
movb %al, 0x68(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdx)
movq %rax, 0x80(%rdx)
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0x2d18f3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d18f3
addq $0x8, %r13
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2d18eb
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d18f3
movq %r13, %rdi
callq 0x1ea63e
leaq 0x50(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2d7ac8
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_socsr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_socsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::stringvar_node<Type>*>         (branch[0])->ref  ();
            std::string   s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            range_t      rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();

            static_cast<details::const_string_range_node<Type>*>(branch[1])->range_ref().clear();

            details::free_node(*node_allocator_,branch[1]);

            return synthesize_str_xoxr_expression_impl<std::string&, const std::string>(opr, s0, s1, rp1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rax
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x1e7738
movq 0x8(%r12), %rax
leaq 0x50(%rax), %rsi
leaq 0x90(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
movb %cl, 0x50(%rax)
movq %rcx, 0x58(%rax)
movb %cl, 0x60(%rax)
movq %rcx, 0x68(%rax)
movb %cl, 0x70(%rax)
movq %rcx, 0x78(%rax)
movb %cl, 0x80(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rax)
movq %rcx, 0x98(%rax)
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x2d19e4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d19e4
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d19dc
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d19e4
movq %r12, %rdi
callq 0x1ea63e
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0x1e7738
leaq 0x90(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x70(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2d87d4
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d1a4b
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d1a62
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d1a98
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2d1a98
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d1aaf
movq 0x60(%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>::synthesize_csos_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csos_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string  s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
            std::string& s1 = static_cast<details::stringvar_node<Type>*     >(branch[1])->ref();

            details::free_node(*node_allocator_,branch[0]);

            return synthesize_sos_expression_impl<const std::string,std::string&>(opr, s0, s1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1e7738
movq (%r12), %rdi
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
testq %rdi, %rdi
je 0x2d1b26
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d1b26
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d1b1e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d1b26
movq %r12, %rdi
callq 0x1ea63e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x1e7738
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2d9e64
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d1b73
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d1b89
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d1bb9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2d1bb9
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2d1bcf
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>::synthesize_csosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string  s0  = static_cast<details::string_literal_node<Type>*>(branch[0])->str  ();
            std::string& s1  = static_cast<details::string_range_node<Type>*  >(branch[1])->ref  ();
            range_t      rp1 = static_cast<details::string_range_node<Type>*  >(branch[1])->range();

            static_cast<details::string_range_node<Type>*>(branch[1])->range_ref().clear();

            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);

            return synthesize_str_xoxr_expression_impl<const std::string,std::string&>(opr, s0, s1, rp1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x1e7738
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
leaq 0x38(%rax), %rsi
leaq 0x90(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
movb %cl, 0x38(%rax)
movq %rcx, 0x40(%rax)
movb %cl, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
movq %rcx, 0x60(%rax)
movb %cl, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movq %rcx, 0x80(%rax)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d2267
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d2267
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d225f
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d2267
movq %r12, %rdi
callq 0x1ea63e
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d229b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d229b
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d2293
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d229b
movq %r12, %rdi
callq 0x1ea63e
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0x1e7738
leaq 0x90(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x70(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2dd656
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d2302
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d2319
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d234f
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2d234f
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d2366
movq 0x60(%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>::synthesize_sros_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_sros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*>   (branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();

            static_cast<details::string_range_node<Type>*>(branch[0])->range_ref().clear();

            details::free_node(*node_allocator_,branch[0]);

            return synthesize_str_xrox_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq 0x30(%rax), %r15
movq 0x30(%rcx), %r12
leaq 0x38(%rax), %rsi
leaq 0x50(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
movb %cl, 0x38(%rax)
movq %rcx, 0x40(%rax)
movb %cl, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
movq %rcx, 0x60(%rax)
movb %cl, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movq %rcx, 0x80(%rax)
movq (%rdx), %rdi
testq %rdi, %rdi
je 0x2d268a
movq %rdx, %r13
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d268a
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2d2682
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d268a
movq %r13, %rdi
callq 0x1ea63e
leaq 0x50(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2e11ac
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_srosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_srosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();

            static_cast<details::string_range_node<Type>*>(branch[0])->range_ref().clear();
            static_cast<details::string_range_node<Type>*>(branch[1])->range_ref().clear();

            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);

            return synthesize_str_xroxr_expression_impl<std::string&,std::string&>(opr, s0, s1, rp0, rp1);
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdx, %rbp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rdx
movq 0x8(%rbp), %rax
movq 0x30(%rdx), %r15
leaq 0x8(%rbp), %r13
movq 0x30(%rax), %r12
leaq 0x38(%rdx), %rsi
leaq 0xf8(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
addq $0x38, %rax
leaq 0xa8(%rsp), %rdi
movl $0xa, %ecx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
xorl %eax, %eax
movb %al, 0x38(%rdx)
movq %rax, 0x40(%rdx)
movb %al, 0x48(%rdx)
movq %rax, 0x50(%rdx)
movb %al, 0x58(%rdx)
movq %rax, 0x60(%rdx)
movb %al, 0x68(%rdx)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rdx)
movq %rax, 0x80(%rdx)
movq 0x8(%rbp), %rcx
movb %al, 0x38(%rcx)
movq %rax, 0x40(%rcx)
movb %al, 0x48(%rcx)
movq %rax, 0x50(%rcx)
movb %al, 0x58(%rcx)
movq %rax, 0x60(%rcx)
movb %al, 0x68(%rcx)
movups %xmm0, 0x70(%rcx)
movq %rax, 0x80(%rcx)
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x2d2793
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d2793
movq (%rbp), %rdi
testq %rdi, %rdi
je 0x2d278b
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d2793
movq %rbp, %rdi
callq 0x1ea63e
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2d27c3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d27c3
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2d27bb
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d27c3
movq %r13, %rdi
callq 0x1ea63e
leaq 0xf8(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x2e1de4
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_srocs_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_srocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*  >(branch[0])->ref  ();
            std::string   s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*  >(branch[0])->range();

            static_cast<details::string_range_node<Type>*>(branch[0])->range_ref().clear();

            details::free_node(*node_allocator_,branch[0]);
            details::free_node(*node_allocator_,branch[1]);

            return synthesize_str_xrox_expression_impl<std::string&, const std::string>(opr, s0, s1, rp0);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rax
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x1e7738
movq (%r12), %rax
leaq 0x38(%rax), %rsi
leaq 0x90(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
movb %cl, 0x38(%rax)
movq %rcx, 0x40(%rax)
movb %cl, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
movq %rcx, 0x60(%rax)
movb %cl, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movq %rcx, 0x80(%rax)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d28c0
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d28c0
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d28b8
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d28c0
movq %r12, %rdi
callq 0x1ea63e
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d28f4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d28f4
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d28ec
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d28f4
movq %r12, %rdi
callq 0x1ea63e
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0x1e7738
leaq 0x90(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x70(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2e318a
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d295b
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d2972
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d29a8
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2d29a8
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d29bf
movq 0x60(%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>::synthesize_csros_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string   s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*         >(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();

            static_cast<details::const_string_range_node<Type>*>(branch[0])->range_ref().clear();

            details::free_node(*node_allocator_,branch[0]);

            return synthesize_str_xrox_expression_impl<const std::string,std::string&>(opr, s0, s1, rp0);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rax
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x1e7738
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
movq (%r12), %rax
leaq 0x50(%rax), %rsi
leaq 0x90(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
movb %cl, 0x50(%rax)
movq %rcx, 0x58(%rax)
movb %cl, 0x60(%rax)
movq %rcx, 0x68(%rax)
movb %cl, 0x70(%rax)
movq %rcx, 0x78(%rax)
movb %cl, 0x80(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rax)
movq %rcx, 0x98(%rax)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d2cbb
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d2cbb
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2d2cb3
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d2cbb
movq %r12, %rdi
callq 0x1ea63e
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0x1e7738
leaq 0x90(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x70(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2e65f6
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d2d22
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d2d39
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rax
addq $0xe0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2d2d6f
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2d2d6f
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2d2d86
movq 0x60(%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::details::string_concat_node<double>::value() const
inline T value() const exprtk_override
         {
            branch(0)->value();
            branch(1)->value();

            std::size_t str0_r0 = 0;
            std::size_t str0_r1 = 0;

            std::size_t str1_r0 = 0;
            std::size_t str1_r1 = 0;

            const range_t& range0 = str0_range_ptr_->range_ref();
            const range_t& range1 = str1_range_ptr_->range_ref();

            if (
                  range0(str0_r0, str0_r1, str0_base_ptr_->size()) &&
                  range1(str1_r0, str1_r1, str1_base_ptr_->size())
               )
            {
               const std::size_t size0 = (str0_r1 - str0_r0);
               const std::size_t size1 = (str1_r1 - str1_r0);

               value_.assign(str0_base_ptr_->base() + str0_r0, size0);
               value_.append(str1_base_ptr_->base() + str1_r0, size1);

               range_.n1_c.second  = value_.size();
               range_.cache.second = range_.n1_c.second;
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r13
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2a4b56
testb %al, %al
je 0x2d38f9
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x2a4b56
testb %al, %al
je 0x2d38f9
movq 0x18(%rsp), %r12
subq 0x10(%rsp), %r12
movq 0x8(%rsp), %r14
subq (%rsp), %r14
leaq 0xd0(%rbx), %r15
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x10(%rsp), %rax
movq 0xd8(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r12, %r8
callq 0x11e290
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq (%rsp), %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x11e190
movq 0xd8(%rbx), %rax
movq %rax, 0xb8(%rbx)
movq %rax, 0xc8(%rbx)
movsd 0xb5907(%rip), %xmm0    # 0x389208
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::lt_op<double>>::value_type>* exprtk::details::node_allocator::allocate_tt<exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::lt_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const) const
inline expression_node<typename node_type::value_type>* allocate_tt(T1 t1, T2 t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl $0x60, %edi
callq 0x11e0f0
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1e7738
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1e7738
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2dc500
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dbc4c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2dbc63
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2dbc9f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2dbc9f
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2dbcbb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2dbcbb
movq %rax, %r14
movl $0x60, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330