LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ColinHarker[P]ltsim/src/memory.cpp
// Function: RandomAccessMemory::run()
void RandomAccessMemory::run()
{
   parseMemInfo("MemTotal", flag::memType::memTotal);
   parseMemInfo("MemAvailable", flag::memType::memAvailable);
   parseMemInfo("SwapTotal", flag::memType::swapTotal);
   parseMemInfo("SwapFree", flag::memType::swapFree);
   calculateMemSwapUsage();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3520
movq -0xc0(%rbp), %rdx
leaq 0x7198(%rip), %rsi      # 0xe110
leaq -0x28(%rbp), %rdi
callq 0x76e0
jmp 0x6f83
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0x71a0
jmp 0x6f97
leaq -0x28(%rbp), %rdi
callq 0x31d0
leaq -0x29(%rbp), %rdi
callq 0x3320
leaq -0x61(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3520
movq -0xd0(%rbp), %rdx
leaq 0x7152(%rip), %rsi      # 0xe119
leaq -0x60(%rbp), %rdi
callq 0x76e0
jmp 0x6fd2
movq -0xc8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
movl $0x1, %edx
callq 0x71a0
jmp 0x6fe9
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x61(%rbp), %rdi
callq 0x3320
leaq -0x89(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3520
movq -0xd8(%rbp), %rdx
leaq 0x710a(%rip), %rsi      # 0xe126
leaq -0x88(%rbp), %rdi
callq 0x76e0
jmp 0x702a
movq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
movl $0x2, %edx
callq 0x71a0
jmp 0x7044
leaq -0x88(%rbp), %rdi
callq 0x31d0
leaq -0x89(%rbp), %rdi
callq 0x3320
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3520
movq -0xe0(%rbp), %rdx
leaq 0x70b3(%rip), %rsi      # 0xe130
leaq -0xb0(%rbp), %rdi
callq 0x76e0
jmp 0x708b
movq -0xc8(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
movl $0x3, %edx
callq 0x71a0
jmp 0x70a5
leaq -0xb0(%rbp), %rdi
callq 0x31d0
leaq -0xb1(%rbp), %rdi
callq 0x3320
movq -0xc8(%rbp), %rdi
callq 0x7480
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x70f5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31d0
leaq -0x29(%rbp), %rdi
callq 0x3320
jmp 0x7197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7126
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x61(%rbp), %rdi
callq 0x3320
jmp 0x7197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7157
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31d0
leaq -0x89(%rbp), %rdi
callq 0x3320
jmp 0x7197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x718b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x31d0
leaq -0xb1(%rbp), %rdi
callq 0x3320
movq -0x38(%rbp), %rdi
callq 0x3510
// File: ColinHarker[P]ltsim/src/runtime.cpp
// Function: displayCpuCores(WindowWrap&, std::vector<CpuReader, std::allocator<CpuReader>>, int, flag::displayLength)
void displayCpuCores(WindowWrap& disp, const std::vector<CpuReader> cores, int startRow, flag::displayLength length)
{
   int coreNumber = 1;  // Index 0 is taken up by full CPU
   for(auto& core : cores)
   {
      displayUtilizationLevel(disp, core.getUtilization(), "Core" + std::to_string(coreNumber), startRow, 0, length);
      startRow++;
      coreNumber++;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x1, -0x1c(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5fb0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x5fe0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x6310
testb $0x1, %al
jne 0x8554
jmp 0x8638
leaq -0x30(%rbp), %rdi
callq 0x6380
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x40(%rbp), %rdi
callq 0x4380
movss %xmm0, -0x9c(%rbp)
movl -0x1c(%rbp), %esi
leaq -0x80(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x89c0
movq -0x98(%rbp), %rdx
leaq 0x5bec(%rip), %rsi      # 0xe18a
leaq -0x60(%rbp), %rdi
callq 0x8970
jmp 0x85a9
movss -0x9c(%rbp), %xmm0
movq -0xa8(%rbp), %rdi
movl -0x14(%rbp), %edx
movl -0x18(%rbp), %r8d
leaq -0x60(%rbp), %rsi
xorl %ecx, %ecx
callq 0x8010
jmp 0x85cc
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x80(%rbp), %rdi
callq 0x31d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x63a0
jmp 0x853e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x862d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31d0
leaq -0x80(%rbp), %rdi
callq 0x31d0
jmp 0x8641
addq $0xb0, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: ColinHarker[P]ltsim/src/runtime.cpp
// Function: displayStorageInformation(WindowWrap&)
void displayStorageInformation(WindowWrap& disp)
{
   displayElement(disp, 1, 0, "Filesystem      Size  Used Avail Use% Mounted on", flag::printType::standard, flag::color::none);

   auto storageVector = parseStorageInformation();

   int row = 2;
   for(auto element : storageVector)
   {
      displayElement(disp, row++, 0, element, flag::printType::standard, flag::color::none);
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xc8(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x3520
movq -0xc0(%rbp), %rdx
leaq 0x5b07(%rip), %rsi      # 0xe18f
leaq -0x28(%rbp), %rdi
callq 0x76e0
jmp 0x8693
movq -0xc8(%rbp), %rdi
leaq -0x28(%rbp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r8d, %esi
movl %r9d, %edx
callq 0xcbf0
jmp 0x86b4
leaq -0x28(%rbp), %rdi
callq 0x31d0
leaq -0x29(%rbp), %rdi
callq 0x3320
leaq -0x58(%rbp), %rdi
callq 0xd3b0
movl $0x2, -0x5c(%rbp)
leaq -0x58(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x68(%rbp), %rdi
callq 0x8ae0
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
callq 0x8b10
movq %rax, -0x78(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8b40
testb $0x1, %al
jne 0x870e
jmp 0x8813
leaq -0x70(%rbp), %rdi
callq 0x8b80
movq %rax, %rsi
leaq -0x98(%rbp), %rdi
callq 0x3130
jmp 0x8728
movq -0x8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, -0xcc(%rbp)
incl %eax
movl %eax, -0x5c(%rbp)
leaq -0xb8(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x3130
jmp 0x8756
movl -0xcc(%rbp), %esi
movq -0xd8(%rbp), %rdi
leaq -0xb8(%rbp), %rcx
movl $0x1, %r8d
xorl %r9d, %r9d
movl %r9d, %edx
callq 0xcbf0
jmp 0x877d
leaq -0xb8(%rbp), %rdi
callq 0x31d0
leaq -0x98(%rbp), %rdi
callq 0x31d0
leaq -0x70(%rbp), %rdi
callq 0x8ba0
jmp 0x86f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x87c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x31d0
leaq -0x29(%rbp), %rdi
callq 0x3320
jmp 0x882e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8825
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x8805
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x31d0
leaq -0x98(%rbp), %rdi
callq 0x31d0
jmp 0x8825
leaq -0x58(%rbp), %rdi
callq 0x8bc0
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x8bc0
movq -0x38(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: ColinHarker[P]ltsim/src/runtime.cpp
// Function: displaySystemProcesses(WindowWrap&)
void displaySystemProcesses(WindowWrap& disp)
{
   System sys = parseSystemInformation();
   sys.remove(0);  // removing the menu string
   sys.sort();
   sys.display(disp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x20(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xcfb0
movq -0x38(%rbp), %rdi
xorl %esi, %esi
callq 0xa070
jmp 0x8866
leaq -0x20(%rbp), %rdi
callq 0x9c70
jmp 0x8871
movq -0x8(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x9cf0
jmp 0x8880
leaq -0x20(%rbp), %rdi
callq 0x3b90
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3b90
movq -0x28(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl %r9d, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
testl %eax, %eax
je 0xcc2b
jmp 0xcc1e
movl -0x24(%rbp), %eax
subl $0x1, %eax
je 0xcca5
jmp 0xccdd
movq -0x8(%rbp), %rdi
callq 0xde80
movq %rax, %rdi
movl -0x20(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x3170
movq -0x8(%rbp), %rdi
callq 0xde80
movq -0x30(%rbp), %rdi
movq %rax, -0x40(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
callq 0x3120
movq -0x40(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq %rax, %rcx
movb $0x0, %al
callq 0x3080
movq -0x8(%rbp), %rdi
callq 0xde80
movq %rax, %rdi
movl -0x20(%rbp), %esi
shll $0x8, %esi
andl $0xff00, %esi           # imm = 0xFF00
xorl %eax, %eax
movl %eax, %edx
callq 0x33e0
jmp 0xccdf
movq -0x8(%rbp), %rdi
callq 0xde80
movq -0x30(%rbp), %rdi
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x44(%rbp)
callq 0x3120
movq -0x50(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
movq %rax, %rcx
movb $0x0, %al
callq 0x3080
jmp 0xccdf
jmp 0xccdf
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, -0x1d8(%rbp)
movq %rdi, %rax
movq %rax, -0x1e0(%rbp)
movq %rdi, -0x8(%rbp)
leaq 0x1359(%rip), %rsi      # 0xe330
leaq -0x20(%rbp), %rdi
callq 0xd140
movq -0x1d8(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x9ae0
jmp 0xcff2
leaq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x8ae0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x8b10
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8b40
testb $0x1, %al
jne 0xd02a
jmp 0xd0e6
leaq -0x48(%rbp), %rdi
callq 0x8b80
movq %rax, %rsi
leaq -0x70(%rbp), %rdi
callq 0x3130
jmp 0xd041
leaq -0x1d0(%rbp), %rdi
callq 0x9150
jmp 0xd04f
leaq -0x1d0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x9210
jmp 0xd061
movq -0x1d8(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
callq 0x9b00
jmp 0xd076
leaq -0x1d0(%rbp), %rdi
callq 0x3f60
leaq -0x70(%rbp), %rdi
callq 0x31d0
leaq -0x48(%rbp), %rdi
callq 0x8ba0
jmp 0xd014
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd121
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd115
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xd0db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0x3f60
leaq -0x70(%rbp), %rdi
callq 0x31d0
jmp 0xd115
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0xd0fc
movq -0x1d8(%rbp), %rdi
callq 0x3b90
leaq -0x20(%rbp), %rdi
callq 0x8bc0
movq -0x1e0(%rbp), %rax
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbp
retq
movq -0x1d8(%rbp), %rdi
callq 0x3b90
leaq -0x20(%rbp), %rdi
callq 0x8bc0
movq -0x30(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x2c8, %rsp            # imm = 0x2C8
movq %rdi, 0x2b8(%rsp)
movq %rsi, 0x2b0(%rsp)
movq 0x2b8(%rsp), %rdi
callq 0x5120
movq %rax, 0x60(%rsp)
movl $0x8, %edi
movl $0x4, %esi
callq 0xd470
movl %eax, %edi
movl $0x2, %esi
callq 0xd470
movq 0x60(%rsp), %rsi
movl %eax, %edx
leaq 0xa8(%rsp), %rdi
callq 0x5510
movq 0xa8(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0xa8(%rsp,%rax), %rdi
callq 0x5160
movb %al, 0x6f(%rsp)
jmp 0x6187
movb 0x6f(%rsp), %al
testb $0x1, %al
jne 0x6191
jmp 0x61cf
movb $0x0, 0x2c7(%rsp)
movl $0x1, 0x98(%rsp)
jmp 0x636d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xa0(%rsp)
movl %eax, 0x9c(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x50b0
jmp 0x638b
movq $0x0, 0x90(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0xa8(%rsp), %rdi
movl $0x2, %edx
callq 0x53b0
movq %rax, 0x58(%rsp)
jmp 0x61f8
movq 0x58(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x54a0
movb %al, 0x57(%rsp)
jmp 0x6212
movb 0x57(%rsp), %al
testb $0x1, %al
jne 0x621c
jmp 0x6270
leaq 0xa8(%rsp), %rdi
callq 0x54d0
movq %rdx, 0x40(%rsp)
movq %rax, 0x48(%rsp)
jmp 0x6235
movq 0x40(%rsp), %rax
movq 0x48(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movq %rax, 0x88(%rsp)
leaq 0x80(%rsp), %rdi
callq 0xd490
movq %rax, 0x38(%rsp)
jmp 0x6263
movq 0x38(%rsp), %rax
movq %rax, 0x90(%rsp)
xorl %edx, %edx
movl %edx, %esi
leaq 0xa8(%rsp), %rdi
callq 0x53b0
movq %rax, 0x30(%rsp)
jmp 0x6288
movq 0x30(%rsp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x54a0
movb %al, 0x2f(%rsp)
jmp 0x62a2
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x62ac
jmp 0x6302
leaq 0xa8(%rsp), %rdi
callq 0x54d0
movq %rdx, 0x18(%rsp)
movq %rax, 0x20(%rsp)
jmp 0x62c5
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movq %rcx, 0x70(%rsp)
movq %rax, 0x78(%rsp)
leaq 0x70(%rsp), %rdi
callq 0xd490
movq %rax, 0x10(%rsp)
jmp 0x62ea
movq 0x10(%rsp), %rcx
movq 0x90(%rsp), %rax
subq %rcx, %rax
movq %rax, 0x90(%rsp)
movq 0x2b0(%rsp), %rdi
movq 0x90(%rsp), %rsi
callq 0x53e0
jmp 0x6319
cmpq $0x0, 0x90(%rsp)
jle 0x635a
movq 0x2b0(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5540
movq %rax, 0x8(%rsp)
jmp 0x633c
movq 0x8(%rsp), %rsi
movq 0x90(%rsp), %rdx
leaq 0xa8(%rsp), %rdi
callq 0x5350
jmp 0x6358
jmp 0x635a
movb $0x1, 0x2c7(%rsp)
movl $0x1, 0x98(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x50b0
movb 0x2c7(%rsp), %al
andb $0x1, %al
addq $0x2c8, %rsp            # imm = 0x2C8
retq
movq 0xa0(%rsp), %rdi
callq 0x54e0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0xd5f0
movl $0x0, 0x30(%rsp)
movslq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x38(%rsp), %rdi
callq 0x5220
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x6c3b
movq 0x38(%rsp), %rdi
movslq 0x30(%rsp), %rsi
callq 0x5320
movq 0x8(%rsp), %rdi
movb (%rax), %al
movb %al, 0x2f(%rsp)
leaq 0x2f(%rsp), %rsi
callq 0xd640
jmp 0x6c12
jmp 0x6c14
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x6bcd
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xd670
jmp 0x6c5b
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x6c51
movq 0x8(%rsp), %rdi
callq 0xd670
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x54e0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb $0x0, 0x37(%rsp)
callq 0x5400
movl $0x0, 0x30(%rsp)
movslq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xd4b0
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x6d05
movq 0x38(%rsp), %rdi
movslq 0x30(%rsp), %rsi
callq 0xd4d0
movq 0x10(%rsp), %rdi
movsbl (%rax), %esi
callq 0x5240
jmp 0x6cdc
jmp 0x6cde
movl 0x30(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x30(%rsp)
jmp 0x6c9d
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5558
jmp 0x6d25
movb $0x1, 0x37(%rsp)
testb $0x1, 0x37(%rsp)
jne 0x6d1b
movq 0x10(%rsp), %rdi
callq 0x5558
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x54e0
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x28(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movb $0x0, 0x47(%rsp)
callq 0xd6d0
movl $0x0, 0x40(%rsp)
cmpl $0x100, 0x40(%rsp)      # imm = 0x100
jge 0x6ebe
movq 0x20(%rsp), %rdi
movslq 0x40(%rsp), %rcx
movl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x48(%rsp), %rax
leaq (%rax,%rcx,4), %rsi
callq 0xd6e0
movq %rax, 0x18(%rsp)
jmp 0x6e8c
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
movl %ecx, (%rax)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x6e5d
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x38(%rsp)
movl %eax, 0x34(%rsp)
callq 0xd7e0
jmp 0x6f1f
movq 0x20(%rsp), %rdi
callq 0xd7d0
cmpq $0x100, %rax            # imm = 0x100
je 0x6eff
movq 0x250f1(%rip), %rdi     # 0x2bfc8
leaq 0x1a12b(%rip), %rsi     # 0x21009
callq 0x5290
movq %rax, 0x8(%rsp)
jmp 0x6eea
movq 0x8(%rsp), %rdi
movq 0x250ba(%rip), %rsi     # 0x2bfb0
callq 0x52e0
jmp 0x6efd
jmp 0x6eff
movb $0x1, 0x47(%rsp)
testb $0x1, 0x47(%rsp)
jne 0x6f15
movq 0x20(%rsp), %rdi
callq 0xd7e0
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
movq 0x38(%rsp), %rdi
callq 0x54e0
nopl (%rax)
// File: 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 %rax
movq %rdi, (%rsp)
movq (%rsp), %rdi
addq $0xf0, %rdi
callq 0x5480
testb $0x1, %al
jne 0x6f8d
movq 0x25078(%rip), %rdi     # 0x2bfc8
leaq 0x1a0cc(%rip), %rsi     # 0x21023
callq 0x5290
movq %rax, %rdi
movq (%rsp), %rsi
addq $0xf0, %rsi
callq 0x5260
movq %rax, %rdi
movq 0x25037(%rip), %rsi     # 0x2bfb0
callq 0x52e0
movq %rax, %rdi
movq 0x25028(%rip), %rsi     # 0x2bfb0
callq 0x52e0
movq 0x25034(%rip), %rdi     # 0x2bfc8
leaq 0x1a090(%rip), %rsi     # 0x2102b
callq 0x5290
movq 0x25021(%rip), %rdi     # 0x2bfc8
leaq 0x1a2d3(%rip), %rsi     # 0x21281
callq 0x5290
movq %rax, %rdi
movq 0x24ff3(%rip), %rsi     # 0x2bfb0
callq 0x52e0
movq (%rsp), %rsi
addq $0x20, %rsi
movq 0x24ff7(%rip), %rdi     # 0x2bfc8
callq 0x5260
movq %rax, %rdi
leaq 0x1a2a8(%rip), %rsi     # 0x21288
callq 0x5290
movq %rax, %rdi
movq 0x24fc1(%rip), %rsi     # 0x2bfb0
callq 0x52e0
movq 0x24fcd(%rip), %rdi     # 0x2bfc8
movq 0x24fae(%rip), %rsi     # 0x2bfb0
callq 0x52e0
movq 0x24fba(%rip), %rdi     # 0x2bfc8
leaq 0x1a29c(%rip), %rsi     # 0x212b1
callq 0x5290
movq %rax, %rdi
movq 0x24f8c(%rip), %rsi     # 0x2bfb0
callq 0x52e0
movq (%rsp), %rdi
movl $0x2, %esi
callq 0xd7f0
popq %rax
retq
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5400
movq $0x0, 0x50(%rsp)
movq 0x50(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0xd872
leaq 0x14a08(%rip), %rsi     # 0x2223f
leaq 0x58(%rsp), %rdi
callq 0x5280
jmp 0xd843
jmp 0xd845
movq 0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x50(%rsp)
jmp 0xd824
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x58(%rsp), %rdi
callq 0x5558
jmp 0xd9c9
movq $0x0, 0x38(%rsp)
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x60, %rdi
callq 0x11620
movq %rax, %rcx
movq 0x18(%rsp), %rax
cmpq %rcx, %rax
jae 0xd9b7
movq 0x20(%rsp), %rdi
addq $0x60, %rdi
movq 0x38(%rsp), %rsi
callq 0x11640
movq %rax, 0x30(%rsp)
movq 0x1e705(%rip), %rdi     # 0x2bfc8
leaq 0x58(%rsp), %rsi
callq 0x5260
jmp 0xd8cf
movq $0x0, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0xea40
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jae 0xd94a
cmpq $0x0, 0x28(%rsp)
jbe 0xd918
movq 0x1e6c0(%rip), %rdi     # 0x2bfc8
leaq 0x14915(%rip), %rsi     # 0x22224
callq 0x5290
jmp 0xd916
jmp 0xd918
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x11660
movq %rax, %rsi
movq 0x1e697(%rip), %rdi     # 0x2bfc8
callq 0x5260
jmp 0xd938
jmp 0xd93a
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0xd8d8
movq 0x30(%rsp), %rdi
addq $0x18, %rdi
callq 0x5480
testb $0x1, %al
jne 0xd98d
movq 0x1e665(%rip), %rdi     # 0x2bfc8
leaq 0x14640(%rip), %rsi     # 0x21faa
callq 0x5290
movq %rax, 0x8(%rsp)
jmp 0xd976
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
addq $0x18, %rsi
callq 0x5260
jmp 0xd98b
jmp 0xd98d
movq 0x1e634(%rip), %rdi     # 0x2bfc8
movq 0x1e615(%rip), %rsi     # 0x2bfb0
callq 0x52e0
jmp 0xd9a2
jmp 0xd9a4
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0xd87b
leaq 0x58(%rsp), %rdi
callq 0x5558
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x54e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x1b0(%rsp)
movq 0x1b0(%rsp), %rsi
leaq 0x30(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movl $0x8, %edx
callq 0x5490
movq 0x10(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x51c0
jmp 0xec5c
movl 0x2c(%rsp), %eax
movl %eax, 0xc(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5170
movl 0xc(%rsp), %eax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x5170
movq 0x20(%rsp), %rdi
callq 0x54e0
nopl (%rax)
// File: 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:
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, 0x8(%rsp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, 0x10(%rsp)
movq %rdi, 0x1b0(%rsp)
movq %rsi, 0x1a8(%rsp)
andb $0x1, %al
movb %al, 0x1a7(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x53a0
testb $0x1, 0x1a7(%rsp)
je 0x11012
leaq 0x8bc6(%rip), %rsi      # 0x19bb0
leaq 0x28(%rsp), %rdi
callq 0x50e0
jmp 0x10ff6
jmp 0x11012
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x5090
jmp 0x11051
movq 0x1a8(%rsp), %rax
movq (%rax), %rsi
leaq 0x28(%rsp), %rdi
callq 0x5080
jmp 0x11029
movq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x52b0
jmp 0x1103a
leaq 0x28(%rsp), %rdi
callq 0x5090
movq 0x10(%rsp), %rax
addq $0x1b8, %rsp            # imm = 0x1B8
retq
movq 0x20(%rsp), %rdi
callq 0x54e0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, (%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movb %dl, 0x37(%rsp)
movb %cl, 0x36(%rsp)
movb %al, 0x35(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rax), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movq 0x10(%rsp), %rax
movl %edx, %ecx
movl %ecx, 0x30(%rsp)
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
cmpl $0x0, 0x30(%rsp)
jne 0x181a5
movq 0x10(%rsp), %rax
movzbl 0x37(%rsp), %ecx
shll $0x10, %ecx
movslq %ecx, %rcx
movq %rcx, 0x10(%rax)
jmp 0x181da
cmpl $0x1, 0x30(%rsp)
jne 0x181c6
movq 0x10(%rsp), %rax
movzbl 0x37(%rsp), %ecx
shll $0x8, %ecx
movslq %ecx, %rcx
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x181d8
movq 0x10(%rsp), %rax
movzbl 0x37(%rsp), %ecx
orq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x181da
movq (%rsp), %rdi
movb $0x0, 0x2f(%rsp)
callq 0x5400
cmpl $0x0, 0x30(%rsp)
jne 0x18231
movq (%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
shrl $0x12, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x18210
jmp 0x1829f
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x5558
jmp 0x182be
cmpl $0x1, 0x30(%rsp)
jne 0x1825b
movq (%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x18259
jmp 0x1829d
movq (%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x1827c
movq (%rsp), %rdi
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rcx), %rcx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x1829b
jmp 0x1829d
jmp 0x1829f
movb $0x1, 0x2f(%rsp)
testb $0x1, 0x2f(%rsp)
jne 0x182b4
movq (%rsp), %rdi
callq 0x5558
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x54e0
nopl (%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x40(%rsp)
movb $0x0, 0x6f(%rsp)
callq 0x5400
movq $0x0, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x3, %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0x5220
movq %rax, %rcx
movq 0x28(%rsp), %rax
cmpq %rcx, %rax
jae 0x184a6
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0x5320
movq 0x40(%rsp), %rdi
movsbl (%rax), %esi
callq 0x18610
movl %eax, 0x24(%rsp)
jmp 0x1835e
movl 0x24(%rsp), %eax
shll $0x12, %eax
movl %eax, 0x1c(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x5320
movq 0x40(%rsp), %rdi
movsbl (%rax), %esi
callq 0x18610
movl %eax, 0x20(%rsp)
jmp 0x1838e
movl 0x1c(%rsp), %eax
movl 0x20(%rsp), %ecx
shll $0xc, %ecx
addl %ecx, %eax
movl %eax, 0x14(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x2, %rsi
callq 0x5320
movq 0x40(%rsp), %rdi
movsbl (%rax), %esi
callq 0x18610
movl %eax, 0x18(%rsp)
jmp 0x183c5
movl 0x14(%rsp), %eax
movl 0x18(%rsp), %ecx
shll $0x6, %ecx
addl %ecx, %eax
movl %eax, 0xc(%rsp)
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x3, %rsi
callq 0x5320
movq 0x40(%rsp), %rdi
movsbl (%rax), %esi
callq 0x18610
movl %eax, 0x10(%rsp)
jmp 0x183fc
movq 0x30(%rsp), %rdi
movl 0x10(%rsp), %ecx
movl 0xc(%rsp), %eax
addl %ecx, %eax
movl %eax, 0x5c(%rsp)
movsbl 0x5e(%rsp), %esi
callq 0x51d0
jmp 0x1841b
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x2, %rsi
callq 0x5320
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x18463
movq 0x30(%rsp), %rdi
movsbl 0x5d(%rsp), %esi
callq 0x51d0
jmp 0x18447
jmp 0x18463
movq 0x30(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x50(%rsp)
movl %eax, 0x4c(%rsp)
callq 0x5558
jmp 0x184c9
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rsi
addq $0x3, %rsi
callq 0x5320
movsbl (%rax), %eax
cmpl $0x3d, %eax
je 0x18491
movq 0x30(%rsp), %rdi
movsbl 0x5c(%rsp), %esi
callq 0x51d0
jmp 0x1848f
jmp 0x18491
jmp 0x18493
movq 0x60(%rsp), %rax
addq $0x4, %rax
movq %rax, 0x60(%rsp)
jmp 0x18313
movb $0x1, 0x6f(%rsp)
testb $0x1, 0x6f(%rsp)
jne 0x184bc
movq 0x30(%rsp), %rdi
callq 0x5558
movq 0x38(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x50(%rsp), %rdi
callq 0x54e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rax), %rax
movl $0x3, %ecx
xorl %edx, %edx
divq %rcx
movl %edx, %eax
movl %eax, 0x34(%rsp)
movb $0x0, 0x33(%rsp)
callq 0x5400
cmpl $0x0, 0x34(%rsp)
jne 0x1854c
jmp 0x1854c
cmpl $0x1, 0x34(%rsp)
jne 0x185a4
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
shrl $0xc, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x18575
movq 0x8(%rsp), %rdi
leaq 0x9c1a(%rip), %rsi      # 0x2219b
callq 0x5280
jmp 0x18588
jmp 0x185a4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5558
jmp 0x18602
cmpl $0x2, 0x34(%rsp)
jne 0x185e2
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movl 0x10(%rcx), %ecx
shrl $0x6, %ecx
andl $0x3f, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x185cd
movq 0x8(%rsp), %rdi
leaq 0x9bc3(%rip), %rsi      # 0x2219c
callq 0x5280
jmp 0x185e0
jmp 0x185e2
movb $0x1, 0x33(%rsp)
testb $0x1, 0x33(%rsp)
jne 0x185f8
movq 0x8(%rsp), %rdi
callq 0x5558
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x54e0
nopl (%rax)
// File: lvandeve[P]base256/base256.cpp
// Function: Base64::fromBase64(int)
int fromBase64(int v) {
    if(v >= 'A' && v <= 'Z') return (v - 'A');
    if(v >= 'a' && v <= 'z') return (v - 'a' + 26);
    if(v >= '0' && v <= '9') return (v - '0' + 52);
    if(v == '+') return 62;
    if(v == '/') return 63;
    return 0; //v == '='
  }

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
cmpl $0x41, -0x14(%rsp)
jl 0x18634
cmpl $0x5a, -0x14(%rsp)
jg 0x18634
movl -0x14(%rsp), %eax
subl $0x41, %eax
movl %eax, -0x4(%rsp)
jmp 0x1869a
cmpl $0x61, -0x14(%rsp)
jl 0x18652
cmpl $0x7a, -0x14(%rsp)
jg 0x18652
movl -0x14(%rsp), %eax
subl $0x61, %eax
addl $0x1a, %eax
movl %eax, -0x4(%rsp)
jmp 0x1869a
cmpl $0x30, -0x14(%rsp)
jl 0x18670
cmpl $0x39, -0x14(%rsp)
jg 0x18670
movl -0x14(%rsp), %eax
subl $0x30, %eax
addl $0x34, %eax
movl %eax, -0x4(%rsp)
jmp 0x1869a
cmpl $0x2b, -0x14(%rsp)
jne 0x18681
movl $0x3e, -0x4(%rsp)
jmp 0x1869a
cmpl $0x2f, -0x14(%rsp)
jne 0x18692
movl $0x3f, -0x4(%rsp)
jmp 0x1869a
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x18(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x8(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %dl, 0x57(%rsp)
movb %cl, 0x56(%rsp)
movb %al, 0x55(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x10(%rsp)
movb $0x0, 0x54(%rsp)
callq 0x5400
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x18(%rax), %rax
movzbl 0x57(%rsp), %ecx
shrl $0x4, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x1873f
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movzbl 0x57(%rsp), %ecx
andl $0xf, %ecx
movsbl (%rax,%rcx), %esi
callq 0x51d0
jmp 0x18760
movq 0x10(%rsp), %rax
testb $0x1, 0x20(%rax)
je 0x187b8
movq 0x18(%rsp), %rdx
leaq 0x9a49(%rip), %rsi      # 0x221c0
leaq 0x20(%rsp), %rdi
callq 0x11ae0
jmp 0x18783
movq 0x18(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5330
leaq 0x20(%rsp), %rdi
callq 0x5558
jmp 0x187b8
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x5558
jmp 0x187d8
movb $0x1, 0x54(%rsp)
testb $0x1, 0x54(%rsp)
jne 0x187ce
movq 0x18(%rsp), %rdi
callq 0x5558
movq 0x8(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x54e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0x5400
movl $0x0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
callq 0x5220
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x18ea3
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x5320
movb (%rax), %al
movb %al, 0x37(%rsp)
movsbl 0x37(%rsp), %eax
cmpl $0x30, %eax
jl 0x18e8e
movsbl 0x37(%rsp), %eax
cmpl $0x39, %eax
jg 0x18e8e
movsbl 0x37(%rsp), %eax
subl $0x30, %eax
movl %eax, 0x30(%rsp)
movl 0x48(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x18e30
movl 0x30(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x18e45
imull $0xa, 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x30(%rsp), %eax
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x48(%rsp), %eax
movl $0x3, %ecx
cltd
idivl %ecx
cmpl $0x2, %edx
jne 0x18e83
movq 0x10(%rsp), %rdi
movsbl 0x44(%rsp), %esi
callq 0x5240
jmp 0x18e67
jmp 0x18e83
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5558
jmp 0x18ec3
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x18e90
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x18db3
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x18eb9
movq 0x10(%rsp), %rdi
callq 0x5558
movq 0x18(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x54e0
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %dl, 0x57(%rsp)
movb %cl, 0x56(%rsp)
movb %al, 0x55(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpb $0x0, 0x13c3d(%rip)     # 0x2cba8
jne 0x18fd5
leaq 0x13c34(%rip), %rdi     # 0x2cba8
callq 0x5500
cmpl $0x0, %eax
je 0x18fd5
leaq 0x54(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x54f0
movq (%rsp), %rdx
leaq 0x13bf1(%rip), %rdi     # 0x2cb88
leaq 0x9230(%rip), %rsi      # 0x221ce
callq 0x53d0
jmp 0x18fa5
leaq 0x54(%rsp), %rdi
callq 0x5300
movq 0x13002(%rip), %rdi     # 0x2bfb8
leaq 0x13bcb(%rip), %rsi     # 0x2cb88
leaq 0x132f4(%rip), %rdx     # 0x2c2b8
callq 0x5250
leaq 0x13bd8(%rip), %rdi     # 0x2cba8
callq 0x51f0
movq 0x8(%rsp), %rdi
movb $0x0, 0x43(%rsp)
callq 0x5400
movzbl 0x57(%rsp), %eax
shrl $0x6, %eax
movl %eax, %esi
leaq 0x13b93(%rip), %rdi     # 0x2cb88
callq 0x5320
movq 0x8(%rsp), %rdi
movsbl (%rax), %esi
callq 0x51d0
jmp 0x19009
movzbl 0x57(%rsp), %eax
shrl $0x3, %eax
andl $0x7, %eax
movl %eax, %esi
leaq 0x13b6b(%rip), %rdi     # 0x2cb88
callq 0x5320
movq 0x8(%rsp), %rdi
movsbl (%rax), %esi
callq 0x51d0
jmp 0x19031
movzbl 0x57(%rsp), %eax
andl $0x7, %eax
movl %eax, %esi
leaq 0x13b46(%rip), %rdi     # 0x2cb88
callq 0x5320
movq 0x8(%rsp), %rdi
movsbl (%rax), %esi
callq 0x51d0
jmp 0x19056
movq 0x18(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x190d4
movq 0x8(%rsp), %rdx
leaq 0x8d98(%rip), %rsi      # 0x21e05
leaq 0x20(%rsp), %rdi
callq 0x11ae0
jmp 0x19079
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5330
leaq 0x20(%rsp), %rdi
callq 0x5558
jmp 0x190d4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x54(%rsp), %rdi
callq 0x5300
leaq 0x13af5(%rip), %rdi     # 0x2cba8
callq 0x51e0
jmp 0x190f4
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x5558
jmp 0x190f4
movb $0x1, 0x43(%rsp)
testb $0x1, 0x43(%rsp)
jne 0x190ea
movq 0x8(%rsp), %rdi
callq 0x5558
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x54e0
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movb %r8b, %al
movq %rdi, %r8
movq %r8, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movb %dl, 0x57(%rsp)
movb %cl, 0x56(%rsp)
movb %al, 0x55(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x54(%rsp)
callq 0x5400
movl $0x0, 0x50(%rsp)
cmpl $0x8, 0x50(%rsp)
jge 0x1923c
movq 0x18(%rsp), %rax
testb $0x1, 0x9(%rax)
je 0x19204
movq 0x8(%rsp), %rdi
movzbl 0x57(%rsp), %eax
movl 0x50(%rsp), %ecx
xorl %esi, %esi
btl %ecx, %eax
adcl $0x30, %esi
callq 0x51d0
jmp 0x191e5
jmp 0x1922a
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x5558
jmp 0x19298
movq 0x8(%rsp), %rdi
movzbl 0x57(%rsp), %eax
movb 0x50(%rsp), %dl
movb $0x7, %cl
subb %dl, %cl
movzbl %cl, %ecx
xorl %esi, %esi
btl %ecx, %eax
adcl $0x30, %esi
callq 0x51d0
jmp 0x19228
jmp 0x1922a
jmp 0x1922c
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x191b6
movq 0x18(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x19278
movq 0x8(%rsp), %rdx
leaq 0x8f84(%rip), %rsi      # 0x221d7
leaq 0x20(%rsp), %rdi
callq 0x11ae0
jmp 0x1925f
movq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x5330
leaq 0x20(%rsp), %rdi
callq 0x5558
movb $0x1, 0x54(%rsp)
testb $0x1, 0x54(%rsp)
jne 0x1928e
movq 0x8(%rsp), %rdi
callq 0x5558
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x54e0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x4f(%rsp)
callq 0x5400
movl $0x0, 0x48(%rsp)
movl $0x0, 0x44(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq %rax, (%rsp)
movq 0x50(%rsp), %rdi
callq 0x5220
movq %rax, %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
jae 0x1940b
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x5320
movb (%rax), %al
movb %al, 0x37(%rsp)
movsbl 0x37(%rsp), %eax
cmpl $0x30, %eax
je 0x1934e
movsbl 0x37(%rsp), %eax
cmpl $0x31, %eax
je 0x1934e
jmp 0x193f8
movq 0x18(%rsp), %rax
testb $0x1, 0x9(%rax)
je 0x1937b
movsbl 0x37(%rsp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x31, %edx
cmovel %ecx, %eax
movl 0x48(%rsp), %ecx
shll %cl, %eax
orl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x1939f
movl 0x44(%rsp), %eax
shll %eax
movl %eax, 0x44(%rsp)
movsbl 0x37(%rsp), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x31, %edx
cmovel %ecx, %eax
orl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
cmpl $0x8, 0x48(%rsp)
jne 0x193f6
movq 0x8(%rsp), %rdi
movl $0x0, 0x48(%rsp)
movb 0x44(%rsp), %al
movb %al, 0x36(%rsp)
movsbl 0x36(%rsp), %esi
callq 0x51d0
jmp 0x193d2
movl $0x0, 0x44(%rsp)
jmp 0x193f6
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x5558
jmp 0x1944d
jmp 0x193f8
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x192fd
cmpl $0x0, 0x48(%rsp)
je 0x1942d
movq 0x8(%rsp), %rdi
movb 0x44(%rsp), %al
movb %al, 0x23(%rsp)
movsbl 0x23(%rsp), %esi
callq 0x51d0
jmp 0x1942b
jmp 0x1942d
movb $0x1, 0x4f(%rsp)
testb $0x1, 0x4f(%rsp)
jne 0x19443
movq 0x8(%rsp), %rdi
callq 0x5558
movq 0x10(%rsp), %rax
addq $0x68, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x54e0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x14b0, %rsp           # imm = 0x14B0
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x1448(%rbp), %rdi
callq 0x5410
cmpl $0x2, -0x8(%rbp)
jge 0x4816
movq 0x1d86a(%rip), %rdi     # 0x21fc0
leaq 0x118a7(%rip), %rsi     # 0x16004
callq 0x4350
movq %rax, -0x1488(%rbp)
jmp 0x476b
movq -0x1488(%rbp), %rdi
movq 0x1d80f(%rip), %rsi     # 0x21f88
callq 0x4390
movq %rax, -0x1490(%rbp)
jmp 0x4787
movq -0x1490(%rbp), %rdi
movq 0x1d7f3(%rip), %rsi     # 0x21f88
callq 0x4390
jmp 0x479c
movq 0x1d81d(%rip), %rdi     # 0x21fc0
leaq 0x11874(%rip), %rsi     # 0x1601e
callq 0x4350
movq %rax, -0x1498(%rbp)
jmp 0x47b8
movq -0x1498(%rbp), %rdi
movq 0x1d7c2(%rip), %rsi     # 0x21f88
callq 0x4390
movq %rax, -0x14a0(%rbp)
jmp 0x47d4
movq -0x14a0(%rbp), %rdi
movq 0x1d7a6(%rip), %rsi     # 0x21f88
callq 0x4390
jmp 0x47e9
movl $0x1, -0x4(%rbp)
movl $0x1, -0x1458(%rbp)
jmp 0x48e2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1450(%rbp)
movl %eax, -0x1454(%rbp)
jmp 0x48fa
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x14b0(%rbp)
leaq -0x1479(%rbp), %rdi
movq %rdi, -0x14a8(%rbp)
callq 0x4540
movq -0x14b0(%rbp), %rsi
movq -0x14a8(%rbp), %rdx
leaq -0x1478(%rbp), %rdi
callq 0x4920
jmp 0x4854
leaq -0x1448(%rbp), %rdi
leaq -0x1478(%rbp), %rsi
callq 0x5600
jmp 0x4869
leaq -0x1478(%rbp), %rdi
callq 0x4200
leaq -0x1479(%rbp), %rdi
callq 0x43b0
leaq -0x1448(%rbp), %rdi
callq 0x5aa0
jmp 0x488f
jmp 0x48d1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1450(%rbp)
movl %eax, -0x1454(%rbp)
jmp 0x48c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1450(%rbp)
movl %eax, -0x1454(%rbp)
leaq -0x1478(%rbp), %rdi
callq 0x4200
leaq -0x1479(%rbp), %rdi
callq 0x43b0
jmp 0x48fa
movl $0x0, -0x4(%rbp)
movl $0x1, -0x1458(%rbp)
leaq -0x1448(%rbp), %rdi
callq 0x49d0
movl -0x4(%rbp), %eax
addq $0x14b0, %rsp           # imm = 0x14B0
popq %rbp
retq
leaq -0x1448(%rbp), %rdi
callq 0x49d0
movq -0x1450(%rbp), %rdi
callq 0x4530
nopw %cs:(%rax,%rax)
nopl (%rax)