LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10dc0
leaq 0x20(%r14), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rcx
movq %rcx, %rax
xorl %edx, %edx
divq 0x28(%r14)
movq %rdx, %rsi
movq %r15, %rdx
callq 0x1177a
movl $0x0, %ecx
testq %rax, %rax
je 0x10d9f
movq (%rax), %rcx
testq %rcx, %rcx
je 0x10dad
movl %ebp, 0x10(%rcx)
movq %rbx, 0x18(%rcx)
jmp 0x10db0
movq (%r14), %r14
testq %rcx, %rcx
je 0x10d6d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x71e5(%rip), %rsi      # 0x17fb9
movq %rax, %rdi
callq 0x5150
movq 0x1020d(%rip), %rsi     # 0x20ff0
movq 0x101c6(%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/context.cc
// Function: asbi::Context::run(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::shared_ptr<asbi::Env>)
Value Context::run(const std::string& str, std::shared_ptr<Env> env) {
	tok::Tokenizer toker(str);
	Parser parser(toker, this);
	auto ast = parser.parse()->optimize();
	std::vector<OpCode> ops;
	ast->to_vmops(this, ops);
	delete ast;

	return execute(ops, env, this);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdx, %r14
movq %rdi, %rbx
xorl %r12d, %r12d
movq %r12, 0x70(%rsp)
movl $0x1, 0x78(%rsp)
movq %rsi, 0x80(%rsp)
movq $0x25, 0x88(%rsp)
movl $0x0, 0x90(%rsp)
movb $0x0, 0x98(%rsp)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0xa0(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x80ec
movq %r15, %rdi
callq 0x8174
movq (%rax), %rcx
movq %rax, %rdi
callq *0x10(%rcx)
movq %rax, %r15
leaq 0x40(%rsp), %rdx
movq %r12, 0x10(%rdx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rdx)
movq (%rax), %rax
movq %r15, %rdi
movq %rbx, %rsi
callq *0x18(%rax)
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x40(%rsp), %rsi
callq 0x101cc
movq (%r14), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%r14), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x11435
movq 0xfb91(%rip), %rcx      # 0x20fb8
cmpb $0x0, (%rcx)
je 0x11431
incl 0x8(%rax)
jmp 0x11435
lock
incl 0x8(%rax)
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %rbx, %rdx
callq 0xc2bc
movl %eax, %ebx
movq %rdx, %r14
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x1145b
callq 0x6614
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x11472
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x11489
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movl %ebx, %eax
movq %r14, %rdx
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x114af
callq 0x6614
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x114cb
movq 0x68(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
jmp 0x114cb
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x114e2
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/context.cc
// Function: asbi::Env::to_map(asbi::Context*) const
Value Env::to_map(Context* ctx) const {
	auto mc = new MapContainer(ctx);
	for (auto [name, value]: vars) {
		mc->set(Value::string(name), value);
	}

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

	return Value::map(mc);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x68, %edi
callq 0x5380
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
callq 0xf2dc
movq 0x30(%r15), %r12
testq %r12, %r12
je 0x1168d
movq 0x8(%r12), %rdx
movl 0x10(%r12), %ecx
movq 0x18(%r12), %r8
movq %rbx, %rdi
movl $0x4, %esi
callq 0xf3ea
movq (%r12), %r12
jmp 0x11666
cmpq $0x0, (%r15)
je 0x116c4
leaq 0x69c3(%rip), %rdi      # 0x1805d
movq %r14, %rsi
callq 0xf59a
movl %eax, %ebp
movq %rdx, %r12
movq (%r15), %rdi
movq %r14, %rsi
callq 0x1163c
movq %rdx, %r8
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %rdx
movl %eax, %ecx
callq 0xf3ea
movl $0x6, %eax
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x68, %esi
movq %rbx, %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1209a
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movl %eax, 0x48(%rsp)
movq %rdx, 0x50(%rsp)
movq %rbx, %rdi
callq 0x11276
leaq 0x58(%rsp), %rdi
movl %eax, (%rdi)
movq %rdx, 0x8(%rdi)
leaq 0x28(%rsp), %rsi
movq $0x0, (%rsi)
movb $0x1, (%rsi)
movq (%rsi), %rax
movl $0x0, (%rsi)
movq %rax, 0x8(%rsi)
callq 0xf928
testb %al, %al
je 0x120cc
movl $0x2, %eax
xorl %edx, %edx
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x60f2(%rip), %rsi      # 0x181a0
movq %rax, %rdi
callq 0x5150
movq 0xef33(%rip), %rsi      # 0x20ff0
movq 0xeeec(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
movq 0xef15(%rip), %rbx      # 0x20fe8
leaq 0x6098(%rip), %rsi      # 0x18172
movl $0x1c, %edx
movq %rbx, %rdi
callq 0x5400
leaq 0x28(%rsp), %r14
leaq 0x58(%rsp), %rsi
movq %r14, %rdi
movl $0x1, %edx
callq 0xfa82
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x5400
movq %rax, %rbx
leaq 0x5880(%rip), %rsi      # 0x17997
movl $0x2, %edx
movq %rax, %rdi
callq 0x5400
leaq 0x8(%rsp), %rdi
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
callq 0xfa82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x5400
leaq 0x4fb4(%rip), %rsi      # 0x17102
movl $0x2, %edx
movq %rax, %rdi
callq 0x5400
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12176
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12191
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x5fea(%rip), %rsi      # 0x1818f
movq %rax, %rdi
callq 0x5150
jmp 0x120b6
jmp 0x121d6
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x121e6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
jmp 0x121e6
jmp 0x121e3
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x12201
movq %rax, %rbx
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x12201
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1225f
movq %rsi, %r14
movq %rsi, %rdi
callq 0x11276
movl %eax, %ebp
movq %rdx, %rbx
movq %r14, %rdi
callq 0x11276
cmpl $0x1, %ebp
jne 0x1227d
cmpl $0x1, %eax
jne 0x1227d
movq %rdx, %xmm0
movq %rbx, %xmm1
cvttsd2si %xmm1, %eax
cvttsd2si %xmm0, %ecx
cltd
idivl %ecx
xorps %xmm0, %xmm0
cvtsi2sd %edx, %xmm0
movq %xmm0, %rdx
movl $0x1, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5f46(%rip), %rsi      # 0x181b9
movq %rax, %rdi
callq 0x5150
jmp 0x12299
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5f28(%rip), %rsi      # 0x181b9
movq %rax, %rdi
callq 0x5150
movq 0xed50(%rip), %rsi      # 0x20ff0
movq 0xed09(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x122b1
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12366
movq %rsi, %rdi
callq 0x11276
cmpl $0x1, %eax
jne 0x12384
movq %rdx, %xmm0
callq 0x55a0
movq %xmm0, %rdx
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5e6e(%rip), %rsi      # 0x181e8
movq %rax, %rdi
callq 0x5150
jmp 0x123a0
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5e50(%rip), %rsi      # 0x181e8
movq %rax, %rdi
callq 0x5150
movq 0xec49(%rip), %rsi      # 0x20ff0
movq 0xec02(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x123b8
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12437
movq %rsi, %rdi
callq 0x11276
movq %rdx, (%rsp)
cmpl $0x4, %eax
je 0x123fc
cmpl $0x6, %eax
jne 0x12455
movq (%rsp), %rcx
movq 0x58(%rcx), %rax
subq 0x50(%rcx), %rax
sarq $0x4, %rax
jmp 0x12404
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, %xmm0
punpckldq 0x5c6f(%rip), %xmm0 # xmm0 = xmm0[0],mem[0],xmm0[1],mem[1]
subpd 0x5c77(%rip), %xmm0     # 0x18090
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
movq %xmm1, %rdx
movl $0x1, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5db5(%rip), %rsi      # 0x18200
movq %rax, %rdi
callq 0x5150
jmp 0x12471
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x5d97(%rip), %rsi      # 0x18200
movq %rax, %rdi
callq 0x5150
movq 0xeb78(%rip), %rsi      # 0x20ff0
movq 0xeb31(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x12489
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x125f8
movq %rsi, %rbx
movq 0xeb2b(%rip), %r14      # 0x20fe8
leaq 0x5d6c(%rip), %rsi      # 0x18230
movl $0x15, %edx
movq %r14, %rdi
callq 0x5400
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5400
movq 0x510(%rbx), %rax
cmpq 0x508(%rbx), %rax
je 0x125b1
movl $0x1, %r15d
xorl %ebp, %ebp
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %r13
movq 0xead5(%rip), %rdi      # 0x20fe8
movq %rbp, %rsi
callq 0x5230
movq %rax, %r14
movl $0x2, %edx
movq %rax, %rdi
leaq 0x6215(%rip), %rsi      # 0x18742
callq 0x5400
shlq $0x4, %rbp
addq 0x508(%rbx), %rbp
movq %r12, %rdi
movq %rbp, %rsi
movl $0x1, %edx
callq 0xfa82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r14, %rdi
callq 0x5400
movb $0xa, 0x7(%rsp)
movl $0x1, %edx
movq %rax, %rdi
movq %r13, %rsi
callq 0x5400
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12590
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x510(%rbx), %rax
subq 0x508(%rbx), %rax
movl %r15d, %ebp
sarq $0x4, %rax
incl %r15d
cmpq %rbp, %rax
ja 0x1250c
movq 0xea30(%rip), %r14      # 0x20fe8
leaq 0x5c87(%rip), %rsi      # 0x18246
movl $0x13, %edx
movq %r14, %rdi
callq 0x5400
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %r14, %rdi
callq 0x5400
movq %rbx, %rdi
callq 0x11276
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x5c0a(%rip), %rsi      # 0x18216
movq %rax, %rdi
callq 0x5150
movq 0xe9d5(%rip), %rsi      # 0x20ff0
movq 0xe98e(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x12656
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x12656
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x12ab9
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movl %eax, %eax
leaq 0x563c(%rip), %rcx      # 0x180a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x5858(%rip), %rdi      # 0x182cc
jmp 0x12aaa
leaq 0x51f1(%rip), %rdi      # 0x17c6e
jmp 0x12aaa
leaq 0x5219(%rip), %rdi      # 0x17c9f
jmp 0x12aaa
leaq 0x6259(%rip), %rdi      # 0x18ce8
jmp 0x12aaa
leaq 0x582d(%rip), %rdi      # 0x182c5
jmp 0x12aaa
leaq 0x581f(%rip), %rdi      # 0x182c0
jmp 0x12aaa
leaq 0x51d4(%rip), %rdi      # 0x17c7e
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf59a
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x57da(%rip), %rsi      # 0x182a7
movq %rax, %rdi
callq 0x5150
movq 0xe514(%rip), %rsi      # 0x20ff0
movq 0xe4cd(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
leaq 0x4957(%rip), %rdi      # 0x17449
leaq 0x57dc(%rip), %rsi      # 0x182d5
leaq 0x57df(%rip), %rcx      # 0x182df
movl $0x9a, %edx
callq 0x5210
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/macros.cc
// Function: macro_eval(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_eval(int n, Context* ctx, std::shared_ptr<Env> callerenv) {
	if (n != 2)
		throw std::runtime_error("eval macro usage error");

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

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

		env = callerenv->getOuter();
	}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x2, %edi
jne 0x13199
movq %rdx, %r14
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movl %eax, %ebp
movq %rdx, 0x20(%rsp)
movq %rbx, %rdi
callq 0x11276
cmpl $0x4, %ebp
jne 0x131b7
cmpl $0x1, %eax
jne 0x131b7
movq %rdx, (%rsp)
movq (%r14), %r13
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x13092
movq 0xdf38(%rip), %rax      # 0x20fb8
cmpb $0x0, (%rax)
je 0x1308c
incl 0x8(%r12)
jmp 0x13092
lock
incl 0x8(%r12)
movq %rbx, 0x18(%rsp)
xorpd %xmm0, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x13123
movl $0x1, %ebp
movq 0xdf06(%rip), %rbx      # 0x20fb8
movq (%r14), %rax
movq (%rax), %r15
movq 0x8(%rax), %rdi
testq %rdi, %rdi
je 0x130cf
cmpb $0x0, (%rbx)
je 0x130cb
incl 0x8(%rdi)
jmp 0x130cf
lock
incl 0x8(%rdi)
testq %rdi, %rdi
je 0x130d9
callq 0x6614
testq %r15, %r15
je 0x13123
movq (%r14), %rax
movq (%rax), %r13
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x130fd
cmpb $0x0, (%rbx)
je 0x130f8
incl 0x8(%r15)
jmp 0x130fd
lock
incl 0x8(%r15)
testq %r12, %r12
je 0x1310a
movq %r12, %rdi
callq 0x6614
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
movq %r15, %r12
ja 0x130b2
jmp 0x13126
movq %r12, %r15
movq 0x20(%rsp), %rsi
addq $0x20, %rsi
movq %r13, 0x8(%rsp)
movq %r15, 0x10(%rsp)
testq %r15, %r15
movq 0x18(%rsp), %rdi
je 0x1315a
movq 0xde6e(%rip), %rax      # 0x20fb8
cmpb $0x0, (%rax)
je 0x13155
incl 0x8(%r15)
jmp 0x1315a
lock
incl 0x8(%r15)
leaq 0x8(%rsp), %rdx
callq 0x11342
movl %eax, %ebx
movq %rdx, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x13178
callq 0x6614
testq %r15, %r15
je 0x13185
movq %r15, %rdi
callq 0x6614
movl %ebx, %eax
movq %r14, %rdx
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x519a(%rip), %rsi      # 0x18347
movq %rax, %rdi
callq 0x5150
jmp 0x131d3
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x517c(%rip), %rsi      # 0x18347
movq %rax, %rdi
callq 0x5150
movq 0xde16(%rip), %rsi      # 0x20ff0
movq 0xddcf(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
jmp 0x131eb
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x13217
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x1320a
callq 0x6614
testq %r15, %r15
je 0x13217
movq %r15, %rdi
callq 0x6614
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/macros.cc
// Function: macro_io_print(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_io_print(int n, Context* ctx, std::shared_ptr<Env>) {
	for (int i = 0; i < n; i++) {
		std::cout << ctx->pop().to_string(false);
	}
	std::cout << std::flush;
	return Value::nil();
}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
testl %edi, %edi
jle 0x13353
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq 0xdcb8(%rip), %r12      # 0x20fc0
movq %rbx, %rdi
callq 0x11276
movl %eax, 0x28(%rsp)
movq %rdx, 0x30(%rsp)
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xfa82
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r12, %rdi
callq 0x5400
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1334f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
decl %ebp
jne 0x13308
leaq 0x8(%rsp), %rsi
movb $0xa, (%rsi)
movq 0xdc5e(%rip), %rdi      # 0x20fc0
movl $0x1, %edx
callq 0x5400
movq %rax, %rdi
callq 0x5240
movl $0x2, %eax
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x133a4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
cmpl $0x1, %edi
jne 0x13435
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movq %rdx, 0x8(%rsp)
cmpl $0x5, %eax
jne 0x13453
movq 0x8(%rsp), %rsi
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
movaps %xmm0, 0x10(%rdx)
movq %rbx, (%rdx)
addq $0x318, %rbx            # imm = 0x318
leaq 0x1f8(%rip), %rax       # 0x135ee
movq %rax, 0x18(%rdx)
leaq 0x37d(%rip), %rax       # 0x1377e
movq %rax, 0x10(%rdx)
movq %rbx, %rdi
callq 0x14ec8
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x13426
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movl $0x2, %eax
xorl %edx, %edx
addq $0x38, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x4f15(%rip), %rsi      # 0x1835e
movq %rax, %rdi
callq 0x5150
jmp 0x1346f
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x4ef7(%rip), %rsi      # 0x1835e
movq %rax, %rdi
callq 0x5150
movq 0xdb7a(%rip), %rsi      # 0x20ff0
movq 0xdb33(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
jmp 0x13487
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x134b2
jmp 0x134ba
movq %rax, %rbx
movq 0x20(%rsp), %rax
testq %rax, %rax
je 0x134b2
leaq 0x10(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x55e0
movq %rax, %rdi
callq 0x64ab
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x10, %rsp
cmpl $0x2, %edi
jne 0x13588
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movl %eax, %ebp
movq %rdx, %r14
movq %rbx, %rdi
callq 0x11276
movq %rdx, 0x8(%rsp)
cmpl $0x1, %ebp
jne 0x135a6
cmpl $0x5, %eax
jne 0x135a6
movq %r14, %xmm0
addq $0x318, %rbx            # imm = 0x318
movq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1523e
movl $0x2, %eax
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x4dfb(%rip), %rsi      # 0x18397
movq %rax, %rdi
callq 0x5150
jmp 0x135c2
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x4ddd(%rip), %rsi      # 0x18397
movq %rax, %rdi
callq 0x5150
movq 0xda27(%rip), %rsi      # 0x20ff0
movq 0xd9e0(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x135da
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/procenv.cc
// Function: asbi::load_procenv(asbi::Context*, int, char const**, int)
void asbi::load_procenv(Context* ctx, int argc, const char* argv[], int scriptArgs) {
	auto env = new MapContainer(ctx);
	auto args = new MapContainer(ctx);
	for (int i = scriptArgs, j = 0; i < argc; ++i, ++j)
		args->set(Value::number(j), Value::string(ctx->new_string(argv[i])));

	env->set(Value::symbol("all",  ctx), Value::macro(all_env_vars));
	env->set(Value::symbol("set",  ctx), Value::macro(set_env_var));
	env->set(Value::symbol("get",  ctx), Value::macro(get_env_var));
	env->set(Value::symbol("argv", ctx), Value::map(args));
	env->set(Value::symbol("$",    ctx), Value::macro(macro_system));
	env->set(Value::symbol("exit", ctx), Value::macro(macro_exit));
	ctx->global_env->decl(ctx, "env", Value::map(env));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %ebp
movq %rdx, %r13
movl %esi, %r12d
movq %rdi, %r14
movl $0x68, %edi
callq 0x5380
movq %rax, 0x8(%rsp)
movq %rax, %rdi
movq %r14, %rsi
callq 0xf2dc
movl $0x68, %edi
callq 0x5380
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xf2dc
subl %ebp, %r12d
jle 0x1384e
movslq %ebp, %rax
leaq (,%rax,8), %rbp
addq %r13, %rbp
pxor %xmm0, %xmm0
xorl %ebx, %ebx
movq %xmm0, 0x10(%rsp)
movq %xmm0, %r13
movq (%rbp,%rbx,8), %rsi
movq %r14, %rdi
callq 0x11560
movq %r15, %rdi
movl $0x1, %esi
movq %r13, %rdx
movl $0x4, %ecx
movq %rax, %r8
callq 0xf3ea
movsd 0x10(%rsp), %xmm0
addsd 0x4b72(%rip), %xmm0     # 0x183b8
incq %rbx
cmpl %ebx, %r12d
jne 0x13808
leaq 0x4689(%rip), %rdi      # 0x17ede
movq %r14, %rsi
callq 0xf59a
leaq 0x119(%rip), %r8        # 0x1397d
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
movl %eax, %esi
movl $0x7, %ecx
callq 0xf3ea
leaq 0x4b90(%rip), %rdi      # 0x1840f
movq %r14, %rsi
callq 0xf59a
leaq 0x303(%rip), %r8        # 0x13b91
movq %rbx, %rdi
movl %eax, %esi
movl $0x7, %ecx
callq 0xf3ea
leaq 0x4b6f(%rip), %rdi      # 0x18413
movq %r14, %rsi
callq 0xf59a
leaq 0x3cf(%rip), %r8        # 0x13c82
movq %rbx, %rdi
movl %eax, %esi
movl $0x7, %ecx
callq 0xf3ea
leaq 0x4b4e(%rip), %rdi      # 0x18417
movq %r14, %rsi
callq 0xf59a
movq %rbx, %rdi
movl %eax, %esi
movl $0x6, %ecx
movq %r15, %r8
callq 0xf3ea
leaq 0x4b32(%rip), %rdi      # 0x1841c
movq %r14, %rsi
callq 0xf59a
leaq 0x43e(%rip), %r8        # 0x13d37
movq %rbx, %rdi
movl %eax, %esi
movl $0x7, %ecx
callq 0xf3ea
leaq 0x4b0f(%rip), %rdi      # 0x1841e
movq %r14, %rsi
callq 0xf59a
leaq 0x66a(%rip), %r8        # 0x13f88
movq %rbx, %rdi
movl %eax, %esi
movl $0x7, %ecx
callq 0xf3ea
movq 0x4f8(%r14), %rdi
leaq 0x4694(%rip), %rdx      # 0x17fcf
movq %r14, %rsi
movl $0x6, %ecx
movq %rbx, %r8
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10cb6
movq %rax, %r14
movq %r15, 0x8(%rsp)
jmp 0x13966
movq %rax, %r14
movl $0x68, %esi
movq 0x8(%rsp), %rdi
callq 0x5390
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/procenv.cc
// Function: all_env_vars(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value all_env_vars(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 0)
		throw std::runtime_error("env:all usage error");

	auto vars = new MapContainer(ctx);
	for (int i = 0; environ[i] != NULL; ++i) {
		const char* str = environ[i];
		const char* pos = std::strchr(str, '=');
		if (pos == NULL)
			throw std::runtime_error("unexpected environment variable format");

		std::size_t len = std::abs(str - pos);
		std::string name(str, len);
		std::string value(str + len + 1);
		vars->set(Value::string(name, ctx), Value::string(value, ctx));
	}
	return Value::map(vars);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
testl %edi, %edi
jne 0x13b09
movq %rsi, %rbx
movl $0x68, %edi
callq 0x5380
movq %rax, (%rsp)
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf2dc
movq 0xd612(%rip), %rax      # 0x20fc8
movq (%rax), %rax
movq (%rax), %r13
testq %r13, %r13
je 0x13abf
movl $0x8, %r14d
leaq 0x28(%rsp), %r15
leaq 0x8(%rsp), %r12
movq %r13, %rdi
movl $0x3d, %esi
callq 0x5130
testq %rax, %rax
je 0x13ad7
movq %r13, %rcx
subq %rax, %rcx
movq %rcx, %rbp
negq %rbp
cmovsq %rcx, %rbp
leaq 0x38(%rsp), %rax
movq %rax, 0x28(%rsp)
addq %r13, %rbp
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
callq 0x6684
leaq 0x1(%rbp), %r13
leaq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %r13, %rdi
callq 0x5180
leaq (%rax,%rbp), %rdx
incq %rdx
movq %r12, %rdi
movq %r13, %rsi
callq 0x6684
movq %r15, %rdi
movq %rbx, %rsi
callq 0xf6b2
movl %eax, %ebp
movq %rdx, %r13
movq %r12, %rdi
movq %rbx, %rsi
callq 0xf6b2
movq %rdx, %r8
movq (%rsp), %rdi
movl %ebp, %esi
movq %r13, %rdx
movl %eax, %ecx
callq 0xf3ea
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13a88
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x13aa4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0xd51d(%rip), %rax      # 0x20fc8
movq (%rax), %rax
movq (%rax,%r14), %r13
addq $0x8, %r14
testq %r13, %r13
jne 0x139d5
movl $0x6, %eax
movq (%rsp), %rdx
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x494c(%rip), %rsi      # 0x18437
movq %rax, %rdi
callq 0x5150
movq 0xd4f6(%rip), %rsi      # 0x20ff0
movq 0xd4af(%rip), %rdx      # 0x20fb0
movq %r14, %rdi
callq 0x55d0
movl $0x10, %edi
callq 0x51b0
movq %rax, %r14
leaq 0x4906(%rip), %rsi      # 0x18423
movq %rax, %rdi
callq 0x5150
jmp 0x13af3
jmp 0x13b37
movq %rax, %rbx
movl $0x68, %esi
movq (%rsp), %rdi
jmp 0x13b84
movq %rax, %rbx
movq %r14, %rdi
callq 0x5280
jmp 0x13b89
movq %rax, %rbx
jmp 0x13b89
movq %rax, %rbx
jmp 0x13b6d
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x13b6d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x5390
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x13b89
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x5390
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/procenv.cc
// Function: set_env_var(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value set_env_var(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 2)
		throw std::runtime_error("env:set usage error");

	auto name = ctx->pop();
	auto value = ctx->pop();
	if (name.type != type_t::String || value.type != type_t::String)
		throw std::runtime_error("env:set usage error");

	if(setenv(name._string->data.c_str(), value._string->data.c_str(), 1) != 0)
		throw std::runtime_error(std::strerror(errno));

	return Value::nil();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
cmpl $0x2, %edi
jne 0x13bf5
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movl %eax, %ebp
movq %rdx, 0x8(%rsp)
movq %rbx, %rdi
callq 0x11276
movq %rdx, (%rsp)
cmpl $0x4, %ebp
jne 0x13c13
cmpl $0x4, %eax
jne 0x13c13
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rdi
movq (%rsp), %rax
movq 0x20(%rax), %rsi
movl $0x1, %edx
callq 0x5520
testl %eax, %eax
jne 0x13c31
movl $0x2, %eax
xorl %edx, %edx
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x4855(%rip), %rsi      # 0x1845e
movq %rax, %rdi
callq 0x5150
jmp 0x13c55
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x4837(%rip), %rsi      # 0x1845e
movq %rax, %rdi
callq 0x5150
jmp 0x13c55
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
callq 0x5050
movl (%rax), %edi
callq 0x5100
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5150
movq 0xd394(%rip), %rsi      # 0x20ff0
movq 0xd34d(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x13c6f
jmp 0x13c6f
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/procenv.cc
// Function: get_env_var(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value get_env_var(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("env:get usage error");

	auto name = ctx->pop();
	if (name.type != type_t::String)
		throw std::runtime_error("env:get usage error");

	const char* value = std::getenv(name._string->data.c_str());
	return value == NULL ? Value::nil() : Value::string(value, ctx);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x13cd2
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x11276
movq %rdx, (%rsp)
cmpl $0x4, %eax
jne 0x13cf0
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x5440
testq %rax, %rax
je 0x13cc3
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xf626
movl $0x2, %eax
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x478c(%rip), %rsi      # 0x18472
movq %rax, %rdi
callq 0x5150
jmp 0x13d0c
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x476e(%rip), %rsi      # 0x18472
movq %rax, %rdi
callq 0x5150
movq 0xd2dd(%rip), %rsi      # 0x20ff0
movq 0xd296(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x13d24
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/procenv.cc
// Function: macro_exit(int, asbi::Context*, std::shared_ptr<asbi::Env>)
static Value macro_exit(int n, Context* ctx, std::shared_ptr<Env>) {
	if (n != 1)
		throw std::runtime_error("exit macro usage error");

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

	std::exit(static_cast<unsigned int>(exitcode._number));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
cmpl $0x1, %edi
jne 0x13fad
movq %rsi, %rdi
callq 0x11276
cmpl $0x1, %eax
jne 0x13fcb
movq %rdx, %xmm0
cvttsd2si %xmm0, %rdi
callq 0x5430
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x44f7(%rip), %rsi      # 0x184b8
movq %rax, %rdi
callq 0x5150
jmp 0x13fe7
movl $0x10, %edi
callq 0x51b0
movq %rax, %rbx
leaq 0x44d9(%rip), %rsi      # 0x184b8
movq %rax, %rdi
callq 0x5150
movq 0xd002(%rip), %rsi      # 0x20ff0
movq 0xcfbb(%rip), %rdx      # 0x20fb0
movq %rbx, %rdi
callq 0x55d0
jmp 0x13fff
movq %rax, %r14
movq %rbx, %rdi
callq 0x5280
movq %r14, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/utils.cc
// Function: asbi::evts::Semaphore::tryAcquire()
bool Semaphore::tryAcquire() {
	std::unique_lock<std::mutex> lock(mut);
	if (counter > 0) {
		counter--;
		return true;
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x14664
movb $0x1, 0x8(%r14)
movl 0x58(%rbx), %eax
testl %eax, %eax
jle 0x14545
leal -0x1(%rax), %ecx
movl %ecx, 0x58(%rbx)
testl %eax, %eax
setg %bl
leaq 0x8(%rsp), %rdi
callq 0x1464e
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/utils.cc
// Function: asbi::evts::Semaphore::acquireFor(std::chrono::duration<double, std::ratio<1l, 1000l>>)
bool Semaphore::acquireFor(std::chrono::duration<double, std::milli> timeout) {
	std::unique_lock<std::mutex> lock(mut);
	if (condvar.wait_for(lock, timeout, [this](){ return this->counter > 0; })) {
		counter--;
		return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movsd %xmm0, (%rsp)
movq %rdi, %rbx
leaq 0x8(%rsp), %r14
movq %rdi, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x14664
movb $0x1, 0x8(%r14)
leaq 0x28(%rbx), %r15
callq 0x54a0
movsd (%rsp), %xmm0
mulsd 0x3f2e(%rip), %xmm0     # 0x184d0
cvttsd2si %xmm0, %rcx
movapd %xmm0, %xmm1
xorps %xmm0, %xmm0
cvtsi2sd %rcx, %xmm0
xorl %edx, %edx
ucomisd %xmm0, %xmm1
seta %dl
addq %rcx, %rax
addq %rdx, %rax
leaq 0x18(%rsp), %r12
movq %rax, (%r12)
cmpl $0x0, 0x58(%rbx)
jg 0x145ee
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x146c8
cmpl $0x1, %eax
jne 0x145cb
cmpl $0x0, 0x58(%rbx)
setg %bpl
jmp 0x145f1
movb $0x1, %bpl
testb %bpl, %bpl
je 0x145f9
decl 0x58(%rbx)
leaq 0x8(%rsp), %rdi
callq 0x1464e
movl %ebp, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1464e
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/loop.cc
// Function: worker(asbi::evts::Loop*)
static void worker(evts::Loop* evtloop) {
	evts::Task* task = nullptr;
	while ((task = evtloop->getTask()) != nullptr) {
		task->fn([evtloop, task](std::vector<Value> *args, bool done) -> void {
			evtloop->addEvent(task, args, done);
		});

		// std::cerr << "Worker#" << std::this_thread::get_id() << " finished Task " << (void*)task << '\n';

		delete task;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x15046
testq %rax, %rax
je 0x14b78
movq %rax, %r14
leaq 0x776(%rip), %r12       # 0x1526a
leaq 0x787(%rip), %r13       # 0x15282
movq %rsp, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq %rbx, (%rsp)
movq %r14, 0x8(%rsp)
movq %r12, 0x18(%rsp)
movq %r13, 0x10(%rsp)
cmpq $0x0, 0x10(%r14)
je 0x14b86
movq %r14, %rdi
movq %r15, %rsi
callq *0x18(%r14)
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14b45
movq %r15, %rdi
movq %r15, %rsi
movl $0x3, %edx
callq *%rax
movq 0x10(%r14), %rax
testq %rax, %rax
je 0x14b5b
movq %r14, %rdi
movq %r14, %rsi
movl $0x3, %edx
callq *%rax
movl $0x28, %esi
movq %r14, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x15046
movq %rax, %r14
testq %rax, %rax
jne 0x14afe
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x5140
jmp 0x14bb3
jmp 0x14bb3
jmp 0x14b91
movq %rax, %rbx
movq 0x10(%rsp), %rax
testq %rax, %rax
je 0x14bab
movq %rsp, %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
movq %rbx, %rdi
callq 0x55e0
movq %rax, %rdi
callq 0x64ab
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/loop.cc
// Function: asbi::evts::Loop::start()
void evts::Loop::start() {
	evts::Event* evt;
	while ((evt = getEvent()) != nullptr) {
		for (auto rit = evt->args.rbegin(); rit != evt->args.rend(); ++rit)
			ctx->push(*rit);

		Value::lambda(evt->callback).call(ctx, evt->args.size(), nullptr);
		delete evt;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
callq 0x14ca6
testq %rax, %rax
je 0x14c7e
movq %rax, %r15
leaq 0x10(%rsp), %r14
movq %rsp, %r12
movq 0x8(%r15), %rax
cmpq (%r15), %rax
je 0x14c09
movq (%rbx), %rdi
leaq -0x10(%rax), %r13
movl -0x10(%rax), %esi
movq -0x8(%rax), %rdx
callq 0x11230
movq %r13, %rax
cmpq (%r15), %r13
jne 0x14bee
movq 0x18(%r15), %rax
movl $0x5, 0x10(%rsp)
movq %rax, 0x18(%rsp)
movq (%rbx), %rsi
movq 0x8(%r15), %rdx
subq (%r15), %rdx
shrq $0x4, %rdx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %r14, %rdi
movq %r12, %rcx
callq 0xf6cc
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14c49
callq 0x6614
movq (%r15), %rdi
testq %rdi, %rdi
je 0x14c5d
movq 0x10(%r15), %rsi
subq %rdi, %rsi
callq 0x5390
movl $0x28, %esi
movq %r15, %rdi
callq 0x5390
movq %rbx, %rdi
callq 0x14ca6
movq %rax, %r15
testq %rax, %rax
jne 0x14be5
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14c9e
callq 0x6614
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/loop.cc
// Function: asbi::evts::Loop::addTask(asbi::evts::Task*)
void evts::Loop::addTask(evts::Task* task) {
	std::unique_lock<std::mutex> lock(tasksMtx);
	task->callback->gc_manage = false;
	tasks.push_back(task);
	if (tasksRunning >= threads.size())
		newThread();

	tasksSem.release();
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
movq %rsi, 0x8(%rsp)
leaq 0x10(%rdi), %rax
leaq 0x10(%rsp), %r14
movq %rax, (%r14)
xorl %ebp, %ebp
movb %bpl, 0x8(%r14)
movq %r14, %rdi
callq 0x14664
movb $0x1, 0x8(%r14)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movb %bpl, 0x11(%rcx)
movq 0xc8(%rbx), %rcx
movq 0xd8(%rbx), %rdx
addq $-0x8, %rdx
cmpq %rdx, %rcx
je 0x14fde
movq %rax, (%rcx)
addq $0x8, 0xc8(%rbx)
jmp 0x14fef
leaq 0x98(%rbx), %rdi
leaq 0x8(%rsp), %rsi
callq 0x15e10
movl 0x8(%rbx), %eax
movq 0x1d0(%rbx), %rcx
subq 0x1c8(%rbx), %rcx
sarq $0x3, %rcx
cmpq %rax, %rcx
ja 0x15011
movq %rbx, %rdi
callq 0x148ec
addq $0x38, %rbx
movq %rbx, %rdi
callq 0x14478
leaq 0x10(%rsp), %rdi
callq 0x1464e
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1464e
movq %rbx, %rdi
callq 0x55e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/loop.cc
// Function: asbi::evts::Loop::getTask()
evts::Task* evts::Loop::getTask() {
	tasksSem.acquire();

	std::unique_lock<std::mutex> lock(tasksMtx);
	auto task = tasks.front();
	tasks.pop_front();
	tasksRunning++;
	return task;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x38, %rdi
callq 0x144bc
leaq 0x10(%rbx), %rax
movq %rsp, %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x14664
movb $0x1, 0x8(%r14)
leaq 0x98(%rbx), %rdi
movq 0xa8(%rbx), %rax
movq (%rax), %r15
callq 0x153de
incl 0x8(%rbx)
movq %r14, %rdi
callq 0x1464e
movq %r15, %rax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/loop.cc
// Function: asbi::evts::Loop::addEvent(asbi::evts::Task*, std::vector<asbi::Value, std::allocator<asbi::Value>>*, bool)
void evts::Loop::addEvent(evts::Task* task, std::vector<Value> *args, bool done) {
	auto evt = new evts::Event();
	evt->taskDone = done;
	evt->callback = task->callback;
	if (args == nullptr) {
		evt->doCall = false;
	} else {
		evt->args = *args;
		evt->doCall = true;
	}
	addEvent(evt);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movl $0x28, %edi
callq 0x5380
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movq $0x0, 0x20(%rax)
movb %bpl, 0x20(%rax)
movq 0x20(%r12), %rax
movq %rax, 0x18(%r14)
testq %r15, %r15
je 0x150f9
movq %r14, %rdi
movq %r15, %rsi
callq 0x1542c
movb $0x1, %al
jmp 0x150fb
xorl %eax, %eax
movb %al, 0x21(%r14)
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x15112
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/loop.cc
// Function: asbi::evts::Loop::addEvent(asbi::evts::Event*)
void evts::Loop::addEvent(evts::Event* evt) {
	std::unique_lock<std::mutex> lock(eventsMtx);

	if (evt->taskDone) {
		std::unique_lock<std::mutex> lock(tasksMtx);
		tasksRunning--;
	}

	events.push_back(evt);
	eventsSem.release();
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
leaq 0xe8(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x14664
movb $0x1, 0x8(%r14)
movq (%rsp), %rax
cmpb $0x1, 0x20(%rax)
jne 0x15171
leaq 0x10(%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rax, (%rdi)
movb $0x0, 0x8(%rdi)
callq 0x14664
leaq 0x18(%rsp), %rdi
movb $0x1, 0x8(%rdi)
decl 0x8(%rbx)
callq 0x1464e
movq 0x1a0(%rbx), %rax
movq 0x1b0(%rbx), %rcx
addq $-0x8, %rcx
cmpq %rcx, %rax
je 0x15199
movq (%rsp), %rcx
movq %rcx, (%rax)
addq $0x8, 0x1a0(%rbx)
jmp 0x151a8
leaq 0x170(%rbx), %rdi
movq %rsp, %rsi
callq 0x15ed8
addq $0x110, %rbx            # imm = 0x110
movq %rbx, %rdi
callq 0x14478
leaq 0x8(%rsp), %rdi
callq 0x1464e
addq $0x28, %rsp
popq %rbx
popq %r14
retq
jmp 0x151cb
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1464e
movq %rbx, %rdi
callq 0x55e0
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/utils.hh
// Function: asbi::evts::SortedQueue<asbi::evts::Timer, std::less<asbi::evts::Timer>>::removeFirst()
void removeFirst() {
			assert(head != nullptr);
			auto tmp = head->next;
			delete head;
			head = tmp;
		}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x155c0
movq 0x10(%rdi), %r14
movl $0x18, %esi
callq 0x5390
movq %r14, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
leaq 0x2ff3(%rip), %rdi      # 0x185ba
leaq 0x2ffc(%rip), %rsi      # 0x185ca
leaq 0x3078(%rip), %rcx      # 0x1864d
movl $0x61, %edx
callq 0x5210
nop
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/events/utils.hh
// Function: asbi::evts::SortedQueue<asbi::evts::Timer, std::less<asbi::evts::Timer>>::insert(asbi::evts::Timer)
void insert(T in) {
			Comp cmp = Comp();

			/*int s1 = size();
			Node **p = &head;
			while (*p != nullptr && cmp((*p)->value, in))
				p = &((*p)->next);

			if (*p == nullptr) {
				*p = node;
			} else {
			 	node->next = (*p)->next;
				*p = node;
			}
			assert(s1 + 1 == size());*/



			Node *drag = nullptr, *curr = head;
			while (curr != nullptr && cmp(curr->value, in)) {
				drag = curr;
				curr = curr->next;
			}

			if (drag == nullptr)
				head = new Node(in, head);
			else
				drag->next = new Node(in, curr);

		}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x15614
ucomisd 0x8(%r15), %xmm0
jbe 0x15614
movq %r15, %r12
movq 0x10(%r15), %r15
testq %r15, %r15
je 0x15617
ucomisd 0x8(%r15), %xmm0
ja 0x155fe
jmp 0x15617
xorl %r12d, %r12d
movsd %xmm0, (%rsp)
movl $0x18, %edi
callq 0x5380
testq %r12, %r12
je 0x15645
movq %r14, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %r15, 0x10(%rax)
addq $0x10, %r12
movq %r12, %rbx
jmp 0x15659
movq (%rbx), %rcx
movq %r14, (%rax)
movsd (%rsp), %xmm0
movsd %xmm0, 0x8(%rax)
movq %rcx, 0x10(%rax)
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/iamlouk[P]asbi/src/tests.cc
// Function: tests::test(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, asbi::Value)
void test(const std::string code, Value expected) {
		Context ctx;
		std::cout << "test(\'" << code << "\'): " << std::flush;
		Value res = ctx.run(code);
		assert(res == expected);
		std::cout << "SUCCESS\n";
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x588, %rsp            # imm = 0x588
movq %rdi, %rbx
movl %esi, (%rsp)
movq %rdx, 0x8(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x10e06
movq 0xaeae(%rip), %rdi      # 0x20fc0
leaq 0x2620(%rip), %rsi      # 0x18739
movl $0x6, %edx
callq 0x5400
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq 0xae8f(%rip), %rdi      # 0x20fc0
callq 0x5400
movq %rax, %r14
leaq 0x2600(%rip), %rsi      # 0x18740
movl $0x4, %edx
movq %rax, %rdi
callq 0x5400
movq %r14, %rdi
callq 0x5240
leaq 0x20(%rsp), %rdi
movq %rbx, %rsi
callq 0x112ba
leaq 0x10(%rsp), %rdi
movl %eax, (%rdi)
movq %rdx, 0x8(%rdi)
movq %rsp, %rsi
callq 0xf928
testb %al, %al
je 0x161a6
movq 0xae40(%rip), %rdi      # 0x20fc0
leaq 0x2602(%rip), %rsi      # 0x18789
movl $0x8, %edx
callq 0x5400
leaq 0x20(%rsp), %rdi
callq 0x110bc
addq $0x588, %rsp            # imm = 0x588
popq %rbx
popq %r14
retq
leaq 0x2598(%rip), %rdi      # 0x18745
leaq 0x25a1(%rip), %rsi      # 0x18755
leaq 0x25a3(%rip), %rcx      # 0x1875e
movl $0x17, %edx
callq 0x5210
jmp 0x161c7
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x110bc
movq %rbx, %rdi
callq 0x55e0