LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpbsyz<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T roundn_impl(const T v0, const T v1, real_type_tag)
            {
               const int index = std::max<int>(0, std::min<int>(pow10_size - 1, static_cast<int>(std::floor(v1))));
               const T p10 = T(pow10[index]);

               if (v0 < T(0))
                  return T(std::ceil ((v0 * p10) - T(0.5)) / p10);
               else
                  return T(std::floor((v0 * p10) + T(0.5)) / p10);
            }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdx), %r13
movq 0x18(%r13), %r14
movq 0x20(%r13), %rax
movq 0x60(%r13), %r12
movq 0x78(%r13), %r15
movq 0x68(%r13), %rdi
cmpq %rax, %rdi
cmovbq %rdi, %rax
cmpq $0x1, (%rsi)
jne 0x37cd15
movq %rdx, %rbx
movq 0x8(%rdx), %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movsd 0xc604(%rip), %xmm4     # 0x389208
cmpq $0x8, %rcx
jb 0x37cdc3
movq 0x90(%r13), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37cdc3
movsd 0xc3f0(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xc5b3(%rip), %xmm0     # 0x3891f0
jne 0x37cdbb
jp 0x37cdbb
movq (%rbx), %rax
movq 0xa8(%rax), %rax
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37cdbb
movq %rax, 0x8(%rsp)
movsd (%rbp), %xmm1
movaps %xmm1, 0x10(%rsp)
movsd 0xc3a4(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xc567(%rip), %xmm0     # 0x3891f0
jne 0x37cdbb
jp 0x37cdbb
movapd 0x10(%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0xc5d1(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rax, %rcx
movq 0x8(%rsp), %rax
movsd (%rax), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
subsd 0xc5ad(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rax
sarq $0x3f, %rsi
andq %rsi, %rax
orq %rdx, %rax
cmpq %rax, %rcx
movsd 0xc51b(%rip), %xmm4     # 0x389208
ja 0x37cdc3
movq (%rbx), %rdx
movq 0x20(%rdx), %rsi
decq %rsi
cmpq %rcx, %rsi
jb 0x37cdc3
cmpq %rax, %rsi
jb 0x37cdc3
movq 0x68(%r13), %rdi
jmp 0x37cd1d
decq %rax
xorl %ecx, %ecx
movq %r13, %rdx
movsd 0xc4e3(%rip), %xmm4     # 0x389208
cmpq %rcx, %rax
jb 0x37cdc3
decq %rdi
cmpq %rcx, %rdi
jb 0x37cdc3
cmpq %rax, %rdi
jb 0x37cdc3
movq 0x80(%r13), %rsi
decq %rsi
cmpq %rax, %rsi
jb 0x37cdc3
movq (%rdx), %rsi
movq 0x30(%rdx), %rdi
movsd (%rsi), %xmm0
movsd (%rdi), %xmm1
movq 0x48(%rdx), %rdx
movsd (%rdx), %xmm2
cvttsd2si %xmm2, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0xc503(%rip), %xmm2     # 0x389280
cvttsd2si %xmm2, %rdi
andq %rsi, %rdi
orq %rdx, %rdi
leaq (%r12,%rdi,8), %rdx
movsd 0xc28c(%rip), %xmm4     # 0x389020
movsd (%rdx,%rcx,8), %xmm2
mulsd %xmm1, %xmm2
movsd (%r14,%rcx,8), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%r15,%rcx,8)
incq %rcx
cmpq %rax, %rcx
jbe 0x37cd94
jmp 0x37cdc3
movsd 0xc445(%rip), %xmm4     # 0x389208
movaps %xmm4, %xmm0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::assign<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 assign_value = scalar_t(parameters[1]);

         const std::size_t step_size = (2 != ps_index) ? 1 :
                                       static_cast<std::size_t>(scalar_t(parameters.back())());

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

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

         for (std::size_t i = r0; i <= r1; i += step_size)
         {
            vec[i] = assign_value;
         }

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movq (%rdx), %rax
movq (%rax), %r14
movq 0x18(%rax), %rcx
movsd (%rcx), %xmm1
movq (%rsi), %rcx
cmpq $0x2, %rcx
jne 0x37baac
movq 0x8(%rbx), %rcx
movq -0x18(%rcx), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0xd7e1(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %r15
andq %rsi, %r15
orq %rdx, %r15
jmp 0x37bac0
cmpq $0x1, %rcx
jne 0x37bbdc
movq 0x8(%rbx), %rcx
movl $0x1, %r15d
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
xorpd %xmm0, %xmm0
cmpq $0x4, %rdx
jb 0x37bc01
movq 0x30(%rax), %r12
movsd (%r12), %xmm2
ucomisd %xmm2, %xmm0
ja 0x37bc01
movsd %xmm1, 0x8(%rsp)
movsd 0xd51b(%rip), %xmm1     # 0x389020
movapd %xmm2, %xmm0
callq 0x11e460
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x37bc01
jp 0x37bc01
movq (%rbx), %rax
movq 0x48(%rax), %r13
movsd (%r13), %xmm2
ucomisd %xmm2, %xmm0
ja 0x37bc01
movsd (%r12), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0xd4d0(%rip), %xmm1     # 0x389020
movapd %xmm2, %xmm0
callq 0x11e460
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x37bc01
jp 0x37bc01
movapd 0x10(%rsp), %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0xd6f5(%rip), %xmm1     # 0x389280
cvttsd2si %xmm1, %rax
andq %rdx, %rax
orq %rcx, %rax
movsd (%r13), %xmm1
cvttsd2si %xmm1, %rdx
movq %rdx, %rsi
subsd 0xd6d4(%rip), %xmm1     # 0x389280
cvttsd2si %xmm1, %rcx
sarq $0x3f, %rsi
andq %rsi, %rcx
orq %rdx, %rcx
cmpq %rcx, %rax
ja 0x37bc01
movq (%rbx), %rdx
movq 0x8(%rdx), %rdx
decq %rdx
cmpq %rax, %rdx
jb 0x37bc01
cmpq %rcx, %rdx
movsd 0x8(%rsp), %xmm1
jae 0x37bbeb
jmp 0x37bc01
movq 0x8(%rax), %rcx
decq %rcx
movl $0x1, %r15d
xorl %eax, %eax
movsd 0xd42d(%rip), %xmm0     # 0x389020
movsd %xmm1, (%r14,%rax,8)
addq %r15, %rax
cmpq %rcx, %rax
jbe 0x37bbf3
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::sumk<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 vec(parameters[0]);

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

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

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

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

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

         return result;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq (%rdx), %rax
movq (%rax), %r14
movq (%rsi), %rcx
cmpq $0x2, %rcx
jne 0x37bf96
movq 0x48(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0xd2f7(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %r15
andq %rdx, %r15
orq %rcx, %r15
jmp 0x37bfa6
movl $0x1, %r15d
cmpq $0x1, %rcx
jne 0x37c0bc
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
movsd 0xd241(%rip), %xmm3     # 0x389208
cmpq $0x3, %rdx
jb 0x37c101
movq 0x18(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37c101
movsd 0xd02f(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xd1f2(%rip), %xmm0     # 0x3891f0
jne 0x37c0f9
jp 0x37c0f9
movq (%rbx), %rax
movq 0x30(%rax), %r12
movsd (%r12), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37c0f9
movsd (%r13), %xmm1
movaps %xmm1, (%rsp)
movsd 0xcfe9(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xd1ac(%rip), %xmm0     # 0x3891f0
jne 0x37c0f9
jp 0x37c0f9
movapd (%rsp), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0xd217(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
movsd (%r12), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
subsd 0xd1f6(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rcx
sarq $0x3f, %rsi
andq %rsi, %rcx
orq %rdx, %rcx
cmpq %rcx, %rax
movsd 0xd164(%rip), %xmm3     # 0x389208
ja 0x37c101
movq (%rbx), %rdx
movq 0x8(%rdx), %rdx
decq %rdx
cmpq %rax, %rdx
jb 0x37c101
cmpq %rcx, %rdx
jae 0x37c0c5
jmp 0x37c101
movq 0x8(%rax), %rcx
decq %rcx
xorl %eax, %eax
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm3, %xmm3
movsd (%r14,%rax,8), %xmm2
subsd %xmm0, %xmm2
addsd %xmm2, %xmm3
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
subsd %xmm2, %xmm0
addq %r15, %rax
movapd %xmm3, %xmm1
cmpq %rcx, %rax
jbe 0x37c0d1
jmp 0x37c101
movsd 0xd107(%rip), %xmm3     # 0x389208
movapd %xmm3, %xmm0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq (%rdx), %r12
movq 0x18(%r12), %r14
movq 0x20(%r12), %rax
movq 0x30(%r12), %r15
movq 0x38(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
cmpq $0x1, (%rsi)
jne 0x37c29e
movq 0x8(%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movsd 0xd066(%rip), %xmm2     # 0x389208
cmpq $0x5, %rcx
jb 0x37c2f5
movq 0x48(%r12), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37c2f5
movsd 0xce54(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xd017(%rip), %xmm0     # 0x3891f0
jne 0x37c2ed
jp 0x37c2ed
movq (%rbx), %rax
movq 0x60(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37c2ed
movsd (%rbp), %xmm1
movaps %xmm1, (%rsp)
movsd 0xce0f(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xcfd2(%rip), %xmm0     # 0x3891f0
jne 0x37c2ed
jp 0x37c2ed
movapd (%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0xd03d(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rax, %rcx
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
subsd 0xd01c(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rax
sarq $0x3f, %rsi
andq %rsi, %rax
orq %rdx, %rax
cmpq %rax, %rcx
movsd 0xcf8a(%rip), %xmm2     # 0x389208
ja 0x37c2f5
movq (%rbx), %rsi
movq 0x20(%rsi), %rdx
decq %rdx
cmpq %rcx, %rdx
jb 0x37c2f5
cmpq %rax, %rdx
jb 0x37c2f5
movq 0x38(%r12), %rdx
movq %rsi, %r12
jmp 0x37c2a3
decq %rax
xorl %ecx, %ecx
movsd 0xcf5d(%rip), %xmm2     # 0x389208
cmpq %rcx, %rax
jb 0x37c2f5
decq %rdx
cmpq %rcx, %rdx
jb 0x37c2f5
cmpq %rax, %rdx
jb 0x37c2f5
movq (%r12), %rdx
movsd (%rdx), %xmm0
movsd 0xcd53(%rip), %xmm2     # 0x389020
movsd (%r14,%rcx,8), %xmm1
mulsd %xmm0, %xmm1
addsd (%r15,%rcx,8), %xmm1
movsd %xmm1, (%r15,%rcx,8)
incq %rcx
cmpq %rax, %rcx
jbe 0x37c2cd
jmp 0x37c2f5
movsd 0xcf13(%rip), %xmm2     # 0x389208
movaps %xmm2, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpby<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[3]);

         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, 4, 5, 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])();
         const T b = scalar_t(parameters[2])();

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

         return T(1);
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq (%rdx), %r12
movq 0x18(%r12), %r14
movq 0x20(%r12), %rax
movq 0x48(%r12), %r15
movq 0x50(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
cmpq $0x1, (%rsi)
jne 0x37c496
movq 0x8(%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movsd 0xce72(%rip), %xmm4     # 0x389208
cmpq $0x6, %rcx
jb 0x37c4fe
movq 0x60(%r12), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37c4fe
movsd 0xcc60(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xce23(%rip), %xmm0     # 0x3891f0
jne 0x37c4f6
jp 0x37c4f6
movq (%rbx), %rax
movq 0x78(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37c4f6
movsd (%rbp), %xmm1
movaps %xmm1, (%rsp)
movsd 0xcc1b(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xcdde(%rip), %xmm0     # 0x3891f0
jne 0x37c4f6
jp 0x37c4f6
movapd (%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0xce49(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rax, %rcx
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
subsd 0xce28(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rax
sarq $0x3f, %rsi
andq %rsi, %rax
orq %rdx, %rax
cmpq %rax, %rcx
movsd 0xcd96(%rip), %xmm4     # 0x389208
ja 0x37c4fe
movq (%rbx), %rsi
movq 0x20(%rsi), %rdx
decq %rdx
cmpq %rcx, %rdx
jb 0x37c4fe
cmpq %rax, %rdx
jb 0x37c4fe
movq 0x50(%r12), %rdx
movq %rsi, %r12
jmp 0x37c49b
decq %rax
xorl %ecx, %ecx
movsd 0xcd65(%rip), %xmm4     # 0x389208
cmpq %rcx, %rax
jb 0x37c4fe
decq %rdx
cmpq %rcx, %rdx
jb 0x37c4fe
cmpq %rax, %rdx
jb 0x37c4fe
movq (%r12), %rdx
movq 0x30(%r12), %rsi
movsd (%rdx), %xmm0
movsd (%rsi), %xmm1
movsd 0xcb52(%rip), %xmm4     # 0x389020
movsd (%r15,%rcx,8), %xmm2
mulsd %xmm1, %xmm2
movsd (%r14,%rcx,8), %xmm3
mulsd %xmm0, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%r15,%rcx,8)
incq %rcx
cmpq %rax, %rcx
jbe 0x37c4ce
jmp 0x37c4fe
movsd 0xcd0a(%rip), %xmm4     # 0x389208
movaps %xmm4, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq (%rdx), %r12
movq (%r12), %r14
movq 0x8(%r12), %rax
movq 0x18(%r12), %r15
movq 0x20(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
cmpq $0x1, (%rsi)
jne 0x37d2a6
movq 0x8(%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movsd 0xc05b(%rip), %xmm1     # 0x389208
cmpq $0x4, %rcx
jb 0x37d2eb
movq 0x30(%r12), %rbp
movsd (%rbp), %xmm0
xorpd %xmm2, %xmm2
ucomisd %xmm0, %xmm2
ja 0x37d2eb
movsd 0xbe49(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xc00c(%rip), %xmm0     # 0x3891f0
jne 0x37d2e3
jp 0x37d2e3
movq (%rbx), %rax
movq 0x48(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37d2e3
movsd (%rbp), %xmm1
movaps %xmm1, (%rsp)
movsd 0xbe04(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xbfc7(%rip), %xmm0     # 0x3891f0
jne 0x37d2e3
jp 0x37d2e3
movapd (%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0xc032(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rax, %rcx
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
subsd 0xc011(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rax
sarq $0x3f, %rsi
andq %rsi, %rax
orq %rdx, %rax
cmpq %rax, %rcx
movsd 0xbf7f(%rip), %xmm1     # 0x389208
ja 0x37d2eb
movq (%rbx), %rdx
movq 0x8(%rdx), %rdx
decq %rdx
cmpq %rcx, %rdx
jb 0x37d2eb
cmpq %rax, %rdx
jb 0x37d2eb
movq 0x20(%r12), %rdx
jmp 0x37d2ab
decq %rax
xorl %ecx, %ecx
movsd 0xbf55(%rip), %xmm1     # 0x389208
cmpq %rcx, %rax
jb 0x37d2eb
decq %rdx
cmpq %rcx, %rdx
jb 0x37d2eb
cmpq %rax, %rdx
jb 0x37d2eb
xorpd %xmm1, %xmm1
movsd (%r14,%rcx,8), %xmm0
mulsd (%r15,%rcx,8), %xmm0
addsd %xmm0, %xmm1
incq %rcx
cmpq %rax, %rcx
jbe 0x37d2c9
jmp 0x37d2eb
movsd 0xbf1d(%rip), %xmm1     # 0x389208
movapd %xmm1, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq (%rdx), %r12
movq (%r12), %r14
movq 0x8(%r12), %rax
movq 0x18(%r12), %r15
movq 0x20(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
cmpq $0x1, (%rsi)
jne 0x37d484
movq 0x8(%rbx), %rax
subq %r12, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
movsd 0xbe7d(%rip), %xmm3     # 0x389208
cmpq $0x4, %rcx
jb 0x37d4e5
movq 0x30(%r12), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37d4e5
movsd 0xbc6b(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xbe2e(%rip), %xmm0     # 0x3891f0
jne 0x37d4dd
jp 0x37d4dd
movq (%rbx), %rax
movq 0x48(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x37d4dd
movsd (%rbp), %xmm1
movaps %xmm1, (%rsp)
movsd 0xbc26(%rip), %xmm1     # 0x389020
callq 0x11e460
ucomisd 0xbde9(%rip), %xmm0     # 0x3891f0
jne 0x37d4dd
jp 0x37d4dd
movapd (%rsp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
subsd 0xbe54(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rcx
andq %rdx, %rcx
orq %rax, %rcx
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
subsd 0xbe33(%rip), %xmm0     # 0x389280
cvttsd2si %xmm0, %rax
sarq $0x3f, %rsi
andq %rsi, %rax
orq %rdx, %rax
cmpq %rax, %rcx
movsd 0xbda1(%rip), %xmm3     # 0x389208
ja 0x37d4e5
movq (%rbx), %rdx
movq 0x8(%rdx), %rdx
decq %rdx
cmpq %rcx, %rdx
jb 0x37d4e5
cmpq %rax, %rdx
jb 0x37d4e5
movq 0x20(%r12), %rdx
jmp 0x37d489
decq %rax
xorl %ecx, %ecx
movsd 0xbd77(%rip), %xmm3     # 0x389208
cmpq %rcx, %rax
jb 0x37d4e5
decq %rdx
cmpq %rcx, %rdx
jb 0x37d4e5
cmpq %rax, %rdx
jb 0x37d4e5
xorpd %xmm0, %xmm0
xorpd %xmm1, %xmm1
xorpd %xmm3, %xmm3
movsd (%r14,%rcx,8), %xmm2
mulsd (%r15,%rcx,8), %xmm2
subsd %xmm0, %xmm2
addsd %xmm2, %xmm3
movapd %xmm3, %xmm0
subsd %xmm1, %xmm0
subsd %xmm2, %xmm0
incq %rcx
movapd %xmm3, %xmm1
cmpq %rax, %rcx
jbe 0x37d4af
jmp 0x37d4e5
movsd 0xbd23(%rip), %xmm3     # 0x389208
movapd %xmm3, %xmm0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq (%rax), %r14
movq (%rsi), %rdx
leaq 0x48(%rax), %rsi
leaq 0x18(%rax), %rdi
testq %rdx, %rdx
cmoveq %rdi, %rsi
movq (%rsi), %rsi
movsd (%rsi), %xmm3
movq -0x18(%rcx), %rsi
movsd (%rsi), %xmm4
cmpq $0x1, %rdx
jne 0x37d693
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
xorpd %xmm0, %xmm0
cmpq $0x3, %rdx
jb 0x37d6be
movq 0x18(%rax), %r15
movsd (%r15), %xmm2
ucomisd %xmm2, %xmm0
ja 0x37d6be
movsd 0xba73(%rip), %xmm1     # 0x389020
movapd %xmm2, %xmm0
movsd %xmm3, 0x8(%rsp)
movsd %xmm4, (%rsp)
callq 0x11e460
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x37d6be
jp 0x37d6be
movq (%rbx), %rax
movq 0x30(%rax), %r12
movsd (%r12), %xmm2
ucomisd %xmm2, %xmm0
ja 0x37d6be
movsd (%r15), %xmm0
movaps %xmm0, 0x10(%rsp)
movsd 0xba1e(%rip), %xmm1     # 0x389020
movapd %xmm2, %xmm0
callq 0x11e460
movapd %xmm0, %xmm1
xorpd %xmm0, %xmm0
ucomisd %xmm0, %xmm1
jne 0x37d6be
jp 0x37d6be
movapd 0x10(%rsp), %xmm1
cvttsd2si %xmm1, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0xbc43(%rip), %xmm1     # 0x389280
cvttsd2si %xmm1, %rax
andq %rdx, %rax
orq %rcx, %rax
movsd (%r12), %xmm1
cvttsd2si %xmm1, %rdx
movq %rdx, %rsi
subsd 0xbc22(%rip), %xmm1     # 0x389280
cvttsd2si %xmm1, %rcx
sarq $0x3f, %rsi
andq %rsi, %rcx
orq %rdx, %rcx
cmpq %rcx, %rax
ja 0x37d6be
movq (%rbx), %rdx
movq 0x8(%rdx), %rdx
decq %rdx
cmpq %rax, %rdx
jb 0x37d6be
cmpq %rcx, %rdx
movsd 0x8(%rsp), %xmm3
movsd (%rsp), %xmm4
jae 0x37d69c
jmp 0x37d6be
movq 0x8(%rax), %rcx
decq %rcx
xorl %eax, %eax
movsd 0xb97c(%rip), %xmm0     # 0x389020
movsd (%r14,%rax,8), %xmm1
ucomisd %xmm3, %xmm1
jbe 0x37d6b6
movsd %xmm4, (%r14,%rax,8)
incq %rax
cmpq %rcx, %rax
jbe 0x37d6a4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
movq (%rsi), %rax
movq 0x8(%rsi), %rcx
subq %rax, %rcx
je 0x380580
sarq $0x3, %rcx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
addsd (%rax,%rdx,8), %xmm0
incq %rdx
cmpq %rdx, %rcx
jne 0x380572
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdx), %r14
movq (%r14), %r15
movq 0x8(%r14), %rsi
movq %rbx, %rdi
callq 0x11e400
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x381203
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
cmpl $0x20, %edi
je 0x3811fb
callq 0x11e130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11e5d0
movq 0x8(%r14), %rax
incq %r12
cmpq %rax, %r12
jb 0x3811dd
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: rem_space_and_uppercase<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& param_seq_index, std::string& result, parameter_list_t params) exprtk_test_override
   {
      if (1 == param_seq_index)
         return this->operator()(result,params);
      else
         return T(0);
   }

// Assembly:
cmpq $0x1, (%rsi)
jne 0x381280
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rcx), %r14
movq (%r14), %r15
movq 0x8(%r14), %rsi
movq %rdx, %rdi
callq 0x11e400
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0x381275
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
cmpl $0x20, %edi
je 0x38126d
callq 0x11e130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x11e5d0
movq 0x8(%r14), %rax
incq %r12
cmpq %rax, %r12
jb 0x38124f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::print<double>::~print()
struct print exprtk_final : public exprtk::igeneric_function<T>
   {
      typedef typename igeneric_function<T>::parameter_list_t parameter_list_t;

      using exprtk::igeneric_function<T>::operator();

      explicit print(const std::string& scalar_format = "%10.5f")
      : scalar_format_(scalar_format)
      {
         exprtk::enable_zero_parameters(*this);
      }

      inline T operator() (parameter_list_t parameters) exprtk_override
      {
         details::print_impl<T>::process(scalar_format_,parameters);
         return T(0);
      }

      std::string scalar_format_;
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x381504
movq (%rax), %rsi
incq %rsi
callq 0x11e0c0
leaq 0x1ba6f5(%rip), %rax    # 0x53bc00
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x381527
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x11e0c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::println<double>::~println()
struct println exprtk_final : public exprtk::igeneric_function<T>
   {
      typedef typename igeneric_function<T>::parameter_list_t parameter_list_t;

      using exprtk::igeneric_function<T>::operator();

      explicit println(const std::string& scalar_format = "%10.5f")
      : scalar_format_(scalar_format)
      {
         exprtk::enable_zero_parameters(*this);
      }

      inline T operator() (parameter_list_t parameters) exprtk_override
      {
         details::print_impl<T>::process(scalar_format_,parameters);
         printf("\n");
         return T(0);
      }

      std::string scalar_format_;
   }

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x48(%rdi), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x3816c4
movq (%rax), %rsi
incq %rsi
callq 0x11e0c0
leaq 0x1ba535(%rip), %rax    # 0x53bc00
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x3816e7
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x11e0c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x34c22(%rip), %rsi     # 0x3b6392
leaq 0x34c20(%rip), %rdx     # 0x3b6397
leaq 0x8(%rsp), %rdi
callq 0x1e4740
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x37e23c
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3817aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
testb %bpl, %bpl
je 0x3817f9
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x34bda(%rip), %rsi     # 0x3b6398
leaq 0x34bda(%rip), %rdx     # 0x3b639f
callq 0x1e4740
addq $0x68, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x37e23c
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3817fb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x3817fb
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38180c
jmp 0x381828
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x38182b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x11e0c0
jmp 0x38182b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdx, %rbx
movq (%rsi), %rax
movq %rax, 0x48(%rdi)
movq %rcx, %rsi
callq 0x381932
movq 0x8(%rbx), %rdx
leaq 0x33a6e(%rip), %rcx     # 0x3b5386
movl $0xd, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x11e290
movsd 0x76f0(%rip), %xmm0     # 0x389020
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq 0x58(%rdi), %rdx
addq $0x50, %r14
leaq 0x218ad(%rip), %rcx     # 0x3a31ff
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x11e290
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x3819bd
movl $0x10, %r15d
xorl %r12d, %r12d
leaq 0x5ef50(%rip), %r13     # 0x3e08c8
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movl (%rax,%r15), %eax
decl %eax
cmpl $0x2, %eax
ja 0x38199f
movl %eax, %eax
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x11e340
incq %r12
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
addq $0x18, %r15
cmpq %rcx, %r12
jb 0x381982
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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:
cmpq $0x6, (%rdx)
ja 0x3828b2
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x930(%rdi), %r12
movq %r12, %rdi
callq 0x383b4e
leaq 0x938(%r14), %rcx
cmpq %rax, %rcx
je 0x382807
movq %r12, %rdi
movq %rax, %rsi
callq 0x383bd8
movq (%r15), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x960(%r14), %rdi
movq %rbx, %rsi
callq 0x383c16
movq %rax, %r12
movq (%r15), %rcx
movq 0x960(%r14), %rax
leaq (%rcx,%rcx,2), %rdx
shlq $0x4, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %r12, %rdx
je 0x38286f
movq 0x40(%r12), %rdi
testq %rdi, %rdi
je 0x38285c
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %rcx
movq 0x960(%r14), %rax
leaq (%rcx,%rcx,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %r12, %rsi
callq 0x383ca0
movq (%r14), %rax
testq %rax, %rax
je 0x3828a7
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x3828a7
leaq 0x38(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e9c28
leaq 0x40(%r15), %rcx
cmpq %rax, %rcx
je 0x3828a7
movq %r14, %rdi
movq %rax, %rsi
callq 0x373690
decq 0x68(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq (%rsi), %rax
movq 0x8(%rax), %r14
cmpq $0x0, 0x178(%r14)
je 0x3843fa
movq 0x168(%r14), %r15
addq $0x158, %r14            # imm = 0x158
cmpq %r15, %r14
je 0x3843fa
movq %rsi, %rbx
leaq 0x10(%rsp), %r12
leaq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x33a20a
movq %r15, %rdi
callq 0x11e4c0
movq %rax, %r15
cmpq %rax, %r14
jne 0x384294
movq 0x10(%rsp), %r13
cmpq 0x18(%rsp), %r13
je 0x3843fa
xorl %ebp, %ebp
movq %rbp, %r12
shlq $0x5, %r12
movq (%rbx), %rax
testq %rax, %rax
je 0x384367
movq 0x8(%rax), %r14
testq %r14, %r14
je 0x384367
addq %r12, %r13
movq 0x8(%r13), %rax
testq %rax, %rax
je 0x384367
movq (%r13), %rcx
movb (%rcx), %dl
andb $-0x21, %dl
addb $-0x41, %dl
cmpb $0x19, %dl
ja 0x384367
cmpq $0x1, %rax
je 0x38434c
leaq -0x1(%rax), %rdx
movl $0x1, %esi
movb (%rcx,%rsi), %dil
cmpb $0x5f, %dil
je 0x384344
leal -0x30(%rdi), %r8d
cmpb $0xa, %r8b
jb 0x384344
movl %edi, %r8d
andb $-0x21, %r8b
addb $-0x41, %r8b
cmpb $0x1a, %r8b
jb 0x384344
cmpq %rdx, %rsi
jae 0x384367
movl $0x0, %r15d
cmpb $0x2e, %dil
jne 0x38436a
incq %rsi
cmpq %rsi, %rax
jne 0x38430e
leaq 0x1f0(%r14), %rdi
movq %r13, %rsi
callq 0x1e806a
addq $0x1f8, %r14            # imm = 0x1F8
cmpq %rax, %r14
je 0x3843cb
xorl %r15d, %r15d
addq 0x10(%rsp), %r12
movq (%r15), %rdi
movq $0x0, 0x8(%rsp)
movq (%rdi), %rax
leaq 0x8(%rsp), %rsi
callq *0x30(%rax)
movq %rax, %r13
movq (%r15), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x8(%rsp), %rcx
callq 0x384706
incq %rbp
movq 0x10(%rsp), %r13
movq 0x18(%rsp), %rax
subq %r13, %rax
sarq $0x5, %rax
cmpq %rax, %rbp
jb 0x3842c2
jmp 0x3843fa
movq (%rbx), %rax
movq 0x8(%rax), %r14
leaq 0x150(%r14), %rdi
movq %r13, %rsi
callq 0x1e83c4
addq $0x158, %r14            # imm = 0x158
cmpq %rax, %r14
je 0x384367
movq 0x48(%rax), %r15
jmp 0x38436a
leaq 0x10(%rsp), %rdi
callq 0x24916a
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x384417
jmp 0x384417
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24916a
movq %rbx, %rdi
callq 0x11e330
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::pre()
inline void pre()
         {
            if (stack_depth++)
            {
               if (!v.empty())
               {
                  var_t var_stack(v.size(),T(0));
                  copy(v,var_stack);
                  input_params_stack.push_back(var_stack);
               }

               if (!local_vars.empty())
               {
                  var_t local_vec_frame(local_var_stack_size,T(0));
                  copy(local_vars,local_vec_frame);
                  local_var_stack.push_back(local_vec_frame);
               }

               if (!local_str_vars.empty())
               {
                  str_t local_str_frame(local_str_vars.size());
                  copy(local_str_vars,local_str_frame);
                  local_str_stack.push_back(local_str_frame);
               }
            }
         }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq 0x98(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x98(%rdi)
testq %rax, %rax
je 0x3855d7
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
cmpq %rsi, %rax
je 0x38551d
subq %rax, %rsi
sarq $0x3, %rsi
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x370ea2
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
je 0x3854f5
sarq $0x3, %rcx
movq 0x10(%rsp), %rdx
cmpq $0x1, %rcx
adcq $0x0, %rcx
xorl %esi, %esi
movq (%rax,%rsi,8), %rdi
movsd (%rdi), %xmm0
movsd %xmm0, (%rdx,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x3854e0
leaq 0xa0(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38561a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x38551d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x60(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x385582
movq 0x90(%rbx), %rsi
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x370ea2
leaq 0x60(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x385644
leaq 0xf0(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x38561a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x385582
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rsi
cmpq %rsi, %rax
je 0x3855d7
subq %rax, %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x3856c6
leaq 0x78(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x385752
addq $0x140, %rbx            # imm = 0x140
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3857a4
leaq 0x10(%rsp), %rdi
callq 0x24916a
addq $0x30, %rsp
popq %rbx
retq
jmp 0x3855e3
jmp 0x3855e3
jmp 0x3855f7
movq %rax, %rbx
jmp 0x385611
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x24916a
jmp 0x385611
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x385611
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x11e0c0
movq %rbx, %rdi
callq 0x11e330
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::post()
inline void post()
         {
            if (--stack_depth)
            {
               if (!v.empty())
               {
                  copy(input_params_stack.back(), v);
                  input_params_stack.pop_back();
               }

               if (!local_vars.empty())
               {
                  copy(local_var_stack.back(), local_vars);
                  local_var_stack.pop_back();
               }

               if (!local_str_vars.empty())
               {
                  copy(local_str_stack.back(), local_str_vars);
                  local_str_stack.pop_back();
               }
            }
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
decq 0x98(%rdi)
je 0x385f3d
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x385ea1
movq 0xd0(%rbx), %rdx
cmpq 0xd8(%rbx), %rdx
jne 0x385e64
movq 0xe8(%rbx), %rcx
movl $0x1f8, %edx            # imm = 0x1F8
addq -0x8(%rcx), %rdx
leaq 0xa0(%rbx), %rdi
movq -0x18(%rdx), %rcx
movq -0x10(%rdx), %rdx
subq %rcx, %rdx
je 0x385e9c
sarq $0x3, %rdx
cmpq $0x1, %rdx
adcq $0x0, %rdx
xorl %esi, %esi
movsd (%rcx,%rsi,8), %xmm0
movq (%rax,%rsi,8), %r8
movsd %xmm0, (%r8)
incq %rsi
cmpq %rsi, %rdx
jne 0x385e86
callq 0x385f46
movq 0x60(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x385eea
leaq 0x60(%rbx), %rdx
leaq 0xf0(%rbx), %r14
movq 0x120(%rbx), %rsi
cmpq 0x128(%rbx), %rsi
jne 0x385ed6
movq 0x138(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x385f72
movq %r14, %rdi
callq 0x385f46
movq 0x78(%rbx), %rax
cmpq 0x80(%rbx), %rax
je 0x385f3d
leaq 0x78(%rbx), %rdx
leaq 0x140(%rbx), %r14
movq 0x170(%rbx), %rsi
cmpq 0x178(%rbx), %rsi
jne 0x385f22
movq 0x188(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x385ffa
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x38604c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::return_value(exprtk::expression<double>&)
static T return_value(expression_t& e)
      {
         typedef exprtk::results_context<T> results_context_t;
         typedef typename results_context_t::type_store_t type_t;
         typedef typename type_t::scalar_view scalar_t;

         const T result = e.value();

         if (e.return_invoked())
         {
            // Due to the post compilation checks, it can be safely
            // assumed that there will be at least one parameter
            // and that the first parameter will always be scalar.
            return scalar_t(e.results()[0])();
         }

         return result;
      }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x38(%rax), %rcx
cmpb $0x1, (%rcx)
jne 0x38616c
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x386161
movb 0x1ea892(%rip), %al     # 0x5709e8
testb %al, %al
je 0x386172
leaq 0x1ea867(%rip), %rax    # 0x5709c8
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x11ed21
movq (%rbx), %rax
jmp 0x386161
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::clear()
void clear()
      {
         symbol_table_.clear();
         expr_map_    .clear();

         for (std::size_t i = 0; i < fp_map_.size(); ++i)
         {
            typename funcparam_t::iterator itr = fp_map_[i].begin();
            typename funcparam_t::iterator end = fp_map_[i].end  ();

            while (itr != end)
            {
               delete itr->second;
               ++itr;
            }

            fp_map_[i].clear();
         }

         clear_loop_runtime_check         ();
         clear_vector_access_runtime_check();
         clear_compilation_timeout_check  ();
      }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1e70ec
leaq 0x930(%rbx), %rdi
callq 0x387752
movq 0x960(%rbx), %rdi
cmpq %rdi, 0x968(%rbx)
je 0x38772e
xorl %r15d, %r15d
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%r15,%r15,2), %r13
shlq $0x4, %r13
leaq (%rdi,%r13), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r14
cmpq %rbp, %r14
je 0x387705
movq 0x40(%r14), %rdi
testq %rdi, %rdi
je 0x3876ee
movq (%rdi), %rax
callq *0x8(%rax)
movq %r14, %rdi
callq 0x11e500
movq %rax, %r14
cmpq %rbp, %rax
jne 0x3876df
movq 0x960(%rbx), %rdi
addq %r13, %rdi
callq 0x387780
incq %r15
movq 0x960(%rbx), %rdi
movq 0x968(%rbx), %rax
subq %rdi, %rax
sarq $0x4, %rax
imulq %r12, %rax
cmpq %rax, %r15
jb 0x3876c6
xorps %xmm0, %xmm0
movups %xmm0, 0x8e0(%rbx)
movq $0x0, 0x8f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: my_usr<double>::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::unknown_symbol_resolver::usr_symbol_type&, double&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool process(const std::string& unknown_symbol,
                usr_symbol_type& st,
                T& default_value,
                std::string& error_message) exprtk_test_override
   {
      if (unknown_symbol[0] == 'v')
      {
         st = usr_t::e_usr_variable_type;
         default_value = next_value();
         error_message.clear();

         return true;
      }
      else if (unknown_symbol[0] == 'c')
      {
         st = usr_t::e_usr_constant_type;
         default_value = next_value();
         error_message.clear();

         return true;
      }
      else
      {
         error_message = "Unknown symbol...";
         return false;
      }
   }

// Assembly:
pushq %rbx
movq %r8, %rdi
movq (%rsi), %rax
movzbl (%rax), %eax
cmpl $0x63, %eax
je 0x387c3c
cmpl $0x76, %eax
jne 0x387c70
movl $0x1, (%rdx)
jmp 0x387c42
movl $0x2, (%rdx)
movsd 0x1e8dc6(%rip), %xmm0   # 0x570a10
addsd 0x13ce(%rip), %xmm0     # 0x389020
movsd %xmm0, 0x1e8db6(%rip)   # 0x570a10
movsd %xmm0, (%rcx)
movq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
movb $0x1, %bl
jmp 0x387c8a
movq 0x8(%rdi), %rdx
leaq 0x33866(%rip), %rcx     # 0x3bb4e1
xorl %ebx, %ebx
movl $0x11, %r8d
xorl %esi, %esi
callq 0x11e290
movl %ebx, %eax
popq %rbx
retq