LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: CallOpNode::fold(std::vector<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>, std::allocator<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>>> const&) const
const ptr_node_t CallOpNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	std::vector<ptr_node_t> nargs;
	for (auto &c : args)
		nargs.push_back(c->fold(consts));

	return std::make_shared<CallOpNode>(path, id, nargs, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
movq 0xb0(%rsi), %rbp
movq 0xb8(%rsi), %rbx
cmpq %rbx, %rbp
je 0x661fc
movq %rdx, %r15
leaq 0x10(%rsp), %r12
leaq 0x20(%rsp), %r13
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r12, %rdi
movq %r15, %rdx
callq *0x18(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x36d3e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x661f3
callq 0x1e5bc
addq $0x10, %rbp
cmpq %rbx, %rbp
jne 0x661c9
leaq 0x8(%r14), %rcx
leaq 0xa8(%r14), %r8
addq $0x28, %r14
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %r14, (%rsp)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x20(%rsp), %r9
callq 0x6d8c4
movaps 0x10(%rsp), %xmm0
movq 0x40(%rsp), %rbx
movups %xmm0, (%rbx)
leaq 0x20(%rsp), %rdi
callq 0x36cf0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6625b
movq %rax, %rbx
jmp 0x66272
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x66272
callq 0x1e5bc
leaq 0x20(%rsp), %rdi
callq 0x36cf0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/node/../rossa.h
// Function: Hash::hashValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
inline const hash_ull hashValue(const std::string &key)
	{
		if (std::find(variable_hash.begin(), variable_hash.end(), key) != variable_hash.end())
			return std::distance(variable_hash.begin(), std::find(variable_hash.begin(), variable_hash.end(), key));
		variable_hash.push_back(key);
		return variable_hash.size() - 1;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
movq 0x8(%rbx), %rsi
movq %r14, %rdx
callq 0x20d1b
movq 0x8(%rbx), %rsi
cmpq %rsi, %rax
je 0x66ac3
movq (%rbx), %rbx
movq %rbx, %rdi
movq %r14, %rdx
callq 0x20d1b
subq %rbx, %rax
sarq $0x5, %rax
jmp 0x66adc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20cde
movq 0x8(%rbx), %rax
subq (%rbx), %rax
sarq $0x5, %rax
decq %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: DefineI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t DefineI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::map<const hash_ull, const symbol_t> capturedVars;
	for (const hash_ull &e : captures)
	{
		capturedVars[e].set(&scope->getVariable(e, &token, stack_trace), &token, stack_trace);
	}
	ptr_function_t f = std::make_shared<function_t>(key, scope->getPtr(), params, body, capturedVars);
	if (key > 0)
	{
		return scope->createVariable(key, symbol_t::FunctionSIG(ftype, f), &token);
	}
	return symbol_t::FunctionSIG(ftype, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r12
movq %rdx, %r15
movq %rdi, 0x18(%rsp)
leaq 0x50(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0xd8(%rsi), %r13
movq %rsi, 0x20(%rsp)
movq 0xe0(%rsi), %rbx
cmpq %rbx, %r13
je 0x6dfba
movq 0x20(%rsp), %rax
leaq 0x8(%rax), %rbp
leaq 0x48(%rsp), %rdi
movq %r13, %rsi
callq 0x3e782
movq %rax, %r14
movq %r15, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x3ced2
movq %r14, %rdi
movq %rax, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x3ff88
addq $0x8, %r13
cmpq %rbx, %r13
jne 0x6df7f
movq %r15, %rdi
callq 0x3cf44
movq 0x20(%rsp), %r14
leaq 0x90(%r14), %r12
leaq 0x28(%rsp), %rcx
movq %rax, (%rcx)
leaq 0xb0(%r14), %r8
leaq 0xc8(%r14), %r9
leaq 0x48(%rsp), %rax
movq %rax, (%rsp)
leaq 0x38(%rsp), %rdi
leaq 0x17(%rsp), %rsi
movq %r12, %rdx
callq 0x78618
cmpq $0x0, (%r12)
je 0x6e04f
leaq 0x98(%r14), %rsi
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x3fdbc
addq $0x8, %r14
leaq 0x28(%rsp), %rdx
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rcx
callq 0x3cee2
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x3fdf4
leaq 0x28(%rsp), %rdi
callq 0x3fe06
jmp 0x6e06b
addq $0x98, %r14
leaq 0x38(%rsp), %rdx
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fdbc
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x6e07a
callq 0x1e5bc
leaq 0x48(%rsp), %rdi
callq 0x1ec5a
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e098
movq %rax, %rbx
jmp 0x6e0aa
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3fe06
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x6e0c0
callq 0x1e5bc
jmp 0x6e0c0
jmp 0x6e0bd
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1ec5a
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: SequenceI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t SequenceI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::vector<symbol_t> evals;
	for (const ptr_instruction_t &e : children)
	{
		switch (e->getType())
		{
		case UNTIL_STEP_EXC_I:
		case UNTIL_NO_STEP_EXC_I:
		case UNTIL_STEP_INC_I:
		case UNTIL_NO_STEP_INC_I:
		case EACH_I:
		{
			std::vector<symbol_t> v = e->evaluate(scope, stack_trace).getVector(&token, stack_trace);
			for (auto &&ve : v)
			{
				evals.push_back(ve);
			}
			break;
		}
		default:
			evals.push_back(e->evaluate(scope, stack_trace));
			break;
		}
	}
	return symbol_t::Array(evals);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, 0x10(%rsp)
movq %rdi, 0x48(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq 0x90(%rsi), %r12
movq %rsi, 0x8(%rsp)
movq 0x98(%rsi), %rax
movq %rax, 0x50(%rsp)
cmpq %rax, %r12
je 0x6e4f6
movq %rcx, %r14
addq $0x8, 0x8(%rsp)
leaq 0x58(%rsp), %r13
leaq 0x30(%rsp), %rbx
movq (%r12), %rsi
movl 0x88(%rsi), %eax
leal -0x13(%rax), %ecx
cmpl $0x4, %ecx
jb 0x6e45c
cmpl $0x41, %eax
jne 0x6e4cc
movq (%rsi), %rax
movq %r13, %rdi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq *(%rax)
movq %r13, %rdi
movq 0x8(%rsp), %rsi
movq %r14, %rdx
callq 0x40848
leaq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0x437fe
movq %r13, %rdi
callq 0x3fe06
movq 0x18(%rsp), %r15
movq 0x20(%rsp), %rbp
cmpq %rbp, %r15
je 0x6e4b1
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2087a
addq $0x10, %r15
jmp 0x6e49b
leaq 0x18(%rsp), %rdi
callq 0x20952
addq $0x10, %r12
cmpq 0x50(%rsp), %r12
jne 0x6e445
jmp 0x6e4f6
movq (%rsi), %rax
leaq 0x18(%rsp), %r15
movq %r15, %rdi
movq 0x10(%rsp), %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2087a
movq %r15, %rdi
callq 0x3fe06
jmp 0x6e4bb
leaq 0x30(%rsp), %rsi
movq 0x48(%rsp), %rbx
movq %rbx, %rdi
callq 0x3fda0
leaq 0x30(%rsp), %rdi
callq 0x20952
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e532
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x6e53f
jmp 0x6e532
movq %rax, %rbx
jmp 0x6e553
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3fe06
jmp 0x6e553
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x20952
leaq 0x30(%rsp), %rdi
callq 0x20952
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: IfThenElseI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t IfThenElseI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const object_t newScope(scope, 0);
	if (ifs->evaluate(&newScope, stack_trace).getBool(&token, stack_trace))
	{
		return body->evaluate(&newScope, stack_trace);
	}
	return elses->evaluate(&newScope, stack_trace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, (%rax)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3c968
movq 0x90(%r15), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq *(%rax)
leaq 0x8(%r15), %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0x409e0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x3fe06
xorb $0x1, %bpl
movzbl %bpl, %eax
shll $0x4, %eax
movq 0xa0(%r15,%rax), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq *(%rax)
leaq 0x10(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e6e2
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3fe06
jmp 0x6e6e5
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: IfThenI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t IfThenI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const object_t newScope(scope, 0);
	if (ifs->evaluate(&newScope, stack_trace).getBool(&token, stack_trace))
	{
		return body->evaluate(&newScope, stack_trace);
	}
	return symbol_t();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movq %rsp, %rax
movq $0x0, (%rax)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3c968
movq 0x90(%r15), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
movq %r12, %rdx
movq %r14, %rcx
callq *(%rax)
leaq 0x8(%r15), %rsi
movq %rsp, %rdi
movq %r14, %rdx
callq 0x409e0
movl %eax, %ebp
movq %rsp, %rdi
callq 0x3fe06
testb %bpl, %bpl
je 0x6e812
movq 0xa0(%r15), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq *(%rax)
jmp 0x6e81a
movq %rbx, %rdi
callq 0x3f9d0
leaq 0x10(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6e843
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3fe06
jmp 0x6e846
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: WhileI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t WhileI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	while (whiles->evaluate(scope, stack_trace).getBool(&token, stack_trace))
	{
		const object_t newScope(scope, OBJECT_WEAK);
		for (const ptr_instruction_t &i : body)
		{
			const symbol_t temp = i->evaluate(&newScope, stack_trace);
			bool cflag = false;
			switch (temp.getSymbolType())
			{
			case symbol_t::type_t::ID_REFER:
			case symbol_t::type_t::ID_RETURN:
				return temp;
			case symbol_t::type_t::ID_BREAK:
				return symbol_t();
			case symbol_t::type_t::ID_CONTINUE:
				cflag = true;
				break;
			default:
				break;
			}
			if (cflag)
				break;
		}
	}
	return symbol_t();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, (%rsp)
leaq 0x8(%rsi), %r13
leaq 0x28(%rsp), %rbp
leaq 0x8(%rsp), %rbx
movq %rdx, 0x20(%rsp)
movq %r13, 0x18(%rsp)
movq %rsi, %r12
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
movq %rbp, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x409e0
movl %eax, %r13d
movq %rbp, %rdi
callq 0x3fe06
testb %r13b, %r13b
je 0x6ea34
movq $0x0, 0x8(%rsp)
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x3c968
movq 0xa0(%r12), %r13
movq 0xa8(%r12), %r15
cmpq %r15, %r13
je 0x6e9d5
movq (%r13), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %rbp, %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbx, %rdi
callq 0x4040c
cmpl $0x4, %eax
ja 0x6e9bf
movl %eax, %eax
leaq 0x189ba(%rip), %rcx     # 0x87370
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x3fe06
addq $0x10, %r13
jmp 0x6e989
movq %rbx, %rdi
callq 0x3fe06
movq %rbp, %rdi
callq 0x3cb40
movq 0x20(%rsp), %r15
movq 0x18(%rsp), %r13
movq %r12, %rsi
jmp 0x6e928
leaq 0x8(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3fdf4
jmp 0x6ea0e
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3f9d0
leaq 0x8(%rsp), %rdi
callq 0x3fe06
leaq 0x28(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3f9d0
jmp 0x6ea22
jmp 0x6ea53
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3fe06
jmp 0x6ea6f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3fe06
jmp 0x6ea65
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: ForI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t ForI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const std::vector<symbol_t> evalFor = fors->evaluate(scope, stack_trace).getVector(&token, stack_trace);
	for (auto &&e : evalFor)
	{
		const object_t newScope(scope, OBJECT_WEAK);
		newScope.createVariable(id, e, &token);
		bool cflag = false;
		for (auto &&i : body)
		{
			const symbol_t temp = i->evaluate(&newScope, stack_trace);
			switch (temp.getSymbolType())
			{
			case symbol_t::type_t::ID_REFER:
			case symbol_t::type_t::ID_RETURN:
				return temp;
			case symbol_t::type_t::ID_BREAK:
				return symbol_t();
			case symbol_t::type_t::ID_CONTINUE:
				cflag = true;
				break;
			default:
				break;
			}
			if (cflag)
				break;
		}
	}
	return symbol_t();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, (%rsp)
movq 0x98(%rsi), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq *(%rax)
movq %r15, 0x8(%rsp)
leaq 0x8(%r15), %r13
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, 0x48(%rsp)
movq %r14, %rdx
callq 0x40848
leaq 0x50(%rsp), %rdi
movq %rax, %rsi
callq 0x437fe
leaq 0x10(%rsp), %rdi
callq 0x3fe06
movq 0x50(%rsp), %rbp
movq 0x58(%rsp), %rax
movq %rax, 0x38(%rsp)
cmpq %rax, %rbp
je 0x6ec72
movq 0x8(%rsp), %rax
addq $0x90, %rax
movq %rax, 0x40(%rsp)
leaq 0x10(%rsp), %rbx
leaq 0x20(%rsp), %r15
movq %r12, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3c968
movq %rbx, %r14
movq %rbx, %rdi
movq 0x40(%rsp), %rsi
movq %rbp, %rdx
movq %r13, %rbx
movq %r13, %rcx
callq 0x3cee2
movq 0x8(%rsp), %rax
movq 0xa8(%rax), %r13
movq 0xb0(%rax), %r12
cmpq %r12, %r13
je 0x6ec50
movq (%r13), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movq %r14, %rdx
movq 0x48(%rsp), %rcx
callq *(%rax)
movq %r15, %rdi
callq 0x4040c
cmpl $0x4, %eax
ja 0x6ec3a
movl %eax, %eax
leaq 0x18753(%rip), %rcx     # 0x87384
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %r15, %rdi
callq 0x3fe06
addq $0x10, %r13
jmp 0x6ec02
movq %r15, %rdi
callq 0x3fe06
movq %r14, %rdi
callq 0x3cb40
addq $0x10, %rbp
cmpq 0x38(%rsp), %rbp
movq 0x30(%rsp), %r12
movq %rbx, %r13
movq %r14, %rbx
jne 0x6ebbf
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3f9d0
jmp 0x6ecb3
leaq 0x20(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3fdf4
jmp 0x6ec9f
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3f9d0
leaq 0x20(%rsp), %rdi
callq 0x3fe06
leaq 0x10(%rsp), %rdi
callq 0x3cb40
leaq 0x50(%rsp), %rdi
callq 0x20952
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x6ecd5
jmp 0x6ece9
jmp 0x6ecf8
movq %rax, %rbx
jmp 0x6ed05
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3fe06
jmp 0x6ed0f
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x3fe06
jmp 0x6ecfb
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3cb40
leaq 0x50(%rsp), %rdi
callq 0x20952
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: InnerI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t InnerI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const symbol_t evalA = a->evaluate(scope, stack_trace);
	switch (evalA.getValueType())
	{
	case value_type_enum::OBJECT:
	{
		const auto &o = evalA.getObject(&token, stack_trace);
		if (o->getType() != scope_type_enum::SCOPE_STATIC && o->getType() != scope_type_enum::SCOPE_INSTANCE)
			throw rossa_error_t(_CANNOT_INDEX_OBJECT_, token, stack_trace);
		return b->evaluate(o, stack_trace);
	}
	default:
		throw rossa_error_t(_CANNOT_INDEX_VALUE_, token, stack_trace);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq *(%rax)
movq %r12, %rdi
callq 0x40b5a
cmpl $-0x8, %eax
jne 0x6f2fa
leaq 0x8(%r14), %r12
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x40a9e
movq %rax, %r13
movq %rax, %rdi
callq 0x3cf0e
cmpl $0x2, %eax
je 0x6f2c9
movq %r13, %rdi
callq 0x3cf0e
cmpl $0x3, %eax
jne 0x6f35d
movq 0xa0(%r14), %rsi
movq (%rsi), %rax
movq %r15, %rdi
movq %r13, %rdx
movq %rbx, %rcx
callq *(%rax)
leaq 0x28(%rsp), %rdi
callq 0x3fe06
movq %r15, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101e0
movq %rax, %r15
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x18410(%rip), %rsi     # 0x87728
leaq 0x18428(%rip), %rdx     # 0x87747
leaq 0x8(%rsp), %rdi
callq 0x1e698
addq $0x8, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x419d4(%rip), %rsi     # 0xb0d20
leaq -0x380af(%rip), %rdx    # 0x372a4
movq %r15, %rdi
callq 0x106d0
jmp 0x6f3b9
movl $0xa8, %edi
callq 0x101e0
movq %rax, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1837b(%rip), %rsi     # 0x876f5
leaq 0x183a6(%rip), %rdx     # 0x87727
leaq 0x8(%rsp), %rdi
callq 0x1e698
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x41976(%rip), %rsi     # 0xb0d20
leaq -0x3810d(%rip), %rdx    # 0x372a4
movq %r14, %rdi
callq 0x106d0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6f3d3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x6f3dd
jmp 0x6f417
movq %rax, %rbx
movq %r14, %rdi
jmp 0x6f409
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x6f3fc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x6f406
jmp 0x6f417
movq %rax, %rbx
movq %r15, %rdi
callq 0x102d0
jmp 0x6f417
jmp 0x6f414
jmp 0x6f414
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: EqualsI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t EqualsI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const symbol_t evalA = a->evaluate(scope, stack_trace);
	const symbol_t evalB = b->evaluate(scope, stack_trace);

	if (evalA.getValueType() == value_type_enum::OBJECT && !evalA.getObject(&token, stack_trace)->hasValue(parser_t::HASH_EQUALS))
		return scope->getVariable(parser_t::HASH_EQUALS, &token, stack_trace).call({evalA, evalB}, &token, stack_trace);

	return symbol_t::Boolean(evalA.equals(&evalB, &token, stack_trace));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0xa0(%r12), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
movq %r13, %rdx
movq %r14, %rcx
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x40b5a
cmpl $-0x8, %eax
jne 0x6fefd
leaq 0x8(%r12), %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40a9e
leaq 0x45acf(%rip), %rsi     # 0xb59c0
movq %rax, %rdi
callq 0x3ce6c
testb %al, %al
je 0x6ff2a
addq $0x8, %r12
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x42c72
leaq 0x28(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x3fd92
jmp 0x6ffb6
leaq 0x45a8f(%rip), %rsi     # 0xb59c0
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
movq %rax, %r12
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3fdf4
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3fdf4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
callq 0x436ac
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x41ffe
leaq 0x48(%rsp), %rdi
callq 0x20952
movl $0x10, %r14d
leaq (%rsp,%r14), %rdi
addq $0x28, %rdi
callq 0x3fe06
addq $-0x10, %r14
cmpq $-0x10, %r14
jne 0x6ff9f
leaq 0x18(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20952
jmp 0x6ffed
movq %rax, %rbx
movl $0x10, %r14d
leaq (%rsp,%r14), %rdi
addq $0x28, %rdi
callq 0x3fe06
addq $-0x10, %r14
cmpq $-0x10, %r14
jne 0x6fff3
jmp 0x70027
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3fe06
jmp 0x70027
jmp 0x70024
movq %rax, %rbx
jmp 0x70031
jmp 0x70024
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: NEqualsI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t NEqualsI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const symbol_t evalA = a->evaluate(scope, stack_trace);
	const symbol_t evalB = b->evaluate(scope, stack_trace);

	if (evalA.getValueType() == value_type_enum::OBJECT && !evalA.getObject(&token, stack_trace)->hasValue(parser_t::HASH_NEQUALS))
		return scope->getVariable(parser_t::HASH_NEQUALS, &token, stack_trace).call({evalA, evalB}, &token, stack_trace);

	return symbol_t::Boolean(evalA.nequals(&evalB, &token, stack_trace));
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r12
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
callq *(%rax)
movq 0xa0(%r12), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdi
movq %r13, %rdx
movq %r14, %rcx
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x40b5a
cmpl $-0x8, %eax
jne 0x700f3
leaq 0x8(%r12), %r15
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40a9e
leaq 0x458e1(%rip), %rsi     # 0xb59c8
movq %rax, %rdi
callq 0x3ce6c
testb %al, %al
je 0x70120
addq $0x8, %r12
leaq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x43066
leaq 0x28(%rsp), %rsi
movb %al, (%rsi)
movq %rbx, %rdi
callq 0x3fd92
jmp 0x701ac
leaq 0x458a1(%rip), %rsi     # 0xb59c8
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
movq %rax, %r12
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x3fdf4
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3fdf4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x7(%rsp), %rcx
movl $0x2, %edx
callq 0x436ac
leaq 0x48(%rsp), %rdx
movq %rbx, %rdi
movq %r12, %rsi
movq %r15, %rcx
movq %r14, %r8
callq 0x41ffe
leaq 0x48(%rsp), %rdi
callq 0x20952
movl $0x10, %r14d
leaq (%rsp,%r14), %rdi
addq $0x28, %rdi
callq 0x3fe06
addq $-0x10, %r14
cmpq $-0x10, %r14
jne 0x70195
leaq 0x18(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20952
jmp 0x701e3
movq %rax, %rbx
movl $0x10, %r14d
leaq (%rsp,%r14), %rdi
addq $0x28, %rdi
callq 0x3fe06
addq $-0x10, %r14
cmpq $-0x10, %r14
jne 0x701e9
jmp 0x7021d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x3fe06
jmp 0x7021d
jmp 0x7021a
movq %rax, %rbx
jmp 0x70227
jmp 0x7021a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: AndI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t AndI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	if (!a->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(false);
	if (b->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(true);
	return symbol_t::Boolean(false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq *(%rax)
leaq 0x8(%r13), %r12
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x409e0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3fe06
testb %bpl, %bpl
je 0x70304
movq 0xa0(%r13), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *(%rax)
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x409e0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3fe06
testb %bpl, %bpl
je 0x70304
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
jmp 0x7030c
leaq 0x8(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x3fd92
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x70328
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: OrI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t OrI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	if (a->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(true);
	if (b->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(true);
	return symbol_t::Boolean(false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r13
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq *(%rax)
leaq 0x8(%r13), %r12
movq %rbp, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x409e0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3fe06
testb %bpl, %bpl
jne 0x703fe
movq 0xa0(%r13), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *(%rax)
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x409e0
movl %eax, %ebp
leaq 0x8(%rsp), %rdi
callq 0x3fe06
testb %bpl, %bpl
je 0x70408
leaq 0x8(%rsp), %rsi
movb $0x1, (%rsi)
jmp 0x70410
leaq 0x8(%rsp), %rsi
movb $0x0, (%rsi)
movq %rbx, %rdi
callq 0x3fd92
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7042c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: ExternI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t ExternI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	auto evalA = a->evaluate(scope, stack_trace);
	std::vector<mediator_t> mv;
	for (auto &e : evalA.getVector(&token, stack_trace))
	{
		mv.push_back(global::convertToMediator(e, &token, stack_trace));
	}
	try
	{
		return global::convertToSymbol(f(mv));
	}
	catch (const library_error_t &e)
	{
		throw rossa_error_t(e.what(), token, stack_trace);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %rbx
movq %rsi, %r14
movq %rdi, 0x48(%rsp)
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
leaq 0x58(%rsp), %r15
movq %r15, %rdi
callq *(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x40(%rsp)
movq %r14, 0x50(%rsp)
addq $0x8, %r14
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x40848
movq (%rax), %r13
movq 0x8(%rax), %r12
cmpq %r12, %r13
je 0x70e0d
leaq 0x10(%rsp), %rbp
leaq 0x30(%rsp), %r15
movq %rbp, %rdi
movq %r13, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x56cf7
movq %r15, %rdi
movq %rbp, %rsi
callq 0x5791e
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x70e04
callq 0x1e5bc
addq $0x10, %r13
cmpq %r12, %r13
jne 0x70dd9
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq 0x50(%rsp), %rax
callq *0xe0(%rax)
leaq 0x10(%rsp), %rsi
movq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x5744d
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x70e43
callq 0x1e5bc
leaq 0x30(%rsp), %rdi
callq 0x5796a
leaq 0x58(%rsp), %rdi
callq 0x3fe06
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r12
movq %rax, %r15
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x70e86
callq 0x1e5bc
jmp 0x70e86
movq %rdx, %r12
movq %rax, %r15
cmpl $0x1, %r12d
jne 0x70f49
movq %r15, %rdi
callq 0x101a0
movq %rax, %r15
movl $0xa8, %edi
callq 0x101e0
movq %rax, %r12
movq (%r15), %rax
movq %r15, %rdi
callq *0x10(%rax)
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
movq %rax, %rsi
callq 0x1d0f8
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x3fe3e(%rip), %rsi     # 0xb0d20
leaq -0x39c45(%rip), %rdx    # 0x372a4
movq %r12, %rdi
callq 0x106d0
movq %rax, %r15
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x70f0f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x70f19
jmp 0x70f21
movq %rax, %r15
movq %r12, %rdi
callq 0x102d0
callq 0x10690
jmp 0x70f49
movq %rax, %rdi
callq 0x1d626
jmp 0x70f32
movq %rax, %r15
jmp 0x70f49
movq %rax, %r15
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x70f49
callq 0x1e5bc
leaq 0x30(%rsp), %rdi
callq 0x5796a
leaq 0x58(%rsp), %rdi
callq 0x3fe06
movq %r15, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: AllocI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t AllocI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const long_int_t evalA = a->evaluate(scope, stack_trace).getNumber(&token, stack_trace).getLong();
	if (evalA < 0)
		throw rossa_error_t(_FAILURE_ALLOC_, token, stack_trace);
	if (setall)
	{
		auto evalB = setall->evaluate(scope, stack_trace);
		return symbol_t::allocateAs(evalA, &evalB, &token, stack_trace);
	}
	return symbol_t::allocate(evalA);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %rbp
movq %rbp, %rdi
callq *(%rax)
leaq 0x8(%r13), %r15
movq %rbp, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x40416
movq %rax, %rdi
callq 0x47180
movq %rax, %rbp
movq %rsp, %rdi
callq 0x3fe06
testq %rbp, %rbp
js 0x732ea
movq 0xa0(%r13), %rsi
testq %rsi, %rsi
je 0x732ca
movq (%rsi), %rax
movq %rsp, %r13
movq %r13, %rdi
movq %r12, %rdx
movq %rbx, %rcx
callq *(%rax)
leaq 0x20(%rsp), %rsi
movq %rbp, (%rsi)
movq %r14, %rdi
movq %r13, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x3fec4
movq %rsp, %rdi
callq 0x3fe06
jmp 0x732d8
movq %rsp, %rsi
movq %rbp, (%rsi)
movq %r14, %rdi
callq 0x3fe70
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101e0
movq %rax, %r14
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x144b8(%rip), %rsi     # 0x877c0
leaq 0x144d8(%rip), %rdx     # 0x877e7
movq %rsp, %rdi
callq 0x1e698
movb $0x1, %bpl
movq %rsp, %rsi
movq %r14, %rdi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x3d9ec(%rip), %rsi     # 0xb0d20
leaq -0x3c097(%rip), %rdx    # 0x372a4
movq %r14, %rdi
callq 0x106d0
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x7335c
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x73366
jmp 0x7337d
movq %rax, %rbx
movq %r14, %rdi
callq 0x102d0
jmp 0x7337d
jmp 0x73372
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: ScopeI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t ScopeI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	for (const ptr_instruction_t &e : children)
	{
		const symbol_t eval = e->evaluate(scope, stack_trace);
		if (eval.getSymbolType() != symbol_t::type_t::ID_CASUAL)
			return eval;
	}
	return symbol_t();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x90(%rsi), %r12
movq 0x98(%rsi), %r13
cmpq %r13, %r12
je 0x73869
movq %rcx, %r14
movq %rdx, %r15
movq (%r12), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbx, %rdi
callq 0x4040c
cmpl $0x3, %eax
jne 0x73871
movq %rbx, %rdi
callq 0x3fe06
addq $0x10, %r12
cmpq %r13, %r12
jne 0x73839
movq %rbx, %rdi
callq 0x3f9d0
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x3fe06
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: MapI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t MapI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::map<const std::string, const symbol_t> evals;
	for (auto &&e : children)
	{
		const symbol_t eval = e.second->evaluate(scope, stack_trace);
		if (eval.getValueType() == value_type_enum::NIL)
			continue;
		evals.insert({e.first, eval});
	}
	return symbol_t::Dictionary(evals);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r14
movq %rsi, %r12
movq %rdi, (%rsp)
leaq 0x50(%rsp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
movq 0xa8(%rsi), %r13
addq $0x98, %r12
cmpq %r12, %r13
je 0x739b6
movq %rdx, %r15
leaq 0x38(%rsp), %rbx
leaq 0x8(%rsp), %rbp
movq 0x40(%r13), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbx, %rdi
callq 0x40b5a
cmpl $-0x1, %eax
je 0x7399e
leaq 0x20(%r13), %rsi
movq %rbp, %rdi
movq %rbx, %rdx
callq 0x76424
leaq 0x48(%rsp), %rdi
movq %rbp, %rsi
callq 0x45d92
leaq 0x28(%rsp), %rdi
callq 0x3fe06
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x7399e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %rbx, %rdi
callq 0x3fe06
movq %r13, %rdi
callq 0x104b0
movq %rax, %r13
cmpq %r12, %rax
jne 0x7393d
leaq 0x48(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3fde6
leaq 0x48(%rsp), %rdi
callq 0x43c6a
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x739f6
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x57a94
jmp 0x739fe
jmp 0x739fb
movq %rax, %rbx
jmp 0x73a08
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3fe06
leaq 0x48(%rsp), %rdi
callq 0x43c6a
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: SwitchI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t SwitchI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const object_t newScope(scope, 0);
	const symbol_t eval = switchs->evaluate(&newScope, stack_trace);
	size_t index = 0;
	const auto it = cases_solved.find(eval);
	if (it != cases_solved.end())
	{
		index = it->second;
	}
	else if (!cases_unsolved.empty())
	{
		for (auto &&e : cases_unsolved)
		{
			const symbol_t evalE = e.first->evaluate(&newScope, stack_trace);
			if (evalE.equals(&eval, &token, stack_trace))
			{
				index = e.second;
				break;
			}
		}
	}

	if (index > 0)
	{
		return cases[index - 1]->evaluate(&newScope, stack_trace);
	}
	else if (elses)
	{
		return elses->evaluate(&newScope, stack_trace);
	}

	return symbol_t();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rsp), %rax
movq $0x0, (%rax)
leaq 0x18(%rsp), %rbx
movq %rbx, %rdi
movq %rdx, %rsi
movq %rax, %rdx
callq 0x3c968
movq 0x90(%r15), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdi
movq %rbx, %rdx
movq %r14, %rcx
callq *(%rax)
leaq 0xa0(%r15), %rdi
leaq 0x8(%rsp), %rsi
callq 0x78a68
movq %r12, (%rsp)
leaq 0xa8(%r15), %rcx
cmpq %rcx, %rax
je 0x73c40
movq 0x30(%rax), %r13
testq %r13, %r13
je 0x73cc3
movq 0x100(%r15), %rax
shlq $0x4, %r13
movq -0x10(%rax,%r13), %rsi
jmp 0x73ccf
cmpq $0x0, 0xf8(%r15)
je 0x73cc3
movq 0xe8(%r15), %r12
leaq 0xd8(%r15), %rax
movq %rax, 0x30(%rsp)
cmpq %rax, %r12
je 0x73cc3
leaq 0x8(%r15), %rax
movq %rax, 0x28(%rsp)
leaq 0x38(%rsp), %rbp
movq 0x20(%r12), %rsi
movq (%rsi), %rax
movq %rbp, %rdi
leaq 0x18(%rsp), %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbp, %rdi
leaq 0x8(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r14, %rcx
callq 0x42c72
movl %eax, %ebx
movq 0x30(%r12), %r13
movq %rbp, %rdi
callq 0x3fe06
testb %bl, %bl
jne 0x73c22
movq %r12, %rdi
callq 0x104b0
movq %rax, %r12
cmpq 0x30(%rsp), %rax
jne 0x73c70
movq 0x118(%r15), %rsi
testq %rsi, %rsi
je 0x73ce5
movq (%rsi), %rax
leaq 0x18(%rsp), %rdx
movq (%rsp), %rbx
movq %rbx, %rdi
movq %r14, %rcx
callq *(%rax)
jmp 0x73cf1
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x3f9d0
leaq 0x8(%rsp), %rdi
callq 0x3fe06
leaq 0x18(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x73d3a
jmp 0x73d1e
movq %rax, %rbx
jmp 0x73d30
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rdi
callq 0x3fe06
leaq 0x18(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: TryCatchI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t TryCatchI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	try
	{
		const object_t newScope(scope, 0);
		return a->evaluate(&newScope, stack_trace);
	}
	catch (const rossa_error_t &e)
	{
		const object_t newScope(scope, 0);
		newScope.createVariable(key, symbol_t::String(std::string(e.what())), &token);
		return b->evaluate(&newScope, stack_trace);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r14
movq %rdx, %r13
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x18(%rsp), %rdi
movq %r13, %rsi
callq 0x3c968
movq 0x90(%r15), %rsi
movq (%rsi), %rax
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq *(%rax)
leaq 0x18(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %rbp
movq %rax, %r12
leaq 0x18(%rsp), %rdi
callq 0x3cb40
jmp 0x73e0a
movq %rdx, %rbp
movq %rax, %r12
cmpl $0x1, %ebp
jne 0x73f0f
movq %r12, %rdi
callq 0x101a0
movq %rax, %r12
leaq 0x18(%rsp), %rdx
movq $0x0, (%rdx)
leaq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x3c968
movq (%r12), %rax
movq %r12, %rdi
callq *0x10(%rax)
leaq 0x18(%rsp), %rdi
leaq 0x7(%rsp), %rdx
movq %rax, %rsi
callq 0x1d0f8
leaq 0x38(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x3fdd8
leaq 0xb0(%r15), %rsi
leaq 0x8(%r15), %rcx
leaq 0x8(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x3cee2
leaq 0x38(%rsp), %rdi
callq 0x3fe06
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73ea1
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x103d0
movq 0xa0(%r15), %rsi
movq (%rsi), %rax
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
movq %r14, %rcx
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x3cb40
callq 0x10690
jmp 0x73de0
jmp 0x73efd
movq %rax, %r12
leaq 0x38(%rsp), %rdi
callq 0x3fe06
jmp 0x73ee0
movq %rax, %r12
leaq 0x28(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x73f00
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x73f00
movq %rax, %r12
leaq 0x8(%rsp), %rdi
callq 0x3cb40
callq 0x10690
movq %r12, %rdi
callq 0x106f0
movq %rax, %r12
jmp 0x73f0a
movq %rax, %rdi
callq 0x1d626
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: CharNI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t CharNI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const std::string evalA = a->evaluate(scope, stack_trace).getString(&token, stack_trace);
	std::vector<symbol_t> nv;
	for (auto &&c : evalA)
		nv.push_back(symbol_t::Number(number_t::Long(c)));
	return symbol_t::Array(nv);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, 0x18(%rsp)
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %r12
movq %r12, %rdi
callq *(%rax)
addq $0x8, %r15
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x40904
movq %rsp, %r14
movq %r14, %rdi
callq 0x3fe06
xorps %xmm0, %xmm0
movaps %xmm0, (%r14)
movq $0x0, 0x10(%r14)
movq 0x30(%rsp), %rbp
testq %rbp, %rbp
je 0x742c4
movq 0x28(%rsp), %rbx
xorl %r14d, %r14d
leaq 0x58(%rsp), %r15
leaq 0x48(%rsp), %r12
movq %rsp, %r13
movsbq (%rbx,%r14), %rax
movq %rax, 0x20(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x47014
movq %rax, 0x48(%rsp)
movl %edx, 0x50(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3fd84
movq %r13, %rdi
movq %r15, %rsi
callq 0x2087a
movq %r15, %rdi
callq 0x3fe06
incq %r14
cmpq %r14, %rbp
jne 0x74281
movq %rsp, %rsi
movq 0x18(%rsp), %rbx
movq %rbx, %rdi
callq 0x3fda0
movq %rsp, %rdi
callq 0x20952
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x742f7
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x74318
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3fe06
jmp 0x7434d
movq %rax, %rbx
jmp 0x7432a
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x3fe06
movq %rsp, %rdi
callq 0x20952
leaq 0x38(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x7434d
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: DeclareVarsI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t DeclareVarsI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::vector<symbol_t> newvs;
	for (const hash_ull &k : keys)
		newvs.push_back(scope->createVariable(k, &token));
	return symbol_t::Array(newvs);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x90(%rsi), %r12
movq 0x98(%rsi), %rbp
cmpq %rbp, %r12
je 0x74677
movq %rdx, %r14
movq %rsi, %r15
addq $0x8, %r15
movq %rsp, %r13
movq %r14, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x3ceda
movq %r13, %rdi
movq %rax, %rsi
callq 0x2087a
addq $0x8, %r12
cmpq %rbp, %r12
jne 0x74655
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3fda0
movq %rsp, %rdi
callq 0x20952
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x7469e
movq %rax, %rbx
movq %rsp, %rdi
callq 0x20952
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: BNotI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t BNotI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	return operation::bnot(
		scope,
		a->evaluate(scope, stack_trace),
		&token,
		stack_trace);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
movq %rsp, %r13
movq %r13, %rdi
callq *(%rax)
addq $0x8, %r12
movq %rbx, %rdi
movq %r15, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq %r14, %r8
callq 0x803be
movq %rsp, %rdi
callq 0x3fe06
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: SetIndexI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t SetIndexI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	auto evalA = a->evaluate(scope, stack_trace);
	auto evalAVector = evalA.getVector(&token, stack_trace);
	auto evalBVector = b->evaluate(scope, stack_trace).getVector(&token, stack_trace);
	if (evalAVector.size() != evalBVector.size())
	{
		throw rossa_error_t(_INCOMPATIBLE_VECTOR_SIZES_, token, stack_trace);
	}
	for (size_t i = 0; i < evalAVector.size(); i++)
	{
		evalAVector[i].set(&evalBVector[i], &token, stack_trace);
	}
	return evalA;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r14
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
movq 0x90(%rsi), %rsi
movq (%rsi), %rax
callq *(%rax)
leaq 0x8(%r13), %r15
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40848
leaq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x437fe
movq 0xa0(%r13), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
movq %r12, %rdx
movq %r14, %rcx
callq *(%rax)
leaq 0x20(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x40848
leaq 0x40(%rsp), %rdi
movq %rax, %rsi
callq 0x437fe
leaq 0x20(%rsp), %rdi
callq 0x3fe06
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq %rax, %rcx
subq %rdi, %rcx
movq 0x48(%rsp), %rdx
subq 0x40(%rsp), %rdx
cmpq %rdx, %rcx
jne 0x75bc6
cmpq %rdi, %rax
je 0x75ba0
xorl %r12d, %r12d
xorl %r13d, %r13d
addq %r12, %rdi
movq 0x40(%rsp), %rsi
addq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ff88
incq %r13
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
subq %rdi, %rax
sarq $0x4, %rax
addq $0x10, %r12
cmpq %rax, %r13
jb 0x75b6d
leaq 0x40(%rsp), %rdi
callq 0x20952
leaq 0x8(%rsp), %rdi
callq 0x20952
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101e0
movq %rax, %r12
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11c27(%rip), %rsi     # 0x8780a
leaq 0x11c47(%rip), %rdx     # 0x87831
leaq 0x20(%rsp), %rdi
callq 0x1e698
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x3b10d(%rip), %rsi     # 0xb0d20
leaq -0x3e976(%rip), %rdx    # 0x372a4
movq %r12, %rdi
callq 0x106d0
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x75c3c
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x75c46
jmp 0x75c6c
movq %rax, %r14
movq %r12, %rdi
callq 0x102d0
jmp 0x75c6c
movq %rax, %r14
jmp 0x75c76
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x3fe06
jmp 0x75c76
movq %rax, %r14
jmp 0x75c80
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x20952
leaq 0x8(%rsp), %rdi
callq 0x20952
movq %rbx, %rdi
callq 0x3fe06
movq %r14, %rdi
callq 0x106f0