LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_node<double>::conditional_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
conditional_node(expression_ptr condition,
                          expression_ptr consequent,
                          expression_ptr alternative)
         {
            construct_branch_pair(condition_  , condition  );
            construct_branch_pair(consequent_ , consequent );
            construct_branch_pair(alternative_, alternative);
            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r15
movq %rdi, %r14
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x2296a4(%rip), %rcx    # 0x56b150
movq %rcx, (%rdi)
leaq 0x2296ea(%rip), %rcx    # 0x56b1a0
movq %rcx, 0x8(%rdi)
movb %al, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
testq %rsi, %rsi
je 0x341afd
movq %rsi, %r12
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x341ae5
xorl %eax, %eax
jmp 0x341af5
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, 0x20(%r14)
movb %al, 0x28(%r14)
testq %r15, %r15
je 0x341b2b
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x341b14
xorl %eax, %eax
jmp 0x341b23
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r15, 0x30(%r14)
movb %al, 0x38(%r14)
testq %rbx, %rbx
je 0x341b59
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x341b42
xorl %eax, %eax
jmp 0x341b51
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %rbx, 0x40(%r14)
movb %al, 0x48(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               condition_  .first && condition_  .first->valid() &&
               consequent_ .first && consequent_ .first->valid() &&
               alternative_.first && alternative_.first->valid() ;
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x341c50
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341c50
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x341c50
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x341c50
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x341c50
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::cons_conditional_node<double>::value() const
inline T value() const exprtk_override
         {
            if (is_true(condition_))
               return consequent_.first->value();
            else
               return std::numeric_limits<T>::quiet_NaN();
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x341dda
jnp 0x341de5
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
movsd 0x70423(%rip), %xmm0    # 0x3b2210
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {

            T result = T(0);

            loop_runtime_checker::reset();

            while (is_true(parent_t::condition_) && loop_runtime_checker::check())
            {
               result = parent_t::loop_body_.first->value();
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq $0x0, 0x40(%rdi)
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x342cf4
jnp 0x342d80
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
cmpq (%rcx), %rax
ja 0x342d5f
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x342d5f
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6f4b1(%rip), %xmm0    # 0x3b21f8
jne 0x342d4b
jnp 0x342d7a
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
jbe 0x342d18
movl 0x58(%rbx), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            while (is_true(condition_))
            {
               result = loop_body_.first->value();
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x342e58
jnp 0x342e84
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6f37e(%rip), %xmm0    # 0x3b21f8
jne 0x342e58
jp 0x342e58
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            while (is_true(parent_t::condition_) && loop_runtime_checker::check())
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq $0x0, 0x40(%rdi)
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm2, %xmm2
xorps %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm2, %xmm0
jne 0x342fa7
jnp 0x34302e
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
ja 0x343013
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x343013
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6f204(%rip), %xmm0    # 0x3b21f8
jne 0x342fb1
jp 0x342fb1
jmp 0x34302e
movq %rax, %rdi
cmpl $0x2, %edx
je 0x34303a
cmpl $0x1, %edx
jne 0x343050
callq 0x120070
callq 0x1203d0
jmp 0x342fe2
movl 0x58(%rbx), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
callq 0x120070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1203d0
jmp 0x34302e
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::while_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            while (is_true(parent_t::condition_))
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm2, %xmm2
xorps %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
ucomisd %xmm2, %xmm0
jne 0x3430cf
jnp 0x34312e
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6f0fd(%rip), %xmm0    # 0x3b21f8
jne 0x3430d9
jp 0x3430d9
jmp 0x34312e
movq %rax, %rdi
cmpl $0x2, %edx
je 0x34311a
cmpl $0x1, %edx
jne 0x34313a
callq 0x120070
callq 0x1203d0
jmp 0x3430e9
callq 0x120070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1203d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset(1);

            do
            {
               result = parent_t::loop_body_.first->value();
            }
            while (is_false(parent_t::condition_.first) && loop_runtime_checker::check());

            return result;
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq $0x1, 0x40(%rdi)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6ed20(%rip), %xmm0    # 0x3b21f8
jne 0x343518
jp 0x343518
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
ja 0x3434fd
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x3434b6
movl 0x58(%rbx), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            do
            {
               result = loop_body_.first->value();
            }
            while (is_false(condition_.first));

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6ebfa(%rip), %xmm0    # 0x3b21f8
jne 0x343602
jnp 0x3435dc
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_bc_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            do
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }
            while (is_false(parent_t::condition_.first) && loop_runtime_checker::check());

            return result;
         }

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq $0x0, 0x40(%rdi)
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6eac8(%rip), %xmm0    # 0x3b21f8
jne 0x34378b
jp 0x34378b
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
ja 0x343770
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x34370e
jmp 0x343770
movq %rax, %rdi
cmpl $0x2, %edx
je 0x343797
cmpl $0x1, %edx
jne 0x3437ad
callq 0x120070
callq 0x1203d0
jmp 0x34371e
movl 0x58(%rbx), %eax
leaq 0x10(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd 0x8(%rsp), %xmm0
addq $0x20, %rsp
popq %rbx
retq
callq 0x120070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1203d0
jmp 0x34378b
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::repeat_until_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            do
            {
               try
               {
                  result = parent_t::loop_body_.first->value();
               }
               catch(const break_exception<T>& e)
               {
                  return e.value;
               }
               catch(const continue_exception&)
               {}
            }
            while (is_false(parent_t::condition_.first));

            return result;
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6e9c0(%rip), %xmm0    # 0x3b21f8
jne 0x34386b
jnp 0x343816
jmp 0x34386b
movq %rax, %rdi
cmpl $0x2, %edx
je 0x343857
cmpl $0x1, %edx
jne 0x343877
callq 0x120070
callq 0x1203d0
jmp 0x343826
callq 0x120070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x1203d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_element(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long)
inline scope_element& get_element(const std::string& var_name,
                                           const std::size_t index = std::numeric_limits<std::size_t>::max())
         {
            const std::size_t current_depth = parser_.state_.scope_depth;

            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (se.depth > current_depth)
                  continue;
               else if (
                         details::imatch(se.name, var_name) &&
                         (se.index == index)
                       )
                  return se;
            }

            return null_element_;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq 0x10(%rdi), %rax
movq 0x8(%rdi), %r8
subq %r8, %rax
setne %r15b
movq %rdi, 0x50(%rsp)
je 0x3439ee
movq (%rdi), %rcx
sarq $0x4, %rax
movabsq $0x6db6db6db6db6db7, %rdi # imm = 0x6DB6DB6DB6DB6DB7
imulq %rax, %rdi
movq 0x3b0(%rcx), %r9
movq (%rsi), %rax
movq %rax, 0x48(%rsp)
movq 0x8(%rsi), %r10
cmpq $0x1, %rdi
movq %rdi, %r11
adcq $0x0, %r11
xorl %ebx, %ebx
movq %rdx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq %r9, 0x20(%rsp)
movq %r10, 0x18(%rsp)
movq %r11, 0x10(%rsp)
imulq $0x70, %rbx, %r14
movl $0x4, %eax
cmpq %r9, 0x30(%r8,%r14)
ja 0x3439d5
addq %r8, %r14
movq 0x8(%r14), %r13
cmpq %r10, %r13
jne 0x34399a
testq %r13, %r13
sete %al
je 0x3439c3
movq %rsi, 0x40(%rsp)
movq (%r14), %r12
movsbl (%r12), %edi
callq 0x120450
movl %eax, %ebp
movq 0x48(%rsp), %rax
movsbl (%rax), %edi
callq 0x120450
cmpl %eax, %ebp
jne 0x34399e
movb %r15b, 0xf(%rsp)
movl $0x1, %ecx
movq %rcx, %r15
cmpq %rcx, %r13
je 0x34398d
movsbl (%r12,%r15), %edi
callq 0x120450
movl %eax, %ebp
movq 0x48(%rsp), %rax
movsbl (%rax,%r15), %edi
callq 0x120450
leaq 0x1(%r15), %rcx
cmpl %eax, %ebp
je 0x343962
cmpq %r13, %r15
setae %al
movb 0xf(%rsp), %r15b
jmp 0x3439a0
xorl %eax, %eax
jmp 0x3439c3
xorl %eax, %eax
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %r8
movq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %r9
movq 0x18(%rsp), %r10
movq 0x10(%rsp), %r11
cmpq %rdx, 0x28(%r14)
sete %cl
andb %al, %cl
movzbl %cl, %eax
testb %al, %al
cmovneq %r14, %rsi
testb $0x3, %al
jne 0x3439ee
incq %rbx
cmpq %rdi, %rbx
setb %r15b
cmpq %r11, %rbx
jne 0x343907
jmp 0x3439ee
movq 0x50(%rsp), %rax
addq $0x20, %rax
testb $0x1, %r15b
cmovneq %rsi, %rax
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::parser<double>::scope_element::operator<(exprtk::parser<double>::scope_element const&) const
bool operator < (const scope_element& se) const
         {
            if (ip_index < se.ip_index)
               return true;
            else if (ip_index > se.ip_index)
               return false;
            else if (depth < se.depth)
               return true;
            else if (depth > se.depth)
               return false;
            else if (index < se.index)
               return true;
            else if (index > se.index)
               return false;
            else
               return (name < se.name);
         }

// Assembly:
movq 0x40(%rdi), %rcx
movq 0x40(%rsi), %rdx
movb $0x1, %al
cmpq %rdx, %rcx
jb 0x344ef9
jbe 0x344eec
xorl %eax, %eax
retq
movq 0x30(%rdi), %rcx
movq 0x30(%rsi), %rdx
cmpq %rdx, %rcx
jae 0x344efa
retq
ja 0x344ee9
movq 0x28(%rdi), %rcx
movq 0x28(%rsi), %rdx
cmpq %rdx, %rcx
jb 0x344ef9
ja 0x344ee9
jmp 0x1ed9cc
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::collect_nodes(std::vector<exprtk::details::expression_node<double>**, std::allocator<exprtk::details::expression_node<double>**>>&)
void collect_nodes(typename expression_node<T>::noderef_list_t& node_delete_list) exprtk_override
         {
            expression_node<T>::ndb_t::collect(initialiser_ , node_delete_list);
            expression_node<T>::ndb_t::collect(condition_   , node_delete_list);
            expression_node<T>::ndb_t::collect(incrementor_ , node_delete_list);
            expression_node<T>::ndb_t::collect(loop_body_   , node_delete_list);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
cmpq $0x0, 0x20(%rdi)
je 0x3455b0
cmpb $0x0, 0x28(%r14)
je 0x3455b0
leaq 0x20(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1f1dac
cmpq $0x0, 0x30(%r14)
je 0x3455d0
cmpb $0x0, 0x38(%r14)
je 0x3455d0
leaq 0x30(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1f1dac
cmpq $0x0, 0x40(%r14)
je 0x3455f0
cmpb $0x0, 0x48(%r14)
je 0x3455f0
leaq 0x40(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x1f1dac
cmpq $0x0, 0x50(%r14)
je 0x345610
cmpb $0x0, 0x58(%r14)
je 0x345610
addq $0x50, %r14
movq %rsp, %rsi
movq %r14, (%rsi)
movq %rbx, %rdi
callq 0x1f1dac
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_rtc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            loop_runtime_checker::reset();

            if (parent_t::initialiser_.first)
               parent_t::initialiser_.first->value();

            if (parent_t::incrementor_.first)
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  result = parent_t::loop_body_.first->value();
                  parent_t::incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(parent_t::condition_) && loop_runtime_checker::check())
               {
                  result = parent_t::loop_body_.first->value();
               }
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq $0x0, 0x60(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x345639
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
testq %r14, %r14
je 0x3456e0
ucomisd %xmm1, %xmm0
jne 0x345660
jnp 0x345774
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq (%rcx), %rax
ja 0x345754
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x345754
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6cb36(%rip), %xmm0    # 0x3b21f8
jne 0x3456ca
jnp 0x34576f
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
cmpq (%rcx), %rax
jbe 0x345686
jmp 0x345754
ucomisd %xmm1, %xmm0
jne 0x3456ec
jnp 0x345774
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
cmpq (%rcx), %rax
ja 0x345754
movsd %xmm0, (%rsp)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x345754
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6cabc(%rip), %xmm0    # 0x3b21f8
jne 0x345740
jnp 0x34576f
movq 0x60(%rbx), %rax
movq 0x70(%rbx), %rcx
incq %rax
movq %rax, 0x60(%rbx)
cmpq (%rcx), %rax
jbe 0x34570e
movl 0x78(%rbx), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
movl $0x1, 0x4(%rsi)
movq 0x68(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movsd (%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            if (initialiser_.first)
               initialiser_.first->value();

            if (incrementor_.first)
            {
               while (is_true(condition_))
               {
                  result = loop_body_.first->value();
                  incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(condition_))
               {
                  result = loop_body_.first->value();
               }
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x34580e
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
testq %r14, %r14
je 0x34585e
ucomisd %xmm1, %xmm0
jne 0x34582d
jnp 0x345890
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6c9a0(%rip), %xmm0    # 0x3b21f8
jne 0x34582d
jp 0x34582d
jmp 0x34588b
ucomisd %xmm1, %xmm0
jne 0x345866
jnp 0x345890
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6c971(%rip), %xmm0    # 0x3b21f8
jne 0x345866
jp 0x345866
movsd (%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_node<double>::for_loop_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
for_loop_node(expression_ptr initialiser,
                       expression_ptr condition,
                       expression_ptr incrementor,
                       expression_ptr loop_body)
         {
            construct_branch_pair(initialiser_, initialiser);
            construct_branch_pair(condition_  , condition  );
            construct_branch_pair(incrementor_, incrementor);
            construct_branch_pair(loop_body_  , loop_body  );
            assert(valid());
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, %r14
xorl %eax, %eax
movb %al, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
leaq 0x225e8e(%rip), %rcx    # 0x56b868
movq %rcx, (%rdi)
leaq 0x225ed4(%rip), %rcx    # 0x56b8b8
movq %rcx, 0x8(%rdi)
movb %al, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
testq %rsi, %rsi
je 0x345a32
movq %rsi, %r13
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x345a1a
xorl %eax, %eax
jmp 0x345a2a
movq (%r13), %rax
movq %r13, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r13, 0x20(%r14)
movb %al, 0x28(%r14)
testq %r12, %r12
je 0x345a62
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x345a4a
xorl %eax, %eax
jmp 0x345a5a
movq (%r12), %rax
movq %r12, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r12, 0x30(%r14)
movb %al, 0x38(%r14)
testq %r15, %r15
je 0x345a90
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x345a79
xorl %eax, %eax
jmp 0x345a88
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %r15, 0x40(%r14)
movb %al, 0x48(%r14)
testq %rbx, %rbx
je 0x345abe
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x345aa7
xorl %eax, %eax
jmp 0x345ab6
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x12, %eax
setne %al
movq %rbx, 0x50(%r14)
movb %al, 0x58(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::for_loop_bc_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);

            if (parent_t::initialiser_.first)
               parent_t::initialiser_.first->value();

            if (parent_t::incrementor_.first)
            {
               while (is_true(parent_t::condition_))
               {
                  try
                  {
                     result = parent_t::loop_body_.first->value();
                  }
                  catch(const break_exception<T>& e)
                  {
                     return e.value;
                  }
                  catch(const continue_exception&)
                  {}

                  parent_t::incrementor_.first->value();
               }
            }
            else
            {
               while (is_true(parent_t::condition_))
               {
                  try
                  {
                     result = parent_t::loop_body_.first->value();
                  }
                  catch(const break_exception<T>& e)
                  {
                     return e.value;
                  }
                  catch(const continue_exception&)
                  {}
               }
            }

            return result;
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x345cb6
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x40(%rbx), %r14
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm2, %xmm2
xorps %xmm1, %xmm1
testq %r14, %r14
je 0x345d3b
movsd %xmm1, (%rsp)
ucomisd %xmm2, %xmm0
jne 0x345ce1
jnp 0x345da7
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x40(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6c4e3(%rip), %xmm0    # 0x3b21f8
jne 0x345cea
jp 0x345cea
jmp 0x345da7
cmpl $0x2, %edx
je 0x345d91
cmpl $0x1, %edx
jne 0x345db4
movq %rax, %rdi
callq 0x120070
callq 0x1203d0
jmp 0x345cf9
movsd %xmm1, (%rsp)
ucomisd %xmm2, %xmm0
jne 0x345d48
jnp 0x345da7
xorpd %xmm0, %xmm0
movsd %xmm0, (%rsp)
movq 0x50(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6c486(%rip), %xmm0    # 0x3b21f8
jne 0x345d51
jp 0x345d51
jmp 0x345da7
cmpl $0x2, %edx
je 0x345d91
cmpl $0x1, %edx
jne 0x345db4
movq %rax, %rdi
callq 0x120070
callq 0x1203d0
jmp 0x345d60
movq %rax, %rdi
callq 0x120070
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
callq 0x1203d0
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x120330
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::switch_n_node<double, exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_1>::~switch_n_node()
class switch_n_node exprtk_final : public switch_node<T>
      {
      public:

         typedef expression_node<T>* expression_ptr;

         template <typename Allocator,
                   template <typename, typename> class Sequence>
         explicit switch_n_node(const Sequence<expression_ptr,Allocator>& arg_list)
         : switch_node<T>(arg_list)
         {}

         inline T value() const exprtk_override
         {
            return Switch_N::process(switch_node<T>::arg_list_);
         }
      }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x225537(%rip), %rax    # 0x56bac8
movq %rax, (%rdi)
leaq 0x22557d(%rip), %rax    # 0x56bb18
movq %rax, 0x8(%rdi)
movq 0x20(%rdi), %rdi
testq %rdi, %rdi
je 0x3465b4
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x1200c0
movl $0x38, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x1200c0
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::switch_node<double>::value() const
inline T value() const exprtk_override
         {
            const std::size_t upper_bound = (arg_list_.size() - 1);

            for (std::size_t i = 0; i < upper_bound; i += 2)
            {
               expression_ptr condition  = arg_list_[i    ].first;
               expression_ptr consequent = arg_list_[i + 1].first;

               if (is_true(condition))
               {
                  return consequent->value();
               }
            }

            return arg_list_[upper_bound].first->value();
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %r15
subq 0x20(%rdi), %r15
sarq $0x4, %r15
decq %r15
setne %bpl
je 0x34678a
movl $0x10, %r12d
xorl %r13d, %r13d
movq 0x20(%rbx), %rax
movq -0x10(%rax,%r12), %rdi
movq (%rax,%r12), %r14
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6baac(%rip), %xmm0    # 0x3b21f8
jne 0x346750
jnp 0x34676b
movq (%r14), %rax
movq %r14, %rdi
movsd %xmm0, 0x10(%rsp)
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
ucomisd 0x6ba85(%rip), %xmm0    # 0x3b21f8
jne 0x34678a
jp 0x34678a
addq $0x2, %r13
addq $0x20, %r12
cmpq %r15, %r13
setb %bpl
jb 0x346731
jmp 0x34678a
testb $0x1, %bpl
je 0x3467a5
movsd 0x8(%rsp), %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x20(%rbx), %rax
shlq $0x4, %r15
movq (%rax,%r15), %rdi
movq (%rdi), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_5::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4)

                  assert(arg.size() == ((2 * 5) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346c73
jnp 0x346c7c
addq $0x10, %rax
jmp 0x346d04
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b56a(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x346c95
jnp 0x346c9b
addq $0x30, %rax
jmp 0x346d04
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346cb4
jnp 0x346cba
addq $0x50, %rax
jmp 0x346d04
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b52c(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x346cd3
jnp 0x346cd9
addq $0x70, %rax
jmp 0x346d04
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x346cf2
jnp 0x346cfc
movl $0x90, %eax
addq (%rbx), %rax
jmp 0x346d04
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_6::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4) case_stmt(5)

                  assert(arg.size() == ((2 * 6) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346de1
jnp 0x346dea
addq $0x10, %rax
jmp 0x346e99
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b3fc(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x346e03
jnp 0x346e0c
addq $0x30, %rax
jmp 0x346e99
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346e25
jnp 0x346e2b
addq $0x50, %rax
jmp 0x346e99
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b3bb(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x346e44
jnp 0x346e4a
addq $0x70, %rax
jmp 0x346e99
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346e66
jnp 0x346e6e
addq $0x90, %rax
jmp 0x346e99
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b375(%rip), %xmm0    # 0x3b21f8
jne 0x346e87
jnp 0x346e91
movl $0xb0, %eax
addq (%rbx), %rax
jmp 0x346e99
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::switch_nodes::switch_impl_7::process(std::vector<std::pair<exprtk::details::expression_node<double>*, bool>, std::allocator<std::pair<exprtk::details::expression_node<double>*, bool>>> const&)
static inline T process(const arg_list_t& arg)
               {
                  case_stmt(0) case_stmt(1)
                  case_stmt(2) case_stmt(3)
                  case_stmt(4) case_stmt(5)
                  case_stmt(6)

                  assert(arg.size() == ((2 * 7) + 1));

                  return arg.back().first->value();
               }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346fa5
jnp 0x346fae
addq $0x10, %rax
jmp 0x347084
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b238(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x346fc7
jnp 0x346fd0
addq $0x30, %rax
jmp 0x347084
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x346fe9
jnp 0x346ff2
addq $0x50, %rax
jmp 0x347084
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b1f4(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x34700b
jnp 0x347011
addq $0x70, %rax
jmp 0x347084
movq 0x80(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
movq (%rbx), %rax
jne 0x34702d
jnp 0x347035
addq $0x90, %rax
jmp 0x347084
movq 0xa0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
ucomisd 0x6b1ae(%rip), %xmm0    # 0x3b21f8
movq (%rbx), %rax
jne 0x347051
jnp 0x347059
addq $0xb0, %rax
jmp 0x347084
movq 0xc0(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x347072
jnp 0x34707c
movl $0xd0, %eax
addq (%rbx), %rax
jmp 0x347084
movq 0x8(%rbx), %rax
addq $-0x10, %rax
movq (%rax), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::varnode_optimise_sf3(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3])
inline expression_node_ptr varnode_optimise_sf3(const details::operator_type& operation, expression_node_ptr (&branch)[3])
         {
            typedef details::variable_node<Type>* variable_ptr;

            const Type& v0 = static_cast<variable_ptr>(branch[0])->ref();
            const Type& v1 = static_cast<variable_ptr>(branch[1])->ref();
            const Type& v2 = static_cast<variable_ptr>(branch[2])->ref();

            switch (operation)
            {
               #define case_stmt(op)                                                                \
               case details::e_sf##op : return node_allocator_->                                    \
                             allocate_rrr<details::sf3_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2);                                                       \

               case_stmt(00) case_stmt(01) case_stmt(02) case_stmt(03)
               case_stmt(04) case_stmt(05) case_stmt(06) case_stmt(07)
               case_stmt(08) case_stmt(09) case_stmt(10) case_stmt(11)
               case_stmt(12) case_stmt(13) case_stmt(14) case_stmt(15)
               case_stmt(16) case_stmt(17) case_stmt(18) case_stmt(19)
               case_stmt(20) case_stmt(21) case_stmt(22) case_stmt(23)
               case_stmt(24) case_stmt(25) case_stmt(26) case_stmt(27)
               case_stmt(28) case_stmt(29) case_stmt(30) case_stmt(31)
               case_stmt(32) case_stmt(33) case_stmt(34) case_stmt(35)
               case_stmt(36) case_stmt(37) case_stmt(38) case_stmt(39)
               case_stmt(40) case_stmt(41) case_stmt(42) case_stmt(43)
               case_stmt(44) case_stmt(45) case_stmt(46) case_stmt(47)
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
movl $0xfffffc18, %eax       # imm = 0xFFFFFC18
addl (%rsi), %eax
cmpl $0x2f, %eax
ja 0x349d25
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x10(%rdx), %rcx
movq 0x28(%rcx), %rbx
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq 0x28(%rdx), %r14
movq 0x28(%rcx), %r15
movl %eax, %eax
leaq 0x22fa85(%rip), %rcx    # 0x579768
movq (%rcx,%rax,8), %r12
leaq 0x22fbfa(%rip), %rcx    # 0x5798e8
movq (%rcx,%rax,8), %r13
movl $0x38, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r12, (%rax)
movq %r13, 0x8(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sf3_node<double, exprtk::details::sf00_op<double>>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::sf3_node<double, exprtk::details::sf00_op<double>>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3])
inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[3])
         {
            expression_node<typename ResultNode::value_type>* result =
               allocate<ResultNode>(operation, branch[0], branch[1], branch[2]);
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x58, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
movq %rax, %rdi
movq %r15, %rsi
callq 0x339d2e
leaq 0x223ac3(%rip), %rax    # 0x56d820
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x223b05(%rip), %rax    # 0x56d870
movq %rax, 0x8(%rbx)
movq %rbx, %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0x339fce
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sf3_node<double, exprtk::details::sf36_op<double>>::value() const
inline T value() const exprtk_override
         {
            const T x = trinary_node<T>::branch_[0].first->value();
            const T y = trinary_node<T>::branch_[1].first->value();
            const T z = trinary_node<T>::branch_[2].first->value();

            return SpecialFunction::process(x, y, z);
         }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x8(%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, (%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd (%rsp), %xmm2
movapd %xmm2, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm2, %xmm1
mulsd 0x8(%rsp), %xmm1
addsd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::varnode_optimise_sf4(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [4])
inline expression_node_ptr varnode_optimise_sf4(const details::operator_type& operation, expression_node_ptr (&branch)[4])
         {
            typedef details::variable_node<Type>* variable_ptr;

            const Type& v0 = static_cast<variable_ptr>(branch[0])->ref();
            const Type& v1 = static_cast<variable_ptr>(branch[1])->ref();
            const Type& v2 = static_cast<variable_ptr>(branch[2])->ref();
            const Type& v3 = static_cast<variable_ptr>(branch[3])->ref();

            switch (operation)
            {
               #define case_stmt(op)                                                                 \
               case details::e_sf##op : return node_allocator_->                                     \
                             allocate_rrrr<details::sf4_var_node<Type,details::sf##op##_op<Type> > > \
                                (v0, v1, v2, v3);                                                    \

               case_stmt(48) case_stmt(49) case_stmt(50) case_stmt(51)
               case_stmt(52) case_stmt(53) case_stmt(54) case_stmt(55)
               case_stmt(56) case_stmt(57) case_stmt(58) case_stmt(59)
               case_stmt(60) case_stmt(61) case_stmt(62) case_stmt(63)
               case_stmt(64) case_stmt(65) case_stmt(66) case_stmt(67)
               case_stmt(68) case_stmt(69) case_stmt(70) case_stmt(71)
               case_stmt(72) case_stmt(73) case_stmt(74) case_stmt(75)
               case_stmt(76) case_stmt(77) case_stmt(78) case_stmt(79)
               case_stmt(80) case_stmt(81) case_stmt(82) case_stmt(83)
               case_stmt(84) case_stmt(85) case_stmt(86) case_stmt(87)
               case_stmt(88) case_stmt(89) case_stmt(90) case_stmt(91)
               case_stmt(92) case_stmt(93) case_stmt(94) case_stmt(95)
               case_stmt(96) case_stmt(97) case_stmt(98) case_stmt(99)
               #undef case_stmt
               default : return error_node();
            }
         }

// Assembly:
movl $0xfffffbe8, %eax       # imm = 0xFFFFFBE8
addl (%rsi), %eax
cmpl $0x33, %eax
ja 0x34e00c
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x18(%rdx), %rcx
movq 0x28(%rcx), %rbx
movq 0x10(%rdx), %rcx
movq 0x28(%rcx), %r14
movq (%rdx), %rcx
movq 0x8(%rdx), %rdx
movq 0x28(%rdx), %r15
movq 0x28(%rcx), %r12
movl %eax, %eax
leaq 0x22baa7(%rip), %rcx    # 0x579a68
movq (%rcx,%rax,8), %r13
leaq 0x22bc3c(%rip), %rcx    # 0x579c08
movq (%rcx,%rax,8), %rbp
movl $0x40, %edi
callq 0x1200f0
movb $0x0, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq %r13, (%rax)
movq %rbp, 0x8(%rax)
movq %r12, 0x20(%rax)
movq %r15, 0x28(%rax)
movq %r14, 0x30(%rax)
movq %rbx, 0x38(%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sf4_node<double, exprtk::details::sf48_op<double>>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::sf4_node<double, exprtk::details::sf48_op<double>>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [4])
inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[4])
         {
            expression_node<typename ResultNode::value_type>* result =
               allocate<ResultNode>(operation, branch[0], branch[1], branch[2], branch[3]);
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movl $0x68, %edi
callq 0x1200f0
movq %rax, %rbx
movq (%r14), %rdx
movq 0x8(%r14), %rcx
movq 0x10(%r14), %r8
movq 0x18(%r14), %r9
movq %rax, %rdi
movq %r15, %rsi
callq 0x33a648
leaq 0x222e77(%rip), %rax    # 0x570ec0
movq %rax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x222eb9(%rip), %rax    # 0x570f10
movq %rax, 0x8(%rbx)
movq %rbx, %rsi
addq $0x28, %rsi
movq %r14, %rdi
callq 0x33a85e
movq 0x8(%rbx), %rax
movq %r14, %rdi
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x1200c0
movq %r14, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sf4_node<double, exprtk::details::sf98_op<double>>::value() const
inline T value() const exprtk_override
         {
            const T x = quaternary_node<T>::branch_[0].first->value();
            const T y = quaternary_node<T>::branch_[1].first->value();
            const T z = quaternary_node<T>::branch_[2].first->value();
            const T w = quaternary_node<T>::branch_[3].first->value();

            return SpecialFunction::process(x, y, z, w);
         }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x10(%rsp)
movq 0x38(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, (%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd %xmm0, 0x20(%rsp)
movq 0x58(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movapd 0x10(%rsp), %xmm4
movapd %xmm4, %xmm2
movapd (%rsp), %xmm5
subsd %xmm5, %xmm2
movapd 0x5ffde(%rip), %xmm3    # 0x3b2440
movapd %xmm2, %xmm1
xorpd %xmm3, %xmm1
unpcklpd %xmm5, %xmm4            # xmm4 = xmm4[0],xmm5[0]
xorpd %xmm4, %xmm3
maxpd %xmm4, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
maxsd %xmm3, %xmm4
maxsd 0x5fb96(%rip), %xmm4    # 0x3b2020
maxsd %xmm2, %xmm1
mulsd 0x5fbc2(%rip), %xmm4    # 0x3b2058
cmplesd %xmm4, %xmm1
movapd 0x20(%rsp), %xmm2
andpd %xmm1, %xmm2
andnpd %xmm0, %xmm1
orpd %xmm2, %xmm1
movapd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
nop