LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
cmpb $0x0, 0x1f94cc(%rip)    # 0x6780d8
jne 0x47ec76
leaq 0x1f94c3(%rip), %rdi    # 0x6780d8
callq 0x119310
cmpl $0x0, %eax
je 0x47ec76
leaq 0x3f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x1197d0
movq (%rsp), %rdx
leaq 0x1f9480(%rip), %rdi    # 0x6780b8
leaq 0x12a7d(%rip), %rsi     # 0x4916bc
callq 0x120970
jmp 0x47ec46
leaq 0x3f(%rsp), %rdi
callq 0x119950
movq 0x1f6389(%rip), %rdi    # 0x674fe0
leaq 0x1f945a(%rip), %rsi    # 0x6780b8
leaq 0x1f6853(%rip), %rdx    # 0x6754b8
callq 0x1196f0
leaq 0x1f9467(%rip), %rdi    # 0x6780d8
callq 0x1194d0
movq 0x8(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x47ed37
movq 0x8(%rsp), %rdi
leaq 0x1f9424(%rip), %rsi    # 0x6780b8
xorl %eax, %eax
movl %eax, %edx
callq 0x119770
movq 0x8(%rsp), %rdi
movq %rax, %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x1195c0
movq 0x8(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x47ed35
movq 0x8(%rsp), %rdi
leaq 0x1f93f0(%rip), %rsi    # 0x6780b8
movq $-0x1, %rdx
callq 0x119940
movq %rax, 0x20(%rsp)
movq $-0x1, %rax
cmpq 0x20(%rsp), %rax
je 0x47ed29
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
addq $0x1, %rsi
movq $-0x1, %rdx
callq 0x1195c0
jmp 0x47ed33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x119950
leaq 0x1f93b6(%rip), %rdi    # 0x6780d8
callq 0x1193a0
jmp 0x47ed50
movq 0x8(%rsp), %rdi
callq 0x1194b0
jmp 0x47ed35
jmp 0x47ed37
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
callq 0x119780
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x119570
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x481210
movq 0x8(%rsp), %rdi
addq $0x1fc0, %rdi           # imm = 0x1FC0
callq 0x2791e0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x1fc0, %rdi           # imm = 0x1FC0
movq 0x28(%rsp), %rsi
callq 0x481250
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x481230
testb $0x1, %al
jne 0x47f192
jmp 0x47f1ba
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x432660
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4812f0
movq (%rsp), %rdi
movl 0x20(%rax), %esi
callq 0x481280
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4813d0
movq 0x8(%rsp), %rdi
addq $0x1ff0, %rdi           # imm = 0x1FF0
callq 0x27a230
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x1ff0, %rdi           # imm = 0x1FF0
movq 0x28(%rsp), %rsi
callq 0x481410
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4813f0
testb $0x1, %al
jne 0x47f232
jmp 0x47f25a
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x432660
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4814b0
movq (%rsp), %rdi
movl 0x20(%rax), %esi
callq 0x481440
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x481590
movq 0x8(%rsp), %rdi
addq $0x2020, %rdi           # imm = 0x2020
callq 0x27b280
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x2020, %rdi           # imm = 0x2020
movq 0x28(%rsp), %rsi
callq 0x4815d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4815b0
testb $0x1, %al
jne 0x47f2d2
jmp 0x47f2fa
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x432660
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x481670
movq (%rsp), %rdi
movl 0x20(%rax), %esi
callq 0x481600
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x481210
movq 0x8(%rsp), %rdi
addq $0x1fc0, %rdi           # imm = 0x1FC0
callq 0x2791e0
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x1fc0, %rdi           # imm = 0x1FC0
movq 0x28(%rsp), %rsi
callq 0x481250
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x481230
testb $0x1, %al
jne 0x47f372
jmp 0x47f39a
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x432660
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4812f0
movq (%rsp), %rdi
movl 0x20(%rax), %esi
callq 0x481750
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4813d0
movq 0x8(%rsp), %rdi
addq $0x1ff0, %rdi           # imm = 0x1FF0
callq 0x27a230
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x1ff0, %rdi           # imm = 0x1FF0
movq 0x28(%rsp), %rsi
callq 0x481410
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4813f0
testb $0x1, %al
jne 0x47f412
jmp 0x47f43a
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x432660
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x4814b0
movq (%rsp), %rdi
movl 0x20(%rax), %esi
callq 0x481970
addq $0x38, %rsp
retq
nop
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x481590
movq 0x8(%rsp), %rdi
addq $0x2020, %rdi           # imm = 0x2020
callq 0x27b280
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
addq $0x2020, %rdi           # imm = 0x2020
movq 0x28(%rsp), %rsi
callq 0x4815d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x4815b0
testb $0x1, %al
jne 0x47f4b2
jmp 0x47f4da
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
callq 0x432660
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x481670
movq (%rsp), %rdi
movl 0x20(%rax), %esi
callq 0x481a30
addq $0x38, %rsp
retq
nop
// File: ArashPartow[P]exprtk-extras/exprtk_repl.cpp
// Function: expression_processor<double>::process_multiline()
void process_multiline()
   {
      std::string program;

      for ( ; ; )
      {
         std::string line;

         std::cout << ">> ";
         std::getline(std::cin,line);

         line = trim_whitespace(line);

         if (line.empty())
            continue;
         else if ("$end" == line)
            break;
         else
            program += (line + "\n");
      }

      process(program);
   }

// Assembly:
subq $0xf8, %rsp
movq %rdi, 0xf0(%rsp)
movq 0xf0(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0xd0(%rsp), %rdi
callq 0x119300
leaq 0xb0(%rsp), %rdi
callq 0x119300
movq 0x1f5ab3(%rip), %rdi    # 0x674fd0
leaq 0xd0ae(%rip), %rsi      # 0x48c5d2
callq 0x1194e0
jmp 0x47f52b
movq 0x1f5ab6(%rip), %rdi    # 0x674fe8
leaq 0xb0(%rsp), %rsi
callq 0x119460
jmp 0x47f541
leaq 0x60(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x119150
jmp 0x47f555
movq 0x10(%rsp), %rsi
leaq 0x80(%rsp), %rdi
leaq 0x60(%rsp), %rdx
callq 0x47ebe0
jmp 0x47f56e
leaq 0xb0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x119490
leaq 0x80(%rsp), %rdi
callq 0x119968
leaq 0x60(%rsp), %rdi
callq 0x119968
leaq 0xb0(%rsp), %rdi
callq 0x119270
testb $0x1, %al
jne 0x47f5ad
jmp 0x47f5f6
movl $0x3, 0x5c(%rsp)
jmp 0x47f67f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x47f6af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x119968
jmp 0x47f6af
leaq 0xda30(%rip), %rdi      # 0x48d02d
leaq 0xb0(%rsp), %rsi
callq 0x123630
testb $0x1, %al
jne 0x47f610
jmp 0x47f61a
movl $0x2, 0x5c(%rsp)
jmp 0x47f67f
leaq 0xd945(%rip), %rdx      # 0x48cf66
leaq 0x38(%rsp), %rdi
leaq 0xb0(%rsp), %rsi
callq 0x27e030
jmp 0x47f635
leaq 0xd0(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1190e0
jmp 0x47f649
leaq 0x38(%rsp), %rdi
callq 0x119968
jmp 0x47f675
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x119968
jmp 0x47f6af
jmp 0x47f677
movl $0x0, 0x5c(%rsp)
leaq 0xb0(%rsp), %rdi
callq 0x119968
movl 0x5c(%rsp), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x47f6aa
jmp 0x47f69a
movl 0xc(%rsp), %eax
subl $0x2, %eax
je 0x47f6be
jmp 0x47f6a5
jmp 0x47f509
jmp 0x47f509
leaq 0xb0(%rsp), %rdi
callq 0x119968
jmp 0x47f736
leaq 0x18(%rsp), %rdi
leaq 0xd0(%rsp), %rsi
callq 0x119150
jmp 0x47f6d2
movq 0x10(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x123fa0
jmp 0x47f6e3
leaq 0x18(%rsp), %rdi
callq 0x119968
leaq 0xd0(%rsp), %rdi
callq 0x119968
addq $0xf8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
jmp 0x47f736
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa8(%rsp)
movl %eax, 0xa4(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x119968
leaq 0xd0(%rsp), %rdi
callq 0x119968
movq 0xa8(%rsp), %rdi
callq 0x119570
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x1c(%rsp), %eax
je 0x4812d8
movl 0x1c(%rsp), %eax
cmpq $0x7, %rax
jae 0x4812d8
movq (%rsp), %rdi
addq $0xa0, %rdi
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x1f5aad(%rip), %rsi    # 0x676d70
shlq $0x5, %rax
addq %rax, %rsi
callq 0x14b200
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x1c(%rsp), %eax
je 0x481498
movl 0x1c(%rsp), %eax
cmpq $0x7, %rax
jae 0x481498
movq (%rsp), %rdi
addq $0xd0, %rdi
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x1f59ad(%rip), %rsi    # 0x676e30
shlq $0x5, %rax
addq %rax, %rsi
callq 0x14b200
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x1c(%rsp), %eax
je 0x481658
movl 0x1c(%rsp), %eax
cmpq $0x9, %rax
jae 0x481658
movq (%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl 0x1c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x1f58ad(%rip), %rsi    # 0x676ef0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x14b200
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x2c(%rsp), %eax
je 0x4817f8
movl 0x2c(%rsp), %eax
cmpq $0x7, %rax
jae 0x4817f8
movq (%rsp), %rdi
addq $0xa0, %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x1f55d9(%rip), %rsi    # 0x676d70
shlq $0x5, %rax
addq %rax, %rsi
callq 0x1405d0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0xa0, %rdi
callq 0x1405a0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x140580
testb $0x1, %al
jne 0x4817d2
jmp 0x4817f6
movq (%rsp), %rdi
addq $0xa0, %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x481810
movq %rax, 0x8(%rsp)
jmp 0x4817f8
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x2c(%rsp), %eax
je 0x481a18
movl 0x2c(%rsp), %eax
cmpq $0x7, %rax
jae 0x481a18
movq (%rsp), %rdi
addq $0xd0, %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x1f5479(%rip), %rsi    # 0x676e30
shlq $0x5, %rax
addq %rax, %rsi
callq 0x1405d0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0xd0, %rdi
callq 0x1405a0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x140580
testb $0x1, %al
jne 0x4819f2
jmp 0x481a16
movq (%rsp), %rdi
addq $0xd0, %rdi
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x481810
movq %rax, 0x8(%rsp)
jmp 0x481a18
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
xorl %eax, %eax
cmpl 0x2c(%rsp), %eax
je 0x481ad8
movl 0x2c(%rsp), %eax
cmpq $0x9, %rax
jae 0x481ad8
movq (%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movl 0x2c(%rsp), %eax
subl $0x1, %eax
cltq
leaq 0x1f5479(%rip), %rsi    # 0x676ef0
shlq $0x5, %rax
addq %rax, %rsi
callq 0x1405d0
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x100, %rdi            # imm = 0x100
callq 0x1405a0
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x140580
testb $0x1, %al
jne 0x481ab2
jmp 0x481ad6
movq (%rsp), %rdi
addq $0x100, %rdi            # imm = 0x100
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rsi
callq 0x481810
movq %rax, 0x8(%rsp)
jmp 0x481ad8
movq (%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
testb $0x1, (%rax)
jne 0x481bb4
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
movq %rdi, (%rsp)
movl $0x1, %esi
callq 0x12a640
movq (%rsp), %rdi
callq 0x1269c0
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x1197d0
movq 0x8(%rsp), %rdx
leaq 0xbc2e(%rip), %rsi      # 0x48d775
leaq 0x30(%rsp), %rdi
callq 0x120970
jmp 0x481b53
movq (%rsp), %rdi
leaq 0x10a8a(%rip), %rdx     # 0x4925e8
leaq 0x30(%rsp), %rsi
callq 0x271460
jmp 0x481b6a
leaq 0x30(%rsp), %rdi
callq 0x119968
leaq 0x2f(%rsp), %rdi
callq 0x119950
jmp 0x481bb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
jmp 0x481ba8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x119968
leaq 0x2f(%rsp), %rdi
callq 0x119950
jmp 0x481bb9
addq $0x58, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x119570
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x200, %rsp            # imm = 0x200
movsd %xmm0, -0x8(%rbp)
movsd %xmm1, -0x10(%rbp)
movsd %xmm2, -0x18(%rbp)
movl %edi, -0x1c(%rbp)
movq %rsi, -0x28(%rbp)
movsd -0x8(%rbp), %xmm0
subsd -0x10(%rbp), %xmm0
callq 0x76c0
movaps %xmm0, %xmm1
movsd -0x18(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0x7547
addq $0x200, %rsp            # imm = 0x200
popq %rbp
retq
leaq -0x1a0(%rbp), %rdi
callq 0x5520
movq -0x1a0(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x1a0(%rbp,%rax), %rdi
movl $0x14, %esi
callq 0x76e0
jmp 0x7572
leaq 0x2bd00(%rip), %rsi     # 0x33279
leaq -0x1a0(%rbp), %rdi
callq 0x53a0
movq %rax, -0x1e0(%rbp)
jmp 0x758e
movq -0x1e0(%rbp), %rdi
movsd -0x8(%rbp), %xmm0
callq 0x5710
movq %rax, -0x1e8(%rbp)
jmp 0x75a8
movq -0x1e8(%rbp), %rdi
leaq 0x2bcda(%rip), %rsi     # 0x33290
callq 0x53a0
movq %rax, -0x1f0(%rbp)
jmp 0x75c4
movq -0x1f0(%rbp), %rdi
movsd -0x10(%rbp), %xmm0
callq 0x5710
jmp 0x75d7
movb $0x1, -0x1d1(%rbp)
movl $0x30, %edi
callq 0x51c0
movq %rax, -0x1f8(%rbp)
leaq -0x1d0(%rbp), %rdi
leaq -0x1a0(%rbp), %rsi
callq 0x53e0
jmp 0x7604
movq -0x1f8(%rbp), %rdi
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rcx
leaq -0x1d0(%rbp), %rsi
callq 0x7450
jmp 0x7620
movq -0x1f8(%rbp), %rdi
movb $0x0, -0x1d1(%rbp)
leaq 0x4441b(%rip), %rsi     # 0x4ba50
leaq -0x1ac(%rip), %rdx      # 0x7490
callq 0x5630
jmp 0x76ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x76a2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
jmp 0x7689
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1a8(%rbp)
movl %eax, -0x1ac(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x5260
testb $0x1, -0x1d1(%rbp)
jne 0x7694
jmp 0x76a0
movq -0x1f8(%rbp), %rdi
callq 0x52f0
jmp 0x76a2
leaq -0x1a0(%rbp), %rdi
callq 0x50c0
movq -0x1a8(%rbp), %rdi
callq 0x5680
nopw (%rax,%rax)
// File: 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
subq $0x80, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x5aa0
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3240
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x5ad0
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x18(%rbp), %rdi
movl -0x3c(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rsi
callq 0x31a0
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3280
movq -0x70(%rbp), %rdi
movq %rax, %rsi
movl -0x3c(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rdx
callq 0x3170
testb $0x1, -0x19(%rbp)
je 0x3593
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5af0
movw %ax, -0x3e(%rbp)
movzwl -0x3e(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x3519
movb $0x0, -0x1(%rbp)
jmp 0x3597
movl $0x0, -0x44(%rbp)
movzwl -0x3e(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
jne 0x3547
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5af0
movw %ax, -0x3e(%rbp)
jmp 0x3520
cmpl $0x3, -0x44(%rbp)
jle 0x3553
movb $0x0, -0x1(%rbp)
jmp 0x3597
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3240
movq %rax, -0x68(%rbp)
movq %rdx, -0x60(%rbp)
leaq -0x68(%rbp), %rdi
movl $0x1, %esi
callq 0x5b20
movq -0x78(%rbp), %rdi
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
callq 0x3180
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x5aa0
addl %eax, %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x20(%rbp)
movq %rax, %rcx
addq $0xf, %rcx
andq $-0x10, %rcx
movq %rsp, %rsi
subq %rcx, %rsi
movq %rsi, -0x58(%rbp)
movq %rsi, %rsp
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
callq 0x3430
testb $0x1, -0x11(%rbp)
je 0x362b
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x5af0
movl -0x18(%rbp), %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x363f
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
movq -0x68(%rbp), %rdi
movb $0x0, -0x29(%rbp)
callq 0x30c0
movq $0x0, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl -0x18(%rbp), %ecx
cmpq %rcx, %rax
jae 0x36bd
movq -0x68(%rbp), %rdi
movq -0x58(%rbp), %rax
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
incq %rdx
movq %rdx, -0x38(%rbp)
movzbl (%rax,%rcx), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x38(%rbp), %rcx
movq %rcx, %rdx
incq %rdx
movq %rdx, -0x38(%rbp)
movzbl (%rax,%rcx), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %esi
shll $0x8, %esi
movl -0x3c(%rbp), %eax
orl %eax, %esi
callq 0x3090
jmp 0x36a4
jmp 0x3654
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
callq 0x3210
jmp 0x36e0
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x36d0
movq -0x68(%rbp), %rdi
callq 0x3210
movq -0x60(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, %rsp
movq %rbp, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3250
nopl (%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x2, %edx
callq 0x3190
movq -0x8(%rbp), %rdi
callq 0x3240
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5ad0
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5a60
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x3180
movl -0xc(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x4f40
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
leaq -0x1c(%rbp), %rdi
xorl %esi, %esi
movl $0x4, %edx
callq 0x30e0
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
callq 0x3430
movq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x5aa0
leaq -0x1c(%rbp), %rsi
leaq 0x60e9(%rip), %rdi      # 0xb0f5
movl $0x4, %edx
callq 0x30b0
movl %eax, %ecx
xorl %eax, %eax
cmpl %ecx, %eax
je 0x5046
movq 0xcfcb(%rip), %rdi      # 0x11ff0
leaq 0x60ce(%rip), %rsi      # 0xb0fa
callq 0x3130
movq %rax, %rdi
movq 0xcf7d(%rip), %rsi      # 0x11fb8
callq 0x3160
movb $0x0, -0x1(%rbp)
jmp 0x504a
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x4fb0
testb $0x1, %al
jne 0x50ad
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30e0
movq -0x60(%rbp), %rdi
callq 0x6a80
jmp 0x519e
movq -0x60(%rbp), %rdi
movb $0x0, -0x15(%rbp)
callq 0x6a80
movq -0x10(%rbp), %rdi
callq 0x3240
movq %rdx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
jmp 0x50cd
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5ad0
movq %rax, -0x78(%rbp)
jmp 0x50ec
movq -0x78(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jge 0x5177
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x3780
jmp 0x5108
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6aa0
jmp 0x5117
leaq -0x48(%rbp), %rdi
callq 0x66a0
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x5157
movl $0x3, -0x4c(%rbp)
jmp 0x515e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5193
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6680
jmp 0x5193
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6680
movl -0x4c(%rbp), %eax
testl %eax, %eax
je 0x5172
jmp 0x5170
jmp 0x5177
jmp 0x50ba
movb $0x1, -0x15(%rbp)
movl $0x1, -0x4c(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5191
movq -0x60(%rbp), %rdi
callq 0x6b10
jmp 0x519e
movq -0x60(%rbp), %rdi
callq 0x6b10
jmp 0x51ab
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3250
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x270(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x6b70
movq -0x260(%rbp), %rsi
movl %eax, %edx
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x31f0
movq -0x258(%rbp), %rdi
callq 0x31e0
movb %al, -0x249(%rbp)
jmp 0x522e
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x523a
jmp 0x5269
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x271(%rbp)
jmp 0x525a
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x5269
jmp 0x5314
movq 0xcd80(%rip), %rdi      # 0x11ff0
leaq 0x5ea1(%rip), %rsi      # 0xb118
callq 0x3130
movq %rax, -0x280(%rbp)
jmp 0x5285
movq -0x280(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3120
movq %rax, -0x288(%rbp)
jmp 0x529e
movq -0x288(%rbp), %rdi
leaq 0x5e6a(%rip), %rsi      # 0xb116
callq 0x3130
movq %rax, -0x290(%rbp)
jmp 0x52ba
movq -0x290(%rbp), %rdi
movq 0xccf0(%rip), %rsi      # 0x11fb8
callq 0x3160
jmp 0x52cf
movq -0x270(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30e0
movq -0x270(%rbp), %rdi
callq 0x6a80
movl $0x1, -0x228(%rbp)
jmp 0x53ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x53d6
movq -0x270(%rbp), %rdi
movb $0x0, -0x229(%rbp)
callq 0x6a80
leaq -0x248(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x5060
jmp 0x533c
movq -0x270(%rbp), %rdi
leaq -0x248(%rbp), %rsi
movq %rsi, -0x298(%rbp)
callq 0x6b90
movq -0x298(%rbp), %rdi
callq 0x6b10
leaq -0x218(%rbp), %rdi
callq 0x3040
jmp 0x5370
movb $0x1, -0x229(%rbp)
movl $0x1, -0x228(%rbp)
testb $0x1, -0x229(%rbp)
jne 0x53b8
jmp 0x53ac
movq -0x270(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
callq 0x6b10
jmp 0x53d6
movq -0x270(%rbp), %rdi
callq 0x6b10
jmp 0x53ba
leaq -0x218(%rbp), %rdi
callq 0x3050
movq -0x268(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3050
movq -0x220(%rbp), %rdi
callq 0x3250
nop
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x4fb0
testb $0x1, %al
jne 0x543d
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30e0
movq -0x60(%rbp), %rdi
callq 0x6a80
jmp 0x552e
movq -0x60(%rbp), %rdi
movb $0x0, -0x15(%rbp)
callq 0x6a80
movq -0x10(%rbp), %rdi
callq 0x3240
movq %rdx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
jmp 0x545d
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq %rax, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x5ad0
movq %rax, -0x78(%rbp)
jmp 0x547c
movq -0x78(%rbp), %rax
movslq -0x14(%rbp), %rcx
cmpq %rcx, %rax
jge 0x5507
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x4660
jmp 0x5498
movq -0x60(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x6aa0
jmp 0x54a7
leaq -0x48(%rbp), %rdi
callq 0x66a0
movzwl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0x54e7
movl $0x3, -0x4c(%rbp)
jmp 0x54ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x5523
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6680
jmp 0x5523
movl $0x0, -0x4c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6680
movl -0x4c(%rbp), %eax
testl %eax, %eax
je 0x5502
jmp 0x5500
jmp 0x5507
jmp 0x544a
movb $0x1, -0x15(%rbp)
movl $0x1, -0x4c(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x5521
movq -0x60(%rbp), %rdi
callq 0x6b10
jmp 0x552e
movq -0x60(%rbp), %rdi
callq 0x6b10
jmp 0x553b
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x3250
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x270(%rbp)
movq %rdi, %rax
movq %rax, -0x268(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x260(%rbp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x6b70
movq -0x260(%rbp), %rsi
movl %eax, %edx
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x31f0
movq -0x258(%rbp), %rdi
callq 0x31e0
movb %al, -0x249(%rbp)
jmp 0x55be
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x55ca
jmp 0x55f9
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x3030
movb %al, -0x271(%rbp)
jmp 0x55ea
movb -0x271(%rbp), %al
testb $0x1, %al
jne 0x55f9
jmp 0x56a4
movq 0xc9f0(%rip), %rdi      # 0x11ff0
leaq 0x5b11(%rip), %rsi      # 0xb118
callq 0x3130
movq %rax, -0x280(%rbp)
jmp 0x5615
movq -0x280(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3120
movq %rax, -0x288(%rbp)
jmp 0x562e
movq -0x288(%rbp), %rdi
leaq 0x5ada(%rip), %rsi      # 0xb116
callq 0x3130
movq %rax, -0x290(%rbp)
jmp 0x564a
movq -0x290(%rbp), %rdi
movq 0xc960(%rip), %rsi      # 0x11fb8
callq 0x3160
jmp 0x565f
movq -0x270(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x30e0
movq -0x270(%rbp), %rdi
callq 0x6a80
movl $0x1, -0x228(%rbp)
jmp 0x574a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x5766
movq -0x270(%rbp), %rdi
movb $0x0, -0x229(%rbp)
callq 0x6a80
leaq -0x248(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x53f0
jmp 0x56cc
movq -0x270(%rbp), %rdi
leaq -0x248(%rbp), %rsi
movq %rsi, -0x298(%rbp)
callq 0x6b90
movq -0x298(%rbp), %rdi
callq 0x6b10
leaq -0x218(%rbp), %rdi
callq 0x3040
jmp 0x5700
movb $0x1, -0x229(%rbp)
movl $0x1, -0x228(%rbp)
testb $0x1, -0x229(%rbp)
jne 0x5748
jmp 0x573c
movq -0x270(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
callq 0x6b10
jmp 0x5766
movq -0x270(%rbp), %rdi
callq 0x6b10
jmp 0x574a
leaq -0x218(%rbp), %rdi
callq 0x3050
movq -0x268(%rbp), %rax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x3050
movq -0x220(%rbp), %rdi
callq 0x3250
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movsd %xmm0, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rax
movq %rax, 0x8(%rsp)
leaq 0x58(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x46b0
movq 0x8(%rsp), %rdi
movq %rax, 0x40(%rsp)
movsd %xmm0, 0x48(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x4660
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x30(%rsp)
movb %dl, 0x38(%rsp)
movsd 0x50(%rsp), %xmm0
addsd 0x68(%rax), %xmm0
movsd %xmm0, 0x68(%rax)
movq 0x58(%rsp), %rdi
addq $0x38, %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x46f0
movq %rax, 0x18(%rsp)
movb %dl, 0x20(%rsp)
movq 0x58(%rsp), %rax
movb $0x0, 0x88(%rax)
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rdi
callq 0x4750
movq %rax, 0x78(%rsp)
movq 0x80(%rsp), %rdi
callq 0x4780
movq %rax, 0x70(%rsp)
leaq 0x78(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x47b0
testb $0x1, %al
jne 0x2568
jmp 0x25ba
leaq 0x78(%rsp), %rdi
callq 0x47d0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rdx
movq %rdx, 0x60(%rsp)
movq 0x8(%rcx), %rcx
movq %rcx, 0x68(%rsp)
movq 0x60(%rsp), %rdi
addq $0x38, %rdi
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x47f0
movq 0x60(%rsp), %rax
movb $0x0, 0x88(%rax)
leaq 0x78(%rsp), %rdi
callq 0x4820
jmp 0x2553
movq (%rsp), %rax
addq $0x38, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4850
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x4880
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x48b0
testb $0x1, %al
jne 0x25fd
jmp 0x26b3
leaq 0x48(%rsp), %rdi
callq 0x48d0
movq %rax, %rcx
movq (%rsp), %rax
movq (%rcx), %rcx
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movq %rax, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x48f0
movq %rax, 0x30(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x4920
movsd 0x8(%rax), %xmm1
movq 0x38(%rsp), %rax
movsd 0x68(%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, 0x68(%rax)
movq 0x38(%rsp), %rdi
addq $0x8, %rdi
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
callq 0x4940
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x26c0
testb $0x1, %al
jne 0x2687
jmp 0x26a2
movq 0x88(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x4980
movq %rax, 0x8(%rsp)
movb %dl, 0x10(%rsp)
jmp 0x26a4
leaq 0x48(%rsp), %rdi
callq 0x49e0
jmp 0x25e5
addq $0x98, %rsp
retq
nopl (%rax,%rax)
// File: yohm[P]dynamical_graph_model/./dynamical_graph_model.cpp
// Function: Species::ToString[abi:cxx11]()
std::string Species::ToString() {
  std::ostringstream oss;
  oss << "immigrationTime: " << m_immigrationTime << std::endl;
  oss << "incoming:" << std::endl;
  for( auto pair : m_incomingInteractions ) {
    oss << "  " << pair.first << ", " << pair.second << std::endl;
  }
  return oss.str();
}

// Assembly:
subq $0x228, %rsp            # imm = 0x228
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x220(%rsp)
movq %rsi, 0x218(%rsp)
movq 0x218(%rsp), %rax
movq %rax, 0x48(%rsp)
leaq 0xa0(%rsp), %rdi
movq %rdi, 0x50(%rsp)
callq 0x2240
movq 0x50(%rsp), %rdi
leaq 0x8901(%rip), %rsi      # 0xb060
callq 0x2190
movq %rax, 0x58(%rsp)
jmp 0x276b
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movl (%rax), %esi
callq 0x2230
movq %rax, 0x30(%rsp)
jmp 0x2783
movq 0x30(%rsp), %rdi
movq 0xd829(%rip), %rsi      # 0xffb8
callq 0x21d0
jmp 0x2796
leaq 0x88d5(%rip), %rsi      # 0xb072
leaq 0xa0(%rsp), %rdi
callq 0x2190
movq %rax, 0x28(%rsp)
jmp 0x27b1
movq 0x28(%rsp), %rdi
movq 0xd7fb(%rip), %rsi      # 0xffb8
callq 0x21d0
jmp 0x27c4
movq 0x48(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x4750
movq %rax, 0x80(%rsp)
movq 0x88(%rsp), %rdi
callq 0x4780
movq %rax, 0x78(%rsp)
leaq 0x80(%rsp), %rdi
leaq 0x78(%rsp), %rsi
callq 0x47b0
testb $0x1, %al
jne 0x2817
jmp 0x28d6
leaq 0x80(%rsp), %rdi
callq 0x47d0
movups (%rax), %xmm0
movaps %xmm0, 0x60(%rsp)
leaq 0x8849(%rip), %rsi      # 0xb07c
leaq 0xa0(%rsp), %rdi
callq 0x2190
movq %rax, 0x20(%rsp)
jmp 0x2847
movq 0x20(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x2140
movq %rax, 0x18(%rsp)
jmp 0x285d
movq 0x18(%rsp), %rdi
leaq 0x8816(%rip), %rsi      # 0xb07f
callq 0x2190
movq %rax, 0x10(%rsp)
jmp 0x2875
movq 0x10(%rsp), %rdi
movsd 0x68(%rsp), %xmm0
callq 0x2300
movq %rax, 0x8(%rsp)
jmp 0x288c
movq 0x8(%rsp), %rdi
movq 0xd720(%rip), %rsi      # 0xffb8
callq 0x21d0
jmp 0x289f
jmp 0x28a1
leaq 0x80(%rsp), %rdi
callq 0x4820
jmp 0x27fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0xa0(%rsp), %rdi
callq 0x2060
jmp 0x2904
movq 0x38(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
callq 0x21b0
jmp 0x28ea
leaq 0xa0(%rsp), %rdi
callq 0x2060
movq 0x40(%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
retq
movq 0x98(%rsp), %rdi
callq 0x22e0
nopw %cs:(%rax,%rax)