LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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, 0xa0(%rsp)
movq %rdi, %r14
movq (%rdx), %rax
movq 0x8(%rdx), %rdx
movq 0x30(%rax), %r15
leaq 0x8(%rbp), %rbx
movq 0x30(%rdx), %r12
addq $0x38, %rax
pushq $0xa
popq %r13
leaq 0xf8(%rsp), %rdi
movq %r13, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x38, %rdx
leaq 0xa8(%rsp), %rdi
movq %r13, %rcx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%rbp), %rdi
addq $0x38, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %rbp, %rsi
callq 0x1ad9c8
movq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x1ad9c8
movq %r13, %rcx
movq %rsp, %rdi
leaq 0xf8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rsp), %rdi
movq %r13, %rcx
leaq 0xa8(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %r14, %rdi
movq 0xa0(%rsp), %rsi
movq %r15, %rdx
movq %r12, %rcx
callq 0x25c612
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rsi
addq $0x30, %rsi
leaq 0x78(%rsp), %rdi
callq 0x1182f0
movq (%r12), %rax
addq $0x38, %rax
pushq $0xa
popq %rcx
leaq 0x98(%rsp), %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1ad9c8
addq $0x8, %r12
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1ad9c8
leaq 0x58(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rcx
leaq 0x98(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x58(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x25d384
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
leaq 0x78(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x118648
jmp 0x2521d3
movq %rax, %rbx
leaq 0x78(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_srocsr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_srocsr_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::const_string_range_node<Type>*>(branch[1])->str  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*      >(branch[0])->range();
            range_t      rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdx), %rax
movq 0x30(%rax), %r14
movq 0x8(%rdx), %rsi
addq $0x30, %rsi
leaq 0xc0(%rsp), %rdi
callq 0x1182f0
movq (%r12), %rax
addq $0x38, %rax
pushq $0xa
popq %rdx
leaq 0x130(%rsp), %rdi
movq %rdx, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x8(%r12), %rsi
addq $0x50, %rsi
leaq 0xe0(%rsp), %rdi
movq %rdx, %rcx
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
leaq 0x8(%r12), %r13
movq (%r13), %rdi
addq $0x50, %rdi
callq 0x255dfe
movq 0x8(%r15), %rdi
movq %r12, %rsi
callq 0x1ad9c8
movq 0x8(%r15), %rdi
movq %r13, %rsi
callq 0x1ad9c8
leaq 0xa0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rax
leaq 0x130(%rsp), %rsi
movq %rax, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movq %rax, %rcx
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rcx
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x25e45e
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x118648
leaq 0xc0(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x118648
jmp 0x252318
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csrosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csrosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string  s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
                  std::string& s1 = static_cast<details::string_range_node<Type>*      >(branch[1])->ref  ();
            const range_t     rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();
            const range_t     rp1 = static_cast<details::string_range_node<Type>*      >(branch[1])->range();

            static_cast<details::const_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<const std::string,std::string&>(opr, s0, s1, rp0, rp1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
addq $0x30, %rsi
leaq 0xc0(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r12), %rax
movq 0x30(%rax), %r15
movq (%r12), %rdx
addq $0x50, %rdx
pushq $0xa
popq %r8
leaq 0x130(%rsp), %rdi
movq %r8, %rcx
movq %rdx, %rsi
rep  movsq (%rsi), %es:(%rdi)
addq $0x38, %rax
leaq 0xe0(%rsp), %rdi
movq %r8, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rdx, %rdi
callq 0x255dfe
leaq 0x8(%r12), %r13
movq (%r13), %rdi
addq $0x38, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %r12, %rsi
callq 0x1ad9c8
movq 0x8(%r14), %rdi
movq %r13, %rsi
callq 0x1ad9c8
leaq 0xa0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rax
leaq 0x130(%rsp), %rsi
movq %rax, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
movq %rax, %rcx
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x260c18
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x118648
leaq 0xc0(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x118648
jmp 0x25253e
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csrocs_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csrocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            const std::string s1 = static_cast<details::string_literal_node<Type>*    >(branch[1])->str  ();
            const 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_all_nodes(*node_allocator_,branch);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x120, %rsp            # imm = 0x120
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
addq $0x30, %rsi
leaq 0xb0(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r15), %rsi
addq $0x30, %rsi
leaq 0x90(%rsp), %rdi
callq 0x1182f0
movq (%r15), %rax
addq $0x50, %rax
pushq $0xa
popq %rcx
leaq 0xd0(%rsp), %rdi
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x22bbb4
leaq 0x70(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x1182f0
leaq 0x50(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rcx
leaq 0xd0(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x26231c
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
leaq 0x70(%rsp), %rdi
callq 0x118648
leaq 0x90(%rsp), %rdi
callq 0x118648
leaq 0xb0(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
jmp 0x25265b
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x118648
jmp 0x25266f
movq %rax, %rbx
jmp 0x25267c
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x118648
leaq 0xb0(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csrocsr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csrocsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            const std::string s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            const std::string s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            const range_t    rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();
            const range_t    rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();

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

            details::free_all_nodes(*node_allocator_,branch);

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdx), %rsi
addq $0x30, %rsi
leaq 0x100(%rsp), %rdi
callq 0x1182f0
movq 0x8(%r15), %rsi
addq $0x30, %rsi
leaq 0xe0(%rsp), %rdi
callq 0x1182f0
movq (%r15), %rax
addq $0x50, %rax
pushq $0xa
popq %rdx
leaq 0x170(%rsp), %rdi
movq %rdx, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq 0x8(%r15), %rsi
addq $0x50, %rsi
leaq 0x120(%rsp), %rdi
movq %rdx, %rcx
rep  movsq (%rsi), %es:(%rdi)
movq %rax, %rdi
callq 0x255dfe
movq 0x8(%r15), %rdi
addq $0x50, %rdi
callq 0x255dfe
movq 0x8(%r14), %rdi
movq %r15, %rsi
callq 0x22bbb4
leaq 0xc0(%rsp), %rdi
leaq 0x100(%rsp), %rsi
callq 0x1182f0
leaq 0xa0(%rsp), %rdi
leaq 0xe0(%rsp), %rsi
callq 0x1182f0
pushq $0xa
popq %rax
leaq 0x170(%rsp), %rsi
movq %rax, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x50(%rsp), %rdi
leaq 0x120(%rsp), %rsi
movq %rax, %rcx
rep  movsq (%rsi), %es:(%rdi)
leaq 0xc0(%rsp), %rdx
leaq 0xa0(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x263a4a
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x118648
leaq 0xc0(%rsp), %rdi
callq 0x118648
leaq 0xe0(%rsp), %rdi
callq 0x118648
leaq 0x100(%rsp), %rdi
callq 0x118648
movq %rbx, %rax
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0xa0(%rsp), %rdi
callq 0x118648
jmp 0x2527ea
movq %rax, %rbx
leaq 0xc0(%rsp), %rdi
callq 0x118648
jmp 0x252801
movq %rax, %rbx
jmp 0x25280e
movq %rax, %rbx
leaq 0xe0(%rsp), %rdi
callq 0x118648
leaq 0x100(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
leaq 0x10(%rsp), %r15
andq $0x0, (%r15)
leaq 0x18(%rsp), %r12
andq $0x0, (%r12)
andq $0x0, (%rsp)
andq $0x0, 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 0x22cc40
testb %al, %al
je 0x252bce
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x22cc40
testb %al, %al
je 0x252bce
movq 0x18(%rsp), %r15
subq 0x10(%rsp), %r15
movq 0x8(%rsp), %r14
subq (%rsp), %r14
leaq 0xd0(%rbx), %r12
movq 0x60(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x10(%rsp), %rax
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
callq 0x1182b0
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq (%rsp), %rax
movq %r12, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x118190
movq 0xd8(%rbx), %rax
movq %rax, 0xb8(%rbx)
movq %rax, 0xc8(%rbx)
movsd 0x7b6ea(%rip), %xmm0    # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<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::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>>&, 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>>&, 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>>&, 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 %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movl $0x98, %edi
callq 0x118100
movq %rax, %rbx
movq %rsp, %rdi
movq %r15, %rsi
callq 0x1182f0
movb $0x0, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
leaq 0x239379(%rip), %rax    # 0x48fdd0
movq %rax, (%rbx)
leaq 0x2393bf(%rip), %rax    # 0x48fe20
movq %rax, 0x8(%rbx)
movq %r14, 0x20(%rbx)
leaq 0x28(%rbx), %rdi
movq %rsp, %rsi
callq 0x1182f0
leaq 0x40(%rsp), %rsi
leaq 0x8(%rbx), %r14
movq %rbx, %rdi
addq $0x48, %rdi
pushq $0xa
popq %rcx
rep  movsq (%rsi), %es:(%rdi)
movq %rsp, %rdi
callq 0x118648
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x118648
jmp 0x256aba
movq %rax, %r14
movl $0x98, %esi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_sogens_node<double, exprtk::details::like_op<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_);
            const range_t& range1 = (*str1_range_ptr_);

            if (
                 range0(str0_r0, str0_r1, str0_base_ptr_->size()) &&
                 range1(str1_r0, str1_r1, str1_base_ptr_->size())
               )
            {
               return Operation::process
                      (
                         str0_base_ptr_->str().substr(str0_r0,(str0_r1 - str0_r0)),
                         str1_base_ptr_->str().substr(str1_r0,(str1_r1 - str1_r0))
                      );
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x28(%rsp), %r15
andq $0x0, (%r15)
leaq 0x20(%rsp), %r12
andq $0x0, (%r12)
andq $0x0, 0x10(%rsp)
andq $0x0, 0x8(%rsp)
movq 0x58(%rbx), %r13
movq 0x60(%rbx), %r14
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x30(%rsp), %rcx
movq %rax, (%rcx)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x22cc40
testb %al, %al
je 0x2548c3
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x90(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0x22cc40
testb %al, %al
je 0x2548c3
movq 0x48(%rbx), %rsi
movq (%rsi), %rax
leaq 0x90(%rsp), %r14
movq %r14, %rdi
callq *0x10(%rax)
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rdx, %rcx
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x118530
movq 0x50(%rbx), %rsi
movq (%rsi), %rax
leaq 0x50(%rsp), %rdi
callq *0x10(%rax)
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
subq %rdx, %rcx
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x118530
leaq 0x30(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x254936
movsd %xmm0, 0x18(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x118648
leaq 0x50(%rsp), %rdi
callq 0x118648
leaq 0x30(%rsp), %rdi
callq 0x118648
leaq 0x90(%rsp), %rdi
callq 0x118648
movsd 0x18(%rsp), %xmm0
jmp 0x2548cb
movsd 0x799f5(%rip), %xmm0    # 0x2ce2c0
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x118648
jmp 0x2548ee
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
jmp 0x2548fd
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x118648
jmp 0x25490c
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::wc_match(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&)
inline bool wc_match(const std::string& wild_card,
                           const std::string& str)
      {
         return match_impl<char_cptr,cs_match>
                (
                   wild_card.data(),
                   wild_card.data() + wild_card.size(),
                   str.data(),
                   str.data() + str.size(),
                   '*', '?'
                );
      }

// Assembly:
pushq %rax
movq (%rdi), %rax
movq 0x8(%rdi), %r10
addq %rax, %r10
movq (%rsi), %rdx
movq 0x8(%rsi), %rcx
addq %rdx, %rcx
leaq 0x7(%rsp), %r8
movb $0x2a, (%r8)
leaq 0x6(%rsp), %r9
movb $0x3f, (%r9)
movq %rax, %rdi
movq %r10, %rsi
callq 0x25498c
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
pushq $0x60
popq %rdi
callq 0x118100
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1182f0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1182f0
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x258f1a
movq %rsp, %rdi
callq 0x118648
leaq 0x20(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x118648
jmp 0x2589e7
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x118648
jmp 0x2589f6
movq %rax, %r14
pushq $0x60
popq %rsi
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::range_pack<double>::clear()
void clear()
         {
            n0_e  = std::make_pair(false,expression_node_ptr(0));
            n1_e  = std::make_pair(false,expression_node_ptr(0));
            n0_c  = std::make_pair(false,0);
            n1_c  = std::make_pair(false,0);
            cache = std::make_pair(0,0);
         }

// Assembly:
xorl %eax, %eax
movb %al, (%rdi)
andq $0x0, 0x8(%rdi)
movb %al, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb %al, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x38(%rdi)
andq $0x0, 0x48(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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::like_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 %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x18(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x10(%rsp), %rdx
andq $0x0, (%rdx)
addq $0x48, %rdi
movq 0x30(%rbx), %rax
leaq 0x20(%rsp), %rcx
movq %rax, (%rcx)
callq 0x22cc40
xorps %xmm0, %xmm0
testb %al, %al
je 0x25773b
movq 0x20(%rbx), %r14
addq $0x28, %rbx
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x118530
movq %r14, %rdi
movq %r15, %rsi
callq 0x254936
movsd %xmm0, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x118648
movsd 0x8(%rsp), %xmm0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x256046
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x256046
movb $0x0, (%rbx)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x256046
leaq 0x8(%rbx), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x25603e
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x256046
movq %r14, %rdi
callq 0x198320
cmpb $0x1, 0x10(%rbx)
jne 0x25607b
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x25607b
movb $0x0, 0x10(%rbx)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x25607b
addq $0x18, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x256083
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
jne 0x256083
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x198320
// File: /workspace/github_cpp_makefile_star2_O2/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
movb $0x0, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
leaq 0x237fa9(%rip), %rax    # 0x4907f0
movq %rax, (%rdi)
leaq 0x23800f(%rip), %rax    # 0x490860
movq %rax, 0x8(%rdi)
leaq 0x23802c(%rip), %rax    # 0x490888
movq %rax, 0x20(%rdi)
leaq 0x238059(%rip), %rax    # 0x4908c0
movq %rax, 0x28(%rdi)
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x1182f0
leaq 0x50(%rbx), %rdi
callq 0x252a68
movb $0x1, %al
movb %al, 0x70(%rbx)
andq $0x0, 0x78(%rbx)
movq 0x8(%r14), %rcx
movb %al, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
andq $0x0, 0x90(%rbx)
movq %rcx, 0x98(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/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::like_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 %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x8(%rsp), %rdx
andq $0x0, (%rdx)
addq $0x30, %rdi
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
callq 0x22cc40
xorps %xmm0, %xmm0
testb %al, %al
je 0x25c4f7
movq 0x20(%rbx), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x18(%rsp), %r14
movq %r14, %rdi
callq 0x118530
movq 0x28(%rbx), %rsi
movq %r14, %rdi
callq 0x254936
movsd %xmm0, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x118648
movsd (%rsp), %xmm0
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_xroxr_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::like_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0_0 = 0;
            std::size_t r0_1 = 0;
            std::size_t r1_0 = 0;
            std::size_t r1_1 = 0;

            if (
                 rp0_(r0_0, r1_0, s0_.size()) &&
                 rp1_(r0_1, r1_1, s1_.size())
               )
            {
               return Operation::process
                      (
                         s0_.substr(r0_0, (r1_0 - r0_0) + 1),
                         s1_.substr(r0_1, (r1_1 - r0_1) + 1)
                      );
            }
            else
               return T(0);
         }

// Assembly:
pushq %rbx
subq $0x70, %rsp
leaq 0x28(%rsp), %rsi
andq $0x0, (%rsi)
movq %rdi, %rbx
andq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
andq $0x0, 0x8(%rsp)
addq $0x48, %rdi
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
leaq 0x50(%rsp), %rcx
movq %rax, (%rcx)
callq 0x22cc40
testb %al, %al
je 0x25f9be
leaq 0x98(%rbx), %rdi
movq 0x30(%rbx), %rax
leaq 0x30(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x22cc40
xorps %xmm0, %xmm0
testb %al, %al
je 0x25f9c1
movq 0x20(%rbx), %rsi
addq $0x28, %rbx
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x50(%rsp), %rdi
callq 0x118530
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x118530
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x254936
movsd %xmm0, 0x18(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x118648
leaq 0x50(%rsp), %rdi
callq 0x118648
movsd 0x18(%rsp), %xmm0
jmp 0x25f9c1
xorps %xmm0, %xmm0
addq $0x70, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x118648
jmp 0x25f9d9
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::str_xroxr_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_tttt<exprtk::details::str_xroxr_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>, 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>, exprtk::details::range_pack<double>) const
inline expression_node<typename node_type::value_type>* allocate_tttt(T1 t1, T2 t2, T3 t3, T4 t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl $0x100, %edi            # imm = 0x100
callq 0x118100
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
callq 0x1182f0
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1182f0
movb $0x0, 0x10(%rbx)
andq $0x0, 0x18(%rbx)
leaq 0x22fc3a(%rip), %rax    # 0x493bd8
movq %rax, (%rbx)
leaq 0x22fc80(%rip), %rax    # 0x493c28
movq %rax, 0x8(%rbx)
leaq 0x20(%rbx), %r15
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0x1182f0
leaq 0x40(%rbx), %rdi
movq %rsp, %rsi
callq 0x1182f0
leaq 0xb0(%rsp), %rax
leaq 0x60(%rsp), %rsi
leaq 0x8(%rbx), %r14
leaq 0x60(%rbx), %rdi
pushq $0xa
popq %rdx
movq %rdx, %rcx
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
addq $0xb0, %rdi
movq %rdx, %rcx
movq %rax, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rsp, %rdi
callq 0x118648
leaq 0x20(%rsp), %rdi
callq 0x118648
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x118648
jmp 0x264033
movq %rax, %r14
movq %rsp, %rdi
callq 0x118648
jmp 0x264040
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x118648
jmp 0x26404f
movq %rax, %r14
movl $0x100, %esi            # imm = 0x100
movq %rbx, %rdi
callq 0x1180d0
movq %r14, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x265645
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x265643
movsd 0x68b7d(%rip), %xmm0    # 0x2ce1c0
popq %rbx
retq
testb %al, %al
jne 0x26563b
xorpd %xmm0, %xmm0
jmp 0x265643
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::valid_operator(exprtk::details::operator_type const&, double (*&)(double const&))
inline bool valid_operator(const details::operator_type& operation, unary_functor_t& uop)
         {
            typename unary_op_map_t::iterator uop_itr = unary_op_map_->find(operation);

            if ((*unary_op_map_).end() == uop_itr)
               return false;

            uop = uop_itr->second;

            return true;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x40(%rdi), %rdi
callq 0x26d966
movq 0x40(%r14), %rcx
addq $0x8, %rcx
cmpq %rax, %rcx
je 0x26d8f1
movq 0x28(%rax), %rdx
movq %rdx, (%rbx)
cmpq %rax, %rcx
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::uvouv_node<double>::value_type>* exprtk::details::node_allocator::allocate_rrrrr<exprtk::details::uvouv_node<double>, double const, double const, double (*)(double const&), double (*)(double const&), double (*)(double const&, double const&)>(double const&, double const&, double (*&)(double const&), double (*&)(double const&), double (*&)(double const&, double const&)) const
inline expression_node<typename node_type::value_type>* allocate_rrrrr(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r9, %rbx
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rsi, %r13
pushq $0x48
popq %rdi
callq 0x118100
movq (%r15), %rcx
movq (%r14), %rdx
movq (%rbx), %rsi
movb $0x0, 0x10(%rax)
andq $0x0, 0x18(%rax)
leaq 0x22af5f(%rip), %rdi    # 0x498898
movq %rdi, (%rax)
leaq 0x22af9d(%rip), %rdi    # 0x4988e0
movq %rdi, 0x8(%rax)
movq %r13, 0x20(%rax)
movq %r12, 0x28(%rax)
movq %rcx, 0x30(%rax)
movq %rdx, 0x38(%rax)
movq %rsi, 0x40(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf4ext_expression::compile_right_impl<exprtk::details::sf3ext_type_node<double, double const, double const&, double const>, double const&, double const, double const&, double const>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&)
static inline bool compile_right_impl(expression_generator<Type>& expr_gen,
                                                  const std::string& id,
                                                  ExternalType t,
                                                  expression_node_ptr& node,
                                                  expression_node_ptr& result)
            {
               SF3TypeNode* n = dynamic_cast<SF3TypeNode*>(node);

               if (n)
               {
                  T0 t0 = n->t0();
                  T1 t1 = n->t1();
                  T2 t2 = n->t2();

                  return synthesize_sf4ext_expression::template compile<ExternalType, T0, T1, T2>
                            (expr_gen, id, t, t0, t1, t2, result);
               }
               else
                  return false;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x26e26d
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1e0ec8(%rip), %rsi    # 0x44f0d0
leaq 0x1ed859(%rip), %rdx    # 0x45ba68
xorl %ecx, %ecx
callq 0x118510
testq %rax, %rax
je 0x26e26d
movq %rax, %r13
movq (%rax), %rax
movq %r13, %rdi
callq *0x40(%rax)
movsd %xmm0, (%rsp)
movq (%r13), %rax
movq %r13, %rdi
callq *0x48(%rax)
movq %rax, %rbp
movq (%r13), %rax
movq %r13, %rdi
callq *0x50(%rax)
movaps %xmm0, %xmm1
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movsd (%rsp), %xmm0
movq %rbp, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1dbff2
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf4ext_expression::compile_left_impl<exprtk::details::sf3ext_type_node<double, double const, double const&, double const>, double const&, double const, double const&, double const>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&)
static inline bool compile_left_impl(expression_generator<Type>& expr_gen,
                                                 const std::string& id,
                                                 ExternalType t,
                                                 expression_node_ptr& node,
                                                 expression_node_ptr& result)
            {
               SF3TypeNode* n = dynamic_cast<SF3TypeNode*>(node);

               if (n)
               {
                  T0 t0 = n->t0();
                  T1 t1 = n->t1();
                  T2 t2 = n->t2();

                  return synthesize_sf4ext_expression::template compile<T0, T1, T2, ExternalType>
                            (expr_gen, id, t0, t1, t2, t, result);
               }
               else
                  return false;
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r12
movq (%rcx), %rdi
testq %rdi, %rdi
je 0x26fae1
movq %r8, %rbx
movq %rdx, %r14
movq %rsi, %r15
leaq 0x1df654(%rip), %rsi    # 0x44f0d0
leaq 0x1ebfe5(%rip), %rdx    # 0x45ba68
xorl %ecx, %ecx
callq 0x118510
testq %rax, %rax
je 0x26fae1
movq %rax, %r13
movq (%rax), %rax
movq %r13, %rdi
callq *0x40(%rax)
movsd %xmm0, (%rsp)
movq (%r13), %rax
movq %r13, %rdi
callq *0x48(%rax)
movq %rax, %rbp
movq (%r13), %rax
movq %r13, %rdi
callq *0x50(%rax)
movaps %xmm0, %xmm1
movq %r12, %rdi
movq %r15, %rsi
movsd (%rsp), %xmm0
movq %rbp, %rdx
movq %r14, %rcx
movq %rbx, %r8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1d7286
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
callq 0x20b691
movl %eax, %ebp
movq 0x8(%r12), %rdi
callq 0x20b691
movl %eax, %r15d
movq 0x10(%r12), %rdi
callq 0x20b691
movl %ebp, %ecx
xorb %r15b, %cl
movl %r15d, %edx
xorb %al, %dl
orb %cl, %dl
jne 0x287422
cmpl $0x44, (%r14)
setne %cl
andb %r15b, %bpl
andb %cl, %bpl
andb %bpl, %al
cmpb $0x1, %al
jne 0x287458
movq 0x68(%rbx), %rbx
leaq 0x533e2(%rip), %rsi     # 0x2da80f
leaq 0x10(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x127016
movq %rbx, %rdi
movq %r14, %rsi
callq 0x229d82
leaq 0x10(%rsp), %rdi
callq 0x118648
movb $0x1, %al
jmp 0x28745a
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::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 %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rdi
callq 0x20b691
movl %eax, %r15d
movq 0x8(%r14), %rdi
callq 0x20b691
movl %eax, %ebp
movq 0x10(%r14), %rdi
callq 0x20b691
movl %eax, %ecx
xorl %eax, %eax
testb %r15b, %r15b
je 0x2874c0
testb %bpl, %bpl
je 0x2874c0
testb %cl, %cl
je 0x2874c0
cmpl $0x44, (%rbx)
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop