LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: VectorNormalize2
vec_t VectorNormalize2 (vec3_t v, vec3_t out)
{
	float	length, ilength;

	length = v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
	length = sqrt (length);		// FIXME

	if (length)
	{
		ilength = 1/length;
		out[0] = v[0]*ilength;
		out[1] = v[1]*ilength;
		out[2] = v[2]*ilength;
	}
		
	return length;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm1
movq -0x8(%rbp), %rax
movss (%rax), %xmm2
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
mulss 0x4(%rax), %xmm0
mulss %xmm2, %xmm1
addss %xmm0, %xmm1
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm2
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19aa0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x6d751
jp 0x6d751
jmp 0x6d7a6
movss 0x2793(%rip), %xmm0     # 0x6feec
divss -0x14(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x4(%rax)
movq -0x8(%rbp), %rax
movss 0x8(%rax), %xmm0
mulss -0x18(%rbp), %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, 0x8(%rax)
movss -0x14(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: VectorLength
vec_t VectorLength(vec3_t v)
{
	int		i;
	float	length;
	
	length = 0;
	for (i=0 ; i< 3 ; i++)
		length += v[i]*v[i];

	length = sqrt (length);		// FIXME

	return length;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0xc(%rbp)
jge 0x6da18
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm0
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movss (%rax,%rcx,4), %xmm2
movss -0x10(%rbp), %xmm1
mulss %xmm2, %xmm0
addss %xmm1, %xmm0
movss %xmm0, -0x10(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6d9db
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x19aa0
cvtsd2ss %xmm0, %xmm0
movss %xmm0, -0x10(%rbp)
movss -0x10(%rbp), %xmm0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Q_log2
int Q_log2(int val)
{
	int answer=0;
	val>>=1;
	while (val)
	{
		answer++;
		val>>=1;
	}
	return answer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
je 0x6db3f
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl -0x4(%rbp), %eax
sarl %eax
movl %eax, -0x4(%rbp)
jmp 0x6db26
movl -0x8(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: COM_SkipPath
char *COM_SkipPath (char *pathname)
{
	char	*last;
	
	last = pathname;
	while (*pathname)
	{
		if (*pathname=='/')
			last = pathname+1;
		pathname++;
	}
	return last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
je 0x6db8f
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
jne 0x6db81
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
jmp 0x6db60
movq -0x10(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: COM_FileExtension
char *COM_FileExtension (char *in)
{
	static char exten[8];
	int		i;

	while (*in && *in != '.')
		in++;
	if (!*in)
		return "";
	in++;
	for (i=0 ; i<7 && *in ; i++,in++)
		exten[i] = *in;
	exten[i] = 0;
	return exten;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0x6dc39
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x6dc42
jmp 0x6dc50
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6dc18
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6dc66
leaq 0x3320(%rip), %rax      # 0x70f80
movq %rax, -0x8(%rbp)
jmp 0x6dce2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
xorl %eax, %eax
cmpl $0x7, -0x14(%rbp)
movb %al, -0x16(%rbp)
jge 0x6dc94
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x6dc9d
jmp 0x6dcc8
movq -0x10(%rbp), %rax
movb (%rax), %dl
movslq -0x14(%rbp), %rcx
leaq 0x455e6(%rip), %rax     # 0xb3294
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6dc79
movslq -0x14(%rbp), %rcx
leaq 0x455c1(%rip), %rax     # 0xb3294
movb $0x0, (%rax,%rcx)
leaq 0x455b6(%rip), %rax     # 0xb3294
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: COM_FileBase
void COM_FileBase (char *in, char *out)
{
	char *s, *s2;
	
	s = in + strlen(in) - 1;
	
	while (s != in && *s != '.')
		s--;
	
	for (s2 = s ; s2 != in && *s2 != '/' ; s2--)
	;
	
	if (s-s2 < 2)
		out[0] = 0;
	else
	{
		s--;
		strncpy (out,s2+1, s-s2);
		out[s-s2] = 0;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
callq 0x186e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x29(%rbp)
je 0x6dd42
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
setne %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x6dd4b
jmp 0x6dd59
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6dd23
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x2a(%rbp)
je 0x6dd80
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x2a(%rbp)
movb -0x2a(%rbp), %al
testb $0x1, %al
jne 0x6dd89
jmp 0x6dd99
jmp 0x6dd8b
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x6dd61
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jge 0x6ddb3
movq -0x10(%rbp), %rax
movb $0x0, (%rax)
jmp 0x6ddee
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x1, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
subq %rax, %rdx
callq 0x181e0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: COM_FilePath
void COM_FilePath (char *in, char *out)
{
	char *s;
	
	s = in + strlen(in) - 1;
	
	while (s != in && *s != '/')
		s--;

	strncpy (out,in, s-in);
	out[s-in] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x186e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpq -0x8(%rbp), %rcx
movb %al, -0x21(%rbp)
je 0x6de52
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2f, %eax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6de5b
jmp 0x6de69
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6de33
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rsi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rax
subq %rax, %rdx
callq 0x181e0
movq -0x10(%rbp), %rax
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rdx
subq %rdx, %rcx
movb $0x0, (%rax,%rcx)
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: COM_DefaultExtension
void COM_DefaultExtension (char *path, char *extension)
{
	char    *src;
//
// if path doesn't have a .EXT, append extension
// (extension should include the .)
//
	src = path + strlen(path) - 1;

	while (*src != '/' && src != path)
	{
		if (*src == '.')
			return;                 // it has an extension
		src--;
	}

	strcat (path, extension);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x186e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
addq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x2f, %ecx
movb %al, -0x21(%rbp)
je 0x6def2
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6defb
jmp 0x6df17
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x6df09
jmp 0x6df24
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6ded3
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x19880
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Q_stricmp
int Q_stricmp(const char* s1, const char* s2)
{
	const unsigned char
		* uc1 = (const unsigned char*)s1,
		* uc2 = (const unsigned char*)s2;

	while (tolower(*uc1) == tolower(*uc2++))
		if (*uc1++ == '\0')
			return (0);
	return (tolower(*uc1) - tolower(*--uc2));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x19070
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %edi
callq 0x19070
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jne 0x6e2d1
movq -0x20(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x20(%rbp)
movzbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6e2cf
movl $0x0, -0x4(%rbp)
jmp 0x6e302
jmp 0x6e280
movq -0x20(%rbp), %rax
movzbl (%rax), %edi
callq 0x19070
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $-0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl -0x1(%rax), %edi
callq 0x19070
movl %eax, %ecx
movl -0x30(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Q_strnicmp
int Q_strnicmp(const char* s1, const char* s2, size_t count)
{
	if (count == 0)
		return 0;
	else
	{
		while (count-- != 0 && tolower(*s1) == tolower(*s2))
		{
			if (count == 0 || *s1 == '\0' || *s2 == '\0')
				break;
			s1++;
			s2++;
		}

		return tolower(*(unsigned char*)s1) - tolower(*(unsigned char*)s2);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6e337
movl $0x0, -0x4(%rbp)
jmp 0x6e3e7
jmp 0x6e339
movq -0x20(%rbp), %rcx
movq %rcx, %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpq $0x0, %rcx
movb %al, -0x21(%rbp)
je 0x6e37b
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
callq 0x19070
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movsbl (%rax), %edi
callq 0x19070
movl %eax, %ecx
movl -0x28(%rbp), %eax
cmpl %ecx, %eax
sete %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x6e384
jmp 0x6e3c2
cmpq $0x0, -0x20(%rbp)
je 0x6e3a3
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x6e3a3
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
jne 0x6e3a5
jmp 0x6e3c2
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x6e339
movq -0x10(%rbp), %rax
movzbl (%rax), %edi
callq 0x19070
movl %eax, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movzbl (%rax), %edi
callq 0x19070
movl %eax, %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Com_sprintf
void Com_sprintf(char* dest, int size, char* fmt, ...)
{
	int		len;
	va_list	argptr;

	va_start(argptr, fmt);
	len = vsprintf(bigbuffer, fmt, argptr);
	va_end(argptr);
	if (len < size)
		strncpy(dest, bigbuffer, (size_t)size - 1);
	else
		Com_Printf("Com_sprintf: overflow of %i in %i\n", len, size);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
testb %al, %al
je 0x6e42b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x40(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x18, (%rax)
movq -0x18(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq 0x45432(%rip), %rdi     # 0xb38b0
callq 0x19540
movl %eax, -0x1c(%rbp)
leaq -0x40(%rbp), %rax
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x6e4ac
movq -0x8(%rbp), %rdi
movslq -0xc(%rbp), %rdx
subq $0x1, %rdx
leaq 0x4540b(%rip), %rsi     # 0xb38b0
callq 0x181e0
jmp 0x6e4c0
movl -0x1c(%rbp), %esi
movl -0xc(%rbp), %edx
leaq 0x97f9(%rip), %rdi      # 0x77cb2
movb $0x0, %al
callq 0x190b0
addq $0xf0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Info_ValueForKey
char *Info_ValueForKey (char *s, char *key)
{
	char	pkey[MAX_INFO_STRING];
	static	char value[2][MAX_INFO_STRING]; // Use two buffers so compares work without stomping on each other.
	static	int	valueindex;
	char	*o;
	
	valueindex ^= 1;
	if (*s == '\\')
		s++;
	while (1)
	{
		o = pkey;
		while (*s != '\\')
		{
			if (!*s)
				return "";
			*o++ = *s++;
		}
		*o = 0;
		s++;

		o = value[valueindex];

		while (*s != '\\' && *s)
		{
			if (!*s)
				return "";
			*o++ = *s++;
		}
		*o = 0;

		if (!strcmp (key, pkey) )
			return value[valueindex];

		if (!*s)
			return "";
		s++;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x230, %rsp            # imm = 0x230
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl 0x557c7(%rip), %eax     # 0xc3cb0
xorl $0x1, %eax
movl %eax, 0x557be(%rip)     # 0xc3cb0
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x6e50a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6e50c
leaq -0x220(%rbp), %rax
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x6e569
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e53f
leaq 0x2a4a(%rip), %rax      # 0x70f80
movq %rax, -0x8(%rbp)
jmp 0x6e672
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x228(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x228(%rbp)
movb %cl, (%rax)
jmp 0x6e51a
movq -0x228(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movslq 0x5572a(%rip), %rcx     # 0xc3cb0
leaq 0x55323(%rip), %rax     # 0xc38b0
shlq $0x9, %rcx
addq %rcx, %rax
movq %rax, -0x228(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x5c, %ecx
movb %al, -0x229(%rbp)
je 0x6e5c2
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x229(%rbp)
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x6e5ce
jmp 0x6e611
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e5e7
leaq 0x29a2(%rip), %rax      # 0x70f80
movq %rax, -0x8(%rbp)
jmp 0x6e672
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movb (%rax), %cl
movq -0x228(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x228(%rbp)
movb %cl, (%rax)
jmp 0x6e59b
movq -0x228(%rbp), %rax
movb $0x0, (%rax)
movq -0x18(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x6e64b
movslq 0x55679(%rip), %rcx     # 0xc3cb0
leaq 0x55272(%rip), %rax     # 0xc38b0
shlq $0x9, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x6e672
movq -0x10(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e661
leaq 0x2925(%rip), %rax      # 0x70f80
movq %rax, -0x8(%rbp)
jmp 0x6e672
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x6e50c
movq -0x8(%rbp), %rax
addq $0x230, %rsp            # imm = 0x230
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Info_RemoveKey
void Info_RemoveKey (char *s, char *key)
{
	char	*start;
	char	pkey[MAX_INFO_STRING];
	char	value[MAX_INFO_STRING];
	char	*o;

	if (strstr (key, "\\"))
	{
//		Com_Printf ("Can't use a key with a \\\n");
		return;
	}

	while (1)
	{
		start = s;
		if (*s == '\\')
			s++;
		o = pkey;
		while (*s != '\\')
		{
			if (!*s)
				return;
			*o++ = *s++;
		}
		*o = 0;
		s++;

		o = value;
		while (*s != '\\' && *s)
		{
			if (!*s)
				return;
			*o++ = *s++;
		}
		*o = 0;

		if (!strcmp (key, pkey) )
		{
			strcpy (start, s);	// remove this part
			return;
		}

		if (!*s)
			return;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x430, %rsp            # imm = 0x430
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x9637(%rip), %rsi      # 0x77cd5
callq 0x19bf0
cmpq $0x0, %rax
je 0x6e6ae
jmp 0x6e7ec
jmp 0x6e6b0
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
jne 0x6e6d0
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x220(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x5c, %eax
je 0x6e722
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e6f8
jmp 0x6e7ec
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x428(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x428(%rbp)
movb %cl, (%rax)
jmp 0x6e6de
movq -0x428(%rbp), %rax
movb $0x0, (%rax)
movq -0x8(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x8(%rbp)
leaq -0x420(%rbp), %rax
movq %rax, -0x428(%rbp)
movq -0x8(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x5c, %ecx
movb %al, -0x429(%rbp)
je 0x6e76d
movq -0x8(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
setne %al
movb %al, -0x429(%rbp)
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0x6e779
jmp 0x6e7ae
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e784
jmp 0x6e7ec
movq -0x8(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x8(%rbp)
movb (%rax), %cl
movq -0x428(%rbp), %rax
movq %rax, %rdx
addq $0x1, %rdx
movq %rdx, -0x428(%rbp)
movb %cl, (%rax)
jmp 0x6e746
movq -0x428(%rbp), %rax
movb $0x0, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x18bf0
cmpl $0x0, %eax
jne 0x6e7dc
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x182c0
jmp 0x6e7ec
movq -0x8(%rbp), %rax
cmpb $0x0, (%rax)
jne 0x6e7e7
jmp 0x6e7ec
jmp 0x6e6b0
addq $0x430, %rsp            # imm = 0x430
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/QwazyWabbitWOS[P]lmctf60/q_shared.c
// Function: Info_Validate
qboolean Info_Validate (char *s)
{
	if (strstr (s, "\""))
		return false;
	if (strstr (s, ";"))
		return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq 0x94c0(%rip), %rsi      # 0x77cd7
callq 0x19bf0
cmpq $0x0, %rax
je 0x6e82b
movl $0x0, -0x4(%rbp)
jmp 0x6e851
movq -0x10(%rbp), %rdi
leaq 0x94a3(%rip), %rsi      # 0x77cd9
callq 0x19bf0
cmpq $0x0, %rax
je 0x6e84a
movl $0x0, -0x4(%rbp)
jmp 0x6e851
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lacework-dev[P]strace_lab_PUBLIC/./src/example_1.c
// Function: main
int main(int argc, char *argv[])
{
	unsigned int fd = open("/tmp/this_file_should_not_exist", O_RDONLY);
	if (fd == -1) {
		printf("[!] Error!\n");
		return 1;
	}
	else if (fd == 99) {
		printf("[*] whoa, should never get here!\n");
		return 99;
	}
	else {
	    printf("The file exists!\n");
	}

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe97(%rip), %rdi       # 0x2004
xorl %esi, %esi
movb $0x0, %al
callq 0x1040
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
jne 0x1196
leaq 0xe9e(%rip), %rdi       # 0x2024
movb $0x0, %al
callq 0x1030
movl $0x1, -0x4(%rbp)
jmp 0x11ca
cmpl $0x63, -0x14(%rbp)
jne 0x11b3
leaq 0xe8d(%rip), %rdi       # 0x2030
movb $0x0, %al
callq 0x1030
movl $0x63, -0x4(%rbp)
jmp 0x11ca
leaq 0xe98(%rip), %rdi       # 0x2052
movb $0x0, %al
callq 0x1030
jmp 0x11c3
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/extrm-ranged.c
// Function: open_ext4_db
static struct inode *open_ext4_db(char *file)
{
	int fd;
	struct ext4_extent_header *ihdr;
	struct inode *inode;
	struct db_handle *db;
	struct block_device *bdev;

	fd = device_open(file);

	bdev = bdev_alloc(fd, 12);
	inode = inode_alloc(bdev->bd_super);

	/* For testing purpose, those data is hard-coded. */
	inode->i_writeback = inode_sb_writeback;
	memset(inode->i_uuid, 0xCC, sizeof(inode->i_uuid));
	inode->i_inum = 45;
	inode->i_csum = ext4_crc32c(~0, inode->i_uuid, sizeof(inode->i_uuid));
	inode->i_csum =
	    ext4_crc32c(inode->i_csum, &inode->i_inum, sizeof(inode->i_inum));
	inode->i_csum = ext4_crc32c(inode->i_csum, &inode->i_generation,
				    sizeof(inode->i_generation));

	if (!device_size(bdev))
		exit(EXIT_FAILURE);

	db = db_open(inode->i_sb);
	ihdr = ext4_ext_inode_hdr(inode);
	memcpy(ihdr, db->db_header->db_tree_base, sizeof(inode->i_data));

	if (ihdr->eh_magic != EXT4_EXT_MAGIC) {
		ext4_ext_init_i_blocks(ihdr);
		inode->i_data_dirty = 1;
	}

	inode->i_db = db;

	return inode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2c70
movl %eax, -0xc(%rbp)
movl -0xc(%rbp), %edi
movl $0xc, %esi
callq 0x2cc0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2770
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
leaq 0x1bb(%rip), %rcx       # 0x27c0
movq %rcx, 0x78(%rax)
movq -0x20(%rbp), %rdi
addq $0x8, %rdi
movl $0xcc, %esi
movl $0x10, %edx
callq 0x20d0
movq -0x20(%rbp), %rax
movl $0x2d, 0x20(%rax)
movq -0x20(%rbp), %rsi
addq $0x8, %rsi
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
movl $0x10, %edx
callq 0x5470
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
movl $0x4, %edx
callq 0x5470
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %edi
movq -0x20(%rbp), %rsi
addq $0x24, %rsi
movl $0x4, %edx
callq 0x5470
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x30(%rbp), %rdi
callq 0x3d90
cmpq $0x0, %rax
jne 0x26a8
movl $0x1, %edi
callq 0x2250
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x5f40
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x2810
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rsi
addq $0x14, %rsi
movl $0x3c, %edx
callq 0x2170
movq -0x18(%rbp), %rax
movzwl (%rax), %eax
cmpl $0xf30a, %eax           # imm = 0xF30A
je 0x2706
movq -0x18(%rbp), %rdi
callq 0x87f0
movq -0x20(%rbp), %rax
movb 0x74(%rax), %cl
andb $-0x2, %cl
orb $0x1, %cl
movb %cl, 0x74(%rax)
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/extrm-ranged.c
// Function: free_ext4_db
static void free_ext4_db(struct inode *inode)
{
	struct db_handle *db_handle = inode->i_db;
	struct block_device *bdev = inode->i_sb->s_bdev;

	inode_free(inode);
	db_close(db_handle);
	bdev_free(bdev);
	fs_bh_showstat();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x2830
movq -0x10(%rbp), %rdi
callq 0x6080
movq -0x18(%rbp), %rdi
callq 0x2f00
callq 0x2b40
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/extrm-ranged.c
// Function: inode_alloc
static struct inode *inode_alloc(struct super_block *sb)
{
	struct inode *inode;
	inode = xzalloc(sizeof(struct inode));
	inode->i_sb = sb;
	inode->i_generation = 0;
	inode->i_data_dirty = 0;
	return inode;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x1, %edi
movl $0x80, %esi
callq 0x2140
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x10(%rbp), %rax
movb 0x74(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x74(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ngkaho1234[P]ext4-extents-tree/extrm-ranged.c
// Function: inode_writeback
static int inode_writeback(struct inode *inode)
{
	int ret = 0;
	if (inode->i_data_dirty) {
		if (inode->i_writeback)
			ret = inode->i_writeback(inode);
		if (!ret)
			inode->i_data_dirty = 0;

	}
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rax
movb 0x74(%rax), %al
shlb $0x7, %al
sarb $0x7, %al
movsbl %al, %eax
cmpl $0x0, %eax
je 0x28dc
movq -0x8(%rbp), %rax
cmpq $0x0, 0x78(%rax)
je 0x28c4
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rax
movq -0x8(%rbp), %rdi
callq *%rax
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
jne 0x28da
movq -0x8(%rbp), %rax
movb 0x74(%rax), %cl
andb $-0x2, %cl
orb $0x0, %cl
movb %cl, 0x74(%rax)
jmp 0x28dc
movl -0xc(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_gl.c
// Function: app_compile_shader
GLuint app_compile_shader(app_t *self, GLenum type, const char *source) {
	GLuint shader = glCreateShader(type);
	glShaderSource(shader, 1, &source, NULL);
	glCompileShader(shader);
	
	GLint success;
	glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
	if (!success) {
		int log_written;
		char log[256];
		glGetShaderInfoLog(shader, 256, &log_written, log);
		SDL_Log("Error compiling shader: %s.\n", log);
	}
	return shader;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x594b(%rip), %rax      # 0x11fa8
movq (%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movl %eax, -0x1c(%rbp)
movq 0x5929(%rip), %rax      # 0x11f98
movq (%rax), %rax
movl -0x1c(%rbp), %edi
movl $0x1, %esi
leaq -0x18(%rbp), %rdx
xorl %ecx, %ecx
callq *%rax
movq 0x58ff(%rip), %rax      # 0x11f88
movq (%rax), %rax
movl -0x1c(%rbp), %edi
callq *%rax
movq 0x58d8(%rip), %rax      # 0x11f70
movq (%rax), %rax
movl -0x1c(%rbp), %edi
movl $0x8b81, %esi           # imm = 0x8B81
leaq -0x20(%rbp), %rdx
callq *%rax
cmpl $0x0, -0x20(%rbp)
jne 0xc6e3
movq 0x58fa(%rip), %rax      # 0x11fb0
movq (%rax), %rax
movl -0x1c(%rbp), %edi
leaq -0x130(%rbp), %rcx
movl $0x100, %esi            # imm = 0x100
leaq -0x24(%rbp), %rdx
callq *%rax
leaq -0x130(%rbp), %rsi
leaq 0x2282(%rip), %rdi      # 0xe95e
movb $0x0, %al
callq 0x21f0
movl -0x1c(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_gl.c
// Function: app_create_texture
GLuint app_create_texture(app_t *self, GLuint index, const char *name) {
	GLuint texture;
	glCreateTextures(GL_TEXTURE_2D, 1, &texture);
	
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	
	glUniform1i(glGetUniformLocation(self->shader_program, name), index);
	return texture;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0xde1, %edi            # imm = 0xDE1
movl $0x1, %esi
leaq -0x1c(%rbp), %rdx
movq 0x5868(%rip), %rax      # 0x11f80
callq *(%rax)
movl -0x1c(%rbp), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq 0x21d0
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2800, %esi           # imm = 0x2800
movl $0x2601, %edx           # imm = 0x2601
callq 0x2210
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2801, %esi           # imm = 0x2801
movl $0x2601, %edx           # imm = 0x2601
callq 0x2210
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2802, %esi           # imm = 0x2802
movl $0x812f, %edx           # imm = 0x812F
callq 0x2210
movl $0xde1, %edi            # imm = 0xDE1
movl $0x2803, %esi           # imm = 0x2803
movl $0x812f, %edx           # imm = 0x812F
callq 0x2210
movq 0x5842(%rip), %rax      # 0x11fc0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq 0x57d4(%rip), %rax      # 0x11f60
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x30(%rcx), %edi
movq -0x18(%rbp), %rsi
callq *%rax
movl %eax, %edi
movq -0x28(%rbp), %rax
movl -0xc(%rbp), %esi
callq *%rax
movl -0x1c(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_gl.c
// Function: app_destroy
void app_destroy(app_t *self) {
	plm_destroy(self->plm);
	
	if (self->texture_mode == APP_TEXTURE_MODE_RGB) {
		free(self->rgb_data);
	}

	if (self->audio_device) {
		SDL_CloseAudioDevice(self->audio_device);
	}
	
	SDL_GL_DeleteContext(self->gl);
	SDL_Quit();
	
	free(self);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2d60
movq -0x8(%rbp), %rax
cmpl $0x2, 0x3c(%rax)
jne 0xc7df
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x21a0
movq -0x8(%rbp), %rax
cmpl $0x0, 0x20(%rax)
je 0xc7f5
movq -0x8(%rbp), %rax
movl 0x20(%rax), %edi
callq 0x20d0
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2060
callq 0x2050
movq -0x8(%rbp), %rdi
callq 0x21a0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_gl.c
// Function: app_update_texture
void app_update_texture(app_t *self, GLuint unit, GLuint texture, plm_plane_t *plane) {
	glActiveTexture(unit);
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexImage2D(
		GL_TEXTURE_2D, 0, GL_LUMINANCE, plane->width, plane->height, 0,
		GL_LUMINANCE, GL_UNSIGNED_BYTE, plane->data
	);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq %rcx, -0x18(%rbp)
movq 0x556b(%rip), %rax      # 0x11fc8
movq (%rax), %rax
movl -0xc(%rbp), %edi
callq *%rax
movl -0x10(%rbp), %esi
movl $0xde1, %edi            # imm = 0xDE1
callq 0x21d0
movq -0x18(%rbp), %rax
movl (%rax), %ecx
movq -0x18(%rbp), %rax
movl 0x4(%rax), %r8d
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl $0xde1, %edi            # imm = 0xDE1
xorl %r9d, %r9d
movl $0x1909, %edx           # imm = 0x1909
movl %r9d, %esi
movl $0x1909, (%rsp)         # imm = 0x1909
movl $0x1401, 0x8(%rsp)      # imm = 0x1401
movq %rax, 0x10(%rsp)
callq 0x20b0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/phoboslab[P]pl_mpeg/pl_mpeg_player_gl.c
// Function: main
int main(int argc, char *argv[]) {
	if (argc < 2) {
		SDL_Log("Usage: pl_mpeg_player_gl <file.mpg>");
		exit(1);
	}
	
	app_t *app = app_create(argv[1], APP_TEXTURE_MODE_YCRCB);
	while (!app->wants_to_quit) {
		app_update(app);
	}
	app_destroy(app);
	
	return EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0xcaf4
leaq 0x1e98(%rip), %rdi      # 0xe97b
movb $0x0, %al
callq 0x21f0
movl $0x1, %edi
callq 0x21b0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x1, %esi
callq 0xc050
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0x10(%rax)
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0xcb1d
jmp 0xcb28
movq -0x18(%rbp), %rdi
callq 0xc820
jmp 0xcb0a
movq -0x18(%rbp), %rdi
callq 0xc7b0
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: Key_Ext64
u64 Key_Ext64(u64 *S)
{
u64 Z;
u64 t1 = (S[0] << (66 - 64) | S[1] >> (128 - 66)) ^ (S[1] << (132 - 128) | S[2] >> (192 - 132));
u64 t2 = (S[3] << (69 - 64) | S[4] >> (128 - 69)) ^ (S[3] << (105 - 64) | S[4] >> (128 - 105));
u64 t3 = (S[5] << (66 - 64) | S[6] >> (128 - 66)) ^ (S[6] << (147 - 128) | S[7] >> (192 - 147));
Z = t1 ^ t2 ^ t3 ^ ((S[0] << 38 | S[1] >> 26) & (S[3] << 2 | S[4] >> 62)); // Key Block generated

return Z;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
shlq $0x2, %rax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
shrq $0x3e, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movq 0x8(%rcx), %rcx
shlq $0x4, %rcx
movq -0x8(%rsp), %rdx
movq 0x10(%rdx), %rdx
shrq $0x3c, %rdx
orq %rdx, %rcx
xorq %rcx, %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rax
shlq $0x5, %rax
movq -0x8(%rsp), %rcx
movq 0x20(%rcx), %rcx
shrq $0x3b, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
shlq $0x29, %rcx
movq -0x8(%rsp), %rdx
movq 0x20(%rdx), %rdx
shrq $0x17, %rdx
orq %rdx, %rcx
xorq %rcx, %rax
movq %rax, -0x20(%rsp)
movq -0x8(%rsp), %rax
movq 0x28(%rax), %rax
shlq $0x2, %rax
movq -0x8(%rsp), %rcx
movq 0x30(%rcx), %rcx
shrq $0x3e, %rcx
orq %rcx, %rax
movq -0x8(%rsp), %rcx
movq 0x30(%rcx), %rcx
shlq $0x13, %rcx
movq -0x8(%rsp), %rdx
movq 0x38(%rdx), %rdx
shrq $0x2d, %rdx
orq %rdx, %rcx
xorq %rcx, %rax
movq %rax, -0x28(%rsp)
movq -0x18(%rsp), %rax
xorq -0x20(%rsp), %rax
xorq -0x28(%rsp), %rax
movq -0x8(%rsp), %rcx
movq (%rcx), %rcx
shlq $0x26, %rcx
movq -0x8(%rsp), %rdx
movq 0x8(%rdx), %rdx
shrq $0x1a, %rdx
orq %rdx, %rcx
movq -0x8(%rsp), %rdx
movq 0x18(%rdx), %rdx
shlq $0x2, %rdx
movq -0x8(%rsp), %rsi
movq 0x20(%rsi), %rsi
shrq $0x3e, %rsi
orq %rsi, %rdx
andq %rdx, %rcx
xorq %rcx, %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: Mult_by_alpha_power
u32 Mult_by_alpha_power(u32 a, int m)
{
   int i; u32 result;
   for(i=0; i<m; i++)
   {
	result = a<<1; 
	if(((a>>31)&1)==1) result = result^(CONST_alpha_32);
	a = result;
   }
   return result;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movl $0x0, -0xc(%rsp)
movl -0xc(%rsp), %eax
cmpl -0x8(%rsp), %eax
jge 0x1865
movl -0x4(%rsp), %eax
shll %eax
movl %eax, -0x10(%rsp)
movl -0x4(%rsp), %eax
shrl $0x1f, %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x1850
movl -0x10(%rsp), %eax
xorl $0x400007, %eax         # imm = 0x400007
movl %eax, -0x10(%rsp)
movl -0x10(%rsp), %eax
movl %eax, -0x4(%rsp)
movl -0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rsp)
jmp 0x1820
movl -0x10(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: V_Horner_32
void V_Horner_32(u32 Input, u32* Tag)//, u8 FULL)
{
	Tag[0] = Tag[0]^Input;
      	Tag[1] = Mult_by_alpha_power(Tag[1],1)^Input;
      	Tag[2] = Mult_by_alpha_power(Tag[2],2)^Input;
      	Tag[3] = Mult_by_alpha_power(Tag[3],3)^Input;
	//if(FULL==1) Tag[4]=Mult_by_alpha_power(Tag[4],4)^Input;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl (%rax), %ecx
xorl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %edi
movl $0x1, %esi
callq 0x1060
movl %eax, %ecx
xorl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edi
movl $0x2, %esi
callq 0x1060
movl %eax, %ecx
xorl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0xc(%rax), %edi
movl $0x3, %esi
callq 0x1060
movl %eax, %ecx
xorl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: Mult_by_beta_power
u64 Mult_by_beta_power(u64 b, int m)
{
   int i; u64 result;
   for(i=0; i<m; i++)
   {
	result = b<<1; 
	if(((b>>63)&1)==1) result = result^(CONST_beta_64);
	b = result;
   }
   return result;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl $0x0, -0x10(%rsp)
movl -0x10(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x1960
movq -0x8(%rsp), %rax
shlq %rax
movq %rax, -0x18(%rsp)
movq -0x8(%rsp), %rax
shrq $0x3f, %rax
andq $0x1, %rax
cmpq $0x1, %rax
jne 0x1949
movq -0x18(%rsp), %rax
xorq $0x1b, %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
movq %rax, -0x8(%rsp)
movl -0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rsp)
jmp 0x1911
movq -0x18(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: Reverse_32
u32 Reverse_32(u32 a)
{
  u32 i, b=0;

  for(i=0;i<31;i++){
  	b^=(a&1); a=a>>1; b=b<<1;}
  b^=(a&1);
  return b;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl $0x0, -0xc(%rsp)
movl $0x0, -0x8(%rsp)
cmpl $0x1f, -0x8(%rsp)
jae 0x1a2b
movl -0x4(%rsp), %eax
andl $0x1, %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0x4(%rsp), %eax
shrl %eax
movl %eax, -0x4(%rsp)
movl -0xc(%rsp), %eax
shll %eax
movl %eax, -0xc(%rsp)
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x19f4
movl -0x4(%rsp), %eax
andl $0x1, %eax
xorl -0xc(%rsp), %eax
movl %eax, -0xc(%rsp)
movl -0xc(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: Field_Mult_32
u32 Field_Mult_32(u32 a, u32 b)
{
   u32 result=0, i;  

   b=Reverse_32(b); 

   if((b&1)==1) result=a;

   for(i=1;i<32;i++)
   {   
	b=b>>1;
	result=Mult_by_alpha_power(result,1); 
	if((b&1)==1) result=result^a;
   }
   return result;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0x10(%rsp), %edi
callq 0x1040
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x1a75
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl $0x1, 0x8(%rsp)
cmpl $0x20, 0x8(%rsp)
jae 0x1ac7
movl 0x10(%rsp), %eax
shrl %eax
movl %eax, 0x10(%rsp)
movl 0xc(%rsp), %edi
movl $0x1, %esi
callq 0x1060
movl %eax, 0xc(%rsp)
movl 0x10(%rsp), %eax
andl $0x1, %eax
cmpl $0x1, %eax
jne 0x1ab8
movl 0xc(%rsp), %eax
xorl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x1aba
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x1a7d
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/mjosaarinen[P]brutus/crypto_aead/trivia128v2/ref/encrypt.c
// Function: process_block
void process_block(u64 Block, u32 *Tag, u64 *Checksum, u64 *SC_State, u64 *Z, u8 IsChecksum)//, u8 IsAD)
{
   u32 State_Key[2], word[2], PDP;
 
   word[0]= (u32)(((Block>>32) & (0x00000000FFFF0000)) ^ ((Block>>16)&(0x000000000000FFFF))); 
   word[1]= (u32)(((Block>>16)&(0x00000000FFFF0000))^ (Block &(0x000000000000FFFF))); // Parse Blocks into words


   State_Key[0]= (u32)(((SC_State[0]>>32) & (0x00000000FFFF0000)) ^ ((SC_State[0]>>16)&(0x000000000000FFFF))); 
   State_Key[1]= (u32)(((SC_State[0]>>16)&(0x00000000FFFF0000))^ (SC_State[0] &(0x000000000000FFFF)));
   //State_Key[0]= (u32)((SC_State[0]>>32)&(0xFFFFFFFF)); 
   //State_Key[1]= (u32)(SC_State[0]&(0xFFFFFFFF));                    // Obtain State-key Words
   
   SC_Update64(SC_State, Z);                                               // State Bits Updated
   
   PDP = Field_Mult_32(word[0]^State_Key[0], word[1]^State_Key[1]); // Pseudo-dot-Product
   
   V_Horner_32(PDP, Tag);                                      // Update Tag always.

   if(!IsChecksum) {V_Horner_64(Block, Checksum);}       // update checksum if not checksum block.
}

// Assembly:
subq $0x48, %rsp
movb %r9b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x40(%rsp), %rax
shrq $0x20, %rax
movabsq $0xffff0000, %rcx       # imm = 0xFFFF0000
andq %rcx, %rax
movq 0x40(%rsp), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
xorq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x40(%rsp), %rax
shrq $0x10, %rax
movabsq $0xffff0000, %rcx       # imm = 0xFFFF0000
andq %rcx, %rax
movq 0x40(%rsp), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
xorq %rcx, %rax
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
shrq $0x20, %rax
movabsq $0xffff0000, %rcx       # imm = 0xFFFF0000
andq %rcx, %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
shrq $0x10, %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
xorq %rcx, %rax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
shrq $0x10, %rax
movabsq $0xffff0000, %rcx       # imm = 0xFFFF0000
andq %rcx, %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
andq $0xffff, %rcx           # imm = 0xFFFF
xorq %rcx, %rax
movl %eax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1090
movl 0xc(%rsp), %edi
xorl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
xorl 0x18(%rsp), %esi
callq 0x1130
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %edi
movq 0x38(%rsp), %rsi
callq 0x1140
cmpb $0x0, 0x1f(%rsp)
jne 0x1c88
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x10f0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: lookup_pid
struct proc_table_entry *lookup_pid(unsigned int pid,int insert){
  int bucket = pid % NUM_PROC_TABLE_BUCKETS;
  struct proc_table_entry *pentry;

  for (pentry=proc_table[bucket];pentry;pentry=pentry->next){
    if (pentry->pid == pid) return pentry;
  }
  // not found
  if (!insert) return NULL;

  pentry = calloc(1,sizeof(struct proc_table_entry));
  pentry->pid = pid;
  pentry->pinfo = calloc(1,sizeof(struct process_info));
  pentry->pinfo->pid = pid;
  if (proc_table[bucket]){
    pentry->next = proc_table[bucket];
    pentry->next->prev = pentry;
  }
  proc_table[bucket] = pentry;
  num_processes++;
  total_processes++;
  if (num_processes > max_num_processes)
    max_num_processes = num_processes;
  return pentry;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movl %esi, -0x10(%rbp)
movl -0xc(%rbp), %eax
movl $0x65, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x3e78(%rip), %rax      # 0x5130
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x12ef
movq -0x20(%rbp), %rax
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x12df
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13d1
jmp 0x12e1
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x12c0
cmpl $0x0, -0x10(%rbp)
jne 0x1302
movq $0x0, -0x8(%rbp)
jmp 0x13d1
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl $0x1, %edi
movl $0x68, %esi
callq 0x10b0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %ecx, (%rax)
movslq -0x14(%rbp), %rcx
leaq 0x3de0(%rip), %rax      # 0x5130
cmpq $0x0, (%rax,%rcx,8)
je 0x137e
movslq -0x14(%rbp), %rcx
leaq 0x3dce(%rip), %rax      # 0x5130
movq (%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rdx
movslq -0x14(%rbp), %rcx
leaq 0x3da3(%rip), %rax      # 0x5130
movq %rdx, (%rax,%rcx,8)
movl 0x3d89(%rip), %eax      # 0x5120
addl $0x1, %eax
movl %eax, 0x3d80(%rip)      # 0x5120
movl 0x3d7e(%rip), %eax      # 0x5124
addl $0x1, %eax
movl %eax, 0x3d75(%rip)      # 0x5124
movl 0x3d6b(%rip), %eax      # 0x5120
cmpl 0x3d6d(%rip), %eax      # 0x5128
jle 0x13c9
movl 0x3d5d(%rip), %eax      # 0x5120
movl %eax, 0x3d5f(%rip)      # 0x5128
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mvermeulen[P]wspy/proctree.c
// Function: remove_pid
int remove_pid(unsigned int pid){
  int bucket = pid % NUM_PROC_TABLE_BUCKETS;
  int found = 0;
  
  struct proc_table_entry *pentry;
  for (pentry=proc_table[bucket];pentry;pentry=pentry->next){
    if (pentry->pid == pid){
      found = 1;
      break;
    }
  }
  if (!found) return 1;

  if (pentry->next){
    pentry->next->prev = pentry->prev;
  }
  if (pentry->prev){
    pentry->prev->next = pentry->next;
  } else {
    proc_table[bucket] = pentry->next;
  }
  num_processes--;
  free(pentry);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl $0x65, %ecx
xorl %edx, %edx
divl %ecx
movl %edx, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x3d24(%rip), %rax      # 0x5130
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x143f
movq -0x18(%rbp), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0x142f
movl $0x1, -0x10(%rbp)
jmp 0x143f
jmp 0x1431
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1414
cmpl $0x0, -0x10(%rbp)
jne 0x144e
movl $0x1, -0x4(%rbp)
jmp 0x14c4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x146d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x148e
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x14a5
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdx
movslq -0xc(%rbp), %rcx
leaq 0x3c8f(%rip), %rax      # 0x5130
movq %rdx, (%rax,%rcx,8)
movl 0x3c75(%rip), %eax      # 0x5120
addl $-0x1, %eax
movl %eax, 0x3c6c(%rip)      # 0x5120
movq -0x18(%rbp), %rdi
callq 0x1030
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)