LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: ticky[P]ps2iconsys/src/ps2_ps2icon.cpp
// Function: PS2Icon::GetFrameKeyValue(int, int) const
float PS2Icon::GetFrameKeyValue(int frame, int key) const {
	if((static_cast<unsigned int>(frame) >= anim_header.n_frames) ||
	   (static_cast<unsigned int>(key) >= animation[frame].n_keys) ) {
		   throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER ) );
	}
	return anim_keys[frame][key].value;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x50(%rcx), %eax
jae 0xbb77
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x58(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl 0x4(%rcx,%rdx,8), %eax
jb 0xbba9
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x20(%rbp)
movl $0x3, %esi
callq 0xf060
movq -0x20(%rbp), %rdi
leaq 0xc1f3(%rip), %rsi      # 0x17d90
leaq 0x35ac(%rip), %rdx      # 0xf150
callq 0x2340
movq -0x18(%rbp), %rax
movq 0x60(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movss 0x4(%rax,%rcx,8), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: ticky[P]ps2iconsys/src/ps2_ps2icon.cpp
// Function: PS2Icon::GetTextureData(unsigned int*, int) const
void PS2Icon::GetTextureData(unsigned int* data, int pitch) const {
	if((pitch < 512) || (pitch % 4 != 0)) { 
		throw( Ghulbus::gbException( Ghulbus::gbException::GB_ILLEGALPARAMETER ) );
	}
	for(int i=0; i<128; i++) {
		memcpy(&(data[i*(pitch>>2)]), &(texture[i*128]), sizeof(unsigned int)*128);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x200, -0x14(%rbp)     # imm = 0x200
jl 0xbdc4
movl -0x14(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
je 0xbdf6
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movl $0x3, %esi
callq 0xf060
movq -0x28(%rbp), %rdi
leaq 0xbfa6(%rip), %rsi      # 0x17d90
leaq 0x335f(%rip), %rdx      # 0xf150
callq 0x2340
movl $0x0, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jge 0xbe4b
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
sarl $0x2, %ecx
imull %ecx, %eax
cltq
shlq $0x2, %rax
addq %rax, %rdi
addq $0x68, %rsi
movl -0x18(%rbp), %eax
shll $0x7, %eax
cltq
shlq $0x2, %rax
addq %rax, %rsi
movl $0x200, %edx            # imm = 0x200
callq 0x2170
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xbdfd
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader.cpp
// Function: GhulbusUtil::gbImageLoader::gbImageLoader(char const*, GhulbusUtil::gbImageLoader::gbImageType*)
gbImageLoader::gbImageLoader(char const* fname, gbImageType* img_type)
		:m_data(NULL), m_palette(NULL), m_width(0), m_height(0), m_bpp(0)
	{
		std::ifstream file( fname, std::ios_base::binary| std::ios_base::in );
		if( file.fail() ) {
			throw( Ghulbus::gbException( Ghulbus::gbException::GB_FAILED,
				                         "Image file could not be opened" ) );
		}		
		if( !img_type->CheckFile(file) ) {
			throw( Ghulbus::gbException( Ghulbus::gbException::GB_FAILED,
				                         "Image file seems to be corrupted" ) );
		}

		img_type->ReadFile(file, &m_width, &m_height, &m_bpp, &m_data, &m_palette);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
movq $0x0, (%rax)
movq $0x0, 0x8(%rax)
movl $0x0, 0x10(%rax)
movl $0x0, 0x14(%rax)
movl $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x238(%rbp)
movl $0x4, %edi
movl $0x8, %esi
callq 0x9de0
movq -0x238(%rbp), %rsi
movl %eax, %edx
leaq -0x220(%rbp), %rdi
callq 0x2390
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x220(%rbp,%rax), %rdi
callq 0x2030
movb %al, -0x22d(%rbp)
jmp 0xd105
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0xd111
jmp 0xd178
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x248(%rbp)
leaq 0x4270(%rip), %rdx      # 0x1139c
movl $0x1, %esi
callq 0xf0b0
movq -0x248(%rbp), %rdi
leaq 0xac4c(%rip), %rsi      # 0x17d90
leaq 0x2005(%rip), %rdx      # 0xf150
callq 0x2340
jmp 0xd240
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x228(%rbp)
movl %eax, -0x22c(%rbp)
leaq -0x220(%rbp), %rdi
callq 0x2070
jmp 0xd234
movq -0x18(%rbp), %rdi
movq (%rdi), %rax
movq 0x8(%rax), %rax
leaq -0x220(%rbp), %rsi
callq *%rax
movb %al, -0x249(%rbp)
jmp 0xd194
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0xd1e1
jmp 0xd1a0
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x258(%rbp)
leaq 0x4200(%rip), %rdx      # 0x113bb
movl $0x1, %esi
callq 0xf0b0
movq -0x258(%rbp), %rdi
leaq 0xabbd(%rip), %rsi      # 0x17d90
leaq 0x1f76(%rip), %rdx      # 0xf150
callq 0x2340
jmp 0xd240
movq -0x240(%rbp), %r9
movq -0x18(%rbp), %rdi
movq %r9, %rdx
addq $0x10, %rdx
movq %r9, %rcx
addq $0x14, %rcx
movq %r9, %r8
addq $0x18, %r8
movq %r9, %r10
addq $0x8, %r10
movq (%rdi), %rax
movq (%rax), %rax
movq %rsp, %rsi
movq %r10, (%rsi)
leaq -0x220(%rbp), %rsi
callq *%rax
jmp 0xd21f
leaq -0x220(%rbp), %rdi
callq 0x2070
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x228(%rbp), %rdi
callq 0x2370
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader.cpp
// Function: GhulbusUtil::gbImageLoader::GetPaletteData(unsigned int*) const
void gbImageLoader::GetPaletteData(unsigned int* pPal) const {
		switch(m_bpp) {
			case 1:
				memcpy(pPal, m_palette, 2 * 4);
				break;
			case 4:
				memcpy(pPal, m_palette, 16 * 4);
				break;
			case 8:
				memcpy(pPal, m_palette, 256 * 4);
				break;
			default:
				throw( Ghulbus::gbException( Ghulbus::gbException::GB_FAILED,
					                         "Unable to acquire palette data" ) );
				break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x1, %eax
je 0xd3b9
jmp 0xd3a5
movl -0x14(%rbp), %eax
subl $0x4, %eax
je 0xd3cd
jmp 0xd3af
movl -0x14(%rbp), %eax
subl $0x8, %eax
je 0xd3e5
jmp 0xd3fd
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rcx), %rcx
movq (%rcx), %rcx
movq %rcx, (%rax)
jmp 0xd436
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
movl $0x40, %edx
callq 0x2170
jmp 0xd436
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x8(%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2170
jmp 0xd436
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movl $0x1, %esi
leaq 0x3fc2(%rip), %rdx      # 0x113dc
callq 0xf0b0
movq -0x28(%rbp), %rdi
leaq 0xa966(%rip), %rsi      # 0x17d90
leaq 0x1d1f(%rip), %rdx      # 0xf150
callq 0x2340
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader.cpp
// Function: GhulbusUtil::gbImageLoader::FlipV()
void gbImageLoader::FlipV() {
		int pitch;		//fields per row
		switch(m_bpp) {
			case 32: case 24: case 16: case 8: 
				pitch = (m_bpp / 8) * m_width;
				break;
			case 4: case 1:
				pitch = m_width;
				break;
			default:
				throw( Ghulbus::gbException( Ghulbus::gbException::GB_FAILED ) );
				break;
		}
		for(int row=0; row<(m_height/2); row++) {
			for(int i=0; i<pitch; i++) {
				m_data[row * pitch + i] ^= m_data[((m_height-1) - row) * pitch + i]
					^= m_data[row * pitch + i] ^= m_data[((m_height-1) - row) * pitch + i];
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl 0x18(%rax), %eax
movl %eax, -0x18(%rbp)
subl $0x1, %eax
je 0xdb4b
jmp 0xdb01
movl -0x18(%rbp), %eax
subl $0x4, %eax
je 0xdb4b
jmp 0xdb0b
movl -0x18(%rbp), %eax
subl $0x8, %eax
je 0xdb33
jmp 0xdb15
movl -0x18(%rbp), %eax
subl $0x10, %eax
je 0xdb33
jmp 0xdb1f
movl -0x18(%rbp), %eax
subl $0x18, %eax
je 0xdb33
jmp 0xdb29
movl -0x18(%rbp), %eax
subl $0x20, %eax
jne 0xdb57
jmp 0xdb33
movq -0x20(%rbp), %rcx
movl 0x18(%rcx), %eax
movl $0x8, %esi
cltd
idivl %esi
imull 0x10(%rcx), %eax
movl %eax, -0xc(%rbp)
jmp 0xdb89
movq -0x20(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0xc(%rbp)
jmp 0xdb89
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x28(%rbp)
movl $0x1, %esi
callq 0xf060
movq -0x28(%rbp), %rdi
leaq 0xa213(%rip), %rsi      # 0x17d90
leaq 0x15cc(%rip), %rdx      # 0xf150
callq 0x2340
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movl 0x14(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0xdc58
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0xdc48
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl 0x14(%rax), %edx
subl $0x1, %edx
subl -0x10(%rbp), %edx
imull -0xc(%rbp), %edx
addl -0x14(%rbp), %edx
movslq %edx, %rdx
movzbl (%rcx,%rdx), %edi
movq (%rax), %rdx
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rsi
movzbl (%rdx,%rsi), %ecx
xorl %edi, %ecx
movb %cl, (%rdx,%rsi)
movzbl %cl, %edi
movq (%rax), %rdx
movl 0x14(%rax), %ecx
subl $0x1, %ecx
subl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rsi
movzbl (%rdx,%rsi), %ecx
xorl %edi, %ecx
movb %cl, (%rdx,%rsi)
movzbl %cl, %esi
movq (%rax), %rax
movl -0x10(%rbp), %ecx
imull -0xc(%rbp), %ecx
addl -0x14(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xdbb9
jmp 0xdc4a
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xdb90
addq $0x30, %rsp
popq %rbp
retq
nop
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader_TGA.cpp
// Function: GhulbusUtil::FlipImageVertical(GhulbusUtil::TGAHEADER const&, unsigned char*)
static void FlipImageVertical(TGAHEADER const& header, unsigned char* data) {
		//Flip image in Y:
		int p = header.ImagePixelSize >> 3;
		for(int y=0; y<header.Height/2; y++) {
			for(int x=0; x<header.Width; x++) {
				for(int q=0; q<p; q++) {			//loop over different color channels
					data[(y*header.Width + x) * p + q] 
						^= data[((((header.Height-1)-y)*header.Width) + x) * p + q]
						^= data[(y*header.Width + x) * p + q] 
						^= data[((((header.Height-1)-y)*header.Width) + x) * p + q];
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl 0x10(%rax), %eax
sarl $0x3, %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xe(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0xe2a6
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
movzwl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jge 0xe296
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xe286
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movzwl 0xe(%rcx), %ecx
subl $0x1, %ecx
subl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movzwl 0xc(%rdx), %edx
imull %edx, %ecx
addl -0x1c(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rdx
movzwl 0xc(%rdx), %edx
imull %edx, %eax
addl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movslq %eax, %rdx
movzbl (%rcx,%rdx), %eax
xorl %esi, %eax
movb %al, (%rcx,%rdx)
movzbl %al, %esi
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movzwl 0xe(%rax), %eax
subl $0x1, %eax
subl -0x18(%rbp), %eax
movq -0x8(%rbp), %rdx
movzwl 0xc(%rdx), %edx
imull %edx, %eax
addl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movslq %eax, %rdx
movzbl (%rcx,%rdx), %eax
xorl %esi, %eax
movb %al, (%rcx,%rdx)
movzbl %al, %esi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
movzwl 0xc(%rdx), %edx
imull %edx, %ecx
addl -0x1c(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xe1b5
jmp 0xe288
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe19b
jmp 0xe298
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xe171
popq %rbp
retq
nopl (%rax,%rax)
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader_BMP.cpp
// Function: GhulbusUtil::ReadData4Bit(std::basic_ifstream<char, std::char_traits<char>>&, GhulbusUtil::BITMAPINFOHEADER const&, GhulbusUtil::BITMAPFILEHEADER const&, unsigned char*, unsigned int**, unsigned int)
static void ReadData4Bit(std::ifstream& file, BITMAPINFOHEADER const& iheader, BITMAPFILEHEADER const& fheader, 
		                     unsigned char* data, unsigned int** palette, unsigned int file_offset)
	{
		switch(iheader.biCompression)
		{
		case 0:						//uncompressed rgb (4 bits, palettized)
			(*palette) = new unsigned int[16];
			file.read( reinterpret_cast<char*>(*palette), 64 );
			file.seekg( file_offset+fheader.bfOffBits, ::std::ios::beg );
			file.read( reinterpret_cast<char*>(data), (iheader.biWidth*iheader.biHeight)>>1 );
			//unpack data (currently each byte describes two consecutive pixels):
			for(int i=(iheader.biWidth*iheader.biHeight)-1; i>0; i-=2) {
				data[i]   = (data[i>>1] & 0xF);			//Lower half-byte
				data[i-1] = (data[i>>1] & 0xF0) >> 4;	//Upper half-byte
			}
			break;
		default:
			throw( Ghulbus::gbException( Ghulbus::gbException::GB_NOTIMPLEMENTED ) );
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
jne 0xeb06
jmp 0xea31
movl $0x40, %edi
callq 0x2040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl $0x40, %edx
callq 0x2260
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0xa(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2290
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
sarl %eax
movslq %eax, %rdx
callq 0x2260
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
subl $0x1, %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jle 0xeb04
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0xf, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x30(%rbp), %rcx
movb %dl, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
sarl %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
andl $0xf0, %eax
sarl $0x4, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x30(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x30(%rbp)
jmp 0xeaa9
jmp 0xeb38
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movl $0x5, %esi
callq 0xf060
movq -0x38(%rbp), %rdi
leaq 0x9264(%rip), %rsi      # 0x17d90
leaq 0x61d(%rip), %rdx       # 0xf150
callq 0x2340
addq $0x40, %rsp
popq %rbp
retq
nop
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader_BMP.cpp
// Function: GhulbusUtil::ReadData8Bit(std::basic_ifstream<char, std::char_traits<char>>&, GhulbusUtil::BITMAPINFOHEADER const&, GhulbusUtil::BITMAPFILEHEADER const&, unsigned char*, unsigned int**, unsigned int)
static void ReadData8Bit(std::ifstream& file, BITMAPINFOHEADER const& iheader, BITMAPFILEHEADER const& fheader, 
		                     unsigned char* data, unsigned int** palette, unsigned int file_offset)
	{
		switch(iheader.biCompression)
		{
		case 0:						//uncompressed rgb (8 bit, palettized)
			(*palette) = new unsigned int[256];
			file.read( reinterpret_cast<char*>(*palette), 1024 );
			file.seekg( file_offset+fheader.bfOffBits, ::std::ios::beg );
			file.read( reinterpret_cast<char*>(data), iheader.biWidth*iheader.biHeight );
			break;
		default:
			throw( Ghulbus::gbException( Ghulbus::gbException::GB_NOTIMPLEMENTED ) );
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
jne 0xebd0
jmp 0xeb6d
movl $0x400, %edi            # imm = 0x400
callq 0x2040
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq (%rax), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x2260
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0xa(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2290
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
movslq %eax, %rdx
callq 0x2260
jmp 0xec02
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movl $0x5, %esi
callq 0xf060
movq -0x38(%rbp), %rdi
leaq 0x919a(%rip), %rsi      # 0x17d90
leaq 0x553(%rip), %rdx       # 0xf150
callq 0x2340
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader_BMP.cpp
// Function: GhulbusUtil::ReadData24Bit(std::basic_ifstream<char, std::char_traits<char>>&, GhulbusUtil::BITMAPINFOHEADER const&, GhulbusUtil::BITMAPFILEHEADER const&, unsigned char*, unsigned int**, unsigned int)
static void ReadData24Bit(std::ifstream& file, BITMAPINFOHEADER const& iheader, BITMAPFILEHEADER const& fheader, 
		                     unsigned char* data, unsigned int** palette, unsigned int file_offset)
	{
		switch(iheader.biCompression)
		{
		case 0:						//uncompressed rgb (24 bits)
			//read image data:
			file.seekg( file_offset+fheader.bfOffBits, ::std::ios::beg );
			file.read( reinterpret_cast<char*>(data), iheader.biWidth*iheader.biHeight*4 );
			break;
		default:
			throw( Ghulbus::gbException( Ghulbus::gbException::GB_NOTIMPLEMENTED ) );
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
testl %eax, %eax
jne 0xecda
jmp 0xec9d
movq -0x8(%rbp), %rdi
movl -0x2c(%rbp), %eax
movq -0x18(%rbp), %rcx
addl 0xa(%rcx), %eax
movl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
callq 0x2290
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
imull 0x8(%rcx), %eax
shll $0x2, %eax
movslq %eax, %rdx
callq 0x2260
jmp 0xed0c
movl $0x18, %edi
callq 0x20f0
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
movl $0x5, %esi
callq 0xf060
movq -0x38(%rbp), %rdi
leaq 0x9090(%rip), %rsi      # 0x17d90
leaq 0x449(%rip), %rdx       # 0xf150
callq 0x2340
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ticky[P]ps2iconsys/gbLib/src/gbImageLoader_BMP.cpp
// Function: GhulbusUtil::FlipImageVertical(GhulbusUtil::BITMAPINFOHEADER const&, unsigned char*)
static void FlipImageVertical(BITMAPINFOHEADER const& iheader, unsigned char* data) {
		//Flip image in Y:
		int p = (iheader.biBitCount >= 8)?(iheader.biBitCount >> 3):1;
		for(int y=0; y<iheader.biHeight/2; y++) {
			for(int x=0; x<iheader.biWidth; x++) {
				for(int q=0; q<p; q++) {			//loop over different color channels
					data[(y*iheader.biWidth + x) * p + q] 
						^= data[((((iheader.biHeight-1)-y)*iheader.biWidth) + x) * p + q]
						^= data[(y*iheader.biWidth + x) * p + q] 
						^= data[((((iheader.biHeight-1)-y)*iheader.biWidth) + x) * p + q];
				}
			}
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0xe(%rax), %eax
cmpl $0x8, %eax
jl 0xeed9
movq -0x8(%rbp), %rax
movzwl 0xe(%rax), %eax
sarl $0x3, %eax
movl %eax, -0x24(%rbp)
jmp 0xeee3
movl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xeee3
movl -0x24(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
jge 0xf013
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0xf003
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xeff3
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
movl 0x8(%rcx), %ecx
subl $0x1, %ecx
subl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x1c(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %esi
movq -0x10(%rbp), %rcx
movl -0x18(%rbp), %eax
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %eax
addl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movslq %eax, %rdx
movzbl (%rcx,%rdx), %eax
xorl %esi, %eax
movb %al, (%rcx,%rdx)
movzbl %al, %esi
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
subl $0x1, %eax
subl -0x18(%rbp), %eax
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %eax
addl -0x1c(%rbp), %eax
imull -0x14(%rbp), %eax
addl -0x20(%rbp), %eax
movslq %eax, %rdx
movzbl (%rcx,%rdx), %eax
xorl %esi, %eax
movb %al, (%rcx,%rdx)
movzbl %al, %esi
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
movq -0x8(%rbp), %rdx
imull 0x4(%rdx), %ecx
addl -0x1c(%rbp), %ecx
imull -0x14(%rbp), %ecx
addl -0x20(%rbp), %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %edx
xorl %esi, %edx
movb %dl, (%rax,%rcx)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xef30
jmp 0xeff5
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xef19
jmp 0xf005
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xeef0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: ticky[P]ps2iconsys/gbLib/src/gbException.cpp
// Function: Ghulbus::gbException::operator=(Ghulbus::gbException const&)
gbException& gbException::operator=(gbException const& e) throw() {
		if(this != &e) {
			this->m_errorcode = e.m_errorcode;
			this->m_errorstring = e.m_errorstring;
		}
		return (*this);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq -0x10(%rbp), %rax
je 0xf244
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movl 0x8(%rcx), %ecx
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: ticky[P]ps2iconsys/gbLib/src/gbException.cpp
// Function: Ghulbus::gbException::what() const
char const* gbException::what() const throw()
	{
		char const* ret;
		switch(m_errorcode) {
			case gbException::GB_OK:
				ret = "GB_OK - No errors.";
				break;
			case gbException::GB_FAILED:
				ret = "GB_FAILED - The operation failed.";
				break;
			case gbException::GB_OUTOFMEMORY:
				ret = "GB_OUTOFMEMORY - Not enough memory.";
				break;
			case gbException::GB_ILLEGALPARAMETER:
				ret = "GB_ILLEGALPARAMETER - A parameter passed to a function was illegal.";
				break;
			case gbException::GB_INVALIDCONTEXT:
				ret = "GB_INVALIDCONTEXT - A function was called in a wrong context.";
				break;
			case gbException::GB_NOTIMPLEMENTED:
				ret = "GB_NOTIMPLEMENTED - The requested functionality is not yet implemented.";
				break;
			default:
				ret = "Unknown Error.";
				break;
		}
		return ret;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0xf2cb
movq -0x18(%rbp), %rax
leaq 0x22fc(%rip), %rcx      # 0x11570
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x231c(%rip), %rax      # 0x115a0
movq %rax, -0x10(%rbp)
jmp 0xf2d6
leaq 0x2322(%rip), %rax      # 0x115b3
movq %rax, -0x10(%rbp)
jmp 0xf2d6
leaq 0x2337(%rip), %rax      # 0x115d5
movq %rax, -0x10(%rbp)
jmp 0xf2d6
leaq 0x234e(%rip), %rax      # 0x115f9
movq %rax, -0x10(%rbp)
jmp 0xf2d6
leaq 0x2385(%rip), %rax      # 0x1163d
movq %rax, -0x10(%rbp)
jmp 0xf2d6
leaq 0x23b6(%rip), %rax      # 0x1167b
movq %rax, -0x10(%rbp)
jmp 0xf2d6
leaq 0x23f1(%rip), %rax      # 0x116c3
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: ticky[P]ps2iconsys/src/obj_to_ps2icon.cpp
// Function: ListOBJFile(OBJ_FileLoader const*)
void ListOBJFile(OBJ_FileLoader const* obj_file)
{
	std::cout << " * Parsing OBJ file \"" << obj_input_file << "\" contents...\n";
	std::cout << " **  Found " << obj_file->GetNMeshes() << " meshes: " << std::endl;
	for(int i=0; i<obj_file->GetNMeshes(); ++i) {
		OBJ_Mesh const* tmp = obj_file->GetMesh(i);
		std::cout << " **   #" << i << ": " << tmp->GetName() << " - " 
			<< tmp->GetNFaces() << " Triangles, " << tmp->GetNVertices() << " Vertices\n";
	}
	std::cout << " *  done." << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq 0x82e5(%rip), %rdi      # 0x17fd8
leaq 0x1f4a(%rip), %rsi      # 0x11c44
callq 0x21c0
movq %rax, %rdi
movq 0x856f(%rip), %rsi      # 0x18278
callq 0x21c0
movq %rax, %rdi
leaq 0x1f42(%rip), %rsi      # 0x11c5a
callq 0x21c0
movq 0x82b4(%rip), %rdi      # 0x17fd8
leaq 0x1f3e(%rip), %rsi      # 0x11c69
callq 0x21c0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3000
movq -0x20(%rbp), %rdi
movl %eax, %esi
callq 0x2350
movq %rax, %rdi
leaq 0x1f23(%rip), %rsi      # 0x11c75
callq 0x21c0
movq %rax, %rdi
movq 0x825f(%rip), %rsi      # 0x17fc0
callq 0x21f0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rdi
callq 0x3000
movl %eax, %ecx
movl -0x24(%rbp), %eax
cmpl %ecx, %eax
jge 0xfe4a
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x3020
movq %rax, -0x18(%rbp)
movq 0x8238(%rip), %rdi      # 0x17fd8
leaq 0x1ed8(%rip), %rsi      # 0x11c7f
callq 0x21c0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2350
movq %rax, %rdi
leaq 0x1e80(%rip), %rsi      # 0x11c41
callq 0x21c0
movq %rax, -0x40(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3f80
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x1e9e(%rip), %rsi      # 0x11c87
callq 0x21c0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x45d0
movq -0x38(%rbp), %rdi
movl %eax, %esi
callq 0x2350
movq %rax, %rdi
leaq 0x1e7b(%rip), %rsi      # 0x11c8b
callq 0x21c0
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3fc0
movq -0x30(%rbp), %rdi
movl %eax, %esi
callq 0x2350
movq %rax, %rdi
leaq 0x1e61(%rip), %rsi      # 0x11c98
callq 0x21c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xfd6d
movq 0x8187(%rip), %rdi      # 0x17fd8
leaq 0x1e4b(%rip), %rsi      # 0x11ca3
callq 0x21c0
movq %rax, %rdi
movq 0x8159(%rip), %rsi      # 0x17fc0
callq 0x21f0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ticky[P]ps2iconsys/src/obj_to_ps2icon.cpp
// Function: IsBMP(char const*)
bool IsBMP(char const* f)
{
	//check for .bmp ending:
	int len = static_cast<int>(strlen(f));
	if( (f[len-3] == 'B' || f[len-3] == 'b') && 
		(f[len-2] == 'M' || f[len-2] == 'm') && 
		(f[len-1] == 'P' || f[len-1] == 'p') ) {
			GhulbusUtil::gbImageType_BMP_T checker;
			std::ifstream tmp(f, std::ios_base::in | std::ios_base::binary);
			return checker.CheckFile(tmp);
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20e0
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x42, %eax
je 0xfecb
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x3, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x62, %eax
jne 0xffe8
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x4d, %eax
je 0xfefb
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x6d, %eax
jne 0xffe8
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x50, %eax
je 0xff2b
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x70, %eax
jne 0xffe8
leaq -0x28(%rbp), %rdi
callq 0xe360
movq -0x10(%rbp), %rax
movq %rax, -0x248(%rbp)
movl $0x8, %edi
movl $0x4, %esi
callq 0x9de0
movl %eax, -0x240(%rbp)
jmp 0xff56
movl -0x240(%rbp), %edx
movq -0x248(%rbp), %rsi
leaq -0x230(%rbp), %rdi
callq 0x2390
jmp 0xff71
leaq -0x28(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0xe400
movb %al, -0x249(%rbp)
jmp 0xff89
movb -0x249(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x2070
leaq -0x28(%rbp), %rdi
callq 0xe3a0
jmp 0xffec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
jmp 0xffdd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x238(%rbp)
movl %eax, -0x23c(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x2070
leaq -0x28(%rbp), %rdi
callq 0xe3a0
jmp 0xfffa
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x238(%rbp), %rdi
callq 0x2370
nopw %cs:(%rax,%rax)
// File: ticky[P]ps2iconsys/src/obj_to_ps2icon.cpp
// Function: main
int main(int argc, char* argv[])
{
	ParseCommandLine(argc, argv);

	if(!obj_input_file) {
		std::cout << "No input file specified." << std::endl << std::endl;
		PrintHelp(argv[0]);
		exit(1);
	}
	std::cout << "OBJ to PS2Icon Converter  V-1.0\n by Ghulbus Inc.  (http://www.ghulbus-inc.de/)\n" << std::endl;
	if((!list_obj_file) && (!ps2_output_file)) { ps2_output_file = "default.icn"; }

	OBJ_FileLoader* obj_file = LoadOBJFile();

	if(list_obj_file) {
		ListOBJFile(obj_file);
	}

	GhulbusUtil::gbImageLoader* img_loader = NULL;
	if(texture_input_file) {
		img_loader = LoadTexture();
	}
	
	if(ps2_output_file) {
		WriteOutputFile(obj_file, img_loader);
	}

	delete img_loader;
	delete obj_file;

	std::cout << "Success :)" << std::endl;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0xf710
cmpq $0x0, 0x794e(%rip)      # 0x18278
jne 0x10973
movq 0x76a5(%rip), %rdi      # 0x17fd8
leaq 0x1492(%rip), %rsi      # 0x11dcc
callq 0x21c0
movq %rax, %rdi
movq 0x7677(%rip), %rsi      # 0x17fc0
callq 0x21f0
movq %rax, %rdi
movq 0x7668(%rip), %rsi      # 0x17fc0
callq 0x21f0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0xf360
movl $0x1, %edi
callq 0x2220
movq 0x765e(%rip), %rdi      # 0x17fd8
leaq 0x1464(%rip), %rsi      # 0x11de5
callq 0x21c0
movq %rax, %rdi
movq 0x7630(%rip), %rsi      # 0x17fc0
callq 0x21f0
testb $0x1, 0x78fd(%rip)      # 0x18299
jne 0x109b6
cmpq $0x0, 0x78e2(%rip)      # 0x18288
jne 0x109b6
leaq 0x1054(%rip), %rax      # 0x11a03
movq %rax, 0x78d2(%rip)      # 0x18288
callq 0xfaa0
movq %rax, -0x18(%rbp)
testb $0x1, 0x78d3(%rip)      # 0x18299
je 0x109d1
movq -0x18(%rbp), %rdi
callq 0xfce0
movq $0x0, -0x20(%rbp)
cmpq $0x0, 0x78af(%rip)      # 0x18290
je 0x109ec
callq 0x10010
movq %rax, -0x20(%rbp)
cmpq $0x0, 0x7894(%rip)      # 0x18288
je 0x10a03
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x10390
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x10a28
movq -0x28(%rbp), %rdi
callq 0xd240
movq -0x28(%rbp), %rdi
movl $0x20, %esi
callq 0x21e0
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x10a4d
movq -0x30(%rbp), %rdi
callq 0x2f70
movq -0x30(%rbp), %rdi
movl $0x18, %esi
callq 0x21e0
movq 0x7584(%rip), %rdi      # 0x17fd8
leaq 0x13da(%rip), %rsi      # 0x11e35
callq 0x21c0
movq %rax, %rdi
movq 0x7556(%rip), %rsi      # 0x17fc0
callq 0x21f0
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
// File: jflemer[P]boost-chat-server/chat_client.cpp
// Function: chat_client<boost::asio::ip::tcp>::handle_connect(boost::system::error_code const&)
void handle_connect(const boost::system::error_code& error)
  {
    if (!error)
    {
      this->async_receive(&read_msg_,
          boost::bind(&chat_client::handle_read,
              this, boost::asio::placeholders::error));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0c0
testb $0x1, %al
jne 0x1cf99
movq -0x40(%rbp), %rcx
movq %rcx, %rax
addq $0x58, %rax
movq %rax, -0x48(%rbp)
leaq 0x6bb5(%rip), %rax      # 0x23b00
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq 0x36(%rip), %r8         # 0x1cfa0
callq 0x1ce80
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x23a40
addq $0x60, %rsp
popq %rbp
retq
nop
// File: jflemer[P]boost-chat-server/./stream_msg_client.hpp
// Function: void stream_msg_client<chat_message, boost::asio::ip::tcp>::async_receive<boost::_bi::bind_t<void, boost::_mfi::mf1<void, chat_client<boost::asio::ip::tcp>, boost::system::error_code const&>, boost::_bi::list2<boost::_bi::value<chat_client<boost::asio::ip::tcp>*>, boost::arg<1> (*)()>>>(chat_message*, boost::_bi::bind_t<void, boost::_mfi::mf1<void, chat_client<boost::asio::ip::tcp>, boost::system::error_code const&>, boost::_bi::list2<boost::_bi::value<chat_client<boost::asio::ip::tcp>*>, boost::arg<1> (*)()>>)
void async_receive(Message * msg, ReadHandler handler)
  {
      boost::asio::async_read(socket_,
          boost::asio::buffer(msg->data(), message::header_length),
          std::bind(
            &stream_msg_client::handle_read_header<ReadHandler>,
            this, msg, handler, std::placeholders::_1, std::placeholders::_2));
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
addq $0x8, %rax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x23c80
movq %rax, %rdi
movl $0x4, %esi
callq 0x23c50
movq -0x88(%rbp), %r8
movq %rax, %rcx
movq -0x80(%rbp), %rax
movq %rcx, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0x24f(%rip), %rcx       # 0x23cf0
movq %rcx, -0x68(%rbp)
movq $0x0, -0x60(%rbp)
movq %rax, -0x70(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0x10(%rbp), %rcx
movq 0x234c8(%rip), %r9      # 0x46f90
movq 0x23521(%rip), %rax     # 0x46ff0
movq %rax, (%rsp)
callq 0x23c90
movq -0x78(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x58(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x23bf0
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: jflemer[P]boost-chat-server/chat_client.cpp
// Function: chat_client<boost::asio::ip::tcp>::handle_read(boost::system::error_code const&)
void handle_read(const boost::system::error_code& error)
  {
    if (!error)
    {
      std::cout << ">> ";
      std::cout.write(read_msg_.body(), read_msg_.body_length());
      std::cout << "\n";
      this->async_receive(&read_msg_,
          boost::bind(&chat_client::handle_read,
              this, boost::asio::placeholders::error));
    }
    else
    {
      do_close();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0c0
testb $0x1, %al
jne 0x23bd9
movq 0x23488(%rip), %rdi     # 0x46fb8
movq %rdi, -0x50(%rbp)
leaq 0xab26(%rip), %rsi      # 0x2e661
callq 0x8400
movq -0x40(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x48(%rbp)
callq 0x9f70
movq -0x48(%rbp), %rdi
movq %rax, -0x58(%rbp)
callq 0x9f90
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdi
movq %rax, %rdx
callq 0x85a0
movq -0x50(%rbp), %rdi
leaq 0xa524(%rip), %rsi      # 0x2e09d
callq 0x8400
movq -0x40(%rbp), %rcx
leaq -0x89(%rip), %rax       # 0x23b00
movq %rax, -0x38(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x6c08(%rip), %r8      # 0x1cfa0
callq 0x1ce80
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
leaq -0x28(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x23a40
jmp 0x23be2
movq -0x40(%rbp), %rdi
callq 0x27da0
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: jflemer[P]boost-chat-server/./stream_msg_client.hpp
// Function: void stream_msg_client<chat_message, boost::asio::ip::tcp>::handle_read_header<boost::_bi::bind_t<void, boost::_mfi::mf1<void, chat_client<boost::asio::ip::tcp>, boost::system::error_code const&>, boost::_bi::list2<boost::_bi::value<chat_client<boost::asio::ip::tcp>*>, boost::arg<1> (*)()>>>(chat_message*, boost::_bi::bind_t<void, boost::_mfi::mf1<void, chat_client<boost::asio::ip::tcp>, boost::system::error_code const&>, boost::_bi::list2<boost::_bi::value<chat_client<boost::asio::ip::tcp>*>, boost::arg<1> (*)()>>, boost::system::error_code const&, unsigned long)
void handle_read_header(Message * msg, ReadHandler handler, const boost::system::error_code& error, std::size_t bytes_transferred)
  {
    if (!error && msg->decode_header())
    {
      boost::asio::async_read(socket_,
          boost::asio::buffer(msg->body(), msg->body_length()),
          handler);
    }
    else
    {
      handler(error);
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0xd0c0
testb $0x1, %al
jne 0x23d87
movq -0x10(%rbp), %rdi
callq 0x26680
testb $0x1, %al
jne 0x23d34
jmp 0x23d87
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f70
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0x9f90
movq -0x50(%rbp), %rdi
movq %rax, %rsi
callq 0x23c50
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movq %rdx, %rax
movq -0x40(%rbp), %rdx
movq %rcx, -0x30(%rbp)
movq %rax, -0x28(%rbp)
leaq -0x30(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
callq 0x26700
jmp 0x23d94
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x26760
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jflemer[P]boost-chat-server/./chat_message.hpp
// Function: chat_message::decode_header()
bool decode_header()
  {
    using namespace std; // For strncat and atoi.
    char header[header_length + 1] = "";
    strncat(header, data_, header_length);
    body_length_ = atoi(header);
    if (body_length_ > max_body_length)
    {
      body_length_ = 0;
      return false;
    }
    return true;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x15(%rbp), %rdi
xorl %esi, %esi
movl $0x5, %edx
callq 0x8240
movq -0x20(%rbp), %rsi
leaq -0x15(%rbp), %rdi
movl $0x4, %edx
callq 0x82b0
leaq -0x15(%rbp), %rdi
callq 0x86b0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movslq %ecx, %rcx
movq %rcx, 0x208(%rax)
cmpq $0x200, 0x208(%rax) # imm = 0x200
jbe 0x266f1
movq -0x20(%rbp), %rax
movq $0x0, 0x208(%rax)
movb $0x0, -0x1(%rbp)
jmp 0x266f5
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
// File: jflemer[P]boost-chat-server/chat_client.cpp
// Function: chat_client<boost::asio::ip::tcp>::do_write(chat_message)
void do_write(chat_message msg)
  {
    bool write_in_progress = !write_msgs_.empty();
    write_msgs_.push_back(msg);
    if (!write_in_progress)
    {
      boost::asio::async_write(this->socket_,
          boost::asio::buffer(write_msgs_.front().data(),
            write_msgs_.front().length()),
          boost::bind(&chat_client::handle_write, this,
            boost::asio::placeholders::error));
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
addq $0x268, %rdi            # imm = 0x268
callq 0x2a860
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
xorb $-0x1, %al
andb $0x1, %al
movb %al, -0x9(%rbp)
addq $0x268, %rdi            # imm = 0x268
callq 0x2a890
testb $0x1, -0x9(%rbp)
jne 0x29d61
movq -0x58(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
addq $0x268, %rdi            # imm = 0x268
movq %rdi, -0x70(%rbp)
callq 0x2a960
movq %rax, %rdi
callq 0x23c80
movq -0x70(%rbp), %rdi
movq %rax, -0x68(%rbp)
callq 0x2a960
movq %rax, %rdi
callq 0x2a990
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x23c50
movq -0x58(%rbp), %rcx
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq 0xc88(%rip), %rax       # 0x2a9b0
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0xcda7(%rip), %r8      # 0x1cfa0
callq 0x1ce80
movq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a900
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: jflemer[P]boost-chat-server/chat_client.cpp
// Function: chat_client<boost::asio::ip::tcp>::handle_write(boost::system::error_code const&)
void handle_write(const boost::system::error_code& error)
  {
    if (!error)
    {
      write_msgs_.pop_front();
      if (!write_msgs_.empty())
      {
        boost::asio::async_write(this->socket_,
            boost::asio::buffer(write_msgs_.front().data(),
              write_msgs_.front().length()),
            boost::bind(&chat_client::handle_write, this,
              boost::asio::placeholders::error));
      }
    }
    else
    {
      do_close();
    }
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq -0x10(%rbp), %rdi
callq 0xd0c0
testb $0x1, %al
jne 0x2aa97
movq -0x50(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x2cd90
movq -0x50(%rbp), %rdi
addq $0x268, %rdi            # imm = 0x268
callq 0x2a860
testb $0x1, %al
jne 0x2aa95
movq -0x50(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
addq $0x268, %rdi            # imm = 0x268
movq %rdi, -0x68(%rbp)
callq 0x2a960
movq %rax, %rdi
callq 0x23c80
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
callq 0x2a960
movq %rax, %rdi
callq 0x2a990
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x23c50
movq -0x50(%rbp), %rcx
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0xac(%rip), %rax       # 0x2a9b0
movq %rax, -0x48(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
leaq -0x38(%rbp), %rdi
leaq -0xdadb(%rip), %r8      # 0x1cfa0
callq 0x1ce80
movq -0x58(%rbp), %rdi
leaq -0x20(%rbp), %rsi
leaq -0x38(%rbp), %rdx
xorl %eax, %eax
movl %eax, %ecx
callq 0x2a900
jmp 0x2aaa0
movq -0x50(%rbp), %rdi
callq 0x27da0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/matrix.h
// Function: std::ostream& efgy::math::operator<<<double, 3ul, 3ul, char>(std::basic_ostream<char, std::char_traits<char>>&, efgy::math::matrix<double, 3ul, 3ul> const&)
std::ostream &operator<<(std::basic_ostream<C> &stream,
                         const matrix<Q, n, m> &matrix) {
  for (int i = 0; i < n; i++) {
    for (int k = 0; k < m; k++) {
      stream << matrix[i][k] << "\t";
    }
    stream << "\n";
  }
  return stream;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $0x3, %rax
jae 0x6b75
movl $0x0, -0x18(%rbp)
movslq -0x18(%rbp), %rax
cmpq $0x3, %rax
jae 0x6b5a
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x332a0
movq %rax, %rdi
movslq -0x18(%rbp), %rsi
callq 0x332d0
movq -0x20(%rbp), %rdi
movsd (%rax), %xmm0
callq 0x5610
movq %rax, %rdi
leaq 0x2e14c(%rip), %rsi     # 0x34c96
callq 0x5350
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6b08
movq -0x8(%rbp), %rdi
leaq 0x2d6d3(%rip), %rsi     # 0x34238
callq 0x5350
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6af7
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: ef-gy[P]libefgy/include/ef.gy/transformation.h
// Function: efgy::geometry::transformation::affine<double, 3ul>::affine(efgy::geometry::transformation::linear<double, 3ul> const&)
affine(const linear<Q, d> &L) {
    for (std::size_t i = 0; i < d; i++) {
      for (std::size_t j = 0; j < d; j++) {
        matrix[i][j] = L.matrix[i][j];
      }
    }
    for (std::size_t i = 0; i < d; i++) {
      matrix[i][d] = Q(0);
      matrix[d][i] = Q(0);
    }
    matrix[d][d] = Q(1);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
cmpq $0x3, -0x18(%rbp)
jae 0x6c18
movq $0x0, -0x20(%rbp)
cmpq $0x3, -0x20(%rbp)
jae 0x6c08
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x332a0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x332d0
movq -0x30(%rbp), %rdi
movsd (%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq -0x18(%rbp), %rsi
callq 0x6cb0
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x6ce0
movsd -0x38(%rbp), %xmm0
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6baf
jmp 0x6c0a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6ba0
movq $0x0, -0x28(%rbp)
cmpq $0x3, -0x28(%rbp)
jae 0x6c77
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6cb0
movq %rax, %rdi
movl $0x3, %esi
callq 0x6ce0
movq -0x30(%rbp), %rdi
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movl $0x3, %esi
callq 0x6cb0
movq %rax, %rdi
movq -0x28(%rbp), %rsi
callq 0x6ce0
xorps %xmm0, %xmm0
movsd %xmm0, (%rax)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6c20
movq -0x30(%rbp), %rdi
movl $0x3, %esi
callq 0x6cb0
movq %rax, %rdi
movl $0x3, %esi
callq 0x6ce0
movsd 0x2d36e(%rip), %xmm0    # 0x34008
movsd %xmm0, (%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: chenhn123[P]wdt_util_src/wdt_ct/wdt_ct.cpp
// Function: print_help(char const*)
void print_help(const char *prog_name)
{
	print_version();
	
	printf("\nUsage: %s [OPTIONS] [FW_FILE|SUB-ARGU]\n", prog_name);
	printf("\t-h, --help\tPrint this message\n");
	printf("\t-d, --device\ti2c device file associated with the device\n");	
	printf("\t-u, --update\tUpdate firmware with verification\n");
	printf("\t-f, --no_force\tNot to force updating firmware\n");
	printf("\t-b, --no_bind\tNot to rebind driver after firmware updated\n");	
	printf("\t-r, --no_rpara\tNo need to update the recovery parameter\n");
	printf("\t-s, --info\tPrint the info associated with the devcie\n");
	printf("\t-w, --wif-info\tPrint the info associated with wif image file.\n");
	printf("\t-v, --fw-ver\tRead the fw version from the device\n");	
	printf("\t-c, --cfg-ver\tRead the cfg version from the device\n");		
	printf("\t-i, --hw-id\tRead the hardware id from the device\n");			
	printf("\t-x, --ext-info\tShow more information\n");
	printf("\t-k, --block\tUpdate fw by block\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x23d0
movq -0x8(%rbp), %rsi
leaq 0xcc61(%rip), %rdi      # 0xf07d
movb $0x0, %al
callq 0x2050
leaq 0xcc7c(%rip), %rdi      # 0xf0a6
movb $0x0, %al
callq 0x2050
leaq 0xcc8e(%rip), %rdi      # 0xf0c6
movb $0x0, %al
callq 0x2050
leaq 0xccba(%rip), %rdi      # 0xf100
movb $0x0, %al
callq 0x2050
leaq 0xccdd(%rip), %rdi      # 0xf131
movb $0x0, %al
callq 0x2050
leaq 0xccff(%rip), %rdi      # 0xf161
movb $0x0, %al
callq 0x2050
leaq 0xcd2d(%rip), %rdi      # 0xf19d
movb $0x0, %al
callq 0x2050
leaq 0xcd59(%rip), %rdi      # 0xf1d7
movb $0x0, %al
callq 0x2050
leaq 0xcd82(%rip), %rdi      # 0xf20e
movb $0x0, %al
callq 0x2050
leaq 0xcdb4(%rip), %rdi      # 0xf24e
movb $0x0, %al
callq 0x2050
leaq 0xcdd9(%rip), %rdi      # 0xf281
movb $0x0, %al
callq 0x2050
leaq 0xce00(%rip), %rdi      # 0xf2b6
movb $0x0, %al
callq 0x2050
leaq 0xce25(%rip), %rdi      # 0xf2e9
movb $0x0, %al
callq 0x2050
leaq 0xce3e(%rip), %rdi      # 0xf310
movb $0x0, %al
callq 0x2050
addq $0x10, %rsp
popq %rbp
retq
nop