LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_constant_node(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_constant_node(const std::string& symbol_name) const
         {
            if (!valid_symbol(symbol_name))
               return false;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

               if (local_data(i).variable_store.is_constant(symbol_name))
               {
                  return true;
               }
            }

            return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x517c30
testb $0x1, %al
jne 0x529010
movb $0x0, 0x37(%rsp)
jmp 0x529097
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x529092
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x529057
jmp 0x529082
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
movq 0x20(%rsp), %rsi
callq 0x52d1e0
testb $0x1, %al
jne 0x529079
jmp 0x529080
movb $0x1, 0x37(%rsp)
jmp 0x529097
jmp 0x529082
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x529019
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_stringvar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_stringvar(const std::string& stringvar_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().stringvar_store
                           .symbol_exists(stringvar_name)
                       )
                  return true;
            }

            return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x529c9e
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x529c4f
jmp 0x529c8b
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x234330
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
callq 0x2346f0
testb $0x1, %al
jne 0x529c80
jmp 0x529c87
movb $0x1, 0x37(%rsp)
jmp 0x529ca3
jmp 0x529c89
jmp 0x529c8b
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x529c11
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline function_ptr get_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<function_ptr>(0);

            function_ptr result = reinterpret_cast<function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x52f800
testb $0x1, %al
jne 0x529ce4
movq $0x0, 0x30(%rsp)
jmp 0x529d7d
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x529d73
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x529d32
jmp 0x529d63
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x38, %rdi
movq 0x20(%rsp), %rsi
callq 0x52f860
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x529d61
jmp 0x529d73
jmp 0x529d63
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x529cf6
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_vararg_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline vararg_function_ptr get_vararg_function(const std::string& vararg_function_name) const
         {
            if (!valid_function_name(vararg_function_name))
               return reinterpret_cast<vararg_function_ptr>(0);

            vararg_function_ptr result = reinterpret_cast<vararg_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .vararg_function_store.get(vararg_function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x52f800
testb $0x1, %al
jne 0x52a504
movq $0x0, 0x30(%rsp)
jmp 0x52a59d
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x52a593
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52a552
jmp 0x52a583
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x70, %rdi
movq 0x20(%rsp), %rsi
callq 0x54e3b0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x52a581
jmp 0x52a593
jmp 0x52a583
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x52a516
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_generic_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_generic_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);

            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i)
                              .generic_function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x52f800
testb $0x1, %al
jne 0x52b454
movq $0x0, 0x30(%rsp)
jmp 0x52b4f0
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x52b4e6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52b4a2
jmp 0x52b4d6
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0xa8, %rdi
movq 0x20(%rsp), %rsi
callq 0x54ef70
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x52b4d4
jmp 0x52b4e6
jmp 0x52b4d6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x52b466
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_string_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_string_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);

            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result =
                     local_data(i).string_function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x52f800
