LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::PCIIO(smooth::GUI::Bitmap const&)
PCIIO::PCIIO(const S::GUI::Bitmap &b)
{
	cfNames[Color::RGB]	= "RGB";
	cfNames[Color::RGBA]	= "RGA";
	cfNames[Color::HSV]	= "HSV";
	cfNames[Color::YUV]	= "YUV";
	cfNames[Color::CMY]	= "CMY";
	cfNames[Color::CMYK]	= "CMK";
	cfNames[Color::GRAY]	= "GRY";

	cpNames[RAW]		= "RAW";
	cpNames[PCI]		= "PCI";
	cpNames[RLE]		= "RLE";
	cpNames[JPEG]		= "JPG";
	cpNames[BZIP2]		= "BZ2";

	majorversion		= PCIMajorVersion;
	minorversion		= PCIMinorVersion;
	compression		= RAW;
	colorspace		= Color::RGB;
	quality			= 100;
	description		= NIL;

	dpix			= 75;
	dpiy			= 75;
	bpcc			= 8;
	overwrite		= True;
	imageid			= 0;
	imagename		= NIL;
	rlebits			= 8;

	bmp			= b;

	sizex			= bmp.GetSize().cx;
	sizey			= bmp.GetSize().cy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r13
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x59c80
leaq 0x20(%r15), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x38(%r15), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0xb8d80(%rip), %rdi     # 0x16cac0
leaq 0x4ef36(%rip), %rsi     # 0x102c7d
callq 0x57010
leaq 0xb8d85(%rip), %rdi     # 0x16cad8
leaq 0x4ef27(%rip), %rsi     # 0x102c81
callq 0x57010
leaq 0xb8d8a(%rip), %rdi     # 0x16caf0
leaq 0x4ef18(%rip), %rsi     # 0x102c85
callq 0x57010
leaq 0xb8d8f(%rip), %rdi     # 0x16cb08
leaq 0x4ef09(%rip), %rsi     # 0x102c89
callq 0x57010
leaq 0xb8d94(%rip), %rdi     # 0x16cb20
leaq 0x4eefa(%rip), %rsi     # 0x102c8d
callq 0x57010
leaq 0xb8d99(%rip), %rdi     # 0x16cb38
leaq 0x4eeeb(%rip), %rsi     # 0x102c91
callq 0x57010
leaq 0xb8d9e(%rip), %rdi     # 0x16cb50
leaq 0x4eedc(%rip), %rsi     # 0x102c95
callq 0x57010
leaq 0xb8dab(%rip), %rdi     # 0x16cb70
leaq 0x4eecd(%rip), %rsi     # 0x102c99
callq 0x57010
leaq 0xb8db0(%rip), %rdi     # 0x16cb88
leaq 0x4eebe(%rip), %rsi     # 0x102c9d
callq 0x57010
leaq 0xb8dcd(%rip), %rdi     # 0x16cbb8
leaq 0x4eeaf(%rip), %rsi     # 0x102ca1
callq 0x57010
leaq 0xb8da2(%rip), %rdi     # 0x16cba0
leaq 0x4eea0(%rip), %rsi     # 0x102ca5
callq 0x57010
leaq 0xb8dbf(%rip), %rdi     # 0x16cbd0
leaq 0x4ee91(%rip), %rsi     # 0x102ca9
callq 0x57010
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%r15)
andl $0x0, 0x50(%r15)
movabsq $0x6400000000, %rax     # imm = 0x6400000000
movq %rax, 0x58(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x58c30
movabsq $0x4b0000004b, %rax     # imm = 0x4B0000004B
movq %rax, 0x18(%r15)
movl $0x8, 0x54(%r15)
movb $0x1, 0x64(%r15)
andl $0x0, 0x68(%r15)
movq %r12, %rdi
xorl %esi, %esi
callq 0x58c30
movl $0x8, 0x60(%r15)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x59570
movq %rbx, %rdi
callq 0x596e0
movl (%rax), %eax
movl %eax, 0x10(%r15)
movq %rbx, %rdi
callq 0x596e0
movl 0x4(%rax), %eax
movl %eax, 0x14(%r15)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0xb3ec0
movq %rax, %r15
jmp 0xb3ec8
movq %rax, %r15
movq %r12, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x5a4c8
movq %r15, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::PCIIO()
PCIIO::PCIIO()
{
	cfNames[Color::RGB]	= "RGB";
	cfNames[Color::RGBA]	= "RGA";
	cfNames[Color::HSV]	= "HSV";
	cfNames[Color::YUV]	= "YUV";
	cfNames[Color::CMY]	= "CMY";
	cfNames[Color::CMYK]	= "CMK";
	cfNames[Color::GRAY]	= "GRY";

	cpNames[RAW]		= "RAW";
	cpNames[PCI]		= "PCI";
	cpNames[RLE]		= "RLE";
	cpNames[JPEG]		= "JPG";
	cpNames[BZIP2]		= "BZ2";

	majorversion		= PCIMajorVersion;
	minorversion		= PCIMinorVersion;
	compression		= RAW;
	colorspace		= Color::RGB;
	quality			= 100;
	description		= NIL;

	dpix			= 75;
	dpiy			= 75;
	bpcc			= 8;
	overwrite		= True;
	imageid			= 0;
	imagename		= NIL;
	rlebits			= 8;

	sizex			= 0;
	sizey			= 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
leaq 0x8(%rdi), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x59c80
leaq 0x20(%r15), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0x38(%r15), %r12
movq %r12, %rdi
xorl %esi, %esi
callq 0x5a180
leaq 0xb8bac(%rip), %rdi     # 0x16cac0
leaq 0x4ed62(%rip), %rsi     # 0x102c7d
callq 0x57010
leaq 0xb8bb1(%rip), %rdi     # 0x16cad8
leaq 0x4ed53(%rip), %rsi     # 0x102c81
callq 0x57010
leaq 0xb8bb6(%rip), %rdi     # 0x16caf0
leaq 0x4ed44(%rip), %rsi     # 0x102c85
callq 0x57010
leaq 0xb8bbb(%rip), %rdi     # 0x16cb08
leaq 0x4ed35(%rip), %rsi     # 0x102c89
callq 0x57010
leaq 0xb8bc0(%rip), %rdi     # 0x16cb20
leaq 0x4ed26(%rip), %rsi     # 0x102c8d
callq 0x57010
leaq 0xb8bc5(%rip), %rdi     # 0x16cb38
leaq 0x4ed17(%rip), %rsi     # 0x102c91
callq 0x57010
leaq 0xb8bca(%rip), %rdi     # 0x16cb50
leaq 0x4ed08(%rip), %rsi     # 0x102c95
callq 0x57010
leaq 0xb8bd7(%rip), %rdi     # 0x16cb70
leaq 0x4ecf9(%rip), %rsi     # 0x102c99
callq 0x57010
leaq 0xb8bdc(%rip), %rdi     # 0x16cb88
leaq 0x4ecea(%rip), %rsi     # 0x102c9d
callq 0x57010
leaq 0xb8bf9(%rip), %rdi     # 0x16cbb8
leaq 0x4ecdb(%rip), %rsi     # 0x102ca1
callq 0x57010
leaq 0xb8bce(%rip), %rdi     # 0x16cba0
leaq 0x4eccc(%rip), %rsi     # 0x102ca5
callq 0x57010
leaq 0xb8beb(%rip), %rdi     # 0x16cbd0
leaq 0x4ecbd(%rip), %rsi     # 0x102ca9
callq 0x57010
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, (%r15)
andl $0x0, 0x50(%r15)
movabsq $0x6400000000, %rax     # imm = 0x6400000000
movq %rax, 0x58(%r15)
movq %r14, %rdi
xorl %esi, %esi
callq 0x58c30
movabsq $0x4b0000004b, %rax     # imm = 0x4B0000004B
movq %rax, 0x18(%r15)
movl $0x8, 0x54(%r15)
movb $0x1, 0x64(%r15)
andl $0x0, 0x68(%r15)
movq %r12, %rdi
xorl %esi, %esi
callq 0x58c30
movl $0x8, 0x60(%r15)
andq $0x0, 0x10(%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0xb4073
movq %rax, %r15
jmp 0xb407b
movq %rax, %r15
movq %r12, %rdi
callq 0x5a588
movq %r14, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x5a4c8
movq %r15, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WritePCIFTAG(smooth::IO::OutStream*)
bool PCIIO::WritePCIFTAG(PCIOut out)
{
	out->OutputString("PCIF");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(-1, 4);
	out->OutputNumber(0 + 14, 4);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e9dc(%rip), %rsi     # 0x102cad
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
pushq $-0x1
popq %rsi
pushq $0x4
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
pushq $0xe
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WriteIMAGTAG(smooth::IO::OutStream*)
bool PCIIO::WriteIMAGTAG(PCIOut out)
{
	out->OutputString("IMAG");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(imageid, 4);
	out->OutputNumber(0 + 14, 4);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e951(%rip), %rsi     # 0x102cb2
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x68(%r14), %rsi
pushq $0x4
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
pushq $0xe
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WriteRESOTAG(smooth::IO::OutStream*)
bool PCIIO::WriteRESOTAG(PCIOut out)
{
	out->OutputString("RESO");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(imageid, 4);
	out->OutputNumber(16 + 14, 4);
	out->OutputNumber(sizex, 4);
	out->OutputNumber(sizey, 4);
	out->OutputNumber(dpix, 4);
	out->OutputNumber(dpiy, 4);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e8c4(%rip), %rsi     # 0x102cb7
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x68(%r14), %rsi
pushq $0x4
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
pushq $0x1e
popq %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x10(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x14(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x18(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x1c(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WriteFORMTAG(smooth::IO::OutStream*)
bool PCIIO::WriteFORMTAG(PCIOut out)
{
	out->OutputString("FORM");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(imageid, 4);

	if (compression == RLE)	out->OutputNumber(6 + 14, 4);
	else			out->OutputNumber(5 + 14, 4);

	out->OutputString(cfNames[colorspace]);
	out->OutputNumber(bpcc, 1);
	out->OutputNumber(compression, 1);

	if (compression == RLE)	out->OutputNumber(rlebits, 1);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x65730(%rip), %rsi     # 0x119bed
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x68(%r14), %rsi
pushq $0x4
popq %r15
movq %rbx, %rdi
movl %r15d, %edx
callq 0x567b0
xorl %esi, %esi
cmpl $0x3, 0x50(%r14)
sete %sil
addq $0x13, %rsi
movq %rbx, %rdi
movl %r15d, %edx
callq 0x567b0
movl 0x58(%r14), %eax
imulq $0x18, %rax, %rax
leaq 0xb858b(%rip), %rsi     # 0x16cac0
addq %rax, %rsi
movq %rbx, %rdi
callq 0x56b30
movslq 0x54(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x50(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
cmpl $0x3, 0x50(%r14)
jne 0xb4572
movslq 0x60(%r14), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x567b0
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WriteDESCTAG(smooth::IO::OutStream*)
bool PCIIO::WriteDESCTAG(PCIOut out)
{
	out->OutputString("DESC");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(imageid, 4);
	out->OutputNumber(description.Length() + 14, 4);
	out->OutputString(description);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e713(%rip), %rsi     # 0x102cbc
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x68(%r14), %rsi
pushq $0x4
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
addq $0x20, %r14
movq %r14, %rdi
callq 0x58370
addl $0xe, %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56b30
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WriteNAMETAG(smooth::IO::OutStream*)
bool PCIIO::WriteNAMETAG(PCIOut out)
{
	out->OutputString("NAME");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(imageid, 4);
	out->OutputNumber(imagename.Length() + 14, 4);
	out->OutputString(imagename);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4ec75(%rip), %rsi     # 0x1032ca
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x68(%r14), %rsi
pushq $0x4
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
addq $0x38, %r14
movq %r14, %rdi
callq 0x58370
addl $0xe, %eax
movslq %eax, %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x56b30
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::WriteDATATAG(smooth::IO::OutStream*)
bool PCIIO::WriteDATATAG(PCIOut out)
{
	out->OutputString("DATA");
	out->OutputNumber(majorversion, 1);
	out->OutputNumber(minorversion, 1);
	out->OutputNumber(imageid, 4);

	int	 dpos = out->GetPos();

	out->OutputNumber(0 + 14, 4);

	CompressPCI(out);

	out->RelSeek(0);

	int	 npos = out->GetPos();
	int	 dsize = npos - dpos - 4;

	out->Seek(dpos);
	out->OutputNumber(dsize + 14, 4);
	out->Seek(npos);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x4e5c0(%rip), %rsi     # 0x102cc1
movq %rsp, %r15
movq %r15, %rdi
callq 0x58c40
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56b30
movq %rsp, %rdi
callq 0x5a588
movslq (%r14), %rsi
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x4(%r14), %rsi
movq %rbx, %rdi
movl %ebp, %edx
callq 0x567b0
movslq 0x68(%r14), %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x567b0
cmpw $0x0, 0x8(%rbx)
je 0xb4759
movq 0x48(%rbx), %r15
jmp 0xb4766
movw $0x5, 0xf8(%rbx)
pushq $-0x1
popq %r15
pushq $0xe
popq %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x567b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb1588
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x30(%rax)
cmpw $0x0, 0x8(%rbx)
je 0xb4797
movq 0x48(%rbx), %r14
jmp 0xb47a4
pushq $-0x1
popq %r14
movw $0x5, 0xf8(%rbx)
movl %r14d, %ebp
subl %r15d, %ebp
movslq %r15d, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
addl $0xa, %ebp
movslq %ebp, %rsi
pushq $0x4
popq %rdx
movq %rbx, %rdi
callq 0x567b0
movslq %r14d, %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x28(%rax)
movb $0x1, %al
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadPCI(smooth::IO::InStream*)
bool PCIIO::ReadPCI(PCIIn instream)
{
	if (instream->GetLastError() != IO::IO_ERROR_OK) return false;

	if (imagename != NIL) FindImageID(instream);

	if (ReadPCIFTAG(instream) == false) return false;
	if (ReadIMAGTAG(instream) == false) return false;
	if (ReadRESOTAG(instream) == false) return false;
	if (ReadFORMTAG(instream) == false) return false;

	ReadDESCTAG(instream);

	if (ReadDATATAG(instream) == false) return false;

	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpw $0x0, 0xf8(%rsi)
jne 0xb487b
movq %rsi, %rbx
movq %rdi, %r14
addq $0x38, %rdi
xorl %esi, %esi
callq 0x57d40
testb %al, %al
je 0xb4822
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4886
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4a14
testb %al, %al
je 0xb487b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4b8a
testb %al, %al
je 0xb487b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4cf4
testb %al, %al
je 0xb487b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb4e9e
testb %al, %al
je 0xb487b
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb50d6
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xb5256
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::FindImageID(smooth::IO::InStream*)
bool PCIIO::FindImageID(PCIIn in)
{
	int	 imageid = 0;

	in->Seek(0);

	do
	{
		static String	 nameTag = "NAME";

		if (in->InputString(4).Compare(nameTag) == 0)
		{
			in->RelSeek(2);

			imageid = in->InputNumber(4);

			if (in->InputString(in->InputNumber(4) - 14).Compare(imagename) == 0)
			{
				this->imageid = imageid;

				return true;
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
movq %rbx, (%rsp)
leaq 0x38(%rbx), %rax
movq %rax, 0x8(%rsp)
leaq 0xb840f(%rip), %r13     # 0x16ccc8
leaq 0x10(%rsp), %r12
pushq $0x4
popq %rbp
movb 0xb8419(%rip), %al      # 0x16cce0
testb %al, %al
je 0xb497c
movq %r12, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r12, %rdi
movq %r13, %rsi
callq 0x598b0
movl %eax, %ebx
movq %r12, %rdi
callq 0x5a588
movq (%r14), %rax
movq 0x30(%rax), %rax
movq %r14, %rdi
testl %ebx, %ebx
je 0xb491d
pushq $0x6
popq %rsi
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
leaq -0xe(%rax), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
jmp 0xb4964
pushq $0x2
popq %rsi
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
movq %rax, %rbx
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
leal -0xe(%rax), %edx
movq %r12, %rdi
movq %r14, %rsi
callq 0x59cd0
movq %r12, %rdi
movq 0x8(%rsp), %rsi
callq 0x598b0
movl %eax, %r15d
movq %r12, %rdi
callq 0x5a588
testl %r15d, %r15d
je 0xb49e1
cmpw $0x0, 0x8(%r14)
je 0xb49c6
movq 0x10(%r14), %rax
cmpq 0x48(%r14), %rax
jg 0xb48c1
jmp 0xb49d0
leaq 0xb835d(%rip), %rdi     # 0x16cce0
callq 0x57210
testl %eax, %eax
je 0xb48cf
movq %r13, %rdi
leaq 0x4e930(%rip), %rsi     # 0x1032ca
callq 0x58c40
movq 0xad58a(%rip), %rdi     # 0x161f30
movq %r13, %rsi
leaq 0xaf890(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb8324(%rip), %rdi     # 0x16cce0
callq 0x57cf0
jmp 0xb48cf
movw $0x5, 0xf8(%r14)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rax
movl %ebx, 0x68(%rax)
movb $0x1, %al
jmp 0xb49d2
movq %rax, %rbx
leaq 0xb82ea(%rip), %rdi     # 0x16cce0
callq 0x57520
jmp 0xb4a0c
jmp 0xb49ff
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadPCIFTAG(smooth::IO::InStream*)
bool PCIIO::ReadPCIFTAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 pcifTag = "PCIF";

		if (in->InputString(4).Compare(pcifTag) == 0)
		{
			majorversion = in->InputNumber(1);
			minorversion = in->InputNumber(1);

			if (in->InputNumber(4) != -1)	return false;
			if (in->InputNumber(4) != 14)	return false;
			else				return true;
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xb81ac(%rip), %r12     # 0x16cbe8
leaq 0x10(%rsp), %r13
pushq $0x4
popq %rbp
pushq $0x6
popq %r15
movb 0xb81b2(%rip), %al      # 0x16cc00
testb %al, %al
je 0xb4abb
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r13, %rdi
movq %r12, %rsi
callq 0x598b0
movl %eax, %r14d
movq %r13, %rdi
callq 0x5a588
testl %r14d, %r14d
je 0xb4b01
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *0x30(%rax)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
leaq -0xe(%rax), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpw $0x0, 0x8(%rbx)
je 0xb4b49
movq 0x10(%rbx), %rax
cmpq 0x48(%rbx), %rax
jg 0xb4a48
jmp 0xb4b52
leaq 0xb813e(%rip), %rdi     # 0x16cc00
callq 0x57210
testl %eax, %eax
je 0xb4a52
movq %r12, %rdi
leaq 0x4e1d8(%rip), %rsi     # 0x102cad
callq 0x58c40
movq 0xad44f(%rip), %rdi     # 0x161f30
movq %r12, %rsi
leaq 0xaf755(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb8109(%rip), %rdi     # 0x16cc00
callq 0x57cf0
jmp 0xb4a52
pushq $0x1
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
movq 0x8(%rsp), %r14
movl %eax, (%r14)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
movl %eax, 0x4(%r14)
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x56f60
cmpq $-0x1, %rax
jne 0xb4b52
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x56f60
cmpq $0xe, %rax
sete %al
jmp 0xb4b54
movw $0x5, 0xf8(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xb8093(%rip), %rdi     # 0x16cc00
callq 0x57520
jmp 0xb4b81
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadIMAGTAG(smooth::IO::InStream*)
bool PCIIO::ReadIMAGTAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 imagTag = "IMAG";

		if (in->InputString(4).Compare(imagTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				if (in->InputNumber(4) != 14)	return false;
				else				return true;
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xb8056(%rip), %r12     # 0x16cc08
leaq 0x10(%rsp), %r13
pushq $0x4
popq %rbp
movb 0xb8060(%rip), %al      # 0x16cc20
testb %al, %al
je 0xb4c60
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r13, %rdi
movq %r12, %rsi
callq 0x598b0
movl %eax, %r15d
movq %r13, %rdi
callq 0x5a588
movq (%rbx), %rax
movq 0x30(%rax), %rax
movq %rbx, %rdi
testl %r15d, %r15d
je 0xb4c0b
pushq $0x6
popq %rsi
callq *%rax
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
jmp 0xb4c39
pushq $0x2
popq %rsi
callq *%rax
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
movq %rax, %r15
movq 0x8(%rsp), %rax
movslq 0x68(%rax), %r14
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
cmpq %r14, %r15
je 0xb4cc4
addq $-0xe, %rax
movq (%rbx), %rcx
movq %rbx, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
cmpw $0x0, 0x8(%rbx)
je 0xb4caa
movq 0x10(%rbx), %rax
cmpq 0x48(%rbx), %rax
jg 0xb4bba
jmp 0xb4cb3
leaq 0xb7fb9(%rip), %rdi     # 0x16cc20
callq 0x57210
testl %eax, %eax
je 0xb4bc8
movq %r12, %rdi
leaq 0x4e034(%rip), %rsi     # 0x102cb2
callq 0x58c40
movq 0xad2a6(%rip), %rdi     # 0x161f30
movq %r12, %rsi
leaq 0xaf5ac(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb7f80(%rip), %rdi     # 0x16cc20
callq 0x57cf0
jmp 0xb4bc8
movw $0x5, 0xf8(%rbx)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0xe, %rax
sete %al
jmp 0xb4cb5
movq %rax, %rbx
leaq 0xb7f49(%rip), %rdi     # 0x16cc20
callq 0x57520
jmp 0xb4ceb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadRESOTAG(smooth::IO::InStream*)
bool PCIIO::ReadRESOTAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 resoTag = "RESO";

		if (in->InputString(4).Compare(resoTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				if (in->InputNumber(4) != 30)	return false;
				else
				{
					sizex = in->InputNumber(4);
					sizey = in->InputNumber(4);
					dpix = in->InputNumber(4);
					dpiy = in->InputNumber(4);

					return true;
				}
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, 0x8(%rsp)
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xb7f0c(%rip), %r12     # 0x16cc28
leaq 0x10(%rsp), %r13
pushq $0x4
popq %rbp
movb 0xb7f16(%rip), %al      # 0x16cc40
testb %al, %al
je 0xb4dc9
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r13, %rdi
movq %r12, %rsi
callq 0x598b0
movl %eax, %ebx
movq %r13, %rdi
callq 0x5a588
movq (%r14), %rax
movq 0x30(%rax), %rax
movq %r14, %rdi
testl %ebx, %ebx
je 0xb4d73
pushq $0x6
popq %rsi
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
jmp 0xb4da1
pushq $0x2
popq %rsi
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
movq %rax, %rbx
movq 0x8(%rsp), %rax
movslq 0x68(%rax), %r15
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
cmpq %r15, %rbx
je 0xb4e2e
addq $-0xe, %rax
movq (%r14), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *0x30(%rcx)
cmpw $0x0, 0x8(%r14)
je 0xb4e13
movq 0x10(%r14), %rax
cmpq 0x48(%r14), %rax
jg 0xb4d24
jmp 0xb4e1d
leaq 0xb7e70(%rip), %rdi     # 0x16cc40
callq 0x57210
testl %eax, %eax
je 0xb4d32
movq %r12, %rdi
leaq 0x4ded0(%rip), %rsi     # 0x102cb7
callq 0x58c40
movq 0xad13d(%rip), %rdi     # 0x161f30
movq %r12, %rsi
leaq 0xaf443(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb7e37(%rip), %rdi     # 0x16cc40
callq 0x57cf0
jmp 0xb4d32
movw $0x5, 0xf8(%r14)
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpq $0x1e, %rax
jne 0xb4e1d
pushq $0x4
popq %rbx
movq %r14, %rdi
movl %ebx, %esi
callq 0x56f60
movq 0x8(%rsp), %r15
movl %eax, 0x10(%r15)
movq %r14, %rdi
movl %ebx, %esi
callq 0x56f60
movl %eax, 0x14(%r15)
movq %r14, %rdi
movl %ebx, %esi
callq 0x56f60
movl %eax, 0x18(%r15)
movq %r14, %rdi
movl %ebx, %esi
callq 0x56f60
movl %eax, 0x1c(%r15)
movb $0x1, %al
jmp 0xb4e1f
movq %rax, %rbx
leaq 0xb7dbe(%rip), %rdi     # 0x16cc40
callq 0x57520
jmp 0xb4e96
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadDESCTAG(smooth::IO::InStream*)
bool PCIIO::ReadDESCTAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 descTag = "DESC";

		if (in->InputString(4).Compare(descTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				description = in->InputString(in->InputNumber(4) - 14);

				return true;
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xb7b6c(%rip), %r12     # 0x16cc68
movq %rsp, %r13
pushq $0x4
popq %rbp
movb 0xb7b78(%rip), %al      # 0x16cc80
testb %al, %al
je 0xb5194
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r13, %rdi
movq %r12, %rsi
callq 0x598b0
movl %eax, %r15d
movq %r13, %rdi
callq 0x5a588
movq (%r14), %rax
movq 0x30(%rax), %rax
movq %r14, %rdi
testl %r15d, %r15d
je 0xb5149
pushq $0x6
popq %rsi
callq *%rax
jmp 0xb5165
pushq $0x2
popq %rsi
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
movslq 0x68(%rbx), %rcx
cmpq %rcx, %rax
je 0xb51f9
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
leaq -0xe(%rax), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
cmpw $0x0, 0x8(%r14)
je 0xb51de
movq 0x10(%r14), %rax
cmpq 0x48(%r14), %rax
jg 0xb5102
jmp 0xb51e8
leaq 0xb7ae5(%rip), %rdi     # 0x16cc80
callq 0x57210
testl %eax, %eax
je 0xb5110
movq %r12, %rdi
leaq 0x4db0a(%rip), %rsi     # 0x102cbc
callq 0x58c40
movq 0xacd72(%rip), %rdi     # 0x161f30
movq %r12, %rsi
leaq 0xaf078(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb7aac(%rip), %rdi     # 0x16cc80
callq 0x57cf0
jmp 0xb5110
movw $0x5, 0xf8(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x56f60
leal -0xe(%rax), %edx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x59cd0
addq $0x20, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56630
movq %rsp, %rdi
callq 0x5a588
movb $0x1, %al
jmp 0xb51ea
movq %rax, %rbx
leaq 0xb7a46(%rip), %rdi     # 0x16cc80
callq 0x57520
jmp 0xb524e
jmp 0xb5243
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadDATATAG(smooth::IO::InStream*)
bool PCIIO::ReadDATATAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 dataTag = "DATA";

		if (in->InputString(4).Compare(dataTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				in->RelSeek(4);

				bmp.CreateBitmap(Size(sizex, sizey));

				DecompressPCI(in);

				return true;
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xb7a2c(%rip), %r12     # 0x16cca8
movq %rsp, %r13
pushq $0x4
popq %rbp
movb 0xb7a38(%rip), %al      # 0x16ccc0
testb %al, %al
je 0xb5313
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r13, %rdi
movq %r12, %rsi
callq 0x598b0
movl %eax, %r15d
movq %r13, %rdi
callq 0x5a588
movq (%rbx), %rax
movq 0x30(%rax), %rax
movq %rbx, %rdi
testl %r15d, %r15d
je 0xb52c9
pushq $0x6
popq %rsi
callq *%rax
jmp 0xb52e5
pushq $0x2
popq %rsi
callq *%rax
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
movslq 0x68(%r14), %rcx
cmpq %rcx, %rax
je 0xb5377
movq %rbx, %rdi
movl %ebp, %esi
callq 0x56f60
leaq -0xe(%rax), %rsi
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x30(%rax)
cmpw $0x0, 0x8(%rbx)
je 0xb535d
movq 0x10(%rbx), %rax
cmpq 0x48(%rbx), %rax
jg 0xb5282
jmp 0xb5366
leaq 0xb79a6(%rip), %rdi     # 0x16ccc0
callq 0x57210
testl %eax, %eax
je 0xb5290
movq %r12, %rdi
leaq 0x4d990(%rip), %rsi     # 0x102cc1
callq 0x58c40
movq 0xacbf3(%rip), %rdi     # 0x161f30
movq %r12, %rsi
leaq 0xaeef9(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb796d(%rip), %rdi     # 0x16ccc0
callq 0x57cf0
jmp 0xb5290
movw $0x5, 0xf8(%rbx)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rax
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq *0x30(%rax)
leaq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
pushq $-0x1
popq %rdx
callq 0x58ea0
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb1e36
movb $0x1, %al
jmp 0xb5368
movq %rax, %rbx
leaq 0xb790e(%rip), %rdi     # 0x16ccc0
callq 0x57520
jmp 0xb53c4
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/misc/pciio.cpp
// Function: PCIIO::ReadNAMETAG(smooth::IO::InStream*)
bool PCIIO::ReadNAMETAG(PCIIn in)
{
	in->Seek(0);

	do
	{
		static String	 nameTag = "NAME";

		if (in->InputString(4).Compare(nameTag) == 0)
		{
			in->RelSeek(2);

			if (in->InputNumber(4) == imageid)
			{
				imagename = in->InputString(in->InputNumber(4) - 14);

				return true;
			}
			else
			{
				in->RelSeek(in->InputNumber(4) - 14);
			}
		}
		else
		{
			in->RelSeek(6);

			in->RelSeek(in->InputNumber(4) - 14);
		}
	}
	while (in->Size() > in->GetPos());

	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x28(%rax)
leaq 0xb7896(%rip), %r12     # 0x16cc88
movq %rsp, %r13
pushq $0x4
popq %rbp
movb 0xb78a2(%rip), %al      # 0x16cca0
testb %al, %al
je 0xb548a
movq %r13, %rdi
movq %r14, %rsi
movl %ebp, %edx
callq 0x59cd0
movq %r13, %rdi
movq %r12, %rsi
callq 0x598b0
movl %eax, %r15d
movq %r13, %rdi
callq 0x5a588
movq (%r14), %rax
movq 0x30(%rax), %rax
movq %r14, %rdi
testl %r15d, %r15d
je 0xb543f
pushq $0x6
popq %rsi
callq *%rax
jmp 0xb545b
pushq $0x2
popq %rsi
callq *%rax
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
movslq 0x68(%rbx), %rcx
cmpq %rcx, %rax
je 0xb54ef
movq %r14, %rdi
movl %ebp, %esi
callq 0x56f60
leaq -0xe(%rax), %rsi
movq (%r14), %rax
movq %r14, %rdi
callq *0x30(%rax)
cmpw $0x0, 0x8(%r14)
je 0xb54d4
movq 0x10(%r14), %rax
cmpq 0x48(%r14), %rax
jg 0xb53f8
jmp 0xb54de
leaq 0xb780f(%rip), %rdi     # 0x16cca0
callq 0x57210
testl %eax, %eax
je 0xb5406
movq %r12, %rdi
leaq 0x4de22(%rip), %rsi     # 0x1032ca
callq 0x58c40
movq 0xaca7c(%rip), %rdi     # 0x161f30
movq %r12, %rsi
leaq 0xaed82(%rip), %rdx     # 0x164240
callq 0x590a0
leaq 0xb77d6(%rip), %rdi     # 0x16cca0
callq 0x57cf0
jmp 0xb5406
movw $0x5, 0xf8(%r14)
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x4
popq %rsi
movq %r14, %rdi
callq 0x56f60
leal -0xe(%rax), %edx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x59cd0
addq $0x38, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x56630
movq %rsp, %rdi
callq 0x5a588
movb $0x1, %al
jmp 0xb54e0
movq %rax, %rbx
leaq 0xb7770(%rip), %rdi     # 0x16cca0
callq 0x57520
jmp 0xb5544
jmp 0xb5539
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/gui/dialogs/directory/dirdlg_gtk.cpp
// Function: smooth::GUI::Dialogs::DirSelection::ShowDialog()
const Error &S::GUI::Dialogs::DirSelection::ShowDialog()
{
	/* Create file chooser dialog.
	 */
	GtkWidget	*dialog = gtk_file_chooser_dialog_new(caption, NULL, GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
							      GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
							      GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
							      NULL);

	if (directory != NIL) gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), directory);

	/* Run dialog and check result.
	 */
	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
	{
		char	*name = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));

		directory.ImportFrom("UTF-8", name);

		g_free(name);
	}
	else
	{
		directory = NIL;
	}

	gtk_widget_destroy(dialog);

	/* Wait for GTK to finish pending actions.
	 */
	while (gtk_events_pending()) gtk_main_iteration();

	/* Check if we actually have a directory.
	 */
	if (directory != NIL)
	{
		if (!directory.EndsWith(Directory::GetDirectoryDelimiter())) directory.Append(Directory::GetDirectoryDelimiter());
	}
	else
	{
		error = Error();
	}

	return error;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
addq $0x5b8, %rdi            # imm = 0x5B8
callq 0x598d0
andq $0x0, 0x8(%rsp)
movl $0xfffffffd, (%rsp)     # imm = 0xFFFFFFFD
leaq 0x4d74b(%rip), %rcx     # 0x102cc6
leaq 0x4d74f(%rip), %r9      # 0x102cd1
pushq $0x2
popq %rdx
pushq $-0x6
popq %r8
movq %rax, %rdi
xorl %esi, %esi
xorl %eax, %eax
callq 0x59c90
movq %rax, %r15
leaq 0x5e8(%rbx), %r14
movq %r14, %rdi
xorl %esi, %esi
callq 0x57d40
testb %al, %al
je 0xb55d3
callq 0x58a30
movq %r15, %rdi
movq %rax, %rsi
callq 0x56450
movq %rax, %r12
movq %r14, %rdi
callq 0x598d0
movq %r12, %rdi
movq %rax, %rsi
callq 0x57270
callq 0x58390
movq %r15, %rdi
movq %rax, %rsi
callq 0x56450
movq %rax, %rdi
callq 0x56ce0
cmpl $-0x3, %eax
jne 0xb5627
callq 0x58a30
movq %r15, %rdi
movq %rax, %rsi
callq 0x56450
movq %rax, %rdi
callq 0x58cf0
movq %rax, %r12
leaq 0x4cbb4(%rip), %rsi     # 0x1021c6
movq %r14, %rdi
movq %rax, %rdx
callq 0x57ab0
movq %r12, %rdi
callq 0x56bc0
jmp 0xb5631
movq %r14, %rdi
xorl %esi, %esi
callq 0x58c30
movq %r15, %rdi
callq 0x565c0
callq 0x597f0
testl %eax, %eax
je 0xb5649
callq 0x56060
jmp 0xb5639
movq %r14, %rdi
xorl %esi, %esi
callq 0x57d40
testb %al, %al
je 0xb56b4
callq 0x563a0
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x58c40
movq %r14, %rdi
movq %r15, %rsi
callq 0x59e50
movl %eax, %ebp
leaq 0x18(%rsp), %rdi
callq 0x5a588
testb %bpl, %bpl
jne 0xb56bb
callq 0x563a0
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x58c40
movq %r14, %rdi
movq %r15, %rsi
callq 0x573e0
leaq 0x18(%rsp), %rdi
callq 0x5a588
jmp 0xb56bb
orl $-0x1, 0x5e0(%rbx)
addq $0x5d8, %rbx            # imm = 0x5D8
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb56d4
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::Init()
S::Int S::Backends::BackendXLib::Init()
{
	XInitThreads();

	/* Open display.
	 */
	const char	*displayId = getenv("DISPLAY");

	if (displayId != NIL)
	{
		display	= XOpenDisplay(NIL);

		if (display == NIL)
		{
			fprintf(stderr, "Error: Unable to open display at %s.\n", displayId);

			return Error();
		}

		/* Init the GTK with SIGALRM signals disabled to make
		 * threads created by gtk_init inherit this SIGMASK.
		 */
		toggleTimerInterrupts(false);

		gtk_init(NULL, NULL);

		toggleTimerInterrupts(true);

		/* Get default colors.
		 */
		UpdateColors();

		/* Set locale and open input method.
		 */
		setlocale(LC_ALL, "");

		XSetLocaleModifiers("");

		im = XOpenIM(display, NIL, NIL, NIL);
	}

	return Success();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
callq 0x56420
leaq 0x4cd3c(%rip), %rdi     # 0x102d10
callq 0x58950
testq %rax, %rax
je 0xb6048
movq %rax, %r14
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x5a4b0
movq %rax, 0xb6cff(%rip)     # 0x16ccf0
testq %rax, %rax
je 0xb6054
xorl %edi, %edi
callq 0xb6074
xorl %edi, %edi
xorl %esi, %esi
callq 0x575d0
pushq $0x1
popq %rdi
callq 0xb6074
callq 0xb60b0
leaq 0x4b90e(%rip), %r14     # 0x101928
pushq $0x6
popq %rdi
movq %r14, %rsi
callq 0x58a00
movq %r14, %rdi
callq 0x572c0
movq 0xb6cbc(%rip), %rdi     # 0x16ccf0
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x57390
movq %rax, 0xb6cb2(%rip)     # 0x16ccf8
jmp 0xb604a
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0xab86d(%rip), %rax     # 0x1618c8
movq (%rax), %rdi
leaq 0x4ccb3(%rip), %rsi     # 0x102d18
movq %r14, %rdx
xorl %eax, %eax
callq 0x56930
pushq $-0x1
popq %rbx
jmp 0xb604a
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::UpdateColors()
S::Void S::Backends::BackendXLib::UpdateColors()
{
	/* Check desktop environment.
	 */
	String			 desktop = getenv("XDG_CURRENT_DESKTOP");
	const Array<String>	&IDs	 = desktop.Explode(":");

	foreach (const String &ID, IDs)
	{
		if (ID == "KDE" && UpdateColorsKDE()) return;
	}

	UpdateColorsGnome();
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %rsp
leaq 0x4cc7b(%rip), %rdi     # 0x102d3e
callq 0x58950
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0x2cff2(%rip), %rsi     # 0xe30ce
leaq 0x8(%rsp), %rdi
callq 0x58c40
leaq 0x38(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x591a0
leaq 0x8(%rsp), %rdi
callq 0x5a588
xorl %ebx, %ebx
leaq 0x38(%rsp), %r14
leaq 0x4cc40(%rip), %r15     # 0x102d52
leal -0x1(%rbx), %eax
movl 0x40(%rsp), %ecx
decl %ecx
cmpl %ecx, %eax
jge 0xb6145
movq %r14, %rdi
movl %ebx, %esi
callq 0x64d9c
movq %rax, %rdi
movq %r15, %rsi
callq 0x59180
testb %al, %al
je 0xb6141
callq 0xb61ca
testb %al, %al
jne 0xb614a
incl %ebx
jmp 0xb6112
callq 0xb68aa
leaq 0x38(%rsp), %rdi
callq 0x64988
leaq 0x20(%rsp), %rdi
callq 0x5a588
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0xb6183
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x5a588
jmp 0xb6190
movq %rax, %rbx
jmp 0xb6190
jmp 0xb6183
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x64988
leaq 0x20(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: get_gtk_color(unsigned long, char const*, GtkStateFlags, bool)
static GdkRGBA get_gtk_color(GType type, const gchar *className, GtkStateFlags stateFlags, bool background)
{
	/* Create dummy widget of requested type.
	 */
	GtkWidget	*widget = NIL;

	if	(type == GTK_TYPE_WINDOW)      widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
	else if	(type == GTK_TYPE_TOOLTIP)     widget = gtk_window_new(GTK_WINDOW_POPUP);
	else if	(type == GTK_TYPE_BUTTON)      widget = gtk_button_new();
	else if	(type == GTK_TYPE_TEXT_VIEW)   widget = gtk_text_view_new();
	else if	(type == GTK_TYPE_LINK_BUTTON) widget = gtk_link_button_new("");

	if (widget == NIL) return { 0, 0, 0, 0 };

	/* Get GtkStyleContext to query color.
	 */
	GtkStyleContext *style = gtk_widget_get_style_context(widget);

	gtk_style_context_add_class(style, className);

	/* Query color from style context.
	 */
	GdkRGBA	 color;

	if (background) gtk_style_context_get_background_color(style, stateFlags, &color);
	else		gtk_style_context_get_color(style, stateFlags, &color);

	g_object_ref_sink(widget);
	g_object_unref(widget);

	return color;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r14d
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x59fa0
cmpq %r12, %rax
jne 0xb6f1b
xorl %edi, %edi
jmp 0xb6f28
callq 0x580c0
cmpq %r12, %rax
jne 0xb6f76
pushq $0x1
popq %rdi
callq 0x59810
movq %rax, %r12
testq %rax, %rax
je 0xb6fb3
movq %r12, %rdi
callq 0x56390
movq %rax, %r13
movq %rax, %rdi
movq %r15, %rsi
callq 0x58e20
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
testb %r14b, %r14b
je 0xb6f5f
callq 0x591b0
jmp 0xb6f64
callq 0x565e0
movq %r12, %rdi
callq 0x583f0
movq %r12, %rdi
callq 0x59790
jmp 0xb6fbd
callq 0x57c20
cmpq %r12, %rax
jne 0xb6f87
callq 0x570e0
jmp 0xb6f2d
callq 0x58430
cmpq %r12, %rax
jne 0xb6f98
callq 0x5a140
jmp 0xb6f2d
callq 0x56a80
cmpq %r12, %rax
jne 0xb6fb3
leaq 0x4a97f(%rip), %rdi     # 0x101928
callq 0x56e00
jmp 0xb6f2d
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movups %xmm0, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: get_kde_color(smooth::String const&, smooth::String const&)
static S::GUI::Color get_kde_color(const S::String &category, const S::String &color)
{
	S::String			 spec	= S::Backends::BackendXLib::QueryKDESettings(S::String("Colors:").Append(category), color);
	const S::Array<S::String>	&values = spec.Explode(",");

	if (values.Length() != 3) return S::GUI::Color();

	return S::GUI::Color(values.GetNth(0).ToInt(), values.GetNth(1).ToInt(), values.GetNth(2).ToInt());
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x4be21(%rip), %rsi     # 0x102e0e
leaq 0x30(%rsp), %r12
movq %r12, %rdi
callq 0x58c40
movq %r12, %rdi
movq %r15, %rsi
callq 0x573e0
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xb7524
leaq 0x30(%rsp), %rdi
callq 0x5a588
leaq 0x4bdf0(%rip), %rsi     # 0x102e16
movq %rsp, %rdi
callq 0x58c40
leaq 0x30(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %rsp, %rdx
callq 0x591a0
movq %rsp, %rdi
callq 0x5a588
cmpl $0x3, 0x38(%rsp)
jne 0xb70a5
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
callq 0x6bb28
movq %rax, %rdi
callq 0x57a10
movq %rax, %r14
leaq 0x30(%rsp), %rdi
pushq $0x1
popq %rsi
callq 0x6bb28
movq %rax, %rdi
callq 0x57a10
movq %rax, %r15
leaq 0x30(%rsp), %rdi
pushq $0x2
popq %rsi
callq 0x6bb28
movq %rax, %rdi
callq 0x57a10
shll $0x10, %eax
shll $0x8, %r15d
orl %r14d, %r15d
orl %eax, %r15d
movslq %r15d, %rax
jmp 0xb70a7
xorl %eax, %eax
movq %rax, 0x8(%rbx)
andl $0x0, (%rbx)
leaq 0x30(%rsp), %rdi
callq 0x64988
leaq 0x18(%rsp), %rdi
callq 0x5a588
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x5a588
jmp 0xb70fd
movq %rax, %rbx
jmp 0xb70fd
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0xb7102
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x64988
leaq 0x18(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260
nop
// File: /workspace/github_c_makefile_star2_O2/enzo1982[P]smooth/classes/backends/xlib/backendxlib.cpp
// Function: smooth::Backends::BackendXLib::FindExecutable(smooth::String const&)
S::String S::Backends::BackendXLib::FindExecutable(const String &executable)
{
	/* Search the path for executable.
	 */
	String			 path  = getenv("PATH");
	const Array<String>	&paths = path.Explode(":");

	foreach (const String &path, paths)
	{
		/* Check for executable in this path.
		 */
		File	 file(String(path).Append("/").Append(executable));

		if (file.Exists()) return file;
	}

	return NIL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rsi, 0x18(%rsp)
movq %rdi, %rbx
leaq 0x4b2d7(%rip), %rdi     # 0x102417
callq 0x58950
leaq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x58c40
leaq 0x2bf75(%rip), %rsi     # 0xe30ce
leaq 0x38(%rsp), %rdi
callq 0x58c40
movq %rbx, 0x10(%rsp)
leaq 0xb0(%rsp), %rdi
leaq 0x20(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x591a0
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x5a588
pushq $-0x1
popq %rcx
xorl %eax, %eax
leaq 0x98(%rsp), %r13
leaq 0x80(%rsp), %r12
leaq 0x68(%rsp), %rbx
movl %ecx, 0xc(%rsp)
testl %eax, %eax
movl 0xc(%rsp), %esi
jne 0xb72b1
movl 0xb8(%rsp), %eax
decl %eax
cmpl %eax, %esi
jge 0xb72b1
incl %esi
leaq 0xb0(%rsp), %rdi
movl %esi, 0xc(%rsp)
callq 0x64d9c
movq %rax, %rbp
movb $0x1, %cl
pushq $-0x1
popq %rax
testb $0x1, %cl
je 0xb71aa
movq %r13, %rdi
movq %rbp, %rsi
callq 0x58280
movq %r12, %rdi
leaq 0x2c4ac(%rip), %rsi     # 0xe36a8
callq 0x58c40
movq %r13, %rdi
movq %r12, %rsi
callq 0x573e0
movq %rax, %rdi
movq 0x18(%rsp), %rsi
callq 0x573e0
movq %rax, %r14
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x57940
movq %rbx, %rdi
callq 0x5a588
movq %r12, %rdi
callq 0x5a588
movq %r13, %rdi
callq 0x5a588
movq %r15, %rdi
callq 0x580a0
testb %al, %al
jne 0xb7269
movq %r15, %rdi
callq 0x5a500
xorl %ecx, %ecx
xorl %eax, %eax
jmp 0xb71e2
leaq 0x38(%rsp), %rsi
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x5a310
leaq 0x38(%rsp), %rdi
callq 0x5a500
leaq 0xb0(%rsp), %rdi
callq 0x64988
leaq 0x20(%rsp), %rdi
callq 0x5a588
movq %rbx, %rax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%rsp), %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5a180
jmp 0xb7285
jmp 0xb72dc
jmp 0xb72f7
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a588
jmp 0xb7330
movq %rax, %rbx
jmp 0xb7330
jmp 0xb72dc
movq %rax, %rbx
jmp 0xb7323
movq %rax, %rbx
jmp 0xb7316
jmp 0xb7306
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x5a588
jmp 0xb7309
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5a500
jmp 0xb7323
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x5a588
leaq 0x98(%rsp), %rdi
callq 0x5a588
leaq 0xb0(%rsp), %rdi
callq 0x64988
leaq 0x20(%rsp), %rdi
callq 0x5a588
movq %rbx, %rdi
callq 0x58260