LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x10db4(%rip), %rdx     # 0x19d1d
movq %rdx, %rsi
callq 0x9052
movq 0x40(%r14), %rax
movq 0x60(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x60(%r14)
cmpb $0xa, (%rax,%rcx)
jne 0x8f95
incq 0x68(%r14)
movq $0x0, 0x70(%r14)
jmp 0x8f99
incq 0x70(%r14)
xorl %r12d, %r12d
movq 0x60(%r14), %rax
cmpq 0x48(%r14), %rax
jae 0x9021
leaq 0x1(%rax), %rcx
movq %rcx, 0x60(%r14)
movq 0x40(%r14), %rcx
movsbl (%rcx,%rax), %esi
cmpl $0xa, %esi
jne 0x8fc9
incq 0x68(%r14)
movq $0x0, 0x70(%r14)
jmp 0x8fcd
incq 0x70(%r14)
cmpb $0xa, %sil
jne 0x8fd8
xorl %r13d, %r13d
jmp 0x9018
testb $0x1, %r12b
je 0x8fee
movq %rbx, %rdi
callq 0x31f0
movb $0x1, %r13b
xorl %r12d, %r12d
jmp 0x9018
cmpb $0x5c, %sil
jne 0x9009
movb $0x1, %r12b
movq %rbx, %rdi
movl $0x5c, %esi
callq 0x31f0
movb $0x1, %r13b
jmp 0x9018
cmpl %ebp, %esi
je 0x8fd3
movb $0x1, %r13b
movq %rbx, %rdi
callq 0x31f0
testb %r13b, %r13b
jne 0x8f9c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x9049
movq (%r15), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
movq %r14, %rdi
movq %rbx, %rsi
movl $0x6, %edx
callq 0x9b4a
movq 0x8(%r14), %rdi
leaq 0x88(%rsp), %rax
cmpq %rax, %rdi
je 0x9376
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3280
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r15
movl (%rbp,%r15), %eax
movl %eax, (%rsp)
leaq 0x18(%rsp), %r13
movq %r13, 0x8(%rsp)
movq 0x8(%rbp,%r15), %rsi
movq 0x10(%rbp,%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x17a38
movups 0x28(%rbp,%r15), %xmm0
movups %xmm0, 0x20(%r14)
movl (%rsp), %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x93d9
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x31, %ebp
jne 0x9451
movq 0xb8(%rbx), %r15
movq 0xd0(%rbx), %rax
leaq 0x1(%rax), %rcx
movq %rcx, 0xd0(%rbx)
imulq $0x38, %rax, %rbp
movl (%r15,%rbp), %eax
movl %eax, 0x38(%rsp)
leaq 0x50(%rsp), %r14
movq %r14, 0x40(%rsp)
movq 0x8(%r15,%rbp), %rsi
movq 0x10(%r15,%rbp), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r13
movq %r13, %rdi
callq 0x17a38
movups 0x28(%r15,%rbp), %xmm0
movups %xmm0, 0x20(%r13)
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0x9449
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3280
incq %r12
jmp 0x9379
movq %r12, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
leaq 0xb0(%rsp), %rdi
movl $0xc, %edx
callq 0x9b4a
leaq 0xc8(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9512
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x10(%rsp), %r15
leaq 0x20(%rsp), %r12
movq 0xb8(%r14), %r13
imulq $0x38, 0xd0(%r14), %rbp
movl (%r13,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq 0x8(%r13,%rbp), %rsi
movq 0x10(%r13,%rbp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x17a38
addq %rbp, %r13
movups 0x28(%r13), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x9576
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0xd, %ebp
je 0x9659
movq %r14, %rdi
callq 0x932c
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x9466
movq %rbx, %rdi
leaq 0x8(%rsp), %rsi
callq 0xa3c6
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x95bd
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq 0xb8(%r14), %r13
imulq $0x38, 0xd0(%r14), %rbp
movl (%r13,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r12, 0x10(%rsp)
movq 0x8(%r13,%rbp), %rsi
movq 0x10(%r13,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x17a38
addq %rbp, %r13
movups 0x28(%r13), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x9619
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0xd, %ebp
je 0x951c
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
movl $0x12, %edx
callq 0x9b4a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x951c
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x951c
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
movl $0xd, %edx
callq 0x9b4a
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x968c
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x96c5
jmp 0x96c5
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x96c8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x96c8
jmp 0x96c5
jmp 0x96c5
movq %rax, %r14
movq %rbx, %rdi
callq 0x9812
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq $0x0, 0x10(%rdi)
leaq 0x70(%rsp), %rdi
movl $0x10, %edx
callq 0x9b4a
leaq 0x88(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x972d
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x3280
leaq 0x8(%rsp), %r15
leaq 0x18(%rsp), %r13
movq 0xb8(%r14), %rbp
imulq $0x38, 0xd0(%r14), %r12
movl (%rbp,%r12), %eax
movl %eax, (%rsp)
movq %r13, 0x8(%rsp)
movq 0x8(%rbp,%r12), %rsi
movq 0x10(%rbp,%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x17a38
addq %r12, %rbp
movups 0x28(%rbp), %xmm0
movups %xmm0, 0x20(%r15)
movl (%rsp), %ebp
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x978e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x11, %ebp
je 0x97ac
movq %r14, %rdi
callq 0xa692
movq %rax, (%rsp)
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xafb6
jmp 0x9737
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
movl $0x11, %edx
callq 0x9b4a
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x97d9
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x97f2
jmp 0x97f2
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x9809
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdi, %rbx
callq 0xc8fe
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17a38
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc5f5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x1d, %ebp
jne 0xc74b
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x17a38
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x1d, %edx
callq 0x9b4a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xc66e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xc8fe
movups 0x30(%rsp), %xmm0
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0xc, 0x100(%rbp)
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc742
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xc598
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xc773
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc78a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdi, %rbx
callq 0xcb1a
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17a38
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xc97d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x1c, %ebp
jne 0xcad3
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x17a38
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x1c, %edx
callq 0x9b4a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xc9f6
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xcb1a
movups 0x30(%rsp), %xmm0
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0xb, 0x100(%rbp)
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcaca
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xc920
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xcafb
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcb12
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdi, %rbx
callq 0xcd36
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17a38
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcb99
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x24, %ebp
jne 0xccef
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x17a38
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x24, %edx
callq 0x9b4a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xcc12
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xcd36
movups 0x30(%rsp), %xmm0
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0x14, 0x100(%rbp)
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcce6
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xcb3c
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xcd17
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcd2e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdi, %rbx
callq 0xcf52
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17a38
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcdb5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x25, %ebp
jne 0xcf0b
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x17a38
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x25, %edx
callq 0x9b4a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xce2e
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xcf52
movups 0x30(%rsp), %xmm0
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0x15, 0x100(%rbp)
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcf02
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xcd58
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xcf33
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcf4a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movq %rdi, %rbx
callq 0xd16e
movq %rax, (%rsp)
leaq 0x20(%rsp), %r13
xorl %r12d, %r12d
movq 0xb8(%rbx), %rbp
imulq $0x38, 0xd0(%rbx), %r14
movl (%rbp,%r14), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%rbp,%r14), %rsi
movq 0x10(%rbp,%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x17a38
movups 0x28(%rbp,%r14), %xmm0
movups %xmm0, 0x20(%r15)
movl 0x8(%rsp), %ebp
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xcfd1
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0x32, %ebp
jne 0xd127
movq 0xb8(%rbx), %r14
imulq $0x38, 0xd0(%rbx), %rbp
movl (%r14,%rbp), %eax
movl %eax, 0x8(%rsp)
movq %r13, 0x10(%rsp)
movq 0x8(%r14,%rbp), %rsi
movq 0x10(%r14,%rbp), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x17a38
movups 0x28(%r14,%rbp), %xmm0
leaq 0x10(%rsp), %rax
movups %xmm0, 0x20(%rax)
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
movl $0x32, %edx
callq 0x9b4a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0xd04a
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq %rax, %rbp
movq %rbx, %rdi
callq 0xd16e
movups 0x30(%rsp), %xmm0
leaq 0x30(%rbp), %rcx
movq %rcx, 0x20(%rbp)
movq %r12, 0x28(%rbp)
movb %r12b, 0x30(%rbp)
leaq 0x58(%rbp), %rcx
movq %rcx, 0x48(%rbp)
movq %r12, 0x50(%rbp)
movb %r12b, 0x58(%rbp)
leaq 0x78(%rbp), %rcx
movq %rcx, 0x68(%rbp)
movq %r12, 0x70(%rbp)
movb %r12b, 0x78(%rbp)
leaq 0x98(%rbp), %rcx
movq %rcx, 0x88(%rbp)
movq %r12, 0x90(%rbp)
movb %r12b, 0x98(%rbp)
movq %rbp, %rcx
addq $0xc8, %rcx
movq %rcx, 0xb8(%rbp)
movq %r12, 0xc0(%rbp)
movb %r12b, 0xc8(%rbp)
xorps %xmm1, %xmm1
movups %xmm1, 0xd8(%rbp)
movq %r12, 0xe8(%rbp)
movl $0x6, (%rbp)
movq (%rsp), %rcx
movq %rcx, 0xf0(%rbp)
movq %rax, 0xf8(%rbp)
movl $0x13, 0x100(%rbp)
movups %xmm0, 0x10(%rbp)
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xd11e
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbp, (%rsp)
jmp 0xcf74
movq (%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x118, %esi            # imm = 0x118
movq %rbp, %rdi
callq 0x3280
jmp 0xd14f
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0xd166
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe8b8
movq %rax, (%rsp)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x48(%rsp), %r12
xorl %r15d, %r15d
movq 0xb8(%r14), %r13
imulq $0x38, 0xd0(%r14), %rbp
movl (%r13,%rbp), %eax
movl %eax, 0x40(%rsp)
leaq 0x58(%rsp), %rbx
movq %rbx, 0x48(%rsp)
movq 0x8(%r13,%rbp), %rsi
movq 0x10(%r13,%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x17a38
addq %rbp, %r13
movups 0x28(%r13), %xmm0
movups %xmm0, 0x20(%r12)
movl 0x40(%rsp), %eax
movl %eax, 0x8(%rsp)
leaq 0x10(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x32f0
movups 0x20(%r12), %xmm0
movups %xmm0, 0x20(%r13)
movl 0x8(%rsp), %ebp
movq 0x48(%rsp), %rdi
cmpq %rbx, %rdi
je 0xe714
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x3280
cmpl $0xe, %ebp
jne 0xe85a
leaq 0xb0(%rsp), %rdi
movq %r14, %rsi
movl $0xe, %edx
callq 0x9b4a
movq 0xb8(%rsp), %rdi
leaq 0xc8(%rsp), %rax
cmpq %rax, %rdi
je 0xe757
movq 0xc8(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0xb374
movq %rax, %r13
leaq 0x78(%rsp), %rdi
movq %r14, %rsi
movl $0xf, %edx
callq 0x9b4a
movq 0x80(%rsp), %rdi
leaq 0x90(%rsp), %rax
cmpq %rax, %rdi
je 0xe799
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x3280
movl $0x118, %edi            # imm = 0x118
callq 0x3270
movq 0x18(%rsp), %rcx
movq 0x30(%rsp), %rdx
notq %rcx
addq 0x38(%rsp), %rcx
leaq 0x30(%rax), %rsi
movq %rsi, 0x20(%rax)
movq %r15, 0x28(%rax)
movb %r15b, 0x30(%rax)
leaq 0x58(%rax), %rsi
movq %rsi, 0x48(%rax)
movq %r15, 0x50(%rax)
movb %r15b, 0x58(%rax)
leaq 0x78(%rax), %rsi
movq %rsi, 0x68(%rax)
movq %r15, 0x70(%rax)
movb %r15b, 0x78(%rax)
leaq 0x98(%rax), %rsi
movq %rsi, 0x88(%rax)
movq %r15, 0x90(%rax)
movb %r15b, 0x98(%rax)
movq %rax, %rsi
addq $0xc8, %rsi
movq %rsi, 0xb8(%rax)
movq %r15, 0xc0(%rax)
movb %r15b, 0xc8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rax)
movq %r15, 0xe8(%rax)
movl $0x4, (%rax)
movq (%rsp), %rsi
movq %rsi, 0xa8(%rax)
movq %r13, 0xb0(%rax)
movq %rdx, 0x10(%rax)
movq %rcx, 0x18(%rax)
movq %rax, (%rsp)
jmp 0xe691
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xe876
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq (%rsp), %rax
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe890
jmp 0xe890
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xe8af
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %r8, 0x40(%rsp)
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, 0x38(%rsp)
movq %rdi, %r15
leaq 0x20(%rdi), %rax
movq %rax, 0x28(%rsp)
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x20(%rdi)
xorl %r12d, %r12d
movq %r12, 0x28(%rdi)
movb %r12b, 0x30(%rdi)
leaq 0x48(%rdi), %rbx
leaq 0x58(%rdi), %rax
movq %rax, 0x8(%rsp)
movq %rax, 0x48(%rdi)
movq %r12, 0x50(%rdi)
movb %r12b, 0x58(%rdi)
leaq 0x68(%rdi), %rax
movq %rax, 0x20(%rsp)
leaq 0x78(%rdi), %rax
movq %rax, (%rsp)
movq %rax, 0x68(%rdi)
movq %r12, 0x70(%rdi)
movb %r12b, 0x78(%rdi)
leaq 0x88(%rdi), %rax
movq %rax, 0x18(%rsp)
leaq 0x98(%rdi), %rbp
movq %rbp, 0x88(%rdi)
movq %r12, 0x90(%rdi)
movb %r12b, 0x98(%rdi)
leaq 0xc8(%rdi), %rax
movq %rax, 0xb8(%rdi)
movq %r12, 0xc0(%rdi)
movb %r12b, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movq %r12, 0xe8(%rdi)
leaq 0x9872(%rip), %rsi      # 0x194aa
movq %rdx, %rdi
callq 0x30b0
movq %rbx, 0x30(%rsp)
testl %eax, %eax
je 0xfca7
leaq 0x9d33(%rip), %rsi      # 0x19983
movq %r13, %rdi
callq 0x30b0
testl %eax, %eax
je 0xfc8f
leaq 0x9d24(%rip), %rsi      # 0x19987
movq %r13, %rdi
callq 0x30b0
testl %eax, %eax
je 0xfc9c
leaq 0x9cce(%rip), %rsi      # 0x19944
movq %r13, %rdi
callq 0x30b0
testl %eax, %eax
jne 0xfcbe
movl $0x3, %r12d
movq 0x18(%rsp), %rbx
jmp 0xfca7
movl $0x1, %r12d
movq 0x28(%rsp), %rbx
jmp 0xfca7
movl $0x2, %r12d
movq 0x20(%rsp), %rbx
leaq 0xb8(%r15), %r13
movl %r12d, (%r15)
movq %rbx, %rdi
movq 0x38(%rsp), %rsi
callq 0x3150
movq %r14, 0x10(%r15)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%r15)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r13, %rdi
callq 0xff3a
movq 0x18(%rsp), %rax
movq (%rax), %rdi
cmpq %rbp, %rdi
je 0xfcfe
movq (%rbp), %rsi
incq %rsi
callq 0x3280
movq 0x20(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0xfd1b
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x30(%rsp), %rax
movq (%rax), %rdi
cmpq 0x8(%rsp), %rdi
je 0xfd3a
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x28(%rsp), %rax
movq (%rax), %rdi
cmpq 0x10(%rsp), %rdi
je 0xfd59
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %rax
movq %rax, 0x10(%rsp)
movq %rax, 0x20(%rdi)
xorl %eax, %eax
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, 0x8(%rsp)
movq %rcx, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movb %al, 0x58(%rdi)
leaq 0x78(%rdi), %rcx
movq %rcx, (%rsp)
movq %rcx, 0x68(%rdi)
movq %rax, 0x70(%rdi)
movb %al, 0x78(%rdi)
leaq 0x98(%rdi), %rbp
movq %rbp, 0x88(%rdi)
movq %rax, 0x90(%rdi)
movb %al, 0x98(%rdi)
leaq 0xb8(%rdi), %r13
leaq 0xc8(%rdi), %rcx
movq %rcx, 0xb8(%rdi)
movq %rax, 0xc0(%rdi)
movb %al, 0xc8(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xd8(%rdi)
movq %rax, 0xe8(%rdi)
movl $0x5, (%rdi)
movq %r13, %rdi
callq 0x3150
leaq 0xd8(%rbx), %rdi
addq $0x20, %r12
movq %r12, %rsi
callq 0x100d6
movq %r15, 0x10(%rbx)
movq %r14, 0x18(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r13, %rdi
callq 0xff3a
movq 0x88(%rbx), %rdi
cmpq %rbp, %rdi
je 0xfee2
movq (%rbp), %rsi
incq %rsi
callq 0x3280
movq 0x68(%rbx), %rdi
cmpq (%rsp), %rdi
je 0xfefb
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x48(%rbx), %rdi
cmpq 0x8(%rsp), %rdi
je 0xff16
movq 0x8(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq 0x20(%rbx), %rdi
cmpq 0x10(%rsp), %rdi
je 0xff31
movq 0x10(%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
movq %rcx, %r12
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
leaq 0x18(%rdi), %r13
movq %r13, 0x8(%rdi)
movq $0x0, 0x10(%rdi)
movb $0x0, 0x18(%rdi)
leaq 0x28(%rdi), %r15
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x31(%rdi)
movq %rsi, (%rdi)
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x3150
movq %r15, %rdi
movq %r12, %rsi
callq 0x1101a
movb $0x1, 0x40(%r14)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x9812
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x103ed
movq (%r13), %rsi
incq %rsi
callq 0x3280
movq %r14, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, 0x8(%rsp)
movq 0x8(%rdi), %r15
movq %rdi, 0x10(%rsp)
movq 0x10(%rdi), %rax
subq %r15, %rax
setne %r12b
je 0x104bd
sarq $0x4, %rax
movabsq $-0x3333333333333333, %r13 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r13
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rbp
xorl %r14d, %r14d
cmpq $0x1, %r13
sbbq %r13, %r14
addq $0x10, %r15
movl $0x1, %ebx
movq (%r15), %rdx
cmpq %rbp, %rdx
jne 0x10497
testq %rdx, %rdx
je 0x104b4
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq -0x8(%r15), %rdi
callq 0x3290
testl %eax, %eax
je 0x104b4
cmpq %rbx, %r13
seta %r12b
addq $0x50, %r15
leaq (%r14,%rbx), %rax
incq %rax
incq %rbx
cmpq $0x1, %rax
jne 0x10475
jmp 0x104bd
movb $0x1, %bpl
testb $0x1, %r12b
jne 0x10517
movq 0x10(%rsp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x10515
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rsp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x17a38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1041e
movl %eax, %ebp
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x10517
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x10517
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x10542
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r13
movq 0x8(%rdi), %rax
movq %rdi, 0x8(%rsp)
movq 0x10(%rdi), %rcx
subq %rax, %rcx
setne %bpl
je 0x147c5
sarq $0x4, %rcx
movabsq $-0x3333333333333333, %r14 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rcx, %r14
movq 0x8(%r13), %rsi
xorl %r12d, %r12d
cmpq $0x1, %r14
sbbq %r14, %r12
movl $0x1, %ebx
movq %rsi, 0x10(%rsp)
movq %rax, %r15
movq 0x10(%rax), %rdx
cmpq %rsi, %rdx
jne 0x147a8
testq %rdx, %rdx
je 0x147c5
movq (%r13), %rsi
movq 0x8(%r15), %rdi
callq 0x3290
movq 0x10(%rsp), %rsi
testl %eax, %eax
je 0x147c5
cmpq %rbx, %r14
seta %bpl
leaq 0x50(%r15), %rax
leaq (%r12,%rbx), %rcx
incq %rcx
incq %rbx
cmpq $0x1, %rcx
jne 0x14781
jmp 0x147c5
testb $0x1, %bpl
jne 0x1481a
movq 0x8(%rsp), %rax
movq (%rax), %r14
leaq 0x28(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r13), %rsi
movq 0x8(%r13), %rdx
addq %rsi, %rdx
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x17a38
movq %r14, %rdi
movq %rbx, %rsi
callq 0x14730
movq %rax, %r15
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x1481a
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r12, %rdi
je 0x14846
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x8(%rdi), %r15
movq 0x10(%rdi), %rax
subq %r15, %rax
setne %bl
je 0x149cb
sarq $0x4, %rax
movabsq $-0x3333333333333333, %r12 # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %r12
movq %rsi, (%rsp)
movq 0x8(%rsi), %r13
xorl %ebp, %ebp
cmpq $0x1, %r12
sbbq %r12, %rbp
addq $0x10, %r15
movl $0x1, %r14d
movq (%r15), %rdx
cmpq %r13, %rdx
jne 0x149b1
testq %rdx, %rdx
je 0x149cb
movq (%rsp), %rax
movq (%rax), %rsi
movq -0x8(%r15), %rdi
callq 0x3290
testl %eax, %eax
je 0x149cb
cmpq %r14, %r12
seta %bl
addq $0x50, %r15
leaq (%r14,%rbp), %rax
incq %rax
incq %r14
cmpq $0x1, %rax
jne 0x14990
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x42bb(%rip), %r12      # 0x191f0
movq (%r15), %r14
movl (%r14), %eax
cmpq $0x6, %rax
ja 0x14fe1
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
addq $0x20, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14fee
movq (%r15), %r15
addq $0x28, %r15
jmp 0x14f35
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14fee
movq (%r15), %r15
addq $0x38, %r15
jmp 0x14f35
cmpq $0x0, 0x70(%r14)
je 0x14fe1
addq $0x70, %r14
jmp 0x14f95
addq $0x78, %r14
jmp 0x14f95
addq $0x40, %r14
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14fee
movq 0x8(%r14), %rsi
cmpq %rsi, 0x10(%r14)
je 0x14fe1
xorl %r15d, %r15d
xorl %r12d, %r12d
addq %r15, %rsi
movq %rbx, %rdi
callq 0x14f20
incq %r12
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rax
subq %rsi, %rax
sarq $0x3, %rax
addq $0x8, %r15
cmpq %r12, %rax
ja 0x14fbb
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x3248(%rip), %r15      # 0x19268
movl (%r14), %eax
cmpq $0x6, %rax
ja 0x16118
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x20(%r14), %rsi
movq %rbx, %rdi
callq 0x1615a
movq 0x28(%r14), %r14
jmp 0x16020
movq 0x30(%r14), %rsi
movq %rbx, %rdi
callq 0x1615a
movq 0x38(%r14), %r14
jmp 0x16020
movq 0x48(%r14), %rax
leaq 0x8(%rsp), %rdi
movq %rax, -0x8(%rdi)
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x50(%r14), %rsi
movq 0x58(%r14), %rdx
addq %rsi, %rdx
callq 0x17a38
movq 0x70(%r14), %rsi
movq %rsi, 0x10(%r15)
testq %rsi, %rsi
je 0x16095
movq %rbx, %rdi
callq 0x1615a
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16118
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x16113
movq 0x78(%r14), %rsi
jmp 0x160b3
movq 0x40(%r14), %rsi
movq %rbx, %rdi
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x1615a
addq $0x8, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xb122
movq (%r15), %rdi
cmpq %rdi, 0x8(%r15)
je 0x16106
xorl %r14d, %r14d
movq (%rdi,%r14,8), %rsi
movq %rbx, %rdi
callq 0x1600a
incq %r14
movq (%rsp), %rdi
movq 0x8(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x160e2
testq %rdi, %rdi
je 0x16118
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x16152
movq 0x18(%rsp), %rsi
incq %rsi
jmp 0x1614d
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x16152
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq %rbx, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3112(%rip), %r15      # 0x19284
movl (%r14), %eax
decl %eax
cmpl $0x6, %eax
ja 0x1623c
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0xf0(%r14), %rsi
movq %rbx, %rdi
callq 0x1615a
movq 0xf8(%r14), %r14
jmp 0x16172
movq 0x108(%r14), %r14
jmp 0x16172
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0xb8(%r14), %rsi
movq 0xc0(%r14), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0x17a38
leaq 0x20(%rsp), %rdi
addq $0xd8, %r14
movq %r14, %rsi
callq 0xfd62
movq 0x20(%rsp), %rdi
cmpq %rdi, 0x28(%rsp)
je 0x16214
xorl %r14d, %r14d
movq (%rdi,%r14,8), %rsi
movq %rbx, %rdi
callq 0x1615a
incq %r14
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rax
subq %rdi, %rax
sarq $0x3, %rax
cmpq %r14, %rax
ja 0x161ef
testq %rdi, %rdi
je 0x16226
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x3280
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x1623c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq 0x20(%rbx), %rdx
leaq 0x1(%rdx), %rax
movq %rax, 0x20(%rbx)
movq %rdx, 0x40(%r14)
leaq 0x39f3(%rip), %rsi      # 0x19c52
movq %rbx, %rdi
xorl %eax, %eax
callq 0x162e4
cmpq $0x0, 0x28(%r14)
je 0x16299
leaq 0x39e2(%rip), %r15      # 0x19c59
xorl %r12d, %r12d
movq 0x20(%r14), %rax
movzbl (%rax,%r12), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x162e4
incq %r12
cmpq %r12, 0x28(%r14)
ja 0x1627a
leaq 0x39c9(%rip), %rsi      # 0x19c69
movq %rbx, %rdi
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x162e4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x162db
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x3280
jmp 0x162db
movq %rax, %rbx
movq %rsp, %rdi
callq 0xff3a
movq %rbx, %rdi
callq 0x33b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
xorps %xmm0, %xmm0
movups %xmm0, 0x9(%rbx)
movups %xmm0, (%rbx)
movups %xmm0, 0x20(%rbx)
xorl %eax, %eax
movq %rax, 0x30(%rbx)
movq %rdx, -0x8(%rbx)
movb 0x20(%rdx), %cl
movb %cl, 0x18(%rbx)
movq 0x28(%rdx), %rcx
movq %rcx, 0x20(%rbx)
movq 0x30(%rdx), %rcx
movq %rcx, 0x28(%rbx)
movq 0x38(%rdx), %rcx
movq %rcx, 0x30(%rbx)
movq %rax, (%rsp)
movq 0x40(%rsi), %rax
cmpq %rax, 0x48(%rsi)
je 0x163fc
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq %rsp, %r13
movq (%rax,%rbp,8), %rsi
movq %r15, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x16a0c
incq %rbp
movq 0x40(%r14), %rax
movq 0x48(%r14), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
cmpq %rbp, %rcx
ja 0x163d3
movq 0x30(%r14), %rax
subq 0x28(%r14), %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
leaq (,%rcx,8), %rax
cmpq $0x6, %rcx
movl $0x30, %ecx
cmovbq %rax, %rcx
subq (%rsp), %rcx
leaq 0x7(%rcx), %rax
testq %rcx, %rcx
cmovnsq %rcx, %rax
andq $-0x8, %rax
leaq 0x8(%rax), %r14
cmpq %rax, %rcx
cmoveq %rcx, %r14
movq %rbx, %rdi
callq 0x15538
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 0x15538
movq %r14, %rdi
callq 0x33b0
// File: /workspace/github_cpp_makefile_star2_O1/saumya-prakash[P]AssemblerEmulator/Emulator.cpp
// Function: Emulator::get_int(std::basic_ifstream<char, std::char_traits<char>>&) const
unsigned Emulator::get_int(ifstream& fi) const
{
    unsigned res = 0;

    char *ptr = (char *) &res;
    char byte = 0;

    if(machine_type==big_endian)    // just read byte and put it
    {
        fi.read(&byte, 1);
        *ptr = byte;
        ptr++;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr++;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr++;

        fi.read(&byte, 1);
        *ptr = byte;
    }

    else    // read and put in reverse order
    {
        ptr += 3;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr--;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr--;

        fi.read(&byte, 1);
        *ptr = byte;
        ptr--;

        fi.read(&byte, 1);
        *ptr = byte;
    }
    
    return res;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
leaq 0x7(%rsp), %rbx
movb $0x0, (%rbx)
movl 0x5ad2(%rip), %ebp      # 0xa1d8
movl $0x1, %edx
movq %rsi, %rdi
movq %rbx, %rsi
callq 0x21d0
movzbl (%rbx), %r12d
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movzbl (%rbx), %r13d
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
movzbl (%rbx), %r15d
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x21d0
cmpl $0x1, %ebp
movzbl (%rbx), %eax
movl %r12d, %ecx
cmovel %eax, %ecx
movl %r13d, %edx
cmovel %r15d, %edx
cmovel %r13d, %r15d
cmovel %r12d, %eax
shll $0x18, %ecx
movl $0xff, %esi
andl %esi, %edx
shll $0x10, %edx
orl %ecx, %edx
andl %esi, %r15d
shll $0x8, %r15d
orl %edx, %r15d
andl %esi, %eax
orl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq