LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_xoxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>, exprtk::details::ilike_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
addq $0x48, %rdi
movq 0x30(%rbx), %rax
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
callq 0x2a4b56
xorps %xmm0, %xmm0
testb %al, %al
je 0x2d9e20
movq 0x20(%rbx), %r15
addq $0x28, %rbx
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x11e510
movq (%r14), %r12
movq 0x8(%r14), %r14
addq %r12, %r14
movq (%r15), %r13
movq 0x8(%r15), %r15
addq %r13, %r15
xorl %eax, %eax
xorl %ebx, %ebx
movq %r12, 0x10(%rsp)
movq %r14, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movq %rax, 0x8(%rsp)
cmpq %r14, %r12
je 0x2d9d7d
movsbl (%r12), %ebp
cmpq %r15, %r13
je 0x2d9d75
movsbl (%r13), %r14d
movl %ebp, %edi
callq 0x11e450
movl %eax, %r15d
movl %r14d, %edi
movq 0x20(%rsp), %r14
callq 0x11e450
cmpl %eax, %r15d
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %r15
je 0x2d9d97
cmpb $0x3f, %bpl
je 0x2d9d97
cmpb $0x2a, %bpl
jne 0x2d9d82
jmp 0x2d9d9f
cmpq %r15, %r13
je 0x2d9df0
xorps %xmm0, %xmm0
cmpq %r15, %r13
je 0x2d9df8
movq %rbx, %r13
movq %rax, %r12
testq %rbx, %rbx
jne 0x2d9d35
jmp 0x2d9df8
incq %r13
incq %r12
jmp 0x2d9d35
cmpb $0x2a, (%r12)
jne 0x2d9db1
incq %r12
cmpq %r14, %r12
jne 0x2d9d9f
movq %r14, %r12
cmpq %r15, %r13
je 0x2d9de2
movb (%r12), %bl
movsbl %bl, %edi
callq 0x11e450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x11e450
cmpb $0x3f, %bl
je 0x2d9de2
cmpl %eax, %ebp
je 0x2d9de2
incq %r13
cmpq %r15, %r13
jne 0x2d9dc4
movq %r15, %r13
leaq -0x1(%r12), %rax
leaq 0x1(%r13), %rbx
jmp 0x2d9d30
movsd 0xaf228(%rip), %xmm0    # 0x389020
leaq 0x48(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
je 0x2d9e20
movq 0x48(%rsp), %rsi
incq %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x11e0c0
movsd 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2d7d40
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0x2d7d40
movb $0x0, (%rbx)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d7d40
leaq 0x8(%rbx), %r14
movq (%r14), %rdi
testq %rdi, %rdi
je 0x2d7d40
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d7d40
cmpq $0x0, (%r14)
je 0x2d7d40
movq %r14, %rdi
callq 0x1ea63e
cmpb $0x1, 0x10(%rbx)
jne 0x2d7d8a
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2d7d8a
movb $0x0, 0x10(%rbx)
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x11, %eax
je 0x2d7d8a
addq $0x18, %rbx
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2d7d8a
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x12, %eax
je 0x2d7d8a
cmpq $0x0, (%rbx)
je 0x2d7d8a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1ea63e
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::details::ilike_op<double>>::value() const
inline bool imatch(const std::string& s1, const std::string& s2)
      {
         if (s1.size() == s2.size())
         {
            for (std::size_t i = 0; i < s1.size(); ++i)
            {
               if (std::tolower(s1[i]) != std::tolower(s2[i]))
               {
                  return false;
               }
            }

            return true;
         }

         return false;
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x20(%rdi), %r12
movq 0x40(%rdi), %rax
movq (%rax), %r15
movq 0x8(%rax), %rax
addq %r15, %rax
movq %rax, (%rsp)
movq 0x28(%rdi), %r14
addq %r12, %r14
xorl %eax, %eax
xorl %r13d, %r13d
movq %r14, 0x8(%rsp)
movq %rax, 0x10(%rsp)
cmpq (%rsp), %r15
je 0x2db178
movsbl (%r15), %ebx
cmpq %r14, %r12
je 0x2db171
movsbl (%r12), %ebp
movl %ebx, %edi
callq 0x11e450
movl %eax, %r14d
movl %ebp, %edi
callq 0x11e450
cmpl %eax, %r14d
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %r14
je 0x2db192
cmpb $0x3f, %bl
je 0x2db192
cmpb $0x2a, %bl
jne 0x2db17d
jmp 0x2db19a
cmpq %r14, %r12
je 0x2db1ed
xorps %xmm0, %xmm0
cmpq %r14, %r12
je 0x2db1f5
movq %r13, %r12
movq %rax, %r15
testq %r13, %r13
jne 0x2db138
jmp 0x2db1f5
incq %r12
incq %r15
jmp 0x2db138
cmpb $0x2a, (%r15)
jne 0x2db1ad
incq %r15
cmpq (%rsp), %r15
jne 0x2db19a
movq (%rsp), %r15
cmpq %r14, %r12
je 0x2db1df
movb (%r15), %bpl
movsbl %bpl, %edi
callq 0x11e450
movl %eax, %ebx
movsbl (%r12), %edi
callq 0x11e450
cmpb $0x3f, %bpl
je 0x2db1df
cmpl %eax, %ebx
je 0x2db1df
incq %r12
cmpq %r14, %r12
jne 0x2db1c0
movq %r14, %r12
leaq -0x1(%r15), %rax
leaq 0x1(%r12), %r13
jmp 0x2db133
movsd 0xade2b(%rip), %xmm0    # 0x389020
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_literal_node<double>::string_literal_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
explicit string_literal_node(const std::string& v)
         : value_(v)
         {
            rp_.n0_c = std::make_pair<bool,std::size_t>(true, 0);
            rp_.n1_c = std::make_pair<bool,std::size_t>(true, v.size());
            rp_.cache.first  = rp_.n0_c.second;
            rp_.cache.second = rp_.n1_c.second;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
movb %r15b, 0x10(%rdi)
movq %r15, 0x18(%rdi)
leaq 0x23be35(%rip), %rax    # 0x517810
movq %rax, (%rdi)
leaq 0x23be9b(%rip), %rax    # 0x517880
movq %rax, 0x8(%rdi)
leaq 0x23beb8(%rip), %rax    # 0x5178a8
movq %rax, 0x20(%rdi)
leaq 0x23bee5(%rip), %rax    # 0x5178e0
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
leaq 0x40(%rbx), %rax
movq %rax, 0x30(%rbx)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
callq 0x1e7738
movb %r15b, 0x50(%rbx)
movq %r15, 0x58(%rbx)
movb %r15b, 0x60(%rbx)
movq %r15, 0x68(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rbx)
movq %r15, 0x98(%rbx)
movb $0x1, %al
movb %al, 0x70(%rbx)
movq %r15, 0x78(%rbx)
movq 0x8(%r14), %rcx
movb %al, 0x80(%rbx)
movq %rcx, 0x88(%rbx)
movq %rcx, 0x98(%rbx)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::str_xoxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>, exprtk::details::lt_op<double>>::value_type>* exprtk::details::node_allocator::allocate_ttt<exprtk::details::str_xoxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>, exprtk::details::lt_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::range_pack<double>) const
inline expression_node<typename node_type::value_type>* allocate_ttt(T1 t1, T2 t2, T3 t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl $0xb0, %edi
callq 0x11e0f0
movq %rax, %rbx
leaq 0x88(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x78(%rsp), %rdi
callq 0x1e7738
leaq 0x68(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x58(%rsp), %rdi
callq 0x1e7738
leaq 0xc0(%rsp), %rsi
movl $0xa, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x78(%rsp), %rsi
leaq 0x58(%rsp), %rdx
movq %rbx, %rdi
callq 0x2dfef2
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2df525
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x78(%rsp), %rdi
cmpq %r12, %rdi
je 0x2df53f
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x58(%rsp), %rdi
cmpq %r15, %rdi
je 0x2df57e
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2df57e
movq %rax, %r14
movq 0x78(%rsp), %rdi
cmpq %r12, %rdi
je 0x2df59d
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x2df59d
movq %rax, %r14
movl $0xb0, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_xrox_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::details::range_pack<double>, exprtk::details::ilike_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x28(%rsp), %rdx
movq %rax, (%rdx)
addq $0x30, %rdi
movq 0x20(%rbx), %rax
movq 0x8(%rax), %rax
leaq 0x38(%rsp), %rcx
movq %rax, (%rcx)
callq 0x2a4b56
xorps %xmm0, %xmm0
testb %al, %al
je 0x2e1dab
movq 0x20(%rbx), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x11e510
movq 0x28(%rbx), %rax
movq (%rax), %r12
movq 0x8(%rax), %r15
addq %r12, %r15
movq (%r14), %r13
movq 0x8(%r14), %r14
addq %r13, %r14
xorl %eax, %eax
movq %r13, 0x10(%rsp)
xorl %ebx, %ebx
movq %r14, 0x20(%rsp)
movq %r15, 0x18(%rsp)
movq %rax, 0x8(%rsp)
cmpq %r15, %r12
je 0x2e1d08
movsbl (%r12), %ebp
cmpq %r14, %r13
je 0x2e1d00
movsbl (%r13), %r14d
movl %ebp, %edi
callq 0x11e450
movl %eax, %r15d
movl %r14d, %edi
movq 0x20(%rsp), %r14
callq 0x11e450
cmpl %eax, %r15d
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %r15
je 0x2e1d22
cmpb $0x3f, %bpl
je 0x2e1d22
cmpb $0x2a, %bpl
jne 0x2e1d0d
jmp 0x2e1d2a
cmpq %r14, %r13
je 0x2e1d7b
xorps %xmm0, %xmm0
cmpq %r14, %r13
je 0x2e1d83
movq %rbx, %r13
movq %rax, %r12
testq %rbx, %rbx
jne 0x2e1cc0
jmp 0x2e1d83
incq %r13
incq %r12
jmp 0x2e1cc0
cmpb $0x2a, (%r12)
jne 0x2e1d3c
incq %r12
cmpq %r15, %r12
jne 0x2e1d2a
movq %r15, %r12
cmpq %r14, %r13
je 0x2e1d6d
movb (%r12), %bl
movsbl %bl, %edi
callq 0x11e450
movl %eax, %ebp
movsbl (%r13), %edi
callq 0x11e450
cmpb $0x3f, %bl
je 0x2e1d6d
cmpl %eax, %ebp
je 0x2e1d6d
incq %r13
cmpq %r14, %r13
jne 0x2e1d4f
movq %r14, %r13
leaq -0x1(%r12), %rax
leaq 0x1(%r13), %rbx
jmp 0x2e1cbb
movsd 0xa729d(%rip), %xmm0    # 0x389020
leaq 0x48(%rsp), %rax
movq 0x10(%rsp), %rdi
cmpq %rax, %rdi
je 0x2e1dab
movq 0x48(%rsp), %rsi
incq %rsi
movsd %xmm0, 0x8(%rsp)
callq 0x11e0c0
movsd 0x8(%rsp), %xmm0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2eebb5
xorpd %xmm0, %xmm0
testb %al, %al
jne 0x2eebb3
movsd 0x9a46d(%rip), %xmm0    # 0x389020
popq %rbx
retq
testb %al, %al
jne 0x2eebab
xorpd %xmm0, %xmm0
jmp 0x2eebb3
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::boc_node<double, exprtk::details::add_op<double>>::value_type>* exprtk::details::node_allocator::allocate_cr<exprtk::details::boc_node<double, exprtk::details::add_op<double>>, exprtk::details::expression_node<double>*, double const>(exprtk::details::expression_node<double>* const&, double const&) const
inline expression_node<typename node_type::value_type>* allocate_cr(const 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
movq %rdx, %r14
movq %rsi, %r15
movl $0x38, %edi
callq 0x11e0f0
movq %rax, %rbx
movq (%r15), %rsi
movsd (%r14), %xmm0
movq %rax, %rdi
callq 0x2fcf54
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movl $0x38, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_invalid_string_op(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3]) const
inline bool is_invalid_string_op(const details::operator_type& operation, expression_node_ptr (&branch)[3]) const
         {
            const bool b0_string = is_generally_string_node(branch[0]);
            const bool b1_string = is_generally_string_node(branch[1]);
            const bool b2_string = is_generally_string_node(branch[2]);

            bool result = false;

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

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

            return result;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdx), %rdi
movabsq $0x388fc0000, %r12      # imm = 0x388FC0000
testq %rdi, %rdi
je 0x313696
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %bpl
cmpl $0x21, %eax
ja 0x313691
movl %eax, %ecx
btq %rcx, %r12
jb 0x313698
cmpl $0x7b, %eax
je 0x313698
xorl %ebp, %ebp
movq 0x8(%r15), %rdi
testq %rdi, %rdi
je 0x3136bc
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %r13b
cmpl $0x21, %eax
ja 0x3136b7
movl %eax, %ecx
btq %rcx, %r12
jb 0x3136bf
cmpl $0x7b, %eax
je 0x3136bf
xorl %r13d, %r13d
movq 0x10(%r15), %rdi
testq %rdi, %rdi
je 0x3136e2
movq (%rdi), %rax
callq *0x28(%rax)
movb $0x1, %cl
cmpl $0x21, %eax
ja 0x3136dd
movl %eax, %edx
btq %rdx, %r12
jb 0x3136e4
cmpl $0x7b, %eax
je 0x3136e4
xorl %ecx, %ecx
movl %ebp, %eax
xorb %r13b, %al
movl %r13d, %edx
xorb %cl, %dl
orb %al, %dl
jne 0x313706
cmpl $0x44, (%r14)
setne %al
andb %r13b, %bpl
andb %bpl, %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x313764
movq 0x68(%rbx), %rbx
leaq 0x18(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x819eb(%rip), %rsi     # 0x395105
leaq 0x819fc(%rip), %rdx     # 0x39511d
leaq 0x8(%rsp), %rdi
callq 0x1e4740
cmpq $0x0, 0x518(%rbx)
jne 0x313749
addq $0x510, %rbx            # imm = 0x510
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11e5a0
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x313760
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movb $0x1, %al
jmp 0x313766
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r14, %rdi
je 0x31378f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::is_string_operation(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [3]) const
inline bool is_string_operation(const details::operator_type& operation, expression_node_ptr (&branch)[3]) const
         {
            const bool b0_string = is_generally_string_node(branch[0]);
            const bool b1_string = is_generally_string_node(branch[1]);
            const bool b2_string = is_generally_string_node(branch[2]);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rdi
movb $0x1, %bpl
movabsq $0x388fc0000, %r15      # imm = 0x388FC0000
movb $0x1, %r12b
testq %rdi, %rdi
je 0x3137d4
movq (%rdi), %rax
callq *0x28(%rax)
xorl %r12d, %r12d
cmpl $0x21, %eax
ja 0x313826
movl %eax, %ecx
btq %rcx, %r15
jae 0x313826
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0x3137f2
movq (%rdi), %rax
callq *0x28(%rax)
xorl %ebp, %ebp
cmpl $0x21, %eax
ja 0x313830
movl %eax, %ecx
btq %rcx, %r15
jae 0x313830
movq 0x10(%r14), %rdi
testq %rdi, %rdi
je 0x313813
movq (%rdi), %rax
callq *0x28(%rax)
cmpl $0x21, %eax
ja 0x31383a
movl %eax, %ecx
btq %rcx, %r15
jae 0x31383a
orb %bpl, %r12b
je 0x313817
xorl %eax, %eax
jmp 0x31381d
cmpl $0x44, (%rbx)
sete %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x7b, %eax
je 0x3137d4
movb $0x1, %r12b
jmp 0x3137d4
cmpl $0x7b, %eax
je 0x3137f2
movb $0x1, %bpl
jmp 0x3137f2
cmpl $0x7b, %eax
je 0x31380e
jmp 0x313813
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>::value_type>* exprtk::details::node_allocator::allocate_type<exprtk::details::sosos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::details::inrange_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
inline expression_node<typename node_type::value_type>* allocate_type(T1 t1, T2 t2, T3 t3) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3));
            result->node_depth();
            return result;
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
movl $0x68, %edi
callq 0x11e0f0
movq %rax, %rbx
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0x1e7738
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x1e7738
leaq 0x20(%rsp), %rsi
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x314ae0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x3146fd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x314714
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x314751
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x314751
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x31476d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x31476d
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::trinary_node<double>::value() const
inline T value() const exprtk_override
         {
            const T arg0 = branch_[0].first->value();
            const T arg1 = branch_[1].first->value();
            const T arg2 = branch_[2].first->value();

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

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

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

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

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

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movl $0xa0, %edi
callq 0x11e0f0
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq %r14, %rdi
callq 0x11e200
leaq (%rax,%r14), %rdx
movq %rsp, %rdi
movq %r14, %rsi
callq 0x1e4740
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x2db9be
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x31b65c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
movq %rbx, %rdi
addq $0x8, %rdi
movq 0x8(%rbx), %rax
callq *0x10(%rax)
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x31b695
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x31b695
movq %rax, %r14
movl $0xa0, %esi
movq %rbx, %rdi
callq 0x11e0c0
movq %r14, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_string_node<double>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

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

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

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

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

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

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

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

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

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

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

                  return T(0);
               }
            }

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
xorl %eax, %eax
movq %rax, 0x8(%rsp)
movq %rax, 0x10(%rsp)
movq 0x100(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x31b9a1
jnp 0x31ba2e
movq 0x108(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x80(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2a4b56
testb %al, %al
je 0x31bac5
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
leaq 0xe0(%rbx), %r15
movq 0x70(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x8(%rsp), %rax
movq 0xe8(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r8
callq 0x11e290
movsd 0x6d5f7(%rip), %xmm0    # 0x389020
jmp 0x31baae
movq 0x110(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x88(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %r14
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
leaq 0x18(%rsp), %rcx
movq %rax, (%rcx)
leaq 0x8(%rsp), %rsi
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x2a4b56
testb %al, %al
je 0x31bac5
movq 0x10(%rsp), %r14
subq 0x8(%rsp), %r14
leaq 0xe0(%rbx), %r15
movq 0x78(%rbx), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
addq 0x8(%rsp), %rax
movq 0xe8(%rbx), %rdx
movq %r15, %rdi
xorl %esi, %esi
movq %rax, %rcx
movq %r14, %r8
callq 0x11e290
xorpd %xmm0, %xmm0
movq 0xe8(%rbx), %rax
movq %rax, 0xc8(%rbx)
movq %rax, 0xd8(%rbx)
jmp 0x31bacd
movsd 0x6d73b(%rip), %xmm0    # 0x389208
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_string_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               initialised_                         &&
               condition_  && condition_  ->valid() &&
               consequent_ && consequent_ ->valid() &&
               alternative_&& alternative_->valid() ;
         }

// Assembly:
pushq %rbx
cmpb $0x1, 0x68(%rdi)
jne 0x31bb27
movq %rdi, %rbx
movq 0x100(%rdi), %rdi
testq %rdi, %rdi
je 0x31bb27
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31bb27
movq 0x108(%rbx), %rdi
testq %rdi, %rdi
je 0x31bb27
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31bb27
movq 0x110(%rbx), %rdi
testq %rdi, %rdi
je 0x31bb27
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_vector_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               initialised_                                      &&
               condition_  .first && condition_  .first->valid() &&
               consequent_ .first && consequent_ .first->valid() &&
               alternative_.first && alternative_.first->valid() &&
               size() <= base_size();
         }

// Assembly:
cmpb $0x1, 0x88(%rdi)
jne 0x31c153
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x31c156
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31c156
movq 0x38(%rbx), %rdi
testq %rdi, %rdi
je 0x31c156
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31c156
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x31c156
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31c156
movq 0x58(%rbx), %rax
movq 0x80(%rbx), %r15
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movq %rax, %r14
movq 0x60(%rbx), %rax
movq 0x28(%rax), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
cmpq %r14, %rax
cmovbq %rax, %r14
cmpq %r14, %r15
setbe %al
jmp 0x31c158
xorl %eax, %eax
retq
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x214df6(%rip), %rcx    # 0x531150
movq %rcx, (%rdi)
leaq 0x214e3c(%rip), %rcx    # 0x5311a0
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 0x31c3ab
movq %rsi, %r12
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31c393
xorl %eax, %eax
jmp 0x31c3a3
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 0x31c3d9
movq (%r15), %rax
movq %r15, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31c3c2
xorl %eax, %eax
jmp 0x31c3d1
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 0x31c407
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
cmpl $0x11, %eax
jne 0x31c3f0
xorl %eax, %eax
jmp 0x31c3ff
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_O3/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 0x31c4fe
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31c4fe
movq 0x30(%rbx), %rdi
testq %rdi, %rdi
je 0x31c4fe
movq (%rdi), %rax
callq *0x30(%rax)
testb %al, %al
je 0x31c4fe
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x31c4fe
movq (%rdi), %rax
popq %rbx
jmpq *0x30(%rax)
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31c68c
jnp 0x31c697
movq 0x30(%rbx), %rdi
movq (%rdi), %rax
popq %rbx
jmpq *0x18(%rax)
movsd 0x6cb69(%rip), %xmm0    # 0x389208
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31d42a
jnp 0x31d4b6
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 0x31d495
movsd %xmm0, 0x8(%rsp)
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x31d495
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 0x6bd73(%rip), %xmm0    # 0x3891f0
jne 0x31d481
jnp 0x31d4b0
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
jbe 0x31d44e
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_O3/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 0x31d592
jnp 0x31d5be
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 0x6bc3c(%rip), %xmm0    # 0x3891f0
jne 0x31d592
jp 0x31d592
movsd 0x8(%rsp), %xmm1
movapd %xmm1, %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31d6e1
jnp 0x31d768
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 0x31d74d
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
je 0x31d74d
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 0x6bac2(%rip), %xmm0    # 0x3891f0
jne 0x31d6eb
jp 0x31d6eb
jmp 0x31d768
movq %rax, %rdi
cmpl $0x2, %edx
je 0x31d774
cmpl $0x1, %edx
jne 0x31d78a
callq 0x11e070
callq 0x11e3d0
jmp 0x31d71c
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 0x11e070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x11e3d0
jmp 0x31d768
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x31d809
jnp 0x31d868
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 0x6b9bb(%rip), %xmm0    # 0x3891f0
jne 0x31d813
jp 0x31d813
jmp 0x31d868
movq %rax, %rdi
cmpl $0x2, %edx
je 0x31d854
cmpl $0x1, %edx
jne 0x31d874
callq 0x11e070
callq 0x11e3d0
jmp 0x31d823
callq 0x11e070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x11e3d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b602(%rip), %xmm0    # 0x3891f0
jne 0x31dc2e
jp 0x31dc2e
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
ja 0x31dc13
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x31dbcc
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_O3/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 0x6b4d8(%rip), %xmm0    # 0x3891f0
jne 0x31dd1c
jnp 0x31dcf6
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b3a6(%rip), %xmm0    # 0x3891f0
jne 0x31dea5
jp 0x31dea5
movq 0x40(%rbx), %rax
movq 0x50(%rbx), %rcx
incq %rax
movq %rax, 0x40(%rbx)
cmpq (%rcx), %rax
ja 0x31de8a
movq 0x48(%rbx), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x31de28
jmp 0x31de8a
movq %rax, %rdi
cmpl $0x2, %edx
je 0x31deb1
cmpl $0x1, %edx
jne 0x31dec7
callq 0x11e070
callq 0x11e3d0
jmp 0x31de38
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 0x11e070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x11e3d0
jmp 0x31dea5
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6b29e(%rip), %xmm0    # 0x3891f0
jne 0x31df85
jnp 0x31df30
jmp 0x31df85
movq %rax, %rdi
cmpl $0x2, %edx
je 0x31df71
cmpl $0x1, %edx
jne 0x31df91
callq 0x11e070
callq 0x11e3d0
jmp 0x31df40
callq 0x11e070
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
callq 0x11e3d0
movsd 0x8(%rsp), %xmm0
addq $0x10, %rsp
popq %rbx
retq
callq 0x11e330