LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_add_op<double>::process<double const*, std::allocator<double const*>, std::vector>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return T(0);
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default :
                         {
                            T result = T(0);

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

                            return result;
                         }
            }
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq %rcx, 0x10(%rsp)
subq $0x5, %rax
ja 0x3a37be
movq 0x10(%rsp), %rax
leaq 0x1f89bb(%rip), %rcx    # 0x59c0fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x3a3830
movq 0x28(%rsp), %rdi
callq 0x3a3840
movsd %xmm0, 0x30(%rsp)
jmp 0x3a3830
movq 0x28(%rsp), %rdi
callq 0x3a3860
movsd %xmm0, 0x30(%rsp)
jmp 0x3a3830
movq 0x28(%rsp), %rdi
callq 0x3a38b0
movsd %xmm0, 0x30(%rsp)
jmp 0x3a3830
movq 0x28(%rsp), %rdi
callq 0x3a3930
movsd %xmm0, 0x30(%rsp)
jmp 0x3a3830
movq 0x28(%rsp), %rdi
callq 0x3a39e0
movsd %xmm0, 0x30(%rsp)
jmp 0x3a3830
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3a3824
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3a37d0
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_avg_op<double>::process<double const*, std::allocator<double const*>, std::vector>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return T(0);
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default : return vararg_add_op<T>::process(arg_list) / T(arg_list.size());
            }
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq %rcx, 0x10(%rsp)
subq $0x5, %rax
ja 0x3a44c8
movq 0x10(%rsp), %rax
leaq 0x1f7cdb(%rip), %rcx    # 0x59c12c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4519
movq 0x18(%rsp), %rdi
callq 0x3a4530
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4519
movq 0x18(%rsp), %rdi
callq 0x3a4550
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4519
movq 0x18(%rsp), %rdi
callq 0x3a45b0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4519
movq 0x18(%rsp), %rdi
callq 0x3a4640
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4519
movq 0x18(%rsp), %rdi
callq 0x3a46f0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4519
movq 0x18(%rsp), %rdi
callq 0x3a3710
movsd %xmm0, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3a2a60
movsd 0x8(%rsp), %xmm0
movq %rax, %xmm1
movaps 0x1f6cac(%rip), %xmm2   # 0x59b1a0
punpckldq %xmm2, %xmm1    # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
movapd 0x1f6cb0(%rip), %xmm2   # 0x59b1b0
subpd %xmm2, %xmm1
movaps %xmm1, %xmm2
unpckhpd %xmm1, %xmm1            # xmm1 = xmm1[1,1]
addsd %xmm2, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_min_op<double>::process<double const*, std::allocator<double const*>, std::vector>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return T(0);
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default :
                         {
                            T result = T(value(arg_list[0]));

                            for (std::size_t i = 1; i < arg_list.size(); ++i)
                            {
                               const T v = value(arg_list[i]);

                               if (v < result)
                                  result = v;
                            }

                            return result;
                         }
            }
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq %rcx, 0x8(%rsp)
subq $0x5, %rax
ja 0x3a4b41
movq 0x8(%rsp), %rax
leaq 0x1f7683(%rip), %rcx    # 0x59c144
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x3a4bde
movq 0x28(%rsp), %rdi
callq 0x3a4bf0
movsd %xmm0, 0x30(%rsp)
jmp 0x3a4bde
movq 0x28(%rsp), %rdi
callq 0x3a4c10
movsd %xmm0, 0x30(%rsp)
jmp 0x3a4bde
movq 0x28(%rsp), %rdi
callq 0x3a4c70
movsd %xmm0, 0x30(%rsp)
jmp 0x3a4bde
movq 0x28(%rsp), %rdi
callq 0x3a4d00
movsd %xmm0, 0x30(%rsp)
jmp 0x3a4bde
movq 0x28(%rsp), %rdi
callq 0x3a4dc0
movsd %xmm0, 0x30(%rsp)
jmp 0x3a4bde
movq 0x28(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x20(%rsp)
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x3a4bd2
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x3a4bc0
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a4bc2
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x3a4b66
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_min_op<double>::process_5<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_5(const Sequence& arg_list)
         {
            return std::min<T>(
                   std::min<T>(std::min<T>(value(arg_list[0]), value(arg_list[1])),
                               std::min<T>(value(arg_list[2]), value(arg_list[3]))),
                               value(arg_list[4]));
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x3a4eb0
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x3a4eb0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x3a4eb0
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rdi
movl $0x4, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x3a4eb0
movsd (%rax), %xmm0
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process<double const*, std::allocator<double const*>, std::vector>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               default :
                         {
                            for (std::size_t i = 0; i < arg_list.size(); ++i)
                            {
                               if (std::equal_to<T>()(T(0), value(arg_list[i])))
                                  return T(0);
                            }

                            return T(1);
                         }
            }
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a2a60
decq %rax
movq %rax, 0x10(%rsp)
subq $0x4, %rax
ja 0x3a596f
movq 0x10(%rsp), %rax
leaq 0x1f6877(%rip), %rcx    # 0x59c174
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x38(%rsp), %rdi
callq 0x3a5a10
movsd %xmm0, 0x40(%rsp)
jmp 0x3a5a04
movq 0x38(%rsp), %rdi
callq 0x3a5a90
movsd %xmm0, 0x40(%rsp)
jmp 0x3a5a04
movq 0x38(%rsp), %rdi
callq 0x3a5b60
movsd %xmm0, 0x40(%rsp)
jmp 0x3a5a04
movq 0x38(%rsp), %rdi
callq 0x3a5c70
movsd %xmm0, 0x40(%rsp)
jmp 0x3a5a04
movq 0x38(%rsp), %rdi
callq 0x3a5df0
movsd %xmm0, 0x40(%rsp)
jmp 0x3a5a04
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x3a59f6
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x18(%rsp)
leaq 0x2f(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x266f00
testb $0x1, %al
jne 0x3a59d9
jmp 0x3a59e4
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x3a5a04
jmp 0x3a59e6
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3a5978
movsd 0x1f5642(%rip), %xmm0   # 0x59b040
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_2<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_2(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1]))
                   ) ? T(1) : T(0);
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x50(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x38(%rsp)
leaq 0x4f(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x3a5ae1
jmp 0x3a5b1f
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x20(%rsp)
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x265d60
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
movsd 0x1f5515(%rip), %xmm0   # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
testb $0x1, %al
movsd %xmm0, 0x10(%rsp)
jne 0x3a5b4a
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_3<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_3(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[2]))
                   ) ? T(1) : T(0);
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
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, 0x17(%rsp)
jne 0x3a5bb4
jmp 0x3a5c3b
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x30(%rsp)
leaq 0x47(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x3a5bfd
jmp 0x3a5c3b
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x60(%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x18(%rsp)
leaq 0x2f(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x265d60
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
movsd 0x1f53f9(%rip), %xmm0   # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x3a5c64
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x68, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_4<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_4(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[2])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[3]))
                   ) ? T(1) : T(0);
         }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x70(%rsp)
