LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::range_pack<double>::operator()(unsigned long&, unsigned long&, unsigned long const&) const
bool operator() (std::size_t& r0, std::size_t& r1,
                          const std::size_t& size = std::numeric_limits<std::size_t>::max()) const
         {
            if (n0_c.first)
               r0 = n0_c.second;
            else if (n0_e.first)
            {
               r0 = static_cast<std::size_t>(details::numeric::to_int64(n0_e.second->value()));
            }
            else
               return false;

            if (n1_c.first)
               r1 = n1_c.second;
            else if (n1_e.first)
            {
               r1 = static_cast<std::size_t>(details::numeric::to_int64(n1_e.second->value()));
            }
            else
               return false;

            if (
                 (std::numeric_limits<std::size_t>::max() != size) &&
                 (std::numeric_limits<std::size_t>::max() == r1  )
               )
            {
               r1 = size;
            }

            cache.first  = r0;
            cache.second = r1;

            #ifndef exprtk_enable_range_runtime_checks
            return (r0 <= r1);
            #else
            return range_runtime_check(r0, r1, size);
            #endif
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x20(%rax)
je 0x3eebeb
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x3eec22
movq 0x8(%rsp), %rax
testb $0x1, (%rax)
je 0x3eec16
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x3eed30
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0x3eec20
movb $0x0, 0x37(%rsp)
jmp 0x3eecd9
jmp 0x3eec22
movq 0x8(%rsp), %rax
testb $0x1, 0x30(%rax)
je 0x3eec40
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x3eec75
movq 0x8(%rsp), %rax
testb $0x1, 0x10(%rax)
je 0x3eec6c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x3eed30
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
jmp 0x3eec73
movb $0x0, 0x37(%rsp)
jmp 0x3eecd9
jmp 0x3eec75
callq 0x237af0
movq 0x10(%rsp), %rcx
cmpq (%rcx), %rax
je 0x3eeca3
callq 0x237af0
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
jne 0x3eeca3
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x40(%rax)
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, 0x48(%rax)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rsp), %rcx
cmpq (%rcx), %rax
setbe %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_string_range_node<double, exprtk::details::asn_assignment>::value() const
inline T value() const exprtk_override
         {
            branch(0)->value();
            branch(1)->value();

            std::size_t s0_r0 = 0;
            std::size_t s0_r1 = 0;

            std::size_t s1_r0 = 0;
            std::size_t s1_r1 = 0;

            const range_t& range0 = (*str0_range_ptr_);
            const range_t& range1 = (*str1_range_ptr_);

            if (
                  range0(s0_r0, s0_r1, str0_base_ptr_->size()) &&
                  range1(s1_r0, s1_r1, str1_base_ptr_->size())
               )
            {
               const std::size_t size = std::min((s0_r1 - s0_r0), (s1_r1 - s1_r0));

               std::copy(
                  str1_base_ptr_->base() + s1_r0,
                  str1_base_ptr_->base() + s1_r0 + size,
                  const_cast<char_ptr>(base() + s0_r0));
            }

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

// Assembly:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq $0x0, 0x98(%rsp)
leaq 0x98(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rsp), %rdi
movq $0x1, 0x90(%rsp)
leaq 0x90(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rsp), %rax
movq $0x0, 0x88(%rsp)
movq $0x0, 0x80(%rsp)
movq $0x0, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq 0x78(%rax), %rcx
movq %rcx, 0x68(%rsp)
movq 0x80(%rax), %rcx
movq %rcx, 0x60(%rsp)
movq 0x68(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq 0x60(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x28(%rsp), %rdi
movq %rax, 0x58(%rsp)
leaq 0x88(%rsp), %rsi
leaq 0x80(%rsp), %rdx
leaq 0x58(%rsp), %rcx
callq 0x3eebb0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x37(%rsp)
jne 0x3ef4e0
jmp 0x3ef51b
movq 0x20(%rsp), %rax
movq 0x60(%rsp), %rcx
movq %rcx, 0x18(%rsp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x20(%rax)
movq 0x18(%rsp), %rdi
movq %rax, 0x50(%rsp)
leaq 0x78(%rsp), %rsi
leaq 0x70(%rsp), %rdx
leaq 0x50(%rsp), %rcx
callq 0x3eebb0
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
testb $0x1, %al
jne 0x3ef528
jmp 0x3ef5c4
movq 0x80(%rsp), %rax
subq 0x88(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rax
subq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x234c90
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x48(%rsp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rcx
movq 0x20(%rsp), %rax
addq 0x78(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x68(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x20(%rsp), %rdi
addq 0x78(%rsp), %rax
addq 0x48(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0x3ef660
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
addq 0x88(%rsp), %rdx
callq 0x3ef850
callq 0x2361c0
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_vec_node<double>::assignment_vec_node(exprtk::details::operator_type const&, exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
assignment_vec_node(const operator_type& opr,
                             expression_ptr branch0,
                             expression_ptr branch1)
         : binary_node<T>(opr, branch0, branch1)
         , vec_node_ptr_(0)
         {
            if (is_vector_node(branch(0)))
            {
               vec_node_ptr_ = static_cast<vector_node<T>*>(branch(0));
               vds()         = vec_node_ptr_->vds();
            }

            assert(valid());
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x4db7c0
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x3b76c0
movq 0x18(%rsp), %rdi
leaq 0x3b2b20(%rip), %rax    # 0x7a34c0
movq %rax, (%rdi)
leaq 0x3b2b96(%rip), %rax    # 0x7a3540
movq %rax, 0x8(%rdi)
leaq 0x3b2bb3(%rip), %rax    # 0x7a3568
movq %rax, 0x48(%rdi)
movq $0x0, 0x50(%rdi)
addq $0x58, %rdi
movq %rdi, 0x20(%rsp)
callq 0x3b76e0
jmp 0x3f09d1
movq 0x18(%rsp), %rdi
movq $0x0, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
callq 0x3b7740
movb %al, 0x17(%rsp)
jmp 0x3f09f7
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3f0a01
jmp 0x3f0a7f
movq 0x18(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x50(%rax)
movq 0x50(%rax), %rdi
callq 0x3a0c40
movq 0x18(%rsp), %rdi
movq %rax, (%rsp)
callq 0x3f0ab0
movq %rax, 0x8(%rsp)
jmp 0x3f0a43
movq (%rsp), %rsi
movq 0x8(%rsp), %rdi
callq 0x3b7780
jmp 0x3f0a53
jmp 0x3f0a7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x3f0a84
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x3b7890
jmp 0x3f0a84
addq $0x68, %rsp
retq
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x3b8250
movq 0x18(%rsp), %rdi
callq 0x3ec280
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_vec_node<double>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec_node_ptr_ &&
               (vds().size() <= vec_node_ptr_->vec_holder().base_size()) &&
               binary_node<T>::valid();
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, 0x1f(%rsp)
je 0x3f0f41
movq 0x10(%rsp), %rdi
callq 0x3f0fb0
movq %rax, %rdi
callq 0x3b8af0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x50(%rax), %rdi
callq 0x3b7a10
movq %rax, %rdi
callq 0x3b88b0
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
ja 0x3f0f41
movq 0x10(%rsp), %rdi
callq 0x3ec310
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::is_ivariable_node<double>(exprtk::details::expression_node<double> const*)
inline bool is_ivariable_node(const expression_node<T>* node)
      {
         return node &&
                (
                  details::expression_node<T>::e_variable      == node->type() ||
                  details::expression_node<T>::e_vecelem       == node->type() ||
                  details::expression_node<T>::e_veccelem      == node->type() ||
                  details::expression_node<T>::e_vecelemrtc    == node->type() ||
                  details::expression_node<T>::e_veccelemrtc   == node->type() ||
                  details::expression_node<T>::e_rbvecelem     == node->type() ||
                  details::expression_node<T>::e_rbveccelem    == node->type() ||
                  details::expression_node<T>::e_rbvecelemrtc  == node->type() ||
                  details::expression_node<T>::e_rbveccelemrtc == node->type()
                );
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xf(%rsp)
je 0x3f122e
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x11, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x7e, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x7f, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x80, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x81, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x82, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x84, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %edx
movb $0x1, %al
movl $0x83, %ecx
cmpl %edx, %ecx
movb %al, 0xe(%rsp)
je 0x3f1226
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x28(%rax)
movl %eax, %ecx
movl $0x85, %eax
cmpl %ecx, %eax
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::swap_vecvec_node<double>::value() const
inline T value() const exprtk_override
         {
            binary_node<T>::branch(0)->value();
            binary_node<T>::branch(1)->value();

            T* vec0 = vec0_node_ptr_->vds().data();
            T* vec1 = vec1_node_ptr_->vds().data();

            assert(size() <= base_size());
            const std::size_t n = size();

            for (std::size_t i = 0; i < n; ++i)
            {
               std::swap(vec0[i],vec1[i]);
            }

            return vec1_node_ptr_->value();
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rdi
movq $0x1, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
callq 0x3a0c40
movq %rax, %rdi
callq 0x3a0c50
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x28(%rsp)
movq 0x58(%rax), %rdi
callq 0x3a0c40
movq %rax, %rdi
callq 0x3a0c50
movq 0x8(%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x3f1c10
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x18(%rsp), %rax
jae 0x3f1e24
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x3f1660
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3f1de1
movq 0x8(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x3b8ef0
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::swap_string_node<double>::swap_string_node(exprtk::details::expression_node<double>*, exprtk::details::expression_node<double>*)
swap_string_node(expression_ptr branch0, expression_ptr branch1)
         : binary_node<T>(details::e_swap, branch0, branch1)
         , initialised_(false)
         , str0_node_ptr_(0)
         , str1_node_ptr_(0)
         {
            if (is_string_node(branch(0)))
            {
               str0_node_ptr_ = static_cast<strvar_node_ptr>(branch(0));
            }

            if (is_string_node(branch(1)))
            {
               str1_node_ptr_ = static_cast<strvar_node_ptr>(branch(1));
            }

            initialised_ = (str0_node_ptr_ && str1_node_ptr_);
            assert(valid());
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0x5c, 0x4c(%rsp)
movq 0x58(%rsp), %rdx
movq 0x50(%rsp), %rcx
leaq 0x4c(%rsp), %rsi
callq 0x4db7c0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x3a7580
movq 0x8(%rsp), %rdi
addq $0x50, %rdi
callq 0x3a75a0
movq 0x8(%rsp), %rdi
leaq 0x3b17e7(%rip), %rax    # 0x7a3848
movq %rax, (%rdi)
leaq 0x3b1855(%rip), %rax    # 0x7a38c0
movq %rax, 0x8(%rdi)
leaq 0x3b1872(%rip), %rax    # 0x7a38e8
movq %rax, 0x48(%rdi)
leaq 0x3b189f(%rip), %rax    # 0x7a3920
movq %rax, 0x50(%rdi)
movb $0x0, 0x58(%rdi)
movq $0x0, 0x60(%rdi)
movq $0x0, 0x68(%rdi)
movq $0x0, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
callq 0x23c9a0
movb %al, 0x17(%rsp)
jmp 0x3f20ba
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3f20c4
jmp 0x3f2123
movq 0x8(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rax)
jmp 0x3f2123
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
addq $0x50, %rdi
callq 0x3a7aa0
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x3a7a80
movq 0x8(%rsp), %rdi
callq 0x3ec280
jmp 0x3f21ae
movq 0x8(%rsp), %rdi
movq $0x1, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
callq 0x23c9a0
movb %al, 0x7(%rsp)
jmp 0x3f2149
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x3f2153
jmp 0x3f2177
movq 0x8(%rsp), %rdi
movq $0x1, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x68(%rax)
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq $0x0, 0x60(%rcx)
movb %al, 0x6(%rsp)
je 0x3f219a
movq 0x8(%rsp), %rax
cmpq $0x0, 0x68(%rax)
setne %al
movb %al, 0x6(%rsp)
movq 0x8(%rsp), %rax
movb 0x6(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x58(%rax)
addq $0x68, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::swap_string_node<double>::value() const
inline T value() const exprtk_override
         {
            branch(0)->value();
            branch(1)->value();

            std::swap(str0_node_ptr_->ref(), str1_node_ptr_->ref());

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, (%rsp)
movq $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rdi
movq $0x1, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x3eed20
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x68(%rax), %rdi
callq 0x3eed20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3f2530
callq 0x2361c0
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::assignment_enabled(exprtk::details::operator_type const&) const
bool assignment_enabled(const details::operator_type& assignment) const
         {
            if (disabled_assignment_set_.empty())
               return true;
            else
               return disabled_assignment_set_.end() == disabled_assignment_set_
                                                           .find(assign_opr_to_string(assignment));
         }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
addq $0xd0, %rdi
callq 0x399140
testb $0x1, %al
jne 0x3f307a
jmp 0x3f3084
movb $0x1, 0x77(%rsp)
jmp 0x3f3113
movq 0x18(%rsp), %rdi
addq $0xd0, %rdi
movq %rdi, (%rsp)
callq 0x256550
movq 0x18(%rsp), %rsi
movq %rax, 0x58(%rsp)
movq 0x60(%rsp), %rax
movl (%rax), %edx
leaq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x3f3130
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x399160
movq %rax, 0x10(%rsp)
jmp 0x3f30ce
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x234630
andb $0x1, %al
movb %al, 0x77(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x3f3113
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x11b838
jmp 0x3f311e
movb 0x77(%rsp), %al
andb $0x1, %al
addq $0x78, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::assignment_vec_op_node<double, exprtk::details::add_op<double>>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec_node_ptr_           &&
               (size() <= base_size()) &&
               binary_node<T>::valid() ;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, 0x1f(%rsp)
je 0x3ff9fa
movq 0x10(%rsp), %rdi
callq 0x3ffa30
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x3ffa50
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
ja 0x3ff9fa
movq 0x10(%rsp), %rdi
callq 0x3ec310
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_binop_vecval_node<double, exprtk::details::lt_op<double>>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec0_node_ptr_          &&
               (size() <= base_size()) &&
               binary_node<T>::valid();
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, 0x1f(%rsp)
je 0x41342a
movq 0x10(%rsp), %rdi
callq 0x413460
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x413480
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
ja 0x41342a
movq 0x10(%rsp), %rdi
callq 0x3ec310
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_binop_valvec_node<double, exprtk::details::lt_op<double>>::valid() const
inline bool valid() const exprtk_override
         {
            return
               vec1_node_ptr_               &&
               (size() <= base_size())      &&
               (vds_.size() <= base_size()) &&
               binary_node<T>::valid();
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x50(%rcx)
movb %al, 0x1f(%rsp)
je 0x41da18
movq 0x10(%rsp), %rdi
callq 0x41da50
movq 0x10(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x41da70
movq 0x8(%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
ja 0x41da18
movq 0x10(%rsp), %rdi
addq $0x58, %rdi
callq 0x3b8af0
movq 0x10(%rsp), %rdi
movq %rax, (%rsp)
callq 0x41da70
movq (%rsp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, 0x1f(%rsp)
ja 0x41da18
movq 0x10(%rsp), %rdi
callq 0x3ec310
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: exprtk::details::scand_node<double>::value() const
inline T value() const exprtk_override
         {
            return (
                     std::not_equal_to<T>()
                        (T(0),branch(0)->value()) &&
                     std::not_equal_to<T>()
                        (T(0),branch(1)->value())
                   ) ? T(1) : T(0);
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x48(%rsp)
leaq 0x5f(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x4382f1
jmp 0x438339
movq 0x10(%rsp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
movq $0x1, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x3ebf00
movq %rax, %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movsd %xmm0, 0x28(%rsp)
leaq 0x3f(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x265d60
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
movsd 0x162cfb(%rip), %xmm0   # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x438362
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_socs_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_socs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string& s0 = static_cast<     details::stringvar_node<Type>*>(branch[0])->ref();
            std::string  s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str();

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

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

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rdi
callq 0x3eed20
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x58(%rsp), %rdi
callq 0x4420a0
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x80(%rsp), %rsi
addq $0x8, %rsi
callq 0x284bd0
jmp 0x438ef3
movq 0x88(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x11b140
jmp 0x438f1b
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rcx
callq 0x4420d0
movq %rax, 0x8(%rsp)
jmp 0x438f3b
leaq 0x28(%rsp), %rdi
callq 0x11b838
leaq 0x58(%rsp), %rdi
callq 0x11b838
movq 0x8(%rsp), %rax
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
jmp 0x438f84
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
movq 0x50(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_sosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_sosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::stringvar_node<Type>*>   (branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();

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

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

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

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x120(%rsp), %rax
movq (%rax), %rdi
callq 0x3eed20
movq %rax, 0x118(%rsp)
movq 0x120(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x443bc0
movq %rax, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x443bd0
movq 0x120(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3efa00
movq %rax, %rdi
callq 0x443c00
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x120(%rsp), %rsi
addq $0x8, %rsi
callq 0x284bd0
movq 0x128(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movl $0x50, %edx
callq 0x11b0c0
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
movups 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x443d40
addq $0x138, %rsp            # imm = 0x138
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_socsr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_socsr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::stringvar_node<Type>*>         (branch[0])->ref  ();
            std::string   s1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->str  ();
            range_t      rp1 = static_cast<details::const_string_range_node<Type>*>(branch[1])->range();

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

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

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

// Assembly:
subq $0x198, %rsp            # imm = 0x198
movq %rdi, 0x190(%rsp)
movq %rsi, 0x188(%rsp)
movq %rdx, 0x180(%rsp)
movq 0x190(%rsp), %rax
movq %rax, 0x78(%rsp)
movq 0x180(%rsp), %rax
movq (%rax), %rdi
callq 0x3eed20
movq %rax, 0x178(%rsp)
movq 0x180(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x158(%rsp), %rdi
callq 0x4463c0
movq 0x180(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x108(%rsp), %rdi
callq 0x4463f0
jmp 0x439168
movq 0x180(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x446420
movq %rax, 0x70(%rsp)
jmp 0x439180
movq 0x70(%rsp), %rdi
callq 0x443c00
jmp 0x43918c
movq 0x78(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x180(%rsp), %rsi
addq $0x8, %rsi
callq 0x284bd0
jmp 0x4391a8
movq 0x188(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x178(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0xd8(%rsp), %rdi
leaq 0x158(%rsp), %rsi
callq 0x11b140
jmp 0x4391d9
movq 0x68(%rsp), %rdx
movq 0x60(%rsp), %rsi
movq 0x78(%rsp), %rdi
movups 0x148(%rsp), %xmm0
movaps %xmm0, 0xc0(%rsp)
movups 0x108(%rsp), %xmm0
movups 0x118(%rsp), %xmm1
movups 0x128(%rsp), %xmm2
movups 0x138(%rsp), %xmm3
movaps %xmm3, 0xb0(%rsp)
movaps %xmm2, 0xa0(%rsp)
movaps %xmm1, 0x90(%rsp)
movaps %xmm0, 0x80(%rsp)
movaps 0xc0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0x80(%rsp), %xmm0
movaps 0x90(%rsp), %xmm1
movaps 0xa0(%rsp), %xmm2
movaps 0xb0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xd8(%rsp), %rcx
callq 0x446430
movq %rax, 0x58(%rsp)
jmp 0x43928a
leaq 0xd8(%rsp), %rdi
callq 0x11b838
leaq 0x158(%rsp), %rdi
callq 0x11b838
movq 0x58(%rsp), %rax
addq $0x198, %rsp            # imm = 0x198
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
jmp 0x4392e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x100(%rsp)
movl %eax, 0xfc(%rsp)
leaq 0xd8(%rsp), %rdi
callq 0x11b838
leaq 0x158(%rsp), %rdi
callq 0x11b838
movq 0x100(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csos_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csos_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string  s0 = static_cast<details::string_literal_node<Type>*>(branch[0])->str();
            std::string& s1 = static_cast<details::stringvar_node<Type>*     >(branch[1])->ref();

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

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rsi
leaq 0x50(%rsp), %rdi
callq 0x4420a0
movq 0x70(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3eed20
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rdi
movq 0x70(%rsp), %rsi
callq 0x284bd0
jmp 0x439373
movq 0x78(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x11b140
jmp 0x43938e
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rcx
leaq 0x18(%rsp), %rdx
callq 0x449440
movq %rax, (%rsp)
jmp 0x4393ad
leaq 0x18(%rsp), %rdi
callq 0x11b838
leaq 0x50(%rsp), %rdi
callq 0x11b838
movq (%rsp), %rax
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
jmp 0x4393f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x11b838
leaq 0x50(%rsp), %rdi
callq 0x11b838
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string  s0  = static_cast<details::string_literal_node<Type>*>(branch[0])->str  ();
            std::string& s1  = static_cast<details::string_range_node<Type>*  >(branch[1])->ref  ();
            range_t      rp1 = static_cast<details::string_range_node<Type>*  >(branch[1])->range();

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

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

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

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0x150(%rsp), %rdi
callq 0x4420a0
movq 0x170(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x443bc0
movq %rax, 0x148(%rsp)
movq 0x170(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x443bd0
movq 0x170(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3efa00
movq %rax, %rdi
callq 0x443c00
jmp 0x4398f1
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x170(%rsp), %rsi
callq 0x284bd0
jmp 0x439909
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x170(%rsp), %rsi
addq $0x8, %rsi
callq 0x284bd0
jmp 0x439925
movq 0x178(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x11b140
jmp 0x439949
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdi
movq 0x148(%rsp), %rcx
movups 0x138(%rsp), %xmm0
movaps %xmm0, 0xb0(%rsp)
movups 0xf8(%rsp), %xmm0
movups 0x108(%rsp), %xmm1
movups 0x118(%rsp), %xmm2
movups 0x128(%rsp), %xmm3
movaps %xmm3, 0xa0(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movaps 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xc8(%rsp), %rdx
callq 0x44d500
movq %rax, 0x58(%rsp)
jmp 0x4399f7
leaq 0xc8(%rsp), %rdi
callq 0x11b838
leaq 0x150(%rsp), %rdi
callq 0x11b838
movq 0x58(%rsp), %rax
addq $0x188, %rsp            # imm = 0x188
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x439a55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x11b838
leaq 0x150(%rsp), %rdi
callq 0x11b838
movq 0xf0(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_sros_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_sros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*>   (branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();

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

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

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

// Assembly:
subq $0x138, %rsp            # imm = 0x138
movq %rdi, 0x130(%rsp)
movq %rsi, 0x128(%rsp)
movq %rdx, 0x120(%rsp)
movq 0x130(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x120(%rsp), %rax
movq (%rax), %rdi
callq 0x443bc0
movq %rax, 0x118(%rsp)
movq 0x120(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3eed20
movq %rax, 0x110(%rsp)
movq 0x120(%rsp), %rax
movq (%rax), %rsi
leaq 0xc0(%rsp), %rdi
callq 0x443bd0
movq 0x120(%rsp), %rax
movq (%rax), %rdi
callq 0x3efa00
movq %rax, %rdi
callq 0x443c00
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x120(%rsp), %rsi
callq 0x284bd0
movq 0x128(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x118(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x110(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
movl $0x50, %edx
callq 0x11b0c0
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x68(%rsp), %rcx
movups 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x4539b0
addq $0x138, %rsp            # imm = 0x138
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_srosr_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_srosr_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*>(branch[0])->ref  ();
            std::string&  s1 = static_cast<details::string_range_node<Type>*>(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*>(branch[0])->range();
            range_t      rp1 = static_cast<details::string_range_node<Type>*>(branch[1])->range();

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

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

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

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq %rdx, 0x210(%rsp)
movq 0x220(%rsp), %rax
movq %rax, 0xa0(%rsp)
movq 0x210(%rsp), %rax
movq (%rax), %rdi
callq 0x443bc0
movq %rax, 0x208(%rsp)
movq 0x210(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x443bc0
movq %rax, 0x200(%rsp)
movq 0x210(%rsp), %rax
movq (%rax), %rsi
leaq 0x1b0(%rsp), %rdi
callq 0x443bd0
movq 0x210(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x160(%rsp), %rdi
callq 0x443bd0
movq 0x210(%rsp), %rax
movq (%rax), %rdi
callq 0x3efa00
movq %rax, %rdi
callq 0x443c00
movq 0x210(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3efa00
movq %rax, %rdi
callq 0x443c00
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x210(%rsp), %rsi
callq 0x284bd0
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x210(%rsp), %rsi
addq $0x8, %rsi
callq 0x284bd0
movq 0x218(%rsp), %rax
movq %rax, 0xa8(%rsp)
movq 0x208(%rsp), %rax
movq %rax, 0xb0(%rsp)
movq 0x200(%rsp), %rax
movq %rax, 0xb8(%rsp)
leaq 0x110(%rsp), %rdi
leaq 0x1b0(%rsp), %rsi
movl $0x50, %edx
callq 0x11b0c0
leaq 0xc0(%rsp), %rdi
leaq 0x160(%rsp), %rsi
movl $0x50, %edx
callq 0x11b0c0
movq 0xa0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
movq 0xb8(%rsp), %rcx
movups 0x100(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x90(%rax)
movups 0xc0(%rsp), %xmm0
movups 0xd0(%rsp), %xmm1
movups 0xe0(%rsp), %xmm2
movups 0xf0(%rsp), %xmm3
movups %xmm3, 0x80(%rax)
movups %xmm2, 0x70(%rax)
movups %xmm1, 0x60(%rax)
movups %xmm0, 0x50(%rax)
movups 0x150(%rsp), %xmm0
movups %xmm0, 0x40(%rax)
movups 0x110(%rsp), %xmm0
movups 0x120(%rsp), %xmm1
movups 0x130(%rsp), %xmm2
movups 0x140(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x455e30
addq $0x228, %rsp            # imm = 0x228
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_srocs_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_srocs_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string&  s0 = static_cast<details::string_range_node<Type>*  >(branch[0])->ref  ();
            std::string   s1 = static_cast<details::string_literal_node<Type>*>(branch[1])->str  ();
            range_t      rp0 = static_cast<details::string_range_node<Type>*  >(branch[0])->range();

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

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

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

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x170(%rsp), %rax
movq (%rax), %rdi
callq 0x443bc0
movq %rax, 0x168(%rsp)
movq 0x170(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x148(%rsp), %rdi
callq 0x4420a0
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x443bd0
movq 0x170(%rsp), %rax
movq (%rax), %rdi
callq 0x3efa00
movq %rax, %rdi
callq 0x443c00
jmp 0x43a0df
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x170(%rsp), %rsi
callq 0x284bd0
jmp 0x43a0f7
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x170(%rsp), %rsi
addq $0x8, %rsi
callq 0x284bd0
jmp 0x43a113
movq 0x178(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x168(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0x148(%rsp), %rsi
callq 0x11b140
jmp 0x43a144
movq 0x60(%rsp), %rdx
movq 0x58(%rsp), %rsi
movq 0x68(%rsp), %rdi
movups 0x138(%rsp), %xmm0
movaps %xmm0, 0xb0(%rsp)
movups 0xf8(%rsp), %xmm0
movups 0x108(%rsp), %xmm1
movups 0x118(%rsp), %xmm2
movups 0x128(%rsp), %xmm3
movaps %xmm3, 0xa0(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movaps 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xc8(%rsp), %rcx
callq 0x4596e0
movq %rax, 0x50(%rsp)
jmp 0x43a1ef
leaq 0xc8(%rsp), %rdi
callq 0x11b838
leaq 0x148(%rsp), %rdi
callq 0x11b838
movq 0x50(%rsp), %rax
addq $0x188, %rsp            # imm = 0x188
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x43a24d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x11b838
leaq 0x148(%rsp), %rdi
callq 0x11b838
movq 0xf0(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::synthesize_csros_expression(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [2])
inline expression_node_ptr synthesize_csros_expression(const details::operator_type& opr, expression_node_ptr (&branch)[2])
         {
            std::string   s0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->str  ();
            std::string&  s1 = static_cast<details::stringvar_node<Type>*         >(branch[1])->ref  ();
            range_t      rp0 = static_cast<details::const_string_range_node<Type>*>(branch[0])->range();

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

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

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

// Assembly:
subq $0x188, %rsp            # imm = 0x188
movq %rdi, 0x180(%rsp)
movq %rsi, 0x178(%rsp)
movq %rdx, 0x170(%rsp)
movq 0x180(%rsp), %rax
movq %rax, 0x68(%rsp)
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0x150(%rsp), %rdi
callq 0x4463c0
movq 0x170(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x3eed20
movq %rax, 0x148(%rsp)
movq 0x170(%rsp), %rax
movq (%rax), %rsi
leaq 0xf8(%rsp), %rdi
callq 0x4463f0
movq 0x170(%rsp), %rax
movq (%rax), %rdi
callq 0x446420
movq %rax, %rdi
callq 0x443c00
jmp 0x43a60f
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x170(%rsp), %rsi
callq 0x284bd0
jmp 0x43a627
movq 0x178(%rsp), %rax
movq %rax, 0x60(%rsp)
leaq 0xc8(%rsp), %rdi
leaq 0x150(%rsp), %rsi
callq 0x11b140
jmp 0x43a64b
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdi
movq 0x148(%rsp), %rcx
movups 0x138(%rsp), %xmm0
movaps %xmm0, 0xb0(%rsp)
movups 0xf8(%rsp), %xmm0
movups 0x108(%rsp), %xmm1
movups 0x118(%rsp), %xmm2
movups 0x128(%rsp), %xmm3
movaps %xmm3, 0xa0(%rsp)
movaps %xmm2, 0x90(%rsp)
movaps %xmm1, 0x80(%rsp)
movaps %xmm0, 0x70(%rsp)
movaps 0xb0(%rsp), %xmm0
movq %rsp, %rax
movups %xmm0, 0x40(%rax)
movaps 0x70(%rsp), %xmm0
movaps 0x80(%rsp), %xmm1
movaps 0x90(%rsp), %xmm2
movaps 0xa0(%rsp), %xmm3
movups %xmm3, 0x30(%rax)
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0xc8(%rsp), %rdx
callq 0x460b30
movq %rax, 0x58(%rsp)
jmp 0x43a6f9
leaq 0xc8(%rsp), %rdi
callq 0x11b838
leaq 0x150(%rsp), %rdi
callq 0x11b838
movq 0x58(%rsp), %rax
addq $0x188, %rsp            # imm = 0x188
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
jmp 0x43a757
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xf0(%rsp)
movl %eax, 0xec(%rsp)
leaq 0xc8(%rsp), %rdi
callq 0x11b838
leaq 0x150(%rsp), %rdi
callq 0x11b838
movq 0xf0(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::wc_match(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool wc_match(const std::string& wild_card,
                           const std::string& str)
      {
         return match_impl<char_cptr,cs_match>
                (
                   wild_card.data(),
                   wild_card.data() + wild_card.size(),
                   str.data(),
                   str.data() + str.size(),
                   '*', '?'
                );
      }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b230
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b230
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq 0x8(%rsp), %rax
addq %rcx, %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11b230
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11b230
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0x11b270
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
addq %rax, %rcx
movb $0x2a, 0x37(%rsp)
movb $0x3f, 0x36(%rsp)
leaq 0x37(%rsp), %r8
leaq 0x36(%rsp), %r9
callq 0x440220
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop