LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r13
movq 0x18(%r13), %r14
movq 0x20(%r13), %r12
movq 0x38(%r13), %rax
cmpq %r12, %rax
cmovbq %rax, %r12
movq 0x30(%r13), %r15
decq %r12
cmpq $0x1, (%rsi)
jne 0x3a4ab5
movq 0x8(%rbx), %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x5, %rcx
jb 0x3a4ab9
movq 0x48(%r13), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a4ab9
movsd 0xd623(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd7ee(%rip), %xmm0     # 0x3b21f8
jne 0x3a4ab9
jp 0x3a4ab9
movsd (%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd859(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %rbp
andq %rcx, %rbp
orq %rax, %rbp
movq (%rbx), %rax
movq 0x60(%rax), %rax
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a4abb
movq %rax, (%rsp)
movsd 0xd5c5(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd790(%rip), %xmm0     # 0x3b21f8
jne 0x3a4abb
jp 0x3a4abb
movq (%rsp), %rax
movsd (%rax), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd800(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq (%rbx), %rax
movq 0x20(%rax), %rax
decq %rax
cmpq %rbp, %rax
setae %cl
cmpq %r12, %rax
setae %dl
andb %cl, %dl
cmpq %r12, %rbp
setbe %al
andb %dl, %al
jmp 0x3a4abd
xorl %ebp, %ebp
jmp 0x3a4ac1
xorl %ebp, %ebp
xorl %eax, %eax
testb %al, %al
je 0x3a4b11
movsd 0xd747(%rip), %xmm0     # 0x3b2210
cmpq %rbp, %r12
jb 0x3a4b19
movq 0x38(%r13), %rax
decq %rax
cmpq %rbp, %rax
jb 0x3a4b19
cmpq %r12, %rax
jb 0x3a4b19
movq (%rbx), %rax
movq (%rax), %rax
movsd (%rax), %xmm1
movsd 0xd52f(%rip), %xmm0     # 0x3b2020
movsd (%r14,%rbp,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r15,%rbp,8), %xmm2
movsd %xmm2, (%r15,%rbp,8)
incq %rbp
cmpq %r12, %rbp
jbe 0x3a4af1
jmp 0x3a4b19
movsd 0xd6f7(%rip), %xmm0     # 0x3b2210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r13
movq 0x18(%r13), %r14
movq 0x20(%r13), %r12
movq 0x50(%r13), %rax
cmpq %r12, %rax
cmovbq %rax, %r12
movq 0x48(%r13), %r15
decq %r12
cmpq $0x1, (%rsi)
jne 0x3a4c8b
movq 0x8(%rbx), %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x6, %rcx
jb 0x3a4c8f
movq 0x60(%r13), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a4c8f
movsd 0xd44d(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd618(%rip), %xmm0     # 0x3b21f8
jne 0x3a4c8f
jp 0x3a4c8f
movsd (%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd683(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %rbp
andq %rcx, %rbp
orq %rax, %rbp
movq (%rbx), %rax
movq 0x78(%rax), %rax
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a4c91
movq %rax, (%rsp)
movsd 0xd3ef(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xd5ba(%rip), %xmm0     # 0x3b21f8
jne 0x3a4c91
jp 0x3a4c91
movq (%rsp), %rax
movsd (%rax), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xd62a(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq (%rbx), %rax
movq 0x20(%rax), %rax
decq %rax
cmpq %rbp, %rax
setae %cl
cmpq %r12, %rax
setae %dl
andb %cl, %dl
cmpq %r12, %rbp
setbe %al
andb %dl, %al
jmp 0x3a4c93
xorl %ebp, %ebp
jmp 0x3a4c97
xorl %ebp, %ebp
xorl %eax, %eax
testb %al, %al
je 0x3a4cf7
movsd 0xd571(%rip), %xmm0     # 0x3b2210
cmpq %rbp, %r12
jb 0x3a4cff
movq 0x50(%r13), %rax
decq %rax
cmpq %rbp, %rax
jb 0x3a4cff
cmpq %r12, %rax
jb 0x3a4cff
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x30(%rax), %rax
movsd (%rcx), %xmm1
movsd (%rax), %xmm2
movsd 0xd351(%rip), %xmm0     # 0x3b2020
movsd (%r15,%rbp,8), %xmm3
mulsd %xmm2, %xmm3
movsd (%r14,%rbp,8), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%r15,%rbp,8)
incq %rbp
cmpq %r12, %rbp
jbe 0x3a4ccf
jmp 0x3a4cff
movsd 0xd511(%rip), %xmm0     # 0x3b2210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq (%rdx), %r13
movq 0x18(%r13), %r14
movq 0x20(%r13), %r12
movq 0x48(%r13), %r15
decq %r12
cmpq $0x1, (%rsi)
jne 0x3a5708
movq 0x8(%rbx), %rax
subq %r13, %rax
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rax, %rcx
cmpq $0x6, %rcx
jb 0x3a570c
movq 0x60(%r13), %rbp
movsd (%rbp), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a570c
movsd 0xc9d0(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xcb9b(%rip), %xmm0     # 0x3b21f8
jne 0x3a570c
jp 0x3a570c
movsd (%rbp), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcc06(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %rbp
andq %rcx, %rbp
orq %rax, %rbp
movq (%rbx), %rax
movq 0x78(%rax), %rax
movsd (%rax), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a570e
movq %rax, (%rsp)
movsd 0xc972(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xcb3d(%rip), %xmm0     # 0x3b21f8
jne 0x3a570e
jp 0x3a570e
movq (%rsp), %rax
movsd (%rax), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xcbad(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq (%rbx), %rax
movq 0x20(%rax), %rax
decq %rax
cmpq %rbp, %rax
setae %cl
cmpq %r12, %rax
setae %dl
andb %cl, %dl
cmpq %r12, %rbp
setbe %al
andb %dl, %al
jmp 0x3a5710
xorl %ebp, %ebp
jmp 0x3a5714
xorl %ebp, %ebp
xorl %eax, %eax
testb %al, %al
je 0x3a576a
movsd 0xcaf4(%rip), %xmm0     # 0x3b2210
cmpq %rbp, %r12
jb 0x3a5772
movq 0x50(%r13), %rax
decq %rax
cmpq %rbp, %rax
jb 0x3a5772
cmpq %r12, %rax
jb 0x3a5772
movq (%rbx), %rax
movq (%rax), %rcx
movq 0x30(%rax), %rax
movsd (%rcx), %xmm1
movsd (%rax), %xmm2
movsd 0xc8d4(%rip), %xmm0     # 0x3b2020
movsd (%r14,%rbp,8), %xmm3
mulsd %xmm1, %xmm3
addsd %xmm2, %xmm3
movsd %xmm3, (%r15,%rbp,8)
incq %rbp
cmpq %r12, %rbp
jbe 0x3a574c
jmp 0x3a5772
movsd 0xca9e(%rip), %xmm0     # 0x3b2210
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq (%rdx), %rax
movq 0x8(%rdx), %rcx
movq (%rax), %r14
movq 0x8(%rax), %r15
movq (%rsi), %rdx
leaq 0x48(%rax), %rsi
leaq 0x18(%rax), %rdi
testq %rdx, %rdx
cmoveq %rdi, %rsi
movq (%rsi), %rsi
movsd (%rsi), %xmm2
movq -0x18(%rcx), %rsi
movsd (%rsi), %xmm3
decq %r15
cmpq $0x1, %rdx
jne 0x3a5d31
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rdx
cmpq $0x3, %rdx
jb 0x3a5d27
movq 0x18(%rax), %r12
movsd (%r12), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
jbe 0x3a5d39
xorl %r12d, %r12d
xorl %eax, %eax
jmp 0x3a5e11
xorl %r12d, %r12d
jmp 0x3a5e19
movsd %xmm3, (%rsp)
movsd %xmm2, 0x8(%rsp)
movsd 0xc2d4(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xc49f(%rip), %xmm0     # 0x3b21f8
jne 0x3a5e01
jp 0x3a5e01
movsd (%r12), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xc509(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r12
andq %rcx, %r12
orq %rax, %r12
movq (%rbx), %rax
movq 0x30(%rax), %r13
movsd (%r13), %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm0, %xmm1
ja 0x3a5e04
movsd 0xc277(%rip), %xmm1     # 0x3b2020
callq 0x120460
ucomisd 0xc442(%rip), %xmm0     # 0x3b21f8
jne 0x3a5e04
jp 0x3a5e04
movsd (%r13), %xmm0
cvttsd2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0xc4b4(%rip), %xmm0     # 0x3b2288
cvttsd2si %xmm0, %r15
andq %rcx, %r15
orq %rax, %r15
movq (%rbx), %rax
movq 0x8(%rax), %rax
decq %rax
cmpq %r12, %rax
setae %cl
cmpq %r15, %rax
setae %dl
andb %cl, %dl
cmpq %r15, %r12
setbe %al
andb %dl, %al
jmp 0x3a5e06
xorl %r12d, %r12d
xorl %eax, %eax
movsd 0x8(%rsp), %xmm2
movsd (%rsp), %xmm3
xorpd %xmm0, %xmm0
testb %al, %al
je 0x3a5e3d
movsd 0xc1ff(%rip), %xmm0     # 0x3b2020
cmpq %r15, %r12
ja 0x3a5e3d
movsd (%r14,%r12,8), %xmm1
ucomisd %xmm2, %xmm1
jbe 0x3a5e38
movsd %xmm3, (%r14,%r12,8)
incq %r12
jmp 0x3a5e21
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3a8f6c
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 0x3a8f5e
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x120400
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
cmpq $0x0, 0x8(%r14)
je 0x3a9fba
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
cmpl $0x20, %edi
je 0x3a9fb1
callq 0x120130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1205d0
incq %r12
cmpq 0x8(%r14), %r12
jb 0x3a9f97
xorps %xmm0, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3aa033
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 0x120400
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
cmpq $0x0, 0x8(%r14)
je 0x3aa028
xorl %r12d, %r12d
movsbl (%r15,%r12), %edi
cmpl $0x20, %edi
je 0x3aa01f
callq 0x120130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1205d0
incq %r12
cmpq 0x8(%r14), %r12
jb 0x3aa005
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3aa2b8
movq (%rax), %rsi
incq %rsi
callq 0x1200c0
leaq 0x1cb941(%rip), %rax    # 0x575c00
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x3aa2db
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x1200c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3aa46e
movq (%rax), %rsi
incq %rsi
callq 0x1200c0
leaq 0x1cb78b(%rip), %rax    # 0x575c00
movq %rax, (%rbx)
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x3aa491
movq (%rbx), %rsi
incq %rsi
popq %rbx
jmp 0x1200c0
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x34e4e(%rip), %rsi     # 0x3df368
leaq 0x34e4c(%rip), %rdx     # 0x3df36d
leaq 0x8(%rsp), %rdi
callq 0x1eabb8
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3a69bc
movl %eax, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3aa554
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
testb %bpl, %bpl
je 0x3aa5a3
leaq 0x8(%rsp), %rdi
movq %r15, (%rdi)
leaq 0x34e06(%rip), %rsi     # 0x3df36e
leaq 0x34e06(%rip), %rdx     # 0x3df375
callq 0x1eabb8
addq $0x68, %rbx
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x3a69bc
movl %eax, %ebx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3aa5a5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x3aa5a5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3aa5b6
jmp 0x3aa5d2
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x3aa5d5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1200c0
jmp 0x3aa5d5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3aa6dc
movq 0x8(%rbx), %rdx
leaq 0x33c9a(%rip), %rcx     # 0x3de35c
movl $0xd, %r8d
movq %rbx, %rdi
xorl %esi, %esi
callq 0x120290
movsd 0x7946(%rip), %xmm0     # 0x3b2020
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x21ad9(%rip), %rcx     # 0x3cc1d5
movq %r14, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x120290
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x3aa767
movl $0x10, %r15d
xorl %r12d, %r12d
leaq 0x5f1a6(%rip), %r13     # 0x4098c8
movabsq $-0x5555555555555555, %rbp # imm = 0xAAAAAAAAAAAAAAAB
movl (%rax,%r15), %eax
decl %eax
cmpl $0x2, %eax
ja 0x3aa749
movl %eax, %eax
movslq (%r13,%rax,4), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x120340
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 0x3aa72c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ab651
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 0x3ac8f4
leaq 0x938(%r14), %rcx
cmpq %rax, %rcx
je 0x3ab5a9
movq %r12, %rdi
movq %rax, %rsi
callq 0x3ac97e
movq (%r15), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x960(%r14), %rdi
movq %rbx, %rsi
callq 0x3ac9bc
movq %rax, %r12
movq (%r15), %rax
movq 0x960(%r14), %rcx
leaq (%rax,%rax,2), %rax
shlq $0x4, %rax
addq %rcx, %rax
addq $0x8, %rax
cmpq %r12, %rax
je 0x3ab60e
movq 0x40(%r12), %rdi
testq %rdi, %rdi
je 0x3ab5f4
movq (%rdi), %rax
callq *0x8(%rax)
movq (%r15), %rax
leaq (%rax,%rax,2), %rdi
shlq $0x4, %rdi
addq 0x960(%r14), %rdi
movq %r12, %rsi
callq 0x3aca46
movq (%r14), %rax
testq %rax, %rax
je 0x3ab646
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x3ab646
leaq 0x38(%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1f0832
leaq 0x40(%r15), %rcx
cmpq %rax, %rcx
je 0x3ab646
movq %r14, %rdi
movq %rax, %rsi
callq 0x39be04
decq 0x68(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq (%rsi), %rax
movq 0x8(%rax), %r13
cmpq $0x0, 0x28(%r13)
je 0x3ad159
movq 0x18(%r13), %r15
addq $0x8, %r13
cmpq %r15, %r13
je 0x3ad159
movq %rsp, %r12
leaq 0x20(%r15), %rsi
movq %r12, %rdi
callq 0x35fd26
movq %r15, %rdi
callq 0x1204c0
movq %rax, %r15
cmpq %rax, %r13
jne 0x3ad13d
movq (%rsp), %rax
cmpq 0x8(%rsp), %rax
je 0x3ad23c
movq (%rsp), %rcx
cmpq %rcx, 0x8(%rsp)
je 0x3ad23c
xorl %r13d, %r13d
movq %r13, %r15
shlq $0x5, %r15
leaq (%rcx,%r15), %r12
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq 0x8(%rcx,%r15), %rax
cmpq $0x1, %rax
je 0x3ad1e9
movq (%rcx,%r15), %rcx
leaq -0x1(%rax), %rdx
movl $0x1, %r8d
xorl %esi, %esi
movb (%rcx,%r8), %r9b
cmpb $0x5f, %r9b
je 0x3ad1d7
leal -0x30(%r9), %r10d
cmpb $0xa, %r10b
jb 0x3ad1d7
movl %r9d, %r10d
andb $-0x21, %r10b
addb $-0x41, %r10b
cmpb $0x1a, %r10b
jb 0x3ad1d7
cmpq %rdx, %r8
jae 0x3ad1e3
cmpb $0x2e, %r9b
jne 0x3ad1e3
incq %r8
cmpq %rax, %r8
setae %sil
jne 0x3ad1a7
testb $0x1, %sil
je 0x3ad1f8
addq $0x1f0, %rdi            # imm = 0x1F0
movq %r12, %rsi
callq 0x1ee3b2
movq (%rbx), %rax
movq 0x8(%rax), %rdi
movq %r12, %rsi
callq 0x1ee43c
movq 0x48(%rax), %rax
movq 0x28(%rax), %rdx
addq (%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x1ee244
incq %r13
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
subq %rcx, %rax
sarq $0x5, %rax
cmpq %rax, %r13
jb 0x3ad17a
movq %rsp, %rdi
callq 0x266c02
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3ad254
movq %rax, %rbx
movq %rsp, %rdi
callq 0x266c02
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0x3ad853
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x3ad853
cmpq $0x0, 0x8(%rbx)
je 0x3ad853
leaq 0x8(%rdi), %r15
movq %rbx, %rsi
callq 0x1ee43c
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r15
jne 0x3ad92d
movq (%r14), %rax
testq %rax, %rax
je 0x3ad88f
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x3ad88f
cmpq $0x0, 0x8(%rbx)
je 0x3ad88f
leaq 0x188(%r15), %rdi
addq $0x190, %r15            # imm = 0x190
movq %rbx, %rsi
callq 0x1ee67c
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r15
jne 0x3ad92d
movq (%r14), %rax
testq %rax, %rax
je 0x3ad8c1
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x3ad8c1
cmpq $0x0, 0x8(%rbx)
je 0x3ad8c1
leaq 0x38(%r15), %rdi
addq $0x40, %r15
movq %rbx, %rsi
callq 0x1eeafc
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r15
jne 0x3ad92d
movq (%r14), %rax
testq %rax, %rax
je 0x3ad8f9
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x3ad8f9
cmpq $0x0, 0x8(%rbx)
je 0x3ad8f9
leaq 0x150(%r15), %rdi
addq $0x158, %r15            # imm = 0x158
movq %rbx, %rsi
callq 0x1ee8bc
movq %rax, %rcx
movb $0x1, %al
cmpq %rcx, %r15
jne 0x3ad92d
movq (%r14), %rax
testq %rax, %rax
je 0x3ad92b
movq 0x8(%rax), %r14
xorl %eax, %eax
testq %r14, %r14
je 0x3ad92d
cmpq $0x0, 0x8(%rbx)
je 0x3ad92d
leaq 0x70(%r14), %rdi
addq $0x78, %r14
movq %rbx, %rsi
callq 0x38e35c
cmpq %rax, %r14
setne %al
jmp 0x3ad92d
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3ae4d7
movq %rdi, %rbx
movq 0x48(%rdi), %rax
movq 0x50(%rdi), %rsi
cmpq %rsi, %rax
je 0x3ae41d
subq %rax, %rsi
sarq $0x3, %rsi
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x399364
movq 0x48(%rbx), %rax
movq 0x50(%rbx), %rcx
subq %rax, %rcx
je 0x3ae3f5
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 0x3ae3e0
leaq 0xa0(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ae51a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ae41d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x60(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x3ae482
movq 0x90(%rbx), %rsi
leaq 0x28(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x399364
leaq 0x60(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ae544
leaq 0xf0(%rbx), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3ae51a
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ae482
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq 0x78(%rbx), %rax
movq 0x80(%rbx), %rsi
cmpq %rsi, %rax
je 0x3ae4d7
subq %rax, %rsi
sarq $0x3, %rsi
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x3ae5c0
leaq 0x78(%rbx), %rsi
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x3ae64a
addq $0x140, %rbx            # imm = 0x140
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3ae69c
leaq 0x10(%rsp), %rdi
callq 0x266c02
addq $0x30, %rsp
popq %rbx
retq
jmp 0x3ae4e3
jmp 0x3ae4e3
jmp 0x3ae4f7
movq %rax, %rbx
jmp 0x3ae511
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x266c02
jmp 0x3ae511
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x3ae511
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1200c0
movq %rbx, %rdi
callq 0x120330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3aee35
movq %rdi, %rbx
movq 0x48(%rdi), %rax
cmpq 0x50(%rdi), %rax
je 0x3aed99
movq 0xd0(%rbx), %rdx
cmpq 0xd8(%rbx), %rdx
jne 0x3aed5c
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 0x3aed94
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 0x3aed7e
callq 0x3aee3e
movq 0x60(%rbx), %rax
cmpq 0x68(%rbx), %rax
je 0x3aede2
leaq 0x60(%rbx), %rdx
leaq 0xf0(%rbx), %r14
movq 0x120(%rbx), %rsi
cmpq 0x128(%rbx), %rsi
jne 0x3aedce
movq 0x138(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x3aee6a
movq %r14, %rdi
callq 0x3aee3e
movq 0x78(%rbx), %rax
cmpq 0x80(%rbx), %rax
je 0x3aee35
leaq 0x78(%rbx), %rdx
leaq 0x140(%rbx), %r14
movq 0x170(%rbx), %rsi
cmpq 0x178(%rbx), %rsi
jne 0x3aee1a
movq 0x188(%rbx), %rax
movl $0x1f8, %esi            # imm = 0x1F8
addq -0x8(%rax), %rsi
addq $-0x18, %rsi
movq %rbx, %rdi
callq 0x3aeeee
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3aef40
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3af060
movq 0x28(%rax), %rax
testq %rax, %rax
jne 0x3af055
movb 0x1fb99e(%rip), %al     # 0x5aa9e8
testb %al, %al
je 0x3af066
leaq 0x1fb973(%rip), %rax    # 0x5aa9c8
movq 0x8(%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
addq $0x10, %rsp
popq %rbx
retq
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x120d6d
movq (%rbx), %rax
jmp 0x3af055
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ed3ea
leaq 0x930(%rbx), %rdi
callq 0x3b0634
movq 0x960(%rbx), %rax
cmpq %rax, 0x968(%rbx)
je 0x3b0610
xorl %r12d, %r12d
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
leaq (%r12,%r12,2), %r14
shlq $0x4, %r14
leaq (%rax,%r14), %rbp
addq $0x8, %rbp
movq 0x10(%rbp), %r15
cmpq %rbp, %r15
je 0x3b05e0
movq 0x40(%r15), %rdi
testq %rdi, %rdi
je 0x3b05d0
movq (%rdi), %rax
callq *0x8(%rax)
movq %r15, %rdi
callq 0x120500
movq %rax, %r15
cmpq %rbp, %rax
jne 0x3b05c1
addq 0x960(%rbx), %r14
movq %r14, %rdi
callq 0x3b0662
incq %r12
movq 0x960(%rbx), %rax
movq 0x968(%rbx), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
imulq %r13, %rcx
cmpq %rcx, %r12
jb 0x3b05a8
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_O1/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 0x3b0b1c
cmpl $0x76, %eax
jne 0x3b0b50
movl $0x1, (%rdx)
jmp 0x3b0b22
movl $0x2, (%rdx)
movsd 0x1f9ee6(%rip), %xmm0   # 0x5aaa10
addsd 0x14ee(%rip), %xmm0     # 0x3b2020
movsd %xmm0, 0x1f9ed6(%rip)   # 0x5aaa10
movsd %xmm0, (%rcx)
movq $0x0, 0x8(%rdi)
movq (%rdi), %rax
movb $0x0, (%rax)
movb $0x1, %bl
jmp 0x3b0b6a
movq 0x8(%rdi), %rdx
leaq 0x3395c(%rip), %rcx     # 0x3e44b7
xorl %ebx, %ebx
movl $0x11, %r8d
xorl %esi, %esi
callq 0x120290
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::results_context<double>::get_string(unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
inline bool get_string(const std::size_t& index, std::string& out) const
      {
         if (
              (index < parameter_list_.size()) &&
              (parameter_list_[index].type == type_store_t::e_string)
            )
         {
            const string_t str(parameter_list_[index]);
            out.assign(str.begin(),str.size());
            return true;
         }

         return false;
      }

// Assembly:
movq (%rsi), %rcx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %rdi # imm = 0xAAAAAAAAAAAAAAAB
imulq %rsi, %rdi
cmpq %rdi, %rcx
jae 0x3b0f28
leaq (%rcx,%rcx,2), %rcx
cmpl $0x3, 0x10(%rax,%rcx,8)
jne 0x3b0f28
pushq %rax
leaq (%rax,%rcx,8), %rax
movq (%rax), %rcx
movq 0x8(%rax), %r8
movq 0x8(%rdx), %rax
movq %rdx, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x120290
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser_error::to_str[abi:cxx11](exprtk::parser_error::error_mode)
inline std::string to_str(error_mode mode)
      {
         switch (mode)
         {
            case e_unknown : return std::string("Unknown Error");
            case e_syntax  : return std::string("Syntax Error" );
            case e_token   : return std::string("Token Error"  );
            case e_numeric : return std::string("Numeric Error");
            case e_symtab  : return std::string("Symbol Error" );
            case e_lexer   : return std::string("Lexer Error"  );
            case e_helper  : return std::string("Helper Error" );
            case e_parser  : return std::string("Parser Error" );
            default        : return std::string("Unknown Error");
         }
      }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
cmpl $0x9, %esi
ja 0x3b1074
movl %esi, %eax
leaq 0x5a49(%rip), %rcx      # 0x3b6ab4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3a895(%rip), %rsi     # 0x3eb910
leaq 0x3a89b(%rip), %rdx     # 0x3eb91d
jmp 0x3b10f2
leaq 0x3a8c7(%rip), %rsi     # 0x3eb952
leaq 0x3a8cb(%rip), %rdx     # 0x3eb95d
jmp 0x3b10f2
leaq 0x3a883(%rip), %rsi     # 0x3eb91e
leaq 0x3a888(%rip), %rdx     # 0x3eb92a
jmp 0x3b10f2
leaq 0x3a8b3(%rip), %rsi     # 0x3eb95e
leaq 0x3a8b8(%rip), %rdx     # 0x3eb96a
jmp 0x3b10f2
leaq 0x3a8b0(%rip), %rsi     # 0x3eb96b
leaq 0x3a8b5(%rip), %rdx     # 0x3eb977
jmp 0x3b10f2
leaq 0x3a860(%rip), %rsi     # 0x3eb92b
leaq 0x3a864(%rip), %rdx     # 0x3eb936
jmp 0x3b10f2
leaq 0x3a85c(%rip), %rsi     # 0x3eb937
leaq 0x3a862(%rip), %rdx     # 0x3eb944
jmp 0x3b10f2
leaq 0x3a85a(%rip), %rsi     # 0x3eb945
leaq 0x3a85f(%rip), %rdx     # 0x3eb951
movq %rbx, %rdi
callq 0x1eabb8
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sorazy[P]canny/HashMap.cpp
// Function: HashMap::contains(int, int)
int HashMap::contains(int a, int b)
{
	Point *temp = new Point(a, b);
	int hash = this->hash(temp);

	for (int i = 0; this->table[hash % this->capacity] != NULL; i++)
	{
		temp = this->table[hash % this->capacity];
		if (temp->x == a && temp->y == b)
			return 1;
		else
			hash += 2 * i + 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edx, %ecx
leal 0x25(%rcx), %eax
leal (%rsi,%rsi,8), %edx
leal (%rsi,%rdx,2), %r8d
addl $0x5dd, %r8d            # imm = 0x5DD
imull %eax, %r8d
addl $0x19189, %r8d          # imm = 0x19189
movq (%rdi), %r9
movl 0xc(%rdi), %edi
movl %r8d, %eax
cltd
idivl %edi
movslq %edx, %rax
movq (%r9,%rax,8), %rdx
testq %rdx, %rdx
setne %al
je 0x3d88
xorl %r10d, %r10d
cmpl %esi, (%rdx)
jne 0x3d69
cmpl %ecx, 0x4(%rdx)
je 0x3d88
addl %r10d, %r8d
incl %r8d
movl %r8d, %eax
cltd
idivl %edi
movslq %edx, %rax
movq (%r9,%rax,8), %rdx
addl $0x2, %r10d
testq %rdx, %rdx
setne %al
jne 0x3d60
movzbl %al, %eax
andl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sorazy[P]canny/HashMap.cpp
// Function: HashMap::insert(int, int)
void HashMap::insert(int a, int b)
{
	// Disallow duplicates
	if (this->contains(a, b))
		return;

	Point *newPoint = new Point(a, b);
	int hash = this->hash(newPoint);

	if (this->size > this->capacity / 2)
		this->expand();

	for (int i = 0; this->table[hash % this->capacity] != NULL; i++)
		hash += 2 * i + 1;

	this->table[hash % this->capacity] = newPoint;
	this->size++;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %rbx
callq 0x3d20
testl %eax, %eax
jne 0x3e34
movl $0x8, %edi
callq 0x2180
movq %rax, %r14
movl %r15d, (%rax)
movl %r12d, 0x4(%rax)
addl $0x25, %r12d
leal (%r15,%r15,8), %eax
leal (%r15,%rax,2), %r15d
addl $0x5dd, %r15d           # imm = 0x5DD
imull %r12d, %r15d
addl $0x19189, %r15d         # imm = 0x19189
movl 0xc(%rbx), %eax
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
cmpl %ecx, 0x8(%rbx)
jle 0x3dfc
movq %rbx, %rdi
callq 0x3e3e
movq (%rbx), %rcx
movl 0xc(%rbx), %esi
movl %r15d, %eax
cltd
idivl %esi
movslq %edx, %rax
cmpq $0x0, (%rcx,%rax,8)
je 0x3e2d
xorl %edi, %edi
addl %edi, %r15d
incl %r15d
movl %r15d, %eax
cltd
idivl %esi
movslq %edx, %rax
addl $0x2, %edi
cmpq $0x0, (%rcx,%rax,8)
jne 0x3e14
movq %r14, (%rcx,%rax,8)
incl 0x8(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/sorazy[P]canny/HashMap.cpp
// Function: HashMap::expand()
void HashMap::expand(void)
{
	this->capacity = this->primes[++this->currentPrime];
	Point **newTable = new Point*[this->capacity];
	Point *temp;

	for (int i = 0; i < this->primes[this->currentPrime - 1]; i++)
	{
		temp = this->table[i];
		if (temp == NULL)
			continue; 

		int hash = this->hash(temp);

		newTable[hash % this->capacity] = temp;

	}

	this->table = newTable;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0x10(%rdi), %r15
leaq 0x1(%r15), %rax
movl %eax, 0x10(%rdi)
movslq 0x18(%rdi,%r15,4), %r14
leaq (,%r14,8), %rax
testq %r14, %r14
movl %r14d, 0xc(%rdi)
movq $-0x1, %rdi
cmovnsq %rax, %rdi
callq 0x2030
movq %rax, %rcx
movslq 0x14(%rbx,%r15,4), %rsi
testq %rsi, %rsi
jle 0x3ec8
movq (%rbx), %rdi
xorl %r8d, %r8d
movq (%rdi,%r8,8), %r9
testq %r9, %r9
je 0x3ec0
movl (%r9), %eax
movl 0x4(%r9), %edx
addl $0x25, %edx
leal (%rax,%rax,8), %r10d
leal (%rax,%r10,2), %eax
addl $0x5dd, %eax            # imm = 0x5DD
imull %edx, %eax
addl $0x19189, %eax          # imm = 0x19189
cltd
idivl %r14d
movslq %edx, %rax
movq %r9, (%rcx,%rax,8)
incq %r8
cmpq %r8, %rsi
jne 0x3e8d
movq %rcx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sorazy[P]canny/HashMap.cpp
// Function: HashMap::printTable()
void HashMap::printTable(void)
{
	Point *temp;

	for (int i = 0; i < this->size; i++)
	{
		temp = this->table[i];
		if (temp == NULL)
			cout << "NULL, ";
		else
			cout << "(" << temp->x << ", " << temp->y << "), ";
	}

	cout << endl << "size is : " << this->size << " and capacity: " << this->capacity << endl;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
jle 0x3f7a
xorl %r13d, %r13d
movq 0x30dd(%rip), %r14      # 0x6fd8
movq (%rbx), %rax
movq (%rax,%r13,8), %r15
testq %r15, %r15
je 0x3f5a
movl $0x1, %edx
movq %r14, %rdi
leaq 0x12e5(%rip), %rsi      # 0x51fb
callq 0x21b0
movl (%r15), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %r12
movl $0x2, %edx
movq %rax, %rdi
leaq 0x12c6(%rip), %rsi      # 0x51fe
callq 0x21b0
movl 0x4(%r15), %esi
movq %r12, %rdi
callq 0x2270
movl $0x3, %edx
movq %rax, %rdi
leaq 0x12a5(%rip), %rsi      # 0x51fd
jmp 0x3f69
movl $0x6, %edx
movq %r14, %rdi
leaq 0x128b(%rip), %rsi      # 0x51f4
callq 0x21b0
incq %r13
movslq 0x8(%rbx), %rax
cmpq %rax, %r13
jl 0x3efb
movq 0x3057(%rip), %r14      # 0x6fd8
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2040
movq %rax, %rdi
callq 0x2100
movq %rax, %r14
leaq 0x124f(%rip), %rsi      # 0x5201
movl $0xa, %edx
movq %rax, %rdi
callq 0x21b0
movl 0x8(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %r14
leaq 0x1238(%rip), %rsi      # 0x520c
movl $0xf, %edx
movq %rax, %rdi
callq 0x21b0
movl 0xc(%rbx), %esi
movq %r14, %rdi
callq 0x2270
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2100
// File: /workspace/github_cpp_makefile_star2_O1/onlyuser[P]Sandbox/test_c/c++0x/main.cpp
// Function: main
int main(int argc, char** argv)
{
    int x;

    // lvalue is a named reference
    printf("test 1\n");
    f(x);    // lvalue
    f(x+0);  // rvalue
    f(g());  // rvalue
    f(g2()); // lvalue
    f(3);    // rvalue

    // assigning rvalue to a variable automatically converts it to an lvalue (by giving it a name)
    printf("test 2\n");
    auto x2 = x;
    auto x3 = x+0;
    auto x4 = g();
    auto x5 = g2();
    auto x6 = 3;
    f(x2); // lvalue
    f(x3); // lvalue!!
    f(x4); // lvalue!!
    f(x5); // lvalue
    f(x6); // lvalue!!

    // std::move coerces lvalue to rvalue
    printf("test 3\n");
    f(std::move(x)); // rvalue

    // rvalue-ness is not necessarily preserved through a universal reference
    printf("test 4\n");
    f2(x);   // lvalue
    f2(g()); // lvalue!!

    // std::forward preserves rvalue-ness through a universal reference
    printf("test 5\n");
    f3(x);   // lvalue
    f3(g()); // rvalue

    return 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0xea8(%rip), %rdi       # 0x2012
callq 0x1030
leaq 0xe8e(%rip), %rbx       # 0x2004
movq %rbx, %rdi
callq 0x1030
leaq 0xe86(%rip), %r14       # 0x200b
movq %r14, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
leaq 0xe6d(%rip), %rdi       # 0x2019
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
leaq 0xe40(%rip), %rdi       # 0x2020
callq 0x1030
movq %r14, %rdi
callq 0x1030
leaq 0xe33(%rip), %rdi       # 0x2027
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %rbx, %rdi
callq 0x1030
leaq 0xe1e(%rip), %rdi       # 0x202e
callq 0x1030
movq %rbx, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq