LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1e74(%rip), %xmm1     # 0x92fc
movss 0xc(%rsi), %xmm2
mulss %xmm1, %xmm2
movss 0x1e57(%rip), %xmm0     # 0x92f0
addss %xmm0, %xmm2
movss 0x1e5b(%rip), %xmm3     # 0x9300
mulss %xmm3, %xmm2
movss 0x1e53(%rip), %xmm4     # 0x9304
mulss %xmm4, %xmm2
movss %xmm2, 0xc(%rsi)
movaps 0x1ddf(%rip), %xmm6     # 0x92a0
movsd 0x4(%rsi), %xmm7
movsd 0x14(%rsi), %xmm9
movsd 0x24(%rsi), %xmm5
mulps %xmm6, %xmm7
movaps 0x1dd5(%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 0x1dc9(%rip), %xmm7     # 0x92c0
mulps %xmm7, %xmm10
movsd 0x1dcc(%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_O1/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 0x7809
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7835
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7861
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x788d
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %xmm3
ucomiss %xmm3, %xmm0
jne 0x78fb
jp 0x78fb
ucomiss 0x24(%rsi), %xmm3
jne 0x78fb
jnp 0x79c8
movss 0x1c(%rsi), %xmm2
movss 0x2c(%rsi), %xmm6
movaps %xmm2, %xmm5
subss %xmm6, %xmm5
movss 0x8(%rsi), %xmm1
movss 0xc(%rsi), %xmm4
mulss %xmm0, %xmm5
movss 0x24(%rsi), %xmm7
movaps %xmm4, %xmm8
subss %xmm2, %xmm8
mulss %xmm7, %xmm8
movaps %xmm3, %xmm9
subss %xmm7, %xmm9
movss 0x18(%rsi), %xmm10
subss %xmm0, %xmm7
mulss %xmm1, %xmm9
movss 0x28(%rsi), %xmm11
subss %xmm3, %xmm0
mulss %xmm11, %xmm0
movaps %xmm10, %xmm12
subss %xmm11, %xmm12
subss %xmm1, %xmm11
subss %xmm10, %xmm1
mulss %xmm6, %xmm1
subss %xmm4, %xmm6
mulss %xmm3, %xmm6
addss %xmm6, %xmm5
addss %xmm5, %xmm8
xorps %xmm3, %xmm3
cvtsi2ss %edx, %xmm3
mulss %xmm8, %xmm3
mulss %xmm10, %xmm7
xorps %xmm5, %xmm5
cvtsi2ss %ecx, %xmm5
addss %xmm7, %xmm9
addss %xmm9, %xmm0
mulss %xmm0, %xmm5
addss %xmm3, %xmm5
xorps 0x18b3(%rip), %xmm5     # 0x9260
mulss %xmm2, %xmm11
mulss %xmm4, %xmm12
addss %xmm11, %xmm12
addss %xmm12, %xmm1
divss %xmm1, %xmm5
movaps %xmm5, %xmm0
cvttss2si %xmm0, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x856d
cvttss2si %xmm1, %rax
movaps %xmm1, %xmm3
shufps $0x55, %xmm1, %xmm3     # xmm3 = xmm3[1,1],xmm1[1,1]
movss 0xee1(%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 0x84c1
xorps %xmm2, %xmm2
cvtsi2ss %rax, %xmm2
jmp 0x84d9
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 0x84f0
xorps %xmm1, %xmm1
cvtsi2ss %rax, %xmm1
jmp 0x8508
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 0x851f
xorps %xmm3, %xmm3
cvtsi2ss %rax, %xmm3
jmp 0x8537
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 0x854f
xorps %xmm0, %xmm0
cvtsi2ss %rax, %xmm0
jmp 0x8567
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_O1/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 0x26b4
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x25da
leaq -0x38(%rbp), %rdi
callq 0x26eb
leaq -0x28(%rbp), %r14
movq -0x10(%r14), %rdi
cmpq %r14, %rdi
je 0x248d
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2150
callq 0x2eb8
movq 0x10(%rbx), %rsi
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x25da
leaq -0x38(%rbp), %rdi
callq 0x2b16
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_O1/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 0x3adf(%rip), %rcx      # 0x61a0
leal -0x61(%rax), %edx
cmpl $0x19, %edx
ja 0x26ce
leal -0x61(%rax), %edx
jmp 0x26db
leal -0x41(%rax), %esi
movb $-0x1, %dl
cmpl $0x19, %esi
ja 0x26db
leal -0x41(%rax), %edx
movb %dl, (%rax,%rcx)
incq %rax
cmpq $0x100, %rax            # imm = 0x100
jne 0x26c1
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33ca(%rip), %rsi      # 0x62a8
cmpq 0x33cb(%rip), %rsi      # 0x62b0
je 0x2ef4
movq %rdi, (%rsi)
addq $0x8, 0x33b6(%rip)      # 0x62a8
jmp 0x2f04
leaq 0x33a5(%rip), %rdi      # 0x62a0
leaq -0x28(%rbp), %rdx
callq 0x3462
movq -0x28(%rbp), %rdi
addq $0x28, %rdi
leaq 0x11a7(%rip), %rsi      # 0x40ba
callq 0x2080
testl %eax, %eax
je 0x2ff9
movq 0x30b1(%rip), %rdi      # 0x5fd8
leaq 0x118d(%rip), %rsi      # 0x40bb
movl $0xc, %edx
callq 0x2170
movq 0x3361(%rip), %rax      # 0x62a0
cmpq %rax, 0x3362(%rip)      # 0x62a8
je 0x2f8c
xorl %r15d, %r15d
movq 0x3086(%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 0x332f(%rip), %rcx      # 0x62a8
movq 0x3320(%rip), %rax      # 0x62a0
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r15, %rcx
ja 0x2f56
movq 0x3045(%rip), %rbx      # 0x5fd8
leaq 0x112e(%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 0x10f4(%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 0x3024
leaq 0x10(%rbx), %rdi
callq 0x2ec6
addq $-0x8, 0x328d(%rip)     # 0x62a8
movq (%rbx), %rbx
movq -0x28(%rbp), %rax
jmp 0x3001
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x33b4
movq %rdi, 0x8(%rsi)
movq (%rax), %rcx
movq %rcx, 0x18(%rsi)
jmp 0x33ba
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 0x33f4
movq %rdi, 0x28(%rsi)
movq (%rax), %rcx
movq %rcx, 0x38(%rsi)
jmp 0x33fa
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), %rdi
movq %rdi, 0x48(%rsi)
movq 0x50(%rdx), %rdi
movq %rdi, 0x50(%rsi)
movq 0x58(%rdx), %r8
movq %r8, 0x58(%rsi)
cmpq %rcx, 0x48(%rdx)
je 0x3458
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r13
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), %r12
leaq 0x38(%rdi), %rbx
movq %rbx, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
leaq 0x48(%rdi), %r15
movq %r15, 0x50(%rdi)
movq %r15, 0x48(%rdi)
movq %rax, 0x58(%rdi)
movb %sil, (%rdi)
movq %rcx, -0x30(%rbp)
movq %rcx, %rdi
movq %r13, %rsi
callq 0x20c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x20c0
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %rbx
movaps %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq %rbx, 0x8(%rbx)
movq %rbx, (%rbx)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x318e
movq %rbx, %rdi
callq 0x31f8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %r15, %rdi
callq 0x31f8
movq (%r12), %rdi
cmpq %rbx, %rdi
je 0x332d
movq (%rbx), %rsi
incq %rsi
callq 0x2150
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x222a
movq %r13, %rdi
callq 0x21d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x553c
testb %al, %al
je 0x5885
movq %r15, %rsi
callq 0x588e
testl %eax, %eax
js 0x5885
movl %eax, %ebp
leaq 0xab92(%rip), %rax      # 0x10350
cmpl $0x0, (%rax)
je 0x5860
movq 0xa7e2(%rip), %r12      # 0xffb0
leaq 0x593f(%rip), %rsi      # 0xb114
movl $0x9, %edx
movq %r12, %rdi
callq 0x4310
movq %r15, %rdi
callq 0x44e0
testq %rax, %rax
je 0x580e
movq %rax, %r15
movq %rax, %rdi
callq 0x4130
movq 0xa7af(%rip), %rdi      # 0xffb0
movq %r15, %rsi
movq %rax, %rdx
callq 0x4310
jmp 0x5827
movq (%r12), %rax
movq -0x18(%rax), %rax
leaq (%r12,%rax), %rdi
movl 0x20(%r12,%rax), %esi
orl $0x1, %esi
callq 0x4510
movq 0xa782(%rip), %r15      # 0xffb0
leaq 0x58e9(%rip), %rsi      # 0xb11e
movl $0x7, %edx
movq %r15, %rdi
callq 0x4310
movq %r15, %rdi
movl %ebp, %esi
callq 0x4530
leaq 0x5eb8(%rip), %rsi      # 0xb70b
movl $0x1, %edx
movq %rax, %rdi
callq 0x4310
movq 0x10(%r14), %rdi
movl %ebp, %r15d
testq %rdi, %rdi
je 0x587d
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_O1/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 0xa263(%rip), %r14      # 0x10354
movl (%r14), %eax
cmpb $0x0, 0xa24d(%rip)      # 0x10348
je 0x6155
movq %rdi, %rbx
testl %eax, %eax
jle 0x611c
movq 0x9ea5(%rip), %rdi      # 0xffb0
leaq 0x52ce(%rip), %rsi      # 0xb3e0
movl $0x2a, %edx
callq 0x4310
movq (%rbx), %rdi
callq 0x43e0
testl %eax, %eax
jne 0x6186
movq (%rbx), %rdi
xorl %esi, %esi
callq 0x4250
testl %eax, %eax
jne 0x61e5
cmpl $0x0, (%r14)
jle 0x617b
movq 0x9e69(%rip), %rdi      # 0xffb0
leaq 0x52d9(%rip), %rsi      # 0xb427
movl $0x1f, %edx
jmp 0x616c
testl %eax, %eax
jle 0x617b
movq 0x9e50(%rip), %rdi      # 0xffb0
leaq 0x5251(%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 0x5268(%rip), %rsi      # 0xb40b
leaq 0x526f(%rip), %rdx      # 0xb419
leaq 0x8(%rsp), %rdi
callq 0x5e88
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be8
xorl %ebp, %ebp
leaq 0x951c(%rip), %rsi      # 0xf6f0
movq 0x9dc5(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6242
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5218(%rip), %rsi      # 0xb41a
leaq 0x521d(%rip), %rdx      # 0xb426
leaq 0x8(%rsp), %rdi
callq 0x5e88
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be8
xorl %ebp, %ebp
leaq 0x94bd(%rip), %rsi      # 0xf6f0
movq 0x9d66(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6246
jmp 0x6262
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6268
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
jmp 0x6268
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6275
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xa0b9(%rip)      # 0x10348
jne 0x62b2
leaq 0xa0bc(%rip), %rax      # 0x10354
cmpl $0x0, (%rax)
jle 0x62fb
movq 0x9d0c(%rip), %rdi      # 0xffb0
leaq 0x50b6(%rip), %rsi      # 0xb361
movl $0x27, %edx
jmp 0x62ec
leaq 0xe1(%rip), %rdx        # 0x639a
xorl %esi, %esi
xorl %ecx, %ecx
callq 0x4590
testl %eax, %eax
jne 0x6306
movb $0x1, 0xa07b(%rip)      # 0x10348
leaq 0xa080(%rip), %rax      # 0x10354
cmpl $0x0, (%rax)
jle 0x62fb
movq 0x9cd0(%rip), %rdi      # 0xffb0
leaq 0x50b1(%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 0x5066(%rip), %rsi      # 0xb389
leaq 0x506d(%rip), %rdx      # 0xb397
leaq 0x8(%rsp), %rdi
callq 0x5e88
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be8
xorl %ebp, %ebp
leaq 0x939c(%rip), %rsi      # 0xf6f0
movq 0x9c45(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6385
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
jmp 0x6385
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6392
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9ca4(%rip), %rax      # 0x10354
cmpl $0x0, (%rax)
jle 0x66cd
movq 0x98f4(%rip), %rdi      # 0xffb0
leaq 0x4d84(%rip), %rsi      # 0xb447
movl $0x2d, %edx
callq 0x4310
movb $0x0, 0x9c74(%rip)      # 0x10348
movq 0x9c5d(%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_O1/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 0x131(%rip), %rax       # 0x6b94
movq %rax, -0x8(%rdi)
callq 0x4390
leaq 0x20(%rsp), %rsi
movl $0x2, %edi
xorl %edx, %edx
callq 0x43b0
cmpl $-0x1, %eax
je 0x6aa6
leaq 0x20(%rsp), %rsi
movl $0xf, %edi
xorl %edx, %edx
callq 0x43b0
cmpl $-0x1, %eax
je 0x6b01
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 0x4b7d(%rip), %rsi      # 0xb640
leaq 0x4b87(%rip), %rdx      # 0xb651
movq %rsp, %rdi
callq 0x5e88
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5be8
xorl %ebp, %ebp
leaq 0x8c00(%rip), %rsi      # 0xf6f0
movq 0x94a9(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6b5a
movl $0x10, %edi
callq 0x4140
movq %rax, %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4b34(%rip), %rsi      # 0xb652
leaq 0x4b3f(%rip), %rdx      # 0xb664
movq %rsp, %rdi
callq 0x5e88
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x5be8
xorl %ebp, %ebp
leaq 0x8ba5(%rip), %rsi      # 0xf6f0
movq 0x944e(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
jmp 0x6b5e
jmp 0x6b79
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x6b7f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x42c0
jmp 0x6b7f
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x6b8c
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/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 0x857a
movl %esi, %eax
outl %eax, %dx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8644
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 0x8644
movl %r8d, %eax
outl %eax, %dx
andl $0x2, %esi
je 0x8674
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 0x8674
movl %r8d, %eax
outl %eax, %dx
shll $0x14, %r9d
shll $0x17, %esi
orl %r9d, %esi
je 0x869c
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 0x869c
movl %esi, %eax
outl %eax, %dx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x86de
testb %al, %al
je 0x86d9
movq %rbx, %rdi
callq 0x893c
testb %al, %al
je 0x86d9
movq %rbx, %rdi
callq 0x8d54
movb $0x1, %al
jmp 0x86db
xorl %eax, %eax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8db2
leaq 0x2eaf(%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 0x8d83
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 0x2d53(%rip), %rsi      # 0xbb22
leaq 0x2d52(%rip), %rdx      # 0xbb28
leaq 0x8(%rsp), %rdi
callq 0x5e88
callq 0x4030
movl (%rax), %edx
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x5be8
xorl %ebp, %ebp
leaq 0x68f0(%rip), %rsi      # 0xf6f0
movq 0x7199(%rip), %rdx      # 0xffa0
movq %rbx, %rdi
callq 0x4520
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x8e31
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x42c0
jmp 0x8e31
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x8e3e
movq %rbx, %rdi
callq 0x41e0
movq %r14, %rdi
callq 0x4550
// File: /workspace/github_cpp_makefile_star2_O1/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 0x913b
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 0x913a
outl %eax, %dx
retq
pushq %rax
leaq 0x2a33(%rip), %rdi      # 0xbb76
leaq 0x2a35(%rip), %rsi      # 0xbb7f
leaq 0x2a4d(%rip), %rcx      # 0xbb9e
movl $0x11a, %edx            # imm = 0x11A
callq 0x4190
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/net/test/test_iobuffer.cc
// Function: testPush(char const*, char const*, char const*, net::IOBuffer&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, bool)
void testPush(const char *module, const char *msg, const char *data, Buffer &b, std::string &s, bool const expect = true){
	bool const result = b.push(data);

	if (expect)
		s += data;

	PRINTF_TEST(msg,	result == expect			);
	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 %rdx, %r12
movq %rsi, (%rsp)
movq %rdi, %rbx
movq %rcx, %rdi
movq %rdx, %rsi
callq 0x1516
movl %eax, %r13d
testl %ebp, %ebp
je 0x11e7
movq %r14, %rdi
movq %r12, %rsi
callq 0x10a0
xorb %bpl, %r13b
leaq 0xe2e(%rip), %rbp       # 0x201f
leaq 0xe24(%rip), %r12       # 0x201c
movq %r12, %rcx
cmovneq %rbp, %rcx
leaq 0xdfe(%rip), %r13       # 0x2004
movq %r13, %rdi
movq %rbx, %rsi
movq (%rsp), %rdx
xorl %eax, %eax
callq 0x1030
movq 0x8(%r14), %rdx
movq 0x8(%r15), %rcx
addq (%r15), %rcx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1080
testl %eax, %eax
cmovneq %rbp, %r12
leaq 0xdeb(%rip), %rdx       # 0x2024
movq %r13, %rdi
movq %rbx, %rsi
movq %r12, %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_O1/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 0x129e
movq (%r15), %rax
movq 0x10(%r15), %rcx
subq %rax, %rcx
cmpq %rdx, %rcx
setae %r13b
jb 0x12ac
jne 0x12a3
movq $0x0, 0x10(%r15)
movq 0x8(%r15), %rax
movb $0x0, (%rax)
xorl %eax, %eax
jmp 0x12a6
xorl %r13d, %r13d
jmp 0x12ac
addq %rdx, %rax
movq %rax, (%r15)
movb $0x1, %r13b
testb %bpl, %bpl
je 0x12bb
movq %r14, %rdi
xorl %esi, %esi
callq 0x1050
xorb %bpl, %r13b
leaq 0xd5a(%rip), %r13       # 0x201f
leaq 0xd50(%rip), %rbp       # 0x201c
movq %rbp, %rcx
cmovneq %r13, %rcx
leaq 0xd2a(%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 0x130f
addq 0x8(%r15), %rcx
movq %r14, %rdi
xorl %esi, %esi
callq 0x1080
testl %eax, %eax
sete %al
leaq 0xd17(%rip), %rdx       # 0x2024
jmp 0x131d
cmpq %rcx, 0x10(%r15)
sete %al
leaq 0xd0d(%rip), %rdx       # 0x202a
testb %al, %al
cmovneq %rbp, %r13
leaq 0xcda(%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_O1/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 0xcb6(%rip), %rsi       # 0x2034
leaq 0xcb4(%rip), %rdx       # 0x2039
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x1, %r9d
callq 0x11ac
leaq 0xc9c(%rip), %rsi       # 0x203d
leaq 0xc73(%rip), %rdx       # 0x201b
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
xorl %r9d, %r9d
callq 0x11ac
leaq 0xc70(%rip), %rsi       # 0x2034
leaq 0xc7c(%rip), %rdx       # 0x2047
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x11ac
leaq 0xc4a(%rip), %rsi       # 0x2034
leaq 0xc5a(%rip), %rdx       # 0x204b
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x11ac
leaq 0xc3f(%rip), %rsi       # 0x204f
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x1257
leaq 0xc1f(%rip), %rsi       # 0x2053
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movq %rbx, %rdi
xorl %edx, %edx
xorl %r9d, %r9d
callq 0x1257
leaq 0xbfd(%rip), %rsi       # 0x204f
leaq 0x28(%rsp), %rcx
leaq 0x8(%rsp), %r8
movl $0x3, %edx
movq %rbx, %rdi
movl $0x1, %r9d
callq 0x1257
leaq 0xbd9(%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 0x14aa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x14c1
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 0x14e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x1070
movq 0x30(%rsp), %rdi
cmpq %r14, %rdi
je 0x14fc
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x1070
movq %rbx, %rdi
callq 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/dm4[P]huffman-homework/decode.cc
// Function: calcBase(int, char*)
int calcBase(int height, char *codeword) {
    unsigned int mask = 1 << 3;
    int sum = 0;
    for (int i = height - 4; codeword[i]; i++) {
        if (codeword[i] == '1')
            sum += mask;
        mask >>= 1;
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
addl $-0x4, %edi
movslq %edi, %rcx
addq %rsi, %rcx
xorl %eax, %eax
movl $0x8, %edx
movzbl (%rcx), %esi
cmpl $0x31, %esi
je 0x14c3
testl %esi, %esi
jne 0x14c5
jmp 0x14cc
addl %edx, %eax
shrl %edx
incq %rcx
jmp 0x14b5
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dm4[P]huffman-homework/decode.cc
// Function: bin2dec(int, int, char*)
int bin2dec(int from, int to, char *codeword) {
    unsigned int mask = 1 << (to - from - 1);
    int sum = 0;
    for (int i = from; i < to; i++) {
        if (codeword[i] == '1')
            sum += mask;
        mask >>= 1;
    }
    return sum;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
cmpl %esi, %edi
jge 0x150a
movslq %edi, %r8
notl %edi
addl %esi, %edi
movl $0x1, %r9d
movl %edi, %ecx
shll %cl, %r9d
movslq %esi, %rcx
xorl %eax, %eax
cmpb $0x31, (%rdx,%r8)
movl $0x0, %esi
cmovel %r9d, %esi
addl %esi, %eax
shrl %r9d
incq %r8
cmpq %r8, %rcx
jne 0x14ef
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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:
cmpb $0x0, (%rdi)
je 0x1548
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
testb $0x3, %r14b
jne 0x152e
movl $0x20, %edi
callq 0x1170
movsbl (%rbx,%r14), %edi
callq 0x1170
cmpb $0x0, 0x1(%rbx,%r14)
leaq 0x1(%r14), %r14
jne 0x151e
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/dm4[P]huffman-homework/decode.cc
// Function: alignBuf(char*)
void alignBuf(char buf[5]) {
    int index = 0;
    int num = 0;
    for (int i = 0; i < 4; i++) {
        if (buf[i]) {
            buf[index++] = buf[i];
            num++;
        }
    }
    for (int i = num; i < 4; i++) {
        buf[i] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movb (%rdi,%rcx), %sil
testb %sil, %sil
je 0x1567
movslq %edx, %r8
incl %edx
movb %sil, (%rdi,%r8)
incl %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x1553
cmpl $0x3, %eax
jg 0x158d
movslq %eax, %rcx
addq %rcx, %rdi
movl $0x3, %edx
subl %eax, %edx
incq %rdx
xorl %esi, %esi
popq %rbp
jmp 0x10a0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::Graph(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
Graph::Graph(vector<vector<int> >& c_nodes) {
  nb_nodes     = 0;
  nb_links     = 0;
  total_weight = 0;
  
  nodes.reserve(c_nodes.size());
  for (size_t i=0; i<c_nodes.size(); i++) {
    nodes.push_back(c_nodes[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
leaq 0x30(%rdi), %r14
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq %r14, %rdi
callq 0x329e
movq (%r15), %rsi
cmpq %rsi, 0x8(%r15)
je 0x2a3a
xorl %r13d, %r13d
xorl %ebp, %ebp
addq %r13, %rsi
movq %r14, %rdi
callq 0x3224
incq %rbp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x18, %r13
cmpq %rax, %rbp
jb 0x2a11
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a4b
movq %rax, %r15
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2a63
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2a78
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x3250
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2a95
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r15, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::write_community(char const*)
void
Graph::write_community(const char *filename_w) {
  FILE* fOut = fopen(filename_w, "wt");
  for (size_t i=0; i<nodes.size(); i++) {
    for (size_t j=0; j<nodes[i].size(); j++) {
      fprintf(fOut, "%d ", nodes[i][j]);  
    }
    fprintf(fOut, "\n");  
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x54ea(%rip), %rsi      # 0x8074
movq %rax, %rdi
callq 0x2240
movq %rax, %r14
movq 0x38(%rbx), %rax
cmpq 0x30(%rbx), %rax
je 0x2c26
leaq 0x54cd(%rip), %r15      # 0x8077
xorl %r13d, %r13d
movq 0x30(%rbx), %rcx
leaq (,%r13,2), %rbp
addq %r13, %rbp
movq (%rcx,%rbp,8), %rax
cmpq %rax, 0x8(%rcx,%rbp,8)
je 0x2bf7
xorl %r12d, %r12d
movl (%rax,%r12,4), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22a0
incq %r12
movq 0x30(%rbx), %rcx
movq (%rcx,%rbp,8), %rax
movq 0x8(%rcx,%rbp,8), %rcx
subq %rax, %rcx
sarq $0x2, %rcx
cmpq %rcx, %r12
jb 0x2bca
movl $0xa, %edi
movq %r14, %rsi
callq 0x2270
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
incq %r13
sarq $0x3, %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rcx, %rax
cmpq %rax, %r13
jb 0x2bad
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::display_reverse()
void
Graph::display_reverse() {
  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      if (node>*(p.first+i)) {
	if (weights.size()!=0)
	  cout << *(p.first+i) << " " << node << " " << *(p.second+i) << endl;
	else
	  cout << *(p.first+i) << " " << node << endl;
      }
    }   
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
cmpl $0x0, (%rdi)
je 0x2da8
movq %rdi, %rbx
xorl %r14d, %r14d
testq %r14, %r14
je 0x2c81
movq 0x60(%rbx), %rcx
cmpq %rcx, 0x68(%rbx)
je 0x2c8f
movq 0x18(%rbx), %rax
movq -0x8(%rax,%r14,8), %rax
leaq (,%rax,4), %rdx
addq 0x48(%rbx), %rdx
leaq (%rcx,%rax,4), %rcx
movq %rcx, (%rsp)
jmp 0x2ca4
movq 0x48(%rbx), %rdx
movq 0x60(%rbx), %rax
movq %rax, (%rsp)
jmp 0x2ca4
movq %rcx, (%rsp)
movq 0x18(%rbx), %rax
movq -0x8(%rax,%r14,8), %rdx
shlq $0x2, %rdx
addq 0x48(%rbx), %rdx
movl (%rbx), %eax
cmpq %rax, %r14
jae 0x2db7
leal -0x1(%r14), %eax
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
movq %rdx, 0x8(%rsp)
testq %r14, %r14
je 0x2cd7
movq 0x18(%rbx), %rcx
movq (%rcx,%r14,8), %rax
movq 0x10(%rsp), %rsi
subq (%rcx,%rsi,8), %rax
jmp 0x2cdd
movq 0x18(%rbx), %rax
movl (%rax), %eax
movl %eax, %eax
cmpq %rax, %rbp
jae 0x2d9a
movl (%rdx,%rbp,4), %esi
cmpq %rsi, %r14
jbe 0x2d8a
movq 0x68(%rbx), %r12
movq 0x60(%rbx), %r15
movq 0x92cd(%rip), %rdi      # 0xbfd0
callq 0x2140
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x59a9(%rip), %rsi      # 0x86c3
callq 0x2230
movq %r13, %rdi
movq %r14, %rsi
callq 0x2140
movq %rax, %r13
cmpq %r15, %r12
je 0x2d5d
movl $0x1, %edx
movq %r13, %rdi
leaq 0x5982(%rip), %rsi      # 0x86c3
callq 0x2230
movq (%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbp,4), %xmm0
movq %r13, %rdi
callq 0x2300
movq %rax, %r13
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq 0x8(%rsp), %rdx
incq %rbp
movl (%rbx), %eax
cmpq %rax, %r14
jb 0x2cbf
jmp 0x2db7
incq %r14
movl (%rbx), %eax
cmpq %rax, %r14
jb 0x2c53
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52bd(%rip), %rdi      # 0x807b
leaq 0x52cf(%rip), %rsi      # 0x8094
leaq 0x5336(%rip), %rcx      # 0x8102
movl $0x5a, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::display_binary(char*)
void
Graph::display_binary(char *outfile) {
  ofstream foutput;
  foutput.open(outfile ,fstream::out | fstream::binary);

  foutput.write((char *)(&nb_nodes),4);
  foutput.write((char *)(&degrees[0]),4*nb_nodes);
  foutput.write((char *)(&links[0]),8*nb_links);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rsi, %r14
movq %rdi, %rbx
movq %rsp, %r15
movq %r15, %rdi
callq 0x2340
movq %r15, %rdi
movq %r14, %rsi
movl $0x14, %edx
callq 0x2040
movq %rsp, %rdi
movl $0x4, %edx
movq %rbx, %rsi
callq 0x2290
movq 0x18(%rbx), %rsi
movl (%rbx), %edx
shll $0x2, %edx
movq %rsp, %rdi
callq 0x2290
movq 0x8(%rbx), %rdx
movq 0x48(%rbx), %rsi
shlq $0x3, %rdx
movq %rsp, %rdi
callq 0x2290
movq 0x8e85(%rip), %rax      # 0xbfc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x8(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, (%rsp,%rcx)
callq 0x2180
leaq 0xf8(%rsp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x22d0
movq %rbx, %rdi
callq 0x2370
nop