LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/inc/screen.h
// Function: init_screen()
bool init_screen() {

	// Initialization flag
	bool success = true;

	// Initialize SDL
	if (SDL_Init( SDL_INIT_VIDEO) < 0) {
		printf("SDL could not initialize! SDL_Error: %s\n", SDL_GetError());
		success = false;
	}
	else {

		//Set texture filtering to linear
		if( !SDL_SetHint( SDL_HINT_RENDER_SCALE_QUALITY, "1" ) )
		{
			printf( "Warning: Linear texture filtering not enabled!" );
		}

		// Create window
		gWindow = SDL_CreateWindow("GPU", SDL_WINDOWPOS_UNDEFINED,
			SDL_WINDOWPOS_UNDEFINED, SCREEN_WIDTH, SCREEN_HEIGHT, SDL_WINDOW_SHOWN );

		if (gWindow == NULL) {
			printf("Window could not created! SDL_Error: %s\n", SDL_GetError());
			success = false;
		}
		else {

			// Create renderer for window
			gRenderer = SDL_CreateRenderer( gWindow, -1, SDL_RENDERER_ACCELERATED);
			if ( gRenderer == NULL ) {
				printf( "Renderer could not be created! SDL Error: %s\n", SDL_GetError() );
				success = false;
			}
			else {
				// Initialize renderer color
				SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			}
		}
	}

	return success;
}

// Assembly:
pushq %rbx
movl $0x20, %edi
callq 0x2210
testl %eax, %eax
js 0x3680
leaq 0x5a7f(%rip), %rdi      # 0x907b
leaq 0x5a91(%rip), %rsi      # 0x9094
callq 0x2380
testl %eax, %eax
jne 0x361a
leaq 0x5a83(%rip), %rdi      # 0x9096
xorl %eax, %eax
callq 0x2070
leaq 0x5aa4(%rip), %rdi      # 0x90c5
movl $0x1fff0000, %esi       # imm = 0x1FFF0000
movl $0x1fff0000, %edx       # imm = 0x1FFF0000
movl $0x320, %ecx            # imm = 0x320
movl $0x280, %r8d            # imm = 0x280
movl $0x4, %r9d
callq 0x2080
movq %rax, 0x8bc8(%rip)      # 0xc210
testq %rax, %rax
je 0x368e
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x2, %edx
callq 0x2050
movq %rax, 0x8bba(%rip)      # 0xc220
testq %rax, %rax
je 0x369c
movq %rax, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22f0
movb $0x1, %bl
jmp 0x36b4
callq 0x21c0
leaq 0x59c6(%rip), %rdi      # 0x9052
jmp 0x36a8
callq 0x21c0
leaq 0x5a2f(%rip), %rdi      # 0x90c9
jmp 0x36a8
callq 0x21c0
leaq 0x5a4a(%rip), %rdi      # 0x90f2
xorl %ebx, %ebx
movq %rax, %rsi
xorl %eax, %eax
callq 0x2070
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/inc/screen.h
// Function: thread_screen(unsigned char (*) [800][3])
void thread_screen( unsigned char FB[][SCREEN_WIDTH][3])
{
	// Event handler
	SDL_Event e;

	// Accessing each byte in vram
	int x, y;

	// Start up SDL and create window
	if ( !init_screen() ) {
		std::cout << "Failed to Initialize!\n";
	}
	else {
		// While application is running
		while( !m_quit ) {

			// Handle events on queue
			while( SDL_PollEvent(&e) != 0) {
				// User requests quit
				if ( e.type == SDL_QUIT ) { m_quit = true; }
			}

			// Clear screen
			SDL_SetRenderDrawColor( gRenderer, 0x00, 0x00, 0x00, 0x00);
			SDL_RenderClear( gRenderer );

			// Render to screen given frame buffer
			for (y = 0; y < SCREEN_HEIGHT; y++) {
				for (x = 0; x < SCREEN_WIDTH; x++) {

					// Render pixel
					SDL_Rect pixel = { x, y, 1, 1};

					// Draw to the screen
					SDL_SetRenderDrawColor( gRenderer, 
							FB[y][x][0], 
							FB[y][x][1], 
							FB[y][x][2], 
							255
						);
					SDL_RenderFillRect( gRenderer, &pixel );
				}
			}

			// Update screen
			SDL_RenderPresent( gRenderer );
		}

		// Free resources and close SDL
		close_sdl();
		
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, 0x8(%rsp)
callq 0x35e2
testb %al, %al
je 0x37fe
cmpb $0x0, 0x8b0b(%rip)      # 0xc209
jne 0x37ea
addq $0x2, 0x8(%rsp)
leaq 0x20(%rsp), %rbx
movabsq $0x100000001, %r12      # imm = 0x100000001
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
callq 0x2160
testl %eax, %eax
je 0x373d
cmpl $0x100, 0x20(%rsp)      # imm = 0x100
jne 0x371e
movb $0x1, 0x8ace(%rip)      # 0xc209
jmp 0x371e
movq 0x8adc(%rip), %rdi      # 0xc220
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
callq 0x22f0
movq 0x8ac7(%rip), %rdi      # 0xc220
callq 0x2240
movq 0x8(%rsp), %rbx
xorl %ebp, %ebp
movq %rbx, %r13
xorl %r14d, %r14d
movl %r14d, 0x10(%rsp)
movl %ebp, 0x14(%rsp)
movq %r12, 0x18(%rsp)
movq 0x8aa0(%rip), %rdi      # 0xc220
movzbl -0x2(%r13), %esi
movzbl -0x1(%r13), %edx
movzbl (%r13), %ecx
movl $0xff, %r8d
callq 0x22f0
movq 0x8a7f(%rip), %rdi      # 0xc220
movq %r15, %rsi
callq 0x2130
incq %r14
addq $0x3, %r13
cmpq $0x320, %r14            # imm = 0x320
jne 0x376b
incq %rbp
addq $0x960, %rbx            # imm = 0x960
cmpq $0x280, %rbp            # imm = 0x280
jne 0x3765
movq 0x8a4d(%rip), %rdi      # 0xc220
callq 0x20a0
cmpb $0x1, 0x8a2a(%rip)      # 0xc209
leaq 0x20(%rsp), %rbx
jne 0x371e
callq 0x36b8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x87d3(%rip), %rdi      # 0xbfd8
leaq 0x5914(%rip), %rsi      # 0x9120
movl $0x16, %edx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x22a0
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::load_const_mem(std::vector<float, std::allocator<float>>)
void gpu::load_const_mem(vector<float> constants)
{
	// Load this baby up.
	int index = 0;
	for ( int i = 0; i < constants.size(); i += 4 )
	{
		main_mem[CONST_REG][index].x = constants[i];
		main_mem[CONST_REG][index].y = constants[i+1];
		main_mem[CONST_REG][index].z = constants[i+2];
		main_mem[CONST_REG][index].w = constants[i+3];
		index++;
	}
}

// Assembly:
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
subq %rax, %rdx
je 0x50ed
sarq $0x2, %rdx
cmpq $0x5, %rdx
movl $0x4, %ecx
cmovaeq %rdx, %rcx
decq %rcx
shrq $0x2, %rcx
incq %rcx
xorl %edx, %edx
movss (%rax,%rdx), %xmm0
movss %xmm0, 0x7d8cc(%rdi,%rdx)
movss 0x4(%rax,%rdx), %xmm0
movss %xmm0, 0x7d8c8(%rdi,%rdx)
movss 0x8(%rax,%rdx), %xmm0
movss %xmm0, 0x7d8c4(%rdi,%rdx)
movss 0xc(%rax,%rdx), %xmm0
movss %xmm0, 0x7d8c0(%rdi,%rdx)
addq $0x10, %rdx
decq %rcx
jne 0x50a9
retq
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::mov_instr(unsigned long long)
void gpu::mov_instr(u64 instr)
{

	u128 temp;

	// Determine destination and source paths
	u8 dest = get_dest_type(instr);
	u8 destIndex = get_dest_index(instr);
	u8 destW = get_dest_w(instr);
	u8 destZ = get_dest_z(instr);
	u8 destY = get_dest_y(instr);
	u8 destX = get_dest_x(instr);

	u8 src = get_srcN_type(instr, 0);
	u8 srcIndex = get_srcN_index(instr, 0);
	u8 srcW = get_srcN_w(instr, 0);
	u8 srcZ = get_srcN_z(instr, 0);
	u8 srcY = get_srcN_y(instr, 0);
	u8 srcX = get_srcN_x(instr, 0);

	// Swizzle it
	temp = swizzle(main_mem[src][srcIndex], srcW, srcZ, srcY, srcX);

	// Negate it
	if (get_srcN_neg(instr, 0))
	{
		temp.x = -temp.x;
		temp.y = -temp.y;
		temp.z = -temp.z;
		temp.w = -temp.w;
	}

	// Bop it..
	if ( dest == TEMP_REG )
	{
		if (destW) main_mem[dest][destIndex].w = temp.w;
		if (destZ) main_mem[dest][destIndex].z = temp.z;
		if (destY) main_mem[dest][destIndex].y = temp.y;
		if (destX) main_mem[dest][destIndex].x = temp.x;
	}
	else
	{
		if (destW) VOB[destIndex].w = temp.w;
		if (destZ) VOB[destIndex].z = temp.z;
		if (destY) VOB[destIndex].y = temp.y;
		if (destX) VOB[destIndex].x = temp.x;
	}

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
shrq $0x34, %r15
andl $0xf, %r15d
movq %rsi, %rbp
shrq $0x32, %rbp
movq %rsi, %r13
shrq $0x31, %r13
movq %rsi, %r12
shrq $0x30, %r12
movq %rsi, %rax
shrq $0x2d, %rax
andl $0x3, %eax
movq %rsi, %rdi
shrq $0x29, %rdi
andl $0xf, %edi
shrq $0x27, %rsi
movq %r14, %rdx
shrq $0x25, %rdx
movq %r14, %rcx
shrq $0x23, %rcx
movq %r14, %r8
shrq $0x21, %r8
shll $0x8, %eax
addq %rbx, %rax
addq $0x7d6c0, %rax          # imm = 0x7D6C0
shll $0x4, %edi
movsd (%rdi,%rax), %xmm0
movsd 0x8(%rdi,%rax), %xmm1
andl $0x3, %esi
andl $0x3, %edx
andl $0x3, %ecx
andl $0x3, %r8d
callq 0x8342
btq $0x2f, %r14
jae 0x52dc
movaps 0x3f8a(%rip), %xmm2     # 0x9260
xorps %xmm2, %xmm1
xorps %xmm2, %xmm0
btq $0x38, %r14
jb 0x533b
addq $0x7d6c0, %rbx          # imm = 0x7D6C0
btq $0x33, %r14
jae 0x52fc
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, (%rbx,%rax)
testb $0x1, %bpl
je 0x5312
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, 0x4(%rbx,%rax)
testb $0x1, %r13b
je 0x5324
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x8(%rbx,%rax)
testb $0x1, %r12b
je 0x5397
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
shll $0x4, %r15d
movss %xmm1, 0xc(%rbx,%r15)
jmp 0x5397
btq $0x33, %r14
jae 0x5351
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, 0x7dec0(%rbx,%rax)
testb $0x1, %bpl
je 0x536a
shufps $0x55, %xmm0, %xmm0     # xmm0 = xmm0[1,1,1,1]
movl %r15d, %eax
shll $0x4, %eax
movss %xmm0, 0x7dec4(%rbx,%rax)
testb $0x1, %r13b
je 0x537f
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec8(%rbx,%rax)
testb $0x1, %r12b
je 0x5397
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
shll $0x4, %r15d
movss %xmm1, 0x7decc(%rbx,%r15)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::rcp_instr(unsigned long long)
void gpu::rcp_instr(u64 instr)
{
	u128 temp;

	// Determine destination and source paths
	u8 dest = get_dest_type(instr);
	u8 destIndex = get_dest_index(instr);
	u8 destW = get_dest_w(instr);
	u8 destZ = get_dest_z(instr);
	u8 destY = get_dest_y(instr);
	u8 destX = get_dest_x(instr);

	u8 src = get_srcN_type(instr, 0);
	u8 srcIndex = get_srcN_index(instr, 0);
	u8 srcW = get_srcN_w(instr, 0);
	u8 srcZ = get_srcN_z(instr, 0);
	u8 srcY = get_srcN_y(instr, 0);
	u8 srcX = get_srcN_x(instr, 0);

	// Swizzle it
	temp = swizzle(main_mem[src][srcIndex], srcW, srcZ, srcY, srcX);

	if (get_srcN_neg(instr, 0))
	{
		temp.x = -temp.x;
	}

	if ( temp.x == 1.0 )
		temp.x = 1;
	else {
		temp.x = 1.0 / temp.x;
	}

	// Bop it..
	if ( dest == TEMP_REG )
	{
		if (destW) main_mem[dest][destIndex].w = temp.x;
		if (destZ) main_mem[dest][destIndex].z = temp.x;
		if (destY) main_mem[dest][destIndex].y = temp.x;
		if (destX) main_mem[dest][destIndex].x = temp.x;
	}
	else
	{
		if (destW) VOB[destIndex].w = temp.x;
		if (destZ) VOB[destIndex].z = temp.x;
		if (destY) VOB[destIndex].y = temp.x;
		if (destX) VOB[destIndex].x = temp.x;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %r15
shrq $0x34, %r15
andl $0xf, %r15d
movq %rsi, %rbp
shrq $0x32, %rbp
movq %rsi, %r13
shrq $0x31, %r13
movq %rsi, %r12
shrq $0x30, %r12
movq %rsi, %rax
shrq $0x2d, %rax
andl $0x3, %eax
movq %rsi, %rdi
shrq $0x29, %rdi
andl $0xf, %edi
shrq $0x27, %rsi
movq %r14, %rdx
shrq $0x25, %rdx
movq %r14, %rcx
shrq $0x23, %rcx
movq %r14, %r8
shrq $0x21, %r8
shll $0x8, %eax
addq %rbx, %rax
addq $0x7d6c0, %rax          # imm = 0x7D6C0
shll $0x4, %edi
movsd (%rdi,%rax), %xmm0
movsd 0x8(%rdi,%rax), %xmm1
andl $0x3, %esi
andl $0x3, %edx
andl $0x3, %ecx
andl $0x3, %r8d
callq 0x8342
btq $0x2f, %r14
jae 0x682c
xorps 0x2a34(%rip), %xmm1     # 0x9260
shufps $0x55, %xmm1, %xmm1     # xmm1 = xmm1[1,1,1,1]
movss 0x2ab8(%rip), %xmm0     # 0x92f0
movaps %xmm0, %xmm2
divss %xmm1, %xmm2
cmpeqss %xmm0, %xmm1
movaps %xmm1, %xmm3
andnps %xmm2, %xmm3
andps %xmm0, %xmm1
orps %xmm3, %xmm1
btq $0x38, %r14
jb 0x68a8
addq $0x7d6c0, %rbx          # imm = 0x7D6C0
btq $0x33, %r14
jae 0x6870
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, (%rbx,%rax)
testb $0x1, %bpl
je 0x6882
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x4(%rbx,%rax)
testb $0x1, %r13b
je 0x6894
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x8(%rbx,%rax)
testb $0x1, %r12b
je 0x6900
shll $0x4, %r15d
leaq (%rbx,%r15), %rax
addq $0xc, %rax
jmp 0x68fc
btq $0x33, %r14
jae 0x68be
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec0(%rbx,%rax)
testb $0x1, %bpl
je 0x68d3
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec4(%rbx,%rax)
testb $0x1, %r13b
je 0x68e8
movl %r15d, %eax
shll $0x4, %eax
movss %xmm1, 0x7dec8(%rbx,%rax)
testb $0x1, %r12b
je 0x6900
shll $0x4, %r15d
leaq (%rbx,%r15), %rax
addq $0x7decc, %rax          # imm = 0x7DECC
movss %xmm1, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::projection(__u128*)
void gpu::projection(u128 *VOB)
{
	// Project V1
	VOB[0].x = ( ( ( VOB[0].x/4 ) + 1 ) / 2 ) * SCREEN_WIDTH;
	VOB[0].y = ( ( ( (-VOB[0].y)/4 ) + 1 ) / 2 ) * SCREEN_HEIGHT;
	VOB[0].z = ( ( ( VOB[0].z/4 ) + 1 ) / 2 ) * SCREEN_DEPTH;

	// Project V2
	VOB[1].x = ( ( ( VOB[1].x/4 ) + 1 ) / 2 ) * SCREEN_WIDTH;
	VOB[1].y = ( ( ( (-VOB[1].y)/4 ) + 1 ) / 2 ) * SCREEN_HEIGHT;
	VOB[1].z = ( ( ( VOB[1].z/4 ) + 1 ) / 2 ) * SCREEN_DEPTH;

	// Project V3
	VOB[2].x = ( ( ( VOB[2].x/4 ) + 1 ) / 2 ) * SCREEN_WIDTH;
	VOB[2].y = ( ( ( (-VOB[2].y)/4 ) + 1 ) / 2 ) * SCREEN_HEIGHT;
	VOB[2].z = ( ( ( VOB[2].z/4 ) + 1 ) / 2 ) * SCREEN_DEPTH;
}

// Assembly:
movss 0x1f26(%rip), %xmm1     # 0x92fc
movss 0xc(%rsi), %xmm2
mulss %xmm1, %xmm2
movss 0x1f09(%rip), %xmm0     # 0x92f0
addss %xmm0, %xmm2
movss 0x1f0d(%rip), %xmm3     # 0x9300
mulss %xmm3, %xmm2
movss 0x1f05(%rip), %xmm4     # 0x9304
mulss %xmm4, %xmm2
movss %xmm2, 0xc(%rsi)
movaps 0x1e91(%rip), %xmm6     # 0x92a0
movsd 0x4(%rsi), %xmm7
movsd 0x14(%rsi), %xmm9
movsd 0x24(%rsi), %xmm5
mulps %xmm6, %xmm7
movaps 0x1e87(%rip), %xmm2     # 0x92b0
movaps %xmm2, %xmm10
subps %xmm7, %xmm10
addps %xmm0, %xmm7
shufps $0x1, %xmm7, %xmm10     # xmm10 = xmm10[1,0],xmm7[0,0]
shufps $0xe2, %xmm7, %xmm10    # xmm10 = xmm10[2,0],xmm7[2,3]
movaps 0x1e7b(%rip), %xmm7     # 0x92c0
mulps %xmm7, %xmm10
movsd 0x1e7e(%rip), %xmm8     # 0x92d0
mulps %xmm8, %xmm10
movlps %xmm10, 0x4(%rsi)
movss 0x1c(%rsi), %xmm10
mulss %xmm1, %xmm10
addss %xmm0, %xmm10
mulss %xmm3, %xmm10
mulss %xmm4, %xmm10
movss %xmm10, 0x1c(%rsi)
mulps %xmm6, %xmm9
movaps %xmm2, %xmm10
subps %xmm9, %xmm10
addps %xmm0, %xmm9
shufps $0x1, %xmm9, %xmm10     # xmm10 = xmm10[1,0],xmm9[0,0]
shufps $0xe2, %xmm9, %xmm10    # xmm10 = xmm10[2,0],xmm9[2,3]
mulps %xmm7, %xmm10
mulps %xmm8, %xmm10
movlps %xmm10, 0x14(%rsi)
mulss 0x2c(%rsi), %xmm1
addss %xmm0, %xmm1
mulss %xmm3, %xmm1
mulss %xmm4, %xmm1
movss %xmm1, 0x2c(%rsi)
mulps %xmm6, %xmm5
addps %xmm5, %xmm0
subps %xmm5, %xmm2
shufps $0x1, %xmm0, %xmm2      # xmm2 = xmm2[1,0],xmm0[0,0]
shufps $0xe2, %xmm0, %xmm2     # xmm2 = xmm2[2,0],xmm0[2,3]
mulps %xmm7, %xmm2
mulps %xmm8, %xmm2
movlps %xmm2, 0x24(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getXMin(__u128*)
int gpu::getXMin(u128 v[])
{
	int min = v[0].x;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].x < min)
			min = v[i].x;
	}	

	return min;
}

// Assembly:
cvttss2si 0xc(%rsi), %eax
xorl %ecx, %ecx
movl %eax, %edx
movss 0x1c(%rsi,%rcx), %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm0, %xmm1
cvttss2si %xmm0, %eax
cmovbel %edx, %eax
addq $0x10, %rcx
cmpq $0x20, %rcx
jne 0x7757
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getXMax(__u128*)
int gpu::getXMax(u128 v[])
{
	int max = v[0].x;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].x > max)
			max = v[i].x;
	}	

	return max;
}

// Assembly:
cvttss2si 0xc(%rsi), %eax
xorl %ecx, %ecx
movl %eax, %edx
movss 0x1c(%rsi,%rcx), %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cmovbel %edx, %eax
addq $0x10, %rcx
cmpq $0x20, %rcx
jne 0x7783
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getYMin(__u128*)
int gpu::getYMin(u128 v[])
{
	int min = v[0].y;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].y < min)
			min = v[i].y;
	}	

	return min;
}

// Assembly:
cvttss2si 0x8(%rsi), %eax
xorl %ecx, %ecx
movl %eax, %edx
movss 0x18(%rsi,%rcx), %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm0, %xmm1
cvttss2si %xmm0, %eax
cmovbel %edx, %eax
addq $0x10, %rcx
cmpq $0x20, %rcx
jne 0x77af
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getYMax(__u128*)
int gpu::getYMax(u128 v[])
{
	int max = v[0].y;

	for (int i = 1; i < 3; i++)
	{
		if (v[i].y > max)
			max = v[i].y;
	}	

	return max;
}

// Assembly:
cvttss2si 0x8(%rsi), %eax
xorl %ecx, %ecx
movl %eax, %edx
movss 0x18(%rsi,%rcx), %xmm0
xorps %xmm1, %xmm1
cvtsi2ss %eax, %xmm1
ucomiss %xmm1, %xmm0
cvttss2si %xmm0, %eax
cmovbel %edx, %eax
addq $0x10, %rcx
cmpq $0x20, %rcx
jne 0x77db
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::getZ(__u128*, int, int)
int gpu::getZ(u128 v[], int x, int y)
{
	// if all z's same return one of them
	if (v[0].z == v[1].z && v[1].z == v[2].z)
		return v[0].z;

	// if not, then do calculations
	// plane equation
	return
	( -((v[0].z*( v[1].x - v[2].x )+
		   v[1].z*( v[2].x - v[0].x )+
		   v[2].z*( v[0].x - v[1].x)) * x +
	
		  (v[0].y*( v[1].z - v[2].z )+
		   v[1].y*( v[2].z - v[0].z )+
		   v[2].y*( v[0].z - v[1].z)) * y) /

		(v[0].x*( v[1].y - v[2].y )+
		   v[1].x*( v[2].y - v[0].y )+
		   v[2].x*( v[0].y - v[1].y))

	);

}

// Assembly:
movss 0x4(%rsi), %xmm0
movss 0x14(%rsi), %xmm4
ucomiss %xmm4, %xmm0
movss 0x24(%rsi), %xmm1
jne 0x784d
jp 0x784d
ucomiss %xmm1, %xmm4
jne 0x784d
jnp 0x7915
movss 0x1c(%rsi), %xmm3
movss 0x2c(%rsi), %xmm7
movaps %xmm3, %xmm6
subss %xmm7, %xmm6
movss 0x8(%rsi), %xmm2
movss 0xc(%rsi), %xmm5
mulss %xmm0, %xmm6
movaps %xmm5, %xmm8
subss %xmm3, %xmm8
mulss %xmm1, %xmm8
movaps %xmm4, %xmm9
subss %xmm1, %xmm9
movss 0x18(%rsi), %xmm10
subss %xmm0, %xmm1
mulss %xmm2, %xmm9
movss 0x28(%rsi), %xmm11
subss %xmm4, %xmm0
mulss %xmm11, %xmm0
movaps %xmm10, %xmm12
subss %xmm11, %xmm12
subss %xmm2, %xmm11
subss %xmm10, %xmm2
mulss %xmm7, %xmm2
subss %xmm5, %xmm7
mulss %xmm4, %xmm7
addss %xmm7, %xmm6
addss %xmm6, %xmm8
xorps %xmm4, %xmm4
cvtsi2ss %edx, %xmm4
mulss %xmm8, %xmm4
mulss %xmm10, %xmm1
xorps %xmm6, %xmm6
cvtsi2ss %ecx, %xmm6
addss %xmm1, %xmm9
addss %xmm9, %xmm0
mulss %xmm0, %xmm6
addss %xmm4, %xmm6
xorps 0x1966(%rip), %xmm6     # 0x9260
mulss %xmm3, %xmm11
mulss %xmm5, %xmm12
addss %xmm11, %xmm12
addss %xmm12, %xmm2
divss %xmm2, %xmm6
movaps %xmm6, %xmm0
cvttss2si %xmm0, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/mlugo2[P]SunshineGPU/src/gpu.cpp
// Function: gpu::swizzle(__u128, unsigned char, unsigned char, unsigned char, unsigned char)
u128 gpu::swizzle(u128 data, u8 w, u8 z, u8 y, u8 x)
{
	// No swizzle 
	if (w == 3 && z == 2 && y == 1 && x == 0)
		return data;

	u32 temp[4];

	// Tear apart all componets, put them in array..
	temp[0] = data.x;
	temp[1] = data.y;
	temp[2] = data.z;
	temp[3] = data.w;

	data.x = temp[x];
	data.y = temp[y];
	data.z = temp[z];
	data.w = temp[w];

	return data;
}

// Assembly:
movl %esi, %eax
xorb $0x3, %al
movl %edx, %edi
xorb $0x2, %dil
orb %al, %dil
movl %ecx, %eax
xorb $0x1, %al
orb %dil, %al
orb %r8b, %al
je 0x84b9
cvttss2si %xmm1, %rax
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movss 0xf95(%rip), %xmm2      # 0x9308
cvttss2si %xmm3, %rdi
subss %xmm2, %xmm3
cvttss2si %xmm3, %r9
movq %rdi, %r10
sarq $0x3f, %r10
andq %r9, %r10
orq %rdi, %r10
movq %r10, -0x28(%rsp)
subss %xmm2, %xmm1
cvttss2si %xmm1, %rdi
movq %rax, %r9
sarq $0x3f, %r9
andq %rdi, %r9
orq %rax, %r9
cvttss2si %xmm0, %rax
movaps %xmm0, %xmm1
shufps $0x55, %xmm0, %xmm1     # xmm1 = xmm1[1,1],xmm0[1,1]
cvttss2si %xmm1, %rdi
movq %r9, -0x20(%rsp)
subss %xmm2, %xmm1
cvttss2si %xmm1, %r9
movq %rdi, %r10
sarq $0x3f, %r10
andq %r9, %r10
orq %rdi, %r10
movq %r10, -0x18(%rsp)
subss %xmm2, %xmm0
cvttss2si %xmm0, %rdi
movq %rax, %r9
sarq $0x3f, %r9
andq %rdi, %r9
orq %rax, %r9
movq %r9, -0x10(%rsp)
movzbl %r8b, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x840d
xorps %xmm2, %xmm2
cvtsi2ss %rax, %xmm2
jmp 0x8425
movq %rax, %rdi
shrq %rdi
andl $0x1, %eax
orq %rdi, %rax
xorps %xmm2, %xmm2
cvtsi2ss %rax, %xmm2
addss %xmm2, %xmm2
movzbl %cl, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x843c
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x8454
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
addss %xmm1, %xmm1
movzbl %dl, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x846b
xorps %xmm3, %xmm3
cvtsi2ss %rax, %xmm3
jmp 0x8483
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm3, %xmm3
cvtsi2ss %rax, %xmm3
addss %xmm3, %xmm3
movzbl %sil, %eax
movq -0x28(%rsp,%rax,8), %rax
testq %rax, %rax
js 0x849b
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x84b3
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
unpcklps %xmm3, %xmm0            # xmm0 = xmm0[0],xmm3[0],xmm0[1],xmm3[1]
unpcklps %xmm2, %xmm1            # xmm1 = xmm1[0],xmm2[0],xmm1[1],xmm2[1]
retq
// File: /workspace/github_cpp_makefile_star2_O3/loverszhaokai[P]TypoCheck/src/typo_check.cc
// Function: main
int main(int argc, char **argv)
{
	if (argc != 3) {
		usage();
		return -1;
	}

	cout << "Checking typos, please wait a moment" << endl;

	init();

	init_typos(string(argv[1]));

	print_typo_info();

	search_typo_per_file(string(argv[2]));

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
cmpl $0x3, %edi
jne 0x24c8
movq %rsi, %rbx
movq 0x3bbe(%rip), %r14      # 0x5fd8
leaq 0x1be3(%rip), %rsi      # 0x4004
movl $0x24, %edx
movq %r14, %rdi
callq 0x2170
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
callq 0x26b8
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x25da
leaq -0x38(%rbp), %rdi
callq 0x26ef
leaq -0x28(%rbp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x248d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
callq 0x2ed5
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x25da
leaq -0x38(%rbp), %rdi
callq 0x2b1e
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
je 0x24c1
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
xorl %eax, %eax
jmp 0x2598
movq 0x3b09(%rip), %rbx      # 0x5fd8
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x1b2c(%rip), %rsi      # 0x4029
movl $0x6, %edx
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
leaq 0x1af8(%rip), %rsi      # 0x4030
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r14, %rdi
jne 0x25c1
jmp 0x25d2
jmp 0x25cf
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x25d2
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
jmp 0x25d2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: init()
void init()
{
	for (int i = 0; i < sizeof(cidx) / sizeof(char); i++) {
		if (i >= 'a' && i <= 'z')
			cidx[i] = i - 'a';
		else if (i >= 'A' && i <= 'Z')
			cidx[i] = i - 'A';
		else
			cidx[i] = -1;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
leaq 0x3adb(%rip), %rcx      # 0x61a0
leal -0x61(%rax), %edx
cmpl $0x19, %edx
ja 0x26d2
leal -0x61(%rax), %edx
jmp 0x26df
leal -0x41(%rax), %esi
movb $-0x1, %dl
cmpl $0x19, %esi
ja 0x26df
leal -0x41(%rax), %edx
movb %dl, (%rax,%rcx)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x26c5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: print_typo(TypoInfo*)
static void print_typo(TypoInfo *tip)
{
	words.push_back(tip);

	if (tip->rw != "") {
		cout << "wrong word:'";
		for (int i = 0; i < words.size(); i++) {
			cout << words[i]->ch;
		}
		cout << "' right word:'" << tip->rw << "'" << endl;
	}

	list<TypoInfo>::iterator it;
	for (it = tip->children.begin(); it != tip->children.end(); it++) {
		print_typo(&(*it));
		words.pop_back();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x28(%rbp)
movq 0x33ad(%rip), %rsi      # 0x62a8
cmpq 0x33ae(%rip), %rsi      # 0x62b0
je 0x2f11
movq %rdi, (%rsi)
addq $0x8, 0x3399(%rip)      # 0x62a8
jmp 0x2f27
leaq 0x3388(%rip), %rdi      # 0x62a0
leaq -0x28(%rbp), %rbx
movq %rbx, %rdx
callq 0x346c
movq (%rbx), %rdi
addq $0x28, %rdi
leaq 0x1188(%rip), %rsi      # 0x40ba
callq 0x2080
testl %eax, %eax
je 0x3018
movq 0x3092(%rip), %rdi      # 0x5fd8
leaq 0x116e(%rip), %rsi      # 0x40bb
movl $0xc, %edx
callq 0x2170
movq 0x3342(%rip), %rax      # 0x62a0
cmpq %rax, 0x3343(%rip)      # 0x62a8
je 0x2fab
xorl %r15d, %r15d
movq 0x3067(%rip), %rbx      # 0x5fd8
leaq -0x19(%rbp), %r14
movq (%rax,%r15,8), %rax
movb (%rax), %al
movb %al, -0x19(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2170
incq %r15
movq 0x3310(%rip), %rcx      # 0x62a8
movq 0x3301(%rip), %rax      # 0x62a0
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x2f75
movq 0x3026(%rip), %rbx      # 0x5fd8
leaq 0x110f(%rip), %rsi      # 0x40c8
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2170
movq -0x28(%rbp), %rax
movq 0x28(%rax), %rsi
movq 0x30(%rax), %rdx
movq %rbx, %rdi
callq 0x2170
movq %rax, %rbx
leaq 0x10d5(%rip), %rsi      # 0x40b9
movl $0x1, %edx
movq %rax, %rdi
callq 0x2170
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x2130
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x20d0
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rbx
addq $0x48, %rax
cmpq %rax, %rbx
je 0x3043
leaq 0x10(%rbx), %rdi
callq 0x2ee3
addq $-0x8, 0x326e(%rip)     # 0x62a8
movq (%rbx), %rbx
movq -0x28(%rbp), %rax
jmp 0x3020
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: void __gnu_cxx::new_allocator<std::_List_node<TypoInfo>>::construct<TypoInfo, TypoInfo>(TypoInfo*, TypoInfo&&)
TypoInfo()
	{
		ch = ' ';
		ww = "";
		rw = "";
		children = list<TypoInfo>();
	}

// Assembly:
movb (%rdx), %al
movb %al, (%rsi)
leaq 0x18(%rsi), %rcx
movq %rcx, 0x8(%rsi)
movq 0x8(%rdx), %rdi
leaq 0x18(%rdx), %rax
cmpq %rax, %rdi
je 0x33c0
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x33c6
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x10(%rdx), %rcx
movq %rcx, 0x10(%rsi)
movq %rax, 0x8(%rdx)
movq $0x0, 0x10(%rdx)
movb $0x0, 0x18(%rdx)
leaq 0x38(%rsi), %rcx
movq %rcx, 0x28(%rsi)
movq 0x28(%rdx), %rdi
leaq 0x38(%rdx), %rax
cmpq %rax, %rdi
je 0x3400
movq %rdi, 0x28(%rsi)
movq (%rax), %rcx
movq %rcx, 0x38(%rsi)
jmp 0x3406
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq 0x30(%rdx), %rcx
movq %rcx, 0x30(%rsi)
movq %rax, 0x28(%rdx)
movq $0x0, 0x30(%rdx)
movb $0x0, 0x38(%rdx)
leaq 0x48(%rsi), %rax
leaq 0x48(%rdx), %rcx
movq 0x48(%rdx), %r8
movq %r8, 0x48(%rsi)
movq 0x50(%rdx), %rdi
movq %rdi, 0x50(%rsi)
movq 0x58(%rdx), %r9
movq %r9, 0x58(%rsi)
cmpq %rcx, %r8
je 0x3463
pushq %rbp
movq %rsp, %rbp
movq %rax, (%rdi)
movq (%rax), %rsi
movq %rax, 0x8(%rsi)
movq %rcx, 0x50(%rdx)
movq %rcx, 0x48(%rdx)
movq $0x0, 0x58(%rdx)
popq %rbp
retq
movq %rax, 0x50(%rsi)
movq %rax, 0x48(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/loverszhaokai[P]TypoCheck/src/typo.cc
// Function: TypoInfo::TypoInfo(char, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
TypoInfo(char _ch, const string &_ww, const string &_rw)
	{
		ch = _ch;
		ww = _rw;
		rw = _rw;
		children = list<TypoInfo>();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
leaq 0x8(%rdi), %rcx
leaq 0x18(%rdi), %r14
movq %r14, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r15
leaq 0x38(%rdi), %rbx
movq %rbx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %r13
movq %r13, 0x50(%rdi)
movq %r13, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movb %sil, (%rdi)
movq %rcx, -0x30(%rbp)
movq %rcx, %rdi
movq %r12, %rsi
callq 0x20c0
movq %r15, %rdi
movq %r12, %rsi
callq 0x20c0
leaq -0x48(%rbp), %rbx
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq $0x0, 0x10(%rbx)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x31a6
movq %rbx, %rdi
callq 0x320c
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r13, %rdi
callq 0x320c
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x333a
movq (%rbx), %rsi
incq %rsi
callq 0x2150
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x222a
movq %r12, %rdi
callq 0x21d0
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/device_monitor.cpp
// Function: DeviceMonitor::deviceChanged_(udev_device*, bool)
void DeviceMonitor::deviceChanged_( udev_device* device, bool state ) {
	if (!acceptDevice_(device)) return;

	int led_idx = scsiHostIndex_(device);
	if (led_idx < 0) return;
	if (debug) std::cout << " device: " << udev_device_get_syspath(device) << "\n led: " << led_idx << "\n";

	// finally we can play with the appopriate LED
	if ( leds_ ) leds_->Set( LED_BLUE, led_idx, state );
        led_enabled_[led_idx] = state;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x553a
testb %al, %al
je 0x5883
movq %r15, %rsi
callq 0x588c
testl %eax, %eax
js 0x5883
movl %eax, %ebp
leaq 0xab94(%rip), %rax      # 0x10350
cmpl $0x0, (%rax)
je 0x585e
movq 0xa7e4(%rip), %r12      # 0xffb0
leaq 0x5941(%rip), %rsi      # 0xb114
movl $0x9, %edx
movq %r12, %rdi
callq 0x4310
movq %r15, %rdi
callq 0x44e0
testq %rax, %rax
je 0x580c
movq %rax, %r15
movq %rax, %rdi
callq 0x4130
movq 0xa7b1(%rip), %rdi      # 0xffb0
movq %r15, %rsi
movq %rax, %rdx
callq 0x4310
jmp 0x5825
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x4510
movq 0xa784(%rip), %r15      # 0xffb0
leaq 0x58eb(%rip), %rsi      # 0xb11e
movl $0x7, %edx
movq %r15, %rdi
callq 0x4310
movq %r15, %rdi
movl %ebp, %esi
callq 0x4530
leaq 0x5eba(%rip), %rsi      # 0xb70b
movl $0x1, %edx
movq %rax, %rdi
callq 0x4310
movq 0x10(%r14), %rdi
movl %ebp, %r15d
testq %rdi, %rdi
je 0x587b
movq (%rdi), %rax
movzbl %bl, %ecx
movl $0x1, %esi
movq %r15, %rdx
callq *0x28(%rax)
movb %bl, 0x168(%r14,%r15)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/update_monitor.cpp
// Function: UpdateMonitor::Stop()
void UpdateMonitor::Stop()
{
	if (!instance_started_)
	{
		if (verbose > 0)
		{
			std::cout << "Update monitor thread already stopped.\n";
		}
		return;
	}
	if (verbose > 0)
	{
		std::cout << "Attempting to stop update monitor thread.\n";
	}
	//Cancelling thread.
	if(pthread_cancel(monitor_thread_) != 0)
	{
		throw ErrnoException("pthread_cancel");
	}
	//Waiting for thread to join.
	if(pthread_join(monitor_thread_, NULL) != 0)
	{
		throw ErrnoException("pthread_join");
	}
	if (verbose > 0)
	{
		std::cout << "Update monitor thread stopped.\n";
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
leaq 0xa253(%rip), %r14      # 0x10354
movl (%r14), %eax
cmpb $0x0, 0xa23d(%rip)      # 0x10348
je 0x6165
movq %rdi, %rbx
testl %eax, %eax
jle 0x612c
movq 0x9e95(%rip), %rdi      # 0xffb0
leaq 0x52be(%rip), %rsi      # 0xb3e0
movl $0x2a, %edx
callq 0x4310
movq (%rbx), %rdi
callq 0x43e0
testl %eax, %eax
jne 0x6196
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x4250
testl %eax, %eax
jne 0x61f5
cmpl $0x0, (%r14)
jle 0x618b
movq 0x9e59(%rip), %rdi      # 0xffb0
leaq 0x52c9(%rip), %rsi      # 0xb427
movl $0x1f, %edx
jmp 0x617c
testl %eax, %eax
jle 0x618b
movq 0x9e40(%rip), %rdi      # 0xffb0
leaq 0x5241(%rip), %rsi      # 0xb3b8
movl $0x27, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4310
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5258(%rip), %rsi      # 0xb40b
leaq 0x525f(%rip), %rdx      # 0xb419
leaq 0x8(%rsp), %rdi
callq 0x5e90
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be6
xorl %ebp, %ebp
leaq 0x959c(%rip), %rsi      # 0xf780
movq 0x9db5(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6252
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5208(%rip), %rsi      # 0xb41a
leaq 0x520d(%rip), %rdx      # 0xb426
leaq 0x8(%rsp), %rdi
callq 0x5e90
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be6
xorl %ebp, %ebp
leaq 0x953d(%rip), %rsi      # 0xf780
movq 0x9d56(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6256
jmp 0x6277
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6270
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
testb %bpl, %bpl
jne 0x627a
jmp 0x6282
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/update_monitor.cpp
// Function: UpdateMonitor::Start()
void UpdateMonitor::Start()
{
	if (instance_started_)
	{
		if (verbose > 0)
		{
			std::cout << "Update monitor thread already running.\n";
		}
		return;
	}
	if (pthread_create(&monitor_thread_, NULL, MonitorThreadProc, NULL) != 0)
	{
		throw ErrnoException("pthread_create");
	}
	instance_started_ = true;
	if (verbose > 0)
	{
		std::cout << "Update monitor thread started.\n";
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, 0xa0ad(%rip)      # 0x10348
jne 0x62be
leaq 0xa0b0(%rip), %rax      # 0x10354
cmpl $0x0, (%rax)
jle 0x6307
movq 0x9d00(%rip), %rdi      # 0xffb0
leaq 0x50aa(%rip), %rsi      # 0xb361
movl $0x27, %edx
jmp 0x62f8
leaq 0xdf(%rip), %rdx        # 0x63a4
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4590
testl %eax, %eax
jne 0x6312
movb $0x1, 0xa06f(%rip)      # 0x10348
leaq 0xa074(%rip), %rax      # 0x10354
cmpl $0x0, (%rax)
jle 0x6307
movq 0x9cc4(%rip), %rdi      # 0xffb0
leaq 0x50a5(%rip), %rsi      # 0xb398
movl $0x1f, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4310
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x505a(%rip), %rsi      # 0xb389
leaq 0x5061(%rip), %rdx      # 0xb397
leaq 0x8(%rsp), %rdi
callq 0x5e90
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be6
xorl %ebp, %ebp
leaq 0x9420(%rip), %rsi      # 0xf780
movq 0x9c39(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6389
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
testb %bpl, %bpl
jne 0x6393
jmp 0x639b
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/update_monitor.cpp
// Function: UpdateMonitor::MonitorThreadCleanupHandler(void*)
void UpdateMonitor::MonitorThreadCleanupHandler(void* /*arg*/)
{
	if (verbose > 0)
	{
		std::cout << "Cleaning up after the update monitor thread.\n";
	}
	instance_started_ = false;
	//Reset LED.
	leds_->SetSystemLed(LED_BLUE | LED_RED, false);
}

// Assembly:
pushq %rax
leaq 0x9ca0(%rip), %rax      # 0x10354
cmpl $0x0, (%rax)
jle 0x66d1
movq 0x98f0(%rip), %rdi      # 0xffb0
leaq 0x4d80(%rip), %rsi      # 0xb447
movl $0x2d, %edx
callq 0x4310
movb $0x0, 0x9c70(%rip)      # 0x10348
movq 0x9c59(%rip), %rdi      # 0x10338
movq (%rdi), %rax
movq 0x40(%rax), %rax
movl $0x3, %esi
xorl %edx, %edx
popq %rcx
jmpq *%rax
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/mediasmartserverd.cpp
// Function: init_signals()
void init_signals( ) {
	struct sigaction sa;
	sa.sa_flags = 0;
	sa.sa_handler = &sig_handler;
	sigemptyset( &sa.sa_mask );
	if ( -1 == sigaction(SIGINT,  &sa, 0) ) throw ErrnoException( "sigaction(SIGINT)"  );
	if ( -1 == sigaction(SIGTERM, &sa, 0) ) throw ErrnoException( "sigaction(SIGTERM)" );
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0xb8, %rsp
leaq 0x28(%rsp), %rdi
movl $0x0, 0x80(%rdi)
leaq 0x12e(%rip), %rax       # 0x6b95
movq %rax, -0x8(%rdi)
callq 0x4390
leaq 0x20(%rsp), %rsi
movl $0x2, %edi
xorl %edx, %edx
callq 0x43b0
cmpl $-0x1, %eax
je 0x6aaa
leaq 0x20(%rsp), %rsi
movl $0xf, %edi
xorl %edx, %edx
callq 0x43b0
cmpl $-0x1, %eax
je 0x6b05
addq $0xb8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4b79(%rip), %rsi      # 0xb640
leaq 0x4b83(%rip), %rdx      # 0xb651
movq %rsp, %rdi
callq 0x5e90
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5be6
xorl %ebp, %ebp
leaq 0x8c8c(%rip), %rsi      # 0xf780
movq 0x94a5(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6b5e
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4b30(%rip), %rsi      # 0xb652
leaq 0x4b3b(%rip), %rdx      # 0xb664
movq %rsp, %rdi
callq 0x5e90
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5be6
xorl %ebp, %ebp
leaq 0x8c31(%rip), %rsi      # 0xf780
movq 0x944a(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6b62
jmp 0x6b82
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b7b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42c0
testb %bpl, %bpl
jne 0x6b85
jmp 0x6b8d
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedAcerH340::MountUsb(bool)
void setGpLpcLvl_( int bit, bool state ) {
		doBits_(
			(1 << (bit % 32)),
			io_lpc_gpiobase_ + ((bit < 32) ? GP_LVL : GP_LVL2),
			state
		);
	}

// Assembly:
movl 0x8(%rdi), %edx
addl $0xc, %edx
inl %dx, %eax
movl %eax, %ecx
andl $-0x41, %ecx
shll $0x6, %esi
orl %ecx, %esi
cmpl %esi, %eax
je 0x8554
movl %esi, %eax
outl %eax, %dx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/led_acerh340.h
// Function: LedAcerH340::SetSystemLed(int, LedState)
virtual void SetSystemLed( int led_type, LedState state ) {
		const bool on_off_state = ( LED_ON == state );
		if ( led_type & LED_BLUE ) setGpLpcLvl_( OUT_SYSTEM_BLUE, !on_off_state );
		if ( led_type & LED_RED  ) setGpLpcLvl_( OUT_SYSTEM_RED,  !on_off_state );
		
		const bool blink_state  = ( LED_BLINK == state );
		int val = 0;
		if ( led_type & LED_BLUE ) val |= 1 << OUT_SYSTEM_BLUE;
		if ( led_type & LED_RED  ) val |= 1 << OUT_SYSTEM_RED;
		if ( val ) doBits_( val, io_lpc_gpiobase_ + GPO_BLINK, blink_state );
	}

// Assembly:
movl %edx, %ecx
movl %esi, %r9d
andl $0x1, %r9d
je 0x861e
xorl %r8d, %r8d
cmpl $0x2, %ecx
setne %r8b
movl 0x8(%rdi), %edx
addl $0xc, %edx
inl %dx, %eax
movl %eax, %r10d
andl $0xffefffff, %r10d      # imm = 0xFFEFFFFF
shll $0x14, %r8d
orl %r10d, %r8d
cmpl %r8d, %eax
je 0x861e
movl %r8d, %eax
outl %eax, %dx
andl $0x2, %esi
je 0x864e
xorl %r8d, %r8d
cmpl $0x2, %ecx
setne %r8b
movl 0x8(%rdi), %edx
addl $0xc, %edx
inl %dx, %eax
movl %eax, %r10d
andl $0xfeffffff, %r10d      # imm = 0xFEFFFFFF
shll $0x18, %r8d
orl %r10d, %r8d
cmpl %r8d, %eax
je 0x864e
movl %r8d, %eax
outl %eax, %dx
shll $0x14, %r9d
shll $0x17, %esi
orl %r9d, %esi
je 0x8676
movl 0x8(%rdi), %edx
addl $0x18, %edx
inl %dx, %eax
movl %eax, %edi
orl %esi, %edi
notl %esi
andl %eax, %esi
cmpl $0x4, %ecx
cmovel %edi, %esi
cmpl %esi, %eax
je 0x8676
movl %esi, %eax
outl %eax, %dx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::Init()
virtual bool Init( ) {
		if ( !initPciLpc_( )  ) return false;
		if ( !initSch5127_( ) ) return false;
		
		disableWatchDog_( );
		
		return true;
	}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x86b8
testb %al, %al
je 0x86b3
movq %rbx, %rdi
callq 0x8912
testb %al, %al
je 0x86b3
movq %rbx, %rdi
callq 0x8d26
movb $0x1, %al
jmp 0x86b5
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::disableWatchDog_()
void disableWatchDog_( ) {
		// watchdog registers to zero out
		const int WDT_REGS[] = { REG_WDT_VAL, REG_WDT_TIME_OUT, REG_WDT_CFG, REG_WDT_CTRL };
		const size_t WDT_REGS_CNT = sizeof(WDT_REGS) / sizeof(WDT_REGS[0]);
		
		// determine the I/O range of those registers
		const int reg_min = *std::min_element( WDT_REGS, WDT_REGS + WDT_REGS_CNT );
		const int reg_max = *std::max_element( WDT_REGS, WDT_REGS + WDT_REGS_CNT );
		const int reg_cnt = reg_max - reg_min + 1;
		
		// get access to the entire range
		if ( ioperm(io_sch5127_regs_ + reg_min, reg_cnt, 1) ) throw ErrnoException("ioperm");
		
		// zero them out
		for ( size_t i = 0; i < WDT_REGS_CNT; ++i ) {
			outb( 0, io_sch5127_regs_ + WDT_REGS[i] );
		}
		
		// done
		ioperm(io_sch5127_regs_ + reg_min, reg_cnt, 0);
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %edi
addl $0x65, %edi
movl $0x4, %esi
movl $0x1, %edx
callq 0x44b0
testl %eax, %eax
jne 0x8d84
leaq 0x2edd(%rip), %rcx      # 0xbc30
xorl %esi, %esi
movl (%rsi,%rcx), %edx
addl 0xc(%rbx), %edx
xorl %eax, %eax
outb %al, %dx
addq $0x4, %rsi
cmpq $0x10, %rsi
jne 0x8d55
movl 0xc(%rbx), %edi
addl $0x65, %edi
movl $0x4, %esi
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44b0
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x2d81(%rip), %rsi      # 0xbb22
leaq 0x2d80(%rip), %rdx      # 0xbb28
leaq 0x8(%rsp), %rdi
callq 0x5e90
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be6
xorl %ebp, %ebp
leaq 0x69ae(%rip), %rsi      # 0xf780
movq 0x71c7(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8dfb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
testb %bpl, %bpl
jne 0x8e05
jmp 0x8e0d
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O3/merelin[P]mediasmartserverd/src/led_control_sch5127_base.h
// Function: LedControlSCH5127Base::setGpRegsLvl_(int, bool)
void setGpRegsLvl_( int bit, bool state ) {
		const int reg = ((bit >> 4) & 0xF) - 1;
		assert( reg >= 0 );
		
		doBits_(
			(1 << (bit & 0xF)),
			io_sch5127_regs_ + REG_GP1 + reg,
			state
		);
	}

// Assembly:
movl %esi, %eax
shrl $0x4, %eax
andl $0xf, %eax
je 0x9109
movl %edx, %ecx
movl 0xc(%rdi), %edx
addl %eax, %edx
addl $0x4a, %edx
inl %dx, %eax
movl %eax, %edi
andb $0xf, %sil
movl %eax, %r8d
btsl %esi, %r8d
btrl %esi, %eax
testb %cl, %cl
cmovnel %r8d, %eax
cmpl %eax, %edi
je 0x9108
outl %eax, %dx
retq
pushq %rax
leaq 0x2a65(%rip), %rdi      # 0xbb76
leaq 0x2a67(%rip), %rsi      # 0xbb7f
leaq 0x2a7f(%rip), %rcx      # 0xbb9e
movl $0x11a, %edx            # imm = 0x11A
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/net/test/test_iobuffer.cc
// Function: testPop(char const*, char const*, unsigned long, net::IOBuffer&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void testPop(const char *module, const char *msg, size_t const size, Buffer &b, std::string &s, bool const expect = true){
	bool const result = b.pop(size);

	if (expect)
		s.erase(0, size);

	PRINTF_TEST(msg, result == expect);

	if (s.empty()){
		PRINTF_TEST("size zero",	b.size() == 0				);
	}else{
		PRINTF_TEST("value",		s.compare(0, s.size(), b.data()) == 0	);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r9d, %ebp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
testq %rdx, %rdx
je 0x1285
movq (%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
cmpq %rdx, %rcx
jae 0x128a
xorl %r13d, %r13d
jmp 0x12a8
jne 0x129f
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
xorl %eax, %eax
jmp 0x12a2
addq %rdx, %rax
movq %rax, (%r15)
movb $0x1, %r13b
testb %bpl, %bpl
je 0x12b7
movq %r14, %rdi
xorl %esi, %esi
callq 0x1050
xorb %bpl, %r13b
leaq 0xd5e(%rip), %r13       # 0x201f
leaq 0xd54(%rip), %rbp       # 0x201c
movq %rbp, %rcx
cmovneq %r13, %rcx
leaq 0xd2e(%rip), %rdi       # 0x2004
movq %rbx, %rsi
movq %r12, %rdx
xorl %eax, %eax
callq 0x1030
movq 0x8(%r14), %rdx
movq (%r15), %rcx
testq %rdx, %rdx
je 0x130b
addq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1080
testl %eax, %eax
sete %al
leaq 0xd1b(%rip), %rdx       # 0x2024
jmp 0x1319
cmpq %rcx, 0x10(%r15)
sete %al
leaq 0xd11(%rip), %rdx       # 0x202a
testb %al, %al
cmovneq %rbp, %r13
leaq 0xcde(%rip), %rdi       # 0x2004
movq %rbx, %rsi
movq %r13, %rcx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_cpp_makefile_star2_O3/nmmmnu[P]HM3/net/test/test_iobuffer.cc
// Function: test(char const*)
void test(const char *module = "iobuffer"){
	Buffer b;

	std::string s;

	testPush(module, "push",		"aaa",	b, s);
	testPush(module, "push zero",		"",	b, s, false);
	testPush(module, "push",		"bbb",	b, s);
	testPush(module, "push",		"ccc",	b, s);

	testPop( module, "pop",			3,	b, s);
	testPop( module, "pop zero",		0,	b, s, false);
	testPop( module, "pop",			3,	b, s);
	testPop( module, "pop",			3,	b, s);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
xorl %eax, %eax
leaq 0x40(%rsp), %r14
movq %rax, -0x18(%r14)
movq %r14, -0x10(%r14)
movq %rax, -0x8(%r14)
movb %al, (%r14)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq %rax, -0x8(%r15)
movb %al, (%r15)
leaq 0xcba(%rip), %rsi       # 0x2034
leaq 0xcb8(%rip), %rdx       # 0x2039
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x1, %r9d
callq 0x11ac
leaq 0xca0(%rip), %rsi       # 0x203d
leaq 0xc77(%rip), %rdx       # 0x201b
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x11ac
leaq 0xc74(%rip), %rsi       # 0x2034
leaq 0xc80(%rip), %rdx       # 0x2047
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x11ac
leaq 0xc4e(%rip), %rsi       # 0x2034
leaq 0xc5e(%rip), %rdx       # 0x204b
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x11ac
leaq 0xc43(%rip), %rsi       # 0x204f
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x1257
leaq 0xc23(%rip), %rsi       # 0x2053
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x1257
leaq 0xc01(%rip), %rsi       # 0x204f
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x1257
leaq 0xbdd(%rip), %rsi       # 0x204f
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x1257
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x14a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x14bd
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x14e1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x14f8
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O3/dm4[P]huffman-homework/decode.cc
// Function: print_codeword(char*)
void print_codeword(char *codeword) {
    for (int i = 0; codeword[i]; i++) {
        if (i % 4 == 0)
            putchar(' ');
        putchar(codeword[i]);
    }
}

// Assembly:
movb (%rdi), %al
testb %al, %al
je 0x154b
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
testb $0x3, %r14b
jne 0x1533
movl $0x20, %edi
callq 0x1170
movb (%rbx,%r14), %al
movsbl %al, %edi
callq 0x1170
movb 0x1(%rbx,%r14), %al
incq %r14
testb %al, %al
jne 0x151f
popq %rbx
popq %r14
popq %rbp
retq