LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3f9c
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movl 0xc(%rbx), %r15d
movl $0x60, %edi
callq 0x1200
movq %rax, %r14
movl $0xe, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x369e
movq %rdx, 0x8(%r14)
movq %rbx, %rdi
callq 0x40ba
movq %rax, 0x10(%r14)
movq %r14, %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 0x3dda
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4090
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movl 0xc(%rbx), %r15d
movl $0x60, %edi
callq 0x1200
movq %rax, %r14
movq 0xcfe2(%rip), %r12      # 0x10fd0
movl $0xa, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x369e
movq %rdx, 0x8(%r14)
movq $0x0, 0x18(%r14)
movq $0x4, 0x20(%r14)
movq %r12, 0x28(%r14)
movq 0xcfa4(%rip), %rax      # 0x10fc8
movq %rax, 0x30(%r14)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x10(%r14)
movq %rbx, %rdi
movl $0x5b, %esi
callq 0x369e
cmpl $0x5d, 0x8(%rbx)
je 0x407e
movq %r14, %r15
addq $0x10, %r15
movq %rbx, %rdi
callq 0x40ba
movq %r15, %rdi
movq %rax, %rsi
callq 0x56f0
cmpl $0x2c, 0x8(%rbx)
jne 0x40a0
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
cmpl $0x5d, %eax
jne 0x4050
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
jmp 0x40ad
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3f30
movq %rbx, %rdi
movl $0x5d, %esi
callq 0x369e
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x7b, 0x8(%rdi)
jne 0x41a2
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movl 0xc(%rbx), %r15d
movl $0x60, %edi
callq 0x1200
movq %rax, %r14
movq 0xced3(%rip), %rax      # 0x10fd0
movl $0x6, (%r14)
movl %r15d, 0x4(%r14)
leaq 0x8(%r14), %r15
xorl %r12d, %r12d
movq %r12, 0x10(%r14)
movq $0x4, 0x18(%r14)
movq %rax, 0x20(%r14)
movq 0xcea2(%rip), %rax      # 0x10fc8
movq %rax, 0x28(%r14)
movl $0x20, %edi
callq 0x1200
movq %rax, 0x8(%r14)
movq %r12, 0x30(%r14)
cmpl $0x7d, 0x8(%rbx)
je 0x41b8
movq %rbx, %rdi
callq 0x41da
movq %rax, %r12
movl (%rax), %eax
xorl $0x3, %eax
movl 0x8(%rbx), %ecx
xorl $0x7d, %ecx
orl %eax, %ecx
setne %r13b
je 0x417a
movq %rbx, %rdi
movl $0x2e, %esi
callq 0x369e
movq %r15, %rdi
movq %r12, %rsi
callq 0x5808
jmp 0x419b
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq 0x8(%r12), %rax
movq %rax, 0x30(%r14)
movq %r12, %rdi
callq 0x11f8
testb %r13b, %r13b
jne 0x413c
jmp 0x41c8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3fae
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
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_O1/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 0x4218
cmpl $0x108, %eax            # imm = 0x108
je 0x4238
cmpl $0x113, %eax            # imm = 0x113
je 0x424a
cmpl $0x114, %eax            # imm = 0x114
jne 0x426e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x42a4
cmpl $0x105, %eax            # imm = 0x105
je 0x425c
cmpl $0x106, %eax            # imm = 0x106
jne 0x426e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x441e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x448a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x44dc
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x439a
movl 0xc(%rbx), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x3, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
callq 0x40ba
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_O1/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 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x34d0
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movl 0xc(%rbx), %r12d
movl $0x60, %edi
callq 0x1200
movq %rax, %r15
movl $0x7, (%rax)
movl %r12d, 0x4(%rax)
movq %rax, 0x10(%r14)
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movl $0x28, %edx
movl $0x29, %ecx
callq 0x3c04
movq 0x20(%r12), %rax
movq %rax, 0x28(%r15)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x18(%r15)
movups %xmm0, 0x8(%r15)
movq %rbx, %rdi
callq 0x40ba
movq %rax, 0x30(%r15)
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x34d0
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq (%rbx), %rdi
callq 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x369e
movq %rbx, %rdi
callq 0x40ba
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_O1/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 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
callq 0x40ba
movq %rax, 0x8(%r14)
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x369e
movq %rbx, %rdi
callq 0x40ba
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_O1/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 0x2502
movq %rax, 0x8(%rbx)
movq %rdx, 0x10(%rbx)
movq %rbx, %rdi
callq 0x40ba
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_O1/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 0x369e
movl 0xc(%rbx), %r15d
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movl $0x4, (%rax)
movl %r15d, 0x4(%rax)
movq %rbx, %rdi
callq 0x40ba
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_O1/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, 0xcba6(%rip)      # 0x11238
incq %rdi
callq 0x1200
movq %rax, %rbx
leaq 0xcb64(%rip), %rdi      # 0x11208
movq %rax, %rsi
callq 0x5492
incq %rbx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc8ac(%rip), %rax      # 0x10fd0
movq %rax, -0x20(%rbp)
movq 0xc899(%rip), %rax      # 0x10fc8
movq %rax, -0x18(%rbp)
movl $0x20, %edi
callq 0x1200
movq %rax, -0x38(%rbp)
cmpq $0x0, 0xcac7(%rip)      # 0x11210
je 0x4780
xorl %r14d, %r14d
leaq -0x38(%rbp), %rbx
movq 0xcaaf(%rip), %rax      # 0x11208
movq (%rax,%r14,8), %rsi
cmpb $0x0, (%rsi)
je 0x476c
movq %rbx, %rdi
callq 0x5492
jmp 0x4774
movq %rsi, %rdi
callq 0x11f8
incq %r14
cmpq %r14, 0xca92(%rip)      # 0x11210
ja 0x4752
movq 0xca81(%rip), %rdi      # 0x11208
callq *0xca9b(%rip)           # 0x11228
xorps %xmm0, %xmm0
movups %xmm0, 0xca79(%rip)     # 0x11210
movq -0x18(%rbp), %rax
movq %rax, 0xca86(%rip)      # 0x11228
movups -0x38(%rbp), %xmm0
movups -0x28(%rbp), %xmm1
movups %xmm1, 0xca67(%rip)     # 0x11218
movups %xmm0, 0xca50(%rip)     # 0x11208
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4873
leaq 0x68e9(%rip), %rcx      # 0xb0c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6d54(%rip), %rdi      # 0xb543
jmp 0x4864
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
movq 0x8(%r15), %rax
movb $0x0, (%r14,%rax)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rdi), %rdi
jmp 0x4864
leaq 0x6d20(%rip), %rdi      # 0xb557
jmp 0x4864
leaq 0x6d31(%rip), %rdi      # 0xb571
jmp 0x4864
movl 0x8(%rdi), %edi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1751
leaq 0x6cf0(%rip), %rdi      # 0xb54b
jmp 0x4864
leaq 0x6cfe(%rip), %rdi      # 0xb562
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11d0
leaq 0x6bf4(%rip), %rdi      # 0xb46e
leaq 0x6cfa(%rip), %rsi      # 0xb57b
leaq 0x6d04(%rip), %rcx      # 0xb58c
movl $0x51, %edx
callq 0x10d0
leaq 0x6bd5(%rip), %rdi      # 0xb46e
leaq 0x6cdb(%rip), %rsi      # 0xb57b
leaq 0x6ce5(%rip), %rcx      # 0xb58c
movl $0x4f, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x48ed
leaq 0x6825(%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 0x48ed
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 0x588a
movq 0x8(%rdi), %rax
movb $0x1, -0x1(%rax)
movq 0x8(%rdi), %rdi
popq %rbp
jmp 0x58b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x492d
cmpl $0x1, %edi
jne 0x4936
addl %esi, %ecx
movl $0x1, %eax
movq %rcx, %rdx
popq %rbp
retq
leaq 0x6ebf(%rip), %rsi      # 0xb7f3
jmp 0x493d
leaq 0x6c68(%rip), %rsi      # 0xb5a5
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4961
cmpl $0x1, %edi
jne 0x496a
subl %ecx, %esi
movl $0x1, %eax
movq %rsi, %rdx
popq %rbp
retq
leaq 0x6e8b(%rip), %rsi      # 0xb7f3
jmp 0x4971
leaq 0x6c49(%rip), %rsi      # 0xb5ba
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c80
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4a31
cmpl $0x8, %edi
ja 0x4a35
movl %edi, %eax
leaq 0x6704(%rip), %rdx      # 0xb100
movslq (%rdx,%rax,4), %rax
addq %rdx, %rax
jmpq *%rax
cmpq %rcx, %rsi
sete %al
jmp 0x4a33
movb $0x1, %al
jmp 0x4a33
cmpl %ecx, %esi
jmp 0x4a08
movq 0x8(%rsi), %rdx
cmpq 0x8(%rcx), %rdx
jne 0x4a31
movq (%rsi), %rdi
movq (%rcx), %rsi
callq 0x1090
testl %eax, %eax
setne %al
jmp 0x4a33
xorl %eax, %eax
popq %rbp
retq
leaq 0x6a32(%rip), %rdi      # 0xb46e
leaq 0x6b38(%rip), %rsi      # 0xb57b
leaq 0x6baf(%rip), %rcx      # 0xb5f9
movl $0xca, %edx
callq 0x10d0
leaq 0x6a13(%rip), %rdi      # 0xb46e
leaq 0x6b19(%rip), %rsi      # 0xb57b
leaq 0x6b90(%rip), %rcx      # 0xb5f9
movl $0xc8, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4aa6
cmpl $0x1, %edi
jne 0x4aaf
cmpl %ecx, %esi
setl %al
popq %rbp
retq
leaq 0x6d46(%rip), %rsi      # 0xb7f3
jmp 0x4ab6
leaq 0x6b75(%rip), %rsi      # 0xb62b
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4ad4
cmpl $0x1, %edi
jne 0x4add
cmpl %ecx, %esi
setg %al
popq %rbp
retq
leaq 0x6d18(%rip), %rsi      # 0xb7f3
jmp 0x4ae4
leaq 0x6b5c(%rip), %rsi      # 0xb640
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b02
cmpl $0x1, %edi
jne 0x4b0b
cmpl %ecx, %esi
setle %al
popq %rbp
retq
leaq 0x6cea(%rip), %rsi      # 0xb7f3
jmp 0x4b12
leaq 0x6b43(%rip), %rsi      # 0xb655
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b30
cmpl $0x1, %edi
jne 0x4b39
cmpl %ecx, %esi
setge %al
popq %rbp
retq
leaq 0x6cbc(%rip), %rsi      # 0xb7f3
jmp 0x4b40
leaq 0x6b2b(%rip), %rsi      # 0xb66b
movl %r8d, %edi
xorl %eax, %eax
callq 0x1c80
// File: /workspace/github_cpp_makefile_star2_O1/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 0x4b5f
movl 0x8(%rdi), %eax
movl %eax, %edx
negl %edx
cmovsl %eax, %edx
movl $0x1, %eax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x6b17(%rip), %rdi      # 0xb681
xorl %eax, %eax
callq 0x1a2a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x47c2
movq %rax, %rbx
leaq 0x6983(%rip), %rdi      # 0xb540
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_O1/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 0x47c2
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_O1/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 0x69a7(%rip), %rdi      # 0xb6c8
callq 0x15dd
cmpq %rbx, %rax
je 0x4d77
leaq 0x699a(%rip), %rdi      # 0xb6cc
callq 0x15dd
cmpq %rbx, %rax
je 0x4d7b
leaq 0x698d(%rip), %rdi      # 0xb6d0
callq 0x15dd
cmpq %rbx, %rax
je 0x4d82
leaq 0x6982(%rip), %rdi      # 0xb6d6
callq 0x15dd
movq %rax, %rcx
movl $0x3, %eax
cmpq %rbx, %rcx
je 0x4d87
leaq 0x6971(%rip), %rdi      # 0xb6de
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1a2a
xorl %eax, %eax
jmp 0x4d87
movl $0x1, %eax
jmp 0x4d87
movl $0x2, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xc4a1(%rip), %rdi      # 0x11240
movq %rbx, %rsi
callq 0x5924
testb %al, %al
je 0x4dbe
leaq 0xc48e(%rip), %rdi      # 0x11240
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x5998
movl $0x18, %edi
callq 0x1200
movq %rax, %r14
movq %rbx, %rdi
callq 0x4d11
movq %rbx, (%r14)
shll $0x3, %eax
leaq 0xc340(%rip), %rcx      # 0x11120
movq (%rax,%rcx), %rcx
movq %rcx, 0x8(%r14)
leaq 0xc351(%rip), %rcx      # 0x11140
movq (%rax,%rcx), %rax
movq %rax, 0x10(%r14)
leaq 0xc442(%rip), %rdi      # 0x11240
movq %rbx, %rsi
movq %r14, %rdx
callq 0x5a52
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x16b6
testq %rax, %rax
je 0x4efa
movq %rax, %rbx
leaq -0xa8(%rbp), %r15
movq %rax, (%r15)
movq %rax, %rdi
callq 0x1080
movq %rax, 0x8(%r15)
movq $0x0, 0x10(%r15)
movq $0x1, 0x18(%r15)
movq %r15, -0x50(%rbp)
movq %r15, %rdi
callq 0x2502
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
leaq -0x88(%rbp), %rdi
movq %r14, %rsi
callq 0x5a9e
cmpl $0x100, -0x48(%rbp)     # imm = 0x100
je 0x4edb
leaq -0x50(%rbp), %r14
leaq -0x38(%rbp), %r13
leaq -0x88(%rbp), %r15
leaq -0x30(%rbp), %r12
movq %r14, %rdi
callq 0x41da
movq %rax, -0x38(%rbp)
movq %r13, -0x30(%rbp)
movq %r14, %rdi
movl $0x2e, %esi
callq 0x369e
movq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x5b08
movq %r12, %rdi
callq 0x4fbe
cmpl $0x100, -0x48(%rbp)     # imm = 0x100
jne 0x4ea1
leaq -0x80(%rbp), %r15
movq (%r15), %rcx
movq 0x8(%r15), %rax
incq %rcx
cmpq %rcx, %rax
jae 0x4f45
testq %rax, %rax
js 0x4f01
cvtsi2ss %rax, %xmm0
jmp 0x4f16
xorl %ebx, %ebx
jmp 0x4f94
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 0x60d6(%rip), %xmm0     # 0xb004
cvttss2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
leaq -0x88(%rbp), %rdi
callq 0x8e48
leaq -0x88(%rbp), %r14
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
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 0x5f10
movq (%r14), %rdi
callq *0x20(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
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 0x4fbe
movq %rbx, %rdi
callq 0x11c0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5484
movq %rsi, %rbx
movq 0x8(%rsi), %rdi
callq 0x1cee
xorl %r14d, %r14d
movq %r14, 0xbe27(%rip)      # 0x11178
movl $0x4, %r15d
movq %r15, 0xbe22(%rip)      # 0x11180
movq 0xbc6b(%rip), %r12      # 0x10fd0
movq %r12, 0xbe1c(%rip)      # 0x11188
movq 0xbc55(%rip), %r13      # 0x10fc8
movq %r13, 0xbe16(%rip)      # 0x11190
movl $0x20, %edi
callq 0x1200
movq %rax, 0xbde5(%rip)      # 0x11170
movq %r14, 0xbe0e(%rip)      # 0x111a0
movq %r15, 0xbe0f(%rip)      # 0x111a8
movq %r12, 0xbe10(%rip)      # 0x111b0
movq %r13, 0xbe11(%rip)      # 0x111b8
movl $0x20, %edi
callq 0x1200
movq %rax, 0xbde0(%rip)      # 0x11198
movq %r14, 0xbe51(%rip)      # 0x11210
movq %r15, 0xbe52(%rip)      # 0x11218
movq %r12, 0xbe53(%rip)      # 0x11220
movq %r13, 0xbe54(%rip)      # 0x11228
movl $0x20, %edi
callq 0x1200
movq %rax, 0xbe23(%rip)      # 0x11208
movl $0x0, 0xbe41(%rip)      # 0x11230
movq %r14, 0xbe42(%rip)      # 0x11238
callq 0x4c1c
movq %r14, 0xbdc6(%rip)      # 0x111c8
movq %r15, 0xbdc7(%rip)      # 0x111d0
movq %r12, 0xbdc8(%rip)      # 0x111d8
movq %r13, 0xbdc9(%rip)      # 0x111e0
movl $0xa0, %edi
callq 0x1200
movq %rax, 0xbd98(%rip)      # 0x111c0
movq 0x8(%rbx), %rdi
callq 0x4feb
movq 0xbd88(%rip), %rdi      # 0x111c0
callq *0xbda2(%rip)           # 0x111e0
xorps %xmm0, %xmm0
movups %xmm0, 0xbd80(%rip)     # 0x111c8
callq 0x4cae
movq 0xbdb4(%rip), %rdi      # 0x11208
callq *0xbdce(%rip)           # 0x11228
xorps %xmm0, %xmm0
movups %xmm0, 0xbdac(%rip)     # 0x11210
callq 0x1591
callq 0x1345
callq 0x203f
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x62c3(%rip), %rdi      # 0xb74e
xorl %eax, %eax
callq 0x1a2a
// File: /workspace/github_cpp_makefile_star2_O1/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 0x568c
movq %rdi, %rbx
leaq 0x5ae6(%rip), %rcx      # 0xb124
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x5624
movq 0x10(%rbx), %rdi
jmp 0x56e4
movq 0x8(%rbx), %rdi
callq 0x5624
movq 0x8(%rbx), %rdi
jmp 0x56e4
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2e3c
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2f8a
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3088
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x315e
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2e6e
movq 0x8(%rbx), %rdi
callq *0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rbx)
movq 0x30(%rbx), %rdi
callq 0x5624
movq 0x30(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x58a1
popq %rbp
retq
movb $0x1, -0x1(%rax)
movq 0x18(%rdi), %rdi
popq %rbp
jmp 0x6cd2
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
cmpq $0x0, 0x10(%rdi)
setne %r14b
je 0x5968
movq %rsi, %rbx
movq %rdi, %r15
xorl %r12d, %r12d
cmpq %r12, 0x10(%r15)
jbe 0x5978
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rdi
movq %rbx, %rsi
callq *(%r15)
testb %al, %al
jne 0x5968
incq %r12
cmpq %r12, 0x10(%r15)
seta %r14b
ja 0x5943
andb $0x1, %r14b
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5e2c(%rip), %rdi      # 0xb7ab
leaq 0x5e32(%rip), %rsi      # 0xb7b8
leaq 0x682e(%rip), %rcx      # 0xc1bb
movl $0x7b, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
cmpq $0x0, 0x10(%rdi)
setne %r15b
je 0x59dd
movq %rsi, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
cmpq %r12, 0x10(%rbx)
jbe 0x59fc
movq 0x8(%rbx), %rax
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
callq *(%rbx)
testb %al, %al
jne 0x59df
incq %r12
cmpq %r12, 0x10(%rbx)
seta %r15b
ja 0x59b7
jmp 0x59ed
jmp 0x59ed
cmpq %r12, 0x38(%rbx)
jbe 0x5a3a
movq 0x30(%rbx), %rax
movq (%rax,%r12,8), %rax
testb $0x1, %r15b
je 0x5a1b
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5da8(%rip), %rdi      # 0xb7ab
leaq 0x5dae(%rip), %rsi      # 0xb7b8
leaq 0x67aa(%rip), %rcx      # 0xc1bb
movl $0x7b, %edx
callq 0x10d0
leaq 0x6616(%rip), %rdi      # 0xc038
leaq 0x6628(%rip), %rsi      # 0xc051
leaq 0x69c2(%rip), %rcx      # 0xc3f2
movl $0x5b, %edx
callq 0x10d0
leaq 0x5d6a(%rip), %rdi      # 0xb7ab
leaq 0x5d70(%rip), %rsi      # 0xb7b8
leaq 0x696c(%rip), %rcx      # 0xc3bb
jmp 0x5a11
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rbx
leaq (,%rbx,8), %rax
leaq (%rax,%rax,2), %rdi
callq 0x1200
testq %rbx, %rbx
je 0x5f57
movq (%r14), %rcx
xorl %edx, %edx
movq %rbx, %rsi
movq 0x10(%rcx,%rdx), %rdi
movq %rdi, 0x10(%rax,%rdx)
movups (%rcx,%rdx), %xmm0
movups %xmm0, (%rax,%rdx)
addq $0x18, %rdx
decq %rsi
jne 0x5f3c
movq 0x28(%r14), %rdi
movq 0x30(%r14), %rsi
movq %rax, %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %rbp
jmp 0x8ec0
// File: /workspace/github_cpp_makefile_star2_O1/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, 0xb2b7(%rip)     # 0x11238
movl $0x59, %edi
callq 0x1200
movq %rax, %rbx
leaq 0xb273(%rip), %rdi      # 0x11208
movq %rax, %rsi
callq 0x5492
leaq 0x1(%rbx), %r14
movq 0xb168(%rip), %rax      # 0x11110
movq 0xb169(%rip), %rcx      # 0x11118
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 0xb136(%rip), %rax      # 0x11110
movq 0xb137(%rip), %rcx      # 0x11118
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_O1/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 0xaf89(%rip), %r13      # 0x10fd0
movq %r13, 0x28(%rdi)
movq 0xaf76(%rip), %rbx      # 0x10fc8
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 0x8f9a
movq %r12, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x8f18
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
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 0x6b4c
movq 0x60(%rbx), %rdi
callq *0x80(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x55b5(%rip), %rdi      # 0xc108
leaq 0x5090(%rip), %rsi      # 0xbbea
leaq 0x55bc(%rip), %rcx      # 0xc11d
movl $0x66, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6cd2
cmpq $0x0, 0x68(%rbx)
je 0x6c1a
xorl %r14d, %r14d
cmpq %r14, 0x68(%rbx)
jbe 0x6c51
movq 0x60(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x9ec0
incq %r14
cmpq %r14, 0x68(%rbx)
ja 0x6bfe
cmpq $0x0, 0x40(%rbx)
je 0x6c46
xorl %r14d, %r14d
xorl %r15d, %r15d
cmpq %r15, 0x40(%rbx)
jbe 0x6c68
movq 0x38(%rbx), %rdi
addq %r14, %rdi
callq 0x48b2
incq %r15
addq $0x10, %r14
cmpq %r15, 0x40(%rbx)
ja 0x6c27
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4b53(%rip), %rdi      # 0xb7ab
leaq 0x4b59(%rip), %rsi      # 0xb7b8
leaq 0x514b(%rip), %rcx      # 0xbdb1
jmp 0x6c7d
leaq 0x4b3c(%rip), %rdi      # 0xb7ab
leaq 0x4b42(%rip), %rsi      # 0xb7b8
leaq 0x4b47(%rip), %rcx      # 0xb7c4
movl $0x7b, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0x6cb1
xorl %r14d, %r14d
movq (%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x11f8
incq %r14
cmpq %r14, 0x8(%rbx)
ja 0x6c9c
movq (%rbx), %rdi
callq *0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x28(%rbx), %rdi
callq *0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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)
cmpq $0x0, 0x30(%rbx)
je 0x6d1e
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq %r12, 0x30(%rbx)
jbe 0x6d3a
movq 0x28(%rbx), %rdi
addq %r15, %rdi
callq 0x48b2
incq %r12
addq $0x10, %r15
cmpq %r12, 0x30(%rbx)
ja 0x6cff
movq 0x50(%rbx), %rax
testq %rax, %rax
je 0x6d31
movb $0x1, -0x1(%rax)
movq 0x50(%rbx), %rbx
jmp 0x6ce3
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4a6a(%rip), %rdi      # 0xb7ab
leaq 0x4a70(%rip), %rsi      # 0xb7b8
leaq 0x4a75(%rip), %rcx      # 0xb7c4
movl $0x7b, %edx
callq 0x10d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6eaf
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 0x495d(%rip), %rdi      # 0xb813
leaq 0x48fb(%rip), %rsi      # 0xb7b8
leaq 0x4964(%rip), %rcx      # 0xb828
movl $0x4a, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O1/pixlark[P]Badge/src/compiler.cc
// Function: Compiler::compile_operator(Operator, int)
void compile_operator(Operator op, Assoc_Ptr assoc)
	{
		switch (op) {
		case OP_NEGATE:
			push(BC::create(BC_NEGATE, assoc));
			break;
		case OP_ADD:
			push(BC::create(BC_ADD, assoc));
			break;
		case OP_SUBTRACT:
			push(BC::create(BC_SUBTRACT, assoc));
			break;
		case OP_MULTIPLY:
			push(BC::create(BC_MULTIPLY, assoc));
			break;
		case OP_DIVIDE:
			push(BC::create(BC_DIVIDE, assoc));
			break;
		case OP_EQUAL:
			push(BC::create(BC_EQUAL, assoc));
			break;
		case OP_NOT_EQUAL:
			push(BC::create(BC_NOT_EQUAL, assoc));
			break;
		case OP_LESS_THAN:
			push(BC::create(BC_LESS_THAN, assoc));
			break;
		case OP_GREATER_THAN:
			push(BC::create(BC_GREATER_THAN, assoc));
			break;
		case OP_LESS_THAN_OR_EQUAL_TO:
			push(BC::create(BC_LESS_THAN_OR_EQUAL_TO, assoc));
			break;
		case OP_GREATER_THAN_OR_EQUAL_TO:
			push(BC::create(BC_GREATER_THAN_OR_EQUAL_TO, assoc));
			break;
		case OP_AND:
			push(BC::create(BC_AND, assoc));
			break;
		case OP_OR:
			push(BC::create(BC_OR, assoc));
			break;
		case OP_NOT:
			push(BC::create(BC_NOT, assoc));
			break;
		}
	}

// Assembly:
cmpl $0xd, %esi
ja 0x8d57
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rdi, %r14
movl %esi, %eax
leaq 0x269d(%rip), %rcx      # 0xb258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0xb, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x17, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0xa, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x18, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x11, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x8, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x9, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0xf, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x7, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0xc, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x19, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0xd, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0x10, %r15d
jmp 0x8ce1
movq 0x8(%r14), %rcx
movq 0x10(%r14), %rax
incq %rcx
movl $0xe, %r15d
cmpq %rcx, %rax
jae 0x8d32
testq %rax, %rax
js 0x8cf2
cvtsi2ss %rax, %xmm0
jmp 0x8d07
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 0x22e5(%rip), %xmm0     # 0xb004
cvttss2si %xmm0, %rsi
andq %rcx, %rsi
orq %rax, %rsi
movq %r14, %rdi
callq 0x8e48
movq (%r14), %rax
movq 0x8(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x8(%r14)
leaq (%rcx,%rcx,2), %rcx
movl %r15d, (%rax,%rcx,8)
movl %ebx, 0x4(%rax,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f6e
movq %rax, 0x8(%rbx)
movq %r12, 0x50(%rax)
movq %r14, 0x10(%rbx)
callq 0x5f6e
movq %rax, 0x18(%rbx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x90dc
movq %rax, 0x20(%rbx)
movq $0x0, 0x28(%rbx)
cmpq %r14, 0x30(%r15)
jbe 0x904d
movq 0x28(%r15), %rax
movq (%rax,%r14,8), %rax
movq %rax, 0x30(%rbx)
movq $0x0, 0x40(%rbx)
movq $0x4, 0x48(%rbx)
movq 0x7fb2(%rip), %rax      # 0x10fd0
movq %rax, 0x50(%rbx)
movq 0x7f9f(%rip), %rax      # 0x10fc8
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 0x2757(%rip), %rdi      # 0xb7ab
leaq 0x275d(%rip), %rsi      # 0xb7b8
leaq 0x2acb(%rip), %rcx      # 0xbb2d
movl $0x7b, %edx
callq 0x10d0