LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb054
movq 0x8(%rdi), %rdx
movzbl (%rdx), %ecx
testb $0x1, 0x1(%rdi)
jne 0xb051
cmpl $0x0, 0x48(%rdi)
je 0xb00f
movl $0x0, 0x48(%rdi)
cmpq $0x2a, %rcx
je 0xb051
cmpl $0x5c, %ecx
jne 0xb05a
movl $0x104, %eax            # imm = 0x104
cmpl $0x1, %esi
je 0xb059
movzbl 0x1(%rdx), %ecx
cmpl $0x29, %ecx
je 0xb043
cmpl $0x28, %ecx
jne 0xb0c7
cmpb $0x0, 0x3a(%rdi)
je 0xb0c0
cmpl $0x29, %ecx
jne 0xb0c7
cmpb $0x0, 0x3a(%rdi)
jne 0xb0c7
cmpl $0x0, 0x34(%rdi)
jne 0xb0c7
jmp 0xb059
movl %ecx, %eax
retq
movl $0x103, %eax            # imm = 0x103
retq
cmpl $0x1, %esi
jne 0xb069
movl $0x105, %eax            # imm = 0x105
cmpb $0x24, %cl
je 0xb059
cmpl $0x29, %ecx
je 0xb084
cmpl $0x5e, %ecx
jne 0xb090
cmpb $0x0, 0x3a(%rdi)
jne 0xb07f
cmpq 0x18(%rdi), %rdx
je 0xb0fb
cmpl $0x29, %ecx
jne 0xb090
cmpb $0x0, 0x3a(%rdi)
je 0xb090
cmpl $0x0, 0x34(%rdi)
je 0xb0f5
leaq 0x8a69(%rip), %rax      # 0x13b00
movzbl (%rcx,%rax), %edx
movl %ecx, %eax
testq %rdx, %rdx
je 0xb059
movzbl 0x3a(%rdi), %eax
leaq (%rdx,%rdx), %rcx
shll $0x4, %edx
subq %rcx, %rdx
leaq 0x24b9(%rip), %rcx      # 0xd570
addq %rdx, %rcx
movswl 0x2(%rcx,%rax,4), %eax
retq
movl $0x1, 0x48(%rdi)
leaq 0x8a32(%rip), %rdx      # 0x13b00
movzbl (%rcx,%rdx), %ecx
testq %rcx, %rcx
je 0xb059
movzbl 0x3a(%rdi), %eax
leaq (%rcx,%rcx), %rdx
shll $0x4, %ecx
subq %rdx, %rcx
leaq 0x2484(%rip), %rdx      # 0xd570
addq %rcx, %rdx
movswl 0x4(%rdx,%rax,4), %eax
retq
movl $0x29, %eax
retq
movl $0x1, 0x48(%rdi)
movl $0x101, %eax            # imm = 0x101
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xba1f
movq %rsi, %r14
movb 0x8(%rbx), %al
testb %al, %al
je 0xba31
movb 0x8(%r14), %cl
testb %cl, %cl
je 0xba01
xorb $0x3, %al
xorb $0x3, %cl
orb %al, %cl
jne 0xba19
movl 0x18(%r14), %eax
addl 0x18(%rbx), %eax
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
ja 0xba19
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 0xb9fb
addl %esi, %ecx
movl %ecx, %edx
cmpl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
ja 0xba19
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 0xba42
testq %rbx, %rbx
je 0xba2d
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
xorl %ebx, %ebx
jmp 0xba42
testq %rbx, %rbx
je 0xba3f
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_O1/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 0xbee8
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x8(%rsi), %r14
movzbl 0x1(%r14), %ecx
cmpl %edi, %ecx
jne 0xbe49
cmpb $0x5d, 0x2(%r14)
jne 0xbe49
movzbl (%r14), %ecx
cmpl $0x3f, %ecx
je 0xbeda
cmpl $0x5b, %ecx
je 0xbeda
addq $0x3, %r14
movq %r14, 0x8(%rsi)
addl $-0x3, 0x10(%rsi)
movl %ecx, %eax
jmp 0xbeda
decq %rdx
movl $0x1, %r13d
movzbl (%r14,%r13), %ecx
cmpl %edi, %ecx
jne 0xbe63
cmpb $0x5d, 0x1(%r14,%r13)
je 0xbe71
incq %r13
decq %rdx
cmpq $0x1, %rdx
jg 0xbe52
jmp 0xbeda
movq %rsi, (%rsp)
leaq 0x7454(%rip), %rbx      # 0x132d0
xorl %ebp, %ebp
movq (%rbx), %r12
movq %r12, %rdi
callq 0x50d0
movq %rax, %r15
movslq %r15d, %rdx
cmpq %r13, %rdx
jne 0xbea3
movq %r12, %rdi
movq %r14, %rsi
callq 0x51a0
testl %eax, %eax
je 0xbeba
incq %rbp
addq $0x8, %rbx
cmpq $0x80, %rbp
jne 0xbe7e
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0xbeda
movslq %r15d, %rax
leaq (%rax,%r14), %rcx
addq $0x2, %rcx
movq (%rsp), %rdx
movq %rcx, 0x8(%rdx)
movl 0x10(%rdx), %ecx
subl %eax, %ecx
addl $-0x2, %ecx
movl %ecx, 0x10(%rdx)
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xbf81
cmpl $0x4, %ecx
je 0xbf90
movl $0x1, %eax
cmpl $0x5, %ecx
jne 0xbfae
movq 0x18(%rdi), %rax
movq %rsi, %rdi
movq %rax, %rsi
jmp 0x8996
pushq %rax
movb 0x20(%rdi), %cl
leaq 0x6(%rsp), %rax
movb %cl, (%rax)
movb $0x0, 0x1(%rax)
movq %rsi, %rdi
movq %rax, %rsi
callq 0x8996
addq $0x8, %rsp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movaps %xmm0, 0x20(%rdx)
movl $0x2, 0x4(%rdx)
movq (%rsi), %rdi
leaq 0x8(%rsp), %rcx
xorl %esi, %esi
callq 0x5450
testl %eax, %eax
je 0x5c39
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0x95ee(%rip), %rdx      # 0xf21f
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x5c8f
leaq 0x10(%rsp), %r14
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movw $0x0, 0x10(%r14)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x10(%rax), %esi
movl $0x1, (%rsp)
movq %r14, %rdx
movl $0x12, %ecx
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0x51f0
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %r14, %rdi
callq 0x5150
leaq (%rsp,%rax), %rdx
addq $0x10, %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x96ea
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe902(%rip), %r14      # 0x15fb8
leaq 0x7adc(%rip), %rsi      # 0xf199
movq %r14, %rdi
callq 0x5330
leaq 0x7b1e(%rip), %rsi      # 0xf1ea
movq %r14, %rdi
callq 0x5330
leaq 0x7b45(%rip), %rsi      # 0xf220
movq %r14, %rdi
callq 0x5330
leaq 0x7b94(%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_O1/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 0x7e8a(%rip), %rdi      # 0x16580
callq 0x5510
testl %eax, %eax
jne 0xe81b
movq 0x78ae(%rip), %rdi      # 0x15fb8
leaq 0x1553(%rip), %rsi      # 0xfc64
movl $0x3, %edx
callq 0x53d0
cmpl $-0x1, %r14d
je 0xe7b5
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 0x7d6f(%rip), %rcx      # 0x164c0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq 0x7857(%rip), %rdi      # 0x15fb8
callq 0x53d0
movq %rax, %r15
leaq 0x14f8(%rip), %rsi      # 0xfc68
movl $0x8, %edx
movq %rax, %rdi
callq 0x53d0
movq %r15, %rdi
movl %r14d, %esi
callq 0x55d0
movq %rax, %r14
leaq 0x14e1(%rip), %rsi      # 0xfc73
movl $0x1, %edx
movq %rax, %rdi
callq 0x53d0
movq 0x7dba(%rip), %rsi      # 0x16560
movq 0x7dbb(%rip), %rdx      # 0x16568
movq %r14, %rdi
callq 0x53d0
movq 0x77fc(%rip), %rdi      # 0x15fb8
leaq 0xb04(%rip), %rsi       # 0xf2c7
movl $0x1, %edx
callq 0x53d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x77dd(%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 0x7d6f(%rip), %rdi      # 0x16580
popq %rbx
popq %r14
popq %r15
jmp 0x5280
movl %eax, %edi
callq 0x5230
movq %rax, %rbx
leaq 0x7d54(%rip), %rdi      # 0x16580
callq 0x5280
movq %rbx, %rdi
callq 0x55f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d35(%rip), %rdi      # 0x16580
callq 0x5510
testl %eax, %eax
jne 0xe970
movq 0x7759(%rip), %rdi      # 0x15fb8
leaq 0x140b(%rip), %rsi      # 0xfc71
movl $0x3, %edx
callq 0x53d0
cmpl $-0x1, %r14d
je 0xe90a
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 0x7c1a(%rip), %rcx      # 0x164c0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq 0x7702(%rip), %rdi      # 0x15fb8
callq 0x53d0
movq %rax, %r15
leaq 0x13a3(%rip), %rsi      # 0xfc68
movl $0x8, %edx
movq %rax, %rdi
callq 0x53d0
movq %r15, %rdi
movl %r14d, %esi
callq 0x55d0
movq %rax, %r14
leaq 0x138c(%rip), %rsi      # 0xfc73
movl $0x1, %edx
movq %rax, %rdi
callq 0x53d0
movq 0x7c65(%rip), %rsi      # 0x16560
movq 0x7c66(%rip), %rdx      # 0x16568
movq %r14, %rdi
callq 0x53d0
movq 0x76a7(%rip), %rdi      # 0x15fb8
leaq 0x9af(%rip), %rsi       # 0xf2c7
movl $0x1, %edx
callq 0x53d0
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0x7688(%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 0x7c1a(%rip), %rdi      # 0x16580
popq %rbx
popq %r14
popq %r15
jmp 0x5280
movl %eax, %edi
callq 0x5230
movq %rax, %rbx
leaq 0x7bff(%rip), %rdi      # 0x16580
callq 0x5280
movq %rbx, %rdi
callq 0x55f0
// File: /workspace/github_cpp_makefile_star2_O1/tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: Undo()
void Undo()
{
	if(lastChanged != NULL)
	{
		*lastChanged = undoValue;
		lastChanged = NULL;
		undoValue = 0.0f;
	}
}

// Assembly:
movq 0xbe58(%rip), %rax      # 0xe5f0
testq %rax, %rax
je 0x27be
movss 0xbe53(%rip), %xmm0     # 0xe5f8
movss %xmm0, (%rax)
movq $0x0, 0xbe3c(%rip) # 0xe5f0
movl $0x0, 0xbe3a(%rip)      # 0xe5f8
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9350
movl %eax, %ebp
testb %al, %al
je 0x3ed3
leaq 0xa7b8(%rip), %rax      # 0xe67f
cmpb $0x1, (%rax)
jne 0x3ed3
movl %r13d, 0x93bd(%rip)     # 0xd290
cmpl %r13d, 0x93b6(%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 0x902a
movl %r15d, %edi
movl %r14d, %esi
movl $0x64, %edx
movl $0x11, %ecx
movl %r13d, %r8d
callq 0x902a
addl $0x5, %r15d
addl $0x5, %r14d
leaq 0x937a(%rip), %rdi      # 0xd2c8
movl %r15d, %esi
movl %r14d, %edx
movl %r12d, %ecx
movq (%rsp), %r8
xorl %eax, %eax
callq 0x926a
testb %bl, %bpl
je 0x3f75
leaq 0xa70e(%rip), %rcx      # 0xe67c
movb $0x1, %al
cmpb $0x1, (%rcx)
jne 0x3f77
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_O1/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 0x9350
testb %al, %al
je 0x3fc7
leaq 0xa6c3(%rip), %rcx      # 0xe67f
cmpb $0x1, (%rcx)
jne 0x3fc7
movl %ebp, 0x92c9(%rip)      # 0xd290
cmpl %ebp, 0x92c3(%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 0x902a
movl %r15d, %edi
movl %r14d, %esi
movl %r13d, %edx
movl %r12d, %ecx
movl %ebp, %r8d
callq 0x902a
addl $0x5, %r15d
addl $0x5, %r14d
leaq 0x9287(%rip), %rdi      # 0xd2c8
movl %r15d, %esi
movl %r14d, %edx
movl %ebx, %ecx
movq 0x10(%rsp), %r8
xorl %eax, %eax
callq 0x926a
movb 0xe(%rsp), %al
testb %al, 0xf(%rsp)
je 0x406d
leaq 0xa616(%rip), %rcx      # 0xe67c
movb $0x1, %al
cmpb $0x1, (%rcx)
jne 0x406f
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_O1/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 0x7850
testb %al, %al
jne 0x7475
movl $0xd, %edi
callq 0x7850
testb %al, %al
je 0x7490
cmpb $0x0, 0x719c(%rip)      # 0xe618
jne 0x74d7
xorl %edi, %edi
callq 0x2e5c
movb $0x1, 0x6018(%rip)      # 0xd4a4
movb $0x1, %al
jmp 0x74d1
movl $0x7a, %edi
callq 0x7850
testb %al, %al
je 0x74cf
movq 0x714b(%rip), %rcx      # 0xe5f0
movb $0x1, %al
testq %rcx, %rcx
je 0x74d1
movss 0x7144(%rip), %xmm0     # 0xe5f8
movss %xmm0, (%rcx)
movq $0x0, 0x712d(%rip) # 0xe5f0
movl $0x0, 0x712b(%rip)      # 0xe5f8
jmp 0x74d1
xorl %eax, %eax
movb %al, 0x7141(%rip)       # 0xe618
callq 0x407e
movl $0x5, %edi
callq 0x21a0
movb $0x1, %al
popq %rcx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x5deb(%rip)      # 0xd4a4
jne 0x76c4
cmpb $0x0, 0x6f46(%rip)      # 0xe608
je 0x76db
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 0x32c4
incl %ebp
cmpl $0x3, %ebp
jb 0x7752
leal -0x1(%r14), %eax
movss 0x2926(%rip), %xmm0     # 0xa044
movss 0x28ea(%rip), %xmm1     # 0xa010
movss 0x2996(%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 0x772e
movq %r15, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6dd7(%rip), %rdi      # 0xe66c
movl 0x6dd1(%rip), %eax      # 0xe66c
movl %eax, 0x6dd3(%rip)      # 0xe674
leaq 0x6dc8(%rip), %rsi      # 0xe670
movl 0x6dc2(%rip), %eax      # 0xe670
movl %eax, 0x6dc4(%rip)      # 0xe678
callq 0x2420
movb 0x6dbd(%rip), %dl       # 0xe67c
movb 0x6db7(%rip), %sil      # 0xe67d
movb 0x6db2(%rip), %cl       # 0xe67e
movl %eax, %edi
andb $0x1, %dil
movb %dil, 0x6da3(%rip)      # 0xe67c
movl %eax, %r8d
shrb $0x2, %r8b
andb $0x1, %r8b
movb %r8b, 0x6d92(%rip)      # 0xe67d
shrb %al
andb $0x1, %al
movb %al, 0x6d89(%rip)       # 0xe67e
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, 0x6d65(%rip)       # 0xe67f
movb %sil, 0x6d5f(%rip)      # 0xe680
xorb $0x1, %cl
movzbl %cl, %ecx
testb %al, %al
cmovel %r9d, %ecx
movb %cl, 0x6d4e(%rip)       # 0xe681
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6d4b(%rip), %rdi      # 0xe688
testb $0x2, (%rdi)
je 0x794b
callq 0x2380
testl %eax, %eax
js 0x7988
movq 0x6d36(%rip), %rcx      # 0xe688
movq 0x8(%rcx), %rax
xorl %edx, %edx
cmpb $0x20, 0x10(%rax)
movl 0x18(%rcx), %eax
sete %dl
leal 0x2(,%rdx,2), %esi
cltd
idivl %esi
movl %eax, 0x6cf6(%rip)      # 0xe668
movq 0x20(%rcx), %rax
movq %rax, 0x6ce3(%rip)      # 0xe660
movq %rax, 0x6cd4(%rip)      # 0xe658
movb $0x1, %al
popq %rcx
retq
xorl %eax, %eax
jmp 0x7986
// File: /workspace/github_cpp_makefile_star2_O1/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, 0x6cc4(%rip)      # 0xe690
movq %rax, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0x1, %edx
callq 0x2060
movq %rax, 0x6cb3(%rip)      # 0xe698
movq 0x6ca4(%rip), %rdi      # 0xe690
movq %rbx, %rsi
callq 0x2490
movq 0x6c95(%rip), %rdi      # 0xe690
callq 0x2360
movq %rax, 0x6c81(%rip)      # 0xe688
testq %rax, %rax
je 0x7a0e
popq %rbx
retq
callq 0x21b0
movq 0x55b6(%rip), %rdi      # 0xcfd0
movq %rax, %rsi
callq 0x2270
movq %rax, %rdi
callq 0x2140
movl $0x1, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8994
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0x7cf1
movq (%rbx), %r15
xorl %r12d, %r12d
movzbl (%r15,%r12), %edi
callq 0x24d0
movb %al, (%r15,%r12)
incq %r12
cmpq %r12, %r14
jne 0x7cdb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7d4a
movq (%r14), %rdi
leaq 0x242c(%rip), %rsi      # 0xa15f
callq 0x2310
testq %rax, %rax
setne %bl
je 0x7d4a
movq %rax, %rdi
callq 0x2280
movb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x217a(%rip), %rsi      # 0xa50b
leaq 0x2174(%rip), %rdx      # 0xa50c
leaq 0x28(%rsp), %rdi
callq 0x7794
leaq 0x60(%rsp), %rdi
leaq 0x28(%rsp), %rsi
xorl %edx, %edx
movl $0x1, %ecx
callq 0x7a5c
leaq 0x10(%rsp), %r14
leaq 0x60(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x8cd4
movq %r15, %rdi
callq 0x894e
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x83ec
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x22a0
movq 0x10(%rsp), %r12
cmpq %r14, %r12
je 0x842e
leaq 0x2108(%rip), %r15      # 0xa505
leaq 0x10(%r12), %rdi
movl $0x5, %ecx
movq %r15, %rsi
xorl %edx, %edx
callq 0x2470
movq (%r12), %r13
cmpq $-0x1, %rax
jne 0x8426
movq %r14, %rdi
movq %r12, %rsi
callq 0x8d3e
movq %r13, %r12
cmpq %r14, %r13
jne 0x83fd
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 0x84b2
movq %r12, %rdi
callq 0x2170
movl 0x28(%rsp), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x846d
cmpl $0x100, %eax            # imm = 0x100
jne 0x8481
jmp 0x84d1
leaq 0x61b4(%rip), %rdi      # 0xe628
leaq 0x3c(%rsp), %rsi
callq 0x8628
movb $0x1, (%rax)
callq 0x788d
movq %r15, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r14, %rcx
movl %ebp, %r8d
callq 0x800d
movl $0x5, %edi
callq 0x21a0
movq 0x61e5(%rip), %rdi      # 0xe690
callq 0x22f0
jmp 0x844a
movb 0xf(%rsp), %bl
leaq 0x10(%rsp), %rdi
callq 0x894e
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 0x84f9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x22a0
jmp 0x84f9
jmp 0x84f6
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x894e
movq %rbx, %rdi
callq 0x24a0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x859d
leaq 0x2017(%rip), %rdi      # 0xa544
leaq 0x1c28(%rip), %rsi      # 0xa15c
callq 0x2110
movq %rax, %rdi
movl $0x1, %esi
callq 0x2230
testq %rax, %rax
jne 0x856b
leaq 0x2008(%rip), %rdi      # 0xa55a
leaq 0x1c03(%rip), %rsi      # 0xa15c
callq 0x2110
movq %rax, %rdi
movl $0x1, %esi
callq 0x2230
testq %rax, %rax
je 0x857f
movq 0x6119(%rip), %rdi      # 0xe690
movq %rax, %rsi
callq 0x2300
leaq -0x7b(%rip), %rdi       # 0x850b
callq 0x9390
leaq 0x6096(%rip), %rdi      # 0xe628
callq 0x8d74
popq %rax
jmp 0x74ea
callq 0x254a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x606c(%rip), %r15      # 0xe628
movq %r14, %rdi
callq 0x2170
movl 0x8(%rsp), %eax
cmpl $0x300, %eax            # imm = 0x300
je 0x85d8
cmpl $0x100, %eax            # imm = 0x100
jne 0x85e6
jmp 0x860c
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8628
movb $0x1, (%rax)
callq 0x788d
callq 0x7458
testb %al, %al
je 0x8602
movq 0x6095(%rip), %rdi      # 0xe690
callq 0x22f0
jmp 0x85bc
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
xorl %edi, %edi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5683(%rip), %rax      # 0xe658
movq (%rax), %rax
addq $0x1c, %rax
xorl %ecx, %ecx
leaq 0x5683(%rip), %rdx      # 0xe668
movl (%rdx), %esi
imull %ecx, %esi
movslq %esi, %rsi
leaq (%rax,%rsi,4), %rsi
movl $0xfffffff8, %r8d       # imm = 0xFFFFFFF8
movl %edi, -0x1c(%rsi)
movl %edi, -0x18(%rsi)
movl %edi, -0x14(%rsi)
movl %edi, -0x10(%rsi)
movl %edi, -0xc(%rsi)
movl %edi, -0x8(%rsi)
movl %edi, -0x4(%rsi)
movl %edi, (%rsi)
addq $0x20, %rsi
addl $0x8, %r8d
cmpl $0x278, %r8d            # imm = 0x278
jb 0x8ff7
incl %ecx
cmpl $0x1e0, %ecx            # imm = 0x1E0
jne 0x8fe5
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x90ed
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
addl %esi, %ecx
leal -0x8(%rdx), %eax
leaq 0x5612(%rip), %r9       # 0xe658
movq (%r9), %r9
leal -0x9(%rdx), %r10d
andl $-0x8, %r10d
addl $0x8, %r10d
leaq 0x1c(%r9), %r11
leaq 0x5608(%rip), %rbx      # 0xe668
movl (%rbx), %r14d
imull %esi, %r14d
cmpl $0x9, %edx
jge 0x9073
addl %edi, %r14d
xorl %ebp, %ebp
jmp 0x90bd
leal (%r14,%rdi), %ebp
movslq %ebp, %r15
leaq (%r11,%r15,4), %r12
xorl %r15d, %r15d
movl %r8d, -0x1c(%r12,%r15,4)
movl %r8d, -0x18(%r12,%r15,4)
movl %r8d, -0x14(%r12,%r15,4)
movl %r8d, -0x10(%r12,%r15,4)
movl %r8d, -0xc(%r12,%r15,4)
movl %r8d, -0x8(%r12,%r15,4)
movl %r8d, -0x4(%r12,%r15,4)
movl %r8d, (%r12,%r15,4)
addq $0x8, %r15
cmpl %eax, %r15d
jl 0x9081
addl %edi, %r15d
addl %r14d, %r15d
movl %r15d, %r14d
movl %r10d, %ebp
movl %edx, %r15d
subl %ebp, %r15d
jle 0x90db
movslq %r14d, %r14
leaq (%r9,%r14,4), %r14
xorl %r12d, %r12d
movl %r8d, (%r14,%r12,4)
incq %r12
cmpl %r12d, %r15d
jne 0x90cf
incl %esi
cmpl %ecx, %esi
jl 0x9060
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x902a
leal (%r12,%r13), %esi
testl %r13d, %r13d
jle 0x9141
leaq 0x5538(%rip), %rax      # 0xe658
movq (%rax), %rax
leaq 0x553e(%rip), %rcx      # 0xe668
movl %r12d, %edx
movl (%rcx), %edi
imull %edx, %edi
addl %r15d, %edi
movslq %edi, %rdi
movl %ebx, (%rax,%rdi,4)
incl %edx
cmpl %esi, %edx
jl 0x912d
testl %r13d, %r13d
jle 0x9171
leal (%r14,%r15), %eax
leaq 0x5507(%rip), %rcx      # 0xe658
movq (%rcx), %rcx
leaq 0x550d(%rip), %rdx      # 0xe668
movl (%rdx), %edi
imull %r12d, %edi
addl %eax, %edi
movslq %edi, %rdi
movl %ebx, (%rcx,%rdi,4)
incl %r12d
cmpl %esi, %r12d
jl 0x915b
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 0x902a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9269
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %rax
xorl %r9d, %r9d
leaq 0x54b9(%rip), %r10      # 0xe668
leaq 0x54a2(%rip), %r11      # 0xe658
movl 0x8(%rdi), %r15d
movl 0x10(%rdi), %r14d
movl %r15d, %ebp
imull %ecx, %ebp
movl (%r10), %ebx
cmpl $0x1000000, %r8d        # imm = 0x1000000
jae 0x9211
testl %r15d, %r15d
jle 0x9252
imull %r9d, %r14d
addl %r14d, %ebp
movslq %ebp, %r14
leaq (%rax,%r14,4), %r14
imull %edx, %ebx
addl %esi, %ebx
movslq %ebx, %rbx
shlq $0x2, %rbx
addq (%r11), %rbx
xorl %r15d, %r15d
cmpl $0x300030, (%r14,%r15,4) # imm = 0x300030
je 0x9203
movl %r8d, (%rbx,%r15,4)
incq %r15
movslq 0x8(%rdi), %r12
cmpq %r12, %r15
jl 0x91f5
jmp 0x9252
testl %r15d, %r15d
jle 0x9252
imull %r9d, %r14d
addl %r14d, %ebp
movslq %ebp, %r14
leaq (%rax,%r14,4), %r14
imull %edx, %ebx
addl %esi, %ebx
movslq %ebx, %rbx
shlq $0x2, %rbx
addq (%r11), %rbx
xorl %r15d, %r15d
movl (%r14,%r15,4), %ebp
cmpl $0x300030, %ebp         # imm = 0x300030
je 0x9246
movl %ebp, (%rbx,%r15,4)
incq %r15
movslq 0x8(%rdi), %r12
cmpq %r12, %r15
jl 0x9236
incl %r9d
incl %edx
cmpl 0xc(%rdi), %r9d
jl 0x91b6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x92c9
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 0x2130
movq %r12, %rdi
callq 0x2120
movq %rax, %r12
testl %r12d, %r12d
jle 0x933e
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
xorl %r13d, %r13d
movsbl 0xd0(%rsp,%r13), %ecx
addl $-0x20, %ecx
movq %r15, %rdi
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %r8d
callq 0x9190
incq %r13
addl $0x8, %r14d
cmpq %r13, %r12
jne 0x9316
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rdi, %rdx
callq 0x2d6e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x23c9
movq (%r14), %rax
movq 0x20(%rax), %rsi
movq 0x40(%rax), %r15
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x2d6e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x23c9
movq (%r14), %rax
movq 0x40(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x2d6e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x23c9
movq (%r14), %rax
movq 0x60(%rax), %rsi
movq 0x80(%rax), %r15
movq %rbx, %rdi
movq %rbx, %rdx
callq 0x2d6e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
je 0x23d1
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
movq (%r14), %rax
movq 0x80(%rax), %r14
movq %rbx, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x2d6e
movq %r14, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
sete %al
jmp 0x23cb
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x80(%rax), %r12
leaq 0x18(%rdi), %r14
movq %r14, %rdx
callq 0x2d6e
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x24a9
movq (%r15), %rax
movq 0x20(%rax), %rsi
movq 0x80(%rax), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d6e
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x24a9
movq (%r15), %rax
movq 0x40(%rax), %rsi
movq 0x80(%rax), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d6e
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x24a9
movq (%r15), %rax
movq 0x60(%rax), %rsi
movq 0x80(%rax), %r12
movq %rbx, %rdi
movq %r14, %rdx
callq 0x2d6e
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
je 0x24b7
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r15), %rax
movq 0x80(%rax), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2d6e
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
sete %al
jmp 0x24ab
// File: /workspace/github_cpp_makefile_star2_O1/sile[P]unf/src/unf/unf-test.cc
// Function: nfc_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 nfc_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfc, ary[1], ary[0]) &&
    NF_TEST(norm.nfc, ary[1], ary[1]) &&
    NF_TEST(norm.nfc, ary[1], ary[2]) &&
    NF_TEST(norm.nfc, ary[3], ary[3]) &&
    NF_TEST(norm.nfc, ary[3], ary[4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x20(%rax), %r12
leaq 0x48(%rdi), %r14
movq %r14, %rdx
movq %rdi, %rcx
callq 0x33ca
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x258d
movq (%r15), %rax
movq 0x20(%rax), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33ca
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x258d
movq (%r15), %rax
movq 0x20(%rax), %r12
movq 0x40(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33ca
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x258d
movq (%r15), %rax
movq 0x60(%rax), %r12
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33ca
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
je 0x259b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq (%r15), %rax
movq 0x60(%rax), %r15
movq 0x80(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x33ca
movq %r15, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
sete %al
jmp 0x258f
// File: /workspace/github_cpp_makefile_star2_O1/sile[P]unf/src/unf/unf-test.cc
// Function: nfkc_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 nfkc_test(UNF::Normalizer& norm, const std::vector<std::string>& ary) {
  return 
    NF_TEST(norm.nfkc, ary[3], ary[0]) &&
    NF_TEST(norm.nfkc, ary[3], ary[1]) &&
    NF_TEST(norm.nfkc, ary[3], ary[2]) &&
    NF_TEST(norm.nfkc, ary[3], ary[3]) &&
    NF_TEST(norm.nfkc, ary[3], ary[4]);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r12
movq %rdi, %rbx
movq (%rsi), %rax
movq (%rax), %rsi
movq 0x60(%rax), %r13
leaq 0x60(%rdi), %r14
leaq 0x18(%rdi), %r15
movq %r14, %rdx
movq %r15, %rcx
callq 0x33ca
movq %r13, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x267e
movq (%r12), %rax
movq 0x20(%rax), %rsi
movq 0x60(%rax), %r13
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x33ca
movq %r13, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x267e
movq (%r12), %rax
movq 0x40(%rax), %rsi
movq 0x60(%rax), %r13
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x33ca
movq %r13, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
jne 0x267e
movq (%r12), %rax
movq 0x60(%rax), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0x33ca
movq %r13, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
je 0x268a
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq (%r12), %rax
movq 0x60(%rax), %r12
movq 0x80(%rax), %rsi
movq %rbx, %rdi
movq %r14, %rdx
movq %r15, %rcx
callq 0x33ca
movq %r12, %rdi
movq %rax, %rsi
callq 0x2160
testl %eax, %eax
sete %al
jmp 0x2680
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2c7d
movl %edx, %eax
leaq 0x13ba(%rip), %rcx      # 0x4004
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rdi, %rdx
jmp 0x2d6e
leaq 0x18(%rdi), %rdx
jmp 0x2d6e
leaq 0x60(%rdi), %rdx
leaq 0x18(%rdi), %rcx
jmp 0x33ca
leaq 0x48(%rdi), %rdx
movq %rdi, %rcx
jmp 0x33ca
movq %rsi, %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2e16
cmpb $0x0, (%rax)
je 0x2e08
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 0x2ed4
movq %rax, %r13
movq %r14, %rdi
movq %r12, %rsi
movq %rax, %rdx
movq %rbx, %rcx
movq %r15, %r8
callq 0x2f30
movq %r14, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x2e16
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 0x2dae
movq (%r15), %r13
movq %r13, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop