LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xb49d(%rip), %rsi      # 0x10d95
leaq 0x7(%rsp), %rdx
callq 0x3a1e
leaq 0x20(%r14), %r15
movq %r15, %rdi
callq 0x5542
xorl %r13d, %r13d
pushq $0x5c
popq %r12
movq 0x60(%r14), %rax
cmpq 0x48(%r14), %rax
jae 0x595b
movq %r15, %rdi
callq 0x5542
cmpl $0xa, %eax
je 0x595b
testb $0x1, %r13b
jne 0x594b
cmpl $0x5c, %eax
jne 0x5947
movb $0x1, %r13b
movq %rbx, %rdi
movl %r12d, %esi
callq 0x21d0
jmp 0x5915
cmpl %ebp, %eax
je 0x595b
xorl %r13d, %r13d
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21d0
jmp 0x5915
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x596f
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x70(%rsp), %rdi
pushq $0x6
popq %rdx
movq %rbx, %rsi
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
addq $0x20, %rbx
leaq 0x8(%rsp), %r14
xorl %r15d, %r15d
movq %rsp, %r13
leaq 0x38(%rsp), %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x5d52
movl (%rsp), %r12d
movq %r14, %rdi
callq 0x2100
cmpl $0x31, %r12d
jne 0x5deb
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x6482
leaq 0x40(%rsp), %rdi
callq 0x2100
incq %r15
jmp 0x5db4
movq %r15, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0xb0(%rsp), %rdi
pushq $0xc
popq %rdx
callq 0x62f0
leaq 0xb8(%rsp), %rdi
callq 0x2100
leaq 0x20(%r14), %r12
leaq 0x10(%rsp), %r13
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x5d52
movl 0x8(%rsp), %ebp
movq %r13, %rdi
callq 0x2100
cmpl $0xd, %ebp
je 0x5f2e
movq %r15, %rdi
movq %r14, %rsi
callq 0x67ec
movq %rbx, %rdi
movq %r15, %rsi
callq 0x681c
leaq 0x10(%rsp), %rdi
callq 0x2100
movq %r15, %rdi
movq %r12, %rsi
callq 0x5d52
movl 0x8(%rsp), %ebp
leaq 0x10(%rsp), %rdi
callq 0x2100
cmpl $0xd, %ebp
je 0x5eb5
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
pushq $0x12
popq %rdx
callq 0x62f0
leaq 0x80(%rsp), %rdi
callq 0x2100
jmp 0x5eb5
leaq 0x40(%rsp), %rdi
pushq $0xd
popq %rdx
movq %r14, %rsi
callq 0x62f0
leaq 0x48(%rsp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5f74
jmp 0x5f74
jmp 0x5f74
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0x5f77
jmp 0x5f74
movq %rax, %r14
movq %rbx, %rdi
callq 0x6048
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x70(%rsp), %rdi
pushq $0x10
popq %rdx
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
leaq 0x20(%r14), %r15
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x5d52
movl (%rsp), %ebp
movq %r12, %rdi
callq 0x2100
cmpl $0x11, %ebp
je 0x6001
movq %r14, %rdi
callq 0x6a30
movq %rax, (%rsp)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x705a
jmp 0x5fcd
leaq 0x38(%rsp), %rdi
pushq $0x11
popq %rdx
movq %r14, %rsi
callq 0x62f0
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6034
jmp 0x6034
movq %rax, %r14
movq %rbx, %rdi
callq 0x72ee
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0xf8, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x20, %r14
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x5d52
cmpl %ebp, (%r15)
je 0x63f1
movl %ebp, %edx
shlq $0x5, %rdx
leaq 0x1211e(%rip), %r15     # 0x18450
addq %r15, %rdx
leaq 0xa69b(%rip), %rsi      # 0x109d7
leaq 0x8(%rsp), %rdi
callq 0x6775
leaq 0xa694(%rip), %rdx      # 0x109e1
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3ae1
movl 0x88(%rsp), %eax
shlq $0x5, %rax
addq %rax, %r15
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %r15, %rdx
callq 0x6756
leaq 0xa66d(%rip), %rdx      # 0x109f0
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x3ae1
leaq 0xc0(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x5b30
leaq 0x68(%rsp), %rsi
leaq 0xc0(%rsp), %rdx
movq %r14, %rdi
callq 0x64b0
leaq 0xc8(%rsp), %rdi
callq 0x2100
leaq 0x68(%rsp), %rdi
callq 0x2100
leaq 0x48(%rsp), %rdi
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6482
leaq 0x90(%rsp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0xf8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xc8(%rsp), %rdi
callq 0x2100
jmp 0x642f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x2100
jmp 0x643e
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2100
jmp 0x644d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x2100
jmp 0x645c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2100
jmp 0x646d
jmp 0x646a
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
callq 0x7dfe
movq %rax, %rbx
leaq 0x20(%r14), %r15
leaq 0x38(%rsp), %rbp
pushq $0x1d
popq %r13
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
movl 0x38(%rsp), %r12d
leaq 0x40(%rsp), %rdi
callq 0x2100
cmpl $0x1d, %r12d
jne 0x7b8c
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r12
movq %rbx, 0x20(%rsp)
movq %r14, %rdi
callq 0x7dfe
movq %rax, 0x28(%rsp)
movl $0xc, 0x30(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x7bc8
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %r12, %rbx
jmp 0x7ae5
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r12, %rdi
callq 0x2250
jmp 0x7bb6
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
callq 0x7f0a
movq %rax, %rbx
leaq 0x20(%r14), %r15
leaq 0x38(%rsp), %rbp
pushq $0x1c
popq %r13
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
movl 0x38(%rsp), %r12d
leaq 0x40(%rsp), %rdi
callq 0x2100
cmpl $0x1c, %r12d
jne 0x7ece
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r12
movq %rbx, 0x20(%rsp)
movq %r14, %rdi
callq 0x7f0a
movq %rax, 0x28(%rsp)
movl $0xb, 0x30(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x7bc8
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %r12, %rbx
jmp 0x7e27
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r12, %rdi
callq 0x2250
jmp 0x7ef8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
callq 0x8016
movq %rax, %rbx
leaq 0x20(%r14), %r15
leaq 0x38(%rsp), %rbp
pushq $0x24
popq %r13
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
movl 0x38(%rsp), %r12d
leaq 0x40(%rsp), %rdi
callq 0x2100
cmpl $0x24, %r12d
jne 0x7fda
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r12
movq %rbx, 0x20(%rsp)
movq %r14, %rdi
callq 0x8016
movq %rax, 0x28(%rsp)
movl $0x14, 0x30(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x7bc8
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %r12, %rbx
jmp 0x7f33
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r12, %rdi
callq 0x2250
jmp 0x8004
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
callq 0x8122
movq %rax, %rbx
leaq 0x20(%r14), %r15
leaq 0x38(%rsp), %rbp
pushq $0x25
popq %r13
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
movl 0x38(%rsp), %r12d
leaq 0x40(%rsp), %rdi
callq 0x2100
cmpl $0x25, %r12d
jne 0x80e6
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r12
movq %rbx, 0x20(%rsp)
movq %r14, %rdi
callq 0x8122
movq %rax, 0x28(%rsp)
movl $0x15, 0x30(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x7bc8
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %r12, %rbx
jmp 0x803f
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r12, %rdi
callq 0x2250
jmp 0x8110
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
callq 0x822e
movq %rax, %rbx
leaq 0x20(%r14), %r15
leaq 0x38(%rsp), %rbp
pushq $0x32
popq %r13
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
movl 0x38(%rsp), %r12d
leaq 0x40(%rsp), %rdi
callq 0x2100
cmpl $0x32, %r12d
jne 0x81f2
movq %rbp, %rdi
movq %r15, %rsi
callq 0x5d52
leaq 0x70(%rsp), %rdi
movq %r14, %rsi
movl %r13d, %edx
callq 0x62f0
leaq 0x78(%rsp), %rdi
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r12
movq %rbx, 0x20(%rsp)
movq %r14, %rdi
callq 0x822e
movq %rax, 0x28(%rsp)
movl $0x13, 0x30(%rsp)
movq 0x60(%rsp), %rsi
movq 0x68(%rsp), %rdx
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x20(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r12, %rdi
callq 0x7bc8
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %r12, %rbx
jmp 0x814b
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r12, %rdi
callq 0x2250
jmp 0x821c
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_equality_term()
expression_t* parse_equality_term() {
		expression_t* node = parse_relational_term();
		token_t token;
		while (input.peek().type == tk_bi_relational_equal ||
			   input.peek().type == tk_bi_relational_non_equal)
		{
			token = input.peek();
			binary_operator_t binary_operator = bi_error;
			if (token.type == tk_bi_relational_equal) {
				expect(tk_bi_relational_equal);
				binary_operator = bi_relational_equal;
			} else if (token.type == tk_bi_relational_non_equal) {
				expect(tk_bi_relational_non_equal);
				binary_operator = bi_relational_non_equal;
			}
			node = new expression_t((binary_expression_t){node, parse_relational_term(), binary_operator}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %r14
callq 0x83de
movq %rax, %rbp
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%r14), %r12
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5d52
cmpl $0x1e, 0x68(%rsp)
jne 0x8282
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x82bb
leaq 0xa0(%rsp), %rdi
movq %r12, %rsi
callq 0x5d52
movl 0xa0(%rsp), %r15d
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x70(%rsp), %rdi
callq 0x2100
cmpl $0x1f, %r15d
jne 0x8385
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5d52
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x5280
leaq 0x70(%rsp), %rdi
callq 0x2100
movl 0x30(%rsp), %eax
cmpl $0x1f, %eax
je 0x8310
pushq $0x1d
popq %r13
cmpl $0x1e, %eax
jne 0x8334
leaq 0x110(%rsp), %rdi
movq %r14, %rsi
pushq $0x1e
popq %rdx
callq 0x62f0
leaq 0x118(%rsp), %rdi
pushq $0xd
popq %r13
jmp 0x832f
leaq 0xd8(%rsp), %rdi
movq %r14, %rsi
pushq $0x1f
popq %rdx
callq 0x62f0
leaq 0xe0(%rsp), %rdi
pushq $0xe
popq %r13
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r15
movq %rbp, 0x18(%rsp)
movq %r14, %rdi
callq 0x83de
movq %rax, 0x20(%rsp)
movl %r13d, 0x28(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x7bc8
movq %r15, %rbp
jmp 0x8264
leaq 0x38(%rsp), %rdi
callq 0x2100
movq %rbp, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x83cc
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r15, %rdi
callq 0x2250
jmp 0x83cc
jmp 0x83c9
jmp 0x83c9
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_shift_term()
expression_t* parse_shift_term() {
		expression_t* node = parse_additive_term();
		token_t token;
		while (input.peek().type == tk_bi_binary_left_shift ||
			   input.peek().type == tk_bi_binary_right_shift)
		{
			token = input.peek();
			binary_operator_t binary_operator = bi_error;
			if (token.type == tk_bi_binary_left_shift) {
				expect(tk_bi_binary_left_shift);
				binary_operator = bi_binary_left_shift;
			} else if (token.type == tk_bi_binary_right_shift) {
				expect(tk_bi_binary_right_shift);
				binary_operator = bi_binary_right_shift;
			}
			node = new expression_t((binary_expression_t){node, parse_additive_term(), binary_operator}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %r14
callq 0x882a
movq %rax, %rbp
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%r14), %r12
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5d52
cmpl $0x29, 0x68(%rsp)
jne 0x86ce
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x8707
leaq 0xa0(%rsp), %rdi
movq %r12, %rsi
callq 0x5d52
movl 0xa0(%rsp), %r15d
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x70(%rsp), %rdi
callq 0x2100
cmpl $0x2a, %r15d
jne 0x87d1
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5d52
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x5280
leaq 0x70(%rsp), %rdi
callq 0x2100
movl 0x30(%rsp), %eax
cmpl $0x2a, %eax
je 0x875c
pushq $0x1d
popq %r13
cmpl $0x29, %eax
jne 0x8780
leaq 0x110(%rsp), %rdi
movq %r14, %rsi
pushq $0x29
popq %rdx
callq 0x62f0
leaq 0x118(%rsp), %rdi
pushq $0x19
popq %r13
jmp 0x877b
leaq 0xd8(%rsp), %rdi
movq %r14, %rsi
pushq $0x2a
popq %rdx
callq 0x62f0
leaq 0xe0(%rsp), %rdi
pushq $0x1a
popq %r13
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r15
movq %rbp, 0x18(%rsp)
movq %r14, %rdi
callq 0x882a
movq %rax, 0x20(%rsp)
movl %r13d, 0x28(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x7bc8
movq %r15, %rbp
jmp 0x86b0
leaq 0x38(%rsp), %rdi
callq 0x2100
movq %rbp, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x8818
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r15, %rdi
callq 0x2250
jmp 0x8818
jmp 0x8815
jmp 0x8815
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_additive_term()
expression_t* parse_additive_term() {
		expression_t* node = parse_multiplicative_term();
		token_t token;
		while (input.peek().type == tk_plus ||
			   input.peek().type == tk_minus)
		{
			token = input.peek();
			binary_operator_t binary_operator = bi_error;
			if (token.type == tk_plus) {
				expect(tk_plus);
				binary_operator = bi_addition;
			} else if (token.type == tk_minus) {
				expect(tk_minus);
				binary_operator = bi_subtraction;
			}
			node = new expression_t((binary_expression_t){node, parse_multiplicative_term(), binary_operator}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x148, %rsp            # imm = 0x148
movq %rdi, %r14
callq 0x89da
movq %rax, %rbp
leaq 0x48(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%r14), %r12
leaq 0x68(%rsp), %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5d52
cmpl $0x2f, 0x68(%rsp)
jne 0x887e
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x88b7
leaq 0xa0(%rsp), %rdi
movq %r12, %rsi
callq 0x5d52
movl 0xa0(%rsp), %r15d
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x70(%rsp), %rdi
callq 0x2100
cmpl $0x30, %r15d
jne 0x8980
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5d52
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x5280
leaq 0x70(%rsp), %rdi
callq 0x2100
movl 0x30(%rsp), %eax
cmpl $0x30, %eax
je 0x890b
pushq $0x1d
popq %r13
cmpl $0x2f, %eax
jne 0x892f
xorl %r13d, %r13d
leaq 0x110(%rsp), %rdi
movq %r14, %rsi
pushq $0x2f
popq %rdx
callq 0x62f0
leaq 0x118(%rsp), %rdi
jmp 0x892a
leaq 0xd8(%rsp), %rdi
movq %r14, %rsi
pushq $0x30
popq %rdx
callq 0x62f0
leaq 0xe0(%rsp), %rdi
pushq $0x1
popq %r13
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r15
movq %rbp, 0x18(%rsp)
movq %r14, %rdi
callq 0x89da
movq %rax, 0x20(%rsp)
movl %r13d, 0x28(%rsp)
movq 0x58(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x7bc8
movq %r15, %rbp
jmp 0x8860
leaq 0x38(%rsp), %rdi
callq 0x2100
movq %rbp, %rax
addq $0x148, %rsp            # imm = 0x148
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2100
jmp 0x89c7
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r15, %rdi
callq 0x2250
jmp 0x89c7
jmp 0x89c4
jmp 0x89c4
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./parser/parser.hpp
// Function: parser_t::parse_multiplicative_term()
expression_t* parse_multiplicative_term() {
		expression_t* node = parse_literal();
		token_t token;
		while (input.peek().type == tk_asterisk ||
			   input.peek().type == tk_bi_division ||
			   input.peek().type == tk_bi_modulo)
		{
			token = input.peek();
			binary_operator_t binary_operator = bi_error;
			if (token.type == tk_asterisk) {
				expect(tk_asterisk);
				binary_operator = bi_multiplication;
			} else if (token.type == tk_bi_division) {
				expect(tk_bi_division);
				binary_operator = bi_division;
			} else if (token.type == tk_bi_modulo) {
				expect(tk_bi_modulo);
				binary_operator = bi_modulo;
			}
			node = new expression_t((binary_expression_t){node, parse_literal(), binary_operator}, EXPRESSION_DEBUG);
		}
		return node;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movq %rdi, %r15
callq 0x8c00
movq %rax, %rbx
leaq 0x80(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%r15), %r13
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5d52
cmpl $0x31, 0x30(%rsp)
je 0x8a4c
leaq 0xa0(%rsp), %rdi
movq %r13, %rsi
callq 0x5d52
cmpl $0x14, 0xa0(%rsp)
jne 0x8a58
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x38(%rsp), %rdi
callq 0x2100
jmp 0x8a9e
leaq 0xd8(%rsp), %rdi
movq %r13, %rsi
callq 0x5d52
movl 0xd8(%rsp), %r14d
leaq 0xe0(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x38(%rsp), %rdi
callq 0x2100
cmpl $0x15, %r14d
jne 0x8b94
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5d52
leaq 0x68(%rsp), %rdi
movq %rbp, %rsi
callq 0x5280
leaq 0x38(%rsp), %rdi
callq 0x2100
movl 0x68(%rsp), %eax
cmpl $0x14, %eax
je 0x8b19
cmpl $0x15, %eax
je 0x8af8
pushq $0x1d
popq %r12
cmpl $0x31, %eax
jne 0x8b3d
leaq 0x180(%rsp), %rdi
movq %r15, %rsi
pushq $0x31
popq %rdx
callq 0x62f0
leaq 0x188(%rsp), %rdi
pushq $0x2
popq %r12
jmp 0x8b38
leaq 0x110(%rsp), %rdi
movq %r15, %rsi
pushq $0x15
popq %rdx
callq 0x62f0
leaq 0x118(%rsp), %rdi
pushq $0x4
popq %r12
jmp 0x8b38
leaq 0x148(%rsp), %rdi
movq %r15, %rsi
pushq $0x14
popq %rdx
callq 0x62f0
leaq 0x150(%rsp), %rdi
pushq $0x3
popq %r12
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r14
movq %rbx, 0x18(%rsp)
movq %r15, %rdi
callq 0x8c00
movq %rax, 0x20(%rsp)
movl %r12d, 0x28(%rsp)
movq 0x90(%rsp), %rsi
movq 0x98(%rsp), %rdx
movq 0x28(%rsp), %rax
movq %rax, 0x10(%rsp)
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0x7bc8
movq %r14, %rbx
jmp 0x8a13
leaq 0x70(%rsp), %rdi
callq 0x2100
movq %rbx, %rax
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0xa8(%rsp), %rdi
callq 0x2100
jmp 0x8bc8
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x2100
jmp 0x8bed
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %r14, %rdi
callq 0x2250
jmp 0x8bed
jmp 0x8bea
jmp 0x8bea
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r14
callq 0x8d14
movq %rax, %r13
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x20(%r14), %r12
leaq 0xb0(%rsp), %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0x5d52
leaq 0x8(%rsp), %rdi
movq %rbp, %rsi
callq 0x5280
movl (%rax), %ebx
leaq 0xb8(%rsp), %rdi
callq 0x2100
cmpl $0xe, %ebx
jne 0x8cdc
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
pushq $0xe
popq %rdx
callq 0x62f0
leaq 0x80(%rsp), %rdi
callq 0x2100
movq %r14, %rdi
callq 0x742e
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
pushq $0xf
popq %rdx
callq 0x62f0
leaq 0x48(%rsp), %rdi
callq 0x2100
movl $0x118, %edi            # imm = 0x118
callq 0x2240
movq %rax, %r15
movq 0x18(%rsp), %r8
movq 0x30(%rsp), %rcx
notq %r8
addq 0x38(%rsp), %r8
movq %rax, %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0x9768
movq %r15, %r13
jmp 0x8c39
leaq 0x10(%rsp), %rdi
callq 0x2100
movq %r13, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x8cff
jmp 0x8cff
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
xorl %r15d, %r15d
movb %r15b, 0x30(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movq %r8, 0x20(%rsp)
movq %rcx, %r13
movb %r15b, 0x58(%rdi)
leaq 0x78(%rdi), %rax
movq %rax, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
movq %rdx, %rbp
movq %rsi, %r14
movb %r15b, 0x78(%rdi)
leaq 0x98(%rdi), %rax
movq %rax, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x48(%rdi), %r12
movb %r15b, 0x98(%rdi)
leaq 0xc8(%rdi), %rax
movq %rax, 0xb8(%rdi)
andq $0x0, 0xc0(%rdi)
leaq 0x68(%rdi), %rax
movq %rax, 0x10(%rsp)
leaq 0x88(%rdi), %rax
movq %rax, 0x8(%rsp)
movb %r15b, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
andq $0x0, 0xe8(%rdi)
leaq 0x6c39(%rip), %rsi      # 0x10505
movq %rdx, %rdi
callq 0x58d0
movq %r12, %rdi
testb %al, %al
jne 0x9933
leaq 0x7117(%rip), %rsi      # 0x109f9
movq %rbp, %rdi
callq 0x58d0
testb %al, %al
je 0x98f9
pushq $0x1
popq %r15
movq 0x18(%rsp), %rdi
jmp 0x9933
leaq 0x70fd(%rip), %rsi      # 0x109fd
movq %rbp, %rdi
callq 0x58d0
testb %al, %al
je 0x9917
pushq $0x2
popq %r15
movq 0x10(%rsp), %rdi
jmp 0x9933
leaq 0x709c(%rip), %rsi      # 0x109ba
movq %rbp, %rdi
callq 0x58d0
testb %al, %al
je 0x9945
pushq $0x3
popq %r15
movq 0x8(%rsp), %rdi
leaq 0xb8(%rbx), %rbp
movl %r15d, (%rbx)
movq %r14, %rsi
callq 0x2140
movq %r13, 0x10(%rbx)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rbp, %rdi
callq 0x9afc
movq 0x8(%rsp), %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
callq 0x2100
movq %r12, %rdi
callq 0x2100
movq 0x18(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rcx, %r15
xorl %eax, %eax
movb %al, 0x30(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x48(%rdi)
andq $0x0, 0x50(%rdi)
movq %rdx, %r13
movb %al, 0x58(%rdi)
leaq 0x78(%rdi), %rcx
movq %rcx, 0x68(%rdi)
andq $0x0, 0x70(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, 0x10(%rsp)
leaq 0x48(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movb %al, 0x78(%rdi)
leaq 0x98(%rdi), %rcx
movq %rcx, 0x88(%rdi)
andq $0x0, 0x90(%rdi)
leaq 0x68(%rdi), %rbp
leaq 0x88(%rdi), %r14
movb %al, 0x98(%rdi)
leaq 0xc8(%rdi), %rcx
movq %rcx, 0xb8(%rdi)
andq $0x0, 0xc0(%rdi)
leaq 0xb8(%rdi), %r12
movb %al, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
andq $0x0, 0xe8(%rdi)
movl $0x5, (%rdi)
movq %r12, %rdi
callq 0x9c9a
movq %r13, 0x10(%rbx)
movq %r15, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x9afc
movq %r14, %rdi
callq 0x2100
movq %rbp, %rdi
callq 0x2100
movq 0x8(%rsp), %rdi
callq 0x2100
movq 0x10(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %rbx
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r12
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x31(%rdi)
movq %rsi, (%rdi)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x2140
movq %r12, %rdi
movq %r15, %rsi
callq 0xa97a
movb $0x1, 0x40(%r14)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x6048
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r15
pushq $0x8
popq %r12
pushq $0x50
popq %r13
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cqto
idivq %r13
incq %r15
cmpq %r15, %rax
jbe 0xa1b6
addq %r12, %rdi
addq $0x50, %r12
movq %rbx, %rsi
callq 0xac6d
testb %al, %al
je 0xa187
movb $0x1, %bl
jmp 0xa1e5
movq (%r14), %r14
testq %r14, %r14
je 0xa1e3
movq %rsp, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x22e0
movq %r14, %rdi
movq %r15, %rsi
callq 0xa168
movl %eax, %ebx
movq %rsp, %rdi
callq 0x2100
jmp 0xa1e5
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %r15
pushq $-0x50
popq %rbx
pushq $-0x1
popq %r12
pushq $0x50
popq %r13
movq 0x8(%r15), %rcx
movq 0x10(%r15), %rax
subq %rcx, %rax
cqto
idivq %r13
incq %r12
cmpq %r12, %rax
jbe 0xccc8
leaq (%rcx,%rbx), %rdi
addq $0x58, %rdi
addq $0x50, %rbx
movq %r14, %rsi
callq 0xac6d
testb %al, %al
je 0xcc92
addq 0x8(%r15), %rbx
jmp 0xccef
movq (%r15), %rbx
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x22e0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xcc74
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
pushq $-0x1
popq %r12
pushq $0x8
popq %r13
pushq $0x50
popq %rbp
movq 0x8(%r14), %rdi
movq 0x10(%r14), %rax
subq %rdi, %rax
cqto
idivq %rbp
movq %rax, %r15
incq %r12
cmpq %r12, %rax
jbe 0xce3c
addq %r13, %rdi
addq $0x50, %r13
movq %rbx, %rsi
callq 0xac6d
testb %al, %al
je 0xce0e
cmpq %r12, %r15
seta %al
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x30
popq %r13
leaq 0x2e96(%rip), %rbp      # 0x101d8
movq (%r15), %r14
movl (%r14), %eax
cmpq $0x6, %rax
ja 0xd3de
movslq (%rbp,%rax,4), %rcx
addq %rbp, %rcx
movq %r13, %rax
pushq $0x38
popq %r12
jmpq *%rcx
pushq $0x20
popq %rax
pushq $0x28
popq %r12
addq %rax, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd3ee
addq (%r15), %r12
movq %r12, %r15
jmp 0xd342
cmpq $0x0, 0x70(%r14)
je 0xd3de
addq $0x70, %r14
jmp 0xd397
addq $0x78, %r14
jmp 0xd397
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xd3ee
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
cmpq %r12, %rax
jbe 0xd3de
addq %r15, %rsi
movq %rbx, %rdi
callq 0xd326
incq %r12
addq $0x8, %r15
jmp 0xd3b6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::pack_strings(statement_t*)
void pack_strings(statement_t* statement) {
		if (statement->type == st_compound) {
			compound_statement_t stmt = statement->compound_stmt;
			for (int i = 0; i < stmt.statements.size(); i++) {
				pack_strings(stmt.statements[i]);
			}
		} else if (statement->type == st_conditional) {
			pack_strings(statement->conditional_stmt.condition);
			pack_strings(statement->conditional_stmt.body);
		} else if (statement->type == st_while) {
			pack_strings(statement->while_stmt.condition);
			pack_strings(statement->while_stmt.body);
		} else if (statement->type == st_return) {
			pack_strings(statement->return_stmt.value);
		} else if (statement->type == st_variable_declaration) {
			variable_declaration_statement_t stmt = statement->variable_declaration_stmt;
			if (stmt.initializer) {
				pack_strings(stmt.initializer);
			}
		} else if (statement->type == st_expression) {
			pack_strings(statement->expression_stmt.expression);
		}
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
pushq $0x38
popq %rbp
pushq $0x30
popq %r12
leaq 0x1f88(%rip), %r13      # 0x10260
movl (%r14), %eax
cmpq $0x6, %rax
ja 0xe3a4
movslq (%r13,%rax,4), %rcx
addq %r13, %rcx
movq %r12, %rax
movq %rbp, %r15
jmpq *%rcx
pushq $0x20
popq %rax
pushq $0x28
popq %r15
movq (%r14,%rax), %rsi
movq %rbx, %rdi
callq 0xe3d8
movq (%r14,%r15), %r14
jmp 0xe2d8
addq $0x48, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xcd7a
movq 0x28(%r15), %rsi
testq %rsi, %rsi
je 0xe333
movq %rbx, %rdi
callq 0xe3d8
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0xe3a4
movq 0x78(%r14), %rsi
jmp 0xe349
movq 0x40(%r14), %rsi
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe3d8
addq $0x8, %r14
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0x71ec
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0xe39a
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0xe2b6
incq %r14
jmp 0xe373
leaq 0x8(%rsp), %rdi
callq 0x72ee
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0xe3cf
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x72ee
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::pack_strings(expression_t*)
void pack_strings(expression_t* expression) {
		if (expression->type == et_string_literal) {
			long string_label = label++;
			expression->string_label = string_label;
			emit("S%ld:\n", string_label);
			for (int i = 0; i < expression->string_literal.size(); i++) {
				emit("    .quad   %u\n", (unsigned char)expression->string_literal[i]);
			}
			emit("    .quad   0\n");
		} else if (expression->type == et_function_call) {
			function_call_expression_t expr = expression->function_call;
			for (int i = 0; i < expr.arguments.size(); i++) {
				pack_strings(expr.arguments[i]);
			}
		} else if (expression->type == et_binary) {
			pack_strings(expression->binary.left_operand);
			pack_strings(expression->binary.right_operand);
		} else if (expression->type == et_unary) {
			pack_strings(expression->unary.operand);
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x1e8c(%rip), %r15      # 0x1027c
movl (%r14), %ecx
decl %ecx
cmpl $0x6, %ecx
ja 0xe4d2
movl $0x108, %eax            # imm = 0x108
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0xe3d8
movl $0xf8, %eax
movq (%r14,%rax), %r14
jmp 0xe3f0
addq $0xb8, %r14
movq %rsp, %rdi
movq %r14, %rsi
callq 0xd096
xorl %r14d, %r14d
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %r14, %rcx
jbe 0xe4ca
movq (%rax,%r14,8), %rsi
movq %rbx, %rdi
callq 0xe3d8
incq %r14
jmp 0xe43b
movq 0x20(%rbx), %rdx
leaq 0x1(%rdx), %rax
movq %rax, 0x20(%rbx)
movq %rdx, 0x40(%r14)
leaq 0x2851(%rip), %rsi      # 0x10cca
movq %rbx, %rdi
xorl %eax, %eax
callq 0xe4f2
leaq 0x2847(%rip), %r15      # 0x10cd1
xorl %r12d, %r12d
cmpq %r12, 0x28(%r14)
jbe 0xe4ae
movq 0x20(%r14), %rax
movzbl (%rax,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0xe4f2
incq %r12
jmp 0xe48d
leaq 0x282c(%rip), %rsi      # 0x10ce1
movq %rbx, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0xe4f2
movq %rsp, %rdi
callq 0x9afc
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x9afc
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/CobaltXII[P]cxcc/./compiler/compiler.hpp
// Function: compiler_t::aligned_offset(function_t, symbol_table_t&)
long aligned_offset(function_t function, symbol_table_t& symbols) {
		symbol_table_t new_symbols(&symbols);
		long lowest_offset = 0;
		for (int i = 0; i < function.body.size(); i++) {
			aligned_offset_statement(function.body[i], new_symbols, lowest_offset);
		}

		long params_offset;
		if (function.parameters.size() >= 6) {
			params_offset = 48;
		} else {
			params_offset = function.parameters.size() * 8;
		}

		long highest_offset = -lowest_offset + params_offset;
		int remainder = highest_offset % 8;
		if (!remainder) {
			return highest_offset;
		}
		return highest_offset + 8 - remainder;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
leaq 0x10(%rsp), %rbx
andq $0x0, 0x10(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rdx, -0x8(%rbx)
movb 0x20(%rdx), %al
movb %al, 0x18(%rbx)
movups 0x28(%rdx), %xmm0
movups %xmm0, 0x20(%rbx)
movq 0x38(%rdx), %rax
movq %rsp, %r15
andq $0x0, (%r15)
movq %rdi, %r12
movq %rax, 0x30(%rbx)
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movq 0x40(%r14), %rax
movq 0x48(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
jbe 0xe5f1
movq (%rax,%rbp,8), %rsi
movq %r12, %rdi
movq %r13, %rdx
movq %r15, %rcx
callq 0xead6
incq %rbp
jmp 0xe5c6
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
pushq $0x28
popq %rcx
cqto
idivq %rcx
leaq (,%rax,8), %rdx
cmpq $0x6, %rax
pushq $0x30
popq %rcx
cmovbq %rdx, %rcx
subq (%rsp), %rcx
pushq $0x8
popq %rsi
movq %rcx, %rax
cqto
idivq %rsi
movq %rcx, %r14
subq %rdx, %r14
addq $0x8, %r14
testq %rdx, %rdx
cmoveq %rcx, %r14
movq %rbx, %rdi
callq 0xdbb0
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0xdbb0
movq %r14, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O2/saumya-prakash[P]AssemblerEmulator/emu.cpp
// Function: print_options()
void print_options()
{
    cout<<"Options :-"<<endl;

    cout<<"\tt - Execute one instruction with trace"<<endl;
    cout<<"\ts - Execute all instrutions with trace"<<endl;
    cout<<"\tn number - Execute specified number of instructions"<<endl;
    cout<<"\ta - Execute all instrucions without trace"<<endl;
    cout<<"\tq - Show current architectural state"<<endl;
    cout<<"\tc - Display number of instructions executed so far"<<endl;
    cout<<"\tu - Disassemble"<<endl;
    cout<<"\td - Show memory dump"<<endl;
    cout<<"\tx - Quit the emulator"<<endl;

    return;
}

// Assembly:
pushq %rbx
movq 0x611c(%rip), %rbx      # 0x8fd0
leaq 0x3175(%rip), %rsi      # 0x6030
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x3169(%rip), %rsi      # 0x603b
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x317a(%rip), %rsi      # 0x6063
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x318b(%rip), %rsi      # 0x608b
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x31a9(%rip), %rsi      # 0x60c0
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x31bd(%rip), %rsi      # 0x60eb
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x31cc(%rip), %rsi      # 0x6111
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x31e9(%rip), %rsi      # 0x6145
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x31e3(%rip), %rsi      # 0x6156
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20d0
leaq 0x31e2(%rip), %rsi      # 0x616c
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
popq %rbx
jmp 0x20d0