LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Rep::stat(Cenv*)
Stat Rep::stat(Cenv *env)
{
	Stat st = rex->stat(env);
	if(st.n == 1 && st.c+st.b == 0)
		st.s++;
	st.c++;
	st.n *= lo;
	if(st.n<0 || st.c<=0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rsp)
movl %edx, 0x10(%rsp)
movq %rdx, %rcx
shrq $0x20, %rcx
movw %cx, 0x14(%rsp)
movq %rax, %rcx
shrq $0x28, %rcx
cmpl $0x1, %eax
jne 0x97e3
movq %rax, %rsi
shrq $0x30, %rsi
orb %cl, %sil
jne 0x97e3
movq %rax, %rsi
shrq $0x20, %rsi
incb %sil
movb %sil, 0xc(%rsp)
incb %cl
setne %sil
movb %cl, 0xd(%rsp)
movl 0x18(%r14), %ecx
imull %eax, %ecx
movl %ecx, 0x8(%rsp)
testl %ecx, %ecx
setns %al
testb %sil, %al
jne 0x980d
shrq $0x28, %rdx
orb $0x1, %dl
movb %dl, 0x15(%rsp)
movq 0x10(%r14), %rsi
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
callq 0x93f8
movabsq $0xffffffffffff, %rcx   # imm = 0xFFFFFFFFFFFF
andq %rcx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: hard(Stat*)
int hard(Stat *stat)
{
	if(stat->a | stat->b)
		return HARD;
	else if(stat->t <=1 && stat->c == 0)
		return EASY;
	else if(stat->t)
		return HARD;
	else if(stat->c<=1 || stat->s==stat->c)
		return EASY;
	else
		return HARD;
}

// Assembly:
movzbl 0x6(%rdi), %ecx
movl $0x800, %eax            # imm = 0x800
orl 0x8(%rdi), %ecx
je 0x98dc
retq
movb 0x7(%rdi), %dl
cmpb $0x1, %dl
ja 0x98db
movb 0x5(%rdi), %cl
testb %cl, %cl
je 0x9905
testb %dl, %dl
jne 0x98db
movl $0x0, %eax
cmpb $0x1, %cl
je 0x98db
xorl %eax, %eax
cmpb %cl, 0x4(%rdi)
setne %al
shll $0xb, %eax
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Conj::serialize(int)
int Conj::serialize(int n)
{
	serial = n++;
	n = left->serialize(n);
	n = right->serialize(n);
	return next? next->serialize(n): n;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leal 0x1(%rsi), %eax
movw %si, 0xa(%rdi)
movq 0x18(%rdi), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x18(%rcx)
movq 0x20(%rbx), %rdi
movq (%rdi), %rcx
movl %eax, %esi
callq *0x18(%rcx)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x99ca
movq (%rdi), %rcx
movq 0x18(%rcx), %rcx
movl %eax, %esi
popq %rbx
jmpq *%rcx
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regAlt(int, Cenv*)
static Rex *
regAlt(int n1, Cenv *env) // n1= no. of 1st subexpr in alt
{
	if(cdebug)
		printf("regAlt %lx.%d parno=%d\n",
			(unsigned long)env->cursor.p, env->cursor.n, env->parno);
	Rex *e = regConj(env);
	if(e == ERROR)
		return e;
	else if(token(env) != T_BAR)
		return e;
	eat(env);
	Rex *f = regAlt(n1, env);
	if(f == ERROR) {
		delete e;
		return f;
	}
	Rex *g = regTrie(e, f, env);
	if(g != ERROR)
		return g;
	if(e->type==OK || f->type==OK)
		goto bad;
	g = NEW(Alt(n1, env->parno, e, f));
	if(g != ERROR)
		return g;
bad:
	delete e;
	delete f;
	return ERROR;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %ebp
movq %rsi, %rdi
callq 0x9efc
testq %rax, %rax
je 0x9d19
movq %rax, %rbx
movq %r14, %rdi
callq 0x9f98
cmpl $0x10e, %eax            # imm = 0x10E
jne 0x9d08
movq %r14, %rdi
callq 0xafb1
movl %ebp, %edi
movq %r14, %rsi
callq 0x9c54
testq %rax, %rax
je 0x9d0d
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x9e06
testq %rax, %rax
jne 0x9d1b
cmpb $0x0, 0x8(%rbx)
je 0x9cfd
cmpb $0x0, 0x8(%r15)
je 0x9cfd
pushq $0x38
popq %rdi
callq 0x5170
movl 0x30(%r14), %ecx
movb $0xa, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x7ed3(%rip), %rdx      # 0x11bb0
movq %rdx, (%rax)
movl %ebp, 0x18(%rax)
movl %ecx, 0x1c(%rax)
movq %rbx, 0x20(%rax)
movq %r15, 0x28(%rax)
testb $0x4, 0x1(%r14)
je 0x9d1b
movq %rax, %rdi
callq 0xaed8
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x9d10
movq %rbx, %rax
jmp 0x9d1b
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regcomb
int
regcomb(regex_t *preg0, regex_t *preg1)
{
	if(cdebug)
		printf("regcomb\n");
	Rex *rex0 = preg0->rex;
	Rex *rex1 = preg1->rex;
	Cenv env(preg0->flags);
	if(rex0==ERROR || rex0->next ||
	   rex1==ERROR || rex1->next)
		return 0;
	Rex *g = regTrie(rex1, rex0, &env);
	if(g == 0)
		return 0;
	preg0->rex = g;
	if((preg0->flags&REG_ANCH) == 0)
		preg0->flags &= ~ONCE;
	preg1->rex = ERROR;
	return 1;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x8(%rbx), %rdi
movl 0x10(%r14), %eax
movl %eax, (%rsp)
xorl %ebp, %ebp
testq %rsi, %rsi
je 0x9dfb
cmpq $0x0, 0x10(%rsi)
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0x9dfb
cmpq $0x0, 0x10(%rdi)
jne 0x9dfb
movq %rsp, %rdx
callq 0x9e06
testq %rax, %rax
je 0x9dfb
movq %rax, 0x8(%r14)
movl 0x10(%r14), %eax
testb %al, %al
js 0x9df3
andl $0xffffef7f, %eax       # imm = 0xFFFFEF7F
movl %eax, 0x10(%r14)
andq $0x0, 0x8(%rbx)
pushq $0x1
popq %rbp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regTrie(Rex*, Rex*, Cenv*)
static Rex *
regTrie(Rex *e, Rex *f, Cenv *env)
{
	Trie *g = (Trie*)f;
	if(e->next || f->next || !isstring(e))
		return ERROR;
	if(isstring(f)) {
		g = (Trie*)NEW(Trie());		// env is used here
		if(g == ERROR)
			return ERROR;
		if(insert(f, g))
			goto nospace;
	} else if(f->type != TRIE)
		return ERROR;
	if(insert(e, g))
		goto nospace;
	delete e;
	if(f != g)
		delete f;
	return g;
nospace:
	if(g != f)
		delete g;
	return ERROR;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
cmpq $0x0, 0x10(%rdi)
jne 0x9e1f
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
je 0x9e30
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rdi, %r15
callq 0xad3f
testl %eax, %eax
je 0x9e1f
movq %r14, %rdi
callq 0xad3f
testl %eax, %eax
je 0x9e9b
movl $0x820, %edi            # imm = 0x820
callq 0x5170
movq %rax, %rbx
movb $0x6, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x7c58(%rip), %rax      # 0x11ac0
movq %rax, (%rbx)
movl $0x7fffffff, 0x18(%rbx) # imm = 0x7FFFFFFF
leaq 0x1c(%rbx), %rdi
movl $0x804, %edx            # imm = 0x804
xorl %esi, %esi
callq 0x5100
testb $0x4, 0x1(%r12)
jne 0x9ecf
movq %r14, %rdi
movq %rbx, %rsi
callq 0xad6a
testl %eax, %eax
jne 0x9eb8
jmp 0x9ea9
cmpb $0x6, 0x8(%r14)
movq %r14, %rbx
jne 0x9e1f
movq %r15, %rdi
movq %rbx, %rsi
callq 0xad6a
testl %eax, %eax
je 0x9edc
cmpq %r14, %rbx
je 0x9e1f
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0x9e1f
movq %rbx, %rdi
callq 0xae38
jmp 0x9e1f
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
cmpq %r14, %rbx
je 0x9e21
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0x9e21
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regConj(Cenv*)
static Rex*
regConj(Cenv *env)
{
	if(cdebug)
		printf("regConj %lx.%d parno=%d\n",
			(unsigned long)env->cursor.p, env->cursor.n, env->parno);
	Rex *e = regSeq(env);
	if(env->retype != ARE)
		return e;
	if(e == ERROR)
		return e;
	if(token(env) != T_AND)
		return e;
	eat(env);
	Rex *f = regConj(env);
	if(f == ERROR) {
		delete e;
		return f;
	}
	Rex *g = NEW(Conj(e, f));
	if(g == ERROR){
		delete e;
		delete f;
	}
	return g;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
callq 0xa095
movq %rax, %rbx
cmpb $0x2, 0x3a(%r14)
jne 0x9f8f
testq %rbx, %rbx
je 0x9f8d
movq %r14, %rdi
callq 0x9f98
cmpl $0x10f, %eax            # imm = 0x10F
jne 0x9f8f
movq %r14, %rdi
callq 0xafb1
movq %r14, %rdi
callq 0x9efc
testq %rax, %rax
je 0x9f6e
movq %rax, %r15
pushq $0x28
popq %rdi
callq 0x5170
movb $0xb, 0x8(%rax)
andq $0x0, 0x10(%rax)
leaq 0x7ca9(%rip), %rcx      # 0x11c00
movq %rcx, (%rax)
movq %rbx, 0x18(%rax)
movq %r15, 0x20(%rax)
testb $0x4, 0x1(%r14)
jne 0x9f73
movq %rax, %rbx
jmp 0x9f8f
movq %rbx, %r15
jmp 0x9f84
movq %rax, %rdi
callq 0xaf24
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: token(Cenv*)
static int
token(Cenv *env)
{
	long n = env->cursor.n;
	if(n <= 0)
		return T_END;
	int c = *env->cursor.p;
	if(env->flags & REG_LITERAL)
		return c;
	if(env->posixkludge) {
		env->posixkludge = 0;
		if(c ==	'*')
			return c;	// * first in subexr
	}
	if(c == '\\') {
		if(n < 2)
			return T_BAD;
		c = env->cursor.p[1];
		if(c=='(' && env->retype==BRE)
			env->posixkludge = 1;
		else if(c==')' && env->retype==BRE && env->parnest==0)
			return T_BAD;
		if(escindex[c])
			return escape[escindex[c]].val[env->retype].esc;
		else
			return T_BAD;
	}
	if(c=='$' && n==1)
		return T_DOLL;
	else if(c=='^' && env->retype==BRE && env->cursor.p==env->expr.p) {
		env->posixkludge = 1;
		return T_CFLX;
	} else if(c==')' && env->retype!=BRE && env->parnest==0)
		return c;
	return escindex[c]? escape[escindex[c]].val[env->retype].unesc: c;
}

// Assembly:
movl 0x10(%rdi), %esi
testl %esi, %esi
jle 0x9feb
movq 0x8(%rdi), %rdx
movzbl (%rdx), %ecx
testb $0x1, 0x1(%rdi)
jne 0x9fe8
cmpl $0x0, 0x48(%rdi)
je 0x9fbc
andl $0x0, 0x48(%rdi)
cmpq $0x2a, %rcx
je 0x9fe8
cmpl $0x5c, %ecx
jne 0x9ff1
movl $0x104, %eax            # imm = 0x104
cmpl $0x1, %esi
je 0x9ff0
movzbl 0x1(%rdx), %ecx
cmpl $0x29, %ecx
je 0xa023
cmpl $0x28, %ecx
jne 0xa02f
cmpb $0x0, 0x3a(%rdi)
jne 0xa02f
movl $0x1, 0x48(%rdi)
jmp 0xa02f
movl %ecx, %eax
retq
movl $0x103, %eax            # imm = 0x103
retq
cmpl $0x1, %esi
jne 0xa000
movl $0x105, %eax            # imm = 0x105
cmpb $0x24, %cl
je 0x9ff0
cmpl $0x29, %ecx
je 0xa057
cmpl $0x5e, %ecx
jne 0xa063
cmpb $0x0, 0x3a(%rdi)
jne 0xa063
cmpq 0x18(%rdi), %rdx
jne 0xa063
movl $0x1, 0x48(%rdi)
movl $0x101, %eax            # imm = 0x101
retq
cmpb $0x0, 0x3a(%rdi)
jne 0xa02f
cmpl $0x0, 0x34(%rdi)
je 0x9ff0
leaq 0x8aca(%rip), %rdx      # 0x12b00
movzbl (%rcx,%rdx), %ecx
testq %rcx, %rcx
je 0x9ff0
movzbl 0x3a(%rdi), %eax
imulq $0xe, %rcx, %rcx
leaq 0x2532(%rip), %rdx      # 0xc580
addq %rcx, %rdx
movswl 0x4(%rdx,%rax,4), %eax
retq
cmpb $0x0, 0x3a(%rdi)
je 0xa063
cmpl $0x0, 0x34(%rdi)
je 0xa091
leaq 0x8a96(%rip), %rax      # 0x12b00
movzbl (%rcx,%rax), %edx
movl %ecx, %eax
testq %rdx, %rdx
je 0x9ff0
movzbl 0x3a(%rdi), %eax
imulq $0xe, %rdx, %rcx
leaq 0x24f8(%rip), %rdx      # 0xc580
addq %rcx, %rdx
movswl 0x2(%rdx,%rax,4), %eax
retq
pushq $0x29
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: mkSeq(Rex*, Rex*)
static Rex *
mkSeq(Rex *e, Rex *f)
{
	Rex *g;
	if(f == ERROR) {
		delete e;
		return f;
	} else if(e->type == OK) {
		delete e;
		return f;
	} else if(f->type == OK) {
		g = (Rex*)f->next;
		f->next = 0;
		delete f;
		f = g;
	} else if(e->type==DOT && f->type==DOT) {
		unsigned m = ((Dot*)e)->lo + ((Dot*)f)->lo;
		unsigned n = ((Dot*)e)->hi + ((Dot*)f)->hi;
		if(m <= RE_DUP_MAX) {
			if(((Dot*)e)->hi > RE_DUP_MAX ||
			   ((Dot*)f)->hi > RE_DUP_MAX) {
				n = RE_DUP_INF;	
				goto n_ok;
			} else if(n <= RE_DUP_MAX) { // unless ovfl,
			n_ok:	((Dot*)e)->lo = m;   // combine
				((Dot*)e)->hi = n;
				g = (Rex*)f->next;
				f->next = 0;
				delete f;
				f = g;
			}
		}
	}
	e->next = f;
	return e;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0xabbf
movq %rsi, %r14
movb 0x8(%rbx), %al
testb %al, %al
je 0xabd1
movb 0x8(%r14), %cl
testb %cl, %cl
je 0xaba4
xorb $0x3, %al
xorb $0x3, %cl
orb %al, %cl
jne 0xabb9
movl 0x18(%r14), %eax
addl 0x18(%rbx), %eax
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
ja 0xabb9
movl 0x1c(%r14), %ecx
movl 0x1c(%rbx), %esi
movl $0x40000000, %edx       # imm = 0x40000000
cmpl %edx, %esi
setge %dil
cmpl %edx, %ecx
setge %r8b
orb %dil, %r8b
jne 0xab9e
addl %esi, %ecx
movl %ecx, %edx
cmpl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
ja 0xabb9
movl %eax, 0x18(%rbx)
movl %edx, 0x1c(%rbx)
movq (%r14), %rax
movq 0x10(%r14), %r15
andq $0x0, 0x10(%r14)
movq %r14, %rdi
callq *0x8(%rax)
movq %r15, %r14
movq %r14, 0x10(%rbx)
jmp 0xabdd
testq %rbx, %rbx
je 0xabcd
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0xabdd
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq %r14, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: findcollelem(int, Cenv*)
static int
findcollelem(int c, Cenv *env)
{
	int i, l;
	const uchar *p, *ep;

	if(env->cursor.n < 3)
		return -1;
	p = env->cursor.p;
	if(p[1] == c && p[2] == ']') {
		// TODO: testre.dat requires that [.?.] and [.[.] be rejected but it's unclear why.
		// http://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap09.html does not help.
		if(p[0] == '?' || p[0] == '[')
			return -1;
		i = p[0];
		env->cursor.next(3);
		return i;
	}
	ep = env->cursor.p+env->cursor.n; 
	for(p++; ep-p >= 2; p++) {
		if(p[0] == c && p[1] == ']') {
			// Found end of bracket, look up name.
			for(i=0; i<128; i++) {
				l = strlen(collelem[i]);
				if(p - env->cursor.p == l && memcmp(collelem[i], env->cursor.p, l) == 0) {
					env->cursor.next(l+2);
					return i;
				}
			}
			break;
		}
	}
	return -1;
}

// Assembly:
movslq 0x10(%rsi), %rdx
pushq $-0x1
popq %rax
cmpq $0x3, %rdx
jl 0xacee
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x8(%rsi), %r14
movzbl 0x1(%r14), %ecx
cmpl %edi, %ecx
jne 0xac3f
cmpb $0x5d, 0x2(%r14)
jne 0xac3f
movzbl (%r14), %ebx
cmpl $0x3f, %ebx
je 0xace0
cmpl $0x5b, %ebx
je 0xace0
addq $0x3, %r14
movq %r14, 0x8(%rsi)
addl $-0x3, %edx
jmp 0xacdb
leaq -0x1(%rdx), %r8
pushq $0x1
popq %r15
cmpq $0x2, %r8
jl 0xace0
movzbl (%r14,%r15), %ecx
cmpl %edi, %ecx
jne 0xac62
cmpb $0x5d, 0x1(%r14,%r15)
je 0xac6a
incq %r15
decq %r8
jmp 0xac47
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x7655(%rip), %rbp      # 0x122d0
xorl %ebx, %ebx
cmpq $0x80, %rbx
je 0xacb8
movq (%rbp), %r13
movq %r13, %rdi
callq 0x50d0
movq %rax, %r12
movslq %r12d, %rax
cmpq %r15, %rax
jne 0xacaf
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x51a0
testl %eax, %eax
je 0xacbd
incq %rbx
addq $0x8, %rbp
jmp 0xac7d
pushq $-0x1
popq %rax
jmp 0xace0
movslq %r12d, %rax
leaq (%rax,%r14), %rcx
addq $0x2, %rcx
movq 0x10(%rsp), %rsi
movq %rcx, 0x8(%rsi)
movq 0x8(%rsp), %rdx
subl %eax, %edx
addl $-0x2, %edx
movl %edx, 0x10(%rsi)
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: insert(Rex*, Trie*)
static int
insert(Rex *f, Trie *g)
{
	uchar temp[2];
	switch(f->type) {
	case KMP:
	case KR:
	case STRING:
		 return g->insert(((String*)f)->seg.p);
	case ONECHAR:
		temp[0] = ((Onechar*)f)->c;
		temp[1] = 0;
		return g->insert(temp);
	}
	return 1;	// shouldn't happen
}

// Assembly:
movzbl 0x8(%rdi), %eax
leal -0xe(%rax), %ecx
cmpl $0x2, %ecx
jb 0xad80
cmpl $0x4, %eax
je 0xad8f
cmpl $0x5, %eax
jne 0xadae
movq 0x18(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x8070
pushq %rax
movb 0x20(%rdi), %cl
leaq 0x6(%rsp), %rax
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x8070
addq $0x8, %rsp
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/brianbbsu[P]TCP-Ping/src/client.cpp
// Function: domain_to_ip(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string domain_to_ip(std::string s){
    addrinfo hints, *host_info;
    memset(&hints, 0, sizeof(hints));
    hints.ai_family = AF_INET;
    int result = getaddrinfo(s.c_str(), NULL, &hints, &host_info);
    if(result != 0)return "";
    char host_ip[INET_ADDRSTRLEN + 2];
    memset(host_ip, 0, sizeof(host_ip));
    getnameinfo(host_info->ai_addr, host_info->ai_addrlen, host_ip, sizeof(host_ip), NULL, 0, NI_NUMERICHOST);
    return std::string(host_ip);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movl $0x2, 0x4(%rdx)
movq (%rsi), %rdi
leaq 0x18(%rsp), %rcx
xorl %esi, %esi
callq 0x6420
testl %eax, %eax
je 0x6ac4
leaq 0x776a(%rip), %rsi      # 0xe224
leaq 0x20(%rsp), %rdx
movq %rbx, %rdi
jmp 0x6b05
leaq 0x20(%rsp), %r14
andw $0x0, 0x10(%r14)
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x10(%rax), %esi
movl $0x1, (%rsp)
pushq $0x12
popq %rcx
movq %r14, %rdx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x61f0
leaq 0x17(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8046
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/brianbbsu[P]TCP-Ping/src/client.cpp
// Function: print_help(boost::program_options::options_description)
void print_help(po::options_description desc){
    std::cout<<"Usage: ./client [--help] [-n num] [-t timeout] [-w wait] target1 [target2 ...]\n\n";
    std::cout<<"TCP Ping - Client - Made by Po-Hsuan Su (b08902107)\n\n";
    std::cout<<"Positional Argument\n  target - Target(s) in `host:port` form, host can be in hostname or ip\n\n";
    std::cout<<"Optional Arguments\n";
    std::cout<<desc<<std::endl;
    exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xe8be(%rip), %r14      # 0x15fb0
leaq 0x6aa5(%rip), %rsi      # 0xe19e
movq %r14, %rdi
callq 0x6320
leaq 0x6ae7(%rip), %rsi      # 0xe1ef
movq %r14, %rdi
callq 0x6320
leaq 0x6b0e(%rip), %rsi      # 0xe225
movq %r14, %rdi
callq 0x6320
leaq 0x6b5d(%rip), %rsi      # 0xe283
movq %r14, %rdi
callq 0x6320
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6090
movq %rax, %rdi
callq 0x6170
xorl %edi, %edi
callq 0x63d0
// File: /workspace/github_cpp_makefile_star2_O2/brianbbsu[P]TCP-Ping/src/logger.cpp
// Function: logger::log_info(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void logger::log_info(std::string msg, int target_no){
    std::lock_guard<std::mutex> mLock(outputLock);
    std::cout<<"[*]";
    if(target_no != -1)std::cout<<color_code[(target_no - 1) % 5] << "[target " << target_no << "]" << color_reset;
    std::cout<<" ";
    std::cout<<msg<<std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x959f(%rip), %rdi      # 0x16580
callq 0xd1d6
movq 0x8fc3(%rip), %rdi      # 0x15fb0
leaq 0x1c90(%rip), %rsi      # 0xec84
callq 0x6320
cmpl $-0x1, %r14d
je 0xd05e
leal -0x1(%r14), %eax
pushq $0x5
popq %rcx
cltd
idivl %ecx
movslq %edx, %rax
shlq $0x5, %rax
leaq 0x94a9(%rip), %rsi      # 0x164c0
addq %rax, %rsi
movq 0x8f8f(%rip), %rdi      # 0x15fb0
callq 0x62e0
leaq 0x1c5b(%rip), %rsi      # 0xec88
movq %rax, %rdi
callq 0x6320
movq %rax, %rdi
movl %r14d, %esi
callq 0x65c0
leaq 0x1c4c(%rip), %rsi      # 0xec93
movq %rax, %rdi
callq 0x6320
leaq 0x950a(%rip), %rsi      # 0x16560
movq %rax, %rdi
callq 0x62e0
movq 0x8f4b(%rip), %rdi      # 0x15fb0
leaq 0x1260(%rip), %rsi      # 0xe2cc
callq 0x6320
movq 0x8f38(%rip), %rdi      # 0x15fb0
movq %rbx, %rsi
callq 0x62e0
movq %rax, %rdi
callq 0x6170
leaq 0x94f1(%rip), %rdi      # 0x16580
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6270
movq %rax, %rbx
leaq 0x94db(%rip), %rdi      # 0x16580
callq 0x6270
movq %rbx, %rdi
callq 0x65e0
// File: /workspace/github_cpp_makefile_star2_O2/brianbbsu[P]TCP-Ping/src/logger.cpp
// Function: logger::log_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void logger::log_error(std::string msg, int target_no){
    std::lock_guard<std::mutex> mLock(outputLock);
    std::cout<<"[!]";
    if(target_no != -1)std::cout<<color_code[(target_no - 1) % 5] << "[target " << target_no << "]" << color_reset;
    std::cout<<" ";
    std::cout<<msg<<std::endl;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x94bd(%rip), %rdi      # 0x16580
callq 0xd1d6
movq 0x8ee1(%rip), %rdi      # 0x15fb0
leaq 0x1bbb(%rip), %rsi      # 0xec91
callq 0x6320
cmpl $-0x1, %r14d
je 0xd140
leal -0x1(%r14), %eax
pushq $0x5
popq %rcx
cltd
idivl %ecx
movslq %edx, %rax
shlq $0x5, %rax
leaq 0x93c7(%rip), %rsi      # 0x164c0
addq %rax, %rsi
movq 0x8ead(%rip), %rdi      # 0x15fb0
callq 0x62e0
leaq 0x1b79(%rip), %rsi      # 0xec88
movq %rax, %rdi
callq 0x6320
movq %rax, %rdi
movl %r14d, %esi
callq 0x65c0
leaq 0x1b6a(%rip), %rsi      # 0xec93
movq %rax, %rdi
callq 0x6320
leaq 0x9428(%rip), %rsi      # 0x16560
movq %rax, %rdi
callq 0x62e0
movq 0x8e69(%rip), %rdi      # 0x15fb0
leaq 0x117e(%rip), %rsi      # 0xe2cc
callq 0x6320
movq 0x8e56(%rip), %rdi      # 0x15fb0
movq %rbx, %rsi
callq 0x62e0
movq %rax, %rdi
callq 0x6170
leaq 0x940f(%rip), %rdi      # 0x16580
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x6270
movq %rax, %rbx
leaq 0x93f9(%rip), %rdi      # 0x16580
callq 0x6270
movq %rbx, %rdi
callq 0x65e0
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: Undo()
void Undo()
{
	if(lastChanged != NULL)
	{
		*lastChanged = undoValue;
		lastChanged = NULL;
		undoValue = 0.0f;
	}
}

// Assembly:
movq 0xaed1(%rip), %rax      # 0xe620
testq %rax, %rax
je 0x376f
movss 0xaecc(%rip), %xmm0     # 0xe628
movss %xmm0, (%rax)
andq $0x0, 0xaeb8(%rip)      # 0xe620
andl $0x0, 0xaeb9(%rip)      # 0xe628
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: Button(int, int, bool, char const*, int)
bool Button(int x, int y, bool highlight, const char* text, int id)
{
	DWORD color1=0x000000;
	DWORD color2=0xA09088;
	DWORD color3=0x000000;
	bool hover=MouseInBox(x, y, 100, 17);
	if(hover && mouse_leftclick)
		vcurbutton=id;
	bool current=(vcurbutton==id);
	if(highlight)
	{
		color1=0x000000;
		color2=0x988070;
		color3=0xFFF0E0;
	}
	if(current && hover)
	{
		color1=0xA09088;
		color2=0xFFF0E0;
		color3=0xA09088;
	}
	DrawBar(x-1, y-1, 102, 19, color1);
	DrawBar(x, y, 100, 17, color2);
	DrawText(font, x+5, y+5, color3, text);
	if(current && hover && !mouse_left)
		return true;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %r13d
movq %rcx, (%rsp)
movl %edx, %r12d
movl %esi, %r14d
movl %edi, %r15d
pushq $0x64
popq %rdx
pushq $0x11
popq %rcx
callq 0x89a9
movl %eax, %ebp
testb %al, %al
je 0x4c99
leaq 0x9a22(%rip), %rax      # 0xe6af
cmpb $0x1, (%rax)
jne 0x4c99
movl %r13d, 0x861f(%rip)     # 0xd2b8
cmpl %r13d, 0x8618(%rip)     # 0xd2b8
sete %bl
xorl %eax, %eax
testb %r12b, %r12b
movl $0x988070, %r13d        # imm = 0x988070
movl $0xa09088, %r8d         # imm = 0xA09088
cmovel %r8d, %r13d
movl $0xfff0e0, %ecx         # imm = 0xFFF0E0
movl $0x0, %r12d
cmovnel %ecx, %r12d
testb %bl, %bpl
cmovnel %ecx, %r13d
cmovnel %r8d, %r12d
cmovel %eax, %r8d
leal -0x1(%r15), %edi
leal -0x1(%r14), %esi
pushq $0x66
popq %rdx
pushq $0x13
popq %rcx
callq 0x8718
pushq $0x64
popq %rdx
pushq $0x11
popq %rcx
movl %r15d, %edi
movl %r14d, %esi
movl %r13d, %r8d
callq 0x8718
addl $0x5, %r15d
addl $0x5, %r14d
leaq 0x85dc(%rip), %rdi      # 0xd2e8
movl %r15d, %esi
movl %r14d, %edx
movl %r12d, %ecx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x88c6
testb %bl, %bpl
je 0x4d33
leaq 0x9980(%rip), %rcx      # 0xe6ac
movb $0x1, %al
cmpb $0x1, (%rcx)
jne 0x4d35
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: ButtonWH(int, int, int, int, bool, char const*, int)
bool ButtonWH(int x, int y, int w, int h, bool highlight, const char* text, int id)
{
	DWORD color1=0x000000;
	DWORD color2=0xA09088;
	DWORD color3=0x000000;
	bool hover=MouseInBox(x, y, w, h);
	if(hover && mouse_leftclick)
		vcurbutton=id;
	bool current=(vcurbutton==id);
	if(highlight)
	{
		color1=0x000000;
		color2=0x988070;
		color3=0xFFF0E0;
	}
	if(current && hover)
	{
		color1=0xA09088;
		color2=0xFFF0E0;
		color3=0xA09088;
	}
	DrawBar(x-1, y-1, w + 2, h + 2, color1);
	DrawBar(x, y, w, h, color2);
	DrawText(font, x+5, y+5, color3, text);
	if(current && hover && !mouse_left)
		return true;
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, 0x10(%rsp)
movl %r8d, %ebx
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movl %edi, %r15d
movl 0x50(%rsp), %ebp
callq 0x89a9
testb %al, %al
je 0x4d85
leaq 0x9935(%rip), %rcx      # 0xe6af
cmpb $0x1, (%rcx)
jne 0x4d85
movl %ebp, 0x8533(%rip)      # 0xd2b8
cmpl %ebp, 0x852d(%rip)      # 0xd2b8
sete %sil
movb %sil, 0xf(%rsp)
xorl %edx, %edx
testb %bl, %bl
movl $0x988070, %ebp         # imm = 0x988070
movl $0xa09088, %r8d         # imm = 0xA09088
cmovel %r8d, %ebp
movl $0xfff0e0, %ecx         # imm = 0xFFF0E0
movl $0x0, %ebx
cmovnel %ecx, %ebx
testb %sil, %al
cmovnel %ecx, %ebp
cmovnel %r8d, %ebx
cmovel %edx, %r8d
leal -0x1(%r15), %edi
leal -0x1(%r14), %esi
movb %al, 0xe(%rsp)
leal 0x2(%r13), %edx
leal 0x2(%r12), %ecx
callq 0x8718
movl %r15d, %edi
movl %r14d, %esi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x8718
addl $0x5, %r15d
addl $0x5, %r14d
leaq 0x84e9(%rip), %rdi      # 0xd2e8
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movq 0x10(%rsp), %r8
xorl %eax, %eax
callq 0x88c6
movb 0xe(%rsp), %al
testb %al, 0xf(%rsp)
je 0x4e2b
leaq 0x9888(%rip), %rcx      # 0xe6ac
movb $0x1, %al
cmpb $0x1, (%rcx)
jne 0x4e2d
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: ddkCalcFrame()
bool ddkCalcFrame()
{
	input->Update(); // (for keyboard input)

	if(input->KeyPressed(DIK_SPACE) || input->KeyPressed(DIK_RETURN)) // (keyboard input only for convenience, ok to remove)
	{
		if(!keydown)
		{
			PlaySample();
			keydown=true;
		}
	}
	else if(input->KeyPressed(DIK_Z))
	{
		Undo();
		keydown=true;
	}
	else
		keydown=false;

	DrawScreen();

	SDL_Delay(5);
	return true;
}

// Assembly:
pushq %rax
pushq $0x20
popq %rdi
callq 0x70e6
testb %al, %al
jne 0x6cf8
pushq $0xd
popq %rdi
callq 0x70e6
testb %al, %al
je 0x6d08
cmpb $0x0, 0x7949(%rip)      # 0xe648
jne 0x6d21
callq 0x4185
jmp 0x6d19
pushq $0x7a
popq %rdi
callq 0x70e6
testb %al, %al
je 0x6d32
callq 0x3748
movb $0x1, %al
movb %al, 0x7927(%rip)       # 0xe648
callq 0x4e3c
pushq $0x5
popq %rdi
callq 0x31c0
movb $0x1, %al
popq %rcx
retq
xorl %eax, %eax
jmp 0x6d1b
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: SDLAudioCallback(void*, unsigned char*, int)
static void SDLAudioCallback(void *userdata, Uint8 *stream, int len)
{
	if (playing_sample && !mute_stream)
	{
		unsigned int l = len/2;
		float* fbuf = new float[l];
		memset(fbuf, 0, sizeof(float));
		SynthSample(l, fbuf, NULL);
		while (l--)
		{
			float f = fbuf[l];
			if (f < -1.0) f = -1.0;
			if (f > 1.0) f = 1.0;
			((Sint16*)stream)[l] = (Sint16)(f * 32767);
		}
		delete[] fbuf;
	}
	else memset(stream, 0, len);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
cmpb $0x1, 0x659b(%rip)      # 0xd4c4
jne 0x6f34
cmpb $0x0, 0x7706(%rip)      # 0xe638
je 0x6f46
movslq %edx, %rdx
movq %rbx, %rdi
xorl %esi, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x3180
pushq $0x2
popq %rcx
movl %edx, %eax
cltd
idivl %ecx
movl %eax, %r15d
leaq (,%r15,4), %rdi
callq 0x3040
movq %rax, %r14
andl $0x0, (%rax)
movl %r15d, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x4196
leaq -0x1(%r15), %rax
movss 0x20cb(%rip), %xmm0     # 0x9048
movss 0x208b(%rip), %xmm1     # 0x9010
movss 0x212f(%rip), %xmm2     # 0x90bc
cmpq $-0x1, %rax
je 0x6fb4
movaps %xmm0, %xmm3
maxss (%r14,%rax,4), %xmm3
movaps %xmm1, %xmm4
minss %xmm3, %xmm4
mulss %xmm2, %xmm4
cvttss2si %xmm4, %ecx
movw %cx, (%rbx,%rax,2)
decq %rax
jmp 0x6f8d
movq %r14, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x3370
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: sdlupdate()
void sdlupdate ()
{
	mouse_px = mouse_x;
	mouse_py = mouse_y;
	Uint8 buttons = SDL_GetMouseState(&mouse_x, &mouse_y);
	bool mouse_left_p = mouse_left;
	bool mouse_right_p = mouse_right;
	bool mouse_middle_p = mouse_middle;
	mouse_left = buttons & SDL_BUTTON(1);
	mouse_right = buttons & SDL_BUTTON(3);
	mouse_middle = buttons & SDL_BUTTON(2);
	mouse_leftclick = mouse_left && !mouse_left_p;
	mouse_rightclick = mouse_right && !mouse_right_p;
	mouse_middleclick = mouse_middle && !mouse_middle_p;
}

// Assembly:
pushq %rax
leaq 0x7571(%rip), %rdi      # 0xe69c
movl 0x756b(%rip), %eax      # 0xe69c
movl %eax, 0x756d(%rip)      # 0xe6a4
leaq 0x7562(%rip), %rsi      # 0xe6a0
movl 0x755c(%rip), %eax      # 0xe6a0
movl %eax, 0x755e(%rip)      # 0xe6a8
callq 0x3460
movb 0x7557(%rip), %dl       # 0xe6ac
movb 0x7551(%rip), %sil      # 0xe6ad
movb 0x754c(%rip), %cl       # 0xe6ae
movl %eax, %edi
andb $0x1, %dil
movb %dil, 0x753d(%rip)      # 0xe6ac
movl %eax, %r8d
shrb $0x2, %r8b
andb $0x1, %r8b
movb %r8b, 0x752c(%rip)      # 0xe6ad
shrb %al
andb $0x1, %al
movb %al, 0x7523(%rip)       # 0xe6ae
xorb $0x1, %dl
movzbl %dl, %edx
xorl %r9d, %r9d
testb %dil, %dil
cmovel %r9d, %edx
xorb $0x1, %sil
movzbl %sil, %esi
testb %r8b, %r8b
cmovel %r9d, %esi
movb %dl, 0x74ff(%rip)       # 0xe6af
movb %sil, 0x74f9(%rip)      # 0xe6b0
xorb $0x1, %cl
movzbl %cl, %ecx
testb %al, %al
cmovel %r9d, %ecx
movb %cl, 0x74e8(%rip)       # 0xe6b1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: ddkLock()
bool ddkLock ()
{
	if(SDL_MUSTLOCK(sdlscreen))
	{
		if(SDL_LockSurface(sdlscreen) < 0)
			return false;
	}
	ddkpitch = sdlscreen->pitch / (sdlscreen->format->BitsPerPixel == 32 ? 4 : 2);
	ddkscreen16 = (Uint16*)(sdlscreen->pixels);
	ddkscreen32 = (Uint32*)(sdlscreen->pixels);
	return true;
}

// Assembly:
pushq %rax
movq 0x74e5(%rip), %rdi      # 0xe6b8
testb $0x2, (%rdi)
je 0x71e8
callq 0x33b0
testl %eax, %eax
js 0x721e
movq 0x74d0(%rip), %rdi      # 0xe6b8
movq 0x8(%rdi), %rax
xorl %ecx, %ecx
cmpb $0x20, 0x10(%rax)
movl 0x18(%rdi), %eax
sete %cl
leal 0x2(,%rcx,2), %ecx
cltd
idivl %ecx
movl %eax, 0x7490(%rip)      # 0xe698
movq 0x20(%rdi), %rax
movq %rax, 0x747d(%rip)      # 0xe690
movq %rax, 0x746e(%rip)      # 0xe688
movb $0x1, %al
popq %rcx
retq
xorl %eax, %eax
jmp 0x721c
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: ddkSetMode(int, int, int, char const*)
void ddkSetMode (int width, int height, int fullscreen, const char *title)
{
	window = SDL_CreateWindow(title, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, width, height, SDL_WINDOW_SHOWN | (fullscreen ? SDL_WINDOW_FULLSCREEN : 0));
	renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
	SDL_SetWindowTitle(window, title);
	sdlscreen = SDL_GetWindowSurface(window);

	if(!sdlscreen) {
		std::cout << SDL_GetError() << std::endl;
		exit(1);
	}
}

// Assembly:
pushq %rbx
movq %rcx, %rbx
movl %esi, %r8d
movl %edi, %ecx
cmpl $0x1, %edx
pushq $0x4
popq %r9
sbbl $-0x1, %r9d
movq %rbx, %rdi
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
callq 0x3070
movq %rax, 0x7460(%rip)      # 0xe6c0
pushq $-0x1
popq %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x3060
movq %rax, 0x7453(%rip)      # 0xe6c8
movq 0x7444(%rip), %rdi      # 0xe6c0
movq %rbx, %rsi
callq 0x34c0
movq 0x7435(%rip), %rdi      # 0xe6c0
callq 0x3390
movq %rax, 0x7421(%rip)      # 0xe6b8
testq %rax, %rax
je 0x729e
popq %rbx
retq
callq 0x31d0
movq 0x5d26(%rip), %rdi      # 0xcfd0
movq %rax, %rsi
callq 0x32a0
movq %rax, %rdi
callq 0x3160
pushq $0x1
popq %rdi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: stoupper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
std::string stoupper(const std::string& s)
{
	std::string result = s;
	std::string::iterator i = result.begin();
	std::string::iterator end = result.end();
	
	while(i != end)
	{
		*i = std::toupper((unsigned char)*i);
		++i;
	}
	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x33c0
movq (%rbx), %r14
movq 0x8(%rbx), %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x7447
movzbl (%r14,%r12), %edi
callq 0x3500
movb %al, (%r14,%r12)
incq %r12
jmp 0x742f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: ioNew(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool ioNew(const std::string& filename)
{
    if(ioExists(filename))
        return false;
    
    FILE* file = fopen(filename.c_str(), "wb");
    if(file == NULL)
        return false;
    fclose(file);
    return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x7456
testb %al, %al
jne 0x7495
movq (%rbx), %rdi
leaq 0x1ce0(%rip), %rsi      # 0x915f
callq 0x3330
testq %rax, %rax
je 0x7495
movq %rax, %rdi
callq 0x32b0
movb $0x1, %al
jmp 0x7497
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: select_file(char*, bool)
bool select_file (char *buf, bool showNewButton)
{
	// FIXME: Needs directory browsing
	
	bool gotFile = false;
	using namespace std;
	list<string> files;
	files = ioList(".", false, true);
	
	for(list<string>::iterator e = files.begin(); e != files.end();)
	{
		if(e->find(".sfxr") == string::npos)
		{
			e = files.erase(e);
			continue;
		}
		
		e++;
	}
	
	bool done = false;
	SDL_Event e;
	while (!done)
	{
		SDL_PollEvent(&e);
		switch (e.type)
		{
			case SDL_QUIT:
				exit(0);
	
			case SDL_KEYDOWN:
				keys[e.key.keysym.sym] = true;
	
			default: break;
		}
		sdlupdate();
		
		DrawFileSelectScreen(files, buf, gotFile, done, showNewButton);

		SDL_Delay(5);
		
		SDL_UpdateWindowSurface(window);
	}
	return gotFile;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movb $0x0, 0xe(%rsp)
leaq 0x10(%rsp), %r14
movq %r14, 0x8(%r14)
movq %r14, (%r14)
andq $0x0, 0x10(%r14)
leaq 0x1b72(%rip), %rsi      # 0x950b
leaq 0x40(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x6fea
leaq 0x28(%rsp), %rdi
leaq 0x40(%rsp), %rsi
pushq $0x1
popq %rcx
xorl %edx, %edx
callq 0x72ea
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x83ec
movq %r15, %rdi
callq 0x7ea4
leaq 0x40(%rsp), %rdi
callq 0x3140
movq 0x10(%rsp), %r12
leaq 0x1b1b(%rip), %r15      # 0x9505
cmpq %r14, %r12
je 0x7a1a
leaq 0x10(%r12), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x3530
cmpq $-0x1, %rax
je 0x7a0a
movq (%r12), %r12
jmp 0x79ea
movq %r14, %rdi
movq %r12, %rsi
callq 0x7e32
movq %rax, %r12
jmp 0x79ea
leaq 0x28(%rsp), %r14
movb $0x0, (%r14)
movzbl %bpl, %ebp
leaq 0x10(%rsp), %r15
leaq 0xe(%rsp), %r13
pushq $0x5
popq %r12
cmpb $0x0, 0x28(%rsp)
jne 0x7a9d
leaq 0x40(%rsp), %rdi
callq 0x3190
movl 0x40(%rsp), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x7a5a
cmpl $0x100, %eax            # imm = 0x100
jne 0x7a6e
jmp 0x7abc
leaq 0x6bf7(%rip), %rdi      # 0xe658
leaq 0x54(%rsp), %rsi
callq 0x7c14
movb $0x1, (%rax)
callq 0x7123
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x76a7
movl %r12d, %edi
callq 0x31c0
movq 0x6c2a(%rip), %rdi      # 0xe6c0
callq 0x3310
jmp 0x7a35
movb 0xe(%rsp), %bl
leaq 0x10(%rsp), %rdi
callq 0x7ea4
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x3350
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x3140
jmp 0x7ad7
jmp 0x7ad4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x7ea4
movq %rbx, %rdi
callq 0x34d0
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: sdlinit()
void sdlinit ()
{
	SDL_Surface *icon;
	VERIFY(!SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO));
	icon = SDL_LoadBMP("/usr/local/share/sfxr/images/sfxr.bmp");
	if (!icon)
		icon = SDL_LoadBMP("images/sfxr.bmp");
	if (icon)
		SDL_SetWindowIcon(window, icon);
	atexit(sdlquit);
	keys.clear();
	ddkInit();
}

// Assembly:
pushq %rax
pushq $0x30
popq %rdi
callq 0x3240
testl %eax, %eax
jne 0x7b75
leaq 0x1a3b(%rip), %rdi      # 0x9544
leaq 0x164c(%rip), %rsi      # 0x915c
callq 0x3110
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x3260
testq %rax, %rax
jne 0x7b48
leaq 0x1a2e(%rip), %rdi      # 0x955a
leaq 0x1629(%rip), %rsi      # 0x915c
callq 0x3110
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0x3260
testq %rax, %rax
je 0x7b57
movq 0x6b71(%rip), %rdi      # 0xe6c0
movq %rax, %rsi
callq 0x3320
leaq -0x75(%rip), %rdi       # 0x7ae9
callq 0x89f0
leaq 0x6aee(%rip), %rdi      # 0xe658
callq 0x8496
popq %rax
jmp 0x6d36
leaq 0x1991(%rip), %rdi      # 0x950d
leaq 0x199c(%rip), %rdx      # 0x951f
movl $0x185, %esi            # imm = 0x185
callq 0x70bc
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/sdlkit.cpp
// Function: loop()
void loop (void)
{
	SDL_Event e;
	while (true)
	{
		SDL_PollEvent(&e);
		switch (e.type)
		{
			case SDL_QUIT:
				exit(0);
	
			case SDL_KEYDOWN:
				keys[e.key.keysym.sym] = true;
	
			default: break;
		}
		sdlupdate();
		if (!ddkCalcFrame())
			return;
		SDL_UpdateWindowSurface(window);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq 0x1c(%rsp), %rbx
leaq 0x8(%rsp), %r14
leaq 0x6ab1(%rip), %r15      # 0xe658
movq %r14, %rdi
callq 0x3190
movl 0x8(%rsp), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x7bc3
cmpl $0x100, %eax            # imm = 0x100
jne 0x7bd1
jmp 0x7bf7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x7c14
movb $0x1, (%rax)
callq 0x7123
callq 0x6cdf
testb %al, %al
je 0x7bed
movq 0x6ada(%rip), %rdi      # 0xe6c0
callq 0x3310
jmp 0x7ba7
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x3350
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: ClearScreen(unsigned int)
void ClearScreen(DWORD color)
{
	for(int y=0;y<480;y++)
	{
		int offset=y*ddkpitch;
		for(int x=0;x<640;x+=8)
		{
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
			ddkscreen32[offset++]=color;
		}
	}
}

// Assembly:
leaq 0x5fbd(%rip), %rax      # 0xe688
movq (%rax), %rax
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
addq $0x10, %rax
xorl %ecx, %ecx
leaq 0x5fb4(%rip), %rdx      # 0xe698
cmpl $0x1e0, %ecx            # imm = 0x1E0
je 0x8717
movl (%rdx), %esi
imull %ecx, %esi
movslq %esi, %rsi
leaq (%rax,%rsi,4), %rsi
xorl %edi, %edi
cmpl $0x280, %edi            # imm = 0x280
jae 0x8713
movdqu %xmm0, -0x10(%rsi,%rdi,4)
movdqu %xmm0, (%rsi,%rdi,4)
addq $0x8, %rdi
jmp 0x86fa
incl %ecx
jmp 0x86e4
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawBar(int, int, int, int, unsigned int)
void DrawBar(int sx, int sy, int w, int h, DWORD color)
{
	for(int y=sy;y<sy+h;y++)
	{
		int offset=y*ddkpitch+sx;
		int x1=0;
		if(w>8)
			for(x1=0;x1<w-8;x1+=8)
			{
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
				ddkscreen32[offset++]=color;
			}
		for(int x=x1;x<w;x++)
			ddkscreen32[offset++]=color;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
addl %esi, %ecx
leal -0x8(%rdx), %eax
movd %r8d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
leaq 0x5f66(%rip), %r9       # 0xe698
leaq 0x5f4f(%rip), %r10      # 0xe688
cmpl %ecx, %esi
jge 0x87a0
movl (%r9), %ebx
imull %esi, %ebx
movq (%r10), %r14
cmpl $0x9, %edx
jl 0x8775
leal (%rbx,%rdi), %r11d
movslq %r11d, %r11
leaq (%r14,%r11,4), %r14
addq $0x10, %r14
xorl %r11d, %r11d
cmpl %eax, %r11d
jge 0x877c
movdqu %xmm0, -0x10(%r14,%r11,4)
movdqu %xmm0, (%r14,%r11,4)
addq $0x8, %r11
jmp 0x875d
addl %edi, %ebx
xorl %r11d, %r11d
jmp 0x8784
addl %edi, %ebx
addl %r11d, %ebx
movq (%r10), %r14
movslq %ebx, %rbx
leaq (%r14,%rbx,4), %rbx
cmpl %edx, %r11d
jge 0x879c
movl %r8d, (%rbx)
incl %r11d
addq $0x4, %rbx
jmp 0x878b
incl %esi
jmp 0x8739
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawBox(int, int, int, int, unsigned int)
void DrawBox(int sx, int sy, int w, int h, DWORD color)
{
	DrawBar(sx, sy, w, 1, color);
	DrawBar(sx, sy, 1, h, color);
	DrawBar(sx+w, sy, 1, h, color);
	DrawBar(sx, sy+h, w+1, 1, color);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, %ebx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r13d
movl %edi, %r12d
pushq $0x1
popq %r15
movl %r15d, %ecx
callq 0x8718
movl %r12d, %edi
movl %r13d, %esi
movl %r15d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x8718
leal (%r14,%r12), %edi
movl %r13d, %esi
movl %r15d, %edx
movl %ebp, %ecx
movl %ebx, %r8d
callq 0x8718
addl %r13d, %ebp
incl %r14d
movl %r12d, %edi
movl %ebp, %esi
movl %r14d, %edx
movl %r15d, %ecx
movl %ebx, %r8d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8718
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawSprite(Spriteset&, int, int, int, unsigned int)
void DrawSprite(Spriteset& sprites, int sx, int sy, int i, DWORD color)
{
	for(int y=0;y<sprites.height;y++)
	{
		int offset=(sy+y)*ddkpitch+sx;
		int spoffset=y*sprites.pitch+i*sprites.width;
		if(color&0xFF000000)
			for(int x=0;x<sprites.width;x++)
			{
				DWORD p=sprites.data[spoffset++];
				if(p!=0x300030)
					ddkscreen32[offset+x]=p;
			}
		else
			for(int x=0;x<sprites.width;x++)
			{
				DWORD p=sprites.data[spoffset++];
				if(p!=0x300030)
					ddkscreen32[offset+x]=color;
			}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
xorl %eax, %eax
leaq 0x5e6f(%rip), %r9       # 0xe698
leaq 0x5e58(%rip), %r10      # 0xe688
cmpl 0xc(%rdi), %eax
jge 0x88bd
movl 0x8(%rdi), %r11d
movl %r11d, %ebp
imull %ecx, %ebp
movl (%r9), %ebx
movl 0x10(%rdi), %r15d
movq (%rdi), %r14
movq (%r10), %r12
imull %edx, %ebx
addl %esi, %ebx
movslq %ebx, %rbx
leaq (%r12,%rbx,4), %rbx
imull %eax, %r15d
addl %r15d, %ebp
movslq %ebp, %r15
leaq (%r14,%r15,4), %r14
xorl %r15d, %r15d
cmpl $0x1000000, %r8d        # imm = 0x1000000
jb 0x88ac
movslq %r11d, %r12
cmpq %r12, %r15
jge 0x88b4
movl (%r14,%r15,4), %ebp
cmpl $0x300030, %ebp         # imm = 0x300030
je 0x8892
movl %ebp, (%rbx,%r15,4)
movl 0x8(%rdi), %r11d
incq %r15
jmp 0x8876
cmpl $0x300030, (%r14,%r15,4) # imm = 0x300030
je 0x88a9
movl %r8d, (%rbx,%r15,4)
movl 0x8(%rdi), %r11d
incq %r15
movslq %r11d, %r12
cmpq %r12, %r15
jl 0x8897
incl %eax
incl %edx
jmp 0x8830
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/tjohnman[P]sfxr-sdl2/build/../src/tools.cpp
// Function: DrawText(Spriteset&, int, int, unsigned int, char const*, ...)
void DrawText(Spriteset& font, int sx, int sy, DWORD color, const char *string, ...)
{
	char string2[256];
	va_list args;

	va_start(args, string);
	vsprintf(string2, string, args);
	va_end(args);

	int len=strlen(string2);
	for(int i=0;i<len;i++)
		DrawSprite(font, sx+i*8, sy, string2[i]-' ', color);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movl %ecx, %ebx
movl %edx, %ebp
movl %esi, %r14d
movq %rdi, %r15
leaq 0x20(%rsp), %rcx
movq %r9, 0x28(%rcx)
testb %al, %al
je 0x8925
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %rdx
movq %rcx, 0x10(%rdx)
leaq 0x210(%rsp), %rax
movq %rax, 0x8(%rdx)
movabsq $0x3000000028, %rax     # imm = 0x3000000028
movq %rax, (%rdx)
leaq 0xd0(%rsp), %r12
movq %r12, %rdi
movq %r8, %rsi
callq 0x3150
movq %r12, %rdi
callq 0x3120
movq %rax, %r12
xorl %r13d, %r13d
testl %r12d, %r12d
cmovlel %r13d, %r12d
cmpq %r13, %r12
je 0x8997
movsbl 0xd0(%rsp,%r13), %ecx
addl $-0x20, %ecx
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %r8d
callq 0x8818
incq %r13
addl $0x8, %r14d
jmp 0x896d
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/unf-test.cc
// Function: nfd_test(UNF::Normalizer&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool nfd_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfd, ary[2], ary[0]) &&
    NF_TEST(norm.nfd, ary[2], ary[1]) &&
    NF_TEST(norm.nfd, ary[2], ary[2]) &&
    NF_TEST(norm.nfd, ary[4], ary[3]) &&
    NF_TEST(norm.nfd, ary[4], ary[4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x40(%rax), %r15
callq 0x295e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x237d
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x40(%rax), %r15
movq %rbx, %rdi
callq 0x295e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x237d
movq (%r14), %rax
movq 0x40(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x295e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x237d
movq (%r14), %rax
movq 0x60(%rax), %rsi
movq 0x80(%rax), %r15
movq %rbx, %rdi
callq 0x295e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
je 0x2385
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x80(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x295e
movq %r14, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
sete %al
jmp 0x237f
// File: /workspace/github_cpp_makefile_star2_O2/sile[P]unf/src/unf/unf-test.cc
// Function: nfkd_test(UNF::Normalizer&, std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&)
bool nfkd_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfkd, ary[4], ary[0]) &&
    NF_TEST(norm.nfkd, ary[4], ary[1]) &&
    NF_TEST(norm.nfkd, ary[4], ary[2]) &&
    NF_TEST(norm.nfkd, ary[4], ary[3]) &&
    NF_TEST(norm.nfkd, ary[4], ary[4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x80(%rax), %r15
callq 0x2966
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2447
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x80(%rax), %r15
movq %rbx, %rdi
callq 0x2966
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2447
movq (%r14), %rax
movq 0x40(%rax), %rsi
movq 0x80(%rax), %r15
movq %rbx, %rdi
callq 0x2966
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
jne 0x2447
movq (%r14), %rax
movq 0x60(%rax), %rsi
movq 0x80(%rax), %r15
movq %rbx, %rdi
callq 0x2966
movq %r15, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
je 0x244f
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x80(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2966
movq %r14, %rdi
movq %rax, %rsi
callq 0x2150
testl %eax, %eax
sete %al
jmp 0x2449