LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq $0x4f, 0x8(%rsi)
ja 0x7fb1
movl $0x50, %esi
movq %rbx, %rdi
movl $0x20, %edx
callq 0x2080
leaq 0x7cd1(%rip), %rsi      # 0xfc89
movq %rbx, %rdi
callq 0x2320
movl 0x20(%r14), %esi
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x7538
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2090
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0x8002
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
movl $0x3a, %esi
callq 0x2180
cmpl $0x0, 0x8(%r14)
je 0x8077
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %rbx, %rdi
movl $0x20, %esi
callq 0x2180
movzbl 0x18(%r14,%r12), %esi
movq %r15, %rdi
movl $0x2, %edx
xorl %ecx, %ecx
callq 0x7538
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x2090
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8069
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
incq %r12
movl 0x8(%r14), %eax
cmpq %rax, %r12
jb 0x801e
jmp 0x807a
xorl %r12d, %r12d
cmpl $0x3, %r12d
ja 0x809b
addl $-0x4, %r12d
leaq 0x7c2b(%rip), %r15      # 0xfcb6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2320
incl %r12d
jne 0x808b
leaq 0x7c15(%rip), %rsi      # 0xfcb7
movq %rbx, %rdi
callq 0x2320
cmpl $0x0, 0x8(%r14)
je 0x8104
xorl %r15d, %r15d
movzbl 0x18(%r14,%r15), %eax
movl %eax, %ecx
andb $0x7f, %cl
testb $0x8, 0x34(%r14)
movzbl %cl, %r12d
cmovel %eax, %r12d
movzbl %r12b, %ebp
movl %ebp, %edi
callq 0x22d0
testb %bpl, %bpl
jns 0x80e2
movl $0x2e, %r12d
testl %eax, %eax
jne 0x80ec
movl $0x2e, %r12d
movsbl %r12b, %esi
movq %rbx, %rdi
callq 0x2180
incq %r15
movl 0x8(%r14), %eax
cmpq %rax, %r15
jb 0x80b4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0x8133
jmp 0x8140
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x8140
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x60, %rsp
movl %ecx, %r15d
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
cmpl $0x0, 0x8(%rdi)
je 0x8185
movq %rbx, %rdi
callq 0x7e24
testl %ebp, %ebp
je 0x81a0
movl %ebp, %ecx
xorl %eax, %eax
movb %r15b, 0x18(%rbx,%rax)
shrl $0x8, %r15d
incq %rax
cmpq %rax, %rcx
jne 0x818d
jmp 0x81a2
xorl %eax, %eax
movl %eax, 0x8(%rbx)
movq (%rbx), %rax
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r14, %rcx
callq *0x18(%rax)
cmpq $0x13, 0x8(%rsp)
ja 0x81d2
movq %rsp, %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %rsp, %rdi
callq 0x2090
cmpq $0x1d, 0x8(%rsp)
ja 0x81fe
movq %rsp, %rdi
movl $0x1e, %esi
movl $0x20, %edx
callq 0x2080
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq %rsp, %rdi
callq 0x2090
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7f84
movq %rsp, %rdi
movl $0xa, %esi
callq 0x2180
movq (%rsp), %rdi
movq 0xcd95(%rip), %rax      # 0x14fc8
movq (%rax), %rsi
callq 0x21e0
movl 0x8(%rbx), %eax
addl %eax, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x24(%rbx)
movl %eax, 0x8(%rbx)
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8264
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x827f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x8295
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x82a4
movq %rax, %rbx
jmp 0x82b6
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x940e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x82cc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14d
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rbx
cmpl $0x0, 0x8(%rdi)
je 0x8632
cmpb $0x0, 0x28(%rbx)
jne 0x863a
movq %rbx, %rdi
callq 0x82f0
cmpb $0x0, 0x28(%rbx)
je 0x867b
cmpl $0x1, 0x8(%rbx)
jne 0x86aa
cmpl %ebp, 0x10(%rbx)
jne 0x86aa
testl %ebp, %ebp
je 0x8666
movl 0x8(%rbx), %eax
movl %eax, %ecx
incl %eax
movb %r14b, 0x18(%rbx,%rcx)
shrl $0x8, %r14d
decl %ebp
jne 0x8652
movl %eax, 0x8(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x86c4
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r14d, %ecx
callq 0x8148
movl 0x2c(%rbx), %eax
testl %eax, %eax
je 0x869f
subl %ebp, %eax
movl %eax, 0x2c(%rbx)
testl %eax, %eax
jg 0x869f
movb $0x1, 0x28(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
movq %r15, %rsi
movl %ebp, %edx
movl %r14d, %ecx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x8148
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rdi
movl $0x14, %esi
movl $0x20, %edx
callq 0x2080
movzbl 0xc(%rbx), %eax
leaq (%rax,%rax,2), %rax
leaq 0x7243(%rip), %rsi      # 0xf950
addq %rax, %rsi
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
callq 0x2050
cmpl $0x0, 0x10(%rbx)
je 0x87cb
cmpq $0x1d, 0x10(%rsp)
ja 0x8745
leaq 0x8(%rsp), %rdi
movl $0x1e, %esi
movl $0x20, %edx
callq 0x2080
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x900c
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x38(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x8782
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x90de
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0x2090
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x87cb
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x7f84
leaq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0x2180
movq 0x8(%rsp), %rdi
movq 0xc7d5(%rip), %rax      # 0x14fc8
movq (%rax), %rsi
callq 0x21e0
movl 0x10(%rbx), %eax
movl 0x20(%rbx), %ecx
addl %ecx, %eax
incl %eax
movl %eax, 0x20(%rbx)
xorl %eax, %eax
movl %eax, 0x24(%rbx)
movl %eax, 0x8(%rbx)
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8827
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
jne 0x8855
jmp 0x8869
jmp 0x8866
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x8869
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21c0
jmp 0x8869
jmp 0x8866
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8880
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $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 0x90b6
movl $0x1, %r8d
leaq 0x64cb(%rip), %rcx      # 0xf514
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6c46(%rip), %rcx      # 0xfc9f
jmp 0x90aa
leaq 0x614b(%rip), %rcx      # 0xf1ad
jmp 0x90aa
leaq 0x6c3e(%rip), %rcx      # 0xfca9
jmp 0x90aa
leaq 0x6c33(%rip), %rcx      # 0xfca7
jmp 0x90aa
movl $0x2, %r8d
leaq 0x6c21(%rip), %rcx      # 0xfca4
jmp 0x90aa
cmpl $0x1, 0x10(%rsi)
jbe 0x90b6
leaq 0x6122(%rip), %rcx      # 0xf1b4
jmp 0x90aa
leaq 0x6c07(%rip), %rcx      # 0xfca2
jmp 0x90aa
movl $0x2, %r8d
leaq 0x6bf7(%rip), %rcx      # 0xfca1
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x90d5
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
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 0x9157
leaq 0x6418(%rip), %rdx      # 0xf534
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
leaq 0x6b85(%rip), %rcx      # 0xfcb1
jmp 0x9145
testl $0xf000, %eax           # imm = 0xF000
jne 0x9157
leaq 0x6b72(%rip), %rcx      # 0xfcae
jmp 0x9145
leaq 0x6b66(%rip), %rcx      # 0xfcab
movl $0x2, %r8d
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x2280
movl $0xf000, %eax           # imm = 0xF000
andl 0x14(%r14), %eax
addl $0xffffd000, %eax       # imm = 0xFFFFD000
cmpl $0x5fff, %eax           # imm = 0x5FFF
ja 0x9191
shrl $0xc, %eax
movl $0x33, %ecx
btl %eax, %ecx
jae 0x9191
movl %eax, %eax
leaq 0x6ade(%rip), %rcx      # 0xfc60
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
movq %rbx, %rdi
callq 0x2320
movl 0x14(%r14), %eax
movl %eax, %ecx
andl $0xf00, %ecx            # imm = 0xF00
cmpl $0x500, %ecx            # imm = 0x500
je 0x91b4
cmpl $0x400, %ecx            # imm = 0x400
jne 0x91c3
testl $0xf000, %eax           # imm = 0xF000
je 0x91c3
leaq 0x6af3(%rip), %rsi      # 0xfcae
movq %rbx, %rdi
callq 0x2320
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x91e2
movq (%r15), %rsi
incq %rsi
callq 0x21c0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %r14
movq 0x30(%rdi), %r15
cmpq %r15, %r14
je 0x926c
movq %r15, %rax
subq %r14, %rax
sarq $0x2, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x94d3
movq %r14, %rdi
movq %r15, %rsi
callq 0x95b6
leaq 0x28(%rbx), %r14
movq 0x28(%rbx), %rdi
movq 0x30(%rbx), %rsi
callq 0x9826
movq 0x30(%rbx), %rcx
cmpq %rcx, %rax
je 0x929c
movq 0x30(%rbx), %rdx
movq %rdx, %rsi
subq %rcx, %rsi
addq %rsi, %rax
cmpq %rax, %rdx
je 0x929c
movq %rax, 0x30(%rbx)
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x92d2
movl 0xc(%rdi), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0xc(%rdi)
testl %ecx, %ecx
je 0x92ed
shll $0x3, %ecx
movzbl %sil, %edx
addb $-0x8, %cl
shll %cl, %edx
addl %edx, 0x20(%rdi)
cmpl 0x14(%rdi), %eax
ja 0x9342
retq
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x92d1
leal -0x1(%rax), %ecx
movl %ecx, 0x4(%rdi)
cmpl $0x1, %eax
jg 0x92d1
movb $0x1, 0x8(%rdi)
movl 0xc(%rdi), %eax
jmp 0x9325
movb %sil, 0x10(%rdi)
movzbl %sil, %ecx
leaq 0x6254(%rip), %rdx      # 0xf550
movl (%rdx,%rcx,4), %ecx
movl %ecx, 0x24(%rdi)
movl %ecx, %edx
andl $0xf, %edx
movl %edx, 0x14(%rdi)
andl 0x18(%rdi), %ecx
testb $0x10, %cl
je 0x9317
incl %edx
movl %edx, 0x14(%rdi)
testb $0x20, %cl
je 0x931f
incl 0x14(%rdi)
cmpl $0x0, 0x14(%rdi)
jne 0x92d1
addl %eax, 0x1c(%rdi)
xorl %eax, %eax
movl %eax, 0x20(%rdi)
movl %eax, 0xc(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9377
movzbl 0x10(%rbx), %eax
cmpl $0xe2, %eax
je 0x936c
cmpl $0xc2, %eax
jne 0x9377
movl 0x20(%rbx), %eax
andl $0x30, %eax
orl %eax, 0x18(%rbx)
jmp 0x9377
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 0x93d4
cmpl $0x3, %eax
je 0x93d4
cmpl $0x7, %eax
jne 0x93fa
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
movl %eax, 0xc(%rsp)
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
jne 0x93e1
leaq 0x28(%rbx), %rdi
leaq 0xc(%rsp), %rdx
jmp 0x93f5
movq 0x30(%rbx), %rsi
cmpq 0x38(%rbx), %rsi
je 0x93ed
movl 0x20(%rbx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rbx)
jmp 0x93fa
leaq 0x20(%rbx), %rdx
leaq 0x28(%rbx), %rdi
callq 0x987a
movl 0xc(%rbx), %eax
addl %eax, 0x1c(%rbx)
xorl %eax, %eax
movl %eax, 0x20(%rbx)
movl %eax, 0xc(%rbx)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl 0x68(%rdi), %eax
cmpl %esi, %eax
je 0xaf37
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %rcx
movq 0x50(%rdi), %r14
movq 0x58(%rdi), %rdx
subq %r14, %rdx
sarq $0x4, %rdx
movabsq $-0x3333333333333333, %rsi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rsi
cmpq %rcx, %rsi
jbe 0xaf44
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
addq %rcx, %r14
cmpl $0x6, %ebp
jl 0xae22
cmpb $0x0, 0x2d(%r14)
je 0xaf44
testl %eax, %eax
js 0xaeca
movq %rbx, %rdi
callq 0x82d4
movl 0x20(%rbx), %eax
movslq 0x68(%rbx), %rcx
movq 0x50(%rbx), %rdx
leaq (%rcx,%rcx,4), %rcx
shlq $0x4, %rcx
movl %eax, 0x48(%rdx,%rcx)
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x44eb(%rip), %rdx      # 0xf344
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0x6b90
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x4e84(%rip), %rsi      # 0xfcfb
leaq 0x4e81(%rip), %rdx      # 0xfcff
movq %rsp, %rdi
callq 0x6b90
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0x766e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xaea9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xaec0
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21c0
movl $0xa, %edi
callq 0x2240
movq %r14, %rsi
callq 0xa720
cmpb $0x0, 0x2c(%r14)
jne 0xaef2
movq %rbx, %rdi
movl %ebp, %esi
callq 0xaa60
movq %rbx, %rdi
movl %ebp, %esi
callq 0xac0e
movb $0x1, 0x2c(%r14)
movl %ebp, 0x68(%rbx)
movl 0x48(%r14), %ebp
cmpl %ebp, 0x20(%rbx)
je 0xaf09
movq %rbx, %rdi
callq 0x82d4
movl %ebp, 0x20(%rbx)
movb 0x21(%r14), %bpl
notb %bpl
shrb $0x7, %bpl
cmpb %bpl, 0x28(%rbx)
je 0xaf26
movq %rbx, %rdi
callq 0x82d4
movb %bpl, 0x28(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq *0x38(%rax)
movl %eax, 0x30(%rbx)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4e8d(%rip), %rdi      # 0xfdd8
movl %ebp, %esi
xorl %eax, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x21d0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xaf7e
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x21c0
jmp 0xaf7e
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xaf95
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x21c0
movq %rbx, %rdi
callq 0x22c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movslq 0x68(%rdi), %rax
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
testq %rax, %rax
js 0xb3c0
movl %esi, %ebp
movq %rdi, %r14
movq 0x50(%rdi), %rcx
leaq (%rax,%rax,4), %rax
shlq $0x4, %rax
leaq (%rcx,%rax), %r13
addq $0x30, %r13
testl %esi, %esi
js 0xb3ae
movq 0x8(%r13), %rdi
cmpq %rdi, (%r13)
je 0xb3ae
movl -0x4(%rdi), %r12d
addq $-0x28, %rdi
movl %r12d, %ebx
cmpl %ebp, %r12d
ja 0xb378
jne 0xb35d
callq 0x764c
jmp 0xb375
movq (%rdi), %rsi
movl 0x68(%r14), %ecx
leaq 0x4a80(%rip), %rdi      # 0xfdeb
movl %r12d, %edx
xorl %eax, %eax
callq 0x21d0
movl %r15d, %ebx
cmpl %ebp, %r12d
ja 0xb3c0
movq 0x8(%r13), %rax
leaq -0x28(%rax), %rcx
movq %rcx, 0x8(%r13)
movq -0x28(%rax), %rdi
addq $-0x18, %rax
cmpq %rax, %rdi
je 0xb3a1
movq (%rax), %rsi
incq %rsi
callq 0x21c0
movq 0x8(%r13), %rdi
movl %ebx, %r15d
cmpq %rdi, (%r13)
jne 0xb344
movq 0x8(%r13), %rax
cmpq %rax, (%r13)
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
je 0xb3c0
movl -0x4(%rax), %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl %edx, %ecx
movq 0x38(%rsi), %rax
movq 0x40(%rsi), %rsi
subq %rax, %rsi
sarq $0x3, %rsi
movabsq $-0x3333333333333333, %rdi # imm = 0xCCCCCCCCCCCCCCCD
imulq %rsi, %rdi
leaq 0x10(%rbx), %r14
cmpq %rcx, %rdi
jbe 0xb8f8
leaq (%rcx,%rcx,4), %rcx
movq %r14, (%rbx)
movq (%rax,%rcx,8), %rsi
movq 0x8(%rax,%rcx,8), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x6b00
jmp 0xb921
leaq 0x4527(%rip), %rdi      # 0xfe26
movl %edx, %esi
xorl %eax, %eax
callq 0x21d0
movq %r14, (%rbx)
leaq 0x447a(%rip), %rsi      # 0xfd8c
leaq 0x4474(%rip), %rdx      # 0xfd8d
movq %rbx, %rdi
callq 0x6b90
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
cmpb $0x1, 0x76cd(%rip)      # 0xd398
je 0x5d44
callq 0x6ca2
movq %rax, %r15
testq %rbx, %rbx
je 0x5cec
movq %r12, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x6d3f
movq %rax, %rdx
jmp 0x5cee
xorl %edx, %edx
movq %rdx, 0x77db(%rip)      # 0xd4d0
testq %r14, %r14
je 0x5cff
movq (%r14), %rcx
jmp 0x5d01
xorl %ecx, %ecx
movq %rcx, 0x77d0(%rip)      # 0xd4d8
movq %r15, %rdi
movq %rdx, %rsi
callq *0x777c(%rip)           # 0xd490
cmpl $0x1, %eax
jne 0x5d4b
movq %rbx, 0x77c0(%rip)      # 0xd4e0
movq 0x77b1(%rip), %rax      # 0xd4d8
testq %rax, %rax
je 0x5d33
movq %rax, 0x77b5(%rip)      # 0xd4e8
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
callq 0x471e
jmp 0x5ccd
movl %eax, %edi
callq 0x474a
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r14
cmpb $0x1, 0x6dc1(%rip)      # 0xd398
je 0x66fc
movslq %r15d, %rax
movq 0x6cf1(%rip), %rdi      # 0xd2d8
xorl %r9d, %r9d
xorl %edx, %edx
divq %rdi
movq 0x6cda(%rip), %rax      # 0xd2d0
movq (%rax,%rdx,8), %rax
testq %rax, %rax
je 0x663d
movq (%rax), %r8
movq %rax, %r9
cmpl %r15d, 0x8(%r8)
je 0x663d
movq %rdx, %rcx
movq %r8, %r10
movq (%r8), %r8
testq %r8, %r8
je 0x663a
movslq 0x8(%r8), %rsi
movq %rsi, %rax
xorl %edx, %edx
divq %rdi
movl $0x0, %r9d
cmpq %rcx, %rdx
jne 0x663d
movq %r10, %r9
cmpl %r15d, %esi
jne 0x660e
jmp 0x663d
xorl %r9d, %r9d
testq %r9, %r9
je 0x6647
movq (%r9), %r13
jmp 0x664a
xorl %r13d, %r13d
testq %r13, %r13
je 0x6686
movq 0x6e1a(%rip), %r14      # 0xd470
callq 0x6ca2
movq (%r12), %rsi
movl 0xc(%r13), %edx
movq %rax, %rdi
movq %rbx, %rcx
callq *%r14
cmpb $0x1, 0x6d25(%rip)      # 0xd398
jne 0x6718
movq %rbx, %rdi
callq 0x4b3d
jmp 0x6718
leal -0x800b(%r15), %eax
cmpl $0x7, %eax
ja 0x66e7
leaq 0x2967(%rip), %rcx      # 0x9000
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x1, (%rbx)
jmp 0x6718
movl $0x40, %edi
callq 0x4280
movq %rax, %r15
movq 0xe8(%r14), %rax
movl 0x38(%rax), %edx
movq %r14, %rdi
xorl %esi, %esi
movl $0x4, %ecx
movq %r15, %r8
callq 0x4310
movq (%r15), %rdi
callq 0x4460
movl %eax, (%rbx)
jmp 0x6718
movl $0x7, (%rbx)
jmp 0x6718
movl %r15d, %eax
andl $-0x2, %eax
cmpl $0x8016, %eax           # imm = 0x8016
jne 0x6709
movl $0x1000, (%rbx)         # imm = 0x1000
jmp 0x6718
movl %r15d, %edi
callq 0x4af3
jmp 0x65dd
cmpl $0x8018, %r15d          # imm = 0x8018
jne 0x6718
movl $0x1000000, (%rbx)      # imm = 0x1000000
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x44a0
leaq 0x67de(%rip), %rdi      # 0xd358
movq %rbx, %rsi
callq 0x4230
testq %rax, %rax
je 0x6b8d
movq 0x28(%rax), %rbx
jmp 0x6bc9
leaq 0x2ea7(%rip), %rsi      # 0x9a3b
leaq 0x10(%rsp), %rdi
callq 0x40b0
testl %eax, %eax
je 0x6bc7
leaq 0x2ea6(%rip), %rsi      # 0x9a4f
leaq 0x10(%rsp), %rdi
callq 0x40b0
testl %eax, %eax
je 0x6bc7
movq 0x10(%rsp), %rdi
callq *0x6856(%rip)           # 0xd418
movq %rax, %rbx
jmp 0x6bc9
xorl %ebx, %ebx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6be4
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6c0b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %r15
callq 0x6ca2
movq %rax, %rbx
movl $0x30a2, %edi           # imm = 0x30A2
callq *0x6867(%rip)           # 0xd4a0
cmpl $0x1, %eax
jne 0x6c9b
testq %r15, %r15
je 0x6c4d
movq (%r15), %rax
movq %rax, 0x8(%rsp)
jmp 0x6c5a
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6cdf
movl $0x3038, 0x4(%rsp)      # imm = 0x3038
testq %r14, %r14
je 0x6c6c
movq (%r14), %rdx
jmp 0x6c6e
xorl %edx, %edx
movq 0x8(%rsp), %rsi
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
callq *0x67f7(%rip)           # 0xd478
movq %rax, %rbx
movl $0x8, %edi
callq 0x4280
movq %rbx, (%rax)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movl %eax, %edi
callq 0x4d4c
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movl $0x313f, %edi           # imm = 0x313F
xorl %esi, %esi
xorl %edx, %edx
callq *0x674e(%rip)           # 0xd400
movq %rax, %rbx
movb $0x1, %al
xchgb %al, 0x680b(%rip)       # 0xd4c8
testb %al, %al
jne 0x6cd3
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq *0x678a(%rip)           # 0xd458
cmpl $0x1, %eax
jne 0x6cd8
movq %rbx, %rax
popq %rbx
retq
movl %eax, %edi
callq 0x4d84
// File: /workspace/github_cpp_makefile_star2_O1/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::get_config(void*, void**)
void get_config(EGLDisplay dp, EGLConfig *egl_cfg) {
	// TODO: proper config choosing
	int cfg_attrs[] = {EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
		EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
		EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER,
		EGL_RED_SIZE, 8,
		EGL_GREEN_SIZE, 8,
		EGL_BLUE_SIZE, 8,
		EGL_NONE};
	int num_configs;
	SP_CHECK(fn_eglChooseConfig(dp, cfg_attrs, egl_cfg, 1, &num_configs));
	SP_ASSERT(num_configs > 0);
}

// Assembly:
subq $0x48, %rsp
movq %rsi, %rdx
movaps 0x2393(%rip), %xmm0     # 0x9080
leaq 0x10(%rsp), %rsi
movaps %xmm0, 0x20(%rsi)
movaps 0x2373(%rip), %xmm0     # 0x9070
movaps %xmm0, 0x10(%rsi)
movaps 0x2358(%rip), %xmm0     # 0x9060
movaps %xmm0, (%rsi)
movl $0x3038, 0x30(%rsi)     # imm = 0x3038
leaq 0xc(%rsp), %r8
movl $0x1, %ecx
callq *0x6746(%rip)           # 0xd468
cmpl $0x1, %eax
jne 0x6d33
cmpl $0x0, 0xc(%rsp)
jle 0x6d3a
addq $0x48, %rsp
retq
movl %eax, %edi
callq 0x4dbc
callq 0x4df4
// File: /workspace/github_cpp_makefile_star2_O1/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::lookup_drawable(_XDisplay*, unsigned long, __GLXFBConfigRec*)
EGLSurface lookup_drawable(Display *dpy, GLXDrawable drawable, GLXFBConfig cfg = nullptr) {
	if (drawable2surface.count(drawable))
		return drawable2surface.at(drawable).egl_sfc;
	// Create a new backing PBuffer
	EGLDisplay dp = disp();
	EGLConfig egl_cfg;
	if (cfg == nullptr) {
		get_config(dp, &egl_cfg);
	} else {
		egl_cfg = *reinterpret_cast<EGLConfig*>(cfg);
	}
	unsigned width, height;
	std::tie(width, height) = get_drawable_dims(dpy, drawable);
	std::vector<int> attrs{EGL_WIDTH, int(width), EGL_HEIGHT, int(height), EGL_NONE};
	EGLSurface surface = fn_eglCreatePbufferSurface(dp, egl_cfg, attrs.data());
	drawable2surface[drawable].egl_sfc = surface;
	drawable2surface[drawable].width = width;
	drawable2surface[drawable].height = height;
	drawable2surface[drawable].cfg = cfg;
	return surface;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
leaq 0x10(%rsp), %rdi
movq %rsi, (%rdi)
callq 0x6e80
testq %rax, %rax
je 0x6d79
leaq 0x10(%rsp), %rdi
callq 0x6eae
movq (%rax), %r14
jmp 0x6e4d
callq 0x6ca2
movq %rax, %r14
testq %rbx, %rbx
je 0x6d90
movq (%rbx), %rax
movq %rax, 0x18(%rsp)
jmp 0x6d9d
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x6cdf
movq %r12, %rdi
movq %r15, %rsi
callq 0x6eea
movq %rax, %r15
movq %rax, %r13
shrq $0x20, %r13
leaq 0x3c(%rsp), %rsi
movl $0x3057, (%rsi)         # imm = 0x3057
movl %r15d, 0x4(%rsi)
movl $0x3056, 0x8(%rsi)      # imm = 0x3056
movl %r13d, 0xc(%rsi)
movl $0x3038, 0x10(%rsi)     # imm = 0x3038
leaq 0x20(%rsp), %r12
leaq 0xf(%rsp), %rcx
movl $0x5, %edx
movq %r12, %rdi
callq 0x4510
movq 0x18(%rsp), %rsi
movq (%r12), %rdx
movq %r14, %rdi
callq *0x668c(%rip)           # 0xd488
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x6f44
movq %r14, (%rax)
leaq 0x10(%rsp), %rdi
callq 0x6f44
movl %r15d, 0x8(%rax)
leaq 0x10(%rsp), %rdi
callq 0x6f44
movl %r13d, 0xc(%rax)
leaq 0x10(%rsp), %rdi
callq 0x6f44
movq %rbx, 0x10(%rax)
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6e4d
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x6e78
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x42a0
movq %rbx, %rdi
callq 0x44d0
// File: /workspace/github_cpp_makefile_star2_O1/gatecat[P]subprime/subprime.cpp
// Function: (anonymous namespace)::get_drawable_dims(_XDisplay*, unsigned long)
std::pair<unsigned, unsigned> get_drawable_dims(Display *dpy, GLXDrawable drawable) {
	Window root;
	int x, y;
	unsigned int width = 0, height = 0, border_width, depth;
	auto st = XGetGeometry(dpy, drawable, &root, &x, &y, &width, &height, &border_width, &depth);
	return std::make_pair(width, height);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
xorl %eax, %eax
leaq 0x14(%rsp), %rbx
movl %eax, (%rbx)
leaq 0x10(%rsp), %r14
movl %eax, (%r14)
subq $0x8, %rsp
leaq 0x10(%rsp), %rax
leaq 0x14(%rsp), %r10
leaq 0x28(%rsp), %rdx
leaq 0x24(%rsp), %rcx
leaq 0x20(%rsp), %r8
movq %rbx, %r9
pushq %rax
pushq %r10
pushq %r14
callq 0x43d0
addq $0x20, %rsp
movl (%rbx), %ecx
movl (%r14), %eax
shlq $0x20, %rax
orq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/kulpreet[P]lightning-network-graph-analysis/src/include/support.hpp
// Function: lncentrality::print_edges_with_components(boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, lncentrality::LitVertex, lncentrality::LitEdge, boost::no_property, boost::listS>&)
void print_edges_with_components(LitGraph &g) {
  graph_traits<LitGraph>::vertex_descriptor src, tgt;
  graph_traits<LitGraph>::edge_iterator ei, ei_end;
  for (boost::tie(ei, ei_end) = edges(g); ei != ei_end; ++ei) {
    src = source(*ei, g);
    tgt = target(*ei, g);
    if (degree(src, g) > 1 && degree(src, g) > 1) {
      std::cout << g[src].name << " -- " << g[tgt].name << " [label=\""
                << g[*ei].component << "\"]\n";
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rdi), %r14
cmpq %rdi, %r14
je 0x7998
movq %rdi, %rbx
leaq 0x14770(%rip), %r12     # 0x1c05d
leaq 0x14773(%rip), %r13     # 0x1c067
movq 0x18(%rbx), %rax
imulq $0xb8, 0x10(%r14), %rcx
movq 0x8(%rax,%rcx), %rdx
subq (%rax,%rcx), %rdx
cmpq $0x11, %rdx
jb 0x798c
movq 0x58(%rax,%rcx), %rsi
movq 0x60(%rax,%rcx), %rdx
imulq $0xb8, 0x18(%r14), %r15
movq 0x22680(%rip), %rdi     # 0x29fa8
callq 0x7350
movq %rax, %rbp
movl $0x4, %edx
movq %rax, %rdi
leaq 0x14719(%rip), %rsi     # 0x1c058
callq 0x7350
movq 0x18(%rbx), %rax
movq 0x58(%rax,%r15), %rsi
movq 0x60(%rax,%r15), %rdx
movq %rbp, %rdi
callq 0x7350
movq %rax, %rbp
movl $0x9, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x7350
movl 0xf8(%r14), %esi
movq %rbp, %rdi
callq 0x7520
movl $0x3, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x7350
movq (%r14), %r14
cmpq %rbx, %r14
jne 0x78f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/kulpreet[P]lightning-network-graph-analysis/src/include/degree_stats.hpp
// Function: lncentrality::get_degrees(std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, std::vector<unsigned long, std::allocator<unsigned long>>&, boost::adjacency_list<boost::vecS, boost::vecS, boost::undirectedS, lncentrality::LitVertex, lncentrality::LitEdge, boost::no_property, boost::listS>&)
void get_degrees(vector<Degree> &in_degrees, vector<Degree> &out_degrees,
                 vector<Degree> &degrees, LitGraph &g) {
  graph_traits<LitGraph>::vertex_iterator i, end;
  for (boost::tie(i, end) = vertices(g); i != end; ++i) {
    in_degrees.push_back(in_degree(*i, g));
    out_degrees.push_back(out_degree(*i, g));
    degrees.push_back(degree(*i, g));
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq 0x20(%rcx), %rax
movq 0x18(%rcx), %rcx
subq %rcx, %rax
je 0x8eda
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
sarq $0x3, %rax
movabsq $-0x2c8590b21642c859, %rbp # imm = 0xD37A6F4DE9BD37A7
imulq %rax, %rbp
movl $0x8, %r13d
movq 0x18(%rbx), %rcx
movq (%rcx,%r13), %rax
subq -0x8(%rcx,%r13), %rax
sarq $0x4, %rax
movq %rax, (%rsp)
movq 0x8(%r12), %rsi
cmpq 0x10(%r12), %rsi
je 0x8e51
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r12)
jmp 0x8e5c
movq %r12, %rdi
movq %rsp, %rdx
callq 0xef88
movq 0x18(%rbx), %rcx
movq (%rcx,%r13), %rax
subq -0x8(%rcx,%r13), %rax
sarq $0x4, %rax
movq %rax, (%rsp)
movq 0x8(%r15), %rsi
cmpq 0x10(%r15), %rsi
je 0x8e88
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r15)
jmp 0x8e93
movq %r15, %rdi
movq %rsp, %rdx
callq 0xef88
movq 0x18(%rbx), %rcx
movq (%rcx,%r13), %rax
subq -0x8(%rcx,%r13), %rax
sarq $0x4, %rax
movq %rax, (%rsp)
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x8ebf
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%r14)
jmp 0x8eca
movq %r14, %rdi
movq %rsp, %rdx
callq 0xef88
addq $0xb8, %r13
decq %rbp
jne 0x8e22
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/sudocode1[P]radio/compiler.cpp
// Function: split(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
std::vector<std::string> split(std::string str, char delimiter) {
  std::vector<std::string> result;
  std::stringstream ss(str); // Turn the string into a stream.
  std::string tok;
  
  while(std::getline(ss,tok,delimiter)) {
    result.push_back(tok);
  }
  
  return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movl %edx, %r14d
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x1d0(%rbp), %rdi
movl $0x18, %edx
callq 0x21f0
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
movq $0x0, -0x8(%r13)
movb $0x0, (%r13)
movsbl %r14b, %r14d
leaq -0x1d0(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl %r14d, %edx
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x2432
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3b16
jmp 0x2409
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2447
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movq 0x3b62(%rip), %rsi      # 0x5fb0
leaq -0x1d0(%rbp), %rdi
callq 0x20e0
leaq -0x150(%rbp), %rdi
callq 0x2080
movq %rbx, %rax
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x24b7
movq %rax, %r14
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x2498
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2150
movq 0x3b11(%rip), %rsi      # 0x5fb0
leaq -0x1d0(%rbp), %rdi
callq 0x20e0
leaq -0x150(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x3b62
movq %r14, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/sudocode1[P]radio/compiler.cpp
// Function: readIncl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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 readIncl(std::string fileName, std::vector<std::string> *lines) {
    std::string curLine;
    std::ifstream inclFile(fileName);
    while (std::getline(inclFile, curLine)) {
        (*lines).push_back(curLine);
    }
    inclFile.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x230, %rsp            # imm = 0x230
movq %rsi, %rbx
movq %rdi, %rsi
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
leaq -0x248(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2200
leaq -0x40(%rbp), %r15
movq -0x248(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x2250
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x254f
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3b16
jmp 0x250e
leaq -0x248(%rbp), %rdi
callq 0x2040
leaq -0x248(%rbp), %rdi
callq 0x2050
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x257c
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2150
addq $0x230, %rsp            # imm = 0x230
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2593
movq %rax, %rbx
jmp 0x25a2
movq %rax, %rbx
leaq -0x248(%rbp), %rdi
callq 0x2050
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x25b7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x2150
movq %rbx, %rdi
callq 0x2230
// File: /workspace/github_cpp_makefile_star2_O1/2TallTim[P]modern-raytracing/hitable_list.cpp
// Function: hitable_list::hit(ray const&, double, double, hit_record&) const
bool hitable_list::hit(const ray& r, double t_min, double t_max, hit_record& rec) const{
    hit_record temp_rec;
    bool hit_anything = false;
    double closest_so_far = t_max;
    for (auto ht : list){
        if (ht->hit(r,t_min,closest_so_far,temp_rec)){
            hit_anything = true;
            closest_so_far = temp_rec.t;
            rec = temp_rec;
        }
    }
    return hit_anything;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movsd %xmm1, 0x8(%rsp)
movsd %xmm0, 0x18(%rsp)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rsp)
movups %xmm0, 0x48(%rsp)
movups %xmm0, 0x38(%rsp)
movups %xmm0, 0x28(%rsp)
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r13
cmpq %r13, %r15
je 0x3957
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x40(%rdx), %rax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movq (%r15), %rdi
movq 0x8(%r15), %r12
testq %r12, %r12
je 0x38d4
movq 0xa706(%rip), %rax      # 0xdfc8
cmpb $0x0, (%rax)
je 0x38ce
incl 0x8(%r12)
jmp 0x38d4
lock
incl 0x8(%r12)
movq (%rdi), %rax
movq %r14, %rsi
movsd 0x18(%rsp), %xmm0
movsd 0x8(%rsp), %xmm1
leaq 0x20(%rsp), %rdx
callq *(%rax)
testb %al, %al
je 0x393b
movsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x30(%rbx)
movups 0x20(%rsp), %xmm0
movups 0x30(%rsp), %xmm1
movups 0x40(%rsp), %xmm2
movups %xmm2, 0x20(%rbx)
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rbx)
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x37a6
movb $0x1, %bpl
testq %r12, %r12
je 0x3948
movq %r12, %rdi
callq 0x37ec
addq $0x10, %r15
cmpq %r13, %r15
jne 0x38af
jmp 0x3959
xorl %ebp, %ebp
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x3968
callq 0x37ec
andb $0x1, %bpl
movl %ebp, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
testq %r12, %r12
je 0x398d
movq %r12, %rdi
callq 0x37ec
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x399c
callq 0x37ec
movq %rbx, %rdi
callq 0x32e0
// File: /workspace/github_cpp_makefile_star2_O1/2TallTim[P]modern-raytracing/rng.cpp
// Function: rng::random_in_unit_sphere()
vec3 rng::random_in_unit_sphere(){
    vec3 p;
    do {
        p = 2.0 * vec3(gen01(), gen01(), gen01()) - vec3(1, 1, 1);
    } while(p.squared_length() >= 1.0);
    return p;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x3d9a
movsd %xmm0, 0x8(%rsp)
callq 0x3d9a
movsd %xmm0, (%rsp)
callq 0x3d9a
movsd (%rsp), %xmm4
movsd 0x8(%rsp), %xmm3
addsd %xmm3, %xmm3
addsd %xmm4, %xmm4
addsd %xmm0, %xmm0
movsd 0x623d(%rip), %xmm1     # 0xa060
addsd %xmm1, %xmm3
addsd %xmm1, %xmm4
addsd %xmm1, %xmm0
movapd %xmm4, %xmm1
mulsd %xmm4, %xmm1
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
addsd %xmm2, %xmm1
ucomisd 0x6211(%rip), %xmm1     # 0xa068
jae 0x3dea
movsd %xmm4, 0x8(%rbx)
movsd %xmm0, 0x10(%rbx)
movsd %xmm3, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/2TallTim[P]modern-raytracing/rng.cpp
// Function: rng::random_in_unit_disk()
vec3 rng::random_in_unit_disk(){
    vec3 p;
    do {
        p = 2.0 * vec3(gen01(),gen01(),0) - vec3(1,1,0);
    } while(p.squared_length() >= 1.0);
    return p;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x3d9a
movsd %xmm0, 0x8(%rsp)
callq 0x3d9a
movsd 0x8(%rsp), %xmm3
addsd %xmm3, %xmm3
addsd %xmm0, %xmm0
movsd 0x61b2(%rip), %xmm1     # 0xa060
addsd %xmm1, %xmm3
addsd %xmm1, %xmm0
movapd %xmm0, %xmm1
mulsd %xmm0, %xmm1
movapd %xmm3, %xmm2
mulsd %xmm3, %xmm2
addsd %xmm1, %xmm2
ucomisd 0x6196(%rip), %xmm2     # 0xa068
jae 0x3e88
movsd %xmm0, 0x8(%rbx)
movq $0x0, 0x10(%rbx)
movsd %xmm3, (%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq