LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2], exprtk::details::expression_node<double>*&)
inline bool synthesize_expression(const details::operator_type& operation,
                                           expression_node_ptr (&branch)[2],
                                           expression_node_ptr& result)
         {
            result = error_node();

            if (!operation_optimisable(operation))
               return false;

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

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

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

               return true;
            }
            else
               return false;
         }

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

// Assembly:
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2b8bb9
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r14
testq %r14, %r14
je 0x2b8b6f
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2b8b47
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x2b8b6f
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b8b6f
leaq 0x2568d9(%rip), %rsi    # 0x50f430
leaq 0x2a0722(%rip), %rdx    # 0x559280
xorl %ecx, %ecx
callq 0x1204f0
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2b8bbe
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2b8bbc
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2b8b94
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x2b8bbc
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b8bbc
leaq 0x25688d(%rip), %rsi    # 0x50f430
leaq 0x2a06d6(%rip), %rdx    # 0x559280
xorl %ecx, %ecx
callq 0x1204f0
testq %rax, %rax
setne %al
jmp 0x2b8bbe
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::coboc_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool coboc_optimisable(const details::operator_type& operation, expression_node_ptr (&branch)[2]) const
         {
            if (
                 (details::e_add == operation) ||
                 (details::e_sub == operation) ||
                 (details::e_mul == operation) ||
                 (details::e_div == operation)
               )
            {
               return (details::is_constant_node(branch[0]) && details::is_boc_node(branch[1])) ||
                      (details::is_constant_node(branch[1]) && details::is_boc_node(branch[0])) ;
            }
            else
               return false;
         }

// Assembly:
movl (%rsi), %eax
addl $-0x2, %eax
cmpl $0x3, %eax
ja 0x2b9397
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r14
testq %r14, %r14
je 0x2b934d
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2b9325
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x2b934d
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2b934d
leaq 0x2560fb(%rip), %rsi    # 0x50f430
leaq 0x2a02ac(%rip), %rdx    # 0x5595e8
xorl %ecx, %ecx
callq 0x1204f0
movq %rax, %rcx
movb $0x1, %al
testq %rcx, %rcx
jne 0x2b939c
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x2b939a
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2b9372
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x2b939a
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2b939a
leaq 0x2560af(%rip), %rsi    # 0x50f430
leaq 0x2a0260(%rip), %rdx    # 0x5595e8
xorl %ecx, %ecx
callq 0x1204f0
testq %rax, %rax
setne %al
jmp 0x2b939c
xorl %eax, %eax
retq
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::cob_optimisable(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2]) const
inline bool operation_optimisable(const details::operator_type& operation) const
         {
            return (details::e_add  == operation) ||
                   (details::e_sub  == operation) ||
                   (details::e_mul  == operation) ||
                   (details::e_div  == operation) ||
                   (details::e_mod  == operation) ||
                   (details::e_pow  == operation) ||
                   (details::e_lt   == operation) ||
                   (details::e_lte  == operation) ||
                   (details::e_gt   == operation) ||
                   (details::e_gte  == operation) ||
                   (details::e_eq   == operation) ||
                   (details::e_ne   == operation) ||
                   (details::e_and  == operation) ||
                   (details::e_nand == operation) ||
                   (details::e_or   == operation) ||
                   (details::e_nor  == operation) ||
                   (details::e_xor  == operation) ||
                   (details::e_xnor == operation) ;
         }

// Assembly:
movl (%rsi), %ecx
xorl %eax, %eax
cmpl $0x1b, %ecx
ja 0x2ba5d1
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl $0xff5c0fc, %edx        # imm = 0xFF5C0FC
btl %ecx, %edx
jae 0x2ba5ca
movq (%rbx), %r14
testq %r14, %r14
je 0x2ba5b3
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
je 0x2ba59c
movq (%r14), %rax
movq %r14, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
jne 0x2ba5b3
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0x2ba5b7
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x2, %eax
jne 0x2ba5bb
xorl %eax, %eax
jmp 0x2ba5ca
movb $0x1, %al
jmp 0x2ba5ca
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x13, %eax
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::interval_container_t<void const*, exprtk::parser<double>::halfopen_range_policy<void const*>>::in_interval(void const*, std::pair<void const*, void const*>&) const
bool in_interval(const interval_point_t point, interval_t& interval) const
         {
            interval_map_citr_t itr = RangePolicy::end_inclusive() ?
                                      interval_map_.lower_bound(point):
                                      interval_map_.upper_bound(point);

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

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

            return false;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rdi), %rcx
addq $0x8, %r15
movq %r15, %rax
testq %rcx, %rcx
je 0x2c05fb
movq %r15, %rax
xorl %edx, %edx
cmpq %r14, 0x20(%rcx)
cmovaq %rcx, %rax
setbe %dl
movq 0x10(%rcx,%rdx,8), %rcx
testq %rcx, %rcx
jne 0x2c059f
jmp 0x2c05fb
movq 0x28(%rax), %rcx
movq 0x30(%rax), %rdx
cmpq %r14, %rcx
setbe %sil
cmpq %r14, %rdx
seta %dil
andb %sil, %dil
cmpb $0x1, %dil
jne 0x2c05e5
movq %rcx, (%rbx)
movq %rdx, 0x8(%rbx)
movl $0x1, %ecx
jmp 0x2c05ef
xorl %ecx, %ecx
cmpq %r14, %rdx
setbe %cl
addl %ecx, %ecx
testl %ecx, %ecx
jne 0x2c0602
movq %rax, %rdi
callq 0x1204c0
cmpq %r15, %rax
jne 0x2c05b8
jmp 0x2c0607
cmpl $0x2, %ecx
jne 0x2c060b
xorl %eax, %eax
jmp 0x2c060d
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::binary_node<double>::value() const
inline T value() const exprtk_override
         {
            return numeric::process<T>
                   (
                      operation_,
                      branch_[0].first->value(),
                      branch_[1].first->value()
                   );
         }

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x20(%rdi), %ebp
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movaps %xmm0, %xmm1
movl %ebp, %edi
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2c0f86
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<2ul>(std::pair<exprtk::details::expression_node<double>*, bool> const (&) [2ul]) const
std::size_t compute_node_depth(const nb_pair_t (&branch)[N]) const
         {
            if (!depth_set)
            {
               depth = 0;

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

               depth += 1;
               depth_set = true;
            }

            return depth;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpb $0x0, 0x8(%rdi)
jne 0x2c1454
movq %rsi, %r14
movq $0x0, 0x10(%rbx)
xorl %r15d, %r15d
movq (%r14,%r15), %rdi
testq %rdi, %rdi
je 0x2c1442
movq 0x8(%rdi), %rax
addq $0x8, %rdi
callq *0x10(%rax)
movq 0x10(%rbx), %rcx
cmpq %rax, %rcx
ja 0x2c143e
movq %rax, %rcx
movq %rcx, 0x10(%rbx)
addq $0x10, %r15
cmpq $0x10, %r15
je 0x2c141e
incq 0x10(%rbx)
movb $0x1, 0x8(%rbx)
movq 0x10(%rbx), %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c1cf4
testb %al, %al
je 0x2c1bcc
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 0x120290
movq 0x28(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd 0xf063c(%rip), %xmm0    # 0x3b2210
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x1, 0x20(%rdi)
jne 0x2c1d14
movq 0x28(%r15), %rax
jmp 0x2c1d29
cmpb $0x1, (%r15)
jne 0x2c1d85
movq 0x8(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cvttsd2si %xmm0, %rax
movq %rax, (%r14)
cmpb $0x1, 0x30(%r15)
jne 0x2c1d39
movq 0x38(%r15), %rax
jmp 0x2c1d4f
cmpb $0x1, 0x10(%r15)
jne 0x2c1d85
movq 0x18(%r15), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
cvttsd2si %xmm0, %rax
movq %rax, (%rbx)
movq (%r12), %rcx
cmpq $-0x1, %rax
movq %rax, %rdx
cmoveq %rcx, %rdx
cmpq $-0x1, %rcx
cmoveq %rax, %rdx
movq %rdx, (%rbx)
movq (%r14), %rax
movq %rax, 0x40(%r15)
movq (%rbx), %rax
movq %rax, 0x48(%r15)
movq (%r14), %rax
cmpq (%rbx), %rax
setbe %al
jmp 0x2c1d87
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c1cf4
testb %al, %al
je 0x2c20d0
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 0x2c1cf4
testb %al, %al
je 0x2c20d0
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 0x2c20d0
addq 0x10(%rsp), %rax
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x120100
movsd 0xf0138(%rip), %xmm0    # 0x3b2210
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::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 0x338258
leaq 0x285d87(%rip), %rax    # 0x548630
movq %rax, (%rbx)
leaq 0x285dfd(%rip), %rax    # 0x5486b0
movq %rax, 0x8(%rbx)
leaq 0x285e1a(%rip), %rax    # 0x5486d8
movq %rax, 0x48(%rbx)
movq $0x0, 0x50(%rbx)
movl $0x20, %edi
callq 0x1200f0
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 0x2c2916
leaq 0x58(%rbx), %r14
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x7c, %eax
jne 0x2c2916
movq 0x28(%rbx), %rsi
movq %rsi, 0x50(%rbx)
addq $0x30, %rsi
movq %r14, %rdi
callq 0x29fa78
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x2c2920
movq %rax, %rbx
movq %r14, %rdi
callq 0x29fb80
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c2afd
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 0x2c2afd
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2c2afd
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2c2afd
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2c2afd
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_O1/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 0x1200f0
movq %rax, %rbx
movq (%r15), %rsi
movq (%r14), %rdx
movq %rax, %rdi
callq 0x2c2c5e
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 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
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 0x28(%rax), %rdx
movq 0x30(%rax), %rax
movq 0x10(%rax), %r15
movq 0x30(%rcx), %rax
movq 0x10(%rax), %r12
movq (%rdx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, %r14
movq 0x58(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpq %r14, %rax
cmovbq %rax, %r14
testq %r14, %r14
je 0x2c3060
xorl %eax, %eax
movsd (%r15,%rax,8), %xmm0
movsd (%r12,%rax,8), %xmm1
movsd %xmm1, (%r15,%rax,8)
movsd %xmm0, (%r12,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x2c3040
movq 0x58(%rbx), %rax
movq 0x30(%rax), %rax
movq 0x10(%rax), %rax
movsd (%rax), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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 0x338258
leaq 0x2857f1(%rip), %rax    # 0x5489b8
movq %rax, (%rbx)
leaq 0x28585f(%rip), %rax    # 0x548a30
movq %rax, 0x8(%rbx)
leaq 0x28587c(%rip), %rax    # 0x548a58
movq %rax, 0x48(%rbx)
leaq 0x2858a9(%rip), %rax    # 0x548a90
movq %rax, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x60(%rbx)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2c3212
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x2c3212
movq 0x28(%rbx), %rax
movq %rax, 0x60(%rbx)
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2c322e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x2c322e
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_O1/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 0x1205f0
movsd 0xeef85(%rip), %xmm0    # 0x3b2210
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c3a40
leaq 0xf11cc(%rip), %rax     # 0x3b4b98
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0xf3285(%rip), %rsi     # 0x3b6c61
leaq 0xf3280(%rip), %rdx     # 0x3b6c63
jmp 0x2c3a33
leaq 0xf3281(%rip), %rsi     # 0x3b6c6d
leaq 0xf327c(%rip), %rdx     # 0x3b6c6f
jmp 0x2c3a33
leaq 0xf326b(%rip), %rsi     # 0x3b6c67
leaq 0xf3266(%rip), %rdx     # 0x3b6c69
jmp 0x2c3a33
leaq 0xf325e(%rip), %rsi     # 0x3b6c6a
leaq 0xf3259(%rip), %rdx     # 0x3b6c6c
jmp 0x2c3a33
leaq 0xf3248(%rip), %rsi     # 0x3b6c64
leaq 0xf3243(%rip), %rdx     # 0x3b6c66
jmp 0x2c3a33
leaq 0xf3244(%rip), %rsi     # 0x3b6c70
leaq 0xf323f(%rip), %rdx     # 0x3b6c72
movq %rbx, %rdi
callq 0x1eabb8
movq %rbx, %rax
popq %rbx
retq
leaq 0x10878e(%rip), %rdx    # 0x3cc1d5
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x2c3a36
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1200f0
movq %rax, %rbx
movq (%r15), %rdx
movq (%r14), %rcx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2c5856
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 0x1200c0
movq %r14, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2ca441
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 0x2ca441
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca441
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2ca441
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2ca441
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_O1/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 0x2d602b
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 0x2d602b
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2d602b
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2d602b
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2d602b
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_O1/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 0x2dcf01
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 0x2dcf01
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 0x2dcf01
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2dcf01
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x2dcf01
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x2dcf01
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_O1/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 0x2ebf30
jnp 0x2ebf4f
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpneqsd %xmm0, %xmm1
movsd 0xc60d5(%rip), %xmm0    # 0x3b2020
andpd %xmm1, %xmm0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1eda34
movq 0x8(%r12), %rdi
testq %rdi, %rdi
je 0x2ec8c0
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2ec8c0
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ec8b8
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2ec8c0
movq %r12, %rdi
callq 0x1f1690
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x1eda34
leaq 0x20(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x2f1a88
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ec90d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2ec923
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
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 0x2ec953
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2ec953
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2ec969
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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 0x2eca07
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2eca07
addq $0x8, %r13
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2ec9ff
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2eca07
movq %r13, %rdi
callq 0x1f1690
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 0x2f2ee6
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1eda34
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 0x2ecaf8
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2ecaf8
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ecaf0
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2ecaf8
movq %r12, %rdi
callq 0x1f1690
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0x1eda34
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 0x2f3c14
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ecb5f
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ecb76
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1200c0
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 0x2ecbac
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2ecbac
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ecbc3
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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 0x1eda34
movq (%r12), %rdi
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
testq %rdi, %rdi
je 0x2ecc3a
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2ecc3a
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ecc32
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2ecc3a
movq %r12, %rdi
callq 0x1f1690
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x1eda34
leaq 0x20(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x2f52ca
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ecc87
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2ecc9d
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
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 0x2ecccd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2ecccd
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x2ecce3
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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 0x1eda34
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 0x2ed3a9
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2ed3a9
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ed3a1
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2ed3a9
movq %r12, %rdi
callq 0x1f1690
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ed3dd
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2ed3dd
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ed3d5
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2ed3dd
movq %r12, %rdi
callq 0x1f1690
leaq 0x80(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x50(%rsp), %rsi
movq 0x58(%rsp), %rdx
addq %rsi, %rdx
leaq 0x70(%rsp), %rdi
callq 0x1eda34
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 0x2f8b40
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ed444
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ed45b
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1200c0
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 0x2ed491
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2ed491
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2ed4a8
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 0x2ed7cc
movq %rdx, %r13
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2ed7cc
movq (%r13), %rdi
testq %rdi, %rdi
je 0x2ed7c4
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2ed7cc
movq %r13, %rdi
callq 0x1f1690
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 0x2fc6d6
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq