LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movb %dl, 0xfb5(%rdi)
movq 0x7614(%rip), %rdi      # 0x14fc8
leaq 0x202d(%rip), %rsi      # 0xf9e8
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq -0x38(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2240
movq %rbx, %rdi
movq %r15, %rsi
callq 0xda2e
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq 0x75d6(%rip), %rdi      # 0x14fc8
leaq 0x1ffb(%rip), %rsi      # 0xf9f4
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0xdb66
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x230(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0xda89
leaq 0x1fd5(%rip), %rsi      # 0xfa45
movq 0x7579(%rip), %rdi      # 0x14ff0
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
jmp 0xdb31
xorl %r12d, %r12d
leaq -0x24(%rbp), %r15
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x210(%rbp,%rax)
jne 0xdb0b
movq %r14, %rdi
movq %r15, %rsi
callq 0x2130
movl -0x24(%rbp), %eax
movl %eax, (%rbx,%r12,4)
cmpl $-0x1, %eax
je 0xdb0b
incq %r12
cmpq $0x3e8, %r12            # imm = 0x3E8
jne 0xda90
movq 0x7521(%rip), %rdi      # 0x14ff0
leaq 0x1f8c(%rip), %rsi      # 0xfa62
callq 0x21a0
movq %rax, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x22c0
leaq 0x1f84(%rip), %rsi      # 0xfa73
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq 0x1f75(%rip), %rsi      # 0xfa7b
jmp 0xda70
movl %r12d, 0xfa4(%rbx)
cmpq $0x3e9, %r12            # imm = 0x3E9
je 0xdb25
orl $-0x1, (%rbx,%r12,4)
incq %r12
jmp 0xdb12
leaq -0x230(%rbp), %rdi
callq 0x2040
leaq -0x230(%rbp), %rdi
callq 0x2050
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdb4f
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0xdebc
movl %edx, %r15d
movq 0x715f(%rip), %rdi      # 0x14ff0
leaq 0x176a(%rip), %rsi      # 0xf602
callq 0x21a0
movq %rax, %rdi
movl %r15d, %esi
callq 0x22c0
leaq 0x177e(%rip), %rsi      # 0xf62d
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
jmp 0xdec3
movq 0x712d(%rip), %rdi      # 0x14ff0
movq %r14, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
movb $0x0, 0xfb4(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x1
popq %rsi
callq 0xdee6
leaq 0xfac(%rbx), %rax
movslq (%rax), %rax
testl %r15d, %r15d
jle 0xdf87
leaq (%rbx,%rax,4), %rax
decl %r15d
jmp 0xdf76
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_O2/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 %rbx
subq $0x28, %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 0xe00c
leaq 0x1a2e(%rip), %rsi      # 0xfa11
leaq -0x40(%rbp), %r15
leaq -0x19(%rbp), %rdx
movq %r15, %rdi
callq 0x20a0
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xde72
leaq -0x40(%rbp), %rdi
callq 0x20d0
jmp 0xe018
movl -0x4(%rbx,%rax,4), %edx
addl %edx, %ecx
decl %ecx
movl %ecx, -0x4(%rbx,%rax,4)
addl $0x3, 0xfb0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe235
movl (%rdi,%rax,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xe261
movl (%rdi,%rax,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addl $0x2, 0xfb0(%rdi)
movl %esi, %r14d
movl 0xfa8(%rdi), %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
movslq %eax, %r15
movq 0x6d41(%rip), %r13      # 0x14fd8
addl %r14d, %eax
cltq
cmpq %rax, %r15
jge 0xe2d4
leaq 0x1(%r15), %r12
movq 0x6d1c(%rip), %rdi      # 0x14fc8
leaq 0x176b(%rip), %rsi      # 0xfa1e
callq 0x21a0
movslq 0x4(%rbx,%r15,4), %rax
leaq (%rbx,%rax,4), %rsi
movq %r13, %rdi
callq 0x2130
movl 0xfa8(%rbx), %eax
movq %r12, %r15
jmp 0xe297
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addl $0x2, 0xfb0(%rdi)
movl %esi, %r14d
movl 0xfa8(%rdi), %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
movslq %eax, %r13
movq 0x6cb1(%rip), %r15      # 0x14fc8
addl %r14d, %eax
cltq
cmpq %rax, %r13
jge 0xe354
leaq 0x1(%r13), %r12
movq %r15, %rdi
leaq 0x16f7(%rip), %rsi      # 0xfa26
callq 0x21a0
movl 0x4(%rbx,%r13,4), %esi
movq %r15, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movl 0xfa8(%rbx), %eax
movq %r12, %r13
jmp 0xe317
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %ecx
subl %esi, %ecx
subl %esi, %ecx
movl %ecx, 0xfa8(%rdi)
movslq %ecx, %rdx
movslq %esi, %rax
leaq (%rdi,%rax,4), %rax
addq $0x4, %rax
addl %esi, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rdx
jge 0xe3ae
movl (%rax,%rdx,4), %ecx
movslq 0x4(%rdi,%rdx,4), %r8
incq %rdx
movl %ecx, (%rdi,%r8,4)
movl 0xfa8(%rdi), %ecx
jmp 0xe38d
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x3
popq %rsi
callq 0xdee6
leaq 0xfac(%r14), %rax
movl (%rax), %eax
testl %r15d, %r15d
jle 0xe3e3
cltq
leaq (%r14,%rax,4), %rax
decl %r15d
jmp 0xe3d1
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
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::prog(int, int)
void Interpreter::prog( int variable_length, int address)
{
  base_register = stack_bottom;
//  cout << "base_register = " << stack_bottom << endl;
  stack_register = base_register;
//  cout << "stack_register = " << stack_register << endl;
  allocate( variable_length + 2);
  program_register = address;
//  cout << "program_register = " << program_register << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl 0xfa4(%rdi), %eax
movl %eax, 0xfac(%rdi)
movl %eax, 0xfa8(%rdi)
addl $0x2, %esi
callq 0xdee6
movl %ebx, 0xfb0(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 -0x228(%rbp), %r14
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x208(%rbp,%rax)
je 0xe5ce
movq 0x6a54(%rip), %rdi      # 0x14ff0
leaq 0x1541(%rip), %rsi      # 0xfae4
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq -0x228(%rbp), %rdi
callq 0x2270
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movw $0x1, %r14w
leaq -0x228(%rbp), %r15
xorl %r12d, %r12d
movl %r14d, %eax
xorl %edx, %edx
movw $0x14, %cx
divw %cx
cmpq $0x3e8, %r12            # imm = 0x3E8
je 0xe5b0
movl %eax, %r13d
movl (%rbx,%r12,4), %esi
movq %r15, %rdi
callq 0x22c0
movq %rax, %rdi
pushq $0x20
popq %rsi
callq 0x21e0
imull $0x14, %r13d, %eax
addl $-0x4, %eax
movzwl %ax, %eax
orq $0x3, %rax
cmpw %r12w, %ax
jne 0xe628
movq %r15, %rdi
callq 0x20f0
incl %r14d
incq %r12
jmp 0xe5dd
jmp 0xe632
movq %rax, %rbx
leaq -0x228(%rbp), %rdi
callq 0x2270
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: hm3::hashindex::HashIndexBuilder::printStats_(unsigned long, unsigned long)
void HashIndexBuilder::printStats_(size_t const size, size_t const collisions){
	constexpr const char *MASKZ = "%-16s : %12zu\n";
	constexpr const char *MASKF = "%-16s : %15.2f %%\n";

	double const percent = 100.0 * (double) collisions / (double) size;

	printf(MASKZ, "Total",			size			);
	printf(MASKZ, "Total Present",		size - collisions	);
	printf(MASKF, "Percent Present",	100 - percent		);
	printf(MASKZ, "Collisions",		collisions		);
	printf(MASKF, "Percent Missing",	percent			);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %xmm0
movq 0x2b9c(%rip), %xmm1     # 0x5010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2ba0(%rip), %xmm2     # 0x5020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
mulsd 0x2b98(%rip), %xmm3     # 0x5030
movq %rdi, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
movapd %xmm3, (%rsp)
leaq 0x2b77(%rip), %r15      # 0x5038
leaq 0x2b92(%rip), %rsi      # 0x505a
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2030
subq %rbx, %r14
leaq 0x2b81(%rip), %rsi      # 0x5060
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2030
movsd 0x2b3c(%rip), %xmm0     # 0x5030
subsd (%rsp), %xmm0
leaq 0x2b47(%rip), %r14      # 0x5047
leaq 0x2b67(%rip), %rsi      # 0x506e
movq %r14, %rdi
movb $0x1, %al
callq 0x2030
leaq 0x2b66(%rip), %rsi      # 0x507e
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2030
leaq 0x2b5d(%rip), %rsi      # 0x5089
movq %r14, %rdi
movaps (%rsp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/main/db_mkhash.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 1 + 1){
		printUsage(argv[0]);
		return 1;
	}

	const char *input_file	= argv[1];
	const char *output_file	= argv[2];

	if (CHECK_FILE_EXISTS && fileExists(output_file)){
		std::cout << "File " << output_file << " exists. Please remove it and try again." << '\n';
		return 2;
	}

	using DiskTable = hm3::DiskTable;

	DiskTable list;
	list.open(input_file);

	using HashIndexBuilder = hm3::hashindex::HashIndexBuilder;

	HashIndexBuilder htb;
	bool const result = htb.createFromList(output_file, list);

	return result ? 0 : 100;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
cmpl $0x2, %edi
jg 0x25f0
movq (%rsi), %r14
movq 0x5a70(%rip), %rdi      # 0x7fd0
leaq 0x2b32(%rip), %rsi      # 0x5099
callq 0x2170
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x2170
leaq 0x2b15(%rip), %rsi      # 0x50a0
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x2b13(%rip), %rsi      # 0x50b7
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x2b29(%rip), %rsi      # 0x50e6
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
leaq 0x2b24(%rip), %rsi      # 0x50fa
movq %rax, %rdi
callq 0x2170
movq %rax, %rdi
movl %ebx, %esi
callq 0x21a0
pushq $0x1
popq %rbx
jmp 0x26d7
movq 0x8(%rsi), %rax
movq 0x10(%rsi), %rbx
xorl %ecx, %ecx
movb %cl, 0x28(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rsp)
movb %cl, 0x40(%rsp)
movups %xmm0, 0x48(%rsp)
andq $0x0, 0x68(%rsp)
movups %xmm0, 0x58(%rsp)
andl $0x0, 0x84(%rsp)
movups %xmm0, 0x74(%rsp)
movl $0x1, 0x8c(%rsp)
movups %xmm0, 0x90(%rsp)
andl $0x0, 0xbc(%rsp)
movups %xmm0, 0xa4(%rsp)
andl $0x0, 0xb4(%rsp)
movb $0x1, 0xc0(%rsp)
movups %xmm0, 0xc8(%rsp)
movups %xmm0, 0xd8(%rsp)
movups %xmm0, 0xe8(%rsp)
movups %xmm0, 0xf8(%rsp)
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x2746
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3240
movq $0x8, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq 0x2746
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
leaq 0x28(%rsp), %rdx
pushq $0x1
popq %rcx
callq 0x2776
xorl %ecx, %ecx
testb %al, %al
pushq $0x64
popq %rbx
cmovnel %ecx, %ebx
leaq 0x28(%rsp), %rdi
callq 0x289c
movl %ebx, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
retq
jmp 0x26e6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x289c
movq %rbx, %rdi
callq 0x2260
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/common/myhash_impl.h
// Function: myhash::impl::MyHashBase<myhash::impl::DJB2A<unsigned long>>::operator()(char const*) const
uint operator()(const char *s) const{
			uint hash = offset_basis;

			for(const char *c = s; *c; ++c)
				h_.add(hash, *c);

			return hash;
		}

// Assembly:
movl $0x1505, %eax           # imm = 0x1505
movsbq (%rsi), %rcx
testq %rcx, %rcx
je 0x2744
imulq $0x21, %rax, %rax
xorq %rcx, %rax
incq %rsi
jmp 0x272f
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x58, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %r14
imulq (%rdi), %r14
leaq (,%r14,8), %r13
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x28f4
movq (%r12), %rax
movq 0x8(%r12), %rcx
leaq 0x10(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movq %r13, %rsi
callq 0x4104
testb %al, %al
je 0x2824
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdi
movaps %xmm0, (%rdi)
movl $0x1, 0x14(%rdi)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rcx
leaq 0x48(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x40d2
movl %eax, %r12d
testb %al, %al
je 0x284d
movq 0x10(%rsp), %rbp
leaq 0x2937(%rip), %rdi      # 0x5143
callq 0x26fb
xorl %eax, %eax
cmpq %rax, %r13
je 0x2829
orq $-0x1, (%rbp,%rax)
addq $0x8, %rax
jmp 0x2813
xorl %r12d, %r12d
jmp 0x2857
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x292a
cmpb $0x0, 0xc(%rsp)
je 0x284d
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x2458
leaq 0x10(%rsp), %rdi
callq 0x28cc
leaq 0x28(%rsp), %rdi
callq 0x20b0
movl %r12d, %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2877
jmp 0x2877
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x28cc
jmp 0x2889
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20b0
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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, %r12
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x2819(%rip), %rdi      # 0x5164
callq 0x26fb
leaq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x2aba
leaq 0x38(%rsp), %rdi
movq %r12, %rsi
callq 0x2ace
addq $0x8, %r15
leaq 0x8(%rsp), %r13
movq 0x8(%r13), %rax
xorl %ebp, %ebp
xorl %r12d, %r12d
movq 0x8(%rsp), %rcx
cmpq 0x38(%rsp), %rcx
jne 0x298f
cmpq 0x40(%rsp), %rax
je 0x29f3
movq %r13, %rdi
callq 0x3c18
movq %rax, %rdi
callq 0x2b68
movq %r15, %rdi
movq %rdx, %rsi
callq 0x272a
xorl %edx, %edx
divq %rbx
movq (%r14,%rdx,8), %rax
cmpq $-0x1, %rax
je 0x29cd
movabsq $-0x100000000000001, %rcx # imm = 0xFEFFFFFFFFFFFFFF
cmpq %rcx, %rax
jne 0x29d9
incq %r12
jmp 0x29e1
movq %rbp, %rax
bswapq %rax
movq %rax, (%r14,%rdx,8)
jmp 0x29e1
movq %rcx, (%r14,%rdx,8)
addq $0x2, %r12
incq %rbp
movq 0x10(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
jmp 0x297c
leaq 0x60(%rsp), %rdi
callq 0x2ae4
leaq 0x30(%rsp), %rdi
callq 0x2ae4
movq %r12, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2a2d
jmp 0x2a20
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2ae4
leaq 0x30(%rsp), %rdi
callq 0x2ae4
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3cf4
movb $0x1, (%r14)
callq 0x427c
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3fe2
movb (%r14), %al
cmpb $0x1, %al
jne 0x3d34
movq 0x8(%r14), %r14
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
callq 0x30f0
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x6ce2
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3120
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
movq %r14, %rdi
callq 0x6dfe
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x30f0
leaq 0x5544(%rip), %rsi      # 0x92a4
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0x6095
movb $0x1, %bpl
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x6d48
xorl %ebp, %ebp
leaq 0x9fe3(%rip), %rsi      # 0xdd70
leaq 0x308a(%rip), %rdx      # 0x6e1e
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3120
jmp 0x3de1
movq %rax, %r14
jmp 0x3de1
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3120
jmp 0x3dc5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x3120
testb %bpl, %bpl
jne 0x3dd9
jmp 0x3de1
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3e52
movb $0x2, (%r14)
callq 0x42d0
movq %rax, 0x8(%r14)
movq %r14, %rdi
callq 0x3fe2
movb (%r14), %al
cmpb $0x2, %al
jne 0x3ec3
movq 0x8(%r14), %r15
movq (%r15), %rax
movq 0x8(%r15), %r12
movq %r12, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
ja 0x3eaa
movq %rbx, %r13
subq %rcx, %r13
incq %r13
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
xorl %esi, %esi
callq 0x3bda
movq %r15, %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
callq 0x7294
leaq 0x8(%rsp), %rdi
callq 0x3fb4
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
pushq $0x20
popq %rdi
callq 0x3130
movq %rax, %rbx
movq %r14, %rdi
callq 0x6dfe
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x30f0
leaq 0x53b5(%rip), %rsi      # 0x92a4
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x6095
movb $0x1, %bpl
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movl $0x131, %esi            # imm = 0x131
callq 0x6d48
xorl %ebp, %ebp
leaq 0x9e54(%rip), %rsi      # 0xdd70
leaq 0x2efb(%rip), %rdx      # 0x6e1e
movq %rbx, %rdi
callq 0x33b0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3fb4
jmp 0x3f6b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x3120
jmp 0x3f4f
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x3120
testb %bpl, %bpl
jne 0x3f63
jmp 0x3f6b
movq %rax, %r14
movq %rbx, %rdi
callq 0x31c0
movq %r14, %rdi
callq 0x33d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x20, %rsp
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
callq 0x4d78
pushq $0x1
popq %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x4d8a
movq %rbx, %rdi
callq 0x3fe2
testl %ebp, %ebp
je 0x48d8
movq %r14, %rdi
callq 0x4d78
pushq $0xf
popq %rsi
movq %r14, %rdi
callq 0x5420
cmpb $0x1, 0xb0(%r14)
jne 0x48f4
leaq 0x10(%rsp), %r14
pushq $0x8
popq %rsi
movq %r14, %rdi
callq 0x544a
jmp 0x4906
cmpb $0x8, (%rbx)
jne 0x4919
movq %rsp, %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x3bda
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5464
movq %r14, %rdi
callq 0x3fb4
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x91a9(%rip), %rax      # 0xdc98
movq %rax, (%rdi)
movq %rsi, 0x8(%rdi)
movq (%rsi), %rax
movq -0x18(%rax), %rax
movq 0xe8(%rsi,%rax), %rax
movq %rax, 0x10(%rdi)
callq 0x4b7c
cmpl $-0x1, %eax
je 0x4b42
cmpl $0xef, %eax
jne 0x4b44
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x4b6e
cmpl $0xbb, %eax
jne 0x4b4e
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
cmpl $-0x1, %eax
je 0x4b62
cmpl $0xbf, %eax
jne 0x4b59
popq %rbx
retq
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x30b0
movq 0x8(%rbx), %rdi
callq 0x30b0
jmp 0x4b6e
movq 0x8(%rbx), %rdi
callq 0x30b0
movq 0x8(%rbx), %rdi
pushq $-0x45
popq %rsi
callq 0x3400
movq 0x8(%rbx), %rdi
pushq $-0x11
popq %rsi
popq %rbx
jmp 0x3400
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55c7
leaq 0x20(%rbx), %rdi
leaq 0xf(%rsp), %rsi
movb %al, (%rsi)
callq 0x5c7a
movl 0x10(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq
pushq $-0x1
popq %rax
jmp 0x55c1
// File: /workspace/github_cpp_makefile_star2_O2/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 0x561f
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
pushq $0x1
popq %r13
cmpq %r15, %r13
jae 0x5613
movq %r14, %rdi
callq 0x5592
movsbl (%r12,%r13), %ecx
incq %r13
cmpl %ecx, %eax
je 0x55ec
leaq 0x347d(%rip), %rax      # 0x8a89
movq %rax, 0x58(%r14)
pushq $0xe
popq %rbx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x348d(%rip), %rdi      # 0x8ab3
leaq 0x3041(%rip), %rsi      # 0x866e
leaq 0x349a(%rip), %rcx      # 0x8ace
movl $0xa5d, %edx            # imm = 0xA5D
callq 0x3190
// File: /workspace/github_cpp_makefile_star2_O2/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_codepoint()
int get_codepoint()
    {
        // this function only makes sense after reading `\u`
        assert(current == 'u');
        int codepoint = 0;

        const auto factors = { 12, 8, 4, 0 };
        for (const auto factor : factors)
        {
            get();

            if (current >= '0' and current <= '9')
            {
                codepoint += ((current - 0x30) << factor);
            }
            else if (current >= 'A' and current <= 'F')
            {
                codepoint += ((current - 0x37) << factor);
            }
            else if (current >= 'a' and current <= 'f')
            {
                codepoint += ((current - 0x57) << factor);
            }
            else
            {
                return -1;
            }
        }

        assert(0x0000 <= codepoint and codepoint <= 0xFFFF);
        return codepoint;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
cmpl $0x75, 0x10(%rdi)
jne 0x5e77
movq %rdi, %rbx
movaps 0x22f6(%rip), %xmm0     # 0x8100
movaps %xmm0, (%rsp)
xorl %r15d, %r15d
pushq $-0x1
popq %r12
xorl %ebp, %ebp
cmpq $0x10, %r15
je 0x5e5b
movl (%rsp,%r15), %r14d
movq %rbx, %rdi
callq 0x5592
movl 0x10(%rbx), %eax
leal -0x30(%rax), %edx
cmpl $0xa, %edx
jb 0x5e4e
leal -0x41(%rax), %ecx
cmpl $0x5, %ecx
ja 0x5e41
addl $-0x37, %eax
jmp 0x5e4c
leal -0x61(%rax), %ecx
cmpl $0x5, %ecx
ja 0x5e72
addl $-0x57, %eax
movl %eax, %edx
movl %r14d, %ecx
shll %cl, %edx
addl %edx, %ebp
addq $0x4, %r15
jmp 0x5e17
cmpl $0x10000, %ebp          # imm = 0x10000
jae 0x5e96
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %r12d, %ebp
jmp 0x5e63
leaq 0x2f16(%rip), %rdi      # 0x8d94
leaq 0x27e9(%rip), %rsi      # 0x866e
leaq 0x2f17(%rip), %rcx      # 0x8da3
movl $0x6d7, %edx            # imm = 0x6D7
callq 0x3190
leaq 0x2f74(%rip), %rdi      # 0x8e11
leaq 0x27ca(%rip), %rsi      # 0x866e
leaq 0x2ef8(%rip), %rcx      # 0x8da3
movl $0x6f1, %edx            # imm = 0x6F1
callq 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5f80
movq %rdi, %rbx
movq (%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rbx), %rax
cmpq 0x20(%rbx), %rax
je 0x5f82
decq %rax
movq %rax, 0x28(%rbx)
popq %rbx
retq
leaq 0x30dc(%rip), %rdi      # 0x9065
leaq 0x26de(%rip), %rsi      # 0x866e
leaq 0x30e7(%rip), %rcx      # 0x907e
movl $0xa91, %edx            # imm = 0xA91
callq 0x3190
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x1a8, %rsp            # imm = 0x1A8
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq 0x20(%rsi), %rbp
movq 0x28(%rsi), %r14
leaq 0x20(%rsp), %r12
movq %rsp, %r15
cmpq %r14, %rbp
je 0x61b2
movsbl (%rbp), %r13d
cmpl $0x1f, %r13d
ja 0x619f
movq %r12, %rdi
callq 0x31b0
leaq 0x30(%rsp), %rdi
leaq 0x3084(%rip), %rsi      # 0x919e
callq 0x3240
movq (%rax), %rcx
movq -0x18(%rcx), %rdx
movq $0x4, 0x10(%rax,%rdx)
movq -0x18(%rcx), %rcx
orl $0x4000, 0x18(%rax,%rcx) # imm = 0x4000
movq %rax, %rdi
pushq $0x30
popq %rsi
callq 0x3350
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%rax,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%rax,%rcx)
movq %rax, %rdi
movl %r13d, %esi
callq 0x33c0
movq %rax, %rdi
leaq 0x3077(%rip), %rsi      # 0x91e7
callq 0x3240
movq %r15, %rdi
leaq 0x38(%rsp), %rsi
callq 0x3360
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3430
movq %r15, %rdi
callq 0x3120
movq %r12, %rdi
callq 0x31d0
jmp 0x61aa
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3200
incq %rbp
jmp 0x60ee
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x61cb
jmp 0x61dd
movq %rax, %r14
jmp 0x61ea
movq %rax, %r14
movq %rsp, %rdi
callq 0x3120
jmp 0x61e0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x31d0
movq %rbx, %rdi
callq 0x3120
movq %r14, %rdi
callq 0x33d0
// File: /workspace/github_cpp_makefile_star2_O2/SYZYGYfpga[P]syzygy-tools/include/json.hpp
// Function: nlohmann::detail::parse_error::create(int, unsigned long, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static parse_error create(int id_, std::size_t byte_, const std::string& what_arg)
    {
        std::string w = exception::name("parse_error", id_) + "parse error" +
                        (byte_ != 0 ? (" at " + std::to_string(byte_)) : "") +
                        ": " + what_arg;
        return parse_error(id_, byte_, w.c_str());
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
leaq 0x28d0(%rip), %rsi      # 0x9287
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x30f0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
movl %ebp, %edx
callq 0x44ca
leaq 0x28b5(%rip), %rdx      # 0x9293
leaq 0x88(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x45aa
testq %rbx, %rbx
je 0x6a1a
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x6b96
leaq 0x2896(%rip), %rsi      # 0x929f
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x6095
jmp 0x6a30
leaq 0x1b36(%rip), %rsi      # 0x8557
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x30f0
leaq 0xa8(%rsp), %rdi
leaq 0x88(%rsp), %rsi
leaq 0x28(%rsp), %rdx
callq 0x45c9
leaq 0x1ae8(%rip), %rdx      # 0x8539
leaq 0xc8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0x45aa
leaq 0xe8(%rsp), %rdi
leaq 0xc8(%rsp), %rsi
movq %r15, %rdx
callq 0x44aa
leaq 0xc8(%rsp), %rdi
callq 0x3120
leaq 0xa8(%rsp), %rdi
callq 0x3120
leaq 0x28(%rsp), %rdi
callq 0x3120
testq %rbx, %rbx
je 0x6ab1
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x88(%rsp), %rdi
callq 0x3120
leaq 0x68(%rsp), %rdi
callq 0x3120
leaq 0x48(%rsp), %rdi
callq 0x3120
movq 0xe8(%rsp), %rcx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0x6bd8
leaq 0xe8(%rsp), %rdi
callq 0x3120
movq %r14, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6b0c
movq %rax, %r14
jmp 0x6b54
movq %rax, %r14
jmp 0x6b5e
movq %rax, %r14
leaq 0xe8(%rsp), %rdi
jmp 0x6b7a
movq %rax, %r14
leaq 0xc8(%rsp), %rdi
callq 0x3120
jmp 0x6b33
movq %rax, %r14
leaq 0xa8(%rsp), %rdi
callq 0x3120
jmp 0x6b45
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x3120
testq %rbx, %rbx
je 0x6b5e
leaq 0x8(%rsp), %rdi
callq 0x3120
leaq 0x88(%rsp), %rdi
callq 0x3120
leaq 0x68(%rsp), %rdi
callq 0x3120
leaq 0x48(%rsp), %rdi
callq 0x3120
movq %r14, %rdi
callq 0x33d0
movq %rax, %r14
jmp 0x6b6b
movq %rax, %r14
jmp 0x6b75
movq %rax, %r14
jmp 0x6b7f
// File: /workspace/github_cpp_makefile_star2_O2/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:
movl %esi, %ecx
movw $0xffff, %ax            # imm = 0xFFFF
xorl %edx, %edx
cmpl %edx, %ecx
je 0x7b94
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
jmp 0x7b60
retq
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: vec_len(std::vector<double, std::allocator<double>>)
double vec_len(vector<double> a)
{
	double res=0;
	for (int i=0; i<a.size(); i++)
		res+=a[i]*a[i];
	return sqrt(res);
}

// Assembly:
movq (%rdi), %rax
movq 0x8(%rdi), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
xorpd %xmm0, %xmm0
xorl %edx, %edx
cmpq %rdx, %rcx
je 0x280b
movsd (%rax,%rdx,8), %xmm1
mulsd %xmm1, %xmm1
addsd %xmm1, %xmm0
incq %rdx
jmp 0x27f4
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x2110
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O2/thunlp[P]KB2E/CTransR/Test_CTransR.cpp
// Function: vec_output(std::vector<double, std::allocator<double>>)
void vec_output(vector<double> a)
{
	for (int i=0; i<a.size(); i++)
	{
		cout<<a[i]<<"\t";
		if (i%9==4)
			cout<<endl;
	}
	cout<<"-------------------------"<<endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x4
popq %rbp
xorl %r14d, %r14d
movq 0x979f(%rip), %r15      # 0xbfd8
leaq 0x583d(%rip), %r12      # 0x807d
movl %r14d, %eax
xorl %edx, %edx
pushq $0x9
popq %rcx
divl %ecx
movq (%rbx), %rcx
movq 0x8(%rbx), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %r14, %rdx
jbe 0x2891
leal (%rax,%rax,8), %r13d
addl %ebp, %r13d
movsd (%rcx,%r14,8), %xmm0
movq %r15, %rdi
callq 0x2210
movq %rax, %rdi
movq %r12, %rsi
callq 0x2150
testl %r13d, %r13d
jne 0x288a
movq %r15, %rdi
callq 0x20a0
incq %r14
decl %ebp
jmp 0x2840
movq 0x9740(%rip), %rdi      # 0xbfd8
leaq 0x57e0(%rip), %rsi      # 0x807f
callq 0x2150
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20a0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2f96
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl %edi, %ebp
movq 0x8(%rsi), %rsi
leaq 0x9233(%rip), %rdi      # 0xc198
callq 0x2290
cmpl $0x3, %ebp
jne 0x2f7f
movq 0x10(%rbx), %rsi
leaq 0x923e(%rip), %rdi      # 0xc1b8
callq 0x2290
callq 0x28db
leaq 0x3a1e5(%rip), %rdi     # 0x3d170
callq 0x330a
addq $0x8, %rsp
popq %rbx
popq %rbp
xorl %eax, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movl %esi, 0x14(%rsp)
movl %edx, 0xc(%rsp)
movl %ecx, 0x10(%rsp)
testl %r8d, %r8d
je 0x32cc
leaq 0xc0(%rbx), %rdi
leaq 0x14(%rsp), %r14
movq %r14, %rsi
callq 0x3252
leaq 0xf0(%rbx), %rdi
leaq 0x10(%rsp), %r15
movq %r15, %rsi
callq 0x3252
leaq 0xd8(%rbx), %rdi
leaq 0xc(%rsp), %rsi
callq 0x3252
movl (%r14), %esi
movl (%r15), %ecx
addq $0x108, %rbx            # imm = 0x108
shlq $0x20, %rcx
movl %esi, %eax
orq %rcx, %rax
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x4a14
leaq 0xc(%rsp), %rsi
movq %rax, %rdi
callq 0x31b6
movl $0x1, (%rax)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop