LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::find_all_level(int)
TableEntry BlockTable::find_all_level (int index)
{
   TableEntry a;

   for (auto it = table[blockLevel].begin(); it != table[blockLevel].end(); ++it)
   //looks through the current block level
   {
      if (it -> idindex == index)
      //if the index is found returns the table entry
      //and set inScope to true to make sure the variable is declared
      {
	       a.idindex = it -> idindex;
	       a.kind = it -> kind;
	       a.type = it -> type;
	       a.size = it -> size;
	       a.value = it -> value;
	       a.disp = it -> disp;
	       a.procLabel = it -> procLabel;
	       inScope = true;
	       return a;
      }
   }
   inScope = false;
   //if the variable is not found in the current block level
   //search all the block levels up to the current one
   for (int i = blockLevel; i >= 0; i--)
   {
      for (auto it = table[i].begin(); it != table[i].end(); ++it)
      {
    	 if (it -> idindex == index)
    	 {
    	    a.idindex = it -> idindex;
    	    a.kind = it -> kind;
    	    a.type = it -> type;
    	    a.size = it -> size;
    	    a.value = it -> value;
    	    a.disp = it -> disp;
    	    a.procLabel = it -> procLabel;
    	    inScope = true;
    	    return a;
    	 }
      }
   }
   inScope = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movslq 0xf8(%rsi), %rdi
leaq (%rdi,%rdi,2), %r8
movq 0x8(%rsi,%r8,8), %rcx
movq 0x10(%rsi,%r8,8), %r8
cmpq %r8, %rcx
je 0x10a3d
cmpl %edx, (%rcx)
je 0x10a72
addq $0x1c, %rcx
jmp 0x10a2e
movb $0x0, (%rsi)
testl %edi, %edi
js 0x10a9b
leaq 0x8(%rsi), %r8
leaq (%rdi,%rdi,2), %r9
movq (%r8,%r9,8), %rcx
movq 0x8(%r8,%r9,8), %r9
cmpq %r9, %rcx
je 0x10a64
cmpl %edx, (%rcx)
je 0x10a72
addq $0x1c, %rcx
jmp 0x10a55
leaq -0x1(%rdi), %rcx
testq %rdi, %rdi
movq %rcx, %rdi
jg 0x10a48
jmp 0x10a9b
movl %edx, (%rax)
movl 0x4(%rcx), %edx
movl %edx, 0x4(%rax)
movl 0x8(%rcx), %edx
movl %edx, 0x8(%rax)
movl 0xc(%rcx), %edx
movl %edx, 0xc(%rax)
movl 0x10(%rcx), %edx
movl %edx, 0x10(%rax)
movl 0x14(%rcx), %edx
movl %edx, 0x14(%rax)
movl 0x18(%rcx), %ecx
movl %ecx, 0x18(%rax)
movb $0x1, (%rsi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::Interpreter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Interpreter::Interpreter( string filename, bool step)
{
//  this->stepping = step;
  stepping = step;
  cout << " Loading..." << endl;
  load_program(filename);
  cout << " Running ..." << endl;
  run_program();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movb %dl, 0xfb5(%rdi)
movq 0x7302(%rip), %r14      # 0x18fc8
leaq 0x1d2b(%rip), %rsi      # 0x139f8
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x424c
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11da2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x11d39
callq 0x21b0
leaq 0x1cc4(%rip), %rsi      # 0x13a04
movl $0xc, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x11f5e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x11d9a
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::load_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Interpreter::load_program( string name)
{
  int x = 0;
  int word;
  const char* tempname = name.c_str(); 
  ifstream program(tempname, ios::in);
  
  if (!program)
  {
    cerr << " Could not open program file" << endl;
    return;
  }

// read program into memory

  while (!program.eof())
  {
    program >> word;
//    cout << " Read word " << word << endl;
    store[x] = word;
    if ( word == -1) break;
    ++x;
//    cout << "x is " << x << endl;
    
    if ( x >= STORE_SIZE)
    {
      cerr << "program exceeded" << x << " words " << endl;
      cerr << "Not enough memory to load program " << endl;
      return;
     }
   }
  
   stack_bottom = x;

 //  cout << "stack_bottom = " << x << endl;
   
   // clear the rest of memory

   for (int i = stack_bottom; i <= STORE_SIZE; i++)
      store[i] = -1;
   program.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x238(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2340
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0x11e2c
movl $0x1c, %edx
leaq 0x1c68(%rip), %rsi      # 0x13a55
movq 0x71fc(%rip), %rbx      # 0x18ff0
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x71d6(%rip), %rdi      # 0x18ff0
callq 0x2030
movq %rax, %rdi
callq 0x2140
jmp 0x11f26
movl $0xfa4, %r14d           # imm = 0xFA4
xorl %r13d, %r13d
leaq -0x238(%rbp), %r15
leaq -0x2c(%rbp), %r12
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
jne 0x11ef9
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
movl -0x2c(%rbp), %eax
movl %eax, (%rbx,%r13,4)
cmpl $-0x1, %eax
je 0x11ef9
incq %r13
addq $-0x4, %r14
cmpq $0x4, %r14
jne 0x11e40
movq 0x7168(%rip), %rdi      # 0x18ff0
leaq 0x1be3(%rip), %rsi      # 0x13a72
movl $0x10, %edx
callq 0x2210
movq 0x7150(%rip), %rdi      # 0x18ff0
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x22f0
movq %rax, %rbx
leaq 0x1bcf(%rip), %rsi      # 0x13a83
movl $0x7, %edx
movq %rax, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x22, %edx
leaq 0x1b97(%rip), %rsi      # 0x13a8b
jmp 0x11ded
movl %r13d, 0xfa4(%rbx)
cmpq $0x3e8, %r13            # imm = 0x3E8
ja 0x11f1a
leaq (%rbx,%r13,4), %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x2110
leaq -0x238(%rbp), %rdi
callq 0x2050
leaq -0x238(%rbp), %rdi
callq 0x2060
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11f46
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::runtime_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Interpreter::runtime_error( string  message, int line_number)
{
  if ( line_number != -1)
     cerr << "line " << line_number << " : " << message << endl;
  else
     cerr << message << endl;
  running = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x124b0
movl %edx, %r15d
movq 0x6b78(%rip), %r12      # 0x18ff0
leaq 0x1193(%rip), %rsi      # 0x13612
movl $0x5, %edx
movq %r12, %rdi
callq 0x2210
movq %r12, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r15
leaq 0x119c(%rip), %rsi      # 0x1363d
movl $0x3, %edx
movq %rax, %rdi
callq 0x2210
jmp 0x124b7
movq 0x6b39(%rip), %r15      # 0x18ff0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movb $0x0, 0xfb4(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::variable(int, int)
void Interpreter::variable( int level, int displacement)
{
  int x;

  allocate(1);
  x = base_register;
  
  while ( level > 0)
  {
    x = store[x];
    --level;
  }
  store[stack_register] = x + displacement;
  program_register += 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %esi
callq 0x12500
movl 0xfac(%rbx), %eax
testl %r15d, %r15d
jle 0x125c1
incl %r15d
cltq
movl (%rbx,%rax,4), %eax
decl %r15d
cmpl $0x1, %r15d
ja 0x125b3
addl %r14d, %eax
movslq 0xfa8(%rbx), %rcx
movl %eax, (%rbx,%rcx,4)
addl $0x3, 0xfb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::index(int, int)
void Interpreter::index( int bound, int line_number)
{
  int i = store[stack_register];
  --stack_register;

  if (i < 1 || i > bound)
     runtime_error(" range error", line_number);
  else
     store[stack_register] = store[stack_register] + i -1;
  program_register += 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movslq 0xfa8(%rdi), %rax
movl (%rdi,%rax,4), %ecx
leal -0x1(%rax), %edx
movl %edx, 0xfa8(%rdi)
testl %ecx, %ecx
setg %dl
cmpl %esi, %ecx
setle %sil
testb %sil, %dl
jne 0x12659
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x13f9(%rip), %rsi      # 0x13a21
leaq 0x13fe(%rip), %rdx      # 0x13a2d
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x12458
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x12665
callq 0x21b0
jmp 0x12665
movl -0x4(%rbx,%rax,4), %edx
addl %edx, %ecx
decl %ecx
movl %ecx, -0x4(%rbx,%rax,4)
addl $0x3, 0xfb0(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1268a
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::pland()
void Interpreter::pland()
{
  ++program_register;
  --stack_register;
  if (store[stack_register] == 1)
    store[stack_register] = store[stack_register + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incl 0xfb0(%rdi)
movslq 0xfa8(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xfa8(%rdi)
cmpl $0x1, -0x4(%rdi,%rax,4)
jne 0x1288b
movl (%rdi,%rax,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::plor()
void Interpreter::plor()
{
  ++program_register;
  --stack_register;
  if (store[stack_register] == 0)
    store[stack_register] = store[stack_register + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
incl 0xfb0(%rdi)
movslq 0xfa8(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xfa8(%rdi)
cmpl $0x0, -0x4(%rdi,%rax,4)
jne 0x128b7
movl (%rdi,%rax,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::read(int)
void Interpreter::read(int count)
{
  int x;
//  cout << "program_register = " << program_register << endl;
//  cout << "stack_register = " << stack_register << endl;
//  cout << "base_register = " << base_register << endl;
  program_register += 2;
  stack_register -= count;
  x = stack_register;
//  cout << "Count = " << count;
  while ( x < stack_register + count)
  {
    ++x;
    cout << "Input: ";
    cin >> ( store[ store[x] ] );
  }
}

// Assembly:
addl $0x2, 0xfb0(%rdi)
movl 0xfa8(%rdi), %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
testl %esi, %esi
jle 0x1293e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %eax, %r14
movq 0x66ea(%rip), %r12      # 0x18fd8
movslq %esi, %r13
leaq 0x1(%r14), %r15
movl $0x7, %edx
movq 0x66c7(%rip), %rdi      # 0x18fc8
leaq 0x1126(%rip), %rsi      # 0x13a2e
callq 0x2210
movslq 0x4(%rbx,%r14,4), %rax
leaq (%rbx,%rax,4), %rsi
movq %r12, %rdi
callq 0x2120
movslq 0xfa8(%rbx), %rax
addq %r13, %rax
movq %r15, %r14
cmpq %rax, %r15
jl 0x128f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::write(int)
void Interpreter::write (int count)
{
  int x;
  program_register += 2;
  stack_register -= count;
  x = stack_register;

  while (x < stack_register + count )
  {
    ++x;
    cout << "  Output: ";
    cout << ( store[x]) << endl;
  }
}

// Assembly:
addl $0x2, 0xfb0(%rdi)
movl 0xfa8(%rdi), %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
testl %esi, %esi
jle 0x129eb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %eax, %r12
movq 0x6650(%rip), %r14      # 0x18fc8
movslq %esi, %r13
leaq 0x1(%r12), %r15
movl $0xa, %edx
movq %r14, %rdi
leaq 0x10a7(%rip), %rsi      # 0x13a36
callq 0x2210
movl 0x4(%rbx,%r12,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movslq 0xfa8(%rbx), %rax
addq %r13, %rax
movq %r15, %r12
cmpq %rax, %r15
jl 0x1297b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::assign(int)
void Interpreter::assign (int count)
{
  int x;
  
  program_register += 2;
  stack_register = stack_register - 2*count;
  x = stack_register;

  while ( x < stack_register + count)
  {
    ++x;
    store[store[x]] = store[x + count];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl $0x2, 0xfb0(%rdi)
movl 0xfa8(%rdi), %eax
subl %esi, %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
testl %esi, %esi
jle 0x12a3d
movslq %eax, %rdx
movl %esi, %eax
leaq (%rdi,%rax,4), %rax
addq $0x4, %rax
movslq %esi, %rcx
movl (%rax,%rdx,4), %esi
movslq 0x4(%rdi,%rdx,4), %r8
leaq 0x1(%rdx), %r9
movl %esi, (%rdi,%r8,4)
movslq 0xfa8(%rdi), %rsi
addq %rcx, %rsi
movq %r9, %rdx
cmpq %rsi, %r9
jl 0x12a1b
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::call(int, int)
void Interpreter::call( int level, int address)
{
  int x;

  allocate(3);
  x = base_register;
  
  while ( level > 0)
  {
    x = store[x];
    --level;
  }
  store[stack_register - 2] = x;
  store[stack_register - 1] = base_register; 
  store[stack_register] = program_register + 3;
  
  base_register = stack_register - 2;
  program_register = address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl $0x3, %esi
callq 0x12500
movl 0xfac(%r14), %eax
testl %r15d, %r15d
jle 0x12a7a
incl %r15d
cltq
movl (%r14,%rax,4), %eax
decl %r15d
cmpl $0x1, %r15d
ja 0x12a6b
movslq 0xfa8(%r14), %rcx
movl %eax, -0x8(%r14,%rcx,4)
movl 0xfac(%r14), %eax
movslq 0xfa8(%r14), %rcx
movl %eax, -0x4(%r14,%rcx,4)
movl 0xfb0(%r14), %eax
addl $0x3, %eax
movslq 0xfa8(%r14), %rcx
movl %eax, (%r14,%rcx,4)
movl 0xfa8(%r14), %eax
addl $-0x2, %eax
movl %eax, 0xfac(%r14)
movl %ebx, 0xfb0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::memory_dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
void Interpreter::memory_dump(string name) const
{
   const char *tempname = name.c_str();
   ofstream dump ( tempname, ios::out);
   
   if (!dump)
   {
     cerr << " couldn't open dump file " << endl;
     return;
   }

   int i = 0;
   
   while ( i < STORE_SIZE )
   {
     dump << store[i] << ' ';
     if ( ( i+1) % 20 == 0)
        dump << endl;
     i++;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x230(%rbp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x21f0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0x12c94
movq 0x63a0(%rip), %rbx      # 0x18ff0
leaq 0xe9d(%rip), %rsi       # 0x13af4
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x636e(%rip), %rdi      # 0x18ff0
callq 0x2030
movq %rax, %rdi
callq 0x2140
jmp 0x12d1d
movw $0x1, %r12w
xorl %r13d, %r13d
leaq -0x29(%rbp), %r15
movl (%rbx,%r13,4), %esi
movq %r14, %rdi
callq 0x22f0
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movzwl %r12w, %eax
imull $0xcccd, %eax, %eax     # imm = 0xCCCD
shrl $0x12, %eax
andl $-0x4, %eax
leal (%rax,%rax,4), %eax
addl $-0x4, %eax
movzwl %ax, %eax
orq $0x3, %rax
cmpw %r13w, %ax
jne 0x12d0e
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
incq %r13
incl %r12d
cmpq $0x3e8, %r13            # imm = 0x3E8
jne 0x12ca0
movq 0x629c(%rip), %rax      # 0x18fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x228(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x230(%rbp,%rcx)
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x2090
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12d67
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: bool hm3::hashindex::HashIndexBuilder::createFromList<hm3::DiskTable>(StringRef const&, hm3::DiskTable const&, bool) const
bool HashIndexBuilder::createFromList(const StringRef &filename2, const LIST &list, bool const stats) const{
	size_t const hashtableSize = list.getCount() * growFactor_;
	size_t const sizeBin       = hashtableSize * sizeof(uint64_t);

	const std::string filename = filenameIndx(filename2);

	// create file

	if ( ! MMAPFile::createFile(filename, sizeBin) ){
		return false;
	}

	// open file

	MMAPFile mmap{ MADV_RANDOM };
	if ( ! mmap.openRW(filename) ){
		return false;
	}

	uint64_t *hashtable = (uint64_t *) mmap.mem();

	// memset is not good, because it needs size to be int
	log__("Set hashtable to zeroes.");
	std::fill(hashtable, hashtable + hashtableSize, htobe64(BUCKET_EMPTY));

	// process

	size_t const collisions = createFromList_(hashtable, hashtableSize, list);

	if (stats)
		printStats_(list.getCount(), collisions);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0x2c(%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq (%rdi), %r14
imulq 0x8(%rdx), %r14
movups (%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x5, 0x40(%rsp)
leaq 0x28ce(%rip), %rax      # 0x515c
movq %rax, 0x48(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x30(%rsp), %rsi
addq $0x5, %rsi
leaq 0x8(%rsp), %rdi
callq 0x2220
leaq (,%r14,8), %r13
movl $0x8, %ebp
leaq 0x8(%rsp), %r12
movq 0x28(%rsp,%rbp), %rdx
movq 0x30(%rsp,%rbp), %rsi
movq %r12, %rdi
callq 0x2050
addq $0x10, %rbp
cmpq $0x28, %rbp
jne 0x28cc
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movq %r13, %rsi
callq 0x44ee
testb %al, %al
je 0x2998
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movl $0x1, 0x14(%rdi)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x58(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x44b8
movl %eax, %r12d
testb %al, %al
je 0x298c
movq 0x30(%rsp), %rbp
leaq 0x27f5(%rip), %rdi      # 0x5143
callq 0x27dc
testq %r14, %r14
je 0x2968
movq %rbp, %rdi
movl $0xff, %esi
movq %r13, %rdx
callq 0x20c0
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2a5c
cmpb $0x0, 0x2c(%rsp)
je 0x298c
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x2480
leaq 0x30(%rsp), %rdi
callq 0x44c8
jmp 0x299b
xorl %r12d, %r12d
leaq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x29b7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r12d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29cf
jmp 0x29cf
jmp 0x29de
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x44c8
jmp 0x29ed
movq %rax, %rdi
callq 0x2a50
jmp 0x29ea
jmp 0x29ea
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a09
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: unsigned long hm3::hashindex::HashIndexBuilder::createFromList_<hm3::DiskTable>(unsigned long*, unsigned long, hm3::DiskTable const&) const
size_t HashIndexBuilder::createFromList_(uint64_t *hashtable, size_t const hashtableSize, const LIST &list) const{
	uint64_t const BE_BUCKET_EMPTY		= htobe64(BUCKET_EMPTY		);
	uint64_t const BE_BUCKET_COLLISION	= htobe64(BUCKET_COLLISION	);

	size_t collisions = 0;

	log__("Creating hashtable.");
	DiskTable::size_type index = 0;
	for(const auto &p : list){
		auto const bucket = bucketForKey_(p.getKey(), hashtableSize);

		auto const htb = hashtable[bucket];

		if (htb == BE_BUCKET_EMPTY){
			hashtable[bucket] = htobe64(index);

		}else{
			++collisions;

			if (htb != BE_BUCKET_COLLISION){
				hashtable[bucket] = BE_BUCKET_COLLISION;
				++collisions;
			}
		}


		++index;
	}

	return collisions;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x26ea(%rip), %rdi      # 0x5164
callq 0x27dc
movzbl 0x18(%r15), %ecx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x41b6
movq 0x8(%r15), %rdx
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x41b6
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x2ac6
movq 0x40(%rsp), %rax
cmpq %rax, 0x10(%rsp)
jne 0x2ac6
xorl %r15d, %r15d
jmp 0x2b71
movabsq $-0x100000000000001, %r13 # imm = 0xFEFFFFFFFFFFFFFF
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x41d0
movq %rax, %rdi
callq 0x2c70
movb (%rdx), %cl
testb %cl, %cl
je 0x2b14
incq %rdx
movl $0x1505, %eax           # imm = 0x1505
movq %rax, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movsbq %cl, %rax
xorq %rsi, %rax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x2af8
jmp 0x2b19
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
divq %rbx
movq (%r14,%rdx,8), %rax
cmpq $-0x1, %rax
je 0x2b32
cmpq %r13, %rax
jne 0x2b3e
incq %r15
jmp 0x2b46
movq %rbp, %rax
bswapq %rax
movq %rax, (%r14,%rdx,8)
jmp 0x2b46
movq %r13, (%r14,%rdx,8)
addq $0x2, %r15
incq %rbp
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
cmpq 0x38(%rsp), %rcx
jne 0x2ada
cmpq 0x40(%rsp), %rax
jne 0x2ada
leaq 0x60(%rsp), %rdi
callq 0x2bbc
leaq 0x30(%rsp), %rdi
callq 0x2bbc
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2ba9
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2bbc
leaq 0x30(%rsp), %rdi
callq 0x2bbc
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get()
std::char_traits<char>::int_type get()
    {
        ++chars_read;
        current = ia->get_character();
        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
        {
            token_string.push_back(std::char_traits<char>::to_char_type(current));
        }
        return current;
    }

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incq 0x18(%rdi)
movq (%rdi), %rdi
movq (%rdi), %rax
callq *(%rax)
movl %eax, 0x10(%rbx)
cmpl $-0x1, %eax
je 0x3459
movb %al, 0xf(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x3442
movb %al, (%rsi)
incq 0x28(%rbx)
jmp 0x3450
leaq 0x20(%rbx), %rdi
leaq 0xf(%rsp), %rdx
callq 0x611a
movl 0x10(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x3453
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>& nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[]<char const>(char const*)
reference operator[](T* key)
    {
        // implicitly convert null to object
        if (is_null())
        {
            m_type = value_t::object;
            m_value = value_t::object;
            assert_invariant();
        }

        // at only works for objects
        if (JSON_LIKELY(is_object()))
        {
            return m_value.object->operator[](key);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x4111
movb $0x1, (%r14)
movl $0x30, %edi
callq 0x3240
leaq 0x8(%rax), %rcx
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
xorl %edx, %edx
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq %rdx, 0x28(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x4476
movb (%r14), %al
cmpb $0x1, %al
jne 0x415a
movq 0x8(%r14), %r14
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0x3100
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x762e
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x414e
callq 0x3220
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x20, %edi
callq 0x3130
movq %rax, %rbx
movzbl (%r14), %eax
cmpq $0x8, %rax
ja 0x417e
leaq 0x9be0(%rip), %rcx      # 0xdd58
movq (%rcx,%rax,8), %rsi
jmp 0x4185
leaq 0x5fd9(%rip), %rsi      # 0xa15e
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x3100
leaq 0x5f76(%rip), %rsi      # 0xa111
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x64bd
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x76aa
xorl %ebp, %ebp
leaq 0x9b50(%rip), %rsi      # 0xdd18
leaq 0x3615(%rip), %rdx      # 0x77e4
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4247
callq 0x3220
jmp 0x4247
movq %rax, %r14
jmp 0x4247
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x420a
callq 0x3220
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x421d
callq 0x3220
testb %bpl, %bpl
jne 0x423f
jmp 0x4247
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x423f
callq 0x3220
jmp 0x423f
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>::operator[](unsigned long)
reference operator[](size_type idx)
    {
        // implicitly convert null value to an empty array
        if (is_null())
        {
            m_type = value_t::array;
            m_value.array = create<array_t>();
            assert_invariant();
        }

        // operator[] only works for arrays
        if (JSON_LIKELY(is_array()))
        {
            // fill up array with null values if given idx is outside range
            if (idx >= m_value.array->size())
            {
                m_value.array->insert(m_value.array->end(),
                                      idx - m_value.array->size() + 1,
                                      basic_json());
            }

            return m_value.array->operator[](idx);
        }

        JSON_THROW(type_error::create(305, "cannot use operator[] with " + std::string(type_name())));
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movb (%rdi), %al
testb %al, %al
jne 0x4295
movb $0x2, (%r14)
movl $0x18, %edi
callq 0x3240
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x4476
movb (%r14), %al
cmpb $0x2, %al
jne 0x4318
movq 0x8(%r14), %r15
movq (%r15), %rax
movq 0x8(%r15), %r12
movq %r12, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
ja 0x42ff
movq %rbx, %r13
subq %rcx, %r13
incq %r13
leaq 0x8(%rsp), %rbp
movb $0x0, (%rbp)
movq $0x0, 0x8(%rbp)
movq %rbp, %rdi
callq 0x4476
movq %rbp, %rdi
callq 0x4476
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x7cdc
leaq 0x8(%rsp), %rdi
callq 0x4448
movq 0x8(%r14), %rax
movq (%rax), %rax
shlq $0x4, %rbx
addq %rax, %rbx
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x3130
movq %rax, %rbx
movzbl (%r14), %eax
cmpq $0x8, %rax
ja 0x433c
leaq 0x9a22(%rip), %rcx      # 0xdd58
movq (%rcx,%rax,8), %rsi
jmp 0x4343
leaq 0x5e1b(%rip), %rsi      # 0xa15e
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x3100
leaq 0x5db8(%rip), %rsi      # 0xa111
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x64bd
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x76aa
xorl %ebp, %ebp
leaq 0x9992(%rip), %rsi      # 0xdd18
leaq 0x3457(%rip), %rdx      # 0x77e4
movq %rbx, %rdi
callq 0x3370
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x4448
jmp 0x43f7
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43ba
callq 0x3220
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43cd
callq 0x3220
testb %bpl, %bpl
jne 0x43ef
jmp 0x43f7
movq %rax, %r14
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x43ef
callq 0x3220
jmp 0x43ef
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::parser<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::parse(bool, nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>&)
void parse(const bool strict, BasicJsonType& result)
    {
        // read first token
        get_token();

        parse_internal(true, result);
        result.assert_invariant();

        // in strict mode, input must be completely read
        if (strict)
        {
            get_token();
            expect(token_type::end_of_input);
        }

        // in case of an error, return discarded value
        if (errored)
        {
            result = value_t::discarded;
            return;
        }

        // set top-level value to null if it was discarded by the callback
        // function
        if (result.is_discarded())
        {
            result = nullptr;
        }
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%r14)
movq %r14, %rdi
movl $0x1, %esi
movq %rbx, %rdx
callq 0x4fd2
movq %rbx, %rdi
callq 0x4476
testl %ebp, %ebp
je 0x4bf3
movq %r15, %rdi
callq 0x5920
movl %eax, 0x28(%r14)
cmpl $0xf, %eax
jne 0x4c73
cmpb $0x1, 0xb0(%r14)
jne 0x4c10
leaq 0x18(%rsp), %r14
movb $0x8, (%r14)
movq $0x0, 0x8(%r14)
jmp 0x4c2e
cmpb $0x8, (%rbx)
jne 0x4c68
leaq 0x8(%rsp), %r14
movb $0x0, (%r14)
movq $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x4476
movq %r14, %rdi
callq 0x4476
movq %r14, %rdi
callq 0x4476
movb (%rbx), %al
movb (%r14), %cl
movb %cl, (%rbx)
movb %al, (%r14)
movq 0x8(%rbx), %rax
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x4476
movq %r14, %rdi
callq 0x4448
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x345e
jmp 0x4bf3
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::input_stream_adapter::input_stream_adapter(std::istream&)
explicit input_stream_adapter(std::istream& i)
        : is(i), sb(*i.rdbuf())
    {
        // skip byte order mark
        std::char_traits<char>::int_type c;
        if ((c = get_character()) == 0xEF)
        {
            if ((c = get_character()) == 0xBB)
            {
                if ((c = get_character()) == 0xBF)
                {
                    return; // Ignore BOM
                }
                else if (c != std::char_traits<char>::eof())
                {
                    is.unget();
                }
                is.putback('\xBB');
            }
            else if (c != std::char_traits<char>::eof())
            {
                is.unget();
            }
            is.putback('\xEF');
        }
        else if (c != std::char_traits<char>::eof())
        {
            is.unget(); // no byte order mark; process as usual
        }
    }

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x8ea9(%rip), %rax      # 0xdc50
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rdi
movq %rdi, 0x10(%rbx)
movq 0x10(%rdi), %rcx
cmpq 0x18(%rdi), %rcx
jae 0x4e46
movzbl (%rcx), %eax
incq %rcx
movq %rcx, 0x10(%rdi)
cmpl $-0x1, %eax
je 0x4e09
cmpl $0xef, %eax
jne 0x4e0b
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x4e37
cmpl $0xbb, %eax
jne 0x4e15
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x4e29
cmpl $0xbf, %eax
jne 0x4e20
popq %rbx
retq
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x30b0
movq 0x8(%rbx), %rdi
callq 0x30b0
jmp 0x4e37
movq 0x8(%rbx), %rdi
callq 0x30b0
movq 0x8(%rbx), %rdi
movl $0xffffffbb, %esi       # imm = 0xFFFFFFBB
callq 0x33d0
movq 0x8(%rbx), %rdi
movl $0xffffffef, %esi       # imm = 0xFFFFFFEF
popq %rbx
jmp 0x33d0
movq (%rdi), %rax
callq *0x50(%rax)
jmp 0x4dd5
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::scan_literal(char const*, unsigned long, nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::token_type)
token_type scan_literal(const char* literal_text, const std::size_t length,
                            token_type return_type)
    {
        assert(current == literal_text[0]);
        for (std::size_t i = 1; i < length; ++i)
        {
            if (JSON_UNLIKELY(get() != literal_text[i]))
            {
                error_message = "invalid literal";
                return token_type::parse_error;
            }
        }
        return return_type;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movsbl (%rsi), %eax
cmpl %eax, 0x10(%rdi)
jne 0x5ab7
movl %ecx, %ebx
movq %rdx, %r15
cmpq $0x2, %rdx
jb 0x5a99
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, %r13d
movq %r14, %rdi
callq 0x3410
movsbl (%r12,%r13), %ecx
cmpl %ecx, %eax
jne 0x5aa5
incq %r13
cmpq %r13, %r15
jne 0x5a80
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x3e4a(%rip), %rax      # 0x98f6
movq %rax, 0x58(%r14)
movl $0xe, %ebx
jmp 0x5a99
leaq 0x3e62(%rip), %rdi      # 0x9920
leaq 0x3b99(%rip), %rsi      # 0x965e
leaq 0x3e6f(%rip), %rcx      # 0x993b
movl $0xa5d, %edx            # imm = 0xA5D
callq 0x3160
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::unget()
void unget()
    {
        --chars_read;
        if (JSON_LIKELY(current != std::char_traits<char>::eof()))
        {
            ia->unget_character();
            assert(token_string.size() != 0);
            token_string.pop_back();
        }
    }

// Assembly:
pushq %rbx
decq 0x18(%rdi)
cmpl $-0x1, 0x10(%rdi)
je 0x6312
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x6314
decq %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
leaq 0x3bb7(%rip), %rdi      # 0x9ed2
leaq 0x333c(%rip), %rsi      # 0x965e
leaq 0x3bc2(%rip), %rcx      # 0x9eeb
movl $0xa91, %edx            # imm = 0xA91
callq 0x3160
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::lexer<nlohmann::basic_json<std::map, std::vector, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, long, unsigned long, double, std::allocator, nlohmann::adl_serializer>>::get_token_string() const
std::string get_token_string() const
    {
        // escape control characters
        std::string result;
        for (const auto c : token_string)
        {
            if ('\x00' <= c and c <= '\x1F')
            {
                // escape control characters
                std::stringstream ss;
                ss << "<U+" << std::setw(4) << std::uppercase << std::setfill('0')
                   << std::hex << static_cast<int>(c) << ">";
                result += ss.str();
            }
            else
            {
                // add character as is
                result.push_back(c);
            }
        }

        return result;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %r13
cmpq %r13, %rbp
je 0x668e
leaq 0x40(%rsp), %r15
movsbl (%rbp), %r14d
cmpl $0x1f, %r14d
ja 0x6677
leaq 0x30(%rsp), %rdi
callq 0x3180
movl $0x3, %edx
movq %r15, %rdi
leaq 0x3a73(%rip), %rsi      # 0xa00b
callq 0x3290
movq 0x40(%rsp), %rax
movq -0x18(%rax), %rcx
movq $0x4, 0x50(%rsp,%rcx)
movq -0x18(%rax), %rcx
orl $0x4000, 0x58(%rsp,%rcx) # imm = 0x4000
movq -0x18(%rax), %rcx
leaq (%r15,%rcx), %r12
cmpb $0x0, 0x121(%rsp,%rcx)
jne 0x65e8
movq %r12, %rdi
movl $0x20, %esi
callq 0x3230
movb $0x1, 0xe1(%r12)
movq 0x40(%rsp), %rax
movb $0x30, 0xe0(%r12)
movq -0x18(%rax), %rax
movl 0x58(%rsp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, 0x58(%rsp,%rax)
movq %r15, %rdi
movl %r14d, %esi
callq 0x3380
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3a37(%rip), %rsi      # 0xa054
callq 0x3290
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3330
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x30a0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x6657
callq 0x3220
leaq 0x30(%rsp), %rdi
movq 0x794d(%rip), %rsi      # 0xdfb0
callq 0x31b0
leaq 0xb0(%rsp), %rdi
callq 0x30c0
jmp 0x6682
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3200
incq %rbp
cmpq %r13, %rbp
jne 0x6570
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x66a7
jmp 0x66c5
movq %rax, %r14
jmp 0x66e6
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x66c8
callq 0x3220
jmp 0x66c8
movq %rax, %r14
movq 0x78e1(%rip), %rsi      # 0xdfb0
leaq 0x30(%rsp), %rdi
callq 0x31b0
leaq 0xb0(%rsp), %rdi
callq 0x30c0
movq (%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0x66f5
callq 0x3220
movq %r14, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O3/SYZYGYfpga[P]syzygy-tools/smartvio/syzygy.c
// Function: szgComputeCRC
unsigned short
szgComputeCRC(const unsigned char *data, unsigned int length)
{
	unsigned short x, crc = 0xffff;

	while (length--){
		x = (crc >> 8) ^ *data++;
		x ^= x>>4;
		crc = (crc<<8) ^ (x<<12) ^ (x<<5) ^ (x);
		crc &= 0xffff;
	}
	return(crc);
}

// Assembly:
testl %esi, %esi
je 0x86bb
movl %esi, %ecx
movw $0xffff, %ax            # imm = 0xFFFF
xorl %edx, %edx
movzwl %ax, %esi
shrl $0x8, %esi
movzbl (%rdi,%rdx), %r8d
xorl %esi, %r8d
movl %r8d, %esi
shrl $0x4, %esi
xorl %r8d, %esi
shll $0x8, %eax
movl %esi, %r8d
orl %esi, %eax
shll $0xc, %esi
shll $0x5, %r8d
xorl %esi, %eax
xorl %r8d, %eax
incq %rdx
cmpl %edx, %ecx
jne 0x8688
retq
movw $0xffff, %ax            # imm = 0xFFFF
retq
// File: /workspace/github_cpp_makefile_star2_O3/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: main
int main(int argc,char**argv)
{
    if (argc<2)
        return 0;
    else
    {
        version = argv[1];
        if (argc==3)
            trainortest = argv[2];
        prepare();
        test.run();
    }
}

// Assembly:
cmpl $0x2, %edi
jl 0x33bc
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %r14
movq 0x8e51(%rip), %r15      # 0xc1a0
leaq 0x8e42(%rip), %r12      # 0xc198
movq %r14, %rdi
callq 0x20b0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
movq %r14, %rcx
movq %rax, %r8
callq 0x2210
cmpl $0x3, %ebp
jne 0x33a3
movq 0x10(%rbx), %rbx
movq 0x8e3f(%rip), %r14      # 0xc1c0
leaq 0x8e30(%rip), %r15      # 0xc1b8
movq %rbx, %rdi
callq 0x20b0
movq %r15, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %rbx, %rcx
movq %rax, %r8
callq 0x2210
callq 0x298e
leaq 0x39dc1(%rip), %rdi     # 0x3d170
callq 0x3830
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: Test::add(int, int, int, bool)
void add(int x,int y,int z, bool flag)
    {
    	if (flag)
    	{
        	fb_h.push_back(x);
        	fb_r.push_back(z);
        	fb_l.push_back(y);
        }
        ok[make_pair(x,z)][y]=1;
    }

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x4(%rsp)
movl %ecx, 0x8(%rsp)
testl %r8d, %r8d
je 0x37ef
movl %ecx, %ebp
movq 0xc8(%rbx), %rax
cmpq 0xd0(%rbx), %rax
je 0x3777
movl %esi, (%rax)
addq $0x4, %rax
movq %rax, 0xc8(%rbx)
jmp 0x378b
leaq 0xc0(%rbx), %rdi
leaq 0xc(%rsp), %rdx
movq %rax, %rsi
callq 0x6c34
movq 0xf8(%rbx), %rsi
cmpq 0x100(%rbx), %rsi
je 0x37aa
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xf8(%rbx)
jmp 0x37bb
leaq 0xf0(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x6c34
movq 0xe0(%rbx), %rsi
cmpq 0xe8(%rbx), %rsi
je 0x37de
movl 0x4(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xe0(%rbx)
jmp 0x37ef
leaq 0xd8(%rbx), %rdi
leaq 0x4(%rsp), %rdx
callq 0x6c34
addq $0x108, %rbx            # imm = 0x108
movl 0xc(%rsp), %eax
movl 0x8(%rsp), %ecx
shlq $0x20, %rcx
orq %rax, %rcx
leaq 0x10(%rsp), %rsi
movq %rcx, (%rsi)
movq %rbx, %rdi
callq 0x542c
leaq 0x4(%rsp), %rsi
movq %rax, %rdi
callq 0x366c
movl $0x1, (%rax)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: main
int main()
{
    Tree code = {};
    TreeConstructor (&code);

    if (LoadTree (&code))
        GoElf (&code);

    TreeDestructor (&code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x58, %rsp
leaq -0x58(%rbp), %rbx
movq $0x0, (%rbx)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, 0x8(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, 0x20(%rbx)
movl $0xc, 0x30(%rbx)
movups %xmm0, 0x38(%rbx)
movq %rax, 0x48(%rbx)
movq %rbx, %rdi
callq 0x315c
movq %rbx, %rdi
callq 0x379f
testb %al, %al
je 0x1305
leaq -0x58(%rbp), %rdi
callq 0x1317
leaq -0x58(%rbp), %rdi
callq 0x3199
xorl %eax, %eax
addq $0x58, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: GoElf(Tree*)
void GoElf (Tree* code)
{
    assert (code);

    Elf elf = {};
    if (ElfConstructor (&elf))
        return;
    
    ElfAddBytes (&elf, "\xE8\x00\x00\x00\x00"           // call ♂sex♂
                       "\x48\xC7\xC0\x3C\x00\x00\x00"   // mov rax, 0x3C
                       "\x48\x31\xFF"                   // xor rdi, rdi
                       "\x0F\x05",                      // syscall
                       17);

    ElfAddPlace (&elf, "♂sex♂", 1);

    if (PrintDec (&elf, code->head))
        printf ("Something went wrong...\n");

    ElfCreateJumps (&elf);
    ElfWrite (&elf);
    system ("chmod u+x CompileResult/RightProgram.elf");
    ElfDestructor (&elf);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
testq %rdi, %rdi
je 0x1422
movq %rdi, %rbx
movq $-0x1, %rax
movq %rax, -0x78(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, -0x70(%rbp)
movq %rax, -0x58(%rbp)
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10a0
xorps %xmm0, %xmm0
movups %xmm0, -0x40(%rbp)
movups %xmm0, -0x50(%rbp)
movups %xmm0, -0x30(%rbp)
movb $0x0, -0x20(%rbp)
movq %rax, -0x40(%rbp)
testq %rax, %rax
je 0x1417
leaq -0x30(%rbp), %r15
leaq 0x3c9c(%rip), %rax      # 0x501c
movq %rax, -0x50(%r15)
leaq 0x3c9f(%rip), %rax      # 0x502a
movq %rax, -0x30(%r15)
movq $0x1000, 0x8(%r15)      # imm = 0x1000
leaq 0x3cbb(%rip), %rsi      # 0x5059
leaq -0x80(%rbp), %r14
movl $0x11, %edx
movq %r14, %rdi
callq 0x156a
leaq 0x401c(%rip), %rsi      # 0x53d2
movl $0x1, %edx
movq %r14, %rdi
callq 0x16da
movq (%rbx), %rsi
movq %r14, %rdi
callq 0x1d7f
testb %al, %al
je 0x13de
leaq 0x43de(%rip), %rdi      # 0x57b7
callq 0x1180
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x1ad2
movq %rbx, %rdi
callq 0x1c61
leaq 0x3fe3(%rip), %rdi      # 0x53dc
callq 0x10d0
movq 0x40(%rbx), %rdi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x48(%rbx), %rdi
callq 0x1507
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3f91(%rip), %rdi      # 0x53ba
leaq 0x3c70(%rip), %rsi      # 0x50a0
leaq 0x3f88(%rip), %rcx      # 0x53bf
movl $0x12b, %edx            # imm = 0x12B
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/AndreyVV-100[P]GachiLang/Backend/Backend.cpp
// Function: ElfConstructor(Elf*)
bool ElfConstructor (Elf* elf)
{
    assert (elf);

    elf->text = (char*) calloc (ALIGN, sizeof (*(elf->text)));
    if (!(elf->text))
        return 1;
    
    elf->printf_.func_name  = PRINT_STR;
    elf-> scanf_.func_name  = SCAN_STR;
    elf->aligned_text_size  = ALIGN;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1491
movq %rdi, %rbx
movl $0x1000, %edi           # imm = 0x1000
movl $0x1, %esi
callq 0x10a0
movq %rax, 0x40(%rbx)
testq %rax, %rax
je 0x1484
leaq 0x3bae(%rip), %rcx      # 0x501c
movq %rcx, (%rbx)
leaq 0x3bb2(%rip), %rcx      # 0x502a
movq %rcx, 0x20(%rbx)
movq $0x1000, 0x58(%rbx)     # imm = 0x1000
testq %rax, %rax
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x3e4e(%rip), %rdi      # 0x52e6
leaq 0x3c01(%rip), %rsi      # 0x50a0
leaq 0x3c0e(%rip), %rcx      # 0x50b4
movl $0x11, %edx
callq 0x1090