LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::write<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());

         switch (ps_index)
         {
            case 0  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }

            case 1  : {
                         const string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(buffer, amount) ? 1 : 0);
                      }

            case 2  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }

            case 3  : {
                         const vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->write(vec, amount) ? 1 : 0);
                      }
         }

         return T(0);
      }

// Assembly:
movq (%rsi), %rcx
cmpq $0x3, %rcx
ja 0x17a603
subq $0x18, %rsp
movq (%rdx), %rax
movq (%rax), %rdx
movq (%rdx), %rdi
leaq 0xd7181(%rip), %rdx     # 0x25169c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x17a5f0
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x17a5a1
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0xd5b1d(%rip), %xmm0    # 0x2500a8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x17a638
jmp 0x17a5f7
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0xd5ace(%rip), %xmm0    # 0x2500a8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x17a608
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: bool exprtk::rtl::io::file::details::file_descriptor::write<exprtk::type_store<double>::type_view<char>>(exprtk::type_store<double>::type_view<char> const&, unsigned long, unsigned long)
bool write(const View& view, const std::size_t amount, const std::size_t offset = 0)
         {
            switch (mode)
            {
               case e_write : reinterpret_cast<std::ofstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset), amount * sizeof(typename View::value_t));
                              break;

               case e_rdwrt : reinterpret_cast<std::fstream*>(stream_ptr)->
                                 write(reinterpret_cast<char_cptr>(view.begin() + offset) , amount * sizeof(typename View::value_t));
                              break;

               default      : return false;
            }

            return true;
         }

// Assembly:
movl 0x8(%rdi), %eax
cmpl $0x4, %eax
je 0x17a61a
cmpl $0x2, %eax
jne 0x17a635
movq (%rdi), %rdi
jmp 0x17a621
movq (%rdi), %rdi
addq $0x10, %rdi
pushq %rax
addq 0x8(%rsi), %rcx
movq %rcx, %rsi
callq 0x1162d0
movb $0x1, %al
addq $0x8, %rsp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::rtl::io::file::read<double>::operator()(unsigned long const&, exprtk::type_store<double>::parameter_list)
inline T operator() (const std::size_t& ps_index, parameter_list_t parameters) exprtk_override
      {
         details::file_descriptor* fd = details::make_handle(scalar_t(parameters[0])());

         switch (ps_index)
         {
            case 0  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount = buffer.size();
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }

            case 1  : {
                         string_t buffer(parameters[1]);
                         const std::size_t amount =
                                  std::min(buffer.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(buffer,amount) ? 1 : 0);
                      }

            case 2  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount = vec.size();
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }

            case 3  : {
                         vector_t vec(parameters[1]);
                         const std::size_t amount =
                                  std::min(vec.size(),
                                           static_cast<std::size_t>(scalar_t(parameters[2])()));
                         return T(fd->read(vec,amount) ? 1 : 0);
                      }
         }

         return T(0);
      }

// Assembly:
movq (%rsi), %rcx
cmpq $0x3, %rcx
ja 0x17a78f
subq $0x18, %rsp
movq (%rdx), %rax
movq (%rax), %rdx
movq (%rdx), %rdi
leaq 0xd7005(%rip), %rdx     # 0x2516ac
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x17a77c
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x20(%rax), %rdx
jmp 0x17a72d
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0xd5991(%rip), %xmm0    # 0x2500a8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x17a7bc
jmp 0x17a783
leaq 0x18(%rax), %rcx
leaq 0x8(%rsp), %rsi
movq %rcx, (%rsi)
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq 0x30(%rax), %rcx
movsd (%rcx), %xmm0
cvttsd2si %xmm0, %rcx
movq 0x20(%rax), %rax
movq %rcx, %r8
subsd 0xd5942(%rip), %xmm0    # 0x2500a8
sarq $0x3f, %r8
cvttsd2si %xmm0, %rdx
andq %r8, %rdx
orq %rcx, %rdx
cmpq %rdx, %rax
cmovbq %rax, %rdx
xorl %ecx, %ecx
callq 0x17a794
movzbl %al, %eax
cvtsi2sd %eax, %xmm0
addq $0x18, %rsp
retq
xorps %xmm0, %xmm0
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::trim_whitespace(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string trim_whitespace(std::string s)
   {
      static const std::string whitespace(" \n\r\t\b\v\f");

      if (!s.empty())
      {
         s.erase(0,s.find_first_not_of(whitespace));

         if (!s.empty())
         {
            std::size_t index = s.find_last_not_of(whitespace);

            if (std::string::npos != index)
               s.erase(index + 1);
            else
               s.clear();
         }
      }

      return s;
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movb 0x1a2c16(%rip), %al     # 0x3effd8
testb %al, %al
je 0x24d43e
cmpq $0x0, 0x8(%r14)
je 0x24d428
leaq 0x1a2be4(%rip), %rsi    # 0x3effb8
movq %r14, %rdi
xorl %edx, %edx
callq 0x1165d0
movq %r14, %rdi
xorl %esi, %esi
movq %rax, %rdx
callq 0x116430
cmpq $0x0, 0x8(%r14)
je 0x24d428
leaq 0x1a2bbf(%rip), %rsi    # 0x3effb8
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x116760
cmpq $-0x1, %rax
je 0x24d41d
incq %rax
pushq $-0x1
popq %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x116430
jmp 0x24d428
andq $0x0, 0x8(%r14)
movq (%r14), %rax
movb $0x0, (%rax)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1164e0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x1a2b93(%rip), %rdi    # 0x3effd8
callq 0x1161f0
testl %eax, %eax
je 0x24d3c6
leaq 0x1a2b5f(%rip), %rdi    # 0x3effb8
leaq 0xcd69(%rip), %rsi      # 0x25a1c9
leaq 0x7(%rsp), %rdx
callq 0x118498
movq 0x19fb6f(%rip), %rdi    # 0x3ecfe0
leaq 0x1a2b40(%rip), %rsi    # 0x3effb8
leaq 0x19ff41(%rip), %rdx    # 0x3ed3c0
callq 0x116560
leaq 0x1a2b4d(%rip), %rdi    # 0x3effd8
callq 0x116370
jmp 0x24d3c6
movq %rax, %rbx
leaq 0x1a2b39(%rip), %rdi    # 0x3effd8
callq 0x116270
movq %rbx, %rdi
callq 0x116400
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::list_symbols()
void list_symbols()
   {
      std::deque<std::pair<std::string,T> > variable_list;
      symbol_table_.get_variable_list(variable_list);

      std::size_t max_varname_length = 0;

      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         max_varname_length = std::max(max_varname_length,variable_list[i].first.size());
      }

      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         int pad_length = 0;

         if (max_varname_length > variable_list[i].first.size())
         {
            pad_length = static_cast<int>(max_varname_length - variable_list[i].first.size());
         }

         printf("%02d %s%*.*s %25.10f\n",
                static_cast<unsigned int>(i),
                variable_list[i].first.c_str(),
                pad_length,
                pad_length,
                std::string(max_varname_length,' ').c_str(),
                variable_list[i].second);
      }
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x24d988
addq $0x10, %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x24d914
leaq 0x38(%rsp), %rbx
xorl %r14d, %r14d
leaq 0x28(%rsp), %r15
xorl %r12d, %r12d
movq %r15, %rdi
callq 0x24d92c
cmpq %rax, %r12
jae 0x24d511
movq %rbx, %rdi
movq %r12, %rsi
callq 0x24ded0
movq 0x8(%rax), %rax
cmpq %rax, %r14
cmovbeq %rax, %r14
incq %r12
jmp 0x24d4e9
xorl %r15d, %r15d
leaq 0x28(%rsp), %rdi
callq 0x24d92c
cmpq %rax, %r15
jae 0x24d5be
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24ded0
xorl %ebp, %ebp
cmpq 0x8(%rax), %r14
jbe 0x24d54d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24ded0
movl 0x8(%rax), %eax
movl %r14d, %ebp
subl %eax, %ebp
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24ded0
movq (%rax), %r12
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
pushq $0x20
popq %rdx
callq 0x116390
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x24ded0
movsd 0x20(%rax), %xmm0
leaq 0xcc39(%rip), %rdi      # 0x25a1d1
movl %r15d, %esi
movq %r12, %rdx
movl %ebp, %ecx
movl %ebp, %r8d
movq (%rsp), %r9
movb $0x1, %al
callq 0x116080
movq %r13, %rdi
callq 0x116778
incq %r15
jmp 0x24d514
leaq 0x28(%rsp), %rdi
callq 0x24d93c
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x24d5d9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x24d93c
movq %rbx, %rdi
callq 0x116400
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_arithmetic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_arithmetic(const std::string& arithmetic)
   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;

      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .disable_arithmetic_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1fc0, %rdi           # imm = 0x1FC0
leaq 0x1fc8(%rbx), %r14
callq 0x24e094
cmpq %rax, %r14
je 0x24d63a
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e068
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_assignment(const std::string& assignment)
   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;

      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .disable_assignment_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1ff0, %rdi           # imm = 0x1FF0
leaq 0x1ff8(%rbx), %r14
callq 0x24e0fe
cmpq %rax, %r14
je 0x24d67a
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e0d2
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_disable_inequality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_disable_inequality(const std::string& inequality)
   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;

      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .disable_inequality_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x2020, %rdi           # imm = 0x2020
leaq 0x2028(%rbx), %r14
callq 0x24e168
cmpq %rax, %r14
je 0x24d6ba
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e13c
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_arithmetic(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_arithmetic(const std::string& arithmetic)
   {
      typename std::map<std::string,typename settings_store_t::settings_arithmetic_opr>::iterator itr;

      if (arith_opr_.end() != (itr = arith_opr_.find(arithmetic)))
      {
         parser_.settings()
            .enable_arithmetic_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1fc0, %rdi           # imm = 0x1FC0
leaq 0x1fc8(%rbx), %r14
callq 0x24e094
cmpq %rax, %r14
je 0x24d6fa
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e1a6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_assignment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_assignment(const std::string& assignment)
   {
      typename std::map<std::string,typename settings_store_t::settings_assignment_opr>::iterator itr;

      if (assign_opr_.end() != (itr = assign_opr_.find(assignment)))
      {
         parser_.settings()
            .enable_assignment_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x1ff0, %rdi           # imm = 0x1FF0
leaq 0x1ff8(%rbx), %r14
callq 0x24e0fe
cmpq %rax, %r14
je 0x24d73a
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e244
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_enable_inequality(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void process_enable_inequality(const std::string& inequality)
   {
      typename std::map<std::string,typename settings_store_t::settings_inequality_opr>::iterator itr;

      if (inequality_opr_.end() != (itr = inequality_opr_.find(inequality)))
      {
         parser_.settings()
            .enable_inequality_operation(itr->second);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x2020, %rdi           # imm = 0x2020
leaq 0x2028(%rbx), %r14
callq 0x24e168
cmpq %rax, %r14
je 0x24d77a
addq $0xf0, %rbx
movl 0x40(%rax), %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x24e294
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::disable_arithmetic_operation(exprtk::parser<double>::settings_store::settings_arithmetic_opr)
settings_store& disable_arithmetic_operation(const settings_arithmetic_opr arithmetic)
         {
            if (
                 (e_arith_unknown != arithmetic) &&
                 (static_cast<std::size_t>(arithmetic) < (details::arithmetic_ops_list_size + 1))
               )
            {
               disabled_arithmetic_set_.insert(details::arithmetic_ops_list[arithmetic - 1]);
            }

            return (*this);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x24e08f
leaq 0xa0(%rbx), %rdi
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1a0be9(%rip), %rsi    # 0x3eec70
addq %rax, %rsi
callq 0x1254bc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::disable_assignment_operation(exprtk::parser<double>::settings_store::settings_assignment_opr)
settings_store& disable_assignment_operation(const settings_assignment_opr assignment)
         {
            if (
                 (e_assign_unknown != assignment) &&
                 (static_cast<std::size_t>(assignment) < (details::assignment_ops_list_size + 1))
               )
            {
               disabled_assignment_set_.insert(details::assignment_ops_list[assignment - 1]);
            }

            return (*this);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x24e0f9
leaq 0xd0(%rbx), %rdi
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1a0c3f(%rip), %rsi    # 0x3eed30
addq %rax, %rsi
callq 0x1254bc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::disable_inequality_operation(exprtk::parser<double>::settings_store::settings_inequality_opr)
settings_store& disable_inequality_operation(const settings_inequality_opr inequality)
         {
            if (
                 (e_ineq_unknown != inequality) &&
                 (static_cast<std::size_t>(inequality) < (details::inequality_ops_list_size + 1))
               )
            {
               disabled_inequality_set_.insert(details::inequality_ops_list[inequality - 1]);
            }

            return (*this);
         }

// Assembly:
pushq %rbx
movq %rdi, %rbx
decl %esi
cmpl $0x7, %esi
ja 0x24e163
leaq 0x100(%rbx), %rdi
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1a0c95(%rip), %rsi    # 0x3eedf0
addq %rax, %rsi
callq 0x1254bc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_arithmetic_operation(exprtk::parser<double>::settings_store::settings_arithmetic_opr)
settings_store& enable_arithmetic_operation(const settings_arithmetic_opr arithmetic)
         {
            if (
                 (e_arith_unknown != arithmetic) &&
                 (static_cast<std::size_t>(arithmetic) < (details::arithmetic_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_arithmetic_set_.find(details::arithmetic_ops_list[arithmetic - 1]);

               if (disabled_arithmetic_set_.end() != itr)
               {
                  disabled_arithmetic_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x24e1ea
leaq 0xa0(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1a0aa8(%rip), %rsi    # 0x3eec70
addq %rax, %rsi
movq %r14, %rdi
callq 0x122722
leaq 0xa8(%rbx), %rcx
cmpq %rax, %rcx
je 0x24e1ea
movq %r14, %rdi
movq %rax, %rsi
callq 0x24e1f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_assignment_operation(exprtk::parser<double>::settings_store::settings_assignment_opr)
settings_store& enable_assignment_operation(const settings_assignment_opr assignment)
         {
            if (
                 (e_assign_unknown != assignment) &&
                 (static_cast<std::size_t>(assignment) < (details::assignment_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_assignment_set_.find(details::assignment_ops_list[assignment - 1]);

               if (disabled_assignment_set_.end() != itr)
               {
                  disabled_assignment_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x5, %esi
ja 0x24e288
leaq 0xd0(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1a0aca(%rip), %rsi    # 0x3eed30
addq %rax, %rsi
movq %r14, %rdi
callq 0x122722
leaq 0xd8(%rbx), %rcx
cmpq %rax, %rcx
je 0x24e288
movq %r14, %rdi
movq %rax, %rsi
callq 0x24e1f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/./exprtk.hpp
// Function: exprtk::parser<double>::settings_store::enable_inequality_operation(exprtk::parser<double>::settings_store::settings_inequality_opr)
settings_store& enable_inequality_operation(const settings_inequality_opr inequality)
         {
            if (
                 (e_ineq_unknown != inequality) &&
                 (static_cast<std::size_t>(inequality) < (details::inequality_ops_list_size + 1))
               )
            {
               const des_itr_t itr = disabled_inequality_set_.find(details::inequality_ops_list[inequality - 1]);

               if (disabled_inequality_set_.end() != itr)
               {
                  disabled_inequality_set_.erase(itr);
               }
            }

            return (*this);
         }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
decl %esi
cmpl $0x7, %esi
ja 0x24e2d8
leaq 0x100(%rbx), %r14
movl %esi, %eax
shlq $0x5, %rax
leaq 0x1a0b3a(%rip), %rsi    # 0x3eedf0
addq %rax, %rsi
movq %r14, %rdi
callq 0x122722
leaq 0x108(%rbx), %rcx
cmpq %rax, %rcx
je 0x24e2d8
movq %r14, %rdi
movq %rax, %rsi
callq 0x24e1f6
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::setup_symbol_table()
void setup_symbol_table()
   {
      if (!persist_symbol_table_)
      {
         symbol_table_.clear_variables();
         symbol_table_.add_constants  ();
         symbol_table_.add_constant ("e", exprtk::details::numeric::constant::e);
      }
   }

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x0, (%rdi)
jne 0x24e33f
movq %rdi, %rbx
addq $0x10, %rbx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x11be0a
movq %rbx, %rdi
callq 0x11af98
leaq 0x7f98(%rip), %rsi      # 0x2562a9
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x118498
leaq 0x25f3e(%rip), %rdx     # 0x274268
movq %rbx, %rdi
movq %r14, %rsi
callq 0x17efa4
leaq 0x8(%rsp), %rdi
callq 0x116778
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x116778
movq %rbx, %rdi
callq 0x116400
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::perform_symbol_dump(std::vector<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, exprtk::parser<double>::symbol_type>>> const&) const
void perform_symbol_dump(const symbol_list_t& variable_list) const
   {
      for (std::size_t i = 0; i < variable_list.size(); ++i)
      {
         const symbol_t& symbol = variable_list[i];

         switch (symbol.second)
         {
            case parser_t::e_st_variable : printf("[%02d] Variable  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            case parser_t::e_st_vector   : printf("[%02d] Vector    %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            case parser_t::e_st_string   : printf("[%02d] String    %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            case parser_t::e_st_function : printf("[%02d] Function  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            case parser_t::e_st_local_variable
                                         : printf("[%02d] LocalVar  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            case parser_t::e_st_local_vector
                                         : printf("[%02d] LocalVec  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            case parser_t::e_st_local_string
                                         : printf("[%02d] LocalStr  %s\n",
                                                  static_cast<int>(i),symbol.first.c_str());
                                           break;

            default                      : break;
         }
      }
   }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
pushq $0x20
popq %r15
pushq $0x28
popq %r12
movl $0xfb, %ebp
leaq 0x25a30(%rip), %r13     # 0x274284
xorl %r14d, %r14d
movq (%rbx), %rcx
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %rax, %r14
jae 0x24e89d
movl (%rcx,%r15), %eax
decl %eax
cmpl $0x7, %eax
ja 0x24e894
btl %eax, %ebp
jae 0x24e894
movl %eax, %eax
movslq (%r13,%rax,4), %rdi
addq %r13, %rdi
movq -0x20(%rcx,%r15), %rdx
movl %r14d, %esi
xorl %eax, %eax
callq 0x116080
incq %r14
addq $0x28, %r15
jmp 0x24e857
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/eecs280staff[P]unit_test_framework/./unit_test_framework.hpp
// Function: unit_test_framework::Assertions::assert_almost_equal(double, double, double, int, char const*)
static void assert_almost_equal(double first, double second,
                                    double precision, int line_number,
                                    const char* assertion_text) {
      if (std::abs(first - second) <= precision) {
        return;
      }
      std::ostringstream reason;
      // For now, we'll just set the precision arbitrarily high.
      // In the future, we may decide to add an option to configure
      // the output precision.
      reason.precision(20);
      reason << "Values too far apart: " << first << " and " << second;
      throw TestFailure(reason.str(), line_number, assertion_text);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1b0, %rsp            # imm = 0x1B0
movapd %xmm0, %xmm3
subsd %xmm1, %xmm3
andpd 0xce1b(%rip), %xmm3     # 0x12030
ucomisd %xmm3, %xmm2
jb 0x5227
addq $0x1b0, %rsp            # imm = 0x1B0
popq %rbx
popq %r14
popq %rbp
retq
movq %rsi, %rbx
movl %edi, %ebp
movsd %xmm0, 0x10(%rsp)
movsd %xmm1, 0x8(%rsp)
leaq 0x38(%rsp), %r14
movq %r14, %rdi
callq 0x43d0
movq (%r14), %rax
movq -0x18(%rax), %rax
movq $0x14, 0x40(%rsp,%rax)
leaq 0xcfbf(%rip), %rsi      # 0x1221b
movq %r14, %rdi
callq 0x42d0
movq %rax, %rdi
movsd 0x10(%rsp), %xmm0
callq 0x4470
leaq 0xcfb9(%rip), %rsi      # 0x12232
movq %rax, %rdi
callq 0x42d0
movq %rax, %rdi
movsd 0x8(%rsp), %xmm0
callq 0x4470
pushq $0x30
popq %rdi
callq 0x4170
movq %rax, %r14
leaq 0x40(%rsp), %rsi
leaq 0x18(%rsp), %rdi
callq 0x4460
movq %r14, %rcx
addq $0x10, %rcx
movq %rcx, (%r14)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
jne 0x52cb
movupd (%rax), %xmm0
movupd %xmm0, (%rcx)
jmp 0x52d7
movq %rdx, (%r14)
movq 0x28(%rsp), %rcx
movq %rcx, 0x10(%r14)
movq 0x20(%rsp), %rcx
movq %rcx, 0x8(%r14)
movq %rax, 0x18(%rsp)
andq $0x0, 0x20(%rsp)
movb $0x0, 0x28(%rsp)
movl %ebp, 0x20(%r14)
movq %rbx, 0x28(%r14)
leaq 0x17791(%rip), %rsi     # 0x1ca90
leaq -0x112(%rip), %rdx      # 0x51f4
movq %r14, %rdi
callq 0x44c0
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x4140
jmp 0x532d
movq %rax, %rbx
movq %r14, %rdi
callq 0x4240
jmp 0x532d
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x4080
movq %rbx, %rdi
callq 0x44f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_string(std::basic_ifstream<char, std::char_traits<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
bool read_string(std::ifstream& f, std::string& ret, bool terminate) {
    uint32_t len = read_arbitrary<uint32_t>(f, 4);
    int start = f.tellg();
    int end = start + len;
    ret.resize(end - start);
    f.read(&ret[0], end - start);
    if (terminate) {
        uint16_t z = read_arbitrary<uint16_t>(f, 1);
        // For whatever reason the string is padded with an arbitrary amount of zeroes
        if (0 != z)
            return false; // If there is no zero, a string16 won't follow
        int count = 0;
        while (0 == z) {
            count += 1;
            z = read_arbitrary<uint16_t>(f, 1);
        }
        if (count > 3)
            return false;
        f.seekg(f.tellg() - 1L);

    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x4
popq %rsi
callq 0x46df
movl %eax, %r12d
movq %rbx, %rdi
callq 0x31e0
movslq %r12d, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x3170
movq (%r14), %rsi
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3140
movb $0x1, %r14b
testl %r15d, %r15d
je 0x3438
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x46fd
xorl %r14d, %r14d
testw %ax, %ax
jne 0x3438
pushq $0x1
popq %r15
xorl %eax, %eax
testw %ax, %ax
jne 0x3416
incl %r14d
movq %rbx, %rdi
movl %r15d, %esi
callq 0x46fd
jmp 0x3401
cmpl $0x3, %r14d
ja 0x3435
movq %rbx, %rdi
callq 0x31e0
leaq -0x1(%rax), %rsi
movq %rbx, %rdi
callq 0x3150
movb $0x1, %r14b
jmp 0x3438
xorl %r14d, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_string16[abi:cxx11](std::basic_ifstream<char, std::char_traits<char>>&, bool)
std::wstring read_string16(std::ifstream& f, bool terminate) {
    uint32_t len = read_arbitrary<uint32_t>(f, 4) * 2; // *2 because UTF-16
#ifdef DEBUG
    std::cout << "Reading string16: " << std::endl;
    std::cout << std::dec << len << std::endl;
    std::cout << std::hex << f.tellg() << std::endl;
    std::cout << std::dec;
#endif
    char tmp[len];
    read_char(f, tmp, len);
    if (terminate) {
        read_arbitrary<uint16_t>(f, 1); // String is null terminated with 0x00
    }

    if (len % 2) { len--; }
    std::wstring ret;
    for (size_t i = 0; i < len;) {
        // little-endian
        int lo = tmp[i++] & 0xFF;
        int hi = tmp[i++] & 0xFF;
        ret.push_back(hi << 8 | lo);
    }
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0x46df
leal (%rax,%rax), %r14d
leaq 0xf(%r14), %rax
andq $-0x10, %rax
movq %rsp, %r15
subq %rax, %r15
movq %r15, %rsp
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x3390
testl %r13d, %r13d
je 0x3499
pushq $0x1
popq %rsi
movq %r12, %rdi
callq 0x46fd
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
andl $0x0, 0x10(%rbx)
xorl %r12d, %r12d
cmpq %r14, %r12
jae 0x34c4
movzwl (%r15,%r12), %esi
movq %rbx, %rdi
callq 0x3090
addq $0x2, %r12
jmp 0x34ac
movq %rbx, %rax
leaq -0x28(%rbp), %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3030
movq %r14, %rdi
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: get_file_size(std::basic_ifstream<char, std::char_traits<char>>&)
int get_file_size(std::ifstream& f) {
    f.seekg(0, std::ios::end);
    int filesize = f.tellg();
    f.seekg(0);
    return filesize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x3160
movq %rbx, %rdi
callq 0x31e0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3150
movl %r14d, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: open_and_check_file(std::basic_ifstream<char, std::char_traits<char>>&, int*)
bool open_and_check_file(std::ifstream& f, int *filesize) {
    *filesize = get_file_size(f);

    char magic[4] = "";
    read_char(f, magic, 4);
    read_arbitrary<uint32_t>(f, 4); // version

    if (0 != std::strncmp("SNSS", magic, 4)) {
        std::cerr << "Error: Not a valid SNSS file." << std::endl;
        return false;
    }

    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x4132
movl %eax, (%rbx)
leaq -0x14(%rbp), %rbx
andl $0x0, (%rbx)
pushq $0x4
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3140
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x46df
movl (%rbx), %ebx
cmpl $0x53534e53, %ebx       # imm = 0x53534E53
je 0x41c2
movq 0x5e42(%rip), %rdi      # 0x9ff0
leaq 0x1f40(%rip), %rsi      # 0x60f5
callq 0x3110
movq %rax, %rdi
callq 0x30c0
cmpl $0x53534e53, %ebx       # imm = 0x53534E53
sete %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_session_file(std::basic_ifstream<char, std::char_traits<char>>&)
std::vector<std::shared_ptr<Command>> read_session_file(std::ifstream& f) {
    int filesize;
    if (!open_and_check_file(f, &filesize))
        return {};

    std::vector<std::shared_ptr<Command>> ret;

    while (f.tellg() < filesize) {
        std::shared_ptr<Command> c = read_next_session_command(f);
        ret.push_back(c);

        if (c->size == 0) {
            break;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq 0x4165
xorps %xmm0, %xmm0
testb %al, %al
je 0x424b
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
movslq -0x2c(%rbp), %r13
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x31e0
cmpq %r13, %rax
jge 0x4253
movq %r12, %rdi
movq %r14, %rsi
callq 0x3550
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4938
movq -0x40(%rbp), %rax
movzwl 0x8(%rax), %r15d
leaq -0x38(%rbp), %rdi
callq 0x4a10
testw %r15w, %r15w
jne 0x420e
jmp 0x4253
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4a10
jmp 0x4278
jmp 0x4275
movq %rax, %r14
movq %rbx, %rdi
callq 0x4974
movq %r14, %rdi
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_session_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::shared_ptr<Command>> read_session_file(const std::string& filename) {
    std::ifstream f(filename, std::ios::binary | std::ios::in);
    if (!f.is_open() || f.fail()) {
        std::cerr << "Error while trying to open file " << filename << "." << std::endl;
        return {};
    }

    std::vector<std::shared_ptr<Command>> ret;
    ret = read_session_file(f);
    f.close();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x230(%rbp), %rdi
pushq $0xc
popq %rdx
callq 0x31a0
leaq -0x1b8(%rbp), %rdi
callq 0x3050
testb %al, %al
je 0x42d0
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0x432b
movq 0x5d19(%rip), %rdi      # 0x9ff0
leaq 0x1e35(%rip), %rsi      # 0x6113
callq 0x3110
movq %rax, %rdi
movq %r14, %rsi
callq 0x3100
leaq 0x1e1c(%rip), %rsi      # 0x6111
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x30c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq -0x230(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq -0x28(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x41d4
leaq -0x28(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a2c
movq %r14, %rdi
callq 0x4974
leaq -0x230(%rbp), %rdi
callq 0x3040
jmp 0x4310
jmp 0x436d
movq %rax, %r14
movq %rbx, %rdi
callq 0x4974
jmp 0x437d
movq %rax, %r14
leaq -0x230(%rbp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_tabs_file(std::basic_ifstream<char, std::char_traits<char>>&)
std::vector<std::shared_ptr<Command>> read_tabs_file(std::ifstream& f) {
    int filesize;
    if (!open_and_check_file(f, &filesize))
        return {};

    std::vector<std::shared_ptr<Command>> ret;

    while (f.tellg() < filesize) {
        std::shared_ptr<Command> c = read_next_tab_command(f);
        ret.push_back(c);

        if (c->size == 0) {
            break;
        }
    }

    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x2c(%rbp), %rsi
movq %r14, %rdi
callq 0x4165
xorps %xmm0, %xmm0
testb %al, %al
je 0x4408
andq $0x0, 0x10(%rbx)
movups %xmm0, (%rbx)
movslq -0x2c(%rbp), %r13
leaq -0x40(%rbp), %r12
movq %r14, %rdi
callq 0x31e0
cmpq %r13, %rax
jge 0x4410
movq %r12, %rdi
movq %r14, %rsi
callq 0x3c99
movq %rbx, %rdi
movq %r12, %rsi
callq 0x4938
movq -0x40(%rbp), %rax
movzwl 0x8(%rax), %r15d
leaq -0x38(%rbp), %rdi
callq 0x4a10
testw %r15w, %r15w
jne 0x43cb
jmp 0x4410
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x4a10
jmp 0x4435
jmp 0x4432
movq %rax, %r14
movq %rbx, %rdi
callq 0x4974
movq %r14, %rdi
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/../snss-parse-lib.hpp
// Function: read_tabs_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<std::shared_ptr<Command>> read_tabs_file(const std::string& filename) {
    std::ifstream f(filename, std::ios::binary | std::ios::in);
    if (!f.is_open() || f.fail()) {
        std::cerr << "Error while trying to open file " << filename << "." << std::endl;
        return {};
    }

    std::vector<std::shared_ptr<Command>> ret;
    ret = read_tabs_file(f);
    f.close();
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x220, %rsp            # imm = 0x220
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x230(%rbp), %rdi
pushq $0xc
popq %rdx
callq 0x31a0
leaq -0x1b8(%rbp), %rdi
callq 0x3050
testb %al, %al
je 0x448d
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0x44e8
movq 0x5b5c(%rip), %rdi      # 0x9ff0
leaq 0x1c78(%rip), %rsi      # 0x6113
callq 0x3110
movq %rax, %rdi
movq %r14, %rsi
callq 0x3100
leaq 0x1c5f(%rip), %rsi      # 0x6111
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x30c0
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq -0x230(%rbp), %rdi
callq 0x3060
movq %rbx, %rax
addq $0x220, %rsp            # imm = 0x220
popq %rbx
popq %r14
popq %rbp
retq
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
andq $0x0, 0x10(%rbx)
leaq -0x28(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x4391
leaq -0x28(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5a2c
movq %r14, %rdi
callq 0x4974
leaq -0x230(%rbp), %rdi
callq 0x3040
jmp 0x44cd
jmp 0x452a
movq %rax, %r14
movq %rbx, %rdi
callq 0x4974
jmp 0x453a
movq %rax, %r14
leaq -0x230(%rbp), %rdi
callq 0x3060
movq %r14, %rdi
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/instance01[P]chromium-snss-parse/examples/parse_print_types.cpp
// Function: main
int main(int argc, char* argv[]) {
    if (argc != 2) {
        std::cout << "Usage: " << argv[0] << " <filename>" << std::endl;
        std::cout << "For example on ArchLinux you could try and parse ";
        std::cout << "~/.config/chromium/Default/Current Session" << std::endl;
    }

    std::ifstream f(argv[1], std::ios::binary | std::ios::in);
    if (!f.is_open() || f.fail())
        return 1;

    std::vector<std::shared_ptr<Command>> cmds = read_session_file(f);

    for (auto & x : cmds) {
        std::cout << " Size: " << x->size << " Type: " << static_cast<uint16_t>(x->type) << std::endl;
    }

    f.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
cmpl $0x2, %edi
je 0x45c8
movq 0x5a5f(%rip), %r14      # 0x9fd0
leaq 0x1bbc(%rip), %rsi      # 0x6134
movq %r14, %rdi
callq 0x3110
movq (%rbx), %rsi
movq %rax, %rdi
callq 0x3110
leaq 0x1baa(%rip), %rsi      # 0x613c
movq %rax, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x30c0
leaq 0x1b9f(%rip), %rsi      # 0x6148
movq %r14, %rdi
callq 0x3110
leaq 0x1bc2(%rip), %rsi      # 0x617a
movq %r14, %rdi
callq 0x3110
movq %rax, %rdi
callq 0x30c0
movq 0x8(%rbx), %rsi
leaq -0x248(%rbp), %rdi
pushq $0xc
popq %rdx
callq 0x3200
leaq -0x1d0(%rbp), %rdi
callq 0x3050
pushq $0x1
popq %rbx
testb %al, %al
je 0x4698
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x228(%rbp,%rax)
jne 0x4698
leaq -0x40(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x41d4
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r13
movq 0x59a6(%rip), %rbx      # 0x9fd0
leaq 0x1b74(%rip), %r14      # 0x61a5
leaq 0x1b75(%rip), %r15      # 0x61ad
cmpq %r13, %r12
je 0x4681
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3110
movq (%r12), %rcx
movzwl 0x8(%rcx), %esi
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x3110
movq (%r12), %rcx
movzwl 0xc(%rcx), %esi
movq %rax, %rdi
callq 0x31c0
movq %rax, %rdi
callq 0x30c0
addq $0x10, %r12
jmp 0x4638
leaq -0x248(%rbp), %rdi
callq 0x3040
leaq -0x40(%rbp), %rdi
callq 0x4974
xorl %ebx, %ebx
leaq -0x248(%rbp), %rdi
callq 0x3060
movl %ebx, %eax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x46bf
movq %rax, %rbx
jmp 0x46cb
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4974
leaq -0x248(%rbp), %rdi
callq 0x3060
movq %rbx, %rdi
callq 0x31f0
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::MakeInteractionWith(Species*, double)
void Species::MakeInteractionWith(Species* other, double coefficient) {
  m_incomingInteractions.insert( std::make_pair(other, coefficient) );
  m_fitness += coefficient;
  other->m_outgoingInteractions.insert(this);
  other->m_cacheReady = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
leaq 0x10(%rsp), %r15
movq %rsi, (%r15)
movsd %xmm0, 0x8(%r15)
movq %r15, %rsi
callq 0x402e
movsd 0x8(%rsp), %xmm0
addsd 0x68(%r14), %xmm0
movsd %xmm0, 0x68(%r14)
leaq 0x38(%rbx), %rdi
movq %r14, (%r15)
leaq 0x10(%rsp), %rsi
callq 0x41c6
movb $0x0, 0x88(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::DeleteInteractions(std::set<Species*, Species::comp, std::allocator<Species*>>&)
void Species::DeleteInteractions( SpeciesSet& dyingSpecies) {
  for( auto pair : m_incomingInteractions ) {
    pair.first->m_outgoingInteractions.erase(this);
    pair.first->m_cacheReady = false;
  }
  for( auto other : m_outgoingInteractions ) {
    auto found = other->m_incomingInteractions.find(this);
    other->m_fitness -= found->second;
    other->m_incomingInteractions.erase(found);

    if( other->IsGoingExtinct() ) {
      dyingSpecies.insert(other);
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r12
leaq 0x10(%rdi), %r13
leaq 0x8(%rsp), %r15
cmpq %r13, %r12
je 0x24b0
movq 0x20(%r12), %rbp
leaq 0x38(%rbp), %rdi
movq %r14, 0x8(%rsp)
movq %r15, %rsi
callq 0x42ea
movb $0x0, 0x88(%rbp)
movq %r12, %rdi
callq 0x2120
movq %rax, %r12
jmp 0x2481
movq 0x50(%r14), %r12
leaq 0x40(%r14), %rbp
leaq 0x10(%rsp), %r15
leaq 0x8(%rsp), %r13
cmpq %rbp, %r12
je 0x2531
movq 0x20(%r12), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
movq %r14, 0x10(%rsp)
movq %r15, %rsi
callq 0x44a2
movq 0x8(%rsp), %rdi
movsd 0x68(%rdi), %xmm0
subsd 0x28(%rax), %xmm0
movsd %xmm0, 0x68(%rdi)
addq $0x8, %rdi
movq %rax, %rsi
callq 0x4502
movq 0x8(%rsp), %rax
xorpd %xmm0, %xmm0
ucomisd 0x68(%rax), %xmm0
jbe 0x2524
cmpq $0x0, 0x30(%rax)
je 0x2524
movq %rbx, %rdi
movq %r13, %rsi
callq 0x454e
movq %r12, %rdi
callq 0x21e0
movq %rax, %r12
jmp 0x24c2
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq