LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::collect_variables<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool collect_variables(const std::string& expression,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef double T;
      typedef details::collector_helper<T> collect_t;

      collect_t::symbol_table_t null_symbol_table;

      std::set<std::string> symbol_set;

      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, true, false, false, null_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, true, false,  true, null_symbol_table);

      if (!variable_pass && !vector_pass)
         return false;

      std::set<std::string>::iterator itr = symbol_set.begin();

      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }

      return true;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0x19486e
leaq 0x18(%rsp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
movl %ebp, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2bf846
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x8(%rsp), %r9
movq %r14, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0x2bf846
orb %al, %bpl
je 0x2bd0b6
movq 0x28(%rsp), %r14
cmpq %r14, %r12
je 0x2bd0b6
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2a18b0
movq %r14, %rdi
callq 0x1184e0
movq %rax, %r14
jmp 0x2bd098
leaq 0x10(%rsp), %rdi
callq 0x195daa
leaq 0x8(%rsp), %rdi
callq 0x195790
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2bd0dd
jmp 0x2bd0dd
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x195daa
leaq 0x8(%rsp), %rdi
callq 0x195790
movq %rbx, %rdi
callq 0x118360
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::collect_functions<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::vector>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline bool collect_functions(const std::string& expression,
                                 Sequence<std::string, Allocator>& symbol_list)
   {
      typedef double T;
      typedef details::collector_helper<T> collect_t;

      collect_t::symbol_table_t null_symbol_table;

      std::set<std::string> symbol_set;

      const bool variable_pass = collect_t::collection_pass
                                    (expression, symbol_set, false, true, false, null_symbol_table);
      const bool vector_pass   = collect_t::collection_pass
                                    (expression, symbol_set, false, true,  true, null_symbol_table);

      if (!variable_pass && !vector_pass)
         return false;

      std::set<std::string>::iterator itr = symbol_set.begin();

      while (symbol_set.end() != itr)
      {
         symbol_list.push_back(*itr);
         ++itr;
      }

      return true;
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
pushq $0x1
popq %rbp
movq %r15, %rdi
movl %ebp, %esi
callq 0x19486e
leaq 0x18(%rsp), %r12
andl $0x0, (%r12)
andq $0x0, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
andq $0x0, 0x20(%r12)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
xorl %edx, %edx
movl %ebp, %ecx
xorl %r8d, %r8d
movq %r15, %r9
callq 0x2bf846
movl %eax, %ebp
leaq 0x10(%rsp), %rsi
pushq $0x1
popq %rcx
leaq 0x8(%rsp), %r9
movq %r14, %rdi
xorl %edx, %edx
movl %ecx, %r8d
callq 0x2bf846
orb %al, %bpl
je 0x2bd19b
movq 0x28(%rsp), %r14
cmpq %r14, %r12
je 0x2bd19b
leaq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x2a18b0
movq %r14, %rdi
callq 0x1184e0
movq %rax, %r14
jmp 0x2bd17d
leaq 0x10(%rsp), %rdi
callq 0x195daa
leaq 0x8(%rsp), %rdi
callq 0x195790
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2bd1c2
jmp 0x2bd1c2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x195daa
leaq 0x8(%rsp), %rdi
callq 0x195790
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::remove(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
inline bool remove(const std::string& symbol_name, const bool delete_node = true)
         {
            const tm_itr_t itr = map.find(symbol_name);

            if (map.end() != itr)
            {
               if (delete_node)
               {
                  deleter::process((*itr).second);
               }

               map.erase(itr);
               --size;

               return true;
            }
            else
               return false;
         }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rdi, %rbx
callq 0x196c6e
movq %rax, %r14
leaq 0x8(%rbx), %r15
cmpq %rax, %r15
je 0x2bd25a
testb %bpl, %bpl
je 0x2bd24b
leaq 0x40(%r14), %rdi
callq 0x196174
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2bd26c
decq 0x30(%rbx)
cmpq %r14, %r15
setne %al
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::replace_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool replace_symbol(const std::string& old_symbol, const std::string& new_symbol)
      {
         if (!settings_.replacer_enabled())
            return false;
         else if (details::is_reserved_word(old_symbol))
            return false;
         else
            return symbol_replacer_.add_replace(old_symbol,new_symbol,lexer::token::e_symbol);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
cmpb $0x1, 0xd0(%rdi)
jne 0x2c02b9
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2c037f
testb %al, %al
je 0x2c02c1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
addq $0x728, %r15            # imm = 0x728
pushq $0x8
popq %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x1a1c0e
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_reserved_word(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_reserved_word(const std::string& symbol)
      {
         for (std::size_t i = 0; i < reserved_words_size; ++i)
         {
            if (imatch(symbol, reserved_words[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1f6ff2(%rip), %r14    # 0x4b7380
xorl %ecx, %ecx
movq %rcx, %r15
cmpq $0x21, %rcx
je 0x2c03b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1fbcc5
leaq 0x1(%r15), %rcx
addq $0x20, %r14
testb %al, %al
je 0x2c0390
cmpq $0x21, %r15
setb %al
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_test.cpp
// Function: unsigned long load_expressions<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::deque>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::deque<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
inline std::size_t load_expressions(const std::string& file_name,
                                    Sequence<std::string,Allocator>& sequence)
{
   std::ifstream stream(file_name.c_str());

   if (!stream) return 0;

   std::string buffer;
   buffer.reserve(1024);

   std::size_t line_count = 0;

   while (std::getline(stream,(buffer)))
   {
      if (buffer.empty())
         continue;
      else if ('#' == buffer[0])
         continue;

      ++line_count;
      sequence.push_back(buffer);
   }

   return line_count;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x20(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x118050
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x40(%rsp,%rax)
je 0x2c082d
xorl %r14d, %r14d
jmp 0x2c0898
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x1183f0
xorl %r14d, %r14d
leaq 0x20(%rsp), %r15
movq %rsp, %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x1182a0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2c0890
cmpq $0x0, 0x8(%rsp)
je 0x2c0856
movq (%rsp), %rax
cmpb $0x23, (%rax)
je 0x2c0856
incq %r14
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2bdcaa
jmp 0x2c0856
movq %rsp, %rdi
callq 0x118648
leaq 0x20(%rsp), %rdi
callq 0x118040
movq %r14, %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x2c08b8
jmp 0x2c08b8
movq %rax, %rbx
movq %rsp, %rdi
callq 0x118648
leaq 0x20(%rsp), %rdi
callq 0x118040
movq %rbx, %rdi
callq 0x118360
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::all_true<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
      {
         if (2 == ps_index)
         {
            for (std::size_t i = 0; i < parameters.size(); ++i)
            {
               if (scalar_t(parameters[i])() == T(0))
               {
                  return T(0);
               }
            }
         }
         else
         {
            const vector_t vec(parameters[0]);

            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 std::numeric_limits<T>::quiet_NaN();
            }

            for (std::size_t i = r0; i <= r1; ++i)
            {
               if (vec[i] == T(0))
               {
                  return T(0);
               }
            }
         }

         return T(1);
      }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rsi), %rcx
cmpq $0x2, %rcx
jne 0x2c15b5
movq (%rdx), %rcx
movq 0x8(%rdx), %rax
subq %rcx, %rax
pushq $0x18
popq %rsi
cqto
idivq %rsi
incq %rax
movsd 0xcc2c(%rip), %xmm1     # 0x2ce1c0
xorpd %xmm0, %xmm0
decq %rax
je 0x2c1612
movq (%rcx), %rdx
addq $0x18, %rcx
movsd (%rdx), %xmm2
ucomisd %xmm0, %xmm2
jne 0x2c1598
jp 0x2c1598
jmp 0x2c1647
movq (%rdx), %rax
movq (%rax), %rbx
andq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, %rcx
jne 0x2c1618
leaq 0x28(%rsp), %rcx
movq $0x1, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x2, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c163f
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
jmp 0x2c161a
movapd %xmm1, %xmm0
jmp 0x2c1647
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
ja 0x2c1635
movsd (%rbx,%rcx,8), %xmm1
incq %rcx
ucomisd %xmm0, %xmm1
jne 0x2c161e
jp 0x2c161e
jmp 0x2c1647
movsd 0xcb83(%rip), %xmm0     # 0x2ce1c0
jmp 0x2c1647
movsd 0xcc79(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::helper::load_vector_range<double>::process(exprtk::type_store<double>::parameter_list&, unsigned long&, unsigned long&, unsigned long const&, unsigned long const&, unsigned long)
static inline bool process(parameter_list_t& parameters,
                                    std::size_t& r0, std::size_t& r1,
                                    const std::size_t& r0_prmidx,
                                    const std::size_t& r1_prmidx,
                                    const std::size_t vec_idx = 0)
         {
            if (r0_prmidx >= parameters.size())
               return false;

            if (r1_prmidx >= parameters.size())
               return false;

            if (!scalar_t(parameters[r0_prmidx]).to_uint(r0))
               return false;

            if (!scalar_t(parameters[r1_prmidx]).to_uint(r1))
               return false;

            return !invalid_range(vector_t(parameters[vec_idx]), r0, r1);
         }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rcx), %rsi
movq (%rdi), %rax
movq (%rax), %rdi
movq 0x8(%rax), %rax
subq %rdi, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
movq %rax, %rcx
xorl %eax, %eax
cmpq %rcx, %rsi
jae 0x2c1736
movq %r8, %r13
cmpq %rcx, (%r8)
jae 0x2c1736
movq %r9, %rbx
imulq $0x18, %rsi, %rax
movq (%rdi,%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r15, %rsi
callq 0x2c1744
testb %al, %al
je 0x2c1734
movq (%r12), %rax
imulq $0x18, (%r13), %rcx
movq (%rax), %rax
movq (%rax,%rcx), %rax
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
movq %r14, %rsi
callq 0x2c1744
testb %al, %al
je 0x2c1734
movq (%r12), %rax
movq (%rax), %rax
movq (%r15), %rcx
movq (%r14), %rdx
imulq $0x18, %rbx, %rsi
movq 0x8(%rax,%rsi), %rax
decq %rax
cmpq %rcx, %rax
setae %sil
cmpq %rdx, %rax
setae %dil
andb %sil, %dil
cmpq %rcx, %rdx
setae %al
andb %dil, %al
jmp 0x2c1736
xorl %eax, %eax
addq $0x10, %rsp
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::rtl::vecops::count<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
      {
         std::size_t cnt = 0;

         if (2 == ps_index)
         {
            for (std::size_t i = 0; i < parameters.size(); ++i)
            {
               if (scalar_t(parameters[i])() != T(0)) ++cnt;
            }
         }
         else
         {
            const vector_t vec(parameters[0]);

            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 std::numeric_limits<T>::quiet_NaN();
            }

            for (std::size_t i = r0; i <= r1; ++i)
            {
               if (vec[i] != T(0)) ++cnt;
            }
         }

         return T(cnt);
      }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rsi), %rcx
cmpq $0x2, %rcx
jne 0x2c1b15
movq (%rdx), %rsi
movq 0x8(%rdx), %rax
subq %rsi, %rax
pushq $0x18
popq %rcx
cqto
idivq %rcx
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
subq $0x1, %rax
jb 0x2c1b96
movq (%rsi), %rdx
movsd (%rdx), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rdx
subq %rdx, %rcx
addq $0x18, %rsi
jmp 0x2c1af1
movq (%rdx), %rax
movq (%rax), %rbx
andq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, %rcx
jne 0x2c1b72
leaq 0x28(%rsp), %rcx
movq $0x1, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x2, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c1bbd
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rax
jmp 0x2c1b74
xorl %edx, %edx
xorl %ecx, %ecx
xorpd %xmm0, %xmm0
cmpq %rax, %rdx
ja 0x2c1b96
movsd (%rbx,%rdx,8), %xmm1
cmpneqsd %xmm0, %xmm1
movq %xmm1, %rsi
subq %rsi, %rcx
incq %rdx
jmp 0x2c1b7a
movq %rcx, %xmm1
punpckldq 0xc46d(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xc475(%rip), %xmm1     # 0x2ce020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbx
retq
movsd 0xc6fb(%rip), %xmm0     # 0x2ce2c0
jmp 0x2c1bb7
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::copy<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t x(parameters[0]);
               vector_t y(parameters[(0 == ps_index) ? 1 : 3]);

         std::size_t xr0 = 0;
         std::size_t xr1 = x.size() - 1;

         std::size_t yr0 = 0;
         std::size_t yr1 = y.size() - 1;

         if (1 == ps_index)
         {
            if (
                 !helper::load_vector_range<T>::process(parameters, xr0, xr1, 1, 2, 0) ||
                 !helper::load_vector_range<T>::process(parameters, yr0, yr1, 4, 5, 3)
               )
               return T(0);
         }

         const std::size_t n = std::min(xr1 - xr0 + 1, yr1 - yr0 + 1);

         std::copy(
            x.begin() + xr0,
            x.begin() + xr0 + n,
            y.begin() + yr0);

         return T(n);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, 0x28(%rsp)
movq (%rdx), %rax
movq (%rax), %rbx
movq (%rsi), %rcx
leaq 0x48(%rax), %rdx
leaq 0x18(%rax), %rsi
testq %rcx, %rcx
cmoveq %rsi, %rdx
movq (%rdx), %r14
andq $0x0, 0x20(%rsp)
movq 0x8(%rax), %rax
leaq -0x1(%rax), %rsi
movq %rsi, 0x18(%rsp)
andq $0x0, 0x10(%rsp)
movq 0x8(%rdx), %r15
leaq -0x1(%r15), %rdx
movq %rdx, 0x8(%rsp)
cmpq $0x1, %rcx
jne 0x2c1cc2
leaq 0x48(%rsp), %rcx
movq $0x1, (%rcx)
leaq 0x40(%rsp), %r8
movq $0x2, (%r8)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x18(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c1d10
leaq 0x38(%rsp), %rcx
movq $0x4, (%rcx)
leaq 0x30(%rsp), %r8
movq $0x5, (%r8)
leaq 0x28(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
pushq $0x3
popq %r9
callq 0x2c1678
xorpd %xmm0, %xmm0
testb %al, %al
je 0x2c1d14
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %r15
movq 0x10(%rsp), %rcx
incq %rax
incq %r15
jmp 0x2c1cc6
xorl %ecx, %ecx
xorl %edx, %edx
subq %rdx, %rax
subq %rcx, %r15
cmpq %rax, %r15
cmovaeq %rax, %r15
testq %r15, %r15
je 0x2c1ced
leaq (%rbx,%rdx,8), %rsi
leaq (,%r15,8), %rdx
leaq (%r14,%rcx,8), %rdi
callq 0x118110
movq %r15, %xmm1
punpckldq 0xc316(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0xc31e(%rip), %xmm1     # 0x2ce020
movapd %xmm1, %xmm0
unpckhpd %xmm1, %xmm0            # xmm0 = xmm0[1],xmm1[1]
addsd %xmm1, %xmm0
jmp 0x2c1d14
xorpd %xmm0, %xmm0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::rol<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]);

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

         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);

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

         const std::size_t dist  = r1 - r0 + 1;
         const std::size_t shift = n % dist;

         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + shift,
            vec.begin() + r1 + 1);

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x20(%rsp)
movq (%rdx), %rcx
movq (%rcx), %r14
leaq 0x18(%rsp), %rax
andq $0x0, (%rax)
andq $0x0, 0x8(%rsp)
movq %rsi, %rbx
movq 0x8(%rcx), %r15
decq %r15
movq %r15, (%rsp)
movq 0x18(%rcx), %rcx
leaq 0x10(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x2c1744
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c1df7
cmpq $0x1, (%rbx)
jne 0x2c1dc5
leaq 0x10(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x28(%rsp), %r8
movq $0x3, (%r8)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
xorl %r9d, %r9d
callq 0x2c1678
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c1df7
movq (%rsp), %r15
movq 0x8(%rsp), %rcx
jmp 0x2c1dc7
xorl %ecx, %ecx
movq %r15, %rsi
subq %rcx, %rsi
incq %rsi
movq 0x18(%rsp), %rax
xorl %edx, %edx
divq %rsi
leaq (%r14,%rcx,8), %rdi
leaq (%rdi,%rdx,8), %rsi
leaq (%r14,%r15,8), %rdx
addq $0x8, %rdx
callq 0x2c1e01
movsd 0xc3c9(%rip), %xmm0     # 0x2ce1c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::reverse<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]);

         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);

         std::reverse(vec.begin() + r0, vec.begin() + r1 + 1);

         return T(1);
      }

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rdx), %rax
movq (%rax), %rbx
andq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c212c
leaq 0x28(%rsp), %rcx
movq $0x1, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x2, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c2147
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
jmp 0x2c212e
xorl %ecx, %ecx
leaq (%rbx,%rcx,8), %rdi
leaq (%rbx,%rax,8), %rsi
addq $0x8, %rsi
callq 0x2c214d
movsd 0xc079(%rip), %xmm0     # 0x2ce1c0
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::shift_left<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]);

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

         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);

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

         const std::size_t dist = r1 - r0 + 1;

         if (n > dist)
            return T(0);

         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + n,
            vec.begin() + r1 + 1);

         for (std::size_t i = r1 - n + 1ULL; i <= r1; ++i)
         {
            vec[i] = T(0);
         }

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x20(%rsp)
movq (%rdx), %rcx
movq (%rcx), %r14
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
andq $0x0, 0x8(%rsp)
movq %rsi, %rbx
movq 0x8(%rcx), %r15
decq %r15
movq %r15, (%rsp)
movq 0x18(%rcx), %rcx
leaq 0x18(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x2c1744
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c2273
cmpq $0x1, (%rbx)
jne 0x2c221d
leaq 0x18(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x28(%rsp), %r8
movq $0x3, (%r8)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c2270
movq (%rsp), %r15
movq 0x8(%rsp), %rax
xorps %xmm0, %xmm0
jmp 0x2c221f
xorl %eax, %eax
movq %r15, %rdx
subq %rax, %rdx
incq %rdx
movq 0x10(%rsp), %rcx
cmpq %rdx, %rcx
ja 0x2c2273
leaq (%r14,%rax,8), %rdi
leaq (%rdi,%rcx,8), %rsi
leaq (%r14,%r15,8), %rdx
addq $0x8, %rdx
callq 0x2c1e01
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
negq %rcx
addq %rax, %rcx
incq %rcx
movsd 0xbf5f(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c2273
andq $0x0, (%r14,%rcx,8)
incq %rcx
jmp 0x2c2261
xorps %xmm0, %xmm0
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::shift_right<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]);

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

         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);

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

         const std::size_t dist = r1 - r0 + 1;

         if (n > dist)
            return T(0);

         const std::size_t shift = (dist - (n % dist)) % dist;

         std::rotate(
            vec.begin() + r0,
            vec.begin() + r0 + shift,
            vec.begin() + r1 + 1);

         for (std::size_t i = r0; i < r0 + n; ++i)
         {
            vec[i] = T(0);
         }

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x20(%rsp)
movq (%rdx), %rcx
movq (%rcx), %r14
leaq 0x10(%rsp), %rax
andq $0x0, (%rax)
andq $0x0, (%rsp)
movq %rsi, %rbx
movq 0x8(%rcx), %r15
decq %r15
movq %r15, 0x8(%rsp)
movq 0x18(%rcx), %rcx
leaq 0x18(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x2c1744
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c2389
cmpq $0x1, (%rbx)
jne 0x2c2329
leaq 0x18(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x28(%rsp), %r8
movq $0x3, (%r8)
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c2386
movq 0x8(%rsp), %r15
movq (%rsp), %rcx
xorps %xmm0, %xmm0
jmp 0x2c232b
xorl %ecx, %ecx
movq %r15, %rsi
subq %rcx, %rsi
incq %rsi
movq 0x10(%rsp), %rax
cmpq %rsi, %rax
ja 0x2c2389
xorl %edx, %edx
divq %rsi
movq %rsi, %rax
subq %rdx, %rax
xorl %edx, %edx
divq %rsi
leaq (%r14,%rcx,8), %rdi
leaq (%rdi,%rdx,8), %rsi
leaq (%r14,%r15,8), %rdx
addq $0x8, %rdx
callq 0x2c1e01
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
addq %rax, %rcx
movsd 0xbe49(%rip), %xmm0     # 0x2ce1c0
cmpq %rcx, %rax
jae 0x2c2389
andq $0x0, (%r14,%rax,8)
incq %rax
jmp 0x2c2377
xorps %xmm0, %xmm0
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::nthelement<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]);

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

         if (!scalar_t(parameters[1]).to_uint(n))
            return T(0);

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

         std::nth_element(
            vec.begin() + r0,
            vec.begin() + r0 + n ,
            vec.begin() + r1 + 1);

         return T(1);
      }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x20(%rsp)
movq (%rdx), %rcx
movq (%rcx), %r14
leaq 0x18(%rsp), %rax
andq $0x0, (%rax)
andq $0x0, 0x8(%rsp)
movq %rsi, %rbx
movq 0x8(%rcx), %r15
decq %r15
movq %r15, (%rsp)
movq 0x18(%rcx), %rcx
leaq 0x10(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, %rsi
callq 0x2c1744
xorps %xmm0, %xmm0
testb %al, %al
je 0x2c2f6c
cmpq $0x1, (%rbx)
jne 0x2c2f3e
leaq 0x10(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x28(%rsp), %r8
movq $0x3, (%r8)
leaq 0x20(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c2f64
movq 0x8(%rsp), %rax
movq (%rsp), %r15
jmp 0x2c2f40
xorl %eax, %eax
leaq (%r14,%rax,8), %rdi
movq 0x18(%rsp), %rax
leaq (%rdi,%rax,8), %rsi
leaq (%r14,%r15,8), %rdx
addq $0x8, %rdx
callq 0x2c2f76
movsd 0xb25e(%rip), %xmm0     # 0x2ce1c0
jmp 0x2c2f6c
movsd 0xb354(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::assign<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         vector_t vec(parameters[0]);

         const T assign_value = scalar_t(parameters[1]);

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

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

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

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

         return T(1);
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, 0x20(%rsp)
movq (%rdx), %rcx
movq 0x18(%rcx), %rdi
movq (%rsi), %rax
cmpq $0x2, %rax
jne 0x2c336b
movq 0x8(%rdx), %rdx
movq -0x18(%rdx), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0xafda(%rip), %xmm0     # 0x2ce338
cvttsd2si %xmm0, %rbx
andq %rsi, %rbx
orq %rdx, %rbx
jmp 0x2c336e
pushq $0x1
popq %rbx
movq (%rcx), %r14
movsd (%rdi), %xmm1
andq $0x0, 0x10(%rsp)
movq 0x8(%rcx), %rcx
decq %rcx
movq %rcx, 0x8(%rsp)
decq %rax
cmpq $0x1, %rax
ja 0x2c33df
movsd %xmm1, 0x18(%rsp)
leaq 0x30(%rsp), %rcx
movq $0x2, (%rcx)
leaq 0x28(%rsp), %r8
movq $0x3, (%r8)
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
xorl %r9d, %r9d
callq 0x2c1678
xorpd %xmm0, %xmm0
testb %al, %al
je 0x2c33f9
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movsd 0x18(%rsp), %xmm1
jmp 0x2c33e1
xorl %eax, %eax
movsd 0xadd7(%rip), %xmm0     # 0x2ce1c0
cmpq %rcx, %rax
ja 0x2c33f9
movsd %xmm1, (%r14,%rax,8)
addq %rbx, %rax
jmp 0x2c33e9
addq $0x38, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::iota<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 start_value = (ps_index <= 1) ?
                               scalar_t(parameters[1]) :
                               scalar_t(parameters[3]) ;

         const T step_size = ((0 == ps_index) || (2 == ps_index)) ?
                             scalar_t(parameters.back())() :
                             T(1) ;

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

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

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

         return T(1);
      }

// Assembly:
pushq %rbx
subq $0x40, %rsp
movq %rdx, 0x28(%rsp)
movq (%rdx), %rax
movq (%rsi), %rcx
leaq 0x48(%rax), %rsi
leaq 0x18(%rax), %rdi
cmpq $0x2, %rcx
cmovbq %rdi, %rsi
movq (%rsi), %rsi
testq $-0x3, %rcx
jne 0x2c3452
movq 0x8(%rdx), %rdx
movq -0x18(%rdx), %rdx
movsd (%rdx), %xmm5
jmp 0x2c345a
movsd 0xad66(%rip), %xmm5     # 0x2ce1c0
movq (%rax), %rbx
movsd (%rsi), %xmm6
andq $0x0, 0x10(%rsp)
movq 0x8(%rax), %rax
decq %rax
movq %rax, 0x8(%rsp)
andq $-0x2, %rcx
cmpq $0x2, %rcx
jne 0x2c34d7
movsd %xmm6, 0x18(%rsp)
movsd %xmm5, 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 0x2c352b
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movsd 0x20(%rsp), %xmm5
movsd 0x18(%rsp), %xmm6
jmp 0x2c34d9
xorl %ecx, %ecx
leaq (%rbx,%rcx,8), %rdx
xorl %esi, %esi
movsd 0xacd9(%rip), %xmm0     # 0x2ce1c0
movq 0xab21(%rip), %xmm1     # 0x2ce010
movapd 0xab29(%rip), %xmm2     # 0x2ce020
leaq (%rcx,%rsi), %rdi
cmpq %rax, %rdi
ja 0x2c352b
movq %rsi, %xmm3
punpckldq %xmm1, %xmm3    # xmm3 = xmm3[0],xmm1[0],xmm3[1],xmm1[1]
subpd %xmm2, %xmm3
movapd %xmm3, %xmm4
unpckhpd %xmm3, %xmm4            # xmm4 = xmm4[1],xmm3[1]
addsd %xmm3, %xmm4
mulsd %xmm5, %xmm4
addsd %xmm6, %xmm4
movsd %xmm4, (%rdx,%rsi,8)
incq %rsi
jmp 0x2c34f7
addq $0x40, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::sumk<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         const vector_t vec(parameters[0]);

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

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

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

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

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

         return result;
      }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, 0x10(%rsp)
movq (%rdx), %rax
movq (%rsi), %rcx
cmpq $0x2, %rcx
jne 0x2c3589
movq 0x48(%rax), %rdx
movsd (%rdx), %xmm0
cvttsd2si %xmm0, %rdx
movq %rdx, %rsi
sarq $0x3f, %rsi
subsd 0xadbc(%rip), %xmm0     # 0x2ce338
cvttsd2si %xmm0, %rbx
andq %rsi, %rbx
orq %rdx, %rbx
jmp 0x2c358c
pushq $0x1
popq %rbx
movq (%rax), %r14
andq $0x0, 0x8(%rsp)
movq 0x8(%rax), %rax
decq %rax
movq %rax, (%rsp)
decq %rcx
cmpq $0x1, %rcx
ja 0x2c35e5
leaq 0x20(%rsp), %rcx
movq $0x1, (%rcx)
leaq 0x18(%rsp), %r8
movq $0x2, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
xorl %r9d, %r9d
callq 0x2c1678
testb %al, %al
je 0x2c361b
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
jmp 0x2c35e7
xorl %ecx, %ecx
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
cmpq %rax, %rcx
ja 0x2c3623
movsd (%r14,%rcx,8), %xmm2
subsd %xmm1, %xmm2
movapd %xmm0, %xmm3
addsd %xmm2, %xmm3
movapd %xmm3, %xmm1
subsd %xmm0, %xmm1
subsd %xmm2, %xmm1
addq %rbx, %rcx
movapd %xmm3, %xmm0
jmp 0x2c35ef
movsd 0xac9d(%rip), %xmm0     # 0x2ce2c0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, 0x18(%rsp)
movq (%rdx), %r15
movq 0x18(%r15), %rbx
movq 0x30(%r15), %r14
andq $0x0, 0x10(%rsp)
movq 0x20(%r15), %rax
movq 0x38(%r15), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c36c2
leaq 0x28(%rsp), %rcx
movq $0x3, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x4, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %r9
callq 0x2c1678
testb %al, %al
je 0x2c3714
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x38(%r15), %rdx
jmp 0x2c36c4
xorl %ecx, %ecx
movsd 0xabf4(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c371c
decq %rdx
cmpq %rcx, %rdx
jb 0x2c371c
cmpq %rax, %rdx
jb 0x2c371c
movq 0x18(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rdx
movsd (%rdx), %xmm1
movsd 0xaacb(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c371c
movsd (%rbx,%rcx,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r14,%rcx,8), %xmm2
movsd %xmm2, (%r14,%rcx,8)
incq %rcx
jmp 0x2c36f5
movsd 0xaba4(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %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
movq 0x50(%r15), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c37bc
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 0x2c381e
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x50(%r15), %rdx
jmp 0x2c37be
xorl %ecx, %ecx
movsd 0xaafa(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3826
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3826
cmpq %rax, %rdx
jb 0x2c3826
movq 0x18(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rsi
movq 0x30(%rdx), %rdx
movsd (%rsi), %xmm1
movsd (%rdx), %xmm2
movsd 0xa9c9(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c3826
movsd (%r14,%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 0x2c37f7
movsd 0xaa9a(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::rtl::vecops::axpyz<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[2]);
               vector_t z(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();
         else if (helper::invalid_range(z, 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)
         {
            z[i] = (a * x[i]) + y[i];
         }

         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 0x30(%r12), %r14
movq 0x48(%r12), %r15
andq $0x0, 0x8(%rsp)
movq 0x20(%r12), %rax
movq 0x38(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, (%rsp)
cmpq $0x1, (%rsi)
jne 0x2c38ce
leaq 0x20(%rsp), %rcx
movq $0x4, (%rcx)
leaq 0x18(%rsp), %r8
movq $0x5, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
pushq $0x1
popq %r9
callq 0x2c1678
testb %al, %al
je 0x2c392d
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq 0x38(%r12), %rdx
jmp 0x2c38d0
xorl %ecx, %ecx
movsd 0xa9e8(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3935
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3935
cmpq %rax, %rdx
jb 0x2c3935
movq 0x50(%r12), %rdx
decq %rdx
cmpq %rax, %rdx
jb 0x2c3935
movq 0x10(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rdx
movsd (%rdx), %xmm1
movsd 0xa8b2(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c3935
movsd (%rbx,%rcx,8), %xmm2
mulsd %xmm1, %xmm2
addsd (%r14,%rcx,8), %xmm2
movsd %xmm2, (%r15,%rcx,8)
incq %rcx
jmp 0x2c390e
movsd 0xa98b(%rip), %xmm0     # 0x2ce2c0
addq $0x28, %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::vecops::axpbyz<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[3]);
               vector_t z(parameters[4]);

         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, 5, 6, 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])();

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

         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 0x48(%r12), %r14
movq 0x60(%r12), %r15
andq $0x0, 0x8(%rsp)
movq 0x20(%r12), %rax
movq 0x50(%r12), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, (%rsp)
cmpq $0x1, (%rsi)
jne 0x2c39e0
leaq 0x20(%rsp), %rcx
movq $0x5, (%rcx)
leaq 0x18(%rsp), %r8
movq $0x6, (%r8)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
pushq $0x1
popq %r9
callq 0x2c1678
testb %al, %al
je 0x2c3a4f
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq 0x50(%r12), %rdx
jmp 0x2c39e2
xorl %ecx, %ecx
movsd 0xa8d6(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3a57
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3a57
cmpq %rax, %rdx
jb 0x2c3a57
movq 0x68(%r12), %rdx
decq %rdx
cmpq %rax, %rdx
jb 0x2c3a57
movq 0x10(%rsp), %rdx
movq (%rdx), %rdx
movq (%rdx), %rsi
movq 0x30(%rdx), %rdx
movsd (%rsi), %xmm1
movsd (%rdx), %xmm2
movsd 0xa798(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c3a57
movsd (%r14,%rcx,8), %xmm3
mulsd %xmm2, %xmm3
movsd (%rbx,%rcx,8), %xmm4
mulsd %xmm1, %xmm4
addsd %xmm3, %xmm4
movsd %xmm4, (%r15,%rcx,8)
incq %rcx
jmp 0x2c3a28
movsd 0xa869(%rip), %xmm0     # 0x2ce2c0
addq $0x28, %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::vecops::axpbsy<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[4]);

         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, 5, 6, 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])();

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

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

         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 0x60(%r15), %r14
andq $0x0, 0x10(%rsp)
movq 0x20(%r15), %rax
movq 0x68(%r15), %rdx
cmpq %rax, %rdx
cmovbq %rdx, %rax
decq %rax
movq %rax, 0x8(%rsp)
cmpq $0x1, (%rsi)
jne 0x2c3afe
leaq 0x28(%rsp), %rcx
movq $0x5, (%rcx)
leaq 0x20(%rsp), %r8
movq $0x6, (%r8)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x8(%rsp), %rdx
pushq $0x1
popq %r9
callq 0x2c1678
testb %al, %al
je 0x2c3b8e
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x68(%r15), %rdx
jmp 0x2c3b00
xorl %ecx, %ecx
movsd 0xa7b8(%rip), %xmm0     # 0x2ce2c0
cmpq %rcx, %rax
jb 0x2c3b96
decq %rdx
cmpq %rcx, %rdx
jb 0x2c3b96
cmpq %rax, %rdx
jb 0x2c3b96
movq 0x18(%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 0xa7e7(%rip), %xmm0     # 0x2ce338
cvttsd2si %xmm0, %rdi
andq %rsi, %rdi
orq %rdx, %rdi
leaq (%r14,%rdi,8), %rdx
movsd 0xa658(%rip), %xmm0     # 0x2ce1c0
cmpq %rax, %rcx
ja 0x2c3b96
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 0x2c3b68
movsd 0xa72a(%rip), %xmm0     # 0x2ce2c0
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq