LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_controllflow()
ast::Node* Parser::parse_controllflow() {
	auto t = tokenizer.peek().type;
	if (t == tok::If) {
		tokenizer.next();

		auto cond = parse_assign();
		expect(tok::LeftCurlyBracket);
		auto ifbody = parse_block();
		ast::Node* elsebody = nullptr;
		if (tokenizer.peek().type == tok::Else) {
			tokenizer.next();
			if (tokenizer.peek().type == tok::If) {
				elsebody = parse_controllflow();
			} else {
				expect(tok::LeftCurlyBracket);
				elsebody = parse_block();
			}
		}

		return new ast::If(cond, ifbody, elsebody);
	}
	if (t == tok::For) {
		tokenizer.next();

		auto expr1 = parse_assign();
		if (tokenizer.peek().type == tok::Semicolon) {
			tokenizer.next();
			auto expr2 = parse_assign();
			expect(tok::Semicolon);
			auto expr3 = parse_assign();
			expect(tok::LeftCurlyBracket);
			return new ast::For(expr1, expr2, expr3, parse_block());
		}

		expect(tok::LeftCurlyBracket);
		return new ast::For(nullptr, expr1, nullptr, parse_block());
	}
	return parse_assign();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
callq 0x668a
cmpl $0x24, %eax
je 0x7bb5
cmpl $0x22, %eax
jne 0x7c38
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x7cee
movq %rax, %r14
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0x796c
movq %rbx, %rdi
callq 0x80f4
movq %rax, %r12
movq %rbx, %rdi
callq 0x668a
cmpl $0x23, %eax
jne 0x7c49
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x668a
cmpl $0x22, %eax
jne 0x7c8d
movq %rbx, %rdi
callq 0x7b36
jmp 0x7ca0
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x7cee
movq %rax, %r14
movq %rbx, %rdi
callq 0x668a
cmpl $0x1e, %eax
jne 0x7c4d
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x7cee
movq %rax, %r12
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0x796c
movq %rbx, %rdi
callq 0x7cee
movq %rax, %r13
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0x796c
pushq $0x28
popq %rdi
callq 0x5390
movq %rax, %r15
movq %rbx, %rdi
callq 0x80f4
leaq 0x17e4d(%rip), %rcx     # 0x1fa70
addq $0x10, %rcx
movq %rcx, (%r15)
movq %r14, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r13, 0x18(%r15)
jmp 0x7c87
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x7cee
xorl %ebx, %ebx
jmp 0x7ca3
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0x796c
pushq $0x28
popq %rdi
callq 0x5390
movq %rax, %r15
movq %rbx, %rdi
callq 0x80f4
leaq 0x17dfe(%rip), %rcx     # 0x1fa70
addq $0x10, %rcx
movq %rcx, (%r15)
andq $0x0, 0x8(%r15)
movq %r14, 0x10(%r15)
andq $0x0, 0x18(%r15)
movq %rax, 0x20(%r15)
jmp 0x7cc8
pushq $0x19
popq %rsi
movq %rbx, %rdi
callq 0x796c
movq %rbx, %rdi
callq 0x80f4
movq %rax, %rbx
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %r15
leaq 0x17d8b(%rip), %rax     # 0x1fa40
addq $0x10, %rax
movq %rax, (%r15)
movq %r14, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %rbx, 0x18(%r15)
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x7cd7
movq %rax, %rbx
pushq $0x28
popq %rsi
movq %r15, %rdi
callq 0x53a0
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_block()
ast::Block* Parser::parse_block() {
	if (tokenizer.peek().type == tok::RightCurlyBracket) {
		tokenizer.next();
		return new ast::Block(std::vector<ast::Node*>());
	}

	std::vector<ast::Node*> exprs;
	exprs.push_back(parse_expr());
	auto t = tokenizer.next();
	while (t.type == tok::Semicolon) {
		if (tokenizer.peek().type == tok::RightCurlyBracket) {
			t = tokenizer.next();
			break;
		}

		exprs.push_back(parse_expr());
		t = tokenizer.next();
	}

	if (t.type != tok::RightCurlyBracket)
		throw utils::parser_error("expected ';' or '}'", t);

	return new ast::Block(std::move(exprs));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
callq 0x668a
cmpl $0x1a, %eax
jne 0x8143
movq %rbx, %rdi
callq 0x66b4
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %rbx
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rax, %rdi
callq 0x9366
leaq 0x20(%rsp), %rdi
jmp 0x820f
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x7b36
leaq 0x18(%rsp), %rsi
movq %rax, (%rsi)
movq %rsp, %rdi
callq 0x97fe
movq %rbx, %rdi
callq 0x66b4
movq %rax, %r14
movq %rdx, %r12
movq %rsp, %r15
leaq 0x18(%rsp), %r13
cmpl $0x1e, %r14d
jne 0x81c7
movq %rbx, %rdi
callq 0x668a
cmpl $0x1a, %eax
je 0x81b9
movq %rbx, %rdi
callq 0x7b36
movq %rax, 0x18(%rsp)
movq %r15, %rdi
movq %r13, %rsi
callq 0x97fe
movq %rbx, %rdi
callq 0x66b4
movq %rax, %r14
movq %rdx, %r12
jmp 0x817e
movq %rbx, %rdi
callq 0x66b4
movq %rax, %r14
movq %rdx, %r12
cmpl $0x1a, %r14d
jne 0x8225
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %rbx
movq (%rsp), %rax
leaq 0x38(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %rbx, %rdi
callq 0x9366
leaq 0x38(%rsp), %rdi
callq 0x9768
movq %rsp, %rdi
callq 0x9768
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
pushq $0x48
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0xc679(%rip), %rsi      # 0x148b0
movq %rax, %rdi
movq %r14, %rdx
movq %r12, %rcx
callq 0x9e26
leaq 0x17324(%rip), %rsi     # 0x1f570
leaq 0x10a5(%rip), %rdx      # 0x92f8
movq %rbx, %rdi
callq 0x55f0
jmp 0x82a6
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
jmp 0x82a9
movq %rax, %r14
leaq 0x38(%rsp), %rdi
callq 0x9768
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x53a0
jmp 0x82a9
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x9768
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0x53a0
jmp 0x82b1
jmp 0x82a6
jmp 0x82a6
jmp 0x82a6
jmp 0x82a6
movq %rax, %r14
movq %rsp, %rdi
callq 0x9768
movq %r14, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_logic()
ast::Node* Parser::parse_logic() {
	auto left = parse_cmp();
	auto t = tokenizer.peek().type;
	while (t == tok::Or || t == tok::And) {
		tokenizer.next();
		auto right = parse_cmp();
		if (t == tok::Or)
			left = new ast::InfixOperator(ast::InfixOperator::Or,  left, right);
		else
			left = new ast::InfixOperator(ast::InfixOperator::And, left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x833c
movq %rax, %r14
pushq $0x20
popq %r15
leaq 0x173f5(%rip), %r13     # 0x1f6d0
addq $0x10, %r13
movq %rbx, %rdi
callq 0x668a
leal -0x15(%rax), %ecx
cmpl $0x1, %ecx
ja 0x8329
xorl %ebp, %ebp
cmpl $0x15, %eax
sete %bpl
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x833c
movq %rax, %r12
movq %r15, %rdi
callq 0x5390
movq %r13, (%rax)
orl $0x4, %ebp
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r14
jmp 0x82df
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_cmp()
ast::Node* Parser::parse_cmp() {
	auto left = parse_addsub();
	auto t = tokenizer.peek().type;
	while (t == tok::Equals || t == tok::EqualsNot || t == tok::Smaller || t == tok::Bigger || t == tok::SmallerOrEqual || t == tok::BiggerOrEqual) {
		tokenizer.next();
		auto right = parse_addsub();
		if (t == tok::Equals)
			left = new ast::InfixOperator(ast::InfixOperator::Equals,    left, right);
		else if (t == tok::EqualsNot)
			left = new ast::InfixOperator(ast::InfixOperator::EqualsNot, left, right);
		else if (t == tok::Smaller)
			left = new ast::InfixOperator(ast::InfixOperator::Smaller,   left, right);
		else if (t == tok::Bigger)
			left = new ast::InfixOperator(ast::InfixOperator::Bigger,    left, right);
		else if (t == tok::SmallerOrEqual)
			left = new ast::InfixOperator(ast::InfixOperator::SmallerOrEqual, left, right);
		else if (t == tok::BiggerOrEqual)
			left = new ast::InfixOperator(ast::InfixOperator::BiggerOrEqual,  left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x83d0
movq %rax, %r14
leaq 0x17377(%rip), %rbp     # 0x1f6d0
addq $0x10, %rbp
leaq 0xc388(%rip), %r15      # 0x146ec
movq %rbx, %rdi
callq 0x668a
movq %rax, %r12
addl $-0xe, %eax
cmpl $0x5, %eax
ja 0x83be
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x83d0
movq %rax, %r13
pushq $0x20
popq %rdi
callq 0x5390
movq %rbp, (%rax)
shlq $0x20, %r12
movabsq $-0xe00000000, %rcx     # imm = 0xFFFFFFF200000000
addq %rcx, %r12
sarq $0x1e, %r12
movl (%r12,%r15), %ecx
movl %ecx, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r13, 0x18(%rax)
movq %rax, %r14
jmp 0x8364
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_addsub()
ast::Node* Parser::parse_addsub() {
	auto left = parse_muldiv();
	auto t = tokenizer.peek().type;
	while (t == tok::Plus || t == tok::Minus) {
		tokenizer.next();
		auto right = parse_muldiv();
		if (t == tok::Plus)
			left = new ast::InfixOperator(ast::InfixOperator::Add, left, right);
		else
			left = new ast::InfixOperator(ast::InfixOperator::Sub, left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x8450
movq %rax, %r14
pushq $0x20
popq %r15
leaq 0x172df(%rip), %r13     # 0x1f6d0
addq $0x10, %r13
movq %rbx, %rdi
callq 0x668a
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x8, %ecx
jne 0x843e
xorl %ebp, %ebp
cmpl $0x8, %eax
setne %bpl
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x8450
movq %rax, %r12
movq %r15, %rdi
callq 0x5390
movq %r13, (%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r14
jmp 0x83f5
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_muldiv()
ast::Node* Parser::parse_muldiv() {
	auto left = parse_unary_ops();
	auto t = tokenizer.peek().type;
	while (t == tok::Mul || t == tok::Div) {
		tokenizer.next();
		auto right = parse_unary_ops();
		if (t == tok::Mul)
			left = new ast::InfixOperator(ast::InfixOperator::Mul, left, right);
		else
			left = new ast::InfixOperator(ast::InfixOperator::Div, left, right);
		t = tokenizer.peek().type;
	}
	return left;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x84d4
movq %rax, %r14
pushq $0x20
popq %r15
leaq 0x1725f(%rip), %r13     # 0x1f6d0
addq $0x10, %r13
movq %rbx, %rdi
callq 0x668a
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x84c1
xorl %ebp, %ebp
cmpl $0xa, %eax
sete %bpl
movq %rbx, %rdi
callq 0x66b4
movq %rbx, %rdi
callq 0x84d4
movq %rax, %r12
movq %r15, %rdi
callq 0x5390
movq %r13, (%rax)
xorl $0x3, %ebp
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rax, %r14
jmp 0x8475
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_unary_ops()
ast::Node* Parser::parse_unary_ops() {
	auto t = tokenizer.peek().type;
	if (t == tok::Minus) {
		tokenizer.next();
		return new ast::PrefxOperator(ast::PrefxOperator::Neg, parse_factor());
	}
	if (t == tok::Not) {
		tokenizer.next();
		return new ast::PrefxOperator(ast::PrefxOperator::Not, parse_factor());
	}
	return parse_factor();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x668a
cmpl $0x14, %eax
je 0x851c
cmpl $0x9, %eax
jne 0x8558
movq %r14, %rdi
callq 0x66b4
pushq $0x18
popq %rdi
callq 0x5390
movq %rax, %rbx
movq %r14, %rdi
callq 0x8580
leaq 0x1720c(%rip), %rcx     # 0x1f718
addq $0x10, %rcx
movq %rcx, (%rbx)
movl $0x1, 0x8(%rbx)
jmp 0x8549
movq %r14, %rdi
callq 0x66b4
pushq $0x18
popq %rdi
callq 0x5390
movq %rax, %rbx
movq %r14, %rdi
callq 0x8580
leaq 0x171da(%rip), %rcx     # 0x1f718
addq $0x10, %rcx
movq %rcx, (%rbx)
andl $0x0, 0x8(%rbx)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x8580
jmp 0x8569
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x53a0
movq %r14, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_arglist(std::vector<ast::Node*, std::allocator<ast::Node*>>&)
void Parser::parse_arglist(std::vector<ast::Node*> &args) {
	if (tokenizer.peek().type == tok::RightBracket) {
		tokenizer.next();
		return;
	}

	args.push_back(parse_expr());
	auto token = tokenizer.next();
	while (token.type == tok::Comma) {
		args.push_back(parse_expr());
		token = tokenizer.next();
	}

	if (token.type != tok::RightBracket)
		throw utils::parser_error("expected ',' or ')' in arglist", token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x668a
cmpl $0x18, %eax
jne 0x8ec8
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x66b4
movq %rbx, %rdi
callq 0x7b36
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x97fe
movq %rbx, %rdi
callq 0x66b4
movq %rax, %r12
cmpl $0x1d, %r12d
jne 0x8f03
movq %rbx, %rdi
callq 0x7b36
movq %rax, 0x8(%rsp)
jmp 0x8ed8
cmpl $0x18, %r12d
jne 0x8f17
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r13
pushq $0x48
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0xb998(%rip), %rsi      # 0x148c4
movq %rax, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x9e26
leaq 0x1662f(%rip), %rsi     # 0x1f570
leaq 0x3b0(%rip), %rdx       # 0x92f8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse_map(ast::Node*)
ast::Map* Parser::parse_map(ast::Node* firstkey) {
	std::vector<std::pair<ast::Node*,ast::Node*>> values;
	values.push_back(std::make_pair(firstkey, parse_expr()));
	auto t = tokenizer.next();
	while (t.type == tok::Comma) {
		auto key = parse_expr();
		expect(tok::KeyValue);
		auto value = parse_expr();
		values.push_back(std::make_pair(key, value));
		t = tokenizer.next();
	}
	if (t.type != tok::RightSquareBracket)
		throw utils::parser_error("expected ',' or ')' while parsing map", t);

	return new ast::Map(std::move(values));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
callq 0x7b36
leaq 0x20(%rsp), %rsi
movq %r14, (%rsi)
movq %rax, 0x8(%rsi)
movq %rsp, %rdi
callq 0x9c00
movq %rbx, %rdi
callq 0x66b4
movq %rax, %r12
movq %rdx, %r13
pushq $0xd
popq %rbp
movq %rsp, %r14
leaq 0x20(%rsp), %r15
cmpl $0x1d, %r12d
jne 0x921f
movq %rbx, %rdi
callq 0x7b36
movq %rax, %r12
movq %rbx, %rdi
movl %ebp, %esi
callq 0x796c
movq %rbx, %rdi
callq 0x7b36
movq %r12, 0x20(%rsp)
movq %rax, 0x28(%rsp)
movq %r14, %rdi
movq %r15, %rsi
callq 0x9c00
movq %rbx, %rdi
callq 0x66b4
movq %rax, %r12
movq %rdx, %r13
jmp 0x91d7
cmpl $0x1c, %r12d
jne 0x927e
pushq $0x20
popq %rdi
callq 0x5390
movq %rax, %r14
movq (%rsp), %rax
leaq 0x30(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq %r14, %rdi
callq 0x9430
leaq 0x30(%rsp), %rdi
callq 0x95ea
movq %rsp, %rdi
callq 0x95ea
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x48
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0xb5fa(%rip), %rsi      # 0x1488a
movq %rax, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0x9e26
leaq 0x162cb(%rip), %rsi     # 0x1f570
leaq 0x4c(%rip), %rdx        # 0x92f8
movq %r14, %rdi
callq 0x55f0
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x95ea
pushq $0x20
popq %rsi
movq %r14, %rdi
callq 0x53a0
jmp 0x92e8
jmp 0x92e5
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
jmp 0x92e8
jmp 0x92e5
jmp 0x92e5
jmp 0x92e5
jmp 0x92e5
movq %rax, %rbx
movq %rsp, %rdi
callq 0x95ea
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::tokenizer_error::tokenizer_error(char const*, int, char)
tokenizer_error::tokenizer_error(const char* msg, int line, char c):
		std::runtime_error(msg), line(line), c(c), what_message("TokenizerError: ") {
		what_message += msg;
		what_message += " (line: ";
		what_message += std::to_string(line);
		what_message += ", `";
		what_message += c;
		what_message += "`)";
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5640
leaq 0x157f1(%rip), %rax     # 0x1f558
movq %rax, (%rbx)
movl %r15d, 0x10(%rbx)
movb %bpl, 0x14(%rbx)
leaq 0x18(%rbx), %r14
leaq 0xabd4(%rip), %rsi      # 0x14951
movq %rsp, %rdx
movq %r14, %rdi
callq 0x60ee
movq %r14, %rdi
movq %r12, %rsi
callq 0x5650
leaq 0xabc8(%rip), %rsi      # 0x14962
movq %r14, %rdi
callq 0x5650
movq %rsp, %rdi
movl %r15d, %esi
callq 0x711c
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5670
movq %rsp, %rdi
callq 0x5170
leaq 0xaba4(%rip), %rsi      # 0x1496b
movq %r14, %rdi
callq 0x5650
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x5300
leaq 0xab8d(%rip), %rsi      # 0x1496f
movq %r14, %rdi
callq 0x5650
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %rsp, %rdi
callq 0x5170
jmp 0x9e0e
jmp 0x9e0b
movq %rax, %r15
jmp 0x9e16
movq %rax, %r15
movq %r14, %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::parser_error::parser_error(char const*, tok::Token)
parser_error::parser_error(const char* msg, tok::Token t):
		std::runtime_error(msg), token(t), node(nullptr), what_message("SyntaxError: ") {
		what_message += msg;
		what_message += " (near token: ";
		what_message += tok::to_string(t);
		what_message += ", line: ";
		what_message += std::to_string(t.line);
		what_message += ")";
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
callq 0x5640
leaq 0x1575d(%rip), %rax     # 0x1f5a8
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
movq %r12, 0x18(%rbx)
andq $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0xab0c(%rip), %rsi      # 0x14972
movq %rsp, %rdx
movq %r14, %rdi
callq 0x60ee
movq %r14, %rdi
movq %r13, %rsi
callq 0x5650
leaq 0xaafd(%rip), %rsi      # 0x14980
movq %r14, %rdi
callq 0x5650
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6bbf
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5670
movq %rsp, %rdi
callq 0x5170
leaq 0xaadc(%rip), %rsi      # 0x1498f
movq %r14, %rdi
callq 0x5650
shrq $0x20, %r15
movq %rsp, %rdi
movl %r15d, %esi
callq 0xa325
movq %rsp, %rsi
movq %r14, %rdi
callq 0x5670
movq %rsp, %rdi
callq 0x5170
leaq 0xa5af(%rip), %rsi      # 0x14493
movq %r14, %rdi
callq 0x5650
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x9efe
jmp 0x9f12
movq %rax, %r15
movq %rsp, %rdi
callq 0x5170
jmp 0x9f15
jmp 0x9f12
movq %rax, %r15
jmp 0x9f1d
movq %rax, %r15
movq %r14, %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::parser_error::parser_error(char const*, ast::Node*)
parser_error::parser_error(const char* msg, ast::Node* node):
		std::runtime_error(msg), token(tok::Token(tok::EOFTok, 0)), node(node), what_message("SyntaxError: ") {
		what_message += msg;
		/*what_message += " (near ast node: ";
		node->to_string(what_message);
		what_message += ")";*/
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5640
leaq 0x1565c(%rip), %rax     # 0x1f5a8
movq %rax, (%rbx)
movq $0x25, 0x10(%rbx)
andl $0x0, 0x18(%rbx)
movq %r15, 0x20(%rbx)
leaq 0x28(%rbx), %r15
leaq 0xaa08(%rip), %rsi      # 0x14972
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x60ee
movq %r15, %rdi
movq %r14, %rsi
callq 0x5650
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x5170
jmp 0x9f9c
movq %rax, %r14
movq %rbx, %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::interpreter_error::interpreter_error(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
interpreter_error::interpreter_error(const char* msg, std::string name):
		std::runtime_error(msg), what_message("RuntimeError: ") {
		what_message += msg;
		what_message += " (";
		what_message += name;
		what_message += ")";
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5640
leaq 0x15607(%rip), %rax     # 0x1f5d0
movq %rax, (%rbx)
leaq 0x10(%rbx), %r14
leaq 0xa9c1(%rip), %rsi      # 0x14998
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x60ee
movq %r14, %rdi
movq %r12, %rsi
callq 0x5650
leaq 0xa9b1(%rip), %rsi      # 0x149a7
movq %r14, %rdi
callq 0x5650
movq %r14, %rdi
movq %r15, %rsi
callq 0x5670
leaq 0xa483(%rip), %rsi      # 0x14493
movq %r14, %rdi
callq 0x5650
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0xa034
movq %rax, %r15
movq %r14, %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string dirname(std::string &path) {
		auto i = path.find_last_of("/");
		if (i == std::string::npos)
			return ".";

		return path.substr(0, i);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa87f(%rip), %rsi      # 0x149b6
pushq $-0x1
popq %rdx
movq %r14, %rdi
callq 0x5360
cmpq $-0x1, %rax
je 0xa15a
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x53b0
jmp 0xa16e
leaq 0x9fd3(%rip), %rsi      # 0x14134
leaq 0x7(%rsp), %rdx
movq %rbx, %rdi
callq 0x60ee
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::normalize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string normalize(std::string &path) {
		char normalized[PATH_MAX + 1];
		if (realpath(path.c_str(), normalized) == nullptr) {
			throw std::runtime_error("normalize path error");
		}
		return std::string(normalized);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, %rbx
movq (%rsi), %rdi
leaq 0x10(%rsp), %rsi
callq 0x50e0
testq %rax, %rax
je 0xa1b8
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x60ee
movq %rbx, %rax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0xa7ee(%rip), %rsi      # 0x149b8
movq %rax, %rdi
callq 0x5120
movq 0x15e17(%rip), %rsi     # 0x1fff0
movq 0x15dc8(%rip), %rdx     # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/utils.cc
// Function: utils::readfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readfile(std::string &path, std::string &content) {
		content.clear();
		std::ifstream ifs(path);
		if (!ifs.good())
			throw std::runtime_error("readfile error");

		content.assign((std::istreambuf_iterator<char>(ifs)),(std::istreambuf_iterator<char>()));
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rsi, %rbx
andq $0x0, 0x8(%rsi)
movq %rdi, %rsi
movq (%rbx), %rax
movb $0x0, (%rax)
movq %rsp, %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x55a0
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%rsp,%rax)
jne 0xa25d
movq 0xe8(%rsp,%rax), %rsi
pushq $-0x1
popq %rdx
movq %rbx, %rdi
xorl %ecx, %ecx
movl %edx, %r8d
callq 0xa364
movq %rsp, %rdi
callq 0x5080
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0xa75e(%rip), %rsi      # 0x149cd
movq %rax, %rdi
callq 0x5120
movq 0x15d72(%rip), %rsi     # 0x1fff0
movq 0x15d23(%rip), %rdx     # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
jmp 0xa29d
movq %rax, %r14
movq %rsp, %rdi
callq 0x5080
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::PrefxOperator::optimize()
Node* PrefxOperator::optimize() {
	switch (type) {
	case PrefxOperator::Neg:{
		auto a = dynamic_cast<Bool*>(operand = operand->optimize());
		if (a != nullptr) {
			auto res = !a->value;
			delete this;
			return new ast::Bool(res);
		}
		return this;
	}
	case PrefxOperator::Not:{
		auto a = dynamic_cast<Number*>(operand = operand->optimize());
		if (a != nullptr) {
			auto res = -a->value;
			delete this;
			return new ast::Number(res);
		}
		return this;
	}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
cmpl $0x1, %ebp
jne 0xabc5
testq %rax, %rax
je 0xac1d
leaq 0x14a09(%rip), %rsi     # 0x1f588
leaq 0x14d2a(%rip), %rdx     # 0x1f8b0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53e0
testq %rax, %rax
je 0xac1d
movb 0x8(%rax), %bpl
xorb $0x1, %bpl
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
pushq $0x10
popq %rdi
callq 0x5390
movq %rax, %rbx
leaq 0x14cd4(%rip), %rax     # 0x1f890
movq %rax, (%rbx)
movb %bpl, 0x8(%rbx)
jmp 0xac1d
testq %rax, %rax
je 0xac1d
leaq 0x149b7(%rip), %rsi     # 0x1f588
leaq 0x14c90(%rip), %rdx     # 0x1f868
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53e0
testq %rax, %rax
je 0xac1d
movsd 0x8(%rax), %xmm0
xorps 0x9f1d(%rip), %xmm0     # 0x14b10
movaps %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
pushq $0x10
popq %rdi
callq 0x5390
movq %rax, %rbx
leaq 0x14c36(%rip), %rax     # 0x1f848
movq %rax, (%rbx)
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::VariableDecl::optimize()
Node* VariableDecl::optimize() {
	for (auto &pair : decls)
		if (pair.second != nullptr)
			pair.second = pair.second->optimize();
	return this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0xac56
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xac50
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%r14)
addq $0x10, %r14
jmp 0xac38
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::AssignAccess::optimize()
Node* AssignAccess::optimize() {
	acs = dynamic_cast<Access*>(acs->optimize());
	if (acs == nullptr)
		throw std::runtime_error("optimizer error");

	val = val->optimize();
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
je 0xace0
leaq 0x148db(%rip), %rsi     # 0x1f588
leaq 0x14a04(%rip), %rdx     # 0x1f6b8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53e0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xace5
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
andq $0x0, 0x8(%rbx)
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x9e29(%rip), %rsi      # 0x14b20
movq %rax, %rdi
callq 0x5120
movq 0x152ea(%rip), %rsi     # 0x1fff0
movq 0x1529b(%rip), %rdx     # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::For::optimize()
Node* For::optimize() {
	if (init) init = init->optimize();
	cond = cond->optimize();
	if (inc) inc = inc->optimize();
	body = body->optimize();
	return this;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xad77
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xad98
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::Map::optimize()
Node* Map::optimize() {
	// TODO: doppelte entfernen und funktioniert das mit den Referenzen?
	for (auto& pair : values) {
		pair.first = pair.first->optimize();
		pair.second = pair.second->optimize();
	}
	return this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0xae1f
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, (%r14)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%r14)
addq $0x10, %r14
jmp 0xadfa
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::Call::optimize()
Node* Call::optimize() {
	callable = callable->optimize();
	for (auto it = args.begin(); it != args.end(); ++it)
		*it = (*it)->optimize();

	return this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0xae97
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, (%r14)
addq $0x8, %r14
jmp 0xae7f
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/mem.cc
// Function: asbi::GCObj::GCObj(asbi::Context*, bool)
asbi::GCObj::GCObj(Context* ctx, bool gc){
	gc_inuse = false;
	gc_manage = gc;
	if (gc_manage) {
		this->gc_next = ctx->heap_head;
		ctx->heap_head = this;
	}
}

// Assembly:
leaq 0x148f9(%rip), %rax     # 0x1f9b0
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb %dl, 0x11(%rdi)
testl %edx, %edx
je 0xb0dc
movq 0x300(%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdi, 0x300(%rsi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/mem.cc
// Function: asbi::Context::check_gc(std::shared_ptr<asbi::Env>)
void asbi::Context::check_gc(std::shared_ptr<Env> env){
	// TODO: heap_size und heap_max
	if (heap_size >= heap_max) {
		gc(env);
		heap_max = heap_size * 2;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq 0x308(%rdi), %rax
cmpq 0x310(%rdi), %rax
jb 0xb163
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x6356
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb180
leaq 0x10(%rsp), %rdi
callq 0x638a
movq 0x308(%rbx), %rax
addq %rax, %rax
movq %rax, 0x310(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x638a
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/mem.cc
// Function: asbi::Context::gc(std::shared_ptr<asbi::Env>)
void asbi::Context::gc(std::shared_ptr<Env> env){
	// std::cerr << "===ASBI===: GC running..." << '\n';

	if (env != nullptr)
		env->gc_visit();

	for (auto elm: stack)
		elm.gc_visit();

	auto p = &heap_head;
	while (*p != nullptr) {
		auto obj = *p;
		// assert(obj->gc_manage); //
		if (!obj->gc_inuse && obj->gc_manage) {
			*p = obj->gc_next;
			heap_size -= obj->gc_size();
			delete obj;
		} else {
			obj->gc_inuse = false;
			p = &obj->gc_next;
		}
	}

	if (env != nullptr)
		env->gc_unvisit();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xb1a0
callq 0xeab2
movq 0x508(%r14), %r12
movq 0x510(%r14), %r13
movq %rsp, %r15
cmpq %r13, %r12
je 0xb1cd
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq 0xd8d6
addq $0x10, %r12
jmp 0xb1b1
leaq 0x300(%r14), %r12
movq (%r12), %r15
testq %r15, %r15
je 0xb21c
cmpb $0x0, 0x10(%r15)
jne 0xb20e
cmpb $0x1, 0x11(%r15)
jne 0xb20e
movq 0x8(%r15), %rax
movq %rax, (%r12)
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
subq %rax, 0x308(%r14)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0xb1d4
movb $0x0, 0x10(%r15)
addq $0x8, %r15
movq %r15, %r12
jmp 0xb1d4
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xb229
callq 0xeb1a
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::Bool::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Bool::to_vmops(Context*, std::vector<OpCode> &ops) const {
	if (value)
		ops.push_back(OpCode::PUSH_TRUE);
	else
		ops.push_back(OpCode::PUSH_FALSE);
}

// Assembly:
pushq %rax
cmpb $0x1, 0x8(%rdi)
jne 0xc23b
movq %rsp, %rsi
movq $0x2, (%rsi)
jmp 0xc245
movq %rsp, %rsi
movq $0x3, (%rsi)
movq %rdx, %rdi
callq 0xd2e0
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::Lambda::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Lambda::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	ops.push_back(OpCode::PUSH_LAMBDA);
	auto lambdaops = new std::vector<OpCode>();
	body->to_vmops(ctx, *lambdaops);
	auto lc = new LambdaContainer(nullptr, lambdaops, argnames, ctx, false);
	ctx->lambdas.push_back(lc);
	ops.push_back(*reinterpret_cast<const OpCode*>(&lc));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r13
leaq 0x10(%rsp), %rsi
movq $0x7, (%rsi)
movq %rdx, %rdi
callq 0xd2e0
pushq $0x18
popq %rdi
callq 0x5390
movq %rax, %r12
andq $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq 0x20(%r13), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r12, %rdx
callq *0x18(%rax)
pushq $0x48
popq %rdi
callq 0x5390
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
addq $0x8, %r13
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x9684
movq %rsp, %rsi
leaq 0x18(%rsp), %rcx
movq %r15, %rdi
movq %r12, %rdx
movq %r14, %r8
xorl %r9d, %r9d
callq 0xd722
leaq 0x18(%rsp), %rdi
callq 0x96d2
leaq 0x8(%rsp), %rdi
callq 0x638a
leaq 0x10(%rsp), %r12
movq %r15, (%r12)
addq $0x520, %r14            # imm = 0x520
movq %r14, %rdi
movq %r12, %rsi
callq 0xd2c2
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2a2
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x96d2
jmp 0xc3b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x638a
pushq $0x48
popq %rsi
movq %r15, %rdi
callq 0x53a0
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::PrefxOperator::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void PrefxOperator::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	switch (type) {
	case PrefxOperator::Neg:{
		ops.push_back(OpCode::PUSH_NUMBER);
		assert(sizeof(double) == sizeof(OpCode));
		double flt = 0.0;
		ops.push_back(*reinterpret_cast<const OpCode*>(&flt));
		operand->to_vmops(ctx, ops);
		ops.push_back(OpCode::SUB);
		return;
	}
	case PrefxOperator::Not:{
		operand->to_vmops(ctx, ops);
		ops.push_back(OpCode::NOT);
		return;
	}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0xc7c5
cmpl $0x1, %eax
jne 0xc7e9
leaq 0x8(%rsp), %r12
andq $0x0, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
andq $0x0, (%r12)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xd2a2
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
leaq 0x10(%rsp), %rsi
movq $0x11, (%rsi)
jmp 0xc7e1
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
leaq 0x8(%rsp), %rsi
movq $0x1a, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::VariableDecl::~VariableDecl()
VariableDecl::~VariableDecl() {
	for (auto [var, val] : decls) {
		delete var;
		if (val != nullptr)
			delete val;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
leaq 0x131eb(%rip), %rax     # 0x1f9f0
movq %rax, (%rdi)
leaq 0x8(%rdi), %rbx
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0xc83f
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %rdi, %rdi
je 0xc82b
movq (%rdi), %rax
callq *0x8(%rax)
testq %r14, %r14
je 0xc839
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x10, %r15
jmp 0xc814
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x9500
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::VariableDecl::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void VariableDecl::to_vmops(asbi::Context* ctx, std::vector<asbi::OpCode> &ops) const {
	for (auto [var, val]: decls) {
		if (val == nullptr)
			ops.push_back(OpCode::PUSH_NIL);
		else
			val->to_vmops(ctx, ops);

		ops.push_back(OpCode::DECL);
		ops.push_back(*reinterpret_cast<const OpCode*>(&var->sc));
		ops.push_back(OpCode::POP);
	}
	ops.push_back(OpCode::PUSH_NIL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rbp
movq %rsp, %r15
cmpq %rbp, %r13
je 0xc8f2
movq (%r13), %r12
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xc8a4
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xc8b7
movq $0x4, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
movq $0xe, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
addq $0x8, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2a2
movq $0x9, (%rsp)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
addq $0x10, %r13
jmp 0xc884
movq %rsp, %rsi
movq $0x4, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::DestructList::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void DestructList::to_vmops(asbi::Context *ctx, std::vector<asbi::OpCode> &ops) const {
	for (auto rit = lhss.rbegin(); rit != lhss.rend(); ++rit) {
		if (auto var = dynamic_cast<ast::Variable*>(*rit); var != nullptr) {
			ops.push_back(OpCode::PUSH_STACK_PLACEHOLDER);
			ops.push_back(*reinterpret_cast<const OpCode*>(&var->sc));
		} else {
			(*rit)->to_vmops(ctx, ops);
		}
	}
	rhs->to_vmops(ctx, ops);
	ops.push_back(OpCode::DESTRUCT_ARRLIKE);
	ops.push_back(static_cast<OpCode>(lhss.size()));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %r13
cmpq 0x8(%r14), %r13
je 0xca07
movq -0x8(%r13), %rbp
addq $-0x8, %r13
testq %rbp, %rbp
je 0xc9f5
movq %rbp, %rdi
leaq 0x12bcd(%rip), %rsi     # 0x1f588
leaq 0x12cae(%rip), %rdx     # 0x1f670
xorl %ecx, %ecx
callq 0x53e0
testq %rax, %rax
je 0xc9f5
movq %rax, %r12
movq $0x8, (%rsp)
movq %rbx, %rdi
movq %rsp, %rsi
callq 0xd2e0
addq $0x8, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2a2
jmp 0xc99e
movq (%rbp), %rax
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xc99e
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rsp, %r15
movq $0x1f, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
movq %rax, (%r15)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::If::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void If::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	cond->to_vmops(ctx, ops);
	ops.push_back(OpCode::IF_TRUE_GOTO);
	ops.push_back(OpCode::NOOP);
	auto pos1 = ops.size() - 1;
	ops.push_back(OpCode::ENTER_SCOPE);
	if (elsebody)
		elsebody->to_vmops(ctx, ops);
	else
		ops.push_back(OpCode::PUSH_NIL);
	ops.push_back(OpCode::LEAVE_SCOPE);
	ops.push_back(OpCode::GOTO);
	ops.push_back(OpCode::NOOP);
	auto pos2 = ops.size() - 1;
	*(ops.data() + pos1) = static_cast<OpCode>(ops.size());
	ops.push_back(OpCode::ENTER_SCOPE);
	ifbody->to_vmops(ctx, ops);
	ops.push_back(OpCode::LEAVE_SCOPE);
	*(ops.data() + pos2) = static_cast<OpCode>(ops.size());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rsp, %r12
movq $0x21, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq $0x23, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq (%rbx), %rbp
movq 0x8(%rbx), %r13
movq $0xa, (%r12)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xcb43
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xcb55
movq %rsp, %rsi
movq $0x4, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
subq %rbp, %r13
pushq $0xb
popq %rax
movq %rsp, %r12
movq %rax, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq $0x20, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq $0x23, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq (%rbx), %rax
movq 0x8(%rbx), %rbp
subq %rax, %rbp
movq %rbp, %rcx
sarq $0x3, %rcx
movq %rcx, -0x8(%rax,%r13)
movq $0xa, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
pushq $0xb
popq %rax
movq %rax, (%r12)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, -0x8(%rax,%rbp)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::If::~If()
If::~If() {
	delete cond;
	delete ifbody;
	if (elsebody != nullptr)
		delete elsebody;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x12e3b(%rip), %rax     # 0x1fa50
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xcc27
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xcc36
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xcc46
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::For::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void For::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	if (init) {
		init->to_vmops(ctx, ops);
		ops.push_back(OpCode::POP);
	}

	auto pos1 = ops.size();
	cond->to_vmops(ctx, ops);
	ops.push_back(OpCode::IF_FALSE_GOTO);
	ops.push_back(OpCode::NOOP);
	auto pos2 = ops.size() - 1;

	ops.push_back(OpCode::ENTER_SCOPE);
	body->to_vmops(ctx, ops);
	ops.push_back(OpCode::LEAVE_SCOPE);
	ops.push_back(OpCode::POP);

	if (inc) {
		inc->to_vmops(ctx, ops);
		ops.push_back(OpCode::POP);
	}

	ops.push_back(OpCode::GOTO);
	ops.push_back(static_cast<OpCode>(pos1));
	*(ops.data() + pos2) = static_cast<OpCode>(ops.size());
	ops.push_back(OpCode::PUSH_NIL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xcc9c
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rsp, %rsi
movq $0x9, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
movq (%rbx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rbx), %r13
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rsp, %r12
movq $0x22, (%r12)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq $0x23, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq (%rbx), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rbp
movq $0xa, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq 0x20(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0xb, (%r12)
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
movq $0x9, (%r12)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
movq 0x18(%r15), %rdi
testq %rdi, %rdi
je 0xcd66
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rsp, %rsi
movq $0x9, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
subq 0x8(%rsp), %rbp
subq 0x10(%rsp), %r13
sarq $0x3, %r13
movq %rsp, %r14
movq $0x20, (%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2e0
movq %r13, (%r14)
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd2e0
movq (%rbx), %rax
movq 0x8(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movq %rcx, -0x8(%rax,%rbp)
movq $0x4, (%r14)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::For::~For()
For::~For() {
	if (init)
		delete init;
	delete cond;
	if (inc)
		delete inc;
	delete body;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x12ca7(%rip), %rax     # 0x1fa80
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xcdeb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xcdfa
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xce09
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xce19
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::Block::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Block::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	int n = exprs.size();
	if (n == 0) {
		ops.push_back(OpCode::PUSH_NIL);
		return;
	}

	for (int i = 0; i < n - 1; i++) {
		exprs[i]->to_vmops(ctx, ops);
		ops.push_back(OpCode::POP);
	}
	exprs[n - 1]->to_vmops(ctx, ops);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
shrq $0x3, %rax
testl %eax, %eax
je 0xcec5
movq %rsi, %r14
movq %rdi, %r15
decl %eax
xorl %ebp, %ebp
testl %eax, %eax
movl $0x0, %r13d
movq %rax, 0x10(%rsp)
cmovgl %eax, %r13d
shlq $0x3, %r13
leaq 0x8(%rsp), %r12
cmpq %rbp, %r13
je 0xceaa
movq 0x8(%r15), %rax
movq (%rax,%rbp), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x9, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0xd2e0
addq $0x8, %rbp
jmp 0xce77
movslq 0x10(%rsp), %rax
movq 0x8(%r15), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xced9
leaq 0x8(%rsp), %rsi
movq $0x4, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq