LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::lt_op<double>>::value_type>* exprtk::details::node_allocator::allocate_tt<exprtk::details::sos_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, exprtk::details::lt_op<double>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const) const
inline expression_node<typename node_type::value_type>* allocate_tt(T1 t1, T2 t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movl $0x60, %edi
callq 0x11b180
movq 0x10(%rsp), %rsi
movq %rax, 0x18(%rsp)
movb $0x1, 0x27(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x11b140
jmp 0x44bc8e
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x11b140
jmp 0x44bc9f
movq 0x18(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x44c660
jmp 0x44bcb5
movb $0x0, 0x27(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11b838
leaq 0x58(%rsp), %rdi
callq 0x11b838
movq 0x18(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x78(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x44bd3a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x44bd30
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11b838
leaq 0x58(%rsp), %rdi
callq 0x11b838
testb $0x1, 0x27(%rsp)
jne 0x44bd43
jmp 0x44bd52
movq 0x18(%rsp), %rdi
movl $0x60, %esi
callq 0x11b130
jmp 0x44bd54
movq 0x50(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::range_pack<double>::clear()
void clear()
         {
            n0_e  = std::make_pair(false,expression_node_ptr(0));
            n1_e  = std::make_pair(false,expression_node_ptr(0));
            n0_c  = std::make_pair(false,0);
            n1_c  = std::make_pair(false,0);
            cache = std::make_pair(0,0);
         }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
movb $0x0, 0x6f(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x6f(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x43bd00
movq 0x8(%rsp), %rdi
movb %al, 0x70(%rsp)
movq %rdx, 0x78(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x444420
movb $0x0, 0x4f(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x4f(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x43bd00
movq 0x8(%rsp), %rdi
movb %al, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
addq $0x10, %rdi
leaq 0x50(%rsp), %rsi
callq 0x444420
movb $0x0, 0x37(%rsp)
movl $0x0, 0x30(%rsp)
leaq 0x37(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x43bd30
movq 0x8(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x20, %rdi
leaq 0x38(%rsp), %rsi
callq 0x444450
movb $0x0, 0x27(%rsp)
movl $0x0, 0x20(%rsp)
leaq 0x27(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x43bd30
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x30, %rdi
leaq 0x28(%rsp), %rsi
callq 0x444450
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
leaq 0x14(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x43bd90
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x40, %rdi
leaq 0x18(%rsp), %rsi
callq 0x444480
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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>>&, exprtk::details::range_pack<double>, exprtk::details::like_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x0, 0x68(%rsp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x28(%rsp)
movq 0x28(%rax), %rdi
callq 0x11b270
movq 0x28(%rsp), %rdi
movq %rax, 0x60(%rsp)
leaq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x60(%rsp), %rcx
callq 0x3eebb0
testb $0x1, %al
jne 0x446051
jmp 0x4460ce
movq 0x20(%rsp), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x28(%rax), %rsi
movq 0x70(%rsp), %rdx
movq 0x68(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x40(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b710
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x440120
movsd %xmm0, 0x18(%rsp)
jmp 0x446099
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x80(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x11b838
jmp 0x4460da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x11b838
jmp 0x4460eb
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
movsd 0x80(%rsp), %xmm0
addq $0x88, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, (%rax)
je 0x4451db
movq 0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x4451db
movq 0x8(%rsp), %rax
movb $0x0, (%rax)
movq 0x8(%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x4451d9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x23c9a0
testb $0x1, %al
jne 0x4451d9
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
callq 0x23c830
jmp 0x4451db
movq 0x8(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x44522e
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x44522e
movq 0x8(%rsp), %rax
movb $0x0, 0x10(%rax)
movq 0x18(%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x44522c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x23c9a0
testb $0x1, %al
jne 0x44522c
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
addq $0x8, %rdi
callq 0x23c830
jmp 0x44522e
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x235e40
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x3a7580
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
callq 0x3a75a0
movq 0x28(%rsp), %rdi
leaq 0x360ba7(%rip), %rax    # 0x7ac418
movq %rax, (%rdi)
leaq 0x360c0d(%rip), %rax    # 0x7ac488
movq %rax, 0x8(%rdi)
leaq 0x360c2a(%rip), %rax    # 0x7ac4b0
movq %rax, 0x20(%rdi)
leaq 0x360c57(%rip), %rax    # 0x7ac4e8
movq %rax, 0x28(%rdi)
addq $0x30, %rdi
movq %rdi, 0x30(%rsp)
movq 0x88(%rsp), %rsi
callq 0x11b140
jmp 0x44b8ad
movq 0x28(%rsp), %rdi
addq $0x50, %rdi
callq 0x43b670
jmp 0x44b8bd
movb $0x1, 0x67(%rsp)
movq $0x0, 0x58(%rsp)
leaq 0x67(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x43b7a0
movq %rdx, 0x18(%rsp)
movb %al, 0x27(%rsp)
jmp 0x44b8e5
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movb 0x27(%rsp), %cl
movb %cl, 0x68(%rsp)
movq %rax, 0x70(%rsp)
addq $0x70, %rdi
leaq 0x68(%rsp), %rsi
callq 0x43b7d0
movb $0x1, 0x47(%rsp)
movq 0x88(%rsp), %rdi
callq 0x11b270
movq %rax, 0x38(%rsp)
leaq 0x47(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x43b7a0
movq %rdx, 0x8(%rsp)
movb %al, 0x17(%rsp)
jmp 0x44b93b
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rax
movb 0x17(%rsp), %cl
movb %cl, 0x48(%rsp)
movq %rax, 0x50(%rsp)
addq $0x50, %rdi
addq $0x30, %rdi
leaq 0x48(%rsp), %rsi
callq 0x43b7d0
movq 0x28(%rsp), %rax
movq 0x78(%rax), %rcx
movq %rcx, 0x90(%rax)
movq 0x88(%rax), %rcx
movq %rcx, 0x98(%rax)
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
jmp 0x44b9b8
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x80(%rsp)
movl %eax, 0x7c(%rsp)
callq 0x11b838
movq 0x28(%rsp), %rdi
addq $0x28, %rdi
callq 0x3a7aa0
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
callq 0x3a7a80
movq 0x28(%rsp), %rdi
callq 0x236080
movq 0x80(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_xrox_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::details::range_pack<double>, exprtk::details::like_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0 = 0;
            std::size_t r1 = 0;

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

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x18(%rsp)
movq 0x20(%rax), %rdi
callq 0x11b270
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
leaq 0x60(%rsp), %rsi
leaq 0x58(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x3eebb0
testb $0x1, %al
jne 0x455afe
jmp 0x455b71
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x30(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x11b710
movq 0x10(%rsp), %rax
movq (%rsp), %rdi
movq 0x28(%rax), %rsi
callq 0x440120
movsd %xmm0, 0x8(%rsp)
jmp 0x455b3f
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x70(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x455b7a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x455b85
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
movsd 0x70(%rsp), %xmm0
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_xroxr_node<double, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::details::range_pack<double>, exprtk::details::like_op<double>>::value() const
inline T value() const exprtk_override
         {
            std::size_t r0_0 = 0;
            std::size_t r0_1 = 0;
            std::size_t r1_0 = 0;
            std::size_t r1_1 = 0;

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

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
movq $0x0, 0x90(%rsp)
movq $0x0, 0x88(%rsp)
movq %rax, %rcx
addq $0x30, %rcx
movq %rcx, 0x20(%rsp)
movq 0x20(%rax), %rdi
callq 0x11b270
movq 0x20(%rsp), %rdi
movq %rax, 0x80(%rsp)
leaq 0xa0(%rsp), %rsi
leaq 0x90(%rsp), %rdx
leaq 0x80(%rsp), %rcx
callq 0x3eebb0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x2b(%rsp)
jne 0x4591da
jmp 0x45921f
movq 0x18(%rsp), %rax
movq %rax, %rcx
addq $0x80, %rcx
movq %rcx, 0x10(%rsp)
movq 0x28(%rax), %rdi
callq 0x11b270
movq 0x10(%rsp), %rdi
movq %rax, 0x78(%rsp)
leaq 0x98(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x78(%rsp), %rcx
callq 0x3eebb0
movb %al, 0x2b(%rsp)
movb 0x2b(%rsp), %al
testb $0x1, %al
jne 0x45922c
jmp 0x4592f0
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rsi
movq 0xa0(%rsp), %rdx
movq 0x90(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x58(%rsp), %rdi
callq 0x11b710
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rsi
movq 0x98(%rsp), %rdx
movq 0x88(%rsp), %rcx
subq %rdx, %rcx
incq %rcx
leaq 0x38(%rsp), %rdi
callq 0x11b710
jmp 0x459280
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x440120
movsd %xmm0, 0x8(%rsp)
jmp 0x459297
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0xb0(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x58(%rsp), %rdi
callq 0x11b838
jmp 0x4592fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x4592e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x58(%rsp), %rdi
callq 0x11b838
jmp 0x45930d
xorps %xmm0, %xmm0
movsd %xmm0, 0xb0(%rsp)
movsd 0xb0(%rsp), %xmm0
addq $0xb8, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
callq 0x470130
andb $0x1, %al
movb %al, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
je 0x470018
movq 0x20(%rsp), %rax
movb 0x20(%rax), %al
movsd 0x12b055(%rip), %xmm0   # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, 0x10(%rsp)
testb $0x1, %al
movsd %xmm0, 0x18(%rsp)
jne 0x47000a
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x470051
movq 0x20(%rsp), %rax
movb 0x20(%rax), %al
xorps %xmm0, %xmm0
movsd 0x12b015(%rip), %xmm1   # 0x59b040
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x470045
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::valid_operator(exprtk::details::operator_type const&, double (*&)(double const&))
inline bool valid_operator(const details::operator_type& operation, unary_functor_t& uop)
         {
            typename unary_op_map_t::iterator uop_itr = unary_op_map_->find(operation);

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

            uop = uop_itr->second;

            return true;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x40(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x485570
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x40(%rax), %rdi
callq 0x4855a0
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x264fd0
testb $0x1, %al
jne 0x485489
jmp 0x485490
movb $0x0, 0x37(%rsp)
jmp 0x4854ab
leaq 0x10(%rsp), %rdi
callq 0x4855d0
movq 0x8(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::uvouv_node<double>::value_type>* exprtk::details::node_allocator::allocate_rrrrr<exprtk::details::uvouv_node<double>, double const, double const, double (*)(double const&), double (*)(double const&), double (*)(double const&, double const&)>(double const&, double const&, double (*&)(double const&), double (*&)(double const&), double (*&)(double const&, double const&)) const
inline expression_node<typename node_type::value_type>* allocate_rrrrr(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x48, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq (%rax), %r8
movq 0x28(%rsp), %rax
movq (%rax), %r9
callq 0x485770
jmp 0x485520
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x48, %esi
callq 0x11b130
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::is_sf3ext_node<double>(exprtk::details::expression_node<double> const*)
inline bool is_sf3ext_node(const expression_node<T>* n)
      {
         switch (n->type())
         {
            case expression_node<T>::e_vovov : return true;
            case expression_node<T>::e_vovoc : return true;
            case expression_node<T>::e_vocov : return true;
            case expression_node<T>::e_covov : return true;
            case expression_node<T>::e_covoc : return true;
            default                          : return false;
         }
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
addl $-0x6a, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x4, %eax
ja 0x48594c
movq (%rsp), %rax
leaq 0x11a4b4(%rip), %rcx    # 0x59fdd4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x17(%rsp)
jmp 0x485951
movb $0x1, 0x17(%rsp)
jmp 0x485951
movb $0x1, 0x17(%rsp)
jmp 0x485951
movb $0x1, 0x17(%rsp)
jmp 0x485951
movb $0x1, 0x17(%rsp)
jmp 0x485951
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf4ext_expression::compile_right_impl<exprtk::details::sf3ext_type_node<double, double const, double const&, double const>, double const&, double const, double const&, double const>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&)
static inline bool compile_right_impl(expression_generator<Type>& expr_gen,
                                                  const std::string& id,
                                                  ExternalType t,
                                                  expression_node_ptr& node,
                                                  expression_node_ptr& result)
            {
               SF3TypeNode* n = dynamic_cast<SF3TypeNode*>(node);

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

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x4867c3
movq 0x10(%rsp), %rdi
leaq 0x2e3a34(%rip), %rsi    # 0x76a1e0
leaq 0x2f0aa5(%rip), %rdx    # 0x777258
xorl %eax, %eax
movl %eax, %ecx
callq 0x11b6d0
movq %rax, 0x8(%rsp)
jmp 0x4867cc
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x4867cc
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x486842
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movsd %xmm0, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movsd 0x28(%rsp), %xmm0
movq 0x20(%rsp), %rcx
movsd 0x18(%rsp), %xmm1
movq 0x38(%rsp), %r8
callq 0x328600
andb $0x1, %al
movb %al, 0x67(%rsp)
jmp 0x486847
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::synthesize_sf4ext_expression::compile_left_impl<exprtk::details::sf3ext_type_node<double, double const, double const&, double const>, double const&, double const, double const&, double const>(exprtk::parser<double>::expression_generator<double>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&, exprtk::details::expression_node<double>*&, exprtk::details::expression_node<double>*&)
static inline bool compile_left_impl(expression_generator<Type>& expr_gen,
                                                 const std::string& id,
                                                 ExternalType t,
                                                 expression_node_ptr& node,
                                                 expression_node_ptr& result)
            {
               SF3TypeNode* n = dynamic_cast<SF3TypeNode*>(node);

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

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x48a253
movq 0x10(%rsp), %rdi
leaq 0x2dffa4(%rip), %rsi    # 0x76a1e0
leaq 0x2ed015(%rip), %rdx    # 0x777258
xorl %eax, %eax
movl %eax, %ecx
callq 0x11b6d0
movq %rax, 0x8(%rsp)
jmp 0x48a25c
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x48a25c
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x48a2d2
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x40(%rax)
movsd %xmm0, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x48(%rax)
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
callq *0x50(%rax)
movsd %xmm0, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movsd 0x28(%rsp), %xmm0
movq 0x20(%rsp), %rdx
movsd 0x18(%rsp), %xmm1
movq 0x48(%rsp), %rcx
movq 0x38(%rsp), %r8
callq 0x316f20
andb $0x1, %al
movb %al, 0x67(%rsp)
jmp 0x48a2d7
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x60(%rsp), %rax
movq (%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0x5f(%rsp)
movq 0x60(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0x5e(%rsp)
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0x5d(%rsp)
movb $0x0, 0x5c(%rsp)
movb 0x5f(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x5e(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
jne 0x4db9ab
movb 0x5e(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
movb 0x5d(%rsp), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
je 0x4db9b2
movb $0x1, 0x5c(%rsp)
jmp 0x4db9dc
movq 0x68(%rsp), %rcx
movl $0x44, %eax
cmpl (%rcx), %eax
je 0x4db9da
testb $0x1, 0x5f(%rsp)
je 0x4db9da
testb $0x1, 0x5e(%rsp)
je 0x4db9da
testb $0x1, 0x5d(%rsp)
je 0x4db9da
movb $0x1, 0x5c(%rsp)
jmp 0x4db9dc
testb $0x1, 0x5c(%rsp)
je 0x4dba77
movq 0x18(%rsp), %rax
movq 0x68(%rax), %rax
movq %rax, 0x8(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x11b6f0
movq 0x10(%rsp), %rdx
leaq 0xcc117(%rip), %rsi     # 0x5a7b27
leaq 0x38(%rsp), %rdi
callq 0x134520
jmp 0x4dba1c
movq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x3e7640
jmp 0x4dba2d
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x4dba77
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x4dba6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x37(%rsp), %rdi
callq 0x11b820
jmp 0x4dba82
movb 0x5c(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0xf(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0xe(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x3a7600
andb $0x1, %al
movb %al, 0xd(%rsp)
xorl %eax, %eax
testb $0x1, 0xf(%rsp)
movb %al, 0xc(%rsp)
je 0x4dbb18
xorl %eax, %eax
testb $0x1, 0xe(%rsp)
movb %al, 0xc(%rsp)
je 0x4dbb18
xorl %eax, %eax
testb $0x1, 0xd(%rsp)
movb %al, 0xc(%rsp)
je 0x4dbb18
movq 0x18(%rsp), %rcx
movl $0x44, %eax
cmpl (%rcx), %eax
sete %al
movb %al, 0xc(%rsp)
movb 0xc(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::trinary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::trinary_node<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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
addq $0x8, %rcx
movq 0x10(%rsp), %r8
addq $0x10, %r8
callq 0x4dd790
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::trinary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::trinary_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3, const T4& t4) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movl $0x58, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rax
movq (%rax), %rdx
movq 0x28(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq (%rax), %r8
callq 0x4dd840
jmp 0x4dd7e5
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x58, %esi
callq 0x11b130
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x20(%rsp), %rax
movsd %xmm0, 0x40(%rsp)
movq 0x38(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x20(%rsp), %rax
movsd %xmm0, 0x38(%rsp)
movq 0x48(%rax), %rdi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq 0x20(%rsp), %rax
movsd %xmm0, 0x30(%rsp)
movl 0x20(%rax), %eax
movl %eax, 0x2c(%rsp)
subl $0x42, %eax
je 0x4ddc66
jmp 0x4ddbe9
movl 0x2c(%rsp), %eax
subl $0x43, %eax
je 0x4ddcc8
jmp 0x4ddbf8
movl 0x2c(%rsp), %eax
subl $0x44, %eax
jne 0x4ddd3b
jmp 0x4ddc07
movsd 0x38(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4ddc24
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
jmp 0x4ddc55
movsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
xorps %xmm3, %xmm3
movsd 0xbd405(%rip), %xmm2    # 0x59b040
cmpltsd %xmm1, %xmm0
movaps %xmm0, %xmm1
andpd %xmm3, %xmm1
andnpd %xmm2, %xmm0
orpd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x4ddd46
movsd 0x38(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x4ddc86
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
jmp 0x4ddcba
movsd 0x38(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jbe 0x4ddca2
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
jmp 0x4ddcae
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x4ddd46
movsd 0x38(%rsp), %xmm1
movsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jae 0x4ddce8
movsd 0x38(%rsp), %xmm0
ucomisd 0x30(%rsp), %xmm0
jb 0x4ddcf6
movsd 0x38(%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x4ddd46
movsd 0xbd382(%rip), %xmm1    # 0x59b080
mulsd 0x38(%rsp), %xmm1
movsd 0x30(%rsp), %xmm0
addsd 0x40(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x4ddd23
movsd 0x40(%rsp), %xmm0
movsd %xmm0, (%rsp)
jmp 0x4ddd2e
movsd 0x30(%rsp), %xmm0
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x50(%rsp)
jmp 0x4ddd46
callq 0x2361c0
movsd %xmm0, 0x50(%rsp)
movsd 0x50(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, 0xf(%rsp)
je 0x4dddfd
movq (%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4dddac
jmp 0x4dddfd
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, 0xf(%rsp)
je 0x4dddfd
movq (%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4dddda
jmp 0x4dddfd
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
movb %al, 0xf(%rsp)
je 0x4dddfd
movq (%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::quaternary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::quaternary_node<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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x10(%rsp), %rcx
addq $0x8, %rcx
movq 0x10(%rsp), %r8
addq $0x10, %r8
movq 0x10(%rsp), %r9
addq $0x18, %r9
callq 0x4de580
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::quaternary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::quaternary_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2,
                                                                          const T3& t3, const T4& t4,
                                                                          const T5& t5) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2, t3, t4, t5));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq %r9, 0x28(%rsp)
movl $0x68, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rax
movq (%rax), %rdx
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x30(%rsp), %rax
movq (%rax), %r8
movq 0x28(%rsp), %rax
movq (%rax), %r9
callq 0x4de640
jmp 0x4de5e3
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x68, %esi
callq 0x11b130
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, 0xf(%rsp)
je 0x4dea6f
movq (%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4de9f0
jmp 0x4dea6f
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, 0xf(%rsp)
je 0x4dea6f
movq (%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4dea1e
jmp 0x4dea6f
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
movb %al, 0xf(%rsp)
je 0x4dea6f
movq (%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4dea4c
jmp 0x4dea6f
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x58(%rcx)
movb %al, 0xf(%rsp)
je 0x4dea6f
movq (%rsp), %rax
movq 0x58(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, (%rsp)
xorl %eax, %eax
testb $0x1, 0x68(%rcx)
movb %al, 0xf(%rsp)
je 0x4e4003
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x100(%rcx)
movb %al, 0xf(%rsp)
je 0x4e4003
movq (%rsp), %rax
movq 0x100(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4e3fa6
jmp 0x4e4003
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x108(%rcx)
movb %al, 0xf(%rsp)
je 0x4e4003
movq (%rsp), %rax
movq 0x108(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0xf(%rsp)
jne 0x4e3fda
jmp 0x4e4003
movq (%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x110(%rcx)
movb %al, 0xf(%rsp)
je 0x4e4003
movq (%rsp), %rax
movq 0x110(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::conditional_vector_node<double>::value() const
inline T value() const exprtk_override
         {
            T result = T(0);
            T* source_vector = 0;
            T* result_vector = vds().data();

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

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

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x4e4bd0
movq %rax, %rdi
callq 0x3b8ad0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x28, %rdi
callq 0x4e4d70
testb $0x1, %al
jne 0x4e48fb
jmp 0x4e494d
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movq 0x58(%rax), %rdi
callq 0x3a0c40
movq %rax, %rdi
callq 0x3a0c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x58(%rax), %rdi
callq 0x3a1990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x80(%rax)
jmp 0x4e499d
movq 0x8(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movsd %xmm0, 0x28(%rsp)
movq 0x60(%rax), %rdi
callq 0x3a0c40
movq %rax, %rdi
callq 0x3a0c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rsp)
movq 0x60(%rax), %rdi
callq 0x3a1990
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x80(%rax)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
cmpq 0x80(%rcx), %rax
jae 0x4e49e7
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x4e49a6
movsd 0x28(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
testb $0x1, 0x88(%rcx)
movb %al, 0x1f(%rsp)
je 0x4e4af8
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x28(%rcx)
movb %al, 0x1f(%rsp)
je 0x4e4af8
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x4e4a6d
jmp 0x4e4af8
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x38(%rcx)
movb %al, 0x1f(%rsp)
je 0x4e4af8
movq 0x10(%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x4e4a9d
jmp 0x4e4af8
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x48(%rcx)
movb %al, 0x1f(%rsp)
je 0x4e4af8
movq 0x10(%rsp), %rax
movq 0x48(%rax), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x4e4acd
jmp 0x4e4af8
movq 0x10(%rsp), %rdi
callq 0x4e4b50
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x4e4b70
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
setbe %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::details::node_depth_base<exprtk::details::expression_node<double>>::compute_node_depth<std::pair<exprtk::details::expression_node<double>*, bool>>(std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&, std::pair<exprtk::details::expression_node<double>*, bool> const&) const
std::size_t compute_node_depth(const BranchType& n0, const BranchType& n1,
                                        const BranchType& n2) const
         {
            if (!depth_set)
            {
               depth = 1 + max_node_depth(n0, n1, n2);
               depth_set = true;
            }

            return depth;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
testb $0x1, 0x8(%rax)
jne 0x4e4e12
movq (%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x4e4e20
movq %rax, %rcx
movq (%rsp), %rax
addq $0x1, %rcx
movq %rcx, 0x10(%rax)
movb $0x1, 0x8(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rax
addq $0x28, %rsp
retq
nop