testb $0x1, %al
jne 0x52c2e4
movq $0x0, 0x30(%rsp)
jmp 0x52c380
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x52c376
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52c332
jmp 0x52c366
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0xe0, %rdi
movq 0x20(%rsp), %rsi
callq 0x54ef70
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x52c364
jmp 0x52c376
jmp 0x52c366
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x52c2f6
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_overload_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline generic_function_ptr get_overload_function(const std::string& function_name) const
         {
            if (!valid_function_name(function_name))
               return reinterpret_cast<generic_function_ptr>(0);

            generic_function_ptr result = reinterpret_cast<generic_function_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result =
                     local_data(i).overload_function_store.get(function_name);

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x20(%rsp), %rsi
callq 0x52f800
testb $0x1, %al
jne 0x52c854
movq $0x0, 0x30(%rsp)
jmp 0x52c8f0
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x52c8e6
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52c8a2
jmp 0x52c8d6
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x118, %rdi            # imm = 0x118
movq 0x20(%rsp), %rsi
callq 0x54ef70
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x52c8d4
jmp 0x52c8e6
jmp 0x52c8d6
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x52c866
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::is_base_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline bool is_base_function(const std::string& function_name)
      {
         for (std::size_t i = 0; i < base_function_list_size; ++i)
         {
            if (imatch(function_name, base_function_list[i]))
            {
               return true;
            }
         }

         return false;
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq $0x0, (%rsp)
cmpq $0x3a, (%rsp)
jae 0x52d081
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
leaq 0x2a7358(%rip), %rsi    # 0x7d43b0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x37fb20
testb $0x1, %al
jne 0x52d06a
jmp 0x52d071
movb $0x1, 0x17(%rsp)
jmp 0x52d086
jmp 0x52d073
movq (%rsp), %rax
addq $0x1, %rax
movq %rax, (%rsp)
jmp 0x52d041
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.hpp
// Function: exprtk::symbol_table<double>::create_variable(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double const&)
inline bool create_variable(const std::string& variable_name, const T& value = T(0))
      {
         if (!valid())
            return false;
         else if (!valid_symbol(variable_name))
            return false;
         else if (symbol_exists(variable_name))
            return false;

         local_data().local_symbol_list_.push_back(value);
         T& t = local_data().local_symbol_list_.back();

         return add_variable(variable_name,t);
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x52d110
movb $0x0, 0x37(%rsp)
jmp 0x52d1ac
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x52d12f
movb $0x0, 0x37(%rsp)
jmp 0x52d1ac
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x52d149
jmp 0x52d150
movb $0x0, 0x37(%rsp)
jmp 0x52d1ac
jmp 0x52d152
jmp 0x52d154
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
movq 0x18(%rsp), %rsi
callq 0x234160
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x1c0, %rdi            # imm = 0x1C0
callq 0x2341a0
movq 0x8(%rsp), %rdi
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rsi
movq 0x10(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2341e0
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::is_constant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_constant(const std::string& symbol_name) const
         {
            if (symbol_name.empty())
               return false;
            else
            {
               const tm_const_itr_t itr = map.find(symbol_name);

               if (map.end() == itr)
                  return false;
               else
                  return (*itr).second.first;
            }
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11b260
testb $0x1, %al
jne 0x52d208
jmp 0x52d20f
movb $0x0, 0x37(%rsp)
jmp 0x52d261
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2348c0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0x234890
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x234ab0
testb $0x1, %al
jne 0x52d247
jmp 0x52d24e
movb $0x0, 0x37(%rsp)
jmp 0x52d261
leaq 0x18(%rsp), %rdi
callq 0x52d270
movb 0x20(%rax), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::lexer::generator::insert_front(exprtk::lexer::token::token_type)
inline void insert_front(token_t::token_type tk_type)
         {
            if (
                 !token_list_.empty() &&
                 (token_list_.end() != token_itr_)
               )
            {
               token_t t = *token_itr_;

               t.type     = tk_type;
               token_itr_ = token_list_.insert(token_itr_,t);
            }
         }

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movl %esi, 0x7c(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x254a30
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, 0x23(%rsp)
jne 0x52d318
movq 0x18(%rsp), %rdi
callq 0x2514b0
movq 0x18(%rsp), %rsi
movq %rax, 0x70(%rsp)
addq $0x18, %rsi
leaq 0x70(%rsp), %rdi
callq 0x379870
movb %al, 0x23(%rsp)
movb 0x23(%rsp), %al
testb $0x1, %al
jne 0x52d325
jmp 0x52d3b8
movq 0x18(%rsp), %rdi
addq $0x18, %rdi
movq %rdi, (%rsp)
callq 0x257700
movq %rax, %rsi
leaq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x255940
movq (%rsp), %rsi
movl 0x7c(%rsp), %eax
movl %eax, 0x40(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x52d600
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rdx
movq 0x30(%rsp), %rsi
callq 0x52d3d0
movq %rax, 0x10(%rsp)
jmp 0x52d37a
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rcx
movq %rcx, 0x18(%rax)
leaq 0x40(%rsp), %rdi
callq 0x2512e0
jmp 0x52d3b8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x40(%rsp), %rdi
callq 0x2512e0
jmp 0x52d3c0
addq $0x88, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_string_context(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline string_context get_string_context(const std::string& string_name) const
         {
            string_context result;

            if (!valid_symbol(string_name))
               return result;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
               {
                  continue;
               }

               result.str_var = local_data(i).stringvar_store.get(string_name);

               if (result.str_var)
               {
                  result.symbol_table = &symtab_list_[i];
                  break;
               }
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x52f150
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x517c30
testb $0x1, %al
jne 0x52daba
jmp 0x52db5c
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
callq 0x240aa0
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x52db5a
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52daff
jmp 0x52db47
movq 0x8(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x18(%rsp), %rsi
callq 0x52f170
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x52db45
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x3eb820
movq %rax, 0x28(%rsp)
jmp 0x52db5a
jmp 0x52db47
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x52dac3
jmp 0x52db5c
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_conststr_stringvar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_conststr_stringvar(const std::string& symbol_name) const
         {
            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (
                         symtab_list_[i].local_data().stringvar_store
                           .symbol_exists(symbol_name)
                       )
               {
                  return (
                           local_data(i).stringvar_store.symbol_exists(symbol_name) ||
                           local_data(i).stringvar_store.is_constant  (symbol_name)
                         );

               }
            }

            return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x52dc81
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52dbd6
jmp 0x52dc6e
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x234330
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
callq 0x2346f0
testb $0x1, %al
jne 0x52dc07
jmp 0x52dc6a
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
callq 0x2346f0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x7(%rsp)
jne 0x52dc5e
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
callq 0x52f1f0
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x37(%rsp)
jmp 0x52dc86
jmp 0x52dc6c
jmp 0x52dc6e
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x52db91
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::is_constant_string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool is_constant_string(const std::string& symbol_name) const
         {
            if (!valid_symbol(symbol_name))
               return false;

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else if (!local_data(i).stringvar_store.symbol_exists(symbol_name))
                  continue;
               else if (local_data(i).stringvar_store.is_constant(symbol_name))
                  return true;
            }

            return false;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x20(%rsp), %rsi
callq 0x517c30
testb $0x1, %al
jne 0x52dcd0
movb $0x0, 0x37(%rsp)
jmp 0x52dd92
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x52dd8d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x52dd1b
jmp 0x52dd7a
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
callq 0x2346f0
testb $0x1, %al
jne 0x52dd44
jmp 0x52dd7a
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
addq $0x188, %rdi            # imm = 0x188
movq 0x20(%rsp), %rsi
callq 0x52f1f0
testb $0x1, %al
jne 0x52dd6d
jmp 0x52dd74
movb $0x1, 0x37(%rsp)
jmp 0x52dd92
jmp 0x52dd76
jmp 0x52dd78
jmp 0x52dd7a
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x52dcd9
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::valid_function(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool valid_function(const std::string& symbol) const
      {
         if (symbol.empty())
            return false;
         else if (!details::is_letter(symbol[0]))
            return false;
         else if (symbol.size() > 1)
         {
            for (std::size_t i = 1; i < symbol.size(); ++i)
            {
               if (
                    !details::is_letter_or_digit(symbol[i]) &&
                    ('_' != symbol[i])
                  )
               {
                  if ((i < (symbol.size() - 1)) && ('.' == symbol[i]))
                     continue;
                  else
                     return false;
               }
            }
         }

         return true;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11b260
testb $0x1, %al
jne 0x52f8fe
jmp 0x52f908
movb $0x0, 0x37(%rsp)
jmp 0x52fa0d
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11b770
movsbl (%rax), %edi
callq 0x234290
testb $0x1, %al
jne 0x52f92c
movb $0x0, 0x37(%rsp)
jmp 0x52fa0d
movq 0x20(%rsp), %rdi
callq 0x11b270
cmpq $0x1, %rax
jbe 0x52fa04
movq $0x1, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x52fa02
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %edi
callq 0x2342f0
testb $0x1, %al
jne 0x52f9ed
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %ecx
movl $0x5f, %eax
cmpl %ecx, %eax
je 0x52f9ed
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x11b270
movq %rax, %rcx
movq 0x8(%rsp), %rax
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x52f9e6
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x11b770
movsbl (%rax), %ecx
movl $0x2e, %eax
cmpl %ecx, %eax
jne 0x52f9e6
jmp 0x52f9ef
movb $0x0, 0x37(%rsp)
jmp 0x52fa0d
jmp 0x52f9ef
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x52f949
jmp 0x52fa04
jmp 0x52fa06
jmp 0x52fa08
movb $0x1, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::function_N_node<double, exprtk::ifunction<double>, 1ul>::init_branches<1ul>(exprtk::details::expression_node<double>* (&) [1ul])
bool init_branches(expression_ptr (&b)[NumBranches])
         {
            // Needed for incompetent and broken msvc compiler versions
            #ifdef _MSC_VER
             #pragma warning(push)
             #pragma warning(disable: 4127)
            #endif

            if (N != NumBranches)
            {
               return false;
            }

            for (std::size_t i = 0; i < NumBranches; ++i)
            {
               if (b[i] && b[i]->valid())
                  branch_[i] = std::make_pair(b[i],branch_deletable(b[i]));
               else
                  return false;
            }

            initialised_ = function_;
            assert(valid());
            return initialised_;

            #ifdef _MSC_VER
             #pragma warning(pop)
            #endif
         }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x38(%rsp)
cmpq $0x1, 0x38(%rsp)
jae 0x53d971
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x53d955
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
callq *0x30(%rax)
testb $0x1, %al
jne 0x53d8ec
jmp 0x53d955
movq 0x40(%rsp), %rax
movq 0x38(%rsp), %rcx
leaq (%rax,%rcx,8), %rdx
movq %rdx, (%rsp)
movq (%rax,%rcx,8), %rdi
callq 0x23c7e0
movq (%rsp), %rdi
movb %al, 0x27(%rsp)
leaq 0x27(%rsp), %rsi
callq 0x39e310
movq 0x8(%rsp), %rdi
movb %dl, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x28(%rsp)
movb 0x18(%rsp), %al
movb %al, 0x30(%rsp)
addq $0x30, %rdi
movq 0x38(%rsp), %rax
shlq $0x4, %rax
addq %rax, %rdi
leaq 0x28(%rsp), %rsi
callq 0x39e340
jmp 0x53d95c
movb $0x0, 0x57(%rsp)
jmp 0x53d98d
jmp 0x53d95e
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x53d8b1
movq 0x8(%rsp), %rax
cmpq $0x0, 0x20(%rax)
setne %cl
andb $0x1, %cl
movb %cl, 0x40(%rax)
movb 0x40(%rax), %al
andb $0x1, %al
movb %al, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 4ul>::evaluate_branches<double, 4ul>::execute(double (&) [4], std::pair<exprtk::details::expression_node<double>*, bool> const (&) [4])
static inline void execute(T_ (&v)[4], const branch_t (&b)[4])
            {
               v[0] = b[0].first->value();
               v[1] = b[1].first->value();
               v[2] = b[2].first->value();
               v[3] = b[3].first->value();
            }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 5ul>::evaluate_branches<double, 5ul>::execute(double (&) [5], std::pair<exprtk::details::expression_node<double>*, bool> const (&) [5])
static inline void execute(T_ (&v)[5], const branch_t (&b)[5])
            {
               v[0] = b[0].first->value();
               v[1] = b[1].first->value();
               v[2] = b[2].first->value();
               v[3] = b[3].first->value();
               v[4] = b[4].first->value();
            }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rax)
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::function_N_node<double, exprtk::ifunction<double>, 6ul>::evaluate_branches<double, 6ul>::execute(double (&) [6], std::pair<exprtk::details::expression_node<double>*, bool> const (&) [6])
static inline void execute(T_ (&v)[6], const branch_t (&b)[6])
            {
               v[0] = b[0].first->value();
               v[1] = b[1].first->value();
               v[2] = b[2].first->value();
               v[3] = b[3].first->value();
               v[4] = b[4].first->value();
               v[5] = b[5].first->value();
            }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x30(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x40(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x50(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rax
movsd %xmm0, 0x28(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::type_checker::allow_zero_parameters() const
bool allow_zero_parameters() const
         {

            for (std::size_t i = 0; i < function_definition_list_.size(); ++i)
            {
               if (std::string::npos != function_definition_list_[i].param_seq.find("Z"))
               {
                  return true;
               }
            }

            return false;
         }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
addq $0x38, %rdi
callq 0x552520
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x54f461
movq 0x8(%rsp), %rdi
addq $0x38, %rdi
movq 0x10(%rsp), %rsi
callq 0x552cb0
movq %rax, %rdi
addq $0x8, %rdi
leaq 0x6185f(%rip), %rsi     # 0x5b0c8f
xorl %eax, %eax
movl %eax, %edx
callq 0x11b030
movq %rax, %rcx
movq $-0x1, %rax
cmpq %rcx, %rax
je 0x54f44f
movb $0x1, 0x27(%rsp)
jmp 0x54f466
jmp 0x54f451
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x54f3ec
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multimode_genfunction_node<double, exprtk::igeneric_function<double>>::value() const
inline T value() const exprtk_override
         {
            assert(gen_function_t::valid());

            if (gen_function_t::populate_value_list())
            {
               typedef typename GenericFunction::parameter_list_t parameter_list_t;

               return
                  (*gen_function_t::function_)
                  (
                     param_seq_index_,
                     parameter_list_t(gen_function_t::typestore_list_)
                  );
            }

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x554bd0
testb $0x1, %al
jne 0x554f5e
jmp 0x554fa5
movq 0x18(%rsp), %rsi
movq 0x20(%rsi), %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rax
addq $0xd0, %rax
movq %rax, 0x10(%rsp)
addq $0x28, %rsi
leaq 0x20(%rsp), %rdi
callq 0x5208f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq (%rdi), %rax
callq *0x20(%rax)
movsd %xmm0, 0x30(%rsp)
jmp 0x554fb0
callq 0x2361c0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_function_node<double, exprtk::igeneric_function<double>>::string_function_node(exprtk::igeneric_function<double>*, std::vector<exprtk::details::expression_node<double>*, std::allocator<exprtk::details::expression_node<double>*>> const&)
string_function_node(StringFunction* func,
                              const std::vector<typename gen_function_t::expression_ptr>& arg_list)
         : gen_function_t(arg_list,func)
         {
            range_.n0_c = std::make_pair<bool,std::size_t>(true,0);
            range_.n1_c = std::make_pair<bool,std::size_t>(true,0);
            range_.cache.first  = range_.n0_c.second;
            range_.cache.second = range_.n1_c.second;
            assert(valid());
         }

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x28(%rsp)
movq 0x80(%rsp), %rsi
movq 0x88(%rsp), %rdx
callq 0x553ee0
movq 0x28(%rsp), %rdi
addq $0xd0, %rdi
callq 0x3a7580
movq 0x28(%rsp), %rdi
addq $0xd8, %rdi
callq 0x3a75a0
movq 0x28(%rsp), %rdi
leaq 0x279e01(%rip), %rax    # 0x7cfac0
movq %rax, (%rdi)
leaq 0x279e7f(%rip), %rax    # 0x7cfb48
movq %rax, 0x8(%rdi)
leaq 0x279e9c(%rip), %rax    # 0x7cfb70
movq %rax, 0xd0(%rdi)
leaq 0x279ec6(%rip), %rax    # 0x7cfba8
movq %rax, 0xd8(%rdi)
addq $0xe0, %rdi
callq 0x43b670
jmp 0x555cf7
movq 0x28(%rsp), %rdi
addq $0x130, %rdi            # imm = 0x130
movq %rdi, 0x10(%rsp)
callq 0x11b2b0
movb $0x1, 0x5f(%rsp)
movq $0x0, 0x50(%rsp)
leaq 0x5f(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x43b7a0
movq %rdx, 0x18(%rsp)
movb %al, 0x27(%rsp)
jmp 0x555d35
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rax
movb 0x27(%rsp), %cl
movb %cl, 0x60(%rsp)
movq %rax, 0x68(%rsp)
addq $0x100, %rdi            # imm = 0x100
leaq 0x60(%rsp), %rsi
callq 0x43b7d0
movb $0x1, 0x3f(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x3f(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x43b7a0
movq %rdx, (%rsp)
movb %al, 0xf(%rsp)
jmp 0x555d84
movq 0x28(%rsp), %rdi
movq (%rsp), %rax
movb 0xf(%rsp), %cl
movb %cl, 0x40(%rsp)
movq %rax, 0x48(%rsp)
addq $0xe0, %rdi
addq $0x30, %rdi
leaq 0x40(%rsp), %rsi
callq 0x43b7d0
movq 0x28(%rsp), %rax
movq 0x108(%rax), %rcx
movq %rcx, 0x120(%rax)
movq 0x118(%rax), %rcx
movq %rcx, 0x128(%rax)
addq $0x98, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x555e00
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
callq 0x11b838
movq 0x28(%rsp), %rdi
addq $0xd8, %rdi
callq 0x3a7aa0
movq 0x28(%rsp), %rdi
addq $0xd0, %rdi
callq 0x3a7a80
movq 0x28(%rsp), %rdi
callq 0x553fd0
movq 0x78(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::string_function_node<double, exprtk::igeneric_function<double>>::value() const
inline T value() const exprtk_override
         {
            if (gen_function_t::populate_value_list())
            {
               typedef typename StringFunction::parameter_list_t parameter_list_t;

               const T result =
                  (*gen_function_t::function_)
                  (
                     ret_string_,
                     parameter_list_t(gen_function_t::typestore_list_)
                  );

               range_.n1_c.second  = ret_string_.size();
               range_.cache.second = range_.n1_c.second;

               return result;
            }

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x554bd0
testb $0x1, %al
jne 0x555f2e
jmp 0x555fad
movq 0x10(%rsp), %rsi
movq 0x20(%rsi), %rax
movq %rax, (%rsp)
movq %rsi, %rax
addq $0x130, %rax            # imm = 0x130
movq %rax, 0x8(%rsp)
addq $0x28, %rsi
leaq 0x18(%rsp), %rdi
callq 0x5208f0
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movsd %xmm0, 0x20(%rsp)
addq $0x130, %rdi            # imm = 0x130
callq 0x11b270
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x118(%rax)
movq 0x118(%rax), %rcx
movq %rcx, 0x128(%rax)
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x30(%rsp)
jmp 0x555fb8
callq 0x2361c0
movsd %xmm0, 0x30(%rsp)
movsd 0x30(%rsp), %xmm0
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::details::multimode_strfunction_node<double, exprtk::igeneric_function<double>>::value() const
inline T value() const exprtk_override
         {
            if (str_function_t::populate_value_list())
            {
               typedef typename StringFunction::parameter_list_t parameter_list_t;

               const T result =
                  (*str_function_t::function_)
                  (
                     param_seq_index_,
                     str_function_t::ret_string_,
                     parameter_list_t(str_function_t::typestore_list_)
                  );

               str_function_t::range_.n1_c.second  = str_function_t::ret_string_.size();
               str_function_t::range_.cache.second = str_function_t::range_.n1_c.second;

               return result;
            }

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x554bd0
testb $0x1, %al
jne 0x556321
jmp 0x5563b5
movq 0x20(%rsp), %rsi
movq 0x20(%rsi), %rax
movq %rax, 0x8(%rsp)
movq %rsi, %rax
addq $0x150, %rax            # imm = 0x150
movq %rax, 0x10(%rsp)
movq %rsi, %rax
addq $0x130, %rax            # imm = 0x130
movq %rax, 0x18(%rsp)
addq $0x28, %rsi
leaq 0x28(%rsp), %rdi
callq 0x5208f0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq (%rdi), %rax
callq *0x28(%rax)
movq 0x20(%rsp), %rdi
movsd %xmm0, 0x30(%rsp)
addq $0x130, %rdi            # imm = 0x130
callq 0x11b270
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x118(%rax)
movq 0x118(%rax), %rcx
movq %rcx, 0x128(%rax)
movsd 0x30(%rsp), %xmm0
movsd %xmm0, 0x40(%rsp)
jmp 0x5563c0
callq 0x2361c0
movsd %xmm0, 0x40(%rsp)
movsd 0x40(%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_vector_name[abi:cxx11](double const*)
inline std::string get_vector_name(const T* data)
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (
                    se.active   &&
                    se.vec_node &&
                    (se.vec_node->data() == data)
                  )
               {
                  return se.name;
               }
            }

            return "neo-vector";
         }

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x374590
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x556a52
movq 0x20(%rsp), %rdi
addq $0x8, %rdi
movq 0x48(%rsp), %rsi
callq 0x374750
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
testb $0x1, 0x4c(%rax)
je 0x556a3d
movq 0x40(%rsp), %rax
cmpq $0x0, 0x60(%rax)
je 0x556a3d
movq 0x40(%rsp), %rax
movq 0x60(%rax), %rdi
callq 0x3ea570
cmpq 0x50(%rsp), %rax
jne 0x556a3d
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x11b140
jmp 0x556a9d
jmp 0x556a3f
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x5569c3
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x11b6f0
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x54616(%rip), %rsi     # 0x5ab086
callq 0x134520
jmp 0x556a77
leaq 0x3f(%rsp), %rdi
callq 0x11b820
jmp 0x556a9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x11b820
jmp 0x556aa7
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::symtab_store::get_variable(double const&) const
inline variable_ptr get_variable(const T& var_ref) const
         {
            variable_ptr result = reinterpret_cast<variable_ptr>(0);

            for (std::size_t i = 0; i < symtab_list_.size(); ++i)
            {
               if (!symtab_list_[i].valid())
                  continue;
               else
                  result = local_data(i).variable_store
                              .get_from_varptr(reinterpret_cast<const void*>(&var_ref));

               if (result) break;
            }

            return result;
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0x240aa0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x556b75
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x3eb820
movq %rax, %rdi
callq 0x232d30
testb $0x1, %al
jne 0x556b38
jmp 0x556b65
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3eb720
movq %rax, %rdi
movq 0x28(%rsp), %rsi
callq 0x556c70
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x556b63
jmp 0x556b75
jmp 0x556b65
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x556afa
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::parser<double>::scope_element_manager::get_variable(double const&)
inline expression_node_ptr get_variable(const T& v)
         {
            for (std::size_t i = 0; i < element_.size(); ++i)
            {
               scope_element& se = element_[i];

               if (
                    se.active   &&
                    se.var_node &&
                    details::is_variable_node(se.var_node)
                  )
               {
                  variable_node_ptr vn = reinterpret_cast<variable_node_ptr>(se.var_node);

                  if (&(vn->ref()) == (&v))
                  {
                     return se.var_node;
                  }
               }
            }

            return expression_node_ptr(0);
         }

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x374590
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x556c53
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movq 0x28(%rsp), %rsi
callq 0x374750
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x4c(%rax)
je 0x556c3e
movq 0x20(%rsp), %rax
cmpq $0x0, 0x58(%rax)
je 0x556c3e
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rdi
callq 0x23c960
testb $0x1, %al
jne 0x556c0d
jmp 0x556c3e
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x235f80
cmpq 0x30(%rsp), %rax
jne 0x556c3c
movq 0x20(%rsp), %rax
movq 0x58(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x556c5c
jmp 0x556c3e
jmp 0x556c40
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x556ba1
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::type_store<exprtk::details::variable_node<double>, double>::get_from_varptr(void const*) const
inline type_ptr get_from_varptr(const void* ptr) const
         {
            tm_const_itr_t itr = map.begin();

            while (map.end() != itr)
            {
               type_ptr ret_ptr = itr->second.second;

               if (ptr_match<Type,RawType,type_ptr>::test(ret_ptr,ptr))
               {
                  return ret_ptr;
               }

               ++itr;
            }

            return type_ptr(0);
         }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x3eb840
movq %rax, 0x18(%rsp)
movq (%rsp), %rdi
callq 0x234890
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x234870
testb $0x1, %al
jne 0x556cb4
jmp 0x556cf4
leaq 0x18(%rsp), %rdi
callq 0x3eb870
movq 0x28(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x556d10
testb $0x1, %al
jne 0x556cdc
jmp 0x556ce8
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x556cfd
leaq 0x18(%rsp), %rdi
callq 0x3eb890
jmp 0x556c91
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)