LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pixlark[P]Badge/src/builtins.cc
// Function: Builtins::v_mod(Value*)
DEFINE(mod)
	{
		PULL_TWO(n, b);
		if (!n.is(TYPE_INTEGER) || !b.is(TYPE_INTEGER)) {
			fatal("FFI function mod() takes integers");
		}
		return Value::raise(n.integer % b.integer);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x18(%rax), %rax
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
movl $0x1, %esi
callq 0x7800
testb $0x1, %al
jne 0x5d07
jmp 0x5d19
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x7800
testb $0x1, %al
jne 0x5d27
leaq 0xacdb(%rip), %rdi      # 0x109fb
movb $0x0, %al
callq 0x1c50
movl -0x20(%rbp), %eax
movl -0x30(%rbp), %ecx
cltd
idivl %ecx
movl %edx, %edi
callq 0x77b0
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/builtins.cc
// Function: Builtins::v_print(Value*)
DEFINE(print)
	{
		PULL_ONE(v);
		char * s = v.to_string();
		defer { free(s); };
		printf("%s", s);
		return Value::nothing();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5300
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5df0
movq -0x38(%rbp), %rsi
leaq 0xa93a(%rip), %rdi      # 0x106ce
xorl %eax, %eax
callq 0x1030
jmp 0x5d9d
callq 0x7820
movq %rdx, -0x68(%rbp)
movl %eax, -0x60(%rbp)
jmp 0x5dab
movq -0x68(%rbp), %rax
movl -0x60(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5e30
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5e30
movq -0x58(%rbp), %rdi
callq 0x11c0
nopl (%rax)
// File: pixlark[P]Badge/src/builtins.cc
// Function: Builtins::v_println(Value*)
DEFINE(println)
	{
		PULL_ONE(v);
		char * s = v.to_string();
		defer { free(s); };
		printf("%s\n", s);
		return Value::nothing();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movups (%rax), %xmm0
movaps %xmm0, -0x30(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x5300
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x5f00
movq -0x38(%rbp), %rsi
leaq 0xab79(%rip), %rdi      # 0x10a1d
xorl %eax, %eax
callq 0x1030
jmp 0x5ead
callq 0x7820
movq %rdx, -0x68(%rbp)
movl %eax, -0x60(%rbp)
jmp 0x5ebb
movq -0x68(%rbp), %rax
movl -0x60(%rbp), %ecx
movl %ecx, -0x10(%rbp)
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5f40
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x5f40
movq -0x58(%rbp), %rdi
callq 0x11c0
nopl (%rax)
// File: pixlark[P]Badge/src/builtins.cc
// Function: Builtins::lower_from_symbol(char const*)
Builtin_Function lower_from_symbol(Symbol symbol)
	{
		if (0) assert(false);
		CASE("abs", BUILTIN_MATH_ABS);
		CASE("mod", BUILTIN_MATH_MOD);
		CASE("print", BUILTIN_IO_PRINT);
		CASE("println", BUILTIN_IO_PRINTLN);
		else fatal("Foreign function '%s' does not exist!", symbol);
		assert(false); // @linter
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0xa9d6(%rip), %rdi      # 0x10a21
callq 0x1740
movq %rax, %rcx
movq -0x18(%rbp), %rax
cmpq %rcx, %rax
jne 0x6068
movl $0x0, -0x4(%rbp)
jmp 0x611d
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0xa9ae(%rip), %rdi      # 0x10a25
callq 0x1740
movq %rax, %rcx
movq -0x20(%rbp), %rax
cmpq %rcx, %rax
jne 0x6094
movl $0x1, -0x4(%rbp)
jmp 0x611d
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xa986(%rip), %rdi      # 0x10a29
callq 0x1740
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jne 0x60bd
movl $0x2, -0x4(%rbp)
jmp 0x611d
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0xa963(%rip), %rdi      # 0x10a2f
callq 0x1740
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jne 0x60e6
movl $0x3, -0x4(%rbp)
jmp 0x611d
movq -0x10(%rbp), %rsi
leaq 0xa946(%rip), %rdi      # 0x10a37
movb $0x0, %al
callq 0x1c50
jmp 0x60fa
jmp 0x60fc
jmp 0x60fe
leaq 0xa4f7(%rip), %rdi      # 0x105fc
leaq 0xa951(%rip), %rsi      # 0x10a5d
movl $0x63, %edx
leaq 0xa955(%rip), %rcx      # 0x10a6d
callq 0x10d0
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/builtins.cc
// Function: Builtins::get_builtin(char const*)
Builtin * get_builtin(Symbol symbol)
	{
		if (builtin_functions.bound(symbol)) {
			return builtin_functions.lookup(symbol);
		}
		// FFI not yet loaded, allocate and load
		Builtin * ffi = (Builtin*) malloc(sizeof(Builtin));
		Builtin_Function kind = lower_from_symbol(symbol);
		ffi->name = symbol;
		ffi->arg_count = builtin_argument_counts[kind];
		ffi->funcptr = builtin_funcptrs[kind];
		builtin_functions.add(symbol, ffi);
		return ffi;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x11189(%rip), %rdi     # 0x172d0
callq 0x7950
testb $0x1, %al
jne 0x6152
jmp 0x6168
movq -0x10(%rbp), %rsi
leaq 0x11173(%rip), %rdi     # 0x172d0
callq 0x79d0
movq %rax, -0x8(%rbp)
jmp 0x61d9
movl $0x18, %edi
callq 0x11f0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6030
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x10ff7(%rip), %rax     # 0x17190
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
leaq 0x10fff(%rip), %rax     # 0x171b0
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq 0x11104(%rip), %rdi     # 0x172d0
callq 0x7a80
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/main.cc
// Function: load_and_compile_file(Blocks*, char const*)
const char * load_and_compile_file(Blocks * blocks, const char * filename)
{
	const char * source = load_string_from_file(filename);
	if (!source) {
		return NULL;
	}
	Lexer lexer;
	lexer.init(source);
	Parser parser;
	parser.init(&lexer);

	Compiler compiler;
	compiler.init(blocks);
	while (!parser.is(TOKEN_EOF)) {
		// The parser feeds from the lexer and returns one
		// statement's worth of abstract syntax tree
		auto stmt = parser.parse_stmt();
		defer {
			stmt->destroy();
			free(stmt);
		};
		
		// Top-level expects terminators for every statement
		parser.expect('.');

		// Here we generate bytecode from our abstract syntax tree
		// (one statement's worth)
		compiler.compile_stmt(stmt);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1810
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x6224
movq $0x0, -0x8(%rbp)
jmp 0x63a7
movq -0x20(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0x2690
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7af0
movq -0x10(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x7b20
leaq -0x58(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
callq 0x3f70
xorb $-0x1, %al
testb $0x1, %al
jne 0x6267
jmp 0x6325
leaq -0x58(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x4bd0
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0xa0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x63c0
movq -0x110(%rbp), %rdi
movl $0x2e, %esi
callq 0x73f0
movq %rdx, -0x108(%rbp)
movq %rax, -0x100(%rbp)
jmp 0x62c0
movq -0x108(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movq %rax, -0xc8(%rbp)
movq -0x98(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x7b90
jmp 0x62f1
leaq -0xa0(%rbp), %rdi
callq 0x6400
jmp 0x624e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xb8(%rbp)
movl %eax, -0xbc(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x6400
jmp 0x63b4
callq 0x7820
movl %eax, -0xf8(%rbp)
movq %rdx, -0xf0(%rbp)
movl -0xf8(%rbp), %edx
movq -0xf0(%rbp), %rcx
leaq -0xe8(%rbp), %rdi
movl $0x2, %esi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0x7fd0
leaq -0x90(%rbp), %rdi
leaq -0xe8(%rbp), %rax
movq (%rax), %rcx
movq %rcx, (%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x7f70
leaq -0x90(%rbp), %rdi
callq 0x8010
leaq -0x90(%rbp), %rdi
callq 0x80b0
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0xb8(%rbp), %rdi
callq 0x11c0
// File: pixlark[P]Badge/src/main.cc
// Function: main
int main(int argc, char ** argv)
{	
	if (argc != 2) {
		fatal("Provide one source file");
	}

	Files::init(argv[1]);
	Global_Alloc::init();
	Intern::init();
	GC::init();
	Builtins::init();
	Assoc_Allocator::init();
	
	work_from_source(argv[1]);

	Assoc_Allocator::destroy();
	Builtins::destroy();
	GC::destroy();
	Intern::destroy();
	Global_Alloc::destroy();
	Files::destroy();
	
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
je 0x66da
leaq 0xa42c(%rip), %rdi      # 0x10aff
movb $0x0, %al
callq 0x1c50
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1fe0
callq 0x1360
callq 0x16a0
callq 0x5090
callq 0x5f90
callq 0x1a20
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x6430
callq 0x1a60
callq 0x5fd0
callq 0x50d0
callq 0x16e0
callq 0x13a0
callq 0x22a0
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/list.cc
// Function: List<void*>::alloc(Allocator)
void List<T>::alloc(Allocator allocator)
{
	size = 0;
	capacity = List::initial_size;
	this->allocator = allocator;
	arr = (T*) allocator.__malloc(sizeof(T) * capacity);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq $0x0, 0x8(%rcx)
movq $0x4, 0x10(%rcx)
movq -0x10(%rbp), %rax
movq %rax, 0x18(%rcx)
movq -0x8(%rbp), %rax
movq %rax, 0x20(%rcx)
movq -0x10(%rbp), %rax
movq 0x10(%rcx), %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr::destroy()
void destroy()
	{
		switch (kind) {
		case EXPR_NOTHING:
			break;
		case EXPR_INTEGER:
			break;
		case EXPR_STRING:
			break;
		case EXPR_VARIABLE:
			break;
		case EXPR_UNARY:
			unary.destroy();
			break;
		case EXPR_BINARY:
			binary.destroy();
			break;
		case EXPR_SCOPE:
			scope.destroy();
			break;
		case EXPR_LAMBDA:
			lambda.destroy();
			break;
		case EXPR_FUNCALL:
			funcall.destroy();
			break;
		case EXPR_IF:
			if_expr.destroy();
			break;
		case EXPR_DIRECTIVE:
			directive.destroy();
			break;
		case EXPR_THIS:
			break;
		case EXPR_FIELD:
			field.destroy();
			break;
		case EXPR_LOOP:
			loop.destroy();
			break;
		case EXPR_ON:
			on.destroy();
			break;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0xe, %rax
ja 0x71d5
movq -0x10(%rbp), %rax
leaq 0x917d(%rip), %rcx      # 0x1029c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x71d5
jmp 0x71d5
jmp 0x71d5
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3290
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x32c0
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3310
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3450
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3490
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3580
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3680
jmp 0x71d5
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3700
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3730
jmp 0x71d5
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
callq 0x3760
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/ast.cc
// Function: Expr::with_kind(Expr_Kind, int)
static Expr * with_kind(Expr_Kind kind, Assoc_Ptr assoc)
	{
		Expr * expr = (Expr*) malloc(sizeof(Expr));
		expr->kind = kind;
		expr->assoc = assoc;
		return expr;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl $0x60, %edi
callq 0x11f0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movl -0x8(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/value-def.cc
// Function: Function::gc_mark()
void gc_mark()
	{
		GC::mark_opaque(parameters);
		if (!GC::is_marked_opaque(closure)) {
			GC::mark_opaque(closure);
			closure->gc_mark();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq (%rax), %rdi
callq 0x5190
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x51b0
testb $0x1, %al
jne 0x7727
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5190
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/map.cc
// Function: Map<char const*, Builtin*>::bound(char const*)
bool Map<K, V>::bound(K key)
{
	for (int i = 0; i < keys.size; i++) {
		if (comparator(keys[i], key)) {
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x1c(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x79be
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq (%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
testb $0x1, %al
jne 0x79ab
jmp 0x79b1
movb $0x1, -0x1(%rbp)
jmp 0x79c2
jmp 0x79b3
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x796f
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/map.cc
// Function: Map<char const*, Builtin*>::lookup(char const*)
V Map<K, V>::lookup(K key)
{
	for (int i = 0; i < keys.size; i++) {
		if (comparator(keys[i], key)) {
			return values[i];
		}
	}
	assert("Not bound in Map!" && 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0x7a52
movq -0x20(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x28(%rbp)
addq $0x8, %rdi
movslq -0x14(%rbp), %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq (%rcx), %rdi
movq -0x10(%rbp), %rsi
callq *%rax
testb $0x1, %al
jne 0x7a2b
jmp 0x7a45
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
movslq -0x14(%rbp), %rsi
callq 0x78c0
movq (%rax), %rax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x7a47
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x79ef
leaq 0x99bb(%rip), %rdi      # 0x11414
leaq 0x99cd(%rip), %rsi      # 0x1142d
movl $0x5b, %edx
leaq 0x9d8f(%rip), %rcx      # 0x117fb
callq 0x10d0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/map.cc
// Function: Map<char const*, Builtin*>::add(char const*, Builtin*)
bool Map<K, V>::add(K key, V value)
{
	if (bound(key)) {
		return false;
	}
	keys.push(key);
	values.push(value);
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
callq 0x7950
testb $0x1, %al
jne 0x7aab
jmp 0x7ab1
movb $0x0, -0x1(%rbp)
jmp 0x7ad7
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movq -0x18(%rbp), %rsi
callq 0x6f20
movq -0x28(%rbp), %rdi
addq $0x30, %rdi
movq -0x20(%rbp), %rsi
callq 0xf120
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pixlark[P]Badge/src/bytecode.cc
// Function: BC::create(BC_Kind, Value, int)
static BC create(BC_Kind kind, Value arg, Assoc_Ptr assoc)
	{
		BC bc;
		bc.kind = kind;
		bc.arg.value = arg;
		bc.assoc = assoc;
		return bc;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %edx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movl %esi, -0x14(%rbp)
movl %r8d, -0x18(%rbp)
movl -0x14(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movq -0x8(%rbp), %rcx
movq %rcx, 0x10(%rdi)
movl -0x18(%rbp), %ecx
movl %ecx, 0x4(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pixlark[P]Badge/src/compiler.cc
// Function: Compiler::finalize()
void finalize()
	{
		BC * final_bc = (BC*) malloc(sizeof(BC) * bytecode.size);
		for (int i = 0; i < bytecode.size; i++) {
			final_bc[i] = bytecode[i];
		}
		blocks->finalize_block(block_reference, final_bc, bytecode.size);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
imulq $0x18, 0x8(%rax), %rdi
callq 0x11f0
movq %rax, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movslq -0x14(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0x8087
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0xc470
movq %rax, %rcx
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rdx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8039
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rdi
movq 0x30(%rax), %rsi
movq -0x10(%rbp), %rdx
movq 0x8(%rax), %rcx
callq 0xc9d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/environment.cc
// Function: Environment::alloc()
static Environment * alloc()
	{
		Environment * env = (Environment*) GC::alloc(sizeof(Environment));
		env->names.alloc();
		env->values.alloc();
		env->next_env = NULL;
		return env;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x58, %edi
callq 0x5130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xcbf0
movq -0x8(%rbp), %rdi
addq $0x28, %rdi
callq 0xcc30
movq -0x8(%rbp), %rax
movq $0x0, 0x50(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::init(Blocks*, Environment*, unsigned long)
void init(Blocks * blocks, Environment * export_scope, size_t block_reference)
	{
		this->blocks = blocks;
		this->export_scope = export_scope;

		export_queue.alloc();
		stack.alloc();
		
		call_stack.alloc();
		call_stack.push(Call_Frame::alloc(blocks, block_reference, NULL, NULL));
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq 0xefb6(%rip), %rax      # 0x171e0
movq %rax, -0x30(%rbp)
movq 0xefb3(%rip), %rax      # 0x171e8
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0xccd0
movq -0x60(%rbp), %rdi
addq $0x38, %rdi
movq 0xef8b(%rip), %rax      # 0x171e0
movq %rax, -0x40(%rbp)
movq 0xef88(%rip), %rax      # 0x171e8
movq %rax, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
callq 0xcc70
movq -0x60(%rbp), %rdi
addq $0x60, %rdi
movq 0xef60(%rip), %rax      # 0x171e0
movq %rax, -0x50(%rbp)
movq 0xef5d(%rip), %rax      # 0x171e8
movq %rax, -0x48(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
callq 0xcd30
movq -0x60(%rbp), %rax
addq $0x60, %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
movq %rcx, %rdx
callq 0xcde0
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0xcd90
addq $0x60, %rsp
popq %rbp
retq
nop
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::destroy()
void destroy()
	{
		export_queue.dealloc();
		stack.dealloc();
		// The call stack should be empty if we're destructing
		assert(call_stack.size == 0);
		call_stack.dealloc();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x10, %rdi
callq 0xe5f0
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
callq 0xe630
movq -0x10(%rbp), %rax
cmpq $0x0, 0x68(%rax)
jne 0x9e27
jmp 0x9e46
leaq 0x76b6(%rip), %rdi      # 0x114e4
leaq 0x7191(%rip), %rsi      # 0x10fc6
movl $0x66, %edx
leaq 0x76b8(%rip), %rcx      # 0x114f9
callq 0x10d0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xe670
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::mark_reachable()
void mark_reachable()
	{
		GC::mark_opaque(export_scope);
		export_scope->gc_mark();
		for (int i = 0; i < call_stack.size; i++) {
			call_stack[i]->gc_mark();
		}
		for (int i = 0; i < stack.size; i++) {
			stack[i].gc_mark();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x8(%rax), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa050
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x68(%rcx), %rax
jae 0x9f53
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
movslq -0xc(%rbp), %rsi
callq 0xdb80
movq (%rax), %rdi
callq 0xe6b0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9f21
movl $0x0, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movslq -0x10(%rbp), %rax
cmpq 0x40(%rcx), %rax
jae 0x9f8c
movq -0x18(%rbp), %rdi
addq $0x38, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa140
movq %rax, %rdi
callq 0x5470
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x9f5a
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pixlark[P]Badge/src/blocks.cc
// Function: Blocks::destroy()
void destroy()
	{
		for (int i = 0; i < blocks.size; i++) {
			free(blocks[i]);
		}
		blocks.dealloc();
		sizes.dealloc();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xa029
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rsi
callq 0xca30
movq (%rax), %rdi
callq 0x11e8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x9ffb
movq -0x18(%rbp), %rdi
callq 0xe740
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xe780
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: pixlark[P]Badge/src/environment.cc
// Function: Environment::gc_mark()
void gc_mark()
	{
		names.gc_mark();
		values.gc_mark();
		for (int i = 0; i < values.size; i++) {
			values[i].gc_mark();
		}
		if (next_env) {
			GC::mark_opaque(next_env);
			next_env->gc_mark();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0xa0e0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0xa110
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x30(%rcx), %rax
jae 0xa0af
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
movslq -0xc(%rbp), %rsi
callq 0xa140
movq %rax, %rdi
callq 0x5470
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa07d
movq -0x18(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xa0d4
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0xa050
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pixlark[P]Badge/src/list.cc
// Function: List<BC*>::resize(unsigned long)
void List<T>::resize(size_t new_capacity)
{
	assert(new_capacity >= size);
	T * new_arr = (T*) allocator.__malloc(sizeof(T) * new_capacity);
	memcpy(new_arr, arr, sizeof(T) * size);
	allocator.__free(arr);
	arr = new_arr;
	capacity = new_capacity;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq 0x8(%rcx), %rax
jb 0xa494
jmp 0xa4b3
leaq 0x6729(%rip), %rdi      # 0x10bc4
leaq 0x66c7(%rip), %rsi      # 0x10b69
movl $0x4a, %edx
leaq 0x672b(%rip), %rcx      # 0x10bd9
callq 0x10d0
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdi
shlq $0x3, %rdi
callq *%rax
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq (%rax), %rsi
movq 0x8(%rax), %rdx
shlq $0x3, %rdx
callq 0x10e0
movq -0x20(%rbp), %rcx
movq 0x20(%rcx), %rax
movq (%rcx), %rdi
callq *%rax
movq -0x20(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pixlark[P]Badge/src/bytecode.cc
// Function: BC::create(BC_Kind, unsigned long, int)
static BC create(BC_Kind kind, size_t arg, Assoc_Ptr assoc)
	{
		BC bc;
		bc.kind = kind;
		bc.arg.block_reference = arg;
		bc.assoc = assoc;
		return bc;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rdi)
movl -0x14(%rbp), %ecx
movl %ecx, 0x4(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/bytecode.cc
// Function: BC::create(BC_Kind, int, int)
static BC create(BC_Kind kind, int arg, Assoc_Ptr assoc)
	{
		BC bc;
		bc.kind = kind;
		bc.arg.integer = arg;
		bc.assoc = assoc;
		return bc;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movl %esi, -0x4(%rbp)
movl %edx, -0x8(%rbp)
movl %ecx, -0xc(%rbp)
movl -0x4(%rbp), %ecx
movl %ecx, (%rdi)
movl -0x8(%rbp), %ecx
movl %ecx, 0x8(%rdi)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4(%rdi)
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: Call_Frame::alloc(Blocks*, unsigned long, Function*, Environment*)
static Call_Frame * alloc(Blocks * blocks, size_t block_reference,
							  Function * origin, Environment * closure)
	{
		Call_Frame * frame = (Call_Frame*) malloc(sizeof(Call_Frame));
		frame->origin = origin;
		frame->environment = Environment::alloc();
		frame->environment->next_env = closure;
		frame->block_reference = block_reference;

		frame->call_flags = Environment::alloc();
	
		frame->bytecode = blocks->retrieve_block(block_reference);
		frame->bc_pointer = 0;
		frame->bc_length = blocks->size_block(block_reference);

		frame->body_stack.alloc();
		return frame;
	}

// 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)
movl $0x60, %edi
callq 0x11f0
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, (%rax)
callq 0x8140
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x50(%rax)
movq -0x10(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
callq 0x8140
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd000
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x28(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xd060
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movq 0xa348(%rip), %rax      # 0x171e0
movq %rax, -0x38(%rbp)
movq 0xa345(%rip), %rax      # 0x171e8
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0xc3c0
movq -0x28(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::do_halting_tasks()
void do_halting_tasks()
	{
		// Push exported names to export_scope
		for (int i = 0; i < export_queue.size; i++) {
			auto _export = export_queue[i];
			current_assoc = _export.assoc;
			auto val = resolve_binding(_export.symbol);
			export_scope->create_binding(_export.symbol, val);
		}
		// Clear out the stack so that the garbage
		// collector can clean everything up
		size_t remaining = stack.size;
		for (int i = 0; i < remaining; i++) {
			pop();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x68(%rbp), %rcx
movslq -0xc(%rbp), %rax
cmpq 0x18(%rcx), %rax
jae 0xd1ab
movq -0x68(%rbp), %rdi
addq $0x10, %rdi
movslq -0xc(%rbp), %rsi
callq 0xdbe0
movq -0x68(%rbp), %rdi
movq (%rax), %rcx
movq %rcx, -0x20(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl %eax, 0x88(%rdi)
movq -0x20(%rbp), %rsi
callq 0xd510
movl %eax, %ecx
movq -0x68(%rbp), %rax
movl %ecx, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0xdc40
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xd12b
movq -0x68(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x4c(%rbp)
movslq -0x4c(%rbp), %rax
cmpq -0x48(%rbp), %rax
jae 0xd1e3
movq -0x68(%rbp), %rdi
callq 0xd240
movl %eax, -0x60(%rbp)
movq %rdx, -0x58(%rbp)
movl -0x4c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4c(%rbp)
jmp 0xd1be
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::return_function()
void return_function()
	{
		GC::heuristic_return();
		auto frame = call_stack.pop();
		frame->destroy();
		free(frame);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x5030
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0xdf60
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0xdfd0
movq -0x10(%rbp), %rdi
callq 0x11e8
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::create_binding(char const*, Value)
void create_binding(Symbol symbol, Value value)
	{
		auto frame = frame_reference();
		bool success = frame->environment->create_binding(symbol, value);
		if (!success) {
			error("Can't create new variable '%s' -- already bound in this scope!",
				  symbol);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edx, -0x10(%rbp)
movq %rcx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0xd0b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0xdc40
andb $0x1, %al
movb %al, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0xd361
movq -0x48(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3fa4(%rip), %rsi      # 0x112fe
movb $0x0, %al
callq 0xd470
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: pixlark[P]Badge/src/environment.cc
// Function: Environment::update_binding(char const*, Value)
bool update_binding(Symbol symbol, Value value)
	{
		assert(names.size == values.size);
		for (int i = 0; i < names.size; i++) {
			if (symbol == names[i]) {
				values[i] = value;
				return true;
			}
		}
		if (next_env) {
			return next_env->update_binding(symbol, value);
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x30(%rcx), %rax
jne 0xd39b
jmp 0xd3ba
leaq 0x3e59(%rip), %rdi      # 0x111fb
leaq 0x3e6c(%rip), %rsi      # 0x11215
movl $0x36, %edx
leaq 0x3f88(%rip), %rcx      # 0x1133d
callq 0x10d0
movl $0x0, -0x2c(%rbp)
movq -0x48(%rbp), %rcx
movslq -0x2c(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xd423
movq -0x48(%rbp), %rdi
movq -0x28(%rbp), %rax
movq %rax, -0x50(%rbp)
movslq -0x2c(%rbp), %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x50(%rbp), %rax
cmpq (%rcx), %rax
jne 0xd416
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xa140
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xd461
jmp 0xd418
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd3c1
movq -0x48(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xd45d
movq -0x48(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl -0x40(%rbp), %edx
movq -0x38(%rbp), %rcx
callq 0xd370
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xd461
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::resolve_binding(char const*)
Value resolve_binding(Symbol symbol)
	{
		auto frame = frame_reference();
		Value value;
		if (frame->environment->resolve_binding(symbol, &value)) {
			return value;
		}
		// TODO(pixlark): Make it so that every environment implicity
		// links to the global environment, thus removing the need for
		// this call frame?
		auto global = call_stack[0];
		if (global->environment->resolve_binding(symbol, &value)) {
			return value;
		}
		// Finally, check in our export scope
		if (export_scope->resolve_binding(symbol, &value)) {
			return value;
		}
		error("Variable '%s' is not bound", symbol);
		assert(false); // @linter
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0xd0b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe1f0
testb $0x1, %al
jne 0xd54c
jmp 0xd551
jmp 0xd5d8
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xdb80
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe1f0
testb $0x1, %al
jne 0xd584
jmp 0xd586
jmp 0xd5d8
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe1f0
testb $0x1, %al
jne 0xd5a1
jmp 0xd5a3
jmp 0xd5d8
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3dbb(%rip), %rsi      # 0x1136d
movb $0x0, %al
callq 0xd470
leaq 0x303c(%rip), %rdi      # 0x105fc
leaq 0x39ff(%rip), %rsi      # 0x10fc6
movl $0xb8, %edx
leaq 0x3db5(%rip), %rcx      # 0x11388
callq 0x10d0
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: pixlark[P]Badge/src/map.cc
// Function: Map<char const*, Value>::update(char const*, Value)
bool Map<K, V>::update(K key, V value)
{
	for (int i = 0; i < keys.size; i++) {
		if (comparator(keys[i], key)) {
			values[i] = value;
			return true;
		}
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x38(%rbp), %rcx
movslq -0x2c(%rbp), %rax
cmpq 0x10(%rcx), %rax
jae 0xda05
movq -0x38(%rbp), %rdi
movq (%rdi), %rax
movq %rax, -0x40(%rbp)
addq $0x8, %rdi
movslq -0x2c(%rbp), %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq (%rcx), %rdi
movq -0x28(%rbp), %rsi
callq *%rax
testb $0x1, %al
jne 0xd9d2
jmp 0xd9f8
movq -0x38(%rbp), %rdi
addq $0x30, %rdi
movslq -0x2c(%rbp), %rsi
callq 0xa140
movq -0x18(%rbp), %rcx
movq %rcx, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xda09
jmp 0xd9fa
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xd996
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: pixlark[P]Badge/src/vm.cc
// Function: VM::lookup_call_flag(char const*)
Value lookup_call_flag(Symbol symbol)
	{
		for (int i = call_stack.size - 1; i >= 0; i--) {
			auto frame = call_stack[i];
			Value value;
			if (frame->call_flags->resolve_binding(symbol, &value)) {
				return value;
			}
		}
		error("Call flag '%s' is not bound", symbol);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x68(%rax), %rax
subq $0x1, %rax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jl 0xdb66
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movslq -0x24(%rbp), %rsi
callq 0xdb80
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x20(%rbp), %rsi
leaq -0x10(%rbp), %rdx
callq 0xe1f0
testb $0x1, %al
jne 0xdb4c
jmp 0xdb59
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
jmp 0xdb5b
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xdb13
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rdx
leaq 0x3953(%rip), %rsi      # 0x114c8
movb $0x0, %al
callq 0xd470
ud2
nop
// File: pixlark[P]Badge/src/environment.cc
// Function: Environment::create_binding(char const*, Value)
bool create_binding(Symbol symbol, Value value)
	{
		assert(names.size == values.size);
		// TODO(pixlark): Do we want to be able to shadow closed
		// variables? Probably...
		if (is_bound(symbol, false)) {
			return false;
		}
		names.push(symbol);
		values.push(value);
		return true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edx, -0x18(%rbp)
movq %rcx, -0x10(%rbp)
movq %rdi, -0x20(%rbp)
movq %rsi, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq %rcx, -0x40(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x30(%rcx), %rax
jne 0xdc6b
jmp 0xdc8a
leaq 0x3589(%rip), %rdi      # 0x111fb
leaq 0x359c(%rip), %rsi      # 0x11215
movl $0x2a, %edx
leaq 0x35a3(%rip), %rcx      # 0x11228
callq 0x10d0
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
xorl %edx, %edx
callq 0xdcf0
testb $0x1, %al
jne 0xdc9f
jmp 0xdca5
movb $0x0, -0x1(%rbp)
jmp 0xdcda
movq -0x40(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x6f20
movq -0x40(%rbp), %rdi
addq $0x28, %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x38(%rbp), %esi
movq -0x30(%rbp), %rdx
callq 0xddc0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: pixlark[P]Badge/src/environment.cc
// Function: Environment::is_bound(char const*, bool)
bool is_bound(Symbol symbol, bool recurse=true)
	{
		assert(names.size == values.size);
		for (int i = 0; i < names.size; i++) {
			if (symbol == names[i]) {
				return true;
			}
		}
		if (recurse && next_env) {
			return next_env->is_bound(symbol);
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x30(%rcx), %rax
jne 0xdd1b
jmp 0xdd3a
leaq 0x34d9(%rip), %rdi      # 0x111fb
leaq 0x34ec(%rip), %rsi      # 0x11215
movl $0x1d, %edx
leaq 0x3523(%rip), %rcx      # 0x11258
callq 0x10d0
movl $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rcx
movslq -0x20(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xdd83
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movslq -0x20(%rbp), %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq (%rcx), %rax
jne 0xdd76
movb $0x1, -0x1(%rbp)
jmp 0xddb5
jmp 0xdd78
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xdd41
testb $0x1, -0x19(%rbp)
je 0xddb1
movq -0x28(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xddb1
movq -0x28(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0xdcf0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xddb5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: pixlark[P]Badge/src/environment.cc
// Function: Environment::resolve_binding(char const*, Value*)
bool resolve_binding(Symbol symbol, Value * value)
	{
		assert(names.size == values.size);
		for (int i = 0; i < names.size; i++) {
			if (symbol == names[i]) {
				*value = values[i];
				return true;
			}
		}
		if (next_env) {
			return next_env->resolve_binding(symbol, value);
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq %rcx, -0x30(%rbp)
movq 0x8(%rcx), %rax
cmpq 0x30(%rcx), %rax
jne 0xe218
jmp 0xe237
leaq 0x2fdc(%rip), %rdi      # 0x111fb
leaq 0x2fef(%rip), %rsi      # 0x11215
movl $0x44, %edx
leaq 0x3178(%rip), %rcx      # 0x113aa
callq 0x10d0
movl $0x0, -0x24(%rbp)
movq -0x30(%rbp), %rcx
movslq -0x24(%rbp), %rax
cmpq 0x8(%rcx), %rax
jae 0xe2a6
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x38(%rbp)
movslq -0x24(%rbp), %rsi
callq 0x6e80
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq (%rcx), %rax
jne 0xe299
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movslq -0x24(%rbp), %rsi
callq 0xa140
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
movb $0x1, -0x1(%rbp)
jmp 0xe2d1
jmp 0xe29b
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0xe23e
movq -0x30(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xe2cd
movq -0x30(%rbp), %rax
movq 0x50(%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xe1f0
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xe2d1
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/vm.cc
// Function: Call_Frame::gc_mark()
void gc_mark()
	{
		if (origin) {
			GC::mark_opaque(origin);
			origin->gc_mark();
		}
		// TODO(pixlark): Why do we check if this is marked opaque??
		// The whole point is that we just do it regardless...
		if (!GC::is_marked_opaque(environment)) {
			GC::mark_opaque(environment);
			environment->gc_mark();
		}
		if (!GC::is_marked_opaque(call_flags)) {
			GC::mark_opaque(call_flags);
			call_flags->gc_mark();
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0xe6e2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x5190
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x76e0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x51b0
testb $0x1, %al
jne 0xe70d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5190
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0xa050
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x51b0
testb $0x1, %al
jne 0xe738
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x5190
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0xa050
addq $0x10, %rsp
popq %rbp
retq
nop
// File: ArashPartow[P]exprtk-extras/exprtk_vector_benchmark_multithreaded.cpp
// Function: main
int main(int argc, char* argv[])
{
   const std::size_t vec_size     = ((argc >= 2) ? atoi(argv[1]) : 100000);
   const std::size_t thread_count = ((argc == 3) ? atoi(argv[2]) : 1     );

   if (thread_count > 36)
      return -1;

   run_threaded_benchmark<double>(vec_size,thread_count);

   return 0;
}

// Assembly:
subq $0x28, %rsp
movl $0x0, 0x24(%rsp)
movl %edi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpl $0x2, 0x20(%rsp)
jl 0x11c4c0
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x113270
movl %eax, 0x4(%rsp)
jmp 0x11c4cb
movl $0x186a0, %eax          # imm = 0x186A0
movl %eax, 0x4(%rsp)
jmp 0x11c4cb
movl 0x4(%rsp), %eax
cltq
movq %rax, 0x10(%rsp)
cmpl $0x3, 0x20(%rsp)
jne 0x11c4f0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x113270
movl %eax, (%rsp)
jmp 0x11c4fa
movl $0x1, %eax
movl %eax, (%rsp)
jmp 0x11c4fa
movl (%rsp), %eax
cltq
movq %rax, 0x8(%rsp)
cmpq $0x24, 0x8(%rsp)
jbe 0x11c516
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x11c52d
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x11c860
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: XuhuiSun95[P]Ticket-Booking-Service/server/Server.cpp
// Function: Server::Server(std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int> const&, std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int> const&)
Server::Server(const std::pair<std::string, int> &server,
               const std::pair<std::string, int> &pair) {

    mTickets = 50;
    mServer = new ServerSocket();
    mServerInfo = server;
    mPairInfo = pair;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x2d20
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x30(%rbp)
callq 0x2d20
jmp 0x25fc
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
callq 0x2d50
movq -0x38(%rbp), %rax
movl $0x32, (%rax)
movl $0x41c, %edi            # imm = 0x41C
callq 0x2200
movq %rax, -0x48(%rbp)
jmp 0x2623
movq -0x48(%rbp), %rdi
callq 0x5200
jmp 0x262e
movq -0x38(%rbp), %rdi
movq -0x48(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x10(%rbp), %rsi
addq $0x10, %rdi
callq 0x2d70
jmp 0x2649
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x38, %rdi
callq 0x2d70
jmp 0x265c
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x269c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2693
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x21e0
movq -0x30(%rbp), %rdi
callq 0x2db0
movq -0x40(%rbp), %rdi
callq 0x2db0
movq -0x20(%rbp), %rdi
callq 0x2350
nop
// File: XuhuiSun95[P]Ticket-Booking-Service/server/Server.cpp
// Function: Server::Run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void Server::Run(const std::string &type) {

    mServer->Init(mServerInfo.first, mServerInfo.second, true);

    while(true) {

        int sockfd = mServer->Accept();
        std::thread t(&Server::ProcessTicket, this, sockfd, type);
        t.detach();
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x50(%rbp)
movq 0x8(%rdx), %rdi
movq %rdx, %rsi
addq $0x10, %rsi
addq $0x10, %rdx
addq $0x20, %rdx
movl $0x1, %ecx
callq 0x5270
movq -0x50(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5460
movl %eax, %ecx
movq -0x50(%rbp), %rax
movl %ecx, -0x14(%rbp)
leaq 0x6e(%rip), %rcx        # 0x27d0
movq %rcx, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %r8
leaq -0x20(%rbp), %rdi
movq %rdi, -0x58(%rbp)
leaq -0x30(%rbp), %rsi
leaq -0x38(%rbp), %rdx
leaq -0x14(%rbp), %rcx
callq 0x2dd0
movq -0x58(%rbp), %rdi
callq 0x2340
jmp 0x279a
leaq -0x20(%rbp), %rdi
callq 0x2ea0
jmp 0x2745
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x2ea0
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)