LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Subexp::stat(Cenv*)
Stat Subexp::stat(Cenv *env)
{
	Stat st = rex->stat(env);
	if(env->backref & 1<<n)     // sole reason stat() has env param
		used = 1;
	if(++st.p <= 0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x58(%rbp), %rcx
movq %rdx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movw -0x34(%rbp), %ax
movw %ax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movswl 0x38(%rax), %eax
movswl 0x18(%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
andl %ecx, %eax
cmpl $0x0, %eax
je 0xd38f
movq -0x58(%rbp), %rax
movb $0x1, 0x1a(%rax)
movb -0x24(%rbp), %al
addb $0x1, %al
movb %al, -0x24(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
jg 0xd3a9
movzbl -0x23(%rbp), %eax
orl $0x1, %eax
movb %al, -0x23(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xd140
movq %rdx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x4a(%rbp), %rcx
movq %rcx, -0xa(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Alt::stat(Cenv*)
Stat Alt::stat(Cenv *env)
{
	Stat st1 = left->stat(env);
	Stat st2 = right->stat(env);
	Stat st = addStat(st1, st2);
	st.n = st1.n<=st2.n? st1.n: st2.n;
	if(++st.a <= 0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rax, %rcx
movq -0x98(%rbp), %rax
movq %rdx, -0x38(%rbp)
movq %rcx, -0x40(%rbp)
movq -0x40(%rbp), %rcx
movq -0x3a(%rbp), %rdx
movq %rdx, -0x2a(%rbp)
movq %rcx, -0x30(%rbp)
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rdx, -0x58(%rbp)
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
movq -0x5a(%rbp), %rcx
movq %rcx, -0x4a(%rbp)
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xd520
movq %rdx, -0x78(%rbp)
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rax
movq %rax, -0x70(%rbp)
movl -0x78(%rbp), %eax
movl %eax, -0x68(%rbp)
movw -0x74(%rbp), %ax
movw %ax, -0x64(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x50(%rbp), %eax
jg 0xd4a8
movl -0x30(%rbp), %eax
movl %eax, -0x9c(%rbp)
jmp 0xd4b1
movl -0x50(%rbp), %eax
movl %eax, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
movl %eax, -0x70(%rbp)
movl -0x68(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x68(%rbp)
cmpl $0x0, %eax
jg 0xd4d2
movzbl -0x63(%rbp), %eax
orl $0x1, %eax
movb %al, -0x63(%rbp)
movq -0x98(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
leaq -0x70(%rbp), %rdi
callq 0xd140
movq %rdx, -0x88(%rbp)
movq %rax, -0x90(%rbp)
movq -0x90(%rbp), %rax
movq -0x8a(%rbp), %rcx
movq %rcx, -0xa(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0xa0, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: addStat(Stat&, Stat&)
static Stat addStat(Stat &st1, Stat &st2)
{	
	Stat st = st1;
	st.n += st2.n;
	st.s += st2.s;
	st.c += st2.c;
	st.b += st2.b;
	st.a += st2.a;
	st.p += st2.p;
	st.t += st2.t;
	if(st.n<st1.n || st.c<st1.c || st.b<st1.b ||
	   st.a<st1.a || st.p<st1.p || st.t<st1.t)
		st.o |= 1;
	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x10(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x4(%rax), %ecx
movzbl -0xc(%rbp), %eax
addl %ecx, %eax
movb %al, -0xc(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x5(%rax), %ecx
movzbl -0xb(%rbp), %eax
addl %ecx, %eax
movb %al, -0xb(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x6(%rax), %ecx
movzbl -0xa(%rbp), %eax
addl %ecx, %eax
movb %al, -0xa(%rbp)
movq -0x20(%rbp), %rax
movl 0x8(%rax), %eax
addl -0x8(%rbp), %eax
movl %eax, -0x8(%rbp)
movq -0x20(%rbp), %rax
movzbl 0xc(%rax), %ecx
movzbl -0x4(%rbp), %eax
addl %ecx, %eax
movb %al, -0x4(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x7(%rax), %ecx
movzbl -0x9(%rbp), %eax
addl %ecx, %eax
movb %al, -0x9(%rbp)
movl -0x10(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jl 0xd604
movzbl -0xb(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
cmpl %ecx, %eax
jl 0xd604
movzbl -0xa(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
cmpl %ecx, %eax
jl 0xd604
movl -0x8(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jl 0xd604
movzbl -0x4(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0xc(%rcx), %ecx
cmpl %ecx, %eax
jl 0xd604
movzbl -0x9(%rbp), %eax
movq -0x18(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
cmpl %ecx, %eax
jge 0xd60e
movzbl -0x3(%rbp), %eax
orl $0x1, %eax
movb %al, -0x3(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
popq %rbp
retq
nopl (%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Rep::stat(Cenv*)
Stat Rep::stat(Cenv *env)
{
	Stat st = rex->stat(env);
	if(st.n == 1 && st.c+st.b == 0)
		st.s++;
	st.c++;
	st.n *= lo;
	if(st.n<0 || st.c<=0)
		st.o |= 1;
	return addStat(st, next, env);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movq 0x28(%rax), %rdi
movq -0x20(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq %rdx, -0x38(%rbp)
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movw -0x34(%rbp), %ax
movw %ax, -0x24(%rbp)
cmpl $0x1, -0x30(%rbp)
jne 0xd744
movzbl -0x2b(%rbp), %eax
movzbl -0x2a(%rbp), %ecx
addl %ecx, %eax
cmpl $0x0, %eax
jne 0xd744
movb -0x2c(%rbp), %al
addb $0x1, %al
movb %al, -0x2c(%rbp)
movq -0x58(%rbp), %rax
movb -0x2b(%rbp), %cl
addb $0x1, %cl
movb %cl, -0x2b(%rbp)
movl 0x18(%rax), %eax
imull -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x30(%rbp)
jl 0xd76a
movzbl -0x2b(%rbp), %eax
cmpl $0x0, %eax
jg 0xd774
movzbl -0x23(%rbp), %eax
orl $0x1, %eax
movb %al, -0x23(%rbp)
movq -0x58(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x20(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0xd140
movq %rdx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movq -0x4a(%rbp), %rcx
movq %rcx, -0xa(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Trie::stat(Cenv*)
Stat Trie::stat(Cenv *env)
{
	Stat st;
	st.n = min;
	if(min == max)
		return st;
	if(++st.t <= 0)
		st.o |= 1;
	return st;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x10140
movq -0x28(%rbp), %rcx
movl 0x18(%rcx), %eax
movl %eax, -0x10(%rbp)
movl 0x18(%rcx), %eax
cmpl 0x1c(%rcx), %eax
jne 0xd8d5
jmp 0xd8f1
movb -0x9(%rbp), %al
addb $0x1, %al
movb %al, -0x9(%rbp)
movzbl %al, %eax
cmpl $0x0, %eax
jg 0xd8ef
movzbl -0x3(%rbp), %eax
orl $0x1, %eax
movb %al, -0x3(%rbp)
jmp 0xd8f1
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: hard(Stat*)
int hard(Stat *stat)
{
	if(stat->a | stat->b)
		return HARD;
	else if(stat->t <=1 && stat->c == 0)
		return EASY;
	else if(stat->t)
		return HARD;
	else if(stat->c<=1 || stat->s==stat->c)
		return EASY;
	else
		return HARD;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
orl %ecx, %eax
cmpl $0x0, %eax
je 0xd927
movl $0x800, -0x4(%rbp)      # imm = 0x800
jmp 0xd98e
movq -0x10(%rbp), %rax
movzbl 0x7(%rax), %eax
cmpl $0x1, %eax
jg 0xd94a
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x0, %eax
jne 0xd94a
movl $0x0, -0x4(%rbp)
jmp 0xd98e
movq -0x10(%rbp), %rax
cmpb $0x0, 0x7(%rax)
je 0xd95d
movl $0x800, -0x4(%rbp)      # imm = 0x800
jmp 0xd98e
movq -0x10(%rbp), %rax
movzbl 0x5(%rax), %eax
cmpl $0x1, %eax
jle 0xd97e
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
cmpl %ecx, %eax
jne 0xd987
movl $0x0, -0x4(%rbp)
jmp 0xd98e
movl $0x800, -0x4(%rbp)      # imm = 0x800
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Alt::serialize(int)
int Alt::serialize(int n)
{
	serial = n++;
	n = left->serialize(n);
	rserial = n++;
	n = right->serialize(n);
	return next? next->serialize(n): n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movw %cx, 0xa(%rax)
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movl %ecx, 0x30(%rax)
movq 0x28(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xdaed
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x1c(%rbp)
jmp 0xdaf3
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: Conj::serialize(int)
int Conj::serialize(int n)
{
	serial = n++;
	n = left->serialize(n);
	n = right->serialize(n);
	return next? next->serialize(n): n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0xc(%rbp)
movw %cx, 0xa(%rax)
movq 0x18(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
movq 0x20(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, -0xc(%rbp)
cmpq $0x0, 0x10(%rax)
je 0xdb6f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movl -0xc(%rbp), %esi
movq (%rdi), %rax
callq *0x18(%rax)
movl %eax, -0x1c(%rbp)
jmp 0xdb75
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe660
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0xa639(%rip), %rax      # 0x18510
jne 0xdee6
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe049
movq -0x18(%rbp), %rdi
callq 0xe7c0
cmpl $0x10e, %eax            # imm = 0x10E
je 0xdf03
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe049
jmp 0xdf05
movq -0x18(%rbp), %rdi
callq 0x10610
movl -0xc(%rbp), %edi
movq -0x18(%rbp), %rsi
callq 0xdeb0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0xa5e7(%rip), %rax      # 0x18510
jne 0xdf50
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xdf43
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe049
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0xe4c0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq 0xa5a0(%rip), %rax      # 0x18510
je 0xdf7f
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe049
movq -0x20(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
je 0xdf99
movq -0x28(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xdf9b
jmp 0xe00e
movl $0x38, %edi
callq 0x51a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movl -0xc(%rbp), %esi
movq -0x18(%rbp), %rax
movl 0x30(%rax), %edx
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %r8
callq 0x10650
jmp 0xdfc8
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0xd030
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpq 0xa52c(%rip), %rax      # 0x18510
je 0xe00c
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe049
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x38, %esi
callq 0x51b0
jmp 0xe053
jmp 0xe00e
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xe026
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x28(%rbp), %rax
movq %rax, -0x60(%rbp)
cmpq $0x0, %rax
je 0xe03e
movq -0x60(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0xa4cb(%rip), %rax      # 0x18510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x52d0
nopl (%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: regerror(int, regex_t const*, char*, unsigned long)
size_t
regerror(int errcode, const regex_t*, char *errbuf, size_t errbuf_size)
{
	if(errbuf_size == 0)
		return 0;
	const char *s = "unknown error";
	switch(errcode) {
	case 0:
		s = "success";
		break;
	case REG_NOMATCH:
		s = "no match";
		break;
	case REG_ESPACE:
		s = "out of space";
		break;
	case REG_BADPAT:
	case REG_ECOLLATE:
	case REG_ECTYPE:
	case REG_EESCAPE:
	case REG_ESUBREG:
	case REG_EBRACK:
	case REG_EPAREN:
	case REG_EBRACE:
	case REG_BADBR:
	case REG_ERANGE:
	case REG_BADRPT:
		s = "improper regular expression";
		break;
	}
	strncpy(errbuf, s, errbuf_size);
	errbuf[errbuf_size-1] = 0;
	return 1+strlen(errbuf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0xe32b
movq $0x0, -0x8(%rbp)
jmp 0xe3bb
leaq 0x36eb(%rip), %rax      # 0x11a1d
movq %rax, -0x30(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0xd, %rax
ja 0xe389
movq -0x38(%rbp), %rax
leaq 0x336e(%rip), %rcx      # 0x116bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x36cd(%rip), %rax      # 0x11a2b
movq %rax, -0x30(%rbp)
jmp 0xe389
leaq 0x36c8(%rip), %rax      # 0x11a33
movq %rax, -0x30(%rbp)
jmp 0xe389
leaq 0x2cf4(%rip), %rax      # 0x1106c
movq %rax, -0x30(%rbp)
jmp 0xe389
leaq 0x36b7(%rip), %rax      # 0x11a3c
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x5100
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movb $0x0, (%rax,%rcx)
movq -0x20(%rbp), %rdi
callq 0x50d0
addq $0x1, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %esi
leaq -0x78(%rbp), %rdi
callq 0x101b0
movq -0x20(%rbp), %rax
cmpq 0xa0fa(%rip), %rax      # 0x18510
je 0xe43b
movq -0x20(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe43b
movq -0x28(%rbp), %rax
cmpq 0xa0e2(%rip), %rax      # 0x18510
je 0xe43b
movq -0x28(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xe444
movl $0x0, -0x4(%rbp)
jmp 0xe4ac
movq -0x28(%rbp), %rdi
movq -0x20(%rbp), %rsi
leaq -0x78(%rbp), %rdx
callq 0xe4c0
movq %rax, -0x80(%rbp)
cmpq $0x0, -0x80(%rbp)
jne 0xe469
movl $0x0, -0x4(%rbp)
jmp 0xe4ac
movq -0x80(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x10(%rax), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0xe496
movq -0x10(%rbp), %rax
movl 0x10(%rax), %ecx
andl $0xffffefff, %ecx       # imm = 0xFFFFEFFF
movl %ecx, 0x10(%rax)
movq 0xa073(%rip), %rcx      # 0x18510
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe500
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
jne 0xe500
movq -0x10(%rbp), %rdi
callq 0x10040
cmpl $0x0, %eax
jne 0xe510
movq 0xa009(%rip), %rax      # 0x18510
movq %rax, -0x8(%rbp)
jmp 0xe644
movq -0x18(%rbp), %rdi
callq 0x10040
cmpl $0x0, %eax
je 0xe59c
movl $0x820, %edi            # imm = 0x820
callq 0x51a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x10ad0
jmp 0xe539
movq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0xd030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x9fbb(%rip), %rax      # 0x18510
jne 0xe586
movq 0x9fb2(%rip), %rax      # 0x18510
movq %rax, -0x8(%rbp)
jmp 0xe644
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x820, %esi            # imm = 0x820
callq 0x51b0
jmp 0xe64e
movq -0x18(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x100b0
cmpl $0x0, %eax
je 0xe59a
jmp 0xe615
jmp 0xe5bb
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x6, %eax
je 0xe5b9
movq 0x9f60(%rip), %rax      # 0x18510
movq %rax, -0x8(%rbp)
jmp 0xe644
jmp 0xe5bb
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x100b0
cmpl $0x0, %eax
je 0xe5cf
jmp 0xe615
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xe5e7
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0xe60b
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xe609
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xe60b
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe644
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
je 0xe639
movq -0x28(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xe637
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xe639
movq 0x9ed0(%rip), %rax      # 0x18510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52d0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xe9d0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x3a(%rax), %eax
cmpl $0x2, %eax
je 0xe693
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7a9
movq -0x18(%rbp), %rax
cmpq 0x9e72(%rip), %rax      # 0x18510
jne 0xe6ad
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7a9
movq -0x10(%rbp), %rdi
callq 0xe7c0
cmpl $0x10f, %eax            # imm = 0x10F
je 0xe6ca
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7a9
movq -0x10(%rbp), %rdi
callq 0x10610
movq -0x10(%rbp), %rdi
callq 0xe660
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq 0x9e25(%rip), %rax      # 0x18510
jne 0xe712
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xe705
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xe7a9
movl $0x28, %edi
callq 0x51a0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x106b0
jmp 0xe735
movq -0x48(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd030
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq 0x9dbf(%rip), %rax      # 0x18510
jne 0xe7a1
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xe76b
movq -0x50(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xe783
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0xe7a1
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl $0x28, %esi
callq 0x51b0
jmp 0xe7b3
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x52d0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq 0x8e85(%rip), %rax      # 0x18510
jne 0xf6b2
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xf6a5
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf815
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xf6e4
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xf6d7
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf815
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x0, %eax
jne 0xf72e
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xf721
movq -0x40(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xf7fd
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x3, %eax
jne 0xf7fb
movq -0x18(%rbp), %rax
movzbl 0x8(%rax), %eax
cmpl $0x3, %eax
jne 0xf7fb
movq -0x10(%rbp), %rax
movl 0x18(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x18(%rcx), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x1c(%rax), %eax
movq -0x18(%rbp), %rcx
addl 0x1c(%rcx), %eax
movl %eax, -0x28(%rbp)
cmpl $0x3fffffff, -0x24(%rbp) # imm = 0x3FFFFFFF
ja 0xf7f9
movq -0x10(%rbp), %rax
cmpl $0x3fffffff, 0x1c(%rax) # imm = 0x3FFFFFFF
jg 0xf795
movq -0x18(%rbp), %rax
cmpl $0x3fffffff, 0x1c(%rax) # imm = 0x3FFFFFFF
jle 0xf79e
movl $0x40000000, -0x28(%rbp) # imm = 0x40000000
jmp 0xf7a9
cmpl $0x3fffffff, -0x28(%rbp) # imm = 0x3FFFFFFF
ja 0xf7f5
jmp 0xf7a9
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x28(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xf7ed
movq -0x48(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xf7f7
jmp 0xf7f9
jmp 0xf7fb
jmp 0xf7fd
jmp 0xf7ff
jmp 0xf801
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: getcharcl(int, Set*, Cenv*)
static int
getcharcl(int c, Set *set, Cenv *env)
{
	int i, j, n;
	for(i=0; (unsigned)i<elementsof(ctype); i++) {
		n = strlen(ctype[i].name);
		if(env->cursor.n > n+2 &&
		   strncmp(ctype[i].name,(char*)env->cursor.p,n) == 0 &&
		   env->cursor.p[n] == c && env->cursor.p[n+1] == ']') {
			env->cursor.next(n+2);
			int (*f)(int) = ctype[i].ctype;
			for(j=0; j<UCHAR_MAX+1; j++)
				if(f(j))
					set->insert(j);
			return 1;
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpq $0xc, %rax
jae 0xfceb
movslq -0x1c(%rbp), %rcx
leaq 0x846e(%rip), %rax      # 0x18050
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
callq 0x50d0
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x10(%rax), %eax
movl -0x24(%rbp), %ecx
addl $0x2, %ecx
cmpl %ecx, %eax
jle 0xfcdb
movslq -0x1c(%rbp), %rcx
leaq 0x843c(%rip), %rax      # 0x18050
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x24(%rbp), %rdx
callq 0x50f0
cmpl $0x0, %eax
jne 0xfcdb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl -0x8(%rbp), %eax
jne 0xfcdb
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x5d, %eax
jne 0xfcdb
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movl -0x24(%rbp), %esi
addl $0x2, %esi
callq 0x10990
movslq -0x1c(%rbp), %rcx
leaq 0x83c7(%rip), %rax      # 0x18050
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x20(%rbp)
cmpl $0x100, -0x20(%rbp)     # imm = 0x100
jge 0xfcd2
movq -0x30(%rbp), %rax
movl -0x20(%rbp), %edi
callq *%rax
cmpl $0x0, %eax
je 0xfcc5
movq -0x10(%rbp), %rdi
movl -0x20(%rbp), %eax
movzbl %al, %esi
callq 0x93a0
jmp 0xfcc7
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xfc9f
movl $0x1, -0x4(%rbp)
jmp 0xfcf2
jmp 0xfcdd
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xfbca
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, 0x10(%rax)
jge 0xfd25
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfe9a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xfd96
movq -0x20(%rbp), %rax
movzbl 0x2(%rax), %eax
cmpl $0x5d, %eax
jne 0xfd96
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x3f, %eax
je 0xfd63
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x5b, %eax
jne 0xfd6f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xfe9a
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl $0x3, %esi
callq 0x10990
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfe9a
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x10(%rbp), %rcx
movslq 0x10(%rcx), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
subq %rcx, %rax
cmpq $0x2, %rax
jl 0xfe93
movq -0x20(%rbp), %rax
movzbl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xfe80
movq -0x20(%rbp), %rax
movzbl 0x1(%rax), %eax
cmpl $0x5d, %eax
jne 0xfe80
movl $0x0, -0x14(%rbp)
cmpl $0x80, -0x14(%rbp)
jge 0xfe7e
movslq -0x14(%rbp), %rcx
leaq 0x7ce6(%rip), %rax      # 0x17af0
movq (%rax,%rcx,8), %rdi
callq 0x50d0
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x8(%rcx), %rcx
subq %rcx, %rax
movslq -0x18(%rbp), %rcx
cmpq %rcx, %rax
jne 0xfe6e
movslq -0x14(%rbp), %rcx
leaq 0x7cb7(%rip), %rax      # 0x17af0
movq (%rax,%rcx,8), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
movslq -0x18(%rbp), %rdx
callq 0x50e0
cmpl $0x0, %eax
jne 0xfe6e
movq -0x10(%rbp), %rdi
addq $0x8, %rdi
movl -0x18(%rbp), %esi
addl $0x2, %esi
callq 0x10990
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xfe9a
jmp 0xfe70
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0xfdf6
jmp 0xfe93
jmp 0xfe82
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xfdb9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: arnoldrobbins[P]mcilroy-regex/re2.cpp
// Function: isstring(Rex*)
static int
isstring(Rex *e)
{
	switch(e->type) {
	case KMP:
	case KR:
	case STRING:
		return 1;
	case ONECHAR:
		return ((Onechar*)e)->lo==1 && ((Onechar*)e)->hi==1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x14(%rbp)
subl $0x4, %eax
je 0x1007a
jmp 0x1005a
movl -0x14(%rbp), %eax
subl $0x5, %eax
je 0x10071
jmp 0x10064
movl -0x14(%rbp), %eax
addl $-0xe, %eax
subl $0x1, %eax
ja 0x100a4
jmp 0x10071
movl $0x1, -0x4(%rbp)
jmp 0x100ab
movq -0x10(%rbp), %rcx
xorl %eax, %eax
cmpl $0x1, 0x18(%rcx)
movb %al, -0x15(%rbp)
jne 0x10097
movq -0x10(%rbp), %rax
cmpl $0x1, 0x1c(%rax)
sete %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
jmp 0x100ab
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x8(%rax), %eax
movl %eax, -0x20(%rbp)
subl $0x4, %eax
je 0x100ff
jmp 0x100d2
movl -0x20(%rbp), %eax
subl $0x5, %eax
je 0x100e9
jmp 0x100dc
movl -0x20(%rbp), %eax
addl $-0xe, %eax
subl $0x1, %eax
ja 0x1011f
jmp 0x100e9
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rsi
callq 0xa2a0
movl %eax, -0x4(%rbp)
jmp 0x10126
movq -0x10(%rbp), %rax
movb 0x20(%rax), %al
movb %al, -0x1a(%rbp)
movb $0x0, -0x19(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x1a(%rbp), %rsi
callq 0xa2a0
movl %eax, -0x4(%rbp)
jmp 0x10126
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x80(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x7210
movq -0x80(%rbp), %rdi
movl $0x2, -0x3c(%rbp)
callq 0x7190
movq %rax, %rdi
xorl %eax, %eax
movl %eax, %esi
leaq -0x40(%rbp), %rdx
leaq -0x48(%rbp), %rcx
callq 0x7590
movl %eax, -0x4c(%rbp)
cmpl $0x0, -0x4c(%rbp)
je 0x8119
leaq -0x4d(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x77c0
movq -0x90(%rbp), %rdi
movq -0x98(%rbp), %rdx
leaq 0x16122(%rip), %rsi     # 0x1e20c
callq 0xa3f0
jmp 0x80f1
leaq -0x4d(%rbp), %rdi
callq 0x74b0
jmp 0x81a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x4d(%rbp), %rdi
callq 0x74b0
jmp 0x81b3
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movw $0x0, -0x60(%rbp)
movq -0x48(%rbp), %rax
movq 0x18(%rax), %rdi
movl 0x10(%rax), %esi
movq %rsp, %rax
movl $0x1, (%rax)
xorl %r9d, %r9d
movl %r9d, %r8d
leaq -0x70(%rbp), %rdx
movq %rdx, -0xa8(%rbp)
movl $0x12, %ecx
callq 0x72a0
leaq -0x71(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x77c0
movq -0x90(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdx
callq 0xa3f0
jmp 0x8181
leaq -0x71(%rbp), %rdi
callq 0x74b0
jmp 0x81a3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x71(%rbp), %rdi
callq 0x74b0
jmp 0x81b3
movq -0x88(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x77a0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x10(%rbp)
movq %rdi, -0x8(%rbp)
movq 0x23c19(%rip), %rdi     # 0x2cfb0
leaq 0x14de8(%rip), %rsi     # 0x1e186
callq 0x7420
movq 0x23c06(%rip), %rdi     # 0x2cfb0
leaq 0x14e26(%rip), %rsi     # 0x1e1d7
callq 0x7420
movq 0x23bf3(%rip), %rdi     # 0x2cfb0
leaq 0x14e49(%rip), %rsi     # 0x1e20d
callq 0x7420
movq 0x23be0(%rip), %rdi     # 0x2cfb0
leaq 0x14e94(%rip), %rsi     # 0x1e26b
callq 0x7420
movq -0x10(%rbp), %rsi
movq 0x23bc9(%rip), %rdi     # 0x2cfb0
callq 0x70d0
movq %rax, %rdi
movq 0x23b72(%rip), %rsi     # 0x2cf68
callq 0x7490
xorl %edi, %edi
callq 0x7530
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x104a6(%rip), %rsi     # 0x2d680
leaq -0x18(%rbp), %rdi
callq 0x1d550
movq 0xfdc6(%rip), %rdi      # 0x2cfb0
leaq 0x1aad(%rip), %rsi      # 0x1ec9e
callq 0x7420
jmp 0x1d1f8
cmpl $-0x1, -0xc(%rbp)
je 0x1d2ba
movl -0xc(%rbp), %edx
movl %edx, %ecx
decl %ecx
movl %edx, %eax
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %edx
negl %edx
movl %edx, %ecx
leal -0x1(%rax,%rcx), %eax
cltq
shlq $0x5, %rax
leaq 0x10384(%rip), %rsi     # 0x2d5c0
addq %rax, %rsi
movq 0xfd6a(%rip), %rdi      # 0x2cfb0
callq 0x73e0
movq %rax, -0x38(%rbp)
jmp 0x1d251
movq -0x38(%rbp), %rdi
leaq 0x1a46(%rip), %rsi      # 0x1eca2
callq 0x7420
movq %rax, -0x40(%rbp)
jmp 0x1d267
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7780
movq %rax, -0x48(%rbp)
jmp 0x1d279
movq -0x48(%rbp), %rdi
leaq 0x1a29(%rip), %rsi      # 0x1ecad
callq 0x7420
movq %rax, -0x50(%rbp)
jmp 0x1d28f
movq -0x50(%rbp), %rdi
leaq 0x103c6(%rip), %rsi     # 0x2d660
callq 0x73e0
jmp 0x1d2a1
jmp 0x1d2ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d580
jmp 0x1d306
movq 0xfcef(%rip), %rdi      # 0x2cfb0
leaq 0xfec(%rip), %rsi       # 0x1e2b4
callq 0x7420
jmp 0x1d2cf
movq -0x30(%rbp), %rsi
movq 0xfcd6(%rip), %rdi      # 0x2cfb0
callq 0x73e0
movq %rax, -0x58(%rbp)
jmp 0x1d2e5
movq -0x58(%rbp), %rdi
movq 0xfc78(%rip), %rsi      # 0x2cf68
callq 0x7490
jmp 0x1d2f7
leaq -0x18(%rbp), %rdi
callq 0x1d580
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x77a0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x10356(%rip), %rsi     # 0x2d680
leaq -0x18(%rbp), %rdi
callq 0x1d550
movq 0xfc76(%rip), %rdi      # 0x2cfb0
leaq 0x196a(%rip), %rsi      # 0x1ecab
callq 0x7420
jmp 0x1d348
cmpl $-0x1, -0xc(%rbp)
je 0x1d40a
movl -0xc(%rbp), %edx
movl %edx, %ecx
decl %ecx
movl %edx, %eax
movslq %ecx, %rcx
imulq $0x66666667, %rcx, %rdx # imm = 0x66666667
movq %rdx, %rcx
shrq $0x3f, %rcx
sarq $0x21, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,4), %edx
negl %edx
movl %edx, %ecx
leal -0x1(%rax,%rcx), %eax
cltq
shlq $0x5, %rax
leaq 0x10234(%rip), %rsi     # 0x2d5c0
addq %rax, %rsi
movq 0xfc1a(%rip), %rdi      # 0x2cfb0
callq 0x73e0
movq %rax, -0x38(%rbp)
jmp 0x1d3a1
movq -0x38(%rbp), %rdi
leaq 0x18f6(%rip), %rsi      # 0x1eca2
callq 0x7420
movq %rax, -0x40(%rbp)
jmp 0x1d3b7
movq -0x40(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x7780
movq %rax, -0x48(%rbp)
jmp 0x1d3c9
movq -0x48(%rbp), %rdi
leaq 0x18d9(%rip), %rsi      # 0x1ecad
callq 0x7420
movq %rax, -0x50(%rbp)
jmp 0x1d3df
movq -0x50(%rbp), %rdi
leaq 0x10276(%rip), %rsi     # 0x2d660
callq 0x73e0
jmp 0x1d3f1
jmp 0x1d40a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x1d580
jmp 0x1d456
movq 0xfb9f(%rip), %rdi      # 0x2cfb0
leaq 0xe9c(%rip), %rsi       # 0x1e2b4
callq 0x7420
jmp 0x1d41f
movq -0x30(%rbp), %rsi
movq 0xfb86(%rip), %rdi      # 0x2cfb0
callq 0x73e0
movq %rax, -0x58(%rbp)
jmp 0x1d435
movq -0x58(%rbp), %rdi
movq 0xfb28(%rip), %rsi      # 0x2cf68
callq 0x7490
jmp 0x1d447
leaq -0x18(%rbp), %rdi
callq 0x1d580
addq $0x60, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x77a0
nop
// File: tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: Undo()
void Undo()
{
	if(lastChanged != NULL)
	{
		*lastChanged = undoValue;
		lastChanged = NULL;
		undoValue = 0.0f;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpq $0x0, 0x10de4(%rip)     # 0x14690
je 0x38d7
movss 0x10de2(%rip), %xmm0    # 0x14698
movq 0x10dd3(%rip), %rax     # 0x14690
movss %xmm0, (%rax)
movq $0x0, 0x10dc4(%rip) # 0x14690
xorps %xmm0, %xmm0
movss %xmm0, 0x10dc1(%rip)    # 0x14698
popq %rbp
retq
nopl (%rax)
// File: tjohnman[P]sfxr-sdl2/build/../src/main.cpp
// Function: ResetParams()
void ResetParams()
{
	lastChanged = NULL;
	wave_type=0;

	p_base_freq=0.3f;
	p_freq_limit=0.0f;
	p_freq_ramp=0.0f;
	p_freq_dramp=0.0f;
	p_duty=0.0f;
	p_duty_ramp=0.0f;

	p_vib_strength=0.0f;
	p_vib_speed=0.0f;
	p_vib_delay=0.0f;

	p_env_attack=0.0f;
	p_env_sustain=0.3f;
	p_env_decay=0.4f;
	p_env_punch=0.0f;

	filter_on=false;
	p_lpf_resonance=0.0f;
	p_lpf_freq=1.0f;
	p_lpf_ramp=0.0f;
	p_hpf_freq=0.0f;
	p_hpf_ramp=0.0f;
	
	p_pha_offset=0.0f;
	p_pha_ramp=0.0f;

	p_repeat_speed=0.0f;

	p_arp_speed=0.0f;
	p_arp_mod=0.0f;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq $0x0, 0x10da1(%rip) # 0x14690
movl $0x0, 0xfbe7(%rip)      # 0x134e0
movss 0xa70f(%rip), %xmm0     # 0xe010
movss %xmm0, 0xfbdb(%rip)     # 0x134e4
xorps %xmm0, %xmm0
movss %xmm0, 0xfbd4(%rip)     # 0x134e8
xorps %xmm0, %xmm0
movss %xmm0, 0xfbcd(%rip)     # 0x134ec
xorps %xmm0, %xmm0
movss %xmm0, 0xfbc6(%rip)     # 0x134f0
xorps %xmm0, %xmm0
movss %xmm0, 0xfbbf(%rip)     # 0x134f4
xorps %xmm0, %xmm0
movss %xmm0, 0xfbb8(%rip)     # 0x134f8
xorps %xmm0, %xmm0
movss %xmm0, 0xfbb1(%rip)     # 0x134fc
xorps %xmm0, %xmm0
movss %xmm0, 0xfbaa(%rip)     # 0x13500
xorps %xmm0, %xmm0
movss %xmm0, 0xfba3(%rip)     # 0x13504
xorps %xmm0, %xmm0
movss %xmm0, 0xfb9c(%rip)     # 0x13508
movss 0xa69c(%rip), %xmm0     # 0xe010
movss %xmm0, 0xfb90(%rip)     # 0x1350c
movss 0xa688(%rip), %xmm0     # 0xe00c
movss %xmm0, 0xfb84(%rip)     # 0x13510
xorps %xmm0, %xmm0
movss %xmm0, 0xfb7d(%rip)     # 0x13514
movb $0x0, 0xfb7a(%rip)      # 0x13518
xorps %xmm0, %xmm0
movss %xmm0, 0xfb73(%rip)     # 0x1351c
movss 0xa657(%rip), %xmm0     # 0xe008
movss %xmm0, 0xfb67(%rip)     # 0x13520
xorps %xmm0, %xmm0
movss %xmm0, 0xfb60(%rip)     # 0x13524
xorps %xmm0, %xmm0
movss %xmm0, 0xfb59(%rip)     # 0x13528
xorps %xmm0, %xmm0
movss %xmm0, 0xfb52(%rip)     # 0x1352c
xorps %xmm0, %xmm0
movss %xmm0, 0xfb4b(%rip)     # 0x13530
xorps %xmm0, %xmm0
movss %xmm0, 0xfb44(%rip)     # 0x13534
xorps %xmm0, %xmm0
movss %xmm0, 0xfb3d(%rip)     # 0x13538
xorps %xmm0, %xmm0
movss %xmm0, 0xfb36(%rip)     # 0x1353c
xorps %xmm0, %xmm0
movss %xmm0, 0xfb2f(%rip)     # 0x13540
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
andb $0x1, %al
movb %al, -0xd(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0xa09088, -0x24(%rbp)  # imm = 0xA09088
movl $0x0, -0x28(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl $0x64, %edx
movl $0x11, %ecx
callq 0xd270
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
je 0x5757
leaq 0xefd6(%rip), %rax      # 0x1471f
testb $0x1, (%rax)
je 0x5757
movl -0x1c(%rbp), %eax
movl %eax, 0xdbe1(%rip)      # 0x13338
movl 0xdbdb(%rip), %eax      # 0x13338
cmpl -0x1c(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x2a(%rbp)
testb $0x1, -0xd(%rbp)
je 0x5783
movl $0x0, -0x20(%rbp)
movl $0x988070, -0x24(%rbp)  # imm = 0x988070
movl $0xfff0e0, -0x28(%rbp)  # imm = 0xFFF0E0
testb $0x1, -0x2a(%rbp)
je 0x57a4
testb $0x1, -0x29(%rbp)
je 0x57a4
movl $0xa09088, -0x20(%rbp)  # imm = 0xA09088
movl $0xfff0e0, -0x24(%rbp)  # imm = 0xFFF0E0
movl $0xa09088, -0x28(%rbp)  # imm = 0xA09088
movl -0x8(%rbp), %edi
subl $0x1, %edi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x20(%rbp), %r8d
movl $0x66, %edx
movl $0x13, %ecx
callq 0xcdd0
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x24(%rbp), %r8d
movl $0x64, %edx
movl $0x11, %ecx
callq 0xcdd0
movl -0x8(%rbp), %esi
addl $0x5, %esi
movl -0xc(%rbp), %edx
addl $0x5, %edx
movl -0x28(%rbp), %ecx
movq -0x18(%rbp), %r8
leaq 0xdb72(%rip), %rdi      # 0x13368
movb $0x0, %al
callq 0xd150
testb $0x1, -0x2a(%rbp)
je 0x581b
testb $0x1, -0x29(%rbp)
je 0x581b
leaq 0xef0c(%rip), %rax      # 0x1471c
testb $0x1, (%rax)
jne 0x581b
movb $0x1, -0x1(%rbp)
jmp 0x581f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movb %r8b, %al
movl 0x10(%rbp), %r8d
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq %r9, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0xa09088, -0x28(%rbp)  # imm = 0xA09088
movl $0x0, -0x2c(%rbp)
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
callq 0xd270
andb $0x1, %al
movb %al, -0x2d(%rbp)
testb $0x1, -0x2d(%rbp)
je 0x589a
leaq 0xee93(%rip), %rax      # 0x1471f
testb $0x1, (%rax)
je 0x589a
movl 0x10(%rbp), %eax
movl %eax, 0xda9e(%rip)      # 0x13338
movl 0xda98(%rip), %eax      # 0x13338
cmpl 0x10(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x2e(%rbp)
testb $0x1, -0x15(%rbp)
je 0x58c6
movl $0x0, -0x24(%rbp)
movl $0x988070, -0x28(%rbp)  # imm = 0x988070
movl $0xfff0e0, -0x2c(%rbp)  # imm = 0xFFF0E0
testb $0x1, -0x2e(%rbp)
je 0x58e7
testb $0x1, -0x2d(%rbp)
je 0x58e7
movl $0xa09088, -0x24(%rbp)  # imm = 0xA09088
movl $0xfff0e0, -0x28(%rbp)  # imm = 0xFFF0E0
movl $0xa09088, -0x2c(%rbp)  # imm = 0xA09088
movl -0x8(%rbp), %edi
subl $0x1, %edi
movl -0xc(%rbp), %esi
subl $0x1, %esi
movl -0x10(%rbp), %edx
addl $0x2, %edx
movl -0x14(%rbp), %ecx
addl $0x2, %ecx
movl -0x24(%rbp), %r8d
callq 0xcdd0
movl -0x8(%rbp), %edi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movl -0x28(%rbp), %r8d
callq 0xcdd0
movl -0x8(%rbp), %esi
addl $0x5, %esi
movl -0xc(%rbp), %edx
addl $0x5, %edx
movl -0x2c(%rbp), %ecx
movq -0x20(%rbp), %r8
leaq 0xda31(%rip), %rdi      # 0x13368
movb $0x0, %al
callq 0xd150
testb $0x1, -0x2e(%rbp)
je 0x595c
testb $0x1, -0x2d(%rbp)
je 0x595c
leaq 0xedcb(%rip), %rax      # 0x1471c
testb $0x1, (%rax)
jne 0x595c
movb $0x1, -0x1(%rbp)
jmp 0x5960
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)