LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_if()
Expr * Parser::parse_if()
{
	if (match(TOKEN_IF)) {
		auto expr = create_expr(EXPR_IF);
		expr->if_expr.conditions.alloc();
		expr->if_expr.expressions.alloc();
		do {
			expr->if_expr.conditions.push(parse_expr());
			expect(TOKEN_THEN);
			expr->if_expr.expressions.push(parse_expr());
		} while (match(TOKEN_ELIF));
		if (match(TOKEN_ELSE)) {
			expr->if_expr.else_expr = parse_expr();
		} else {
			expr->if_expr.else_expr = NULL;
		}
		return expr;
	} else {
		return parse_loop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x10d, 0x8(%rdi)       # imm = 0x10D
jne 0x3c3e
movq (%rbx), %rdi
callq 0x240c
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
shrq $0x20, %r15
movl $0x60, %edi
callq 0x1200
movq %rax, %r14
movq 0xc471(%rip), %rax      # 0xffd0
movl $0x9, (%r14)
movl %r15d, 0x4(%r14)
leaq 0x8(%r14), %r15
xorl %ecx, %ecx
movq %rcx, 0x10(%r14)
movl $0x4, %ecx
movq %rcx, 0x18(%r14)
movq %rax, 0x20(%r14)
movq 0xc440(%rip), %r13      # 0xffc8
movq %r13, 0x28(%r14)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x8(%r14)
leaq 0x30(%r14), %r12
xorl %eax, %eax
movq %rax, 0x38(%r14)
movl $0x4, %eax
movq %rax, 0x40(%r14)
movq 0xc41c(%rip), %rax      # 0xffd0
movq %rax, 0x48(%r14)
movq %r13, 0x50(%r14)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x30(%r14)
movq %rbx, %rdi
callq 0x3dfe
movq %r15, %rdi
movq %rax, %rsi
callq 0x5394
movq %rbx, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x343a
movq %rbx, %rdi
callq 0x3dfe
movq %r12, %rdi
movq %rax, %rsi
callq 0x5394
movl 0x8(%rbx), %eax
cmpl $0x10f, %eax            # imm = 0x10F
jne 0x3c19
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
jmp 0x3bca
cmpl $0x110, %eax            # imm = 0x110
jne 0x3c54
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x58(%r14)
jmp 0x3c5c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3aa6
movq $0x0, 0x58(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_on()
Expr * Parser::parse_on()
{
	if (match(TOKEN_ON)) {
		auto expr = create_expr(EXPR_ON);
		expr->on.to_bind = expect(TOKEN_SYMBOL).values.symbol;
		expr->on.body = parse_expr();
		return expr;
	} else {
		return parse_if();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x115, 0x8(%rdi)       # imm = 0x115
jne 0x3cdd
movq (%rbx), %rdi
callq 0x240c
movq %rax, %r14
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
shrq $0x20, %r14
movl $0x60, %edi
callq 0x1200
movq %rax, %r15
movl $0xe, (%rax)
movl %r14d, 0x4(%rax)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x343a
movq %rdx, 0x8(%r15)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x10(%r15)
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3b16
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_directive()
Expr * Parser::parse_directive()
{
	if (match('@')) {
		auto expr = create_expr(EXPR_DIRECTIVE);
		expr->directive.name = expect(TOKEN_SYMBOL).values.symbol;
		expr->directive.arguments.alloc();
		expect('[');
		while (true) {
			if (match(']')) {
				break;
			}
			expr->directive.arguments.push(parse_expr());
			if (!match(',')) {
				expect(']');
				break;
			}
		}
		return expr;
	} else {
		return parse_on();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x40, 0x8(%rdi)
jne 0x3dd5
movq (%rbx), %rdi
callq 0x240c
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
shrq $0x20, %r15
movl $0x60, %edi
callq 0x1200
movq %rax, %r14
movq 0xc29d(%rip), %r12      # 0xffd0
movl $0xa, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x343a
movq %rdx, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq $0x4, 0x20(%r14)
movq %r12, 0x28(%r14)
movq 0xc25f(%rip), %rax      # 0xffc8
movq %rax, 0x30(%r14)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x343a
cmpl $0x5d, 0x8(%rbx)
je 0x3dc3
movq %r14, %r15
addq $0x10, %r15
movq %rbx, %rdi
callq 0x3dfe
movq %r15, %rdi
movq %rax, %rsi
callq 0x5394
cmpl $0x2c, 0x8(%rbx)
jne 0x3de5
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
cmpl $0x5d, %eax
jne 0x3d95
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
jmp 0x3df2
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3c6e
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x343a
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_scope()
Expr * Parser::parse_scope()
{
	if (match('{')) {
		auto scope = create_expr(EXPR_SCOPE);
		scope->scope.body.alloc();
		scope->scope.terminator = NULL;
		while (!match('}')) {
			auto stmt = parse_stmt();
			if (stmt->kind == STMT_EXPR && match('}')) {
				scope->scope.terminator = stmt->expr;
				free(stmt);
				break;
			}
			expect('.');
			scope->scope.body.push(stmt);
		}
		return scope;
	} else {
		return parse_directive();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x7b, 0x8(%rdi)
jne 0x3ed2
movq (%rbx), %rdi
callq 0x240c
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rax, %r12
shrq $0x20, %r12
movl $0x60, %edi
callq 0x1200
movq %rax, %r14
movq 0xc18c(%rip), %rax      # 0xffd0
movl $0x6, (%r14)
movl %r12d, 0x4(%r14)
xorl %r12d, %r12d
movq %r12, 0x10(%r14)
movq $0x4, 0x18(%r14)
movq %rax, 0x20(%r14)
movq 0xc15f(%rip), %rax      # 0xffc8
movq %rax, 0x28(%r14)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x8(%r14)
movq %r12, 0x30(%r14)
cmpl $0x7d, %r15d
je 0x3ec0
movq %r14, %r15
addq $0x8, %r15
movq %rbx, %rdi
callq 0x3f10
movq %rax, %r12
cmpl $0x3, (%rax)
jne 0x3ea2
cmpl $0x7d, 0x8(%rbx)
je 0x3ee2
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x343a
movq %r15, %rdi
movq %r12, %rsi
callq 0x54ae
cmpl $0x7d, 0x8(%rbx)
jne 0x3e8c
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
jmp 0x3f03
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3cf0
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x30(%r14)
movq %r12, %rdi
callq 0x11f8
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_stmt()
Stmt * Parser::parse_stmt()
{
	Stmt * stmt;
	if (is(TOKEN_LET)) {
		stmt = parse_let();
	} else if (is(TOKEN_SET)) {
		stmt = parse_set();
	} else if (is(TOKEN_RETURN)) {
		stmt = parse_return();
	} else if (is(TOKEN_BREAK)) {
		stmt = parse_break();
	} else if (is(TOKEN_FUNC)) {
        stmt = parse_func();
    } else {
		stmt = create_stmt(STMT_EXPR);
		stmt->expr = parse_expr();
	}
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x107, %eax            # imm = 0x107
jle 0x3f4e
cmpl $0x108, %eax            # imm = 0x108
je 0x3f6e
cmpl $0x113, %eax            # imm = 0x113
je 0x3f80
cmpl $0x114, %eax            # imm = 0x114
jne 0x3fa4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3fda
cmpl $0x105, %eax            # imm = 0x105
je 0x3f92
cmpl $0x106, %eax            # imm = 0x106
jne 0x3fa4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4158
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x41c4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4216
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x40d4
movl 0xc(%rbx), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x3, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_func()
Stmt * Parser::parse_func()
{
    Stmt * stmt = create_stmt(STMT_LET);
    advance();

    weak_expect(TOKEN_SYMBOL);
    stmt->let.left = peek.values.symbol;
    advance();

    stmt->let.right = create_expr(EXPR_LAMBDA);
    stmt->let.right->lambda.parameters =
        parse_symbol_list((Token_Kind) '(', (Token_Kind) ')');
    stmt->let.right->lambda.body = parse_expr();

    return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl 0xc(%rdi), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x0, (%rax)
movl %r15d, 0x4(%rax)
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x325e
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq (%rbx), %rdi
callq 0x240c
movq %rax, %r15
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
shrq $0x20, %r15
movl $0x60, %edi
callq 0x1200
movq %rax, %r12
movl $0x7, (%rax)
movl %r15d, 0x4(%rax)
movq %rax, 0x10(%r14)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl $0x28, %edx
movl $0x29, %ecx
callq 0x393a
movq 0x20(%r15), %rax
movq %rax, 0x28(%r12)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x18(%r12)
movups %xmm0, 0x8(%r12)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x30(%r12)
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_let()
Stmt * Parser::parse_let()
{
	Stmt * stmt = create_stmt(STMT_LET);
	advance();
	
	weak_expect(TOKEN_SYMBOL);
	stmt->let.left = peek.values.symbol;
	advance();

	expect('=');

	stmt->let.right = parse_expr();
	
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x0, (%rax)
movl %r15d, 0x4(%rax)
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x325e
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x343a
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_set()
Stmt * Parser::parse_set()
{
	Stmt * stmt = create_stmt(STMT_SET);
	advance();
	
	//stmt->set.left = peek.values.symbol;
	stmt->set.left = parse_expr();
	//advance();

	expect('=');

	stmt->set.right = parse_expr();
	
	return stmt;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x1, (%rax)
movl %r15d, 0x4(%rax)
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x343a
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x10(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_return()
Stmt * Parser::parse_return()
{
	Stmt * stmt = create_stmt(STMT_RETURN);
	advance();
	stmt->_return.expr = parse_expr();
	return stmt;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0xc(%rdi), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x2, (%rax)
movl %r15d, 0x4(%rax)
movq (%rbx), %rdi
callq 0x240c
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_break()
Stmt * Parser::parse_break()
{
	expect(TOKEN_BREAK);
	auto stmt = create_stmt(STMT_BREAK);
	stmt->_break = parse_expr();
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x113, %esi            # imm = 0x113
callq 0x343a
movl 0xc(%rbx), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x4, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
callq 0x3dfe
movq %rax, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/gc.cc
// Function: GC::alloc(unsigned long)
void * alloc(size_t size)
	{
		allocation_acc += size;
		void * ptr = malloc(size + 1);
		allocations.push(ptr);
		return raw_to_opaque(ptr);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
addq %rdi, 0xbe6c(%rip)      # 0x10238
incq %rdi
callq 0x1200
movq %rax, %rbx
leaq 0xbe2a(%rip), %rdi      # 0x10208
movq %rax, %rsi
callq 0x5136
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/gc.cc
// Function: GC::free_unmarked()
void free_unmarked()
	{
		List<void*> new_allocations;
		new_allocations.alloc();
		for (int i = 0; i < allocations.size; i++) {
			if (*((uint8_t*) allocations[i])) {
				new_allocations.push(allocations[i]);
			} else {
				free(allocations[i]);
			}
		}
		#if SHOW_TOTAL_ALLOCATIONS
		printf("\n-- %zu allocations\n\n", new_allocations.size);
		#endif
		#if SHOW_COLLECTIONS
		printf("\n-- %zu collections\n\n", allocations.size - new_allocations.size);
		#endif
		allocations.dealloc();
		allocations = new_allocations;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq $0x0, -0x30(%rbp)
movq $0x4, -0x28(%rbp)
movq 0xbb72(%rip), %rax      # 0xffd0
movq %rax, -0x20(%rbp)
movq 0xbb5f(%rip), %rax      # 0xffc8
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x1200
movq %rax, -0x38(%rbp)
cmpq $0x0, 0xbd8d(%rip)      # 0x10210
je 0x44ba
xorl %r14d, %r14d
leaq -0x38(%rbp), %rbx
movq 0xbd75(%rip), %rax      # 0x10208
movq (%rax,%r14,8), %rsi
cmpb $0x0, (%rsi)
je 0x44a6
movq %rbx, %rdi
callq 0x5136
jmp 0x44ae
movq %rsi, %rdi
callq 0x11f8
incq %r14
cmpq %r14, 0xbd58(%rip)      # 0x10210
ja 0x448c
movq 0xbd47(%rip), %rdi      # 0x10208
callq *0xbd61(%rip)           # 0x10228
movq -0x18(%rbp), %rax
movq %rax, 0xbd56(%rip)      # 0x10228
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0xbd37(%rip)     # 0x10218
movups %xmm0, 0xbd20(%rip)     # 0x10208
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::to_string()
char * Value::to_string()
{
	switch (type) {
	case TYPE_NOTHING:
		return strdup("nothing");
	case TYPE_INTEGER:
		return itoa(integer);
	case TYPE_SYMBOL:
		return strdup(symbol);
	case TYPE_STRING: {
		char * s = (char*) malloc(sizeof(char) * (ref_string->length + 1));
		strncpy(s, ref_string->string, ref_string->length);
		s[ref_string->length] = '\0';
		return s;
	};
	case TYPE_FUNCTION:
		return strdup("@[function]");
	case TYPE_BUILTIN:
		return strdup("@[builtin]");
	case TYPE_CONSTRUCTOR:
		return strdup("@[constructor]");
	case TYPE_OBJECT:
		return strdup("@[object]");
	case TYPE_FILE_UNIT:
		assert(false);
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x8, %rax
ja 0x459f
leaq 0x6bb9(%rip), %rcx      # 0xb0c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6fbc(%rip), %rdi      # 0xb4db
jmp 0x4590
movq 0x8(%rdi), %r15
movq 0x8(%r15), %rbx
leaq 0x1(%rbx), %rdi
callq 0x1200
movq %rax, %r14
movq (%r15), %rsi
movq %rax, %rdi
movq %rbx, %rdx
callq 0x10b0
movb $0x0, (%r14,%rbx)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rdi), %rdi
jmp 0x4590
leaq 0x6f8c(%rip), %rdi      # 0xb4ef
jmp 0x4590
leaq 0x6f9d(%rip), %rdi      # 0xb509
jmp 0x4590
movl 0x8(%rdi), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1726
leaq 0x6f5c(%rip), %rdi      # 0xb4e3
jmp 0x4590
leaq 0x6f6a(%rip), %rdi      # 0xb4fa
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11d0
leaq 0x6ec8(%rip), %rdi      # 0xb46e
leaq 0x6f66(%rip), %rsi      # 0xb513
leaq 0x6f70(%rip), %rcx      # 0xb524
movl $0x51, %edx
callq 0x10d0
leaq 0x6ea9(%rip), %rdi      # 0xb46e
leaq 0x6f47(%rip), %rsi      # 0xb513
leaq 0x6f51(%rip), %rcx      # 0xb524
movl $0x4f, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::gc_mark()
void Value::gc_mark()
{
	switch (type) {
	case TYPE_NOTHING:
		break;
	case TYPE_INTEGER:
		break;
	case TYPE_SYMBOL:
		break;
	case TYPE_STRING:
		GC::mark_opaque(ref_string);
		ref_string->gc_mark();
		break;
	case TYPE_FUNCTION:
		GC::mark_opaque(ref_function);
		ref_function->gc_mark();
		break;
	case TYPE_BUILTIN:
		break;
	case TYPE_CONSTRUCTOR:
		GC::mark_opaque(ref_constructor);
		ref_constructor->gc_mark();
		break;
	case TYPE_OBJECT:
		GC::mark_opaque(ref_object);
		ref_object->gc_mark();
		break;
	case TYPE_FILE_UNIT:
		GC::mark_opaque(ref_file_unit);
		break;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0x4, %eax
ja 0x4619
leaq 0x6af9(%rip), %rcx      # 0xb0ec
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movb $0x1, %cl
movb %cl, -0x1(%rax)
movq 0x8(%rdi), %rax
movq (%rax), %rax
movb %cl, -0x1(%rax)
jmp 0x4619
movq 0x8(%rdi), %rax
movb $0x1, -0x1(%rax)
popq %rbp
retq
movq 0x8(%rdi), %rax
movb $0x1, -0x1(%rax)
movq 0x8(%rdi), %rdi
popq %rbp
jmp 0x5530
movq 0x8(%rdi), %rax
movb $0x1, -0x1(%rax)
movq 0x8(%rdi), %rdi
popq %rbp
jmp 0x5556
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::add(Value, Value, int)
Value Value::add(Value a, Value b, Assoc_Ptr assoc)
{
	validate_same_type(a, b, assoc);
	switch (a.type) {
	case TYPE_INTEGER:
		return Value::raise(a.integer + b.integer);
	default:
		fatal_assoc(assoc, "+ not valid for type");
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x4659
cmpl $0x1, %edi
jne 0x4662
addl %esi, %ecx
movl $0x1, %eax
movq %rcx, %rdx
popq %rbp
retq
leaq 0x712b(%rip), %rsi      # 0xb78b
jmp 0x4669
leaq 0x6ed4(%rip), %rsi      # 0xb53d
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c52
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::subtract(Value, Value, int)
Value Value::subtract(Value a, Value b, Assoc_Ptr assoc)
{
	validate_same_type(a, b, assoc);
	switch (a.type) {
	case TYPE_INTEGER:
		return Value::raise(a.integer - b.integer);
	default:
		fatal_assoc(assoc, "- not valid for type");
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x468d
cmpl $0x1, %edi
jne 0x4696
subl %ecx, %esi
movl $0x1, %eax
movq %rsi, %rdx
popq %rbp
retq
leaq 0x70f7(%rip), %rsi      # 0xb78b
jmp 0x469d
leaq 0x6eb5(%rip), %rsi      # 0xb552
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c52
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::equal(Value, Value, int)
bool Value::equal(Value a, Value b, Assoc_Ptr assoc)
{
	if (a.type != b.type) {
		return false;
	}
	switch (a.type) {
	case TYPE_NOTHING:
		return true;
	case TYPE_INTEGER:
		return a.integer == b.integer;
	case TYPE_SYMBOL:
		return a.symbol == b.symbol;
	case TYPE_STRING:
		if (a.ref_string->length != b.ref_string->length) {
			return false;
		}
		return strncmp(a.ref_string->string,
					   b.ref_string->string,
					   a.ref_string->length);
	case TYPE_FUNCTION:
		return a.ref_function == b.ref_function;
	case TYPE_BUILTIN:
		return a.builtin == b.builtin;
	case TYPE_CONSTRUCTOR:
		return a.ref_constructor == b.ref_constructor;
	case TYPE_OBJECT:
		return a.ref_object == b.ref_object;
	case TYPE_FILE_UNIT:
		assert(false);
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x475d
cmpl $0x8, %edi
ja 0x4761
movl %edi, %eax
leaq 0x69d8(%rip), %rdx      # 0xb100
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
cmpq %rcx, %rsi
sete %al
jmp 0x475f
movb $0x1, %al
jmp 0x475f
cmpl %ecx, %esi
jmp 0x4734
movq 0x8(%rsi), %rdx
cmpq 0x8(%rcx), %rdx
jne 0x475d
movq (%rsi), %rdi
movq (%rcx), %rsi
callq 0x1090
testl %eax, %eax
setne %al
jmp 0x475f
xorl %eax, %eax
popq %rbp
retq
leaq 0x6d06(%rip), %rdi      # 0xb46e
leaq 0x6da4(%rip), %rsi      # 0xb513
leaq 0x6e1b(%rip), %rcx      # 0xb591
movl $0xca, %edx
callq 0x10d0
leaq 0x6ce7(%rip), %rdi      # 0xb46e
leaq 0x6d85(%rip), %rsi      # 0xb513
leaq 0x6dfc(%rip), %rcx      # 0xb591
movl $0xc8, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::less_than(Value, Value, int)
bool Value::less_than(Value a, Value b, Assoc_Ptr assoc)
{
	validate_same_type(a, b, assoc);
	switch (a.type) {
	case TYPE_INTEGER:
		return a.integer < b.integer;
	default:
		fatal_assoc(assoc, "< not valid for type");
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x47d2
cmpl $0x1, %edi
jne 0x47db
cmpl %ecx, %esi
setl %al
popq %rbp
retq
leaq 0x6fb2(%rip), %rsi      # 0xb78b
jmp 0x47e2
leaq 0x6de1(%rip), %rsi      # 0xb5c3
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c52
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::greater_than(Value, Value, int)
bool Value::greater_than(Value a, Value b, Assoc_Ptr assoc)
{
	validate_same_type(a, b, assoc);
	switch (a.type) {
	case TYPE_INTEGER:
		return a.integer > b.integer;
	default:
		fatal_assoc(assoc, "> not valid for type");
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x4800
cmpl $0x1, %edi
jne 0x4809
cmpl %ecx, %esi
setg %al
popq %rbp
retq
leaq 0x6f84(%rip), %rsi      # 0xb78b
jmp 0x4810
leaq 0x6dc8(%rip), %rsi      # 0xb5d8
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c52
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::less_than_or_equal_to(Value, Value, int)
bool Value::less_than_or_equal_to(Value a, Value b, Assoc_Ptr assoc)
{
	validate_same_type(a, b, assoc);
	switch (a.type) {
	case TYPE_INTEGER:
		return a.integer <= b.integer;
	default:
		fatal_assoc(assoc, "<= not valid for type");
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x482e
cmpl $0x1, %edi
jne 0x4837
cmpl %ecx, %esi
setle %al
popq %rbp
retq
leaq 0x6f56(%rip), %rsi      # 0xb78b
jmp 0x483e
leaq 0x6daf(%rip), %rsi      # 0xb5ed
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c52
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/value-def.cc
// Function: Value::greater_than_or_equal_to(Value, Value, int)
bool Value::greater_than_or_equal_to(Value a, Value b, Assoc_Ptr assoc)
{
	validate_same_type(a, b, assoc);
	switch (a.type) {
	case TYPE_INTEGER:
		return a.integer >= b.integer;
	default:
		fatal_assoc(assoc, ">= not valid for type");
	}
	assert(false); // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl %edx, %edi
jne 0x485c
cmpl $0x1, %edi
jne 0x4865
cmpl %ecx, %esi
setge %al
popq %rbp
retq
leaq 0x6f28(%rip), %rsi      # 0xb78b
jmp 0x486c
leaq 0x6d97(%rip), %rsi      # 0xb603
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c52
// File: /workspace/github_cpp_makefile_star2_O3/pixlark[P]Badge/src/builtins.cc
// Function: Builtins::v_abs(Value*)
DEFINE(abs)
	{
		PULL_ONE(n);
		if (n.type != TYPE_INTEGER) {
			fatal("Builtin function abs() takes integer");
		}
		return Value::raise(abs(n.integer));
	}

// Assembly:
cmpl $0x1, (%rdi)
jne 0x488b
movl 0x8(%rdi), %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
movl $0x1, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x6d83(%rip), %rdi      # 0xb619
xorl %eax, %eax
callq 0x1a00
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x18, %rsp
movups (%rdi), %xmm0
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
callq 0x44f2
movq %rax, %rbx
leaq 0x6bef(%rip), %rdi      # 0xb4d8
movq %rax, %rsi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
callq 0x11f8
xorl %eax, %eax
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
subq $0x18, %rsp
movups (%rdi), %xmm0
leaq -0x20(%rbp), %rdi
movaps %xmm0, (%rdi)
callq 0x44f2
movq %rax, %rbx
movq %rax, %rdi
callq 0x1180
movq %rbx, %rdi
callq 0x11f8
xorl %eax, %eax
xorl %edx, %edx
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6c13(%rip), %rdi      # 0xb660
callq 0x15dd
cmpq %rbx, %rax
je 0x4aa3
leaq 0x6c06(%rip), %rdi      # 0xb664
callq 0x15dd
cmpq %rbx, %rax
je 0x4aa7
leaq 0x6bf9(%rip), %rdi      # 0xb668
callq 0x15dd
cmpq %rbx, %rax
je 0x4aae
leaq 0x6bee(%rip), %rdi      # 0xb66e
callq 0x15dd
movq %rax, %rcx
movl $0x3, %eax
cmpq %rbx, %rcx
je 0x4ab3
leaq 0x6bdd(%rip), %rdi      # 0xb676
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1a00
xorl %eax, %eax
jmp 0x4ab3
movl $0x1, %eax
jmp 0x4ab3
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0xb775(%rip), %rdi      # 0x10240
movq %rbx, %rsi
callq 0x55ce
testb %al, %al
je 0x4aea
leaq 0xb762(%rip), %rdi      # 0x10240
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x563c
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movq %rbx, %rdi
callq 0x4a3d
movq %rbx, (%r14)
shll $0x3, %eax
leaq 0xb614(%rip), %rcx      # 0x10120
movq (%rax,%rcx), %rcx
movq %rcx, 0x8(%r14)
leaq 0xb625(%rip), %rcx      # 0x10140
movq (%rax,%rcx), %rax
movq %rax, 0x10(%r14)
leaq 0xb716(%rip), %rdi      # 0x10240
movq %rbx, %rsi
movq %r14, %rdx
callq 0x56e8
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %r14
movq %rsi, %rdi
callq 0x168b
movq %rax, %rbx
testq %rax, %rax
je 0x4cb6
leaq -0xa8(%rbp), %r15
movq %rbx, (%r15)
movq %rbx, %rdi
callq 0x1080
movq %rax, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq $0x1, 0x18(%r15)
movq %r15, -0x50(%rbp)
movq %r15, %rdi
callq 0x240c
movq %rax, %r15
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x5734
cmpl $0x100, %r15d           # imm = 0x100
je 0x4c0a
leaq -0x50(%rbp), %r14
leaq -0x38(%rbp), %r13
leaq -0x88(%rbp), %r15
leaq -0x30(%rbp), %r12
movq %r14, %rdi
callq 0x3f10
movq %rax, -0x38(%rbp)
movq %r13, -0x30(%rbp)
movq %r14, %rdi
movl $0x2e, %esi
callq 0x343a
movq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x579e
movq %r12, %rdi
callq 0x4ce0
cmpl $0x100, -0x48(%rbp)     # imm = 0x100
jne 0x4bd0
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
leaq 0x1(%rcx), %rdx
cmpq %rdx, %rax
jae 0x4c76
testq %rax, %rax
js 0x4c27
cvtsi2ss %rax, %xmm0
jmp 0x4c3c
movq %rax, %rcx
shrq %rcx
andl $0x1, %eax
orq %rcx, %rax
cvtsi2ss %rax, %xmm0
addss %xmm0, %xmm0
addss %xmm0, %xmm0
cvttss2si %xmm0, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subss 0x63b0(%rip), %xmm0     # 0xb004
cvttss2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x937e
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
leaq -0x88(%rbp), %r14
movq (%r14), %rax
movq %rdx, 0x8(%r14)
leaq (%rcx,%rcx,2), %rcx
movabsq $-0xfffffffe, %rdx      # imm = 0xFFFFFFFF00000002
movq %rdx, (%rax,%rcx,8)
movl $0x0, 0x8(%rax,%rcx,8)
movq $0x0, 0x10(%rax,%rcx,8)
movq %r14, %rdi
callq 0x5de6
movq (%r14), %rdi
callq *0x20(%r14)
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x4ce0
movq %rbx, %rdi
callq 0x11c0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
cmpl $0x2, %edi
jne 0x5127
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1cc0
xorl %r14d, %r14d
movq %r14, 0xb184(%rip)      # 0x10178
movl $0x4, %r15d
movq %r15, 0xb17f(%rip)      # 0x10180
movq 0xafc8(%rip), %r12      # 0xffd0
movq %r12, 0xb179(%rip)      # 0x10188
movq 0xafb2(%rip), %r13      # 0xffc8
movq %r13, 0xb173(%rip)      # 0x10190
movl $0x20, %edi
callq 0x1200
movq %rax, 0xb142(%rip)      # 0x10170
movq %r14, 0xb16b(%rip)      # 0x101a0
movq %r15, 0xb16c(%rip)      # 0x101a8
movq %r12, 0xb16d(%rip)      # 0x101b0
movq %r13, 0xb16e(%rip)      # 0x101b8
movl $0x20, %edi
callq 0x1200
movq %rax, 0xb13d(%rip)      # 0x10198
movq %r14, 0xb1ae(%rip)      # 0x10210
movq %r15, 0xb1af(%rip)      # 0x10218
movq %r12, 0xb1b0(%rip)      # 0x10220
movq %r13, 0xb1b1(%rip)      # 0x10228
movl $0x20, %edi
callq 0x1200
movq %rax, 0xb180(%rip)      # 0x10208
movl $0x0, 0xb19e(%rip)      # 0x10230
movq %r14, 0xb19f(%rip)      # 0x10238
callq 0x4948
movq %r14, 0xb123(%rip)      # 0x101c8
movq %r15, 0xb124(%rip)      # 0x101d0
movq %r12, 0xb125(%rip)      # 0x101d8
movq %r13, 0xb126(%rip)      # 0x101e0
movl $0xa0, %edi
callq 0x1200
movq %rax, 0xb0f5(%rip)      # 0x101c0
movq 0x8(%rbx), %rdi
callq 0x4d0d
movq 0xb0e5(%rip), %rdi      # 0x101c0
callq *0xb0ff(%rip)           # 0x101e0
xorps %xmm0, %xmm0
movups %xmm0, 0xb0dd(%rip)     # 0x101c8
callq 0x49da
movq 0xb111(%rip), %rdi      # 0x10208
callq *0xb12b(%rip)           # 0x10228
xorps %xmm0, %xmm0
movups %xmm0, 0xb109(%rip)     # 0x10210
callq 0x1591
callq 0x1345
callq 0x1fab
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x65b8(%rip), %rdi      # 0xb6e6
xorl %eax, %eax
callq 0x1a00
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
movl (%rdi), %eax
addl $-0x4, %eax
cmpl $0xa, %eax
ja 0x5330
movq %rdi, %rbx
leaq 0x5e42(%rip), %rcx      # 0xb124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x52c8
movq 0x10(%rbx), %rdi
jmp 0x5388
movq 0x8(%rbx), %rdi
callq 0x52c8
movq 0x8(%rbx), %rdi
jmp 0x5388
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b8e
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2cdc
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2dea
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2ec8
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2bc0
movq 0x8(%rbx), %rdi
callq *0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
callq 0x52c8
movq 0x30(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq (%rdi), %rax
movb $0x1, -0x1(%rax)
movq 0x18(%rdi), %rax
cmpb $0x0, -0x1(%rax)
je 0x5547
popq %rbp
retq
movb $0x1, -0x1(%rax)
movq 0x18(%rdi), %rdi
popq %rbp
jmp 0x6c04
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rcx
testq %rcx, %rcx
je 0x560f
movq %rsi, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpq %r15, %rcx
jbe 0x561c
movq 0x8(%r14), %rax
movq (%rax,%r15,8), %rdi
movq %rbx, %rsi
callq *(%r14)
testb %al, %al
jne 0x5611
incq %r15
movq 0x10(%r14), %rcx
cmpq %r15, %rcx
ja 0x55ea
jmp 0x5611
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6120(%rip), %rdi      # 0xb743
leaq 0x6126(%rip), %rsi      # 0xb750
leaq 0x6b22(%rip), %rcx      # 0xc153
movl $0x7b, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x567a
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
cmpq %r15, %rax
jbe 0x56b2
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rsi
callq *(%rbx)
testb %al, %al
jne 0x5699
incq %r15
movq 0x10(%rbx), %rax
cmpq %r15, %rax
ja 0x5658
leaq 0x694f(%rip), %rdi      # 0xbfd0
leaq 0x6961(%rip), %rsi      # 0xbfe9
leaq 0x6cfb(%rip), %rcx      # 0xc38a
movl $0x5b, %edx
callq 0x10d0
cmpq %r15, 0x38(%rbx)
jbe 0x56d1
movq 0x30(%rbx), %rax
movq (%rax,%r15,8), %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x608a(%rip), %rdi      # 0xb743
leaq 0x6090(%rip), %rsi      # 0xb750
leaq 0x6a8c(%rip), %rcx      # 0xc153
movl $0x7b, %edx
callq 0x10d0
leaq 0x606b(%rip), %rdi      # 0xb743
leaq 0x6071(%rip), %rsi      # 0xb750
leaq 0x6c6d(%rip), %rcx      # 0xc353
jmp 0x56c7
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
addq $0x58, 0xa3e1(%rip)     # 0x10238
movl $0x59, %edi
callq 0x1200
movq %rax, %rbx
leaq 0xa39d(%rip), %rdi      # 0x10208
movq %rax, %rsi
callq 0x5136
leaq 0x1(%rbx), %r14
movq 0xa292(%rip), %rax      # 0x10110
movq 0xa293(%rip), %rcx      # 0x10118
xorl %r15d, %r15d
movq %r15, 0x9(%rbx)
movl $0x4, %r12d
movq %r12, 0x11(%rbx)
movq %rax, 0x19(%rbx)
movq %rcx, 0x21(%rbx)
movl $0x20, %edi
callq *%rax
movq %rax, 0x1(%rbx)
movq 0xa260(%rip), %rax      # 0x10110
movq 0xa261(%rip), %rcx      # 0x10118
movq %r15, 0x31(%rbx)
movq %r12, 0x39(%rbx)
movq %rax, 0x41(%rbx)
movq %rcx, 0x49(%rbx)
movl $0x40, %edi
callq *%rax
movq %rax, 0x29(%rbx)
movq %r15, 0x51(%rbx)
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, (%rdi)
movq %rdx, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x18(%rdi)
movl $0x4, %eax
movq %rax, 0x20(%rdi)
movl $0x4, %r12d
movq 0xa0b3(%rip), %r13      # 0xffd0
movq %r13, 0x28(%rdi)
movq 0xa0a0(%rip), %rbx      # 0xffc8
movq %rbx, 0x30(%rdi)
movl $0x40, %edi
callq 0x1200
movq %rax, 0x10(%r15)
xorl %eax, %eax
movq %rax, 0x40(%r15)
movq %r12, 0x48(%r15)
movq %r13, 0x50(%r15)
movq %rbx, 0x58(%r15)
movl $0x40, %edi
callq 0x1200
movq %rax, 0x38(%r15)
leaq 0x60(%r15), %r12
xorl %eax, %eax
movq %rax, 0x68(%r15)
movl $0x4, %eax
movq %rax, 0x70(%r15)
movq %r13, 0x78(%r15)
movq %rbx, 0x80(%r15)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x60(%r15)
movq %r14, %rdi
movq -0x30(%rbp), %rsi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x94d0
movq %r12, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x944e
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq *0x30(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rbx)
movq 0x38(%rbx), %rdi
callq *0x58(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rbx)
cmpq $0x0, 0x68(%rbx)
jne 0x6a6b
leaq 0x68(%rbx), %r14
movq 0x60(%rbx), %rdi
callq *0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x562e(%rip), %rdi      # 0xc0a0
leaq 0x5109(%rip), %rsi      # 0xbb82
leaq 0x5635(%rip), %rcx      # 0xc0b5
movl $0x66, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rax
movb $0x1, -0x1(%rax)
movq 0x8(%rdi), %rdi
callq 0x6c04
movq 0x68(%rbx), %rax
testq %rax, %rax
je 0x6b3c
xorl %r14d, %r14d
cmpq %r14, %rax
jbe 0x6b77
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0xa346
incq %r14
movq 0x68(%rbx), %rax
cmpq %r14, %rax
ja 0x6b1e
movq 0x40(%rbx), %rax
testq %rax, %rax
je 0x6b6c
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %r15, %rax
jbe 0x6b8e
movq 0x38(%rbx), %rdi
addq %r14, %rdi
callq 0x45de
incq %r15
movq 0x40(%rbx), %rax
addq $0x10, %r14
cmpq %r15, %rax
ja 0x6b4b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4bc5(%rip), %rdi      # 0xb743
leaq 0x4bcb(%rip), %rsi      # 0xb750
leaq 0x51bd(%rip), %rcx      # 0xbd49
jmp 0x6ba3
leaq 0x4bae(%rip), %rdi      # 0xb743
leaq 0x4bb4(%rip), %rsi      # 0xb750
leaq 0x4bb9(%rip), %rcx      # 0xb75c
movl $0x7b, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
cmpq $0x0, 0x8(%rdi)
je 0x6bde
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x11f8
incq %r15
cmpq %r15, 0x8(%rbx)
ja 0x6bc9
movq (%rbx), %rdi
callq *0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r14)
movq 0x28(%rbx), %rdi
callq *0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movb $0x1, %r14b
movq (%rbx), %rax
movb %r14b, -0x1(%rax)
movq 0x28(%rbx), %rax
movb %r14b, -0x1(%rax)
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x6c54
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, %rax
jbe 0x6c70
movq 0x28(%rbx), %rdi
addq %r15, %rdi
callq 0x45de
incq %r12
movq 0x30(%rbx), %rax
addq $0x10, %r15
cmpq %r12, %rax
ja 0x6c33
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x6c67
movb $0x1, -0x1(%rax)
movq 0x50(%rbx), %rbx
jmp 0x6c15
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4acc(%rip), %rdi      # 0xb743
leaq 0x4ad2(%rip), %rsi      # 0xb750
leaq 0x4ad7(%rip), %rcx      # 0xb75c
movl $0x7b, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
cmpq %rsi, 0x8(%rdi)
ja 0x6de5
movq %rsi, %rbx
movq %rdi, %r14
leaq (,%rsi,8), %rdi
callq *0x18(%r14)
movq %rax, %r15
movq (%r14), %rsi
movq 0x8(%r14), %rdx
shlq $0x3, %rdx
movq %rax, %rdi
callq 0x10e0
movq (%r14), %rdi
callq *0x20(%r14)
movq %r15, (%r14)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x49bf(%rip), %rdi      # 0xb7ab
leaq 0x495d(%rip), %rsi      # 0xb750
leaq 0x49c6(%rip), %rcx      # 0xb7c0
movl $0x4a, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %r15
movl $0x60, %edi
callq 0x1200
movq %rax, %rbx
movq %r13, (%rax)
callq 0x5e44
movq %rax, 0x8(%rbx)
movq %r12, 0x50(%rax)
movq %r14, 0x10(%rbx)
callq 0x5e44
movq %rax, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x9612
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
cmpq %r14, 0x30(%r15)
jbe 0x9583
movq 0x28(%r15), %rax
movq (%rax,%r14,8), %rax
movq %rax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
movq $0x4, 0x48(%rbx)
movq 0x6a7c(%rip), %rax      # 0xffd0
movq %rax, 0x50(%rbx)
movq 0x6a69(%rip), %rax      # 0xffc8
movq %rax, 0x58(%rbx)
movl $0x10, %edi
callq 0x1200
movq %rax, 0x38(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x21b9(%rip), %rdi      # 0xb743
leaq 0x21bf(%rip), %rsi      # 0xb750
leaq 0x252d(%rip), %rcx      # 0xbac5
movl $0x7b, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0x96cc
movl $0x8, %r15d
xorl %r12d, %r12d
cmpq %r12, %rax
jbe 0x96ef
movq 0x10(%rbx), %rax
movq -0x8(%rax,%r15), %r14
movl (%rax,%r15), %eax
movl %eax, 0x88(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x98fa
movq %rdx, %rcx
movq 0x8(%rbx), %rdi
movq %r14, %rsi
movl %eax, %edx
callq 0x9e4a
incq %r12
movq 0x18(%rbx), %rax
addq $0x10, %r15
cmpq %r12, %rax
ja 0x9688
movq 0x40(%rbx), %r14
testq %r14, %r14
je 0x96e6
addq $0x38, %rbx
movq %rbx, %rdi
callq 0xa104
decq %r14
jne 0x96d9
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x204d(%rip), %rdi      # 0xb743
leaq 0x2053(%rip), %rsi      # 0xb750
leaq 0x2682(%rip), %rcx      # 0xbd86
movl $0x7b, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %rbx
pushq %rax
cvtss2sd 0x6b14(%rip), %xmm0     # 0x10230
addsd 0x1a3c(%rip), %xmm0     # 0xb160
cvtsd2ss %xmm0, %xmm0
movss %xmm0, 0x6b00(%rip)     # 0x10230
addq $0x60, %rdi
callq 0xa03a
movq %rax, %rbx
movq 0x38(%rax), %rdi
callq *0x58(%rax)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
nop