LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::parser<double>::dependent_entity_collector::symbols<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>>&)
inline std::size_t symbols(Sequence<symbol_t,Allocator>& symbols_list)
         {
            if (!collect_variables_ && !collect_functions_)
               return 0;
            else if (symbol_name_list_.empty())
               return 0;

            for (std::size_t i = 0; i < symbol_name_list_.size(); ++i)
            {
               details::case_normalise(symbol_name_list_[i].first);
            }

            std::sort(symbol_name_list_.begin(), symbol_name_list_.end());

            std::unique_copy
            (
               symbol_name_list_.begin(),
               symbol_name_list_.end  (),
               std::back_inserter(symbols_list)
            );

            return symbols_list.size();
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0x8(%rax)
jne 0x565807
movq 0x10(%rsp), %rax
testb $0x1, 0x9(%rax)
jne 0x565807
movq $0x0, 0x60(%rsp)
jmp 0x565916
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x56b400
testb $0x1, %al
jne 0x56581b
jmp 0x565829
movq $0x0, 0x60(%rsp)
jmp 0x565916
jmp 0x56582b
movq $0x0, 0x48(%rsp)
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x10, %rdi
callq 0x39eef0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x565884
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq 0x48(%rsp), %rsi
callq 0x56b4d0
movq %rax, %rdi
callq 0x56b450
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x565834
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x39ee00
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x10, %rdi
callq 0x39ebe0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x56b4f0
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x39ee00
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x10, %rdi
callq 0x39ebe0
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x56b5c0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x56b530
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x565a70
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::parser<double>::dependent_entity_collector::assignment_symbols<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>>&)
inline std::size_t assignment_symbols(Sequence<symbol_t,Allocator>& assignment_list)
         {
            if (!collect_assignments_)
               return 0;
            else if (assignment_name_list_.empty())
               return 0;

            for (std::size_t i = 0; i < assignment_name_list_.size(); ++i)
            {
               details::case_normalise(assignment_name_list_[i].first);
            }

            std::sort(assignment_name_list_.begin(),assignment_name_list_.end());

            std::unique_copy
            (
               assignment_name_list_.begin(),
               assignment_name_list_.end  (),
               std::back_inserter(assignment_list)
            );

            return assignment_list.size();
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, 0xa(%rax)
jne 0x565bfc
movq $0x0, 0x60(%rsp)
jmp 0x565d0b
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x56b400
testb $0x1, %al
jne 0x565c10
jmp 0x565c1e
movq $0x0, 0x60(%rsp)
jmp 0x565d0b
jmp 0x565c20
movq $0x0, 0x48(%rsp)
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x28, %rdi
callq 0x39eef0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x565c79
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
movq 0x48(%rsp), %rsi
callq 0x56b4d0
movq %rax, %rdi
callq 0x56b450
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x565c29
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x39ee00
movq 0x10(%rsp), %rdi
movq %rax, 0x40(%rsp)
addq $0x28, %rdi
callq 0x39ebe0
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x56b4f0
movq 0x10(%rsp), %rdi
addq $0x28, %rdi
callq 0x39ee00
movq 0x10(%rsp), %rdi
movq %rax, 0x30(%rsp)
addq $0x28, %rdi
callq 0x39ebe0
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rdi
callq 0x56b5c0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x56b530
movq %rax, 0x18(%rsp)
movq 0x50(%rsp), %rdi
callq 0x565a70
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::operator=(exprtk::symbol_table<double> const&)
inline symbol_table<T>& operator=(const symbol_table<T>& st)
      {
         if (this != &st)
         {
            control_block::destroy(control_block_,reinterpret_cast<symbol_table<T>*>(0));

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

         return (*this);
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq 0x8(%rsp), %rax
je 0x565d67
movq (%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x55ccb0
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
movq (%rax), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x1, %esi
movl %esi, 0x24(%rsp)
callq 0x22de90
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x230300
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %edx
movq 0x28(%rsp), %r9
movq 0xa8(%rsp), %rdi
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x56e4f0
movb %al, 0x37(%rsp)
jmp 0x565dd8
movb 0x37(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
xorl %ecx, %ecx
movl $0x1, %r8d
leaq 0x98(%rsp), %r9
movl %r8d, %edx
callq 0x56e4f0
movb %al, 0x17(%rsp)
jmp 0x565e0d
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x53(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x565e64
testb $0x1, 0x53(%rsp)
jne 0x565e64
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x4c(%rsp)
jmp 0x565ed9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2303e0
leaq 0x98(%rsp), %rdi
callq 0x22fc60
jmp 0x565f01
leaq 0x68(%rsp), %rdi
callq 0x56e890
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x234410
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2343f0
testb $0x1, %al
jne 0x565e97
jmp 0x565ec9
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x56e8c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x51d420
jmp 0x565ebd
leaq 0x40(%rsp), %rdi
callq 0x56e8e0
jmp 0x565e73
movb $0x1, 0xb7(%rsp)
movl $0x1, 0x4c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2303e0
leaq 0x98(%rsp), %rdi
callq 0x22fc60
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: 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:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq %rsi, 0xa0(%rsp)
leaq 0x98(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movl $0x1, %esi
movl %esi, 0x24(%rsp)
callq 0x22de90
leaq 0x68(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x230300
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %ecx
movq 0x28(%rsp), %r9
movq 0xa8(%rsp), %rdi
xorl %r8d, %r8d
movl %r8d, %edx
callq 0x56e4f0
movb %al, 0x37(%rsp)
jmp 0x565f78
movb 0x37(%rsp), %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movq 0xa8(%rsp), %rdi
leaq 0x68(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %r8d
leaq 0x98(%rsp), %r9
movl %r8d, %ecx
callq 0x56e4f0
movb %al, 0x17(%rsp)
jmp 0x565fad
movb 0x17(%rsp), %al
andb $0x1, %al
movb %al, 0x53(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x566004
testb $0x1, 0x53(%rsp)
jne 0x566004
movb $0x0, 0xb7(%rsp)
movl $0x1, 0x4c(%rsp)
jmp 0x566079
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x58(%rsp)
movl %eax, 0x54(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2303e0
leaq 0x98(%rsp), %rdi
callq 0x22fc60
jmp 0x5660a1
leaq 0x68(%rsp), %rdi
callq 0x56e890
movq %rax, 0x40(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x234410
movq %rax, 0x38(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x2343f0
testb $0x1, %al
jne 0x566037
jmp 0x566069
movq 0xa0(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x56e8c0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x51d420
jmp 0x56605d
leaq 0x40(%rsp), %rdi
callq 0x56e8e0
jmp 0x566013
movb $0x1, 0xb7(%rsp)
movl $0x1, 0x4c(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x2303e0
leaq 0x98(%rsp), %rdi
callq 0x22fc60
movb 0xb7(%rsp), %al
andb $0x1, %al
addq $0xb8, %rsp
retq
movq 0x58(%rsp), %rdi
callq 0x11b4e0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movb %dl, %al
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x30(%rsp), %rsi
callq 0x235a10
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
callq 0x232f70
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x232fa0
testb $0x1, %al
jne 0x566231
jmp 0x566285
testb $0x1, 0x2f(%rsp)
je 0x56624e
leaq 0x20(%rsp), %rdi
callq 0x233000
movq %rax, %rdi
addq $0x20, %rdi
callq 0x232fc0
movq (%rsp), %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x5662a0
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rsp)
movq 0x30(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x30(%rax)
movb $0x1, 0x47(%rsp)
jmp 0x56628a
movb $0x0, 0x47(%rsp)
movb 0x47(%rsp), %al
andb $0x1, %al
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_stringvar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline stringvar_ptr get_stringvar(const std::string& string_name) const
      {
         if (!valid())
            return reinterpret_cast<stringvar_ptr>(0);
         else if (!valid_symbol(string_name))
            return reinterpret_cast<stringvar_ptr>(0);
         else
            return local_data().stringvar_store.get(string_name);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x56656c
movq $0x0, 0x20(%rsp)
jmp 0x5665b2
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x56658f
movq $0x0, 0x20(%rsp)
jmp 0x5665b2
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x10(%rsp), %rsi
callq 0x52f170
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::get_list<std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>>, std::deque>(std::deque<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, double>>>&) const
inline std::size_t get_list(Sequence<std::pair<std::string,RawType>,Allocator>& list) const
         {
            std::size_t count = 0;

            if (!map.empty())
            {
               tm_const_itr_t itr = map.begin();
               tm_const_itr_t end = map.end  ();

               while (end != itr)
               {
                  list.push_back(std::make_pair((*itr).first,itr->second.second->ref()));
                  ++itr;
                  ++count;
               }
            }

            return count;
         }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
movq $0x0, 0x70(%rsp)
callq 0x232f20
testb $0x1, %al
jne 0x566fc7
movq 0x20(%rsp), %rdi
callq 0x3eb840
movq 0x20(%rsp), %rdi
movq %rax, 0x68(%rsp)
callq 0x234890
movq %rax, 0x60(%rsp)
leaq 0x60(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x234870
testb $0x1, %al
jne 0x566f2d
jmp 0x566fc5
movq 0x78(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x68(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x52d270
movq (%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x3eb870
movq 0x28(%rax), %rdi
callq 0x235f80
movq 0x8(%rsp), %rsi
movq %rax, %rdx
leaq 0x38(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x567010
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x566fe0
jmp 0x566f84
leaq 0x38(%rsp), %rdi
callq 0x137400
leaq 0x68(%rsp), %rdi
callq 0x3eb890
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
jmp 0x566f15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x137400
jmp 0x566fd4
jmp 0x566fc7
movq 0x70(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: unsigned long exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::get_list<std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::deque>(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>>>>&) const
inline std::size_t get_list(Sequence<std::string,Allocator>& vlist) const
         {
            std::size_t count = 0;

            if (!map.empty())
            {
               tm_const_itr_t itr = map.begin();
               tm_const_itr_t end = map.end  ();

               while (end != itr)
               {
                  vlist.push_back((*itr).first);
                  ++itr;
                  ++count;
               }
            }

            return count;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq $0x0, 0x20(%rsp)
callq 0x232f20
testb $0x1, %al
jne 0x5685a8
movq 0x8(%rsp), %rdi
callq 0x3eb840
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x234890
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x234870
testb $0x1, %al
jne 0x56856d
jmp 0x5685a6
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x52d270
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x5685c0
leaq 0x18(%rsp), %rdi
callq 0x3eb890
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x568558
jmp 0x5685a8
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::enable_unknown_symbol_resolver(exprtk::parser<double>::unknown_symbol_resolver*)
inline void enable_unknown_symbol_resolver(unknown_symbol_resolver* usr = reinterpret_cast<unknown_symbol_resolver*>(0))
      {
         resolve_unknown_symbol_ = true;

         if (usr)
            unknown_symbol_resolver_ = usr;
         else
            unknown_symbol_resolver_ = &default_usr_;
      }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movb $0x1, 0x3c8(%rax)
cmpq $0x0, -0x10(%rsp)
je 0x56e986
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movq %rcx, 0x3d8(%rax)
jmp 0x56e99c
movq -0x18(%rsp), %rax
movq %rax, %rcx
addq $0x3e0, %rcx            # imm = 0x3E0
movq %rcx, 0x3d8(%rax)
retq
nopl (%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
addq $0xd0, %rdi
callq 0x25ec50
testb $0x1, %al
jne 0x570563
movb $0x0, 0x27(%rsp)
jmp 0x57059f
movq 0x10(%rsp), %rdi
callq 0x5707b0
testb $0x1, %al
jne 0x570573
jmp 0x57057a
movb $0x0, 0x27(%rsp)
jmp 0x57059f
movq (%rsp), %rdi
addq $0x728, %rdi            # imm = 0x728
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl $0x8, %ecx
callq 0x25ec80
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_reserved_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::ifunction<double>&)
inline bool add_reserved_function(const std::string& function_name, function_t& function)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(function_name,false))
            return false;
         else if (symbol_exists(function_name,false))
            return false;
         else
            return local_data().function_store.add(function_name,function);
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x5705fc
movb $0x0, 0x27(%rsp)
jmp 0x57065b
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x570617
movb $0x0, 0x27(%rsp)
jmp 0x57065b
movq (%rsp), %rdi
movq 0x10(%rsp), %rsi
xorl %edx, %edx
callq 0x234050
testb $0x1, %al
jne 0x57062d
jmp 0x570634
movb $0x0, 0x27(%rsp)
jmp 0x57065b
movq (%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rdx
xorl %ecx, %ecx
callq 0x23b360
andb $0x1, %al
movb %al, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::disable_base_function(exprtk::parser<double>::settings_store::settings_base_funcs)
settings_store& disable_base_function(const settings_base_funcs bf)
         {
            if (
                 (e_bf_unknown != bf) &&
                 (static_cast<std::size_t>(bf) < (details::base_function_list_size + 1))
               )
            {
               disabled_func_set_.insert(details::base_function_list[bf - 1]);
            }

            return (*this);
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x1c(%rsp), %eax
je 0x5706c5
movl 0x1c(%rsp), %eax
cmpq $0x3b, %rax
jae 0x5706c5
movq (%rsp), %rdi
addq $0x10, %rdi
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x263d00(%rip), %rsi    # 0x7d43b0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x260ef0
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x21, (%rsp)
jae 0x570801
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
leaq 0x262c98(%rip), %rsi    # 0x7d3470
shlq $0x5, %rax
addq %rax, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x5707ea
jmp 0x5707f1
movb $0x1, 0x17(%rsp)
jmp 0x570806
jmp 0x5707f3
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x5707c1
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x288, %rsp            # imm = 0x288
movq %rdi, 0x278(%rsp)
movq %rsi, 0x270(%rsp)
movq 0x278(%rsp), %rdi
callq 0x11b120
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
movl $0x8, %edx
callq 0x11b080
movq 0x68(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x68(%rsp,%rax), %rdi
callq 0x11b060
movb %al, 0x2f(%rsp)
jmp 0x570fef
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x570ff9
jmp 0x571025
movq $0x0, 0x280(%rsp)
movl $0x1, 0x58(%rsp)
jmp 0x57112c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
jmp 0x571146
leaq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x11b2b0
movq 0x20(%rsp), %rdi
movl $0x400, %esi            # imm = 0x400
callq 0x11b5a0
jmp 0x571045
movq $0x0, 0x30(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x11b400
movq %rax, 0x18(%rsp)
jmp 0x571064
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x11b2f0
movb %al, 0x17(%rsp)
jmp 0x57107e
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x57108b
jmp 0x57110d
leaq 0x38(%rsp), %rdi
callq 0x11b260
testb $0x1, %al
jne 0x57109b
jmp 0x5710ba
jmp 0x57104e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11b838
jmp 0x571146
xorl %eax, %eax
movl %eax, %esi
leaq 0x38(%rsp), %rdi
callq 0x11b7a0
movq %rax, 0x8(%rsp)
jmp 0x5710cf
movq 0x8(%rsp), %rax
movsbl (%rax), %ecx
movl $0x23, %eax
cmpl %ecx, %eax
jne 0x5710e5
jmp 0x57104e
jmp 0x5710e7
movq 0x30(%rsp), %rax
incq %rax
movq %rax, 0x30(%rsp)
movq 0x270(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x5685c0
jmp 0x571108
jmp 0x57104e
movq 0x30(%rsp), %rax
movq %rax, 0x280(%rsp)
movl $0x1, 0x58(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x11b838
leaq 0x68(%rsp), %rdi
callq 0x11b070
movq 0x280(%rsp), %rax
addq $0x288, %rsp            # imm = 0x288
retq
leaq 0x68(%rsp), %rdi
callq 0x11b070
movq 0x60(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdx, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq 0x68(%rsp), %rcx
movl $0x2, %eax
cmpq (%rcx), %rax
jne 0x572be0
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x572dc0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x572bdb
leaq 0x78(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x572e10
leaq 0x58(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x572bc9
jp 0x572bc9
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
jmp 0x572cf2
jmp 0x572bcb
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
jmp 0x572b62
jmp 0x572ce1
movq $0x0, 0x40(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x38(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x30(%rsp)
movq 0x68(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0xf(%rsp)
jne 0x572c71
movq $0x1, 0x28(%rsp)
movq $0x2, 0x20(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x38(%rsp), %rsi
leaq 0x30(%rsp), %rdx
leaq 0x28(%rsp), %rcx
leaq 0x20(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x572c7b
jmp 0x572c8b
callq 0x2361c0
movsd %xmm0, 0x80(%rsp)
jmp 0x572cf2
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x30(%rsp), %rax
ja 0x572cdf
leaq 0x48(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x572ccd
jp 0x572ccd
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
jmp 0x572cf2
jmp 0x572ccf
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x572c95
jmp 0x572ce1
movsd 0x28357(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x80(%rsp)
movsd 0x80(%rsp), %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq %r9, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rdi
callq 0x572dc0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jb 0x572ee0
movb $0x0, 0x67(%rsp)
jmp 0x572fbe
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x58(%rsp), %rdi
callq 0x572dc0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jb 0x572f0c
movb $0x0, 0x67(%rsp)
jmp 0x572fbe
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x572e10
movq 0x50(%rsp), %rsi
leaq 0x28(%rsp), %rdi
callq 0x573000
xorb $-0x1, %al
testb $0x1, %al
jne 0x572f3f
jmp 0x572f46
movb $0x0, 0x67(%rsp)
jmp 0x572fbe
movq 0x58(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x20(%rsp), %rdi
callq 0x572e10
movq 0x48(%rsp), %rsi
leaq 0x20(%rsp), %rdi
callq 0x573000
xorb $-0x1, %al
testb $0x1, %al
jne 0x572f79
jmp 0x572f80
movb $0x0, 0x67(%rsp)
jmp 0x572fbe
movq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x572e40
movq 0x50(%rsp), %rax
movq (%rax), %rsi
movq 0x48(%rsp), %rax
movq (%rax), %rdx
leaq 0x10(%rsp), %rdi
callq 0x5730a0
xorb $-0x1, %al
andb $0x1, %al
movb %al, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::type_store<double>::scalar_view::to_uint<unsigned long>(unsigned long&) const
inline bool to_uint(UIntType& u) const
         {
            if (v_ < T(0))
               return false;
            else if (!exprtk::details::numeric::is_integer(v_))
               return false;

            u = static_cast<UIntType>(v_);

            return true;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq (%rax), %rax
xorps %xmm0, %xmm0
ucomisd (%rax), %xmm0
jbe 0x57302b
movb $0x0, 0x27(%rsp)
jmp 0x573088
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
callq 0x287ab0
testb $0x1, %al
jne 0x573047
movb $0x0, 0x27(%rsp)
jmp 0x573088
jmp 0x573049
movq 0x8(%rsp), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movsd 0x28103(%rip), %xmm2    # 0x59b160
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rax
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
andq %rdx, %rax
orq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movb $0x1, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::rtl::vecops::helper::invalid_range<exprtk::type_store<double>::type_view<double>>(exprtk::type_store<double>::type_view<double> const&, unsigned long, unsigned long)
inline bool invalid_range(const Vector& v, const std::size_t r0, const std::size_t r1)
      {
         if (r0 > (v.size() - 1))
            return true;
         else if (r1 > (v.size() - 1))
            return true;
         else if (r1 < r0)
            return true;
         else
            return false;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x572e70
movq %rax, %rcx
movq 0x10(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x5730df
movb $0x1, 0x37(%rsp)
jmp 0x573123
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x572e70
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jbe 0x57310b
movb $0x1, 0x37(%rsp)
jmp 0x573123
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jae 0x57311e
movb $0x1, 0x37(%rsp)
jmp 0x573123
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x98, %rsp
movq %rdx, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq $0x0, 0x60(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x68(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x48(%rsp)
movq $0x1, 0x38(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
callq 0x572e10
leaq 0x40(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x573000
xorb $-0x1, %al
testb $0x1, %al
jne 0x573ec8
jmp 0x573ed9
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x573fea
movq 0x78(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x17(%rsp)
jne 0x573f2c
movq $0x2, 0x30(%rsp)
movq $0x3, 0x28(%rsp)
leaq 0x88(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x573f36
jmp 0x573f47
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x573fea
movq 0x48(%rsp), %rax
subq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x20(%rsp)
movq %rdx, 0x18(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x573ca0
movq 0x50(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x68(%rsp), %rdi
callq 0x573ca0
movq 0x50(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x573ca0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x48(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
addq $0x8, %rdx
callq 0x574000
movsd 0x2705f(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x90(%rsp)
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rdx, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x28(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0xf(%rsp)
jne 0x5747e4
movq $0x1, 0x18(%rsp)
movq $0x2, 0x10(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x20(%rsp), %rdx
leaq 0x18(%rsp), %rcx
leaq 0x10(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x5747ee
jmp 0x5747f9
xorps %xmm0, %xmm0
movsd %xmm0, 0x60(%rsp)
jmp 0x574847
leaq 0x38(%rsp), %rdi
callq 0x573ca0
movq 0x28(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
callq 0x573ca0
movq (%rsp), %rdi
movq %rax, %rsi
movq 0x20(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
addq $0x8, %rsi
callq 0x574860
movsd 0x267ff(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x60(%rsp)
movsd 0x60(%rsp), %xmm0
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdx, 0x78(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
callq 0x572e40
movq $0x0, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x38(%rsp)
movq $0x1, 0x28(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x30(%rsp), %rdi
callq 0x572e10
leaq 0x30(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x573000
xorb $-0x1, %al
testb $0x1, %al
jne 0x576cbc
jmp 0x576ccd
xorps %xmm0, %xmm0
movsd %xmm0, 0x80(%rsp)
jmp 0x576db4
movq 0x68(%rsp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq (%rdx), %rcx
movb %al, 0x17(%rsp)
jne 0x576d1d
movq $0x2, 0x20(%rsp)
movq $0x3, 0x18(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x20(%rsp), %rcx
leaq 0x18(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
testb $0x1, %al
jne 0x576d27
jmp 0x576d37
callq 0x2361c0
movsd %xmm0, 0x80(%rsp)
jmp 0x576db4
leaq 0x58(%rsp), %rdi
callq 0x573ca0
movq 0x40(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, (%rsp)
leaq 0x58(%rsp), %rdi
callq 0x573ca0
movq 0x40(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq 0x48(%rsp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x573ca0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq %rax, %rdx
movq 0x38(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdx
addq $0x8, %rdx
callq 0x576dd0
movsd 0x24295(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0x80(%rsp)
movsd 0x80(%rsp), %xmm0
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x572e40
movq $0x1, 0x58(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
callq 0x572e10
leaq 0x60(%rsp), %rdi
callq 0x5779a0
movsd %xmm0, 0x68(%rsp)
movq 0x88(%rsp), %rcx
movl $0x2, %eax
cmpq (%rcx), %rax
je 0x57783d
movl $0x1, %eax
movq %rax, 0x18(%rsp)
jmp 0x577895
leaq 0x98(%rsp), %rdi
callq 0x5779c0
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x572e10
movq 0x10(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd 0x238ee(%rip), %xmm2    # 0x59b160
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x50(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x38(%rsp)
movq 0x88(%rsp), %rax
cmpq $0x1, (%rax)
je 0x5778dd
movq 0x88(%rsp), %rcx
xorl %eax, %eax
cmpq $0x2, (%rcx)
movb %al, 0xf(%rsp)
jne 0x57791b
movq $0x2, 0x30(%rsp)
movq $0x3, 0x28(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x38(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x577925
jmp 0x577933
xorps %xmm0, %xmm0
movsd %xmm0, 0xa0(%rsp)
jmp 0x57798e
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
ja 0x57797d
movsd 0x68(%rsp), %xmm0
movsd %xmm0, (%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x574b60
movsd (%rsp), %xmm0
movsd %xmm0, (%rax)
movq 0x50(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x57793d
movsd 0x236bb(%rip), %xmm0    # 0x59b040
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nop
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq $0x0, 0x70(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x78(%rsp), %rdi
callq 0x572e40
movq 0x88(%rsp), %rcx
movl $0x2, %eax
cmpq (%rcx), %rax
je 0x577db5
movl $0x1, %eax
movq %rax, 0x18(%rsp)
jmp 0x577e1b
movq $0x3, 0x58(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x60(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x572e10
movq 0x10(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd 0x23368(%rip), %xmm2    # 0x59b160
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x78(%rsp), %rdi
callq 0x572e70
subq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x88(%rsp), %rcx
movl $0x1, %eax
cmpq (%rcx), %rax
je 0x577e6b
movq 0x88(%rsp), %rdx
xorl %eax, %eax
movl $0x2, %ecx
cmpq (%rdx), %rcx
movb %al, 0xf(%rsp)
jne 0x577ea9
movq $0x1, 0x40(%rsp)
movq $0x2, 0x38(%rsp)
leaq 0x98(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x48(%rsp), %rdx
leaq 0x40(%rsp), %rcx
leaq 0x38(%rsp), %r8
xorl %eax, %eax
movl %eax, %r9d
callq 0x572e90
xorb $-0x1, %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x577eb3
jmp 0x577ec3
callq 0x2361c0
movsd %xmm0, 0xa0(%rsp)
jmp 0x577f2d
xorps %xmm0, %xmm0
movsd %xmm0, 0x30(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x28(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x48(%rsp), %rax
ja 0x577f1e
leaq 0x78(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x572fd0
movsd (%rax), %xmm0
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x577f40
movq 0x68(%rsp), %rax
addq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x577edf
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0xa0(%rsp)
movsd 0xa0(%rsp), %xmm0
addq $0xa8, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: void exprtk::rtl::vecops::details::kahan_sum<double>(double&, double&, double)
inline void kahan_sum(T& sum, T& error, const T v)
      {
         const T x = v - error;
         const T y = sum + x;
         error = (y - sum) - x;
         sum = y;
      }

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movsd %xmm0, -0x18(%rsp)
movsd -0x18(%rsp), %xmm0
movq -0x10(%rsp), %rax
subsd (%rax), %xmm0
movsd %xmm0, -0x20(%rsp)
movq -0x8(%rsp), %rax
movsd (%rax), %xmm0
addsd -0x20(%rsp), %xmm0
movsd %xmm0, -0x28(%rsp)
movsd -0x28(%rsp), %xmm0
movq -0x8(%rsp), %rax
subsd (%rax), %xmm0
subsd -0x20(%rsp), %xmm0
movq -0x10(%rsp), %rax
movsd %xmm0, (%rax)
movsd -0x28(%rsp), %xmm0
movq -0x8(%rsp), %rax
movsd %xmm0, (%rax)
retq
nopl (%rax,%rax)