LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x11d5(%rip), %rsi      # 0xa3c7
movq %rax, %rdi
callq 0x3090
testq %rax, %rax
je 0x92e4
movq %rax, %r14
leaq 0x28(%rsp), %rdi
movl $0x200, %esi            # imm = 0x200
movq %rax, %rdx
callq 0x3370
testq %rax, %rax
je 0x92aa
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
leaq 0x1197(%rip), %r13      # 0xa3c9
leaq 0x119b(%rip), %rbp      # 0xa3d4
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 0x9295
movl $0x9, %ecx
movq %r12, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0x33e0
cmpq $-0x1, %rax
jne 0x9295
movq (%rsp), %rdi
movq %r12, %rsi
callq 0x9376
movq %r15, %rdi
movl $0x200, %esi            # imm = 0x200
movq %r14, %rdx
callq 0x3370
testq %rax, %rax
jne 0x9239
movq %r14, %rdi
callq 0x32f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x92ce
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, %r14
leaq 0xe0c(%rip), %rsi       # 0xa104
movq %rax, %rdi
callq 0x30e0
movq 0x4ce9(%rip), %rsi      # 0xdff0
movq 0x4cb2(%rip), %rdx      # 0xdfc0
movq %r14, %rdi
callq 0x33d0
movq %rax, %r15
jmp 0x9333
movq %rax, %r15
movq %r14, %rdi
callq 0x31b0
jmp 0x9333
movq %rax, %r15
movq %r14, %rdi
callq 0x32f0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x934f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3210
movq (%rsp), %rdi
callq 0x5ce6
movq %r15, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x61bb
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 0x61a7
movb %al, (%rsi)
incq 0x8(%rbx)
jmp 0x61b2
movq %rbx, %rdi
movq %r15, %rdx
callq 0xfdc0
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x618a
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 0x61da
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x622e
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 0x620f
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 0x624d
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x97e0
movl %r15d, (%rax)
incq %r15
addq $0x4, %r14
cmpq $0x100, %r15            # imm = 0x100
jne 0x6322
cmpq $0x100, 0x28(%rbx)      # imm = 0x100
je 0x6390
movq 0x11c77(%rip), %r14     # 0x17fc8
leaq 0xb11d(%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 0x11c45(%rip), %rdi     # 0x17fc8
callq 0x5030
movq %rax, %rdi
callq 0x5190
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
jmp 0x639b
movq %rax, %r14
movq %rbx, %rdi
callq 0xb1ce
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6449
movq 0x11bfd(%rip), %r14     # 0x17fc8
leaq 0xb0bd(%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 0x11b78(%rip), %r14     # 0x17fc8
leaq 0xb040(%rip), %rsi      # 0x11497
movl $0x255, %edx            # imm = 0x255
movq %r14, %rdi
callq 0x5290
leaq 0xb282(%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 0xb23b(%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 0xb202(%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 0x984c
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9896
movq %rsi, %r14
leaq 0x8e54(%rip), %r15      # 0x126d5
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x5430
decq %r14
jne 0x9886
movq (%rsp), %rax
movq 0x60(%rax), %r13
cmpq %r13, 0x68(%rax)
je 0x999c
xorl %ebp, %ebp
movq 0xe717(%rip), %r14      # 0x17fc8
leaq 0x8e02(%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 (%r13), %rax
cmpq %rax, 0x8(%r13)
je 0x992b
movl $0x8, %r15d
xorl %ebx, %ebx
testq %rbx, %rbx
je 0x98ff
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
incq %rbx
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
addq $0x20, %r15
cmpq %rcx, %rbx
jb 0x98e6
cmpq $0x0, 0x20(%r13)
je 0x9956
movl $0x2, %edx
movq %r14, %rdi
leaq 0x8ad5(%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 0x98b8
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x99b0
callq 0x5210
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x99c3
jmp 0x99c3
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x99da
callq 0x5210
movq %rbx, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xda67(%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 0xda3b(%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_O3/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 0xaf79
leaq 0x10(%rbx), %rax
movq %rax, (%rsp)
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0xaf88
xorl %r13d, %r13d
leaq 0x28(%rsp), %r12
movq (%r14), %rax
leaq 0x1(%r13), %rsi
cmpq %rsi, %rcx
cmovaq %rcx, %rsi
movq %r13, %rdx
cmpb $0x20, (%rax,%rdx)
jg 0xaeb3
incq %rdx
cmpq %rdx, %rsi
jne 0xaea2
movq %rsi, %rdx
cmpq %rcx, %rdx
je 0xaf88
leaq 0x1(%rdx), %rsi
cmpq %rsi, %rcx
cmovaq %rcx, %rsi
leaq -0x1(%rsi), %r13
movq %rdx, %rdi
cmpq %rdi, %r13
je 0xaee7
leaq 0x1(%rdi), %rcx
cmpb $0x20, 0x1(%rax,%rdi)
movq %rcx, %rdi
jg 0xaece
leaq -0x1(%rcx), %r13
jmp 0xaeea
movq %rsi, %rcx
subq %rdx, %rcx
cmpq $0x1, %rcx
jne 0xaeff
movb (%rax,%rdx), %al
leal -0x7f(%rax), %esi
cmpb $-0x5e, %sil
jae 0xaf5b
movq (%r15), %rbp
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 0xaf45
callq 0x5210
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xaf66
callq 0x5210
jmp 0xaf66
movsbl %al, %esi
movq %rbx, %rdi
callq 0x51f0
addq $0x2, %r13
movq 0x8(%r14), %rcx
cmpq %rcx, %r13
jb 0xae91
jmp 0xaf88
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 0xafa1
movq %rax, %r14
jmp 0xafbd
movq %rax, %r14
jmp 0xafd1
movq %rax, %r14
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xafbd
callq 0x5210
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0xafd1
callq 0x5210
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0xafdf
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb08f
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 0xcf10(%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 0xcee3(%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_O3/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 0xc386
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x620d(%rip), %rsi      # 0x1258a
leaq 0x622d(%rip), %rdx      # 0x125b1
jmp 0xc3a1
cmpb $0x1, 0x9(%rsi)
jne 0xc3bb
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x6218(%rip), %rsi      # 0x125b2
leaq 0x6235(%rip), %rdx      # 0x125d6
movq %rbx, %rdi
callq 0xbfd2
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 0x6255
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0xc4d3
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0xc676(%rip), %r14      # 0x18a70
movq 0xbbc7(%rip), %r15      # 0x17fc8
xorl %ebp, %ebp
cmpl $0xa, (%rsi,%r13)
je 0xc4b2
addq %r13, %rsi
movq %r14, %rdi
callq 0xc6f6
testq %rax, %rax
je 0xc433
movq 0x10(%rsp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x97e0
movb (%rax), %r12b
jmp 0xc4a6
movl $0x13, %edx
movq %r15, %rdi
leaq 0x6195(%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 0x6181(%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 0xc403
testq %rsi, %rsi
je 0xc3a9
movq %rsi, %rdi
callq 0x5210
jmp 0xc3a9
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xc4fb
callq 0x5210
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc50a
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc832
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5d61(%rip), %rsi      # 0x1258a
leaq 0x5d81(%rip), %rdx      # 0x125b1
jmp 0xc84d
cmpb $0x1, 0x9(%rsi)
jne 0xc867
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x5d6c(%rip), %rsi      # 0x125b2
leaq 0x5d89(%rip), %rdx      # 0x125d6
movq %rbx, %rdi
callq 0xbfd2
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 0x6255
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq (%r14), %rsi
cmpq %rsi, 0x8(%r14)
je 0xc97f
movq %rax, 0x8(%rsp)
xorl %r13d, %r13d
leaq 0xc1fa(%rip), %r14      # 0x18aa0
movq 0xb71b(%rip), %r15      # 0x17fc8
xorl %ebp, %ebp
cmpl $0xa, (%rsi,%r13)
je 0xc95e
addq %r13, %rsi
movq %r14, %rdi
callq 0xc6f6
testq %rax, %rax
je 0xc8df
movq 0x10(%rsp), %rsi
addq %r13, %rsi
movq %r14, %rdi
callq 0x97e0
movb (%rax), %r12b
jmp 0xc952
movl $0x13, %edx
movq %r15, %rdi
leaq 0x5ce9(%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 0x5cd5(%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 0xc8af
testq %rsi, %rsi
je 0xc855
movq %rsi, %rdi
callq 0x5210
jmp 0xc855
movq %rax, %r14
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xc9a7
callq 0x5210
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0xc9b6
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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, %ecx
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %rsi
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rsi, %rax
mulq %rdx
shrq %rdx
leaq (%rdx,%rdx,2), %rax
movq %rsi, %rdx
subq %rax, %rdx
incq %rsi
movq %rsi, 0x18(%r14)
movl %ecx, %eax
cmpq $0x1, %rdx
je 0xcb83
testq %rdx, %rdx
jne 0xcbb9
movl %eax, %ecx
shll $0x10, %ecx
movq %rcx, 0x10(%r14)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
shrl $0x2, %eax
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
jmp 0xcc01
shll $0x8, %eax
orq 0x10(%r14), %rax
movq %rax, 0x10(%r14)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
shrl $0xc, %eax
andl $0x3f, %eax
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
jmp 0xcc01
orq 0x10(%r14), %rax
movq %rax, 0x10(%r14)
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movq 0x8(%r14), %rcx
shrl $0x6, %eax
andl $0x3f, %eax
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %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 0xcc1a
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcdbb
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 0xcc9b
leal -0x61(%rdx), %eax
cmpl $0x19, %eax
ja 0xcc7a
addl $-0x47, %edx
jmp 0xcc85
leal -0x30(%rdx), %eax
cmpl $0x9, %eax
ja 0xcc89
addl $0x4, %edx
movl %edx, %eax
jmp 0xcc9b
movl $0x3f, %eax
cmpb $0x2f, %dl
je 0xcc95
xorl %eax, %eax
cmpb $0x2b, %dl
cmovel %ebp, %eax
movsbl -0x2(%rcx,%r12), %esi
leal -0x41(%rsi), %edx
cmpl $0x1a, %edx
jb 0xccd9
leal -0x61(%rsi), %edx
cmpl $0x19, %edx
ja 0xccb6
addl $-0x47, %esi
jmp 0xccc1
leal -0x30(%rsi), %edx
cmpl $0x9, %edx
ja 0xccc5
addl $0x4, %esi
movl %esi, %edx
jmp 0xccd9
movl $0x3f, %edx
cmpb $0x2f, %sil
je 0xccd2
xorl %edx, %edx
cmpb $0x2b, %sil
cmovel %ebp, %edx
movsbl -0x1(%rcx,%r12), %esi
leal -0x41(%rsi), %r13d
cmpl $0x1a, %r13d
jb 0xcd1d
leal -0x61(%rsi), %edi
cmpl $0x19, %edi
ja 0xccf6
addl $-0x47, %esi
jmp 0xcd01
leal -0x30(%rsi), %edi
cmpl $0x9, %edi
ja 0xcd06
addl $0x4, %esi
movl %esi, %r13d
jmp 0xcd1d
movl $0x3f, %r13d
cmpb $0x2f, %sil
je 0xcd15
xorl %r13d, %r13d
cmpb $0x2b, %sil
cmovel %ebp, %r13d
movsbl (%rcx,%r12), %ecx
leal -0x41(%rcx), %esi
cmpl $0x1a, %esi
jb 0xcd58
leal -0x61(%rcx), %esi
cmpl $0x19, %esi
ja 0xcd37
addl $-0x47, %ecx
jmp 0xcd42
leal -0x30(%rcx), %esi
cmpl $0x9, %esi
ja 0xcd46
addl $0x4, %ecx
movl %ecx, %esi
jmp 0xcd58
movl $0x3f, %esi
cmpb $0x2f, %cl
je 0xcd52
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 0xcd9a
movl %r13d, %eax
shrl $0x8, %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x51f0
movq (%r14), %rax
cmpb $0x3d, (%rax,%r12)
je 0xcdad
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x51f0
addq $0x4, %r12
cmpq 0x8(%r14), %r12
jb 0xcc5c
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 0xcddd
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
movq %rcx, %rax
mulq %rdx
shrq %rdx
leaq (%rdx,%rdx,2), %rax
subq %rax, %rcx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpq $0x2, %rcx
je 0xce57
cmpq $0x1, %rcx
jne 0xce7f
movq 0x8(%rsi), %rax
movl 0x10(%rsi), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x51f0
leaq 0x57dc(%rip), %rsi      # 0x12631
jmp 0xce77
movq 0x8(%rsi), %rax
movl 0x10(%rsi), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
movq %rbx, %rdi
callq 0x51f0
leaq 0x57bb(%rip), %rsi      # 0x12632
movq %rbx, %rdi
callq 0x5430
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xce98
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xcf31
leaq 0x5754(%rip), %rsi      # 0x12656
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xb2c4
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52b0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xcf31
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xcf42
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xcf52
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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), %rax
testq %rax, %rax
je 0xd04d
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
xorl %ecx, %ecx
xorl %r12d, %r12d
cmpb $0x0, 0x20(%r15)
je 0xcfc5
leaq 0x2(%r12), %rsi
movq (%r14), %rdx
cmpq %rax, %rsi
jae 0xcfc8
cmpb $0x30, (%rdx,%r12)
jne 0xcfc8
cmpb $0x78, 0x1(%rdx,%r12)
je 0xcfc0
movq %r12, %rsi
movq %rsi, %r12
jmp 0xcfc8
movq (%r14), %rdx
movb (%rdx,%r12), %dl
leal -0x30(%rdx), %esi
cmpb $0xa, %sil
jb 0xcff2
movzbl %dl, %esi
addl $-0x41, %esi
cmpl $0x25, %esi
ja 0xd041
movabsq $0x3f0000003f, %rdi     # imm = 0x3F0000003F
btq %rsi, %rdi
jae 0xd041
xorl %esi, %esi
leal -0x61(%rdx), %edi
leal -0x57(%rdx), %r8d
cmpb $0x6, %dil
movzbl %sil, %esi
movzbl %r8b, %edi
cmovael %esi, %edi
leal -0x41(%rdx), %esi
addb $-0x37, %dl
cmpb $0x6, %sil
movzbl %dl, %ebp
cmovael %edi, %ebp
movl %r13d, %edx
andl $0x80000001, %edx       # imm = 0x80000001
cmpl $0x1, %edx
jne 0xd03c
shlb $0x4, %cl
orb %cl, %bpl
movsbl %bpl, %esi
movq %rbx, %rdi
callq 0x51f0
movq 0x8(%r14), %rax
incl %r13d
movl %ebp, %ecx
incq %r12
cmpq %rax, %r12
jb 0xcf9a
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 0xd070
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xba4c(%rip), %al       # 0x18af0
testb %al, %al
je 0xd15f
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
movzbl %bpl, %r12d
cmpb $0x63, %bpl
ja 0xd0d8
cmpb $0x0, 0x8(%r14)
je 0xd0d8
cmpb $0x9, %bpl
ja 0xd0f6
jmp 0xd129
leal (%r12,%r12,4), %eax
leal (%r12,%rax,8), %eax
shrl $0xc, %eax
movq 0xb9e6(%rip), %rcx      # 0x18ad0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
imull $0xcd, %r12d, %eax
shrl $0xb, %eax
leal (%rax,%rax,4), %ecx
leal (%rcx,%rcx,4), %ecx
addl %eax, %ecx
shrl $0x7, %ecx
andl $0x6, %ecx
leal (%rcx,%rcx,4), %ecx
subb %cl, %al
movzbl %al, %eax
movq 0xb9b3(%rip), %rcx      # 0x18ad0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
imull $0xcd, %r12d, %eax
shrl $0xa, %eax
andl $-0x2, %eax
leal (%rax,%rax,4), %eax
subb %al, %bpl
movzbl %bpl, %eax
movq 0xb989(%rip), %rcx      # 0x18ad0
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb98a(%rip), %rdi      # 0x18af0
callq 0x5400
testl %eax, %eax
je 0xd0ac
leaq 0xb966(%rip), %rax      # 0x18ae0
movq %rax, 0xb94f(%rip)      # 0x18ad0
leaq 0xb948(%rip), %rdi      # 0x18ad0
leaq 0x54ca(%rip), %rsi      # 0x12659
leaq 0x54cd(%rip), %rdx      # 0x12663
callq 0xbfd2
movq 0xadfe(%rip), %rdi      # 0x17fa0
leaq 0xb927(%rip), %rsi      # 0x18ad0
leaq 0xb078(%rip), %rdx      # 0x18228
callq 0x5200
leaq 0xb934(%rip), %rdi      # 0x18af0
callq 0x5170
jmp 0xd0ac
movq %rax, %r14
leaq 0xb920(%rip), %rdi      # 0x18af0
callq 0x5160
jmp 0xd1e7
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xd1e7
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0xd285
movq %rdx, %r14
xorl %r12d, %r12d
xorl %ebp, %ebp
xorl %r13d, %r13d
movq (%r14), %rcx
movb (%rcx,%r13), %cl
addb $-0x30, %cl
cmpb $0x9, %cl
ja 0xd27d
movslq %r12d, %rsi
imulq $0x55555556, %rsi, %rdx # imm = 0x55555556
movq %rdx, %rdi
shrq $0x3f, %rdi
shrq $0x20, %rdx
addl %edi, %edx
leal (%rdx,%rdx,2), %edx
subl %edx, %esi
movzbl %bpl, %edx
addl %edx, %edx
leal (%rdx,%rdx,4), %edx
addb %cl, %dl
testl %esi, %esi
movzbl %dl, %edi
movzbl %cl, %ebp
cmovnel %edi, %ebp
cmpl $0x2, %esi
jne 0xd27a
movsbl %dl, %esi
movq %rbx, %rdi
callq 0x51f0
movq 0x8(%r14), %rax
incl %r12d
incq %r13
cmpq %rax, %r13
jb 0xd225
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 0xd2a7
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb83e(%rip), %al       # 0x18b18
testb %al, %al
je 0xd38f
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 0xb7f2(%rip), %rcx      # 0x18af8
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
movl %r12d, %eax
shrl $0x3, %eax
andl $0x7, %eax
movq 0xb7d6(%rip), %rcx      # 0x18af8
movsbl (%rcx,%rax), %esi
movq %rbx, %rdi
callq 0x51f0
andl $0x7, %r12d
movq 0xb7bf(%rip), %rax      # 0x18af8
movsbl (%rax,%r12), %esi
movq %rbx, %rdi
callq 0x51f0
cmpb $0x1, 0x8(%r14)
jne 0xd37f
leaq 0x4f1d(%rip), %rsi      # 0x12271
movq %rsp, %rdi
movq %rbx, %rdx
callq 0xb2c4
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52b0
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xd37f
callq 0x5210
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xb782(%rip), %rdi      # 0x18b18
callq 0x5400
testl %eax, %eax
je 0xd2e2
leaq 0xb75e(%rip), %rax      # 0x18b08
movq %rax, 0xb747(%rip)      # 0x18af8
leaq 0xb740(%rip), %rdi      # 0x18af8
leaq 0x52a5(%rip), %rsi      # 0x12664
leaq 0x52a6(%rip), %rdx      # 0x1266c
callq 0xbfd2
movq 0xabce(%rip), %rdi      # 0x17fa0
leaq 0xb71f(%rip), %rsi      # 0x18af8
leaq 0xae48(%rip), %rdx      # 0x18228
callq 0x5200
leaq 0xb72c(%rip), %rdi      # 0x18b18
callq 0x5170
jmp 0xd2e2
movq %rax, %r14
leaq 0xb718(%rip), %rdi      # 0x18b18
callq 0x5160
jmp 0xd419
jmp 0xd409
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xd419
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd466
cmpb $0x0, 0x8(%r14)
je 0xd4cb
leaq 0x51d1(%rip), %rsi      # 0x1266d
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0xb2c4
leaq 0x8(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x52b0
movq (%r14), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xd4cb
callq 0x5210
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd4df
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xd4ef
callq 0x5210
movq %r14, %rdi
callq 0x53e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/lvandeve[P]base256/base256.cpp
// Function: Binary::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 != '1') continue;
      if(lsb_first) {
        val |= (c == '1' ? 1 : 0) << count;
      } else {
        val <<= 1;
        val |= (c == '1' ? 1 : 0);
      }
      count++;
      if(count == 8) {
        count = 0;
        char c2 = val;
        result += c2;
        val = 0;
      }
    }
    if(count != 0) {
      char c2 = val;
      result += c2;
    }
    return result;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x8(%rdx), %rax
testq %rax, %rax
je 0xd5a7
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
movq (%r14), %rsi
movb 0x9(%r15), %dil
xorl %ecx, %ecx
xorl %edx, %edx
movb (%rsi,%r13), %r8b
leal -0x32(%r8), %r9d
cmpb $-0x2, %r9b
jb 0xd575
testb $0x1, %dil
je 0xd55f
xorl %r9d, %r9d
cmpb $0x31, %r8b
sete %r9b
shll %cl, %r9d
orl %r9d, %edx
jmp 0xd56e
xorl %r9d, %r9d
cmpb $0x31, %r8b
sete %r9b
leal (%r9,%rdx,2), %edx
incl %ecx
cmpl $0x8, %ecx
je 0xd57f
incq %r13
cmpq %rax, %r13
jb 0xd538
jmp 0xd598
movsbl %dl, %esi
movq %rbx, %rdi
callq 0x51f0
movq 0x8(%r14), %rax
incq %r13
cmpq %rax, %r13
jb 0xd52d
jmp 0xd5a7
testl %ecx, %ecx
je 0xd5a7
movsbl %dl, %esi
movq %rbx, %rdi
callq 0x51f0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xd5b6
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xd5c6
callq 0x5210
movq %r14, %rdi
callq 0x53e0
// File: /workspace/github_cpp_makefile_star2_O3/isaacbrodsky[P]K-means-plus-plus/main.cpp
// Function: main
int main(int argc, char *argv[]) {

	// local variables
	Cluster_set clCluster_set_instance;

	// check if there are any command line arguments
	if (argc < 2) { // missing input argument
		cout << "No control file specified" << endl << endl;
		cout << "Required input format is: k-means++ <control file name>" << endl << endl;
		return 1;
	}
	else { // input argument present
		// read the parameter data from the input file
		clCluster_set_instance.Read_control_data(argv[1]);

		// start the clustering program
		clCluster_set_instance.Execute_clustering();
	} // if

	return 0;  // that's all folks
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x1460, %rsp           # imm = 0x1460
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x28(%rsp), %rdi
callq 0x3aaa
cmpl $0x1, %ebp
jg 0x3796
movq 0x890a(%rip), %rbx      # 0xbfc0
leaq 0x4947(%rip), %rsi      # 0x8004
movl $0x19, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq 0x88d8(%rip), %rdi      # 0xbfc0
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq 0x889a(%rip), %rbx      # 0xbfc0
leaq 0x48f1(%rip), %rsi      # 0x801e
movl $0x37, %edx
movq %rbx, %rdi
callq 0x3330
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq 0x8868(%rip), %rdi      # 0xbfc0
callq 0x3030
movq %rax, %rdi
callq 0x31e0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movl $0x1, %ebx
movq %rax, %rdi
callq 0x31e0
jmp 0x37df
movq 0x8(%rbx), %rsi
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3884
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3cac
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x37d3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
xorl %ebx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x402a
leaq 0xa8(%rsp), %r14
movq %r14, %rdi
callq 0x3914
movq -0x28(%r14), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0x3810
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x32f0
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x382b
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x32f0
leaq 0x40(%rsp), %rdi
callq 0x3944
leaq 0x28(%rsp), %rdi
callq 0x3944
movl %ebx, %eax
addq $0x1460, %rsp           # imm = 0x1460
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3872
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x32f0
jmp 0x3872
jmp 0x386f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x38c2
movq %rbx, %rdi
callq 0x3450
// File: /workspace/github_cpp_makefile_star2_O3/isaacbrodsky[P]K-means-plus-plus/k-means-multi.cpp
// Function: Cluster_set::Cluster_set()
Cluster_set::Cluster_set(void){

	// local variables
	random_device rd;

	// initialize the class variables
	iIteration = 0;
	iK_count = 1;
	sIn_file = "default_in.dat";
	sOut_file = "default_out.txt";
	bUseLabels = false;
	fTolerance = 0.1f;
	// Use K-means++ by default.
	bUsePlusPlus = true;
	// Seed with real random value if available
	mtRandom = mt19937(rd());
	iNumThreads = 1;
	iNumPlusPlusThreads = 1;

	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2718, %rsp           # imm = 0x2718
movq %rdi, %rbx
leaq 0x38(%rdi), %r14
leaq 0x48(%rdi), %rbp
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x10(%rdi)
movups %xmm0, (%rdi)
movq %rbp, 0x38(%rdi)
xorl %eax, %eax
movq %rax, 0x40(%rdi)
movb %al, 0x48(%rdi)
leaq 0x58(%rdi), %r15
leaq 0x68(%rdi), %r13
movq %r13, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x80(%rdi), %rcx
movq %rcx, (%rsp)
movups %xmm0, 0x80(%rdi)
movq %rax, 0x90(%rdi)
leaq 0xa8(%rdi), %r12
movq $0x1571, 0xa8(%rdi) # imm = 0x1571
movl $0x1571, %ecx           # imm = 0x1571
movl $0x16, %eax
movq %rcx, %rdx
shrq $0x1e, %rdx
xorl %ecx, %edx
imull $0x6c078965, %edx, %ecx # imm = 0x6C078965
addl %eax, %ecx
addl $-0x15, %ecx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq $0x285, %rax            # imm = 0x285
jne 0x3b29
movq $0x270, 0x1428(%rbx) # imm = 0x270
leaq 0x8(%rsp), %rdi
callq 0x54fe
movl $0x0, 0x98(%rbx)
movl $0x1, 0x30(%rbx)
movq 0x40(%rbx), %rdx
leaq 0x456b(%rip), %rcx      # 0x80e8
movl $0xe, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x33b0
movq 0x60(%rbx), %rdx
leaq 0x455f(%rip), %rcx      # 0x80f7
movl $0xf, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x33b0
movw $0x100, 0xa0(%rbx)      # imm = 0x100
movl $0x3dcccccd, 0x78(%rbx) # imm = 0x3DCCCCCD
leaq 0x8(%rsp), %rdi
callq 0x3360
movl %eax, %eax
movq %rax, 0x1390(%rsp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, 0x1390(%rsp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x3bd1
leaq 0x1390(%rsp), %rsi
movq $0x270, 0x1380(%rsi) # imm = 0x270
movl $0x1388, %edx           # imm = 0x1388
movq %r12, %rdi
callq 0x3220
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0x1430(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x32c0
addq $0x2718, %rsp           # imm = 0x2718
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ca3
jmp 0x3c4c
movq %rax, %r12
jmp 0x3c59
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x32c0
movq (%rsp), %rdi
callq 0x3914
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x3c76
movq (%r13), %rsi
incq %rsi
callq 0x32f0
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0x3c8a
movq (%rbp), %rsi
incq %rsi
callq 0x32f0
leaq 0x18(%rbx), %rdi
callq 0x3944
movq %rbx, %rdi
callq 0x3944
movq %r12, %rdi
callq 0x3450
movq %rax, %rdi
callq 0x3997
nop