LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_nearest3f
struct kdres *kd_nearest3f(struct kdtree *tree, float x, float y, float z)
{
	double pos[3];
	pos[0] = x;
	pos[1] = y;
	pos[2] = z;
	return kd_nearest(tree, pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x31b30
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_nearest_range
struct kdres *kd_nearest_range(struct kdtree *kd, const double *pos, double range)
{
	int ret;
	struct kdres *rset;

	if(!(rset = (kdres*)malloc(sizeof *rset))) {	// (kdres*) added
		return 0;
	}
	if(!(rset->rlist = (res_node*)alloc_resnode())) {	// (res_node*) added
		free(rset);
		return 0;
	}
	rset->rlist->next = 0;
	rset->tree = kd;

	if((ret = find_nearest(kd->root, pos, range, rset->rlist, 0, kd->dim)) == -1) {
		kd_res_free(rset);
		return 0;
	}
	rset->size = ret;
	kd_res_rewind(rset);
	return rset;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movsd %xmm0, -0x20(%rbp)
movl $0x20, %edi
callq 0x3390
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
jne 0x322c6
movq $0x0, -0x8(%rbp)
jmp 0x32369
movl $0x18, %edi
callq 0x3390
movq -0x30(%rbp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x322f1
movq -0x30(%rbp), %rdi
callq 0x3320
movq $0x0, -0x8(%rbp)
jmp 0x32369
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movsd -0x20(%rbp), %xmm0
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdx
movq -0x10(%rbp), %rax
movl (%rax), %r8d
xorl %ecx, %ecx
callq 0x32380
movl %eax, -0x24(%rbp)
cmpl $-0x1, %eax
jne 0x3234e
movq -0x30(%rbp), %rdi
callq 0x31d50
movq $0x0, -0x8(%rbp)
jmp 0x32369
movl -0x24(%rbp), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x30(%rbp), %rdi
callq 0x320b0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_nearest_rangef
struct kdres *kd_nearest_rangef(struct kdtree *kd, const float *pos, float range)
{
	static double sbuf[16];
	double *bptr, *buf = 0;
	int dim = kd->dim;
	struct kdres *res;

	if(dim > 16) {
#ifndef NO_ALLOCA
		if(dim <= 256)
			bptr = buf = (double*)alloca(dim * sizeof *bptr);	// (double*) added
		else
#endif
			if(!(bptr = buf = (double*)malloc(dim * sizeof *bptr))) {	// (double*) added
				return 0;
			}
	} else {
		bptr = buf = sbuf;
	}

	while(dim-- > 0) {
		*bptr++ = *pos++;
	}

	res = kd_nearest_range(kd, buf, range);
#ifndef NO_ALLOCA
	if(kd->dim > 256)
#else
	if(kd->dim > 16)
#endif
		free(buf);
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movss %xmm0, -0x1c(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x10, -0x34(%rbp)
jle 0x32634
cmpl $0x100, -0x34(%rbp)     # imm = 0x100
jg 0x32608
movslq -0x34(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
jmp 0x32632
movslq -0x34(%rbp), %rdi
shlq $0x3, %rdi
callq 0x3390
movq %rax, -0x30(%rbp)
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
jne 0x32630
movq $0x0, -0x8(%rbp)
jmp 0x326bf
jmp 0x32632
jmp 0x3264a
leaq 0x1bf05(%rip), %rax     # 0x4e540
movq %rax, -0x30(%rbp)
leaq 0x1befa(%rip), %rax     # 0x4e540
movq %rax, -0x28(%rbp)
jmp 0x3264c
movl -0x34(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x34(%rbp)
cmpl $0x0, %eax
jle 0x32688
movq -0x18(%rbp), %rax
movq %rax, %rcx
addq $0x4, %rcx
movq %rcx, -0x18(%rbp)
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x8, %rcx
movq %rcx, -0x28(%rbp)
movsd %xmm0, (%rax)
jmp 0x3264c
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
movss -0x1c(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x32290
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x100, (%rax)          # imm = 0x100
jle 0x326b7
movq -0x30(%rbp), %rdi
callq 0x3320
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rbp, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_nearest_range3
struct kdres *kd_nearest_range3(struct kdtree *tree, double x, double y, double z, double range)
{
	double buf[3];
	buf[0] = x;
	buf[1] = y;
	buf[2] = z;
	return kd_nearest_range(tree, buf, range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movsd %xmm0, -0x10(%rbp)
movsd %xmm1, -0x18(%rbp)
movsd %xmm2, -0x20(%rbp)
movsd %xmm3, -0x28(%rbp)
movsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x40(%rbp), %rsi
movsd -0x28(%rbp), %xmm0
callq 0x32290
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_nearest_range3f
struct kdres *kd_nearest_range3f(struct kdtree *tree, float x, float y, float z, float range)
{
	double buf[3];
	buf[0] = x;
	buf[1] = y;
	buf[2] = z;
	return kd_nearest_range(tree, buf, range);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movss %xmm0, -0xc(%rbp)
movss %xmm1, -0x10(%rbp)
movss %xmm2, -0x14(%rbp)
movss %xmm3, -0x18(%rbp)
movss -0xc(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movss -0x10(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movss -0x14(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
movss -0x18(%rbp), %xmm0
cvtss2sd %xmm0, %xmm0
callq 0x32290
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: clear_results(kdres*)
static void clear_results(struct kdres *rset)
{
	struct res_node *tmp, *node = rset->rlist->next;

	while(node) {
		tmp = node;
		node = node->next;
		//free_resnode(tmp);
		free(tmp);
	}

	rset->rlist->next = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x327e2
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x3320
jmp 0x327bc
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_res_item
void *kd_res_item(struct kdres *rset, double *pos)
{
	if(rset->riter) {
		if(pos) {
			memcpy(pos, rset->riter->item->pos, rset->tree->dim * sizeof *pos);
		}
		return rset->riter->item->data;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x328cc
cmpq $0x0, -0x18(%rbp)
je 0x328b7
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq (%rax), %rdx
shlq $0x3, %rdx
callq 0x3240
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x328d4
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_res_itemf
void *kd_res_itemf(struct kdres *rset, float *pos)
{
	if(rset->riter) {
		if(pos) {
			int i;
			for(i=0; i<rset->tree->dim; i++) {
				pos[i] = rset->riter->item->pos[i];
			}
		}
		return rset->riter->item->data;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3295d
cmpq $0x0, -0x18(%rbp)
je 0x32948
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x32946
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movss %xmm0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x32905
jmp 0x32948
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x32965
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_res_item3
void *kd_res_item3(struct kdres *rset, double *x, double *y, double *z)
{
	if(rset->riter) {
		if(*x) *x = rset->riter->item->pos[0];
		if(*y) *y = rset->riter->item->pos[1];
		if(*z) *z = rset->riter->item->pos[2];
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x32a24
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x329a8
jp 0x329a8
jmp 0x329c2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
movq -0x10(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x18(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x329d7
jp 0x329d7
jmp 0x329f2
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
movq -0x18(%rbp), %rax
movsd %xmm0, (%rax)
movq -0x20(%rbp), %rax
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jne 0x32a07
jp 0x32a07
jmp 0x32a22
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
movq -0x20(%rbp), %rax
movsd %xmm0, (%rax)
jmp 0x32a24
xorl %eax, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: kd_res_item3f
void *kd_res_item3f(struct kdres *rset, float *x, float *y, float *z)
{
	if(rset->riter) {
		if(*x) *x = rset->riter->item->pos[0];
		if(*y) *y = rset->riter->item->pos[1];
		if(*z) *z = rset->riter->item->pos[2];
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x32aed
movq -0x10(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32a67
jp 0x32a67
jmp 0x32a85
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd (%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x10(%rbp), %rax
movss %xmm0, (%rax)
movq -0x18(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32a99
jp 0x32a99
jmp 0x32ab8
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd 0x8(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x18(%rbp), %rax
movss %xmm0, (%rax)
movq -0x20(%rbp), %rax
movss (%rax), %xmm0
xorps %xmm1, %xmm1
ucomiss %xmm1, %xmm0
jne 0x32acc
jp 0x32acc
jmp 0x32aeb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movsd 0x10(%rax), %xmm0
cvtsd2ss %xmm0, %xmm0
movq -0x20(%rbp), %rax
movss %xmm0, (%rax)
jmp 0x32aed
xorl %eax, %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: gjoni[P]iPot/src/kdtree.cpp
// Function: hyperrect_dist_sq(kdhyperrect*, double const*)
static double hyperrect_dist_sq(struct kdhyperrect *rect, const double *pos)
{
	int i;
	double result = 0;

	for (i=0; i < rect->dim; i++) {
		if (pos[i] < rect->min[i]) {
			result += SQ(rect->min[i] - pos[i]);
		} else if (pos[i] > rect->max[i]) {
			result += SQ(rect->max[i] - pos[i]);
		}
	}

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x32c3e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x32bbe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x32c2e
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
ucomisd (%rax,%rcx,8), %xmm0
jbe 0x32c2c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm2
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm2
movsd -0x20(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
jmp 0x32c2e
jmp 0x32c30
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x32b3b
movsd -0x20(%rbp), %xmm0
popq %rbp
retq
// File: rfotino[P]consolite-emulator/src/vidmem.cpp
// Function: EmuVideoMemory::EmuVideoMemory()
EmuVideoMemory::EmuVideoMemory() {
  _buffer = cairo_image_surface_create(CAIRO_FORMAT_RGB24,
                                       getWidth(),
                                       getHeight());
  _cairo = cairo_create(_buffer);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
callq 0x4dc0
movq -0x10(%rbp), %rdi
movl %eax, -0x14(%rbp)
callq 0x4dd0
movl -0x14(%rbp), %esi
movl %eax, %edx
movl $0x1, %edi
callq 0x33f0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq (%rax), %rdi
callq 0x30b0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rfotino[P]consolite-emulator/src/vidmem.cpp
// Function: EmuVideoMemory::set(unsigned char const&, unsigned char const&, unsigned char const&)
void EmuVideoMemory::set(const uint8_t& x,
                         const uint8_t& y,
                         const uint8_t& color) {
  // Decode the color. The most significant three bits represent
  // red, the middle three bits represent green, and the lowest
  // two bits represent blue. We want the color as a double from
  // 0.0 to 1.0 for cairo.
  double red = (color & 0xe0) / 255.0;
  double green = ((color & 0x1c) << 3) / 255.0;
  double blue = ((color & 0x3) << 6) / 255.0;
  // Paint the pixel specified by (x, y) to the buffer
  cairo_set_source_rgb(_cairo, red, green, blue);
  cairo_rectangle(_cairo, x, y, 1, 1);
  cairo_fill(_cairo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
andl $-0x20, %ecx
cvtsi2sd %ecx, %xmm0
movsd 0x53ca(%rip), %xmm1     # 0xa0f0
divsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
andl $0x1c, %ecx
shll $0x3, %ecx
cvtsi2sd %ecx, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rcx
movzbl (%rcx), %ecx
andl $0x3, %ecx
shll $0x6, %ecx
cvtsi2sd %ecx, %xmm0
divsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x8(%rax), %rdi
movsd -0x28(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd -0x38(%rbp), %xmm2
callq 0x31b0
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm0
movq -0x18(%rbp), %rax
movzbl (%rax), %eax
cvtsi2sd %eax, %xmm1
movsd 0x5347(%rip), %xmm3     # 0xa0e8
movaps %xmm3, %xmm2
callq 0x3140
movq -0x40(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3580
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: rfotino[P]consolite-emulator/src/window.cpp
// Function: EmuWindow::~EmuWindow()
EmuWindow::~EmuWindow() {
  // Destroy the cairo object
  cairo_destroy(_cairo);
  // Destroy the cairo Xlib surface
  cairo_surface_destroy(_surface);
  // Close the connection to the X server
  XCloseDisplay(_display);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x8(%rax), %rdi
callq 0x3420
jmp 0x54cf
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x3370
jmp 0x54dd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x35a0
jmp 0x54ec
movq -0x10(%rbp), %rdi
addq $0x68, %rdi
callq 0x5ab0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0x5ad0
addq $0x10, %rsp
popq %rbp
retq
movq %rax, %rdi
callq 0x4160
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-emulator/src/window.cpp
// Function: EmuWindow::_draw()
void EmuWindow::_draw() {
  // Scale and paint the video memory's buffer to the window
  double scaleX = (double)_width / _vidMem->getWidth();
  double scaleY = (double)_height / _vidMem->getHeight();
  cairo_identity_matrix(_cairo);
  cairo_scale(_cairo, scaleX, scaleY);
  cairo_set_source_surface(_cairo, _vidMem->getBuffer(), 0, 0);
  cairo_pattern_set_filter(cairo_get_source(_cairo), CAIRO_FILTER_NEAREST);
  cairo_paint(_cairo);
  cairo_surface_flush(_surface);
  XFlush(_display);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cvtsi2sdl 0x2c(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movq 0x20(%rax), %rdi
callq 0x4dc0
movsd -0x38(%rbp), %xmm0
movl %eax, %ecx
movq -0x20(%rbp), %rax
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
cvtsi2sdl 0x30(%rax), %xmm0
movsd %xmm0, -0x30(%rbp)
movq 0x20(%rax), %rdi
callq 0x4dd0
movsd -0x30(%rbp), %xmm0
movl %eax, %ecx
movq -0x20(%rbp), %rax
cvtsi2sd %ecx, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x3170
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movsd -0x10(%rbp), %xmm0
movsd -0x18(%rbp), %xmm1
callq 0x3050
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x20(%rax), %rdi
callq 0x5bd0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
xorps %xmm1, %xmm1
movaps %xmm1, %xmm0
callq 0x3570
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3450
movq %rax, %rdi
movl $0x3, %esi
callq 0x3590
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x34a0
movq -0x20(%rbp), %rax
movq (%rax), %rdi
callq 0x34e0
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3470
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: rfotino[P]consolite-emulator/src/window.cpp
// Function: EmuWindow::getInput(unsigned short const&)
uint16_t EmuWindow::getInput(const uint16_t& input_id) {
  // Return current input status. If this input_id is
  // not registered to a key or button, return 0.
  auto keySymPtr = _keyMap.find(input_id);
  if (_keyMap.end() == keySymPtr) {
    // This input isn't mapped to anything.
    return 0;
  }
  auto statePtr = _keyState.find(keySymPtr->second);
  if (_keyState.end() == statePtr) {
    // This key hasn't been pressed or released.
    return 0;
  }
  return statePtr->second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x40(%rbp)
addq $0x38, %rdi
movq -0x18(%rbp), %rsi
callq 0x5bf0
movq -0x40(%rbp), %rdi
movq %rax, -0x20(%rbp)
addq $0x38, %rdi
callq 0x5c50
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5c20
testb $0x1, %al
jne 0x56ad
jmp 0x56b5
movw $0x0, -0x2(%rbp)
jmp 0x571b
movq -0x40(%rbp), %rax
addq $0x68, %rax
movq %rax, -0x48(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x5cb0
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x8, %rsi
callq 0x5c80
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x68, %rdi
callq 0x5d00
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5cd0
testb $0x1, %al
jne 0x5702
jmp 0x570a
movw $0x0, -0x2(%rbp)
jmp 0x571b
leaq -0x30(%rbp), %rdi
callq 0x5d30
movw 0x8(%rax), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-emulator/src/window.cpp
// Function: EmuWindow::_updateKeyState(XKeyEvent const&)
void EmuWindow::_updateKeyState(const XKeyEvent& event) {
  // Filter out auto repeat key events
  if (event.type == KeyRelease && XPending(_display)) {
    XEvent nev;
    XPeekEvent(_display, &nev);
    if (nev.type == KeyPress &&
        nev.xkey.time == event.time &&
        nev.xkey.keycode == event.keycode) {
      // Key wasn't really released, get rid of the
      // pending KeyPress event and return
      XNextEvent(_display, &nev);
      return;
    }
  }
  int keysyms_per_keycode_return;
  KeySym *keysym = XGetKeyboardMapping(_display,
                                       event.keycode,
                                       1,
                                       &keysyms_per_keycode_return);
  uint16_t status = KeyPress == event.type ? 1 : 0;
  _keyState[keysym[0]] = status;
  XFree(keysym);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf0(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x57c7
movq -0xf0(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3270
cmpl $0x0, %eax
je 0x57c7
movq -0xf0(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x30d0
cmpl $0x2, -0xd0(%rbp)
jne 0x57c5
movq -0x98(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x38(%rcx), %rax
jne 0x57c5
movl -0x7c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x54(%rcx), %eax
jne 0x57c5
movq -0xf0(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x3430
jmp 0x584d
jmp 0x57c7
movq -0xf0(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x54(%rax), %eax
movl $0x1, %edx
leaq -0xd4(%rbp), %rcx
movzbl %al, %esi
callq 0x3550
movq -0xf0(%rbp), %rdi
movq %rax, -0xe0(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %esi
movl $0x2, %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movw %ax, -0xe2(%rbp)
movw -0xe2(%rbp), %ax
movw %ax, -0xf2(%rbp)
addq $0x68, %rdi
movq -0xe0(%rbp), %rsi
callq 0x5d50
movw -0xf2(%rbp), %cx
movw %cx, (%rax)
movq -0xe0(%rbp), %rdi
callq 0x33a0
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: rfotino[P]consolite-emulator/src/processor.cpp
// Function: EmuProcessor::_push(unsigned short const&)
void EmuProcessor::_push(const uint16_t& val) {
  _registers[REG_SP] += 2;
  uint16_t sp = _registers[REG_SP];
  _mainMem[sp] = val >> 8;
  _mainMem[sp+1] = val & 0xff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzwl 0x10008(%rax), %ecx
addl $0x2, %ecx
movw %cx, 0x10008(%rax)
movw 0x10008(%rax), %cx
movw %cx, -0x12(%rbp)
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
sarl $0x8, %ecx
movb %cl, %dl
movzwl -0x12(%rbp), %ecx
movb %dl, 0x8(%rax,%rcx)
movq -0x10(%rbp), %rcx
movzwl (%rcx), %ecx
andl $0xff, %ecx
movb %cl, %dl
movzwl -0x12(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, 0x8(%rax,%rcx)
popq %rbp
retq
nop
// File: rfotino[P]consolite-emulator/src/processor.cpp
// Function: EmuProcessor::_pop()
uint16_t EmuProcessor::_pop() {
  uint16_t sp = _registers[REG_SP];
  uint16_t val = (_mainMem[sp] << 8) | _mainMem[sp+1];
  _registers[REG_SP] -= 2;
  return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movw 0x10008(%rax), %cx
movw %cx, -0xa(%rbp)
movzwl -0xa(%rbp), %ecx
movzbl 0x8(%rax,%rcx), %ecx
shll $0x8, %ecx
movzwl -0xa(%rbp), %edx
addl $0x1, %edx
movslq %edx, %rdx
movzbl 0x8(%rax,%rdx), %edx
orl %edx, %ecx
movw %cx, -0xc(%rbp)
movzwl 0x10008(%rax), %ecx
subl $0x2, %ecx
movw %cx, 0x10008(%rax)
movw -0xc(%rbp), %ax
popq %rbp
retq
nop
// File: ef-gy[P]libefgy/include/ef.gy/test-case.h
// Function: main
int main(int argc, char **argv) {
  if (cli::options(argc, argv, false).matches == 0) {
    return run<function>() ? 0 : -1;
  } else {
    return 0;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x59f0
movq %rax, -0x58(%rbp)
callq 0x5ae0
movl -0x64(%rbp), %esi
movq -0x60(%rbp), %rdx
movq -0x58(%rbp), %r8
movq %rax, %r9
leaq -0x48(%rbp), %rdi
xorl %ecx, %ecx
callq 0x6590
movq -0x48(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x6620
movq -0x50(%rbp), %rax
cmpq $0x0, %rax
jne 0x5ad0
callq 0x5b40
movq %rax, %rdi
callq 0x6640
movb %al, %dl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %ecx, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
jmp 0x5ad7
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x70, %rsp
popq %rbp
retq
// File: ef-gy[P]libefgy/include/ef.gy/test-case.h
// Function: bool efgy::test::run<efgy::test::function>(efgy::beacon<efgy::test::function>::set&)
bool run(beacons<test> &tests = global<beacons<test>>()) {
  int i = 0;
  for (const auto &f : tests) {
    i++;
    std::cout << "running test case " << i << " in batch of " << tests.size()
              << ": ";
    if (!f->run(std::cerr)) {
      std::cout << "FAIL\n";
      return false;
    }
    std::cout << "OK\n";
  }

  return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x32580
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x325b0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x29690
testb $0x1, %al
jne 0x668b
jmp 0x6747
leaq -0x28(%rbp), %rdi
callq 0x325e0
movq %rax, -0x38(%rbp)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq 0x47908(%rip), %rdi     # 0x4dfb0
leaq 0x2e5a9(%rip), %rsi     # 0x34c58
callq 0x5350
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x5580
movq %rax, %rdi
leaq 0x2e5a2(%rip), %rsi     # 0x34c6b
callq 0x5350
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rdi
callq 0x32600
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x50a0
movq %rax, %rdi
leaq 0x2e4f8(%rip), %rsi     # 0x34be9
callq 0x5350
movq -0x38(%rbp), %rax
movq (%rax), %rdi
movq 0x478e4(%rip), %rsi     # 0x4dfe8
callq 0x32620
testb $0x1, %al
jne 0x6726
movq 0x4789c(%rip), %rdi     # 0x4dfb0
leaq 0x2e55e(%rip), %rsi     # 0x34c79
callq 0x5350
movb $0x0, -0x1(%rbp)
jmp 0x674b
movq 0x47883(%rip), %rdi     # 0x4dfb0
leaq 0x2e54b(%rip), %rsi     # 0x34c7f
callq 0x5350
leaq -0x28(%rbp), %rdi
callq 0x32740
jmp 0x6675
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: ef-gy[P]libefgy/include/ef.gy/cli.h
// Function: efgy::cli::processor<efgy::cli::option, efgy::cli::hint>::apply(int, char**)
void apply(int argc, char *argv[]) {
    std::vector<std::string> args;
    for (int i = 0; i < argc; i++) {
      args.push_back(argv[i]);
    }
    apply(args);
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x13650
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2a6ba
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x55b0
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdx
leaq -0x58(%rbp), %rdi
callq 0x6350
jmp 0x2a660
leaq -0x30(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2a700
jmp 0x2a66f
leaq -0x58(%rbp), %rdi
callq 0x5220
leaq -0x59(%rbp), %rdi
callq 0x53b0
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x2a61e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x2a6af
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x5220
leaq -0x59(%rbp), %rdi
callq 0x53b0
jmp 0x2a6e7
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2a730
jmp 0x2a6c9
leaq -0x30(%rbp), %rdi
callq 0x137c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x137c0
movq -0x68(%rbp), %rdi
callq 0x55a0
nopl (%rax)
// File: ef-gy[P]libefgy/include/ef.gy/test-case.h
// Function: efgy::test::function::run(std::ostream&)
bool run(std::ostream &log) {
    try {
      return func(log);
    } catch (std::exception &e) {
      std::cerr << "Exception: " << e.what() << "\n";
    } catch (...) {
      std::cerr << "Unknown Exception\n";
    }
    return false;
  }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x327f0
movb %al, -0x31(%rbp)
jmp 0x32642
movb -0x31(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x32718
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl $0x2, %ecx
cmpl %ecx, %eax
jne 0x326c9
movq -0x20(%rbp), %rdi
callq 0x5120
movq %rax, -0x30(%rbp)
movq 0x1b96d(%rip), %rdi     # 0x4dfe8
leaq 0x2614(%rip), %rsi      # 0x34c96
callq 0x5350
movq %rax, -0x40(%rbp)
jmp 0x3268d
movq -0x30(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movq -0x40(%rbp), %rdi
movq %rax, %rsi
callq 0x5350
movq %rax, -0x48(%rbp)
jmp 0x326ac
movq -0x48(%rbp), %rdi
leaq 0x1c8a(%rip), %rsi      # 0x34341
callq 0x5350
jmp 0x326be
callq 0x5510
movb $0x0, -0x1(%rbp)
jmp 0x32718
movq -0x20(%rbp), %rdi
callq 0x5120
movq 0x1b90f(%rip), %rdi     # 0x4dfe8
leaq 0x25a3(%rip), %rsi      # 0x34c83
callq 0x5350
jmp 0x326e7
callq 0x5510
jmp 0x326c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5510
jmp 0x32701
jmp 0x32723
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x5510
jmp 0x32716
jmp 0x32723
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x55a0
movq %rax, %rdi
callq 0x6c10
nopw %cs:(%rax,%rax)
nop
// File: ahupowerdns[P]spamidea/getsender.cc
// Function: flattenDomain(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, 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&)
string flattenDomain(const std::string& input, const vector<string>& repl)
{
  for(const auto& r: repl) {
    auto pos = input.find(r);
    if(pos != string::npos) {
      return "*."+r;
    }
  }
  return input;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7f80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x7fb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x7fe0
testb $0x1, %al
jne 0x6ac4
jmp 0x6b10
leaq -0x28(%rbp), %rdi
callq 0x8020
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x6850
movq %rax, -0x40(%rbp)
cmpq $-0x1, -0x40(%rbp)
je 0x6b03
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x3269d(%rip), %rsi     # 0x39199
callq 0x8040
jmp 0x6b1d
jmp 0x6b05
leaq -0x28(%rbp), %rdi
callq 0x8150
jmp 0x6ab1
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x61a0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ahupowerdns[P]spamidea/getsender.cc
// Function: processReceived(_IO_FILE*)
void processReceived(FILE* fp)
{
  char line[512];
  std::string completeline;
  MailTreeNode* start = &g_mtn;
  while(fgets(line, sizeof(line)-1, fp)) {
    chomp(line);
    if(!*line)
      break;
    if(isspace(*line)) {
      *line=' ';
      completeline += line;
    }
    else {
      processLine(completeline, start);
      completeline=line;
    }
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x6640
leaq 0x4f57e(%rip), %rax     # 0x56870
movq %rax, -0x238(%rbp)
movq -0x8(%rbp), %rdx
leaq -0x210(%rbp), %rdi
movl $0x1ff, %esi            # imm = 0x1FF
callq 0x66e0
movq %rax, -0x250(%rbp)
jmp 0x7317
movq -0x250(%rbp), %rax
cmpq $0x0, %rax
je 0x73c4
leaq -0x210(%rbp), %rdi
callq 0x73f0
jmp 0x7336
cmpb $0x0, -0x210(%rbp)
jne 0x7364
jmp 0x73c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x240(%rbp)
movl %eax, -0x244(%rbp)
leaq -0x230(%rbp), %rdi
callq 0x6290
jmp 0x73d9
movsbl -0x210(%rbp), %edi
callq 0x6070
cmpl $0x0, %eax
je 0x7393
movb $0x20, -0x210(%rbp)
leaq -0x230(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x6410
jmp 0x7391
jmp 0x73bf
leaq -0x230(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x6b30
jmp 0x73a8
leaq -0x230(%rbp), %rdi
leaq -0x210(%rbp), %rsi
callq 0x6610
jmp 0x73bd
jmp 0x73bf
jmp 0x72f9
leaq -0x230(%rbp), %rdi
callq 0x6290
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x240(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]spamidea/getsender.cc
// Function: processFile(boost::filesystem::path const&)
void processFile(const boost::filesystem::path& p)
{
  FILE* fp = fopen(p.c_str(), "r");
  if(!fp) {
    cerr<<"Could not open " << p.string() << " for reading"<<endl;
    exit(EXIT_FAILURE);
  }
  processReceived(fp);
  fclose(fp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8ca0
movq %rax, %rdi
leaq 0x324c7(%rip), %rsi     # 0x39936
callq 0x6550
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x74d3
movq 0x4eb6a(%rip), %rdi     # 0x55ff0
leaq 0x31d70(%rip), %rsi     # 0x391fd
callq 0x6420
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x8cc0
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x63e0
movq %rax, %rdi
leaq 0x31d58(%rip), %rsi     # 0x3920d
callq 0x6420
movq %rax, %rdi
movq 0x4eabc(%rip), %rsi     # 0x55f80
callq 0x6480
movl $0x1, %edi
callq 0x6560
movq -0x10(%rbp), %rdi
callq 0x72d0
movq -0x10(%rbp), %rdi
callq 0x6430
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: ahupowerdns[P]spamidea/getsender.cc
// Function: processDir(boost::filesystem::path const&)
void processDir(const boost::filesystem::path& p)
{
  for (auto& entry : boost::make_iterator_range(boost::filesystem::directory_iterator(p), {}))
    if (boost::filesystem::is_regular_file(entry))
      processFile(entry);
    else if (boost::filesystem::is_directory(entry))
      processDir(entry);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x68(%rbp)
xorl %edx, %edx
callq 0x8d70
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x8dd0
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
leaq -0x20(%rbp), %rdi
callq 0x8cd0
jmp 0x7532
leaq -0x30(%rbp), %rdi
callq 0x8df0
leaq -0x28(%rbp), %rdi
callq 0x8df0
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x8e10
jmp 0x755b
movq -0x10(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x8e40
jmp 0x756a
jmp 0x756c
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x8e70
movb %al, -0x69(%rbp)
jmp 0x757e
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x760a
jmp 0x758b
leaq -0x50(%rbp), %rdi
callq 0x8df0
leaq -0x48(%rbp), %rdi
callq 0x8df0
leaq -0x20(%rbp), %rdi
callq 0x8f80
jmp 0x76a1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x8df0
leaq -0x28(%rbp), %rdi
callq 0x8df0
jmp 0x76aa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7696
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x768d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8df0
jmp 0x768d
leaq -0x48(%rbp), %rdi
callq 0x8eb0
movq %rax, -0x78(%rbp)
jmp 0x7619
movq -0x78(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x8ee0
movb %al, -0x79(%rbp)
jmp 0x762f
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x7638
jmp 0x764d
movq -0x58(%rbp), %rdi
callq 0x8f10
movq %rax, %rdi
callq 0x7450
jmp 0x764b
jmp 0x767b
movq -0x58(%rbp), %rdi
callq 0x8f20
movb %al, -0x7a(%rbp)
jmp 0x765b
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x7664
jmp 0x7679
movq -0x58(%rbp), %rdi
callq 0x8f10
movq %rax, %rdi
callq 0x74f0
jmp 0x7677
jmp 0x7679
jmp 0x767b
jmp 0x767d
leaq -0x48(%rbp), %rdi
callq 0x8f50
jmp 0x7688
jmp 0x756c
leaq -0x48(%rbp), %rdi
callq 0x8df0
leaq -0x20(%rbp), %rdi
callq 0x8f80
jmp 0x76aa
addq $0x80, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: ahupowerdns[P]spamidea/getsender.cc
// Function: main
int main(int argc, char**argv)
{
  for(int n = 1 ; n < argc; ++n) {
    boost::filesystem::path p(argv[n]);
    if (boost::filesystem::exists(p)) {
      if (boost::filesystem::is_regular_file(p))
        processFile(p);
      else if (boost::filesystem::is_directory(p)) {
        processDir(p);
      }
    }
  }
  
  ofstream plot2("plot2.dot");
  plot2 << "digraph { " <<endl;
  g_mtn.emitLinks(plot2);
  plot2 << "}"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x280, %rsp            # imm = 0x280
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x77b1
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x8fa0
movq -0x258(%rbp), %rdi
callq 0x9010
movb %al, -0x249(%rbp)
jmp 0x771c
movb -0x249(%rbp), %al
testb $0x1, %al
jne 0x7728
jmp 0x779a
leaq -0x38(%rbp), %rdi
callq 0x9040
movb %al, -0x259(%rbp)
jmp 0x7739
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x7745
jmp 0x776c
leaq -0x38(%rbp), %rdi
callq 0x7450
jmp 0x7750
jmp 0x7798
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x90a0
jmp 0x7879
leaq -0x38(%rbp), %rdi
callq 0x9070
movb %al, -0x25a(%rbp)
jmp 0x777d
movb -0x25a(%rbp), %al
testb $0x1, %al
jne 0x7789
jmp 0x7796
leaq -0x38(%rbp), %rdi
callq 0x74f0
jmp 0x7794
jmp 0x7796
jmp 0x7798
jmp 0x779a
leaq -0x38(%rbp), %rdi
callq 0x90a0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x76e0
leaq 0x31a62(%rip), %rsi     # 0x3921a
leaq -0x248(%rbp), %rdi
movq %rdi, -0x270(%rbp)
movl $0x10, %edx
callq 0x64b0
movq -0x270(%rbp), %rdi
leaq 0x31a46(%rip), %rsi     # 0x39224
callq 0x6420
movq %rax, -0x268(%rbp)
jmp 0x77ec
movq -0x268(%rbp), %rdi
movq 0x4e786(%rip), %rsi     # 0x55f80
callq 0x6480
jmp 0x7801
leaq 0x4f068(%rip), %rdi     # 0x56870
leaq -0x248(%rbp), %rsi
xorl %edx, %edx
callq 0x90c0
jmp 0x7818
leaq 0x31a10(%rip), %rsi     # 0x3922f
leaq -0x248(%rbp), %rdi
callq 0x6420
movq %rax, -0x278(%rbp)
jmp 0x7834
movq -0x278(%rbp), %rdi
movq 0x4e73e(%rip), %rsi     # 0x55f80
callq 0x6480
jmp 0x7849
leaq -0x248(%rbp), %rdi
callq 0x66a0
movl -0x4(%rbp), %eax
addq $0x280, %rsp            # imm = 0x280
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x66a0
movq -0x40(%rbp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: NathanWine[P]2048-AI-Solvers/src/MonteCarlo.cpp
// Function: monteCarloSolve(int, int, int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
int monteCarloSolve(int n, int runs, int display_level,
    std::vector<int> &scores, std::vector<int> &highest_tiles) {

    int successes = 0;
    for (int i = 0; i < n; ++i) {
        std::pair<int, int> result = monteCarloSimulateGame(runs, display_level, Game());
        if (result.first >= WIN) {
            successes++;
        }
        highest_tiles.push_back(result.first);
        scores.push_back(result.second);
    }
    return successes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3f4c
movl -0x8(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x44b0
movl -0x78(%rbp), %edi
movl -0x74(%rbp), %esi
movq -0x70(%rbp), %rdx
callq 0x3b80
movq %rax, -0x68(%rbp)
jmp 0x3ee4
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4460
cmpl $0x800, -0x30(%rbp)     # imm = 0x800
jl 0x3f20
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x3f20
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4460
jmp 0x3f58
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4960
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x4, %rsi
callq 0x4960
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x3eaa
movl -0x24(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: NathanWine[P]2048-AI-Solvers/src/Minimax.cpp
// Function: minimaxSolve(int, int, int, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
int minimaxSolve(int n, int depth, int display_level, 
    std::vector<int> &scores, std::vector<int> &highest_tiles) {

    int successes = 0;
    for (int i = 0; i < n; ++i) {
        std::pair<int, int> result = minimaxSearch(depth, display_level, Game());
        if (result.first >= WIN) {
            successes++;
        }
        highest_tiles.push_back(result.first);
        scores.push_back(result.second);
    }
    return successes;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x7e0c
movl -0x8(%rbp), %eax
movl %eax, -0x78(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x44b0
movl -0x78(%rbp), %edi
movl -0x74(%rbp), %esi
movq -0x70(%rbp), %rdx
callq 0x7760
movq %rax, -0x68(%rbp)
jmp 0x7da4
movq -0x68(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4460
cmpl $0x800, -0x30(%rbp)     # imm = 0x800
jl 0x7de0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x7de0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x4460
jmp 0x7e18
movq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4960
movq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
addq $0x4, %rsi
callq 0x4960
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x7d6a
movl -0x24(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: NathanWine[P]2048-AI-Solvers/src/Main.cpp
// Function: isNumber(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
bool isNumber(const std::string& str) {
    for (char const &c : str) {
        if (std::isdigit(c) == 0) {
            return false;
        }
    }
    return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3240
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x3410
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xb930
testb $0x1, %al
jne 0xa091
jmp 0xa0c2
leaq -0x20(%rbp), %rdi
callq 0xb970
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %edi
callq 0x3220
cmpl $0x0, %eax
jne 0xa0b5
movb $0x0, -0x1(%rbp)
jmp 0xa0c6
jmp 0xa0b7
leaq -0x20(%rbp), %rdi
callq 0xb990
jmp 0xa07e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: NathanWine[P]2048-AI-Solvers/src/Main.cpp
// Function: CmdParser::getCmdOption(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
const std::string& getCmdOption(const std::string &opt) const {
            std::vector<std::string>::const_iterator itr;
            itr =  std::find(cmds.begin(), cmds.end(), opt);
            if (itr != cmds.end() && ++itr != cmds.end()){
                return *itr;
            }
            static const std::string empty_string("");
            return empty_string;
        }

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0xd270
movq -0x68(%rbp), %rdi
callq 0xcd70
movq -0x68(%rbp), %rdi
movq %rax, -0x30(%rbp)
callq 0xcda0
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0xcd20
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
callq 0xcda0
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xcce0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x5d(%rbp)
jne 0xbd73
jmp 0xbd9d
leaq -0x20(%rbp), %rdi
callq 0xd0e0
movq -0x68(%rbp), %rdi
movq %rax, -0x70(%rbp)
callq 0xcda0
movq -0x70(%rbp), %rdi
movq %rax, -0x48(%rbp)
leaq -0x48(%rbp), %rsi
callq 0xcce0
movb %al, -0x5d(%rbp)
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0xbda6
jmp 0xbdb8
leaq -0x20(%rbp), %rdi
callq 0xd190
movq %rax, -0x8(%rbp)
jmp 0xbe57
cmpb $0x0, 0x174a9(%rip)     # 0x23268
jne 0xbe27
leaq 0x174a0(%rip), %rdi     # 0x23268
callq 0x3400
cmpl $0x0, %eax
je 0xbe27
leaq -0x49(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x33e0
movq -0x78(%rbp), %rdx
leaq 0x1745e(%rip), %rdi     # 0x23248
leaq 0xc26e(%rip), %rsi      # 0x1805f
callq 0xbc40
jmp 0xbdf8
leaq -0x49(%rbp), %rdi
callq 0x32c0
movq 0x171b0(%rip), %rdi     # 0x22fb8
leaq 0x17439(%rip), %rsi     # 0x23248
leaq 0x1741a(%rip), %rdx     # 0x23230
callq 0x3200
leaq 0x17446(%rip), %rdi     # 0x23268
callq 0x3160
leaq 0x1741a(%rip), %rax     # 0x23248
movq %rax, -0x8(%rbp)
jmp 0xbe57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x32c0
leaq 0x17418(%rip), %rdi     # 0x23268
callq 0x3150
jmp 0xbe64
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x33d0
nopl (%rax)
// File: NathanWine[P]2048-AI-Solvers/src/Game.cpp
// Function: print_vec(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>)
void print_vec(board v) {
    for (int i = 0; i < (int) v.size(); ++i) {
        for (int j = 0; j < (int) v[i].size(); ++j) {
            std::cout << v[i][j] << " ";
        }
        std::cout << std::endl;
    }
    std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x5f30
movq %rax, %rcx
movl -0x1c(%rbp), %eax
cmpl %ecx, %eax
jge 0xf292
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rdi
movl -0x10(%rbp), %eax
movl %eax, -0x20(%rbp)
movslq -0xc(%rbp), %rsi
callq 0x7fb0
movq %rax, %rdi
callq 0x41e0
movq %rax, %rcx
movl -0x20(%rbp), %eax
cmpl %ecx, %eax
jge 0xf271
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0x7fb0
movq %rax, %rdi
movslq -0x10(%rbp), %rsi
callq 0x4230
movl (%rax), %esi
movq 0x13d76(%rip), %rdi     # 0x22fc8
callq 0x33b0
movq %rax, %rdi
leaq 0x8eb0(%rip), %rsi      # 0x18111
callq 0x3260
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xf20b
movq 0x13d50(%rip), %rdi     # 0x22fc8
movq 0x13d31(%rip), %rsi     # 0x22fb0
callq 0x32a0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xf1e7
movq 0x13d2f(%rip), %rdi     # 0x22fc8
movq 0x13d10(%rip), %rsi     # 0x22fb0
callq 0x32a0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)