movq 0x80(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x68(%rsp)
leaq 0x7f(%rsp), %rdi
leaq 0x70(%rsp), %rsi
leaq 0x68(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x3a5ccd
jmp 0x3a5da9
xorps %xmm0, %xmm0
movsd %xmm0, 0x58(%rsp)
movq 0x80(%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x50(%rsp)
leaq 0x67(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x3a5d1c
jmp 0x3a5da9
xorps %xmm0, %xmm0
movsd %xmm0, 0x40(%rsp)
movq 0x80(%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x38(%rsp)
leaq 0x4f(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x1f(%rsp)
jne 0x3a5d68
jmp 0x3a5da9
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x80(%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x20(%rsp)
leaq 0x37(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
callq 0x265d60
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
movsd 0x1f528b(%rip), %xmm0   # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, 0x8(%rsp)
testb $0x1, %al
movsd %xmm0, 0x10(%rsp)
jne 0x3a5dd4
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_mand_op<double>::process_5<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_5(const Sequence& arg_list)
         {
            return (
                     std::not_equal_to<T>()(T(0), value(arg_list[0])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[1])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[2])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[3])) &&
                     std::not_equal_to<T>()(T(0), value(arg_list[4]))
                   ) ? T(1) : T(0);
         }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
movq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x78(%rsp)
leaq 0x8f(%rsp), %rdi
leaq 0x80(%rsp), %rsi
leaq 0x78(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x3a5e56
jmp 0x3a5f81
xorps %xmm0, %xmm0
movsd %xmm0, 0x68(%rsp)
movq 0x90(%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x60(%rsp)
leaq 0x77(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x3a5ea5
jmp 0x3a5f81
xorps %xmm0, %xmm0
movsd %xmm0, 0x50(%rsp)
movq 0x90(%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
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, 0x17(%rsp)
jne 0x3a5ef4
jmp 0x3a5f81
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x90(%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x30(%rsp)
leaq 0x47(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x265d60
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x3a5f40
jmp 0x3a5f81
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x90(%rsp), %rdi
movl $0x4, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x18(%rsp)
leaq 0x2f(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
callq 0x265d60
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
movsd 0x1f50b3(%rip), %xmm0   # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x3a5faa
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process<double const*, std::allocator<double const*>, std::vector>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process(const Sequence<Type,Allocator>& arg_list)
         {
            switch (arg_list.size())
            {
               case 0  : return std::numeric_limits<T>::quiet_NaN();
               case 1  : return process_1(arg_list);
               case 2  : return process_2(arg_list);
               case 3  : return process_3(arg_list);
               case 4  : return process_4(arg_list);
               case 5  : return process_5(arg_list);
               case 6  : return process_6(arg_list);
               case 7  : return process_7(arg_list);
               case 8  : return process_8(arg_list);
               default :
                        {
                           for (std::size_t i = 0; i < (arg_list.size() - 1); ++i)
                           {
                              value(arg_list[i]);
                           }
                           return value(arg_list.back());
                        }
            }
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq %rcx, 0x8(%rsp)
subq $0x8, %rax
ja 0x3a6d1c
movq 0x8(%rsp), %rax
leaq 0x1f553b(%rip), %rcx    # 0x59c19c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
callq 0x2361c0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6da0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6dc0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6e00
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6e50
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6eb0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6f30
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a6fc0
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq 0x18(%rsp), %rdi
callq 0x3a7060
movsd %xmm0, 0x20(%rsp)
jmp 0x3a6d87
movq $0x0, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
callq 0x3a2a60
movq %rax, %rcx
movq (%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x3a6d6f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x3a6d25
movq 0x18(%rsp), %rdi
callq 0x3a7120
movq (%rax), %rdi
callq 0x3a3ab0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_4<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_4(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
            return value(arg_list[3]);
         }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
popq %rax
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_5<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_5(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
                   value(arg_list[3]);
            return value(arg_list[4]);
         }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
popq %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_6<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_6(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
                   value(arg_list[3]);
                   value(arg_list[4]);
            return value(arg_list[5]);
         }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x5, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
popq %rax
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_7<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_7(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
                   value(arg_list[3]);
                   value(arg_list[4]);
                   value(arg_list[5]);
            return value(arg_list[6]);
         }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x5, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x6, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
popq %rax
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: double exprtk::details::vararg_multi_op<double>::process_8<std::vector<double const*, std::allocator<double const*>>>(std::vector<double const*, std::allocator<double const*>> const&)
static inline T process_8(const Sequence& arg_list)
         {
                   value(arg_list[0]);
                   value(arg_list[1]);
                   value(arg_list[2]);
                   value(arg_list[3]);
                   value(arg_list[4]);
                   value(arg_list[5]);
                   value(arg_list[6]);
            return value(arg_list[7]);
         }

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x3, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x4, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x5, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x6, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
movq (%rsp), %rdi
movl $0x7, %esi
callq 0x3a3ac0
movq (%rax), %rdi
callq 0x3a3ab0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::is_generally_string_node<double>(exprtk::details::expression_node<double> const*)
inline bool is_generally_string_node(const expression_node<T>* node)
      {
         if (node)
         {
            switch (node->type())
            {
               case expression_node<T>::e_stringvar     :
               case expression_node<T>::e_stringconst   :
               case expression_node<T>::e_stringvarrng  :
               case expression_node<T>::e_cstringvarrng :
               case expression_node<T>::e_strgenrange   :
               case expression_node<T>::e_strass        :
               case expression_node<T>::e_strconcat     :
               case expression_node<T>::e_strfunction   :
               case expression_node<T>::e_strcondition  :
               case expression_node<T>::e_strccondition :
               case expression_node<T>::e_stringvararg  : return true;
               default                                  : return false;
            }
         }

         return false;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x3a764f
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
addl $-0x12, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x69, %eax
ja 0x3a7648
movq (%rsp), %rax
leaq 0x1f4b88(%rip), %rcx    # 0x59c1c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x17(%rsp)
jmp 0x3a7654
movb $0x0, 0x17(%rsp)
jmp 0x3a7654
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::str_vararg_node<double, exprtk::details::vararg_multi_op<double>>::value() const
inline T value() const exprtk_override
         {
            if (!arg_list_.empty())
            {
               VarArgFunction::process(arg_list_);
            }

            final_node_.first->value();

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x58, %rdi
callq 0x39e520
testb $0x1, %al
jne 0x3a775e
movq 0x8(%rsp), %rdi
addq $0x58, %rdi
callq 0x3a7b70
movq 0x8(%rsp), %rax
movq 0x38(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
callq 0x2361c0
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vararg_node<double, exprtk::details::vararg_add_op<double>>::vararg_node<std::allocator<exprtk::details::expression_node<double>*>, std::vector>(std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
explicit vararg_node(const Sequence<expression_ptr,Allocator>& arg_list)
         : initialised_(false)
         {
            arg_list_.resize(arg_list.size());

            for (std::size_t i = 0; i < arg_list.size(); ++i)
            {
               if (arg_list[i] && arg_list[i]->valid())
               {
                  construct_branch_pair(arg_list_[i],arg_list[i]);
               }
               else
               {
                  arg_list_.clear();
                  return;
               }
            }

            initialised_ = (arg_list_.size() == arg_list.size());
            assert(valid());
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x235e40
movq 0x20(%rsp), %rdi
leaq 0x3f4027(%rip), %rax    # 0x79c580
movq %rax, (%rdi)
leaq 0x3f406d(%rip), %rax    # 0x79c5d0
movq %rax, 0x8(%rdi)
addq $0x20, %rdi
movq %rdi, 0x28(%rsp)
callq 0x39d440
movq 0x20(%rsp), %rax
movb $0x0, 0x38(%rax)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x39d450
jmp 0x3a8597
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0x3a868a
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39d0f0
cmpq $0x0, (%rax)
je 0x3a8665
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39d0f0
movq (%rax), %rdi
movq (%rdi), %rax
movq 0x30(%rax), %rax
callq *%rax
movb %al, 0x17(%rsp)
jmp 0x3a85ff
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x3a8609
jmp 0x3a8665
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
movq 0x30(%rsp), %rsi
callq 0x39d550
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x39d0f0
movq 0x8(%rsp), %rdi
movq (%rax), %rsi
callq 0x39d4f0
jmp 0x3a863f
jmp 0x3a8675
movq 0x28(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
callq 0x39d590
movq 0x20(%rsp), %rdi
callq 0x236080
jmp 0x3a86c3
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x39d570
jmp 0x3a86be
jmp 0x3a8677
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3a85a0
movq 0x20(%rsp), %rdi
addq $0x20, %rdi
callq 0x39d8c0
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0x39d0d0
movq (%rsp), %rcx
movq %rax, %rdx
movq 0x20(%rsp), %rax
cmpq %rdx, %rcx
sete %cl
andb $0x1, %cl
movb %cl, 0x38(%rax)
addq $0x58, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::expression_generator<double>::operator()(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [1])
inline expression_node_ptr operator() (const details::operator_type& operation, expression_node_ptr (&branch)[1])
         {
            if (0 == branch[0])
            {
               return error_node();
            }
            else if (details::is_null_node(branch[0]))
            {
               return branch[0];
            }
            else if (details::is_break_node(branch[0]))
            {
               return error_node();
            }
            else if (details::is_continue_node(branch[0]))
            {
               return error_node();
            }
            else if (details::is_constant_node(branch[0]))
            {
               return synthesize_expression<unary_node_t,1>(operation,branch);
            }
            else if (unary_optimisable(operation) && details::is_variable_node(branch[0]))
            {
               return synthesize_uv_expression(operation,branch);
            }
            else if (unary_optimisable(operation) && details::is_ivector_node(branch[0]))
            {
               return synthesize_uvec_expression(operation,branch);
            }
            else
               return synthesize_unary_expression(operation,branch);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x3ad8a7
callq 0x2821f0
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3af620
testb $0x1, %al
jne 0x3ad8ba
jmp 0x3ad8cc
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3af660
testb $0x1, %al
jne 0x3ad8df
jmp 0x3ad8ee
callq 0x2821f0
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x3af6a0
testb $0x1, %al
jne 0x3ad901
jmp 0x3ad910
callq 0x2821f0
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x3ad923
jmp 0x3ad940
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3af6e0
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3afa40
testb $0x1, %al
jne 0x3ad954
jmp 0x3ad981
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x3ad967
jmp 0x3ad981
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3afe00
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3afa40
testb $0x1, %al
jne 0x3ad995
jmp 0x3ad9c2
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x39f460
testb $0x1, %al
jne 0x3ad9a8
jmp 0x3ad9c2
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3b02d0
movq %rax, 0x20(%rsp)
jmp 0x3ad9da
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
callq 0x3b0880
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::unary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::unary_node<double>, exprtk::details::operator_type const, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* (&) [1])
inline expression_node<typename ResultNode::value_type>* allocate(OpType& operation, ExprNode (&branch)[1])
         {
            expression_node<typename ResultNode::value_type>* result =
               allocate<ResultNode>(operation, branch[0]);
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x3b0ed0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::parser<double>::expression_generator<double>::is_constant_foldable<1ul, exprtk::details::expression_node<double>*>(exprtk::details::expression_node<double>* (&) [1ul]) const
inline bool is_constant_foldable(NodePtr (&b)[N]) const
         {
            for (std::size_t i = 0; i < N; ++i)
            {
               if (0 == b[i])
                  return false;
               else if (!details::is_constant_node(b[i]))
                  return false;
            }

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
cmpq $0x1, 0x8(%rsp)
jae 0x3b0eba
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rdx
xorl %eax, %eax
cmpq (%rcx,%rdx,8), %rax
jne 0x3b0e88
movb $0x0, 0x27(%rsp)
jmp 0x3b0ebf
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x39cbf0
testb $0x1, %al
jne 0x3b0ea6
movb $0x0, 0x27(%rsp)
jmp 0x3b0ebf
jmp 0x3b0ea8
jmp 0x3b0eaa
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x3b0e67
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::expression_node<exprtk::details::unary_node<double>::value_type>* exprtk::details::node_allocator::allocate<exprtk::details::unary_node<double>, exprtk::details::operator_type, exprtk::details::expression_node<double>*>(exprtk::details::operator_type const&, exprtk::details::expression_node<double>* const&) const
inline expression_node<typename node_type::value_type>* allocate(const T1& t1, const T2& t2) const
         {
            expression_node<typename node_type::value_type>*
            result = (new node_type(t1, t2));
            result->node_depth();
            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x38, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rax
movq (%rax), %rdx
callq 0x3b0f60
jmp 0x3b0f0b
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movq 0x8(%rax), %rax
callq *0x10(%rax)
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
movl $0x38, %esi
callq 0x11b130
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::operator=(exprtk::details::vec_data_store<double> const&)
type& operator=(const type& vds)
         {
            if (this != &vds)
            {
               const std::size_t final_size = min_size(control_block_, vds.control_block_);

               vds.control_block_->size = final_size;
                   control_block_->size = final_size;

               if (control_block_->destruct || (0 == control_block_->data))
               {
                  control_block::destroy(control_block_);

                  control_block_ = vds.control_block_;
                  control_block_->ref_count++;
               }
            }

            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq 0x18(%rsp), %rax
je 0x3b7824
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x3b86d0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq 0x10(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rdx, 0x8(%rcx)
movq 0x10(%rsp), %rdx
movq (%rax), %rcx
movq %rdx, 0x8(%rcx)
movq (%rax), %rax
testb $0x1, 0x18(%rax)
jne 0x3b77fb
movq 0x8(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq 0x10(%rcx), %rax
jne 0x3b7822
movq 0x8(%rsp), %rdi
callq 0x3b8760
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
jmp 0x3b7824
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::memory_context_t<double> exprtk::details::make_memory_context<double>(exprtk::details::vector_holder<double>&, exprtk::details::vec_data_store<double>&)
inline memory_context_t<T> make_memory_context(vector_holder<T>& vec_holder,
                                                     vec_data_store<T>& vds)
      {
         memory_context_t<T> result_ctxt;

         result_ctxt.temp_  = (vec_holder.rebaseable()) ?
                              new vector_holder<T>(vec_holder,vds) :
                              new vector_holder<T>(vds) ;

         result_ctxt.temp_vec_node_ = new vector_node<T>(vds,result_ctxt.temp_);

         return result_ctxt;
      }

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x3b7720
movq 0x60(%rsp), %rdi
callq 0x3b8910
movb $0x0, 0x4f(%rsp)
movb $0x0, 0x2f(%rsp)
testb $0x1, %al
jne 0x3b78d2
jmp 0x3b790e
movl $0x48, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x50(%rsp)
movb $0x1, 0x4f(%rsp)
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
callq 0x3b8930
jmp 0x3b7902
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x3b7945
movl $0x48, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x30(%rsp)
movb $0x1, 0x2f(%rsp)
movq 0x58(%rsp), %rsi
callq 0x3b89b0
jmp 0x3b7939
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x3b7945
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
movl $0x38, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0x3b8a20
jmp 0x3b7975
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
movq 0x68(%rsp), %rax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x3b79a5
jmp 0x3b79b4
movq 0x50(%rsp), %rdi
movl $0x48, %esi
callq 0x11b130
jmp 0x3b79fb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x3b79cd
jmp 0x3b79dc
movq 0x30(%rsp), %rdi
movl $0x48, %esi
callq 0x11b130
jmp 0x3b79fb
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x38, %esi
callq 0x11b130
movq 0x40(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::create(unsigned long const&, double*, bool)
static inline control_block* create(const std::size_t& dsize, data_t data_ptr = data_t(0), bool dstrct = false)
            {
               if (dsize)
               {
                  if (0 == data_ptr)
                     return (new control_block(dsize));
                  else
                     return (new control_block(dsize, data_ptr, dstrct));
               }
               else
                  return (new control_block);
            }

// Assembly:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rax
cmpq $0x0, (%rax)
je 0x3b8349
xorl %eax, %eax
cmpq 0x30(%rsp), %rax
jne 0x3b82f0
movl $0x20, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rsi
callq 0x3b83b0
jmp 0x3b82bf
movq 0x10(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3b838d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x11b130
jmp 0x3b8397
movl $0x20, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movzbl 0x2f(%rsp), %ecx
andl $0x1, %ecx
callq 0x3b83f0
jmp 0x3b831e
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3b838d
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x11b130
jmp 0x3b8397
movl $0x20, %edi
callq 0x11b180
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
callq 0x3b8440
jmp 0x3b8364
movq (%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x3b838d
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
movl $0x20, %esi
callq 0x11b130
jmp 0x3b8397
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::create_data()
inline void create_data()
            {
               destruct = true;
               data     = new T[size];
               std::fill_n(data, size, T(0));
               dump_ptr("control_block::create_data() - data", data, size);
            }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
movb $0x1, 0x18(%rax)
movq 0x8(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
movq $-0x1, %rax
cmovoq %rax, %rdi
callq 0x11b390
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rax), %rsi
movq 0x10(%rax), %rdi
movq $0x0, 0x48(%rsp)
leaq 0x48(%rsp), %rdx
callq 0x3b8560
leaq 0x27(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x11b6f0
movq 0x8(%rsp), %rdx
leaq 0x1ef520(%rip), %rsi    # 0x5a7a06
leaq 0x28(%rsp), %rdi
callq 0x134520
jmp 0x3b84f2
movq (%rsp), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x3b85c0
jmp 0x3b850a
leaq 0x28(%rsp), %rdi
callq 0x11b838
leaq 0x27(%rsp), %rdi
callq 0x11b820
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
jmp 0x3b854b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x11b838
leaq 0x27(%rsp), %rdi
callq 0x11b820
movq 0x18(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::min_size(exprtk::details::vec_data_store<double>::control_block const*, exprtk::details::vec_data_store<double>::control_block const*)
static inline std::size_t min_size(const control_block* cb0, const control_block* cb1)
         {
            const std::size_t size0 = cb0->size;
            const std::size_t size1 = cb1->size;

            if (size0 && size1)
               return std::min(size0,size1);
            else
               return (size0) ? size0 : size1;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3b8723
cmpq $0x0, 0x10(%rsp)
je 0x3b8723
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x234c90
movq (%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x3b874b
cmpq $0x0, 0x18(%rsp)
je 0x3b8737
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x3b8741
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::vec_data_store<double>::control_block::destroy(exprtk::details::vec_data_store<double>::control_block*&)
static inline void destroy(control_block*& cntrl_blck)
            {
               if (cntrl_blck)
               {
                  if (
                       (0 !=   cntrl_blck->ref_count) &&
                       (0 == --cntrl_blck->ref_count)
                     )
                  {
                     delete cntrl_blck;
                  }

                  cntrl_blck = 0;
               }
            }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, (%rax)
je 0x3b87d6
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
je 0x3b87ca
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
addq $-0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
cmpq %rcx, %rax
jne 0x3b87ca
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x3b87c8
movq 0x8(%rsp), %rdi
callq 0x3b87e0
movq 0x8(%rsp), %rdi
movl $0x20, %esi
callq 0x11b130
jmp 0x3b87ca
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)