LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpbsyz<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]);
         const vector_t y(parameters[4]);
               vector_t z(parameters[5]);

         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, 6, 7, 1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(y, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();
         else if (helper::invalid_range(z, r0, r1))
            return std::numeric_limits<T>::quiet_NaN();

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

         const std::size_t s = static_cast<std::size_t>(scalar_t(parameters[3])());

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

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x10(%rsp)
movq (%rdx), %r12
movq 0x18(%r12), %rbx
movq 0x60(%r12), %r15
movq 0x78(%r12), %r14
andq $0x0, 0x8(%rsp)
movq 0x20(%r12), %rax
movq 0x68(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, (%rsp)
cmpq $0x1, (%rsi)
jne 0x2c3c42
leaq 0x20(%rsp), %rcx
movq $0x6, (%rcx)
leaq 0x18(%rsp), %r8
movq $0x7, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
pushq $0x1
popq %r9
callq 0x2c1678
testb %al, %al
je 0x2c3cea
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq 0x68(%r12), %rdx
jmp 0x2c3c44
xorl %ecx, %ecx
movsd 0xa674(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3cf2
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3cf2
cmpq %rax, %rdx
jb 0x2c3cf2
movq 0x80(%r12), %rdx
decq %rdx
cmpq %rax, %rdx
jb 0x2c3cf2
movq 0x10(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rsi
movq 0x30(%rdx), %rdi
movsd (%rsi), %xmm1
movsd (%rdi), %xmm2
movq 0x48(%rdx), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0xa68b(%rip), %xmm0     # 0x2ce338
cvttsd2si %xmm0, %rdi
andq %rsi, %rdi
orq %rdx, %rdi
leaq (%r15,%rdi,8), %rdx
movsd 0xa4fc(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c3cf2
movsd (%rdx,%rcx,8), %xmm3
mulsd %xmm2, %xmm3
movsd (%rbx,%rcx,8), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%r14,%rcx,8)
incq %rcx
jmp 0x2c3cc4
movsd 0xa5ce(%rip), %xmm0     # 0x2ce2c0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpbz<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[1]);
               vector_t z(parameters[3]);

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

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

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

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

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rdx), %r15
movq 0x18(%r15), %rbx
movq 0x48(%r15), %r14
andq $0x0, 0x10(%rsp)
movq 0x20(%r15), %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c3d85
leaq 0x28(%rsp), %rcx
movq $0x4, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x5, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %r9
callq 0x2c1678
testb %al, %al
je 0x2c3de1
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
jmp 0x2c3d87
xorl %ecx, %ecx
movsd 0xa531(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3de9
movq 0x50(%r15), %rdx
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3de9
cmpq %rax, %rdx
jb 0x2c3de9
movq 0x18(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rsi
movq 0x30(%rdx), %rdx
movsd (%rsi), %xmm1
movsd (%rdx), %xmm2
movsd 0xa3fc(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c3de9
movsd (%rbx,%rcx,8), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%r14,%rcx,8)
incq %rcx
jmp 0x2c3dc4
movsd 0xa4d7(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rdx), %r15
movq (%r15), %rbx
movq 0x18(%r15), %r14
andq $0x0, 0x10(%rsp)
movq 0x8(%r15), %rax
movq 0x20(%r15), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c3f3a
leaq 0x28(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x3, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c3f73
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x20(%r15), %rdx
jmp 0x2c3f3c
xorl %ecx, %ecx
movsd 0xa37c(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3f7b
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3f7b
cmpq %rax, %rdx
jb 0x2c3f7b
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
ja 0x2c3f7b
movsd (%rbx,%rcx,8), %xmm1
mulsd (%r14,%rcx,8), %xmm1
addsd %xmm1, %xmm0
incq %rcx
jmp 0x2c3f5a
movsd 0xa345(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rdx), %r15
movq (%r15), %rbx
movq 0x18(%r15), %r14
andq $0x0, 0x10(%rsp)
movq 0x8(%r15), %rax
movq 0x20(%r15), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c401a
leaq 0x28(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x3, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c406f
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x20(%r15), %rdx
jmp 0x2c401c
xorl %ecx, %ecx
movsd 0xa29c(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c4077
decq %rdx
cmpq %rcx, %rdx
jb 0x2c4077
cmpq %rax, %rdx
jb 0x2c4077
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
ja 0x2c4077
movsd (%rbx,%rcx,8), %xmm2
mulsd (%r14,%rcx,8), %xmm2
subsd %xmm1, %xmm2
movapd %xmm0, %xmm3
addsd %xmm2, %xmm3
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
subsd %xmm2, %xmm1
incq %rcx
movapd %xmm3, %xmm0
jmp 0x2c403e
movsd 0xa249(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x40, %rsp
movq %rdx, 0x28(%rsp)
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq (%rsi), %rdx
leaq 0x48(%rax), %rsi
leaq 0x18(%rax), %rdi
testq %rdx, %rdx
cmoveq %rdi, %rsi
movq (%rax), %rbx
movq (%rsi), %rsi
movsd (%rsi), %xmm2
movq -0x18(%rcx), %rcx
movsd (%rcx), %xmm3
andq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, %rdx
jne 0x2c413f
movsd %xmm3, 0x18(%rsp)
movsd %xmm2, 0x20(%rsp)
leaq 0x38(%rsp), %rcx
movq $0x1, (%rcx)
leaq 0x30(%rsp), %r8
movq $0x2, (%r8)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c4163
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movsd 0x20(%rsp), %xmm2
movsd 0x18(%rsp), %xmm3
jmp 0x2c4141
xorl %ecx, %ecx
movsd 0xa077(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c4163
movsd (%rbx,%rcx,8), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x2c415e
movsd %xmm3, (%rbx,%rcx,8)
incq %rcx
jmp 0x2c4149
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::rebase(double*)
inline void rebase(data_ptr_t data)
      {
         data_ = data;

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

// Assembly:
movq %rsi, 0x10(%rdi)
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rdx
cmpq %rdx, %rax
je 0x2c5437
xorl %ecx, %ecx
subq %rax, %rdx
sarq $0x3, %rdx
cmpq %rdx, %rcx
jae 0x2c5437
movq (%rax,%rcx,8), %rax
movq %rsi, (%rax)
incq %rcx
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rdx
jmp 0x2c5417
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
sarq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x2c5bb5
addsd (%rax,%rdx,8), %xmm0
incq %rdx
jmp 0x2c5ba6
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: gen_func<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t params) exprtk_test_override
   {
      for (std::size_t i = 0; i < params.size(); ++i)
      {
         generic_type& gt = params[i];

         switch (gt.type)
         {
            case generic_type::e_scalar : scalar_count++;
                                          break;

            case generic_type::e_vector : vector_count++;
                                          break;

            case generic_type::e_string : {
                                             if (
                                                  ("CdEf"   != exprtk::to_str(string_t(gt))) &&
                                                  ("abc123" != exprtk::to_str(string_t(gt)))
                                                )
                                             {
                                                return std::numeric_limits<T>::quiet_NaN();
                                             }
                                             else
                                                string_count++;
                                          }
                                          break;

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

      return T(0);
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rdi), %rax
movq %rax, 0x10(%rsp)
addq $0x48, %r14
xorl %r13d, %r13d
pushq $0x18
popq %rsi
movsd 0x817c(%rip), %xmm0     # 0x2ce2c0
leaq 0x38(%rsp), %rbp
xorl %r15d, %r15d
movq (%rbx), %r12
movq 0x8(%rbx), %rax
subq %r12, %rax
cqto
idivq %rsi
cmpq %rax, %r15
jae 0x2c623e
movl 0x10(%r12,%r13), %ecx
movq %r14, %rax
cmpl $0x1, %ecx
je 0x2c622f
cmpl $0x3, %ecx
je 0x2c618d
movq 0x10(%rsp), %rax
cmpl $0x2, %ecx
je 0x2c622f
jmp 0x2c6241
addq %r13, %r12
movq %r12, 0x28(%rsp)
movq (%r12), %rax
movq %rax, 0x30(%rsp)
movq %rbp, %rdi
leaq 0x28(%rsp), %rsi
callq 0x2c259f
leaq 0x358d4(%rip), %rdi     # 0x2fba86
movq %rbp, %rsi
callq 0x2baf9b
testb %al, %al
je 0x2c6217
movq %r12, 0x18(%rsp)
movq (%r12), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %r12
movq %r12, %rdi
leaq 0x18(%rsp), %rsi
callq 0x2c259f
leaq 0x1f217(%rip), %rdi     # 0x2e53fc
movq %r12, %rsi
callq 0x2baf9b
movq %r12, %rdi
movl %eax, %r12d
callq 0x118648
movq %rbp, %rdi
callq 0x118648
movq 0x8(%rsp), %rax
testb %r12b, %r12b
movsd 0x80b0(%rip), %xmm0     # 0x2ce2c0
pushq $0x18
popq %rsi
je 0x2c622f
jmp 0x2c6241
movq %rbp, %rdi
callq 0x118648
movq 0x8(%rsp), %rax
movsd 0x8094(%rip), %xmm0     # 0x2ce2c0
pushq $0x18
popq %rsi
incq (%rax)
incq %r15
addq $0x18, %r13
jmp 0x2c614c
xorps %xmm0, %xmm0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x118648
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: inc_func<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t params) exprtk_test_override
   {
      for (std::size_t i = 0; i < params.size(); ++i)
      {
         generic_type& gt = params[i];

         switch (gt.type)
         {
            case generic_type::e_scalar : {
                                             scalar_t scalar(gt);
                                             scalar() += T(1);
                                          }
                                          break;

            case generic_type::e_vector : {
                                             vector_t vector(gt);

                                             for (std::size_t x = 0; x < vector.size(); ++x)
                                             {
                                                vector[x] += T(1);
                                             }
                                          }
                                          break;

            case generic_type::e_string : {
                                             string_t string(gt);

                                             for (std::size_t x = 0; x < string.size(); ++x)
                                             {
                                                string[x] += static_cast<typename string_t::value_t>(1);
                                             }
                                          }
                                          break;

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

      return T(0);
   }

// Assembly:
xorl %ecx, %ecx
pushq $0x18
popq %rdi
movsd 0x800d(%rip), %xmm0     # 0x2ce2c0
movsd 0x7f05(%rip), %xmm1     # 0x2ce1c0
movq (%rsi), %r8
movq 0x8(%rsi), %rax
subq %r8, %rax
cqto
idivq %rdi
cmpq %rax, %rcx
jae 0x2c6338
imulq $0x18, %rcx, %rdx
leaq (%r8,%rdx), %rax
movl 0x10(%r8,%rdx), %edx
cmpl $0x3, %edx
je 0x2c6323
cmpl $0x2, %edx
je 0x2c62ff
cmpl $0x1, %edx
jne 0x2c633b
movq (%rax), %rax
movsd (%rax), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rax)
incq %rcx
jmp 0x2c62bb
movq (%rax), %rdx
movq 0x8(%rax), %rax
xorl %r8d, %r8d
cmpq %r8, %rax
je 0x2c62fa
movsd (%rdx,%r8,8), %xmm2
addsd %xmm1, %xmm2
movsd %xmm2, (%rdx,%r8,8)
incq %r8
jmp 0x2c6309
movq (%rax), %rdx
xorl %r8d, %r8d
cmpq 0x8(%rax), %r8
jae 0x2c62fa
incb (%rdx,%r8)
incq %r8
jmp 0x2c6329
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1183f0
andq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
xorl %r12d, %r12d
cmpq 0x8(%r14), %r12
jae 0x2c63cc
movsbl (%r15,%r12), %edi
cmpl $0x20, %edi
je 0x2c63c7
callq 0x118130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1185f0
incq %r12
jmp 0x2c63a7
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::details::print_impl<double>::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::type_store<double>::parameter_list)
static void process(const std::string& scalar_format, parameter_list_t parameters)
         {
            for (std::size_t i = 0; i < parameters.size(); ++i)
            {
               generic_type& gt = parameters[i];

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

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

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

                  default                     : continue;
               }
            }
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorl %r12d, %r12d
pushq $0x18
popq %r13
leaq 0x8(%rsp), %r15
xorl %ebp, %ebp
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %rax, %rbp
jae 0x2c6622
movl 0x10(%rcx,%r12), %eax
addq %r12, %rcx
cmpl $0x3, %eax
je 0x2c6604
cmpl $0x2, %eax
je 0x2c65ea
cmpl $0x1, %eax
jne 0x2c6619
movq (%rcx), %rax
movq %rax, 0x8(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c6632
jmp 0x2c6619
movq %rcx, 0x8(%rsp)
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x2c663e
jmp 0x2c6619
movq %rcx, 0x8(%rsp)
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq %r15, %rdi
callq 0x2c668c
incq %rbp
addq $0x18, %r12
jmp 0x2c65aa
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::io::details::print_impl<double>::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::type_store<double>::type_view<double> const&)
static inline void print(const std::string& scalar_format, const vector_t& v)
         {
            for (std::size_t i = 0; i < v.size(); ++i)
            {
               print_type(scalar_format,v[i],num_type());

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
pushq $0x20
popq %rbp
movq (%rbx), %rax
cmpq 0x8(%rax), %r15
jae 0x2c6681
movq 0x8(%rbx), %rax
movsd (%rax,%r15,8), %xmm0
movq %r14, %rdi
callq 0x2c66be
incq %r15
movq (%rbx), %rax
cmpq 0x8(%rax), %r15
jae 0x2c6651
movl %ebp, %edi
callq 0x1185d0
jmp 0x2c6651
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3537b(%rip), %rsi     # 0x2fba9c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x127016
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2c4a48
movl %eax, %ebp
leaq 0x10(%rsp), %rdi
callq 0x118648
testb %bpl, %bpl
je 0x2c6789
leaq 0x3534a(%rip), %rsi     # 0x2fbaa2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x127016
addq $0x68, %rbx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x2c4a48
movl %eax, %ebx
leaq 0x10(%rsp), %rdi
callq 0x118648
jmp 0x2c678b
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2c679a
jmp 0x2c67a9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x118648
jmp 0x2c67ac
movq %rax, %rbx
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2c684c
leaq 0x34256(%rip), %rsi     # 0x2faa90
movq %rbx, %rdi
callq 0x118600
movsd 0x7976(%rip), %xmm0     # 0x2ce1c0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x50, %r14
leaq 0x220a1(%rip), %rsi     # 0x2e8909
movq %r14, %rdi
callq 0x118600
pushq $0x10
popq %r15
xorl %r12d, %r12d
pushq $0x18
popq %r13
leaq 0x5f7b6(%rip), %rbp     # 0x326038
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %rax, %r12
jae 0x2c68bc
movl (%rcx,%r15), %eax
decl %eax
cmpl $0x2, %eax
ja 0x2c68b3
movl %eax, %eax
movslq (%rbp,%rax,4), %rsi
addq %rbp, %rsi
movq %r14, %rdi
callq 0x118370
incq %r12
addq $0x18, %r15
jmp 0x2c6882
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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)
jbe 0x2c7355
retq
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 0x2c7ce8
leaq 0x938(%r14), %rcx
cmpq %rax, %rcx
je 0x2c738c
movq %r12, %rdi
movq %rax, %rsi
callq 0x2c7d5e
imulq $0x30, (%r15), %rdi
addq 0x960(%r14), %rdi
movq %rbx, %rsi
callq 0x2c7dac
movq %rax, %r12
movq (%r15), %rcx
movq 0x960(%r14), %rax
imulq $0x30, %rcx, %rdx
addq %rax, %rdx
addq $0x8, %rdx
cmpq %r12, %rdx
je 0x2c73e5
movq 0x40(%r12), %rdi
testq %rdi, %rdi
je 0x2c73d6
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %rcx
movq 0x960(%r14), %rax
imulq $0x30, %rcx, %rdi
addq %rax, %rdi
movq %r12, %rsi
callq 0x2c7e22
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2bcbfc
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::load_variables_from(exprtk::symbol_table<double> const&)
inline void load_variables_from(const symbol_table<T>& st)
      {
         std::vector<std::string> name_list;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %rsi
andq $0x0, 0x10(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsi)
movq (%rbx), %rax
movq 0x8(%rax), %rdi
callq 0x2c880e
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
cmpq %rax, %rsi
je 0x2c818b
xorl %r15d, %r15d
xorl %r12d, %r12d
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r12
jae 0x2c818b
addq %r15, %rsi
movq %rbx, %rdi
callq 0x2bc076
movq 0x28(%rax), %rdx
movq (%rsp), %rsi
addq %r15, %rsi
movq %r14, %rdi
xorl %ecx, %ecx
callq 0x19666e
incq %r12
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
addq $0x20, %r15
jmp 0x2c814d
movq %rsp, %rdi
callq 0x1f5c78
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2c81a1
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f5c78
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq (%rbx), %rax
movl $0x150, %edi            # imm = 0x150
addq 0x8(%rax), %rdi
callq 0x2c8860
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
cmpq %rax, %rsi
je 0x2c825f
xorl %r15d, %r15d
xorl %r14d, %r14d
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %r14
jae 0x2c825f
addq %r15, %rsi
movq %rbx, %rdi
callq 0x2c88b2
movq %rax, %rbp
movq (%rsp), %r12
addq %r15, %r12
movq %rax, %rdi
callq 0x22b516
movq %rax, %r13
movq (%rbp), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
leaq 0x20(%rsp), %rcx
callq 0x2c88fc
incq %r14
movq (%rsp), %rsi
movq 0x8(%rsp), %rax
addq $0x20, %r15
jmp 0x2c81fd
movq %rsp, %rdi
callq 0x1f5c78
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c827a
jmp 0x2c827a
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1f5c78
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::valid(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned long const&) const
inline bool valid(const std::string& name,
                        const std::size_t& arg_count) const
      {
         if (arg_count > 6)
            return false;
         else if (symbol_used(name))
            return false;
         else if (fp_map_[arg_count].end() != fp_map_[arg_count].find(name))
            return false;
         else
            return true;
      }

// Assembly:
cmpq $0x6, (%rdx)
jbe 0x2c8297
xorl %eax, %eax
retq
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x2c897a
testb %al, %al
je 0x2c82b2
xorl %eax, %eax
jmp 0x2c82d7
movq 0x960(%r15), %rax
imulq $0x30, (%r14), %rcx
leaq (%rax,%rcx), %rdi
leaq (%rax,%rcx), %r14
addq $0x8, %r14
movq %rbx, %rsi
callq 0x2c8a86
cmpq %rax, %r14
sete %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::operator=(exprtk::expression<double> const&)
inline expression<T>& operator=(const expression<T>& e)
      {
         if (this != &e)
         {
            if (control_block_)
            {
               if (
                    (0 !=   control_block_->ref_count) &&
                    (0 == --control_block_->ref_count)
                  )
               {
                  delete control_block_;
               }

               control_block_ = 0;
            }

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

         return *this;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq %rsi, %rdi
je 0x2c859c
movq %rsi, %r14
movq (%rbx), %r15
testq %r15, %r15
je 0x2c8583
movq (%r15), %rax
testq %rax, %rax
je 0x2c857f
decq %rax
movq %rax, (%r15)
jne 0x2c857f
movq %r15, %rdi
callq 0x1981bc
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x1180d0
andq $0x0, (%rbx)
movq (%r14), %rax
movq %rax, (%rbx)
incq (%rax)
addq $0x8, %r14
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x2cab3a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::symbol_used(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool symbol_used(const std::string& symbol) const
      {
         return (
                  symbol_table_.is_variable       (symbol) ||
                  symbol_table_.is_stringvar      (symbol) ||
                  symbol_table_.is_function       (symbol) ||
                  symbol_table_.is_vector         (symbol) ||
                  symbol_table_.is_vararg_function(symbol)
                );
      }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x2c89d6
testb %al, %al
jne 0x2c89ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c89ee
testb %al, %al
jne 0x2c89ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c8a0e
testb %al, %al
jne 0x2c89ba
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2c8a2c
testb %al, %al
je 0x2c89c4
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2c8a4c
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x28, %rsp
movq 0x98(%rdi), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0x98(%rdi)
testq %rax, %rax
je 0x2c9896
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
cmpq %rsi, %rax
je 0x2c97ec
subq %rax, %rsi
sarq $0x3, %rsi
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x2bb504
leaq 0x48(%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2c98ce
leaq 0xa0(%rbx), %rdi
movq %r14, %rsi
callq 0x2c98fa
leaq 0x8(%rsp), %rdi
callq 0x2a26b6
movq 0x60(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x2c9841
movq 0x90(%rbx), %rsi
leaq 0x20(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rcx
callq 0x2bb504
leaq 0x60(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2c9924
leaq 0xf0(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2c98fa
leaq 0x8(%rsp), %rdi
callq 0x2a26b6
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rsi
cmpq %rsi, %rax
je 0x2c9896
subq %rax, %rsi
sarq $0x3, %rsi
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x2c9998
leaq 0x78(%rbx), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x2c99ea
addq $0x140, %rbx            # imm = 0x140
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2c9a36
leaq 0x8(%rsp), %rdi
callq 0x1f5c78
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x2c98a4
jmp 0x2c98a4
jmp 0x2c98b8
movq %rax, %rbx
jmp 0x2c98c5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1f5c78
jmp 0x2c98c5
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2a26b6
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::copy(std::vector<std::pair<double*, unsigned long>, std::allocator<std::pair<double*, unsigned long>>> const&, std::vector<double, std::allocator<double>>&)
void copy(const lvr_vec_t& src_v, var_t& dest_v)
         {
            typename var_t::iterator itr = dest_v.begin();
            typedef  typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;

            for (std::size_t i = 0; i < src_v.size(); ++i)
            {
               lvarref_t vr = src_v[i];

               if (1 == vr.second)
                  *itr++ = (*vr.first);
               else
               {
                  std::copy(vr.first, vr.first + vr.second, itr);
                  itr += static_cast<diff_t>(vr.second);
               }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdx), %r14
pushq $0x8
popq %r15
xorl %r12d, %r12d
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %r12
jae 0x2c998d
movq (%rax,%r15), %r13
testq %r13, %r13
je 0x2c9980
movq -0x8(%rax,%r15), %rsi
cmpq $0x1, %r13
jne 0x2c9970
movsd (%rsi), %xmm0
movsd %xmm0, (%r14)
addq $0x8, %r14
jmp 0x2c9984
leaq (,%r13,8), %rdx
movq %r14, %rdi
callq 0x118110
leaq (%r14,%r13,8), %r14
incq %r12
addq $0x10, %r15
jmp 0x2c993a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2ca18b
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x2ca0ef
leaq 0x48(%rbx), %rdx
leaq 0xa0(%rbx), %r14
movq 0xd0(%rbx), %rsi
cmpq 0xd8(%rbx), %rsi
jne 0x2ca0db
movq 0xe8(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x2ca194
movq %r14, %rdi
callq 0x2ca1c0
movq 0x60(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x2ca138
leaq 0x60(%rbx), %rdx
leaq 0xf0(%rbx), %r14
movq 0x120(%rbx), %rsi
cmpq 0x128(%rbx), %rsi
jne 0x2ca124
movq 0x138(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x2ca1de
movq %r14, %rdi
callq 0x2ca1c0
movq 0x78(%rbx), %rax
cmpq 0x80(%rbx), %rax
je 0x2ca18b
leaq 0x78(%rbx), %rdx
leaq 0x140(%rbx), %r14
movq 0x170(%rbx), %rsi
cmpq 0x178(%rbx), %rsi
jne 0x2ca170
movq 0x188(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x2ca258
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2ca2a4
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::copy(std::vector<double, std::allocator<double>> const&, std::vector<std::pair<double*, unsigned long>, std::allocator<std::pair<double*, unsigned long>>>&)
void copy(const var_t& src_v, lvr_vec_t& dest_v)
         {
            typename var_t::const_iterator itr = src_v.begin();
            typedef  typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;

            for (std::size_t i = 0; i < dest_v.size(); ++i)
            {
               lvarref_t& vr = dest_v[i];

               assert(vr.first != 0);
               assert(vr.second > 0);

               if (1 == vr.second)
                  (*vr.first) = *itr++;
               else
               {
                  std::copy(itr, itr + static_cast<diff_t>(vr.second), vr.first);
                  itr += static_cast<diff_t>(vr.second);
               }
            }
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq (%rsi), %r14
pushq $0x8
popq %r15
xorl %r12d, %r12d
movq (%rbx), %r13
movq 0x8(%rbx), %rax
subq %r13, %rax
sarq $0x4, %rax
cmpq %rax, %r12
jae 0x2ca24e
movq (%r13,%r15), %rdx
testq %rdx, %rdx
je 0x2ca241
cmpq $0x1, %rdx
jne 0x2ca22b
movsd (%r14), %xmm0
addq $0x8, %r14
movq -0x8(%r13,%r15), %rax
movsd %xmm0, (%rax)
jmp 0x2ca245
shlq $0x3, %rdx
movq -0x8(%r13,%r15), %rdi
movq %r14, %rsi
callq 0x118110
movq (%r13,%r15), %rdx
leaq (%r14,%rdx,8), %r14
incq %r12
addq $0x10, %r15
jmp 0x2ca1f4
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rdi, %rbx
movq (%rdi), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rbx), %rax
movq 0x38(%rax), %rax
cmpb $0x1, (%rax)
jne 0x2ca396
movq %rbx, %rdi
callq 0x2ca398
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::results() const
inline const results_context_t& results() const
      {
         if (control_block_->results)
            return (*control_block_->results);
         else
         {
            static const results_context_t null_results;
            return null_results;
         }
      }

// Assembly:
pushq %rbx
movq (%rdi), %rax
movq 0x28(%rax), %rbx
testq %rbx, %rbx
jne 0x2ca3b6
movb 0x21d65d(%rip), %al     # 0x4e7a08
leaq 0x21d636(%rip), %rbx    # 0x4e79e8
testb %al, %al
je 0x2ca3bb
movq %rbx, %rax
popq %rbx
retq
leaq 0x21d646(%rip), %rdi    # 0x4e7a08
callq 0x1181a0
testl %eax, %eax
je 0x2ca3b6
movb $0x0, 0x21d616(%rip)    # 0x4e79e8
leaq 0x21d60f(%rip), %rbx    # 0x4e79e8
xorps %xmm0, %xmm0
movups %xmm0, 0x21d60d(%rip)   # 0x4e79f0
andq $0x0, 0x21d615(%rip)    # 0x4e7a00
leaq -0x1320c6(%rip), %rdi   # 0x19832c
leaq 0x1ecf2f(%rip), %rdx    # 0x4b7328
movq %rbx, %rsi
callq 0x118490
leaq 0x21d600(%rip), %rdi    # 0x4e7a08
callq 0x118300
jmp 0x2ca3b6
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::local_data_list()
inline const typename control_block::local_data_list_t& local_data_list()
      {
         if (control_block_)
         {
            return control_block_->local_data_list;
         }
         else
         {
            static typename control_block::local_data_list_t null_local_data_list;
            return null_local_data_list;
         }
      }

// Assembly:
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x2cb0af
addq $0x10, %rbx
jmp 0x2cb0c0
movb 0x21c973(%rip), %al     # 0x4e7a28
leaq 0x21c954(%rip), %rbx    # 0x4e7a10
testb %al, %al
je 0x2cb0c5
movq %rbx, %rax
popq %rbx
retq
leaq 0x21c95c(%rip), %rdi    # 0x4e7a28
callq 0x1181a0
testl %eax, %eax
je 0x2cb0c0
xorps %xmm0, %xmm0
movups %xmm0, 0x21c931(%rip)   # 0x4e7a10
andq $0x0, 0x21c939(%rip)    # 0x4e7a20
leaq 0x21c922(%rip), %rbx    # 0x4e7a10
leaq -0x132dbf(%rip), %rdi   # 0x198336
leaq 0x1ec22c(%rip), %rdx    # 0x4b7328
movq %rbx, %rsi
callq 0x118490
leaq 0x21c91d(%rip), %rdi    # 0x4e7a28
callq 0x118300
jmp 0x2cb0c0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x19580a
leaq 0x930(%rbx), %rdi
callq 0x2cba76
xorl %r12d, %r12d
pushq $0x30
popq %r13
movq 0x960(%rbx), %rcx
movq 0x968(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %rax, %r12
jae 0x2cba54
imulq $0x30, %r12, %r14
leaq (%rcx,%r14), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r15
cmpq %rbp, %r15
je 0x2cba40
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x2cba33
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x118520
movq %rax, %r15
jmp 0x2cba1f
addq 0x960(%rbx), %r14
movq %r14, %rdi
callq 0x2cbaa4
incq %r12
jmp 0x2cb9f4
xorps %xmm0, %xmm0
movups %xmm0, 0x8e0(%rbx)
andq $0x0, 0x8f0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> results_to_string<double>(exprtk::results_context<double> const&)
inline std::string results_to_string(const exprtk::results_context<T>& results)
{
   typedef exprtk::results_context<T> results_context_t;
   typedef typename results_context_t::type_store_t type_t;

   std::string res_str;

   for (std::size_t i = 0; i < results.count(); ++i)
   {
      type_t t = results[i];

      switch (t.type)
      {
         case type_t::e_scalar : res_str += 'T';
                                 break;

         case type_t::e_vector : res_str += 'V';
                                 break;

         case type_t::e_string : res_str += 'S';
                                 break;

         default               : continue;
      }
   }

   return res_str;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
pushq $0x10
popq %r15
xorl %r12d, %r12d
pushq $0x18
popq %r13
cmpb $0x1, (%r14)
jne 0x2cc05f
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
cqto
idivq %r13
jmp 0x2cc061
xorl %eax, %eax
cmpq %rax, %r12
jae 0x2cc093
movq 0x8(%r14), %rax
movl (%rax,%r15), %ecx
decl %ecx
cmpl $0x3, %ecx
jae 0x2cc08a
shll $0x3, %ecx
movl $0x535654, %eax         # imm = 0x535654
shrl %cl, %eax
movzbl %al, %esi
movq %rbx, %rdi
callq 0x1185f0
incq %r12
addq $0x18, %r15
jmp 0x2cc04a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x118648
movq %r14, %rdi
callq 0x118360