LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::interpreter_error::interpreter_error(char const*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
interpreter_error::interpreter_error(const char* msg, std::string name):
		std::runtime_error(msg), what_message("RuntimeError: ") {
		what_message += msg;
		what_message += " (";
		what_message += name;
		what_message += ")";
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
callq 0x5620
leaq 0x15948(%rip), %rax     # 0x205d8
movq %rax, (%rbx)
leaq 0x10(%rbx), %r14
leaq 0x20(%rbx), %r13
movq %r13, 0x10(%rbx)
leaq 0xcce2(%rip), %rsi      # 0x17988
leaq 0xcce9(%rip), %rdx      # 0x17996
movq %r14, %rdi
callq 0x6684
movq %r14, %rdi
movq %r12, %rsi
callq 0x5630
leaq 0xccd0(%rip), %rsi      # 0x17997
movq %r14, %rdi
callq 0x5630
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x50e0
leaq 0xc7a6(%rip), %rsi      # 0x1748b
movq %r14, %rdi
callq 0x5630
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r15
jmp 0xad13
movq %rax, %r15
movq (%r14), %rdi
cmpq %r13, %rdi
je 0xad13
movq (%r13), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x53d0
movq %r15, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::type_error::type_error(char const*, ast::Node const*)
type_error::type_error(const char* msg, const ast::Node* node):
		std::runtime_error(msg), node(node), what_message("TypeError: ") {
		what_message += msg;
		/*what_message += " (near ast node: ";
		node->to_string(what_message);
		what_message += ")";*/
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
callq 0x5620
leaq 0x158bf(%rip), %rax     # 0x20600
movq %rax, (%rbx)
movq %r15, 0x10(%rbx)
leaq 0x18(%rbx), %r15
leaq 0x28(%rbx), %r12
movq %r12, 0x18(%rbx)
leaq 0xcc3f(%rip), %rsi      # 0x1799a
leaq 0xcc43(%rip), %rdx      # 0x179a5
movq %r15, %rdi
callq 0x6684
movq %r15, %rdi
movq %r14, %rsi
callq 0x5630
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xad9d
movq (%r12), %rsi
incq %rsi
callq 0x5390
jmp 0xad9d
movq %rax, %r14
movq %rbx, %rdi
callq 0x53d0
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::dirname(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string dirname(std::string &path) {
		auto i = path.find_last_of("/");
		if (i == std::string::npos)
			return ".";

		return path.substr(0, i);
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xcb5d(%rip), %rsi      # 0x179a6
movl $0x1, %ecx
movq %r14, %rdi
movq $-0x1, %rdx
callq 0x5640
cmpq $-0x1, %rax
je 0xae75
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
movq %rax, %rcx
callq 0x53b0
jmp 0xae92
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq 0xc2b1(%rip), %rsi      # 0x17134
leaq 0xc2ab(%rip), %rdx      # 0x17135
movq %rbx, %rdi
callq 0x6684
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::normalize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
std::string normalize(std::string &path) {
		char normalized[PATH_MAX + 1];
		if (realpath(path.c_str(), normalized) == nullptr) {
			throw std::runtime_error("normalize path error");
		}
		return std::string(normalized);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1008, %rsp           # imm = 0x1008
movq %rdi, %rbx
movq (%rsi), %rdi
movq %rsp, %rsi
callq 0x5110
testq %rax, %rax
je 0xaee9
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rsp, %r14
movq %r14, %rdi
callq 0x5180
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x6684
movq %rbx, %rax
addq $0x1008, %rsp           # imm = 0x1008
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xcaab(%rip), %rsi      # 0x179a8
movq %rax, %rdi
callq 0x5150
movq 0x160e4(%rip), %rsi     # 0x20ff0
movq 0x1609d(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/utils.cc
// Function: utils::readfile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void readfile(std::string &path, std::string &content) {
		content.clear();
		std::ifstream ifs(path);
		if (!ifs.good())
			throw std::runtime_error("readfile error");

		content.assign((std::istreambuf_iterator<char>(ifs)),(std::istreambuf_iterator<char>()));
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rsi, %rbx
movq %rdi, %rsi
movq $0x0, 0x8(%rbx)
movq (%rbx), %rax
movb $0x0, (%rax)
leaq 0x20(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x5570
movq (%r14), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x40(%rsp,%rax)
jne 0xafbb
movq 0x108(%rsp,%rax), %rcx
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
addq %rsi, %rdx
movq $0x0, 0x10(%rsp)
movl $0xffffffff, 0x18(%rsp) # imm = 0xFFFFFFFF
movups 0x10(%rsp), %xmm0
movups %xmm0, (%rsp)
movq %rbx, %rdi
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
callq 0xb210
leaq 0x20(%rsp), %rdi
callq 0x5090
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xc9ee(%rip), %rsi      # 0x179bd
movq %rax, %rdi
callq 0x5150
movq 0x16012(%rip), %rsi     # 0x20ff0
movq 0x15fcb(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
jmp 0xaffd
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x5090
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::PrefxOperator::optimize()
Node* PrefxOperator::optimize() {
	switch (type) {
	case PrefxOperator::Neg:{
		auto a = dynamic_cast<Bool*>(operand = operand->optimize());
		if (a != nullptr) {
			auto res = !a->value;
			delete this;
			return new ast::Bool(res);
		}
		return this;
	}
	case PrefxOperator::Not:{
		auto a = dynamic_cast<Number*>(operand = operand->optimize());
		if (a != nullptr) {
			auto res = -a->value;
			delete this;
			return new ast::Number(res);
		}
		return this;
	}
	}
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
movl 0x8(%rdi), %ebp
movq 0x10(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
cmpl $0x1, %ebp
jne 0xbb10
testq %rax, %rax
je 0xbb2f
leaq 0x14a93(%rip), %rsi     # 0x20590
leaq 0x14db4(%rip), %rdx     # 0x208b8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53f0
jmp 0xbb31
testq %rax, %rax
je 0xbb64
leaq 0x14a74(%rip), %rsi     # 0x20590
leaq 0x14d4d(%rip), %rdx     # 0x20870
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53f0
jmp 0xbb66
xorl %eax, %eax
testq %rax, %rax
je 0xbba3
movb 0x8(%rax), %bpl
xorb $0x1, %bpl
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl $0x10, %edi
callq 0x5380
movq %rax, %rbx
leaq 0x14d3d(%rip), %rax     # 0x20898
movq %rax, (%rbx)
movb %bpl, 0x8(%rbx)
jmp 0xbba3
xorl %eax, %eax
testq %rax, %rax
je 0xbba3
movsd 0x8(%rax), %xmm0
xorps 0xbf89(%rip), %xmm0     # 0x17b00
movaps %xmm0, (%rsp)
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x8(%rax)
movl $0x10, %edi
callq 0x5380
movq %rax, %rbx
leaq 0x14cb8(%rip), %rax     # 0x20850
movq %rax, (%rbx)
movaps (%rsp), %xmm0
movlps %xmm0, 0x8(%rbx)
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::VariableDecl::optimize()
Node* VariableDecl::optimize() {
	for (auto &pair : decls)
		if (pair.second != nullptr)
			pair.second = pair.second->optimize();
	return this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0xbbdc
movq 0x8(%r14), %rdi
testq %rdi, %rdi
je 0xbbd6
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%r14)
addq $0x10, %r14
jmp 0xbbbe
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::AssignAccess::optimize()
Node* AssignAccess::optimize() {
	acs = dynamic_cast<Access*>(acs->optimize());
	if (acs == nullptr)
		throw std::runtime_error("optimizer error");

	val = val->optimize();
	return this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
testq %rax, %rax
je 0xbc46
leaq 0x1495d(%rip), %rsi     # 0x20590
leaq 0x14a86(%rip), %rdx     # 0x206c0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x53f0
jmp 0xbc48
xorl %eax, %eax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0xbc6a
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0xbe92(%rip), %rsi      # 0x17b10
movq %rax, %rdi
callq 0x5150
movq 0x15363(%rip), %rsi     # 0x20ff0
movq 0x1531c(%rip), %rdx     # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::If::optimize()
Node* If::optimize() {
	cond = cond->optimize();
	ifbody = ifbody->optimize();
	if (elsebody != nullptr)
		elsebody = elsebody->optimize();

	return this;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xbce3
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::For::optimize()
Node* For::optimize() {
	if (init) init = init->optimize();
	cond = cond->optimize();
	if (inc) inc = inc->optimize();
	body = body->optimize();
	return this;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xbcff
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xbd20
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x18(%rbx)
movq 0x20(%rbx), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::Map::optimize()
Node* Map::optimize() {
	// TODO: doppelte entfernen und funktioniert das mit den Referenzen?
	for (auto& pair : values) {
		pair.first = pair.first->optimize();
		pair.second = pair.second->optimize();
	}
	return this;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
cmpq %r15, %r14
je 0xbdab
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, (%r14)
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%r14)
addq $0x10, %r14
jmp 0xbd86
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast-optimize.cc
// Function: ast::Call::optimize()
Node* Call::optimize() {
	callable = callable->optimize();
	for (auto it = args.begin(); it != args.end(); ++it)
		*it = (*it)->optimize();

	return this;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x8(%rdi), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %r14
cmpq 0x18(%rbx), %r14
je 0xbe23
movq (%r14), %rdi
movq (%rdi), %rax
callq *0x10(%rax)
movq %rax, (%r14)
addq $0x8, %r14
jmp 0xbe0b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/mem.cc
// Function: asbi::GCObj::GCObj(asbi::Context*, bool)
asbi::GCObj::GCObj(Context* ctx, bool gc){
	gc_inuse = false;
	gc_manage = gc;
	if (gc_manage) {
		this->gc_next = ctx->heap_head;
		ctx->heap_head = this;
	}
}

// Assembly:
leaq 0x148b1(%rip), %rax     # 0x209b8
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movb %dl, 0x11(%rdi)
testl %edx, %edx
je 0xc12f
movq 0x300(%rsi), %rax
movq %rax, 0x8(%rdi)
movq %rdi, 0x300(%rsi)
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/mem.cc
// Function: asbi::Context::check_gc(std::shared_ptr<asbi::Env>)
void asbi::Context::check_gc(std::shared_ptr<Env> env){
	// TODO: heap_size und heap_max
	if (heap_size >= heap_max) {
		gc(env);
		heap_max = heap_size * 2;
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq 0x308(%rdi), %rax
cmpq 0x310(%rdi), %rax
jb 0xc1d7
movq %rdi, %rbx
movq (%rsi), %rax
movq %rax, (%rsp)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rsp)
testq %rax, %rax
je 0xc1ac
movq 0x14e1a(%rip), %rcx     # 0x20fb8
cmpb $0x0, (%rcx)
je 0xc1a8
incl 0x8(%rax)
jmp 0xc1ac
lock
incl 0x8(%rax)
movq %rsp, %rsi
movq %rbx, %rdi
callq 0xc1f8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc1c6
callq 0x6614
movq 0x308(%rbx), %rax
addq %rax, %rax
movq %rax, 0x310(%rbx)
addq $0x10, %rsp
popq %rbx
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0xc1ef
callq 0x6614
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/mem.cc
// Function: asbi::Context::gc(std::shared_ptr<asbi::Env>)
void asbi::Context::gc(std::shared_ptr<Env> env){
	// std::cerr << "===ASBI===: GC running..." << '\n';

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

	for (auto elm: stack)
		elm.gc_visit();

	auto p = &heap_head;
	while (*p != nullptr) {
		auto obj = *p;
		// assert(obj->gc_manage); //
		if (!obj->gc_inuse && obj->gc_manage) {
			*p = obj->gc_next;
			heap_size -= obj->gc_size();
			delete obj;
		} else {
			obj->gc_inuse = false;
			p = &obj->gc_next;
		}
	}

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

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
testq %rdi, %rdi
je 0xc218
callq 0x10928
movq 0x508(%r14), %r12
movq 0x510(%r14), %r13
cmpq %r13, %r12
je 0xc248
movq %rsp, %r15
movups (%r12), %xmm0
movaps %xmm0, (%rsp)
movq %r15, %rdi
callq 0xf3b4
addq $0x10, %r12
cmpq %r13, %r12
jne 0xc22e
movq 0x300(%r14), %r15
testq %r15, %r15
je 0xc2a1
leaq 0x300(%r14), %r12
cmpb $0x0, 0x10(%r15)
jne 0xc28c
cmpb $0x1, 0x11(%r15)
jne 0xc28c
movq 0x8(%r15), %rax
movq %rax, (%r12)
movq (%r15), %rax
movq %r15, %rdi
callq *0x18(%rax)
subq %rax, 0x308(%r14)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0xc298
movb $0x0, 0x10(%r15)
addq $0x8, %r15
movq %r15, %r12
movq (%r12), %r15
testq %r15, %r15
jne 0xc25b
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xc2ae
callq 0x10994
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::Bool::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Bool::to_vmops(Context*, std::vector<OpCode> &ops) const {
	if (value)
		ops.push_back(OpCode::PUSH_TRUE);
	else
		ops.push_back(OpCode::PUSH_FALSE);
}

// Assembly:
pushq %rax
cmpb $0x1, 0x8(%rdi)
jne 0xd4c0
movq $0x2, (%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0xd4e3
movq $0x2, (%rsi)
jmp 0xd4d9
movq $0x3, (%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0xd4e3
movq $0x3, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rdx)
jmp 0xd4f1
movq %rsp, %rax
movq %rdx, %rdi
movq %rax, %rdx
callq 0xedae
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::Lambda::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void Lambda::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	ops.push_back(OpCode::PUSH_LAMBDA);
	auto lambdaops = new std::vector<OpCode>();
	body->to_vmops(ctx, *lambdaops);
	auto lc = new LambdaContainer(nullptr, lambdaops, argnames, ctx, false);
	ctx->lambdas.push_back(lc);
	ops.push_back(*reinterpret_cast<const OpCode*>(&lc));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq $0x7, 0x8(%rsp)
movq 0x8(%rdx), %rsi
cmpq 0x10(%rdx), %rsi
je 0xd636
movq $0x7, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xd643
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xedae
movl $0x18, %edi
callq 0x5380
movq %rax, %r13
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq 0x20(%r12), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %r13, %rdx
callq *0x18(%rax)
movl $0x48, %edi
callq 0x5380
movq %rax, %r15
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
addq $0x8, %r12
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0xa23e
leaq 0x10(%rsp), %rsi
leaq 0x28(%rsp), %rcx
movq %r15, %rdi
movq %r13, %rdx
movq %r14, %r8
xorl %r9d, %r9d
callq 0xf1b8
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd6c7
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd6d6
callq 0x6614
movq %r15, 0x8(%rsp)
movq 0x528(%r14), %rsi
cmpq 0x530(%r14), %rsi
je 0xd6f8
movq %r15, (%rsi)
addq $0x8, 0x528(%r14)
jmp 0xd70c
addq $0x520, %r14            # imm = 0x520
leaq 0x8(%rsp), %rdx
movq %r14, %rdi
callq 0xefc6
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xd728
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xd735
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xeeea
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0xd762
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
jmp 0xd762
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0xd771
callq 0x6614
movl $0x48, %esi
movq %r15, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::PrefxOperator::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void PrefxOperator::to_vmops(Context* ctx, std::vector<OpCode> &ops) const {
	switch (type) {
	case PrefxOperator::Neg:{
		ops.push_back(OpCode::PUSH_NUMBER);
		assert(sizeof(double) == sizeof(OpCode));
		double flt = 0.0;
		ops.push_back(*reinterpret_cast<const OpCode*>(&flt));
		operand->to_vmops(ctx, ops);
		ops.push_back(OpCode::SUB);
		return;
	}
	case PrefxOperator::Not:{
		operand->to_vmops(ctx, ops);
		ops.push_back(OpCode::NOT);
		return;
	}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %eax
testl %eax, %eax
je 0xdd53
cmpl $0x1, %eax
jne 0xddfd
movq $0x0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdd7e
movq $0x0, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdd89
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x1a, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xddf2
movq $0x1a, (%rsi)
jmp 0xdde1
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
movq $0x0, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xddac
movq (%rsp), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xddb7
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xeeea
movq 0x10(%r15), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x11, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xddeb
movq $0x11, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xddfd
leaq 0x8(%rsp), %rdx
jmp 0xddf5
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::VariableDecl::~VariableDecl()
VariableDecl::~VariableDecl() {
	for (auto [var, val] : decls) {
		delete var;
		if (val != nullptr)
			delete val;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x12bde(%rip), %rax     # 0x209f8
movq %rax, (%rdi)
movq 0x8(%rdi), %r15
movq 0x10(%rdi), %r12
cmpq %r12, %r15
je 0xde50
movq (%r15), %rdi
movq 0x8(%r15), %r14
testq %rdi, %rdi
je 0xde3c
movq (%rdi), %rax
callq *0x8(%rax)
testq %r14, %r14
je 0xde4a
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
addq $0x10, %r15
jmp 0xde25
movq 0x8(%rbx), %rdi
testq %rdi, %rdi
je 0xde70
movq 0x18(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x5390
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::VariableDecl::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void VariableDecl::to_vmops(asbi::Context* ctx, std::vector<asbi::OpCode> &ops) const {
	for (auto [var, val]: decls) {
		if (val == nullptr)
			ops.push_back(OpCode::PUSH_NIL);
		else
			val->to_vmops(ctx, ops);

		ops.push_back(OpCode::DECL);
		ops.push_back(*reinterpret_cast<const OpCode*>(&var->sc));
		ops.push_back(OpCode::POP);
	}
	ops.push_back(OpCode::PUSH_NIL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq 0x8(%rdi), %r13
movq 0x10(%rdi), %rbp
cmpq %rbp, %r13
je 0xdf95
movq %rsi, %r14
movq %rsp, %r15
movq (%r13), %r12
movq 0x8(%r13), %rdi
testq %rdi, %rdi
je 0xded4
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xdf02
movq $0x4, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdef7
movq $0x4, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdf02
movq %rbx, %rdi
movq %r15, %rdx
callq 0xedae
movq $0xe, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdf25
movq $0xe, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdf30
movq %rbx, %rdi
movq %r15, %rdx
callq 0xedae
addq $0x8, %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdf4f
movq (%r12), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdf5a
movq %rbx, %rdi
movq %r12, %rdx
callq 0xeeea
movq $0x9, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdf7d
movq $0x9, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdf88
movq %rbx, %rdi
movq %r15, %rdx
callq 0xedae
addq $0x10, %r13
cmpq %rbp, %r13
jne 0xdeb9
movq $0x4, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xdfb8
movq $0x4, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xdfc3
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::DestructList::to_vmops(asbi::Context*, std::vector<asbi::OpCode, std::allocator<asbi::OpCode>>&) const
void DestructList::to_vmops(asbi::Context *ctx, std::vector<asbi::OpCode> &ops) const {
	for (auto rit = lhss.rbegin(); rit != lhss.rend(); ++rit) {
		if (auto var = dynamic_cast<ast::Variable*>(*rit); var != nullptr) {
			ops.push_back(OpCode::PUSH_STACK_PLACEHOLDER);
			ops.push_back(*reinterpret_cast<const OpCode*>(&var->sc));
		} else {
			(*rit)->to_vmops(ctx, ops);
		}
	}
	rhs->to_vmops(ctx, ops);
	ops.push_back(OpCode::DESTRUCT_ARRLIKE);
	ops.push_back(static_cast<OpCode>(lhss.size()));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rdi), %rbp
cmpq 0x8(%rdi), %rbp
je 0xe178
movq -0x8(%rbp), %r13
testq %r13, %r13
je 0xe0f8
movq %r13, %rdi
leaq 0x124ab(%rip), %rsi     # 0x20590
leaq 0x1258c(%rip), %rdx     # 0x20678
xorl %ecx, %ecx
callq 0x53f0
movq %rax, %r12
jmp 0xe0fb
xorl %r12d, %r12d
testq %r12, %r12
je 0xe123
movq $0x8, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe135
movq $0x8, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe140
movq (%r13), %rax
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xe16a
movq %rbx, %rdi
movq %rsp, %rdx
callq 0xedae
addq $0x8, %r12
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe15f
movq (%r12), %rax
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe16a
movq %rbx, %rdi
movq %r12, %rdx
callq 0xeeea
addq $-0x8, %rbp
cmpq 0x8(%r14), %rbp
jne 0xe0d2
movq 0x20(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0x1f, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe1ab
movq $0x1f, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe1b6
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe1dd
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe1e8
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::If::~If()
If::~If() {
	delete cond;
	delete ifbody;
	if (elsebody != nullptr)
		delete elsebody;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x1259f(%rip), %rax     # 0x20a58
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe4cb
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xe4da
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe4ea
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/ast.cc
// Function: ast::For::~For()
For::~For() {
	if (init)
		delete init;
	delete cond;
	if (inc)
		delete inc;
	delete body;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
leaq 0x12305(%rip), %rax     # 0x20a88
movq %rax, (%rdi)
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xe795
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0xe7a4
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0xe7b3
movq (%rdi), %rax
callq *0x8(%rax)
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0xe7c3
movq (%rdi), %rax
popq %rbx
jmpq *0x8(%rax)
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10(%rdi), %rax
subq 0x8(%rdi), %rax
shrq $0x3, %rax
testl %eax, %eax
je 0xe887
movq %rsi, %r14
movq %rdi, %r15
leal -0x1(%rax), %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x2, %eax
jl 0xe86c
movl 0xc(%rsp), %r13d
xorl %ebp, %ebp
leaq 0x10(%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, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe859
movq $0x9, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe864
movq %rbx, %rdi
movq %r12, %rdx
callq 0xedae
incq %rbp
cmpq %rbp, %r13
jne 0xe821
movslq 0xc(%rsp), %rax
movq 0x8(%r15), %rcx
movq (%rcx,%rax,8), %rdi
movq (%rdi), %rax
movq %r14, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
jmp 0xe8b8
movq $0x4, 0x10(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe8ab
movq $0x4, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe8b8
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe904
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 0xe8eb
movq $0x1c, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe928
movq $0x1c, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe935
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xedae
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x3, %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe95d
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe96a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xea32
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 0xea05
movq $0x1b, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xea55
movq $0x1b, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xea60
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
movq 0x10(%r14), %rax
subq 0x8(%r14), %rax
sarq $0x4, %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xea87
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xea92
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xebfe
movq $0x1e, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xec0b
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xec4c
movq -0x8(%r12), %rdi
addq $-0x8, %r12
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
cmpq 0x10(%r14), %r12
jne 0xec31
movq 0x8(%r14), %rdi
movq (%rdi), %rax
movq %r15, %rsi
movq %rbx, %rdx
callq *0x18(%rax)
movq $0xc, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xec7f
movq $0xc, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xec8a
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
movq 0x18(%r14), %rax
subq 0x10(%r14), %rax
sarq $0x3, %rax
movq %rax, (%rsp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xecb1
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xecbc
movq %rsp, %rdx
movq %rbx, %rdi
callq 0xedae
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf2a3
retq
movb $0x1, 0x10(%rdi)
movq 0x18(%rdi), %rdi
testq %rdi, %rdi
je 0xf2b5
jmp 0x10928
pushq %rax
leaq 0x893f(%rip), %rdi      # 0x17bfc
leaq 0x8bbc(%rip), %rsi      # 0x17e80
leaq 0x8bbe(%rip), %rcx      # 0x17e89
movl $0x34, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf3b3
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 0xf37f
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 0xf3b4
movq %r14, %rdi
callq 0xf3b4
movq (%r12), %r12
testq %r12, %r12
jne 0xf351
movq 0x50(%rbx), %r14
movq 0x58(%rbx), %r15
cmpq %r15, %r14
je 0xf3a8
movq %rsp, %rbx
movups (%r14), %xmm0
movaps %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf3b4
addq $0x10, %r14
cmpq %r15, %r14
jne 0xf38f
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf4ba
testb %al, %al
je 0xf48f
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 0xf486
leaq 0x50(%r14), %r12
leaq 0x8(%rsp), %r13
movl $0x2, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
cmpq 0x60(%r14), %rsi
je 0xf464
movups 0x8(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x58(%r14)
jmp 0xf46f
movq %r12, %rdi
movq %r13, %rdx
callq 0x10334
movq 0x50(%r14), %rax
movq 0x58(%r14), %rsi
movq %rsi, %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %r15, %rcx
jbe 0xf43e
shlq $0x4, %r15
addq %rax, %r15
jmp 0xf4a3
addq $0x18, %r14
leaq 0x18(%rsp), %rsi
movq %r14, %rdi
callq 0x10474
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf515
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movsd 0x8(%rdi), %xmm0
movq %rsp, %r14
movq %r14, %rdi
callq 0x55f0
andpd 0x88d2(%rip), %xmm0     # 0x17db0
movsd (%r14), %xmm1
movsd 0x88d5(%rip), %xmm2     # 0x17dc0
cmpltpd %xmm2, %xmm0
xorpd %xmm2, %xmm2
cmplepd %xmm1, %xmm2
andpd %xmm0, %xmm2
movd %xmm2, %eax
testb $0x1, %al
je 0xf50c
cvttsd2si %xmm1, %rcx
movl %ecx, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf517
xorl %eax, %eax
andb $0x1, %al
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf4ba
testb %al, %al
je 0xf564
movl 0xc(%rsp), %eax
movq 0x50(%rbx), %rcx
movq 0x58(%rbx), %rdx
subq %rcx, %rdx
sarq $0x4, %rdx
cmpq %rax, %rdx
jbe 0xf58c
shlq $0x4, %rax
leaq (%rcx,%rax), %rdx
addq %rax, %rcx
addq $0x8, %rcx
jmp 0xf585
addq $0x18, %rbx
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x1079c
testq %rax, %rax
je 0xf58c
movq %rax, %rcx
leaq 0x18(%rax), %rdx
addq $0x20, %rcx
movl (%rdx), %eax
movq (%rcx), %rdx
jmp 0xf593
movl $0x2, %eax
xorl %edx, %edx
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x646e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10b4c
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf5ed
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x10(%rsp), %rdx
movl $0x3, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf61d
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsi, %rbx
movq %rdi, %rsi
movq $0x0, 0x10(%rsp)
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rdx
movq %r14, %rdi
callq 0x646e
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10b4c
movq %rax, 0x10(%rsp)
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf679
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x10(%rsp), %rdx
movl $0x4, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xf6a9
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf9c3
movl (%rsi), %eax
cmpl $0x8, %eax
je 0xf9e2
cmpl %eax, %ecx
jne 0xf97f
movb $0x1, %al
movl %ecx, %ecx
leaq 0x8482(%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 0xf97f
testq %rdx, %rdx
je 0xf9ab
movq 0x20(%rsi), %rsi
movq 0x20(%rcx), %rdi
callq 0x53a0
testl %eax, %eax
jmp 0xf9a8
xorl %eax, %eax
jmp 0xf9ab
movq 0x8(%rdi), %rax
cmpq 0x8(%rsi), %rax
jmp 0xf9a8
movsd 0x8(%rsi), %xmm0
cmpeqsd 0x8(%rdi), %xmm0
movq %xmm0, %rax
andl $0x1, %eax
jmp 0xf9ab
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 0x107da
leaq 0x855b(%rip), %rdi      # 0x17f25
leaq 0x84af(%rip), %rsi      # 0x17e80
leaq 0x8517(%rip), %rcx      # 0x17eef
movl $0x9c, %edx
callq 0x5210
leaq 0x8538(%rip), %rdi      # 0x17f21
leaq 0x8490(%rip), %rsi      # 0x17e80
leaq 0x84f8(%rip), %rcx      # 0x17eef
movl $0x9d, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x83e5(%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 0x837c(%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 0x84bc(%rip), %rdi      # 0x17f25
leaq 0x8410(%rip), %rsi      # 0x17e80
leaq 0x84cf(%rip), %rcx      # 0x17f46
movl $0xb5, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10992
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movb $0x1, 0x58(%rdi)
movq 0x30(%rdi), %r15
testq %r15, %r15
je 0x1096e
leaq 0x8(%rsp), %r14
movq 0x18(%r15), %rax
movq %rax, 0x10(%rsp)
movups 0x8(%r15), %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
callq 0xf3b4
movq (%r15), %r15
testq %r15, %r15
jne 0x1094c
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x1097b
callq 0x10928
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x10989
callq 0x10928
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x109b8
movb $0x0, 0x58(%rbx)
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x109af
callq 0x10994
movq 0x10(%rbx), %rbx
testq %rbx, %rbx
jne 0x10998
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
testq %rbx, %rbx
je 0x10a25
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 0x1177a
movl $0x0, %ecx
testq %rax, %rax
je 0x109ff
movq (%rax), %rcx
testq %rcx, %rcx
je 0x10a0d
movl 0x10(%rcx), %ebp
movq 0x18(%rcx), %r15
jmp 0x10a10
movq (%rbx), %rbx
testq %rcx, %rcx
je 0x109cd
movl %ebp, %eax
movq %r15, %rdx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
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 0x7d0e
movb $0x1, %bpl
leaq 0x755b(%rip), %rsi      # 0x17fb9
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xac72
xorl %ebp, %ebp
leaq 0xfba4(%rip), %rsi      # 0x20618
leaq -0x594f(%rip), %rdx     # 0xb12c
movq %rbx, %rdi
callq 0x55d0
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x10aa5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x10aa5
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x10ab2
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x7(%rsp), %rdi
callq 0x116ee
movq %rax, %r15
andl $0x1f, %eax
leaq (%rax,%rax,2), %rax
movq (%rbx,%rax,8), %rbp
movq %rbx, 0x20(%rsp)
movq %rax, 0x18(%rsp)
movq 0x8(%rbx,%rax,8), %r14
cmpq %r14, %rbp
sete %r13b
je 0x10c02
movq (%r12), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%r12), %rsi
movq %r12, %rbx
movq %r12, 0x28(%rsp)
movq (%rbp), %r12
cmpq %r15, 0x18(%r12)
jne 0x10be4
movq 0x28(%r12), %rdx
cmpq %rsi, %rdx
jne 0x10be4
testq %rdx, %rdx
je 0x10bf9
movq 0x20(%r12), %rdi
movq %r15, %rbx
movq %rsi, %r15
movq 0x30(%rsp), %rsi
callq 0x53a0
movq %r15, %rsi
movq %rbx, %r15
movq 0x28(%rsp), %rbx
testl %eax, %eax
je 0x10bf9
movb $0x1, %al
testb %al, %al
je 0x10c05
addq $0x8, %rbp
cmpq %r14, %rbp
sete %r13b
jne 0x10ba6
jmp 0x10c05
xorl %eax, %eax
movq %r12, 0x8(%rsp)
jmp 0x10be6
movq %r12, %rbx
testb $0x1, %r13b
movq 0x8(%rsp), %rax
je 0x10c67
movl $0x40, %edi
callq 0x5380
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq 0x20(%rsp), %rbx
movq %rbx, %rcx
xorl %r8d, %r8d
callq 0xf104
movq 0x18(%rsp), %rax
leaq (%rbx,%rax,8), %rdi
movq %r12, 0x10(%rsp)
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x10c58
movq %r12, (%rsi)
addq $0x8, 0x8(%rdi)
jmp 0x10c62
leaq 0x10(%rsp), %rdx
callq 0xa5f4
movq 0x10(%rsp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movl $0x40, %esi
movq %r12, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0