LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpy<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t y(parameters[2]);

         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;

         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 3, 4, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();

         const T a = scalar_t(parameters[0])();

         for (std::size_t i = r0; i <= r1; ++i)
         {
            y[i] = (a * x[i]) + y[i];
         }

         return T(1);
      }

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0xb8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq $0x1, 0x90(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x98(%rsp), %rdi
callq 0x572e40
movq $0x2, 0x78(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x572e70
movq %rax, 0x60(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x572e70
movq %rax, 0x58(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x68(%rsp)
movq 0xa8(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x27(%rsp)
jne 0x5780fa
movq $0x3, 0x50(%rsp)
movq $0x4, 0x48(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x50(%rsp), %rcx
leaq 0x48(%rsp), %r8
movl $0x1, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
testb $0x1, %al
jne 0x578104
jmp 0x578117
callq 0x2361c0
movsd %xmm0, 0xc0(%rsp)
jmp 0x578237
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x5730a0
testb $0x1, %al
jne 0x578134
jmp 0x578147
callq 0x2361c0
movsd %xmm0, 0xc0(%rsp)
jmp 0x578237
jmp 0x578149
movq $0x0, 0x30(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x572e10
leaq 0x38(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq 0x68(%rsp), %rax
ja 0x578226
movsd 0x40(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x574b60
movsd 0x8(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd (%rax), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x574b60
movsd 0x18(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x57818f
movsd 0x22e12(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpbz<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t z(parameters[3]);

         std::size_t r0 = 0;
         std::size_t r1 = x.size() - 1;

         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 4, 5, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(z, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();

         const T a = scalar_t(parameters[0])();
         const T b = scalar_t(parameters[2])();

         for (std::size_t i = r0; i <= r1; ++i)
         {
            z[i] = (a * x[i]) + b;
         }

         return T(1);
      }

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0xb8(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq $0x1, 0x90(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x98(%rsp), %rdi
callq 0x572e40
movq $0x3, 0x78(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x80(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x68(%rsp)
movq 0xa8(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x1f(%rsp)
jne 0x5794c1
movq $0x4, 0x60(%rsp)
movq $0x5, 0x58(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
leaq 0x60(%rsp), %rcx
leaq 0x58(%rsp), %r8
movl $0x1, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x5794cb
jmp 0x5794de
callq 0x2361c0
movsd %xmm0, 0xc0(%rsp)
jmp 0x579617
movq 0x70(%rsp), %rsi
movq 0x68(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x5730a0
testb $0x1, %al
jne 0x5794fb
jmp 0x57950e
callq 0x2361c0
movsd %xmm0, 0xc0(%rsp)
jmp 0x579617
jmp 0x579510
movq $0x0, 0x40(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x572e10
leaq 0x48(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd %xmm0, 0x50(%rsp)
movq $0x2, 0x28(%rsp)
leaq 0xb8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x572e10
leaq 0x30(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x68(%rsp), %rax
ja 0x579606
movsd 0x50(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x572fd0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x574b60
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x579592
movsd 0x21a32(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0xc0(%rsp)
movsd 0xc0(%rsp), %xmm0
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::diff<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
               vector_t y(parameters[1]);

         const std::size_t r0 = 0;
         const std::size_t r1 = std::min(x.size(),y.size()) - 1;

         const std::size_t stride = (1 != ps_index) ? 1 :
                                    std::min(r1,static_cast<std::size_t>(scalar_t(parameters[2])()));

         for (std::size_t i = 0; i < stride; ++i)
         {
            y[i] = std::numeric_limits<T>::quiet_NaN();
         }

         for (std::size_t i = (r0 + stride); i <= r1; ++i)
         {
            y[i] = x[i] - x[i - stride];
         }

         return T(1);
      }

// Assembly:
subq $0xc8, %rsp
movq %rdx, 0xc0(%rsp)
movq %rdi, 0xb8(%rsp)
movq %rsi, 0xb0(%rsp)
movq $0x0, 0x98(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x98(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0xa0(%rsp), %rdi
callq 0x572e40
movq $0x1, 0x80(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x88(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x78(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x572e70
movq %rax, 0x68(%rsp)
leaq 0x88(%rsp), %rdi
callq 0x572e70
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x70(%rsp)
movq 0xb0(%rsp), %rcx
movl $0x1, %eax
cmpq (%rcx), %rax
je 0x579747
movl $0x1, %eax
movq %rax, 0x20(%rsp)
jmp 0x5797c4
movq $0x2, 0x40(%rsp)
leaq 0xc0(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x572e10
movq 0x18(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd 0x219d6(%rip), %xmm2    # 0x59b160
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x50(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x58(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x58(%rsp), %rax
jae 0x57981a
callq 0x2361c0
movsd %xmm0, 0x10(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x574b60
movsd 0x10(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x5797d7
movq 0x58(%rsp), %rax
addq $0x0, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
cmpq 0x70(%rsp), %rax
ja 0x5798ae
leaq 0xa0(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x30(%rsp), %rax
subq 0x58(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0xa0(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x572fd0
movsd (%rsp), %xmm0
subsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x574b60
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x579828
movsd 0x2178a(%rip), %xmm0    # 0x59b040
addq $0xc8, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::dot<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
         const vector_t y(parameters[1]);

         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;

         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();

         T result = T(0);

         for (std::size_t i = r0; i <= r1; ++i)
         {
            result += (x[i] * y[i]);
         }

         return result;
      }

// Assembly:
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x572e40
movq $0x1, 0x58(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x572e70
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x572e70
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x17(%rsp)
jne 0x5799f7
movq $0x2, 0x30(%rsp)
movq $0x3, 0x28(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x579a01
jmp 0x579a14
callq 0x2361c0
movsd %xmm0, 0xa0(%rsp)
jmp 0x579ac7
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x5730a0
testb $0x1, %al
jne 0x579a2e
jmp 0x579a41
callq 0x2361c0
movsd %xmm0, 0xa0(%rsp)
jmp 0x579ac7
jmp 0x579a43
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x48(%rsp), %rax
ja 0x579ab8
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x572fd0
movsd 0x8(%rsp), %xmm0
movsd (%rax), %xmm2
movsd 0x20(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x579a56
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::dotk<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
         const vector_t y(parameters[1]);

         std::size_t r0 = 0;
         std::size_t r1 = std::min(x.size(),y.size()) - 1;

         if ((1 == ps_index) && !helper::load_vector_range<T>::process(parameters, r0, r1, 2, 3, 0))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();

         T result = T(0);
         T error  = T(0);

         for (std::size_t i = r0; i <= r1; ++i)
         {
            details::kahan_sum(result, error, (x[i] * y[i]));
         }

         return result;
      }

// Assembly:
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x572e40
movq $0x1, 0x58(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x572e70
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x572e70
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0xf(%rsp)
jne 0x579c17
movq $0x2, 0x30(%rsp)
movq $0x3, 0x28(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x579c21
jmp 0x579c34
callq 0x2361c0
movsd %xmm0, 0xa0(%rsp)
jmp 0x579ce9
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x60(%rsp), %rdi
callq 0x5730a0
testb $0x1, %al
jne 0x579c4e
jmp 0x579c61
callq 0x2361c0
movsd %xmm0, 0xa0(%rsp)
jmp 0x579ce9
jmp 0x579c63
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x18(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x48(%rsp), %rax
ja 0x579cda
leaq 0x78(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x572fd0
movsd (%rsp), %xmm0
mulsd (%rax), %xmm0
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x577f40
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x579c7f
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::threshold_above<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);

         const T threshold_value = (0 == ps_index) ?
                                   scalar_t(parameters[1]) :
                                   scalar_t(parameters[3]) ;

         const T snap_value = scalar_t(parameters.back());

         std::size_t r0 = 0;
         std::size_t r1 = vec.size() - 1;

         if (
              (1 == ps_index) &&
              !helper::load_vector_range<T>::process(parameters, r0, r1, 1, 2, 0)
            )
         {
            return T(0);
         }

         for (std::size_t i = r0; i <= r1; ++i)
         {
            if (vec[i] > threshold_value)
            {
               vec[i] = snap_value;
            }
         }

         return T(1);
      }

// Assembly:
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x572e40
movq 0x88(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x579db0
movq $0x1, 0x58(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x572e10
jmp 0x579dd8
movq $0x3, 0x50(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x572e10
leaq 0x60(%rsp), %rdi
callq 0x5779a0
movsd %xmm0, 0x68(%rsp)
leaq 0x98(%rsp), %rdi
callq 0x5779c0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x572e10
leaq 0x40(%rsp), %rdi
callq 0x5779a0
movsd %xmm0, 0x48(%rsp)
movq $0x0, 0x38(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x88(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x17(%rsp)
jne 0x579e84
movq $0x1, 0x28(%rsp)
movq $0x2, 0x20(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x579e8e
jmp 0x579e9c
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0x579f15
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
ja 0x579f04
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x574b60
movsd (%rax), %xmm0
ucomisd 0x68(%rsp), %xmm0
jbe 0x579ef2
movsd 0x48(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x574b60
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x579ef4
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x579ea6
movsd 0x21134(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::ivararg_function<double>&)
inline bool add_function(const std::string& vararg_function_name, vararg_function_t& vararg_function)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(vararg_function_name))
            return false;
         else if (symbol_exists(vararg_function_name))
            return false;
         else
            return local_data().vararg_function_store.add(vararg_function_name,vararg_function);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x57d92c
movb $0x0, 0x27(%rsp)
jmp 0x57d991
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x57d94a
movb $0x0, 0x27(%rsp)
jmp 0x57d991
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x57d963
jmp 0x57d96a
movb $0x0, 0x27(%rsp)
jmp 0x57d991
movq (%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x70, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x57f9f0
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::rebase(double*)
inline void rebase(data_ptr_t data)
      {
         data_ = data;

         if (!data_ref_.empty())
         {
            for (std::size_t i = 0; i < data_ref_.size(); ++i)
            {
               (*data_ref_[i]) = data;
            }
         }
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rdi)
addq $0x18, %rdi
callq 0x5814f0
testb $0x1, %al
jne 0x57dfc6
movq $0x0, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x18, %rdi
callq 0x527da0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x57dfc4
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x18, %rdi
movq 0x20(%rsp), %rsi
callq 0x581540
movq 0x8(%rsp), %rcx
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x57df67
jmp 0x57dfc6
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: va_func<double>::operator()(std::vector<double, std::allocator<double>> const&)
inline T operator()(const std::vector<T>& arglist) exprtk_test_override
   {
      T result = T(0);

      for (std::size_t i = 0; i < arglist.size(); ++i)
      {
         result += arglist[i];
      }

      return result;
   }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x521ce0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x57f95e
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x57f9d0
movsd (%rax), %xmm0
addsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x57f910
movsd 0x10(%rsp), %xmm0
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: rem_space_and_uppercase<double>::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::type_store<double>::parameter_list)
inline T operator()(std::string& result, parameter_list_t params) exprtk_test_override
   {
      string_t string(params[0]);

      result.reserve(string.size());
      result.clear();

      char c;

      for (std::size_t i = 0; i < string.size(); ++i)
      {
         if (' ' != (c = string[i]))
            result += static_cast<char>(std::toupper(c));
      }

      return T(0);
   }

// Assembly:
subq $0x58, %rsp
movq %rdx, 0x50(%rsp)
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq $0x0, 0x28(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x575370
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x575430
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x11b5a0
movq 0x40(%rsp), %rdi
callq 0x11b450
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x575430
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5813c7
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x581190
movb (%rax), %al
movb %al, 0x27(%rsp)
movsbl %al, %ecx
movl $0x20, %eax
cmpl %ecx, %eax
je 0x5813b5
movsbl 0x27(%rsp), %edi
callq 0x11b1b0
movq 0x40(%rsp), %rdi
movsbl %al, %esi
callq 0x11b510
jmp 0x5813b7
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x58135c
xorps %xmm0, %xmm0
addq $0x58, %rsp
retq
nop
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: vararg_func<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator()(const std::size_t& ps_index, parameter_list_t /*arglist*/) exprtk_test_override
   {
      switch (ps_index)
      {                         // Overload resolution:
         case 0  : return T(0); // Z  - Zero arguments
         case 1  : return T(1); // T* - One or more scalars
         case 2  : return T(2); // V  - One vector
         default : return std::numeric_limits<T>::quiet_NaN();
      }
   }

// Assembly:
subq $0x28, %rsp
movq %rdx, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x5814ae
jmp 0x581496
movq (%rsp), %rax
subq $0x1, %rax
je 0x5814b9
jmp 0x5814a2
movq (%rsp), %rax
subq $0x2, %rax
je 0x5814c9
jmp 0x5814d9
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x5814e4
movsd 0x19b7f(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x20(%rsp)
jmp 0x5814e4
movsd 0x19baf(%rip), %xmm0    # 0x59b080
movsd %xmm0, 0x20(%rsp)
jmp 0x5814e4
callq 0x2361c0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::details::print_impl<double>::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::type_store<double>::parameter_list)
static void process(const std::string& scalar_format, parameter_list_t parameters)
         {
            for (std::size_t i = 0; i < parameters.size(); ++i)
            {
               generic_type& gt = parameters[i];

               switch (gt.type)
               {
                  case generic_type::e_scalar : print(scalar_format,scalar_t(gt));
                                                break;

                  case generic_type::e_vector : print(scalar_format,vector_t(gt));
                                                break;

                  case generic_type::e_string : print(string_t(gt));
                                                break;

                  default                     : continue;
               }
            }
         }

// Assembly:
subq $0x68, %rsp
movq %rsi, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x572dc0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x581a1d
leaq 0x60(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x572de0
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x14(%rsp)
subl $0x1, %eax
je 0x581999
jmp 0x581983
movl 0x14(%rsp), %eax
subl $0x2, %eax
je 0x5819c3
jmp 0x58198e
movl 0x14(%rsp), %eax
subl $0x3, %eax
je 0x5819eb
jmp 0x581a06
movq 0x58(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rsi
leaq 0x40(%rsp), %rdi
callq 0x572e10
movq 0x8(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x581a30
jmp 0x581a08
movq 0x58(%rsp), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x572e40
movq (%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x581a80
jmp 0x581a08
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x575370
leaq 0x20(%rsp), %rdi
callq 0x581b50
jmp 0x581a08
jmp 0x581a0a
jmp 0x581a0a
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0x581937
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::details::print_impl<double>::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::type_store<double>::type_view<double> const&)
static inline void print(const std::string& scalar_format, const vector_t& v)
         {
            for (std::size_t i = 0; i < v.size(); ++i)
            {
               print_type(scalar_format,v[i],num_type());

               if ((i + 1) < v.size())
                  printf(" ");
            }
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rdi
callq 0x572e70
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x581b41
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x233dd0
movq 0x8(%rsp), %rdi
movsd 0x10(%rsp), %xmm0
callq 0x581bc0
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x572e70
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x581b2c
leaq 0x4851f(%rip), %rdi     # 0x5ca044
movb $0x0, %al
callq 0x11b0b0
jmp 0x581b2e
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x581a97
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::package<double>::register_package(exprtk::symbol_table<double>&)
bool register_package(exprtk::symbol_table<T>& symtab)
      {
         #define exprtk_register_function(FunctionName, FunctionType)             \
         if (!symtab.add_function(FunctionName,FunctionType))                     \
         {                                                                        \
            exprtk_debug((                                                        \
              "exprtk::rtl::io::register_package - Failed to add function: %s\n", \
              FunctionName));                                                     \
            return false;                                                         \
         }                                                                        \

         exprtk_register_function("print"  , p )
         exprtk_register_function("println", pl)
         #undef exprtk_register_function

         return true;
      }

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x7f(%rsp), %rdi
movq %rdi, 0x38(%rsp)
callq 0x11b6f0
movq 0x38(%rsp), %rdx
leaq 0x47b6e(%rip), %rsi     # 0x5c98aa
leaq 0x80(%rsp), %rdi
callq 0x134520
jmp 0x581d4b
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x57bf00
movb %al, 0x27(%rsp)
jmp 0x581d68
movb 0x27(%rsp), %al
xorb $-0x1, %al
movb %al, 0x26(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x11b838
leaq 0x7f(%rsp), %rdi
callq 0x11b820
movb 0x26(%rsp), %al
testb $0x1, %al
jne 0x581d93
jmp 0x581dda
movb $0x0, 0xb7(%rsp)
jmp 0x581e9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x581dcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x80(%rsp), %rdi
callq 0x11b838
leaq 0x7f(%rsp), %rdi
callq 0x11b820
jmp 0x581eab
movq 0xa0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x47(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x11b6f0
movq 0x18(%rsp), %rdx
leaq 0x47aae(%rip), %rsi     # 0x5c98b0
leaq 0x48(%rsp), %rdi
callq 0x134520
jmp 0x581e0e
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rdx
addq $0x68, %rdx
leaq 0x48(%rsp), %rsi
callq 0x57bf00
movb %al, 0xf(%rsp)
jmp 0x581e2c
movb 0xf(%rsp), %al
xorb $-0x1, %al
movb %al, 0xe(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11b838
leaq 0x47(%rsp), %rdi
callq 0x11b820
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x581e54
jmp 0x581e92
movb $0x0, 0xb7(%rsp)
jmp 0x581e9a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
jmp 0x581e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x70(%rsp)
movl %eax, 0x6c(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x11b838
leaq 0x47(%rsp), %rdi
callq 0x11b820
jmp 0x581eab
movb $0x1, 0xb7(%rsp)
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x70(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: overload_func<double>::operator()(unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, exprtk::type_store<double>::parameter_list)
inline T operator()(const std::size_t& ps_index,
                       std::string& result,
                       parameter_list_t parameters) exprtk_test_override
   {
      current_ps_index = ps_index;
      determine_param_seq(parameters);
      result = "string result";
      return T(1);
   }

// Assembly:
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x48(%rdi)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rsi
callq 0x582060
movq 0x8(%rsp), %rdi
leaq 0x46857(%rip), %rsi     # 0x5c889e
callq 0x11b340
movsd 0x18fec(%rip), %xmm0    # 0x59b040
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: overload_func<double>::determine_param_seq(exprtk::type_store<double>::parameter_list)
void determine_param_seq(parameter_list_t parameters)
   {
      current_param_seq = "";

      for (std::size_t i = 0; i < parameters.size(); ++i)
      {
         generic_type& gt = parameters[i];

         switch (gt.type)
         {
            case generic_type::e_scalar : current_param_seq += "T";
                                          break;

            case generic_type::e_vector : current_param_seq += "V";
                                          break;

            case generic_type::e_string : current_param_seq += "S";
                                          break;

            default                     : continue;
         }
      }
   }

// Assembly:
subq $0x38, %rsp
movq %rsi, 0x30(%rsp)
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
addq $0x50, %rdi
leaq 0x33bc5(%rip), %rsi     # 0x5b5c48
callq 0x11b340
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x572dc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x58214f
leaq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x572de0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
movl %eax, 0x4(%rsp)
subl $0x1, %eax
je 0x5820f3
jmp 0x5820dd
movl 0x4(%rsp), %eax
subl $0x2, %eax
je 0x58210a
jmp 0x5820e8
movl 0x4(%rsp), %eax
subl $0x3, %eax
je 0x582121
jmp 0x582138
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
leaq 0x4634d(%rip), %rsi     # 0x5c8450
callq 0x11b150
jmp 0x58213a
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
leaq 0x41eee(%rip), %rsi     # 0x5c4008
callq 0x11b150
jmp 0x58213a
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
leaq 0x41f11(%rip), %rsi     # 0x5c4042
callq 0x11b150
jmp 0x58213a
jmp 0x58213c
jmp 0x58213c
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x582091
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const&)
inline void remove(const std::string& name, const std::size_t& arg_count)
      {
         if (arg_count > 6)
            return;

         const typename std::map<std::string,expression_t>::iterator em_itr = expr_map_.find(name);

         if (expr_map_.end() != em_itr)
         {
            expr_map_.erase(em_itr);
         }

         const typename funcparam_t::iterator fp_itr = fp_map_[arg_count].find(name);

         if (fp_map_[arg_count].end() != fp_itr)
         {
            delete fp_itr->second;
            fp_map_[arg_count].erase(fp_itr);
         }

         symbol_table_.remove_function(name);
      }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rax
cmpq $0x6, (%rax)
jbe 0x58492d
jmp 0x584a64
movq 0x8(%rsp), %rdi
addq $0x930, %rdi            # imm = 0x930
movq 0x58(%rsp), %rsi
callq 0x584880
movq 0x8(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x930, %rdi            # imm = 0x930
callq 0x5848d0
movq %rax, 0x40(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x5848b0
testb $0x1, %al
jne 0x584973
jmp 0x584998
movq 0x8(%rsp), %rdi
addq $0x930, %rdi            # imm = 0x930
movq 0x48(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rsi
callq 0x585fa0
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rdi
addq $0x960, %rdi            # imm = 0x960
movq 0x50(%rsp), %rax
movq (%rax), %rsi
callq 0x585730
movq %rax, %rdi
movq 0x58(%rsp), %rsi
callq 0x585fe0
movq 0x8(%rsp), %rdi
movq %rax, 0x28(%rsp)
addq $0x960, %rdi            # imm = 0x960
movq 0x50(%rsp), %rax
movq (%rax), %rsi
callq 0x585730
movq %rax, %rdi
callq 0x586030
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x586010
testb $0x1, %al
jne 0x5849fe
jmp 0x584a55
leaq 0x28(%rsp), %rdi
callq 0x586060
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x584a20
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x8(%rsp), %rdi
addq $0x960, %rdi            # imm = 0x960
movq 0x50(%rsp), %rax
movq (%rax), %rsi
callq 0x585730
movq %rax, %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
callq 0x586080
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x565240
addq $0x68, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::load_variables_from(exprtk::symbol_table<double> const&)
inline void load_variables_from(const symbol_table<T>& st)
      {
         std::vector<std::string> name_list;

         st.local_data().variable_store.get_list(name_list);

         if (!name_list.empty())
         {
            for (std::size_t i = 0; i < name_list.size(); ++i)
            {
               T& variable = st.get_variable(name_list[i])->ref();
               add_variable(name_list[i], variable);
            }
         }
      }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x50(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x251fa0
movq 0x68(%rsp), %rdi
callq 0x234330
movq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x5884c0
jmp 0x586c00
leaq 0x50(%rsp), %rdi
callq 0x587cf0
testb $0x1, %al
jne 0x586cd2
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x51ddd0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x586cd0
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x551340
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x563450
movq %rax, 0x10(%rsp)
jmp 0x586c6d
movq 0x10(%rsp), %rdi
callq 0x235f80
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x50(%rsp), %rdi
callq 0x551340
movq 0x20(%rsp), %rdi
movq %rax, %rsi
movq 0x30(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2341e0
jmp 0x586ca1
jmp 0x586ca3
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x586c1b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x371380
jmp 0x586ce1
jmp 0x586cd2
leaq 0x50(%rsp), %rdi
callq 0x371380
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::load_vectors_from(exprtk::symbol_table<double> const&)
inline void load_vectors_from(const symbol_table<T>& st)
      {
         std::vector<std::string> name_list;

         st.local_data().vector_store.get_list(name_list);

         if (!name_list.empty())
         {
            for (std::size_t i = 0; i < name_list.size(); ++i)
            {
               vector_holder_t& vecholder = *st.get_vector(name_list[i]);
               add_vector(name_list[i], vecholder.data(), vecholder.size());
            }
         }
      }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0x70(%rsp), %rdi
movq %rdi, 0x40(%rsp)
callq 0x251fa0
movq 0x88(%rsp), %rdi
callq 0x234330
movq 0x40(%rsp), %rsi
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
callq 0x588570
jmp 0x586d46
leaq 0x70(%rsp), %rdi
callq 0x587cf0
testb $0x1, %al
jne 0x586e4c
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x51ddd0
movq %rax, %rcx
movq 0x30(%rsp), %rax
cmpq %rcx, %rax
jae 0x586e4a
movq 0x88(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x551340
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x588620
movq %rax, 0x28(%rsp)
jmp 0x586db6
movq 0x28(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rsi
leaq 0x70(%rsp), %rdi
callq 0x551340
movq %rax, 0x10(%rsp)
movq 0x50(%rsp), %rdi
callq 0x3ea570
movq %rax, 0x18(%rsp)
jmp 0x586de5
movq 0x50(%rsp), %rdi
callq 0x3a19c0
movq %rax, 0x8(%rsp)
jmp 0x586df6
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0x48(%rsp), %rcx
callq 0x5886a0
jmp 0x586e1b
jmp 0x586e1d
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x586d61
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x371380
jmp 0x586e5e
jmp 0x586e4c
leaq 0x70(%rsp), %rdi
callq 0x371380
addq $0x98, %rsp
retq
movq 0x68(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const&) const
inline bool valid(const std::string& name,
                        const std::size_t& arg_count) const
      {
         if (arg_count > 6)
            return false;
         else if (symbol_used(name))
            return false;
         else if (fp_map_[arg_count].end() != fp_map_[arg_count].find(name))
            return false;
         else
            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 0x18(%rsp), %rax
cmpq $0x6, (%rax)
jbe 0x586ea1
movb $0x0, 0x37(%rsp)
jmp 0x586f2c
movq (%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x588880
testb $0x1, %al
jne 0x586eb5
jmp 0x586ebc
movb $0x0, 0x37(%rsp)
jmp 0x586f2c
movq (%rsp), %rdi
addq $0x960, %rdi            # imm = 0x960
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x588950
movq %rax, %rdi
callq 0x588970
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
addq $0x960, %rdi            # imm = 0x960
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x588950
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x5889a0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x588930
testb $0x1, %al
jne 0x586f20
jmp 0x586f27
movb $0x0, 0x37(%rsp)
jmp 0x586f2c
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::operator=(exprtk::expression<double> const&)
inline expression<T>& operator=(const expression<T>& e)
      {
         if (this != &e)
         {
            if (control_block_)
            {
               if (
                    (0 !=   control_block_->ref_count) &&
                    (0 == --control_block_->ref_count)
                  )
               {
                  delete control_block_;
               }

               control_block_ = 0;
            }

            control_block_ = e.control_block_;
            control_block_->ref_count++;
            symbol_table_list_ = e.symbol_table_list_;
         }

         return *this;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq 0x18(%rsp), %rax
je 0x587c2f
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x587c00
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x587bf4
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x587bf4
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x587bf2
movq 0x8(%rsp), %rdi
callq 0x23c540
movq 0x8(%rsp), %rdi
movl $0x40, %esi
callq 0x11b130
jmp 0x587bf4
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rdi)
movq (%rdi), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
addq $0x8, %rdi
callq 0x590280
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline function_ptr get_function(const std::string& function_name) const
      {
         if (!valid())
            return reinterpret_cast<function_ptr>(0);
         else if (!valid_symbol(function_name))
            return reinterpret_cast<function_ptr>(0);
         else
            return local_data().function_store.get(function_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x587d6c
movq $0x0, 0x20(%rsp)
jmp 0x587daf
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x587d8f
movq $0x0, 0x20(%rsp)
jmp 0x587daf
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
callq 0x52f860
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_vararg_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline vararg_function_ptr get_vararg_function(const std::string& vararg_function_name) const
      {
         if (!valid())
            return reinterpret_cast<vararg_function_ptr>(0);
         else if (!valid_symbol(vararg_function_name))
            return reinterpret_cast<vararg_function_ptr>(0);
         else
            return local_data().vararg_function_store.get(vararg_function_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x587e9c
movq $0x0, 0x20(%rsp)
jmp 0x587edf
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x587ebf
movq $0x0, 0x20(%rsp)
jmp 0x587edf
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x70, %rdi
movq 0x10(%rsp), %rsi
callq 0x54e3b0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_generic_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_generic_function(const std::string& function_name) const
      {
         if (!valid())
            return reinterpret_cast<generic_function_ptr>(0);
         else if (!valid_symbol(function_name))
            return reinterpret_cast<generic_function_ptr>(0);
         else
            return local_data().generic_function_store.get(function_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x587fcc
movq $0x0, 0x20(%rsp)
jmp 0x588012
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x587fef
movq $0x0, 0x20(%rsp)
jmp 0x588012
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0xa8, %rdi
movq 0x10(%rsp), %rsi
callq 0x54ef70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_string_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_string_function(const std::string& function_name) const
      {
         if (!valid())
            return reinterpret_cast<generic_function_ptr>(0);
         else if (!valid_symbol(function_name))
            return reinterpret_cast<generic_function_ptr>(0);
         else
            return local_data().string_function_store.get(function_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x58804c
movq $0x0, 0x20(%rsp)
jmp 0x588092
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x58806f
movq $0x0, 0x20(%rsp)
jmp 0x588092
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0xe0, %rdi
movq 0x10(%rsp), %rsi
callq 0x54ef70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_overload_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_overload_function(const std::string& function_name) const
      {
         if (!valid())
            return reinterpret_cast<generic_function_ptr>(0);
         else if (!valid_symbol(function_name))
            return reinterpret_cast<generic_function_ptr>(0);
         else
            return local_data().overload_function_store.get(function_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x5880cc
movq $0x0, 0x20(%rsp)
jmp 0x588112
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x5880ef
movq $0x0, 0x20(%rsp)
jmp 0x588112
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x118, %rdi            # imm = 0x118
movq 0x10(%rsp), %rsi
callq 0x54ef70
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)