LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/error.cc
// Function: print_assoc(Assoc)
void print_assoc(Assoc assoc)
{
	printf(DIM(":%zu\n"), assoc.line);
	size_t start = assoc.position;
	while (true) {
		if (start == 0) {
			break;
		}
		if (assoc.source[start - 1] == '\n') {
			break;
		}
		start--;
	}
	size_t end = assoc.position;
	while (true) {
		if (end == assoc.source_length - 1) {
			break;
		}
		if (assoc.source[end + 1] == '\n') {
			break;
		}
		end++;
	}
	// Line itself
	const char * selection = assoc.source + start;
	size_t selection_length = end - start + 1;
	printf(DIM("  %.*s\n"), (int) selection_length, selection);
	// Pointer char
	printf("  ");
	for (int i = 0; i < assoc.position - start; i++) {
		if (selection[i] == '\t') {
			printf("\t");
		} else {
			printf(" ");
		}
	}
	for (int i = 0; i < assoc.extents; i++) {
		printf(RED("^"));
	}
	printf("\n");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x10(%rbp), %rbx
movq 0x20(%rbx), %rsi
leaq 0x7908(%rip), %rdi      # 0x92fc
xorl %r14d, %r14d
xorl %eax, %eax
callq 0x1030
movq (%rbx), %rcx
movq 0x10(%rbx), %rax
leaq (%rcx,%rax), %r15
movq %rax, %rdx
negq %rdx
cmpq %r14, %rdx
je 0x1a21
cmpb $0xa, -0x1(%r15,%r14)
je 0x1a21
decq %r14
jmp 0x1a0f
movq 0x8(%rbx), %rdx
leaq -0x1(%rax), %r8
pushq $0x1
popq %rdi
subq %rdx, %rdi
decq %rdx
leaq (%rdi,%r8), %rsi
cmpq $-0x1, %rsi
je 0x1a4d
leaq 0x1(%r8), %rsi
cmpb $0xa, 0x2(%rcx,%r8)
movq %rsi, %r8
jne 0x1a32
jmp 0x1a50
movq %rdx, %rsi
leaq (%r15,%r14), %rdx
subl %eax, %esi
subl %r14d, %esi
incl %esi
leaq 0x78a8(%rip), %rdi      # 0x930a
xorl %eax, %eax
callq 0x1030
leaq 0x78aa(%rip), %rdi      # 0x931a
xorl %eax, %eax
callq 0x1030
pushq $0x9
popq %r12
pushq $0x20
popq %r13
testq %r14, %r14
je 0x1a9b
cmpb $0x9, (%r15,%r14)
movl %r12d, %edi
je 0x1a91
movl %r13d, %edi
callq 0x1150
incq %r14
jmp 0x1a7f
movq 0x18(%rbx), %r14
leaq 0x7877(%rip), %rbx      # 0x931d
subq $0x1, %r14
jb 0x1ab8
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1030
jmp 0x1aa6
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1150
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/error.cc
// Function: v_fatal_assoc(int, char const*, __va_list_tag*)
void v_fatal_assoc(Assoc_Ptr assoc, const char * fmt, va_list args)
{
	fprintf(stderr, RED(BOLD("encountered error")) ":\n");
	vfprintf(stderr, fmt, args);
	printf("\n");
	if (assoc != -1) {
		print_assoc(Assoc_Allocator::get(assoc));
	}
	abort();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movl %edi, %ebx
movq 0xd4ec(%rip), %r12      # 0xefd8
movq (%r12), %rcx
leaq 0x77e0(%rip), %rdi      # 0x92d7
pushq $0x24
popq %rsi
pushq $0x1
popq %rdx
callq 0x11e0
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1140
pushq $0xa
popq %rdi
callq 0x1150
cmpl $-0x1, %ebx
je 0x1b4c
leaq -0x48(%rbp), %r14
movq %r14, %rdi
movl %ebx, %esi
callq 0x182d
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x19d7
callq 0x10c0
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/files.cc
// Function: Files::destroy()
void destroy()
	{
		free((void*) stdlib_dir);
		free((void*) running_dir);
		free((void*) cwd);
		free((void*) first_file);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0xd43b(%rip), %rdi      # 0xf200
callq 0x11f8
movq 0xd427(%rip), %rdi      # 0xf1f8
callq 0x11f8
movq 0xd413(%rip), %rdi      # 0xf1f0
callq 0x11f8
movq 0xd3ff(%rip), %rdi      # 0xf1e8
popq %rbp
jmp 0x11f8
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/files.cc
// Function: Files::stdlib_file(char const*)
const char * stdlib_file(const char * name)
	{
		String_Builder builder;
		builder.append(stdlib_dir);
		builder.append(name);
		builder.append(".bdg");
		return builder.final_string();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
andq $0x0, 0x8(%r14)
movq $0x4, 0x10(%r14)
movq 0xd1bb(%rip), %rax      # 0xefd0
movq %rax, 0x18(%r14)
movq 0xd1a8(%rip), %rax      # 0xefc8
movq %rax, 0x20(%r14)
pushq $0x4
popq %rdi
callq 0x1200
movq %rax, (%r14)
movq 0xd3ca(%rip), %rsi      # 0xf200
movq %r14, %rdi
callq 0x1434
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x1434
leaq 0x7508(%rip), %rsi      # 0x9359
leaq -0x38(%rbp), %rdi
callq 0x1434
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x14aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x1404
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1404
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/files.cc
// Function: Files::path_for_file(char const*)
const char * path_for_file(const char * filename)
	{
		String_Builder builder;
		builder.append(running_dir);
		builder.append(filename);
		return builder.final_string();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq -0x38(%rbp), %r14
andq $0x0, 0x8(%r14)
movq $0x4, 0x10(%r14)
movq 0xd119(%rip), %rax      # 0xefd0
movq %rax, 0x18(%r14)
movq 0xd106(%rip), %rax      # 0xefc8
movq %rax, 0x20(%r14)
pushq $0x4
popq %rdi
callq 0x1200
movq %rax, (%r14)
movq 0xd320(%rip), %rsi      # 0xf1f8
movq %r14, %rdi
callq 0x1434
leaq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x1434
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x14aa
movq %rax, %r14
movq %rbx, %rdi
callq 0x1404
movq %r14, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1404
movq %rbx, %rdi
callq 0x11c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/lexer.cc
// Function: Token::type_to_string(Token_Kind)
char * Token::type_to_string(Token_Kind kind)
{
	if (kind < 256) {
		return Token::with_kind(kind).to_string();
	}
	
	if (kind >= RESERVED_WORDS_BEGIN && kind < RESERVED_WORDS_END) {
		return strdup(reserved_words[kind - RESERVED_WORDS_BEGIN]);
	}
	
	switch (kind) {
	case TOKEN_EOF:
		return strdup("EOF");
	case TOKEN_SYMBOL:
		return strdup("<symbol>");
	case TOKEN_INTEGER_LITERAL:
		return strdup("<integer>");
	case TOKEN_STRING_LITERAL:
		return strdup("<string>");
	default:
		fatal("Token::type_to_string() switch incomplete");
	}
	return NULL; // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
cmpl $0xff, %edi
jg 0x1f48
movl %edi, %eax
leaq -0x10(%rbp), %rdi
movq %rax, (%rdi)
callq 0x1fbc
addq $0x10, %rsp
popq %rbp
retq
leal -0x105(%rdi), %eax
cmpl $0x10, %eax
ja 0x1f6a
movl %eax, %eax
leaq 0xcdc4(%rip), %rcx      # 0xed20
movq (%rcx,%rax,8), %rdi
addq $0x10, %rsp
popq %rbp
jmp 0x11d0
cmpl $0x118, %edi            # imm = 0x118
je 0x1f9c
cmpl $0x116, %edi            # imm = 0x116
je 0x1fa5
cmpl $0x117, %edi            # imm = 0x117
je 0x1f93
cmpl $0x100, %edi            # imm = 0x100
jne 0x1fae
leaq 0x73cd(%rip), %rdi      # 0x935e
jmp 0x1f60
leaq 0x73d1(%rip), %rdi      # 0x936b
jmp 0x1f60
leaq 0x73d2(%rip), %rdi      # 0x9375
jmp 0x1f60
leaq 0x73b6(%rip), %rdi      # 0x9362
jmp 0x1f60
leaq 0x73c9(%rip), %rdi      # 0x937e
xorl %eax, %eax
callq 0x1928
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/lexer.cc
// Function: Token::to_string()
char * Token::to_string()
{
	if (kind >= 0 && kind < 256) {
		char buf[2];
		buf[0] = kind;
		buf[1] = '\0';
		return strdup(buf);
	}
	switch (kind) {
	case TOKEN_SYMBOL: {
		return strdup(values.symbol);
	}
	case TOKEN_INTEGER_LITERAL: {
		return itoa(values.integer);
	}
	case TOKEN_STRING_LITERAL: {
		String_Builder builder;
		builder.append("string \"");
		builder.append(values.string);
		builder.append("\"");
		return builder.final_string();
	}
	default:
		return Token::type_to_string(kind);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movl (%rdi), %edi
cmpl $0xff, %edi
ja 0x1ff6
leaq -0x38(%rbp), %rax
movb %dil, (%rax)
movb $0x0, 0x1(%rax)
movq %rax, %rdi
callq 0x11d0
movq %rax, %rbx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
cmpl $0x118, %edi            # imm = 0x118
je 0x2033
cmpl $0x117, %edi            # imm = 0x117
je 0x2023
cmpl $0x116, %edi            # imm = 0x116
jne 0x20a9
movq 0x8(%rbx), %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x11d0
movl 0x8(%rbx), %edi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x16f2
leaq -0x38(%rbp), %r14
andq $0x0, 0x8(%r14)
movq $0x4, 0x10(%r14)
movq 0xcf85(%rip), %rax      # 0xefd0
movq %rax, 0x18(%r14)
movq 0xcf72(%rip), %rax      # 0xefc8
movq %rax, 0x20(%r14)
pushq $0x4
popq %rdi
callq 0x1200
movq %rax, (%r14)
leaq 0x733c(%rip), %rsi      # 0x93a8
movq %r14, %rdi
callq 0x1434
movq 0x8(%rbx), %rsi
leaq -0x38(%rbp), %rdi
callq 0x1434
leaq 0x7327(%rip), %rsi      # 0x93af
leaq -0x38(%rbp), %rdi
callq 0x1434
movq %r14, %rdi
callq 0x14aa
movq %rax, %rbx
movq %r14, %rdi
callq 0x1404
jmp 0x1fea
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1f24
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x1404
movq %rbx, %rdi
callq 0x11c0
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/lexer.cc
// Function: Lexer::init(char const*)
void Lexer::init(const char * source)
{
	this->source = source;
	source_length = strlen(source);
	cursor = 0;
	line = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rsi, (%rdi)
movq %rsi, %rdi
callq 0x1080
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
movq $0x1, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/lexer.cc
// Function: Lexer::advance()
void Lexer::advance()
{
	if (cursor >= source_length) {
		return;
	}
	if (source[cursor] == '\n') {
		line++;
	}
	cursor++;
}

// Assembly:
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
jae 0x218f
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
cmpb $0xa, (%rcx,%rax)
jne 0x2187
incq 0x18(%rdi)
incq %rax
movq %rax, 0x10(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/lexer.cc
// Function: Lexer::read_double_token(char, char, Token_Kind)
Token_Kind Lexer::read_double_token(char left, char right, Token_Kind double_type)
{
	assert(peek() == left);
	advance();
	if (peek() == right) {
		advance();
		return double_type;
	} else {
		return (Token_Kind) left;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r12d
movl %esi, %r15d
movq %rdi, %r14
movq 0x10(%rdi), %rax
cmpq 0x8(%rdi), %rax
jae 0x26ee
movq (%r14), %rcx
movb (%rcx,%rax), %al
jmp 0x26f0
xorl %eax, %eax
cmpb %r15b, %al
jne 0x272f
movq %r14, %rdi
callq 0x216c
movq 0x10(%r14), %rax
cmpq 0x8(%r14), %rax
jae 0x270f
movq (%r14), %rcx
movb (%rcx,%rax), %al
jmp 0x2711
xorl %eax, %eax
cmpb %r12b, %al
jne 0x2720
movq %r14, %rdi
callq 0x216c
jmp 0x2724
movsbl %r15b, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6cbf(%rip), %rdi      # 0x93f5
leaq 0x6cc7(%rip), %rsi      # 0x9404
leaq 0x6ccd(%rip), %rcx      # 0x9411
movl $0x12b, %edx            # imm = 0x12B
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Expr_Binary::destroy()
void Expr_Binary::destroy()
{
	left->destroy();
	free(left);
	right->destroy();
	free(right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x48cc
movq (%rbx), %rdi
callq 0x11f8
movq 0x10(%rbx), %rdi
callq 0x48cc
movq 0x10(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Expr_Scope::destroy()
void Expr_Scope::destroy()
{
	for (int i = 0; i < body.size; i++) {
		body[i]->destroy();
		free(body[i]);
	}
	body.dealloc();
	if (terminator) {
		terminator->destroy();
		free(terminator);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
xorl %r14d, %r14d
cmpq %r14, (%r15)
jbe 0x27e6
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4950
movq (%rax), %rdi
callq 0x2820
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4950
movq (%rax), %rdi
callq 0x11f8
incq %r14
jmp 0x27b6
movq (%rbx), %rdi
callq *0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x28(%rbx), %rdi
testq %rdi, %rdi
je 0x2814
callq 0x48cc
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11f8
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Stmt::destroy()
void Stmt::destroy()
{
	switch (kind) {
	case STMT_LET:
		let.destroy();
		break;
	case STMT_SET:
		set.destroy();
		break;
	case STMT_RETURN:
		_return.destroy();
		break;
	case STMT_EXPR:
		expr->destroy();
		free(expr);
		break;
	case STMT_BREAK:
		_break->destroy();
		free(_break);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movl (%rdi), %eax
cmpq $0x4, %rax
ja 0x288f
movq %rdi, %rbx
leaq 0x684c(%rip), %rcx      # 0x9084
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rbx), %rdi
callq 0x48cc
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b62
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b0e
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2b30
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Expr_Lambda::destroy()
void Expr_Lambda::destroy()
{
	parameters.dealloc();
	body->destroy();
	free(body);
	/*
	for (int i = 0; i < body.size; i++) {
		body[i]->destroy();
		free(body[i]);
	}
	body.dealloc();*/
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq *0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
movq 0x28(%rbx), %rdi
callq 0x48cc
movq 0x28(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Expr_Funcall::destroy()
void Expr_Funcall::destroy()
{
	func->destroy();
	free(func);
	
	for (int i = 0; i < args.size; i++) {
		args[i]->destroy();
		free(args[i]);
	}
	args.dealloc();
	
	for (int i = 0; i < flags.size; i++) {
		flags[i].expr->destroy();
		free(flags[i].expr);
	}
	flags.dealloc();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x48cc
movq (%rbx), %rdi
callq 0x11f8
leaq 0x8(%rbx), %r14
leaq 0x10(%rbx), %r12
xorl %r15d, %r15d
cmpq %r15, (%r12)
jbe 0x291e
movq %r14, %rdi
movq %r15, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x48cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x11f8
incq %r15
jmp 0x28ed
movq 0x8(%rbx), %rdi
callq *0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
leaq 0x30(%rbx), %r14
leaq 0x38(%rbx), %r12
xorl %r15d, %r15d
cmpq %r15, (%r12)
jbe 0x296b
movq %r14, %rdi
movq %r15, %rsi
callq 0x49b4
movq 0x8(%rax), %rdi
callq 0x48cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x49b4
movq 0x8(%rax), %rdi
callq 0x11f8
incq %r15
jmp 0x2938
movq 0x30(%rbx), %rdi
callq *0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Expr_If::destroy()
void Expr_If::destroy()
{
	for (int i = 0; i < conditions.size; i++) {
		conditions[i]->destroy();
		free(conditions[i]);
	}
	conditions.dealloc();
	
	for (int i = 0; i < expressions.size; i++) {
		expressions[i]->destroy();
		free(expressions[i]);
	}
	expressions.dealloc();

	if (else_expr) {
		else_expr->destroy();
		free(else_expr);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
xorl %r14d, %r14d
cmpq %r14, (%r15)
jbe 0x29c9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x48cc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x11f8
incq %r14
jmp 0x2999
movq (%rbx), %rdi
callq *0x20(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
leaq 0x28(%rbx), %r14
leaq 0x30(%rbx), %r12
xorl %r15d, %r15d
cmpq %r15, (%r12)
jbe 0x2a12
movq %r14, %rdi
movq %r15, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x48cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x11f8
incq %r15
jmp 0x29e1
movq 0x28(%rbx), %rdi
callq *0x48(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x2a40
callq 0x48cc
movq 0x50(%rbx), %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x11f8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Expr_Directive::destroy()
void Expr_Directive::destroy()
{
	for (int i = 0; i < arguments.size; i++) {
		arguments[i]->destroy();
		free(arguments[i]);
	}
	arguments.dealloc();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq 0x10(%rdi), %r12
xorl %r15d, %r15d
cmpq %r15, (%r12)
jbe 0x2a94
movq %r14, %rdi
movq %r15, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x48cc
movq %r14, %rdi
movq %r15, %rsi
callq 0x4982
movq (%rax), %rdi
callq 0x11f8
incq %r15
jmp 0x2a63
movq 0x8(%rbx), %rdi
callq *0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Stmt_Set::destroy()
void Stmt_Set::destroy()
{
	left->destroy();
	free(left);
	right->destroy();
	free(right);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
callq 0x48cc
movq (%rbx), %rdi
callq 0x11f8
movq 0x8(%rbx), %rdi
callq 0x48cc
movq 0x8(%rbx), %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x11f8
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/ast.cc
// Function: Stmt::with_kind(Stmt_Kind, int)
Stmt * Stmt::with_kind(Stmt_Kind kind, Assoc_Ptr assoc)
{
	Stmt * stmt = (Stmt*) malloc(sizeof(Stmt));
	stmt->kind = kind;
	stmt->assoc = assoc;
	return stmt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movl %edi, %r14d
pushq $0x18
popq %rdi
callq 0x1200
movl %r14d, (%rax)
movl %ebx, 0x4(%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_atom()
Expr * Parser::parse_atom()
{
	if (match('(')) {
		auto expr = parse_expr();
		expect(')');
		return expr;
	}
	switch (peek.kind) {
	case TOKEN_NOTHING: {
		auto atom = create_expr(EXPR_NOTHING);
		advance();
		return atom;
	} break;
	case TOKEN_INTEGER_LITERAL: {
		auto atom = create_expr(EXPR_INTEGER);
		atom->integer = peek.values.integer;
		advance();
		return atom;
	} break;
	case TOKEN_STRING_LITERAL: {
		auto atom = create_expr(EXPR_STRING);
		atom->string = peek.values.string;
		advance();
		return atom;
	} break;
	case TOKEN_SYMBOL: {
		auto atom = create_expr(EXPR_VARIABLE);
		atom->variable = peek.values.symbol;
		advance();
		return atom;
	} break;
	case TOKEN_THIS: {
		auto atom = create_expr(EXPR_THIS);
		advance();
		return atom;
	} break;
	default:
		fatal_assoc(peek.assoc, "Expected <int>, <symbol>; got %s", peek.to_string());
	}
	return NULL; // @linter
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x28
popq %rsi
callq 0x2ff4
testb %al, %al
je 0x2bd0
movq %rbx, %rdi
callq 0x379a
movq %rax, %r14
pushq $0x29
popq %rsi
movq %rbx, %rdi
callq 0x2ef2
jmp 0x2c46
movl 0x8(%rbx), %ecx
leal -0x111(%rcx), %eax
cmpl $0x7, %eax
ja 0x2bf6
leaq 0x64b3(%rip), %rcx      # 0x9098
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0xb
popq %rsi
movq %rbx, %rdi
jmp 0x2c03
cmpl $0x109, %ecx            # imm = 0x109
jne 0x2c4e
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2c7c
movq %rax, %r14
jmp 0x2c3e
pushq $0x2
jmp 0x2c2a
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
movl 0x10(%rbx), %eax
movl %eax, 0x8(%r14)
jmp 0x2c3e
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x2c8e
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movl 0xc(%rbx), %r14d
addq $0x8, %rbx
movq %rbx, %rdi
callq 0x1fbc
leaq 0x67e8(%rip), %rsi      # 0x944d
movl %r14d, %edi
movq %rax, %rdx
xorl %eax, %eax
callq 0x1b51
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_field_access()
Expr * Parser::parse_field_access()
{
	auto left = parse_atom();
	while (match('\'')) {
		auto expr = create_expr(EXPR_FIELD);
		expr->field.left = left;
		weak_expect(TOKEN_SYMBOL);
		expr->field.right = peek.values.symbol;
		advance();
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2ba2
movq %rax, %r12
pushq $0x27
popq %r14
pushq $0xc
popq %r15
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2ff4
testb %al, %al
je 0x2d12
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2c7c
movq %rax, %r13
movq %r12, 0x8(%rax)
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2d24
movq 0x10(%rbx), %rax
movq %rax, 0x10(%r13)
movq %rbx, %rdi
callq 0x2c8e
movq %r13, %r12
jmp 0x2ccf
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jne 0x2d49
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rdx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl 0xc(%rbx), %r14d
addq $0x8, %rbx
movl %esi, %edi
callq 0x1f24
movq %rax, %r15
movq %rbx, %rdi
callq 0x1fbc
leaq 0x67c5(%rip), %rsi      # 0x952f
movl %r14d, %edi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1b51
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_function_call()
Expr * Parser::parse_function_call()
{
	auto left = parse_field_access();
	while (match('(')) {
		// Create our function
		auto expr = create_expr(EXPR_FUNCALL);
		expr->assoc = left->assoc;
		expr->funcall.func = left;
		expr->funcall.args.alloc();
		expr->funcall.flags.alloc();
		// Parse arguments
		while (true) {
			if (match(')')) {
				break;
			}
			expr->funcall.args.push(parse_expr());
			if (!match(',')) {
				expect(')');
				break;
			}
		}
		// Parse flags
		if (match('$')) {
			do {
				auto name = expect(TOKEN_SYMBOL).values.symbol;
				expect(':');
				auto flag_expr = parse_expr();
				auto pair = (Flag_Pair) {
					.name = name,
					.expr = flag_expr,
				};
				expr->funcall.flags.push(pair);
			} while (match(','));
		}
		left = expr;
	}
	return left;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2cae
movq %rax, %r15
pushq $0x2c
popq %r13
movq %rbx, %rdi
pushq $0x28
popq %rsi
callq 0x2ff4
testb %al, %al
je 0x2edf
movq %rbx, %rdi
pushq $0x8
popq %rsi
callq 0x2c7c
movq %rax, %r12
movl 0x4(%r15), %eax
movl %eax, 0x4(%r12)
movq %r15, 0x8(%r12)
andq $0x0, 0x18(%r12)
leaq 0x10(%r12), %r15
pushq $0x4
popq %rax
movq %rax, 0x20(%r12)
movq 0xc1f0(%rip), %rax      # 0xefd0
movq %rax, 0x28(%r12)
movq 0xc1dc(%rip), %rax      # 0xefc8
movq %rax, 0x30(%r12)
pushq $0x20
popq %rdi
callq 0x1200
movq %rax, 0x10(%r12)
andq $0x0, 0x40(%r12)
leaq 0x38(%r12), %r14
pushq $0x4
popq %rax
movq %rax, 0x48(%r12)
movq 0xc1b8(%rip), %rax      # 0xefd0
movq %rax, 0x50(%r12)
movq 0xc1a4(%rip), %rax      # 0xefc8
movq %rax, 0x58(%r12)
pushq $0x40
popq %rdi
callq 0x1200
movq %rax, 0x38(%r12)
movq %rbx, %rdi
pushq $0x29
popq %rsi
callq 0x2ff4
testb %al, %al
jne 0x2e72
movq %rbx, %rdi
callq 0x379a
movq %r15, %rdi
movq %rax, %rsi
callq 0x49e6
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2ff4
testb %al, %al
jne 0x2e36
movq %rbx, %rdi
pushq $0x29
popq %rsi
callq 0x2ef2
movq %rbx, %rdi
pushq $0x24
popq %rsi
callq 0x2ff4
movq %r12, %r15
testb %al, %al
je 0x2d97
movq %r12, -0x30(%rbp)
movl %r13d, %r12d
pushq $0x3a
popq %r13
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2ef2
movq %rdx, %r15
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2ef2
movq %rbx, %rdi
callq 0x379a
movq %r14, %rdi
movq %r15, %rsi
movq %rax, %rdx
callq 0x4a18
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2ff4
testb %al, %al
jne 0x2e93
movq -0x30(%rbp), %r15
movl %r12d, %r13d
jmp 0x2d97
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl %esi, 0x8(%rdi)
jne 0x2f16
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3aea
movl 0xc(%rbx), %r14d
addq $0x8, %rbx
movl %esi, %edi
callq 0x1f24
movq %rax, %r15
movq %rbx, %rdi
callq 0x1fbc
leaq 0x65f8(%rip), %rsi      # 0x952f
movl %r14d, %edi
movq %r15, %rdx
movq %rax, %rcx
xorl %eax, %eax
callq 0x1b51
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x10c, %eax            # imm = 0x10C
je 0x2f64
cmpl $0x2d, %eax
jne 0x2fb7
pushq $0x2d
popq %rsi
movq %rbx, %rdi
callq 0x2ff4
xorl %r15d, %r15d
testb %al, %al
jne 0x2f8b
movq %rbx, %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x2ff4
testb %al, %al
je 0x2fc9
pushq $0xd
popq %r15
pushq $0x4
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
movl %r15d, 0x8(%rax)
movq %rbx, %rdi
callq 0x2f48
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 0x2d7a
leaq 0x649e(%rip), %rdi      # 0x946e
leaq 0x649d(%rip), %rsi      # 0x9474
leaq 0x64a4(%rip), %rcx      # 0x9482
movl $0x9d, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl 0x8(%rdi), %r14d
cmpl %esi, %r14d
jne 0x300b
callq 0x2c8e
cmpl %ebx, %r14d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x2f48
movq %rax, %r12
pushq $0x5
popq %r15
movl 0x8(%rbx), %eax
cmpl $0x2f, %eax
je 0x3040
cmpl $0x2a, %eax
jne 0x308d
movq %rbx, %rdi
pushq $0x2a
popq %rsi
callq 0x2ff4
pushq $0x3
popq %r14
testb %al, %al
jne 0x3066
movq %rbx, %rdi
pushq $0x2f
popq %rsi
callq 0x2ff4
pushq $0x4
popq %r14
testb %al, %al
je 0x309f
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2c7c
movq %rax, %r13
movq %r12, 0x8(%rax)
movl %r14d, 0x10(%rax)
movq %rbx, %rdi
callq 0x2f48
movq %rax, 0x18(%r13)
movq %r13, %r12
jmp 0x3033
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x63c8(%rip), %rdi      # 0x946e
leaq 0x63c7(%rip), %rsi      # 0x9474
leaq 0x63ea(%rip), %rcx      # 0x949e
movl $0xaf, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3016
movq %rax, %r12
pushq $0x2b
popq %r15
pushq $0x1
popq %r14
movl 0x8(%rbx), %eax
cmpl $0x2d, %eax
je 0x30ec
cmpl $0x2b, %eax
jne 0x3137
movq %rbx, %rdi
pushq $0x5
popq %rsi
callq 0x2c7c
movq %rax, %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2ff4
movl %r14d, %ecx
testb %al, %al
jne 0x311e
movq %rbx, %rdi
pushq $0x2d
popq %rsi
callq 0x2ff4
pushq $0x2
popq %rcx
testb %al, %al
je 0x3149
movl %ecx, 0x10(%r13)
movq %r12, 0x8(%r13)
movq %rbx, %rdi
callq 0x3016
movq %rax, 0x18(%r13)
movq %r13, %r12
jmp 0x30df
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x631e(%rip), %rdi      # 0x946e
leaq 0x631d(%rip), %rsi      # 0x9474
leaq 0x6366(%rip), %rcx      # 0x94c4
movl $0xc2, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x30be
movq %rax, %r12
pushq $0x3c
popq %r15
pushq $0x7
popq %r14
movl 0x8(%rbx), %eax
leal -0x103(%rax), %ecx
cmpl $0x2, %ecx
jb 0x31a1
cmpl $0x3e, %eax
je 0x31a1
cmpl $0x3c, %eax
jne 0x3217
movq %rbx, %rdi
pushq $0x5
popq %rsi
callq 0x2c7c
movq %rax, %r13
movq %rbx, %rdi
movl %r15d, %esi
callq 0x2ff4
movl %r14d, %ecx
testb %al, %al
jne 0x31fb
movq %rbx, %rdi
pushq $0x3e
popq %rsi
callq 0x2ff4
pushq $0x8
popq %rcx
testb %al, %al
jne 0x31fb
movq %rbx, %rdi
movl $0x104, %esi            # imm = 0x104
callq 0x2ff4
pushq $0x9
popq %rcx
testb %al, %al
jne 0x31fb
movq %rbx, %rdi
movl $0x103, %esi            # imm = 0x103
callq 0x2ff4
pushq $0xa
popq %rcx
testb %al, %al
je 0x3229
movl %ecx, 0x10(%r13)
movq %r12, 0x8(%r13)
movq %rbx, %rdi
callq 0x30be
movq %rax, 0x18(%r13)
movq %r13, %r12
jmp 0x3189
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x623e(%rip), %rdi      # 0x946e
leaq 0x623d(%rip), %rsi      # 0x9474
leaq 0x62a9(%rip), %rcx      # 0x94e7
movl $0xd7, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x3168
movq %rax, %r15
pushq $0x5
popq %r13
movl 0x8(%rbx), %eax
movl $0xfffffeff, %ecx       # imm = 0xFFFFFEFF
addl %ecx, %eax
cmpl $0x1, %eax
ja 0x32c5
movq %rbx, %rdi
movl $0x101, %esi            # imm = 0x101
callq 0x2ff4
movl %r13d, %r14d
testb %al, %al
jne 0x329d
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x2ff4
pushq $0x6
popq %r14
testb %al, %al
je 0x32d7
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2c7c
movq %rax, %r12
movq %r15, 0x8(%rax)
movl %r14d, 0x10(%rax)
movq %rbx, %rdi
callq 0x3168
movq %rax, 0x18(%r12)
movq %r12, %r15
jmp 0x3265
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x6190(%rip), %rdi      # 0x946e
leaq 0x618f(%rip), %rsi      # 0x9474
leaq 0x621d(%rip), %rcx      # 0x9509
movl $0xe8, %edx
callq 0x10d0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x3248
movq %rax, %r15
pushq $0x5
popq %r14
movq %rbx, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x2ff4
testb %al, %al
je 0x334c
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2c7c
movq %rax, %r12
movq %r15, 0x8(%rax)
movl $0xb, 0x10(%rax)
movq %rbx, %rdi
callq 0x3248
movq %rax, 0x18(%r12)
movq %r12, %r15
jmp 0x3310
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x32f6
movq %rax, %r15
pushq $0x5
popq %r14
movq %rbx, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x2ff4
testb %al, %al
je 0x33ae
movq %rbx, %rdi
movl %r14d, %esi
callq 0x2c7c
movq %rax, %r12
movq %r15, 0x8(%rax)
movl $0xc, 0x10(%rax)
movq %rbx, %rdi
callq 0x32f6
movq %rax, 0x18(%r12)
movq %r12, %r15
jmp 0x3372
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
movq %rsi, %rdi
movl %edx, %esi
callq 0x2ef2
andq $0x0, 0x8(%rbx)
movq $0x4, 0x10(%rbx)
movq 0xbbe4(%rip), %rax      # 0xefd0
movq %rax, 0x18(%rbx)
movq 0xbbd1(%rip), %rax      # 0xefc8
movq %rax, 0x20(%rbx)
pushq $0x20
popq %rdi
callq 0x1200
movq %rax, (%rbx)
pushq $0x2c
popq %r12
movq %r15, %rdi
movl %r14d, %esi
callq 0x2ff4
testb %al, %al
jne 0x3454
movq %r15, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2d24
movq 0x10(%r15), %rsi
movq %rbx, %rdi
callq 0x486a
movq %r15, %rdi
callq 0x2c8e
movq %r15, %rdi
movl %r12d, %esi
callq 0x2ff4
testb %al, %al
jne 0x340a
movq %r15, %rdi
movl %r14d, %esi
callq 0x2ef2
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movl $0x107, %esi            # imm = 0x107
callq 0x2ff4
testb %al, %al
je 0x34d6
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
leaq -0x40(%rbp), %r15
pushq $0x28
popq %rdx
pushq $0x29
popq %rcx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x33ba
movq 0x20(%r15), %rax
movq %rax, 0x28(%r14)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x18(%r14)
movups %xmm0, 0x8(%r14)
movq %rbx, %rdi
callq 0x379a
movq %rax, 0x30(%r14)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3358
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x112, %esi            # imm = 0x112
callq 0x2ff4
testb %al, %al
je 0x3522
pushq $0xd
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
movq %rbx, %rdi
callq 0x379a
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3460
// File: /workspace/github_cpp_makefile_star2_O2/pixlark[P]Badge/src/parser.cc
// Function: Parser::parse_if()
Expr * Parser::parse_if()
{
	if (match(TOKEN_IF)) {
		auto expr = create_expr(EXPR_IF);
		expr->if_expr.conditions.alloc();
		expr->if_expr.expressions.alloc();
		do {
			expr->if_expr.conditions.push(parse_expr());
			expect(TOKEN_THEN);
			expr->if_expr.expressions.push(parse_expr());
		} while (match(TOKEN_ELIF));
		if (match(TOKEN_ELSE)) {
			expr->if_expr.else_expr = parse_expr();
		} else {
			expr->if_expr.else_expr = NULL;
		}
		return expr;
	} else {
		return parse_loop();
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x10d, %esi            # imm = 0x10D
callq 0x2ff4
testb %al, %al
je 0x362a
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
andq $0x0, 0x10(%rax)
leaq 0x8(%rax), %r15
pushq $0x4
popq %rax
movq %rax, 0x18(%r14)
movq 0xba5a(%rip), %rax      # 0xefd0
movq %rax, 0x20(%r14)
movq 0xba47(%rip), %rax      # 0xefc8
movq %rax, 0x28(%r14)
pushq $0x20
popq %r13
movq %r13, %rdi
callq 0x1200
movq %rax, 0x8(%r14)
andq $0x0, 0x38(%r14)
leaq 0x30(%r14), %r12
pushq $0x4
popq %rax
movq %rax, 0x40(%r14)
movq 0xba24(%rip), %rax      # 0xefd0
movq %rax, 0x48(%r14)
movq 0xba11(%rip), %rax      # 0xefc8
movq %rax, 0x50(%r14)
movq %r13, %rdi
callq 0x1200
movq %rax, 0x30(%r14)
movq %rbx, %rdi
callq 0x379a
movq %r15, %rdi
movq %rax, %rsi
callq 0x49e6
movq %rbx, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x2ef2
movq %rbx, %rdi
callq 0x379a
movq %r12, %rdi
movq %rax, %rsi
callq 0x49e6
movq %rbx, %rdi
movl $0x10f, %esi            # imm = 0x10F
callq 0x2ff4
testb %al, %al
jne 0x35c7
movq %rbx, %rdi
movl $0x110, %esi            # imm = 0x110
callq 0x2ff4
testb %al, %al
je 0x3640
movq %rbx, %rdi
callq 0x379a
movq %rax, 0x58(%r14)
jmp 0x3645
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x34e8
andq $0x0, 0x58(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movl $0x115, %esi            # imm = 0x115
callq 0x2ff4
testb %al, %al
je 0x36a3
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2ef2
movq %rdx, 0x8(%r14)
movq %rbx, %rdi
callq 0x379a
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x352e
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
pushq $0x40
popq %rsi
callq 0x2ff4
testb %al, %al
je 0x3784
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2ef2
movq %rdx, 0x8(%r14)
leaq 0x10(%r14), %r15
andq $0x0, 0x18(%r14)
movq $0x4, 0x20(%r14)
movq 0xb8c8(%rip), %rax      # 0xefd0
movq %rax, 0x28(%r14)
movq 0xb8b5(%rip), %rax      # 0xefc8
movq %rax, 0x30(%r14)
pushq $0x20
popq %rdi
callq 0x1200
movq %rax, 0x10(%r14)
pushq $0x5b
popq %rsi
movq %rbx, %rdi
callq 0x2ef2
pushq $0x5d
popq %r12
pushq $0x2c
popq %r13
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2ff4
testb %al, %al
jne 0x3772
movq %rbx, %rdi
callq 0x379a
movq %r15, %rdi
movq %rax, %rsi
callq 0x49e6
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2ff4
testb %al, %al
jne 0x3736
pushq $0x5d
popq %rsi
movq %rbx, %rdi
callq 0x2ef2
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3658
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x7b
popq %rsi
callq 0x2ff4
testb %al, %al
je 0x3853
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r14
leaq 0x8(%rax), %r15
andq $0x0, 0x10(%rax)
movq $0x4, 0x18(%rax)
movq 0xb7ef(%rip), %rax      # 0xefd0
movq %rax, 0x20(%r14)
movq 0xb7dc(%rip), %rax      # 0xefc8
movq %rax, 0x28(%r14)
pushq $0x20
popq %rdi
callq 0x1200
movq %rax, 0x8(%r14)
movq %r14, -0x30(%rbp)
andq $0x0, 0x30(%r14)
pushq $0x7d
popq %r12
pushq $0x2e
popq %r13
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2ff4
testb %al, %al
jne 0x387d
movq %rbx, %rdi
callq 0x3890
movq %rax, %r14
cmpl $0x3, (%rax)
jne 0x383b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x2ff4
testb %al, %al
jne 0x3869
movq %rbx, %rdi
movl %r13d, %esi
callq 0x2ef2
movq %r15, %rdi
movq %r14, %rsi
callq 0x4a5e
jmp 0x380d
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36b0
movq 0x8(%r14), %rax
movq -0x30(%rbp), %rcx
movq %rax, 0x30(%rcx)
movq %r14, %rdi
callq 0x11f8
movq -0x30(%rbp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
movl 0x8(%rdi), %eax
cmpl $0x114, %eax            # imm = 0x114
je 0x3912
cmpl $0x106, %eax            # imm = 0x106
je 0x38cc
cmpl $0x108, %eax            # imm = 0x108
je 0x38e4
cmpl $0x113, %eax            # imm = 0x113
je 0x38d8
cmpl $0x105, %eax            # imm = 0x105
jne 0x38f0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x39d2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a2a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3aa4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3a72
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x39c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x379a
movq %rax, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x391e
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %esi, %esi
callq 0x39c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c8e
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2d24
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x2c8e
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x2c7c
movq %rax, %r15
movq %rax, 0x10(%r14)
leaq -0x48(%rbp), %r12
pushq $0x28
popq %rdx
pushq $0x29
popq %rcx
movq %r12, %rdi
movq %rbx, %rsi
callq 0x33ba
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 0x379a
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_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
xorl %esi, %esi
callq 0x39c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2c8e
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x2d24
movq 0x10(%rbx), %rax
movq %rax, 0x8(%r14)
movq %rbx, %rdi
callq 0x2c8e
pushq $0x3d
popq %rsi
movq %rbx, %rdi
callq 0x2ef2
movq %rbx, %rdi
callq 0x379a
movq %rax, 0x10(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq