LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::get_vector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline vector_holder_ptr get_vector(const std::string& vector_name) const
      {
         if (!valid())
            return reinterpret_cast<vector_holder_ptr>(0);
         else if (!valid_symbol(vector_name))
            return reinterpret_cast<vector_holder_ptr>(0);
         else
            return local_data().vector_store.get(vector_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 0x58864c
movq $0x0, 0x20(%rsp)
jmp 0x588692
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x58866f
movq $0x0, 0x20(%rsp)
jmp 0x588692
movq 0x8(%rsp), %rdi
callq 0x234330
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x10(%rsp), %rsi
callq 0x517c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::symbol_table<double>::add_vector(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, double*, unsigned long const&)
inline bool add_vector(const std::string& vector_name, T* v, const std::size_t& v_size)
      {
         if (!valid())
            return false;
         else if (!valid_symbol(vector_name))
            return false;
         else if (symbol_exists(vector_name))
            return false;
         else if (0 == v_size)
            return false;
         else
            return local_data().vector_store.add(vector_name, v, v_size);
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x232d30
testb $0x1, %al
jne 0x5886d5
movb $0x0, 0x37(%rsp)
jmp 0x58875c
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x233ed0
testb $0x1, %al
jne 0x5886f4
movb $0x0, 0x37(%rsp)
jmp 0x58875c
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
movl $0x1, %edx
callq 0x234050
testb $0x1, %al
jne 0x58870e
jmp 0x588715
movb $0x0, 0x37(%rsp)
jmp 0x58875c
movq 0x10(%rsp), %rcx
xorl %eax, %eax
cmpq (%rcx), %rax
jne 0x588728
movb $0x0, 0x37(%rsp)
jmp 0x58875c
movq 0x8(%rsp), %rdi
callq 0x232e60
movq %rax, %rdi
addq $0x150, %rdi            # imm = 0x150
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
xorl %r8d, %r8d
callq 0x588790
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::function_compositor<double>::symbol_used(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
inline bool symbol_used(const std::string& symbol) const
      {
         return (
                  symbol_table_.is_variable       (symbol) ||
                  symbol_table_.is_stringvar      (symbol) ||
                  symbol_table_.is_function       (symbol) ||
                  symbol_table_.is_vector         (symbol) ||
                  symbol_table_.is_vararg_function(symbol)
                );
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x18(%rsp), %rsi
callq 0x5889d0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x588916
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x588a20
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x588916
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x588a80
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x588916
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x588ae0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, 0x17(%rsp)
jne 0x588916
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x588b40
movb %al, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::copy(std::vector<std::pair<double*, unsigned long>, std::allocator<std::pair<double*, unsigned long>>> const&, std::vector<double, std::allocator<double>>&)
void copy(const lvr_vec_t& src_v, var_t& dest_v)
         {
            typename var_t::iterator itr = dest_v.begin();
            typedef  typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;

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

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

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5227b0
movq %rax, 0x48(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rdi
callq 0x58d4f0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x58c4e5
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x58d510
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
movl $0x1, %eax
cmpq 0x38(%rsp), %rax
jne 0x58c492
movq 0x30(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, 0x8(%rsp)
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x58d530
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x580bc0
movsd 0x8(%rsp), %xmm0
movsd %xmm0, (%rax)
jmp 0x58c4d0
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
movq 0x48(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdx
callq 0x58d570
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rsi
leaq 0x48(%rsp), %rdi
callq 0x58d5d0
jmp 0x58c4d2
movq 0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x40(%rsp)
jmp 0x58c40b
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::post()
inline void post()
         {
            if (--stack_depth)
            {
               if (!v.empty())
               {
                  copy(input_params_stack.back(), v);
                  input_params_stack.pop_back();
               }

               if (!local_vars.empty())
               {
                  copy(local_var_stack.back(), local_vars);
                  local_var_stack.pop_back();
               }

               if (!local_str_vars.empty())
               {
                  copy(local_str_stack.back(), local_str_vars);
                  local_str_stack.pop_back();
               }
            }
         }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movq 0x98(%rcx), %rax
addq $-0x1, %rax
movq %rax, 0x98(%rcx)
cmpq $0x0, %rax
je 0x58e849
movq 0x8(%rsp), %rdi
addq $0x48, %rdi
callq 0x58c250
testb $0x1, %al
jne 0x58e7b7
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x58e8e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rdi, %rdx
addq $0x48, %rdx
callq 0x58e850
movq 0x8(%rsp), %rdi
addq $0xa0, %rdi
callq 0x58e910
movq 0x8(%rsp), %rdi
addq $0x60, %rdi
callq 0x58c390
testb $0x1, %al
jne 0x58e7ff
movq 0x8(%rsp), %rdi
addq $0xf0, %rdi
callq 0x58e8e0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rdi, %rdx
addq $0x60, %rdx
callq 0x58e980
movq 0x8(%rsp), %rdi
addq $0xf0, %rdi
callq 0x58e910
movq 0x8(%rsp), %rdi
addq $0x78, %rdi
callq 0x58c4f0
testb $0x1, %al
jne 0x58e847
movq 0x8(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x58eb20
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq %rdi, %rdx
addq $0x78, %rdx
callq 0x58ea90
movq 0x8(%rsp), %rdi
addq $0x140, %rdi            # imm = 0x140
callq 0x58eb50
jmp 0x58e849
addq $0x18, %rsp
retq
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::base_func::copy(std::vector<double, std::allocator<double>> const&, std::vector<std::pair<double*, unsigned long>, std::allocator<std::pair<double*, unsigned long>>>&)
void copy(const var_t& src_v, lvr_vec_t& dest_v)
         {
            typename var_t::const_iterator itr = src_v.begin();
            typedef  typename std::iterator_traits<typename var_t::iterator>::difference_type diff_t;

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

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

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x58cad0
movq %rax, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
callq 0x58d4f0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x58ea82
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x58ed00
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rcx
movl $0x1, %eax
cmpq 0x8(%rcx), %rax
jne 0x58ea21
leaq 0x38(%rsp), %rdi
xorl %esi, %esi
callq 0x58ed20
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x58ed60
movsd (%rax), %xmm0
movq 0x28(%rsp), %rax
movq (%rax), %rax
movsd %xmm0, (%rax)
jmp 0x58ea6d
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0x58ed70
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdx
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x58cbf0
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
leaq 0x38(%rsp), %rdi
callq 0x58edb0
jmp 0x58ea6f
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x58e9ab
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::return_value(exprtk::expression<double>&)
static T return_value(expression_t& e)
      {
         typedef exprtk::results_context<T> results_context_t;
         typedef typename results_context_t::type_store_t type_t;
         typedef typename type_t::scalar_view scalar_t;

         const T result = e.value();

         if (e.return_invoked())
         {
            // Due to the post compilation checks, it can be safely
            // assumed that there will be at least one parameter
            // and that the first parameter will always be scalar.
            return scalar_t(e.results()[0])();
         }

         return result;
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x22fb10
movsd %xmm0, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x58f010
testb $0x1, %al
jne 0x58efb9
jmp 0x58eff9
movq 0x18(%rsp), %rdi
callq 0x58f030
movq %rax, %rdi
movq $0x0, (%rsp)
movq %rsp, %rsi
callq 0x58f0f0
movq %rax, %rsi
leaq 0x8(%rsp), %rdi
callq 0x58f120
leaq 0x8(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd %xmm0, 0x20(%rsp)
jmp 0x58f005
movsd 0x10(%rsp), %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x20(%rsp), %xmm0
addq $0x28, %rsp
retq
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::results() const
inline const results_context_t& results() const
      {
         if (control_block_->results)
            return (*control_block_->results);
         else
         {
            static const results_context_t null_results;
            return null_results;
         }
      }

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
movq (%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x58f05e
movq (%rsp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x58f0d6
cmpb $0x0, 0x274a93(%rip)    # 0x803af8
jne 0x58f0ac
leaq 0x274a8a(%rip), %rdi    # 0x803af8
callq 0x11b2c0
cmpl $0x0, %eax
je 0x58f0ac
leaq 0x274a59(%rip), %rdi    # 0x803ad8
callq 0x5217b0
jmp 0x58f086
leaq -0x3527ad(%rip), %rdi   # 0x23c8e0
leaq 0x274a44(%rip), %rsi    # 0x803ad8
leaq 0x244385(%rip), %rdx    # 0x7d3420
callq 0x11b630
leaq 0x274a51(%rip), %rdi    # 0x803af8
callq 0x11b470
leaq 0x274a25(%rip), %rax    # 0x803ad8
movq %rax, 0x20(%rsp)
jmp 0x58f0d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x274a29(%rip), %rdi    # 0x803af8
callq 0x11b360
jmp 0x58f0e0
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
movq 0x10(%rsp), %rdi
callq 0x11b4e0
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::expression<double>::local_data_list()
inline const typename control_block::local_data_list_t& local_data_list()
      {
         if (control_block_)
         {
            return control_block_->local_data_list;
         }
         else
         {
            static typename control_block::local_data_list_t null_local_data_list;
            return null_local_data_list;
         }
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rax)
je 0x5919ca
movq (%rsp), %rax
movq (%rax), %rax
addq $0x10, %rax
movq %rax, 0x10(%rsp)
jmp 0x591a22
cmpb $0x0, 0x272147(%rip)    # 0x803b18
jne 0x591a16
leaq 0x27213e(%rip), %rdi    # 0x803b18
callq 0x11b2c0
cmpl $0x0, %eax
je 0x591a16
leaq 0x272115(%rip), %rdi    # 0x803b00
callq 0x2407a0
leaq -0x3550f7(%rip), %rdi   # 0x23c900
leaq 0x272102(%rip), %rsi    # 0x803b00
leaq 0x241a1b(%rip), %rdx    # 0x7d3420
callq 0x11b630
leaq 0x272107(%rip), %rdi    # 0x803b18
callq 0x11b470
leaq 0x2720e3(%rip), %rax    # 0x803b00
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::function_compositor<double>::clear()
void clear()
      {
         symbol_table_.clear();
         expr_map_    .clear();

         for (std::size_t i = 0; i < fp_map_.size(); ++i)
         {
            typename funcparam_t::iterator itr = fp_map_[i].begin();
            typename funcparam_t::iterator end = fp_map_[i].end  ();

            while (itr != end)
            {
               delete itr->second;
               ++itr;
            }

            fp_map_[i].clear();
         }

         clear_loop_runtime_check         ();
         clear_vector_access_runtime_check();
         clear_compilation_timeout_check  ();
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x22fd50
movq 0x10(%rsp), %rdi
addq $0x930, %rdi            # imm = 0x930
callq 0x594910
movq $0x0, 0x28(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x960, %rdi            # imm = 0x960
callq 0x594920
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x5948e8
movq 0x10(%rsp), %rdi
addq $0x960, %rdi            # imm = 0x960
movq 0x28(%rsp), %rsi
callq 0x585730
movq %rax, %rdi
callq 0x594940
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x960, %rdi            # imm = 0x960
movq 0x28(%rsp), %rsi
callq 0x585730
movq %rax, %rdi
callq 0x586030
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x586010
testb $0x1, %al
jne 0x594889
jmp 0x5948b7
leaq 0x20(%rsp), %rdi
callq 0x586060
movq 0x20(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x5948ab
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
leaq 0x20(%rsp), %rdi
callq 0x586480
jmp 0x594874
movq 0x10(%rsp), %rdi
addq $0x960, %rdi            # imm = 0x960
movq 0x28(%rsp), %rsi
callq 0x585730
movq %rax, %rdi
callq 0x594970
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x594802
movq 0x10(%rsp), %rdi
callq 0x594980
movq 0x10(%rsp), %rdi
callq 0x5949a0
movq 0x10(%rsp), %rdi
callq 0x5949c0
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: my_usr<double>::process(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, exprtk::parser<double>::unknown_symbol_resolver::usr_symbol_type&, double&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool process(const std::string& unknown_symbol,
                usr_symbol_type& st,
                T& default_value,
                std::string& error_message) exprtk_test_override
   {
      if (unknown_symbol[0] == 'v')
      {
         st = usr_t::e_usr_variable_type;
         default_value = next_value();
         error_message.clear();

         return true;
      }
      else if (unknown_symbol[0] == 'c')
      {
         st = usr_t::e_usr_constant_type;
         default_value = next_value();
         error_message.clear();

         return true;
      }
      else
      {
         error_message = "Unknown symbol...";
         return false;
      }
   }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11b770
movsbl (%rax), %eax
cmpl $0x76, %eax
jne 0x59568c
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movl $0x1, (%rax)
xorl %esi, %esi
callq 0x595520
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rdi
callq 0x11b450
movb $0x1, 0x37(%rsp)
jmp 0x5956e8
movq 0x20(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11b770
movsbl (%rax), %eax
cmpl $0x63, %eax
jne 0x5956d2
movq (%rsp), %rdi
movq 0x18(%rsp), %rax
movl $0x2, (%rax)
xorl %esi, %esi
callq 0x595520
movq 0x10(%rsp), %rax
movsd %xmm0, (%rax)
movq 0x8(%rsp), %rdi
callq 0x11b450
movb $0x1, 0x37(%rsp)
jmp 0x5956e8
movq 0x8(%rsp), %rdi
leaq 0x3996f(%rip), %rsi     # 0x5cf04d
callq 0x11b340
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_test.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> results_to_string<double>(exprtk::results_context<double> const&)
inline std::string results_to_string(const exprtk::results_context<T>& results)
{
   typedef exprtk::results_context<T> results_context_t;
   typedef typename results_context_t::type_store_t type_t;

   std::string res_str;

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

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

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

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

         default               : continue;
      }
   }

   return res_str;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movb $0x0, 0x67(%rsp)
callq 0x11b2b0
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x68(%rsp), %rdi
callq 0x595db0
movq %rax, 0x18(%rsp)
jmp 0x595bf9
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
cmpq %rcx, %rax
jae 0x595cbb
movq 0x68(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x58f0f0
movq 0x10(%rax), %rcx
movq %rcx, 0x40(%rsp)
movups (%rax), %xmm0
movaps %xmm0, 0x30(%rsp)
movl 0x40(%rsp), %eax
movl %eax, 0xc(%rsp)
subl $0x1, %eax
je 0x595c6b
jmp 0x595c3b
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x595c7e
jmp 0x595c46
movl 0xc(%rsp), %eax
subl $0x3, %eax
je 0x595c91
jmp 0x595ca4
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x11b838
jmp 0x595cdb
movq 0x20(%rsp), %rdi
movl $0x54, %esi
callq 0x11b510
jmp 0x595c7c
jmp 0x595ca6
movq 0x20(%rsp), %rdi
movl $0x56, %esi
callq 0x11b510
jmp 0x595c8f
jmp 0x595ca6
movq 0x20(%rsp), %rdi
movl $0x53, %esi
callq 0x11b510
jmp 0x595ca2
jmp 0x595ca6
jmp 0x595ca8
jmp 0x595ca8
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x595bde
movb $0x1, 0x67(%rsp)
testb $0x1, 0x67(%rsp)
jne 0x595cd1
movq 0x20(%rsp), %rdi
callq 0x11b838
movq 0x28(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x11b4e0
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: bool result_equal<double>(exprtk::results_context<double> const&, double const&)
inline bool result_equal(const exprtk::results_context<T>& results, const T& value)
{
   typedef exprtk::results_context<T> results_context_t;
   typedef typename results_context_t::type_store_t type_t;
   typedef typename type_t::scalar_view scalar_t;

   if (1 != results.count())
      return false;
   else if (type_t::e_scalar != results[0].type)
      return false;
   else
      return (value == scalar_t(results[0])());
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x595db0
movq %rax, %rcx
movl $0x1, %eax
cmpq %rcx, %rax
je 0x595d1f
movb $0x0, 0x37(%rsp)
jmp 0x595d9f
movq 0x28(%rsp), %rdi
movq $0x0, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x58f0f0
movq %rax, %rcx
movl $0x1, %eax
cmpl 0x10(%rcx), %eax
je 0x595d4b
movb $0x0, 0x37(%rsp)
jmp 0x595d9f
movq 0x20(%rsp), %rax
movsd (%rax), %xmm0
movsd %xmm0, (%rsp)
movq 0x28(%rsp), %rdi
movq $0x0, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x58f0f0
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x58f120
leaq 0x10(%rsp), %rdi
callq 0x572e30
movsd (%rsp), %xmm0
ucomisd (%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
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::results_context<double>::get_scalar(unsigned long const&, double&) const
inline bool get_scalar(const std::size_t& index, T& out) const
      {
         if (
              (index < parameter_list_.size()) &&
              (parameter_list_[index].type == type_store_t::e_scalar)
            )
         {
            const scalar_t scalar(parameter_list_[index]);
            out = scalar();
            return true;
         }

         return false;
      }

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x520c10
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x595e8a
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x58f140
cmpl $0x1, 0x10(%rax)
jne 0x595e8a
movq (%rsp), %rdi
addq $0x8, %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x58f140
movq %rax, %rsi
leaq 0x10(%rsp), %rdi
callq 0x58f120
leaq 0x10(%rsp), %rdi
callq 0x581bf0
movsd (%rax), %xmm0
movq 0x18(%rsp), %rax
movsd %xmm0, (%rax)
movb $0x1, 0x37(%rsp)
jmp 0x595e8f
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::results_context<double>::get_string(unsigned long const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&) const
inline bool get_string(const std::size_t& index, std::string& out) const
      {
         if (
              (index < parameter_list_.size()) &&
              (parameter_list_[index].type == type_store_t::e_string)
            )
         {
            const string_t str(parameter_list_[index]);
            out.assign(str.begin(),str.size());
            return true;
         }

         return false;
      }

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq 0x48(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
addq $0x8, %rdi
callq 0x520c10
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x595ffb
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
callq 0x58f140
cmpl $0x3, 0x10(%rax)
jne 0x595ffb
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq 0x40(%rsp), %rax
movq (%rax), %rsi
callq 0x58f140
movq %rax, %rsi
leaq 0x28(%rsp), %rdi
callq 0x596d30
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x575420
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x575430
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq %rax, %rdx
callq 0x11b410
movb $0x1, 0x57(%rsp)
jmp 0x596000
movb $0x0, 0x57(%rsp)
movb 0x57(%rsp), %al
andb $0x1, %al
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: exprtk::vector_view<double>::set_size(unsigned long)
bool set_size(const std::size_t new_size)
      {
         if ((new_size > 0) && (new_size <= base_size_))
         {
            size_ = new_size;
            exprtk_debug(("vector_view::set_size() - data_: %p size: %lu\n",
                          reinterpret_cast<void*>(data_),
                          size_));
            return true;
         }

         exprtk_debug(("vector_view::set_size() - error invalid new_size: %lu  base_size: %lu\n",
                       new_size,
                       base_size_));
         return false;
      }

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x18(%rsp)
jbe 0x596680
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
cmpq (%rcx), %rax
ja 0x596680
movq -0x20(%rsp), %rax
movq -0x18(%rsp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rsp)
jmp 0x596685
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
andb $0x1, %al
retq
nopl (%rax)
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::results_context<double>::get_vector<std::back_insert_iterator<std::vector<double, std::allocator<double>>>>(unsigned long const&, std::back_insert_iterator<std::vector<double, std::allocator<double>>>) const
inline bool get_vector(const std::size_t& index, OutputIterator out_itr) const
      {
         if (
              (index < parameter_list_.size()) &&
              (parameter_list_[index].type == type_store_t::e_vector)
            )
         {
            const vector_t vector(parameter_list_[index]);
            for (std::size_t i = 0; i < vector.size(); ++i)
            {
               *(out_itr++) = vector[i];
            }

            return true;
         }

         return false;
      }

// Assembly:
subq $0x68, %rsp
movq %rdx, 0x58(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
addq $0x8, %rdi
callq 0x520c10
movq %rax, %rcx
movq 0x20(%rsp), %rax
cmpq %rcx, %rax
jae 0x5968e4
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
callq 0x58f140
cmpl $0x2, 0x10(%rax)
jne 0x5968e4
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rsi
callq 0x58f140
movq %rax, %rsi
leaq 0x38(%rsp), %rdi
callq 0x596930
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x572e70
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0x5968dd
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x572fd0
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x596960
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x596980
movq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x596990
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x596870
movb $0x1, 0x67(%rsp)
jmp 0x5968e9
movb $0x0, 0x67(%rsp)
movb 0x67(%rsp), %al
andb $0x1, %al
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/exprtk_test.cpp
// Function: vv_size_handler_t<double>::operator()(exprtk::type_store<double>::parameter_list)
inline T operator()(parameter_list_t parameters)
   {
      vector_t vector(parameters[0]);
      size_t   new_size = static_cast<std::size_t>(scalar_t(parameters[1])());
      void*    key      = static_cast<void*>(&vector[0]);

      typename map_t::iterator itr = vector_map_.find(key);

      if (itr == vector_map_.end())
      {
         return T(0);
      }

      exprtk::vector_view<T>& vv = *itr->second;

      if (vv.base_size() < new_size)
      {
         return T(0);
      }

      return vv.set_size(new_size) ? T(1) : T(0);
   }

// Assembly:
subq $0x98, %rsp
movq %rsi, 0x88(%rsp)
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x68(%rsp)
leaq 0x88(%rsp), %rdi
movq %rdi, 0x10(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x70(%rsp), %rdi
callq 0x572e40
movq 0x10(%rsp), %rdi
movq $0x1, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x572de0
movq %rax, %rsi
leaq 0x58(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x572e10
movq 0x18(%rsp), %rdi
callq 0x572e30
movsd (%rax), %xmm0
movsd 0x3cef(%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, 0x60(%rsp)
movq $0x0, 0x40(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x574b60
movq 0x20(%rsp), %rdi
movq %rax, 0x48(%rsp)
addq $0x48, %rdi
leaq 0x48(%rsp), %rsi
callq 0x597610
movq 0x20(%rsp), %rdi
movq %rax, 0x38(%rsp)
addq $0x48, %rdi
callq 0x597660
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x597640
testb $0x1, %al
jne 0x5974f1
jmp 0x5974ff
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x597574
leaq 0x38(%rsp), %rdi
callq 0x597690
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x3b8d30
cmpq 0x60(%rsp), %rax
jae 0x597531
xorps %xmm0, %xmm0
movsd %xmm0, 0x90(%rsp)
jmp 0x597574
movq 0x28(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x596640
movsd 0x3af8(%rip), %xmm0     # 0x59b040
xorps %xmm1, %xmm1
movsd %xmm1, (%rsp)
testb $0x1, %al
movsd %xmm0, 0x8(%rsp)
jne 0x597565
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm0
movsd %xmm0, 0x90(%rsp)
movsd 0x90(%rsp), %xmm0
addq $0x98, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: ArashPartow[P]exprtk/./exprtk.hpp
// Function: bool exprtk::details::is_sf4ext_node<double>(exprtk::details::expression_node<double> const*)
inline bool is_sf4ext_node(const expression_node<T>* n)
      {
         switch (n->type())
         {
            case expression_node<T>::e_vovovov : return true;
            case expression_node<T>::e_vovovoc : return true;
            case expression_node<T>::e_vovocov : return true;
            case expression_node<T>::e_vocovov : return true;
            case expression_node<T>::e_covovov : return true;
            case expression_node<T>::e_covocov : return true;
            case expression_node<T>::e_vocovoc : return true;
            case expression_node<T>::e_covovoc : return true;
            case expression_node<T>::e_vococov : return true;
            default                            : return false;
         }
      }

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
movq 0x28(%rax), %rax
callq *%rax
addl $-0x6f, %eax
movl %eax, %ecx
movq %rcx, (%rsp)
subl $0x8, %eax
ja 0x59abf8
movq (%rsp), %rax
leaq 0x5950(%rip), %rcx      # 0x5a0500
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x1, 0x17(%rsp)
jmp 0x59abfd
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
andb $0x1, %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: sorazy[P]canny/HashMap.cpp
// Function: HashMap::contains(int, int)
int HashMap::contains(int a, int b)
{
	Point *temp = new Point(a, b);
	int hash = this->hash(temp);

	for (int i = 0; this->table[hash % this->capacity] != NULL; i++)
	{
		temp = this->table[hash % this->capacity];
		if (temp->x == a && temp->y == b)
			return 1;
		else
			hash += 2 * i + 1;
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x8, %edi
callq 0x21f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
callq 0x5630
jmp 0x577b
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
callq 0x56d0
movl %eax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x48(%rbp), %rcx
movq (%rcx), %rax
movq %rax, -0x50(%rbp)
movl -0x30(%rbp), %eax
cltd
idivl 0xc(%rcx)
movq -0x50(%rbp), %rax
movslq %edx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x5835
movq -0x48(%rbp), %rcx
movq (%rcx), %rax
movq %rax, -0x58(%rbp)
movl -0x30(%rbp), %eax
cltd
idivl 0xc(%rcx)
movq -0x58(%rbp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x5817
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x5817
movl $0x1, -0x4(%rbp)
jmp 0x583c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x8, %esi
callq 0x2200
jmp 0x5845
movl -0x34(%rbp), %eax
shll %eax
addl $0x1, %eax
addl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x5827
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x579a
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x2370
nop
// File: sorazy[P]canny/HashMap.cpp
// Function: HashMap::insert(int, int)
void HashMap::insert(int a, int b)
{
	// Disallow duplicates
	if (this->contains(a, b))
		return;

	Point *newPoint = new Point(a, b);
	int hash = this->hash(newPoint);

	if (this->size > this->capacity / 2)
		this->expand();

	for (int i = 0; this->table[hash % this->capacity] != NULL; i++)
		hash += 2 * i + 1;

	this->table[hash % this->capacity] = newPoint;
	this->size++;

	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5740
cmpl $0x0, %eax
je 0x587f
jmp 0x5965
movl $0x8, %edi
callq 0x21f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
callq 0x5630
jmp 0x58a0
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
callq 0x56d0
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, -0x28(%rbp)
movl 0x8(%rax), %ecx
movl %ecx, -0x44(%rbp)
movl 0xc(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x44(%rbp), %eax
cmpl %ecx, %eax
jle 0x58ff
movq -0x38(%rbp), %rdi
callq 0x5980
jmp 0x58ff
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x8, %esi
callq 0x2200
jmp 0x596b
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movq (%rcx), %rax
movq %rax, -0x50(%rbp)
movl -0x28(%rbp), %eax
cltd
idivl 0xc(%rcx)
movq -0x50(%rbp), %rax
movslq %edx, %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x593f
movl -0x2c(%rbp), %eax
shll %eax
addl $0x1, %eax
addl -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x5906
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rcx
movl -0x28(%rbp), %eax
cltd
idivl 0xc(%rdi)
movq -0x38(%rbp), %rax
movslq %edx, %rdx
movq %rsi, (%rcx,%rdx,8)
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: sorazy[P]canny/HashMap.cpp
// Function: HashMap::expand()
void HashMap::expand(void)
{
	this->capacity = this->primes[++this->currentPrime];
	Point **newTable = new Point*[this->capacity];
	Point *temp;

	for (int i = 0; i < this->primes[this->currentPrime - 1]; i++)
	{
		temp = this->table[i];
		if (temp == NULL)
			continue; 

		int hash = this->hash(temp);

		newTable[hash % this->capacity] = temp;

	}

	this->table = newTable;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
movslq %ecx, %rcx
movl 0x14(%rax,%rcx,4), %ecx
movl %ecx, 0xc(%rax)
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x2030
movq %rax, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
movl 0x10(%rcx), %edx
subl $0x1, %edx
movslq %edx, %rdx
cmpl 0x14(%rcx,%rdx,4), %eax
jge 0x5a50
movq -0x28(%rbp), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a09
jmp 0x5a45
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x56d0
movq -0x28(%rbp), %rcx
movl %eax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x20(%rbp), %eax
cltd
idivl 0xc(%rcx)
movq -0x38(%rbp), %rax
movl %edx, %ecx
movq -0x30(%rbp), %rdx
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x59d7
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sorazy[P]canny/HashMap.cpp
// Function: HashMap::printTable()
void HashMap::printTable(void)
{
	Point *temp;

	for (int i = 0; i < this->size; i++)
	{
		temp = this->table[i];
		if (temp == NULL)
			cout << "NULL, ";
		else
			cout << "(" << temp->x << ", " << temp->y << "), ";
	}

	cout << endl << "size is : " << this->size << " and capacity: " << this->capacity << endl;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x8(%rcx), %eax
jge 0x5b28
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x5aca
movq 0x3514(%rip), %rdi      # 0x8fd0
leaq 0x731(%rip), %rsi       # 0x61f4
callq 0x21e0
jmp 0x5b18
movq 0x34ff(%rip), %rdi      # 0x8fd0
leaq 0x723(%rip), %rsi       # 0x61fb
callq 0x21e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x2360
movq %rax, %rdi
leaq 0x709(%rip), %rsi       # 0x61fe
callq 0x21e0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %esi
callq 0x2360
movq %rax, %rdi
leaq 0x6ea(%rip), %rsi       # 0x61fd
callq 0x21e0
jmp 0x5b1a
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x5a8b
movq 0x34a1(%rip), %rdi      # 0x8fd0
movq 0x348a(%rip), %rsi      # 0x8fc0
callq 0x2210
movq %rax, %rdi
leaq 0x6bc(%rip), %rsi       # 0x6201
callq 0x21e0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0x8(%rax), %esi
callq 0x2360
movq %rax, %rdi
leaq 0x6a9(%rip), %rsi       # 0x620c
callq 0x21e0
movq %rax, %rdi
movq -0x20(%rbp), %rax
movl 0xc(%rax), %esi
callq 0x2360
movq %rax, %rdi
movq 0x343f(%rip), %rsi      # 0x8fc0
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
// File: onlyuser[P]Sandbox/test_c/c++0x/main.cpp
// Function: main
int main(int argc, char** argv)
{
    int x;

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

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

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

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

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

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe57(%rip), %rdi       # 0x2014
movb $0x0, %al
callq 0x1030
leaq -0x14(%rbp), %rdi
callq 0x1160
movl -0x14(%rbp), %eax
addl $0x0, %eax
movl %eax, -0x18(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1180
callq 0x1140
movl %eax, -0x1c(%rbp)
leaq -0x1c(%rbp), %rdi
callq 0x1180
callq 0x1150
movq %rax, %rdi
callq 0x1160
movl $0x3, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x1180
leaq 0xe08(%rip), %rdi       # 0x201c
movb $0x0, %al
callq 0x1030
movl -0x14(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %eax
addl $0x0, %eax
movl %eax, -0x28(%rbp)
callq 0x1140
movl %eax, -0x2c(%rbp)
callq 0x1150
movl (%rax), %eax
movl %eax, -0x30(%rbp)
movl $0x3, -0x34(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x1160
leaq -0x28(%rbp), %rdi
callq 0x1160
leaq -0x2c(%rbp), %rdi
callq 0x1160
leaq -0x30(%rbp), %rdi
callq 0x1160
leaq -0x34(%rbp), %rdi
callq 0x1160
leaq 0xdad(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1030
leaq -0x14(%rbp), %rdi
callq 0x1180
leaq 0xd9e(%rip), %rdi       # 0x202c
movb $0x0, %al
callq 0x1030
leaq -0x14(%rbp), %rdi
callq 0x12e0
callq 0x1140
movl %eax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1300
leaq 0xd7e(%rip), %rdi       # 0x2034
movb $0x0, %al
callq 0x1030
leaq -0x14(%rbp), %rdi
callq 0x1320
callq 0x1140
movl %eax, -0x3c(%rbp)
leaq -0x3c(%rbp), %rdi
callq 0x1340
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: bchu7796[P]p2p-file-sharing/server_main.cpp
// Function: main
int main(void){
    server server_instance;
    if(server_instance.execute()!= 0){
        perror("server execution fault");
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x5(%rbp), %rdi
callq 0x3450
cmpl $0x0, %eax
je 0x25a9
leaq 0x7a60(%rip), %rdi      # 0xa004
callq 0x21e0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: bchu7796[P]p2p-file-sharing/server.cpp
// Function: server::caculate_chunk_number(unsigned int)
int server::caculate_chunk_number(uint32_t file_length){
    int chunk_number = file_length / CHUNK_SIZE;
    if((chunk_number * CHUNK_SIZE) < file_length){
        chunk_number += 1;
    }
    return chunk_number;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
shrl $0xa, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
shll $0xa, %eax
cmpl -0xc(%rbp), %eax
jae 0x25e8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movl -0x10(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: bchu7796[P]p2p-file-sharing/server.cpp
// Function: server::file_list_reply(int)
int server::file_list_reply(int process_fd){
    uint16_t number_of_file = files.size();
    send(process_fd, &number_of_file, sizeof(number_of_file), 0);
    for(int i=0; i<number_of_file; i++){
        send(process_fd, &files[i].file_name, sizeof(files[i].file_name), 0);
        send(process_fd, &files[i].file_length, sizeof(files[i].file_length), 0);
    }
    close(process_fd);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0xd6da(%rip), %rdi      # 0x10210
callq 0x3cc0
movw %ax, -0xe(%rbp)
movl -0xc(%rbp), %edi
leaq -0xe(%rbp), %rsi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x2120
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movzwl -0xe(%rbp), %ecx
cmpl %ecx, %eax
jge 0x2bc3
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0xd69b(%rip), %rdi      # 0x10210
callq 0x3ce0
movl -0x1c(%rbp), %edi
movq %rax, %rsi
movl $0x20, %edx
xorl %ecx, %ecx
callq 0x2120
movl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rsi
leaq 0xd673(%rip), %rdi      # 0x10210
callq 0x3ce0
movl -0x18(%rbp), %edi
movq %rax, %rsi
addq $0x20, %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x2120
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b59
movl -0xc(%rbp), %edi
callq 0x23b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bchu7796[P]p2p-file-sharing/server.cpp
// Function: server::handle_request(int, unsigned int, sockaddr_in)
void server::handle_request(int new_sock, uint32_t request_type, struct sockaddr_in client_address){
    switch (request_type){
        case 0:
            register_reply(new_sock, client_address);
            break;
        case 1:
            file_list_reply(new_sock);
            break;
        case 2:
            location_reply(new_sock);
            break;
        case 3:
            chunk_register_reply(new_sock, client_address);
            break;
        default:
            break;
    }
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x10(%rbp)
movq %r8, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movl %edx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
movl -0x20(%rbp), %eax
movq %rax, -0x48(%rbp)
subq $0x3, %rax
ja 0x343b
movq -0x48(%rbp), %rax
leaq 0x6c52(%rip), %rcx      # 0xa01c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rcx
callq 0x25f0
jmp 0x343d
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2b20
jmp 0x343d
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
callq 0x2be0
jmp 0x343d
movq -0x50(%rbp), %rdi
movl -0x1c(%rbp), %esi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
callq 0x2ea0
jmp 0x343d
jmp 0x343d
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: bchu7796[P]p2p-file-sharing/server.cpp
// Function: server::execute()
int server::execute(void){
    server myserver;
    int process_fd;
    int server_fd;
    struct sockaddr_in server_address, client_address;
    //create socket
    if((server_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0){
        perror("Failed to create socket"); 
        exit(0);
    }

    //initailize address structure
    bzero(&server_address, sizeof(server_address));
    server_address.sin_family = PF_INET; 
    server_address.sin_addr.s_addr = INADDR_ANY; 
    server_address.sin_port = htons(SERVER_PORT); 

    //bind socket
    if(bind(server_fd, (struct sockaddr*) &server_address, sizeof(server_address)) < 0){
        perror("Failed to bind"); 
        exit(0);
    }

    //listen socket
    if(listen(server_fd, 5) < 0){
        perror("Failed to listen"); 
        exit(0);
    }


    while(1){
        int client_address_length = sizeof(client_address);
        if((process_fd = accept(server_fd,(struct sockaddr*) &client_address, (socklen_t *) &client_address_length)) < 0){
            perror("Failed to accept"); 
            exit(0);
        }
        uint32_t request_type;
        recv(process_fd, &request_type, sizeof(request_type), 0);
        //use multi-thread to handle requests
        std::thread tid(&server::handle_request, myserver, process_fd, request_type, client_address);
        tid.detach();
        //handle_request(process_fd, request_type, client_address);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x2070
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jge 0x348b
leaq 0x6bfc(%rip), %rdi      # 0xa07b
callq 0x21e0
xorl %edi, %edi
callq 0x22c0
leaq -0x24(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2140
movw $0x2, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x1f90, %edi           # imm = 0x1F90
callq 0x2040
movw %ax, -0x22(%rbp)
movl -0x14(%rbp), %edi
leaq -0x24(%rbp), %rsi
movl $0x10, %edx
callq 0x2050
cmpl $0x0, %eax
jge 0x34df
leaq 0x6bc0(%rip), %rdi      # 0xa093
callq 0x21e0
xorl %edi, %edi
callq 0x22c0
movl -0x14(%rbp), %edi
movl $0x5, %esi
callq 0x22b0
cmpl $0x0, %eax
jge 0x3504
leaq 0x6baa(%rip), %rdi      # 0xa0a2
callq 0x21e0
xorl %edi, %edi
callq 0x22c0
jmp 0x3506
movl $0x10, -0x38(%rbp)
movl -0x14(%rbp), %edi
leaq -0x34(%rbp), %rsi
leaq -0x38(%rbp), %rdx
callq 0x2090
movl %eax, -0x10(%rbp)
cmpl $0x0, %eax
jge 0x3538
leaq 0x6b87(%rip), %rdi      # 0xa0b3
callq 0x21e0
xorl %edi, %edi
callq 0x22c0
movl -0x10(%rbp), %edi
leaq -0x3c(%rbp), %rsi
movq %rsi, -0x78(%rbp)
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20a0
movq -0x78(%rbp), %r8
leaq -0x1ca(%rip), %rax      # 0x3390
movq %rax, -0x58(%rbp)
movq $0x0, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
leaq -0x58(%rbp), %rsi
leaq -0x9(%rbp), %rdx
leaq -0x10(%rbp), %rcx
leaq -0x34(%rbp), %r9
callq 0x3e10
movq -0x70(%rbp), %rdi
callq 0x2370
jmp 0x358e
leaq -0x48(%rbp), %rdi
callq 0x3ef0
jmp 0x3506
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3ef0
movq -0x60(%rbp), %rdi
callq 0x2380
nopw (%rax,%rax)