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

	if (t == tok::Semicolon) {
		tokenizer.next();
		return node;
	}

	throw utils::parser_error("expected ';' or EOF", tokenizer.peek());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x8262
movq %rax, %rbx
movq %r14, %rdi
callq 0x69d4
cmpl $0x25, %eax
je 0x81fd
cmpl $0x1e, %eax
jne 0x8208
movq %r14, %rdi
callq 0x69fe
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
movq %r14, %rdi
callq 0x69d4
movq %rdx, %rcx
leaq 0xf4de(%rip), %rsi      # 0x17705
movq %rbx, %rdi
movq %rax, %rdx
callq 0xa896
leaq 0x1833f(%rip), %rsi     # 0x20578
leaq 0x1c40(%rip), %rdx      # 0x9e80
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69d4
cmpl $0x24, %eax
je 0x82e3
cmpl $0x22, %eax
jne 0x836c
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x8428
movq %rax, %r14
movq %rbx, %rdi
movl $0x19, %esi
callq 0x8044
movq %rbx, %rdi
callq 0x88da
movq %rax, %r12
movq %rbx, %rdi
callq 0x69d4
cmpl $0x23, %eax
jne 0x837d
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x69d4
cmpl $0x22, %eax
jne 0x83c2
movq %rbx, %rdi
callq 0x8262
jmp 0x83d7
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x8428
movq %rax, %r14
movq %rbx, %rdi
callq 0x69d4
movq %rbx, %rdi
cmpl $0x1e, %eax
jne 0x8381
callq 0x69fe
movq %rbx, %rdi
callq 0x8428
movq %rax, %r12
movq %rbx, %rdi
movl $0x1e, %esi
callq 0x8044
movq %rbx, %rdi
callq 0x8428
movq %rax, %r13
movq %rbx, %rdi
movl $0x19, %esi
callq 0x8044
movl $0x28, %edi
callq 0x5380
movq %rax, %r15
movq %rbx, %rdi
callq 0x88da
leaq 0x18721(%rip), %rcx     # 0x20a78
addq $0x10, %rcx
movq %rcx, (%r15)
movq %r14, 0x8(%r15)
movq %r12, 0x10(%r15)
movq %r13, 0x18(%r15)
jmp 0x83bc
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x8428
xorl %ebx, %ebx
jmp 0x83da
movl $0x19, %esi
callq 0x8044
movl $0x28, %edi
callq 0x5380
movq %rax, %r15
movq %rbx, %rdi
callq 0x88da
leaq 0x186d1(%rip), %rcx     # 0x20a78
addq $0x10, %rcx
movq %rcx, (%r15)
xorl %ecx, %ecx
movq %rcx, 0x8(%r15)
movq %r14, 0x10(%r15)
movq %rcx, 0x18(%r15)
movq %rax, 0x20(%r15)
jmp 0x8401
movq %rbx, %rdi
movl $0x19, %esi
callq 0x8044
movq %rbx, %rdi
callq 0x88da
movq %rax, %rbx
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
leaq 0x1865a(%rip), %rax     # 0x20a48
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 0x8410
movq %rax, %rbx
movl $0x28, %esi
movq %r15, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8bba
movq %rax, %r14
movq %rbx, %rdi
callq 0x69d4
leal -0x15(%rax), %ecx
cmpl $0x1, %ecx
ja 0x8ba4
leaq 0x17b87(%rip), %r13     # 0x206d8
addq $0x10, %r13
xorl %ebp, %ebp
cmpl $0x15, %eax
sete %bpl
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x8bba
movq %rax, %r12
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
movq %r13, (%rax)
orl $0x4, %ebp
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
callq 0x69d4
leal -0x15(%rax), %ecx
movq %r15, %r14
cmpl $0x2, %ecx
jb 0x8b55
jmp 0x8ba7
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8c6e
movq %rax, %r14
movq %rbx, %rdi
callq 0x69d4
movq %rax, %r15
addl $-0xe, %eax
cmpl $0x5, %eax
ja 0x8c58
leaq 0x17aee(%rip), %rbp     # 0x206d8
addq $0x10, %rbp
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x8c6e
movq %rax, %r13
movl $0x20, %edi
callq 0x5380
movq %rax, %r12
movq %rbp, (%rax)
shlq $0x20, %r15
movabsq $-0xe00000000, %rax     # imm = 0xFFFFFFF200000000
addq %rax, %r15
sarq $0x1e, %r15
leaq 0xeaaf(%rip), %rax      # 0x176dc
movl (%r15,%rax), %eax
movl %eax, 0x8(%r12)
movq %r14, 0x10(%r12)
movq %r13, 0x18(%r12)
movq %rbx, %rdi
callq 0x69d4
movq %rax, %r15
addl $-0xe, %eax
movq %r12, %r14
cmpl $0x6, %eax
jb 0x8bee
jmp 0x8c5b
movq %r14, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d04
movq %rax, %r14
movq %rbx, %rdi
callq 0x69d4
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x8, %ecx
jne 0x8cef
leaq 0x17a3b(%rip), %r13     # 0x206d8
addq $0x10, %r13
xorl %ebp, %ebp
cmpl $0x8, %eax
setne %bpl
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x8d04
movq %rax, %r12
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
movq %r13, (%rax)
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
callq 0x69d4
movl %eax, %ecx
andl $-0x2, %ecx
movq %r15, %r14
cmpl $0x8, %ecx
je 0x8ca1
jmp 0x8cf2
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8d9e
movq %rax, %r14
movq %rbx, %rdi
callq 0x69d4
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0xa, %ecx
jne 0x8d88
leaq 0x179a5(%rip), %r13     # 0x206d8
addq $0x10, %r13
xorl %ebp, %ebp
cmpl $0xa, %eax
sete %bpl
movq %rbx, %rdi
callq 0x69fe
movq %rbx, %rdi
callq 0x8d9e
movq %rax, %r12
movl $0x20, %edi
callq 0x5380
movq %rax, %r15
movq %r13, (%rax)
xorl $0x3, %ebp
movl %ebp, 0x8(%rax)
movq %r14, 0x10(%rax)
movq %r12, 0x18(%rax)
movq %rbx, %rdi
callq 0x69d4
movl %eax, %ecx
andl $-0x2, %ecx
movq %r15, %r14
cmpl $0xa, %ecx
je 0x8d37
jmp 0x8d8b
movq %r14, %r15
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69d4
cmpl $0x14, %eax
je 0x8de8
cmpl $0x9, %eax
jne 0x8e29
movq %r14, %rdi
callq 0x69fe
movl $0x18, %edi
callq 0x5380
movq %rax, %rbx
movq %r14, %rdi
callq 0x8e52
leaq 0x17948(%rip), %rcx     # 0x20720
addq $0x10, %rcx
movq %rcx, (%rbx)
movl $0x1, 0x8(%rbx)
jmp 0x8e1a
movq %r14, %rdi
callq 0x69fe
movl $0x18, %edi
callq 0x5380
movq %rax, %rbx
movq %r14, %rdi
callq 0x8e52
leaq 0x17914(%rip), %rcx     # 0x20720
addq $0x10, %rcx
movq %rcx, (%rbx)
movl $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 0x8e52
jmp 0x8e3a
movq %rax, %r14
movl $0x18, %esi
movq %rbx, %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x69d4
cmpl $0x18, %eax
jne 0x991c
movq %rbx, %rdi
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x69fe
movq %rbx, %rdi
callq 0x8262
leaq 0x8(%rsp), %r15
movq %rax, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xa198
movq %rbx, %rdi
callq 0x69fe
movq %rax, %r12
cmpl $0x1d, %r12d
jne 0x9957
movq %rbx, %rdi
callq 0x8262
movq %rax, 0x8(%rsp)
jmp 0x992c
cmpl $0x18, %r12d
jne 0x996b
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rdx, %r13
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xdf32(%rip), %rsi      # 0x178b4
movq %rax, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa896
leaq 0x16be1(%rip), %rsi     # 0x20578
leaq 0x4e2(%rip), %rdx       # 0x9e80
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
callq 0x8262
leaq 0x18(%rsp), %rdx
movq %r14, (%rdx)
movq %rax, 0x8(%rdx)
movq %rsp, %rdi
xorl %esi, %esi
callq 0xa5b2
movq %rbx, %rdi
callq 0x69fe
movq %rax, %r12
movq %rdx, %r13
movq %rsp, %r14
leaq 0x18(%rsp), %r15
cmpl $0x1d, %r12d
jne 0x9d53
movq %rbx, %rdi
callq 0x8262
movq %rax, %r12
movq %rbx, %rdi
movl $0xd, %esi
callq 0x8044
movq %rbx, %rdi
callq 0x8262
movq %r12, 0x18(%rsp)
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rsi
cmpq 0x10(%rsp), %rsi
je 0x9d38
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x8(%rsp)
jmp 0x9d43
movq %r14, %rdi
movq %r15, %rdx
callq 0xa5b2
movq %rbx, %rdi
callq 0x69fe
movq %rax, %r12
movq %rdx, %r13
jmp 0x9cec
cmpl $0x1c, %r12d
jne 0x9de7
movl $0x20, %edi
callq 0x5380
movq %rax, %rbx
movq (%rsp), %rax
leaq 0x28(%rsp), %rsi
movq %rax, (%rsi)
movups 0x8(%rsp), %xmm0
movups %xmm0, 0x8(%rsi)
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x16d42(%rip), %rax     # 0x20ad8
addq $0x10, %rax
movq %rax, (%rbx)
movq %rbx, %rdi
addq $0x8, %rdi
callq 0xa04c
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x9dc0
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9dd6
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movl $0x48, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xda7f(%rip), %rsi      # 0x1787a
movq %rax, %rdi
movq %r12, %rdx
movq %r13, %rcx
callq 0xa896
leaq 0x16768(%rip), %rsi     # 0x20578
leaq 0x69(%rip), %rdx        # 0x9e80
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x9e39
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movl $0x20, %esi
movq %rbx, %rdi
callq 0x5390
jmp 0x9e62
jmp 0x9e5f
jmp 0x9e5f
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0x9e62
jmp 0x9e5f
jmp 0x9e5f
jmp 0x9e5f
movq %rax, %r14
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x9e78
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebp
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5620
leaq 0x15e63(%rip), %rax     # 0x20560
movq %rax, (%rbx)
movl %r15d, 0x10(%rbx)
movb %bpl, 0x14(%rbx)
leaq 0x18(%rbx), %r14
leaq 0x28(%rbx), %rax
movq %rax, (%rsp)
movq %rax, 0x18(%rbx)
leaq 0xd222(%rip), %rsi      # 0x17941
leaq 0xd22b(%rip), %rdx      # 0x17951
movq %r14, %rdi
callq 0x6646
movq %r14, %rdi
movq %r12, %rsi
callq 0x5630
leaq 0xd212(%rip), %rsi      # 0x17952
movq %r14, %rdi
callq 0x5630
movl %r15d, %r12d
negl %r12d
cmovsl %r15d, %r12d
movl $0x1, %r13d
cmpl $0xa, %r12d
jb 0xa7a8
movl $0x4, %r13d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r12d, %ecx
cmpl $0x63, %ecx
jbe 0xa79f
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0xa7a5
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0xa7a8
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r13d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0xa76c
addl $-0x3, %r13d
jmp 0xa7a8
addl $-0x2, %r13d
jmp 0xa7a8
decl %r13d
shrl $0x1f, %r15d
leal (%r15,%r13), %esi
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x8(%rsp), %rdi
movl $0x2d, %edx
callq 0x5410
movl %r15d, %edi
addq 0x8(%rsp), %rdi
movl %r13d, %esi
movl %r12d, %edx
callq 0x7b1f
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x50e0
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa809
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0xd14b(%rip), %rsi      # 0x1795b
movq %r14, %rdi
callq 0x5630
movsbl %bpl, %esi
movq %r14, %rdi
callq 0x5300
leaq 0xd134(%rip), %rsi      # 0x1795f
movq %r14, %rdi
callq 0x5630
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0xa86d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0xa86d
jmp 0xa86a
movq %rax, %r15
jmp 0xa885
movq %rax, %r15
movq (%r14), %rdi
cmpq (%rsp), %rdi
je 0xa885
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
callq 0x5620
leaq 0x15cf4(%rip), %rax     # 0x205b0
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
movq %r12, 0x18(%rbx)
movq $0x0, 0x20(%rbx)
leaq 0x28(%rbx), %r14
leaq 0x38(%rbx), %rbp
movq %rbp, 0x28(%rbx)
leaq 0xd080(%rip), %rsi      # 0x17962
leaq 0xd086(%rip), %rdx      # 0x1796f
movq %r14, %rdi
callq 0x6646
movq %r14, %rdi
movq %r13, %rsi
callq 0x5630
leaq 0xd06d(%rip), %rsi      # 0x17970
movq %r14, %rdi
callq 0x5630
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x6f95
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x50e0
leaq 0x18(%rsp), %r13
movq -0x10(%r13), %rdi
cmpq %r13, %rdi
je 0xa948
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0xd030(%rip), %rsi      # 0x1797f
movq %r14, %rdi
callq 0x5630
movq %r15, %r12
shrq $0x20, %r12
shrq $0x21, %r15
movl $0x1, %eax
cmpl $0x5, %r15d
jb 0xa9b2
movl $0x4, %eax
movl $0xd1b71759, %ecx       # imm = 0xD1B71759
movl %r12d, %edx
cmpl $0x63, %edx
jbe 0xa9ab
cmpl $0x3e7, %edx            # imm = 0x3E7
jbe 0xa9b0
cmpl $0x2710, %edx           # imm = 0x2710
jb 0xa9b2
movl %edx, %esi
imulq %rcx, %rsi
shrq $0x2d, %rsi
addl $0x4, %eax
cmpl $0x1869f, %edx          # imm = 0x1869F
movl %esi, %edx
ja 0xa97a
addl $-0x3, %eax
jmp 0xa9b2
addl $-0x2, %eax
jmp 0xa9b2
decl %eax
movl %eax, %esi
leaq 0x8(%rsp), %rdi
movq %r13, (%rdi)
xorl %edx, %edx
callq 0x5410
movq 0x8(%rsp), %rdi
movl 0x10(%rsp), %esi
movl %r12d, %edx
callq 0x7b1f
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x50e0
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0xa9fd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0xca87(%rip), %rsi      # 0x1748b
movq %r14, %rdi
callq 0x5630
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
jne 0xaa3d
jmp 0xaa56
jmp 0xaa53
movq %rax, %r15
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaa56
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0xaa56
jmp 0xaa53
movq %rax, %r15
jmp 0xaa6a
movq %rax, %r15
movq (%r14), %rdi
cmpq %rbp, %rdi
je 0xaa6a
movq (%rbp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5620
leaq 0x15b19(%rip), %rax     # 0x205b0
movq %rax, (%rbx)
movq $0x25, 0x10(%rbx)
movl $0x0, 0x18(%rbx)
movq %r15, 0x20(%rbx)
leaq 0x28(%rbx), %r15
leaq 0x38(%rbx), %r12
movq %r12, 0x28(%rbx)
leaq 0xcea2(%rip), %rsi      # 0x17962
leaq 0xcea8(%rip), %rdx      # 0x1796f
movq %r15, %rdi
callq 0x6646
movq %r15, %rdi
movq %r14, %rsi
callq 0x5630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xab02
movq (%r12), %rsi
incq %rsi
callq 0x5390
jmp 0xab02
movq %rax, %r14
movq %rbx, %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5620
leaq 0x15aa8(%rip), %rax     # 0x205d8
movq %rax, (%rbx)
leaq 0x10(%rbx), %r14
leaq 0x20(%rbx), %r13
movq %r13, 0x10(%rbx)
leaq 0xce42(%rip), %rsi      # 0x17988
leaq 0xce49(%rip), %rdx      # 0x17996
movq %r14, %rdi
callq 0x6646
movq %r14, %rdi
movq %r12, %rsi
callq 0x5630
leaq 0xce30(%rip), %rsi      # 0x17997
movq %r14, %rdi
callq 0x5630
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x50e0
leaq 0xc906(%rip), %rsi      # 0x1748b
movq %r14, %rdi
callq 0x5630
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0xabb3
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0xabb3
movq (%r13), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/utils.cc
// Function: utils::type_error::type_error(char const*, ast::Node const*)
type_error::type_error(const char* msg, const ast::Node* node):
		std::runtime_error(msg), node(node), what_message("TypeError: ") {
		what_message += msg;
		/*what_message += " (near ast node: ";
		node->to_string(what_message);
		what_message += ")";*/
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5620
leaq 0x15a1f(%rip), %rax     # 0x20600
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
leaq 0x18(%rbx), %r15
leaq 0x28(%rbx), %r12
movq %r12, 0x18(%rbx)
leaq 0xcd9f(%rip), %rsi      # 0x1799a
leaq 0xcda3(%rip), %rdx      # 0x179a5
movq %r15, %rdi
callq 0x6646
movq %r15, %rdi
movq %r14, %rsi
callq 0x5630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xac3d
movq (%r12), %rsi
incq %rsi
callq 0x5390
jmp 0xac3d
movq %rax, %r14
movq %rbx, %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xccbd(%rip), %rsi      # 0x179a6
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x5640
cmpq $-0x1, %rax
je 0xad15
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x53b0
jmp 0xad32
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xc411(%rip), %rsi      # 0x17134
leaq 0xc40b(%rip), %rdx      # 0x17135
movq %rbx, %rdi
callq 0x6646
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rsp, %rsi
callq 0x5110
testq %rax, %rax
je 0xad89
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x5180
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6646
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xcc0b(%rip), %rsi      # 0x179a8
movq %rax, %rdi
callq 0x5150
movq 0x16244(%rip), %rsi     # 0x20ff0
movq 0x161fd(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %rsi
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x5570
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x40(%rsp,%rax)
jne 0xae5b
movq 0x108(%rsp,%rax), %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq $0x0, 0x10(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xb0b0
leaq 0x20(%rsp), %rdi
callq 0x5090
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xcb4e(%rip), %rsi      # 0x179bd
movq %rax, %rdi
callq 0x5150
movq 0x16172(%rip), %rsi     # 0x20ff0
movq 0x1612b(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0xae9d
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5090
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xba25
testq %rax, %rax
je 0xba7f
leaq 0x14bb3(%rip), %rsi     # 0x20590
leaq 0x14ed4(%rip), %rdx     # 0x208b8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53f0
testq %rax, %rax
je 0xba7f
movb 0x8(%rax), %bpl
xorb $0x1, %bpl
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl $0x10, %edi
callq 0x5380
movq %rax, %rbx
leaq 0x14e7c(%rip), %rax     # 0x20898
movq %rax, (%rbx)
movb %bpl, 0x8(%rbx)
jmp 0xba7f
testq %rax, %rax
je 0xba7f
leaq 0x14b5f(%rip), %rsi     # 0x20590
leaq 0x14e38(%rip), %rdx     # 0x20870
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53f0
testq %rax, %rax
je 0xba7f
movsd 0x8(%rax), %xmm0
xorps 0xc0ad(%rip), %xmm0     # 0x17b00
movaps %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl $0x10, %edi
callq 0x5380
movq %rax, %rbx
leaq 0x14ddc(%rip), %rax     # 0x20850
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_O3/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 0xbab8
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbab2
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%r14)
addq $0x10, %r14
jmp 0xba9a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbb42
leaq 0x14a81(%rip), %rsi     # 0x20590
leaq 0x14baa(%rip), %rdx     # 0x206c0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53f0
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xbb4a
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
movq $0x0, 0x8(%rbx)
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xbfb2(%rip), %rsi      # 0x17b10
movq %rax, %rdi
callq 0x5150
movq 0x15483(%rip), %rsi     # 0x20ff0
movq 0x1543c(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbbdf
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 0xbc00
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_O3/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 0xbc8b
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 0xbc66
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xbd03
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, (%r14)
addq $0x8, %r14
jmp 0xbceb
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x149d1(%rip), %rax     # 0x209b8
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb %dl, 0x11(%rdi)
testl %edx, %edx
je 0xc00f
movq 0x300(%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdi, 0x300(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq 0x308(%rdi), %rax
cmpq 0x310(%rdi), %rax
jb 0xc0b7
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xc08c
movq 0x14f3a(%rip), %rcx     # 0x20fb8
cmpb $0x0, (%rcx)
je 0xc088
incl 0x8(%rax)
jmp 0xc08c
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc0d8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc0a6
callq 0x65d6
movq 0x308(%rbx), %rax
addq %rax, %rax
movq %rax, 0x310(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc0cf
callq 0x65d6
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc0f8
callq 0x1083c
movq 0x508(%r14), %r12
movq 0x510(%r14), %r13
cmpq %r13, %r12
je 0xc128
movq %rsp, %r15
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq 0xf34c
addq $0x10, %r12
cmpq %r13, %r12
jne 0xc10e
movq 0x300(%r14), %r15
testq %r15, %r15
je 0xc181
leaq 0x300(%r14), %r12
cmpb $0x0, 0x10(%r15)
jne 0xc16c
cmpb $0x1, 0x11(%r15)
jne 0xc16c
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 0xc178
movb $0x0, 0x10(%r15)
addq $0x8, %r15
movq %r15, %r12
movq (%r12), %r15
testq %r15, %r15
jne 0xc13b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc18e
callq 0x108a8
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xd39e
movq $0x2, (%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0xd3c1
movq $0x2, (%rsi)
jmp 0xd3b7
movq $0x3, (%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0xd3c1
movq $0x3, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdx)
jmp 0xd3cf
movq %rsp, %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0xed48
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq $0x7, 0x8(%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0xd520
movq $0x7, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xd52d
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xed48
movl $0x18, %edi
callq 0x5380
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r13, %rdx
callq *0x18(%rax)
movl $0x48, %edi
callq 0x5380
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
addq $0x8, %r12
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xa0e0
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %r15, %rdi
movq %r13, %rdx
movq %r14, %r8
xorl %r9d, %r9d
callq 0xf150
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd5b1
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd5c0
callq 0x65d6
movq %r15, 0x8(%rsp)
movq 0x528(%r14), %rsi
cmpq 0x530(%r14), %rsi
je 0xd5e2
movq %r15, (%rsi)
addq $0x8, 0x528(%r14)
jmp 0xd5f6
addq $0x520, %r14            # imm = 0x520
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xef60
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xd612
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xd61f
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xee84
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd64c
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
jmp 0xd64c
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd65b
callq 0x65d6
movl $0x48, %esi
movq %r15, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0xdc6a
cmpl $0x1, %eax
jne 0xdd1b
movq $0x0, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xdc99
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdcac
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x1a, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdd10
movq $0x1a, (%rsi)
jmp 0xdcff
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq $0x0, (%rsp)
cmpq %rax, %rsi
je 0xdcca
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdcd5
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xee84
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x11, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdd09
movq $0x11, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdd1b
leaq 0x8(%rsp), %rdx
jmp 0xdd13
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %rbx
leaq 0x12cc0(%rip), %rax     # 0x209f8
movq %rax, (%rdi)
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r12
cmpq %r12, %r14
je 0xdd75
movq (%r14), %rdi
movq 0x8(%r14), %r15
testq %rdi, %rdi
je 0xdd5a
movq (%rdi), %rax
callq *0x8(%rax)
testq %r15, %r15
je 0xdd68
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
addq $0x10, %r14
cmpq %r12, %r14
jne 0xdd48
movq 0x8(%rbx), %r14
testq %r14, %r14
je 0xdd94
movq 0x18(%rbx), %rsi
subq %r14, %rsi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5390
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x8(%rdi), %r13
movq 0x10(%rdi), %rbp
cmpq %rbp, %r13
je 0xdec2
movq %rsi, %r14
movq %rsp, %r15
movq (%r13), %r12
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xddf8
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xde26
movq $0x4, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xde1b
movq $0x4, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xde26
movq %rbx, %rdi
movq %r15, %rdx
callq 0xed48
movq $0xe, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xde4c
movq $0xe, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xde5f
movq %rbx, %rdi
movq %r15, %rdx
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
addq $0x8, %r12
cmpq %rax, %rsi
je 0xde79
movq (%r12), %rcx
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xde8c
movq %rbx, %rdi
movq %r12, %rdx
callq 0xee84
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq $0x9, (%rsp)
cmpq %rax, %rsi
je 0xdeaa
movq $0x9, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdeb5
movq %rbx, %rdi
movq %r15, %rdx
callq 0xed48
addq $0x10, %r13
cmpq %rbp, %r13
jne 0xdddd
movq $0x4, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdee5
movq $0x4, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdef0
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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(%rdi), %r13
je 0xe0b3
movq -0x8(%r13), %r12
testq %r12, %r12
je 0xe05b
movq %r12, %rdi
leaq 0x12571(%rip), %rsi     # 0x20590
leaq 0x12652(%rip), %rdx     # 0x20678
xorl %ecx, %ecx
callq 0x53f0
testq %rax, %rax
je 0xe05b
movq %rax, %rbp
movq $0x8, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xe06d
movq $0x8, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe080
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xe0a5
movq %rbx, %rdi
movq %rsp, %rdx
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
addq $0x8, %rbp
cmpq %rax, %rsi
je 0xe09a
movq (%rbp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe0a5
movq %rbx, %rdi
movq %rbp, %rdx
callq 0xee84
addq $-0x8, %r13
cmpq 0x8(%r14), %r13
jne 0xe00c
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x1f, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xe0e9
movq $0x1f, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe0fc
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq 0x10(%r14), %rcx
subq 0x8(%r14), %rcx
sarq $0x3, %rcx
movq %rcx, (%rsp)
cmpq %rax, %rsi
je 0xe11e
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe129
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12649(%rip), %rax     # 0x20a58
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe421
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xe430
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe440
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0x12397(%rip), %rax     # 0x20a88
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe703
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xe712
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe721
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xe731
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop