LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/ast.cc
// Function: ast::Block::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Block::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	int n = exprs.size();
	if (n == 0) {
		ops.push_back(OpCode::PUSH_NIL);
		return;
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
je 0xe7f8
movq %rsi, %r14
leal -0x1(%rcx), %edx
cmpl $0x2, %ecx
jl 0xe7e3
movq %rdi, %r15
movl %edx, 0x14(%rsp)
movl %edx, %r13d
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x9, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe7c8
movq $0x9, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe7d3
movq %rbx, %rdi
movq %r12, %rdx
callq 0xed48
incq %rbp
cmpq %rbp, %r13
jne 0xe790
movq 0x8(%r15), %rax
movl 0x14(%rsp), %edx
movslq %edx, %rcx
movq (%rax,%rcx,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xe829
movq $0x4, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe81c
movq $0x4, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe829
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/ast.cc
// Function: ast::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:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r13
cmpq %r13, %r12
je 0xe874
movq %rsi, %r15
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r12
cmpq %r13, %r12
jne 0xe85b
movq $0x1c, 0x8(%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xe89b
movq $0x1c, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe8b0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq 0x10(%r14), %rcx
subq 0x8(%r14), %rcx
sarq $0x3, %rcx
movq %rcx, 0x8(%rsp)
cmpq %rax, %rsi
je 0xe8d3
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe8e0
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/ast.cc
// Function: ast::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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rbp
cmpq %rbp, %r13
je 0xe9ae
movq %rsi, %r15
movq (%r13), %r12
movq 0x8(%r13), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x10, %r13
cmpq %rbp, %r13
jne 0xe981
movq $0x1b, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xe9d4
movq $0x1b, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe9e7
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq 0x10(%r14), %rcx
subq 0x8(%r14), %rcx
sarq $0x4, %rcx
movq %rcx, (%rsp)
cmpq %rax, %rsi
je 0xea09
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xea14
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/ast.cc
// Function: ast::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:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x8(%rdi), %rax
movq 0x10(%rax), %rdi
movq (%rdi), %rax
callq *0x18(%rax)
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq 0x8(%r15), %rax
movq 0x8(%rax), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x1e, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xeb86
movq $0x1e, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xeb93
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/ast.cc
// Function: ast::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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdi), %r12
cmpq 0x10(%rdi), %r12
je 0xebd4
movq -0x8(%r12), %rdi
addq $-0x8, %r12
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
cmpq 0x10(%r14), %r12
jne 0xebb9
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0xc, (%rsp)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
cmpq %rax, %rsi
je 0xec0a
movq $0xc, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xec1d
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rax
movq 0x18(%r14), %rcx
subq 0x10(%r14), %rcx
sarq $0x3, %rcx
movq %rcx, (%rsp)
cmpq %rax, %rsi
je 0xec3f
movq %rcx, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xec4a
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xed48
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x0, 0x10(%rdi)
je 0xf23b
retq
movb $0x1, 0x10(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xf24d
jmp 0x1083c
pushq %rax
leaq 0x89a7(%rip), %rdi      # 0x17bfc
leaq 0x8c24(%rip), %rsi      # 0x17e80
leaq 0x8c26(%rip), %rcx      # 0x17e89
movl $0x34, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x0, 0x10(%rdi)
jne 0xf34b
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb $0x1, 0x10(%rdi)
movq 0x28(%rdi), %r12
testq %r12, %r12
je 0xf317
leaq 0x10(%rsp), %r14
movq %rsp, %r15
movups 0x8(%r12), %xmm0
movups 0x18(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq 0xf34c
movq %r14, %rdi
callq 0xf34c
movq (%r12), %r12
testq %r12, %r12
jne 0xf2e9
movq 0x50(%rbx), %r14
movq 0x58(%rbx), %r15
cmpq %r15, %r14
je 0xf340
movq %rsp, %rbx
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf34c
addq $0x10, %r14
cmpq %r15, %r14
jne 0xf327
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movl %ecx, %ebp
movq %rdi, %r14
leaq 0x18(%rsp), %rdi
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x4(%rsp), %rsi
callq 0xf458
testb %al, %al
je 0xf42e
movl 0x4(%rsp), %r15d
movq 0x50(%r14), %rax
movq 0x58(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
ja 0xf425
leaq 0x50(%r14), %r12
leaq 0x8(%rsp), %r13
movl $0x2, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
cmpq 0x60(%r14), %rsi
je 0xf403
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
movq 0x58(%r14), %rsi
addq $0x10, %rsi
movq %rsi, 0x58(%r14)
jmp 0xf412
movq %r12, %rdi
movq %r13, %rdx
callq 0x10278
movq 0x58(%r14), %rsi
movq (%r12), %rax
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
jbe 0xf3d6
shlq $0x4, %r15
addq %rax, %r15
jmp 0xf442
addq $0x18, %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x103b8
movq %rax, %r15
movl %ebp, (%r15)
movq %rbx, 0x8(%r15)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/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:
cmpl $0x1, (%rdi)
jne 0xf4b3
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd 0x8(%rdi), %xmm0
movq %rsp, %r14
movq %r14, %rdi
callq 0x55f0
andpd 0x8934(%rip), %xmm0     # 0x17db0
movsd (%r14), %xmm1
movsd 0x8937(%rip), %xmm2     # 0x17dc0
cmpltpd %xmm2, %xmm0
xorpd %xmm2, %xmm2
cmplepd %xmm1, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
testb $0x1, %al
je 0xf4aa
cvttsd2si %xmm1, %rcx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf4b5
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %rdi
movl %esi, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0xc(%rsp), %rsi
callq 0xf458
testb %al, %al
je 0xf502
movl 0xc(%rsp), %eax
movq 0x50(%rbx), %rcx
movq 0x58(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0xf52a
shlq $0x4, %rax
leaq (%rcx,%rax), %rdx
addq %rax, %rcx
addq $0x8, %rcx
jmp 0xf523
addq $0x18, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x106da
testq %rax, %rax
je 0xf52a
movq %rax, %rcx
leaq 0x18(%rax), %rdx
addq $0x20, %rcx
movl (%rdx), %eax
movq (%rcx), %rdx
jmp 0xf531
movl $0x2, %eax
xorl %edx, %edx
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x643e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10a4c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf580
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movl $0x3, %eax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf5ae
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x643e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10a4c
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf5fe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movl $0x4, %eax
movq %rbx, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf62c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rax
movl (%rdi), %ecx
cmpl $0x8, %ecx
je 0xf943
movl (%rsi), %eax
cmpl $0x8, %eax
je 0xf962
cmpl %eax, %ecx
jne 0xf8ff
movb $0x1, %al
movl %ecx, %ecx
leaq 0x8502(%rip), %rdx      # 0x17dd0
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movq 0x8(%rdi), %rcx
movq 0x8(%rsi), %rsi
movq 0x28(%rcx), %rdx
cmpq 0x28(%rsi), %rdx
jne 0xf8ff
testq %rdx, %rdx
je 0xf92b
movq 0x20(%rsi), %rsi
movq 0x20(%rcx), %rdi
callq 0x53a0
testl %eax, %eax
jmp 0xf928
xorl %eax, %eax
jmp 0xf92b
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0xf928
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0xf92b
movb 0x8(%rdi), %al
cmpb 0x8(%rsi), %al
sete %al
popq %rcx
retq
movq 0x8(%rdi), %rdi
addq $0x18, %rdi
movq 0x8(%rsi), %rsi
addq $0x18, %rsi
popq %rax
jmp 0x10718
leaq 0x85db(%rip), %rdi      # 0x17f25
leaq 0x852f(%rip), %rsi      # 0x17e80
leaq 0x8597(%rip), %rcx      # 0x17eef
movl $0x9c, %edx
callq 0x5210
leaq 0x85b8(%rip), %rdi      # 0x17f21
leaq 0x8510(%rip), %rsi      # 0x17e80
leaq 0x8578(%rip), %rcx      # 0x17eef
movl $0x9d, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
movl (%rdi), %eax
leaq 0x8465(%rip), %rcx      # 0x17df0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rax
movq 0x18(%rax), %rax
retq
movq 0x8(%rdi), %rax
retq
movl $0xaffe, %eax           # imm = 0xAFFE
retq
movzbl 0x8(%rdi), %eax
orq $0xabc0, %rax           # imm = 0xABC0
retq
movsd 0x8(%rdi), %xmm0
cvttsd2si %xmm0, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x83fc(%rip), %xmm0     # 0x17dc8
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
retq
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
retq
pushq %rax
leaq 0x853c(%rip), %rdi      # 0x17f25
leaq 0x8490(%rip), %rsi      # 0x17e80
leaq 0x854f(%rip), %rcx      # 0x17f46
movl $0xb5, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
cmpb $0x0, 0x58(%rdi)
jne 0x108a6
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb $0x1, 0x58(%rdi)
movq 0x30(%rdi), %r15
testq %r15, %r15
je 0x10882
leaq 0x8(%rsp), %r14
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r15), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0xf34c
movq (%r15), %r15
testq %r15, %r15
jne 0x10860
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1088f
callq 0x1083c
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x1089d
callq 0x1083c
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbx
movq %rdi, %rbx
cmpb $0x1, 0x58(%rbx)
jne 0x108cc
movb $0x0, 0x58(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x108c3
callq 0x108a8
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x108ac
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsp, %r14
movq %rsi, (%r14)
leaq 0x20(%rbx), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x28(%rbx)
movq %rdx, %rsi
movq %r14, %rdx
callq 0x11626
testq %rax, %rax
je 0x1090e
movq (%rax), %rcx
testq %rcx, %rcx
jne 0x10974
movq (%rbx), %rbx
testq %rbx, %rbx
jne 0x108e1
movl $0x30, %edi
callq 0x51b0
movq %rax, %rbx
movq (%rsp), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x7c3e
movb $0x1, %bpl
leaq 0x766a(%rip), %rsi      # 0x17fb9
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xab12
xorl %ebp, %ebp
leaq 0xfcb3(%rip), %rsi      # 0x20618
leaq -0x59a0(%rip), %rdx     # 0xafcc
movq %rbx, %rdi
callq 0x55d0
movl 0x10(%rcx), %eax
movq 0x18(%rcx), %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x109a0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
testb %bpl, %bpl
jne 0x109aa
jmp 0x109b2
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
movq %rsi, 0x8(%rsp)
callq 0x1159a
movq %rax, %r12
andl $0x1f, %eax
leaq (%rax,%rax,2), %rax
movq (%rbx,%rax,8), %r14
movq %rbx, 0x18(%rsp)
movq %rax, 0x10(%rsp)
movq 0x8(%rbx,%rax,8), %rbx
cmpq %rbx, %r14
je 0x10aca
movq 0x8(%rsp), %rax
movq (%rax), %r13
movq 0x8(%rax), %rbp
movq (%r14), %r15
cmpq %r12, 0x18(%r15)
jne 0x10ac1
cmpq %rbp, 0x28(%r15)
jne 0x10ac1
testq %rbp, %rbp
je 0x10b24
movq 0x20(%r15), %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x53a0
testl %eax, %eax
je 0x10b24
addq $0x8, %r14
cmpq %rbx, %r14
jne 0x10a9a
movl $0x40, %edi
callq 0x5380
movq %rax, %r15
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movq %r12, %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xf09c
movq 0x10(%rsp), %rax
leaq (%rbx,%rax,8), %rdi
movq %r15, 0x20(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x10b14
movq %r15, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x10b24
leaq 0x20(%rsp), %rbx
movq %rbx, %rdx
callq 0xa492
movq (%rbx), %r15
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x40, %esi
movq %r15, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq %rsp, %r15
movq %rsi, (%r15)
leaq 0x20(%r14), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x28(%r14)
movq %rdx, %rsi
movq %r15, %rdx
callq 0x11626
testq %rax, %rax
je 0x10c5a
movq (%rax), %rax
testq %rax, %rax
jne 0x10c94
movq (%r14), %r14
testq %r14, %r14
jne 0x10c2d
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x7343(%rip), %rsi      # 0x17fb9
movq %rax, %rdi
callq 0x5150
movq 0x1036b(%rip), %rsi     # 0x20ff0
movq 0x10324(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/context.cc
// Function: asbi::Context::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<asbi::Env>)
Value Context::run(const std::string& str, std::shared_ptr<Env> env) {
	tok::Tokenizer toker(str);
	Parser parser(toker, this);
	auto ast = parser.parse()->optimize();
	std::vector<OpCode> ops;
	ast->to_vmops(this, ops);
	delete ast;

	return execute(ops, env, this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0x70(%rsp)
movl $0x1, 0x78(%rsp)
movq %rsi, 0x80(%rsp)
movq $0x25, 0x88(%rsp)
movl $0x0, 0x90(%rsp)
movb $0x0, 0x98(%rsp)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8024
movq %r15, %rdi
callq 0x80ac
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r15
leaq 0x40(%rsp), %rdx
movq %r12, 0x10(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq (%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x10110
movq (%r14), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x112e1
movq 0xfce5(%rip), %rcx      # 0x20fb8
cmpb $0x0, (%rcx)
je 0x112dd
incl 0x8(%rax)
jmp 0x112e1
lock
incl 0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rbx, %rdx
callq 0xc19c
movl %eax, %ebx
movq %rdx, %r14
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x11307
callq 0x65d6
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x1131e
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x11335
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movl %ebx, %eax
movq %r14, %rdx
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1135b
callq 0x65d6
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x11377
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
jmp 0x11377
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x1138e
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/context.cc
// Function: asbi::Env::to_map(asbi::Context*) const
Value Env::to_map(Context* ctx) const {
	auto mc = new MapContainer(ctx);
	for (auto [name, value]: vars) {
		mc->set(Value::string(name), value);
	}

	if (outer != nullptr)
		mc->set(Value::symbol("outer_scope", ctx), outer->to_map(ctx));

	return Value::map(mc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x68, %edi
callq 0x5380
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xf274
movq 0x30(%r15), %r12
testq %r12, %r12
je 0x11539
movq 0x8(%r12), %rdx
movl 0x10(%r12), %ecx
movq 0x18(%r12), %r8
movq %rbx, %rdi
movl $0x4, %esi
callq 0xf382
movq (%r12), %r12
jmp 0x11512
cmpq $0x0, (%r15)
je 0x11570
leaq 0x6b17(%rip), %rdi      # 0x1805d
movq %r14, %rsi
callq 0xf538
movl %eax, %ebp
movq %rdx, %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0x114e8
movq %rdx, %r8
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0xf382
movl $0x6, %eax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_assert(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_assert(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n == 2) {
		auto msg = ctx->pop();
		auto val = ctx->pop();
		if (!(val == Value::boolean(true))) {
			std::cerr << "==asbi==: Assertion failed: " << val.to_string(true) << " (" << msg.to_string(false) << ")\n";
			throw std::runtime_error("assertion failed");
		}
		return Value::nil();
	}

	throw std::runtime_error("assert macro usage error");
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
cmpl $0x2, %edi
jne 0x11f2e
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11122
movl %eax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rbx, %rdi
callq 0x11122
leaq 0x58(%rsp), %rdi
movl %eax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x28(%rsp), %rsi
movq $0x0, (%rsi)
movb $0x1, (%rsi)
movq (%rsi), %rax
movl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
callq 0xf8a8
testb %al, %al
je 0x11f60
movl $0x2, %eax
xorl %edx, %edx
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x625e(%rip), %rsi      # 0x181a0
movq %rax, %rdi
callq 0x5150
movq 0xf09f(%rip), %rsi      # 0x20ff0
movq 0xf058(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
movq 0xf081(%rip), %rbx      # 0x20fe8
leaq 0x6204(%rip), %rsi      # 0x18172
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x5400
leaq 0x28(%rsp), %r14
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xfa02
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x5400
movq %rax, %rbx
leaq 0x59ec(%rip), %rsi      # 0x17997
movl $0x2, %edx
movq %rax, %rdi
callq 0x5400
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0xfa02
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x5400
leaq 0x5120(%rip), %rsi      # 0x17102
movl $0x2, %edx
movq %rax, %rdi
callq 0x5400
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1200a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12025
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x6156(%rip), %rsi      # 0x1818f
movq %rax, %rdi
callq 0x5150
jmp 0x11f4a
jmp 0x1206a
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1207a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x1207a
jmp 0x12077
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x12095
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12095
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_mod(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_mod(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 2)
		throw std::runtime_error("mod macro usage error");

	auto a = ctx->pop();
	auto b = ctx->pop();
	if (a.type != type_t::Number || b.type != type_t::Number)
		throw std::runtime_error("mod macro usage error");

	return Value::number(static_cast<int>(a._number) % static_cast<int>(b._number));
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %edi
jne 0x120f3
movq %rsi, %r14
movq %rsi, %rdi
callq 0x11122
movl %eax, %ebp
movq %rdx, %rbx
movq %r14, %rdi
callq 0x11122
cmpl $0x1, %ebp
jne 0x12111
cmpl $0x1, %eax
jne 0x12111
movq %rdx, %xmm0
movq %rbx, %xmm1
cvttsd2si %xmm1, %eax
cvttsd2si %xmm0, %ecx
cltd
idivl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movq %xmm0, %rdx
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x60b2(%rip), %rsi      # 0x181b9
movq %rax, %rdi
callq 0x5150
jmp 0x1212d
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x6094(%rip), %rsi      # 0x181b9
movq %rax, %rdi
callq 0x5150
movq 0xeebc(%rip), %rsi      # 0x20ff0
movq 0xee75(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x12145
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_toInt(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_toInt(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("toInt macro usage error");

	auto num = ctx->pop();
	if (num.type != type_t::Number)
		throw std::runtime_error("toInt macro usage error");

	return Value::number(floor(num._number));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x121fa
movq %rsi, %rdi
callq 0x11122
cmpl $0x1, %eax
jne 0x12218
movq %rdx, %xmm0
callq 0x55a0
movq %xmm0, %rdx
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5fda(%rip), %rsi      # 0x181e8
movq %rax, %rdi
callq 0x5150
jmp 0x12234
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5fbc(%rip), %rsi      # 0x181e8
movq %rax, %rdi
callq 0x5150
movq 0xedb5(%rip), %rsi      # 0x20ff0
movq 0xed6e(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x1224c
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_len(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_len(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("len macro usage error");

	auto val = ctx->pop();
	if (val.type == type_t::Map)
		return Value::number(val._map->vecdata.size());

	if (val.type == type_t::String)
		return Value::number(val._string->data.size());

	throw std::runtime_error("len macro usage error");
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x122bf
movq %rsi, %rdi
callq 0x11122
cmpl $0x4, %eax
je 0x12288
cmpl $0x6, %eax
jne 0x122dd
movq 0x58(%rdx), %rax
subq 0x50(%rdx), %rax
sarq $0x4, %rax
jmp 0x1228c
movq 0x28(%rdx), %rax
movq %rax, %xmm0
punpckldq 0x5de7(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5def(%rip), %xmm0     # 0x18090
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq %xmm1, %rdx
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5f2d(%rip), %rsi      # 0x18200
movq %rax, %rdi
callq 0x5150
jmp 0x122f9
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5f0f(%rip), %rsi      # 0x18200
movq %rax, %rdi
callq 0x5150
movq 0xecf0(%rip), %rsi      # 0x20ff0
movq 0xeca9(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x12311
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_debug(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_debug(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("__debug macro usage error");

	std::cerr << "==asbi==: Stack start" << '\n';
	for (unsigned int i = 0; i < ctx->stack.size(); ++i) {
		std::cerr << i << ": " << ctx->stack[i].to_string(true) << '\n';
	}
	std::cerr << "==asbi==: Stack end" << '\n';

	return ctx->pop();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jne 0x12480
movq %rsi, %rbx
movq 0xeca3(%rip), %r14      # 0x20fe8
leaq 0x5ee4(%rip), %rsi      # 0x18230
movl $0x15, %edx
movq %r14, %rdi
callq 0x5400
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5400
movq 0x510(%rbx), %rax
cmpq 0x508(%rbx), %rax
je 0x12439
movl $0x1, %r15d
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %r13
movq 0xec4d(%rip), %rdi      # 0x20fe8
movq %rbp, %rsi
callq 0x5230
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
leaq 0x638d(%rip), %rsi      # 0x18742
callq 0x5400
shlq $0x4, %rbp
addq 0x508(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0xfa02
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x5400
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x5400
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12418
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x510(%rbx), %rax
subq 0x508(%rbx), %rax
movl %r15d, %ebp
sarq $0x4, %rax
incl %r15d
cmpq %rbp, %rax
ja 0x12394
movq 0xeba8(%rip), %r14      # 0x20fe8
leaq 0x5dff(%rip), %rsi      # 0x18246
movl $0x13, %edx
movq %r14, %rdi
callq 0x5400
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5400
movq %rbx, %rdi
callq 0x11122
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x5d82(%rip), %rsi      # 0x18216
movq %rax, %rdi
callq 0x5150
movq 0xeb4d(%rip), %rsi      # 0x20ff0
movq 0xeb06(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x124de
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x124de
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_typeof(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_typeof(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("typeof macro usage error");

	auto arg = ctx->pop();
	switch (arg.type) {
	case type_t::Bool:
		return Value::symbol("bool", ctx);
	case type_t::Number:
		return Value::symbol("number", ctx);
	case type_t::Nil:
		return Value::symbol("nil", ctx);
	case type_t::Symbol:
		return Value::symbol("symbol", ctx);
	case type_t::String:
		return Value::symbol("string", ctx);
	case type_t::Lambda:
		return Value::symbol("function", ctx);
	case type_t::Map:
		return Value::symbol("map", ctx);
	case type_t::Macro:
		return Value::symbol("function", ctx);
	case type_t::StackPlaceholder:
		assert(false);
		return Value::symbol("internal_stack_placeholder", ctx);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x1293c
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11122
movl %eax, %eax
leaq 0x57b9(%rip), %rcx      # 0x180a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x59d5(%rip), %rdi      # 0x182cc
jmp 0x1292d
leaq 0x536e(%rip), %rdi      # 0x17c6e
jmp 0x1292d
leaq 0x5396(%rip), %rdi      # 0x17c9f
jmp 0x1292d
leaq 0x63d6(%rip), %rdi      # 0x18ce8
jmp 0x1292d
leaq 0x59aa(%rip), %rdi      # 0x182c5
jmp 0x1292d
leaq 0x599c(%rip), %rdi      # 0x182c0
jmp 0x1292d
leaq 0x5351(%rip), %rdi      # 0x17c7e
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf538
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5957(%rip), %rsi      # 0x182a7
movq %rax, %rdi
callq 0x5150
movq 0xe691(%rip), %rsi      # 0x20ff0
movq 0xe64a(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
leaq 0x4ad4(%rip), %rdi      # 0x17449
leaq 0x5959(%rip), %rsi      # 0x182d5
leaq 0x595c(%rip), %rcx      # 0x182df
movl $0x9a, %edx
callq 0x5210
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_eval(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_eval(int n, Context* ctx, std::shared_ptr<Env> callerenv) {
	if (n != 2)
		throw std::runtime_error("eval macro usage error");

	auto string = ctx->pop();
	auto envdepth = ctx->pop();
	if (string.type != type_t::String || envdepth.type != type_t::Number)
		throw std::runtime_error("eval macro usage error");

	auto env = callerenv;
	for (int i = 0; i < envdepth._number; i++) {
		if (callerenv->getOuter() == nullptr)
			break;

		env = callerenv->getOuter();
	}

	return ctx->run(string._string->data, env);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, %edi
jne 0x13025
movq %rdx, %r14
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11122
movl %eax, %ebp
movq %rdx, 0x20(%rsp)
movq %rbx, %rdi
callq 0x11122
cmpl $0x4, %ebp
jne 0x13043
cmpl $0x1, %eax
jne 0x13043
movq %rdx, (%rsp)
movq (%r14), %r13
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x12f10
movq 0xe0ba(%rip), %rax      # 0x20fb8
cmpb $0x0, (%rax)
je 0x12f0a
incl 0x8(%r12)
jmp 0x12f10
lock
incl 0x8(%r12)
movq %rbx, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x12faf
movl $0x1, %ebp
movq 0xe084(%rip), %rbx      # 0x20fb8
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x12f4d
cmpb $0x0, (%rbx)
je 0x12f57
incl 0x8(%rdi)
jmp 0x12f5b
testq %r15, %r15
je 0x12faf
movq %r15, %r13
jmp 0x12f7f
lock
incl 0x8(%rdi)
callq 0x65d6
testq %r15, %r15
je 0x12faf
movq (%r14), %rax
movq (%rax), %r13
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x12f7f
cmpb $0x0, (%rbx)
je 0x12fa8
incl 0x8(%r15)
jmp 0x12f82
xorl %r15d, %r15d
testq %r12, %r12
je 0x12f8f
movq %r12, %rdi
callq 0x65d6
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %r15, %r12
ja 0x12f34
jmp 0x12fb2
lock
incl 0x8(%r15)
jmp 0x12f82
movq %r12, %r15
movq 0x20(%rsp), %rsi
addq $0x20, %rsi
movq %r13, 0x8(%rsp)
movq %r15, 0x10(%rsp)
testq %r15, %r15
movq 0x18(%rsp), %rdi
je 0x12fe6
movq 0xdfe2(%rip), %rax      # 0x20fb8
cmpb $0x0, (%rax)
je 0x12fe1
incl 0x8(%r15)
jmp 0x12fe6
lock
incl 0x8(%r15)
leaq 0x8(%rsp), %rdx
callq 0x111ee
movl %eax, %ebx
movq %rdx, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13004
callq 0x65d6
testq %r15, %r15
je 0x13011
movq %r15, %rdi
callq 0x65d6
movl %ebx, %eax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x530e(%rip), %rsi      # 0x18347
movq %rax, %rdi
callq 0x5150
jmp 0x1305f
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x52f0(%rip), %rsi      # 0x18347
movq %rax, %rdi
callq 0x5150
movq 0xdf8a(%rip), %rsi      # 0x20ff0
movq 0xdf43(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
jmp 0x13077
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x130a3
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13096
callq 0x65d6
testq %r15, %r15
je 0x130a3
movq %r15, %rdi
callq 0x65d6
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_io_print(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_io_print(int n, Context* ctx, std::shared_ptr<Env>) {
	for (int i = 0; i < n; i++) {
		std::cout << ctx->pop().to_string(false);
	}
	std::cout << std::flush;
	return Value::nil();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %edi, %edi
jle 0x13123
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq 0xdee8(%rip), %r12      # 0x20fc0
movq %rbx, %rdi
callq 0x11122
movl %eax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xfa02
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x5400
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1311f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
decl %ebp
jne 0x130d8
movq 0xde96(%rip), %rdi      # 0x20fc0
callq 0x5240
movl $0x2, %eax
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1315f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_io_println(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_io_println(int n, Context* ctx, std::shared_ptr<Env>) {
	for (int i = 0; i < n; i++) {
		std::cout << ctx->pop().to_string(false);
	}
	std::cout << '\n' << std::flush;
	return Value::nil();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %edi, %edi
jle 0x131df
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq 0xde2c(%rip), %r12      # 0x20fc0
movq %rbx, %rdi
callq 0x11122
movl %eax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xfa02
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x5400
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x131db
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
decl %ebp
jne 0x13194
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movq 0xddd2(%rip), %rdi      # 0x20fc0
movl $0x1, %edx
callq 0x5400
movq %rax, %rdi
callq 0x5240
movl $0x2, %eax
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x13230
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_io_readline(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_io_readline(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("io:readline macro usage error");

	auto lambda = ctx->pop();
	if (lambda.type != type_t::Lambda)
		throw std::runtime_error("io:readline macro usage error");

	ctx->evtloop.addTask(lambda._lambda, [ctx](evts::callback_t cb) -> void {
		char* line = readline("");
		std::vector<Value> args;
		if (line == NULL)
			args.push_back(Value::nil());
		else
			args.push_back(Value::string(line, ctx));
		cb(&args, true);
		free(line);
	});

	return Value::nil();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpl $0x1, %edi
jne 0x132bb
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11122
cmpl $0x5, %eax
jne 0x132d9
leaq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq %rbx, (%rax)
addq $0x318, %rbx            # imm = 0x318
leaq 0x1ee(%rip), %rcx       # 0x13464
movq %rcx, 0x18(%rax)
leaq 0x36b(%rip), %rcx       # 0x135ec
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x14c96
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x132ac
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl $0x2, %eax
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x508f(%rip), %rsi      # 0x1835e
movq %rax, %rdi
callq 0x5150
jmp 0x132f5
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5071(%rip), %rsi      # 0x1835e
movq %rax, %rdi
callq 0x5150
movq 0xdcf4(%rip), %rsi      # 0x20ff0
movq 0xdcad(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x1330d
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0x13338
jmp 0x13340
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x13338
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x55e0
movq %rax, %rdi
callq 0x647b
// File: /workspace/github_cpp_makefile_star2_O3/iamlouk[P]asbi/src/macros.cc
// Function: macro_time_runAt(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_time_runAt(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 2)
		throw std::runtime_error("time:runat macro usage error");

	auto timestamp = ctx->pop();
	auto callback = ctx->pop();
	if (timestamp.type != type_t::Number || callback.type != type_t::Lambda)
		throw std::runtime_error("time:runat macro usage error");

	ctx->evtloop.addTimer(callback._lambda, timestamp._number);
	return Value::nil();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
cmpl $0x2, %edi
jne 0x133ff
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11122
movl %eax, %ebp
movq %rdx, %r14
movq %rbx, %rdi
callq 0x11122
cmpl $0x1, %ebp
jne 0x1341d
cmpl $0x5, %eax
jne 0x1341d
movq %r14, %xmm0
addq $0x318, %rbx            # imm = 0x318
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x15004
movl $0x2, %eax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x4f84(%rip), %rsi      # 0x18397
movq %rax, %rdi
callq 0x5150
jmp 0x13439
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x4f66(%rip), %rsi      # 0x18397
movq %rax, %rdi
callq 0x5150
movq 0xdbb0(%rip), %rsi      # 0x20ff0
movq 0xdb69(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x13451
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0