LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::DumpMem(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void mos6502::DumpMem(std::vector<std::string> &args) {
  if (args.size() < 3) {
	std::cout << "usage: x [MEM] [LEN]" << std::endl;
	return;
  }

  uint16_t mem, len;
  std::stringstream ss;
  ss << args[1];
  ss >> mem;
  
  ss << args[2];
  ss >> len;

  for (uint16_t i = 0; i < len; ++i) {
	uint8_t byte = Read(mem + i);
	std::cout << std::hex << byte << " ";
	if (i && (i % 8 == 0)) {
	  std::cout << std::endl;
	}
  }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x40, %rax
ja 0x2c06
movq 0x7416(%rip), %rbx      # 0x9fd0
leaq 0x44e4(%rip), %rsi      # 0x70a5
movl $0x14, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1b8(%rbp), %rdi
callq 0x20f0
leaq -0x1a8(%rbp), %r15
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
movq %r15, %rdi
callq 0x21c0
leaq -0x1b8(%rbp), %rdi
leaq -0x2e(%rbp), %rsi
callq 0x2200
movq (%r14), %rax
movq 0x40(%rax), %rsi
movq 0x48(%rax), %rdx
movq %r15, %rdi
callq 0x21c0
leaq -0x1b8(%rbp), %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2200
cmpw $0x0, -0x2c(%rbp)
je 0x2d16
xorl %r13d, %r13d
movq 0x7356(%rip), %r14      # 0x9fd0
leaq -0x29(%rbp), %r15
leaq 0x43bb(%rip), %r12      # 0x7040
movzwl -0x2e(%rbp), %esi
addq %r13, %rsi
movq %rbx, %rdi
callq 0x2d74
movq (%r14), %rcx
movq -0x18(%rcx), %rcx
movl 0x18(%r14,%rcx), %edx
andl $-0x4b, %edx
orl $0x8, %edx
movl %edx, 0x18(%r14,%rcx)
movb %al, -0x29(%rbp)
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x21c0
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
testl %r13d, %r13d
sete %al
testb $0x7, %r13b
setne %cl
orb %al, %cl
jne 0x2d06
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movzwl -0x2c(%rbp), %eax
incq %r13
cmpl %eax, %r13d
jb 0x2c85
movq 0x7293(%rip), %rsi      # 0x9fb0
leaq -0x1b8(%rbp), %rdi
callq 0x2120
leaq -0x138(%rbp), %rdi
callq 0x2080
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2d49
movq %rax, %rbx
movq 0x725d(%rip), %rsi      # 0x9fb0
leaq -0x1b8(%rbp), %rdi
callq 0x2120
leaq -0x138(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Read(unsigned long)
uint8_t mos6502::Read(uint64_t where) {
  uint8_t byte = InternalRead(where);
  for (auto addr : watches) {
	if (addr == DebugPC) {
	  printf("0x%x: read mem[0x%llx] -> 0x%x\n", DebugPC, where, byte);
	}
  }
  return byte;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq *0x2020(%r14)
movb %al, -0x29(%rbp)
movq 0x2050(%r14), %r15
movq 0x2058(%r14), %r13
cmpq %r13, %r15
je 0x2dd8
movzbl -0x29(%rbp), %r12d
movzwl (%r15), %esi
cmpw 0x2030(%r14), %si
jne 0x2dcf
leaq 0x435d(%rip), %rdi      # 0x711f
movq %rbx, %rdx
movl %r12d, %ecx
xorl %eax, %eax
callq 0x2040
addq $0x2, %r15
cmpq %r13, %r15
jne 0x2dad
movb -0x29(%rbp), %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::AddBreakpoint(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void mos6502::AddBreakpoint(std::vector<std::string> &args) {
  if (args.size() < 2) {
	std::cout << "usage: b [MEM]" << std::endl;
	return;
  }

  std::stringstream ss;
  ss << std::hex << args[1];

  uint16_t addr;
  ss >> addr;

  bps.push_back(addr);

  std::cout << "Breakpoint #" << bps.size() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x20, %rax
ja 0x2e52
movq 0x71c4(%rip), %rbx      # 0x9fd0
leaq 0x42a7(%rip), %rsi      # 0x70ba
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x20f0
leaq -0x190(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl -0x178(%rbp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, -0x178(%rbp,%rax)
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x21c0
leaq -0x1a0(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2200
movq 0x2040(%rbx), %rsi
cmpq 0x2048(%rbx), %rsi
je 0x2eca
movzwl -0x12(%rbp), %eax
movw %ax, (%rsi)
addq $0x2, %rsi
movq %rsi, 0x2040(%rbx)
jmp 0x2eda
leaq 0x2038(%rbx), %rdi
leaq -0x12(%rbp), %rdx
callq 0x5e48
movq 0x70ef(%rip), %rdi      # 0x9fd0
leaq 0x41e1(%rip), %rsi      # 0x70c9
movl $0xc, %edx
callq 0x21c0
movq 0x2040(%rbx), %rsi
subq 0x2038(%rbx), %rsi
sarq %rsi
movq 0x70c6(%rip), %rdi      # 0x9fd0
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x7070(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2f66
movq %rax, %rbx
movq 0x7040(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::RemoveBreakpoint(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void mos6502::RemoveBreakpoint(std::vector<std::string> &args) {
  if (args.size() < 2) {
	std::cout << "usage: d [NUM]" << std::endl;
	return;
  }

  std::stringstream ss;
  ss << args[1];

  uint16_t num;
  ss >> num;

  bps[num] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x20, %rax
ja 0x2ff8
movq 0x701e(%rip), %rbx      # 0x9fd0
leaq 0x411d(%rip), %rsi      # 0x70d6
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x20f0
leaq -0x190(%rbp), %rdi
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x21c0
leaq -0x1a0(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2200
movzwl -0x12(%rbp), %eax
movq 0x2038(%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movq 0x6f67(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x306f
movq %rax, %rbx
movq 0x6f37(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::MemWatch(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void mos6502::MemWatch(std::vector<std::string> &args) {
  if (args.size() < 2) {
	std::cout << "usage: w [ADDR]" << std::endl;
	return;
  }

  std::stringstream ss;
  ss << std::hex << args[1];

  uint16_t addr;
  ss >> addr;

  watches.push_back(addr);

  std::cout << "Watch on #" << watches.size() << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x20, %rax
ja 0x3102
movq 0x6f14(%rip), %rbx      # 0x9fd0
leaq 0x4022(%rip), %rsi      # 0x70e5
movl $0xf, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x20f0
leaq -0x190(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
movl -0x178(%rbp,%rax), %ecx
andl $-0x4b, %ecx
orl $0x8, %ecx
movl %ecx, -0x178(%rbp,%rax)
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x21c0
leaq -0x1a0(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2200
movq 0x2058(%rbx), %rsi
cmpq 0x2060(%rbx), %rsi
je 0x317a
movzwl -0x12(%rbp), %eax
movw %ax, (%rsi)
addq $0x2, %rsi
movq %rsi, 0x2058(%rbx)
jmp 0x318a
leaq 0x2050(%rbx), %rdi
leaq -0x12(%rbp), %rdx
callq 0x5e48
movq 0x6e3f(%rip), %rdi      # 0x9fd0
leaq 0x3f5d(%rip), %rsi      # 0x70f5
movl $0xa, %edx
callq 0x21c0
movq 0x2058(%rbx), %rsi
subq 0x2050(%rbx), %rsi
sarq %rsi
movq 0x6e16(%rip), %rdi      # 0x9fd0
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x6dc0(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3216
movq %rax, %rbx
movq 0x6d90(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::RemoveMemWatch(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&)
void mos6502::RemoveMemWatch(std::vector<std::string> &args) {
  if (args.size() < 2) {
	std::cout << "usage: r [NUM]" << std::endl;
	return;
  }

  std::stringstream ss;
  ss << args[1];

  uint16_t num;
  ss >> num;

  watches[num] = 0;

  std::cout << "Removed watch #" << num << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq 0x8(%rsi), %rax
subq (%rsi), %rax
cmpq $0x20, %rax
ja 0x32a8
movq 0x6d6e(%rip), %rbx      # 0x9fd0
leaq 0x3e97(%rip), %rsi      # 0x7100
movl $0xe, %edx
movq %rbx, %rdi
callq 0x21c0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x1a0(%rbp), %rdi
callq 0x20f0
leaq -0x190(%rbp), %rdi
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
callq 0x21c0
leaq -0x1a0(%rbp), %rdi
leaq -0x12(%rbp), %rsi
callq 0x2200
movzwl -0x12(%rbp), %eax
movq 0x2050(%rbx), %rcx
movw $0x0, (%rcx,%rax,2)
movq 0x6cd7(%rip), %rdi      # 0x9fd0
leaq 0x3e0f(%rip), %rsi      # 0x710f
movl $0xf, %edx
callq 0x21c0
movzwl -0x12(%rbp), %esi
movq 0x6cbb(%rip), %rdi      # 0x9fd0
callq 0x20d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2170
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20e0
movq 0x6c65(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3371
movq %rax, %rbx
movq 0x6c35(%rip), %rsi      # 0x9fb0
leaq -0x1a0(%rbp), %rdi
callq 0x2120
leaq -0x120(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Write(unsigned long, unsigned long)
void mos6502::Write(uint64_t where, uint64_t what) {
  for (auto addr : watches) {
	if (addr == DebugPC) {
	  printf("0x%x: write mem[0x%llx] <- 0x%llx\n", DebugPC, where, what);
	}
  }
  InternalWrite(where, what);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x2050(%rdi), %r13
movq 0x2058(%rdi), %r12
cmpq %r12, %r13
je 0x33ef
movzwl (%r13), %esi
cmpw 0x2030(%r15), %si
jne 0x33e9
leaq 0x3d63(%rip), %rdi      # 0x713f
movq %r14, %rdx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x2040
addq $0x2, %r13
jmp 0x33c1
movq 0x2028(%r15), %rax
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_ADC(unsigned short)
void mos6502::Op_ADC(uint16_t src)
{
	uint8_t m = Read(src);
	unsigned int tmp = m + A + (IF_CARRY() ? 1 : 0);
	SET_ZERO(!(tmp & 0xFF));
    if (IF_DECIMAL())
    {
        if (((A & 0xF) + (m & 0xF) + (IF_CARRY() ? 1 : 0)) > 9) tmp += 6;
        SET_NEGATIVE(tmp & 0x80);
        SET_OVERFLOW(!((A ^ m) & 0x80) && ((A ^ tmp) & 0x80));
        if (tmp > 0x99)
        {
        	tmp += 96;
        }
        SET_CARRY(tmp > 0x99);
    }
	else
	{
		SET_NEGATIVE(tmp & 0x80);
		SET_OVERFLOW(!((A ^ m) & 0x80) && ((A ^ tmp) & 0x80));
		SET_CARRY(tmp > 0xFF);
    }
	
    A = tmp & 0xFF;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
movzbl %al, %esi
movzbl (%rbx), %edx
movzbl 0x12(%rbx), %edi
movl %edi, %ecx
andl $0x1, %ecx
addl %edx, %ecx
addl %esi, %ecx
xorl %eax, %eax
testb %cl, %cl
sete %al
andl $-0x3, %edi
leal (%rdi,%rax,2), %edi
testb $0x8, %dil
jne 0x4923
movl %edi, %eax
andb $0x77, %al
orb $-0x80, %dil
testb %cl, %cl
movzbl %al, %r8d
movzbl %dil, %eax
cmovnsl %r8d, %eax
xorl %edx, %esi
cmpl $0x7f, %esi
ja 0x491f
xorb %cl, %dl
js 0x495d
andb $-0x41, %al
jmp 0x495f
movl %edx, %eax
andl $0xf, %eax
movl %edx, %r8d
xorl %esi, %r8d
andl $0xf, %esi
addl %eax, %esi
movl %edi, %eax
andl $0x1, %eax
addl %esi, %eax
leal 0x6(%rcx), %esi
cmpl $0xa, %eax
cmovbl %ecx, %esi
andb $0x7f, %dil
movl %esi, %eax
andb $-0x80, %al
orb %dil, %al
cmpl $0x7f, %r8d
ja 0x4959
xorb %sil, %dl
js 0x4971
andb $-0x41, %al
jmp 0x4973
orb $0x40, %al
cmpl $0x100, %ecx            # imm = 0x100
jb 0x496b
orb $0x1, %al
jmp 0x496d
andb $-0x2, %al
movl %ecx, %esi
jmp 0x4984
orb $0x40, %al
cmpl $0x9a, %esi
jb 0x4982
addl $0x60, %esi
orb $0x1, %al
jmp 0x4984
andb $-0x2, %al
movb %al, 0x12(%rbx)
movb %sil, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Addr_ABS()
uint16_t mos6502::Addr_ABS()
{
	uint16_t addrL;
	uint16_t addrH;
	uint16_t addr;
	
	addrL = Read(pc++);
	addrH = Read(pc++);
	
	addr = addrL + (addrH << 8);
		
	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x10(%rdi), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rdi)
callq 0x2d74
movl %eax, %r14d
movzwl 0x10(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2d74
movzbl %r14b, %ecx
movzbl %al, %eax
shll $0x8, %eax
orl %ecx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Addr_INX()
uint16_t mos6502::Addr_INX()
{
	uint16_t zeroL;
	uint16_t zeroH;
	uint16_t addr;
	
	zeroL = (Read(pc++) + X) % 256;
	zeroH = (zeroL + 1) % 256;
	addr = Read(zeroL) + (Read(zeroH) << 8);
	
	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x10(%rdi), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rdi)
callq 0x2d74
movl %eax, %r14d
addb 0x1(%rbx), %r14b
movzbl %r14b, %esi
incb %r14b
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %r15d
movzbl %r14b, %esi
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
shll $0x8, %eax
orl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Addr_INY()
uint16_t mos6502::Addr_INY()
{
	uint16_t zeroL;
	uint16_t zeroH;
	uint16_t addr;
	
	zeroL = Read(pc++);
	zeroH = (zeroL + 1) % 256;
	addr = Read(zeroL) + (Read(zeroH) << 8) + Y;
	
	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movzwl 0x10(%rdi), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rdi)
callq 0x2d74
movl %eax, %r14d
movzbl %al, %esi
incb %r14b
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %r15d
movzbl %r14b, %esi
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %ecx
shll $0x8, %ecx
orl %r15d, %ecx
movzbl 0x2(%rbx), %eax
addl %ecx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Addr_ABX()
uint16_t mos6502::Addr_ABX()
{
	uint16_t addr;
	uint16_t addrL;
	uint16_t addrH;
	
	addrL = Read(pc++);
	addrH = Read(pc++);
	
	addr = addrL + (addrH << 8) + X;
	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x10(%rdi), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rdi)
callq 0x2d74
movl %eax, %r14d
movzwl 0x10(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2d74
movzbl %r14b, %ecx
movzbl %al, %edx
shll $0x8, %edx
orl %ecx, %edx
movzbl 0x1(%rbx), %eax
addl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Addr_ABY()
uint16_t mos6502::Addr_ABY()
{
	uint16_t addr;
	uint16_t addrL;
	uint16_t addrH;
	
	addrL = Read(pc++);
	addrH = Read(pc++);
	
	addr = addrL + (addrH << 8) + Y;
	return addr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movzwl 0x10(%rdi), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rdi)
callq 0x2d74
movl %eax, %r14d
movzwl 0x10(%rbx), %esi
leal 0x1(%rsi), %eax
movw %ax, 0x10(%rbx)
movq %rbx, %rdi
callq 0x2d74
movzbl %r14b, %ecx
movzbl %al, %edx
shll $0x8, %edx
orl %ecx, %edx
movzbl 0x2(%rbx), %eax
addl %edx, %eax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_AND(unsigned short)
void mos6502::Op_AND(uint16_t src)
{
	uint8_t m = Read(src);
	uint8_t res = m & A;
	SET_NEGATIVE(res & 0x80);
	SET_ZERO(!res);
	A = res;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
movb 0x12(%rbx), %cl
andb (%rbx), %al
js 0x4b77
andb $0x7f, %cl
testb %al, %al
jne 0x4b7a
orb $0x2, %cl
jmp 0x4b7d
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_ASL(unsigned short)
void mos6502::Op_ASL(uint16_t src)
{
	uint8_t m = Read(src);
    SET_CARRY(m & 0x80);
    m <<= 1;
    m &= 0xFF;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    Write(src, m);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl %esi, %ebx
movq %rbx, %rsi
callq 0x2d74
movb 0x12(%r14), %dl
andb $-0x2, %dl
movl %eax, %ecx
shrb $0x7, %cl
orb %dl, %cl
addb %al, %al
js 0x4bbc
andb $0x7f, %cl
testb %al, %al
jne 0x4bbf
orb $0x2, %cl
jmp 0x4bc2
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%r14)
movzbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x339c
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_ASL_ACC(unsigned short)
void mos6502::Op_ASL_ACC(uint16_t src)
{
	uint8_t m = A;
    SET_CARRY(m & 0x80);
    m <<= 1;
    m &= 0xFF;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    A = m;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb 0x12(%rdi), %dl
andb $-0x2, %dl
movl %eax, %ecx
shrb $0x7, %cl
orb %dl, %cl
addb %al, %al
js 0x4c03
andb $0x7f, %cl
testb %al, %al
jne 0x4c06
orb $0x2, %cl
jmp 0x4c09
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, (%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_BRK(unsigned short)
void mos6502::Op_BRK(uint16_t src)
{
	pc++;
	StackPush((pc >> 8) & 0xFF);
	StackPush(pc & 0xFF);
	StackPush(status | BREAK);
	SET_INTERRUPT(1);
	pc = (Read(irqVectorH) << 8) + Read(irqVectorL);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x10(%rdi), %eax
incl %eax
movw %ax, 0x10(%rdi)
movzbl %ah, %edx
movl $0x100, %r14d           # imm = 0x100
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x339c
movq 0x8(%rbx), %rsi
subq $0x1, %rsi
movl $0xff, %r15d
cmovbq %r15, %rsi
movq %rsi, 0x8(%rbx)
movzbl 0x10(%rbx), %edx
addq %r14, %rsi
movq %rbx, %rdi
callq 0x339c
movq 0x8(%rbx), %rsi
subq $0x1, %rsi
cmovbq %r15, %rsi
movq %rsi, 0x8(%rbx)
movzbl 0x12(%rbx), %edx
orq $0x10, %rdx
addq %r14, %rsi
movq %rbx, %rdi
callq 0x339c
movq 0x8(%rbx), %rax
subq $0x1, %rax
cmovbq %r15, %rax
movq %rax, 0x8(%rbx)
orb $0x4, 0x12(%rbx)
movl $0xffff, %esi           # imm = 0xFFFF
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %r14d
shll $0x8, %r14d
movl $0xfffe, %esi           # imm = 0xFFFE
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
orl %r14d, %eax
movw %ax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_DEC(unsigned short)
void mos6502::Op_DEC(uint16_t src)
{
	uint8_t m = Read(src);
	m = (m - 1) % 256;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    Write(src, m);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl %esi, %ebx
movq %rbx, %rsi
callq 0x2d74
decb %al
movb 0x12(%r14), %cl
js 0x4ed8
andb $0x7f, %cl
testb %al, %al
jne 0x4edb
orb $0x2, %cl
jmp 0x4ede
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%r14)
movzbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x339c
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_DEX(unsigned short)
void mos6502::Op_DEX(uint16_t src)
{
	uint8_t m = X;
	m = (m - 1) % 256;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    X = m;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1(%rdi), %al
movb 0x12(%rdi), %cl
decb %al
js 0x4f0e
andb $0x7f, %cl
testb %al, %al
jne 0x4f11
orb $0x2, %cl
jmp 0x4f14
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x1(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_DEY(unsigned short)
void mos6502::Op_DEY(uint16_t src)
{
	uint8_t m = Y;
	m = (m - 1) % 256;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    Y = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x2(%rdi), %al
movb 0x12(%rdi), %cl
decb %al
js 0x4f36
andb $0x7f, %cl
testb %al, %al
jne 0x4f39
orb $0x2, %cl
jmp 0x4f3c
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x2(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_EOR(unsigned short)
void mos6502::Op_EOR(uint16_t src)
{
	uint8_t m = Read(src);
	m = A ^ m;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    A = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
movb (%rbx), %cl
movb 0x12(%rbx), %dl
movl %ecx, %esi
xorb %al, %sil
andb $0x7d, %dl
movl %esi, %edi
andb $-0x80, %dil
orb %dl, %dil
cmpb %al, %cl
sete %al
addb %al, %al
orb %dil, %al
movb %al, 0x12(%rbx)
movb %sil, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_INC(unsigned short)
void mos6502::Op_INC(uint16_t src)
{
	uint8_t m = Read(src);
	m = (m + 1) % 256;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    Write(src, m);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %r14
movl %esi, %ebx
movq %rbx, %rsi
callq 0x2d74
incb %al
movb 0x12(%r14), %cl
js 0x4faa
andb $0x7f, %cl
testb %al, %al
jne 0x4fad
orb $0x2, %cl
jmp 0x4fb0
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%r14)
movzbl %al, %edx
movq %r14, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x339c
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_INX(unsigned short)
void mos6502::Op_INX(uint16_t src)
{
	uint8_t m = X;
	m = (m + 1) % 256;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    X = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1(%rdi), %al
movb 0x12(%rdi), %cl
incb %al
js 0x4fe0
andb $0x7f, %cl
testb %al, %al
jne 0x4fe3
orb $0x2, %cl
jmp 0x4fe6
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x1(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_INY(unsigned short)
void mos6502::Op_INY(uint16_t src)
{
	uint8_t m = Y;
	m = (m + 1) % 256;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    Y = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x2(%rdi), %al
movb 0x12(%rdi), %cl
incb %al
js 0x5008
andb $0x7f, %cl
testb %al, %al
jne 0x500b
orb $0x2, %cl
jmp 0x500e
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x2(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_LDA(unsigned short)
void mos6502::Op_LDA(uint16_t src)
{
	uint8_t m = Read(src);
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	A = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
movb 0x12(%rbx), %cl
testb %al, %al
js 0x5135
andb $0x7f, %cl
testb %al, %al
jne 0x5138
orb $0x2, %cl
jmp 0x513b
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_LDX(unsigned short)
void mos6502::Op_LDX(uint16_t src)
{
	uint8_t m = Read(src);
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	X = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
movb 0x12(%rbx), %cl
testb %al, %al
js 0x516b
andb $0x7f, %cl
testb %al, %al
jne 0x516e
orb $0x2, %cl
jmp 0x5171
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
movb %al, 0x1(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_LDY(unsigned short)
void mos6502::Op_LDY(uint16_t src)
{
	uint8_t m = Read(src);
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	Y = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
movb 0x12(%rbx), %cl
testb %al, %al
js 0x51c7
andb $0x7f, %cl
testb %al, %al
jne 0x51ca
orb $0x2, %cl
jmp 0x51cd
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
movb %al, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_ORA(unsigned short)
void mos6502::Op_ORA(uint16_t src)
{
	uint8_t m = Read(src);
	m = A | m;
	SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
    A = m;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %esi, %esi
callq 0x2d74
orb (%rbx), %al
movb 0x12(%rbx), %cl
js 0x5275
andb $0x7f, %cl
testb %al, %al
jne 0x5278
orb $0x2, %cl
jmp 0x527b
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
movb %al, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_PLA(unsigned short)
void mos6502::Op_PLA(uint16_t src)
{
	A = StackPop();
	SET_NEGATIVE(A & 0x80);
    SET_ZERO(!A);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rcx
xorl %esi, %esi
cmpq $0xff, %rax
cmovneq %rcx, %rsi
movq %rsi, 0x8(%rdi)
addq $0x100, %rsi            # imm = 0x100
callq 0x2d74
movb %al, (%rbx)
movb 0x12(%rbx), %cl
testb %al, %al
js 0x533c
andb $0x7f, %cl
testb %al, %al
jne 0x533f
orb $0x2, %cl
jmp 0x5342
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_RTI(unsigned short)
void mos6502::Op_RTI(uint16_t src)
{
	uint8_t lo, hi;
	
	status = StackPop();
	
	lo = StackPop();
	hi = StackPop();
	
	pc = (hi << 8) | lo;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rsi
xorl %r15d, %r15d
movl $0xff, %r12d
cmpq %r12, %rax
cmoveq %r15, %rsi
movq %rsi, 0x8(%rdi)
movl $0x100, %r13d           # imm = 0x100
addq %r13, %rsi
callq 0x2d74
movb %al, 0x12(%rbx)
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %r12, %rax
cmoveq %r15, %rsi
movq %rsi, 0x8(%rbx)
addq %r13, %rsi
movq %rbx, %rdi
callq 0x2d74
movl %eax, %r14d
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %r12, %rax
cmoveq %r15, %rsi
movq %rsi, 0x8(%rbx)
addq %r13, %rsi
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
orl %eax, %ecx
movw %cx, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_RTS(unsigned short)
void mos6502::Op_RTS(uint16_t src)
{
	uint8_t lo, hi;
	
	lo = StackPop();
	hi = StackPop();
	
	pc = ((hi << 8) | lo) + 1;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
leaq 0x1(%rax), %rsi
xorl %r15d, %r15d
movl $0xff, %r12d
cmpq %r12, %rax
cmoveq %r15, %rsi
movq %rsi, 0x8(%rdi)
movl $0x100, %r13d           # imm = 0x100
addq %r13, %rsi
callq 0x2d74
movl %eax, %r14d
movq 0x8(%rbx), %rax
leaq 0x1(%rax), %rsi
cmpq %r12, %rax
cmoveq %r15, %rsi
movq %rsi, 0x8(%rbx)
addq %r13, %rsi
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
shll $0x8, %eax
movzbl %r14b, %ecx
addl %ecx, %eax
incl %eax
movw %ax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TAX(unsigned short)
void mos6502::Op_TAX(uint16_t src)
{
	uint8_t m = A;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	X = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x56cb
andb $0x7f, %cl
testb %al, %al
jne 0x56ce
orb $0x2, %cl
jmp 0x56d1
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x1(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TAY(unsigned short)
void mos6502::Op_TAY(uint16_t src)
{
	uint8_t m = A;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	Y = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x56f3
andb $0x7f, %cl
testb %al, %al
jne 0x56f6
orb $0x2, %cl
jmp 0x56f9
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, 0x2(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TXA(unsigned short)
void mos6502::Op_TXA(uint16_t src)
{
	uint8_t m = X;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	A = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x1(%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x5742
andb $0x7f, %cl
testb %al, %al
jne 0x5745
orb $0x2, %cl
jmp 0x5748
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Op_TYA(unsigned short)
void mos6502::Op_TYA(uint16_t src)
{
	uint8_t m = Y;
    SET_NEGATIVE(m & 0x80);
    SET_ZERO(!m);
	A = m;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb 0x2(%rdi), %al
movb 0x12(%rdi), %cl
testb %al, %al
js 0x5778
andb $0x7f, %cl
testb %al, %al
jne 0x577b
orb $0x2, %cl
jmp 0x577e
orb $-0x80, %cl
andb $-0x3, %cl
movb %cl, 0x12(%rdi)
movb %al, (%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Reset()
void mos6502::Reset()
{
	A = 0x00;
	Y = 0x00;
	X = 0x00;
	
	pc = (Read(rstVectorH) << 8) + Read(rstVectorL); // load PC from reset vector
		
    sp = 0xFD;
    
    status |= CONSTANT;
    
	cycles = 6; // according to the datasheet, the reset routine takes 6 clock cycles

	illegalOpcode = false;
	
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movw $0x0, (%rdi)
xorl %r14d, %r14d
movb %r14b, 0x2(%rdi)
movl $0xfffd, %esi           # imm = 0xFFFD
callq 0x2d74
movzbl %al, %r15d
shll $0x8, %r15d
movl $0xfffc, %esi           # imm = 0xFFFC
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
orl %r15d, %eax
movw %ax, 0x10(%rbx)
movq $0xfd, 0x8(%rbx)
orb $0x20, 0x12(%rbx)
movl $0x6, 0x14(%rbx)
movb %r14b, 0x2018(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::IRQ()
void mos6502::IRQ()
{
	if(!IF_INTERRUPT())
	{
		SET_BREAK(0);
		StackPush((pc >> 8) & 0xFF);
		StackPush(pc & 0xFF);
		StackPush(status);
		SET_INTERRUPT(1);
		pc = (Read(irqVectorH) << 8) + Read(irqVectorL);
	}
	return;
}

// Assembly:
movb 0x12(%rdi), %al
testb $0x4, %al
jne 0x58af
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andb $-0x15, %al
movb %al, 0x12(%rdi)
movzbl 0x11(%rdi), %edx
movl $0x100, %r14d           # imm = 0x100
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x339c
movq 0x8(%rbx), %rsi
subq $0x1, %rsi
movl $0xff, %r15d
cmovbq %r15, %rsi
movq %rsi, 0x8(%rbx)
movzbl 0x10(%rbx), %edx
addq %r14, %rsi
movq %rbx, %rdi
callq 0x339c
movq 0x8(%rbx), %rsi
subq $0x1, %rsi
cmovbq %r15, %rsi
movq %rsi, 0x8(%rbx)
movzbl 0x12(%rbx), %edx
addq %r14, %rsi
movq %rbx, %rdi
callq 0x339c
movq 0x8(%rbx), %rax
subq $0x1, %rax
cmovbq %r15, %rax
movq %rax, 0x8(%rbx)
orb $0x4, 0x12(%rbx)
movl $0xffff, %esi           # imm = 0xFFFF
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %r14d
shll $0x8, %r14d
movl $0xfffe, %esi           # imm = 0xFFFE
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
orl %r14d, %eax
movw %ax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::NMI()
void mos6502::NMI()
{
	SET_BREAK(0);
	StackPush((pc >> 8) & 0xFF);
	StackPush(pc & 0xFF);
	StackPush(status);
	SET_INTERRUPT(1);
	pc = (Read(nmiVectorH) << 8) + Read(nmiVectorL);
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
andb $-0x11, 0x12(%rdi)
movzbl 0x11(%rdi), %edx
movl $0x100, %r14d           # imm = 0x100
movq 0x8(%rdi), %rsi
addq %r14, %rsi
callq 0x339c
movq 0x8(%rbx), %rsi
subq $0x1, %rsi
movl $0xff, %r15d
cmovbq %r15, %rsi
movq %rsi, 0x8(%rbx)
movzbl 0x10(%rbx), %edx
addq %r14, %rsi
movq %rbx, %rdi
callq 0x339c
movq 0x8(%rbx), %rsi
subq $0x1, %rsi
cmovbq %r15, %rsi
movq %rsi, 0x8(%rbx)
movzbl 0x12(%rbx), %edx
addq %r14, %rsi
movq %rbx, %rdi
callq 0x339c
movq 0x8(%rbx), %rax
subq $0x1, %rax
cmovbq %r15, %rax
movq %rax, 0x8(%rbx)
orb $0x4, 0x12(%rbx)
movl $0xfffb, %esi           # imm = 0xFFFB
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %r14d
shll $0x8, %r14d
movl $0xfffa, %esi           # imm = 0xFFFA
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %eax
orl %r14d, %eax
movw %ax, 0x10(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/Escapingbug[P]mos6502-emulator-debugging/mos6502.cpp
// Function: mos6502::Run(unsigned int)
void mos6502::Run(uint32_t n)
{
	uint32_t start = cycles;
	uint8_t opcode;
	Instr instr;

	//while(start + n > cycles && !illegalOpcode)
	while(start + 1000000 > cycles && !illegalOpcode)
	{

		// fetch
		if (!DebuggingFirst) {
		  DebugCommandline(pc);
		  DebuggingFirst = true;
		}

		DebugPC = pc;

		for (auto bp : bps) {
		  if (bp == DebugPC) {
			DebugCommandline(DebugPC);
		  }
		}


		opcode = Read(pc++);
		
		// decode
		instr = InstrTable[opcode];
		
		// execute
		Exec(instr);
		
		cycles++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x14(%rdi), %r15d
subl $0xfff0bdc0, %r15d      # imm = 0xFFF0BDC0
jae 0x5a5f
movq %rdi, %rbx
leaq 0x18(%rdi), %r12
cmpb $0x0, 0x2018(%rbx)
jne 0x5a5f
cmpb $0x0, 0x2032(%rbx)
jne 0x59b5
movzwl 0x10(%rbx), %esi
movq %rbx, %rdi
callq 0x265c
movb $0x1, 0x2032(%rbx)
movzwl 0x10(%rbx), %eax
movw %ax, 0x2030(%rbx)
movq 0x2038(%rbx), %r14
movq 0x2040(%rbx), %r13
cmpq %r13, %r14
je 0x59f8
movzwl (%r14), %eax
cmpw 0x2030(%rbx), %ax
jne 0x59eb
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x265c
addq $0x2, %r14
cmpq %r13, %r14
jne 0x59d3
movzwl 0x10(%rbx), %eax
leal 0x1(%rax), %ecx
movw %cx, 0x10(%rbx)
movzwl %ax, %esi
movq %rbx, %rdi
callq 0x2d74
movzbl %al, %ecx
shll $0x5, %ecx
movq (%r12,%rcx), %rax
movq 0x10(%r12,%rcx), %r13
movq 0x18(%r12,%rcx), %r14
movq 0x8(%r12,%rcx), %rdi
addq %rbx, %rdi
testb $0x1, %al
je 0x5a32
movq (%rdi), %rcx
movq -0x1(%rcx,%rax), %rax
callq *%rax
addq %rbx, %r14
testb $0x1, %r13b
je 0x5a45
movq (%r14), %rcx
movq -0x1(%rcx,%r13), %r13
movzwl %ax, %esi
movq %r14, %rdi
callq *%r13
movl 0x14(%rbx), %eax
incl %eax
movl %eax, 0x14(%rbx)
cmpl %eax, %r15d
ja 0x598c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::_clear_buff(std::ostream&)
void HuffEncode::_clear_buff(std::ostream &out) {
    if (_buff_fill) {
        out.write(reinterpret_cast<char*>(&_buff), sizeof(int8_t));
        _encoded_data_size++;
        _buff_fill = 0;
        _buff = 0;
    }
}

// Assembly:
cmpq $0x0, 0x50(%rdi)
je 0x2d8c
pushq %rbx
movq %rdi, %rbx
leaq 0x58(%rdi), %rax
movl $0x1, %edx
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2200
incq 0x48(%rbx)
movq $0x0, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::HuffEncode(std::istream&)
HuffEncode::HuffEncode(std::istream &in) {
    in.seekg(0, std::ios::end);
    _data.reserve(in.tellg());
    in.seekg(0, std::ios::beg);
    _data.assign((std::istreambuf_iterator<char>(in)), std::istreambuf_iterator<char>());

    std::vector<std::size_t> frequencies(256, 0);
    for (unsigned char c : _data)
        frequencies[c]++;
    _tree = std::make_shared<HuffTree>(frequencies);
    _codes = _tree->get_codes();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x30(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x49(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x2210
movq %r15, %rdi
callq 0x22c0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x2270
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2210
movq (%r15), %rax
movq -0x18(%rax), %rax
movq 0xe8(%r15,%rax), %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq $0x0, 0x18(%rsp)
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x4ade
movl $0x800, %edi            # imm = 0x800
callq 0x21b0
movq %rax, %r15
movq %rax, 0x18(%rsp)
movq %rax, %r13
addq $0x800, %r13            # imm = 0x800
movq %r13, 0x28(%rsp)
movl $0x800, %edx            # imm = 0x800
movq %rax, %rdi
xorl %esi, %esi
callq 0x20f0
movq %r13, 0x20(%rsp)
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0x2e8d
movq (%rbx), %rcx
xorl %edx, %edx
movzbl (%rcx,%rdx), %esi
incq (%r15,%rsi,8)
incq %rdx
cmpq %rdx, %rax
jne 0x2e7d
leaq 0x38(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x30(%rsp), %rsi
leaq 0x17(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x4f0e
leaq 0x20(%rbx), %r15
movaps 0x30(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x30(%rsp)
movq 0x28(%rbx), %rdi
movups %xmm0, 0x20(%rbx)
testq %rdi, %rdi
je 0x2ee0
callq 0x3c2e
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x2ee0
callq 0x3c2e
movq (%r15), %rsi
addq $0x38, %rsi
movq %r14, %rdi
callq 0x3a7a
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2f06
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x2f16
movq %rax, %r15
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x2f39
movq 0x28(%rsp), %rsi
subq %rdi, %rsi
callq 0x21c0
jmp 0x2f39
jmp 0x2f36
jmp 0x2f36
movq %rax, %r15
movq %r14, %rdi
callq 0x392a
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2f4f
callq 0x3c2e
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x2f63
movq (%r12), %rsi
incq %rsi
callq 0x21c0
movq %r15, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/ivanoleinik[P]archiver/src/huffman.cpp
// Function: HuffEncode::write(std::ostream&)
void HuffEncode::write(std::ostream &out) {
    for (size_t freq : _tree->get_frequencies())
        out.write(reinterpret_cast<char*>(&freq), sizeof(size_t));

    for (unsigned char c : _data) {
        for (bool bit : _codes[c]) {
            _serialize(out, bit);
        }
    }
    _clear_buff(out);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x20(%rdi), %rax
movq (%rax), %r12
movq 0x8(%rax), %r13
cmpq %r13, %r12
je 0x2fb7
leaq 0x10(%rsp), %r15
movq (%r12), %rax
movq %rax, 0x10(%rsp)
movl $0x8, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2200
addq $0x8, %r12
cmpq %r13, %r12
jne 0x2f95
movq 0x8(%rbx), %rax
movq %rax, (%rsp)
testq %rax, %rax
je 0x304f
movq (%rbx), %rax
addq %rax, (%rsp)
movq %rax, 0x8(%rsp)
movzbl (%rax), %eax
movq 0x30(%rbx), %rcx
leaq (%rax,%rax,4), %rax
movq (%rcx,%rax,8), %r13
movq 0x10(%rcx,%rax,8), %r15
movl 0x18(%rcx,%rax,8), %r12d
cmpq %r15, %r13
setne %al
testl %r12d, %r12d
setne %cl
orb %al, %cl
cmpb $0x1, %cl
jne 0x3041
xorl %ebp, %ebp
movq (%r13), %rax
xorl %edx, %edx
btq %rbp, %rax
setb %dl
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2d1c
xorl %edx, %edx
xorl %eax, %eax
cmpl $0x3f, %ebp
leal 0x1(%rbp), %ecx
sete %al
leaq (%r13,%rax,8), %r13
cmovel %edx, %ecx
cmpq %r15, %r13
setne %al
cmpl %r12d, %ecx
setne %dl
orb %al, %dl
movl %ecx, %ebp
jne 0x3002
movq 0x8(%rsp), %rax
incq %rax
cmpq (%rsp), %rax
jne 0x2fcf
cmpq $0x0, 0x50(%rbx)
je 0x3077
leaq 0x58(%rbx), %rsi
movl $0x1, %edx
movq %r14, %rdi
callq 0x2200
incq 0x48(%rbx)
movq $0x0, 0x50(%rbx)
movb $0x0, 0x58(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/ruankotovich[P]B-Tree/src/findrec.cpp
// Function: main
int main(int argc, char* argv[])
{
  FILE* blockFile = fopen("files/data.block", "rb+");
  if (blockFile != NULL) {

    fseek(blockFile, sizeof(Block_t), SEEK_END);
    int numberOfArticles = ftell(blockFile) / sizeof(Block_t) - 1;
    rewind(blockFile);
    
    
    int id;

    if(argc > 1){
      id = atoi(argv[1]);
    }else{
      std::cin >> id;
    }

    Article_t article;

    if (getArticleFromHash(id, &article, blockFile)) { // recover an article from the hash
      std::cout << article.toString();
      std::cout << "\n\n> Number of records: " << numberOfArticles << "\n" << "> Number of blocks read: 1 \n"; // since it's a perfect hash
    } else {
      std::cout << "Record not found\n";
    }

  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x978, %rsp            # imm = 0x978
movq %rsi, %r15
movl %edi, %ebp
leaq 0x5d0(%rip), %rdi       # 0x2021
leaq 0x5da(%rip), %rsi       # 0x2032
callq 0x10f0
testq %rax, %rax
je 0x1b82
movq %rax, %r14
movl $0x1000, %esi           # imm = 0x1000
movq %rax, %rdi
movl $0x2, %edx
callq 0x10d0
movq %r14, %rdi
callq 0x1030
movq %rax, %rbx
movq %r14, %rdi
callq 0x1040
cmpl $0x2, %ebp
jl 0x1aa2
movq 0x8(%r15), %rdi
callq 0x1120
movl %eax, 0x4(%rsp)
jmp 0x1ab3
movq 0x2537(%rip), %rdi      # 0x3fe0
leaq 0x4(%rsp), %rsi
callq 0x1070
leaq 0x2c(%rsp), %r15
movq %r15, %rdi
callq 0x1bb8
movl 0x4(%rsp), %edi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1f50
testb %al, %al
je 0x1b6a
leaq 0x8(%rsp), %r14
leaq 0x2c(%rsp), %rsi
movq %r14, %rdi
callq 0x1c44
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq 0x24d9(%rip), %rdi      # 0x3fd0
callq 0x10e0
shrq $0xc, %rbx
decl %ebx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1b1d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10c0
movq 0x24ac(%rip), %r14      # 0x3fd0
leaq 0x50b(%rip), %rsi       # 0x2036
movl $0x17, %edx
movq %r14, %rdi
callq 0x10e0
movq %r14, %rdi
movl %ebx, %esi
callq 0x1150
movq %rax, %rbx
leaq 0x539(%rip), %rsi       # 0x2085
movl $0x1, %edx
movq %rax, %rdi
callq 0x10e0
leaq 0x4ee(%rip), %rsi       # 0x204e
movl $0x1c, %edx
movq %rbx, %rdi
jmp 0x1b7d
movq 0x245f(%rip), %rdi      # 0x3fd0
leaq 0x4f3(%rip), %rsi       # 0x206b
movl $0x11, %edx
callq 0x10e0
xorl %eax, %eax
addq $0x978, %rsp            # imm = 0x978
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1bb0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10c0
movq %rbx, %rdi
callq 0x1160