LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseNewNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseNewNode(std::vector<node_scope_t> *scopes)
{
	nextToken();

	auto body = parseUnitNode(scopes);
	if (body->getType() != Node::type_t::CALL_NODE)
		return logErrorN(_EXPECTED_OBJECT_NAME_, currentToken);
	auto object = reinterpret_cast<CallNode *>(body.get())->getCallee();
	auto params = std::make_shared<VectorNode>(*scopes, (reinterpret_cast<CallNode *>(body.get())->getArgs()), false, currentToken);

	return std::make_shared<NewNode>(*scopes, object, params, currentToken);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e24
leaq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2780a
movq (%r12), %rdi
callq 0x4ec06
cmpl $0x1, %eax
jne 0x2778d
movq 0x20(%rsp), %rsi
leaq 0x10(%rsp), %rdi
callq 0x51488
movq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdi
callq 0x5149e
leaq 0xf(%rsp), %rcx
movb $0x0, (%rcx)
addq $0x58, %r14
leaq 0x58(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r15, %rsi
movq %r14, %r8
callq 0x2ec88
leaq 0x30(%rsp), %rdi
callq 0x2e838
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
leaq 0x58(%rsp), %rcx
movq %r15, %rsi
movq %r14, %r8
callq 0x2ecaf
leaq 0x38(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x60(%rsp), %rdi
callq 0x1d786
leaq 0x18(%rsp), %rdi
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x4f1bc(%rip), %rsi     # 0x76950
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1c814
leaq 0x58(%r14), %rcx
leaq 0x30(%rsp), %rdx
movq %r14, %rsi
callq 0x25932
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x101d0
jmp 0x277f7
jmp 0x277f4
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x1d786
jmp 0x277e6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2e838
jmp 0x277e6
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x277f7
jmp 0x277f4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1d786
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseTypeNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseTypeNode(std::vector<node_scope_t> *scopes)
{
	nextToken();
	aug_type_t ftype = {};
	while (currentToken.type == TOK_IDF)
	{
		ftype.push_back(ROSSA_HASH(currentToken.valueString));
		nextToken();
		if (currentToken.type != TOK_INNER)
			break;
		nextToken();
	}
	return std::make_shared<ContainerNode>(*scopes, symbol_t::TypeName(parameter_t({}, {ftype})), currentToken);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e24
leaq 0xb0(%r14), %r12
leaq 0x20(%rsp), %r13
andq $0x0, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
leaq 0x8e1d4(%rip), %rbp     # 0xb6908
leaq 0x70(%rsp), %r15
cmpl $-0x2, 0xd0(%r14)
jne 0x2877a
movq %rbp, %rdi
movq %r12, %rsi
callq 0x1efb0
movq %rax, 0x70(%rsp)
movq %r13, %rdi
movq %r15, %rsi
callq 0x31648
movq %r14, %rdi
callq 0x22e24
cmpl $-0x27, 0xd0(%r14)
jne 0x2877a
movq %r14, %rdi
callq 0x22e24
jmp 0x28739
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
leaq 0x70(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0x36e60
leaq 0x10(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x39072
addq $0x58, %r14
leaq 0x60(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rsi
movq %r14, %rcx
callq 0x2e7a5
leaq 0x68(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x10(%rsp), %rdi
callq 0x39102
leaq 0x70(%rsp), %rdi
callq 0x2e9f6
leaq 0x40(%rsp), %rdi
callq 0x2e99e
leaq 0x20(%rsp), %rdi
callq 0x2fa2a
movq %rbx, %rax
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39102
jmp 0x2882c
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x2e9f6
jmp 0x2883b
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x2e99e
jmp 0x2884c
jmp 0x28849
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x2fa2a
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseUntilNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*, std::shared_ptr<Node> const&, bool const&)
ptr_node_t node_parser_t::parseUntilNode(std::vector<node_scope_t> *scopes, const ptr_node_t &a, const bool &inclusive)
{
	nextToken();

	auto b = parseEquNode(scopes);
	if (!b)
		return logErrorN(_FAILURE_PARSE_CODE_, currentToken);

	if (currentToken.type == ':')
	{
		nextToken();
		auto step = parseEquNode(scopes);
		if (!step)
			return logErrorN(_FAILURE_PARSE_CODE_, currentToken);

		return std::make_shared<UntilNode>(*scopes, a, b, step, inclusive, currentToken);
	}

	return std::make_shared<UntilNode>(*scopes, a, b, nullptr, inclusive, currentToken);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x22e24
leaq 0x48(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x25798
cmpq $0x0, (%rbp)
je 0x28970
leaq 0x58(%r14), %rbp
cmpl $0x3a, 0xd0(%r14)
jne 0x28915
movq %r14, %rdi
callq 0x22e24
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x25798
cmpq $0x0, 0x10(%rsp)
je 0x28997
movq %rbp, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %r9
callq 0x2ee12
leaq 0x28(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x18(%rsp), %rdi
jmp 0x2894f
leaq 0x10(%rsp), %r8
andq $0x0, (%r8)
movq %rbp, (%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %rcx
movq %r13, %rsi
movq %r12, %rdx
movq %r15, %r9
callq 0x2ee43
leaq 0x28(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x50(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4dfc3(%rip), %rsi     # 0x7693a
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x1c814
leaq 0x58(%r14), %rcx
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
callq 0x25932
leaq 0x4df9c(%rip), %rsi     # 0x7693a
leaq 0x20(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1c814
leaq 0x20(%rsp), %rdx
movq %r14, %rsi
movq %rbp, %rcx
callq 0x25932
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x101d0
jmp 0x289d1
jmp 0x289ce
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x289f5
jmp 0x289f2
jmp 0x289f2
jmp 0x289f2
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x101d0
jmp 0x289f5
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1d786
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseExternNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseExternNode(std::vector<node_scope_t> *scopes)
{

	nextToken();

	std::string libname = currentToken.valueString;

	nextToken();
	if (currentToken.type != ';')
		return logErrorN(util::format(_EXPECTED_ERROR_, {";"}), currentToken);
	nextToken();

	global::loadLibrary(currentFile.parent_path(), libname, &currentToken);
	return nullptr;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x22e24
leaq 0xb0(%rbx), %rsi
leaq 0x50(%rsp), %rdi
callq 0x10550
movq %rbx, %rdi
callq 0x22e24
leaq 0x58(%rbx), %r14
cmpl $0x3b, 0xd0(%rbx)
jne 0x2dbc4
movq %rbx, %rdi
callq 0x22e24
addq $0x28, %rbx
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
callq 0x10750
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
movq %r14, %rdx
callq 0x4bd75
leaq 0x10(%rsp), %rdi
callq 0x1ca5c
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq %r15, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
leaq 0x48cd9(%rip), %rsi     # 0x768a4
leaq 0x90(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1c814
leaq 0x4854e(%rip), %rsi     # 0x76132
leaq 0x70(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1c814
leaq 0x38(%rsp), %rdi
leaq 0x70(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xd(%rsp), %rcx
callq 0x1f298
leaq 0x10(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x38(%rsp), %rdx
callq 0x3f724
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x25932
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x2dc43
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1cea0
jmp 0x2dc52
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x101d0
jmp 0x2dc61
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x101d0
jmp 0x2dc86
jmp 0x2dc83
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1ca5c
jmp 0x2dc86
jmp 0x2dc83
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::object_t(unsigned long long const&)
object_t::object_t(const hash_ull &key)
	: scope{new scope_t(scope_type_enum::SCOPE_BOUNDED, NULL, nullptr, key)}, type{OBJECT_STRONG}
{
#ifdef DEBUG
	parser_t::object_count++;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %r14
movl $0x88, %edi
callq 0x103c0
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
movq %rax, %rbx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rax, %rdi
xorl %edx, %edx
movq %r15, %r8
callq 0x375e0
leaq 0x18(%rsp), %rdi
callq 0x1d786
movq %rbx, (%r14)
movl $0x1, 0x8(%r14)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x1d786
movl $0x88, %esi
movq %rbx, %rdi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::object_t(object_t const*, unsigned long long const&)
object_t::object_t(const object_t *parent, const hash_ull &key)
	: scope{new scope_t(scope_type_enum::SCOPE_BOUNDED, parent->scope, nullptr, key)}, type{OBJECT_STRONG}
{
#ifdef DEBUG
	parser_t::object_count++;
#endif
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movl $0x88, %edi
callq 0x103c0
movq %rax, %rbx
leaq 0xc(%rsp), %rsi
andl $0x0, (%rsi)
movq (%r12), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rax, %rdi
movq %r15, %r8
callq 0x375e0
leaq 0x18(%rsp), %rdi
callq 0x1d786
movq %rbx, (%r14)
movl $0x1, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x18(%rsp), %rdi
callq 0x1d786
movl $0x88, %esi
movq %rbx, %rdi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::object_t(object_t const*, scope_type_enum const&, std::shared_ptr<Instruction const> const&, unsigned long long const&, object_t const*, std::vector<std::vector<long long, std::allocator<long long>>, std::allocator<std::vector<long long, std::allocator<long long>>>> const&)
object_t::object_t(const object_t *parent, const scope_type_enum &type, const ptr_instruction_t &body, const hash_ull &key, const object_t *ex, const std::vector<aug_type_t> &extensions)
	: scope{new scope_t(type, parent->scope, body, key)}, type{OBJECT_STRONG}
{
#ifdef DEBUG
	parser_t::object_count++;
#endif
	if (ex != NULL)
	{
		this->scope->extensions = ex->scope->extensions;
		this->scope->extensions.push_back(ex->scope->name_trace);
	}
	else
	{
		this->scope->extensions = extensions;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
movq 0x50(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x88, %edi
callq 0x103c0
movq %rax, %r15
movq (%r13), %rdx
movq %rax, %rdi
movq %r12, %rsi
movq %rbp, %rcx
movq 0x10(%rsp), %r8
callq 0x375e0
movq %r15, (%r14)
movl $0x1, 0x8(%r14)
testq %rbx, %rbx
je 0x36342
movq (%rbx), %rsi
addq $0x70, %rsi
addq $0x70, %r15
movq %r15, %rdi
callq 0x36748
movq (%r14), %rdi
addq $0x70, %rdi
movq (%rbx), %rsi
addq $0x58, %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36826
addq $0x70, %r15
movq %r15, %rdi
movq 0x8(%rsp), %rsi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x36748
movq %rax, %rbx
movl $0x88, %esi
movq %r15, %rdi
callq 0x103d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::~object_t()
object_t::~object_t()
{
#ifdef DEBUG
	parser_t::object_count--;
#endif
	if (scope != NULL && type == OBJECT_STRONG)
	{
		scope->references--;
		if (scope->references == 0)
			delete scope;
	}
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x36407
cmpl $0x1, 0x8(%rdi)
jne 0x36407
decq 0x10(%rbx)
je 0x36409
popq %rbx
retq
movq %rbx, %rdi
callq 0x37b42
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x103d0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::operator=(object_t const&)
void object_t::operator=(const object_t &b)
{
	if (this->scope != NULL && type == OBJECT_STRONG)
	{
		this->scope->references--;
		if (this->scope->references == 0)
			delete scope;
	}

	this->scope = b.scope;
	this->type = b.type;

	if (this->scope != NULL && this->type == OBJECT_STRONG)
		this->scope->references++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
testq %r15, %r15
je 0x36454
cmpl $0x1, 0x8(%rbx)
jne 0x36454
decq 0x10(%r15)
jne 0x36454
movq %r15, %rdi
callq 0x37b42
movl $0x88, %esi
movq %r15, %rdi
callq 0x103d0
movq (%r14), %rax
movq %rax, (%rbx)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rbx)
testq %rax, %rax
setne %dl
cmpl $0x1, %ecx
sete %cl
andb %dl, %cl
cmpb $0x1, %cl
jne 0x36478
incq 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::instantiate(std::vector<symbol_t, std::allocator<symbol_t>> const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t object_t::instantiate(const std::vector<symbol_t> &params, const token_t *token, trace_t &stack_trace) const
{
	if (scope->type != scope_type_enum::SCOPE_STRUCT)
		throw rossa_error_t(_FAILURE_INSTANTIATE_OBJECT_, *token, stack_trace);

	object_t o(scope->parent, scope->name_trace, scope->extensions);
	scope->body->evaluate(&o, stack_trace);
	o.scope->getVariable(parser_t::HASH_INIT, token, stack_trace).call(params, token, stack_trace);
	return symbol_t::Object(o);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, %rbx
movq %rcx, %r14
movq (%rsi), %rcx
cmpl $0x1, (%rcx)
jne 0x36542
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movq 0x8(%rcx), %rsi
leaq 0x58(%rcx), %rdx
addq $0x70, %rcx
leaq 0x8(%rsp), %rbp
movq %rbp, %rdi
callq 0x3637a
movq (%r13), %rax
movq 0x48(%rax), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
movq %rbp, %rdx
movq %rbx, %rcx
callq *(%rax)
leaq 0x38(%rsp), %rdi
callq 0x39102
movq 0x8(%rsp), %rdi
leaq 0x80432(%rip), %rsi     # 0xb6920
movq %r14, %rdx
movq %rbx, %rcx
callq 0x37754
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x3aa8c
leaq 0x28(%rsp), %rdi
callq 0x39102
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x390aa
leaq 0x8(%rsp), %rdi
callq 0x363f2
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101f0
movq %rax, %r15
leaq 0x41079(%rip), %rsi     # 0x775cf
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1c814
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x7b71c(%rip), %rsi     # 0xb1ca0
leaq -0x7119(%rip), %rdx     # 0x2f472
movq %r15, %rdi
callq 0x106c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x365aa
jmp 0x365c1
movq %rax, %rbx
movq %r15, %rdi
callq 0x102e0
jmp 0x365c1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x363f2
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/object/object.cpp
// Function: object_t::getKey[abi:cxx11]() const
const std::string object_t::getKey() const
{
	size_t i = 0;
	std::string path = "";
	for (auto &p : scope->name_trace)
	{
		if (i++ > 0)
			path += ".";
		path += ROSSA_DEHASH(p);
	}
	return path;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x3fbaf(%rip), %rsi     # 0x761ae
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1c814
movq (%r15), %rax
movq 0x58(%rax), %rbp
movq 0x60(%rax), %r13
xorl %r15d, %r15d
movq %rsp, %r12
cmpq %r13, %rbp
je 0x3666a
subq $0x1, %r15
jb 0x36637
movq %rbx, %rdi
leaq 0x3fd64(%rip), %rsi     # 0x76396
callq 0x10760
movq (%rbp), %rax
movq %rax, (%rsp)
movq %r14, %rdi
leaq 0x802bf(%rip), %rsi     # 0xb6908
movq %r12, %rdx
callq 0x1f164
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10790
movq %r14, %rdi
callq 0x101d0
addq $0x8, %rbp
jmp 0x3661d
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3667e
movq %rax, %r14
jmp 0x36690
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x101d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/parameter/parameter.cpp
// Function: parameter_t::toString[abi:cxx11]() const
const std::string parameter_t::toString() const
{
	std::string s = global::getTypeString(base);
	if (!qualifiers.empty())
	{
		s += "<";
		size_t i = 0;
		for (auto &v : qualifiers)
		{
			if (i++ > 0)
				s += ", ";
			s += v.toString();
		}
		s += ">";
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
addq $0x18, %rsi
callq 0x4c366
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
je 0x36f9f
leaq 0x3f46d(%rip), %rsi     # 0x763a5
movq %rbx, %rdi
callq 0x10760
movq 0x30(%r15), %r14
movq 0x38(%r15), %r13
xorl %ebp, %ebp
leaq 0x8(%rsp), %r15
leaq 0x406c4(%rip), %r12     # 0x7761a
cmpq %r13, %r14
je 0x36f90
subq $0x1, %rbp
jb 0x36f6c
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
movq %r15, %rdi
movq %r14, %rsi
callq 0x36f0a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x10790
movq %r15, %rdi
callq 0x101d0
addq $0x48, %r14
jmp 0x36f56
leaq 0x3f3d7(%rip), %rsi     # 0x7636e
movq %rbx, %rdi
callq 0x10760
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x36fb7
jmp 0x36fb7
jmp 0x36fb7
movq %rax, %r14
jmp 0x36fc9
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x101d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/parameter/parameter.cpp
// Function: parameter_t::toCodeString[abi:cxx11]() const
const std::string parameter_t::toCodeString() const
{
	std::string s = "parameter_t(static_cast<type_sll>(" + global::getTypeString(base) + "), ";
	s += "{";
	size_t i = 0;
	for (auto &v : qualifiers)
	{
		if (i++ > 0)
			s += ", ";
		s += v.toCodeString();
	}
	s += "}";
	return s + ")";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x18, %rsi
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x4c366
leaq 0x40558(%rip), %rsi     # 0x775f6
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq 0x1cb73
leaq 0x40567(%rip), %rdx     # 0x77619
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1ca7d
movq %rbx, (%rsp)
leaq 0x28(%rsp), %rdi
callq 0x101d0
leaq 0x48(%rsp), %rdi
callq 0x101d0
leaq 0x3f975(%rip), %rsi     # 0x76a55
leaq 0x8(%rsp), %rdi
callq 0x10760
movq 0x30(%r14), %r15
movq 0x38(%r14), %rbp
xorl %ebx, %ebx
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %r12
leaq 0x40515(%rip), %r13     # 0x7761a
cmpq %rbp, %r15
je 0x3713f
subq $0x1, %rbx
jb 0x3711b
movq %r12, %rdi
movq %r13, %rsi
callq 0x10760
movq %r14, %rdi
movq %r15, %rsi
callq 0x37072
movq %r12, %rdi
movq %r14, %rsi
callq 0x10790
movq %r14, %rdi
callq 0x101d0
addq $0x48, %r15
jmp 0x37105
leaq 0x4377b(%rip), %rsi     # 0x7a8c1
leaq 0x8(%rsp), %rdi
callq 0x10760
movq (%rsp), %rbx
leaq 0x411d6(%rip), %rdx     # 0x78331
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1cb3b
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x371a3
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x101d0
jmp 0x37198
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x371ba
jmp 0x371a3
jmp 0x371a3
movq %rax, %rbx
jmp 0x371b5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x101d0
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/parameter/parameter.cpp
// Function: parameter_t::operator<(parameter_t const&) const
const bool parameter_t::operator<(const parameter_t &pt) const
{
	if (base != pt.base)
		return base < pt.base;
	if (qualifiers.size() != pt.qualifiers.size())
		return qualifiers.size() < pt.qualifiers.size();
	for (size_t i = 0; i < qualifiers.size(); i++)
	{
		if (qualifiers[i] < pt.qualifiers[i])
			return true;
	}
	if (ancestors.size() != pt.ancestors.size())
		return ancestors.size() < pt.ancestors.size();
	for (size_t i = 0; i < ancestors.size(); i++)
	{
		if (ancestors[i] < pt.ancestors[i])
			return true;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x18(%rdi), %r15
leaq 0x18(%rsi), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x37421
testb %al, %al
je 0x3722d
movq %r15, %rdi
movq %r12, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3742b
movq 0x38(%r14), %rax
subq 0x30(%r14), %rax
pushq $0x48
popq %r15
cqto
idivq %r15
movq %rax, %rcx
movq 0x38(%rbx), %rax
subq 0x30(%rbx), %rax
cqto
idivq %r15
cmpq %rax, %rcx
jne 0x372ee
pushq $-0x1
popq %r12
xorl %esi, %esi
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rax
subq %rdi, %rax
cqto
idivq %r15
incq %r12
cmpq %rax, %r12
jae 0x37291
leaq 0x48(%rsi), %r13
addq %rsi, %rdi
addq 0x30(%rbx), %rsi
callq 0x371ec
movq %r13, %rsi
testb %al, %al
je 0x3725d
movb $0x1, %bpl
jmp 0x372f2
movq 0x8(%r14), %rax
subq (%r14), %rax
pushq $0x18
popq %r15
cqto
idivq %r15
movq %rax, %rcx
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r15
cmpq %rax, %rcx
jne 0x372ee
pushq $-0x1
popq %r12
xorl %esi, %esi
movq (%r14), %rdi
movq 0x8(%r14), %rax
subq %rdi, %rax
cqto
idivq %r15
incq %r12
cmpq %rax, %r12
setb %bpl
jae 0x372f2
leaq 0x18(%rsi), %r13
addq %rsi, %rdi
addq (%rbx), %rsi
callq 0x3742b
movq %r13, %rsi
testb %al, %al
je 0x372bb
jmp 0x372f2
setb %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/scope/scope.cpp
// Function: scope_t::traceName(unsigned long long const&)
void scope_t::traceName(const hash_ull &key)
{
	if (parent != NULL)
	{
		name_trace = parent->name_trace;
	}
	if (key != 0)
	{
		name_trace.push_back(key);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
testq %rsi, %rsi
je 0x376a2
addq $0x58, %rsi
leaq 0x58(%rbx), %rdi
callq 0x3692e
movq (%r14), %rax
testq %rax, %rax
je 0x376bc
addq $0x58, %rbx
movq %rsp, %rsi
movq %rax, (%rsi)
movq %rbx, %rdi
callq 0x31648
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/scope/scope.cpp
// Function: scope_t::getVariable(unsigned long long const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t &scope_t::getVariable(const hash_ull &key, const token_t *token, trace_t &stack_trace) const
{
	const auto it = values.find(key);
	if (it != values.end())
	{
		return it->second;
	}
	if (parent != NULL)
	{
		return parent->getVariable(key, token, stack_trace);
	}

	throw rossa_error_t(util::format(_UNDECLARED_VARIABLE_ERROR_, {ROSSA_DEHASH(key)}), *token, stack_trace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x37c80
leaq 0x20(%rbx), %rcx
cmpq %rcx, %rax
jne 0x37821
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3776f
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
leaq 0x3fe78(%rip), %rsi     # 0x7761d
leaq 0x40(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1c814
leaq 0x7f14d(%rip), %rsi     # 0xb6908
leaq 0x20(%rsp), %rdi
movq %r12, %rdx
callq 0x1f164
leaq 0x8(%rsp), %rdi
leaq 0x20(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0x6(%rsp), %rcx
callq 0x1f298
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x3f724
movb $0x1, %bpl
leaq 0x60(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x7a48e(%rip), %rsi     # 0xb1ca0
leaq -0x83a7(%rip), %rdx     # 0x2f472
movq %rbx, %rdi
callq 0x106c0
addq $0x28, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x60(%rsp), %rdi
callq 0x101d0
jmp 0x3784a
movq %rax, %r14
movb $0x1, %bpl
leaq 0x8(%rsp), %rdi
callq 0x1cea0
jmp 0x3785c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x20(%rsp), %rdi
callq 0x101d0
jmp 0x3786e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x40(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x37882
jmp 0x3788a
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/scope/scope.cpp
// Function: scope_t::createVariable(unsigned long long const&, symbol_t const&, token_t const*)
const symbol_t &scope_t::createVariable(const hash_ull &key, const symbol_t &d, const token_t *token)
{
	const auto it = values.find(key);
	if (it != values.end() && it->second.getValueType() == value_type_enum::FUNCTION)
	{
		it->second.addFunctions(&d, token);
		return it->second;
	}
	return values.insert({key, d}).first->second;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r12
movq %rdx, %r14
movq %rsi, %r13
movq %rdi, %rbp
leaq 0x18(%rdi), %r15
movq %r15, %rdi
callq 0x36c9c
addq $0x20, %rbp
cmpq %rbp, %rax
je 0x37915
movq %rax, %rbx
leaq 0x28(%rax), %rbp
movq %rbp, %rdi
callq 0x39ca6
cmpl $-0x6, %eax
jne 0x37915
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3b00a
jmp 0x3793e
movq %rsp, %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r14, %rdx
callq 0x37c6e
movq %r15, %rdi
movq %rbx, %rsi
callq 0x37f8a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39102
addq $0x28, %rbx
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39102
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/scope/scope.cpp
// Function: scope_t::hash() const
const unsigned int scope_t::hash() const
{
	int h = 0;
	int i = 0;
	for (auto &e : values)
	{
		h = (h + ((e.first + e.second.hash()) << i++)) % 0xFFFFFFFF;
	}
	return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x30(%rdi), %r14
addq $0x20, %rbx
xorl %r15d, %r15d
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %r12d, %r12d
cmpq %rbx, %r14
je 0x379cb
movslq %r12d, %r12
movq 0x20(%r14), %rbp
leaq 0x28(%r14), %rdi
callq 0x39160
movl %eax, %eax
addq %rbp, %rax
leaq 0x1(%r15), %rbp
movl %r15d, %ecx
shlq %cl, %rax
addq %r12, %rax
xorl %edx, %edx
divq %r13
movq %rdx, %r12
movq %r14, %rdi
callq 0x104a0
movq %rax, %r14
movq %rbp, %r15
jmp 0x3798c
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/scope/scope.cpp
// Function: scope_t::getThis(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&)
const symbol_t scope_t::getThis(const token_t *token, trace_t &stack_trace)
{
	if (type != scope_type_enum::SCOPE_BOUNDED)
	{
		return symbol_t::Object(object_t(this, object_type_enum::OBJECT_STRONG));
	}
	if (parent != NULL)
	{
		return parent->getThis(token, stack_trace);
	}

	throw rossa_error_t(util::format(_UNDECLARED_VARIABLE_ERROR_, {KEYWORD_THIS}), *token, stack_trace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jne 0x37a98
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x379f4
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
leaq 0x3fc03(%rip), %rsi     # 0x7761d
leaq 0x48(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1c814
leaq 0x3e92f(%rip), %rsi     # 0x7635f
leaq 0x68(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0x1c814
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
pushq $0x1
popq %rdx
leaq 0xd(%rsp), %rcx
callq 0x1f298
leaq 0x10(%rsp), %rdi
leaq 0x48(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x3f724
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x7a217(%rip), %rsi     # 0xb1ca0
leaq -0x861e(%rip), %rdx     # 0x2f472
movq %rbx, %rdi
callq 0x106c0
leaq 0x48(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3618c
movq %rbx, %rdi
movq %r14, %rsi
callq 0x390aa
leaq 0x10(%rsp), %rdi
callq 0x363f2
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x363f2
jmp 0x37b3a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x37afa
movq %rax, %r14
movb $0x1, %bpl
leaq 0x30(%rsp), %rdi
callq 0x1cea0
jmp 0x37b0c
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rdi
callq 0x101d0
jmp 0x37b1e
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x37b32
jmp 0x37b3a
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/scope/scope.cpp
// Function: scope_t::~scope_t()
scope_t::~scope_t()
{
#ifdef DEBUG
	std::cout << "~scope_t\t" << std::to_string(type) << "\n";
#endif
	if (type == scope_type_enum::SCOPE_INSTANCE)
	{
		const auto it = values.find(parser_t::HASH_DELETER);
		if (it != values.end())
		{
#ifdef DEBUG
			std::cout << "Deleter Found\n";
#endif
			trace_t stack_trace;
			it->second.call({}, NULL, stack_trace);
#ifdef DEBUG
			std::cout << "Deleter Executed\n";
#endif
		}
	}
	for (auto &e : values)
	{
		e.second.shift();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
cmpl $0x3, (%rdi)
jne 0x37bb7
leaq 0x18(%rbx), %rdi
leaq 0x7edda(%rip), %rsi     # 0xb6938
callq 0x36c9c
leaq 0x20(%rbx), %rcx
cmpq %rcx, %rax
je 0x37bb7
leaq 0x30(%rsp), %r8
andq $0x0, 0x10(%r8)
xorps %xmm0, %xmm0
movaps %xmm0, (%r8)
addq $0x28, %rax
leaq 0x10(%rsp), %rdx
movaps %xmm0, (%rdx)
andq $0x0, 0x10(%rdx)
movq %rsp, %rdi
movq %rax, %rsi
xorl %ecx, %ecx
callq 0x3aa8c
movq %rsp, %rdi
callq 0x39102
leaq 0x10(%rsp), %rdi
callq 0x1f0b8
leaq 0x30(%rsp), %rdi
callq 0x1cb1a
movq 0x30(%rbx), %r14
leaq 0x20(%rbx), %r15
cmpq %r15, %r14
je 0x37bda
leaq 0x28(%r14), %rdi
callq 0x3b84c
movq %r14, %rdi
callq 0x102b0
movq %rax, %r14
jmp 0x37bbf
leaq 0x18(%rbx), %r14
leaq 0x70(%rbx), %rdi
callq 0x2e99e
leaq 0x58(%rbx), %rdi
callq 0x2fa2a
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x1d786
movq %r14, %rdi
callq 0x1df58
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x37c10
movq %rax, %rdi
callq 0x1ca72
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/signature/signature.cpp
// Function: signature_t::toCodeString[abi:cxx11]() const
const std::string signature_t::toCodeString() const
{
	std::string s = "{";
	size_t i = 0;
	for (auto &v : values)
	{
		if (i++ > 0)
		{
			s += ", ";
		}
		s += v.toCodeString();
	}
	return s + "}";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r13
movq %rdi, (%rsp)
leaq 0x3e537(%rip), %rsi     # 0x76a55
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq %r14, %rdi
movq %r15, %rdx
callq 0x1c814
movq (%r13), %r12
movq 0x8(%r13), %rbp
xorl %ebx, %ebx
leaq 0x3f0d6(%rip), %r13     # 0x7761a
cmpq %rbp, %r12
je 0x3857e
subq $0x1, %rbx
jb 0x3855a
movq %r14, %rdi
movq %r13, %rsi
callq 0x10760
movq %r15, %rdi
movq %r12, %rsi
callq 0x37072
movq %r14, %rdi
movq %r15, %rsi
callq 0x10790
movq %r15, %rdi
callq 0x101d0
addq $0x48, %r12
jmp 0x38544
leaq 0x4233c(%rip), %rdx     # 0x7a8c1
leaq 0x8(%rsp), %rsi
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x1cb3b
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x385b6
jmp 0x385b6
movq %rax, %rbx
jmp 0x385c8
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x101d0
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/signature/signature.cpp
// Function: signature_t::toString[abi:cxx11]() const
const std::string signature_t::toString() const
{
	std::string s = "";
	size_t i = 0;
	for (auto &v : values)
	{
		if (i++ > 0)
		{
			s += ", ";
		}
		s += v.toString();
	}
	return s;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x3dbb9(%rip), %rsi     # 0x761ae
leaq 0x8(%rsp), %r14
movq %r14, %rdx
callq 0x1c814
movq (%r12), %r15
movq 0x8(%r12), %r13
xorl %ebp, %ebp
leaq 0x3f006(%rip), %r12     # 0x7761a
cmpq %r13, %r15
je 0x3864e
subq $0x1, %rbp
jb 0x3862a
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
movq %r14, %rdi
movq %r15, %rsi
callq 0x36f0a
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10790
movq %r14, %rdi
callq 0x101d0
addq $0x48, %r15
jmp 0x38614
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x38662
movq %rax, %r14
jmp 0x38674
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x101d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::~symbol_t()
symbol_t::~symbol_t()
{
#ifdef DEBUG
	parser_t::symbol_count--;
#endif
	d->references--;
	if (d->references == 0)
		delete d;
}

// Assembly:
pushq %rbx
movq (%rdi), %rbx
decq 0x58(%rbx)
je 0x3910e
popq %rbx
retq
movq %rbx, %rdi
callq 0x3e712
pushq $0x60
popq %rsi
movq %rbx, %rdi
popq %rbx
jmp 0x103d0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::operator=(symbol_t const&)
void symbol_t::operator=(const symbol_t &b)
{
	this->d->references--;
	if (this->d->references == 0)
		delete d;

	this->d = b.d;
	this->type = b.type;
	this->d->references++;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
decq 0x58(%r15)
jne 0x39149
movq %r15, %rdi
callq 0x3e712
pushq $0x60
popq %rsi
movq %r15, %rdi
callq 0x103d0
movq (%r14), %rax
movq %rax, (%rbx)
movl 0x8(%r14), %ecx
movl %ecx, 0x8(%rbx)
incq 0x58(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::allocateAs(unsigned long const&, symbol_t const*, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&)
const symbol_t symbol_t::allocateAs(const size_t &size, const symbol_t *value, const token_t *token, trace_t &stack_trace)
{
	std::vector<symbol_t> v(size);
	for (auto e : v)
	{
		e.set(value, token, stack_trace);
	}
	return symbol_t(v);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rdx, %r12
movq %rdi, 0x8(%rsp)
movq (%rsi), %rsi
leaq 0x10(%rsp), %rbx
leaq 0x28(%rsp), %r13
movq %rbx, %rdi
movq %r13, %rdx
callq 0x3b8f4
movq (%rbx), %rbp
movq 0x8(%rbx), %rbx
cmpq %rbx, %rbp
je 0x39226
movq %r13, %rdi
movq %rbp, %rsi
callq 0x390f0
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3927a
movq %r13, %rdi
callq 0x39102
addq $0x10, %rbp
jmp 0x391f7
leaq 0x10(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x38ea6
leaq 0x10(%rsp), %rdi
callq 0x1f0b8
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x39256
movq %rax, %rbx
jmp 0x39268
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x39102
leaq 0x10(%rsp), %rdi
callq 0x1f0b8
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::indexVector(unsigned long const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t &symbol_t::indexVector(const size_t &i, const token_t *token, trace_t &stack_trace) const
{
	auto &v = std::get<std::vector<symbol_t>>(d->value);
	if (i >= v.size())
	{
		throw rossa_error_t(util::format(_INDEX_OUT_OF_BOUNDS_, {std::to_string(v.size()), std::to_string(i)}), *token, stack_trace);
	}
	return v.at(i);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq (%rdi), %rdi
addq $0x8, %rdi
callq 0x3bce8
movq %rax, %r13
movq (%r12), %rsi
movq 0x8(%rax), %rax
subq (%r13), %rax
sarq $0x4, %rax
cmpq %rax, %rsi
jae 0x398e1
movq %r13, %rdi
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3b946
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
leaq 0x3de2a(%rip), %rsi     # 0x7771f
leaq 0x28(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1c814
movq 0x8(%r13), %rsi
subq (%r13), %rsi
sarq $0x4, %rsi
leaq 0x68(%rsp), %rdi
callq 0x1f201
leaq 0x88(%rsp), %rdi
movq (%r12), %rsi
callq 0x1f201
leaq 0x10(%rsp), %rdi
leaq 0x68(%rsp), %rsi
pushq $0x2
popq %rdx
leaq 0xe(%rsp), %rcx
callq 0x1f298
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x10(%rsp), %rdx
callq 0x3f724
movb $0x1, %bpl
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x7832b(%rip), %rsi     # 0xb1ca0
leaq -0xa50a(%rip), %rdx     # 0x2f472
movq %rbx, %rdi
callq 0x106c0
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x101d0
jmp 0x39999
movq %rax, %r14
movb $0x1, %bpl
leaq 0x10(%rsp), %rdi
callq 0x1cea0
jmp 0x399ab
movq %rax, %r14
movb $0x1, %bpl
pushq $0x20
popq %r15
leaq (%rsp,%r15), %rdi
addq $0x68, %rdi
callq 0x101d0
addq $-0x20, %r15
cmpq $-0x20, %r15
jne 0x399af
jmp 0x399dd
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x101d0
jmp 0x399da
movq %rax, %r14
movb $0x1, %bpl
leaq 0x28(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x399f1
jmp 0x399f9
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::getFunctionOverloads(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const std::map<const size_t, std::map<const signature_t, ptr_function_t>> &symbol_t::getFunctionOverloads(const token_t *token, trace_t &stack_trace) const
{
	switch (d->type)
	{
	case value_type_enum::FUNCTION:
		return std::get<wrapper_t>(d->value).map;
	case value_type_enum::OBJECT:
		return std::get<object_t>(d->value).getVariable(parser_t::HASH_CALL, token, stack_trace).getFunctionOverloads(token, stack_trace);
	default:
		throw rossa_error_t(_NOT_FUNCTION_, *token, stack_trace);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
leaq 0x7cbc6(%rip), %rbx     # 0xb69e8
movq (%rax), %rdi
movl (%rdi), %eax
cmpl $-0x8, %eax
jne 0x39e48
addq $0x8, %rdi
callq 0x3bd3f
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x366ec
jmp 0x39e22
cmpl $-0x6, %eax
jne 0x39e60
addq $0x8, %rdi
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3bd79
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
leaq 0x3d966(%rip), %rsi     # 0x777da
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1c814
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x77dfe(%rip), %rsi     # 0xb1ca0
leaq -0xaa37(%rip), %rdx     # 0x2f472
movq %rbx, %rdi
callq 0x106c0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x39ec8
jmp 0x39ed0
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::hasVarg(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const bool symbol_t::hasVarg(const token_t *token, trace_t &stack_trace) const
{
	switch (d->type)
	{
	case value_type_enum::FUNCTION:
		return std::get<wrapper_t>(d->value).varg != nullptr;
	case value_type_enum::OBJECT:
		return std::get<object_t>(d->value).getVariable(parser_t::HASH_CALL, token, stack_trace).hasVarg(token, stack_trace);
	default:
		throw rossa_error_t(_NOT_FUNCTION_, *token, stack_trace);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
leaq 0x7caf6(%rip), %rbx     # 0xb69e8
movq (%rax), %rdi
movl (%rdi), %eax
cmpl $-0x8, %eax
jne 0x39f18
addq $0x8, %rdi
callq 0x3bd3f
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x366ec
jmp 0x39ef2
cmpl $-0x6, %eax
jne 0x39f39
addq $0x8, %rdi
callq 0x3bd79
cmpq $0x0, 0x30(%rax)
setne %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
leaq 0x3d88d(%rip), %rsi     # 0x777da
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1c814
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x77d25(%rip), %rsi     # 0xb1ca0
leaq -0xab10(%rip), %rdx     # 0x2f472
movq %rbx, %rdi
callq 0x106c0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x39fa1
jmp 0x39fa9
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::addFunctions(symbol_t const*, token_t const*) const
void symbol_t::addFunctions(const symbol_t *b, const token_t *token) const
{
	auto fs = std::get<wrapper_t>(b->d->value).map;
	for (auto &f : fs)
	{
		for (auto &t : f.second)
		{
			std::get<wrapper_t>(d->value).map[f.first][t.first] = t.second;
		}
	}
	if (std::get<wrapper_t>(b->d->value).varg != nullptr)
		std::get<wrapper_t>(d->value).varg = std::get<wrapper_t>(b->d->value).varg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movq %rsi, (%rsp)
movq (%rsi), %rdi
addq $0x8, %rdi
callq 0x3bd79
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x386ea
movq 0x18(%r15), %r15
leaq 0x10(%rsp), %rbp
cmpq %rbp, %r15
je 0x3b0a3
leaq 0x20(%r15), %r12
movq 0x40(%r15), %r13
leaq 0x30(%r15), %r14
cmpq %r14, %r13
je 0x3b096
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x3bd79
movq %rax, %rdi
movq %r12, %rsi
callq 0x3b9ce
leaq 0x20(%r13), %rsi
movq %rax, %rdi
callq 0x3ba1e
leaq 0x38(%r13), %rsi
movq %rax, %rdi
callq 0x3bd96
movq %r13, %rdi
callq 0x102b0
movq %rax, %r13
jmp 0x3b055
movq %r15, %rdi
callq 0x102b0
movq %rax, %r15
jmp 0x3b044
movq (%rsp), %r14
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x3bd79
cmpq $0x0, 0x30(%rax)
je 0x3b0e8
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x3bd79
movq %rax, %r14
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x3bd79
addq $0x30, %r14
addq $0x30, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x3bd96
leaq 0x8(%rsp), %rdi
callq 0x38c2e
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3b103
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x38c2e
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::getVARGFunction(token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const ptr_function_t &symbol_t::getVARGFunction(const token_t *token, trace_t &stack_trace) const
{
	if (d->type == value_type_enum::FUNCTION)
	{
		return std::get<wrapper_t>(d->value).varg;
	}
	if (d->type == value_type_enum::OBJECT)
	{
		return std::get<object_t>(d->value).getVariable(parser_t::HASH_CALL, token, stack_trace).getVARGFunction(token, stack_trace);
	}
	throw rossa_error_t(_NOT_FUNCTION_, *token, stack_trace);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
leaq 0x7b8b6(%rip), %rbx     # 0xb69e8
movq (%rax), %rdi
movl (%rdi), %eax
cmpl $-0x8, %eax
jne 0x3b158
addq $0x8, %rdi
callq 0x3bd3f
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x366ec
jmp 0x3b132
cmpl $-0x6, %eax
jne 0x3b175
addq $0x8, %rdi
callq 0x3bd79
addq $0x30, %rax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101f0
movq %rax, %rbx
leaq 0x3c651(%rip), %rsi     # 0x777da
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x1c814
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ebb8
xorl %ebp, %ebp
leaq 0x76ae9(%rip), %rsi     # 0xb1ca0
leaq -0xbd4c(%rip), %rdx     # 0x2f472
movq %rbx, %rdi
callq 0x106c0
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x101d0
testb %bpl, %bpl
jne 0x3b1dd
jmp 0x3b1e5
movq %rax, %r14
movq %rbx, %rdi
callq 0x102e0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::nequals(symbol_t const*, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const bool symbol_t::nequals(const symbol_t *b, const token_t *token, trace_t &stack_trace) const
{
	switch (d->type)
	{
	case value_type_enum::OBJECT:
	{
		auto &o = std::get<object_t>(d->value);
		if (o.hasValue(parser_t::HASH_NEQUALS))
		{
			return o.getVariable(parser_t::HASH_NEQUALS, token, stack_trace).call({*b}, token, stack_trace).getBool(token, stack_trace);
		}
	}
	default:
		return !this->equals(b, token, stack_trace);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rdi), %rdi
cmpl $-0x8, (%rdi)
jne 0x3b6a1
addq $0x8, %rdi
callq 0x3bd3f
movq %rax, %r13
leaq 0x7b3ce(%rip), %rsi     # 0xb69d8
movq %rax, %rdi
callq 0x366b2
testb %al, %al
je 0x3b6a1
leaq 0x7b3b7(%rip), %rsi     # 0xb69d8
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x366ec
movq %rax, %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x390f0
leaq 0x28(%rsp), %rdi
pushq $0x1
popq %rdx
leaq 0x7(%rsp), %rcx
movq %r13, %rsi
callq 0x3ba84
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x3aa8c
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x39b5c
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x39102
leaq 0x28(%rsp), %rdi
callq 0x1f0b8
leaq 0x18(%rsp), %rdi
callq 0x39102
jmp 0x3b6b7
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3b202
movl %eax, %ebx
xorb $0x1, %bl
movl %ebx, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x39102
jmp 0x3b6d9
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1f0b8
jmp 0x3b6e8
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x39102
movq %rbx, %rdi
callq 0x106f0