LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_lit_string()
token_t read_lit_string() {
		return {
			tk_lit_string,
			read_escaped('"'),
			TOKEN_DEBUG
		};
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl $0x2, (%rdi)
addq $0x8, %rdi
movl $0x22, %edx
callq 0xc2e0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movq 0x70(%rcx), %rcx
movq %rcx, 0x30(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_lit_character()
token_t read_lit_character() {
		return {
			tk_lit_character,
			read_escaped('\''),
			TOKEN_DEBUG
		};
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x18(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x28(%rbp)
movl $0x3, (%rdi)
addq $0x8, %rdi
movl $0x27, %edx
callq 0xc2e0
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x68(%rcx), %rdx
movq %rdx, 0x28(%rdi)
movq 0x70(%rcx), %rcx
movq %rcx, 0x30(%rdi)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/../lexer/../util/char_stream.hpp
// Function: char_stream_t::next()
int next() {
		int ch = buffer[cursor++];
		if (ch == '\n') {
			lineno++;
			colno = 0;
		} else {
			colno++;
		}
		return ch;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, %rdi
addq $0x20, %rdi
movq 0x40(%rax), %rsi
movq %rsi, %rcx
addq $0x1, %rcx
movq %rcx, 0x40(%rax)
callq 0x3540
movsbl (%rax), %eax
movl %eax, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jne 0xbc15
movq -0x18(%rbp), %rax
movq 0x48(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x48(%rax)
movq $0x0, 0x50(%rax)
jmp 0xbc25
movq -0x18(%rbp), %rax
movq 0x50(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x50(%rax)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_while[abi:cxx11](bool (*)(int))
std::string read_while(bool (*predicate)(int)) {
		std::string str = "";
		while (!input.eof() && predicate(input.peek())) {
			str += input.next();
		}
		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x50(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movb $0x0, -0x19(%rbp)
leaq -0x1a(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x34d0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rdx
leaq 0x1c9df(%rip), %rsi     # 0x28b06
callq 0x6d70
jmp 0xc12e
leaq -0x1a(%rbp), %rdi
callq 0x3320
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0xb630
movb %al, -0x51(%rbp)
jmp 0xc149
movb -0x51(%rbp), %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x52(%rbp)
jne 0xc188
jmp 0xc158
movq -0x48(%rbp), %rdi
movq -0x18(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x20, %rdi
callq 0xb670
movl %eax, -0x58(%rbp)
jmp 0xc172
movq -0x60(%rbp), %rax
movl -0x58(%rbp), %edi
callq *%rax
movb %al, -0x61(%rbp)
jmp 0xc180
movb -0x61(%rbp), %al
movb %al, -0x52(%rbp)
jmp 0xc188
movb -0x52(%rbp), %al
testb $0x1, %al
jne 0xc191
jmp 0xc1e4
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
callq 0xbbc0
movl %eax, -0x68(%rbp)
jmp 0xc1a3
movq -0x40(%rbp), %rdi
movl -0x68(%rbp), %eax
movsbl %al, %esi
callq 0x31d0
jmp 0xc1b4
jmp 0xc137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
leaq -0x1a(%rbp), %rdi
callq 0x3320
jmp 0xc201
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x31c0
jmp 0xc201
movb $0x1, -0x19(%rbp)
testb $0x1, -0x19(%rbp)
jne 0xc1f7
movq -0x40(%rbp), %rdi
callq 0x31c0
movq -0x50(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x34c0
nopw (%rax,%rax)
// File: CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::chr_id(int)
static bool chr_id(int ch) {
		return (ch >= 'a' && ch <= 'z') ||
			   (ch >= 'A' && ch <= 'Z') ||
			   (ch >= '0' && ch <= '9') ||
			   ch == '_';
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
cmpl $0x61, -0x4(%rbp)
jl 0xc278
movb $0x1, %al
cmpl $0x7a, -0x4(%rbp)
movb %al, -0x5(%rbp)
jle 0xc2a4
cmpl $0x41, -0x4(%rbp)
jl 0xc289
movb $0x1, %al
cmpl $0x5a, -0x4(%rbp)
movb %al, -0x5(%rbp)
jle 0xc2a4
cmpl $0x30, -0x4(%rbp)
jl 0xc29a
movb $0x1, %al
cmpl $0x39, -0x4(%rbp)
movb %al, -0x5(%rbp)
jle 0xc2a4
cmpl $0x5f, -0x4(%rbp)
sete %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: CobaltXII[P]cxcc/./parser/../lexer/token_stream.hpp
// Function: token_stream_t::read_escaped[abi:cxx11](int)
std::string read_escaped(int quote) {
		bool escaped = false;
		std::string str = "";
		input.next();
		while (!input.eof()) {
			int ch = input.next();
			if (ch == '\n') {
				break;
			} else if (escaped) {
				str += ch;
				escaped = false;
			} else if (ch == '\\') {
				str += ch;
				escaped = true;
			} else if (ch == quote) {
				break;
			} else {
				str += ch;
			}
		}
		return str;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x48(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movb $0x0, -0x15(%rbp)
movb $0x0, -0x16(%rbp)
leaq -0x17(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x34d0
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
leaq 0x1c7dc(%rip), %rsi     # 0x28b06
callq 0x6d70
jmp 0xc331
leaq -0x17(%rbp), %rdi
callq 0x3320
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0xbbc0
jmp 0xc349
jmp 0xc34b
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0xb630
xorb $-0x1, %al
testb $0x1, %al
jne 0xc363
jmp 0xc413
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
callq 0xbbc0
movl %eax, -0x4c(%rbp)
jmp 0xc375
movl -0x4c(%rbp), %eax
movl %eax, -0x28(%rbp)
cmpl $0xa, -0x28(%rbp)
jne 0xc3b7
jmp 0xc413
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x17(%rbp), %rdi
callq 0x3320
jmp 0xc430
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x31c0
jmp 0xc430
testb $0x1, -0x15(%rbp)
je 0xc3d2
movq -0x38(%rbp), %rdi
movsbl -0x28(%rbp), %esi
callq 0x31d0
jmp 0xc3cc
movb $0x0, -0x15(%rbp)
jmp 0xc40c
cmpl $0x5c, -0x28(%rbp)
jne 0xc3ed
movq -0x38(%rbp), %rdi
movsbl -0x28(%rbp), %esi
callq 0x31d0
jmp 0xc3e7
movb $0x1, -0x15(%rbp)
jmp 0xc40a
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0xc3f7
jmp 0xc413
movq -0x38(%rbp), %rdi
movsbl -0x28(%rbp), %esi
callq 0x31d0
jmp 0xc406
jmp 0xc408
jmp 0xc40a
jmp 0xc40c
jmp 0xc40e
jmp 0xc34b
movb $0x1, -0x16(%rbp)
testb $0x1, -0x16(%rbp)
jne 0xc426
movq -0x38(%rbp), %rdi
callq 0x31c0
movq -0x48(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_type()
type_t parse_type() {
		expect(tk_int);
		long pointer_depth = 0;
		while (input.peek().type == tk_asterisk) {
			input.next();
			pointer_depth++;
		}
		return {pointer_depth};
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
leaq -0x48(%rbp), %rdi
movl $0x6, %edx
callq 0xe580
leaq -0x48(%rbp), %rdi
callq 0xb430
movq $0x0, -0x50(%rbp)
movq -0xc8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x88(%rbp), %rdi
callq 0xd3a0
movl -0x88(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xb430
movl -0xcc(%rbp), %eax
cmpl $0x31, %eax
jne 0xd4c4
movq -0xc8(%rbp), %rsi
addq $0x20, %rsi
leaq -0xc0(%rbp), %rdi
callq 0xe7d0
leaq -0xc0(%rbp), %rdi
callq 0xb430
movq -0x50(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rbp)
jmp 0xd459
movq -0x50(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_parameters()
std::vector<parameter_t> parse_parameters() {
		std::vector<parameter_t> parameters;
		expect(tk_left_parenthesis);
		while (input.peek().type != tk_right_parenthesis) {
			parameters.push_back(parse_parameter());
			if (input.peek().type != tk_right_parenthesis) {
				expect(tk_comma);
			}
		}
		expect(tk_right_parenthesis);
		return parameters;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x190, %rsp            # imm = 0x190
movq %rdi, -0x180(%rbp)
movq %rdi, %rax
movq %rax, -0x178(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x170(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xefe0
movq -0x170(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0xc, %edx
callq 0xe580
jmp 0xd57f
leaq -0x50(%rbp), %rdi
callq 0xb430
movq -0x170(%rbp), %rsi
addq $0x20, %rsi
leaq -0x98(%rbp), %rdi
callq 0xd3a0
jmp 0xd5a1
movl -0x98(%rbp), %eax
movl %eax, -0x184(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xb430
movl -0x184(%rbp), %eax
cmpl $0xd, %eax
je 0xd68f
movq -0x170(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0xf030
jmp 0xd5dd
movq -0x180(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0xf000
jmp 0xd5f2
leaq -0xc0(%rbp), %rdi
callq 0xf080
movq -0x170(%rbp), %rsi
addq $0x20, %rsi
leaq -0xf8(%rbp), %rdi
callq 0xd3a0
jmp 0xd617
movl -0xf8(%rbp), %eax
movl %eax, -0x188(%rbp)
leaq -0xf8(%rbp), %rdi
callq 0xb430
movl -0x188(%rbp), %eax
cmpl $0xd, %eax
je 0xd68a
movq -0x170(%rbp), %rsi
leaq -0x130(%rbp), %rdi
movl $0x12, %edx
callq 0xe580
jmp 0xd654
leaq -0x130(%rbp), %rdi
callq 0xb430
jmp 0xd68a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xd6db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0xf080
jmp 0xd6db
jmp 0xd588
movq -0x170(%rbp), %rsi
leaq -0x168(%rbp), %rdi
movl $0xd, %edx
callq 0xe580
jmp 0xd6a9
leaq -0x168(%rbp), %rdi
callq 0xb430
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd6cb
movq -0x180(%rbp), %rdi
callq 0xd830
movq -0x178(%rbp), %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbp
retq
movq -0x180(%rbp), %rdi
callq 0xd830
movq -0x58(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_statements()
std::vector<statement_t*> parse_statements() {
		std::vector<statement_t*> statements;
		expect(tk_left_brace);
		while (input.peek().type != tk_right_brace) {
			statements.push_back(parse_statement());
		}
		expect(tk_right_brace);
		return statements;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movb $0x0, -0x11(%rbp)
callq 0xfab0
movq -0xe0(%rbp), %rsi
leaq -0x50(%rbp), %rdi
movl $0x10, %edx
callq 0xe580
jmp 0xd73f
leaq -0x50(%rbp), %rdi
callq 0xb430
movq -0xe0(%rbp), %rsi
addq $0x20, %rsi
leaq -0x98(%rbp), %rdi
callq 0xd3a0
jmp 0xd761
movl -0x98(%rbp), %eax
movl %eax, -0xf4(%rbp)
leaq -0x98(%rbp), %rdi
callq 0xb430
movl -0xf4(%rbp), %eax
cmpl $0x11, %eax
je 0xd7d8
movq -0xe0(%rbp), %rdi
callq 0xfb00
movq %rax, -0x100(%rbp)
jmp 0xd799
movq -0xf0(%rbp), %rdi
movq -0x100(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0xa0(%rbp), %rsi
callq 0xfad0
jmp 0xd7bc
jmp 0xd748
movq -0xf0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
callq 0x105f0
jmp 0xd824
movq -0xe0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
movl $0x11, %edx
callq 0xe580
jmp 0xd7f2
leaq -0xd8(%rbp), %rdi
callq 0xb430
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0xd814
movq -0xf0(%rbp), %rdi
callq 0x105f0
movq -0xe8(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::expect(token_type_t)
token_t expect(token_type_t type) {
		token_t peek = input.peek();
		if (peek.type != type) {
			input.die("expected " + token_type_str[type] + ", encountered " + token_type_str[peek.type] + " instead", peek);
		}
		return input.next();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rdi, -0x130(%rbp)
movq %rdi, %rax
movq %rax, -0x128(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x120(%rbp)
addq $0x20, %rsi
leaq -0x50(%rbp), %rdi
callq 0xd3a0
movl -0x50(%rbp), %eax
cmpl -0x14(%rbp), %eax
je 0xe77b
movq -0x120(%rbp), %rax
addq $0x20, %rax
movq %rax, -0x138(%rbp)
movl -0x14(%rbp), %eax
shlq $0x5, %rax
leaq 0x26f15(%rip), %rdx     # 0x35500
addq %rax, %rdx
leaq 0x1a042(%rip), %rsi     # 0x28637
leaq -0xd0(%rbp), %rdi
callq 0xeda0
jmp 0xe603
leaq 0x1a037(%rip), %rdx     # 0x28641
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x7160
jmp 0xe61f
movl -0x50(%rbp), %eax
shlq $0x5, %rax
leaq 0x26ed3(%rip), %rdx     # 0x35500
addq %rax, %rdx
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0xed50
jmp 0xe645
leaq 0x1a004(%rip), %rdx     # 0x28650
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x7160
jmp 0xe65e
leaq -0x118(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xc740
jmp 0xe670
movq -0x138(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x118(%rbp), %rdx
callq 0xe830
jmp 0xe689
leaq -0x118(%rbp), %rdi
callq 0xb430
leaq -0x70(%rbp), %rdi
callq 0x31c0
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0xb0(%rbp), %rdi
callq 0x31c0
leaq -0xd0(%rbp), %rdi
callq 0x31c0
jmp 0xe77b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xe7ad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xe76d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xe761
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xe755
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
jmp 0xe74c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xd8(%rbp)
movl %eax, -0xdc(%rbp)
leaq -0x118(%rbp), %rdi
callq 0xb430
leaq -0x70(%rbp), %rdi
callq 0x31c0
leaq -0x90(%rbp), %rdi
callq 0x31c0
leaq -0xb0(%rbp), %rdi
callq 0x31c0
leaq -0xd0(%rbp), %rdi
callq 0x31c0
jmp 0xe7ad
movq -0x130(%rbp), %rdi
movq -0x120(%rbp), %rsi
addq $0x20, %rsi
callq 0xe7d0
jmp 0xe794
leaq -0x50(%rbp), %rdi
callq 0xb430
movq -0x128(%rbp), %rax
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0xb430
movq -0xd8(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_logical_or_term()
expression_t* parse_logical_or_term() {
		expression_t* node = parse_logical_and_term();
		while (input.peek().type == tk_bi_logical_or) {
			token_t peek = input.peek();
			expect(tk_bi_logical_or);
			node = new expression_t((binary_expression_t){node, parse_logical_and_term(), bi_logical_or}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x13d00
movq %rax, -0x10(%rbp)
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0xd3a0
movl -0x48(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb430
movl -0xec(%rbp), %eax
cmpl $0x1d, %eax
jne 0x12e87
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd3a0
movq -0xe8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x1d, %edx
callq 0xe580
jmp 0x12d96
leaq -0xb8(%rbp), %rdi
callq 0xb430
movl $0x118, %edi            # imm = 0x118
callq 0x32e0
movq %rax, -0xf8(%rbp)
jmp 0x12db5
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x13d00
movq %rax, -0x100(%rbp)
jmp 0x12de3
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, (%rax)
movl $0xc, -0xd0(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xe0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x13070
jmp 0x12e2c
movq -0xf8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x12d33
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x12e7c
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0x32f0
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x12e94
movq -0x10(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/expression.hpp
// Function: expression_t::expression_t(binary_expression_t, long, long)
expression_t(binary_expression_t expr, long lineno, long colno) {
		type = et_binary;
		binary = expr;
		this->lineno = lineno;
		this->colno = colno;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
leaq 0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0x33e0
movq -0x20(%rbp), %rdi
addq $0x48, %rdi
callq 0x33e0
movq -0x20(%rbp), %rdi
addq $0x68, %rdi
callq 0x33e0
movq -0x20(%rbp), %rdi
addq $0x88, %rdi
callq 0x33e0
movq -0x20(%rbp), %rdi
addq $0xb8, %rdi
callq 0x16e10
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl $0x6, (%rax)
movq (%rcx), %rdx
movq %rdx, 0xf0(%rax)
movq 0x8(%rcx), %rdx
movq %rdx, 0xf8(%rax)
movq 0x10(%rcx), %rcx
movq %rcx, 0x100(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_logical_and_term()
expression_t* parse_logical_and_term() {
		expression_t* node = parse_binary_or_term();
		while (input.peek().type == tk_bi_logical_and) {
			token_t peek = input.peek();
			expect(tk_bi_logical_and);
			node = new expression_t((binary_expression_t){node, parse_binary_or_term(), bi_logical_and}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x13e90
movq %rax, -0x10(%rbp)
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0xd3a0
movl -0x48(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb430
movl -0xec(%rbp), %eax
cmpl $0x1c, %eax
jne 0x13e77
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd3a0
movq -0xe8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x1c, %edx
callq 0xe580
jmp 0x13d86
leaq -0xb8(%rbp), %rdi
callq 0xb430
movl $0x118, %edi            # imm = 0x118
callq 0x32e0
movq %rax, -0xf8(%rbp)
jmp 0x13da5
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x13e90
movq %rax, -0x100(%rbp)
jmp 0x13dd3
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, (%rax)
movl $0xb, -0xd0(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xe0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x13070
jmp 0x13e1c
movq -0xf8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x13d23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x13e6c
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0x32f0
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x13e84
movq -0x10(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_binary_or_term()
expression_t* parse_binary_or_term() {
		expression_t* node = parse_binary_xor_term();
		while (input.peek().type == tk_bi_binary_or) {
			token_t peek = input.peek();
			expect(tk_bi_binary_or);
			node = new expression_t((binary_expression_t){node, parse_binary_xor_term(), bi_binary_or}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x14020
movq %rax, -0x10(%rbp)
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0xd3a0
movl -0x48(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb430
movl -0xec(%rbp), %eax
cmpl $0x24, %eax
jne 0x14007
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd3a0
movq -0xe8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x24, %edx
callq 0xe580
jmp 0x13f16
leaq -0xb8(%rbp), %rdi
callq 0xb430
movl $0x118, %edi            # imm = 0x118
callq 0x32e0
movq %rax, -0xf8(%rbp)
jmp 0x13f35
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x14020
movq %rax, -0x100(%rbp)
jmp 0x13f63
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, (%rax)
movl $0x14, -0xd0(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xe0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x13070
jmp 0x13fac
movq -0xf8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x13eb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x13ffc
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0x32f0
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x14014
movq -0x10(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_binary_xor_term()
expression_t* parse_binary_xor_term() {
		expression_t* node = parse_binary_and_term();
		while (input.peek().type == tk_bi_binary_xor) {
			token_t peek = input.peek();
			expect(tk_bi_binary_xor);
			node = new expression_t((binary_expression_t){node, parse_binary_and_term(), bi_binary_xor}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x141b0
movq %rax, -0x10(%rbp)
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0xd3a0
movl -0x48(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb430
movl -0xec(%rbp), %eax
cmpl $0x25, %eax
jne 0x14197
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd3a0
movq -0xe8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x25, %edx
callq 0xe580
jmp 0x140a6
leaq -0xb8(%rbp), %rdi
callq 0xb430
movl $0x118, %edi            # imm = 0x118
callq 0x32e0
movq %rax, -0xf8(%rbp)
jmp 0x140c5
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x141b0
movq %rax, -0x100(%rbp)
jmp 0x140f3
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, (%rax)
movl $0x15, -0xd0(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xe0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x13070
jmp 0x1413c
movq -0xf8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x14043
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x1418c
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0x32f0
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x141a4
movq -0x10(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_binary_and_term()
expression_t* parse_binary_and_term() {
		expression_t* node = parse_equality_term();
		while (input.peek().type == tk_ampersand) {
			token_t peek = input.peek();
			expect(tk_ampersand);
			node = new expression_t((binary_expression_t){node, parse_equality_term(), bi_binary_and}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x14340
movq %rax, -0x10(%rbp)
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x48(%rbp), %rdi
callq 0xd3a0
movl -0x48(%rbp), %eax
movl %eax, -0xec(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb430
movl -0xec(%rbp), %eax
cmpl $0x32, %eax
jne 0x14327
movq -0xe8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd3a0
movq -0xe8(%rbp), %rsi
leaq -0xb8(%rbp), %rdi
movl $0x32, %edx
callq 0xe580
jmp 0x14236
leaq -0xb8(%rbp), %rdi
callq 0xb430
movl $0x118, %edi            # imm = 0x118
callq 0x32e0
movq %rax, -0xf8(%rbp)
jmp 0x14255
movq -0xe8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
leaq -0xd8(%rbp), %rax
movq %rax, -0x108(%rbp)
callq 0x14340
movq %rax, -0x100(%rbp)
jmp 0x14283
movq -0xf8(%rbp), %rdi
movq -0x108(%rbp), %rax
movq -0x100(%rbp), %rcx
movq %rcx, (%rax)
movl $0x13, -0xd0(%rbp)
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %rsp, %rax
movq %rcx, 0x10(%rax)
movups -0xe0(%rbp), %xmm0
movups %xmm0, (%rax)
callq 0x13070
jmp 0x142cc
movq -0xf8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x141d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
jmp 0x1431c
movq -0xf8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xc0(%rbp)
movl %eax, -0xc4(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0x32f0
leaq -0x80(%rbp), %rdi
callq 0xb430
jmp 0x14334
movq -0x10(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_literal()
expression_t* parse_literal() {
		expression_t* node = parse_literal_no_suffix();
		token_t peek;
		while ((peek = input.peek()).type == tk_left_bracket) {
			expect(tk_left_bracket);
			expression_t* index = parse_expression();
			expect(tk_right_bracket);
			node = new expression_t((indexing_expression_t){node, index}, peek.lineno, peek.colno - peek.text.length() - 1);
		}
		return node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x150, %rsp            # imm = 0x150
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x120(%rbp)
callq 0x154b0
movq %rax, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x8e00
movq -0x120(%rbp), %rsi
addq $0x20, %rsi
leaq -0x80(%rbp), %rdi
callq 0xd3a0
jmp 0x15312
leaq -0x48(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xb3e0
movl (%rax), %eax
movl %eax, -0x124(%rbp)
leaq -0x80(%rbp), %rdi
callq 0xb430
movl -0x124(%rbp), %eax
cmpl $0xe, %eax
jne 0x15475
movq -0x120(%rbp), %rsi
leaq -0xc8(%rbp), %rdi
movl $0xe, %edx
callq 0xe580
jmp 0x15359
leaq -0xc8(%rbp), %rdi
callq 0xb430
movq -0x120(%rbp), %rdi
callq 0x11110
movq %rax, -0x130(%rbp)
jmp 0x1537a
movq -0x120(%rbp), %rsi
movq -0x130(%rbp), %rax
movq %rax, -0xd0(%rbp)
leaq -0x108(%rbp), %rdi
movl $0xf, %edx
callq 0xe580
jmp 0x153a2
leaq -0x108(%rbp), %rdi
callq 0xb430
movl $0x118, %edi            # imm = 0x118
callq 0x32e0
movq %rax, -0x138(%rbp)
jmp 0x153c1
movq -0x10(%rbp), %rax
movq %rax, -0x118(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0x110(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x148(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x140(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3420
movq -0x138(%rbp), %rdi
movq -0x148(%rbp), %rcx
movq %rax, %r8
movq -0x140(%rbp), %rax
notq %r8
addq %rax, %r8
movq -0x118(%rbp), %rsi
movq -0x110(%rbp), %rdx
callq 0x16810
jmp 0x1542c
movq -0x138(%rbp), %rax
movq %rax, -0x10(%rbp)
jmp 0x152fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x15499
movq -0x138(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
movl $0x118, %esi            # imm = 0x118
callq 0x32f0
jmp 0x15499
movq -0x10(%rbp), %rax
movq %rax, -0x150(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xb430
movq -0x150(%rbp), %rax
addq $0x150, %rsp            # imm = 0x150
popq %rbp
retq
leaq -0x48(%rbp), %rdi
callq 0xb430
movq -0x88(%rbp), %rdi
callq 0x34c0
nop
// File: CobaltXII[P]cxcc/./parser/expression.hpp
// Function: expression_t::expression_t(indexing_expression_t, long, long)
expression_t(indexing_expression_t expr, long lineno, long colno) {
		type = et_indexing;
		indexing = expr;
		this->lineno = lineno;
		this->colno = colno;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0xb8, %rdi
callq 0x16e10
movq -0x30(%rbp), %rax
movl $0x4, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0xa8(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0xb0(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CobaltXII[P]cxcc/./parser/expression.hpp
// Function: expression_t::expression_t(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, long, long)
expression_t(std::string literal, std::string disambiguation, long lineno, long colno) {
		if (disambiguation == "int") {
			type = et_integer_literal;
			integer_literal = literal;
		} else if (disambiguation == "str") {
			type = et_string_literal;
			string_literal = literal;
		} else if (disambiguation == "chr") {
			type = et_character_literal;
			character_literal = literal;
		} else if (disambiguation == "id") {
			type = et_identifier;
			identifier = literal;
		}
		this->lineno = lineno;
		this->colno = colno;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movq %rdx, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
callq 0x33e0
movq -0x50(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x68(%rbp)
callq 0x33e0
movq -0x50(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x60(%rbp)
callq 0x33e0
movq -0x50(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x58(%rbp)
callq 0x33e0
movq -0x50(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x48(%rbp)
callq 0x16e10
movq -0x40(%rbp), %rdi
leaq 0x1184e(%rip), %rsi     # 0x2818f
callq 0xc2b0
testb $0x1, %al
jne 0x1694c
jmp 0x169a8
movq -0x78(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl $0x0, (%rdi)
addq $0x48, %rdi
callq 0x3040
jmp 0x16965
jmp 0x16a44
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
callq 0x16c50
movq -0x58(%rbp), %rdi
callq 0x31c0
movq -0x60(%rbp), %rdi
callq 0x31c0
movq -0x68(%rbp), %rdi
callq 0x31c0
movq -0x70(%rbp), %rdi
callq 0x31c0
jmp 0x16a61
movq -0x40(%rbp), %rdi
leaq 0x11ca6(%rip), %rsi     # 0x28659
callq 0xc2b0
testb $0x1, %al
jne 0x169be
jmp 0x169d9
movq -0x78(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl $0x1, (%rdi)
addq $0x20, %rdi
callq 0x3040
jmp 0x169d7
jmp 0x16a42
movq -0x40(%rbp), %rdi
leaq 0x11c79(%rip), %rsi     # 0x2865d
callq 0xc2b0
testb $0x1, %al
jne 0x169ef
jmp 0x16a0a
movq -0x78(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl $0x2, (%rdi)
addq $0x68, %rdi
callq 0x3040
jmp 0x16a08
jmp 0x16a40
movq -0x40(%rbp), %rdi
leaq 0x12526(%rip), %rsi     # 0x28f3b
callq 0xc2b0
testb $0x1, %al
jne 0x16a20
jmp 0x16a3e
movq -0x78(%rbp), %rsi
movq -0x50(%rbp), %rdi
movl $0x3, (%rdi)
addq $0x88, %rdi
callq 0x3040
jmp 0x16a3c
jmp 0x16a3e
jmp 0x16a40
jmp 0x16a42
jmp 0x16a44
movq -0x50(%rbp), %rax
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x34c0
nopw (%rax,%rax)
// File: CobaltXII[P]cxcc/./parser/expression.hpp
// Function: expression_t::expression_t(function_call_expression_t, long, long)
expression_t(function_call_expression_t expr, long lineno, long colno) {
		type = et_function_call;
		function_call = expr;
		this->lineno = lineno;
		this->colno = colno;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0x48, %rdi
movq %rdi, -0x60(%rbp)
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0x68, %rdi
movq %rdi, -0x58(%rbp)
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0x88, %rdi
movq %rdi, -0x50(%rbp)
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0xb8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x16e10
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl $0x5, (%rax)
callq 0x17390
jmp 0x16bf4
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x16c50
movq -0x50(%rbp), %rdi
callq 0x31c0
movq -0x58(%rbp), %rdi
callq 0x31c0
movq -0x60(%rbp), %rdi
callq 0x31c0
movq -0x68(%rbp), %rdi
callq 0x31c0
movq -0x28(%rbp), %rdi
callq 0x34c0
// File: CobaltXII[P]cxcc/./parser/expression.hpp
// Function: expression_t::expression_t(unary_expression_t, long, long)
expression_t(unary_expression_t expr, long lineno, long colno) {
		type = et_unary;
		unary = expr;
		this->lineno = lineno;
		this->colno = colno;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x20, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0x48, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0x68, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0x88, %rdi
callq 0x33e0
movq -0x30(%rbp), %rdi
addq $0xb8, %rdi
callq 0x16e10
movq -0x30(%rbp), %rax
movl $0x7, (%rax)
movq -0x10(%rbp), %rcx
movq %rcx, 0x108(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, 0x110(%rax)
movq -0x20(%rbp), %rcx
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::symbol_table_t(symbol_table_t*)
symbol_table_t(symbol_table_t* parent = nullptr) {
		this->parent = parent;
		if (parent) {
			this->in_loop = parent->in_loop;
			this->offset = parent->offset;
			this->loop_break_to = parent->loop_break_to;
			this->loop_continue_to = parent->loop_continue_to;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x19c30
movq -0x18(%rbp), %rax
movb $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rcx
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
je 0x19224
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movb 0x20(%rcx), %cl
andb $0x1, %cl
movb %cl, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq %rcx, 0x30(%rax)
movq -0x10(%rbp), %rcx
movq 0x38(%rcx), %rcx
movq %rcx, 0x38(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_t::symbol_t(type_t, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<parameter_t, std::allocator<parameter_t>>)
symbol_t(type_t type, identifier_t identifier, std::vector<parameter_t> parameters) {
		this->type = type;
		this->identifier = identifier;
		this->parameters = parameters;
		is_function = true;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdx, -0x38(%rbp)
movq %rcx, -0x58(%rbp)
movq %rsi, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x8, %rdi
movq %rdi, -0x40(%rbp)
callq 0x33e0
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x50(%rbp)
callq 0xefe0
movq -0x48(%rbp), %rax
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movb $0x0, 0x40(%rax)
movq -0x8(%rbp), %rcx
movq %rcx, (%rax)
callq 0x3040
jmp 0x19364
movq -0x58(%rbp), %rsi
movq -0x48(%rbp), %rdi
addq $0x28, %rdi
callq 0x1aca0
jmp 0x19377
movq -0x48(%rbp), %rax
movb $0x1, 0x40(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0xd830
movq -0x40(%rbp), %rdi
callq 0x31c0
movq -0x28(%rbp), %rdi
callq 0x34c0
nopl (%rax)
// File: CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::exists(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool exists(identifier_t identifier) {
		// Search the current scope for the specified identifier.
		for (int i = 0; i < symbols.size(); i++) {
			if (symbols[i].identifier == identifier) {
				return true;
			}
		}
		if (parent) {
			// Search the parent scope for the specified identifier.
			return parent->exists(identifier);
		} else {
			return false;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0x1a3c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x19561
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba20
movq -0x60(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1b990
testb $0x1, %al
jne 0x1954e
jmp 0x19554
movb $0x1, -0x1(%rbp)
jmp 0x195c7
jmp 0x19556
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19506
movq -0x58(%rbp), %rax
cmpq $0x0, (%rax)
je 0x195c3
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3130
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x194e0
movb %al, -0x69(%rbp)
jmp 0x19599
movb -0x69(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x195c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x195d5
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34c0
nop
// File: CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::fetch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
symbol_t& fetch(identifier_t identifier) {
		// Search the current scope for the specified identifier.
		for (int i = 0; i < symbols.size(); i++) {
			if (symbols[i].identifier == identifier) {
				return symbols[i];
			}
		}
		// Search the parent scope for the specified identifier.
		return parent->fetch(identifier);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x68(%rbp)
addq $0x8, %rdi
callq 0x1a3c0
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x20892
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba20
movq -0x60(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1b990
testb $0x1, %al
jne 0x2086e
jmp 0x20885
movq -0x58(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba20
movq %rax, -0x8(%rbp)
jmp 0x208eb
jmp 0x20887
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20826
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3130
movq -0x80(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x20800
movq %rax, -0x70(%rbp)
jmp 0x208c1
movq -0x70(%rbp), %rax
movq %rax, -0x8(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x208eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x31c0
jmp 0x208f8
movq -0x8(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x34c0
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: CobaltXII[P]cxcc/./semantic/symbol_table.hpp
// Function: symbol_table_t::exists_locally(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool exists_locally(identifier_t identifier) {
		// Search the current scope for the specified identifier.
		for (int i = 0; i < symbols.size(); i++) {
			if (symbols[i].identifier == identifier) {
				return true;
			}
		}
		return false;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rdi
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x8, %rdi
callq 0x1a3c0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x20b4e
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1ba20
movq -0x30(%rbp), %rsi
movq %rax, %rdi
addq $0x8, %rdi
callq 0x1b990
testb $0x1, %al
jne 0x20b3b
jmp 0x20b41
movb $0x1, -0x1(%rbp)
jmp 0x20b52
jmp 0x20b43
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x20af3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: CobaltXII[P]cxcc/./semantic/semantic_analyzer.hpp
// Function: semantic_analyzer_t::is_rvalue(expression_t*, symbol_table_t)
bool is_rvalue(expression_t* expression, symbol_table_t symbols) {
		if (expression->type == et_unary) {
			return expression->unary.unary_operator != un_value_of;
		} else {
			return expression->type != et_identifier &&
				   expression->type != et_indexing;
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x7, (%rax)
jne 0x212ce
movq -0x18(%rbp), %rax
cmpl $0x0, 0x110(%rax)
setne %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0x212f1
movq -0x18(%rbp), %rcx
xorl %eax, %eax
cmpl $0x3, (%rcx)
movb %al, -0x21(%rbp)
je 0x212e9
movq -0x18(%rbp), %rax
cmpl $0x4, (%rax)
setne %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopl (%rax,%rax)
// File: CobaltXII[P]cxcc/./semantic/semantic_analyzer.hpp
// Function: semantic_analyzer_t::expand_ast(statement_t*&)
void expand_ast(statement_t*& statement) {
		if (statement->type == st_compound) {
			compound_statement_t& stmt = statement->compound_stmt;
			for (int i = 0; i < stmt.statements.size(); i++) {
				expand_ast(stmt.statements[i]);
			}
		} else if (statement->type == st_conditional) {
			expand_ast(statement->conditional_stmt.condition);
			expand_ast(statement->conditional_stmt.body);
		} else if (statement->type == st_while) {
			expand_ast(statement->while_stmt.condition);
			expand_ast(statement->while_stmt.body);
		} else if (statement->type == st_return) {
			expand_ast(statement->return_stmt.value);
		} else if (statement->type == st_variable_declaration) {
			variable_declaration_statement_t& stmt = statement->variable_declaration_stmt;
			if (stmt.initializer) {
				expand_ast(stmt.initializer);
			}
		} else if (statement->type == st_expression) {
			expand_ast(statement->expression_stmt.expression);
		}
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0x21c10
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x10c30
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x21c0b
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x1c130
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x21b90
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x21bca
jmp 0x21d0f
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, (%rax)
jne 0x21c4d
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x20, %rsi
callq 0x21d20
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x20, %rsi
addq $0x8, %rsi
callq 0x21b90
jmp 0x21d0d
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x2, (%rax)
jne 0x21c8a
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x30, %rsi
callq 0x21d20
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x30, %rsi
addq $0x8, %rsi
callq 0x21b90
jmp 0x21d0b
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x3, (%rax)
jne 0x21cac
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x40, %rsi
callq 0x21d20
jmp 0x21d09
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x4, (%rax)
jne 0x21ce5
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq $0x48, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x21ce3
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
addq $0x28, %rsi
callq 0x21d20
jmp 0x21d07
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x6, (%rax)
jne 0x21d05
movq -0x30(%rbp), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rsi
addq $0x78, %rsi
callq 0x21d20
jmp 0x21d07
jmp 0x21d09
jmp 0x21d0b
jmp 0x21d0d
jmp 0x21d0f
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop