LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_string_node<double, exprtk::details::asn_assignment>::assignment_string_node(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
assignment_string_node(const operator_type& opr,
                                expression_ptr branch0,
                                expression_ptr branch1)
         : binary_node<T>(opr, branch0, branch1)
         , initialised_(false)
         , str0_base_ptr_ (0)
         , str1_base_ptr_ (0)
         , str0_node_ptr_ (0)
         , str1_range_ptr_(0)
         {
            if (is_string_node(branch(0)))
            {
               str0_node_ptr_ = static_cast<strvar_node_ptr>(branch(0));
               str0_base_ptr_ = dynamic_cast<str_base_ptr>(branch(0));
            }

            if (is_generally_string_node(branch(1)))
            {
               str1_base_ptr_ = dynamic_cast<str_base_ptr>(branch(1));

               if (0 == str1_base_ptr_)
                  return;

               irange_ptr range = dynamic_cast<irange_ptr>(branch(1));

               if (0 == range)
                  return;

               str1_range_ptr_ = &(range->range_ref());
            }

            initialised_ = str0_base_ptr_  &&
                           str1_base_ptr_  &&
                           str0_node_ptr_  &&
                           str1_range_ptr_ ;

            assert(valid());
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x287330
leaq 0x25ab67(%rip), %rax    # 0x487538
movq %rax, (%rbx)
leaq 0x25abd5(%rip), %rax    # 0x4875b0
movq %rax, 0x8(%rbx)
leaq 0x25abf2(%rip), %rax    # 0x4875d8
movq %rax, 0x48(%rbx)
leaq 0x25ac1f(%rip), %rax    # 0x487610
movq %rax, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movups %xmm0, 0x70(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x22ca46
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x22ca46
leaq 0x60(%rbx), %r14
movq 0x28(%rbx), %rdi
movq %rdi, 0x70(%rbx)
testq %rdi, %rdi
je 0x22ca41
leaq 0x2226a0(%rip), %rsi    # 0x44f0d0
leaq 0x254051(%rip), %rdx    # 0x480a88
pushq $-0x2
popq %rcx
callq 0x118510
jmp 0x22ca43
xorl %eax, %eax
movq %rax, (%r14)
movq 0x38(%rbx), %rdi
callq 0x20b691
testb %al, %al
je 0x22caad
movq 0x38(%rbx), %r14
testq %r14, %r14
je 0x22cad8
leaq 0x22266d(%rip), %rsi    # 0x44f0d0
leaq 0x25401e(%rip), %rdx    # 0x480a88
pushq $-0x2
popq %rcx
movq %r14, %rdi
callq 0x118510
movq %rax, 0x68(%rbx)
testq %rax, %rax
je 0x22cadd
leaq 0x22264b(%rip), %rsi    # 0x44f0d0
leaq 0x25400c(%rip), %rdx    # 0x480a98
pushq $-0x2
popq %rcx
movq %r14, %rdi
callq 0x118510
testq %rax, %rax
je 0x22cadd
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, 0x78(%rbx)
movb $0x1, %al
jmp 0x22cab5
cmpq $0x0, 0x78(%rbx)
setne %al
cmpq $0x0, 0x60(%rbx)
setne %cl
cmpq $0x0, 0x68(%rbx)
setne %dl
andb %cl, %dl
cmpq $0x0, 0x70(%rbx)
setne %cl
andb %al, %cl
andb %dl, %cl
movb %cl, 0x58(%rbx)
jmp 0x22cadd
andq $0x0, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x8(%rsp), %r14
andq $0x0, (%r14)
movq %rsp, %r15
andq $0x0, (%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 0x22cc40
testb %al, %al
je 0x22cb76
movq 0x68(%rbx), %rdi
movq 0x70(%rbx), %rax
movq 0x30(%rax), %r14
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rcx
leaq (%rax,%rcx), %rsi
movq (%rsp), %rdx
subq %rcx, %rdx
movq %r14, %rdi
callq 0x1182b0
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0xa1742(%rip), %xmm0    # 0x2ce2c0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::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 0x22cc60
movq 0x28(%r15), %rax
jmp 0x22cc75
cmpb $0x1, (%r15)
jne 0x22ccce
movq 0x8(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cvttsd2si %xmm0, %rax
movq %rax, (%rbx)
cmpb $0x1, 0x30(%r15)
jne 0x22cc85
movq 0x38(%r15), %rax
jmp 0x22cc9b
cmpb $0x1, 0x10(%r15)
jne 0x22ccce
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 0x22ccd0
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::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)
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
leaq 0x18(%rsp), %r12
andq $0x0, (%r12)
andq $0x0, (%rsp)
andq $0x0, 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 0x22cc40
testb %al, %al
je 0x22d038
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 0x22cc40
testb %al, %al
je 0x22d038
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 0x22d038
addq 0x10(%rsp), %rax
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x118110
movsd 0xa1280(%rip), %xmm0    # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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, %r14
callq 0x287330
leaq 0x25a1dd(%rip), %rax    # 0x487910
movq %rax, (%r14)
leaq 0x25a253(%rip), %rax    # 0x487990
movq %rax, 0x8(%r14)
leaq 0x25a270(%rip), %rax    # 0x4879b8
movq %rax, 0x48(%r14)
andq $0x0, 0x50(%r14)
leaq 0x58(%r14), %rbx
movq %rbx, %rdi
callq 0x211240
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x22d785
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
jne 0x22d785
movq 0x28(%r14), %rsi
movq %rsi, 0x50(%r14)
addq $0x30, %rsi
movq %rbx, %rdi
callq 0x211264
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x22d78f
movq %rax, %r14
movq %rbx, %rdi
callq 0x211a7c
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22d92e
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
jbe 0x22d938
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22beac
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::is_ivariable_node<double>(exprtk::details::expression_node<double> const*)
inline bool is_ivariable_node(const expression_node<T>* node)
      {
         return node &&
                (
                  details::expression_node<T>::e_variable      == node->type() ||
                  details::expression_node<T>::e_vecelem       == node->type() ||
                  details::expression_node<T>::e_veccelem      == node->type() ||
                  details::expression_node<T>::e_vecelemrtc    == node->type() ||
                  details::expression_node<T>::e_veccelemrtc   == node->type() ||
                  details::expression_node<T>::e_rbvecelem     == node->type() ||
                  details::expression_node<T>::e_rbveccelem    == node->type() ||
                  details::expression_node<T>::e_rbvecelemrtc  == node->type() ||
                  details::expression_node<T>::e_rbveccelemrtc == node->type()
                );
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x22da81
movq %rdi, %r14
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bl
cmpl $0x11, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x7e, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x7f, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x80, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x81, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x82, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x84, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x83, %eax
je 0x22da83
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x85, %eax
sete %bl
jmp 0x22da83
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::swap_vecvec_node<double>::swap_vecvec_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
swap_vecvec_node(expression_ptr branch0,
                          expression_ptr branch1)
         : binary_node<T>(details::e_swap, branch0, branch1)
         , vec0_node_ptr_(0)
         , vec1_node_ptr_(0)
         , initialised_  (false)
         {
            if (is_ivector_node(branch(0)))
            {
               vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);

               if (0 != (vi = dynamic_cast<vector_interface<T>*>(branch(0))))
               {
                  vec0_node_ptr_ = vi->vec();
                  vds()          = vi->vds();
               }
            }

            if (is_ivector_node(branch(1)))
            {
               vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);

               if (0 != (vi = dynamic_cast<vector_interface<T>*>(branch(1))))
               {
                  vec1_node_ptr_ = vi->vec();
               }
            }

            if (vec0_node_ptr_ && vec1_node_ptr_)
            {
               initialised_ = size() <= base_size();
            }

            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rcx
movq %rsi, %rdx
movq %rdi, %r14
leaq 0xc(%rsp), %rsi
movl $0x5c, (%rsi)
callq 0x287330
leaq 0x259deb(%rip), %rax    # 0x487b60
movq %rax, (%r14)
leaq 0x259e61(%rip), %rax    # 0x487be0
movq %rax, 0x8(%r14)
leaq 0x259e7e(%rip), %rax    # 0x487c08
movq %rax, 0x48(%r14)
leaq 0x68(%r14), %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x50(%r14)
movb $0x0, 0x60(%r14)
movq %rbx, %rdi
callq 0x211240
movq 0x28(%r14), %rdi
callq 0x208d51
testb %al, %al
je 0x22ddff
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x22ddff
leaq 0x22130c(%rip), %rsi    # 0x44f0d0
leaq 0x25250d(%rip), %rdx    # 0x4802d8
pushq $-0x2
popq %rcx
callq 0x118510
testq %rax, %rax
je 0x22ddff
movq %rax, %r15
movq (%rax), %rax
movq %r15, %rdi
callq *0x28(%rax)
leaq 0x50(%r14), %rcx
movq %rax, (%rcx)
movq (%r15), %rax
movq %r15, %rdi
callq *0x30(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x211264
movq 0x38(%r14), %rdi
callq 0x208d51
testb %al, %al
je 0x22de3d
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x22de3d
leaq 0x2212b4(%rip), %rsi    # 0x44f0d0
leaq 0x2524b5(%rip), %rdx    # 0x4802d8
pushq $-0x2
popq %rcx
callq 0x118510
testq %rax, %rax
je 0x22de3d
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq %rax, 0x58(%r14)
cmpq $0x0, 0x50(%r14)
je 0x22de66
cmpq $0x0, 0x58(%r14)
je 0x22de66
movq %r14, %rdi
callq 0x22de92
movq %rax, %r15
movq %r14, %rdi
callq 0x22dece
cmpq %rax, %r15
setbe 0x60(%r14)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x22de78
jmp 0x22de78
jmp 0x22de78
jmp 0x22de78
movq %rax, %r14
movq %rbx, %rdi
callq 0x211a7c
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::swap_vecvec_node<double>::value() const
inline T value() const exprtk_override
         {
            binary_node<T>::branch(0)->value();
            binary_node<T>::branch(1)->value();

            T* vec0 = vec0_node_ptr_->vds().data();
            T* vec1 = vec1_node_ptr_->vds().data();

            assert(size() <= base_size());
            const std::size_t n = size();

            for (std::size_t i = 0; i < n; ++i)
            {
               std::swap(vec0[i],vec1[i]);
            }

            return vec1_node_ptr_->value();
         }

// Assembly:
pushq %r15
pushq %r14
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 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
movq 0x30(%rax), %rax
movq 0x10(%rax), %r14
movq 0x30(%rcx), %rax
movq 0x10(%rax), %r15
movq %rbx, %rdi
callq 0x22de92
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x22df8e
movsd (%r14,%rcx,8), %xmm0
movsd (%r15,%rcx,8), %xmm1
movsd %xmm1, (%r14,%rcx,8)
movsd %xmm0, (%r15,%rcx,8)
incq %rcx
jmp 0x22df6c
movq 0x58(%rbx), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x287330
leaq 0x259c55(%rip), %rax    # 0x487c98
movq %rax, (%rbx)
leaq 0x259cc3(%rip), %rax    # 0x487d10
movq %rax, 0x8(%rbx)
leaq 0x259ce0(%rip), %rax    # 0x487d38
movq %rax, 0x48(%rbx)
leaq 0x259d0d(%rip), %rax    # 0x487d70
movq %rax, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x22e08e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x22e08e
movq 0x28(%rbx), %rax
movq %rax, 0x60(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x22e0aa
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x22e0aa
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_O2/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 0x118620
movsd 0xa01bb(%rip), %xmm0    # 0x2ce2c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
subq $0x10, %rsp
movq %rdi, %rbx
addl $-0x51, %edx
cmpl $0x5, %edx
ja 0x22e818
leaq 0xa2955(%rip), %rax     # 0x2d1110
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xa4b9e(%rip), %rsi     # 0x2d3369
leaq 0xf(%rsp), %rdx
jmp 0x22e824
leaq 0xa4b9c(%rip), %rsi     # 0x2d3375
leaq 0xb(%rsp), %rdx
jmp 0x22e824
leaq 0xa4b88(%rip), %rsi     # 0x2d336f
leaq 0xd(%rsp), %rdx
jmp 0x22e824
leaq 0xa4b7d(%rip), %rsi     # 0x2d3372
leaq 0xc(%rsp), %rdx
jmp 0x22e824
leaq 0xa4b69(%rip), %rsi     # 0x2d336c
leaq 0xe(%rsp), %rdx
jmp 0x22e824
leaq 0xa4b67(%rip), %rsi     # 0x2d3378
leaq 0xa(%rsp), %rdx
jmp 0x22e824
leaq 0xba0ea(%rip), %rsi     # 0x2e8909
leaq 0x9(%rsp), %rdx
movq %rbx, %rdi
callq 0x127016
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sf3_var_node<double, exprtk::details::sf00_op<double>>::value_type>* exprtk::details::node_allocator::allocate_rrr<exprtk::details::sf3_var_node<double, exprtk::details::sf00_op<double>>, double const, double const, double const>(double const&, double const&, double const&) 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 %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
pushq $0x38
popq %rdi
callq 0x118100
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x21a872(%rip), %rcx    # 0x4aae80
movq %rcx, (%rax)
leaq 0x21a8b0(%rip), %rcx    # 0x4aaec8
movq %rcx, 0x8(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x233708
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
jbe 0x233712
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22beac
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_binop_vecval_node<double, exprtk::details::lt_op<double>>::vec_binop_vecval_node(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
vec_binop_vecval_node(const operator_type& opr,
                               expression_ptr branch0,
                               expression_ptr branch1)
         : binary_node<T>(opr, branch0, branch1)
         , vec0_node_ptr_(0)
         {
            bool v0_is_ivec = false;

            if (is_vector_node(branch(0)))
            {
               vec0_node_ptr_ = static_cast<vector_node_ptr>(branch(0));
            }
            else if (is_ivector_node(branch(0)))
            {
               vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);

               if (0 != (vi = dynamic_cast<vector_interface<T>*>(branch(0))))
               {
                  vec0_node_ptr_ = vi->vec();
                  v0_is_ivec     = true;
               }
            }

            if (vec0_node_ptr_)
            {
               if (v0_is_ivec)
                  vds() = vec0_node_ptr_->vds();
               else
                  vds() = vds_t(vec0_node_ptr_->base_size());

               memory_context_ = make_memory_context(vec0_node_ptr_->vec_holder(), vds());
            }

            assert(valid());
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x287330
leaq 0x24dd9c(%rip), %rax    # 0x48b2a0
movq %rax, (%r14)
leaq 0x24de12(%rip), %rax    # 0x48b320
movq %rax, 0x8(%r14)
leaq 0x24de2f(%rip), %rax    # 0x48b348
movq %rax, 0x48(%r14)
andq $0x0, 0x50(%r14)
leaq 0x58(%r14), %rbx
movq %rbx, %rdi
callq 0x211240
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x23d554
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x28(%r14), %rdi
cmpl $0x7c, %eax
jne 0x23d556
movq %rdi, 0x50(%r14)
jmp 0x23d5aa
xorl %edi, %edi
callq 0x208d51
testb %al, %al
je 0x23d5a6
movq 0x28(%r14), %rdi
testq %rdi, %rdi
je 0x23d5a6
leaq 0x211b61(%rip), %rsi    # 0x44f0d0
leaq 0x242d62(%rip), %rdx    # 0x4802d8
pushq $-0x2
popq %rcx
callq 0x118510
testq %rax, %rax
je 0x23d5a6
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq %rax, 0x50(%r14)
testq %rax, %rax
je 0x23d5fd
addq $0x30, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x211264
jmp 0x23d5e5
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x23d5fd
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x2112d8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x211264
leaq 0x8(%rsp), %rdi
callq 0x211a7c
movq 0x50(%r14), %rax
movq 0x28(%rax), %rdi
movq %rbx, %rsi
callq 0x2112ee
movq %rax, 0x60(%r14)
movq %rdx, 0x68(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x23d61e
jmp 0x23d61e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x211a7c
jmp 0x23d621
jmp 0x23d61e
jmp 0x23d61e
jmp 0x23d61e
movq %rax, %r14
movq %rbx, %rdi
callq 0x211a7c
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x23dabe
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
jbe 0x23dac8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22beac
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_binop_valvec_node<double, exprtk::details::lt_op<double>>::vec_binop_valvec_node(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
vec_binop_valvec_node(const operator_type& opr,
                               expression_ptr branch0,
                               expression_ptr branch1)
         : binary_node<T>(opr, branch0, branch1)
         , vec1_node_ptr_(0)
         {
            bool v1_is_ivec = false;

            if (is_vector_node(branch(1)))
            {
               vec1_node_ptr_ = static_cast<vector_node_ptr>(branch(1));
            }
            else if (is_ivector_node(branch(1)))
            {
               vector_interface<T>* vi = reinterpret_cast<vector_interface<T>*>(0);

               if (0 != (vi = dynamic_cast<vector_interface<T>*>(branch(1))))
               {
                  vec1_node_ptr_ = vi->vec();
                  v1_is_ivec     = true;
               }
            }

            if (vec1_node_ptr_)
            {
               if (v1_is_ivec)
                  vds() = vec1_node_ptr_->vds();
               else
                  vds() = vds_t(vec1_node_ptr_->base_size());

               memory_context_ = make_memory_context(vec1_node_ptr_->vec_holder(), vds());
            }

            assert(valid());
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r14
callq 0x287330
leaq 0x248bb0(%rip), %rax    # 0x48c278
movq %rax, (%r14)
leaq 0x248c26(%rip), %rax    # 0x48c2f8
movq %rax, 0x8(%r14)
leaq 0x248c43(%rip), %rax    # 0x48c320
movq %rax, 0x48(%r14)
andq $0x0, 0x50(%r14)
leaq 0x58(%r14), %rbx
movq %rbx, %rdi
callq 0x211240
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%r14)
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x243718
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x38(%r14), %rdi
cmpl $0x7c, %eax
jne 0x24371a
movq %rdi, 0x50(%r14)
jmp 0x24376e
xorl %edi, %edi
callq 0x208d51
testb %al, %al
je 0x24376a
movq 0x38(%r14), %rdi
testq %rdi, %rdi
je 0x24376a
leaq 0x20b99d(%rip), %rsi    # 0x44f0d0
leaq 0x23cb9e(%rip), %rdx    # 0x4802d8
pushq $-0x2
popq %rcx
callq 0x118510
testq %rax, %rax
je 0x24376a
movq (%rax), %rcx
movq %rax, %rdi
callq *0x28(%rcx)
movq %rax, 0x50(%r14)
testq %rax, %rax
je 0x2437c1
addq $0x30, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x211264
jmp 0x2437a9
movq 0x50(%r14), %rdi
testq %rdi, %rdi
je 0x2437c1
movq 0x28(%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
leaq 0x10(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x2112d8
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x211264
leaq 0x8(%rsp), %rdi
callq 0x211a7c
movq 0x50(%r14), %rax
movq 0x28(%rax), %rdi
movq %rbx, %rsi
callq 0x2112ee
movq %rax, 0x60(%r14)
movq %rdx, 0x68(%r14)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x2437e2
jmp 0x2437e2
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x211a7c
jmp 0x2437e5
jmp 0x2437e2
jmp 0x2437e2
jmp 0x2437e2
movq %rax, %r14
movq %rbx, %rdi
callq 0x211a7c
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x243c9a
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 0x243c9a
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
jbe 0x243ca4
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22beac
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x25147e
jnp 0x25149d
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0x7cd27(%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>::synthesize_strogen_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_strogen_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            switch (opr)
            {
               #define case_stmt(op0, op1)                                                      \
               case op0 : return node_allocator_->                                              \
                             allocate_ttt<typename details::str_sogens_node<Type,op1<Type> > >  \
                                (opr, branch[0], branch[1]);                                    \

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

// Assembly:
movl (%rsi), %eax
leal -0xe(%rax), %ecx
cmpl $0x7, %ecx
ja 0x2517b4
leaq 0x80a13(%rip), %rax     # 0x2d21a8
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0xe
popq %rsi
movq %rax, %rdx
jmp 0x252c9e
cmpl $0x57, %eax
je 0x251868
cmpl $0x58, %eax
je 0x251852
cmpl $0x59, %eax
jne 0x2517e1
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x59
popq %rsi
movq %rax, %rdx
jmp 0x252fce
xorl %eax, %eax
retq
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x14
popq %rsi
movq %rax, %rdx
jmp 0x252dd0
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x12
popq %rsi
movq %rax, %rdx
jmp 0x252e9c
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x10
popq %rsi
movq %rax, %rdx
jmp 0x252e36
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0xf
popq %rsi
movq %rax, %rdx
jmp 0x252d04
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x15
popq %rsi
movq %rax, %rdx
jmp 0x252d6a
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x58
popq %rsi
movq %rax, %rdx
jmp 0x252f68
movq 0x8(%rdi), %rdi
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
pushq $0x57
popq %rsi
movq %rax, %rdx
jmp 0x252f02
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rsi
leaq 0x8(%rdx), %r12
addq $0x30, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1ad9c8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1182f0
leaq 0x8(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x255302
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x251926
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
movq 0x30(%rcx), %r15
leaq 0x8(%rdx), %r12
movq 0x30(%rax), %r13
addq $0x38, %rax
pushq $0xa
popq %rbp
leaq 0x58(%rsp), %rdi
movq %rbp, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x255e28
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rsi
addq $0x30, %rsi
leaq 0x78(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r12), %rax
addq $0x50, %rax
pushq $0xa
popq %rcx
leaq 0x98(%rsp), %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
addq $0x8, %r12
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1ad9c8
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rcx
leaq 0x98(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x25674a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
leaq 0x78(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
jmp 0x251a8c
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
addq $0x30, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1182f0
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x25786e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
leaq 0x28(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x118648
jmp 0x251b32
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
addq $0x30, %rsi
leaq 0x78(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
addq $0x38, %rax
pushq $0xa
popq %rcx
leaq 0x98(%rsp), %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
addq $0x8, %r12
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rcx
leaq 0x98(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2595a4
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
leaq 0x78(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
jmp 0x251e36
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csocsr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::string_literal_node<Type>*    >(branch[0])->str  ();
                  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[0]);
            details::free_node(*node_allocator_,branch[1]);

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x128, %rsp            # imm = 0x128
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
addq $0x30, %rsi
leaq 0xb8(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r15), %rsi
addq $0x30, %rsi
leaq 0x98(%rsp), %rdi
callq 0x1182f0
leaq 0x8(%r15), %r12
movq (%r12), %rax
addq $0x50, %rax
pushq $0xa
popq %rcx
leaq 0xd8(%rsp), %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x1ad9c8
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
leaq 0x78(%rsp), %rdi
leaq 0xb8(%rsp), %rsi
callq 0x1182f0
leaq 0x58(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rcx
leaq 0xd8(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x78(%rsp), %rdx
leaq 0x58(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x25a67e
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
leaq 0x78(%rsp), %rdi
callq 0x118648
leaq 0x98(%rsp), %rdi
callq 0x118648
leaq 0xb8(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x128, %rsp            # imm = 0x128
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
jmp 0x251f64
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x118648
jmp 0x251f78
movq %rax, %rbx
jmp 0x251f85
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x118648
leaq 0xb8(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq 0x30(%rax), %r12
movq 0x30(%rcx), %r13
addq $0x38, %rax
pushq $0xa
popq %rbp
leaq 0x58(%rsp), %rdi
movq %rbp, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r15), %rdi
movq %r14, %rsi
callq 0x1ad9c8
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0x58(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r15, %rdi
movq %rbx, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x25bdac
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop