LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8f2b
testl %r8d, %r8d
jne 0x8f4c
movl %r9d, %r12d
movq %r14, %rdi
callq 0x969e
shll $0x8, %r12d
movzwl %r12w, %r12d
movq %rax, %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x3110
movq %r14, %rdi
callq 0x969e
movq (%r15), %rcx
movq %rax, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3060
movq %r14, %rdi
callq 0x969e
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 0x969e
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_O1/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 %r12
pushq %rbx
subq $0x80, %rsp
movl %ecx, %ebx
movl %edx, %ebp
movq %rdi, %r14
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x8fb7
jp 0x8fb7
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rsp, %rdi
movq %rax, %rsi
callq 0x3c88
movq %r14, %rdi
callq 0x969e
movq (%rsp), %rcx
movq %rax, %rdi
movl %ebp, %esi
movl %ebx, %edx
xorl %eax, %eax
callq 0x3060
movq (%rsp), %rdi
jmp 0x90a4
movss 0x1399(%rip), %xmm1     # 0xa358
ucomiss %xmm0, %xmm1
jbe 0x900a
leaq 0x70(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x60(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c88
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
movl $0x1, %r9d
callq 0x8eb8
movq 0x60(%rsp), %rdi
jmp 0x90a4
ucomiss 0x1347(%rip), %xmm0     # 0xa358
jb 0x9063
movss 0x1341(%rip), %xmm1     # 0xa35c
ucomiss %xmm0, %xmm1
jbe 0x9063
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c88
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
movl $0x2, %r9d
callq 0x8eb8
movq 0x40(%rsp), %rdi
jmp 0x90a4
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3c88
movq %r14, %rdi
movl %ebp, %esi
movl %ebx, %edx
movq %r15, %rcx
xorl %r8d, %r8d
movl $0x3, %r9d
callq 0x8eb8
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x90b5
movq (%r12), %rsi
incq %rsi
callq 0x3210
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x90ea
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x90ea
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x90ea
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x90fb
movq (%r12), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
leaq 0x1242(%rip), %rsi      # 0xa360
leaq 0x20(%rsp), %rdi
callq 0x9213
movq %rbx, %rdi
callq 0x6434
movq 0x20(%rsp), %r13
movq 0x28(%rsp), %rbp
cmpq %rbp, %r13
je 0x91a8
leaq 0x10(%rsp), %r12
movq %rsp, %r14
leaq 0x38(%rsp), %r15
movq %r12, (%rsp)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x3c88
movq %r15, %rdi
callq 0x5de0
movq %r15, %rdi
movq %r14, %rsi
callq 0x5edc
movq %rbx, %rdi
movq %r15, %rsi
callq 0x6444
movq %r15, %rdi
callq 0x3b50
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x919f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
addq $0x20, %r13
cmpq %rbp, %r13
jne 0x914c
leaq 0x20(%rsp), %rdi
callq 0x5d16
movq %rbx, %rax
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x9201
movq %rax, %r14
jmp 0x91f9
movq %rax, %r14
jmp 0x91e3
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x3b50
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x91f9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3210
movq %rbx, %rdi
callq 0x3b00
leaq 0x20(%rsp), %rdi
callq 0x5d16
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rax
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
xorps %xmm0, %xmm0
movq %rdi, (%rsp)
movups %xmm0, (%rdi)
leaq 0x18(%rsp), %rdx
movq %rdx, -0x10(%rdx)
movq %rcx, -0x8(%rdx)
movb $0x0, (%rdx)
leaq 0x1129(%rip), %rsi      # 0xa377
movq %rax, %rdi
callq 0x3090
movq %rax, %r14
testq %rax, %rax
je 0x9340
leaq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x3370
testq %rax, %rax
je 0x9306
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x10eb(%rip), %r13      # 0xa379
leaq 0x10ef(%rip), %rbp      # 0xa384
movq 0x10(%rsp), %rbx
movq %r15, %rdi
callq 0x3100
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x3350
movl $0xa, %ecx
movq %r12, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x92f1
movl $0x9, %ecx
movq %r12, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x92f1
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x93d4
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x3370
testq %rax, %rax
jne 0x9295
movq %r14, %rdi
callq 0x32f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x932a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq (%rsp), %rax
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x3120
movq %rax, %r12
leaq 0xdb0(%rip), %rsi       # 0xa104
movq %rax, %rdi
callq 0x30e0
movq 0x4c8d(%rip), %rsi      # 0xdff0
movq 0x4c56(%rip), %rdx      # 0xdfc0
movq %r12, %rdi
callq 0x33d0
jmp 0x9381
movq %rax, %r15
movq %r12, %rdi
callq 0x31b0
jmp 0x9384
movq %rax, %r15
testq %r14, %r14
je 0x9391
movq %r14, %rdi
callq 0x32f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x93ad
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq (%rsp), %rdi
callq 0x5d16
movq %r15, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %r14, %rdi
movl $0xe, %edx
callq 0x5410
movq (%r14), %rax
movq -0x18(%rax), %rax
movl 0x28(%rsp,%rax), %ebp
testb $0x5, %bpl
jne 0x5a9c
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x5300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
je 0x5a44
xorl %r14d, %r14d
jmp 0x5a51
leaq 0x8(%rsp), %rdi
callq 0x53d0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x5300
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
cmpl $0x0, 0x20(%rax,%rcx)
jne 0x5a7a
leaq 0x8(%rsp), %rdi
callq 0x53d0
subq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0x50a0
testq %r14, %r14
jle 0x5a9c
movq (%rbx), %rsi
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0x52c0
testb $0x5, %bpl
sete %bl
leaq 0x8(%rsp), %rdi
callq 0x5070
movl %ebx, %eax
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x5abf
jmp 0x5abf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5070
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rsi)
je 0x6183
movq %rsi, %r14
xorl %r12d, %r12d
leaq 0x7(%rsp), %r15
movq (%r14), %rax
movb (%rax,%r12), %al
movb %al, 0x7(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x616f
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x617a
movq %rbx, %rdi
movq %r15, %rdx
callq 0x10056
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x6152
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x61a2
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x61f6
movq %rsi, %r14
xorl %r12d, %r12d
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x51f0
incq %r12
movq (%r14), %rax
movq 0x8(%r14), %rcx
subq %rax, %rcx
cmpq %r12, %rcx
ja 0x61d7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x6215
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %r15d, %r15d
movq %r15, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %r15, 0x28(%rdi)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x993a
movl %r15d, (%rax)
incq %r15
addq $0x4, %r14
cmpq $0x100, %r15            # imm = 0x100
jne 0x62ea
cmpq $0x100, 0x28(%rbx)      # imm = 0x100
je 0x6358
movq 0x11caf(%rip), %r14     # 0x17fc8
leaq 0xb155(%rip), %rsi      # 0x11475
movl $0x19, %edx
movq %r14, %rdi
callq 0x5290
movq (%r14), %rax
addq -0x18(%rax), %r14
movq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq 0x11c7d(%rip), %rdi     # 0x17fc8
callq 0x5030
movq %rax, %rdi
callq 0x5190
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x6363
movq %rax, %r14
movq %rbx, %rdi
callq 0xb432
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0xf8(%rdi)
je 0x6411
movq 0x11c35(%rip), %r14     # 0x17fc8
leaq 0xb0f5(%rip), %rsi      # 0x1148f
movl $0x7, %edx
movq %r14, %rdi
callq 0x5290
movq 0xf0(%rbx), %rsi
movq 0xf8(%rbx), %rdx
movq %r14, %rdi
callq 0x5290
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
movq 0x11bb0(%rip), %r14     # 0x17fc8
leaq 0xb078(%rip), %rsi      # 0x11497
movl $0x255, %edx            # imm = 0x255
movq %r14, %rdi
callq 0x5290
leaq 0xb2ba(%rip), %rsi      # 0x116ed
movl $0x6, %edx
movq %r14, %rdi
callq 0x5290
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
movq %r14, %rdi
callq 0x5290
movq %rax, %r15
leaq 0xb273(%rip), %rsi      # 0x116f4
movl $0x28, %edx
movq %rax, %rdi
callq 0x5290
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r15, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
leaq 0xb23a(%rip), %rsi      # 0x1171d
movl $0x8, %edx
movq %r14, %rdi
callq 0x5290
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
movl $0x2, %esi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x99a4
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, (%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
testq %rsi, %rsi
je 0x99ee
movq %rsi, %r14
leaq 0x8cfc(%rip), %r15      # 0x126d5
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5430
decq %r14
jne 0x99de
movq (%rsp), %rax
movq 0x60(%rax), %r13
cmpq %r13, 0x68(%rax)
je 0x9af1
xorl %ebp, %ebp
movq 0xe5bf(%rip), %r14      # 0x17fc8
leaq 0x8caa(%rip), %r12      # 0x126ba
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x5290
movq %rbp, %rax
shlq $0x7, %rax
addq %rax, %r13
movq 0x8(%r13), %rax
cmpq (%r13), %rax
je 0x9a80
movl $0x8, %r15d
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x9a53
movl $0x2, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x5290
movq (%r13), %rax
movq -0x8(%rax,%r15), %rsi
movq (%rax,%r15), %rdx
movq %r14, %rdi
callq 0x5290
movq 0x8(%r13), %rax
subq (%r13), %rax
incq %rbx
sarq $0x5, %rax
addq $0x20, %r15
cmpq %rax, %rbx
jb 0x9a3e
cmpq $0x0, 0x20(%r13)
je 0x9aab
movl $0x2, %edx
movq %r14, %rdi
leaq 0x8980(%rip), %rsi      # 0x12416
callq 0x5290
movq 0x18(%r13), %rsi
movq 0x20(%r13), %rdx
movq %r14, %rdi
callq 0x5290
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r14, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5190
incq %rbp
movq (%rsp), %rax
movq 0x60(%rax), %r13
movq 0x68(%rax), %rax
subq %r13, %rax
sarq $0x7, %rax
cmpq %rax, %rbp
jb 0x9a10
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9b05
callq 0x5210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9b18
jmp 0x9b18
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x9b2f
callq 0x5210
movq %rbx, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rbx, %rdi
movl $0x8, %edx
callq 0x53b0
leaq 0xc(%rsp), %rsi
movq %rbx, %rdi
callq 0x5150
movl 0xc(%rsp), %ebx
movq 0xd813(%rip), %rsi      # 0x17fb8
leaq 0x10(%rsp), %rdi
callq 0x5320
leaq 0x88(%rsp), %rdi
callq 0x50c0
movl %ebx, %eax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq %rax, %rbx
movq 0xd7e7(%rip), %rsi      # 0x17fb8
leaq 0x10(%rsp), %rdi
callq 0x5320
leaq 0x88(%rsp), %rdi
callq 0x50c0
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x1, 0x1a(%rsi)
jne 0xb1e3
leaq 0x10(%rbx), %rax
movq %rax, (%rsp)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xb1f2
xorl %edx, %edx
leaq 0x28(%rsp), %r12
movq (%r14), %rsi
leaq 0x1(%rdx), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
cmpb $0x20, (%rsi,%rdx)
jg 0xb109
incq %rdx
cmpq %rdx, %rcx
jne 0xb0f8
movq %rcx, %rdx
cmpq %rax, %rdx
je 0xb1f2
leaq 0x1(%rdx), %rcx
cmpq %rcx, %rax
cmovaq %rax, %rcx
movq (%r14), %rax
leaq -0x1(%rcx), %rsi
movq %rdx, %rdi
cmpq %rdi, %rsi
je 0xb13c
leaq 0x1(%rdi), %r13
cmpb $0x20, 0x1(%rax,%rdi)
movq %r13, %rdi
jg 0xb127
jmp 0xb13f
movq %rcx, %r13
movq %r13, %rax
subq %rdx, %rax
cmpq $0x1, %rax
jne 0xb16e
movq (%r14), %rax
movb (%rax,%rdx), %al
leal -0x7f(%rax), %ebp
cmpb $-0x5e, %bpl
jb 0xb168
movsbl %al, %esi
movq %rbx, %rdi
callq 0x51f0
movq %r13, %rdx
cmpb $-0x5f, %bpl
ja 0xb1d1
movq (%r15), %rbp
movq %r13, %rcx
subq %rdx, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0x5250
movq (%rbp), %rax
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
movq %r12, %rdx
callq *0x18(%rax)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x50b0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb1ba
callq 0x5210
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xb1ce
callq 0x5210
movq %r13, %rdx
incq %rdx
movq 0x8(%r14), %rax
cmpq %rax, %rdx
jb 0xb0ea
jmp 0xb1f2
movq (%r15), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %r14, %rdx
callq *0x18(%rax)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb20b
movq %rax, %r14
jmp 0xb227
movq %rax, %r14
jmp 0xb23b
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xb227
callq 0x5210
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xb23b
callq 0x5210
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xb249
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x52f0
testl %ebp, %ebp
je 0xb2f9
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 0x5180
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x5380
movq 0xcca6(%rip), %rsi      # 0x17fc0
leaq 0x8(%rsp), %rdi
callq 0x5130
leaq 0x78(%rsp), %rdi
callq 0x50c0
movq %rbx, %rax
addq $0x180, %rsp            # imm = 0x180
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0xcc79(%rip), %rsi      # 0x17fc0
leaq 0x8(%rsp), %rdi
callq 0x5130
leaq 0x78(%rsp), %rdi
callq 0x50c0
movq %rbx, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0xc650
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5f43(%rip), %rsi      # 0x1258a
leaq 0x5f63(%rip), %rdx      # 0x125b1
jmp 0xc66b
cmpb $0x1, 0x9(%rsi)
jne 0xc685
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5f4e(%rip), %rsi      # 0x125b2
leaq 0x5f6b(%rip), %rdx      # 0x125d6
movq %rbx, %rdi
callq 0xc264
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x621d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0xc79d
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0xc3ac(%rip), %r14      # 0x18a70
movq 0xb8fd(%rip), %r15      # 0x17fc8
xorl %ebp, %ebp
cmpl $0xa, (%rsi,%r13)
je 0xc77c
addq %r13, %rsi
movq %r14, %rdi
callq 0xc9cc
testq %rax, %rax
je 0xc6fd
movq 0x10(%rsp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x993a
movb (%rax), %r12b
jmp 0xc770
movl $0x13, %edx
movq %r15, %rdi
leaq 0x5ecb(%rip), %rsi      # 0x125d7
callq 0x5290
movq 0x10(%rsp), %rax
movl (%rax,%r13), %esi
movq %r15, %rdi
callq 0x53c0
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
leaq 0x5eb7(%rip), %rsi      # 0x125eb
callq 0x5290
movq %r12, %rdi
movl %ebp, %esi
callq 0x53c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r12, %rdi
callq 0x5030
movb $0x3f, %r12b
movq %rax, %rdi
callq 0x5190
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x51f0
incq %rbp
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x2, %rax
addq $0x4, %r13
cmpq %rbp, %rax
ja 0xc6cd
testq %rsi, %rsi
je 0xc673
movq %rsi, %rdi
callq 0x5210
jmp 0xc673
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xc7c5
callq 0x5210
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc7d4
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
cmpb $0x1, 0x8(%rsi)
jne 0xcb0a
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5a89(%rip), %rsi      # 0x1258a
leaq 0x5aa9(%rip), %rdx      # 0x125b1
jmp 0xcb25
cmpb $0x1, 0x9(%rsi)
jne 0xcb3f
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5a94(%rip), %rsi      # 0x125b2
leaq 0x5ab1(%rip), %rdx      # 0x125d6
movq %rbx, %rdi
callq 0xc264
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rdx, %rsi
callq 0x621d
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0xcc57
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0xbf22(%rip), %r14      # 0x18aa0
movq 0xb443(%rip), %r15      # 0x17fc8
xorl %ebp, %ebp
cmpl $0xa, (%rsi,%r13)
je 0xcc36
addq %r13, %rsi
movq %r14, %rdi
callq 0xc9cc
testq %rax, %rax
je 0xcbb7
movq 0x10(%rsp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x993a
movb (%rax), %r12b
jmp 0xcc2a
movl $0x13, %edx
movq %r15, %rdi
leaq 0x5a11(%rip), %rsi      # 0x125d7
callq 0x5290
movq 0x10(%rsp), %rax
movl (%rax,%r13), %esi
movq %r15, %rdi
callq 0x53c0
movq %rax, %r12
movl $0x4, %edx
movq %rax, %rdi
leaq 0x59fd(%rip), %rsi      # 0x125eb
callq 0x5290
movq %r12, %rdi
movl %ebp, %esi
callq 0x53c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x5220
movsbl %al, %esi
movq %r12, %rdi
callq 0x5030
movb $0x3f, %r12b
movq %rax, %rdi
callq 0x5190
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x51f0
incq %rbp
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rax
subq %rsi, %rax
sarq $0x2, %rax
addq $0x4, %r13
cmpq %rbp, %rax
ja 0xcb87
testq %rsi, %rsi
je 0xcb2d
movq %rsi, %rdi
callq 0x5210
jmp 0xcb2d
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xcc7f
callq 0x5210
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xcc8e
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %r8d
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
shrq %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x1(%rcx), %rdx
movq %rdx, 0x18(%rsi)
subq %rax, %rcx
je 0xce31
movzbl %r8b, %eax
cmpq $0x1, %rcx
jne 0xce2b
shll $0x8, %eax
orq %rax, 0x10(%r14)
jmp 0xce3c
movzbl %r8b, %eax
shll $0x10, %eax
movq %rax, 0x10(%r14)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
testq %rcx, %rcx
je 0xce68
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
cmpq $0x1, %rcx
jne 0xce76
shrq $0xc, %rdx
jmp 0xce90
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
shrq $0x12, %rdx
jmp 0xce90
shrl $0x6, %edx
andl $0x3f, %edx
movsbl (%rax,%rdx), %esi
movq %rbx, %rdi
callq 0x51f0
movq 0x8(%r14), %rax
movq 0x10(%r14), %rdx
andl $0x3f, %edx
movsbl (%rax,%rdx), %esi
movq %rbx, %rdi
callq 0x51f0
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xceb8
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x4, 0x8(%rdx)
jb 0xd059
movq %rdx, %r14
movl $0x3, %r12d
movl $0x3e, %ebp
movq (%r14), %rcx
movsbl -0x3(%rcx,%r12), %edx
leal -0x41(%rdx), %eax
cmpl $0x1a, %eax
jb 0xcf39
leal -0x61(%rdx), %eax
cmpl $0x19, %eax
ja 0xcf18
addl $-0x47, %edx
jmp 0xcf23
leal -0x30(%rdx), %eax
cmpl $0x9, %eax
ja 0xcf27
addl $0x4, %edx
movl %edx, %eax
jmp 0xcf39
movl $0x3f, %eax
cmpb $0x2f, %dl
je 0xcf33
xorl %eax, %eax
cmpb $0x2b, %dl
cmovel %ebp, %eax
movsbl -0x2(%rcx,%r12), %esi
leal -0x41(%rsi), %edx
cmpl $0x1a, %edx
jb 0xcf77
leal -0x61(%rsi), %edx
cmpl $0x19, %edx
ja 0xcf54
addl $-0x47, %esi
jmp 0xcf5f
leal -0x30(%rsi), %edx
cmpl $0x9, %edx
ja 0xcf63
addl $0x4, %esi
movl %esi, %edx
jmp 0xcf77
movl $0x3f, %edx
cmpb $0x2f, %sil
je 0xcf70
xorl %edx, %edx
cmpb $0x2b, %sil
cmovel %ebp, %edx
movsbl -0x1(%rcx,%r12), %esi
leal -0x41(%rsi), %r13d
cmpl $0x1a, %r13d
jb 0xcfbb
leal -0x61(%rsi), %edi
cmpl $0x19, %edi
ja 0xcf94
addl $-0x47, %esi
jmp 0xcf9f
leal -0x30(%rsi), %edi
cmpl $0x9, %edi
ja 0xcfa4
addl $0x4, %esi
movl %esi, %r13d
jmp 0xcfbb
movl $0x3f, %r13d
cmpb $0x2f, %sil
je 0xcfb3
xorl %r13d, %r13d
cmpb $0x2b, %sil
cmovel %ebp, %r13d
movsbl (%rcx,%r12), %ecx
leal -0x41(%rcx), %esi
cmpl $0x1a, %esi
jb 0xcff6
leal -0x61(%rcx), %esi
cmpl $0x19, %esi
ja 0xcfd5
addl $-0x47, %ecx
jmp 0xcfe0
leal -0x30(%rcx), %esi
cmpl $0x9, %esi
ja 0xcfe4
addl $0x4, %ecx
movl %ecx, %esi
jmp 0xcff6
movl $0x3f, %esi
cmpb $0x2f, %cl
je 0xcff0
xorl %esi, %esi
cmpb $0x2b, %cl
cmovel %ebp, %esi
shll $0x12, %eax
shll $0xc, %edx
addl %eax, %edx
shll $0x6, %r13d
addl %edx, %r13d
addl %esi, %r13d
movl %r13d, %eax
shrl $0x10, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x51f0
movq (%r14), %rax
cmpb $0x3d, -0x1(%rax,%r12)
je 0xd035
movl %r13d, %eax
shrl $0x8, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x51f0
movq (%r14), %rax
cmpb $0x3d, (%rax,%r12)
je 0xd04b
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x51f0
addq $0x4, %r12
cmpq 0x8(%r14), %r12
jb 0xcefa
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
cmpq %r15, %rdi
je 0xd07b
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
movq %r15, %rax
mulq %rcx
shrq %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %r15
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x2, %r15
je 0xd108
cmpq $0x1, %r15
jne 0xd131
movq 0x8(%r14), %rax
movl 0x10(%r14), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x51f0
leaq 0x5537(%rip), %rsi      # 0x12631
movq %rbx, %rdi
callq 0x5430
cmpq $0x2, %r15
jne 0xd131
movq 0x8(%r14), %rax
movl 0x10(%r14), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x51f0
leaq 0x5509(%rip), %rsi      # 0x12632
movq %rbx, %rdi
callq 0x5430
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xd150
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x18(%rsi), %rax
movl %edx, %ecx
shrl $0x4, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51f0
movq 0x18(%r14), %rax
andl $0xf, %r15d
movsbl (%rax,%r15), %esi
movq %rbx, %rdi
callq 0x51f0
cmpb $0x1, 0x20(%r14)
jne 0xd1e9
leaq 0x549c(%rip), %rsi      # 0x12656
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xb528
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52b0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd1e9
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xd1fa
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xd20a
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rcx
testq %rcx, %rcx
je 0xd2fd
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
xorl %eax, %eax
xorl %r12d, %r12d
cmpb $0x1, 0x20(%r15)
jne 0xd27b
leaq 0x2(%r12), %rdx
cmpq %rcx, %rdx
jae 0xd27b
movq (%r14), %rcx
cmpb $0x30, (%rcx,%r12)
jne 0xd27b
cmpb $0x78, 0x1(%rcx,%r12)
je 0xd278
movq %r12, %rdx
movq %rdx, %r12
movq (%r14), %rcx
movb (%rcx,%r12), %cl
movzbl %cl, %ebp
leal -0x30(%rbp), %ecx
cmpb $0xa, %cl
jb 0xd2a5
leal -0x41(%rbp), %edx
cmpl $0x25, %edx
ja 0xd2ed
movabsq $0x3f0000003f, %rsi     # imm = 0x3F0000003F
btq %rdx, %rsi
jae 0xd2ed
cmpb $0xa, %cl
jb 0xd2ae
xorl %ecx, %ecx
jmp 0xd2b1
leal -0x30(%rbp), %ecx
leal -0x61(%rbp), %edx
leal -0x57(%rbp), %esi
cmpb $0x6, %dl
cmovael %ecx, %esi
leal -0x41(%rbp), %ecx
addl $-0x37, %ebp
cmpb $0x6, %cl
cmovael %esi, %ebp
movl %r13d, %ecx
andl $0x80000001, %ecx       # imm = 0x80000001
cmpl $0x1, %ecx
jne 0xd2e8
shll $0x4, %eax
orl %eax, %ebp
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x51f0
incl %r13d
movl %ebp, %eax
incq %r12
movq 0x8(%r14), %rcx
cmpq %rcx, %r12
jb 0xd252
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
cmpq (%rsp), %rdi
je 0xd320
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0xb79c(%rip), %al       # 0x18af0
testb %al, %al
je 0xd42a
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl %bpl, %r12d
cmpb $0x1, 0x8(%r14)
movl %r12d, %r14d
jne 0xd3a9
cmpb $0x64, %bpl
jb 0xd3a1
imulq $0x28f5c29, %r14, %rax  # imm = 0x28F5C29
shrq $0x20, %rax
movq 0xb73b(%rip), %rcx      # 0x18ad0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
cmpb $0x9, %bpl
ja 0xd3c7
jmp 0xd3f7
imulq $0x28f5c29, %r14, %rax  # imm = 0x28F5C29
shrq $0x20, %rax
movq 0xb715(%rip), %rcx      # 0x18ad0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
imulq $0x1999999a, %r14, %rax # imm = 0x1999999A
shrq $0x20, %rax
imulq $0x1999999a, %rax, %rcx # imm = 0x1999999A
shrq $0x20, %rcx
addl %ecx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movq 0xb6e5(%rip), %rcx      # 0x18ad0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
imulq $0x1999999a, %r14, %rax # imm = 0x1999999A
shrq $0x20, %rax
addl %eax, %eax
leal (%rax,%rax,4), %eax
subl %eax, %r12d
movq 0xb6bf(%rip), %rax      # 0x18ad0
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x51f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb6bf(%rip), %rdi      # 0x18af0
callq 0x5400
testl %eax, %eax
je 0xd35c
leaq 0xb69b(%rip), %rax      # 0x18ae0
movq %rax, 0xb684(%rip)      # 0x18ad0
leaq 0xb67d(%rip), %rdi      # 0x18ad0
leaq 0x51ff(%rip), %rsi      # 0x12659
leaq 0x5202(%rip), %rdx      # 0x12663
callq 0xc264
movq 0xab33(%rip), %rdi      # 0x17fa0
leaq 0xb65c(%rip), %rsi      # 0x18ad0
leaq 0xadad(%rip), %rdx      # 0x18228
callq 0x5200
leaq 0xb669(%rip), %rdi      # 0x18af0
callq 0x5170
jmp 0xd35c
movq %rax, %r14
leaq 0xb655(%rip), %rdi      # 0x18af0
callq 0x5160
jmp 0xd4b2
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xd4b2
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]base256/base256.cpp
// Function: Decimal::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++) {
      char c = s[i];
      if((c >= '0' && c <= '9')) {
        int d = c - '0';
        if(count % 3 == 0) {
          val = d;
        } else {
          val *= 10;
          val += d;
        }
        if(count % 3 == 2) result.push_back(val);
        count++;
      }
    }
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x0, 0x8(%rdx)
je 0xd550
movq %rdx, %r14
xorl %r12d, %r12d
movl $0xffffffd0, %ebp       # imm = 0xFFFFFFD0
xorl %r15d, %r15d
xorl %r13d, %r13d
movq (%r14), %rax
movzbl (%rax,%r13), %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0xd547
movslq %r12d, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rsi
shrq $0x3f, %rsi
shrq $0x20, %rdx
addl %esi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %ecx
leal (%r15,%r15,4), %edx
leal -0x30(%rdx,%rdx), %r15d
cmovel %ebp, %r15d
addl %eax, %r15d
cmpl $0x2, %ecx
jne 0xd544
movsbl %r15b, %esi
movq %rbx, %rdi
callq 0x51f0
incl %r12d
incq %r13
cmpq 0x8(%r14), %r13
jb 0xd4f7
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
cmpq (%rsp), %rdi
je 0xd573
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]base256/base256.cpp
// Function: Octal::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 = "01234567";
    std::string result;
    result += d[c / 64];
    result += d[(c / 8) % 8];
    result += d[c % 8];
    if(prefix) result = "0" + result;
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movb 0xb572(%rip), %al       # 0x18b18
testb %al, %al
je 0xd65b
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl %bpl, %r12d
movl %r12d, %eax
shrl $0x6, %eax
movq 0xb526(%rip), %rcx      # 0x18af8
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
movl %r12d, %eax
shrl $0x3, %eax
andl $0x7, %eax
movq 0xb50a(%rip), %rcx      # 0x18af8
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
andl $0x7, %r12d
movq 0xb4f3(%rip), %rax      # 0x18af8
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x51f0
cmpb $0x1, 0x8(%r14)
jne 0xd64b
leaq 0x4c51(%rip), %rsi      # 0x12271
movq %rsp, %rdi
movq %rbx, %rdx
callq 0xb528
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52b0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xd64b
callq 0x5210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb4b6(%rip), %rdi      # 0x18b18
callq 0x5400
testl %eax, %eax
je 0xd5ae
leaq 0xb492(%rip), %rax      # 0x18b08
movq %rax, 0xb47b(%rip)      # 0x18af8
leaq 0xb474(%rip), %rdi      # 0x18af8
leaq 0x4fd9(%rip), %rsi      # 0x12664
leaq 0x4fda(%rip), %rdx      # 0x1266c
callq 0xc264
movq 0xa902(%rip), %rdi      # 0x17fa0
leaq 0xb453(%rip), %rsi      # 0x18af8
leaq 0xab7c(%rip), %rdx      # 0x18228
callq 0x5200
leaq 0xb460(%rip), %rdi      # 0x18b18
callq 0x5170
jmp 0xd5ae
movq %rax, %r14
leaq 0xb44c(%rip), %rdi      # 0x18b18
callq 0x5160
jmp 0xd6e5
jmp 0xd6d5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xd6e5
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/lvandeve[P]base256/base256.cpp
// Function: Binary::encodeChar[abi:cxx11](unsigned char, unsigned char, unsigned char)
std::string encodeChar(unsigned char c, unsigned char prev, unsigned char next) {
    std::string result;
    for(int j = 0; j < 8; j++) {
      if(lsb_first) {
        result += ((c >> j) & 1) ? '1' : '0';
      } else {
        result += ((c >> (7 - j)) & 1) ? '1' : '0';
      }
    }
    if(prefix) result = "0b" + result;
    return result;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %r12d, %r12d
movl $0x7, %r13d
cmpb $0x0, 0x9(%r14)
movl %r13d, %eax
cmovnel %r12d, %eax
btl %eax, %ebp
movl $0x0, %esi
adcl $0x30, %esi
movq %rbx, %rdi
callq 0x51f0
incl %r12d
addl $-0x1, %r13d
jb 0xd732
cmpb $0x0, 0x8(%r14)
je 0xd797
leaq 0x4f05(%rip), %rsi      # 0x1266d
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xb528
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52b0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd797
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd7ab
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xd7bb
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop