LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode) {
	std::string tmp;
	tmp = label;

	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0x20f0
cmpq $0x0, 0x8(%rbx)
je 0x5823
movq %rsp, %rdi
pushq $0x14
popq %rsi
callq 0x56b4
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2380
movq %rsp, %rdi
pushq $0xa
popq %rsi
callq 0x2190
movq %rsp, %rbx
movq (%rbx), %rdi
movq 0xc78d(%rip), %rax      # 0x11fc8
movq (%rax), %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand) {

	std::string tmp;
	tmp = label;


	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	if (!operand.empty()) {
		indent_to(tmp, kOperandTab);
		tmp += operand;
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %rsi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x20f0
cmpq $0x0, 0x8(%r14)
je 0x58b0
leaq 0x8(%rsp), %rdi
pushq $0x14
popq %rsi
callq 0x56b4
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2380
cmpq $0x0, 0x8(%rbx)
je 0x58d1
leaq 0x8(%rsp), %rdi
pushq $0x1e
popq %rsi
callq 0x56b4
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x2380
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x2190
leaq 0x8(%rsp), %rbx
movq (%rbx), %rdi
movq 0xc6db(%rip), %rax      # 0x11fc8
movq (%rax), %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x20d0
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::emit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::emit(const std::string &label, const std::string &opcode, const std::string &operand, const std::string &comment) {

	std::string tmp;
	tmp = label;

	if (!opcode.empty()) {
		indent_to(tmp, kOpcodeTab);
		tmp += opcode;
	}

	if (!operand.empty()) {
		indent_to(tmp, kOperandTab);
		tmp += operand;
	}

	if (!comment.empty()) {
		indent_to(tmp, kCommentTab);
		tmp += "; ";
		tmp += comment;	
	}

	tmp.push_back('\n');
	fputs(tmp.c_str(), stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq %rsp, %rdi
callq 0x20f0
cmpq $0x0, 0x8(%r15)
je 0x5965
movq %rsp, %rdi
pushq $0x14
popq %rsi
callq 0x56b4
movq %rsp, %rdi
movq %r15, %rsi
callq 0x2380
cmpq $0x0, 0x8(%r14)
je 0x5982
movq %rsp, %rdi
pushq $0x1e
popq %rsi
callq 0x56b4
movq %rsp, %rdi
movq %r14, %rsi
callq 0x2380
cmpq $0x0, 0x8(%rbx)
je 0x59ae
movq %rsp, %rdi
pushq $0x50
popq %rsi
callq 0x56b4
leaq 0x633e(%rip), %rsi      # 0xbcd9
movq %rsp, %rdi
callq 0x2360
movq %rsp, %rdi
movq %rbx, %rsi
callq 0x2380
movq %rsp, %rdi
pushq $0xa
popq %rsi
callq 0x2190
movq %rsp, %rbx
movq (%rbx), %rdi
movq 0xc602(%rip), %rax      # 0x11fc8
movq (%rax), %rsi
callq 0x21f0
movq %rbx, %rdi
callq 0x20d0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::format_data[abi:cxx11](unsigned int, unsigned char const*)
std::pair<std::string, std::string> 
disassembler::format_data(unsigned size, const uint8_t *data) {

	std::string tmp;

	for (unsigned i = 0; i < size; ++i) {
		if (i > 0) tmp += ", ";
		tmp += to_x(data[i], 2, '$');
	}

	return std::make_pair("db", tmp);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdi, 0x8(%rsp)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl %edx, %ebx
xorl %ebp, %ebp
leaq 0x30(%rsp), %r15
pushq $0x24
popq %r12
leaq 0x10(%rsp), %r13
cmpq %rbp, %rbx
je 0x5a7b
testq %rbp, %rbp
je 0x5a50
movq %r13, %rdi
leaq 0x5823(%rip), %rsi      # 0xb26e
callq 0x2360
movzbl (%r14,%rbp), %esi
movq %r15, %rdi
pushq $0x2
popq %rdx
movl %r12d, %ecx
callq 0x56d0
movq %r13, %rdi
movq %r15, %rsi
callq 0x2380
movq %r15, %rdi
callq 0x20d0
incq %rbp
jmp 0x5a37
leaq 0x625a(%rip), %rax      # 0xbcdc
leaq 0x38(%rsp), %r14
movq %rax, -0x8(%r14)
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x2260
leaq 0x30(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x6cce
movq %r14, %rdi
callq 0x20d0
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r14, %rdi
jmp 0x5ae7
jmp 0x5ada
jmp 0x5ada
movq %rax, %rbx
jmp 0x5aec
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20d0
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::format_data(unsigned int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::pair<std::string, std::string> 
disassembler::format_data(unsigned size, const std::string &data) {

	switch(size) {
		case 1: return std::make_pair("db", data);
		case 2: return std::make_pair("dw", data);
		case 3: return std::make_pair("da", data);
		case 4: return std::make_pair("dl", data);

		default: { 
			std::string tmp;
			tmp = std::to_string(size) + " bytes";
			return std::make_pair(tmp, data);

		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdi, %rbx
leal -0x1(%rdx), %eax
cmpl $0x3, %eax
ja 0x5be0
leaq 0x5a0e(%rip), %rcx      # 0xb530
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x61aa(%rip), %rax      # 0xbcdc
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2260
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6cce
jmp 0x5bc9
leaq 0x6188(%rip), %rax      # 0xbce2
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2260
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6cce
jmp 0x5bc9
leaq 0x6163(%rip), %rax      # 0xbce5
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2260
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6cce
jmp 0x5bc9
leaq 0x6135(%rip), %rax      # 0xbcdf
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x2260
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6cce
movq %r15, %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x28(%rsp), %rdi
movl %edx, %esi
callq 0x4b15
leaq 0x60e4(%rip), %rdx      # 0xbce8
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x49b4
movq %rsp, %r15
leaq 0x48(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq %r12, %rdi
callq 0x20d0
leaq 0x28(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x6d62
movq %rsp, %rdi
jmp 0x5bcc
jmp 0x5c5c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
jmp 0x5c5f
movq %rax, %rbx
movq %rsp, %rdi
jmp 0x5c70
jmp 0x5c6a
jmp 0x5c6a
jmp 0x5c6a
movq %rax, %rbx
movq %r15, %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::hexdump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void disassembler::hexdump(std::string &line) {
	// print pc and hexdump...

	indent_to(line, kCommentTab);
	line += "; ";

	line += to_x(_pc, 4);
	line.push_back(':');

	int i;
	for (i = 0; i < _st; ++i) {
		line.push_back(' ');
		line += to_x(_bytes[i], 2);
	}
	for ( ; i < 4; ++i) {
		line += "   ";
	}
	line += "  ";
	for (i = 0; i < _st; ++i) {
		uint8_t c = _bytes[i];
		// msb flag?
		if (_traits & msb_hexdump) c &= 0x7f;
		if (isprint(c) && isascii(c)) line += c;
		else line += '.';
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $0x50
popq %rsi
movq %rbx, %rdi
callq 0x56b4
leaq 0x5f5d(%rip), %rsi      # 0xbcd9
movq %rbx, %rdi
callq 0x2360
movl 0x20(%r14), %esi
leaq 0x8(%rsp), %r15
pushq $0x4
popq %rdx
movq %r15, %rdi
xorl %ecx, %ecx
callq 0x56d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2380
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x20d0
pushq $0x3a
popq %rsi
movq %rbx, %rdi
callq 0x2190
xorl %r13d, %r13d
pushq $0x20
popq %rbp
pushq $0x2
popq %r12
movl 0x8(%r14), %eax
cmpq %rax, %r13
jae 0x5e05
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2190
movzbl 0x18(%r14,%r13), %esi
movq %r15, %rdi
movl %r12d, %edx
xorl %ecx, %ecx
callq 0x56d0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2380
movq %r15, %rdi
callq 0x20d0
incq %r13
jmp 0x5dc7
leaq 0x5efa(%rip), %r15      # 0xbd06
cmpl $0x3, %r13d
ja 0x5e22
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2360
incl %r13d
jmp 0x5e0c
leaq 0x5ede(%rip), %rsi      # 0xbd07
movq %rbx, %rdi
callq 0x2360
xorl %r15d, %r15d
pushq $0x2e
popq %r12
movl 0x8(%r14), %eax
cmpq %rax, %r15
jae 0x5e84
movzbl 0x18(%r14,%r15), %eax
movl %eax, %ecx
andb $0x7f, %cl
testb $0x8, 0x34(%r14)
movzbl %cl, %r13d
cmovel %eax, %r13d
movzbl %r13b, %ebp
movl %ebp, %edi
callq 0x2310
testb %bpl, %bpl
jns 0x5e6c
movl %r12d, %r13d
testl %eax, %eax
jne 0x5e73
movl %r12d, %r13d
movsbl %r13b, %esi
movq %rbx, %rdi
callq 0x2190
incq %r15
jmp 0x5e38
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5e95
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
void disassembler::dump(const std::string &expr, unsigned size, uint32_t value) {

	std::string line;

	if (_st) dump();

	for (_st = 0; _st < size; ++_st) {
		_bytes[_st] = value & 0xff;
		value >>= 8;
	}

	auto p = format_data(size, expr);

	indent_to(line, kOpcodeTab);
	line += p.first;
	indent_to(line, kOperandTab);
	line += p.second;

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _st;
	reset();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
cmpl $0x0, 0x8(%rdi)
je 0x5ede
movq %rbx, %rdi
callq 0x5c7e
movl %ebp, %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x5ef5
movb %r15b, 0x18(%rbx,%rcx)
shrl $0x8, %r15d
incq %rcx
jmp 0x5ee2
movl %ebp, 0x8(%rbx)
movq (%rbx), %rax
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq *0x18(%rax)
leaq 0x8(%rsp), %rdi
pushq $0x14
popq %rsi
callq 0x56b4
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2380
leaq 0x8(%rsp), %rdi
pushq $0x1e
popq %rsi
callq 0x56b4
leaq 0x48(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x2380
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5d56
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x2190
leaq 0x8(%rsp), %r14
movq (%r14), %rdi
movq 0xc05c(%rip), %rax      # 0x11fc8
movq (%rax), %rsi
callq 0x21f0
movl 0x8(%rbx), %eax
addl %eax, 0x20(%rbx)
andl $0x0, 0x24(%rbx)
andl $0x0, 0x8(%rbx)
leaq 0x28(%rsp), %rdi
callq 0x6d00
movq %r14, %rdi
callq 0x20d0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5fa1
movq %rax, %rbx
jmp 0x5fb3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x6d00
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::space(unsigned int)
void disassembler::space(unsigned size) {
	flush();

	std::string line;

	indent_to(line, kOpcodeTab);
	line += ds();
	indent_to(line, kOperandTab);


	while (size) {
		uint32_t chunk;
		if (_next_label == -1) chunk = size;
		else {
			chunk = _next_label - _pc;
			chunk = std::min(chunk, size);
		}

		line.resize(kOperandTab);
		line += std::to_string(chunk);
		indent_to(line, kCommentTab);
		line += "; ";

		line += to_x(_pc, 4);
		line.push_back(':');
		line.push_back('\n');
		fputs(line.c_str(), stdout);	


		_pc += chunk;
		size -= chunk;
		if (_next_label == _pc) _next_label = next_label(_pc);
	}


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movl %esi, %ebx
movq %rdi, %r14
callq 0x5fc6
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
pushq $0x14
popq %rsi
callq 0x56b4
movq (%r14), %rax
leaq 0x28(%rsp), %rdi
movq %r14, %rsi
callq *0x30(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2380
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
pushq $0x1e
popq %rsi
callq 0x56b4
leaq 0x8(%rsp), %r15
leaq 0x28(%rsp), %r13
pushq $0xa
popq %rbp
testl %ebx, %ebx
je 0x616a
movl 0x30(%r14), %eax
movl %eax, %r12d
subl 0x20(%r14), %r12d
cmpl %r12d, %ebx
cmovbl %ebx, %r12d
cmpl $-0x1, %eax
cmovel %ebx, %r12d
movq %r15, %rdi
pushq $0x1e
popq %rsi
callq 0x2270
movq %r13, %rdi
movl %r12d, %esi
callq 0x4b15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2380
movq %r13, %rdi
callq 0x20d0
movq %r15, %rdi
pushq $0x50
popq %rsi
callq 0x56b4
movq %r15, %rdi
leaq 0x5beb(%rip), %rsi      # 0xbcd9
callq 0x2360
movl 0x20(%r14), %esi
movq %r13, %rdi
pushq $0x4
popq %rdx
xorl %ecx, %ecx
callq 0x56d0
movq %r15, %rdi
movq %r13, %rsi
callq 0x2380
movq %r13, %rdi
callq 0x20d0
movq %r15, %rdi
pushq $0x3a
popq %rsi
callq 0x2190
movq %r15, %rdi
movl %ebp, %esi
callq 0x2190
movq 0x8(%rsp), %rdi
movq 0xbe90(%rip), %rax      # 0x11fc8
movq (%rax), %rsi
callq 0x21f0
subl %r12d, %ebx
addl 0x20(%r14), %r12d
movl %r12d, 0x20(%r14)
cmpl %r12d, 0x30(%r14)
jne 0x608f
movq (%r14), %rax
movq %r14, %rdi
movl %r12d, %esi
callq *0x38(%rax)
movl %eax, 0x30(%r14)
jmp 0x608f
leaq 0x8(%rsp), %rdi
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x618f
jmp 0x619e
jmp 0x619e
jmp 0x619e
jmp 0x618f
jmp 0x619e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
jmp 0x61a1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::operator()(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, unsigned int, unsigned int)
void disassembler::operator()(const std::string &expr, unsigned size, uint32_t value) {

	if (_st == 0 || !_code)
		check_labels();

	if (!_code) {
		dump(expr, size, value);
		if (_inline_data) {
			_inline_data -= size;
			if (_inline_data <= 0) _code = true; 
		}
		return;
	}

	if (_st != 1 || size != _size) {
		dump(expr, size, value);
		return;
	}
	for (int i = 0; i < size; ++i) {
		_bytes[_st++] = value & 0xff;
		value >>= 8;
	}
	print(expr);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x61d3
movb 0x28(%rbx), %al
testb %al, %al
jne 0x61de
movq %rbx, %rdi
callq 0x5fe2
movb 0x28(%rbx), %al
testb $0x1, %al
je 0x620e
cmpl $0x1, 0x8(%rbx)
jne 0x623e
cmpl %r14d, 0x10(%rbx)
jne 0x623e
negl %r14d
pushq $0x1
popq %rax
leal (%r14,%rax), %ecx
cmpl $0x1, %ecx
je 0x6258
movl %eax, %ecx
incl %eax
movl %eax, 0x8(%rbx)
movb %bpl, 0x18(%rbx,%rcx)
shrl $0x8, %ebp
jmp 0x61f4
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
callq 0x5eaa
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0x6233
subl %r14d, %eax
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jg 0x6233
movb $0x1, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
movl %ebp, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x5eaa
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x626e
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::print(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void disassembler::print(const std::string &expr) {


	std::string line;

	indent_to(line, kOpcodeTab);
	line.append(&opcodes[_op * 3], 3);

	if (_size) {

		indent_to(line, kOperandTab);
		line += prefix();
		line += expr;
		line += suffix();
	}

	hexdump(line);
	line.push_back('\n');
	fputs(line.c_str(), stdout);

	_pc += _size + 1;
	reset();	
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x8(%rsp), %rdi
pushq $0x14
popq %rsi
callq 0x56b4
movzbl 0xc(%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq 0x56f8(%rip), %rsi      # 0xb9a0
addq %rax, %rsi
leaq 0x8(%rsp), %rdi
pushq $0x3
popq %rdx
callq 0x2050
cmpl $0x0, 0x10(%rbx)
je 0x6324
leaq 0x8(%rsp), %rdi
pushq $0x1e
popq %rsi
callq 0x56b4
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x6950
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2380
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x2380
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x69fe
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2380
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5d56
leaq 0x8(%rsp), %rdi
pushq $0xa
popq %rsi
callq 0x2190
leaq 0x8(%rsp), %r14
movq (%r14), %rdi
movq 0xbc7b(%rip), %rax      # 0x11fc8
movq (%rax), %rsi
callq 0x21f0
movl 0x10(%rbx), %eax
movl 0x20(%rbx), %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x20(%rbx)
andl $0x0, 0x24(%rbx)
andl $0x0, 0x8(%rbx)
movq %r14, %rdi
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x637e
jmp 0x638f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
jmp 0x6392
jmp 0x638f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::prefix[abi:cxx11]()
std::string disassembler::prefix() {

	std::string tmp;

	switch(_mode & 0xf000) {
		case mImmediate: tmp = "#"; break;
		case mDP: tmp = "<"; break;
		case mDPI: tmp = "(<"; break;
		case mDPIL: tmp = "[<"; break;
		case mAbsoluteIL: tmp = "["; break;

		case mRelative:
		case mBlockMove:
			break;

		// cop, brk are treated as absolute.
		case mAbsolute: 
			//if (_size == 1) printf("\t");
			if (_size > 1) tmp = "|";
			break;
		case mAbsoluteLong: tmp = ">"; break;
		case mAbsoluteI: tmp = "("; break;
	}
	return tmp;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl $0xf000, %eax           # imm = 0xF000
andl 0x14(%rsi), %eax
addl $0xfffff000, %eax       # imm = 0xFFFFF000
shrl $0xc, %eax
cmpl $0x7, %eax
ja 0x69e0
leaq 0x4be1(%rip), %rcx      # 0xb564
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x535c(%rip), %rsi      # 0xbcef
jmp 0x69d8
leaq 0x486d(%rip), %rsi      # 0xb209
jmp 0x69d8
leaq 0x5354(%rip), %rsi      # 0xbcf9
jmp 0x69d8
leaq 0x5349(%rip), %rsi      # 0xbcf7
jmp 0x69d8
leaq 0x533d(%rip), %rsi      # 0xbcf4
jmp 0x69d8
cmpl $0x1, 0x10(%rsi)
jbe 0x69e0
leaq 0x484a(%rip), %rsi      # 0xb210
jmp 0x69d8
leaq 0x5323(%rip), %rsi      # 0xbcf2
jmp 0x69d8
leaq 0x5319(%rip), %rsi      # 0xbcf1
movq %rbx, %rdi
callq 0x2370
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: disassembler::suffix[abi:cxx11]()
std::string disassembler::suffix() {

	std::string tmp;

	switch(_mode & 0x0f00) {
		case m_X: tmp = ",x"; break;
		case m_Y: if (!(_mode & (mDPI|mDPIL))) tmp = ",y"; break;
		case m_S:
		case m_S | m_Y:
			tmp = ",s"; break;
	}

	switch(_mode & 0xf000) {
		case mAbsoluteI:
		case mDPI:
			tmp += ")"; break;
		case mAbsoluteIL:
		case mDPIL:
			tmp += "]"; break;
	}

	// (xxx,s),y
	// (xxx),y
	// [xxx],y
	switch(_mode & 0x0f00) {
		case m_Y:
			if (_mode & (mDPI|mDPIL)) tmp += ",y"; break;
		case m_S | m_Y:
			tmp += ",y"; break;
	}	
	return tmp;

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r14
movb $0x0, 0x10(%rdi)
movl 0x14(%rsi), %eax
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
addl $0xffffff00, %ecx       # imm = 0xFFFFFF00
shrl $0x8, %ecx
cmpl $0x4, %ecx
ja 0x6a68
leaq 0x4b4c(%rip), %rdx      # 0xb584
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x52b9(%rip), %rsi      # 0xbd01
jmp 0x6a60
testw $0xf000, %ax            # imm = 0xF000
jne 0x6a68
leaq 0x52a7(%rip), %rsi      # 0xbcfe
jmp 0x6a60
leaq 0x529b(%rip), %rsi      # 0xbcfb
movq %rbx, %rdi
callq 0x2370
movl $0xf000, %eax           # imm = 0xF000
andl 0x14(%r14), %eax
addl $0xffffd000, %eax       # imm = 0xFFFFD000
cmpl $0x5fff, %eax           # imm = 0x5FFF
ja 0x6aa0
shrl $0xc, %eax
pushq $0x33
popq %rcx
btl %eax, %ecx
jae 0x6aa0
movl %eax, %eax
leaq 0x521f(%rip), %rcx      # 0xbcb0
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x2360
movl 0x14(%r14), %eax
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
cmpl $0x500, %ecx            # imm = 0x500
je 0x6ac2
cmpl $0x400, %ecx            # imm = 0x400
jne 0x6ad1
testw $0xf000, %ax            # imm = 0xF000
je 0x6ad1
leaq 0x5235(%rip), %rsi      # 0xbcfe
movq %rbx, %rdi
callq 0x2360
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::finish()
const std::vector<uint32_t> &analyzer::finish() {
	std::sort(_labels.begin(), _labels.end());
	auto end = std::unique(_labels.begin(), _labels.end());
	_labels.erase(end, _labels.end());
	return _labels;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x28(%rdi), %r14
movq 0x28(%rdi), %rdi
movq 0x30(%rbx), %rsi
callq 0x6d98
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x7198
movq 0x30(%rbx), %rdx
movq %r14, %rdi
movq %rax, %rsi
callq 0x6d16
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::operator()(unsigned char)
void analyzer::operator()(uint8_t byte) {


	if (!_code) {

		if (_inline_data && --_inline_data <= 0) {
			_code = true;
			reset();
			return;
		}
		return;
	}

	_st++;
	if (_st == 1) {
		_op = byte;
		_mode = modes[_op];

		_size = _mode & 0x0f;
		if (_mode & _flags & m_I) _size++;
		if (_mode & _flags & m_M) _size++;

		if (!_size) { reset(); }
		return;
	}
	unsigned shift = (_st - 2) * 8;
	_arg = _arg + (byte << shift);
	if (_st <= _size) return;


	// all done... now process it
	process();
}

// Assembly:
cmpb $0x0, 0x8(%rdi)
je 0x6ba0
movl 0xc(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0xc(%rdi)
testl %ecx, %ecx
je 0x6bc5
shll $0x3, %ecx
movzbl %sil, %edx
addb $-0x8, %cl
shll %cl, %edx
addl %edx, 0x20(%rdi)
cmpl 0x14(%rdi), %eax
ja 0x6c10
retq
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x6b9f
leal -0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl $0x1, %eax
jg 0x6b9f
movb $0x1, 0x8(%rdi)
movl 0xc(%rdi), %eax
addl %eax, 0x1c(%rdi)
andl $0x0, 0x20(%rdi)
andl $0x0, 0xc(%rdi)
retq
movb %sil, 0x10(%rdi)
movzbl %sil, %ecx
leaq 0x49cc(%rip), %rdx      # 0xb5a0
movl (%rdx,%rcx,4), %edx
movl %edx, 0x24(%rdi)
movl %edx, %ecx
andl $0xf, %ecx
movl %ecx, 0x14(%rdi)
andl 0x18(%rdi), %edx
testb $0x10, %dl
je 0x6bef
incl %ecx
movl %ecx, 0x14(%rdi)
testb $0x20, %dl
jne 0x6bfa
testl %ecx, %ecx
jne 0x6b9f
jmp 0x6bb9
incl %ecx
movl %ecx, 0x14(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/disassembler.cpp
// Function: analyzer::process()
void analyzer::process() {

	if (_traits & disassembler::track_rep_sep) {
		switch(_op) {
			case 0xc2: // REP
				_flags |= (_arg & 0x30);
				break;
			case 0xe2: // SEP
				_flags &= ~(_arg & 0x30);
				break;
		}
	}

	switch (_mode & 0xf000) {
		case mRelative: {

			uint32_t pc = _pc + 1 + _size + _arg;

			if ((_size == 1) && (_arg & 0x80))
				pc += 0xff00;
			pc &= 0xffff;

			_labels.push_back(pc);
			break;
		}
		case mAbsolute:
		case mAbsoluteI:
		case mAbsoluteLong: {
			_labels.push_back(_arg);
			break;
		}
	}
	reset();
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
testb $0x10, (%rdi)
je 0x6c45
movzbl 0x10(%rbx), %eax
cmpl $0xe2, %eax
je 0x6c3a
cmpl $0xc2, %eax
jne 0x6c45
movl 0x20(%rbx), %eax
andl $0x30, %eax
orl %eax, 0x18(%rbx)
jmp 0x6c45
movl 0x20(%rbx), %eax
notl %eax
orl $-0x31, %eax
andl %eax, 0x18(%rbx)
movl $0xf000, %eax           # imm = 0xF000
andl 0x24(%rbx), %eax
addl $0xffffe000, %eax       # imm = 0xFFFFE000
shrl $0xc, %eax
cmpl $0x2, %eax
jb 0x6c96
cmpl $0x3, %eax
je 0x6c96
cmpl $0x7, %eax
jne 0x6ca3
movl 0x14(%rbx), %eax
movl 0x20(%rbx), %ecx
movl 0x1c(%rbx), %edx
addl %eax, %edx
leal (%rcx,%rdx), %esi
incl %esi
testb %cl, %cl
leal 0xff01(%rcx,%rdx), %ecx
cmovnsl %esi, %ecx
cmpl $0x1, %eax
cmovnel %esi, %ecx
movzwl %cx, %eax
leaq 0xc(%rsp), %rsi
movl %eax, (%rsi)
leaq 0x28(%rbx), %rdi
jmp 0x6c9e
leaq 0x28(%rbx), %rdi
leaq 0x20(%rbx), %rsi
callq 0x6d1c
movl 0xc(%rbx), %eax
addl %eax, 0x1c(%rbx)
andl $0x0, 0x20(%rbx)
andl $0x0, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::print_externs()
void zrdz_disassembler::print_externs() {

	std::vector<std::string> tmp;

	for (auto &s : _symbols) {
		if (s.type == S_UND) tmp.push_back(s.name);
	}

	if (tmp.empty()) return;
	std::sort(tmp.begin(), tmp.end());
	for (const auto &s : tmp) emit("", "extern", s);
	putchar('\n');

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rbx)
movq 0x38(%rdi), %r14
movq 0x40(%rdi), %r15
cmpq %r15, %r14
je 0x79ff
cmpb $0x0, 0x20(%r14)
jne 0x79f9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8f36
addq $0x28, %r14
jmp 0x79e2
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
cmpq %rsi, %rdi
je 0x7a86
callq 0x95c1
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r12
leaq 0x48(%rsp), %r15
leaq 0x4382(%rip), %r13      # 0xbdab
leaq 0x28(%rsp), %rbp
leaq 0xe(%rsp), %r14
cmpq %r12, %rbx
je 0x7a7e
movq %r15, %rdi
leaq 0x395e(%rip), %rsi      # 0xb3a0
leaq 0xf(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x48d4
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x5864
movq %rbp, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x20d0
addq $0x20, %rbx
jmp 0x7a33
pushq $0xa
popq %rdi
callq 0x2280
leaq 0x10(%rsp), %rdi
callq 0x4a68
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7aa3
jmp 0x7aa3
movq %rax, %rbx
jmp 0x7ac4
movq %rax, %rbx
jmp 0x7aba
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %rdi
callq 0x20d0
leaq 0x10(%rsp), %rdi
callq 0x4a68
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::print_globals(int)
void zrdz_disassembler::print_globals(int section) {

	std::vector<std::string> tmp;

	for (auto &s : _symbols) {
		if (s.section == section && s.flags & SF_GBL) tmp.push_back(s.name);
	}

	if (tmp.empty()) return;
	std::sort(tmp.begin(), tmp.end());
	for (const auto &s : tmp) emit("", "public", s);
	putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x38(%rdi), %r15
movq 0x40(%rdi), %r12
cmpq %r12, %r15
je 0x7f27
movzbl 0x22(%r15), %eax
cmpl %ebx, %eax
jne 0x7f21
testb $0x1, 0x21(%r15)
je 0x7f21
movq %r14, %rdi
movq %r15, %rsi
callq 0x8f36
addq $0x28, %r15
jmp 0x7f01
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
cmpq %rsi, %rdi
je 0x7fae
callq 0x95c1
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r12
leaq 0x48(%rsp), %r15
leaq 0x3e61(%rip), %r13      # 0xbdb2
leaq 0x28(%rsp), %rbp
leaq 0xe(%rsp), %r14
cmpq %r12, %rbx
je 0x7fa6
movq %r15, %rdi
leaq 0x3436(%rip), %rsi      # 0xb3a0
leaq 0xf(%rsp), %rdx
callq 0x48d4
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x48d4
movq %r15, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x5864
movq %rbp, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x20d0
addq $0x20, %rbx
jmp 0x7f5b
pushq $0xa
popq %rdi
callq 0x2280
leaq 0x10(%rsp), %rdi
callq 0x4a68
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7fcb
jmp 0x7fcb
movq %rax, %rbx
jmp 0x7fec
movq %rax, %rbx
jmp 0x7fe2
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %rdi
callq 0x20d0
leaq 0x10(%rsp), %rdi
callq 0x4a68
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::print_equs(int)
void zrdz_disassembler::print_equs(int section) {

	std::vector<symbol> tmp;

	std::copy_if(_symbols.begin(), _symbols.end(), std::back_inserter(tmp),
		[=](const symbol &s) { return s.section == section && s.type == equ_type; }
	);

	if (tmp.empty()) return;
	std::sort(tmp.begin(), tmp.end());

	for (const auto &s : tmp) emit(s.name, "gequ", to_x(s.offset, 4, '$'));
	putchar('\n');
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %esi, %ebx
leaq 0x10(%rsp), %r14
andq $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x38(%rdi), %r15
movq 0x40(%rdi), %r12
cmpq %r12, %r15
je 0x804d
movzbl 0x22(%r15), %eax
cmpl %ebx, %eax
jne 0x8047
cmpb $-0x6f, 0x20(%r15)
jne 0x8047
movq %r14, %rdi
movq %r15, %rsi
callq 0x8f76
addq $0x28, %r15
jmp 0x8027
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
cmpq %rsi, %rdi
je 0x80d1
callq 0x9e4f
movq 0x10(%rsp), %rbx
movq 0x18(%rsp), %r12
leaq 0x48(%rsp), %r15
leaq 0x28(%rsp), %r13
pushq $0x4
popq %rbp
pushq $0x24
popq %r14
cmpq %r12, %rbx
je 0x80c9
movq %r15, %rdi
leaq 0x3d32(%rip), %rsi      # 0xbdbd
leaq 0xf(%rsp), %rdx
callq 0x48d4
movl 0x24(%rbx), %esi
movq %r13, %rdi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x56d0
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x5864
movq %r13, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x20d0
addq $0x28, %rbx
jmp 0x807c
pushq $0xa
popq %rdi
callq 0x2280
leaq 0x10(%rsp), %rdi
callq 0x485a
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x80ee
jmp 0x80ee
movq %rax, %rbx
jmp 0x810f
movq %rax, %rbx
jmp 0x8105
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20d0
leaq 0x48(%rsp), %rdi
callq 0x20d0
leaq 0x10(%rsp), %rdi
callq 0x485a
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::set_section(int)
void zrdz_disassembler::set_section(int section) {
	if (section == _section) return;
	if (section >= _sections.size()) {
		warnx("Invalid section %d", section);
		return;
	}
	auto &e = _sections[section];
	if (section >5 && !e.valid) {
		warnx("Invalid section %d", section);
		return;		
	}

	if (_section >= 0) {
		flush();
		_sections[_section].pc = pc();
		emit("", "ends");
		putchar('\n');
	}

	print_section(e);

	if (!e.processed) {
		print_globals(section);
		print_equs(section);
		e.processed = true;
	}

	_section = section;
	set_pc(e.pc);
	set_code((e.flags & SEC_DATA) == 0);
	recalc_next_label();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl 0x68(%rdi), %ecx
cmpl %esi, %ecx
je 0x823f
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %rsi
movq 0x50(%rdi), %r14
movq 0x58(%rdi), %rax
subq %r14, %rax
pushq $0x50
popq %rdi
cqto
idivq %rdi
cmpq %rsi, %rax
jbe 0x8248
imulq $0x50, %rsi, %rax
addq %rax, %r14
cmpl $0x6, %ebp
jl 0x8170
cmpb $0x0, 0x2d(%r14)
je 0x8248
testl %ecx, %ecx
js 0x81e6
movq %rbx, %rdi
callq 0x5fc6
movl 0x20(%rbx), %eax
movslq 0x68(%rbx), %rcx
movq 0x50(%rbx), %rdx
imulq $0x50, %rcx, %rcx
movl %eax, 0x48(%rdx,%rcx)
leaq 0x320a(%rip), %rsi      # 0xb3a0
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x48d4
leaq 0x3b9f(%rip), %rsi      # 0xbd4b
leaq 0x10(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x48d4
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x57e2
leaq 0x10(%rsp), %rdi
callq 0x20d0
leaq 0x30(%rsp), %rdi
callq 0x20d0
pushq $0xa
popq %rdi
callq 0x2280
movq %r14, %rsi
callq 0x7c4a
cmpb $0x0, 0x2c(%r14)
jne 0x820e
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7ed8
movq %rbx, %rdi
movl %ebp, %esi
callq 0x7ffe
movb $0x1, 0x2c(%r14)
movl %ebp, 0x68(%rbx)
movl 0x48(%r14), %esi
movq %rbx, %rdi
callq 0x4bd2
xorl %esi, %esi
cmpb $0x0, 0x21(%r14)
setns %sil
movq %rbx, %rdi
callq 0x8fa2
movq (%rbx), %rax
pushq $-0x1
popq %rsi
movq %rbx, %rdi
callq *0x38(%rax)
movl %eax, 0x30(%rbx)
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x3bd9(%rip), %rdi      # 0xbe28
movl %ebp, %esi
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x21e0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20d0
jmp 0x8272
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::next_label(int)
int32_t zrdz_disassembler::next_label(int32_t pc) {
	if (_section < 0) return -1;

	auto &symbols = _sections[_section].symbols;
	if (pc >= 0) {

		for(; !symbols.empty(); symbols.pop_back()) {
			auto &s = symbols.back();
			if (s.offset > pc) return s.offset;
			if (s.offset == pc) emit(s.name);
			else {
				warnx("Unable to place symbol %s at offset $%04x in section %d",
					s.name.c_str(), s.offset, _section);
			}
		}

	}
	if (symbols.empty()) return -1;
	return symbols.back().offset;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movslq 0x68(%rdi), %rax
pushq $-0x1
popq %rbx
testq %rax, %rax
js 0x8584
movl %esi, %ebp
movq %rdi, %r14
movq 0x50(%rdi), %rcx
imulq $0x50, %rax, %rax
leaq (%rcx,%rax), %r15
addq $0x30, %r15
testl %esi, %esi
js 0x8571
leaq 0x3905(%rip), %r12      # 0xbe3b
movq (%r15), %rax
movq 0x8(%r15), %rdi
cmpq %rdi, %rax
je 0x8578
movl -0x4(%rdi), %edx
addq $-0x28, %rdi
cmpl %ebp, %edx
ja 0x8582
jne 0x8556
callq 0x57c2
jmp 0x8567
movq (%rdi), %rsi
movl 0x68(%r14), %ecx
movq %r12, %rdi
xorl %eax, %eax
callq 0x21e0
movq %r15, %rdi
callq 0x8f22
jmp 0x8536
movq (%r15), %rax
movq 0x8(%r15), %rdi
cmpq %rdi, %rax
je 0x8584
movl -0x4(%rdi), %ebx
jmp 0x8584
movl %edx, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::symbol_name[abi:cxx11](unsigned int) const
std::string zrdz_disassembler::symbol_name(unsigned entry) const {
	if (entry >= _symbols.size()) {
		warnx("Invalid symbol %d", entry);
		return "$";
	}
	return _symbols[entry].name;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edx, %ecx
movq %rsi, %rax
movq %rdi, %rbx
movl %edx, %edi
movq 0x38(%rsi), %rsi
movq 0x40(%rax), %rax
subq %rsi, %rax
pushq $0x28
popq %r8
cqto
idivq %r8
cmpq %rdi, %rax
jbe 0x8895
imulq $0x28, %rdi, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x2260
jmp 0x88b9
leaq 0x35da(%rip), %rdi      # 0xbe76
movl %ecx, %esi
xorl %eax, %eax
callq 0x21e0
leaq 0x3530(%rip), %rsi      # 0xbddc
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x48d4
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/ksherlock[P]wdc-utils/zrdz_disassembler.cpp
// Function: zrdz_disassembler::section_name[abi:cxx11](unsigned int) const
std::string zrdz_disassembler::section_name(unsigned section) const {

	std::string defname = std::string("section") + std::to_string(section);

	if (section >= _sections.size()) {
		warnx("Invalid section %d", section);
		return defname;
	}
	auto &e = _sections[section];
	if (!e.valid) {
		warnx("Invalid section %d", section);
		return defname;
	}

	return e.name;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3547(%rip), %rsi      # 0xbe20
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x48d4
leaq 0x30(%rsp), %rdi
movl %ebp, %esi
callq 0x4b15
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x494d
leaq 0x30(%rsp), %rdi
callq 0x20d0
leaq 0x50(%rsp), %rdi
callq 0x20d0
movl %ebp, %ecx
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rax
subq %rsi, %rax
pushq $0x50
popq %rdi
cqto
idivq %rdi
cmpq %rcx, %rax
jbe 0x894e
imulq $0x50, %rcx, %rax
cmpb $0x0, 0x2d(%rsi,%rax)
je 0x8960
addq %rax, %rsi
movq %rbx, %rdi
callq 0x2260
jmp 0x89b2
leaq 0x34d3(%rip), %rdi      # 0xbe28
movl %ebp, %esi
xorl %eax, %eax
callq 0x21e0
jmp 0x8970
leaq 0x34c1(%rip), %rdi      # 0xbe28
movl %ebp, %esi
xorl %eax, %eax
callq 0x21e0
leaq 0x10(%rbx), %rcx
movq %rcx, (%rbx)
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0x8993
movq %rdx, (%rbx)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rbx)
jmp 0x8999
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x18(%rsp), %rcx
movq %rcx, 0x8(%rbx)
movq %rax, 0x10(%rsp)
andq $0x0, 0x18(%rsp)
movb $0x0, 0x20(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x20d0
movq %rbx, %rax
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x89ca
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x89eb
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20d0
jmp 0x89e6
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20d0
jmp 0x89f5
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::glx_make_current(_XDisplay*, unsigned long, __GLXcontextRec*)
Bool glx_make_current(Display *dpy, GLXDrawable drawable, GLXContext ctx) {
	SP_TRACE("");
	EGLDisplay dp = disp();
	curr_surface = drawable ? lookup_drawable(dpy, drawable) : EGL_NO_SURFACE;
	curr_context = ctx ? get_context(ctx).egl_ctx : EGL_NO_CONTEXT;
	SP_CHECK(fn_eglMakeCurrent(dp, curr_surface, curr_surface, curr_context));
	curr_drawable = drawable;
	if (curr_context != EGL_NO_CONTEXT)
		last_valid_context = curr_context;
	return True;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
cmpb $0x1, 0x8194(%rip)      # 0x10598
je 0x8478
callq 0x95e6
movq %rax, %r15
testq %rbx, %rbx
je 0x8425
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x9739
movq %rax, %rdx
jmp 0x8427
xorl %edx, %edx
movq %rdx, 0x82a2(%rip)      # 0x106d0
testq %r14, %r14
je 0x8438
movq (%r14), %rcx
jmp 0x843a
xorl %ecx, %ecx
movq %rcx, 0x8297(%rip)      # 0x106d8
movq %r15, %rdi
movq %rdx, %rsi
callq *0x8243(%rip)           # 0x10690
cmpl $0x1, %eax
jne 0x84a7
movq %rbx, 0x8287(%rip)      # 0x106e0
movq 0x8278(%rip), %rax      # 0x106d8
testq %rax, %rax
je 0x846c
movq %rax, 0x827c(%rip)      # 0x106e8
pushq $0x1
popq %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x7b59(%rip), %r15      # 0xffd8
movq (%r15), %rdi
leaq 0x3ee3(%rip), %rsi      # 0xc36c
leaq 0x4152(%rip), %rdx      # 0xc5e2
xorl %eax, %eax
callq 0x7610
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x7540
jmp 0x8406
movl %eax, %ebp
movq 0x7b28(%rip), %rax      # 0xffd8
movq (%rax), %rbx
callq *0x81c7(%rip)           # 0x10680
leaq 0x3fdd(%rip), %rsi      # 0xc49d
leaq 0x412c(%rip), %rdx      # 0xc5f3
movq %rbx, %rdi
movl %ebp, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x7610
callq 0x70f0
// File: /workspace/github_cpp_makefile_star2_O2/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::glx_get_fb_config_attrib(_XDisplay*, __GLXFBConfigRec*, int, int*)
int glx_get_fb_config_attrib(Display *dpy, GLXFBConfig config, int attribute, int *value) {
	SP_TRACE("%d", attribute);
	const EGLConfig &egl_cfg = *reinterpret_cast<EGLConfig*>(config);
	auto fnd_attr = egl_attr_map.find(attribute);
	if (fnd_attr != egl_attr_map.end()) {
		fn_eglGetConfigAttrib(disp(), egl_cfg, fnd_attr->second, value);
		SP_TRACE(" val=%d", *value);
	} else if (attribute == GLX_VISUAL_ID) {
		*value = XVisualIDFromVisual(get_visual(dpy, 0)->visual);
	} else if (attribute == GLX_DRAWABLE_TYPE) {
		*value = (GLX_WINDOW_BIT | GLX_PIXMAP_BIT | GLX_PBUFFER_BIT);
	} else if (attribute == GLX_RENDER_TYPE) {
		*value = GLX_RGBA_BIT;
	} else if (attribute == GLX_X_RENDERABLE) {
		*value = True;
	} else if (attribute == GLX_MAX_PBUFFER_WIDTH || attribute == GLX_MAX_PBUFFER_HEIGHT) {
		*value = 4096;
	} else if (attribute == GLX_MAX_PBUFFER_PIXELS) {
		*value = 4096*4096;
	}
	return Success;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movl %edx, 0xc(%rsp)
cmpb $0x1, 0x776f(%rip)      # 0x10598
je 0x8f11
leaq 0x769a(%rip), %rdi      # 0x104d0
leaq 0xc(%rsp), %rsi
callq 0x7500
testq %rax, %rax
je 0x8eb4
movq %rax, %r12
movq 0x7821(%rip), %r14      # 0x10670
callq 0x95e6
movq (%r15), %rsi
movl 0xc(%r12), %edx
movq %rax, %rdi
movq %rbx, %rcx
callq *%r14
cmpb $0x1, 0x772c(%rip)      # 0x10598
jne 0x8f65
movq 0x715f(%rip), %r14      # 0xffd8
movq (%r14), %rdi
leaq 0x34e9(%rip), %rsi      # 0xc36c
leaq 0x3af8(%rip), %rdx      # 0xc982
xorl %eax, %eax
callq 0x7610
movq (%r14), %rdi
movl (%rbx), %edx
leaq 0x3afe(%rip), %rsi      # 0xc99b
xorl %eax, %eax
callq 0x7610
movq (%r14), %rsi
pushq $0xa
popq %rdi
callq 0x7540
jmp 0x8f65
movl 0xc(%rsp), %eax
leal -0x800b(%rax), %ecx
cmpl $0x7, %ecx
ja 0x8efc
leaq 0x3136(%rip), %rdx      # 0xc000
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x1, (%rbx)
jmp 0x8f65
movq %r14, %rdi
xorl %esi, %esi
callq 0x94e5
movq (%rax), %rdi
callq 0x7790
movl %eax, (%rbx)
jmp 0x8f65
movl $0x7, (%rbx)
jmp 0x8f65
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x8016, %ecx           # imm = 0x8016
jne 0x8f58
movl $0x1000, (%rbx)         # imm = 0x1000
jmp 0x8f65
movl %edx, %ebp
movq 0x70be(%rip), %r12      # 0xffd8
movq (%r12), %rdi
leaq 0x3447(%rip), %rsi      # 0xc36c
leaq 0x3a56(%rip), %rdx      # 0xc982
xorl %eax, %eax
callq 0x7610
movq (%r12), %rdi
leaq 0x396b(%rip), %rsi      # 0xc8a9
movl %ebp, %edx
xorl %eax, %eax
callq 0x7610
movq (%r12), %rsi
pushq $0xa
popq %rdi
callq 0x7540
jmp 0x8e2f
cmpl $0x8018, %eax           # imm = 0x8018
jne 0x8f65
movl $0x1000000, (%rbx)      # imm = 0x1000000
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::get_proc_address(unsigned char const*)
void *get_proc_address(const GLubyte *procName) {
	std::string name_str(reinterpret_cast<const char*>(procName));
	// SP_TRACE("%s", name_str.c_str());

	auto glx_fnd = glx_procs.find(name_str);
	if (glx_fnd != glx_procs.end())
		return glx_fnd->second;
	// Unsupported extensions
	if (name_str == "glXImportContextEXT" ||
		name_str == "glXFreeContextEXT")
		return nullptr;
	// Use EGL for the base OpenGL functions
	return egl_imports.getProcAddress(name_str.c_str());
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rsi
leaq 0x10(%rsp), %rbx
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x77e0
leaq 0x710c(%rip), %rdi      # 0x10558
movq %rbx, %rsi
callq 0x73b0
testq %rax, %rax
je 0x945f
movq 0x28(%rax), %rbx
jmp 0x949b
leaq 0x35de(%rip), %rsi      # 0xca44
leaq 0x10(%rsp), %rdi
callq 0x7960
testb %al, %al
jne 0x9489
leaq 0x35dd(%rip), %rsi      # 0xca58
leaq 0x10(%rsp), %rdi
callq 0x7960
testb %al, %al
je 0x948d
xorl %ebx, %ebx
jmp 0x949b
movq 0x10(%rsp), %rdi
callq *0x7180(%rip)           # 0x10618
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x71e0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x71e0
movq %rbx, %rdi
callq 0x7820
// File: /workspace/github_cpp_makefile_star2_O2/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::get_visual(_XDisplay*, int)
static XVisualInfo* get_visual(Display *dpy, int screen)
{
    XVisualInfo *ret = new XVisualInfo;
    if (XMatchVisualInfo(dpy, screen,
                         DefaultDepth(dpy, screen),
                         TrueColor,
                         ret) == 0) {
        return nullptr;
    }
    return ret;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
pushq $0x40
popq %rdi
callq 0x7430
movq %rax, %r15
movq 0xe8(%r14), %rax
movslq %ebx, %rsi
movq %rsi, %rcx
shlq $0x7, %rcx
movl 0x38(%rax,%rcx), %edx
pushq $0x4
popq %rcx
movq %r14, %rdi
movq %r15, %r8
callq 0x7550
xorl %ecx, %ecx
testl %eax, %eax
cmovneq %r15, %rcx
movq %rcx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::create_context(__GLXFBConfigRec*, __GLXcontextRec*)
GLXContext create_context(GLXFBConfig cfg, GLXContext share_context) {
	EGLDisplay dp = disp();
	SP_CHECK(fn_eglBindAPI(EGL_OPENGL_API));

	EGLConfig egl_cfg;
	if (cfg == nullptr) {
		get_config(dp, &egl_cfg);
	} else {
		egl_cfg = *reinterpret_cast<EGLConfig*>(cfg);
	}

	std::array<int, 1> ctx_attrs{EGL_NONE};
	EGLContext share = EGL_NO_CONTEXT;
	if (share_context)
		share = get_context(share_context).egl_ctx;

	EGLContext egl_ctx = fn_eglCreateContext(dp, egl_cfg, share, ctx_attrs.data());

	return reinterpret_cast<GLXContext>(new GLXConfigImpl(egl_ctx));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x95e6
movq %rax, %rbx
movl $0x30a2, %edi           # imm = 0x30A2
callq *0x714f(%rip)           # 0x106a0
cmpl $0x1, %eax
jne 0x95b2
testq %r15, %r15
je 0x9565
movq (%r15), %rax
movq %rax, 0x10(%rsp)
jmp 0x9572
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x9657
movl $0x3038, 0xc(%rsp)      # imm = 0x3038
testq %r14, %r14
je 0x9584
movq (%r14), %rdx
jmp 0x9586
xorl %edx, %edx
movq 0x10(%rsp), %rsi
leaq 0xc(%rsp), %rcx
movq %rbx, %rdi
callq *0x70df(%rip)           # 0x10678
movq %rax, %rbx
pushq $0x8
popq %rdi
callq 0x7430
movq %rbx, (%rax)
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl %eax, %ebp
movq 0x6a1d(%rip), %rax      # 0xffd8
movq (%rax), %rbx
callq *0x70bc(%rip)           # 0x10680
leaq 0x2ed2(%rip), %rsi      # 0xc49d
leaq 0x2ef0(%rip), %rdx      # 0xc4c2
movq %rbx, %rdi
movl %ebp, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x7610
callq 0x70f0
// File: /workspace/github_cpp_makefile_star2_O2/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::disp()
EGLDisplay disp() {
	EGLDisplay d = egl_imports.getPlatformDisplay(EGL_PLATFORM_DEVICE_EXT, nullptr, nullptr);
	if (!egl_initialised.test_and_set()) {
		SP_CHECK(fn_eglInitialize(d, nullptr, nullptr));
	}
	return d;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl $0x313f, %edi           # imm = 0x313F
xorl %esi, %esi
xorl %edx, %edx
callq *0x7008(%rip)           # 0x10600
movq %rax, %rbx
movb $0x1, %al
xchgb %al, 0x70c5(%rip)       # 0x106c8
testb %al, %al
jne 0x9619
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x7044(%rip)           # 0x10658
cmpl $0x1, %eax
jne 0x9623
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl %eax, %ebp
movq 0x69ac(%rip), %rax      # 0xffd8
movq (%rax), %rbx
callq *0x704b(%rip)           # 0x10680
leaq 0x2e61(%rip), %rsi      # 0xc49d
leaq 0x2e9d(%rip), %rdx      # 0xc4e0
movq %rbx, %rdi
movl %ebp, %ecx
movl %eax, %r8d
xorl %eax, %eax
callq 0x7610
callq 0x70f0