LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/runtime.cpp
// Function: displaySystemProcesses(WindowWrap&)
void displaySystemProcesses(WindowWrap& disp)
{
   System sys = parseSystemInformation();
   sys.remove(0);  // removing the menu string
   sys.sort();
   sys.display(disp);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %r14, %rdi
callq 0x6a0d
movq %r14, %rdi
xorl %esi, %esi
callq 0x5bfe
movq %rsp, %rdi
callq 0x597c
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x5a00
movq %rsp, %rdi
callq 0x3930
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3930
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/system-process.cpp
// Function: SystemProcess::parse(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void SystemProcess::parse(const std::string& buffer)
{
   std::istringstream ss(buffer);

   ss >> user >> pid >> cpu >> mem >> vsz >> rss >> tty >> stat >> start >> time;
   std::string word;
   while(ss >> word)
   {
      command += word;
   }

   size_t bufferSize = COLS - 63;

   if(command.length() > bufferSize)
   {
      command = command.substr(1, bufferSize);
   }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, %rbx
leaq 0x48(%rsp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x33a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32c0
leaq 0x20(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0x40(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0x60(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0x80(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0xa0(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0xc0(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0xe0(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0x100(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0x120(%rbx), %rsi
movq %rax, %rdi
callq 0x32c0
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x140(%rbx), %r14
leaq 0x48(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x32c0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x55c4
movq %r14, %rdi
movq %r12, %rsi
callq 0x3410
jmp 0x559e
movq 0x59dd(%rip), %rax      # 0xafa8
movslq (%rax), %rcx
addq $-0x3f, %rcx
cmpq %rcx, 0x148(%rbx)
jbe 0x5603
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
movq %r14, %rsi
callq 0x3250
leaq 0x28(%rsp), %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3290
movq %rbx, %rdi
callq 0x3110
leaq 0x8(%rsp), %rdi
callq 0x3110
leaq 0x48(%rsp), %rdi
callq 0x3120
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x562d
movq %rax, %rbx
jmp 0x563a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3110
leaq 0x48(%rsp), %rdi
callq 0x3120
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/system-process.cpp
// Function: SystemProcess::toString[abi:cxx11]()
std::string SystemProcess::toString()
{
   std::ostringstream oss;
   oss << std::setw(5) << user << "" << std::setw(5) << pid << " "
       << std::setw(8) << vsz << " " << std::setw(6) << rss << " "
       << std::setw(5) << tty << " " << std::setw(5) << stat << " "
       << std::setw(5) << start << " " << std::setw(5) << time << " "
       << command << std::endl;
   return oss.str();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x32f0
movq (%r15), %rax
movq -0x18(%rax), %rax
movq $0x5, 0x18(%rsp,%rax)
movq %r15, %rdi
movq %r14, %rsi
callq 0x3210
leaq 0x1945(%rip), %rsi      # 0x701e
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x5, 0x10(%rax,%rcx)
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x1951(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x8, 0x10(%rax,%rcx)
leaq 0x80(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x1923(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x6, 0x10(%rax,%rcx)
leaq 0xa0(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x18f5(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x5, 0x10(%rax,%rcx)
leaq 0xc0(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x18c7(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x5, 0x10(%rax,%rcx)
leaq 0xe0(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x1899(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x5, 0x10(%rax,%rcx)
leaq 0x100(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x186b(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movq $0x5, 0x10(%rax,%rcx)
leaq 0x120(%r14), %rsi
movq %rax, %rdi
callq 0x3210
leaq 0x183d(%rip), %rsi      # 0x7055
movq %rax, %rdi
callq 0x3220
addq $0x140, %r14            # imm = 0x140
movq %rax, %rdi
movq %r14, %rsi
callq 0x3210
movq %rax, %rdi
callq 0x3140
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x3370
leaq 0x8(%rsp), %rdi
callq 0x3070
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3070
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/system.cpp
// Function: System::display(WindowWrap&)
void System::display(WindowWrap& disp)
{
   constexpr char titles[] = " CPU   MEM  USER   PID      VSZ    RSS   TTY  STAT START  "
                             "TIME COMMAND";

   mvwprintw(disp.getWin(), 1, 0, titles);
   int ROW = 2;
   for(SystemProcess sp : m_processes)
   {
      float cpu = sp.getCpuAsFloat();
      float mem = sp.getMemAsFloat();

      std::string cpuStr = sp.getCpuAsString();
      std::string memStr = sp.getMemAsString();

      displayPercentColor(disp, cpu, cpuStr + " ", ROW, 1);
      displayPercentColor(disp, mem, memStr, ROW, 7);

      mvwprintw(disp.getWin(), ROW, 12, sp.toString().c_str());
      ROW++;
   }
   wclrtobot(disp.getWin());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rdi, %r15
leaq 0x1932(%rip), %rsi      # 0x7350
pushq $0x47
popq %rcx
leaq 0xb0(%rsp), %r14
movq %r14, %rdi
rep  movsb (%rsi), %es:(%rdi)
movq %rbx, %rdi
callq 0x6e9c
pushq $0x1
popq %rsi
movq %rax, %rdi
xorl %edx, %edx
movq %r14, %rcx
xorl %eax, %eax
callq 0x3060
movq (%r15), %r14
movq 0x8(%r15), %rax
movq %rax, 0x8(%rsp)
pushq $0x2
popq %r15
leaq 0xf8(%rsp), %r12
leaq 0x90(%rsp), %rbp
cmpq 0x8(%rsp), %r14
je 0x5b7a
movq %r12, %rdi
movq %r14, %rsi
callq 0x61cc
movq %r12, %rdi
callq 0x5876
movss %xmm0, 0x4(%rsp)
movq %r12, %rdi
callq 0x5898
movss %xmm0, (%rsp)
leaq 0x50(%rsp), %rdi
movq %r12, %rsi
callq 0x5886
leaq 0x30(%rsp), %rdi
movq %r12, %rsi
callq 0x58a8
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x1591(%rip), %rdx      # 0x7055
callq 0x497f
movq %rbx, %rdi
movss 0x4(%rsp), %xmm0
leaq 0x70(%rsp), %r13
movq %r13, %rsi
movl %r15d, %edx
pushq $0x1
popq %rcx
callq 0x68e9
movq %r13, %rdi
callq 0x3110
movq %rbp, %rdi
leaq 0x30(%rsp), %rsi
callq 0x3300
movq %rbx, %rdi
movss (%rsp), %xmm0
movq %rbp, %rsi
movl %r15d, %edx
pushq $0x7
popq %rcx
callq 0x68e9
movq %rbp, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x6e9c
movq %rax, %r13
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x5698
movq 0x10(%rsp), %rcx
movq %r13, %rdi
movl %r15d, %esi
pushq $0xc
popq %rdx
xorl %eax, %eax
callq 0x3060
leaq 0x10(%rsp), %rdi
callq 0x3110
incl %r15d
leaq 0x30(%rsp), %rdi
callq 0x3110
leaq 0x50(%rsp), %rdi
callq 0x3110
movq %r12, %rdi
callq 0x39ac
addq $0x160, %r14            # imm = 0x160
jmp 0x5a68
movq %rbx, %rdi
callq 0x6e9c
movq %rax, %rdi
callq 0x32a0
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5bac
jmp 0x5bd2
jmp 0x5bac
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x5bcb
movq %rax, %rbx
jmp 0x5be9
movq %rax, %rbx
jmp 0x5bdf
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x5bcb
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x3110
jmp 0x5bd5
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x3110
leaq 0x50(%rsp), %rdi
callq 0x3110
leaq 0xf8(%rsp), %rdi
callq 0x39ac
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/utils.cpp
// Function: displayElement(WindowWrap&, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, flag::printType, flag::color)
void displayElement(WindowWrap& disp, int row, int col, string element, flag::printType flag, flag::color c)
{
   switch(flag)
   {
      case flag::printType::use_color:
         wattron(disp.getWin(), COLOR_PAIR(c));
         mvwprintw(disp.getWin(), row, col, element.c_str());
         wattroff(disp.getWin(), COLOR_PAIR(c));
         break;
      case flag::printType::standard:
         mvwprintw(disp.getWin(), row, col, element.c_str());
         break;
      default:
         break;
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %r15
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
cmpl $0x1, %r8d
je 0x68bf
testl %r8d, %r8d
jne 0x68e0
movl %r9d, %r12d
movq %r14, %rdi
callq 0x6e9c
shll $0x8, %r12d
movzwl %r12w, %r12d
movq %rax, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x3130
movq %r14, %rdi
callq 0x6e9c
movq (%r15), %rcx
movq %rax, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
callq 0x6e9c
movq %rax, %rdi
movl %r12d, %esi
xorl %edx, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x32d0
movq %r14, %rdi
callq 0x6e9c
movq (%r15), %rcx
movq %rax, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3060
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/utils.cpp
// Function: displayPercentColor(WindowWrap&, float, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void displayPercentColor(WindowWrap& disp, float percent, string str, int row, int col)
{
   if(percent == 0.0)
   {
      displayElement(disp, row, col, str, flag::printType::standard, flag::color::none);
   }
   else if(percent < 60)
   {
      displayElement(disp, row, col, str, flag::printType::use_color, flag::color::green);
   }
   else if(percent >= 60 && percent < 85)
   {
      displayElement(disp, row, col, str, flag::printType::use_color, flag::color::yellow);
   }
   else
   {
      displayElement(disp, row, col, str, flag::printType::use_color, flag::color::red);
   }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %ecx, %ebp
movl %edx, %r14d
movq %rdi, %r15
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6931
jp 0x6931
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
callq 0x3300
pushq $0x1
popq %r8
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r9d, %r9d
callq 0x684c
jmp 0x69c4
movss 0xa5f(%rip), %xmm1      # 0x7398
ucomiss %xmm0, %xmm1
jbe 0x6964
leaq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x3300
pushq $0x1
popq %r9
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x684c
jmp 0x69c4
ucomiss 0xa2d(%rip), %xmm0      # 0x7398
jb 0x69a0
movss 0xa27(%rip), %xmm1      # 0x739c
ucomiss %xmm0, %xmm1
jbe 0x69a0
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3300
pushq $0x2
popq %r9
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x684c
jmp 0x69c4
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3300
pushq $0x3
popq %r9
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0x684c
movq %rbx, %rdi
callq 0x3110
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x6a00
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x6a00
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x6a00
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/utils.cpp
// Function: parseSystemInformation()
System parseSystemInformation()
{
   auto   buffer_container = parseCommandLineOutput("ps -aux");
   System sys;

   for(auto buffer : buffer_container)
   {
      SystemProcess sp;
      sp.parse(buffer);
      sys.add(sp);
   }
   return sys;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a0, %rsp            # imm = 0x1A0
movq %rdi, %rbx
leaq 0x979(%rip), %rsi       # 0x73a0
leaq 0x8(%rsp), %rdi
callq 0x6aef
movq %rbx, %rdi
callq 0x58c4
movq 0x8(%rsp), %r14
movq 0x10(%rsp), %r13
leaq 0x20(%rsp), %r15
leaq 0x40(%rsp), %r12
cmpq %r13, %r14
je 0x6a91
movq %r15, %rdi
movq %r14, %rsi
callq 0x3300
movq %r12, %rdi
callq 0x53cc
movq %r12, %rdi
movq %r15, %rsi
callq 0x54d2
movq %rbx, %rdi
movq %r12, %rsi
callq 0x58d0
movq %r12, %rdi
callq 0x39ac
movq %r15, %rdi
callq 0x3110
addq $0x20, %r14
jmp 0x6a4d
leaq 0x8(%rsp), %rdi
callq 0x52b8
movq %rbx, %rax
addq $0x1a0, %rsp            # imm = 0x1A0
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
jmp 0x6add
movq %rax, %r14
jmp 0x6ad5
movq %rax, %r14
jmp 0x6acb
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x39ac
leaq 0x20(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3930
leaq 0x8(%rsp), %rdi
callq 0x52b8
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/ColinHarker[P]ltsim/src/utils.cpp
// Function: parseCommandLineOutput[abi:cxx11](char const*)
vector<string> parseCommandLineOutput(const char* cmd)
{
   vector<string> buffer_container;

   std::array<char, 512>                    buffer;
   string                                   result;
   std::unique_ptr<FILE, decltype(&pclose)> pipe(popen(cmd, "r"), pclose);
   if(!pipe)
   {
      throw std::runtime_error("popen() failed!");
   }
   while(fgets(buffer.data(), buffer.size(), pipe.get()) != nullptr)
   {
      result = buffer.data();

      // skipping over unneccessary data in stream
      if((result.find("Filesystem") != string::npos) || (result.find("/dev/loop") != string::npos))
      {
         continue;
      }
      buffer_container.emplace_back(result);
   }

   return buffer_container;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rax
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
leaq 0x20(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x88f(%rip), %rsi       # 0x73b7
movq %rax, %rdi
callq 0x30b0
movq %rax, %rdx
movq 0x4496(%rip), %rax      # 0xafd0
movq %rax, (%rsp)
movq %rdx, 0x8(%rsp)
testq %rdx, %rdx
je 0x6bdf
leaq 0x30(%rsp), %r14
leaq 0x10(%rsp), %r15
leaq 0x85c(%rip), %r12       # 0x73b9
leaq 0x860(%rip), %r13       # 0x73c4
movq %r14, %rdi
movl $0x200, %esi            # imm = 0x200
callq 0x3360
testq %rax, %rax
je 0x6bb9
movq %r15, %rdi
movq %r14, %rsi
callq 0x3400
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x3420
cmpq $-0x1, %rax
jne 0x6bb2
movq %r15, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x3420
cmpq $-0x1, %rax
jne 0x6bb2
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6c58
movq 0x8(%rsp), %rdx
jmp 0x6b64
movq %rsp, %rdi
callq 0x42be
leaq 0x10(%rsp), %rdi
callq 0x3110
movq %rbx, %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x10
popq %rdi
callq 0x3150
movq %rax, %r15
leaq 0x4e3(%rip), %rsi       # 0x70d4
movq %rax, %rdi
callq 0x30d0
movq 0x43f0(%rip), %rsi      # 0xaff0
movq 0x43b9(%rip), %rdx      # 0xafc0
movq %r15, %rdi
callq 0x33b0
jmp 0x6c1e
movq %rax, %r14
movq %r15, %rdi
callq 0x31c0
jmp 0x6c21
movq %rax, %r14
movq %rsp, %rdi
callq 0x42be
leaq 0x10(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x52b8
movq %r14, %rdi
callq 0x33c0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: load_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>*)
bool load_file(const std::string& filename, std::string* result) {
  std::ifstream file(filename.c_str(), std::ios::in|std::ios::binary|std::ios::ate);
  if(!file) return false;

  std::streamsize size = 0;
  if(file.seekg(0, std::ios::end).good()) size = file.tellg();
  if(file.seekg(0, std::ios::beg).good()) size -= file.tellg();

  result->resize(size_t(size));
  if(size > 0) file.read((char*)(&(*result)[0]), size);

  return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %rbx
movq (%rdi), %rsi
leaq 0x8(%rsp), %r14
pushq $0xe
popq %rdx
movq %r14, %rdi
callq 0x43c0
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ebp
testb $0x5, %bpl
jne 0x4a06
leaq 0x8(%rsp), %rdi
pushq $0x2
popq %rdx
xorl %esi, %esi
callq 0x42b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
je 0x49b0
xorl %r14d, %r14d
jmp 0x49bd
leaq 0x8(%rsp), %rdi
callq 0x4390
movq %rax, %r14
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x42b0
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
jne 0x49e6
leaq 0x8(%rsp), %rdi
callq 0x4390
subq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x42d0
testq %r14, %r14
jle 0x4a06
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x4260
testb $0x5, %bpl
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x4080
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x4a29
jmp 0x4a29
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4080
movq %rbx, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: string_to_utf8(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::vector<uint8_t> string_to_utf8(const std::string& s) {
  std::vector<uint8_t> result;
  for(int i = 0; i < s.size(); i++) {
    result.push_back((unsigned char)(s[i]));
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
andq $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
cmpq %r12, 0x8(%r14)
jbe 0x4f06
movq (%r14), %rax
movb (%rax,%r12), %al
movb %al, 0x7(%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc6a2
incq %r12
jmp 0x4ee5
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xc694
movq %r14, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: utf8_to_string[abi:cxx11](std::vector<unsigned char, std::allocator<unsigned char>> const&)
std::string utf8_to_string(const std::vector<uint8_t>& a) {
  std::string result;
  for(int i = 0; i < a.size(); i++) {
    result.push_back(a[i]);
  }
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
xorl %r15d, %r15d
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
cmpq %r15, %rcx
jbe 0x4f67
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x41a0
incq %r15
jmp 0x4f46
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: invertTable(int*)
std::map<int, int> invertTable(int table[256]) {
  std::map<int, int> result;
  for(int i = 0; i < 256; i++) result[table[i]] = i;
  if(result.size() != 256) std::cout << "Warning: duplicates found" << std::endl;
  return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rsi, %r14
leaq 0x8(%rdi), %rax
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
xorl %r15d, %r15d
cmpq $0x100, %r15            # imm = 0x100
je 0x5057
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7702
movl %r15d, (%rax)
incq %r15
addq $0x4, %r14
jmp 0x5037
cmpq $0x100, 0x28(%rbx)      # imm = 0x100
je 0x507c
movq 0xff60(%rip), %rdi      # 0x14fc8
leaq 0x8406(%rip), %rsi      # 0xd475
callq 0x41e0
movq %rax, %rdi
callq 0x4110
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x5087
movq %rax, %r14
movq %rbx, %rdi
callq 0x8c0c
movq %r14, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: printHelp(UnixArgs const&)
void printHelp(const UnixArgs& args) {
  if(!args.error.empty()) {
    std::cout << "ERROR: " << args.error << std::endl << std::endl;
  }

  std::cout << "base256, a base-256 viewer (as opposed to a base-16 hexdump).\n"
               "Converts binary data from bytes to various formats, by default using 256 unique unicode glyphs.\n"
               "Other formats, including hex, are supported as well.\n"
               "\n"
               "If no output file is given, outputs to stdout. If no input file is given either, inputs from stdin (e.g. for piping, e.g. when giving no arguments at all).\n"
               "\n"
               "Requires terminal unicode suppport and/or ANSI color support, depending on the format and flags\n"
               "Most encodings use unique symbols for each possible byte, but some print options may affect that property.\n"
               "Made by Lode Vandevenne\n"
               "\n";

  std::cout << "Usage:" << std::endl;
  std::cout << args.binary << " [-options] [in.bin] [--outfile=out.txt]" << std::endl;
  std::cout << std::endl;
  std::cout << "Options:" << std::endl;
  args.printHelp(2);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0xf8(%rdi)
je 0x50e0
leaq 0xf0(%rbx), %r14
movq 0xff0f(%rip), %rdi      # 0x14fc8
leaq 0x83cf(%rip), %rsi      # 0xd48f
callq 0x41e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x41c0
movq %rax, %rdi
callq 0x4110
movq %rax, %rdi
callq 0x4110
movq 0xfee1(%rip), %r14      # 0x14fc8
leaq 0x83a9(%rip), %rsi      # 0xd497
movq %r14, %rdi
callq 0x41e0
leaq 0x85f0(%rip), %rsi      # 0xd6ed
movq %r14, %rdi
callq 0x41e0
movq %rax, %rdi
callq 0x4110
leaq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x41c0
leaq 0x85d4(%rip), %rsi      # 0xd6f4
movq %rax, %rdi
callq 0x41e0
movq %rax, %rdi
callq 0x4110
movq %r14, %rdi
callq 0x4110
leaq 0x85de(%rip), %rsi      # 0xd71d
movq %r14, %rdi
callq 0x41e0
movq %rax, %rdi
callq 0x4110
pushq $0x2
popq %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x7756
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: UnixArgs::printHelp(unsigned long) const
void printHelp(size_t indent) const {
    std::string ind;
    for(size_t i = 0; i < indent; i++) ind += " ";
    for(size_t i = 0; i < args.size(); i++) {
      const Arg& arg = args[i];
      std::cout << ind;
      for(size_t j = 0; j < arg.helpargs.size(); j++) {
        if(j > 0) std::cout << ", ";
        std::cout << arg.helpargs[j];
      }
      if(!arg.help.empty()) {
        std::cout << ": " << arg.help;
      }
      std::cout << std::endl;
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, (%rsp)
movb $0x0, (%rax)
leaq 0x6f28(%rip), %r15      # 0xe6ab
leaq 0x8(%rsp), %r12
subq $0x1, %r14
jb 0x779b
movq %r12, %rdi
movq %r15, %rsi
callq 0x43d0
jmp 0x7788
xorl %r13d, %r13d
movq 0xd823(%rip), %r14      # 0x14fc8
leaq 0x6ee4(%rip), %r12      # 0xe690
movq (%rsp), %rax
movq 0x60(%rax), %rbp
movq 0x68(%rax), %rax
subq %rbp, %rax
sarq $0x7, %rax
cmpq %rax, %r13
jae 0x7855
movq %r14, %rdi
leaq 0x8(%rsp), %rsi
callq 0x41c0
movq %r13, %rax
shlq $0x7, %rax
addq %rax, %rbp
xorl %r15d, %r15d
xorl %ebx, %ebx
movq (%rbp), %rsi
movq 0x8(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rax, %rbx
jae 0x7820
testq %rbx, %rbx
je 0x780c
movq %r14, %rdi
movq %r12, %rsi
callq 0x41e0
movq (%rbp), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x41c0
incq %rbx
addq $0x20, %r15
jmp 0x77e4
cmpq $0x0, 0x20(%rbp)
je 0x7845
movq %r14, %rdi
leaq 0x6be5(%rip), %rsi      # 0xe416
callq 0x41e0
addq $0x18, %rbp
movq %rax, %rdi
movq %rbp, %rsi
callq 0x41c0
movq %r14, %rdi
callq 0x4110
incq %r13
jmp 0x77ac
leaq 0x8(%rsp), %rdi
callq 0x4408
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7872
jmp 0x7872
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4408
movq %rbx, %rdi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: UnixArgs::registerArg(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void registerArg(char c, const std::string& s, const std::string& help = "", const std::string& def = "") {
    size_t index = args.size();
    args.resize(args.size() + 1);
    if(!s.empty()) {
      strings[s] = index;
      args.back().helpargs.push_back("--" + s);
      if(!def.empty()) args.back().helpargs.back() += "=[default:" + def + "]";
    }
    if(c) {
      chars[c] = index;
      args.back().helpargs.push_back("-" + std::string(1, c));
    }
    args.back().help = help;
    args.back().value = def;
    args.back().def = def;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r13
movq %rcx, 0x30(%rsp)
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movb %bpl, 0x7(%rsp)
addq $0x60, %rdi
movq 0x68(%r14), %rbx
subq 0x60(%r14), %rbx
sarq $0x7, %rbx
leaq 0x1(%rbx), %rsi
callq 0x8c54
cmpq $0x0, 0x8(%r12)
je 0x797c
movq %r13, 0x28(%rsp)
leaq 0xa8(%r14), %rdi
movq %r12, %rsi
callq 0x8c84
movq %rbx, (%rax)
movq 0x68(%r14), %r13
addq $-0x80, %r13
leaq 0x6b50(%rip), %rsi      # 0xe446
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rdx
callq 0x8cea
movq %r13, %rdi
movq %r15, %rsi
callq 0x951e
leaq 0x8(%rsp), %rdi
callq 0x4408
movq 0x28(%rsp), %r13
cmpq $0x0, 0x8(%r13)
je 0x797c
leaq 0x6b1b(%rip), %rsi      # 0xe449
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %r13, %rdx
callq 0x8cea
leaq 0x5dd6(%rip), %rdx      # 0xd71b
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x8d60
movq 0x68(%r14), %rax
movq -0x78(%rax), %rdi
addq $-0x20, %rdi
leaq 0x8(%rsp), %rsi
callq 0x43f0
leaq 0x8(%rsp), %rdi
callq 0x4408
leaq 0x38(%rsp), %rdi
callq 0x4408
testb %bpl, %bpl
je 0x79ee
leaq 0x78(%r14), %rdi
leaq 0x7(%rsp), %r15
movq %r15, %rsi
callq 0x8d80
movq %rbx, (%rax)
movq 0x68(%r14), %r12
movsbl (%r15), %edx
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x4240
leaq 0x6a8d(%rip), %rsi      # 0xe447
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x8ae6
addq $-0x80, %r12
leaq 0x8(%rsp), %rsi
movq %r12, %rdi
callq 0x951e
leaq 0x8(%rsp), %rdi
callq 0x4408
leaq 0x38(%rsp), %rdi
callq 0x4408
movq 0x68(%r14), %rdi
addq $-0x68, %rdi
movq 0x30(%rsp), %rsi
callq 0x4130
movq 0x68(%r14), %rdi
addq $-0x48, %rdi
movq %r13, %rsi
callq 0x4130
movq 0x68(%r14), %rdi
addq $-0x28, %rdi
movq %r13, %rsi
callq 0x4130
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7a33
jmp 0x7a42
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4408
jmp 0x7a45
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x7a59
movq %rax, %rbx
jmp 0x7a5e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4408
movq %rbx, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: int strtoval<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
T strtoval(const std::string& s) {
  std::istringstream sstream(s);
  T val;
  sstream >> val;
  return val;
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x4370
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x4140
movl 0xc(%rsp), %ebx
leaq 0x10(%rsp), %rdi
callq 0x4100
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x4100
movq %rbx, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Printer::decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string decode(const std::string& s) {
    if(mix) {
      std::string result;
      for(size_t i = 0; i < s.size(); i++) {
        // 32 is space, anything <= 32 is considered whitespace
        while(i < s.size() && (s[i] <= 32)) i++;
        if(i == s.size()) break;
        size_t j = i + 1;
        while(j < s.size() && (s[j] > 32)) j++;
        size_t size = j - i;
        if(size == 1) {
          char c = s[i];
          if(c > 32 && c < 127) {
            result += c;
            i = j;
            continue;
          }
        }
        result += n->decode(s.substr(i, j - i));
        i = j;
      }
      return result;
    } else {
      return n->decode(s);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rcx
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x1, 0x1a(%rsi)
jne 0x8a92
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %edx, %edx
leaq 0x8(%rsp), %rbp
leaq 0x28(%rsp), %r13
movq 0x8(%rcx), %rsi
cmpq %rsi, %rdx
jae 0x8aa1
movq (%rcx), %rax
cmpq %rdx, %rsi
je 0x8aa1
cmpb $0x20, (%rax,%rdx)
jg 0x89eb
incq %rdx
jmp 0x89d7
cmpq %rdx, %rsi
je 0x8aa1
movq %rcx, (%rsp)
leaq 0x1(%rdx), %rdi
cmpq %rdi, %rsi
cmovaq %rsi, %rdi
movq %rdx, %rcx
movq %rcx, %r12
incq %rcx
cmpq %rsi, %rcx
jae 0x8a1b
cmpb $0x20, 0x1(%rax,%r12)
jg 0x8a06
jmp 0x8a1e
movq %rdi, %rcx
leaq -0x1(%rcx), %rsi
cmpq %rdx, %rsi
jne 0x8a33
movb (%rax,%rdx), %al
leal -0x7f(%rax), %esi
cmpb $-0x5e, %sil
jae 0x8a77
subq %rdx, %rcx
movq %r15, %r14
movq (%r15), %r15
movq %rbp, %rdi
movq (%rsp), %rsi
callq 0x4200
movq (%r15), %rax
movq %r13, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq *0x18(%rax)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x43f0
movq %r14, %r15
movq %r13, %rdi
callq 0x4408
movq %rbp, %rdi
callq 0x4408
jmp 0x8a82
movsbl %al, %esi
movq %rbx, %rdi
callq 0x41a0
addq $0x2, %r12
movq %r12, %rdx
movq (%rsp), %rcx
jmp 0x89c7
movq (%r15), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %rcx, %rdx
callq *0x18(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8ad3
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x4408
jmp 0x8ac7
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4408
jmp 0x8ad6
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> valtostr<unsigned long>(unsigned long const&, bool)
std::string valtostr(const T& val, bool hex = false) {
  std::ostringstream sstream;
  if(hex) sstream << std::hex;
  sstream << val;
  return sstream.str();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x180, %rsp            # imm = 0x180
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %rdi
callq 0x42a0
testl %ebp, %ebp
je 0x8b42
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
movl 0x20(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x20(%rsp,%rax)
movq (%r14), %rsi
leaq 0x8(%rsp), %rdi
callq 0x4170
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x4330
leaq 0x8(%rsp), %rdi
callq 0x4060
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4060
movq %rbx, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: CP437::decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string decode(const std::string& s) {
    if(newline) return "not supported with printnewline enabled";
    if(printnull) return "not supported with printnull enabled";
    std::vector<int> u = string_to_unicode(s);
    std::string result;
    for(int i = 0; i < u.size(); i++) {
      if(u[i] == 10) {
        continue;
      } else if(!inv437.count(u[i])) {
        std::cout << "invalid character: " << u[i] << " at " << i << std::endl;
        result.push_back('?');
      } else {
        result.push_back(inv437[u[i]]);
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0x9c20
leaq 0x4942(%rip), %rsi      # 0xe560
jmp 0x9c2d
cmpb $0x1, 0x9(%rsi)
jne 0x9c3d
leaq 0x495b(%rip), %rsi      # 0xe588
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x40c0
jmp 0x9d16
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x4f83
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %r14d, %r14d
leaq 0xbdee(%rip), %r15      # 0x15a50
leaq 0x4944(%rip), %r13      # 0xe5ad
leaq 0x4951(%rip), %rbp      # 0xe5c1
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0x9d0e
cmpl $0xa, (%rax,%r14,4)
je 0x9d06
leaq (%rax,%r14,4), %rsi
movq %r15, %rdi
callq 0x9f1e
testq %rax, %rax
je 0x9cba
leaq (,%r14,4), %rsi
addq (%rsp), %rsi
movq %r15, %rdi
callq 0x7702
movb (%rax), %r12b
jmp 0x9cfa
movq 0xb307(%rip), %rdi      # 0x14fc8
movq %r13, %rsi
callq 0x41e0
movq (%rsp), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x4380
movq %rax, %rdi
movq %rbp, %rsi
callq 0x41e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x4380
movb $0x3f, %r12b
movq %rax, %rdi
callq 0x4110
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x41a0
incq %r14
jmp 0x9c70
movq %rsp, %rdi
callq 0x9eba
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %rsp, %rdi
callq 0x9eba
movq %r14, %rdi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: CP1252::decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string decode(const std::string& s) {
    if(newline) return "not supported with printnewline enabled";
    if(printnull) return "not supported with printnull enabled";
    std::vector<int> u = string_to_unicode(s);
    std::string result;
    for(int i = 0; i < u.size(); i++) {
      if(u[i] == 10) {
        continue;
      } else if(!inv1252.count(u[i])) {
        std::cout << "invalid character: " << u[i] << " at " << i << std::endl;
        result.push_back('?');
      } else {
        result.push_back(inv1252[u[i]]);
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0xa04c
leaq 0x4516(%rip), %rsi      # 0xe560
jmp 0xa059
cmpb $0x1, 0x9(%rsi)
jne 0xa069
leaq 0x452f(%rip), %rsi      # 0xe588
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x40c0
jmp 0xa142
movq %rsp, %rdi
movq %rdx, %rsi
callq 0x4f83
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
xorl %r14d, %r14d
leaq 0xb9f2(%rip), %r15      # 0x15a80
leaq 0x4518(%rip), %r13      # 0xe5ad
leaq 0x4525(%rip), %rbp      # 0xe5c1
movq (%rsp), %rax
movq 0x8(%rsp), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %r14, %rcx
jbe 0xa13a
cmpl $0xa, (%rax,%r14,4)
je 0xa132
leaq (%rax,%r14,4), %rsi
movq %r15, %rdi
callq 0x9f1e
testq %rax, %rax
je 0xa0e6
leaq (,%r14,4), %rsi
addq (%rsp), %rsi
movq %r15, %rdi
callq 0x7702
movb (%rax), %r12b
jmp 0xa126
movq 0xaedb(%rip), %rdi      # 0x14fc8
movq %r13, %rsi
callq 0x41e0
movq (%rsp), %rcx
movl (%rcx,%r14,4), %esi
movq %rax, %rdi
callq 0x4380
movq %rax, %rdi
movq %rbp, %rsi
callq 0x41e0
movq %rax, %rdi
movl %r14d, %esi
callq 0x4380
movb $0x3f, %r12b
movq %rax, %rdi
callq 0x4110
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x41a0
incq %r14
jmp 0xa09c
movq %rsp, %rdi
callq 0x9eba
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %rsp, %rdi
callq 0x9eba
movq %r14, %rdi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Base64::encodeChar[abi:cxx11](unsigned char, unsigned char, unsigned char)
std::string encodeChar(unsigned char c, unsigned char prev, unsigned char next) {
    int r = num % 3;
    num++;
    if(r == 0) v = (c << 16u);
    else if(r == 1) v |= (c << 8u);
    else v |= c;
    std::string result;
    if(r == 0) {
      result += BASE64[(v >> 18) & 0x3f];
    } else if(r == 1) {
      result += BASE64[(v >> 12) & 0x3f];
    } else {
      result += BASE64[(v >>  6) & 0x3f];
      result += BASE64[(v >>  0) & 0x3f];
    }
    return result;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ecx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
pushq $0x3
popq %rdi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
incq %rsi
movq %rsi, 0x18(%r14)
movl %ecx, %eax
testq %rdx, %rdx
je 0xa303
cmpq $0x1, %rdx
jne 0xa2d6
shll $0x8, %eax
orq 0x10(%r14), %rax
movq %rax, 0x10(%r14)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
cmpq $0x1, %rdx
jne 0xa321
shrl $0xc, %eax
andl $0x3f, %eax
addq %rcx, %rax
jmp 0xa33e
movl %eax, %ecx
shll $0x10, %ecx
movq %rcx, 0x10(%r14)
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
shrl $0x2, %eax
jmp 0xa33a
shrl $0x6, %eax
andl $0x3f, %eax
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x41a0
movq 0x10(%r14), %rax
andl $0x3f, %eax
addq 0x8(%r14), %rax
movsbl (%rax), %esi
movq %rbx, %rdi
callq 0x41a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Base64::decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string decode(const std::string& s) {
    std::string result;
    for(size_t i = 0; i + 3 < s.size(); i += 4) {
      int v = 262144 * fromBase64(s[i]) + 4096 * fromBase64(s[i + 1]) + 64 * fromBase64(s[i + 2]) + fromBase64(s[i + 3]);
      result += ((v >> 16) & 0xff);
      if(s[i + 2] != '=') result += ((v >> 8) & 0xff);
      if(s[i + 3] != '=') result += ((v >> 0) & 0xff);
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r12
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, 0x10(%rsp)
movb $0x0, 0x10(%rdi)
pushq $0x3
popq %rbx
movq %rdi, 0x8(%rsp)
movq 0x10(%rsp), %r15
cmpq 0x8(%r14), %rbx
jae 0xa452
movq (%r14), %rax
movsbl -0x3(%rax,%rbx), %esi
movq %r15, %rdi
callq 0xa518
movl %eax, %ebp
shll $0x12, %ebp
movq (%r14), %rax
movsbl -0x2(%rax,%rbx), %esi
movq %r15, %rdi
callq 0xa518
movl %eax, %r12d
shll $0xc, %r12d
addl %ebp, %r12d
movq (%r14), %rax
movsbl -0x1(%rax,%rbx), %esi
movq %r15, %rdi
callq 0xa518
movl %eax, %r13d
shll $0x6, %r13d
movq (%r14), %rax
movsbl (%rax,%rbx), %esi
movq %r15, %rdi
callq 0xa518
movl %eax, %ebp
addl %r13d, %ebp
addl %r12d, %ebp
movq 0x8(%rsp), %r12
movl %ebp, %eax
shrl $0x10, %eax
movsbl %al, %esi
movq %r12, %rdi
callq 0x41a0
movq (%r14), %rax
cmpb $0x3d, -0x1(%rax,%rbx)
je 0xa437
movl %ebp, %eax
shrl $0x8, %eax
movsbl %al, %esi
movq %r12, %rdi
callq 0x41a0
movq (%r14), %rax
cmpb $0x3d, (%rax,%rbx)
je 0xa449
movsbl %bpl, %esi
movq %r12, %rdi
callq 0x41a0
addq $0x4, %rbx
jmp 0xa39e
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Base64::close[abi:cxx11]()
virtual std::string close() {
    int r = num % 3;
    std::string result;
    if(r == 0) {
    }
    if(r == 1) {
      result += BASE64[(v >> 12) & 0x3f];
      result += "==";
    }
    if(r == 2) {
      result += BASE64[(v >> 6) & 0x3f];
      result += "=";
    }
    return result;
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rsi), %rax
pushq $0x3
popq %rcx
xorl %edx, %edx
divq %rcx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x2, %rdx
je 0xa4d1
cmpq $0x1, %rdx
jne 0xa4f9
movq 0x8(%rsi), %rax
movl 0x10(%rsi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x41a0
leaq 0x4138(%rip), %rsi      # 0xe607
jmp 0xa4f1
movq 0x8(%rsi), %rax
movl 0x10(%rsi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x41a0
leaq 0x4117(%rip), %rsi      # 0xe608
movq %rbx, %rdi
callq 0x43d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Base64::fromBase64(int)
int fromBase64(int v) {
    if(v >= 'A' && v <= 'Z') return (v - 'A');
    if(v >= 'a' && v <= 'z') return (v - 'a' + 26);
    if(v >= '0' && v <= '9') return (v - '0' + 52);
    if(v == '+') return 62;
    if(v == '/') return 63;
    return 0; //v == '='
  }

// Assembly:
leal -0x41(%rsi), %eax
cmpl $0x1a, %eax
jae 0xa521
retq
leal -0x61(%rsi), %eax
cmpl $0x19, %eax
ja 0xa52e
addl $-0x47, %esi
jmp 0xa539
leal -0x30(%rsi), %eax
cmpl $0x9, %eax
ja 0xa53c
addl $0x4, %esi
movl %esi, %eax
retq
xorl %eax, %eax
cmpl $0x2f, %esi
pushq $0x3f
popq %rcx
cmovnel %eax, %ecx
cmpl $0x2b, %esi
pushq $0x3e
popq %rax
cmovnel %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Hex::encodeChar[abi:cxx11](unsigned char, unsigned char, unsigned char)
std::string encodeChar(unsigned char c, unsigned char prev, unsigned char next) {
    std::string result;
    result += digits[(c >> 4) & 15];
    result += digits[c & 15];
    if(prefix) result = "0x" + result;
    return result;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %rax
movl %edx, %ecx
shrl $0x4, %ecx
movsbl (%rax,%rcx), %esi
callq 0x41a0
movq 0x18(%r14), %rax
andl $0xf, %r15d
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x41a0
cmpb $0x1, 0x20(%r14)
jne 0xa5d0
leaq 0x407d(%rip), %rsi      # 0xe62c
movq %rsp, %rdi
movq %rbx, %rdx
callq 0x8cea
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4250
movq %r14, %rdi
callq 0x4408
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xa5df
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Hex::decode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string decode(const std::string& s) {
    std::string result;
    int count = 0;
    int val = 0;
    for(size_t i = 0; i < s.size(); i++) {
      if(prefix && i + 2 < s.size() && s[i] == '0' && s[i + 1] == 'x') i += 2;
      char c = s[i];
      if((c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') || (c >= 'A' && c <= 'F')) {
        int d = 0;
        if(c >= '0' && c <= '9') d = c - '0';
        if(c >= 'a' && c <= 'f') d = c - 'a' + 10;
        if(c >= 'A' && c <= 'F') d = c - 'A' + 10;
        if(count % 2 == 1) {
          val <<= 4;
          val |= d;
          result.push_back(val);
        } else {
          val = d;
        }
        count++;
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r13d, %r13d
xorl %eax, %eax
xorl %ebp, %ebp
movq 0x8(%r14), %rsi
cmpq %rsi, %r13
jae 0xa6d1
cmpb $0x0, 0x20(%r15)
je 0xa654
leaq 0x2(%r13), %rdx
movq (%r14), %rcx
cmpq %rsi, %rdx
jae 0xa657
cmpb $0x30, (%rcx,%r13)
jne 0xa657
cmpb $0x78, 0x1(%rcx,%r13)
je 0xa64f
movq %r13, %rdx
movq %rdx, %r13
jmp 0xa657
movq (%r14), %rcx
movb (%rcx,%r13), %cl
leal -0x30(%rcx), %edx
cmpb $0xa, %dl
jb 0xa680
movzbl %cl, %edx
addl $-0x41, %edx
cmpl $0x25, %edx
ja 0xa6c9
movabsq $0x3f0000003f, %rsi     # imm = 0x3F0000003F
btq %rdx, %rsi
jae 0xa6c9
xorl %edx, %edx
leal -0x61(%rcx), %esi
leal -0x57(%rcx), %edi
cmpb $0x6, %sil
movzbl %dl, %edx
movzbl %dil, %esi
cmovael %edx, %esi
leal -0x41(%rcx), %edx
addb $-0x37, %cl
cmpb $0x6, %dl
movzbl %cl, %r12d
cmovael %esi, %r12d
movl %ebp, %ecx
andl $0x80000001, %ecx       # imm = 0x80000001
cmpl $0x1, %ecx
jne 0xa6c4
shlb $0x4, %al
orb %al, %r12b
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x41a0
incl %ebp
movl %r12d, %eax
incq %r13
jmp 0xa61d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
// File: /workspace/github_cpp_makefile_star2_O2/lvandeve[P]base256/base256.cpp
// Function: Decimal::encodeChar[abi:cxx11](unsigned char, unsigned char, unsigned char)
std::string encodeChar(unsigned char c, unsigned char prev, unsigned char next) {
    static const std::string d = "0123456789";
    std::string result;
    if(prefix) {
      if(c >= 100) result += d[c / 100];
      if(c >= 10) result += d[(c / 10) % 10];
      result += d[c % 10];
    } else {
      result += d[c / 100];
      result += d[(c / 10) % 10];
      result += d[c % 10];
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0xb3af(%rip), %al       # 0x15ad0
testb %al, %al
je 0xa7bc
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl %bpl, %r15d
cmpb $0x63, %bpl
ja 0xa752
cmpb $0x0, 0x8(%r14)
je 0xa752
cmpb $0x9, %bpl
ja 0xa76f
jmp 0xa791
movb $0x64, %cl
movl %r15d, %eax
divb %cl
movzbl %al, %eax
movq 0xb34d(%rip), %rcx      # 0x15ab0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x41a0
movb $0xa, %cl
movl %r15d, %eax
divb %cl
movzbl %al, %eax
divb %cl
movzbl %ah, %eax
movq 0xb32b(%rip), %rcx      # 0x15ab0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x41a0
movb $0xa, %cl
movl %r15d, %eax
divb %cl
movzbl %ah, %eax
movq 0xb30e(%rip), %rcx      # 0x15ab0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x41a0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb30d(%rip), %rdi      # 0x15ad0
callq 0x43b0
testl %eax, %eax
je 0xa729
leaq 0xb2d9(%rip), %rdi      # 0x15ab0
leaq 0x3e51(%rip), %rsi      # 0xe62f
leaq 0x7(%rsp), %rdx
callq 0x40c0
movq 0xa7c9(%rip), %rdi      # 0x14fb8
leaq 0xb2ba(%rip), %rsi      # 0x15ab0
leaq 0xaa0b(%rip), %rdx      # 0x15208
callq 0x41b0
leaq 0xb2c7(%rip), %rdi      # 0x15ad0
callq 0x4160
jmp 0xa729
movq %rax, %r14
leaq 0xb2b3(%rip), %rdi      # 0x15ad0
callq 0x4150
jmp 0xa82f
movq %rax, %r14
movq %rbx, %rdi
callq 0x4408
movq %r14, %rdi
callq 0x43a0
nop