LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::next_number()
Token Tokenizer::next_number() {
	std::string str = "";
	bool contains_dot = false;
	char c = source[pos];
	while (('0' <= c && c <= '9') || c == '.' || (c >= 'a' && c <= 'z')) {
		str += c;
		if (c == '.')
			contains_dot = true;
		if (++pos >= source.length())
			break;
		c = source[pos];
	}

	if (contains_dot)
		return Token(Real, std::stod(str, nullptr), line);
	else
		return Token(Int, std::stoi(str, nullptr, 0), line);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x4f(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x67b0
movq 0x28(%rsp), %rdx
leaq 0x2f043(%rip), %rsi     # 0x38104
leaq 0x50(%rsp), %rdi
callq 0x7c20
jmp 0x90cd
leaq 0x4f(%rsp), %rdi
callq 0x64c0
movq 0x20(%rsp), %rax
movb $0x0, 0x3b(%rsp)
movq 0x10(%rax), %rdi
movq (%rax), %rsi
callq 0x64e0
movb (%rax), %al
movb %al, 0x3a(%rsp)
movsbl 0x3a(%rsp), %ecx
movl $0x30, %eax
cmpl %ecx, %eax
jg 0x9111
movsbl 0x3a(%rsp), %ecx
movb $0x1, %al
cmpl $0x39, %ecx
movb %al, 0x1f(%rsp)
jle 0x9148
movsbl 0x3a(%rsp), %ecx
movb $0x1, %al
cmpl $0x2e, %ecx
movb %al, 0x1f(%rsp)
je 0x9148
movsbl 0x3a(%rsp), %ecx
xorl %eax, %eax
cmpl $0x61, %ecx
movb %al, 0x1e(%rsp)
jl 0x9140
movsbl 0x3a(%rsp), %eax
cmpl $0x7a, %eax
setle %al
movb %al, 0x1e(%rsp)
movb 0x1e(%rsp), %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x9155
jmp 0x91f9
movsbl 0x3a(%rsp), %esi
leaq 0x50(%rsp), %rdi
callq 0x62a0
jmp 0x9166
movsbl 0x3a(%rsp), %eax
cmpl $0x2e, %eax
jne 0x91b1
movb $0x1, 0x3b(%rsp)
jmp 0x91b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x4f(%rsp), %rdi
callq 0x64c0
jmp 0x9297
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6290
jmp 0x9297
movq 0x20(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movq %rcx, (%rax)
movq 0x10(%rax), %rdi
callq 0x66c0
movq %rax, %rcx
movq 0x10(%rsp), %rax
cmpq %rcx, %rax
jb 0x91dd
jmp 0x91f9
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rax), %rsi
callq 0x64e0
movb (%rax), %al
movb %al, 0x3a(%rsp)
jmp 0x90f3
testb $0x1, 0x3b(%rsp)
je 0x923f
xorl %eax, %eax
movl %eax, %esi
leaq 0x50(%rsp), %rdi
callq 0xba40
movsd %xmm0, 0x8(%rsp)
jmp 0x9216
movsd 0x8(%rsp), %xmm0
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x78(%rsp), %rdi
movl $0x2, %esi
callq 0xba80
jmp 0x9235
movl $0x1, 0x34(%rsp)
jmp 0x9278
xorl %edx, %edx
movl %edx, %esi
leaq 0x50(%rsp), %rdi
callq 0xbac0
movl %eax, 0x4(%rsp)
jmp 0x9253
movl 0x4(%rsp), %edx
movq 0x20(%rsp), %rax
movl 0x8(%rax), %ecx
leaq 0x78(%rsp), %rdi
movl $0x1, %esi
callq 0xb7e0
jmp 0x9270
movl $0x1, 0x34(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6290
movq 0x78(%rsp), %rax
movq 0x80(%rsp), %rdx
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/tokenizer.cc
// Function: tok::Tokenizer::peek()
Token Tokenizer::peek() {
	if (tokbuffed)
		return tokbuf;

	tokbuf = next();
	tokbuffed = true;
	return tokbuf;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x28(%rax)
je 0x92e2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x9326
movq 0x8(%rsp), %rdi
callq 0x9340
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
movq 0x10(%rsp), %rcx
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq %rcx, 0x20(%rax)
movb $0x1, 0x28(%rax)
movq 0x18(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x20(%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x30(%rsp), %rdx
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/parser.cc
// Function: asbi::Parser::parse()
ast::Node* Parser::parse() {
	std::vector<ast::Node*> parsed;
	while (tokenizer.peek().type != tok::EOFTok) {
		parsed.push_back(next());
	}

	return parsed.size() == 1 ? parsed[0] : new ast::Block(parsed);
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x90(%rsp), %rdi
callq 0x11ce0
movq 0x30(%rsp), %rdi
callq 0x92b0
movq %rdx, 0x20(%rsp)
movq %rax, 0x28(%rsp)
jmp 0xddbf
movq 0x20(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rcx, 0x80(%rsp)
movq %rax, 0x88(%rsp)
cmpl $0x25, 0x80(%rsp)
je 0xde27
movq 0x30(%rsp), %rdi
callq 0xdf60
movq %rax, 0x18(%rsp)
jmp 0xddf4
movq 0x18(%rsp), %rax
movq %rax, 0x68(%rsp)
leaq 0x90(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x11cf0
jmp 0xde12
jmp 0xdda9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xdf42
leaq 0x90(%rsp), %rdi
callq 0x11d20
movb $0x0, 0x5f(%rsp)
movb $0x0, 0x3f(%rsp)
cmpq $0x1, %rax
jne 0xde5f
leaq 0x90(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11d40
movq (%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xdeb8
movl $0x20, %edi
callq 0x6460
movq %rax, 0x8(%rsp)
jmp 0xde70
movq 0x8(%rsp), %rax
movq %rax, 0x60(%rsp)
movb $0x1, 0x5f(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x90(%rsp), %rsi
callq 0x11d60
jmp 0xde93
movq 0x8(%rsp), %rdi
movb $0x1, 0x3f(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x11e60
jmp 0xdea9
movq 0x8(%rsp), %rax
movb $0x0, 0x5f(%rsp)
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0xb0(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0xdece
jmp 0xded8
leaq 0x40(%rsp), %rdi
callq 0x11ed0
leaq 0x90(%rsp), %rdi
callq 0x11ed0
movq 0xb0(%rsp), %rax
addq $0xb8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0xdf28
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
testb $0x1, 0x3f(%rsp)
jne 0xdf1c
jmp 0xdf26
leaq 0x40(%rsp), %rdi
callq 0x11ed0
jmp 0xdf28
testb $0x1, 0x5f(%rsp)
jne 0xdf31
jmp 0xdf40
movq 0x60(%rsp), %rdi
movl $0x20, %esi
callq 0x6470
jmp 0xdf42
leaq 0x90(%rsp), %rdi
callq 0x11ed0
movq 0x78(%rsp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xe090
movq 0x20(%rsp), %rdi
movq %rax, 0x70(%rsp)
callq 0x92b0
movq %rax, 0x58(%rsp)
movq %rdx, 0x60(%rsp)
movl 0x58(%rsp), %eax
movl %eax, 0x6c(%rsp)
cmpl $0x25, 0x6c(%rsp)
jne 0xdfb5
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xe06a
cmpl $0x1e, 0x6c(%rsp)
jne 0xdfe2
movq 0x20(%rsp), %rdi
callq 0x9340
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xe06a
movl $0x48, %edi
callq 0x6200
movq 0x20(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0x92b0
movq %rdx, 0x10(%rsp)
movq %rax, 0x18(%rsp)
jmp 0xe007
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movq %rax, 0x40(%rsp)
movq 0x38(%rsp), %rdx
movq 0x40(%rsp), %rcx
leaq 0x2a7ec(%rip), %rsi     # 0x3881d
callq 0x17350
jmp 0xe038
movq 0x8(%rsp), %rdi
leaq 0x3d4e4(%rip), %rsi     # 0x4b528
leaq 0x3c55(%rip), %rdx      # 0x11ca0
callq 0x6780
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6320
jmp 0xe07a
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf440
movq 0x20(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x92b0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x74(%rsp)
movb $0x1, %al
cmpl $0x15, 0x74(%rsp)
movb %al, 0x1f(%rsp)
je 0xf31b
cmpl $0x16, 0x74(%rsp)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xf328
jmp 0xf422
movq 0x20(%rsp), %rdi
callq 0x9340
movq 0x20(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
callq 0xf440
movq %rax, 0x48(%rsp)
cmpl $0x15, 0x74(%rsp)
jne 0xf3ab
movl $0x20, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
movl $0x5, %esi
callq 0x122f0
jmp 0xf37d
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xf401
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0x6470
jmp 0xf42f
movl $0x20, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
movl $0x4, %esi
callq 0x122f0
jmp 0xf3d6
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xf401
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0x6470
jmp 0xf42f
movq 0x20(%rsp), %rdi
callq 0x92b0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0xf302
movq 0x78(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xf970
movq 0x20(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x92b0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x74(%rsp)
movb $0x1, %al
cmpl $0x8, 0x74(%rsp)
movb %al, 0x1f(%rsp)
je 0xf84b
cmpl $0x9, 0x74(%rsp)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xf858
jmp 0xf94f
movq 0x20(%rsp), %rdi
callq 0x9340
movq 0x20(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
callq 0xf970
movq %rax, 0x48(%rsp)
cmpl $0x8, 0x74(%rsp)
jne 0xf8d8
movl $0x20, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
xorl %esi, %esi
callq 0x122f0
jmp 0xf8aa
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xf92e
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0x6470
jmp 0xf95c
movl $0x20, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
movl $0x1, %esi
callq 0x122f0
jmp 0xf903
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xf92e
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0x6470
jmp 0xf95c
movq 0x20(%rsp), %rdi
callq 0x92b0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0xf832
movq 0x78(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0xfaf0
movq 0x20(%rsp), %rdi
movq %rax, 0x78(%rsp)
callq 0x92b0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x74(%rsp)
movb $0x1, %al
cmpl $0xa, 0x74(%rsp)
movb %al, 0x1f(%rsp)
je 0xf9cb
cmpl $0xb, 0x74(%rsp)
sete %al
movb %al, 0x1f(%rsp)
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0xf9d8
jmp 0xfad2
movq 0x20(%rsp), %rdi
callq 0x9340
movq 0x20(%rsp), %rdi
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
callq 0xfaf0
movq %rax, 0x48(%rsp)
cmpl $0xa, 0x74(%rsp)
jne 0xfa5b
movl $0x20, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
movl $0x2, %esi
callq 0x122f0
jmp 0xfa2d
movq 0x10(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xfab1
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0x6470
jmp 0xfadf
movl $0x20, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq 0x78(%rsp), %rdx
movq 0x48(%rsp), %rcx
movl $0x3, %esi
callq 0x122f0
jmp 0xfa86
movq 0x8(%rsp), %rax
movq %rax, 0x78(%rsp)
jmp 0xfab1
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x40(%rsp)
movl %eax, 0x3c(%rsp)
movl $0x20, %esi
callq 0x6470
jmp 0xfadf
movq 0x20(%rsp), %rdi
callq 0x92b0
movq %rax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movl 0x28(%rsp), %eax
movl %eax, 0x74(%rsp)
jmp 0xf9b2
movq 0x78(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x40(%rsp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x92b0
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
movl 0x60(%rsp), %eax
movl %eax, 0x74(%rsp)
cmpl $0x9, 0x74(%rsp)
jne 0xfba2
movq 0x28(%rsp), %rdi
callq 0x9340
movq %rax, 0x50(%rsp)
movq %rdx, 0x58(%rsp)
movl $0x18, %edi
callq 0x6460
movq 0x28(%rsp), %rdi
movq %rax, 0x18(%rsp)
callq 0xfc50
movq %rax, 0x20(%rsp)
jmp 0xfb58
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rdi
movl $0x1, %esi
callq 0x12350
jmp 0xfb6e
movq 0x18(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xfc30
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x18, %esi
callq 0x6470
jmp 0xfc40
cmpl $0x14, 0x74(%rsp)
jne 0xfc1e
movq 0x28(%rsp), %rdi
callq 0x9340
movq %rax, 0x30(%rsp)
movq %rdx, 0x38(%rsp)
movl $0x18, %edi
callq 0x6460
movq 0x28(%rsp), %rdi
movq %rax, 0x8(%rsp)
callq 0xfc50
movq %rax, 0x10(%rsp)
jmp 0xfbdd
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rdi
xorl %esi, %esi
callq 0x12350
jmp 0xfbf0
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0xfc30
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
movl $0x18, %esi
callq 0x6470
jmp 0xfc40
movq 0x28(%rsp), %rdi
callq 0xfc50
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdi, 0xa0(%rsp)
movq %rsi, 0x98(%rsp)
movq 0xa0(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x92b0
movq %rax, 0x88(%rsp)
movq %rdx, 0x90(%rsp)
cmpl $0x18, 0x88(%rsp)
jne 0x1138f
movq 0x18(%rsp), %rdi
callq 0x9340
movq %rax, 0x78(%rsp)
movq %rdx, 0x80(%rsp)
jmp 0x11497
movq 0x18(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x10(%rsp)
callq 0xe090
movq 0x10(%rsp), %rdi
movq %rax, 0x70(%rsp)
leaq 0x70(%rsp), %rsi
callq 0x11cf0
movq 0x18(%rsp), %rdi
callq 0x9340
movq %rax, 0x60(%rsp)
movq %rdx, 0x68(%rsp)
cmpl $0x1d, 0x60(%rsp)
jne 0x1142a
movq 0x18(%rsp), %rdi
movq 0x98(%rsp), %rax
movq %rax, 0x8(%rsp)
callq 0xe090
movq 0x8(%rsp), %rdi
movq %rax, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x11cf0
movq 0x18(%rsp), %rdi
callq 0x9340
movq %rax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x68(%rsp)
jmp 0x113ce
cmpl $0x18, 0x60(%rsp)
je 0x11497
movl $0x48, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movups 0x60(%rsp), %xmm0
movaps %xmm0, 0x30(%rsp)
movq 0x30(%rsp), %rdx
movq 0x38(%rsp), %rcx
leaq 0x2756c(%rip), %rsi     # 0x389cc
callq 0x17350
jmp 0x11467
movq (%rsp), %rdi
leaq 0x3a0b6(%rip), %rsi     # 0x4b528
leaq 0x827(%rip), %rdx       # 0x11ca0
callq 0x6780
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6320
jmp 0x1149f
addq $0xa8, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x67a0
nopl (%rax)
// File: 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:
subq $0x68, %rsp
movb %cl, %al
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movb %al, 0x53(%rsp)
movq 0x60(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x58(%rsp), %rsi
callq 0x67f0
movq 0x8(%rsp), %rax
leaq 0x34318(%rip), %rcx     # 0x4b510
movq %rcx, (%rax)
movl 0x54(%rsp), %ecx
movl %ecx, 0x10(%rax)
movb 0x53(%rsp), %cl
movb %cl, 0x14(%rax)
addq $0x18, %rax
movq %rax, 0x10(%rsp)
leaq 0x52(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x67b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x21827(%rip), %rsi     # 0x38a59
callq 0x7c20
jmp 0x17239
leaq 0x52(%rsp), %rdi
callq 0x64c0
movq 0x8(%rsp), %rdi
movq 0x58(%rsp), %rsi
addq $0x18, %rdi
callq 0x6420
jmp 0x17258
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x21802(%rip), %rsi     # 0x38a6a
callq 0x6420
jmp 0x1726f
movl 0x54(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0xbd40
jmp 0x1727f
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x20(%rsp), %rsi
callq 0x65c0
jmp 0x17294
leaq 0x20(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x217c5(%rip), %rsi     # 0x38a73
callq 0x6420
jmp 0x172b5
movq 0x8(%rsp), %rdi
movsbl 0x53(%rsp), %esi
addq $0x18, %rdi
callq 0x62a0
jmp 0x172ca
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
leaq 0x2179d(%rip), %rsi     # 0x38a77
callq 0x6420
jmp 0x172e1
addq $0x68, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x52(%rsp), %rdi
callq 0x64c0
jmp 0x17332
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x17328
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6290
movq 0x10(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
callq 0x6500
movq 0x48(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0xa8, %rsp
movq %rdx, 0x98(%rsp)
movq %rcx, 0xa0(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq 0x88(%rsp), %rsi
callq 0x67f0
movq 0x8(%rsp), %rax
leaq 0x341c3(%rip), %rcx     # 0x4b560
movq %rcx, (%rax)
movups 0x98(%rsp), %xmm0
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
addq $0x28, %rax
movq %rax, 0x10(%rsp)
leaq 0x87(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x67b0
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq 0x2169a(%rip), %rsi     # 0x38a7a
callq 0x7c20
jmp 0x173e7
leaq 0x87(%rsp), %rdi
callq 0x64c0
movq 0x8(%rsp), %rdi
movq 0x88(%rsp), %rsi
addq $0x28, %rdi
callq 0x6420
jmp 0x1740c
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x2166c(%rip), %rsi     # 0x38a88
callq 0x6420
jmp 0x17423
movups 0x98(%rsp), %xmm0
movaps %xmm0, 0x40(%rsp)
movq 0x40(%rsp), %rsi
movq 0x48(%rsp), %rdx
leaq 0x50(%rsp), %rdi
callq 0xa220
jmp 0x17446
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x50(%rsp), %rsi
callq 0x65c0
jmp 0x1745b
leaq 0x50(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x21622(%rip), %rsi     # 0x38a97
callq 0x6420
jmp 0x1747c
movl 0x9c(%rsp), %esi
leaq 0x20(%rsp), %rdi
callq 0x17d00
jmp 0x1748f
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x20(%rsp), %rsi
callq 0x65c0
jmp 0x174a4
leaq 0x20(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
addq $0x28, %rdi
leaq 0x210c5(%rip), %rsi     # 0x38583
callq 0x6420
jmp 0x174c5
addq $0xa8, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x87(%rsp), %rdi
callq 0x64c0
jmp 0x17536
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
jmp 0x1752c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x6290
jmp 0x1752c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x78(%rsp)
movl %eax, 0x74(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x6290
movq 0x10(%rsp), %rdi
callq 0x6290
movq 0x8(%rsp), %rdi
callq 0x6500
movq 0x78(%rsp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x18(%rsp)
movq 0x38(%rsp), %rsi
callq 0x67f0
movq 0x18(%rsp), %rdi
leaq 0x33fdd(%rip), %rax     # 0x4b560
movq %rax, (%rdi)
addq $0x10, %rdi
movl $0x25, %esi
xorl %edx, %edx
callq 0xb5d0
jmp 0x17598
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x20(%rax)
addq $0x28, %rax
movq %rax, 0x8(%rsp)
leaq 0x23(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x67b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x214ab(%rip), %rsi     # 0x38a7a
callq 0x7c20
jmp 0x175d6
leaq 0x23(%rsp), %rdi
callq 0x64c0
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x28, %rdi
callq 0x6420
jmp 0x175f5
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1763c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x23(%rsp), %rdi
callq 0x64c0
jmp 0x1763c
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6290
movq 0x18(%rsp), %rdi
callq 0x6500
movq 0x28(%rsp), %rdi
callq 0x67a0
// File: 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:
subq $0x58, %rsp
movq %rdx, 0x8(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq 0x48(%rsp), %rsi
callq 0x67f0
movq 0x10(%rsp), %rax
leaq 0x33f30(%rip), %rcx     # 0x4b5b8
movq %rcx, (%rax)
addq $0x10, %rax
movq %rax, 0x18(%rsp)
leaq 0x3f(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x67b0
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rdx
leaq 0x213ec(%rip), %rsi     # 0x38aa0
callq 0x7c20
jmp 0x176bb
leaq 0x3f(%rsp), %rdi
callq 0x64c0
movq 0x10(%rsp), %rdi
movq 0x48(%rsp), %rsi
addq $0x10, %rdi
callq 0x6420
jmp 0x176da
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x213c5(%rip), %rsi     # 0x38aaf
callq 0x6420
jmp 0x176f1
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
callq 0x65c0
jmp 0x17706
movq 0x10(%rsp), %rdi
addq $0x10, %rdi
leaq 0x20e6d(%rip), %rsi     # 0x38583
callq 0x6420
jmp 0x1771d
addq $0x58, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x3f(%rsp), %rdi
callq 0x64c0
jmp 0x17754
movq 0x18(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
callq 0x6290
movq 0x10(%rsp), %rdi
callq 0x6500
movq 0x30(%rsp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, (%rsp)
movq 0x38(%rsp), %rsi
callq 0x67f0
movq (%rsp), %rax
leaq 0x33e3f(%rip), %rcx     # 0x4b5e0
movq %rcx, (%rax)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x8(%rsp)
leaq 0x2f(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0x67b0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x212dc(%rip), %rsi     # 0x38ab2
callq 0x7c20
jmp 0x177dd
leaq 0x2f(%rsp), %rdi
callq 0x64c0
movq (%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x18, %rdi
callq 0x6420
jmp 0x177fb
addq $0x48, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x64c0
jmp 0x17832
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0x6290
movq (%rsp), %rdi
callq 0x6500
movq 0x20(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
leaq 0x21167(%rip), %rsi     # 0x38abe
movq $-0x1, %rdx
callq 0x6410
movq %rax, 0x30(%rsp)
cmpq $-0x1, 0x30(%rsp)
jne 0x179bb
leaq 0x2f(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x67b0
movq 0x8(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x207a6(%rip), %rsi     # 0x38134
callq 0x7c20
jmp 0x17995
leaq 0x2f(%rsp), %rdi
callq 0x64c0
jmp 0x179d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x2f(%rsp), %rdi
callq 0x64c0
jmp 0x179dd
movq 0x8(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rcx
xorl %eax, %eax
movl %eax, %edx
callq 0x6480
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: 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:
subq $0x1048, %rsp           # imm = 0x1048
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x1040(%rsp)
movq %rsi, 0x1038(%rsp)
movq 0x1038(%rsp), %rdi
callq 0x6180
movq %rax, %rdi
leaq 0x30(%rsp), %rsi
callq 0x6110
cmpq $0x0, %rax
jne 0x17a89
movl $0x10, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x21070(%rip), %rsi     # 0x38ac0
callq 0x6160
jmp 0x17a57
movq 0x8(%rsp), %rdi
movq 0x3458d(%rip), %rsi     # 0x4bff0
movq 0x34536(%rip), %rdx     # 0x4bfa0
callq 0x6780
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6320
jmp 0x17adb
leaq 0x23(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x67b0
movq 0x10(%rsp), %rdi
movq (%rsp), %rdx
leaq 0x30(%rsp), %rsi
callq 0x7c20
jmp 0x17aac
leaq 0x23(%rsp), %rdi
callq 0x64c0
movq 0x18(%rsp), %rax
addq $0x1048, %rsp           # imm = 0x1048
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x23(%rsp), %rdi
callq 0x64c0
movq 0x28(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x268, %rsp            # imm = 0x268
movq %rdi, 0x260(%rsp)
movq %rsi, 0x258(%rsp)
movq 0x258(%rsp), %rdi
callq 0x65e0
movq 0x260(%rsp), %rsi
leaq 0x50(%rsp), %rdi
movl $0x8, %edx
callq 0x6720
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rax
leaq 0x50(%rsp,%rax), %rdi
callq 0x6760
movb %al, 0x1f(%rsp)
jmp 0x17b44
movb 0x1f(%rsp), %al
testb $0x1, %al
jne 0x17bb8
jmp 0x17b4e
movl $0x10, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x10(%rsp)
leaq 0x20f6b(%rip), %rsi     # 0x38ad5
callq 0x6160
jmp 0x17b71
movq 0x10(%rsp), %rdi
movq 0x34473(%rip), %rsi     # 0x4bff0
movq 0x3441c(%rip), %rdx     # 0x4bfa0
callq 0x6780
jmp 0x17c23
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x17c0f
movq 0x10(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
callq 0x6320
jmp 0x17c0f
movq 0x258(%rsp), %rax
movq %rax, 0x8(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x17ed0
leaq 0x20(%rsp), %rdi
callq 0x17f30
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
movl 0x38(%rsp), %edx
movq 0x20(%rsp), %rcx
movl 0x28(%rsp), %r8d
callq 0x17e00
jmp 0x17bfd
leaq 0x50(%rsp), %rdi
callq 0x60a0
addq $0x268, %rsp            # imm = 0x268
retq
leaq 0x50(%rsp), %rdi
callq 0x60a0
movq 0x48(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x8(%rax), %eax
movl %eax, 0x44(%rsp)
testl %eax, %eax
je 0x199dd
jmp 0x198d7
movl 0x44(%rsp), %eax
subl $0x1, %eax
jne 0x19ade
jmp 0x198e6
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x38(%rsp), %rcx
movq %rax, 0x30(%rsp)
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x1992c
movq 0x30(%rsp), %rdi
leaq 0x31c2b(%rip), %rsi     # 0x4b540
leaq 0x31f7c(%rip), %rdx     # 0x4b898
xorl %eax, %eax
movl %eax, %ecx
callq 0x6520
movq %rax, 0x28(%rsp)
jmp 0x19935
xorl %eax, %eax
movq %rax, 0x28(%rsp)
jmp 0x19935
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
cmpq $0x0, 0x70(%rsp)
je 0x199cb
movq 0x38(%rsp), %rax
movq 0x70(%rsp), %rcx
movb 0x8(%rcx), %cl
xorb $-0x1, %cl
andb $0x1, %cl
movb %cl, 0x6f(%rsp)
cmpq $0x0, %rax
je 0x19973
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movzbl 0x6f(%rsp), %esi
andl $0x1, %esi
callq 0x124f0
jmp 0x19997
movq 0x20(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x19ae0
movq 0x20(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x10, %esi
callq 0x6470
jmp 0x19af0
movq 0x38(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x19ae0
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x38(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq %rax, 0x10(%rcx)
cmpq $0x0, %rax
je 0x19a23
movq 0x18(%rsp), %rdi
leaq 0x31b34(%rip), %rsi     # 0x4b540
leaq 0x31e3d(%rip), %rdx     # 0x4b850
xorl %eax, %eax
movl %eax, %ecx
callq 0x6520
movq %rax, 0x10(%rsp)
jmp 0x19a2c
xorl %eax, %eax
movq %rax, 0x10(%rsp)
jmp 0x19a2c
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
je 0x19acf
movq 0x38(%rsp), %rax
movq 0x50(%rsp), %rcx
movsd 0x8(%rcx), %xmm0
movq %xmm0, %rcx
movabsq $-0x8000000000000000, %rdx # imm = 0x8000000000000000
xorq %rdx, %rcx
movq %rcx, %xmm0
movsd %xmm0, 0x48(%rsp)
cmpq $0x0, %rax
je 0x19a7f
movq 0x38(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movl $0x10, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movsd 0x48(%rsp), %xmm0
callq 0x124b0
jmp 0x19aa1
movq 0x8(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x19ae0
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x60(%rsp)
movl %eax, 0x5c(%rsp)
movl $0x10, %esi
callq 0x6470
jmp 0x19af0
movq 0x38(%rsp), %rax
movq %rax, 0x80(%rsp)
jmp 0x19ae0
ud2
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
movq 0x60(%rsp), %rdi
callq 0x67a0
nopw (%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x15d60
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x15b90
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1a1b0
testb $0x1, %al
jne 0x19b4f
jmp 0x19b93
leaq 0x20(%rsp), %rdi
callq 0x16070
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x19b85
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x19b87
leaq 0x20(%rsp), %rdi
callq 0x1a1f0
jmp 0x19b3a
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x19c4b
movq 0x18(%rsp), %rdi
leaq 0x3190c(%rip), %rsi     # 0x4b540
leaq 0x31a65(%rip), %rdx     # 0x4b6a0
xorl %eax, %eax
movl %eax, %ecx
callq 0x6520
movq %rax, 0x8(%rsp)
jmp 0x19c54
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x19c54
movq 0x10(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rcx, 0x8(%rax)
cmpq $0x0, 0x8(%rax)
jne 0x19cbb
movl $0x10, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x1ef89(%rip), %rsi     # 0x38c0d
callq 0x6160
jmp 0x19c8b
movq (%rsp), %rdi
movq 0x3235a(%rip), %rsi     # 0x4bff0
movq 0x32303(%rip), %rdx     # 0x4bfa0
callq 0x6780
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
callq 0x6320
jmp 0x19cdb
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
addq $0x38, %rsp
retq
movq 0x28(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::If::optimize()
Node* If::optimize() {
	cond = cond->optimize();
	ifbody = ifbody->optimize();
	if (elsebody != nullptr)
		elsebody = elsebody->optimize();

	return this;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x18(%rax)
je 0x19d51
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x19d95
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
cmpq $0x0, 0x18(%rax)
je 0x19dd2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16ea0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x16cd0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1a210
testb $0x1, %al
jne 0x19f1f
jmp 0x19f6e
leaq 0x20(%rsp), %rdi
callq 0x171b0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
leaq 0x20(%rsp), %rdi
callq 0x1a250
jmp 0x19f0a
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq 0x8(%rsp), %rdi
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
callq 0x12800
movq %rax, 0x18(%rsp)
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x12830
movq %rax, 0x10(%rsp)
leaq 0x18(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x12860
testb $0x1, %al
jne 0x1a08c
jmp 0x1a0c0
leaq 0x18(%rsp), %rdi
callq 0x128a0
movq (%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, (%rsp)
leaq 0x18(%rsp), %rdi
callq 0x128a0
movq (%rsp), %rcx
movq %rcx, (%rax)
leaq 0x18(%rsp), %rdi
callq 0x12920
jmp 0x1a064
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: 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:
movb %dl, %al
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
andb $0x1, %al
movb %al, -0x11(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x20(%rsp)
leaq 0x311e5(%rip), %rcx     # 0x4b988
addq $0x10, %rcx
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, 0x11(%rax)
movb $0x0, 0x10(%rax)
movb -0x11(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x11(%rax)
testb $0x1, 0x11(%rax)
je 0x1a7ef
movq -0x20(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x300(%rax), %rax
movq %rax, 0x8(%rcx)
movq -0x10(%rsp), %rax
movq %rcx, 0x300(%rax)
retq
// File: 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:
subq $0x48, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rcx
movq %rcx, 0x10(%rsp)
movq 0x308(%rcx), %rax
cmpq 0x310(%rcx), %rax
jb 0x1a8fc
movq 0x8(%rsp), %rsi
leaq 0x28(%rsp), %rdi
movq %rdi, (%rsp)
callq 0x7d80
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1a910
jmp 0x1a8c0
leaq 0x28(%rsp), %rdi
callq 0x7db0
movq 0x10(%rsp), %rax
movq 0x308(%rax), %rcx
shlq %rcx
movq %rcx, 0x310(%rax)
jmp 0x1a8fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x7db0
jmp 0x1a901
addq $0x48, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: 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:
subq $0x68, %rsp
movq %rsi, 0x8(%rsp)
movq %rdi, %rax
movq 0x8(%rsp), %rdi
movq %rdi, 0x10(%rsp)
movq %rax, 0x60(%rsp)
movq %rdi, 0x58(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x1a949
jmp 0x1a95b
movq 0x10(%rsp), %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25cd0
movq 0x18(%rsp), %rax
addq $0x508, %rax            # imm = 0x508
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1aad0
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x1ab00
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1ab30
testb $0x1, %al
jne 0x1a99e
jmp 0x1a9cf
leaq 0x48(%rsp), %rdi
callq 0x1ab70
movq (%rax), %rcx
movq %rcx, 0x30(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x21490
leaq 0x48(%rsp), %rdi
callq 0x1ab80
jmp 0x1a989
movq 0x18(%rsp), %rax
addq $0x300, %rax            # imm = 0x300
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1aa7d
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x10(%rax)
jne 0x1aa61
movq 0x20(%rsp), %rax
testb $0x1, 0x11(%rax)
je 0x1aa61
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x308(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x308(%rax)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1aa5f
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1aa78
movq 0x20(%rsp), %rax
movb $0x0, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x28(%rsp)
jmp 0x1a9df
movq 0x10(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x1aa91
jmp 0x1aaa3
movq 0x10(%rsp), %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25df0
addq $0x68, %rsp
retq
nopl (%rax,%rax)
// File: iamlouk[P]asbi/src/./include/types.hh
// Function: asbi::Value::number(double)
static inline Value number(double num) {
			Value val;
			val.type = type_t::Number;
			val._number = num;
			return val;
		}

// Assembly:
subq $0x18, %rsp
movsd %xmm0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x7ce0
movl $0x1, 0x8(%rsp)
movsd (%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: iamlouk[P]asbi/src/./include/types.hh
// Function: asbi::Value::boolean(bool)
static inline Value boolean(bool boolean) {
			Value val;
			val.type = type_t::Bool;
			val._boolean = boolean;
			return val;
		}

// Assembly:
subq $0x18, %rsp
movb %dil, %al
andb $0x1, %al
movb %al, 0x7(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x7ce0
movl $0x0, 0x8(%rsp)
movb 0x7(%rsp), %al
andb $0x1, %al
movb %al, 0x10(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: iamlouk[P]asbi/src/./include/types.hh
// Function: asbi::Value::string(asbi::StringContainer*)
static inline Value string(StringContainer* sc) {
			Value val;
			val.type = type_t::String;
			val._string = sc;
			return val;
		}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x7ce0
movl $0x4, 0x8(%rsp)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rdx
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
testb $0x1, 0x8(%rax)
je 0x1d9e8
movq 0x10(%rsp), %rdi
movq $0x2, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x1f840
jmp 0x1d9fd
movq 0x10(%rsp), %rdi
movq $0x3, (%rsp)
movq %rsp, %rsi
callq 0x1f840
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: 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:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x70(%rsp), %rdi
movq $0x7, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x1f840
movl $0x18, %edi
callq 0x6460
movq %rax, %rdi
movq %rdi, (%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
callq 0x1f8e0
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x60(%rsp)
movq 0x20(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movl $0x48, %edi
callq 0x6460
movq %rax, 0x8(%rsp)
movb $0x1, 0x23(%rsp)
xorl %eax, %eax
movl %eax, %esi
leaq 0x48(%rsp), %rdi
callq 0x1f8f0
movq 0x10(%rsp), %rsi
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
addq $0x8, %rsi
leaq 0x30(%rsp), %rdi
callq 0x140a0
jmp 0x1dba8
movq 0x18(%rsp), %rdx
movq 0x8(%rsp), %rdi
movq 0x78(%rsp), %r8
leaq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rcx
xorl %r9d, %r9d
callq 0x21100
jmp 0x1dbcb
movb $0x0, 0x23(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x129f0
leaq 0x48(%rsp), %rdi
callq 0x7db0
movq 0x8(%rsp), %rax
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rdi
addq $0x520, %rdi            # imm = 0x520
leaq 0x58(%rsp), %rsi
callq 0x1f910
movq 0x70(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x1f870
addq $0x88, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
jmp 0x1dc43
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x30(%rsp), %rdi
callq 0x129f0
leaq 0x48(%rsp), %rdi
callq 0x7db0
testb $0x1, 0x23(%rsp)
jne 0x1dc56
jmp 0x1dc65
movq 0x8(%rsp), %rdi
movl $0x48, %esi
callq 0x6470
jmp 0x1dc67
movq 0x28(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)