LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseEntryNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseEntryNode(std::vector<node_scope_t> *scopes)
{
	std::vector<ptr_node_t> v;
	while (currentToken.type != NULL_TOK)
		v.push_back(parseExprNode(scopes));
	return std::make_shared<VectorNode>(*scopes, v, false, currentToken);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq $0x0, 0x30(%rsp)
cmpl $0x0, 0xd0(%rsi)
je 0x25f42
leaq 0x10(%rsp), %r12
leaq 0x20(%rsp), %r13
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x25fda
movq %r13, %rdi
movq %r12, %rsi
callq 0x382ca
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25f38
callq 0x1e6ee
cmpl $0x0, 0xd0(%r15)
jne 0x25f10
addq $0x58, %r15
leaq 0xe(%rsp), %r9
movb $0x0, (%r9)
leaq 0x18(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %r15, (%rsp)
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x20(%rsp), %r8
movq %r14, %rcx
callq 0x38494
movq 0x10(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x18(%rsp), %rcx
movq %rax, 0x18(%rsp)
movq %rcx, 0x8(%rbx)
leaq 0x20(%rsp), %rdi
callq 0x37214
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x25fb0
movq %rax, %rbx
jmp 0x25fc7
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x25fc7
callq 0x1e6ee
leaq 0x20(%rsp), %rdi
callq 0x37214
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseTrailingNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*, std::shared_ptr<Node> const&, bool const&)
ptr_node_t node_parser_t::parseTrailingNode(std::vector<node_scope_t> *scopes, const ptr_node_t &ret, const bool &allowInner)
{
	if (currentToken.type == NULL_TOK)
		return ret;

	switch (currentToken.type)
	{
	case TOK_INNER:
		if (allowInner)
			return parseInsNode(scopes, ret);
		else
			return ret;
	case '(':
		return parseCallNode(scopes, ret);
	case '[':
		return parseIndexNode(scopes, ret);
	default:
		return ret;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0xd0(%rsi), %eax
cmpl $0x27, %eax
jg 0x2828e
cmpl $-0x27, %eax
je 0x282a2
testl %eax, %eax
jmp 0x282b2
cmpl $0x28, %eax
je 0x282d6
cmpl $0x5b, %eax
jne 0x282b2
movq %rbx, %rdi
callq 0x28dd8
jmp 0x282e4
cmpb $0x1, (%r8)
jne 0x282b2
movq %rbx, %rdi
callq 0x282ea
jmp 0x282e4
movq (%rcx), %rax
movq %rax, (%rbx)
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x282e4
movq 0x8ecc4(%rip), %rcx     # 0xb6f90
cmpb $0x0, (%rcx)
je 0x282e0
incl 0x8(%rax)
jmp 0x282e4
movq %rbx, %rdi
callq 0x2844e
jmp 0x282e4
lock
incl 0x8(%rax)
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseInsNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*, std::shared_ptr<Node> const&)
ptr_node_t node_parser_t::parseInsNode(std::vector<node_scope_t> *scopes, const ptr_node_t &ret)
{
	auto curr = ret;
	while (currentToken.type == TOK_INNER)
	{
		nextToken();
		curr = std::make_shared<InsNode>(*scopes, curr, parseBIDNode(scopes), currentToken);
	}

	return parseTrailingNode(scopes, curr, false);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, 0x30(%rsp)
movq (%rcx), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rcx), %rax
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x2832e
movq 0x8ec70(%rip), %rcx     # 0xb6f90
cmpb $0x0, (%rcx)
je 0x2832a
incl 0x8(%rax)
jmp 0x2832e
lock
incl 0x8(%rax)
cmpl $-0x27, 0xd0(%r15)
jne 0x283da
leaq 0x58(%r15), %rbp
leaq 0x38(%rsp), %r13
leaq 0xf(%rsp), %rbx
leaq 0x10(%rsp), %r12
movq %r15, %rdi
callq 0x2565a
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x25e3c
movq $0x0, 0x20(%rsp)
movq %rbp, (%rsp)
leaq 0x28(%rsp), %rdi
leaq 0x20(%rsp), %rsi
movq %rbx, %rdx
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x3b616
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x18(%rsp), %rdi
movups %xmm0, 0x10(%rsp)
testq %rdi, %rdi
je 0x283ae
callq 0x1e6ee
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x283bd
callq 0x1e6ee
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x283cc
callq 0x1e6ee
cmpl $-0x27, 0xd0(%r15)
je 0x2834f
leaq 0x20(%rsp), %r8
movb $0x0, (%r8)
leaq 0x10(%rsp), %rcx
movq 0x30(%rsp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x28276
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x28407
callq 0x1e6ee
movq 0x30(%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2841f
jmp 0x2841f
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x28431
callq 0x1e6ee
movq %rbx, %rdi
callq 0x106f0
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x28422
callq 0x1e6ee
jmp 0x28422
nop
// File: /workspace/github_cpp_makefile_star2_O1/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::parseEquNode(std::vector<node_scope_t, std::allocator<node_scope_t>>*)
ptr_node_t node_parser_t::parseEquNode(std::vector<node_scope_t> *scopes)
{
	if (currentToken.type == NULL_TOK)
		return logErrorN(_UNEXPECTED_TERMINATION_, currentToken);

	if (auto ret = parseUnitNode(scopes))
	{
		if (currentToken.type != NULL_TOK)
		{
			switch (currentToken.type)
			{
			case TOK_UNTILT:
				return parseUntilNode(scopes, ret, true);
			case TOK_UNTILF:
				return parseUntilNode(scopes, ret, false);
			case TOK_OPR:
				ret = parseBinOpNode(scopes, ret);
				break;
			default:
				break;
			}
			if (currentToken.type == '?')
				return parseThenNode(scopes, ret);
		}

		return ret;
	}

	return logErrorN(_FAILURE_PARSE_CODE_, currentToken);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rsi, %r14
leaq 0x58(%rsi), %rbx
cmpl $0x0, 0xd0(%rsi)
je 0x297f5
movq %rdx, %r12
movq %rdi, %r15
movq %rsp, %r13
movq %r13, %rdi
movq %r14, %rsi
callq 0x2c656
movq (%r13), %r13
testq %r13, %r13
je 0x297d0
movl 0xd0(%r14), %eax
cmpl $-0x5, %eax
jg 0x2972b
cmpl $-0x38, %eax
je 0x29736
cmpl $-0x37, %eax
jne 0x29794
leaq 0x20(%rsp), %r8
movb $0x1, (%r8)
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2e00e
jmp 0x297d0
cmpl $-0x4, %eax
je 0x29752
testl %eax, %eax
je 0x297b1
jmp 0x29794
leaq 0x20(%rsp), %r8
movb $0x0, (%r8)
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x2e00e
jmp 0x297d0
leaq 0x20(%rsp), %rdi
movq %rsp, %rcx
movq %r14, %rsi
movq %r12, %rdx
callq 0x2e236
movaps 0x20(%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, 0x20(%rsp)
movq 0x8(%rsp), %rdi
movups %xmm0, (%rsp)
testq %rdi, %rdi
je 0x29785
callq 0x1e6ee
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x29794
callq 0x1e6ee
cmpl $0x3f, 0xd0(%r14)
jne 0x297b1
movq %rsp, %rcx
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x32940
jmp 0x297d0
movq (%rsp), %rax
movq %rax, (%r15)
xorl %eax, %eax
movq %rax, 0x8(%r15)
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rsp)
movq %rcx, 0x8(%r15)
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x297df
callq 0x1e6ee
testq %r13, %r13
je 0x29822
movq %r15, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5b151(%rip), %rsi     # 0x84956
leaq 0x5b16c(%rip), %rdx     # 0x84978
movq %rsp, %rdi
callq 0x1e7ca
movq %rsp, %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x29894
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5b0c7(%rip), %rsi     # 0x848f9
leaq 0x5b0d5(%rip), %rdx     # 0x8490e
movq %rsp, %rdi
callq 0x1e7ca
movq %rsp, %rdx
movq %r14, %rsi
movq %rbx, %rcx
callq 0x29894
jmp 0x29855
jmp 0x29855
jmp 0x29855
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2988b
callq 0x1e6ee
jmp 0x2988b
jmp 0x2986d
jmp 0x29888
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x2988b
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x2988b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Nallantli[P]Rossa/main/rossa/node_parser/node_parser.cpp
// Function: node_parser_t::logErrorN(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, token_t const&)
ptr_node_t node_parser_t::logErrorN(const std::string &s, const token_t &t)
{
	trace_t stack_trace;
	if (t.type == NULL_TOK)
		throw rossa_error_t(s, tokens.at(index - 1), stack_trace);
	else
		throw rossa_error_t(s, t, stack_trace);
	return nullptr;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rcx, %r15
movq %rdx, %r14
movq %rsi, %r12
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movl 0x78(%rcx), %ebp
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
testl %ebp, %ebp
jne 0x29901
movl 0x50(%r12), %esi
decl %esi
movq 0x10(%r12), %rdx
movq 0x18(%r12), %rax
subq %rdx, %rax
sarq $0x7, %rax
cmpq %rsi, %rax
jbe 0x29928
shlq $0x7, %rsi
addq %rsi, %rdx
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x476dc
jmp 0x29912
movq %rsp, %rcx
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x476dc
leaq 0x893c7(%rip), %rsi     # 0xb2ce0
leaq 0xde94(%rip), %rdx      # 0x377b4
movq %rbx, %rdi
callq 0x106d0
leaq 0x5b19f(%rip), %rdi     # 0x84ace
movq %rax, %rdx
xorl %eax, %eax
callq 0x105d0
jmp 0x29940
movq %rax, %r14
jmp 0x2994b
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %rsp, %rdi
callq 0x1d77a
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2565a
leaq 0x58(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2c656
movq (%r12), %r12
movq %r12, %rdi
callq 0x59cd8
cmpl $0x1, %eax
jne 0x2c5b3
leaq 0x48(%rsp), %rdi
movq %r12, %rsi
callq 0x5d45c
leaq 0x18(%rsp), %rdi
movq %r12, %rsi
callq 0x5d48e
leaq 0x17(%rsp), %r9
movb $0x0, (%r9)
addq $0x58, %r14
leaq 0x40(%rsp), %rdi
movq $0x0, -0x8(%rdi)
movq %r14, (%rsp)
leaq 0x38(%rsp), %rsi
leaq 0x16(%rsp), %rdx
leaq 0x18(%rsp), %r8
movq %r15, %rcx
callq 0x39e32
leaq 0x18(%rsp), %r12
movq %r12, %rdi
callq 0x37214
movq $0x0, (%r12)
leaq 0x20(%rsp), %rdi
movq %r14, (%rsp)
leaq 0x18(%rsp), %rsi
leaq 0x16(%rsp), %rdx
leaq 0x48(%rsp), %r8
leaq 0x38(%rsp), %r9
movq %r15, %rcx
callq 0x39ec4
movq 0x18(%rsp), %rax
movq %rax, (%rbx)
xorl %eax, %eax
movq %rax, 0x8(%rbx)
movq 0x20(%rsp), %rcx
movq %rax, 0x20(%rsp)
movq %rcx, 0x8(%rbx)
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2c586
callq 0x1e6ee
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2c595
callq 0x1e6ee
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2c5a4
callq 0x1e6ee
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x5834c(%rip), %rsi     # 0x8490f
leaq 0x58360(%rip), %rdx     # 0x8492a
leaq 0x18(%rsp), %rdi
callq 0x1e7ca
leaq 0x58(%r14), %rcx
leaq 0x18(%rsp), %rdx
movq %r14, %rsi
callq 0x29894
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x2c63f
movq 0x28(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x2c63f
jmp 0x2c63c
movq %rax, %rbx
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2c629
callq 0x1e6ee
jmp 0x2c629
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x37214
jmp 0x2c629
movq %rax, %rbx
movq 0x50(%rsp), %rdi
testq %rdi, %rdi
je 0x2c63f
callq 0x1e6ee
jmp 0x2c63f
jmp 0x2c63c
movq %rax, %rbx
movq 0x60(%rsp), %rdi
testq %rdi, %rdi
je 0x2c64e
callq 0x1e6ee
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0xc8, %rsp
movq %rdx, 0x48(%rsp)
movq %rsi, %r14
movq %rdi, 0x40(%rsp)
movq %rsi, %rdi
callq 0x2565a
leaq 0xb0(%r14), %r12
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
movq $0x0, 0x10(%r13)
leaq 0x89aeb(%rip), %rbp     # 0xb78f8
leaq 0x80(%rsp), %r15
cmpl $-0x2, 0xd0(%r14)
jne 0x2deba
movq (%rbp), %rdi
movq 0x8(%rbp), %rsi
movq %r12, %rdx
callq 0x20e41
movq 0x8(%rbp), %rsi
cmpq %rsi, %rax
je 0x2de54
movq (%rbp), %rbx
movq %rbx, %rdi
movq %r12, %rdx
callq 0x20e41
subq %rbx, %rax
sarq $0x5, %rax
jmp 0x2de6e
movq %rbp, %rdi
movq %r12, %rsi
callq 0x20e04
movq 0x8(%rbp), %rax
subq (%rbp), %rax
sarq $0x5, %rax
decq %rax
movq %rax, 0x80(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x2de90
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x2de9b
movq %r13, %rdi
movq %r15, %rdx
callq 0x391c6
movq %r14, %rdi
callq 0x2565a
cmpl $-0x27, 0xd0(%r14)
jne 0x2deba
movq %r14, %rdi
callq 0x2565a
jmp 0x2de15
xorps %xmm0, %xmm0
leaq 0x60(%rsp), %rsi
movaps %xmm0, (%rsi)
movq $0x0, 0x10(%rsi)
leaq 0x80(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x3dc0c
leaq 0x50(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0x4044a
addq $0x58, %r14
leaq 0x38(%rsp), %rdi
movq $0x0, -0x8(%rdi)
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rdx
leaq 0x50(%rsp), %r8
movq 0x48(%rsp), %rcx
movq %r14, %r9
callq 0x37e92
movq 0x30(%rsp), %rax
movq 0x40(%rsp), %r14
movq %rax, (%r14)
xorl %eax, %eax
movq %rax, 0x8(%r14)
movq 0x38(%rsp), %rcx
movq %rax, 0x38(%rsp)
movq %rcx, 0x8(%r14)
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x404da
leaq 0xb0(%rsp), %rbx
movq %rbx, %rdi
callq 0x3743a
movq -0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2df77
movq 0xa8(%rsp), %rsi
subq %rdi, %rsi
callq 0x103d0
leaq 0x80(%rsp), %rdi
callq 0x3729c
leaq 0x60(%rsp), %rdi
callq 0x3729c
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2dfa5
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x103d0
movq %r14, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x404da
jmp 0x2dfcc
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x37330
jmp 0x2dfde
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x3729c
jmp 0x2dfef
jmp 0x2dfec
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2e006
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x103d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x2565a
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0xb0(%rbx), %rsi
movq 0xb8(%rbx), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x1e014
movq %rbx, %rdi
callq 0x2565a
leaq 0x58(%rbx), %r14
cmpl $0x3b, 0xd0(%rbx)
jne 0x361a9
movq %rbx, %rdi
callq 0x2565a
addq $0x28, %rbx
leaq 0x30(%rsp), %rdi
movq %rbx, %rsi
callq 0x10760
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %r14, %rdx
callq 0x56b3a
leaq 0x30(%rsp), %rdi
callq 0x1d736
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x36195
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r15, %rax
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0x88(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4e6a7(%rip), %rsi     # 0x84863
leaq 0x4e6ae(%rip), %rdx     # 0x84871
leaq 0x78(%rsp), %rdi
callq 0x1e7ca
leaq 0x68(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x4df15(%rip), %rsi     # 0x840f2
leaq 0x4df0f(%rip), %rdx     # 0x840f3
leaq 0x58(%rsp), %rdi
callq 0x1e7ca
leaq 0x98(%rsp), %rdi
leaq 0x58(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x20c5e
leaq 0x30(%rsp), %rdi
leaq 0x78(%rsp), %rsi
leaq 0x98(%rsp), %rdx
callq 0x48694
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
movq %r14, %rcx
callq 0x29894
movq %rax, %rbx
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x36254
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x36254
movq %rax, %rbx
leaq 0x98(%rsp), %rdi
callq 0x1dca2
jmp 0x36266
movq %rax, %rbx
movq 0x58(%rsp), %rdi
cmpq %r13, %rdi
je 0x36282
movq 0x68(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x36282
movq %rax, %rbx
movq 0x78(%rsp), %rdi
cmpq %r15, %rdi
je 0x362b4
movq 0x88(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x362b4
jmp 0x362b1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x1d736
jmp 0x362b4
jmp 0x362b1
movq %rax, %rbx
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x362cb
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq %rax, %rbx
leaq 0xc(%rsp), %rsi
movl $0x0, (%rsi)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rax, %rdi
xorl %edx, %edx
movq %r15, %r8
callq 0x3e62c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3cf54
callq 0x1e6ee
movq %rbx, (%r14)
movl $0x1, 0x8(%r14)
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3cf7b
callq 0x1e6ee
movl $0x88, %esi
movq %rbx, %rdi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x0, (%rsi)
movq (%r12), %rdx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %rcx
movaps %xmm0, (%rcx)
movq %rax, %rdi
movq %r15, %r8
callq 0x3e62c
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3cfe5
callq 0x1e6ee
movq %rbx, (%r14)
movl $0x1, 0x8(%r14)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x3d00e
callq 0x1e6ee
movl $0x88, %esi
movq %rbx, %rdi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e62c
movq %r15, (%r14)
movl $0x1, 0x8(%r14)
testq %rbx, %rbx
je 0x3d0b8
movq (%rbx), %rsi
addq $0x70, %rsi
addq $0x70, %r15
movq %r15, %rdi
callq 0x3d578
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 0x3d6f0
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 0x3d578
movq %rax, %rbx
movl $0x88, %esi
movq %r15, %rdi
callq 0x103d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d17d
cmpl $0x1, 0x8(%rdi)
jne 0x3d17d
decq 0x10(%rbx)
je 0x3d17f
popq %rbx
retq
movq %rbx, %rdi
callq 0x3ed0e
movl $0x88, %esi
movq %rbx, %rdi
popq %rbx
jmp 0x103d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d1ca
cmpl $0x1, 0x8(%rbx)
jne 0x3d1ca
decq 0x10(%r15)
jne 0x3d1ca
movq %r15, %rdi
callq 0x3ed0e
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 0x3d1ee
incq 0x10(%rax)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3d2b8
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 0x3d0f0
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 0x404da
movq 0x8(%rsp), %rdi
leaq 0x7a6ac(%rip), %rsi     # 0xb7910
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3e7e8
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x42736
leaq 0x28(%rsp), %rdi
callq 0x404da
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x40482
leaq 0x8(%rsp), %rdi
callq 0x3d168
movq %r15, %rax
addq $0x48, %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 0x482a9(%rip), %rsi     # 0x8557f
leaq 0x482c8(%rip), %rdx     # 0x855a5
leaq 0x8(%rsp), %rdi
callq 0x1e7ca
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x476dc
xorl %ebp, %ebp
leaq 0x759da(%rip), %rsi     # 0xb2ce0
leaq -0x5b59(%rip), %rdx     # 0x377b4
movq %r15, %rdi
callq 0x106d0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3d337
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3d337
movq %rax, %rbx
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3d353
movq %r15, %rdi
callq 0x102d0
jmp 0x3d353
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3d168
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x46dd2(%rip), %rdx     # 0x8416e
movq %rdx, %rsi
callq 0x1e7ca
movq (%r14), %rax
movq 0x58(%rax), %r13
movq 0x60(%rax), %r12
cmpq %r12, %r13
je 0x3d433
leaq 0x18(%rsp), %rbp
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
subq $0x1, %r15
jb 0x3d3d6
movq %rbx, %rdi
leaq 0x46f7f(%rip), %rsi     # 0x84350
callq 0x10770
movq (%r13), %rax
leaq 0x7a517(%rip), %rcx     # 0xb78f8
movq (%rcx), %rcx
shlq $0x5, %rax
movq %rbp, 0x8(%rsp)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x1e014
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10120
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3d42a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x8, %r13
cmpq %r12, %r13
jne 0x3d3c1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3d447
movq %rax, %r14
jmp 0x3d466
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3d466
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x3d47e
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x573a4
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
je 0x3dd7b
leaq 0x46667(%rip), %rsi     # 0x8435f
movq %rbx, %rdi
callq 0x10770
movq 0x30(%r15), %r14
movq 0x38(%r15), %rbp
cmpq %rbp, %r14
je 0x3dd6c
leaq 0x18(%rsp), %r13
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
subq $0x1, %r12
jb 0x3dd2f
movq %rbx, %rdi
leaq 0x478a0(%rip), %rsi     # 0x855ca
callq 0x10770
movq %r15, %rdi
movq %r14, %rsi
callq 0x3dcc6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10120
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3dd63
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r14
cmpq %rbp, %r14
jne 0x3dd1a
leaq 0x465b5(%rip), %rsi     # 0x84328
movq %rbx, %rdi
callq 0x10770
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3dd93
jmp 0x3dd93
jmp 0x3dd93
movq %rax, %r14
jmp 0x3ddb2
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3ddb2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3ddc9
movq (%rbx), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x573a4
leaq 0x476e6(%rip), %rsi     # 0x855a6
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x1d7be
leaq 0x476f5(%rip), %rsi     # 0x855c9
leaq 0x20(%rsp), %rdi
callq 0x10770
leaq 0x10(%rsp), %rsi
movq %rsi, -0x10(%rsi)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x3df04
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x3df0a
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x30(%rsp), %rbp
movq -0x10(%rbp), %rdi
cmpq %rbp, %rdi
je 0x3df3d
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %rbx, 0x40(%rsp)
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3df5d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x103d0
leaq 0x46ab0(%rip), %rsi     # 0x84a14
movq %rsp, %rdi
callq 0x10770
movq 0x30(%r14), %r15
movq 0x38(%r14), %rbx
cmpq %rbx, %r15
je 0x3dfd6
xorl %r13d, %r13d
leaq 0x20(%rsp), %r14
movq %rsp, %r12
subq $0x1, %r13
jb 0x3df99
movq %r12, %rdi
leaq 0x47636(%rip), %rsi     # 0x855ca
callq 0x10770
movq %r14, %rdi
movq %r15, %rsi
callq 0x3de94
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x10120
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3dfcd
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r15
cmpq %rbx, %r15
jne 0x3df84
leaq 0x4a8cc(%rip), %rsi     # 0x888a9
movq %rsp, %rdi
callq 0x10770
movq 0x40(%rsp), %r15
leaq 0x10(%r15), %rbx
movq %rbx, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1e014
leaq 0x482e5(%rip), %rsi     # 0x862f1
movq %r15, %rdi
callq 0x10770
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3e02f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x3e0ae
movq (%rbx), %rsi
jmp 0x3e0a6
jmp 0x3e08f
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e076
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e076
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e0c9
movq 0x58(%rsp), %rsi
jmp 0x3e0c1
jmp 0x3e08f
jmp 0x3e08f
movq %rax, %r14
jmp 0x3e0ae
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3e0ae
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3e0c9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/Nallantli[P]Rossa/main/rossa/parameter/parameter.cpp
// Function: parameter_t::operator&(parameter_t const&) const
const size_t parameter_t::operator&(const parameter_t &pt) const
{
	if (base[0] == value_type_enum::ANY)
		return 1;
	if (base != pt.base && std::find(pt.ancestors.begin(), pt.ancestors.end(), base) == pt.ancestors.end())
		return 0;
	if (qualifiers.empty() && pt.qualifiers.empty())
		return 3;
	if (qualifiers.empty() && !pt.qualifiers.empty())
		return 2;
	if (!qualifiers.empty() && qualifiers.size() != pt.qualifiers.size())
		return 0;
	size_t v = 3;
	for (size_t i = 0; i < qualifiers.size(); i++)
	{
		auto val = qualifiers[i] & pt.qualifiers[i];
		if (val == 0)
			return 0;
		if (val < v)
			v = val;
	}
	return v;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x18(%rdi), %rdi
movl $0x1, %r15d
cmpq $-0xb, (%rdi)
je 0x3e42d
movq %rsi, %rbx
movq 0x20(%r14), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq 0x18(%rsi), %rsi
movq 0x20(%rbx), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0x3e35f
cmpq %rdi, %rax
je 0x3e375
callq 0x10400
testl %eax, %eax
je 0x3e375
leaq 0x18(%r14), %rdx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3e4e7
cmpq 0x8(%rbx), %rax
je 0x3e3f1
movq 0x30(%r14), %rcx
movq 0x38(%r14), %rax
cmpq %rax, %rcx
je 0x3e3f6
subq %rcx, %rax
movq 0x38(%rbx), %rcx
subq 0x30(%rbx), %rcx
cmpq %rcx, %rax
jne 0x3e3f1
movq 0x30(%r14), %rdi
cmpq %rdi, 0x38(%r14)
je 0x3e427
movl $0x3, %r15d
movabsq $-0x71c71c71c71c71c7, %r12 # imm = 0x8E38E38E38E38E39
xorl %r13d, %r13d
xorl %ebp, %ebp
addq %r13, %rdi
movq 0x30(%rbx), %rsi
addq %r13, %rsi
callq 0x3e312
testq %rax, %rax
je 0x3e3f1
cmpq %r15, %rax
cmovbq %rax, %r15
incq %rbp
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rax
subq %rdi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x48, %r13
cmpq %rax, %rbp
jb 0x3e3b5
jmp 0x3e42d
xorl %r15d, %r15d
jmp 0x3e42d
movq 0x30(%rbx), %rdx
cmpq 0x38(%rbx), %rdx
je 0x3e427
cmpq %rax, %rcx
jne 0x3e382
movq 0x30(%rbx), %rdx
movl $0x2, %r15d
cmpq 0x38(%rbx), %rdx
jne 0x3e42d
cmpq %rax, %rcx
jne 0x3e382
jmp 0x3e392
movl $0x3, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3e70e
addq $0x58, %rsi
leaq 0x58(%rbx), %rdi
callq 0x3d79c
movq (%r14), %rax
testq %rax, %rax
je 0x3e740
movq %rax, (%rsp)
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0x3e731
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x60(%rbx)
jmp 0x3e740
addq $0x58, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x391c6
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq 0x28(%rdi), %rax
leaq 0x20(%rdi), %rcx
movq %rcx, %rdx
testq %rax, %rax
je 0x3e832
movq (%r12), %rsi
movq %rcx, %rdx
xorl %r8d, %r8d
cmpq %rsi, 0x20(%rax)
setb %r8b
cmovaeq %rax, %rdx
movq 0x10(%rax,%r8,8), %rax
testq %rax, %rax
jne 0x3e819
movq %rcx, %rax
cmpq %rcx, %rdx
je 0x3e849
movq (%r12), %rax
cmpq 0x20(%rdx), %rax
cmovbq %rcx, %rdx
movq %rdx, %rax
cmpq %rcx, %rax
jne 0x3e916
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x3e802
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x40(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x46d55(%rip), %rsi     # 0x855cd
leaq 0x46d79(%rip), %rdx     # 0x855f8
leaq 0x30(%rsp), %rdi
callq 0x1e7ca
movq (%r12), %rax
leaq 0x79064(%rip), %rcx     # 0xb78f8
movq (%rcx), %rcx
shlq $0x5, %rax
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x1e014
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x20c5e
leaq 0x68(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x48694
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x476dc
xorl %ebp, %ebp
leaq 0x743d9(%rip), %rsi     # 0xb2ce0
leaq -0x715a(%rip), %rdx     # 0x377b4
movq %rbx, %rdi
callq 0x106d0
addq $0x28, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e952
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e952
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0x1dca2
jmp 0x3e964
movq %rax, %r14
movb $0x1, %bpl
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3e983
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e983
movq %rax, %r14
movb $0x1, %bpl
movq 0x30(%rsp), %rdi
cmpq %r13, %rdi
je 0x3e9a2
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e9a2
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3e9af
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
movq 0x28(%rdi), %rdx
leaq 0x20(%rdi), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x3ea31
movq (%r12), %rsi
movq %rax, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x3ea19
movq %rax, %r13
cmpq %rax, %rcx
je 0x3ea48
movq (%r12), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %rax, %rcx
movq %rcx, %r13
cmpq %rax, %r13
je 0x3ea6e
leaq 0x28(%r13), %rbp
movq %rbp, %rdi
callq 0x41262
cmpl $-0x6, %eax
jne 0x3ea6e
movq %rbp, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x4317a
jmp 0x3eaa0
addq $0x18, %rbx
movq (%r12), %rax
leaq 0x8(%rsp), %r15
movq %rax, -0x8(%r15)
movq %r15, %rdi
movq %r14, %rsi
callq 0x404c8
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3f126
movq %rax, %r13
movq %r15, %rdi
callq 0x404da
addq $0x28, %r13
movq %r13, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x404da
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
cmpq %rbx, %r14
je 0x3eb42
xorl %r12d, %r12d
movabsq $-0x7fffffff7fffffff, %r13 # imm = 0x8000000080000001
xorl %r15d, %r15d
movslq %r15d, %r15
movq 0x20(%r14), %rbp
leaq 0x28(%r14), %rdi
callq 0x40554
movl %eax, %esi
addq %rbp, %rsi
movl %r12d, %ecx
shlq %cl, %rsi
incq %r12
addq %r15, %rsi
movq %rsi, %rax
mulq %r13
movq %rdx, %r15
shrq $0x1f, %r15
movq %r15, %rax
shlq $0x20, %rax
subq %rax, %r15
addq %rsi, %r15
movq %r14, %rdi
callq 0x104b0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x3eaf5
jmp 0x3eb45
xorl %r15d, %r15d
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %rbx
cmpl $0x0, (%rsi)
jne 0x3ec2f
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x3eb72
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x46a2b(%rip), %rsi     # 0x855cd
leaq 0x46a4f(%rip), %rdx     # 0x855f8
leaq 0x30(%rsp), %rdi
callq 0x1e7ca
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x46a36(%rip), %rsi     # 0x855f9
leaq 0x46a33(%rip), %rdx     # 0x855fd
leaq 0x50(%rsp), %rdi
callq 0x1e7ca
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x20c5e
leaq 0x10(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x48694
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x476dc
xorl %ebp, %ebp
leaq 0x740c0(%rip), %rsi     # 0xb2ce0
leaq -0x7473(%rip), %rdx     # 0x377b4
movq %rbx, %rdi
callq 0x106d0
leaq 0x30(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x10(%rsp), %r14
movq %r14, %rdi
callq 0x3cee4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x40482
leaq 0x10(%rsp), %rdi
callq 0x3d168
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x3d168
jmp 0x3ed06
movq %rax, %r14
leaq 0x20(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3eca9
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3eca9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x1dca2
jmp 0x3ecbb
movq %rax, %r14
movb $0x1, %bpl
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x3ecda
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3ecda
movq %rax, %r14
movb $0x1, %bpl
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x3ecf9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3ecf9
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3ed06
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3edc2
movq 0x28(%rbx), %rdx
leaq 0x20(%rbx), %rax
movq %rax, %rcx
testq %rdx, %rdx
je 0x3ed58
leaq 0x78bee(%rip), %rcx     # 0xb7928
movq (%rcx), %rsi
movq %rax, %rcx
xorl %edi, %edi
cmpq %rsi, 0x20(%rdx)
setb %dil
cmovaeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0x3ed40
movq %rax, %rsi
cmpq %rax, %rcx
je 0x3ed75
leaq 0x78bc1(%rip), %rdx     # 0xb7928
movq (%rdx), %rdx
cmpq 0x20(%rcx), %rdx
cmovbq %rax, %rcx
movq %rcx, %rsi
cmpq %rax, %rsi
je 0x3edc2
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r8
movaps %xmm0, (%r8)
xorl %eax, %eax
movq %rax, 0x10(%r8)
addq $0x28, %rsi
leaq 0x10(%rsp), %rdx
movq %rax, 0x10(%rdx)
movaps %xmm0, (%rdx)
movq %rsp, %rdi
xorl %ecx, %ecx
callq 0x42736
movq %rsp, %rdi
callq 0x404da
leaq 0x10(%rsp), %rdi
callq 0x20a84
leaq 0x30(%rsp), %rdi
callq 0x1d77a
movq 0x30(%rbx), %r14
leaq 0x20(%rbx), %r15
cmpq %r15, %r14
je 0x3ede8
leaq 0x28(%r14), %rdi
callq 0x43af8
movq %r14, %rdi
callq 0x102a0
movq %rax, %r14
cmpq %r15, %rax
jne 0x3edcf
leaq 0x70(%rbx), %rdi
callq 0x3729c
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x3ee06
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x103d0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3ee14
callq 0x1e6ee
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1ed86
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3ee2c
movq %rax, %rdi
callq 0x1d76e
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, 0x20(%rsp)
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
leaq 0x451b6(%rip), %rsi     # 0x84a14
leaq 0x451b0(%rip), %rdx     # 0x84a15
movq %rsp, %rdi
callq 0x1e7ca
movq (%r15), %r14
movq 0x8(%r15), %rbx
cmpq %rbx, %r14
je 0x3f8db
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
movq %rsp, %r12
subq $0x1, %r13
jb 0x3f89e
movq %r12, %rdi
leaq 0x45d31(%rip), %rsi     # 0x855ca
callq 0x10770
movq %r15, %rdi
movq %r14, %rsi
callq 0x3de94
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x10120
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f8d2
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r14
cmpq %rbx, %r14
jne 0x3f889
movq 0x20(%rsp), %r15
leaq 0x10(%r15), %rbx
movq %rbx, (%r15)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x1e014
leaq 0x48fa7(%rip), %rsi     # 0x888a9
movq %r15, %rdi
callq 0x10770
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3f925
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %rbx, %rdi
je 0x3f96a
movq (%rbx), %rsi
jmp 0x3f962
jmp 0x3f94b
jmp 0x3f94b
movq %rax, %r14
jmp 0x3f96a
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f96a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3f985
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
leaq 0x447ba(%rip), %rdx     # 0x8416e
movq %rdx, %rsi
callq 0x1e7ca
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0x3fa27
leaq 0x18(%rsp), %rbp
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
subq $0x1, %r12
jb 0x3f9ea
movq %rbx, %rdi
leaq 0x45be5(%rip), %rsi     # 0x855ca
callq 0x10770
movq %r15, %rdi
movq %r14, %rsi
callq 0x3dcc6
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10120
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3fa1e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r14
cmpq %r13, %r14
jne 0x3f9d5
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3fa3b
movq %rax, %r14
jmp 0x3fa5a
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3fa5a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x3fa72
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0