LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r12
movq 0x10(%rdi), %r13
cmpq %r13, %r12
je 0xcf21
movq (%r12), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
addq $0x8, %r12
jmp 0xcf06
leaq 0x8(%rsp), %r15
movq $0x1c, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
movq %rax, (%r15)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xd2e0
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rbp
cmpq %rbp, %r13
je 0xd005
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
jmp 0xcfd6
movq %rsp, %r15
movq $0x1b, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x4, %rax
movq %rax, (%r15)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/ast.cc
// Function: ast::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)
leaq 0x8(%rsp), %rsi
movq $0x1e, (%rsi)
movq %rbx, %rdi
callq 0xd2e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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(%r14), %r12
je 0xd194
movq -0x8(%r12), %rdi
addq $-0x8, %r12
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xd177
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq %rsp, %r15
movq $0xc, (%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xd2e0
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x3, %rax
movq %rax, (%r15)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xd2e0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd7d7
retq
movb $0x1, 0x10(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xd7e9
jmp 0xeab2
pushq %rax
leaq 0x741b(%rip), %rdi      # 0x14c0c
leaq 0x7698(%rip), %rsi      # 0x14e90
leaq 0x769a(%rip), %rcx      # 0x14e99
pushq $0x34
popq %rdx
callq 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd8d5
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movb $0x1, 0x10(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x10(%rsp), %r14
movq %rsp, %r15
movq (%r12), %r12
testq %r12, %r12
je 0xd8a4
movups 0x8(%r12), %xmm0
movups 0x18(%r12), %xmm1
movaps %xmm1, 0x10(%rsp)
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq 0xd8d6
movq %r14, %rdi
callq 0xd8d6
jmp 0xd874
movq 0x50(%rbx), %r14
movq 0x58(%rbx), %r15
movq %rsp, %rbx
cmpq %r15, %r14
je 0xd8ca
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xd8d6
addq $0x10, %r14
jmp 0xd8af
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd9a8
testb %al, %al
je 0xd978
leaq 0x50(%r14), %r15
movl 0x4(%rsp), %r13d
leaq 0x8(%rsp), %r12
movq 0x50(%r14), %rax
movq 0x58(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r13, %rcx
ja 0xd98b
movl $0x2, 0x8(%rsp)
andq $0x0, 0x10(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe3d6
jmp 0xd949
addq $0x18, %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0xe556
jmp 0xd992
shlq $0x4, %r13
addq %r13, %rax
movl %ebp, (%rax)
movq %rbx, 0x8(%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/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 0xda03
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd 0x8(%rdi), %xmm0
movq %rsp, %r14
movq %r14, %rdi
callq 0x5610
andpd 0x73f4(%rip), %xmm0     # 0x14dc0
movsd (%r14), %xmm1
movsd 0x73f7(%rip), %xmm2     # 0x14dd0
cmpltpd %xmm2, %xmm0
xorpd %xmm2, %xmm2
cmplepd %xmm1, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
testb $0x1, %al
je 0xd9fa
cvttsd2si %xmm1, %rcx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xda05
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xd9a8
testb %al, %al
je 0xda52
movl 0xc(%rsp), %eax
movq 0x50(%rbx), %rcx
movq 0x58(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0xda7a
shlq $0x4, %rax
leaq (%rcx,%rax), %rdx
addq %rax, %rcx
addq $0x8, %rcx
jmp 0xda73
addq $0x18, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0xe924
testq %rax, %rax
je 0xda7a
movq %rax, %rcx
leaq 0x18(%rax), %rdx
addq $0x20, %rcx
movl (%rdx), %eax
movq (%rcx), %rdx
jmp 0xda7f
pushq $0x2
popq %rax
xorl %edx, %edx
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/types.cc
// Function: asbi::Value::call(asbi::Context*, unsigned int, std::shared_ptr<asbi::Env>) const
Value Value::call(Context *ctx, unsigned int n, std::shared_ptr<Env> callerenv) const {
	switch (type) {
	case type_t::Lambda:{
		if (_lambda->argnames.size() != n)
			throw std::runtime_error("callable argnum does not match call");

		auto lbdenv = std::make_shared<Env>(ctx, _lambda->env);
		for (unsigned int i = 0; i < n; ++i)
			lbdenv->decl(_lambda->argnames[i], ctx->pop());

		lbdenv->caller = callerenv;
		return execute(*_lambda->ops, lbdenv, ctx);
	}
	case type_t::Macro:
		return _macro(n, ctx, callerenv);
	default:
		throw std::runtime_error("not callable");
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movq %rdi, %r14
movq %rsi, 0x8(%rsp)
movl (%rdi), %eax
cmpl $0x7, %eax
je 0xdbe2
cmpl $0x5, %eax
jne 0xdc8c
movq 0x8(%r14), %rdx
movq 0x38(%rdx), %r13
subq 0x30(%rdx), %r13
sarq $0x3, %r13
movl %ebp, %eax
cmpq %rax, %r13
jne 0xdca8
addq $0x18, %rdx
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc019
xorl %ebp, %ebp
movq 0x10(%rsp), %r15
cmpq %rbp, %r13
je 0xdc10
movq 0x8(%r14), %rax
movq 0x30(%rax), %rax
movq (%rax,%rbp,8), %r12
movq 0x8(%rsp), %rdi
callq 0xf1b4
movq %rdx, %rcx
movq %r15, %rdi
movq %r12, %rsi
movl %eax, %edx
callq 0xed22
incq %rbp
jmp 0xdbad
movq %rsi, %r15
movq 0x8(%r14), %r12
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x6356
movl %ebp, %edi
movq %r15, %rsi
movq %r14, %rdx
callq *%r12
movl %eax, %ebx
movq %rdx, %r14
leaq 0x28(%rsp), %rdi
jmp 0xdc73
addq $0x10, %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc03a
movq 0x8(%r14), %rax
movq 0x28(%rax), %rsi
leaq 0x40(%rsp), %rdi
callq 0xe238
leaq 0x30(%rsp), %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x6356
movq 0x8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0xb238
movl %eax, %ebx
movq %rdx, %r14
leaq 0x38(%rsp), %rdi
callq 0x638a
leaq 0x40(%rsp), %rdi
callq 0xe954
leaq 0x18(%rsp), %rdi
callq 0x638a
movl %ebx, %eax
movq %r14, %rdx
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x7254(%rip), %rsi      # 0x14ef2
movq %rax, %rdi
callq 0x5120
jmp 0xdcc2
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x7214(%rip), %rsi      # 0x14ece
movq %rax, %rdi
callq 0x5120
movq 0x12327(%rip), %rsi     # 0x1fff0
movq 0x122d8(%rip), %rdx     # 0x1ffa8
movq %r14, %rdi
callq 0x55f0
jmp 0xdcda
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
jmp 0xdd19
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x638a
leaq 0x40(%rsp), %rdi
callq 0xe954
jmp 0xdd0f
jmp 0xdd0c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xdd14
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x638a
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/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), %eax
cmpl $0x8, %eax
je 0xdda9
movl (%rsi), %ecx
cmpl $0x8, %ecx
je 0xddc8
cmpl %ecx, %eax
jne 0xdd61
movl %eax, %eax
leaq 0x709e(%rip), %rcx      # 0x14de0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq 0x8(%rdi), %rdi
addq $0x20, %rdi
movq 0x8(%rsi), %rsi
addq $0x20, %rsi
popq %rax
jmp 0xe285
xorl %eax, %eax
jmp 0xdd91
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0xdd79
movb $0x1, %al
jmp 0xdd91
movb 0x8(%rdi), %al
cmpb 0x8(%rsi), %al
sete %al
jmp 0xdd91
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
popq %rcx
retq
movq 0x8(%rdi), %rdi
addq $0x18, %rdi
movq 0x8(%rsi), %rsi
addq $0x18, %rsi
popq %rax
jmp 0xe998
leaq 0x7185(%rip), %rdi      # 0x14f35
leaq 0x70d9(%rip), %rsi      # 0x14e90
leaq 0x7141(%rip), %rcx      # 0x14eff
movl $0x9c, %edx
callq 0x5220
leaq 0x7162(%rip), %rdi      # 0x14f31
leaq 0x70ba(%rip), %rsi      # 0x14e90
leaq 0x7122(%rip), %rcx      # 0x14eff
movl $0x9d, %edx
callq 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x700f(%rip), %rcx      # 0x14e00
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 0x6fa6(%rip), %xmm0     # 0x14dd8
cvttsd2si %xmm0, %rax
andq %rdx, %rax
orq %rcx, %rax
retq
movq 0x8(%rdi), %rax
movq 0x28(%rax), %rax
retq
pushq %rax
leaq 0x70e6(%rip), %rdi      # 0x14f35
leaq 0x703a(%rip), %rsi      # 0x14e90
leaq 0x70f9(%rip), %rcx      # 0x14f56
movl $0xb5, %edx
callq 0x5220
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xeb19
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb $0x1, 0x58(%rdi)
leaq 0x30(%rdi), %r15
leaq 0x8(%rsp), %r14
movq (%r15), %r15
testq %r15, %r15
je 0xeaf5
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r15), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0xd8d6
jmp 0xead1
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xeb02
callq 0xeab2
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xeb10
callq 0xeab2
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0xeb3e
movb $0x0, 0x58(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xeb35
callq 0xeb1a
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0xeb1e
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rsi, (%r14)
testq %rbx, %rbx
je 0xeb80
leaq 0x20(%rbx), %rdi
movq %r14, %rsi
callq 0xf658
testq %rax, %rax
jne 0xeb6e
movq (%rbx), %rbx
jmp 0xeb53
movl 0x10(%rax), %ecx
movq 0x18(%rax), %rdx
movl %ecx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x30
popq %rdi
callq 0x51b0
movq %rax, %rbx
movq 0x8(%rsp), %rsi
addq $0x20, %rsi
leaq 0x10(%rsp), %rdi
callq 0x54d0
movb $0x1, %bpl
leaq 0x6422(%rip), %rsi      # 0x14fca
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x9fac
xorl %ebp, %ebp
leaq 0x10a52(%rip), %rsi     # 0x1f610
leaq -0x47f3(%rip), %rdx     # 0xa3d2
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x5170
testb %bpl, %bpl
jne 0xebe4
jmp 0xebec
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0xf594
movq %rax, %r12
andl $0x1f, %eax
imulq $0x18, %rax, %rax
leaq (%rbx,%rax), %rcx
movq %rcx, 0x8(%rsp)
movq (%rbx,%rax), %rbp
movq 0x8(%rbx,%rax), %r15
cmpq %r15, %rbp
je 0xecc3
movq (%rbp), %r13
cmpq %r12, 0x18(%r13)
jne 0xecbd
leaq 0x20(%r13), %rdi
movq %r14, %rsi
callq 0xe285
testb %al, %al
jne 0xecfa
addq $0x8, %rbp
jmp 0xec9e
pushq $0x40
popq %rdi
callq 0x5390
movq %rax, %r13
movq %rax, %rdi
movq %r14, %rsi
movq %r12, %rdx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xd690
leaq 0x10(%rsp), %rbx
movq %r13, (%rbx)
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x9448
movq (%rbx), %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x40
popq %rsi
movq %r13, %rdi
callq 0x53a0
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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)
testq %r14, %r14
je 0xee0c
leaq 0x20(%r14), %rdi
movq %r15, %rsi
callq 0xf658
testq %rax, %rax
jne 0xedfa
movq (%r14), %r14
jmp 0xeddf
movl %ebp, 0x10(%rax)
movq %rbx, 0x18(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x61ac(%rip), %rsi      # 0x14fca
movq %rax, %rdi
callq 0x5120
movq 0x111c3(%rip), %rsi     # 0x1fff0
movq 0x11174(%rip), %rdx     # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/context.cc
// Function: asbi::Context::Context()
Context::Context(): evtloop(this, 0) {
	global_env = std::make_shared<Env>(this, nullptr);

	std::string str = "__file";
	names.__file = new_stringconstant(str);
	str = "__main";
	names.__main = new_stringconstant(str);
	str = "__imports";
	names.__imports = new_stringconstant(str);
	str = "exports";
	names.exports = new_stringconstant(str);
	str = "ok";
	names.ok = new_stringconstant(str);
	str = "err";
	names.err = new_stringconstant(str);

	load_macros();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movl $0x310, %edx            # imm = 0x310
xorl %esi, %esi
callq 0x5200
movq $0x200, 0x310(%rbx) # imm = 0x200
leaq 0x318(%rbx), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x11f14
xorps %xmm0, %xmm0
movups %xmm0, 0x528(%rbx)
movups %xmm0, 0x518(%rbx)
movups %xmm0, 0x508(%rbx)
movups %xmm0, 0x4f8(%rbx)
leaq 0x28(%rsp), %rsi
movq %rbx, (%rsi)
leaq 0x30(%rsp), %rdx
andq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
callq 0xf555
leaq 0x4f8(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0xc1c0
leaq 0x10(%rsp), %rdi
callq 0x638a
leaq 0x60ff(%rip), %rsi      # 0x14fe4
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x60ee
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec64
movq %rax, 0x538(%rbx)
leaq 0x60dc(%rip), %rsi      # 0x14feb
leaq 0x8(%rsp), %rdi
callq 0x5660
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec64
movq %rax, 0x540(%rbx)
leaq 0x60be(%rip), %rsi      # 0x14ff2
leaq 0x8(%rsp), %rdi
callq 0x5660
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec64
movq %rax, 0x548(%rbx)
leaq 0x60a3(%rip), %rsi      # 0x14ffc
leaq 0x8(%rsp), %rdi
callq 0x5660
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec64
movq %rax, 0x550(%rbx)
leaq 0x6086(%rip), %rsi      # 0x15004
leaq 0x8(%rsp), %rdi
callq 0x5660
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec64
movq %rax, 0x558(%rbx)
leaq 0x6064(%rip), %rsi      # 0x15007
leaq 0x8(%rsp), %rdi
callq 0x5660
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0xec64
movq %rax, 0x560(%rbx)
movq %rbx, %rdi
callq 0xfcd8
leaq 0x8(%rsp), %rdi
callq 0x5170
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xefe1
movq %rax, %r15
jmp 0xeff8
movq %rax, %r15
jmp 0xf027
movq %rax, %r15
leaq 0x8(%rsp), %rdi
callq 0x5170
leaq 0x508(%rbx), %r12
leaq 0x520(%rbx), %rdi
callq 0xfb02
movq %r12, %rdi
callq 0xe2ee
leaq 0x500(%rbx), %rdi
callq 0x638a
movq %r14, %rdi
callq 0x12076
movl $0x2e8, %r14d           # imm = 0x2E8
leaq (%rbx,%r14), %rdi
callq 0x96d2
addq $-0x18, %r14
cmpq $-0x18, %r14
jne 0xf02d
movq %r15, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0xe0, %rsp
movq %rdx, %r14
andq $0x0, 0x40(%rsp)
movq %rdi, %rbx
movl $0x1, 0x48(%rsp)
movq %rsi, 0x50(%rsp)
movq $0x25, 0x58(%rsp)
andl $0x0, 0x60(%rsp)
movb $0x0, 0x68(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x794c
movq %r15, %rdi
callq 0x79d2
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r15
xorps %xmm0, %xmm0
leaq 0x70(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq (%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xe238
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x6356
leaq 0x90(%rsp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xb238
movl %eax, %ebx
movq %rdx, %r14
leaq 0x38(%rsp), %rdi
callq 0x638a
leaq 0x90(%rsp), %rdi
callq 0xe954
leaq 0x70(%rsp), %rdi
callq 0xe954
movl %ebx, %eax
movq %r14, %rdx
addq $0xe0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x638a
leaq 0x90(%rsp), %rdi
callq 0xe954
jmp 0xf38f
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0xe954
movq %rbx, %rdi
callq 0x5600
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x68
popq %rdi
callq 0x5390
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xd80c
leaq 0x30(%r15), %r12
pushq $0x4
popq %rbp
movq (%r12), %r12
testq %r12, %r12
je 0xf4f9
movq 0x8(%r12), %rdx
movl 0x10(%r12), %ecx
movq 0x18(%r12), %r8
movq %rbx, %rdi
movl %ebp, %esi
callq 0xd90c
jmp 0xf4d5
cmpq $0x0, (%r15)
je 0xf530
leaq 0x5b68(%rip), %rdi      # 0x1506e
movq %r14, %rsi
callq 0xda86
movl %eax, %ebp
movq %rdx, %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0xf4aa
movq %rdx, %r8
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0xd90c
pushq $0x6
popq %rax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
pushq $0x68
popq %rsi
movq %rbx, %rdi
callq 0x53a0
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10003
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xf1b4
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
movq %rbx, %rdi
callq 0xf1b4
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rsi
andq $0x0, (%rsi)
movl %eax, (%rdi)
movq %rdx, 0x8(%rdi)
movb $0x1, (%rsi)
movq (%rsi), %rax
andl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
callq 0xdd22
testb %al, %al
je 0x10033
pushq $0x2
popq %rax
xorl %edx, %edx
addq $0x68, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x519b(%rip), %rsi      # 0x151b0
movq %rax, %rdi
callq 0x5120
movq 0xffcc(%rip), %rsi      # 0x1fff0
movq 0xff7d(%rip), %rdx      # 0x1ffa8
movq %r14, %rdi
callq 0x55f0
movq 0xffae(%rip), %rdi      # 0x1ffe8
leaq 0x5141(%rip), %rsi      # 0x15182
callq 0x5380
movq %rax, %rbx
leaq 0x38(%rsp), %r14
leaq 0x58(%rsp), %rsi
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0xde68
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5320
leaq 0x4937(%rip), %rsi      # 0x149a7
movq %rax, %rdi
callq 0x5380
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
xorl %edx, %edx
callq 0xde68
leaq 0x18(%rsp), %rsi
movq %rbx, %rdi
callq 0x5320
leaq 0x4062(%rip), %rsi      # 0x14102
movq %rax, %rdi
callq 0x5380
leaq 0x18(%rsp), %rdi
callq 0x5170
leaq 0x38(%rsp), %rdi
callq 0x5170
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x50d1(%rip), %rsi      # 0x1519f
movq %rax, %rdi
callq 0x5120
jmp 0x1001d
jmp 0x100ee
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x5170
jmp 0x100fe
jmp 0x100fb
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
jmp 0x10108
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10161
movq %rsi, %r14
movq %rsi, %rdi
callq 0xf1b4
movl %eax, %ebp
movq %rdx, %rbx
movq %r14, %rdi
callq 0xf1b4
cmpl $0x1, %ebp
jne 0x1017d
cmpl $0x1, %eax
jne 0x1017d
movq %rdx, %xmm0
movq %rbx, %xmm1
cvttsd2si %xmm1, %eax
cvttsd2si %xmm0, %ecx
cltd
idivl %ecx
cvtsi2sd %edx, %xmm0
movq %xmm0, %rdx
pushq $0x1
popq %rax
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x5056(%rip), %rsi      # 0x151c9
movq %rax, %rdi
callq 0x5120
jmp 0x10197
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x503a(%rip), %rsi      # 0x151c9
movq %rax, %rdi
callq 0x5120
movq 0xfe52(%rip), %rsi      # 0x1fff0
movq 0xfe03(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
jmp 0x101af
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1025e
movq %rsi, %rdi
callq 0xf1b4
cmpl $0x1, %eax
jne 0x1027a
movq %rdx, %xmm0
callq 0x55d0
movq %xmm0, %rdx
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4f88(%rip), %rsi      # 0x151f8
movq %rax, %rdi
callq 0x5120
jmp 0x10294
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4f6c(%rip), %rsi      # 0x151f8
movq %rax, %rdi
callq 0x5120
movq 0xfd55(%rip), %rsi      # 0x1fff0
movq 0xfd06(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
jmp 0x102ac
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1031d
movq %rsi, %rdi
callq 0xf1b4
cmpl $0x4, %eax
je 0x102e8
cmpl $0x6, %eax
jne 0x10339
movq 0x58(%rdx), %rax
subq 0x50(%rdx), %rax
sarq $0x4, %rax
jmp 0x102ec
movq 0x28(%rdx), %rax
movq %rax, %xmm0
punpckldq 0x4d97(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x4d9f(%rip), %xmm0     # 0x150a0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq %xmm1, %rdx
pushq $0x1
popq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4ee1(%rip), %rsi      # 0x15210
movq %rax, %rdi
callq 0x5120
jmp 0x10353
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4ec5(%rip), %rsi      # 0x15210
movq %rax, %rdi
callq 0x5120
movq 0xfc96(%rip), %rsi      # 0x1fff0
movq 0xfc47(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
jmp 0x1036b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1046a
movq %rsi, %rbx
movq 0xfc49(%rip), %rdi      # 0x1ffe8
leaq 0x4e9a(%rip), %rsi      # 0x15240
callq 0x5380
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x5400
xorl %r15d, %r15d
leaq 0x5392(%rip), %r12      # 0x15752
leaq 0x8(%rsp), %r13
pushq $0x1
popq %r14
movl %r15d, %r15d
movq 0x510(%rbx), %rax
subq 0x508(%rbx), %rax
sarq $0x4, %rax
movq 0xfc03(%rip), %rdi      # 0x1ffe8
cmpq %r15, %rax
jbe 0x1043c
movq %r15, %rsi
callq 0x5240
movq %rax, %rdi
movq %r12, %rsi
callq 0x5380
movq %rax, %rbp
movq %r15, %rsi
shlq $0x4, %rsi
addq 0x508(%rbx), %rsi
movq %r13, %rdi
movl %r14d, %edx
callq 0xde68
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5320
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x5400
movq %r13, %rdi
callq 0x5170
incl %r15d
jmp 0x103c9
leaq 0x4e13(%rip), %rsi      # 0x15256
callq 0x5380
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x5400
movq %rbx, %rdi
callq 0xf1b4
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4daa(%rip), %rsi      # 0x15226
movq %rax, %rdi
callq 0x5120
movq 0xfb65(%rip), %rsi      # 0x1fff0
movq 0xfb16(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
jmp 0x104b4
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x5170
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10839
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xf1b4
movl %eax, %eax
leaq 0x48cc(%rip), %rcx      # 0x150b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x4ae8(%rip), %rdi      # 0x152dc
jmp 0x1082a
leaq 0x4481(%rip), %rdi      # 0x14c7e
jmp 0x1082a
leaq 0x44a9(%rip), %rdi      # 0x14caf
jmp 0x1082a
leaq 0x54e9(%rip), %rdi      # 0x15cf8
jmp 0x1082a
leaq 0x4abd(%rip), %rdi      # 0x152d5
jmp 0x1082a
leaq 0x4aaf(%rip), %rdi      # 0x152d0
jmp 0x1082a
leaq 0x4464(%rip), %rdi      # 0x14c8e
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xda86
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4a6c(%rip), %rsi      # 0x152b7
movq %rax, %rdi
callq 0x5120
movq 0xf796(%rip), %rsi      # 0x1fff0
movq 0xf747(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
leaq 0x3be1(%rip), %rdi      # 0x14451
leaq 0x4a6e(%rip), %rsi      # 0x152e5
leaq 0x4a71(%rip), %rcx      # 0x152ef
movl $0x9a, %edx
callq 0x5220
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/iamlouk[P]asbi/src/macros.cc
// Function: macro_reduce(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_reduce(int n, Context* ctx, std::shared_ptr<Env> env) {
	if (n != 3)
		throw std::runtime_error("reduce macro usage error");

	auto map = ctx->pop();
	auto acc = ctx->pop();
	auto fn  = ctx->pop();
	if (map.type != type_t::Map || fn.type != type_t::Lambda)
		throw std::runtime_error("reduce macro usage error");

	auto &vecdata = map._map->vecdata;
	for (unsigned int i = 0; i < vecdata.size(); ++i) {
		ctx->push(vecdata[i]);
		ctx->push(Value::number(i));
		ctx->push(acc);
		acc = fn.call(ctx, 3, env);
	}

	for (auto [key, value]: map._map->data) {
		ctx->push(value);
		ctx->push(key);
		ctx->push(acc);
		acc = fn.call(ctx, 3, env);
	}

	return acc;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, (%rsp)
cmpl $0x3, %edi
jne 0x10a0a
movq %rsi, %r14
movq %rsi, %rdi
callq 0xf1b4
movl %eax, %r13d
movq %rdx, %r15
movq %r14, %rdi
callq 0xf1b4
movl %eax, %ebp
movq %rdx, %r12
movq %r14, %rdi
callq 0xf1b4
movl %eax, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpl $0x6, %r13d
jne 0x10a26
cmpl $0x5, %eax
jne 0x10a26
xorl %ebx, %ebx
leaq 0x28(%rsp), %r13
movl %ebx, %ebx
movq 0x50(%r15), %rax
movq 0x58(%r15), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rbx, %rcx
jbe 0x10983
movq %rbx, %rcx
shlq $0x4, %rcx
movl (%rax,%rcx), %esi
movq 0x8(%rax,%rcx), %rdx
movq %r14, %rdi
callq 0xf190
cvtsi2sd %rbx, %xmm0
movq %xmm0, %rdx
movq %r14, %rdi
pushq $0x1
popq %rsi
callq 0xf190
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xf190
movq %r13, %rdi
movq (%rsp), %rsi
callq 0x6356
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
pushq $0x3
popq %rdx
movq %r13, %rcx
callq 0xdb52
movl %eax, %ebp
movq %rdx, %r12
leaq 0x30(%rsp), %rdi
callq 0x638a
incl %ebx
jmp 0x108ff
addq $0x28, %r15
movq (%r15), %r15
testq %r15, %r15
je 0x109f6
movl 0x8(%r15), %ebx
movq 0x10(%r15), %r13
movl 0x18(%r15), %esi
movq 0x20(%r15), %rdx
movq %r14, %rdi
callq 0xf190
movq %r14, %rdi
movl %ebx, %esi
movq %r13, %rdx
callq 0xf190
movq %r14, %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xf190
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x6356
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
pushq $0x3
popq %rdx
movq %rbx, %rcx
callq 0xdb52
movl %eax, %ebp
movq %rdx, %r12
leaq 0x20(%rsp), %rdi
callq 0x638a
jmp 0x10987
movl %ebp, %eax
movq %r12, %rdx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x490c(%rip), %rsi      # 0x15328
movq %rax, %rdi
callq 0x5120
jmp 0x10a40
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x48f0(%rip), %rsi      # 0x15328
movq %rax, %rdi
callq 0x5120
movq 0xf5a9(%rip), %rsi      # 0x1fff0
movq 0xf55a(%rip), %rdx      # 0x1ffa8
movq %r14, %rdi
callq 0x55f0
jmp 0x10a58
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
jmp 0x10a7c
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0x10a77
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x638a
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 $0x48, %rsp
cmpl $0x2, %edi
jne 0x10dc6
movq %rdx, %r15
movq %rsi, %r14
movq %rsi, %rdi
callq 0xf1b4
movl %eax, %ebx
movq %rdx, 0x10(%rsp)
movq %r14, 0x18(%rsp)
movq %r14, %rdi
callq 0xf1b4
cmpl $0x4, %ebx
jne 0x10de2
cmpl $0x1, %eax
jne 0x10de2
movq %rdx, 0x20(%rsp)
movq %rsp, %rdi
movq %r15, %rsi
callq 0x6356
leaq 0x30(%rsp), %r13
xorl %r14d, %r14d
leaq 0x30(%rsp), %rbp
leaq 0x28(%rsp), %rbx
cvtsi2sd %r14d, %xmm0
movsd 0x20(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x10d70
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6356
movq 0x28(%rsp), %r12
movq %r13, %rdi
callq 0x638a
testq %r12, %r12
je 0x10d70
movq (%r15), %rsi
movq %rbx, %rdi
callq 0x6356
movq %rsp, %rdi
movq %rbx, %rsi
callq 0xc1c0
movq %rbp, %rdi
callq 0x638a
incl %r14d
jmp 0x10d1f
movq 0x10(%rsp), %r14
addq $0x20, %r14
leaq 0x38(%rsp), %rbx
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x6356
movq 0x18(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xf262
movl %eax, %ebx
movq %rdx, %r14
leaq 0x40(%rsp), %rdi
callq 0x638a
leaq 0x8(%rsp), %rdi
callq 0x638a
movl %ebx, %eax
movq %r14, %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x457f(%rip), %rsi      # 0x15357
movq %rax, %rdi
callq 0x5120
jmp 0x10dfc
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x4563(%rip), %rsi      # 0x15357
movq %rax, %rdi
callq 0x5120
movq 0xf1ed(%rip), %rsi      # 0x1fff0
movq 0xf19e(%rip), %rdx      # 0x1ffa8
movq %r14, %rdi
callq 0x55f0
jmp 0x10e14
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
jmp 0x10e38
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x638a
leaq 0x8(%rsp), %rdi
callq 0x638a
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebx
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %ebx
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq 0xf150(%rip), %r13      # 0x1ffb8
subl $0x1, %ebx
jb 0x10e9f
movq %r14, %rdi
callq 0xf1b4
movl %eax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xde68
movq %r13, %rdi
movq %r15, %rsi
callq 0x5320
movq %r15, %rdi
callq 0x5170
jmp 0x10e68
movq 0xf112(%rip), %rdi      # 0x1ffb8
callq 0x5250
pushq $0x2
popq %rax
xorl %edx, %edx
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edi, %ebx
xorl %eax, %eax
testl %edi, %edi
cmovlel %eax, %ebx
movq %rsi, %r14
leaq 0x10(%rsp), %r15
movq %rsp, %r12
movq 0xf0bd(%rip), %r13      # 0x1ffb8
subl $0x1, %ebx
jb 0x10f32
movq %r14, %rdi
callq 0xf1b4
movl %eax, (%rsp)
movq %rdx, 0x8(%rsp)
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xde68
movq %r13, %rdi
movq %r15, %rsi
callq 0x5320
movq %r15, %rdi
callq 0x5170
jmp 0x10efb
movq 0xf07f(%rip), %rdi      # 0x1ffb8
pushq $0xa
popq %rsi
callq 0x5400
movq %rax, %rdi
callq 0x5250
pushq $0x2
popq %rax
xorl %edx, %edx
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x5170
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x10fdc
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xf1b4
cmpl $0x5, %eax
jne 0x10ff8
leaq 0x8(%rsp), %rax
andq $0x0, 0x8(%rax)
movq %rbx, (%rax)
addq $0x318, %rbx            # imm = 0x318
leaq 0x1b6(%rip), %rcx       # 0x1115e
movq %rcx, 0x18(%rax)
leaq 0x29b(%rip), %rcx       # 0x1124e
movq %rcx, 0x10(%rax)
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x124f8
leaq 0x8(%rsp), %rdi
callq 0x11274
pushq $0x2
popq %rax
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x4380(%rip), %rsi      # 0x1536e
movq %rax, %rdi
callq 0x5120
jmp 0x11012
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %r14
leaq 0x4364(%rip), %rsi      # 0x1536e
movq %rax, %rdi
callq 0x5120
movq 0xefd7(%rip), %rsi      # 0x1fff0
movq 0xef88(%rip), %rdx      # 0x1ffa8
movq %r14, %rdi
callq 0x55f0
jmp 0x1102a
movq %rax, %rbx
movq %r14, %rdi
callq 0x5290
jmp 0x11044
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x11274
movq %rbx, %rdi
callq 0x5600
// File: /workspace/github_cpp_makefile_star2_O2/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 0x110fd
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xf1b4
movl %eax, %ebp
movq %rdx, %r14
movq %rbx, %rdi
callq 0xf1b4
cmpl $0x1, %ebp
jne 0x11119
cmpl $0x5, %eax
jne 0x11119
movq %r14, %xmm0
addq $0x318, %rbx            # imm = 0x318
movq %rbx, %rdi
movq %rdx, %rsi
callq 0x127b0
pushq $0x2
popq %rax
xorl %edx, %edx
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x4298(%rip), %rsi      # 0x153a7
movq %rax, %rdi
callq 0x5120
jmp 0x11133
pushq $0x10
popq %rdi
callq 0x51b0
movq %rax, %rbx
leaq 0x427c(%rip), %rsi      # 0x153a7
movq %rax, %rdi
callq 0x5120
movq 0xeeb6(%rip), %rsi      # 0x1fff0
movq 0xee67(%rip), %rdx      # 0x1ffa8
movq %rbx, %rdi
callq 0x55f0
jmp 0x1114b
movq %rax, %r14
movq %rbx, %rdi
callq 0x5290
movq %r14, %rdi
callq 0x5600