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_srosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_srosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe0, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rax
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x30(%rax), %rsi
movq 0x38(%rax), %rdx
addq %rsi, %rdx
leaq 0x50(%rsp), %rdi
callq 0x1eda34
movq (%r12), %rax
leaq 0x38(%rax), %rsi
leaq 0x90(%rsp), %rdi
movl $0xa, %ecx
rep  movsq (%rsi), %es:(%rdi)
xorl %ecx, %ecx
movb %cl, 0x38(%rax)
movq %rcx, 0x40(%rax)
movb %cl, 0x48(%rax)
movq %rcx, 0x50(%rax)
movb %cl, 0x58(%rax)
movq %rcx, 0x60(%rax)
movb %cl, 0x68(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x70(%rax)
movq %rcx, 0x80(%rax)
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2eda02
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2eda02
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2ed9fa
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2eda02
movq %r12, %rdi
callq 0x1f1690
addq $0x8, %r12
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2eda36
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2eda36
movq (%r12), %rdi
testq %rdi, %rdi
je 0x2eda2e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2eda36
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 0x2fe6da
movq %rax, %rbx
movq 0x70(%rsp), %rdi
cmpq %r12, %rdi
je 0x2eda9d
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2edab4
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 0x2edaea
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2edaea
movq %rax, %rbx
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x2edb01
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_csros_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string   s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*         >(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();

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

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

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

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

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorl %eax, %eax
leaq 0x10(%rsp), %r15
movq %rax, (%r15)
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
movq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r13
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x2c1cf4
testb %al, %al
je 0x2eea4b
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 0x2eea4b
movq 0x18(%rsp), %r12
subq 0x10(%rsp), %r12
movq 0x8(%rsp), %r14
subq (%rsp), %r14
leaq 0xd0(%rbx), %r15
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x10(%rsp), %rax
movq 0xd8(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r12, %r8
callq 0x120290
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq (%rsp), %rax
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x120190
movq 0xd8(%rbx), %rax
movq %rax, 0xb8(%rbx)
movq %rax, 0xc8(%rbx)
movsd 0xc37bd(%rip), %xmm0    # 0x3b2210
addq $0x30, %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::details::expression_node<exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::lt_op<double>>::value_type>* exprtk::details::node_allocator::allocate_tt<exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::lt_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const) const
inline expression_node<typename node_type::value_type>* allocate_tt(T1 t1, T2 t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl $0x60, %edi
callq 0x1200f0
movq %rax, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x1eda34
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x1eda34
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2f79b0
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f70fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f7113
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2f714f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2f714f
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x2f716b
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2f716b
movq %rax, %r14
movl $0x60, %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::str_xoxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>, exprtk::details::ilike_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

            if (rp1_(r0, r1, s1_.size()))
            {
               return Operation::process
                      (
                         s0_,
                         s1_.substr(r0, (r1 - r0) + 1)
                      );
            }
            else
               return T(0);
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
addq $0x48, %rdi
movq 0x30(%rbx), %rax
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
callq 0x2c1cf4
xorps %xmm0, %xmm0
testb %al, %al
je 0x2f5286
movq 0x20(%rbx), %r15
addq $0x28, %rbx
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x120510
movq (%r14), %r12
movq 0x8(%r14), %rbx
addq %r12, %rbx
movq (%r15), %r13
movq 0x8(%r15), %r15
addq %r13, %r15
xorl %ecx, %ecx
xorl %r14d, %r14d
movq %r12, 0x18(%rsp)
movq %rbx, 0x20(%rsp)
cmpq %rbx, %r12
je 0x2f5238
movsbl (%r12), %ebp
cmpq %r15, %r13
je 0x2f51d6
movsbl (%r13), %eax
movl %eax, 0x14(%rsp)
movl %ebp, %edi
movq %rcx, 0x8(%rsp)
callq 0x120450
movq %r15, %rbx
movl %eax, %r15d
movl 0x14(%rsp), %edi
callq 0x120450
cmpl %eax, %r15d
movq %rbx, %r15
movq 0x20(%rsp), %rbx
sete %al
cmpb $0x3f, %bpl
sete %cl
orb %al, %cl
cmpb $0x1, %cl
movq 0x8(%rsp), %rcx
jne 0x2f51d6
incq %r13
incq %r12
jmp 0x2f522c
movb $0x1, %al
cmpb $0x2a, %bpl
jne 0x2f522e
cmpb $0x2a, (%r12)
jne 0x2f51f0
incq %r12
cmpq %rbx, %r12
jne 0x2f51de
movq %rbx, %r12
cmpq %r15, %r13
je 0x2f5223
movb (%r12), %r14b
movsbl %r14b, %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x120450
cmpb $0x3f, %r14b
je 0x2f5223
cmpl %eax, %ebp
je 0x2f5223
incq %r13
cmpq %r15, %r13
jne 0x2f5204
movq %r15, %r13
leaq -0x1(%r12), %rcx
leaq 0x1(%r13), %r14
xorl %eax, %eax
testb %al, %al
je 0x2f5176
jmp 0x2f523d
cmpq %r15, %r13
je 0x2f5256
xorps %xmm0, %xmm0
cmpq %r15, %r13
je 0x2f525e
movq %r14, %r13
movq %rcx, %r12
testq %r14, %r14
jne 0x2f5176
jmp 0x2f525e
movsd 0xbcdc2(%rip), %xmm0    # 0x3b2020
leaq 0x48(%rsp), %rax
movq 0x18(%rsp), %rdi
cmpq %rax, %rdi
je 0x2f5286
movq 0x48(%rsp), %rsi
incq %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x1200c0
movsd 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::range_pack<double>::free()
void free()
         {
            if (n0_e.first && n0_e.second)
            {
               n0_e.first = false;

               if (
                    !is_variable_node(n0_e.second) &&
                    !is_string_node  (n0_e.second)
                  )
               {
                  destroy_node(n0_e.second);
               }
            }

            if (n1_e.first && n1_e.second)
            {
               n1_e.first = false;

               if (
                    !is_variable_node(n1_e.second) &&
                    !is_string_node  (n1_e.second)
                  )
               {
                  destroy_node(n1_e.second);
               }
            }
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpb $0x1, (%rdi)
jne 0x2f315e
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2f315e
movb $0x0, (%rbx)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2f315e
leaq 0x8(%rbx), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2f3150
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2f315e
cmpq $0x0, (%r14)
je 0x2f315e
movq %r14, %rdi
callq 0x1f1690
cmpb $0x1, 0x10(%rbx)
jne 0x2f31a8
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2f31a8
movb $0x0, 0x10(%rbx)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2f31a8
addq $0x18, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2f3193
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2f31a8
cmpq $0x0, (%rbx)
je 0x2f31a8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1f1690
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::details::ilike_op<double>>::value() const
inline bool imatch(const std::string& s1, const std::string& s2)
      {
         if (s1.size() == s2.size())
         {
            for (std::size_t i = 0; i < s1.size(); ++i)
            {
               if (std::tolower(s1[i]) != std::tolower(s2[i]))
               {
                  return false;
               }
            }

            return true;
         }

         return false;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x20(%rdi), %r12
movq 0x40(%rdi), %rax
movq (%rax), %r15
movq 0x8(%rax), %r13
addq %r15, %r13
movq 0x28(%rdi), %r14
addq %r12, %r14
xorl %ecx, %ecx
xorl %ebp, %ebp
movq %r13, 0x8(%rsp)
cmpq %r13, %r15
je 0x2f6671
movsbl (%r15), %ebx
cmpq %r14, %r12
je 0x2f6612
movsbl (%r12), %eax
movl %eax, 0x4(%rsp)
movl %ebx, %edi
movq %rcx, 0x10(%rsp)
callq 0x120450
movq %r14, %r13
movl %eax, %r14d
movl 0x4(%rsp), %edi
callq 0x120450
cmpl %eax, %r14d
movq %r13, %r14
movq 0x8(%rsp), %r13
sete %al
cmpb $0x3f, %bl
sete %cl
orb %al, %cl
cmpb $0x1, %cl
movq 0x10(%rsp), %rcx
jne 0x2f6612
incq %r12
incq %r15
jmp 0x2f6665
movb $0x1, %al
cmpb $0x2a, %bl
jne 0x2f6667
cmpb $0x2a, (%r15)
jne 0x2f662a
incq %r15
cmpq %r13, %r15
jne 0x2f6619
movq %r13, %r15
cmpq %r14, %r12
je 0x2f665c
movb (%r15), %bpl
movsbl %bpl, %edi
callq 0x120450
movl %eax, %ebx
movsbl (%r12), %edi
callq 0x120450
cmpb $0x3f, %bpl
je 0x2f665c
cmpl %eax, %ebx
je 0x2f665c
incq %r12
cmpq %r14, %r12
jne 0x2f663d
movq %r14, %r12
leaq -0x1(%r15), %rcx
leaq 0x1(%r12), %rbp
xorl %eax, %eax
testb %al, %al
je 0x2f65b4
jmp 0x2f6676
cmpq %r14, %r12
je 0x2f668f
xorps %xmm0, %xmm0
cmpq %r14, %r12
je 0x2f6697
movq %rbp, %r12
movq %rcx, %r15
testq %rbp, %rbp
jne 0x2f65b4
jmp 0x2f6697
movsd 0xbb989(%rip), %xmm0    # 0x3b2020
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_literal_node<double>::string_literal_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit string_literal_node(const std::string& v)
         : value_(v)
         {
            rp_.n0_c = std::make_pair<bool,std::size_t>(true, 0);
            rp_.n1_c = std::make_pair<bool,std::size_t>(true, v.size());
            rp_.cache.first  = rp_.n0_c.second;
            rp_.cache.second = rp_.n1_c.second;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movb %r15b, 0x10(%rdi)
movq %r15, 0x18(%rdi)
leaq 0x25a70b(%rip), %rax    # 0x551588
movq %rax, (%rdi)
leaq 0x25a771(%rip), %rax    # 0x5515f8
movq %rax, 0x8(%rdi)
leaq 0x25a78e(%rip), %rax    # 0x551620
movq %rax, 0x20(%rdi)
leaq 0x25a7bb(%rip), %rax    # 0x551658
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x1eda34
movb %r15b, 0x50(%rbx)
movq %r15, 0x58(%rbx)
movb %r15b, 0x60(%rbx)
movq %r15, 0x68(%rbx)
movq %r15, 0x78(%rbx)
movb %r15b, 0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movq %r15, 0x98(%rbx)
movb $0x1, %al
movb %al, 0x70(%rbx)
movq 0x8(%r14), %rcx
movb %al, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
movq %r15, 0x90(%rbx)
movq %rcx, 0x98(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::str_xoxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>, exprtk::details::lt_op<double>>::value_type>* exprtk::details::node_allocator::allocate_ttt<exprtk::details::str_xoxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>, exprtk::details::lt_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>) const
inline expression_node<typename node_type::value_type>* allocate_ttt(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
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl $0xb0, %edi
callq 0x1200f0
movq %rax, %rbx
leaq 0x88(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x78(%rsp), %rdi
callq 0x1eda34
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x58(%rsp), %rdi
callq 0x1eda34
leaq 0xc0(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x2fb3fc
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2faa2f
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x78(%rsp), %rdi
cmpq %r12, %rdi
je 0x2faa49
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2faa88
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2faa88
movq %rax, %r14
movq 0x78(%rsp), %rdi
cmpq %r12, %rdi
je 0x2faaa7
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x2faaa7
movq %rax, %r14
movl $0xb0, %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::str_xrox_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::details::range_pack<double>, exprtk::details::ilike_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

            if (rp0_(r0, r1, s0_.size()))
               return Operation::process(s0_.substr(r0, (r1 - r0) + 1), s1_);
            else
               return T(0);
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
addq $0x30, %rdi
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
callq 0x2c1cf4
xorps %xmm0, %xmm0
testb %al, %al
je 0x2fd2fd
movq 0x20(%rbx), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x120510
movq 0x28(%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %rbx
addq %r12, %rbx
movq (%r14), %r13
movq 0x8(%r14), %r15
addq %r13, %r15
xorl %ecx, %ecx
movq %r13, 0x18(%rsp)
xorl %r14d, %r14d
movq %rbx, 0x20(%rsp)
cmpq %rbx, %r12
je 0x2fd2af
movsbl (%r12), %ebp
cmpq %r15, %r13
je 0x2fd24d
movsbl (%r13), %eax
movl %eax, 0x14(%rsp)
movl %ebp, %edi
movq %rcx, 0x8(%rsp)
callq 0x120450
movq %r15, %rbx
movl %eax, %r15d
movl 0x14(%rsp), %edi
callq 0x120450
cmpl %eax, %r15d
movq %rbx, %r15
movq 0x20(%rsp), %rbx
sete %al
cmpb $0x3f, %bpl
sete %cl
orb %al, %cl
cmpb $0x1, %cl
movq 0x8(%rsp), %rcx
jne 0x2fd24d
incq %r13
incq %r12
jmp 0x2fd2a3
movb $0x1, %al
cmpb $0x2a, %bpl
jne 0x2fd2a5
cmpb $0x2a, (%r12)
jne 0x2fd267
incq %r12
cmpq %rbx, %r12
jne 0x2fd255
movq %rbx, %r12
cmpq %r15, %r13
je 0x2fd29a
movb (%r12), %r14b
movsbl %r14b, %edi
callq 0x120450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x120450
cmpb $0x3f, %r14b
je 0x2fd29a
cmpl %eax, %ebp
je 0x2fd29a
incq %r13
cmpq %r15, %r13
jne 0x2fd27b
movq %r15, %r13
leaq -0x1(%r12), %rcx
leaq 0x1(%r13), %r14
xorl %eax, %eax
testb %al, %al
je 0x2fd1ed
jmp 0x2fd2b4
cmpq %r15, %r13
je 0x2fd2cd
xorps %xmm0, %xmm0
cmpq %r15, %r13
je 0x2fd2d5
movq %r14, %r13
movq %rcx, %r12
testq %r14, %r14
jne 0x2fd1ed
jmp 0x2fd2d5
movsd 0xb4d4b(%rip), %xmm0    # 0x3b2020
leaq 0x48(%rsp), %rax
movq 0x18(%rsp), %rdi
cmpq %rax, %rdi
je 0x2fd2fd
movq 0x48(%rsp), %rsi
incq %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x1200c0
movsd 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::null_eq_node<double>::value() const
inline T value() const exprtk_override
         {
            const T v = branch_.first->value();
            const bool result = details::numeric::is_nan(v);

            if (result)
               return equality_ ? T(1) : T(0);
            else
               return equality_ ? T(0) : T(1);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd %xmm0, %xmm0
movb 0x20(%rbx), %al
jp 0x30a177
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x30a175
movsd 0xa7eab(%rip), %xmm0    # 0x3b2020
popq %rbx
retq
testb %al, %al
jne 0x30a16d
xorpd %xmm0, %xmm0
jmp 0x30a175
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_invalid_string_op(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3]) const
inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[3]) const
         {
            const bool b0_string = is_generally_string_node(branch[0]);
            const bool b1_string = is_generally_string_node(branch[1]);
            const bool b2_string = is_generally_string_node(branch[2]);

            bool result = false;

            if ((b0_string != b1_string) || (b1_string != b2_string))
               result = true;
            else if ((details::e_inrange != operation) && b0_string && b1_string && b2_string)
               result = true;

            if (result)
            {
               parser_->set_synthesis_error("Invalid string operation");
            }

            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbp
movq (%rdx), %rdi
movabsq $0x388fc0000, %r13      # imm = 0x388FC0000
testq %rdi, %rdi
je 0x33839c
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %r12b
cmpl $0x21, %eax
ja 0x338397
movl %eax, %ecx
btq %rcx, %r13
jb 0x33839f
cmpl $0x7b, %eax
je 0x33839f
xorl %r12d, %r12d
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x3383c2
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bl
cmpl $0x21, %eax
ja 0x3383bd
movl %eax, %ecx
btq %rcx, %r13
jb 0x3383c4
cmpl $0x7b, %eax
je 0x3383c4
xorl %ebx, %ebx
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x3383ef
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %cl
cmpl $0x21, %eax
ja 0x338485
movl %eax, %edx
btq %rdx, %r13
jae 0x338485
movq %rbp, %rsi
jmp 0x3383f4
movq %rbp, %rsi
xorl %ecx, %ecx
movl %r12d, %eax
xorb %bl, %al
movl %ebx, %edx
xorb %cl, %dl
orb %al, %dl
movb $0x1, %bpl
jne 0x338415
cmpl $0x44, (%r14)
setne %al
andb %bl, %r12b
andb %r12b, %cl
andb %al, %cl
movl %ecx, %ebp
testb %bpl, %bpl
je 0x338474
movq 0x68(%rsi), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x85cad(%rip), %rsi     # 0x3be0db
leaq 0x85cbe(%rip), %rdx     # 0x3be0f3
leaq 0x8(%rsp), %rdi
callq 0x1eabb8
cmpq $0x0, 0x518(%rbx)
jne 0x33845d
addq $0x510, %rbx            # imm = 0x510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1205a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x338474
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 %rbp, %rsi
cmpl $0x7b, %eax
je 0x3383f4
jmp 0x3383f2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x3384b0
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>::is_string_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3]) const
inline bool is_string_operation(const details::operator_type& operation, expression_node_ptr (&branch)[3]) const
         {
            const bool b0_string = is_generally_string_node(branch[0]);
            const bool b1_string = is_generally_string_node(branch[1]);
            const bool b2_string = is_generally_string_node(branch[2]);

            return (b0_string && b1_string && b2_string && (details::e_inrange == operation));
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rdi
movb $0x1, %bpl
movabsq $0x388fc0000, %r12      # imm = 0x388FC0000
movb $0x1, %r15b
testq %rdi, %rdi
je 0x3384f4
movq (%rdi), %rax
callq *0x28(%rax)
xorl %r15d, %r15d
cmpl $0x21, %eax
ja 0x33854d
movl %eax, %ecx
btq %rcx, %r12
jae 0x33854d
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x338512
movq (%rdi), %rax
callq *0x28(%rax)
xorl %ebp, %ebp
cmpl $0x21, %eax
ja 0x338557
movl %eax, %ecx
btq %rcx, %r12
jae 0x338557
movq 0x10(%r14), %rdi
movb $0x1, %cl
testq %rdi, %rdi
je 0x338532
movq (%rdi), %rax
callq *0x28(%rax)
xorl %ecx, %ecx
cmpl $0x21, %eax
ja 0x338561
movl %eax, %edx
btq %rdx, %r12
jae 0x338561
orb %bpl, %r15b
orb %cl, %r15b
je 0x33853e
xorl %eax, %eax
jmp 0x338544
cmpl $0x44, (%rbx)
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7b, %eax
je 0x3384f4
movb $0x1, %r15b
jmp 0x3384f4
cmpl $0x7b, %eax
je 0x338512
movb $0x1, %bpl
jmp 0x338512
cmpl $0x7b, %eax
je 0x338532
movb $0x1, %cl
jmp 0x338532
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
inline expression_node<typename node_type::value_type>* allocate_type(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 %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movl $0x68, %edi
callq 0x1200f0
movq %rax, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x1eda34
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1eda34
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x339876
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x339475
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x33948c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3394c9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x3394c9
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x3394e5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x3394e5
movq %rax, %r14
movl $0x68, %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::trinary_node<double>::value() const
inline T value() const exprtk_override
         {
            const T arg0 = branch_[0].first->value();
            const T arg1 = branch_[1].first->value();
            const T arg2 = branch_[2].first->value();

            switch (operation_)
            {
               case e_inrange : return (arg1 < arg0) ? T(0) : ((arg1 > arg2) ? T(0) : T(1));

               case e_clamp   : return (arg1 < arg0) ? arg0 : (arg1 > arg2 ? arg2 : arg1);

               case e_iclamp  : if ((arg1 <= arg0) || (arg1 >= arg2))
                                   return arg1;
                                else
                                   return ((T(2) * arg1  <= (arg2 + arg0)) ? arg0 : arg2);

               default        : exprtk_debug(("trinary_node::value() - Error: Invalid operation\n"));
                                return std::numeric_limits<T>::quiet_NaN();
            }
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, (%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x10(%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movl 0x20(%rbx), %eax
cmpl $0x42, %eax
je 0x339edb
cmpl $0x43, %eax
je 0x339ea0
cmpl $0x44, %eax
movapd 0x10(%rsp), %xmm2
jne 0x339f01
cmpltsd %xmm2, %xmm0
cmpltsd (%rsp), %xmm2
movsd 0x7818a(%rip), %xmm1    # 0x3b2020
andnpd %xmm1, %xmm0
andnpd %xmm0, %xmm2
jmp 0x339f09
movapd 0x10(%rsp), %xmm2
movapd (%rsp), %xmm1
ucomisd %xmm2, %xmm1
jae 0x339f09
ucomisd %xmm0, %xmm2
jae 0x339f09
addsd %xmm2, %xmm2
movapd (%rsp), %xmm3
movapd %xmm3, %xmm1
addsd %xmm0, %xmm1
cmplesd %xmm1, %xmm2
movapd %xmm2, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm0, %xmm2
jmp 0x339efb
movapd 0x10(%rsp), %xmm2
minsd %xmm2, %xmm0
movapd (%rsp), %xmm3
cmpltsd %xmm3, %xmm2
movapd %xmm2, %xmm1
andnpd %xmm0, %xmm1
andpd %xmm3, %xmm2
orpd %xmm1, %xmm2
jmp 0x339f09
movsd 0x78307(%rip), %xmm2    # 0x3b2210
movapd %xmm2, %xmm0
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::trinary_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               branch_[0].first && branch_[0].first->valid() &&
               branch_[1].first && branch_[1].first->valid() &&
               branch_[2].first && branch_[2].first->valid() ;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x339f54
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x339f54
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x339f54
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x339f54
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x339f54
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::quaternary_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               branch_[0].first && branch_[0].first->valid() &&
               branch_[1].first && branch_[1].first->valid() &&
               branch_[2].first && branch_[2].first->valid() &&
               branch_[3].first && branch_[3].first->valid() ;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x33a7e3
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x33a7e3
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x33a7e3
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x33a7e3
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x33a7e3
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x33a7e3
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x33a7e3
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::string_literal_node<double>::value_type>* exprtk::details::node_allocator::allocate_c<exprtk::details::string_literal_node<double>, char [1]>(char const (&) [1]) const
inline expression_node<typename node_type::value_type>* allocate_c(const T1& t1) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movl $0xa0, %edi
callq 0x1200f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x120200
leaq (%rax,%r14), %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1eabb8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2f6e60
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x340d3c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x340d75
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x340d75
movq %rax, %r14
movl $0xa0, %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::conditional_string_node<double>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

            if (is_true(condition_))
            {
               consequent_->value();

               const range_t& range = str0_range_ptr_->range_ref();

               if (range(r0, r1, str0_base_ptr_->size()))
               {
                  const std::size_t size = (r1 - r0);

                  value_.assign(str0_base_ptr_->base() + r0, size);

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

                  return T(1);
               }
            }
            else
            {
               alternative_->value();

               const range_t& range = str1_range_ptr_->range_ref();

               if (range(r0, r1, str1_base_ptr_->size()))
               {
                  const std::size_t size = (r1 - r0);

                  value_.assign(str1_base_ptr_->base() + r0, size);

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

                  return T(0);
               }
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x100(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x3410ab
jnp 0x341138
movq 0x108(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2c1cf4
testb %al, %al
je 0x3411cf
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
leaq 0xe0(%rbx), %r15
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x8(%rsp), %rax
movq 0xe8(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r8
callq 0x120290
movsd 0x70eed(%rip), %xmm0    # 0x3b2020
jmp 0x3411b8
movq 0x110(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2c1cf4
testb %al, %al
je 0x3411cf
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
leaq 0xe0(%rbx), %r15
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x8(%rsp), %rax
movq 0xe8(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r8
callq 0x120290
xorpd %xmm0, %xmm0
movq 0xe8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq %rax, 0xd8(%rbx)
jmp 0x3411d7
movsd 0x71039(%rip), %xmm0    # 0x3b2210
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_string_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               initialised_                         &&
               condition_  && condition_  ->valid() &&
               consequent_ && consequent_ ->valid() &&
               alternative_&& alternative_->valid() ;
         }

// Assembly:
pushq %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x341231
movq %rdi, %rbx
movq 0x100(%rdi), %rdi
testq %rdi, %rdi
je 0x341231
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341231
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x341231
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341231
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x341231
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_vector_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);
            T* source_vector = 0;
            T* result_vector = vds().data();

            if (is_true(condition_))
            {
               result           = consequent_.first->value();
               source_vector    = consequent_node_ptr_->vds().data();
               result_vec_size_ = consequent_node_ptr_->size();
            }
            else
            {
               result           = alternative_.first->value();
               source_vector    = alternative_node_ptr_->vds().data();
               result_vec_size_ = alternative_node_ptr_->size();
            }

            for (std::size_t i = 0; i < result_vec_size_; ++i)
            {
               result_vector[i] = source_vector[i];
            }

            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq 0x78(%rbx), %rax
movq 0x10(%rax), %r14
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
cmpeqsd %xmm0, %xmm1
movq %xmm1, %r15
andl $0x1, %r15d
movl %r15d, %eax
shll $0x4, %eax
movq 0x38(%rax,%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x58(%rbx,%r15,8), %rax
movq 0x28(%rax), %rcx
movq 0x30(%rax), %rax
movq 0x10(%rax), %r15
movq (%rcx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, 0x80(%rbx)
testq %rax, %rax
je 0x3417c9
xorl %ecx, %ecx
movsd (%r15,%rcx,8), %xmm0
movsd %xmm0, (%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x3417b5
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_vector_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               initialised_                                      &&
               condition_  .first && condition_  .first->valid() &&
               consequent_ .first && consequent_ .first->valid() &&
               alternative_.first && alternative_.first->valid() &&
               size() <= base_size();
         }

// Assembly:
cmpb $0x1, 0x88(%rdi)
jne 0x341865
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x341868
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341868
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x341868
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341868
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x341868
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341868
movq 0x58(%rbx), %rax
movq 0x80(%rbx), %r15
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r14
movq 0x60(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %r14, %rax
cmovbq %rax, %r14
cmpq %r14, %r15
setbe %al
jmp 0x34186a
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq