LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
movq %rsi, %r14
movl %edi, %ebp
movq %rsi, %rdi
callq 0xb081
testq %rax, %rax
je 0xae84
movq %rax, %rbx
movq %r14, %rdi
callq 0xb15e
cmpl $0x10e, %eax            # imm = 0x10E
jne 0xae73
movq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpb $0x5c, (%rax)
sete %cl
addq %rcx, %rax
incq %rax
movq %rax, 0x8(%r14)
notl %ecx
addl %ecx, 0x10(%r14)
movl %ebp, %edi
movq %r14, %rsi
callq 0xad80
testq %rax, %rax
je 0xae78
movq %rax, %r15
movq %rbx, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0xaf7b
movq %rax, %r12
testq %rax, %rax
jne 0xae87
cmpb $0x0, 0x8(%rbx)
je 0xae68
cmpb $0x0, 0x8(%r15)
je 0xae68
movl $0x38, %edi
callq 0x5170
movq %rax, %r12
movl 0x30(%r14), %eax
movb $0xa, 0x8(%r12)
movq $0x0, 0x10(%r12)
leaq 0x7d7c(%rip), %rcx      # 0x12bb0
movq %rcx, (%r12)
movl %ebp, 0x18(%r12)
movl %eax, 0x1c(%r12)
movq %rbx, 0x20(%r12)
movq %r15, 0x28(%r12)
testb $0x4, 0x1(%r14)
je 0xae87
movq %r12, %rdi
callq 0xc21e
movl $0x38, %esi
movq %r12, %rdi
callq 0x5180
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xae7b
movq %rbx, %r12
jmp 0xae87
movq %rbx, %r15
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %r12d, %r12d
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf70
cmpq $0x0, 0x10(%rsi)
setne %al
testq %rdi, %rdi
sete %cl
orb %al, %cl
jne 0xaf70
cmpq $0x0, 0x10(%rdi)
jne 0xaf70
movq %rsp, %rdx
callq 0xaf7b
testq %rax, %rax
je 0xaf70
movq %rax, 0x8(%r14)
movl 0x10(%r14), %eax
testb %al, %al
js 0xaf63
andl $0xffffef7f, %eax       # imm = 0xFFFFEF7F
movl %eax, 0x10(%r14)
movq $0x0, 0x8(%rbx)
movl $0x1, %ebp
movl %ebp, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xaf94
movq %rsi, %r14
cmpq $0x0, 0x10(%rsi)
je 0xafa5
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 0xc09d
testl %eax, %eax
je 0xaf94
movq %r14, %rdi
callq 0xc09d
testl %eax, %eax
je 0xb013
movl $0x820, %edi            # imm = 0x820
callq 0x5170
movq %rax, %rbx
movb $0x6, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x7ae0(%rip), %rax      # 0x12ac0
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 0xb047
movq %r14, %rdi
movq %rbx, %rsi
callq 0xc0ca
testl %eax, %eax
jne 0xb030
jmp 0xb021
cmpb $0x6, 0x8(%r14)
movq %r14, %rbx
jne 0xaf94
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc0ca
testl %eax, %eax
je 0xb061
cmpq %r14, %rbx
je 0xaf94
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
jmp 0xaf94
movq %rbx, %rdi
callq 0xc144
movl $0x820, %esi            # imm = 0x820
movq %rbx, %rdi
callq 0x5180
jmp 0xaf94
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
cmpq %r14, %rbx
je 0xaf96
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
jmp 0xaf96
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0xb26c
movq %rax, %rbx
cmpb $0x2, 0x3a(%r14)
jne 0xb14f
testq %rbx, %rbx
je 0xb14d
movq %r14, %rdi
callq 0xb15e
cmpl $0x10f, %eax            # imm = 0x10F
jne 0xb14f
movq 0x8(%r14), %rax
xorl %ecx, %ecx
cmpb $0x5c, (%rax)
sete %cl
addq %rcx, %rax
incq %rax
movq %rax, 0x8(%r14)
notl %ecx
addl %ecx, 0x10(%r14)
movq %r14, %rdi
callq 0xb081
testq %rax, %rax
je 0xb121
movq %rax, %r15
movl $0x28, %edi
callq 0x5170
movq %rax, %r12
movb $0xb, 0x8(%rax)
movq $0x0, 0x10(%rax)
leaq 0x7af9(%rip), %rax      # 0x12c00
movq %rax, (%r12)
movq %rbx, 0x18(%r12)
movq %r15, 0x20(%r12)
testb $0x4, 0x1(%r14)
jne 0xb126
movq %r12, %rbx
jmp 0xb14f
movq %rbx, %r15
jmp 0xb144
movq %r12, %rdi
callq 0xc26c
movl $0x28, %esi
movq %r12, %rdi
callq 0x5180
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb1b4
movq 0x8(%rdi), %rdx
movzbl (%rdx), %ecx
testb $0x1, 0x1(%rdi)
jne 0xb1b1
cmpl $0x0, 0x48(%rdi)
je 0xb185
movl $0x0, 0x48(%rdi)
cmpq $0x2a, %rcx
je 0xb1b1
cmpl $0x5c, %ecx
jne 0xb1ba
movl $0x104, %eax            # imm = 0x104
cmpl $0x1, %esi
je 0xb1b9
movzbl 0x1(%rdx), %ecx
cmpl $0x29, %ecx
je 0xb1ec
cmpl $0x28, %ecx
jne 0xb1f8
cmpb $0x0, 0x3a(%rdi)
jne 0xb1f8
movl $0x1, 0x48(%rdi)
jmp 0xb1f8
movl %ecx, %eax
retq
movl $0x103, %eax            # imm = 0x103
retq
cmpl $0x1, %esi
jne 0xb1c9
movl $0x105, %eax            # imm = 0x105
cmpb $0x24, %cl
je 0xb1b9
cmpl $0x29, %ecx
je 0xb226
cmpl $0x5e, %ecx
jne 0xb232
cmpb $0x0, 0x3a(%rdi)
jne 0xb232
cmpq 0x18(%rdi), %rdx
jne 0xb232
movl $0x1, 0x48(%rdi)
movl $0x101, %eax            # imm = 0x101
retq
cmpb $0x0, 0x3a(%rdi)
jne 0xb1f8
cmpl $0x0, 0x34(%rdi)
je 0xb1b9
leaq 0x8901(%rip), %rdx      # 0x13b00
movzbl (%rcx,%rdx), %ecx
testq %rcx, %rcx
je 0xb1b9
movzbl 0x3a(%rdi), %eax
leaq (%rcx,%rcx), %rdx
shll $0x4, %ecx
subq %rdx, %rcx
leaq 0x2363(%rip), %rdx      # 0xd580
addq %rcx, %rdx
movswl 0x4(%rdx,%rax,4), %eax
retq
cmpb $0x0, 0x3a(%rdi)
je 0xb232
cmpl $0x0, 0x34(%rdi)
je 0xb266
leaq 0x88c7(%rip), %rax      # 0x13b00
movzbl (%rcx,%rax), %edx
movl %ecx, %eax
testq %rdx, %rdx
je 0xb1b9
movzbl 0x3a(%rdi), %eax
leaq (%rdx,%rdx), %rcx
shll $0x4, %edx
subq %rcx, %rdx
leaq 0x2323(%rip), %rcx      # 0xd580
addq %rdx, %rcx
movswl 0x2(%rcx,%rax,4), %eax
retq
movl $0x29, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbb75
movq %rsi, %r14
movb 0x8(%rbx), %al
testb %al, %al
je 0xbb87
movb 0x8(%r14), %cl
testb %cl, %cl
je 0xbb57
xorb $0x3, %al
xorb $0x3, %cl
orb %al, %cl
jne 0xbb6f
movl 0x18(%r14), %eax
addl 0x18(%rbx), %eax
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
ja 0xbb6f
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 0xbb51
addl %esi, %ecx
movl %ecx, %edx
cmpl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
ja 0xbb6f
movl %eax, 0x18(%rbx)
movl %edx, 0x1c(%rbx)
movq (%r14), %rax
movq 0x10(%r14), %r15
movq $0x0, 0x10(%r14)
movq %r14, %rdi
callq *0x8(%rax)
movq %r15, %r14
movq %r14, 0x10(%rbx)
jmp 0xbb93
testq %rbx, %rbx
je 0xbb83
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0xbb93
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_O3/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:
movl 0x10(%rsi), %edx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl $0x3, %edx
jl 0xc04c
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 0xbf9f
cmpb $0x5d, 0x2(%r14)
jne 0xbf9f
movzbl (%r14), %ebx
cmpl $0x3f, %ebx
je 0xc03e
cmpl $0x5b, %ebx
je 0xc03e
addq $0x3, %r14
movq %r14, 0x8(%rsi)
addl $-0x3, %edx
jmp 0xc039
leaq -0x1(%rdx), %r8
movl $0x1, %r15d
movzbl (%r14,%r15), %ecx
cmpl %edi, %ecx
jne 0xbfba
cmpb $0x5d, 0x1(%r14,%r15)
je 0xbfc8
incq %r15
decq %r8
cmpq $0x1, %r8
jg 0xbfa9
jmp 0xc03e
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
leaq 0x72f7(%rip), %rbp      # 0x132d0
xorl %ebx, %ebx
movq (%rbp), %r13
movq %r13, %rdi
callq 0x50d0
movq %rax, %r12
movslq %r12d, %rax
cmpq %r15, %rax
jne 0xc004
movq %r13, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x51a0
testl %eax, %eax
je 0xc01b
incq %rbx
addq $0x8, %rbp
cmpq $0x80, %rbx
jne 0xbfdb
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xc03e
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_O3/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), %ecx
leal -0xe(%rcx), %eax
cmpl $0x2, %eax
jb 0xc0e5
cmpl $0x4, %ecx
je 0xc0f4
movl $0x1, %eax
cmpl $0x5, %ecx
jne 0xc112
movq 0x18(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x8b04
pushq %rax
movb 0x20(%rdi), %cl
leaq 0x6(%rsp), %rax
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x8b04
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe913(%rip), %r14      # 0x15fb8
leaq 0x7aed(%rip), %rsi      # 0xf199
movq %r14, %rdi
callq 0x5330
leaq 0x7b2f(%rip), %rsi      # 0xf1ea
movq %r14, %rdi
callq 0x5330
leaq 0x7b56(%rip), %rsi      # 0xf220
movq %r14, %rdi
callq 0x5330
leaq 0x7ba5(%rip), %rsi      # 0xf27e
movq %r14, %rdi
callq 0x5330
movq %r14, %rdi
movq %rbx, %rsi
callq 0x50a0
movq %rax, %rdi
callq 0x5180
xorl %edi, %edi
callq 0x5400
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x7fa2(%rip), %rdi      # 0x16580
callq 0x5510
testl %eax, %eax
jne 0xe703
movq 0x79c6(%rip), %rdi      # 0x15fb8
leaq 0x166b(%rip), %rsi      # 0xfc64
movl $0x3, %edx
callq 0x53d0
cmpl $-0x1, %r14d
je 0xe69d
leal -0x1(%r14), %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cltq
shlq $0x5, %rax
leaq 0x7e87(%rip), %rcx      # 0x164c0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq 0x796f(%rip), %rdi      # 0x15fb8
callq 0x53d0
movq %rax, %r15
leaq 0x1610(%rip), %rsi      # 0xfc68
movl $0x8, %edx
movq %rax, %rdi
callq 0x53d0
movq %r15, %rdi
movl %r14d, %esi
callq 0x55d0
movq %rax, %r14
leaq 0x15f9(%rip), %rsi      # 0xfc73
movl $0x1, %edx
movq %rax, %rdi
callq 0x53d0
movq 0x7ed2(%rip), %rsi      # 0x16560
movq 0x7ed3(%rip), %rdx      # 0x16568
movq %r14, %rdi
callq 0x53d0
movq 0x7914(%rip), %rdi      # 0x15fb8
leaq 0xc1c(%rip), %rsi       # 0xf2c7
movl $0x1, %edx
callq 0x53d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x78f5(%rip), %rdi      # 0x15fb8
callq 0x53d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5320
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5240
leaq 0x7e87(%rip), %rdi      # 0x16580
popq %rbx
popq %r14
popq %r15
jmp 0x5280
movl %eax, %edi
callq 0x5230
movq %rax, %rbx
leaq 0x7e6c(%rip), %rdi      # 0x16580
callq 0x5280
movq %rbx, %rdi
callq 0x55f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
leaq 0x7e4d(%rip), %rdi      # 0x16580
callq 0x5510
testl %eax, %eax
jne 0xe858
movq 0x7871(%rip), %rdi      # 0x15fb8
leaq 0x1523(%rip), %rsi      # 0xfc71
movl $0x3, %edx
callq 0x53d0
cmpl $-0x1, %r14d
je 0xe7f2
leal -0x1(%r14), %eax
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x21, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cltq
shlq $0x5, %rax
leaq 0x7d32(%rip), %rcx      # 0x164c0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq 0x781a(%rip), %rdi      # 0x15fb8
callq 0x53d0
movq %rax, %r15
leaq 0x14bb(%rip), %rsi      # 0xfc68
movl $0x8, %edx
movq %rax, %rdi
callq 0x53d0
movq %r15, %rdi
movl %r14d, %esi
callq 0x55d0
movq %rax, %r14
leaq 0x14a4(%rip), %rsi      # 0xfc73
movl $0x1, %edx
movq %rax, %rdi
callq 0x53d0
movq 0x7d7d(%rip), %rsi      # 0x16560
movq 0x7d7e(%rip), %rdx      # 0x16568
movq %r14, %rdi
callq 0x53d0
movq 0x77bf(%rip), %rdi      # 0x15fb8
leaq 0xac7(%rip), %rsi       # 0xf2c7
movl $0x1, %edx
callq 0x53d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x77a0(%rip), %rdi      # 0x15fb8
callq 0x53d0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x5320
movsbl %al, %esi
movq %rbx, %rdi
callq 0x5030
movq %rax, %rdi
callq 0x5240
leaq 0x7d32(%rip), %rdi      # 0x16580
popq %rbx
popq %r14
popq %r15
jmp 0x5280
movl %eax, %edi
callq 0x5230
movq %rax, %rbx
leaq 0x7d17(%rip), %rdi      # 0x16580
callq 0x5280
movq %rbx, %rdi
callq 0x55f0
// File: /workspace/github_cpp_makefile_star2_O3/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: Undo()
void Undo()
{
	if(lastChanged != NULL)
	{
		*lastChanged = undoValue;
		lastChanged = NULL;
		undoValue = 0.0f;
	}
}

// Assembly:
movq 0xbe68(%rip), %rax      # 0xe600
testq %rax, %rax
je 0x27be
movss 0xbe63(%rip), %xmm0     # 0xe608
movss %xmm0, (%rax)
movq $0x0, 0xbe4c(%rip) # 0xe600
movl $0x0, 0xbe4a(%rip)      # 0xe608
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x64, %edx
movl $0x11, %ecx
callq 0x93d0
movl %eax, %ebp
testb %al, %al
je 0x3ed9
leaq 0xa7c2(%rip), %rax      # 0xe68f
cmpb $0x1, (%rax)
jne 0x3ed9
movl %r13d, 0x93b7(%rip)     # 0xd290
cmpl %r13d, 0x93b0(%rip)     # 0xd290
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
movl $0x66, %edx
movl $0x13, %ecx
callq 0x8fd6
movl %r15d, %edi
movl %r14d, %esi
movl $0x64, %edx
movl $0x11, %ecx
movl %r13d, %r8d
callq 0x8fd6
addl $0x5, %r15d
addl $0x5, %r14d
leaq 0x9374(%rip), %rdi      # 0xd2c8
movl %r15d, %esi
movl %r14d, %edx
movl %r12d, %ecx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x92ea
testb %bl, %bpl
je 0x3f7b
leaq 0xa718(%rip), %rcx      # 0xe68c
movb $0x1, %al
cmpb $0x1, (%rcx)
jne 0x3f7d
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_O3/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 0x93d0
testb %al, %al
je 0x3fcd
leaq 0xa6cd(%rip), %rcx      # 0xe68f
cmpb $0x1, (%rcx)
jne 0x3fcd
movl %ebp, 0x92c3(%rip)      # 0xd290
cmpl %ebp, 0x92bd(%rip)      # 0xd290
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 0x8fd6
movl %r15d, %edi
movl %r14d, %esi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x8fd6
addl $0x5, %r15d
addl $0x5, %r14d
leaq 0x9281(%rip), %rdi      # 0xd2c8
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movq 0x10(%rsp), %r8
xorl %eax, %eax
callq 0x92ea
movb 0xe(%rsp), %al
testb %al, 0xf(%rsp)
je 0x4073
leaq 0xa620(%rip), %rcx      # 0xe68c
movb $0x1, %al
cmpb $0x1, (%rcx)
jne 0x4075
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_O3/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
movl $0x20, %edi
callq 0x783c
testb %al, %al
jne 0x745d
movl $0xd, %edi
callq 0x783c
testb %al, %al
je 0x7478
cmpb $0x0, 0x71c4(%rip)      # 0xe628
jne 0x74bf
xorl %edi, %edi
callq 0x2e5c
movb $0x1, 0x6030(%rip)      # 0xd4a4
movb $0x1, %al
jmp 0x74b9
movl $0x7a, %edi
callq 0x783c
testb %al, %al
je 0x74b7
movq 0x7173(%rip), %rcx      # 0xe600
movb $0x1, %al
testq %rcx, %rcx
je 0x74b9
movss 0x716c(%rip), %xmm0     # 0xe608
movss %xmm0, (%rcx)
movq $0x0, 0x7155(%rip) # 0xe600
movl $0x0, 0x7153(%rip)      # 0xe608
jmp 0x74b9
xorl %eax, %eax
movb %al, 0x7169(%rip)       # 0xe628
callq 0x4084
movl $0x5, %edi
callq 0x21a0
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
cmpb $0x1, 0x5e03(%rip)      # 0xd4a4
jne 0x76ac
cmpb $0x0, 0x6f6e(%rip)      # 0xe618
je 0x76c3
movslq %ebp, %rdx
movq %rbx, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2160
movl %ebp, %r14d
shrl $0x1f, %r14d
addl %ebp, %r14d
sarl %r14d
leaq (,%r14,4), %rdi
callq 0x2040
movq %rax, %r15
movl $0x0, (%rax)
movl %r14d, %edi
movq %rax, %rsi
xorl %edx, %edx
callq 0x32b4
incl %ebp
cmpl $0x3, %ebp
jb 0x773a
leal -0x1(%r14), %eax
movss 0x293e(%rip), %xmm0     # 0xa044
movss 0x2902(%rip), %xmm1     # 0xa010
movss 0x29ae(%rip), %xmm2     # 0xa0c4
movaps %xmm0, %xmm3
maxss (%r15,%rax,4), %xmm3
movaps %xmm1, %xmm4
minss %xmm3, %xmm4
mulss %xmm2, %xmm4
cvttss2si %xmm4, %ecx
movw %cx, (%rbx,%rax,2)
decq %rax
decl %r14d
jne 0x7716
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2350
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6dfb(%rip), %rdi      # 0xe67c
movl 0x6df5(%rip), %eax      # 0xe67c
movl %eax, 0x6df7(%rip)      # 0xe684
leaq 0x6dec(%rip), %rsi      # 0xe680
movl 0x6de6(%rip), %eax      # 0xe680
movl %eax, 0x6de8(%rip)      # 0xe688
callq 0x2420
movb 0x6de1(%rip), %dl       # 0xe68c
movb 0x6ddb(%rip), %sil      # 0xe68d
movb 0x6dd6(%rip), %cl       # 0xe68e
movl %eax, %edi
andb $0x1, %dil
movb %dil, 0x6dc7(%rip)      # 0xe68c
movl %eax, %r8d
shrb $0x2, %r8b
andb $0x1, %r8b
movb %r8b, 0x6db6(%rip)      # 0xe68d
shrb %al
andb $0x1, %al
movb %al, 0x6dad(%rip)       # 0xe68e
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, 0x6d89(%rip)       # 0xe68f
movb %sil, 0x6d83(%rip)      # 0xe690
xorb $0x1, %cl
movzbl %cl, %ecx
testb %al, %al
cmovel %r9d, %ecx
movb %cl, 0x6d72(%rip)       # 0xe691
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x6d6f(%rip), %rdi      # 0xe698
testb $0x2, (%rdi)
je 0x793e
callq 0x2380
testl %eax, %eax
js 0x7974
movq 0x6d5a(%rip), %rdi      # 0xe698
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, 0x6d1a(%rip)      # 0xe678
movq 0x20(%rdi), %rax
movq %rax, 0x6d07(%rip)      # 0xe670
movq %rax, 0x6cf8(%rip)      # 0xe668
movb $0x1, %al
popq %rcx
retq
xorl %eax, %eax
jmp 0x7972
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x4, %r9d
sbbl $-0x1, %r9d
movq %rbx, %rdi
movl $0x2fff0000, %esi       # imm = 0x2FFF0000
movl $0x2fff0000, %edx       # imm = 0x2FFF0000
callq 0x2070
movq %rax, 0x6ce8(%rip)      # 0xe6a0
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x2060
movq %rax, 0x6cd7(%rip)      # 0xe6a8
movq 0x6cc8(%rip), %rdi      # 0xe6a0
movq %rbx, %rsi
callq 0x2490
movq 0x6cb9(%rip), %rdi      # 0xe6a0
callq 0x2360
movq %rax, 0x6ca5(%rip)      # 0xe698
testq %rax, %rax
je 0x79fa
popq %rbx
retq
callq 0x21b0
movq 0x55ca(%rip), %rdi      # 0xcfd0
movq %rax, %rsi
callq 0x2270
movq %rax, %rdi
callq 0x2140
movl $0x1, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
movq %rax, %rsi
callq 0x894a
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x7cdd
movq (%rbx), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0x24d0
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x7cc7
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rdi
xorl %ebx, %ebx
xorl %esi, %esi
callq 0x2460
testl %eax, %eax
je 0x7d37
movq (%r14), %rdi
leaq 0x2450(%rip), %rsi      # 0xa16f
callq 0x2310
testq %rax, %rax
je 0x7d35
movq %rax, %rdi
callq 0x2280
movb $0x1, %bl
jmp 0x7d37
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0xf(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, 0x8(%rax)
movq %rax, (%rax)
movq $0x0, 0x10(%rax)
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x21bf(%rip), %rsi      # 0xa51b
leaq 0x21b9(%rip), %rdx      # 0xa51c
leaq 0x28(%rsp), %rdi
callq 0x7778
leaq 0x60(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x7a48
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8c8e
movq %r15, %rdi
callq 0x8904
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x83b7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x22a0
movq 0x10(%rsp), %r12
cmpq %r14, %r12
je 0x83f9
leaq 0x214d(%rip), %r15      # 0xa515
leaq 0x10(%r12), %rdi
movl $0x5, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x2470
movq (%r12), %r13
cmpq $-0x1, %rax
jne 0x83f1
movq %r14, %rdi
movq %r12, %rsi
callq 0x8cf4
movq %r13, %r12
cmpq %r14, %r13
jne 0x83c8
leaq 0x60(%rsp), %r14
movb $0x0, (%r14)
leaq 0x28(%rsp), %r12
movzbl %bpl, %ebp
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %r13
cmpb $0x0, 0x60(%rsp)
jne 0x847d
movq %r12, %rdi
callq 0x2170
movl 0x28(%rsp), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x8438
cmpl $0x100, %eax            # imm = 0x100
jne 0x844c
jmp 0x849c
leaq 0x61f9(%rip), %rdi      # 0xe638
leaq 0x3c(%rsp), %rsi
callq 0x85f4
movb $0x1, (%rax)
callq 0x7879
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x7fd8
movl $0x5, %edi
callq 0x21a0
movq 0x622a(%rip), %rdi      # 0xe6a0
callq 0x22f0
jmp 0x8415
movb 0xf(%rsp), %bl
leaq 0x10(%rsp), %rdi
callq 0x8904
movl %ebx, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x2330
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x84c4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x22a0
jmp 0x84c4
jmp 0x84c1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8904
movq %rbx, %rdi
callq 0x24a0
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x30, %edi
callq 0x2210
testl %eax, %eax
jne 0x8568
leaq 0x205c(%rip), %rdi      # 0xa554
leaq 0x1c6d(%rip), %rsi      # 0xa16c
callq 0x2110
movq %rax, %rdi
movl $0x1, %esi
callq 0x2230
testq %rax, %rax
jne 0x853b
leaq 0x204d(%rip), %rdi      # 0xa56a
leaq 0x1c48(%rip), %rsi      # 0xa16c
callq 0x2110
movq %rax, %rdi
movl $0x1, %esi
callq 0x2230
testq %rax, %rax
je 0x854a
movq 0x615e(%rip), %rdi      # 0xe6a0
movq %rax, %rsi
callq 0x2300
leaq -0x7b(%rip), %rdi       # 0x84d6
callq 0x9410
leaq 0x60db(%rip), %rdi      # 0xe638
callq 0x8d2a
popq %rax
jmp 0x74d2
callq 0x254a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x60b1(%rip), %r15      # 0xe638
movq %r14, %rdi
callq 0x2170
movl 0x8(%rsp), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x85a3
cmpl $0x100, %eax            # imm = 0x100
jne 0x85b1
jmp 0x85d7
movq %r15, %rdi
movq %rbx, %rsi
callq 0x85f4
movb $0x1, (%rax)
callq 0x7879
callq 0x7440
testb %al, %al
je 0x85cd
movq 0x60da(%rip), %rdi      # 0xe6a0
callq 0x22f0
jmp 0x8587
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O3/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 0x56df(%rip), %rax      # 0xe668
movq (%rax), %rax
movd %edi, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
addq $0x10, %rax
xorl %ecx, %ecx
leaq 0x56d6(%rip), %rdx      # 0xe678
movl (%rdx), %esi
imull %ecx, %esi
movslq %esi, %rsi
leaq (%rax,%rsi,4), %rsi
movl $0xfffffff8, %edi       # imm = 0xFFFFFFF8
movdqu %xmm0, -0x10(%rsi)
movdqu %xmm0, (%rsi)
addq $0x20, %rsi
addl $0x8, %edi
cmpl $0x278, %edi            # imm = 0x278
jb 0x8fb3
incl %ecx
cmpl $0x1e0, %ecx            # imm = 0x1E0
jne 0x8fa2
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
testl %ecx, %ecx
jle 0x9173
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
addl %esi, %ecx
leal -0x8(%rdx), %eax
leaq 0x5676(%rip), %r9       # 0xe668
movq (%r9), %r9
leal -0x9(%rdx), %r10d
andl $-0x8, %r10d
addl $0x8, %r10d
movd %r8d, %xmm0
pshufd $0x0, %xmm0, %xmm0      # xmm0 = xmm0[0,0,0,0]
leaq 0x10(%r9), %r11
addq $0xc, %r9
leaq 0x565e(%rip), %rbx      # 0xe678
movdqa 0x155e(%rip), %xmm1     # 0xa580
movdqa 0x1566(%rip), %xmm2     # 0xa590
movdqa 0x10fe(%rip), %xmm3     # 0xa130
pcmpeqd %xmm4, %xmm4
movl (%rbx), %r14d
imull %esi, %r14d
cmpl $0x9, %edx
jge 0x904a
addl %edi, %r14d
xorl %r15d, %r15d
jmp 0x907a
leal (%r14,%rdi), %ebp
movslq %ebp, %r15
leaq (%r11,%r15,4), %r12
xorl %r15d, %r15d
movdqu %xmm0, -0x10(%r12,%r15,4)
movdqu %xmm0, (%r12,%r15,4)
addq $0x8, %r15
cmpl %eax, %r15d
jl 0x9058
addl %edi, %r15d
addl %r14d, %r15d
movl %r15d, %r14d
movl %r10d, %r15d
cmpl %edx, %r15d
jge 0x9161
movslq %r14d, %r12
notl %r15d
addl %edx, %r15d
leaq 0x4(%r15), %r14
andq $-0x4, %r14
movq %r15, %xmm5
pshufd $0x44, %xmm5, %xmm5     # xmm5 = xmm5[0,1,0,1]
leaq (%r9,%r12,4), %r15
pxor %xmm3, %xmm5
xorl %r12d, %r12d
movq %r12, %xmm6
pshufd $0x44, %xmm6, %xmm6     # xmm6 = xmm6[0,1,0,1]
movdqa %xmm6, %xmm7
por %xmm2, %xmm7
pxor %xmm3, %xmm7
movdqa %xmm7, %xmm8
pcmpgtd %xmm5, %xmm8
pcmpeqd %xmm5, %xmm7
pshufd $0xf5, %xmm7, %xmm9     # xmm9 = xmm7[1,1,3,3]
pand %xmm8, %xmm9
pshufd $0xf5, %xmm8, %xmm7     # xmm7 = xmm8[1,1,3,3]
por %xmm9, %xmm7
movd %xmm7, %ebp
notl %ebp
testb $0x1, %bpl
je 0x90f4
movl %r8d, -0xc(%r15,%r12,4)
pxor %xmm4, %xmm7
pextrw $0x4, %xmm7, %ebp
testb $0x1, %bpl
je 0x9108
movl %r8d, -0x8(%r15,%r12,4)
por %xmm1, %xmm6
pxor %xmm3, %xmm6
movdqa %xmm6, %xmm7
pcmpgtd %xmm5, %xmm7
pcmpeqd %xmm5, %xmm6
pshufd $0xf5, %xmm6, %xmm8     # xmm8 = xmm6[1,1,3,3]
pand %xmm7, %xmm8
pshufd $0xf5, %xmm7, %xmm6     # xmm6 = xmm7[1,1,3,3]
por %xmm8, %xmm6
pxor %xmm4, %xmm6
pextrw $0x0, %xmm6, %ebp
testb $0x1, %bpl
je 0x9145
movl %r8d, -0x4(%r15,%r12,4)
pextrw $0x4, %xmm6, %ebp
testb $0x1, %bpl
je 0x9154
movl %r8d, (%r15,%r12,4)
addq $0x4, %r12
cmpq %r12, %r14
jne 0x90a9
incl %esi
cmpl %ecx, %esi
jl 0x9036
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %r8d, %ebx
movl %ecx, %r13d
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %r15d
movl $0x1, %ecx
callq 0x8fd6
leal (%r12,%r13), %esi
testl %r13d, %r13d
jle 0x91e7
leaq 0x54c2(%rip), %rcx      # 0xe668
movq (%rcx), %rdx
leaq 0x54c8(%rip), %rax      # 0xe678
movl %r12d, %edi
movl (%rax), %r8d
imull %edi, %r8d
addl %r15d, %r8d
movslq %r8d, %r8
movl %ebx, (%rdx,%r8,4)
incl %edi
cmpl %esi, %edi
jl 0x91b3
leal (%r14,%r15), %edx
movq (%rcx), %rcx
movl (%rax), %edi
imull %r12d, %edi
addl %edx, %edi
movslq %edi, %rdi
movl %ebx, (%rcx,%rdi,4)
incl %r12d
cmpl %esi, %r12d
jl 0x91d1
incl %r14d
movl %r15d, %edi
movl %r14d, %edx
movl $0x1, %ecx
movl %ebx, %r8d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8fd6
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpl $0x0, 0xc(%rdi)
jle 0x92e9
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rdi), %rax
movl 0x8(%rdi), %ebx
xorl %r9d, %r9d
leaq 0x544e(%rip), %r10      # 0xe678
leaq 0x5437(%rip), %r11      # 0xe668
movl %ebx, %r14d
imull %ecx, %r14d
movl (%r10), %ebp
movl 0x10(%rdi), %r15d
cmpl $0x1000000, %r8d        # imm = 0x1000000
jae 0x928e
testl %ebx, %ebx
jle 0x92d0
imull %r9d, %r15d
addl %r15d, %r14d
movslq %r14d, %r14
leaq (%rax,%r14,4), %r14
imull %edx, %ebp
addl %esi, %ebp
movslq %ebp, %r15
shlq $0x2, %r15
addq (%r11), %r15
xorl %r12d, %r12d
cmpl $0x300030, (%r14,%r12,4) # imm = 0x300030
je 0x9281
movl %r8d, (%r15,%r12,4)
movl 0x8(%rdi), %ebx
incq %r12
movslq %ebx, %r13
cmpq %r13, %r12
jl 0x9270
jmp 0x92d0
testl %ebx, %ebx
jle 0x92d0
imull %r9d, %r15d
addl %r15d, %r14d
movslq %r14d, %r14
leaq (%rax,%r14,4), %r14
imull %edx, %ebp
addl %esi, %ebp
movslq %ebp, %r15
shlq $0x2, %r15
addq (%r11), %r15
xorl %r12d, %r12d
movl (%r14,%r12,4), %ebp
cmpl $0x300030, %ebp         # imm = 0x300030
je 0x92c5
movl %ebp, (%r15,%r12,4)
movl 0x8(%rdi), %ebx
incq %r12
movslq %ebx, %r13
cmpq %r13, %r12
jl 0x92b2
incl %r9d
incl %edx
cmpl 0xc(%rdi), %r9d
jl 0x9231
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::normalize(char const*, UNF::Normalizer::Form)
const char* normalize(const char* src, Form form) {
      switch(form) {
      case FORM_NFD:  return nfd(src);
      case FORM_NFC:  return nfc(src);
      case FORM_NFKD: return nfkd(src);
      case FORM_NFKC: return nfkc(src);
      default:        return src;
      }
    }

// Assembly:
cmpl $0x3, %edx
ja 0x2c75
movl %edx, %eax
leaq 0x13c2(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdi, %rdx
jmp 0x2d6c
leaq 0x18(%rdi), %rdx
jmp 0x2d6c
leaq 0x60(%rdi), %rdx
leaq 0x18(%rdi), %rcx
jmp 0x3370
leaq 0x48(%rdi), %rdx
movq %rdi, %rcx
jmp 0x3370
movq %rsi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::decompose(char const*, UNF::Trie::NormalizationForm const&)
const char* decompose(const char* src, const Trie::NormalizationForm& nf) {
      const char* beg = next_invalid_char(src, nf);
      if(*beg=='\0')
	return src;
      
      buffer.assign(src, beg);
      do {
	const char* end = next_valid_starter(beg, nf);
	decompose_one(beg, end, nf, buffer);
	beg = next_invalid_char(end, nf);
	buffer.append(end, beg);
      } while(*beg!='\0');
      
      return buffer.c_str();      
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r14
callq 0x2e14
cmpb $0x0, (%rax)
je 0x2e06
movq %rax, %r12
leaq 0x90(%r14), %r15
movq 0x98(%r14), %rdx
movq %rax, %r8
subq %r13, %r8
movq %r15, %rdi
xorl %esi, %esi
movq %r13, %rcx
callq 0x2140
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x2eb0
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2f0c
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2e14
movq %rax, %r12
movq 0x98(%r14), %rsi
movq %rax, %r8
subq %r13, %r8
movq %r15, %rdi
xorl %edx, %edx
movq %r13, %rcx
callq 0x2140
cmpb $0x0, (%r12)
jne 0x2dac
movq (%r15), %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::next_invalid_char(char const*, UNF::Trie::NormalizationForm const&) const
const char* next_invalid_char(const char* src, const Trie::NormalizationForm& nf) const {
      int last_canonical_class = 0;
      const char* cur = Util::nearest_utf8_char_start_point(src);
      const char* starter = cur;
      
      for(; *cur != '\0'; cur = Util::nearest_utf8_char_start_point(cur+1)) {
	int canonical_class = ccc.get_class(cur);
	if(last_canonical_class > canonical_class && canonical_class != 0)
	  return starter;

	if(nf.quick_check(cur)==false)
	  return starter;

	if(canonical_class==0)
	  starter=cur;

	last_canonical_class = canonical_class;
      }
      return cur;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
decq %rbx
movb 0x1(%rbx), %al
incq %rbx
movl %eax, %ecx
andb $-0x40, %cl
negb %cl
jo 0x2e2b
testb %al, %al
je 0x2e9e
addq $0x78, %r15
xorl %ebp, %ebp
movq %rbx, %r12
movl %ebp, %r13d
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0x2f6e
movl %eax, %ebp
cmpl %eax, %r13d
setg %al
testl %ebp, %ebp
setne %cl
testb %cl, %al
jne 0x2e9e
movq %r14, %rdi
movq %r12, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2f6e
cmpl $-0x1, %eax
jne 0x2e9e
movq %r12, %rax
movb 0x1(%rax), %cl
incq %rax
movl %ecx, %edx
andb $-0x40, %dl
negb %dl
jo 0x2e80
testl %ebp, %ebp
cmoveq %r12, %rbx
movq %rax, %r12
testb %cl, %cl
jne 0x2e47
jmp 0x2ea1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/sile[P]unf/src/unf/normalizer.hh
// Function: UNF::Normalizer::next_valid_starter(char const*, UNF::Trie::NormalizationForm const&) const
const char* next_valid_starter(const char* src, const Trie::NormalizationForm& nf) const {
      const char* cur = Util::nearest_utf8_char_start_point(src+1);
      while(ccc.get_class(cur)!=0 || nf.quick_check(cur)==false)
	cur = Util::nearest_utf8_char_start_point(cur+1);
      return cur;
    }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movb 0x1(%rbx), %al
incq %rbx
andb $-0x40, %al
negb %al
jo 0x2ebe
addq $0x78, %r15
movq %r15, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2f6e
testl %eax, %eax
jne 0x2ef4
movq %r14, %rdi
movq %rbx, %rsi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2f6e
cmpl $-0x1, %eax
je 0x2f02
movb 0x1(%rbx), %al
incq %rbx
andb $-0x40, %al
negb %al
jo 0x2ef4
jmp 0x2ece
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop