LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::weak_expect(Token_Kind)
Token Parser::weak_expect(Token_Kind type)
{
	if (!is(type)) {
		fatal_assoc(peek.assoc,
					"Expected %s, got %s",
					Token::type_to_string(type),
					peek.to_string());
	}
	return peek;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x1c(%rbp), %esi
callq 0x3f70
testb $0x1, %al
jne 0x3bae
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %edi
callq 0x23f0
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x24f0
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xcb16(%rip), %rsi      # 0x106bd
movb $0x0, %al
callq 0x1f40
movq -0x28(%rbp), %rax
movups 0x8(%rax), %xmm0
movaps %xmm0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::expect(Token_Kind)
Token Parser::expect(Token_Kind type)
{
	if (!is(type)) {
		fatal_assoc(peek.assoc,
					"Expected %s, got %s",
					Token::type_to_string(type),
					peek.to_string());
	}
	return next();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl -0x1c(%rbp), %esi
callq 0x3f70
testb $0x1, %al
jne 0x3e5e
movq -0x28(%rbp), %rax
movl 0xc(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x1c(%rbp), %edi
callq 0x23f0
movq -0x28(%rbp), %rdi
movq %rax, -0x30(%rbp)
addq $0x8, %rdi
callq 0x24f0
movl -0x34(%rbp), %edi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0xc866(%rip), %rsi      # 0x106bd
movb $0x0, %al
callq 0x1f40
movq -0x28(%rbp), %rdi
callq 0x4fa0
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_unary()
Expr * Parser::parse_unary()
{
	if (is('-') || is(TOKEN_NOT)) {
		Operator op;
		if (match('-')) {
			op = OP_NEGATE;
		} else if (match(TOKEN_NOT)) {
			op = OP_NOT;
		} else assert(false);
		auto expr = create_expr(EXPR_UNARY);
		expr->unary.op = op;
		expr->unary.expr = parse_unary();
		return expr;
	}
	return parse_function_call();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x2d, %esi
callq 0x75a0
testb $0x1, %al
jne 0x3eb9
movq -0x28(%rbp), %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x3f70
testb $0x1, %al
jne 0x3eb9
jmp 0x3f4e
movq -0x28(%rbp), %rdi
movl $0x2d, %esi
callq 0x73c0
testb $0x1, %al
jne 0x3ecd
jmp 0x3ed6
movl $0x0, -0x14(%rbp)
jmp 0x3f14
movq -0x28(%rbp), %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x3f90
testb $0x1, %al
jne 0x3eea
jmp 0x3ef3
movl $0xd, -0x14(%rbp)
jmp 0x3f12
leaq 0xc702(%rip), %rdi      # 0x105fc
leaq 0xc701(%rip), %rsi      # 0x10602
movl $0x9d, %edx
leaq 0xc703(%rip), %rcx      # 0x10610
callq 0x10d0
jmp 0x3f14
movq -0x28(%rbp), %rdi
movl $0x4, %esi
callq 0x3a40
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
callq 0x3e80
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x3f5b
movq -0x28(%rbp), %rdi
callq 0x3bd0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::match(Token_Kind)
bool Parser::match(Token_Kind type)
{
	if (is(type)) {
		advance();
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl -0x14(%rbp), %esi
callq 0x3f70
testb $0x1, %al
jne 0x3fb5
jmp 0x3fc4
movq -0x20(%rbp), %rdi
callq 0x3a70
movb $0x1, -0x1(%rbp)
jmp 0x3fc8
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_multiply_divide()
Expr * Parser::parse_multiply_divide()
{
	auto left = parse_unary();
	while (is('*') || is('/')) {
		Operator op;
		if (match('*')) {
			op = OP_MULTIPLY;
		} else if (match('/')) {
			op = OP_DIVIDE;
		} else assert(false);
		auto expr = create_expr(EXPR_BINARY);
		expr->binary.left = left;
		expr->binary.op = op;
		expr->binary.right = parse_unary();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x3e80
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movl $0x2a, %esi
callq 0x75a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x4028
movq -0x28(%rbp), %rdi
movl $0x2f, %esi
callq 0x75a0
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x4034
jmp 0x40d8
movq -0x28(%rbp), %rdi
movl $0x2a, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4048
jmp 0x4051
movl $0x3, -0x14(%rbp)
jmp 0x408f
movq -0x28(%rbp), %rdi
movl $0x2f, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4065
jmp 0x406e
movl $0x4, -0x14(%rbp)
jmp 0x408d
leaq 0xc587(%rip), %rdi      # 0x105fc
leaq 0xc586(%rip), %rsi      # 0x10602
movl $0xaf, %edx
leaq 0xc5a4(%rip), %rcx      # 0x1062c
callq 0x10d0
jmp 0x408f
movq -0x28(%rbp), %rdi
movl $0x5, %esi
callq 0x3a40
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
callq 0x3e80
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x3ffd
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_add_subtract()
Expr * Parser::parse_add_subtract()
{
	auto left = parse_multiply_divide();
	while (is('+') || is('-')) {
		auto expr = create_expr(EXPR_BINARY);
		if (match('+')) {
			expr->binary.op = OP_ADD;
		} else if (match('-')) {
			expr->binary.op = OP_SUBTRACT;
		} else assert(false);
		expr->binary.left = left;
		expr->binary.right = parse_multiply_divide();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x3fe0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl $0x2b, %esi
callq 0x75a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x4138
movq -0x20(%rbp), %rdi
movl $0x2d, %esi
callq 0x75a0
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4144
jmp 0x41e6
movq -0x20(%rbp), %rdi
movl $0x5, %esi
callq 0x3a40
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl $0x2b, %esi
callq 0x73c0
testb $0x1, %al
jne 0x416a
jmp 0x4177
movq -0x18(%rbp), %rax
movl $0x1, 0x10(%rax)
jmp 0x41b9
movq -0x20(%rbp), %rdi
movl $0x2d, %esi
callq 0x73c0
testb $0x1, %al
jne 0x418b
jmp 0x4198
movq -0x18(%rbp), %rax
movl $0x2, 0x10(%rax)
jmp 0x41b7
leaq 0xc45d(%rip), %rdi      # 0x105fc
leaq 0xc45c(%rip), %rsi      # 0x10602
movl $0xc2, %edx
leaq 0xc4a0(%rip), %rcx      # 0x10652
callq 0x10d0
jmp 0x41b9
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3fe0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x410d
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_comparisons()
Expr * Parser::parse_comparisons()
{
	auto left = parse_add_subtract();
	while (is('<') || is('>') || is(TOKEN_LTE) || is(TOKEN_GTE)) {
		auto expr = create_expr(EXPR_BINARY);
		if (match('<')) {
			expr->binary.op = OP_LESS_THAN;
		} else if (match('>')) {
			expr->binary.op = OP_GREATER_THAN;
		} else if (match(TOKEN_LTE)) {
			expr->binary.op = OP_LESS_THAN_OR_EQUAL_TO;
		} else if (match(TOKEN_GTE)) {
			expr->binary.op = OP_GREATER_THAN_OR_EQUAL_TO;
		} else assert(false);
		expr->binary.left = left;
		expr->binary.right = parse_add_subtract();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x40f0
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl $0x3c, %esi
callq 0x75a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x426c
movq -0x20(%rbp), %rdi
movl $0x3e, %esi
callq 0x75a0
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x426c
movq -0x20(%rbp), %rdi
movl $0x104, %esi            # imm = 0x104
callq 0x3f70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x426c
movq -0x20(%rbp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x3f70
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x4278
jmp 0x4363
movq -0x20(%rbp), %rdi
movl $0x5, %esi
callq 0x3a40
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl $0x3c, %esi
callq 0x73c0
testb $0x1, %al
jne 0x429e
jmp 0x42ae
movq -0x18(%rbp), %rax
movl $0x7, 0x10(%rax)
jmp 0x4336
movq -0x20(%rbp), %rdi
movl $0x3e, %esi
callq 0x73c0
testb $0x1, %al
jne 0x42c2
jmp 0x42cf
movq -0x18(%rbp), %rax
movl $0x8, 0x10(%rax)
jmp 0x4334
movq -0x20(%rbp), %rdi
movl $0x104, %esi            # imm = 0x104
callq 0x3f90
testb $0x1, %al
jne 0x42e3
jmp 0x42f0
movq -0x18(%rbp), %rax
movl $0x9, 0x10(%rax)
jmp 0x4332
movq -0x20(%rbp), %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x3f90
testb $0x1, %al
jne 0x4304
jmp 0x4311
movq -0x18(%rbp), %rax
movl $0xa, 0x10(%rax)
jmp 0x4330
leaq 0xc2e4(%rip), %rdi      # 0x105fc
leaq 0xc2e3(%rip), %rsi      # 0x10602
movl $0xd7, %edx
leaq 0xc34a(%rip), %rcx      # 0x10675
callq 0x10d0
jmp 0x4332
jmp 0x4334
jmp 0x4336
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x40f0
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x420d
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_equal_not_equal()
Expr * Parser::parse_equal_not_equal()
{
	auto left = parse_comparisons();
	while (is(TOKEN_EQUAL) || is(TOKEN_NOT_EQUAL)) {
		Operator op;
		if (match(TOKEN_EQUAL)) {
			op = OP_EQUAL;
		} else if (match(TOKEN_NOT_EQUAL)) {
			op = OP_NOT_EQUAL;
		} else assert(false);
		auto expr = create_expr(EXPR_BINARY);
		expr->binary.left = left;
		expr->binary.op = op;
		expr->binary.right = parse_comparisons();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x41f0
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x3f70
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x29(%rbp)
jne 0x43b8
movq -0x28(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x3f70
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x43c4
jmp 0x4468
movq -0x28(%rbp), %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x3f90
testb $0x1, %al
jne 0x43d8
jmp 0x43e1
movl $0x5, -0x14(%rbp)
jmp 0x441f
movq -0x28(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x3f90
testb $0x1, %al
jne 0x43f5
jmp 0x43fe
movl $0x6, -0x14(%rbp)
jmp 0x441d
leaq 0xc1f7(%rip), %rdi      # 0x105fc
leaq 0xc1f6(%rip), %rsi      # 0x10602
movl $0xe8, %edx
leaq 0xc27f(%rip), %rcx      # 0x10697
callq 0x10d0
jmp 0x441f
movq -0x28(%rbp), %rdi
movl $0x5, %esi
callq 0x3a40
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10(%rax)
callq 0x41f0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x438d
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_and()
Expr * Parser::parse_and()
{
	auto left = parse_equal_not_equal();
	while (match(TOKEN_AND)) {
		auto expr = create_expr(EXPR_BINARY);
		expr->binary.left = left;
		expr->binary.op = OP_AND;
		expr->binary.right = parse_equal_not_equal();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4370
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x3f90
testb $0x1, %al
jne 0x44b1
jmp 0x44f8
movq -0x20(%rbp), %rdi
movl $0x5, %esi
callq 0x3a40
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0xb, 0x10(%rax)
callq 0x4370
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x449d
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_or()
Expr * Parser::parse_or()
{
	auto left = parse_and();
	while (match(TOKEN_OR)) {
		auto expr = create_expr(EXPR_BINARY);
		expr->binary.left = left;
		expr->binary.op = OP_OR;
		expr->binary.right = parse_and();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x4480
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x3f90
testb $0x1, %al
jne 0x4541
jmp 0x4588
movq -0x20(%rbp), %rdi
movl $0x5, %esi
callq 0x3a40
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movl $0xc, 0x10(%rax)
callq 0x4480
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x452d
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_symbol_list(Token_Kind, Token_Kind)
List<Symbol> Parser::parse_symbol_list(Token_Kind open, Token_Kind close)
{
	expect(open);
	List<Symbol> list;
	list.alloc();
	while (true) {
		if (match(close)) {
			break;
		}
		weak_expect(TOKEN_SYMBOL);
		list.push(peek.values.symbol);
		advance();
		if (!match(',')) {
			expect(close);
			break;
		}
	}
	return list;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, -0x68(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl -0xc(%rbp), %esi
callq 0x3e00
movq -0x58(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x12c03(%rip), %rax     # 0x171e0
movq %rax, -0x30(%rbp)
movq 0x12c00(%rip), %rax     # 0x171e8
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x6e20
movq -0x60(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3f90
testb $0x1, %al
jne 0x460b
jmp 0x460d
jmp 0x466a
movq -0x60(%rbp), %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x3b50
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movq -0x60(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq 0x10(%rax), %rsi
callq 0x6f20
movq -0x60(%rbp), %rdi
callq 0x3a70
movq -0x60(%rbp), %rdi
movl $0x2c, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4668
movq -0x60(%rbp), %rdi
movl -0x10(%rbp), %esi
callq 0x3e00
movq %rax, -0x50(%rbp)
movq %rdx, -0x48(%rbp)
jmp 0x466a
jmp 0x45f9
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_lambda()
Expr * Parser::parse_lambda()
{
	if (match(TOKEN_LAMBDA)) {
		auto lambda = create_expr(EXPR_LAMBDA);
		lambda->lambda.parameters = parse_symbol_list((Token_Kind) '(',
													  (Token_Kind) ')');
		lambda->lambda.body = parse_expr();
		return lambda;
	} else {
		return parse_or();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x107, %esi            # imm = 0x107
callq 0x3f90
testb $0x1, %al
jne 0x46a4
jmp 0x4701
movq -0x48(%rbp), %rdi
movl $0x7, %esi
callq 0x3a40
movq -0x48(%rbp), %rsi
movq %rax, -0x18(%rbp)
leaq -0x40(%rbp), %rdi
movl $0x28, %edx
movl $0x29, %ecx
callq 0x45a0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq -0x40(%rbp), %rsi
movl $0x28, %edx
callq 0x10e0
movq -0x48(%rbp), %rdi
callq 0x3a20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x470e
movq -0x48(%rbp), %rdi
callq 0x4510
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_loop()
Expr * Parser::parse_loop()
{
	if (match(TOKEN_LOOP)) {
		// Check for `for` expression
		auto loop = create_expr(EXPR_LOOP);
		loop->loop.body = parse_expr();
		return loop;
	} else {
		return parse_lambda();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x112, %esi            # imm = 0x112
callq 0x3f90
testb $0x1, %al
jne 0x4744
jmp 0x4774
movq -0x20(%rbp), %rdi
movl $0xd, %esi
callq 0x3a40
movq -0x20(%rbp), %rdi
movq %rax, -0x18(%rbp)
callq 0x3a20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4781
movq -0x20(%rbp), %rdi
callq 0x4680
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x10d, %esi            # imm = 0x10D
callq 0x3f90
testb $0x1, %al
jne 0x47b7
jmp 0x48d1
movq -0x50(%rbp), %rdi
movl $0x9, %esi
callq 0x3a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq 0x12a08(%rip), %rax     # 0x171e0
movq %rax, -0x28(%rbp)
movq 0x12a05(%rip), %rax     # 0x171e8
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x7430
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x28, %rdi
movq 0x129d9(%rip), %rax     # 0x171e0
movq %rax, -0x38(%rbp)
movq 0x129d6(%rip), %rax     # 0x171e8
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7430
movq -0x50(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x60(%rbp)
callq 0x3a20
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x74f0
movq -0x50(%rbp), %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x3e00
movq -0x50(%rbp), %rdi
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x28, %rax
movq %rax, -0x58(%rbp)
callq 0x3a20
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x74f0
movq -0x50(%rbp), %rdi
movl $0x10f, %esi            # imm = 0x10F
callq 0x3f90
testb $0x1, %al
jne 0x4823
movq -0x50(%rbp), %rdi
movl $0x110, %esi            # imm = 0x110
callq 0x3f90
testb $0x1, %al
jne 0x48a5
jmp 0x48bb
movq -0x50(%rbp), %rdi
callq 0x3a20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x58(%rax)
jmp 0x48c7
movq -0x18(%rbp), %rax
movq $0x0, 0x58(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x48de
movq -0x50(%rbp), %rdi
callq 0x4720
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movl $0x115, %esi            # imm = 0x115
callq 0x3f90
testb $0x1, %al
jne 0x4914
jmp 0x4966
movq -0x30(%rbp), %rdi
movl $0xe, %esi
callq 0x3a40
movq -0x30(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl $0x116, %esi            # imm = 0x116
callq 0x3e00
movq -0x30(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3a20
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4973
movq -0x30(%rbp), %rdi
callq 0x4790
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x40, %esi
callq 0x73c0
testb $0x1, %al
jne 0x49a7
jmp 0x4a91
movq -0x60(%rbp), %rdi
movl $0xa, %esi
callq 0x3a40
movq -0x60(%rbp), %rdi
movq %rax, -0x18(%rbp)
movl $0x116, %esi            # imm = 0x116
callq 0x3e00
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
addq $0x8, %rdi
movq 0x127f2(%rip), %rax     # 0x171e0
movq %rax, -0x38(%rbp)
movq 0x127ef(%rip), %rax     # 0x171e8
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x7430
movq -0x60(%rbp), %rdi
movl $0x5b, %esi
callq 0x73f0
movq %rax, -0x48(%rbp)
movq %rdx, -0x40(%rbp)
movq -0x60(%rbp), %rdi
movl $0x5d, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4a34
jmp 0x4a36
jmp 0x4a87
movq -0x60(%rbp), %rdi
movq -0x18(%rbp), %rax
addq $0x8, %rax
addq $0x8, %rax
movq %rax, -0x68(%rbp)
callq 0x3a20
movq -0x68(%rbp), %rdi
movq %rax, %rsi
callq 0x74f0
movq -0x60(%rbp), %rdi
movl $0x2c, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4a85
movq -0x60(%rbp), %rdi
movl $0x5d, %esi
callq 0x73f0
movq %rax, -0x58(%rbp)
movq %rdx, -0x50(%rbp)
jmp 0x4a87
jmp 0x4a20
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4a9e
movq -0x60(%rbp), %rdi
callq 0x48f0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movl $0x7b, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4ad7
jmp 0x4bb1
movq -0x48(%rbp), %rdi
movl $0x6, %esi
callq 0x3a40
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq 0x126e8(%rip), %rax     # 0x171e0
movq %rax, -0x28(%rbp)
movq 0x126e5(%rip), %rax     # 0x171e8
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x75d0
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x48(%rbp), %rdi
movl $0x7d, %esi
callq 0x73c0
xorb $-0x1, %al
testb $0x1, %al
jne 0x4b36
jmp 0x4ba7
movq -0x48(%rbp), %rdi
callq 0x4bd0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
cmpl $0x3, (%rax)
jne 0x4b7b
movq -0x48(%rbp), %rdi
movl $0x7d, %esi
callq 0x73c0
testb $0x1, %al
jne 0x4b60
jmp 0x4b7b
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x30(%rbp), %rdi
callq 0x11e8
jmp 0x4ba7
movq -0x48(%rbp), %rdi
movl $0x2e, %esi
callq 0x73f0
movq %rax, -0x40(%rbp)
movq %rdx, -0x38(%rbp)
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rsi
callq 0x7630
jmp 0x4b20
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x4bbe
movq -0x48(%rbp), %rdi
callq 0x4980
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x105, %esi            # imm = 0x105
callq 0x3f70
testb $0x1, %al
jne 0x4bf4
jmp 0x4c06
movq -0x18(%rbp), %rdi
callq 0x4dc0
movq %rax, -0x10(%rbp)
jmp 0x4cc3
movq -0x18(%rbp), %rdi
movl $0x106, %esi            # imm = 0x106
callq 0x3f70
testb $0x1, %al
jne 0x4c1a
jmp 0x4c2c
movq -0x18(%rbp), %rdi
callq 0x4e50
movq %rax, -0x10(%rbp)
jmp 0x4cc1
movq -0x18(%rbp), %rdi
movl $0x108, %esi            # imm = 0x108
callq 0x3f70
testb $0x1, %al
jne 0x4c40
jmp 0x4c4f
movq -0x18(%rbp), %rdi
callq 0x4ed0
movq %rax, -0x10(%rbp)
jmp 0x4cbf
movq -0x18(%rbp), %rdi
movl $0x113, %esi            # imm = 0x113
callq 0x3f70
testb $0x1, %al
jne 0x4c63
jmp 0x4c72
movq -0x18(%rbp), %rdi
callq 0x4f20
movq %rax, -0x10(%rbp)
jmp 0x4cbd
movq -0x18(%rbp), %rdi
movl $0x114, %esi            # imm = 0x114
callq 0x3f70
testb $0x1, %al
jne 0x4c86
jmp 0x4c95
movq -0x18(%rbp), %rdi
callq 0x4cd0
movq %rax, -0x10(%rbp)
jmp 0x4cbb
movq -0x18(%rbp), %rdi
movl $0x3, %esi
callq 0x4d90
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3a20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0x4cbd
jmp 0x4cbf
jmp 0x4cc1
jmp 0x4cc3
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
xorl %esi, %esi
callq 0x4d90
movq -0x50(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3a70
movq -0x50(%rbp), %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x3b50
movq -0x50(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x10(%rdi), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3a70
movq -0x50(%rbp), %rdi
movl $0x7, %esi
callq 0x3a40
movq -0x50(%rbp), %rsi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
leaq -0x48(%rbp), %rdi
movl $0x28, %edx
movl $0x29, %ecx
callq 0x45a0
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
addq $0x8, %rdi
leaq -0x48(%rbp), %rsi
movl $0x28, %edx
callq 0x10e0
movq -0x50(%rbp), %rdi
callq 0x3a20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
callq 0x4d90
movq -0x38(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3a70
movq -0x38(%rbp), %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x3b50
movq -0x38(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
movq 0x10(%rdi), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
callq 0x3a70
movq -0x38(%rbp), %rdi
movl $0x3d, %esi
callq 0x73f0
movq -0x38(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq %rdx, -0x28(%rbp)
callq 0x3a20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x1, %esi
callq 0x4d90
movq -0x28(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3a70
movq -0x28(%rbp), %rdi
callq 0x3a20
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x3d, %esi
callq 0x73f0
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
callq 0x3a20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x2, %esi
callq 0x4d90
movq -0x18(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x3a70
movq -0x18(%rbp), %rdi
callq 0x3a20
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movl $0x113, %esi            # imm = 0x113
callq 0x3e00
movq -0x28(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
movl $0x4, %esi
callq 0x4d90
movq -0x28(%rbp), %rdi
movq %rax, -0x20(%rbp)
callq 0x3a20
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq 0x12171(%rip), %rax     # 0x172b8
movq %rax, 0x1216a(%rip)     # 0x172b8
movq -0x8(%rbp), %rdi
addq $0x1, %rdi
callq 0x11f0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x1211e(%rip), %rdi     # 0x17288
callq 0x6c70
movq -0x10(%rbp), %rdi
callq 0x50f0
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x40, %rsp
movq 0x11fa1(%rip), %rax     # 0x171e0
movq %rax, -0x38(%rbp)
movq 0x11f9e(%rip), %rax     # 0x171e8
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x28(%rbp), %rdi
callq 0x6b70
movl $0x0, -0x3c(%rbp)
movslq -0x3c(%rbp), %rax
cmpq 0x1201f(%rip), %rax     # 0x17290
jae 0x52ce
movslq -0x3c(%rbp), %rsi
leaq 0x1200a(%rip), %rdi     # 0x17288
callq 0x6bd0
movq (%rax), %rax
cmpb $0x0, (%rax)
je 0x52a9
movslq -0x3c(%rbp), %rsi
leaq 0x11ff2(%rip), %rdi     # 0x17288
callq 0x6bd0
movq (%rax), %rsi
leaq -0x28(%rbp), %rdi
callq 0x6c70
jmp 0x52c1
movslq -0x3c(%rbp), %rsi
leaq 0x11fd4(%rip), %rdi     # 0x17288
callq 0x6bd0
movq (%rax), %rdi
callq 0x11e8
jmp 0x52c3
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x5266
leaq 0x11fb3(%rip), %rdi     # 0x17288
callq 0x6c30
leaq 0x11fa7(%rip), %rdi     # 0x17288
leaq -0x28(%rbp), %rsi
movl $0x28, %edx
callq 0x10e0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl (%rax), %eax
movq %rax, -0x20(%rbp)
subq $0x8, %rax
ja 0x543c
movq -0x20(%rbp), %rax
leaq 0xaf01(%rip), %rcx      # 0x10230
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0xb392(%rip), %rdi      # 0x106d1
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x545b
movq -0x28(%rbp), %rax
movl 0x8(%rax), %edi
callq 0x19a0
movq %rax, -0x8(%rbp)
jmp 0x545b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x545b
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x11f0
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq 0x8(%rax), %rcx
movq (%rcx), %rsi
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
callq 0x10b0
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rcx
movb $0x0, (%rax,%rcx)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x545b
leaq 0xb2fd(%rip), %rdi      # 0x106d9
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x545b
leaq 0xb2f7(%rip), %rdi      # 0x106e5
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x545b
leaq 0xb2f0(%rip), %rdi      # 0x106f0
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x545b
leaq 0xb2ed(%rip), %rdi      # 0x106ff
callq 0x11d0
movq %rax, -0x8(%rbp)
jmp 0x545b
leaq 0xb1d8(%rip), %rdi      # 0x105fc
leaq 0xb2de(%rip), %rsi      # 0x10709
movl $0x4f, %edx
leaq 0xb2e3(%rip), %rcx      # 0x1071a
callq 0x10d0
leaq 0xb1b9(%rip), %rdi      # 0x105fc
leaq 0xb2bf(%rip), %rsi      # 0x10709
movl $0x51, %edx
leaq 0xb2c4(%rip), %rcx      # 0x1071a
callq 0x10d0
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl (%rax), %eax
movq %rax, -0x10(%rbp)
subq $0x8, %rax
ja 0x5533
movq -0x10(%rbp), %rax
leaq 0xadb5(%rip), %rcx      # 0x10254
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
jmp 0x5533
jmp 0x5533
jmp 0x5533
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x76c0
jmp 0x5533
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x76e0
jmp 0x5533
jmp 0x5533
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7730
jmp 0x5533
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5190
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x7750
jmp 0x5533
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x5190
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x60, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x34(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movl -0x34(%rbp), %r8d
movl -0x50(%rbp), %edi
movq -0x48(%rbp), %rsi
movl -0x60(%rbp), %edx
movq -0x58(%rbp), %rcx
callq 0x55e0
movl -0x20(%rbp), %eax
subl $0x1, %eax
jne 0x55ac
jmp 0x558b
movl -0x18(%rbp), %edi
movl -0x28(%rbp), %eax
addl %eax, %edi
callq 0x77b0
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
movl -0x34(%rbp), %edi
leaq 0xb17d(%rip), %rsi      # 0x10733
movb $0x0, %al
callq 0x1f40
leaq 0xb038(%rip), %rdi      # 0x105fc
leaq 0xb13e(%rip), %rsi      # 0x10709
movl $0x85, %edx
leaq 0xb171(%rip), %rcx      # 0x10748
callq 0x10d0
nopl (%rax)
// File: 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
subq $0x60, %rsp
movl %edi, -0x20(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x30(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x34(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movups -0x30(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movl -0x34(%rbp), %r8d
movl -0x50(%rbp), %edi
movq -0x48(%rbp), %rsi
movl -0x60(%rbp), %edx
movq -0x58(%rbp), %rcx
callq 0x55e0
movl -0x20(%rbp), %eax
subl $0x1, %eax
jne 0x56ac
jmp 0x568b
movl -0x18(%rbp), %edi
movl -0x28(%rbp), %eax
subl %eax, %edi
callq 0x77b0
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x60, %rsp
popq %rbp
retq
movl -0x34(%rbp), %edi
leaq 0xb0c3(%rip), %rsi      # 0x10779
movb $0x0, %al
callq 0x1f40
leaq 0xaf38(%rip), %rdi      # 0x105fc
leaq 0xb03e(%rip), %rsi      # 0x10709
movl $0x91, %edx
leaq 0xb0b7(%rip), %rcx      # 0x1078e
callq 0x10d0
nopl (%rax)
// File: 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
subq $0x40, %rsp
movl %edi, -0x18(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x28(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x2c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x28(%rbp), %eax
je 0x584b
movb $0x0, -0x1(%rbp)
jmp 0x596d
movl -0x18(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x8, %rax
ja 0x594e
movq -0x38(%rbp), %rax
leaq 0xaa11(%rip), %rcx      # 0x10278
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x596d
movl -0x10(%rbp), %eax
cmpl -0x20(%rbp), %eax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x58bc
movb $0x0, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
callq 0x1090
cmpl $0x0, %eax
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
sete %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x596d
leaq 0xacc6(%rip), %rdi      # 0x105fc
leaq 0xadcc(%rip), %rsi      # 0x10709
movl $0xc8, %edx
leaq 0xaf0f(%rip), %rcx      # 0x10858
callq 0x10d0
leaq 0xaca7(%rip), %rdi      # 0x105fc
leaq 0xadad(%rip), %rsi      # 0x10709
movl $0xca, %edx
leaq 0xaef0(%rip), %rcx      # 0x10858
callq 0x10d0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x24(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x24(%rbp), %r8d
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x55e0
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x5a7c
jmp 0x5a6b
movl -0x8(%rbp), %eax
cmpl -0x18(%rbp), %eax
setl %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movl -0x24(%rbp), %edi
leaq 0xae04(%rip), %rsi      # 0x1088a
movb $0x0, %al
callq 0x1f40
leaq 0xab68(%rip), %rdi      # 0x105fc
leaq 0xac6e(%rip), %rsi      # 0x10709
movl $0xe0, %edx
leaq 0xadf8(%rip), %rcx      # 0x1089f
callq 0x10d0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x24(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x24(%rbp), %r8d
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x55e0
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x5b0c
jmp 0x5afb
movl -0x8(%rbp), %eax
cmpl -0x18(%rbp), %eax
setg %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movl -0x24(%rbp), %edi
leaq 0xadbf(%rip), %rsi      # 0x108d5
movb $0x0, %al
callq 0x1f40
leaq 0xaad8(%rip), %rdi      # 0x105fc
leaq 0xabde(%rip), %rsi      # 0x10709
movl $0xec, %edx
leaq 0xadb3(%rip), %rcx      # 0x108ea
callq 0x10d0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x24(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x24(%rbp), %r8d
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x55e0
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x5b9c
jmp 0x5b8b
movl -0x8(%rbp), %eax
cmpl -0x18(%rbp), %eax
setle %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movl -0x24(%rbp), %edi
leaq 0xad7d(%rip), %rsi      # 0x10923
movb $0x0, %al
callq 0x1f40
leaq 0xaa48(%rip), %rdi      # 0x105fc
leaq 0xab4e(%rip), %rsi      # 0x10709
movl $0xf8, %edx
leaq 0xad72(%rip), %rcx      # 0x10939
callq 0x10d0
nopl (%rax)
// File: 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
subq $0x50, %rsp
movl %edi, -0x10(%rbp)
movq %rsi, -0x8(%rbp)
movl %edx, -0x20(%rbp)
movq %rcx, -0x18(%rbp)
movl %r8d, -0x24(%rbp)
movups -0x10(%rbp), %xmm0
movaps %xmm0, -0x40(%rbp)
movups -0x20(%rbp), %xmm0
movaps %xmm0, -0x50(%rbp)
movl -0x24(%rbp), %r8d
movl -0x40(%rbp), %edi
movq -0x38(%rbp), %rsi
movl -0x50(%rbp), %edx
movq -0x48(%rbp), %rcx
callq 0x55e0
movl -0x10(%rbp), %eax
subl $0x1, %eax
jne 0x5c2c
jmp 0x5c1b
movl -0x8(%rbp), %eax
cmpl -0x18(%rbp), %eax
setge %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movl -0x24(%rbp), %edi
leaq 0xad45(%rip), %rsi      # 0x1097b
movb $0x0, %al
callq 0x1f40
leaq 0xa9b8(%rip), %rdi      # 0x105fc
leaq 0xaabe(%rip), %rsi      # 0x10709
movl $0x104, %edx            # imm = 0x104
leaq 0xad3a(%rip), %rcx      # 0x10991
callq 0x10d0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpl $0x1, -0x28(%rbp)
je 0x5c93
leaq 0xad4a(%rip), %rdi      # 0x109d6
movb $0x0, %al
callq 0x1c50
movl -0x20(%rbp), %edi
movl %edi, %eax
negl %eax
cmovnsl %eax, %edi
callq 0x77b0
movl %eax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movl -0x10(%rbp), %eax
movq -0x8(%rbp), %rdx
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)