LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movl 0x8(%rax), %eax
movl %eax, 0xc(%rsp)
testl %eax, %eax
je 0x1e40a
jmp 0x1e399
movl 0xc(%rsp), %eax
subl $0x1, %eax
jne 0x1e43a
jmp 0x1e3a8
movq 0x30(%rsp), %rdi
movq $0x0, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x1f840
xorps %xmm0, %xmm0
movsd %xmm0, 0x20(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1f870
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rsp), %rdi
movq $0x11, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
jmp 0x1e43a
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rsp), %rdi
movq $0x1a, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1f840
addq $0x48, %rsp
retq
nop
// File: 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:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x2d56e(%rip), %rcx     # 0x4b9c8
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x8, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x15d60
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x15b90
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1a1b0
testb $0x1, %al
jne 0x1e4a0
jmp 0x1e531
leaq 0x40(%rsp), %rdi
callq 0x16070
movq (%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1f9a0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
callq 0x1f9b0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1e4f7
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1e520
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1e51e
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1e520
jmp 0x1e522
leaq 0x40(%rsp), %rdi
callq 0x1a1f0
jmp 0x1e488
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x121c0
movq 0x10(%rsp), %rdi
callq 0x12c20
addq $0x58, %rsp
retq
nop
// File: 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:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
addq $0x8, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x13070
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x130a0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x13450
testb $0x1, %al
jne 0x1e5d7
jmp 0x1e6a2
leaq 0x50(%rsp), %rdi
callq 0x134c0
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1f9a0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1f9b0
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x1e635
movq 0x60(%rsp), %rdi
movq $0x4, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1f840
jmp 0x1e64d
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x60(%rsp), %rdi
movq $0xe, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
addq $0x8, %rsi
callq 0x1f870
movq 0x60(%rsp), %rdi
movq $0x9, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1f840
leaq 0x50(%rsp), %rdi
callq 0x134d0
jmp 0x1e5bf
movq 0x60(%rsp), %rdi
movq $0x4, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x1f840
addq $0x78, %rsp
retq
nop
// File: 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:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rsi
movq %rsi, 0x18(%rsp)
addq $0x8, %rsi
leaq 0x48(%rsp), %rdi
callq 0x1f9c0
movq 0x18(%rsp), %rsi
addq $0x8, %rsi
leaq 0x40(%rsp), %rdi
callq 0x1fa40
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x1fa10
testb $0x1, %al
jne 0x1e7d6
jmp 0x1e887
leaq 0x48(%rsp), %rdi
callq 0x1fa90
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1e811
movq 0x10(%rsp), %rdi
leaq 0x2cd46(%rip), %rsi     # 0x4b540
leaq 0x2ce57(%rip), %rdx     # 0x4b658
xorl %eax, %eax
movl %eax, %ecx
callq 0x6520
movq %rax, 0x8(%rsp)
jmp 0x1e81a
xorl %eax, %eax
movq %rax, 0x8(%rsp)
jmp 0x1e81a
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x1e859
movq 0x50(%rsp), %rdi
movq $0x8, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x1f840
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
addq $0x8, %rsi
callq 0x1f870
jmp 0x1e876
leaq 0x48(%rsp), %rdi
callq 0x1fa90
movq (%rax), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1e878
leaq 0x48(%rsp), %rdi
callq 0x1fac0
jmp 0x1e7ab
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x50(%rsp), %rdi
movq $0x1f, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x1f840
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x11d20
movq (%rsp), %rdi
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1f840
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::If::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void If::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	cond->to_vmops(ctx, ops);
	ops.push_back(OpCode::IF_TRUE_GOTO);
	ops.push_back(OpCode::NOOP);
	auto pos1 = ops.size() - 1;
	ops.push_back(OpCode::ENTER_SCOPE);
	if (elsebody)
		elsebody->to_vmops(ctx, ops);
	else
		ops.push_back(OpCode::PUSH_NIL);
	ops.push_back(OpCode::LEAVE_SCOPE);
	ops.push_back(OpCode::GOTO);
	ops.push_back(OpCode::NOOP);
	auto pos2 = ops.size() - 1;
	*(ops.data() + pos1) = static_cast<OpCode>(ops.size());
	ops.push_back(OpCode::ENTER_SCOPE);
	ifbody->to_vmops(ctx, ops);
	ops.push_back(OpCode::LEAVE_SCOPE);
	*(ops.data() + pos2) = static_cast<OpCode>(ops.size());
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rdi
movq $0x21, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0x23, 0x60(%rsp)
leaq 0x60(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
callq 0x1d050
subq $0x1, %rax
movq %rax, 0x58(%rsp)
movq 0x70(%rsp), %rdi
movq $0xa, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x1f840
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1eabc
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
jmp 0x1ead4
movq 0x70(%rsp), %rdi
movq $0x4, 0x48(%rsp)
leaq 0x48(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0xb, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0x20, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0x23, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
callq 0x1d050
subq $0x1, %rax
movq %rax, 0x28(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1d050
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x1f980
movq (%rsp), %rdx
movq 0x58(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x70(%rsp), %rdi
movq $0xa, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1f840
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rdi
movq $0xb, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
callq 0x1d050
movq %rax, 0x8(%rsp)
movq 0x70(%rsp), %rdi
callq 0x1f980
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x88, %rsp
retq
nopl (%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::If::~If()
If::~If() {
	delete cond;
	delete ifbody;
	if (elsebody != nullptr)
		delete elsebody;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x2ce3e(%rip), %rcx     # 0x4ba28
addq $0x10, %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1ec0b
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1ec2a
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ec55
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x1ec53
movq (%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1ec55
movq 0x10(%rsp), %rdi
callq 0x12c20
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::For::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void For::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	if (init) {
		init->to_vmops(ctx, ops);
		ops.push_back(OpCode::POP);
	}

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

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

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

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

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rax)
je 0x1ecfe
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rdi
movq $0x9, 0x68(%rsp)
leaq 0x68(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
callq 0x1d050
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x60(%rsp)
movq 0x10(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rdi
movq $0x22, 0x58(%rsp)
leaq 0x58(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0x23, 0x50(%rsp)
leaq 0x50(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
callq 0x1d050
subq $0x1, %rax
movq %rax, 0x48(%rsp)
movq 0x70(%rsp), %rdi
movq $0xa, 0x40(%rsp)
leaq 0x40(%rsp), %rsi
callq 0x1f840
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rdi
movq $0xb, 0x38(%rsp)
leaq 0x38(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0x9, 0x30(%rsp)
leaq 0x30(%rsp), %rsi
callq 0x1f840
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ee0a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x78(%rsp), %rsi
movq 0x70(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x70(%rsp), %rdi
movq $0x9, 0x28(%rsp)
leaq 0x28(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq $0x20, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
movq 0x70(%rsp), %rdi
callq 0x1d050
movq %rax, (%rsp)
movq 0x70(%rsp), %rdi
callq 0x1f980
movq (%rsp), %rdx
movq 0x48(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x70(%rsp), %rdi
movq $0x4, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1f840
addq $0x88, %rsp
retq
// File: 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:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
leaq 0x2cbbe(%rip), %rcx     # 0x4ba58
addq $0x10, %rcx
movq %rcx, (%rax)
cmpq $0x0, 0x8(%rax)
je 0x1eec9
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x1eec7
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1eec9
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1eee8
movq 0x18(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1ef15
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1ef13
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x1ef15
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1ef34
movq 0x8(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x28(%rsp), %rdi
callq 0x12c20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::Block::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Block::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	int n = exprs.size();
	if (n == 0) {
		ops.push_back(OpCode::PUSH_NIL);
		return;
	}

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x8, %rdi
callq 0x11d20
movl %eax, 0x2c(%rsp)
cmpl $0x0, 0x2c(%rsp)
jne 0x1efce
movq 0x30(%rsp), %rdi
movq $0x4, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1f840
jmp 0x1f05b
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1f030
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movslq 0x1c(%rsp), %rsi
callq 0x1faf0
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rsp), %rdi
movq $0x9, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1f840
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1efd6
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
movl 0x2c(%rsp), %eax
subl $0x1, %eax
movslq %eax, %rsi
callq 0x1faf0
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
addq $0x48, %rsp
retq
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::List::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void List::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	for (auto node: values) {
		node->to_vmops(ctx, ops);
	}

	ops.push_back(OpCode::MAKE_MAP_ARRLIKE);
	ops.push_back(static_cast<OpCode>(values.size()));
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x14b20
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x14b50
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1fb10
testb $0x1, %al
jne 0x1f0b9
jmp 0x1f0ec
leaq 0x30(%rsp), %rdi
callq 0x1fb50
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x30(%rsp), %rdi
callq 0x1fb60
jmp 0x1f0a4
movq 0x40(%rsp), %rdi
movq $0x1c, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
movq 0x8(%rsp), %rdi
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
addq $0x8, %rdi
callq 0x11d20
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1f840
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::Map::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Map::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	for (auto [key, val]: values) {
		val->to_vmops(ctx, ops);
		key->to_vmops(ctx, ops);
	}

	ops.push_back(OpCode::MAKE_MAP);
	ops.push_back(static_cast<OpCode>(values.size()));
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x10(%rsp)
addq $0x8, %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rdi
callq 0x13990
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rdi
callq 0x139c0
movq %rax, 0x48(%rsp)
leaq 0x50(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x13d80
testb $0x1, %al
jne 0x1f289
jmp 0x1f301
leaq 0x50(%rsp), %rdi
callq 0x13df0
movq (%rax), %rcx
movq %rcx, 0x38(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1fb80
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x1fb90
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rdi
movq 0x68(%rsp), %rsi
movq 0x60(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x50(%rsp), %rdi
callq 0x13e00
jmp 0x1f274
movq 0x60(%rsp), %rdi
movq $0x1b, 0x20(%rsp)
leaq 0x20(%rsp), %rsi
callq 0x1f840
movq 0x10(%rsp), %rdi
movq 0x60(%rsp), %rax
movq %rax, 0x8(%rsp)
addq $0x8, %rdi
callq 0x13870
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::AssignAccess::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void AssignAccess::to_vmops(asbi::Context* ctx, std::vector<asbi::OpCode> &ops) const {
	acs->right->to_vmops(ctx, ops); // key
	val->to_vmops(ctx, ops);        // value
	acs->left->to_vmops(ctx, ops);  // dict
	ops.push_back(OpCode::SET_MAP_VAL);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0x18(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%rsp), %rdi
movq $0x1e, 0x8(%rsp)
leaq 0x8(%rsp), %rsi
callq 0x1f840
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/ast.cc
// Function: ast::Call::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Call::to_vmops(asbi::Context* ctx, std::vector<asbi::OpCode> &ops) const {
	for (auto rit = args.rbegin(); rit != args.rend(); ++rit)
		(*rit)->to_vmops(ctx, ops);

	callable->to_vmops(ctx, ops);
	ops.push_back(OpCode::CALL);
	ops.push_back(static_cast<OpCode>(args.size()));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x10, %rsi
leaq 0x28(%rsp), %rdi
callq 0x1f9c0
movq 0x8(%rsp), %rsi
addq $0x10, %rsi
leaq 0x20(%rsp), %rdi
callq 0x1fa40
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x1fa10
testb $0x1, %al
jne 0x1f5b3
jmp 0x1f5dc
leaq 0x28(%rsp), %rdi
callq 0x1fa90
movq (%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
leaq 0x28(%rsp), %rdi
callq 0x1fac0
jmp 0x1f58b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x30(%rsp), %rdi
movq $0xc, 0x18(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x1f840
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
addq $0x10, %rdi
callq 0x11d20
movq (%rsp), %rdi
movq %rax, 0x10(%rsp)
leaq 0x10(%rsp), %rsi
callq 0x1f840
addq $0x48, %rsp
retq
nopl (%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::LambdaContainer::gc_visit() const
void LambdaContainer::gc_visit() const {
	if (gc_inuse)
		return;

	gc_inuse = true;
	assert(env != nullptr);
	env->gc_visit();
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x10(%rax)
je 0x2125b
jmp 0x212ae
movq 0x8(%rsp), %rdi
movb $0x1, 0x10(%rdi)
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x21277
jmp 0x21279
jmp 0x21298
leaq 0x17a78(%rip), %rdi     # 0x38cf8
leaq 0x17d01(%rip), %rsi     # 0x38f88
movl $0x34, %edx
leaq 0x17cfe(%rip), %rcx     # 0x38f91
callq 0x62b0
movq 0x8(%rsp), %rdi
addq $0x18, %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25cd0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::MapContainer::gc_visit() const
void MapContainer::gc_visit() const {
	if (gc_inuse)
		return;

	gc_inuse = true;

	for (auto [key, val]: data) {
		key.gc_visit();
		val.gc_visit();
	}

	for (auto val: vecdata) {
		val.gc_visit();
	}
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x10(%rax)
je 0x21357
jmp 0x21479
movq 0x8(%rsp), %rax
movb $0x1, 0x10(%rax)
addq $0x18, %rax
movq %rax, 0x78(%rsp)
movq 0x78(%rsp), %rdi
callq 0x22a80
movq %rax, 0x70(%rsp)
movq 0x78(%rsp), %rdi
callq 0x22ab0
movq %rax, 0x68(%rsp)
leaq 0x70(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0x22ae0
testb $0x1, %al
jne 0x2139c
jmp 0x21407
leaq 0x70(%rsp), %rdi
callq 0x22b00
movq (%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x10(%rax), %rcx
movq %rcx, 0x58(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x60(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x22b20
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
callq 0x22b30
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x21490
movq 0x38(%rsp), %rdi
callq 0x21490
leaq 0x70(%rsp), %rdi
callq 0x22b40
jmp 0x21387
movq 0x8(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x22b70
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
callq 0x22ba0
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x22bd0
testb $0x1, %al
jne 0x21448
jmp 0x21479
leaq 0x28(%rsp), %rdi
callq 0x22c10
movq (%rax), %rcx
movq %rcx, 0x10(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
leaq 0x10(%rsp), %rdi
callq 0x21490
leaq 0x28(%rsp), %rdi
callq 0x22c20
jmp 0x21433
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::gc_visit() const
void Value::gc_visit() const {
	switch (type) {
	case type_t::Symbol:
	case type_t::String:
		_string->gc_visit();
		return;
	case type_t::Lambda:
		_lambda->gc_visit();
		return;
	case type_t::Map:
		_map->gc_visit();
		return;
	default:
		return;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movl (%rax), %eax
movl %eax, 0xc(%rsp)
addl $-0x3, %eax
subl $0x2, %eax
jb 0x214c8
jmp 0x214b2
movl 0xc(%rsp), %eax
subl $0x5, %eax
je 0x214d8
jmp 0x214bd
movl 0xc(%rsp), %eax
subl $0x6, %eax
je 0x214e8
jmp 0x214f8
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x214fa
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x214fa
movq (%rsp), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
jmp 0x214fa
jmp 0x214fa
addq $0x18, %rsp
retq
nop
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::MapContainer::set(asbi::Value, asbi::Value)
void MapContainer::set(Value key, Value val) {
	unsigned int idx;
	if (key.asUint(&idx)) {
		while (vecdata.size() <= idx)
			vecdata.push_back(Value::nil());

		vecdata[idx] = val;
	} else {
		data[key] = val;
	}
}

// Assembly:
subq $0x58, %rsp
movl %esi, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movl %ecx, 0x38(%rsp)
movq %r8, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x21620
testb $0x1, %al
jne 0x2158a
jmp 0x215f7
jmp 0x2158c
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
callq 0x1d030
movl 0x2c(%rsp), %ecx
cmpq %rcx, %rax
ja 0x215d0
movq 0x10(%rsp), %rax
addq $0x50, %rax
movq %rax, 0x8(%rsp)
callq 0x1d110
movq 0x8(%rsp), %rdi
movl %eax, 0x18(%rsp)
movq %rdx, 0x20(%rsp)
leaq 0x18(%rsp), %rsi
callq 0x22c50
jmp 0x2158c
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x22c80
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
jmp 0x2161b
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
leaq 0x48(%rsp), %rsi
callq 0x22ca0
movq 0x38(%rsp), %rcx
movq %rcx, (%rax)
movq 0x40(%rsp), %rcx
movq %rcx, 0x8(%rax)
addq $0x58, %rsp
retq
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::asUint(unsigned int*) const
bool Value::asUint(unsigned int *intpart) const {
	if (type != type_t::Number)
		return false;

	double ipart;
	double fpart = std::modf(_number, &ipart);
	if (std::fabs(fpart) < 0.00001 && ipart >= 0.0) {
		*intpart = static_cast<unsigned int>(ipart);
		return true;
	}
	return false;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x1, (%rax)
je 0x21644
movb $0x0, 0x37(%rsp)
jmp 0x216a8
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
leaq 0x18(%rsp), %rdi
callq 0x67c0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movaps 0x17855(%rip), %xmm0    # 0x38ec0
pand %xmm0, %xmm1
movsd 0x17831(%rip), %xmm0    # 0x38ea8
ucomisd %xmm1, %xmm0
jbe 0x216a3
movsd 0x18(%rsp), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x216a3
cvttsd2si 0x18(%rsp), %rax
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movb $0x1, 0x37(%rsp)
jmp 0x216a8
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
andb $0x1, %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::MapContainer::get(asbi::Value)
Value MapContainer::get(Value key) {
	unsigned int idx;
	if (key.asUint(&idx)) {
		if (idx < vecdata.size())
			return vecdata[idx];
		else
			return Value::nil();
	} else {
		auto search = data.find(key);
		if (search == data.end())
			return Value::nil();
		else
			return search->second;
	}
}

// Assembly:
subq $0x58, %rsp
movl %esi, 0x38(%rsp)
movq %rdx, 0x40(%rsp)
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x2c(%rsp), %rsi
callq 0x21620
testb $0x1, %al
jne 0x216f1
jmp 0x2174c
movq 0x10(%rsp), %rdi
movl 0x2c(%rsp), %eax
movq %rax, 0x8(%rsp)
addq $0x50, %rdi
callq 0x1d030
movq %rax, %rcx
movq 0x8(%rsp), %rax
cmpq %rcx, %rax
jae 0x2173c
movq 0x10(%rsp), %rdi
addq $0x50, %rdi
movl 0x2c(%rsp), %eax
movl %eax, %esi
callq 0x22c80
movq (%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x217b8
callq 0x1d110
movl %eax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x217b8
movq 0x10(%rsp), %rdi
addq $0x18, %rdi
leaq 0x38(%rsp), %rsi
callq 0x22cd0
movq 0x10(%rsp), %rdi
movq %rax, 0x20(%rsp)
addq $0x18, %rdi
callq 0x22d20
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x22d00
testb $0x1, %al
jne 0x2178c
jmp 0x2179c
callq 0x1d110
movl %eax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
jmp 0x217b8
leaq 0x20(%rsp), %rdi
callq 0x22d50
movq 0x10(%rax), %rcx
movq %rcx, 0x48(%rsp)
movq 0x18(%rax), %rax
movq %rax, 0x50(%rsp)
movl 0x48(%rsp), %eax
movq 0x50(%rsp), %rdx
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::symbol(char const*, asbi::Context*)
Value Value::symbol(const char* str, Context* ctx) {
	Value val;
	val.type = type_t::Symbol;
	std::string cppstr(str);
	val._string = ctx->new_stringconstant(cppstr);
	return val;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x7ce0
movl $0x3, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x67b0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x7c20
jmp 0x2181f
leaq 0x37(%rsp), %rdi
callq 0x64c0
movq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x260c0
movq %rax, 0x8(%rsp)
jmp 0x2183f
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6290
movl 0x68(%rsp), %eax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x64c0
jmp 0x21893
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6290
movq 0x28(%rsp), %rdi
callq 0x67a0
nopl (%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::string(char const*, asbi::Context*)
Value Value::string(const char* str, Context* ctx) {
	Value val;
	val.type = type_t::String;
	std::string cppstr(str);
	val._string = ctx->new_stringconstant(cppstr);
	return val;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
leaq 0x68(%rsp), %rdi
callq 0x7ce0
movl $0x4, 0x68(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x10(%rsp)
leaq 0x37(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x67b0
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
leaq 0x38(%rsp), %rdi
callq 0x7c20
jmp 0x218ef
leaq 0x37(%rsp), %rdi
callq 0x64c0
movq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x260c0
movq %rax, 0x8(%rsp)
jmp 0x2190f
movq 0x8(%rsp), %rax
movq %rax, 0x70(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6290
movl 0x68(%rsp), %eax
movq 0x70(%rsp), %rdx
addq $0x78, %rsp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x37(%rsp), %rdi
callq 0x64c0
jmp 0x21963
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x28(%rsp)
movl %eax, 0x24(%rsp)
leaq 0x38(%rsp), %rdi
callq 0x6290
movq 0x28(%rsp), %rdi
callq 0x67a0
nopl (%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::string(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, asbi::Context*)
Value Value::string(std::string &str, Context *ctx) {
	Value val;
	val.type = type_t::String;
	val._string = ctx->new_string(str);
	return val;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x7ce0
movl $0x4, 0x18(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x27030
movq %rax, 0x20(%rsp)
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::operator==(asbi::Value const&) const
bool Value::operator==(const Value &rhs) const {
	assert(type != type_t::StackPlaceholder);
	assert(rhs.type != type_t::StackPlaceholder);
	if (type != rhs.type) return false;
	switch (type) {
	case type_t::Bool:
		return _boolean == rhs._boolean;
	case type_t::Number:
		return _number == rhs._number;
	case type_t::Nil:
		return true;
	case type_t::Symbol:
	case type_t::String:
		return _string->data == rhs._string->data;
	case type_t::Lambda:
		return _lambda == rhs._lambda;
	case type_t::Map:
		return _map->data == rhs._map->data;
	case type_t::Macro:
		return _macro == rhs._macro;
	case type_t::StackPlaceholder:
		return false; // should not happen
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpl $0x8, (%rax)
je 0x21dff
jmp 0x21e1e
leaq 0x17227(%rip), %rdi     # 0x3902d
leaq 0x1717b(%rip), %rsi     # 0x38f88
movl $0x9c, %edx
leaq 0x171de(%rip), %rcx     # 0x38ff7
callq 0x62b0
movq 0x10(%rsp), %rax
cmpl $0x8, (%rax)
je 0x21e2a
jmp 0x21e49
leaq 0x171f8(%rip), %rdi     # 0x39029
leaq 0x17150(%rip), %rsi     # 0x38f88
movl $0x9d, %edx
leaq 0x171b3(%rip), %rcx     # 0x38ff7
callq 0x62b0
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
je 0x21e63
movb $0x0, 0x27(%rsp)
jmp 0x21f79
movq 0x8(%rsp), %rax
movl (%rax), %eax
movq %rax, (%rsp)
subq $0x8, %rax
ja 0x21f77
movq (%rsp), %rax
leaq 0x1704d(%rip), %rcx     # 0x38ed0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rsp), %rax
movb 0x8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
movb 0x8(%rcx), %cl
andb $0x1, %cl
movzbl %cl, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x21f79
movq 0x8(%rsp), %rax
movsd 0x8(%rax), %xmm0
movq 0x10(%rsp), %rax
ucomisd 0x8(%rax), %xmm0
sete %al
setnp %cl
andb %cl, %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x21f79
movb $0x1, 0x27(%rsp)
jmp 0x21f79
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x20, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
addq $0x20, %rsi
callq 0x22ef0
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x21f79
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x21f79
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
addq $0x18, %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
addq $0x18, %rsi
callq 0x22f90
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x21f79
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rsp), %rcx
cmpq 0x8(%rcx), %rax
sete %al
andb $0x1, %al
movb %al, 0x27(%rsp)
jmp 0x21f79
movb $0x0, 0x27(%rsp)
jmp 0x21f79
ud2
movb 0x27(%rsp), %al
andb $0x1, %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::hash() const
std::size_t Value::hash() const {
	assert(type != type_t::StackPlaceholder);
	switch (type) {
	case type_t::Bool:
		return _boolean ? 0xABC1 : 0xABC0;
	case type_t::Number:
		return static_cast<std::size_t>(_number);
	case type_t::Nil:
		return 0xAFFE;
	case type_t::Symbol:
	case type_t::String:
		return _string->hash;
	case type_t::Lambda:
		return reinterpret_cast<std::size_t>(_lambda->ops);
	case type_t::Map:
		return reinterpret_cast<std::size_t>(_map);
	case type_t::Macro:
		return reinterpret_cast<std::size_t>(_macro);
	case type_t::StackPlaceholder:
		return 0; // should not happen
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpl $0x8, (%rax)
je 0x21faa
jmp 0x21fc9
leaq 0x1707c(%rip), %rdi     # 0x3902d
leaq 0x16fd0(%rip), %rsi     # 0x38f88
movl $0xb5, %edx
leaq 0x1708a(%rip), %rcx     # 0x3904e
callq 0x62b0
movq 0x10(%rsp), %rax
movl (%rax), %eax
movq %rax, 0x8(%rsp)
subq $0x8, %rax
ja 0x220ad
movq 0x8(%rsp), %rax
leaq 0x16f09(%rip), %rcx     # 0x38ef4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x10(%rsp), %rax
movb 0x8(%rax), %dl
movl $0xabc0, %eax           # imm = 0xABC0
movl $0xabc1, %ecx           # imm = 0xABC1
testb $0x1, %dl
cmovnel %ecx, %eax
cltq
movq %rax, 0x20(%rsp)
jmp 0x220af
movq 0x10(%rsp), %rax
movsd 0x8(%rax), %xmm0
movsd 0x16e86(%rip), %xmm2    # 0x38eb0
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x20(%rsp)
jmp 0x220af
movq $0xaffe, 0x20(%rsp)     # imm = 0xAFFE
jmp 0x220af
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x220af
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x220af
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x220af
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x220af
movq $0x0, 0x20(%rsp)
jmp 0x220af
ud2
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Env::gc_visit() const
void Env::gc_visit() const {
	if (gc_visited)
		return;

	gc_visited = true;

	for (auto [key, val]: vars)
		val.gc_visit();

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

	if (caller != nullptr)
		caller->gc_visit();
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x58(%rax)
je 0x25cee
jmp 0x25ddf
movq 0x8(%rsp), %rax
movb $0x1, 0x58(%rax)
addq $0x20, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rdi
callq 0x27320
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
callq 0x27350
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x27380
testb $0x1, %al
jne 0x25d33
jmp 0x25d8b
leaq 0x40(%rsp), %rdi
callq 0x273a0
movq (%rax), %rcx
movq %rcx, 0x20(%rsp)
movq 0x8(%rax), %rcx
movq %rcx, 0x28(%rsp)
movq 0x10(%rax), %rax
movq %rax, 0x30(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x273c0
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x273d0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x21490
leaq 0x40(%rsp), %rdi
callq 0x273e0
jmp 0x25d1e
movq 0x8(%rsp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x25d9f
jmp 0x25db1
movq 0x8(%rsp), %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25cd0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x25dc9
jmp 0x25ddf
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25cd0
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Env::gc_unvisit() const
void Env::gc_unvisit() const {
	if (!gc_visited)
		return;

	gc_visited = false;

	if (outer != nullptr)
		outer->gc_unvisit();

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
testb $0x1, 0x58(%rax)
jne 0x25e0b
jmp 0x25e63
movq 0x8(%rsp), %rdi
movb $0x0, 0x58(%rdi)
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x25e23
jmp 0x25e35
movq 0x8(%rsp), %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25df0
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1aab0
testb $0x1, %al
jne 0x25e4d
jmp 0x25e63
movq 0x8(%rsp), %rdi
addq $0x10, %rdi
callq 0x7bd0
movq %rax, %rdi
callq 0x25df0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Env::lookup(asbi::StringContainer*)
Value Env::lookup(StringContainer* sc) {
	auto env = this;
	while (env != nullptr) {
		auto search = env->vars.find(sc);
		if (search != env->vars.end())
			return search->second;

		env = env->outer.get();
	}

	throw utils::interpreter_error("variable not found in env", sc->data);
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x48(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x25f02
movq 0x48(%rsp), %rdi
addq $0x20, %rdi
leaq 0x50(%rsp), %rsi
callq 0x27410
movq %rax, 0x40(%rsp)
movq 0x48(%rsp), %rdi
addq $0x20, %rdi
callq 0x27440
movq %rax, 0x38(%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x27380
testb $0x1, %al
jne 0x25ed0
jmp 0x25ef1
leaq 0x40(%rsp), %rdi
callq 0x27470
movups 0x8(%rax), %xmm0
movaps %xmm0, 0x60(%rsp)
movl 0x60(%rsp), %eax
movq 0x68(%rsp), %rdx
addq $0x78, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0x8ba0
movq %rax, 0x48(%rsp)
jmp 0x25e88
movb $0x1, 0xb(%rsp)
movl $0x30, %edi
callq 0x6200
movq %rax, (%rsp)
movq 0x50(%rsp), %rsi
addq $0x20, %rsi
leaq 0x18(%rsp), %rdi
callq 0x61a0
jmp 0x25f2a
movq (%rsp), %rdi
leaq 0x1319e(%rip), %rsi     # 0x390d3
leaq 0x18(%rsp), %rdx
callq 0x17650
jmp 0x25f41
movq (%rsp), %rdi
movb $0x0, 0xb(%rsp)
leaq 0x256a7(%rip), %rsi     # 0x4b5f8
leaq -0xdf68(%rip), %rdx     # 0x17ff0
callq 0x6780
jmp 0x25fa5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
jmp 0x25f87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x10(%rsp)
movl %eax, 0xc(%rsp)
leaq 0x18(%rsp), %rdi
callq 0x6290
testb $0x1, 0xb(%rsp)
jne 0x25f90
jmp 0x25f99
movq (%rsp), %rdi
callq 0x6320
jmp 0x25f9b
movq 0x10(%rsp), %rdi
callq 0x67a0
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Context::new_stringconstant(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
StringContainer* Context::new_stringconstant(std::string &string) {
	std::size_t hash = std::hash<std::string>()(string);
	auto &consts = strconsts[hash % (sizeof(strconsts) / sizeof(*strconsts))];
	for (auto sc: consts)
		if (sc->hash == hash && sc->data == string)
			return sc;

	auto sc = new StringContainer(string, hash, this, false);
	consts.push_back(sc);
	return sc;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x68(%rsp)
movq %rsi, 0x60(%rsp)
movq 0x68(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x57(%rsp), %rdi
callq 0x277a0
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x58(%rsp)
movq 0x58(%rsp), %rcx
andq $0x1f, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x48(%rsp)
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rdi
callq 0x16840
movq %rax, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x166c0
movq %rax, 0x30(%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x30(%rsp), %rsi
callq 0x275e0
testb $0x1, %al
jne 0x26146
jmp 0x2619b
leaq 0x38(%rsp), %rdi
callq 0x27620
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x58(%rsp), %rax
jne 0x2618d
movq 0x28(%rsp), %rdi
addq $0x20, %rdi
movq 0x60(%rsp), %rsi
callq 0x22ef0
testb $0x1, %al
jne 0x26181
jmp 0x2618d
movq 0x28(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2620a
jmp 0x2618f
leaq 0x38(%rsp), %rdi
callq 0x27630
jmp 0x26131
movl $0x40, %edi
callq 0x6460
movq 0x8(%rsp), %rcx
movq %rax, %rdi
movq %rdi, %rax
movq %rax, (%rsp)
movq 0x60(%rsp), %rsi
movq 0x58(%rsp), %rdx
xorl %r8d, %r8d
callq 0x20fd0
jmp 0x261c8
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x128b0
movq 0x20(%rsp), %rax
movq %rax, 0x70(%rsp)
jmp 0x2620a
movq (%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
movl $0x40, %esi
callq 0x6470
jmp 0x26214
movq 0x70(%rsp), %rax
addq $0x78, %rsp
retq
movq 0x18(%rsp), %rdi
callq 0x67a0
nop
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Env::set(asbi::StringContainer*, asbi::Value)
void Env::set(StringContainer* sc, Value val) {
	auto env = this;
	while (env != nullptr) {
		auto search = env->vars.find(sc);
		if (search != env->vars.end()) {
			search->second = val;
			return;
		}

		env = env->outer.get();
	}

	throw std::runtime_error("variable not found in env");
}

// Assembly:
subq $0x58, %rsp
movl %edx, 0x48(%rsp)
movq %rcx, 0x50(%rsp)
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x2641b
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
leaq 0x38(%rsp), %rsi
callq 0x27410
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rdi
addq $0x20, %rdi
callq 0x27440
movq %rax, 0x20(%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
callq 0x27380
testb $0x1, %al
jne 0x263e9
jmp 0x2640a
leaq 0x28(%rsp), %rdi
callq 0x27470
movq 0x48(%rsp), %rcx
movq %rcx, 0x8(%rax)
movq 0x50(%rsp), %rcx
movq %rcx, 0x10(%rax)
addq $0x58, %rsp
retq
movq 0x30(%rsp), %rdi
callq 0x8ba0
movq %rax, 0x30(%rsp)
jmp 0x263a1
movl $0x10, %edi
callq 0x6200
movq %rax, %rdi
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x12c9c(%rip), %rsi     # 0x390d3
callq 0x6160
jmp 0x2643e
movq 0x8(%rsp), %rdi
movq 0x25ba6(%rip), %rsi     # 0x4bff0
movq 0x25b4f(%rip), %rdx     # 0x4bfa0
callq 0x6780
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x18(%rsp)
movl %eax, 0x14(%rsp)
callq 0x6320
movq 0x18(%rsp), %rdi
callq 0x67a0
nopl (%rax,%rax)
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Context::~Context()
Context::~Context() {
	assert(stack.size() == 0);
	gc(nullptr);

	for (unsigned int i = 0; i < sizeof(strconsts) / sizeof(*strconsts); ++i)
		for (auto sc: strconsts[i])
			delete sc;

	for (auto lc: lambdas) {
		delete lc->ops;
		delete lc;
	}
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq 0x90(%rsp), %rdi
movq %rdi, 0x30(%rsp)
addq $0x508, %rdi            # imm = 0x508
callq 0x1d030
cmpq $0x0, %rax
jne 0x268e0
jmp 0x268ff
leaq 0x1282d(%rip), %rdi     # 0x39114
leaq 0x12838(%rip), %rsi     # 0x39126
movl $0x69, %edx
leaq 0x12837(%rip), %rcx     # 0x39131
callq 0x62b0
xorl %eax, %eax
movl %eax, %esi
leaq 0x80(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1f8f0
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1a910
jmp 0x26926
leaq 0x80(%rsp), %rdi
callq 0x7db0
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
cmpq $0x20, %rax
jae 0x269de
movq 0x30(%rsp), %rax
movl 0x7c(%rsp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, 0x70(%rsp)
movq 0x70(%rsp), %rdi
callq 0x16840
movq %rax, 0x68(%rsp)
movq 0x70(%rsp), %rdi
callq 0x166c0
movq %rax, 0x60(%rsp)
leaq 0x68(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0x275e0
testb $0x1, %al
jne 0x26991
jmp 0x269cc
leaq 0x68(%rsp), %rdi
callq 0x27620
movq (%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x269be
movq 0x20(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x269c0
leaq 0x68(%rsp), %rdi
callq 0x27630
jmp 0x2697c
jmp 0x269ce
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x2693b
movq 0x30(%rsp), %rax
addq $0x520, %rax            # imm = 0x520
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
callq 0x20b90
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
callq 0x20a10
movq %rax, 0x40(%rsp)
leaq 0x48(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x27650
testb $0x1, %al
jne 0x26a21
jmp 0x26a89
leaq 0x48(%rsp), %rdi
callq 0x27690
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x26a60
movq 0x18(%rsp), %rdi
callq 0x22e90
movq 0x18(%rsp), %rdi
movl $0x18, %esi
callq 0x6470
movq 0x38(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x26a7b
movq 0x10(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x26a7d
leaq 0x48(%rsp), %rdi
callq 0x276a0
jmp 0x26a0c
movq 0x30(%rsp), %rdi
addq $0x520, %rdi            # imm = 0x520
callq 0x27580
movq 0x30(%rsp), %rdi
addq $0x508, %rdi            # imm = 0x508
callq 0x232e0
movq 0x30(%rsp), %rdi
addq $0x4f8, %rdi            # imm = 0x4F8
callq 0x7db0
movq 0x30(%rsp), %rdi
addq $0x318, %rdi            # imm = 0x318
callq 0x2fa80
movq 0x30(%rsp), %rax
addq $0x300, %rax            # imm = 0x300
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
addq $-0x18, %rdi
movq %rdi, (%rsp)
callq 0x129f0
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
cmpq %rcx, %rax
movq %rax, 0x8(%rsp)
jne 0x26add
addq $0x98, %rsp
retq
movq %rax, %rdi
callq 0x7dc0
nopw %cs:(%rax,%rax)
// File: iamlouk[P]asbi/src/context.cc
// Function: asbi::Context::pop()
Value Context::pop() {
	Value v = stack.back();
	assert(stack.size() > 0);
	stack.pop_back();
	return v;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
addq $0x508, %rdi            # imm = 0x508
callq 0x23e00
movq 0x8(%rsp), %rdi
movq (%rax), %rcx
movq %rcx, 0x18(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
addq $0x508, %rdi            # imm = 0x508
callq 0x1d030
cmpq $0x0, %rax
jbe 0x26b99
jmp 0x26bb8
leaq 0x125ab(%rip), %rdi     # 0x3914b
leaq 0x1257f(%rip), %rsi     # 0x39126
movl $0x7c, %edx
leaq 0x125a9(%rip), %rcx     # 0x3915c
callq 0x62b0
movq 0x8(%rsp), %rdi
addq $0x508, %rdi            # imm = 0x508
callq 0x27730
movl 0x18(%rsp), %eax
movq 0x20(%rsp), %rdx
addq $0x28, %rsp
retq
nopw (%rax,%rax)