LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3cc90
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 0x3cac8
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 0x3fe06
movq 0x8(%rsp), %rdi
leaq 0x78cd4(%rip), %rsi     # 0xb5910
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3e150
leaq 0x28(%rsp), %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x41ffe
leaq 0x28(%rsp), %rdi
callq 0x3fe06
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
callq 0x3fdae
leaq 0x8(%rsp), %rdi
callq 0x3cb40
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 0x478f1(%rip), %rsi     # 0x8459f
leaq 0x47910(%rip), %rdx     # 0x845c5
leaq 0x8(%rsp), %rdi
callq 0x1e698
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x74042(%rip), %rsi     # 0xb0d20
leaq -0x5a41(%rip), %rdx     # 0x372a4
movq %r15, %rdi
callq 0x106d0
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x3cd07
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x3cd11
jmp 0x3cd28
movq %rax, %rbx
movq %r15, %rdi
callq 0x102d0
jmp 0x3cd28
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x463fe(%rip), %rdx     # 0x8316e
movq %rdx, %rsi
callq 0x1e698
movq (%r14), %rax
movq 0x58(%rax), %r13
movq 0x60(%rax), %r12
cmpq %r12, %r13
je 0x3ce07
leaq 0x18(%rsp), %rbp
xorl %r15d, %r15d
leaq 0x8(%rsp), %r14
subq $0x1, %r15
jb 0x3cdaa
movq %rbx, %rdi
leaq 0x465ab(%rip), %rsi     # 0x83350
callq 0x10770
movq (%r13), %rax
leaq 0x78b43(%rip), %rcx     # 0xb58f8
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 0x1ded4
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10120
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3cdfe
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x8, %r13
cmpq %r12, %r13
jne 0x3cd95
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ce1b
movq %rax, %r14
jmp 0x3ce3a
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3ce3a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x3ce52
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x56b41
movq 0x30(%r15), %rax
cmpq 0x38(%r15), %rax
je 0x3d76f
leaq 0x45c73(%rip), %rsi     # 0x8335f
movq %rbx, %rdi
callq 0x10770
movq 0x30(%r15), %r14
movq 0x38(%r15), %rbp
cmpq %rbp, %r14
je 0x3d760
leaq 0x18(%rsp), %r13
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
subq $0x1, %r12
jb 0x3d723
movq %rbx, %rdi
leaq 0x46ecc(%rip), %rsi     # 0x845ea
callq 0x10770
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d6ba
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10120
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3d757
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r14
cmpq %rbp, %r14
jne 0x3d70e
leaq 0x45bc1(%rip), %rsi     # 0x83328
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 0x3d787
jmp 0x3d787
jmp 0x3d787
movq %rax, %r14
jmp 0x3d7a6
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x3d7a6
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rbx), %rdi
addq $0x10, %rbx
cmpq %rbx, %rdi
je 0x3d7bd
movq (%rbx), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x56b41
leaq 0x46d12(%rip), %rsi     # 0x845c6
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq 0x1d67c
leaq 0x46d21(%rip), %rsi     # 0x845e9
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 0x3d8f8
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x3d8fe
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 0x3d931
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %rbx, 0x40(%rsp)
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3d951
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x103d0
leaq 0x460dc(%rip), %rsi     # 0x83a34
movq %rsp, %rdi
callq 0x10770
movq 0x30(%r14), %r15
movq 0x38(%r14), %rbx
cmpq %rbx, %r15
je 0x3d9ca
xorl %r13d, %r13d
leaq 0x20(%rsp), %r14
movq %rsp, %r12
subq $0x1, %r13
jb 0x3d98d
movq %r12, %rdi
leaq 0x46c62(%rip), %rsi     # 0x845ea
callq 0x10770
movq %r14, %rdi
movq %r15, %rsi
callq 0x3d888
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq %r12, %rdi
callq 0x10120
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3d9c1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r15
cmpq %rbx, %r15
jne 0x3d978
leaq 0x49ef8(%rip), %rsi     # 0x878c9
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 0x1ded4
leaq 0x47911(%rip), %rsi     # 0x85311
movq %r15, %rdi
callq 0x10770
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3da23
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 0x3daa2
movq (%rbx), %rsi
jmp 0x3da9a
jmp 0x3da83
movq %rax, %r14
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3da6a
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3da6a
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3dabd
movq 0x58(%rsp), %rsi
jmp 0x3dab5
jmp 0x3da83
jmp 0x3da83
movq %rax, %r14
jmp 0x3daa2
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3daa2
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3dabd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3dd9f
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 0x3dd03
cmpq %rdi, %rax
je 0x3dd19
callq 0x10400
testl %eax, %eax
je 0x3dd19
leaq 0x18(%r14), %rdx
movq (%rbx), %rdi
movq 0x8(%rbx), %rsi
callq 0x3de3f
cmpq 0x8(%rbx), %rax
je 0x3dd87
movq 0x30(%r14), %rdi
movq 0x38(%r14), %rax
cmpq %rax, %rdi
je 0x3dd8c
subq %rdi, %rax
movq 0x38(%rbx), %rcx
subq 0x30(%rbx), %rcx
cmpq %rcx, %rax
jne 0x3dd87
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 0x3dcb6
testq %rax, %rax
je 0x3dd87
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 0x3dd4b
jmp 0x3dd9f
xorl %r15d, %r15d
jmp 0x3dd9f
movq 0x30(%rbx), %rax
xorl %r15d, %r15d
cmpq 0x38(%rbx), %rax
sete %r15b
orq $0x2, %r15
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_O3/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 0x3e076
addq $0x58, %rsi
leaq 0x58(%rbx), %rdi
callq 0x3d192
movq (%r14), %rax
testq %rax, %rax
je 0x3e0a8
movq %rax, (%rsp)
movq 0x60(%rbx), %rsi
cmpq 0x68(%rbx), %rsi
je 0x3e099
movq %rax, (%rsi)
addq $0x8, %rsi
movq %rsi, 0x60(%rbx)
jmp 0x3e0a8
addq $0x58, %rbx
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x38c52
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 (%rsi), %rcx
movq 0x28(%rdi), %rdx
testq %rdx, %rdx
je 0x3e1a5
leaq 0x20(%rdi), %rsi
movq %rsi, %rax
xorl %r8d, %r8d
cmpq %rcx, 0x20(%rdx)
setb %r8b
cmovaeq %rdx, %rax
movq 0x10(%rdx,%r8,8), %rdx
testq %rdx, %rdx
jne 0x3e17d
cmpq %rsi, %rax
je 0x3e1a5
cmpq 0x20(%rax), %rcx
jae 0x3e269
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x3e16d
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x20(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x46422(%rip), %rsi     # 0x845ed
leaq 0x46446(%rip), %rdx     # 0x84618
leaq 0x10(%rsp), %rdi
callq 0x1e698
movq (%r12), %rax
leaq 0x77711(%rip), %rcx     # 0xb58f8
movq (%rcx), %rcx
shlq $0x5, %rax
leaq 0x40(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rdi
callq 0x1ded4
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x20b38
leaq 0x68(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x50(%rsp), %rdx
callq 0x47db4
movb $0x1, %bpl
leaq 0x68(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x72ac6(%rip), %rsi     # 0xb0d20
leaq -0x6fbd(%rip), %rdx     # 0x372a4
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 0x3e2a5
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e2a5
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rdi
callq 0x1db60
jmp 0x3e2b7
movq %rax, %r14
movb $0x1, %bpl
movq 0x30(%rsp), %rdi
cmpq %r12, %rdi
je 0x3e2ce
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x103d0
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x3e2e5
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x3e30b
jmp 0x3e313
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r13, %rdi
je 0x3e30b
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e30b
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rdi, %rbx
movq 0x28(%rdi), %rcx
movq (%rsi), %rax
testq %rcx, %rcx
je 0x3e3c1
movq %rsi, %r13
leaq 0x20(%rbx), %rdx
movq %rdx, %r15
xorl %esi, %esi
cmpq %rax, 0x20(%rcx)
setb %sil
cmovaeq %rcx, %r15
movq 0x10(%rcx,%rsi,8), %rcx
testq %rcx, %rcx
jne 0x3e379
cmpq %rdx, %r15
je 0x3e3c1
cmpq 0x20(%r15), %rax
jb 0x3e3c1
leaq 0x28(%r15), %rbp
movq %rbp, %rdi
callq 0x40b5a
cmpl $-0x6, %eax
jne 0x3e3bd
movq %rbp, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x42a42
jmp 0x3e3f0
movq (%r13), %rax
addq $0x18, %rbx
leaq 0x8(%rsp), %r12
movq %rax, -0x8(%r12)
movq %r12, %rdi
movq %r14, %rsi
callq 0x3fdf4
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x3ea6e
movq %rax, %r15
movq %r12, %rdi
callq 0x3fe06
addq $0x28, %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r12, %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e492
xorl %r12d, %r12d
movabsq $-0x7fffffff7fffffff, %r13 # imm = 0x8000000080000001
xorl %r15d, %r15d
movslq %r15d, %r15
movq 0x20(%r14), %rbp
leaq 0x28(%r14), %rdi
callq 0x3fe68
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 0x3e445
jmp 0x3e495
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_O3/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 0x3e57f
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0x3e4c2
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x20(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x460fb(%rip), %rsi     # 0x845ed
leaq 0x4611f(%rip), %rdx     # 0x84618
leaq 0x10(%rsp), %rdi
callq 0x1e698
leaq 0x60(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x46106(%rip), %rsi     # 0x84619
leaq 0x46103(%rip), %rdx     # 0x8461d
leaq 0x50(%rsp), %rdi
callq 0x1e698
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x1, %edx
callq 0x20b38
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x47db4
movb $0x1, %bpl
leaq 0x30(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x727b0(%rip), %rsi     # 0xb0d20
leaq -0x72d3(%rip), %rdx     # 0x372a4
movq %rbx, %rdi
callq 0x106d0
leaq 0x10(%rsp), %rdx
movl $0x1, (%rdx)
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x3c8bc
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3fdae
leaq 0x30(%rsp), %rdi
callq 0x3cb40
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x3cb40
jmp 0x3e667
movq %rax, %r14
leaq 0x40(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3e5f9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e5f9
movq %rax, %r14
movb $0x1, %bpl
leaq 0x70(%rsp), %rdi
callq 0x1db60
jmp 0x3e60b
movq %rax, %r14
movb $0x1, %bpl
movq 0x50(%rsp), %rdi
cmpq %r13, %rdi
je 0x3e622
movq 0x60(%rsp), %rsi
incq %rsi
callq 0x103d0
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3e639
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x3e65f
jmp 0x3e667
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %r12, %rdi
je 0x3e65f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x3e65f
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3e70a
movq 0x28(%rbx), %rax
testq %rax, %rax
je 0x3e70a
leaq 0x20(%rbx), %rdx
leaq 0x7728f(%rip), %rcx     # 0xb5928
movq (%rcx), %rcx
movq %rdx, %rsi
xorl %edi, %edi
cmpq %rcx, 0x20(%rax)
setb %dil
cmovaeq %rax, %rsi
movq 0x10(%rax,%rdi,8), %rax
testq %rax, %rax
jne 0x3e69f
cmpq %rdx, %rsi
je 0x3e70a
cmpq 0x20(%rsi), %rcx
jb 0x3e70a
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 0x41ffe
movq %rsp, %rdi
callq 0x3fe06
leaq 0x10(%rsp), %rdi
callq 0x20952
leaq 0x30(%rsp), %rdi
callq 0x1d632
movq 0x30(%rbx), %r14
leaq 0x20(%rbx), %r15
cmpq %r15, %r14
je 0x3e730
leaq 0x28(%r14), %rdi
callq 0x43366
movq %r14, %rdi
callq 0x102a0
movq %rax, %r14
cmpq %r15, %rax
jne 0x3e717
leaq 0x70(%rbx), %rdi
callq 0x36d84
movq 0x58(%rbx), %rdi
testq %rdi, %rdi
je 0x3e74e
movq 0x68(%rbx), %rsi
subq %rdi, %rsi
callq 0x103d0
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x3e75c
callq 0x1e5bc
addq $0x18, %rbx
movq %rbx, %rdi
callq 0x1ec5a
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x3e774
movq %rax, %rdi
callq 0x1d626
// File: /workspace/github_cpp_makefile_star2_O3/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 0x44894(%rip), %rsi     # 0x83a34
leaq 0x4488e(%rip), %rdx     # 0x83a35
movq %rsp, %rdi
callq 0x1e698
movq (%r15), %r14
movq 0x8(%r15), %rbx
cmpq %rbx, %r14
je 0x3f21d
leaq 0x38(%rsp), %rbp
xorl %r13d, %r13d
leaq 0x28(%rsp), %r15
movq %rsp, %r12
subq $0x1, %r13
jb 0x3f1e0
movq %r12, %rdi
leaq 0x4540f(%rip), %rsi     # 0x845ea
callq 0x10770
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d888
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq %r12, %rdi
callq 0x10120
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f214
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r14
cmpq %rbx, %r14
jne 0x3f1cb
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 0x1ded4
leaq 0x48685(%rip), %rsi     # 0x878c9
movq %r15, %rdi
callq 0x10770
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3f267
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 0x3f2ac
movq (%rbx), %rsi
jmp 0x3f2a4
jmp 0x3f28d
jmp 0x3f28d
movq %rax, %r14
jmp 0x3f2ac
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f2ac
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x3f2c7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43e78(%rip), %rdx     # 0x8316e
movq %rdx, %rsi
callq 0x1e698
movq (%r15), %r14
movq 0x8(%r15), %r13
cmpq %r13, %r14
je 0x3f369
leaq 0x18(%rsp), %rbp
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
subq $0x1, %r12
jb 0x3f32c
movq %rbx, %rdi
leaq 0x452c3(%rip), %rsi     # 0x845ea
callq 0x10770
movq %r15, %rdi
movq %r14, %rsi
callq 0x3d6ba
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x10120
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f360
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
addq $0x48, %r14
cmpq %r13, %r14
jne 0x3f317
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f37d
movq %rax, %r14
jmp 0x3f39c
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x3f39c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x103d0
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x3f3b4
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x103d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3fe51
movq %r15, %rdi
callq 0x466c6
movl $0x60, %esi
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_O3/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 0x20(%rsp), %rbp
leaq 0x10(%rsp), %rdx
movq %rbp, %rdi
callq 0x43418
movq (%rbp), %r13
movq 0x8(%rbp), %rbx
cmpq %rbx, %r13
je 0x3ff34
leaq 0x10(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3fdf4
movq %rbp, %rdi
movq %r12, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ff88
movq %rbp, %rdi
callq 0x3fe06
addq $0x10, %r13
cmpq %rbx, %r13
jne 0x3ff07
leaq 0x20(%rsp), %rsi
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x3fb90
leaq 0x20(%rsp), %rdi
callq 0x20952
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3ff64
movq %rax, %rbx
jmp 0x3ff76
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3fe06
leaq 0x20(%rsp), %rdi
callq 0x20952
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x439e7
movq %rax, %r13
movq (%r12), %rcx
movq (%rax), %rax
movq 0x8(%r13), %rdx
subq %rax, %rdx
sarq $0x4, %rdx
cmpq %rdx, %rcx
jae 0x406d1
shlq $0x4, %rcx
addq %rcx, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
leaq 0x44005(%rip), %rsi     # 0x846f3
leaq 0x44024(%rip), %rdx     # 0x84719
leaq 0x10(%rsp), %rdi
callq 0x1e698
movq 0x8(%r13), %rsi
subq (%r13), %rsi
sarq $0x4, %rsi
leaq 0x68(%rsp), %rdi
callq 0x434a6
leaq 0x88(%rsp), %rdi
movq (%r12), %rsi
callq 0x434a6
leaq 0x30(%rsp), %rdi
leaq 0x68(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x2, %edx
callq 0x20b38
leaq 0x48(%rsp), %rdi
leaq 0x10(%rsp), %rsi
leaq 0x30(%rsp), %rdx
callq 0x47db4
movb $0x1, %r12b
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %r12d, %r12d
leaq 0x705ad(%rip), %rsi     # 0xb0d20
leaq -0x94d6(%rip), %rdx     # 0x372a4
movq %rbx, %rdi
callq 0x106d0
movq %rax, %r14
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x407a8
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x407a8
movq %rax, %r14
movb $0x1, %r12b
leaq 0x30(%rsp), %rdi
callq 0x1db60
jmp 0x407ba
movq %rax, %r14
movb $0x1, %r12b
leaq 0x98(%rsp), %r15
xorl %r13d, %r13d
movq 0x88(%rsp,%r13), %rdi
leaq (%r15,%r13), %rax
cmpq %rdi, %rax
je 0x407e1
movq (%rax), %rsi
incq %rsi
callq 0x103d0
addq $-0x20, %r13
cmpq $-0x40, %r13
jne 0x407c5
jmp 0x40816
movq %rax, %r14
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
movb $0x1, %r12b
cmpq %rax, %rdi
je 0x40816
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x103d0
jmp 0x40816
movq %rax, %r14
movb $0x1, %r12b
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4082d
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %r12b, %r12b
jne 0x40837
jmp 0x4083f
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
leaq 0x74c82(%rip), %rbx     # 0xb59d8
movq (%rax), %rdi
movl (%rdi), %eax
cmpl $-0x8, %eax
jne 0x40d7c
addq $0x8, %rdi
callq 0x43b28
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
jmp 0x40d56
cmpl $-0x6, %eax
jne 0x40d96
addq $0x8, %rdi
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x43bfe
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x439fa(%rip), %rsi     # 0x847ae
leaq 0x43a12(%rip), %rdx     # 0x847cd
movq %rsp, %rdi
callq 0x1e698
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x6ff40(%rip), %rsi     # 0xb0d20
leaq -0x9b43(%rip), %rdx     # 0x372a4
movq %rbx, %rdi
callq 0x106d0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x40e08
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x40e12
jmp 0x40e1a
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
leaq 0x74b9a(%rip), %rbx     # 0xb59d8
movq (%rax), %rdi
movl (%rdi), %eax
cmpl $-0x8, %eax
jne 0x40e64
addq $0x8, %rdi
callq 0x43b28
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
jmp 0x40e3e
cmpl $-0x6, %eax
jne 0x40e87
addq $0x8, %rdi
callq 0x43bfe
cmpq $0x0, 0x30(%rax)
setne %al
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x43909(%rip), %rsi     # 0x847ae
leaq 0x43921(%rip), %rdx     # 0x847cd
movq %rsp, %rdi
callq 0x1e698
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x6fe4f(%rip), %rsi     # 0xb0d20
leaq -0x9c34(%rip), %rdx     # 0x372a4
movq %rbx, %rdi
callq 0x106d0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x40ef9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x40f03
jmp 0x40f0b
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43bfe
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x3f484
movq 0x18(%r15), %r15
leaq 0x10(%rsp), %rbp
cmpq %rbp, %r15
je 0x42aef
movq 0x40(%r15), %r12
leaq 0x30(%r15), %r14
cmpq %r14, %r12
je 0x42adf
leaq 0x20(%r15), %r13
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x43bfe
movq %rax, %rdi
movq %r13, %rsi
callq 0x435b2
leaq 0x20(%r12), %rsi
movq %rax, %rdi
callq 0x43618
movq 0x38(%r12), %rcx
movq %rcx, (%rax)
addq $0x8, %rax
leaq 0x40(%r12), %rsi
movq %rax, %rdi
callq 0x3775e
movq %r12, %rdi
callq 0x102a0
movq %rax, %r12
cmpq %r14, %rax
jne 0x42a92
movq %r15, %rdi
callq 0x102a0
movq %rax, %r15
cmpq %rbp, %rax
jne 0x42a81
movq (%rsp), %r14
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x43bfe
cmpq $0x0, 0x30(%rax)
je 0x42b3c
movq (%r14), %rdi
addq $0x8, %rdi
callq 0x43bfe
movq %rax, %r14
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x43bfe
movq 0x30(%r14), %rcx
movq %rcx, 0x30(%rax)
addq $0x38, %rax
addq $0x38, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3775e
leaq 0x8(%rsp), %rdi
callq 0x3f950
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42b57
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3f950
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rax
leaq 0x72e50(%rip), %rbx     # 0xb59d8
movq (%rax), %rdi
movl (%rdi), %eax
cmpl $-0x8, %eax
jne 0x42bae
addq $0x8, %rdi
callq 0x43b28
movq %rax, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movq %r14, %rcx
callq 0x3ced2
jmp 0x42b88
cmpl $-0x6, %eax
jne 0x42bcd
addq $0x8, %rdi
callq 0x43bfe
addq $0x30, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0xa8, %edi
callq 0x101e0
movq %rax, %rbx
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x41bc3(%rip), %rsi     # 0x847ae
leaq 0x41bdb(%rip), %rdx     # 0x847cd
movq %rsp, %rdi
callq 0x1e698
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movq %r15, %rdx
movq %r14, %rcx
callq 0x46e88
xorl %ebp, %ebp
leaq 0x6e109(%rip), %rsi     # 0xb0d20
leaq -0xb97a(%rip), %rdx     # 0x372a4
movq %rbx, %rdi
callq 0x106d0
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x42c3f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x103d0
testb %bpl, %bpl
jne 0x42c49
jmp 0x42c51
movq %rax, %r14
movq %rbx, %rdi
callq 0x102d0
movq %r14, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x43137
addq $0x8, %rdi
callq 0x43b28
movq %rax, %r13
leaq 0x7292a(%rip), %rsi     # 0xb59c8
movq %rax, %rdi
callq 0x3ce6c
testb %al, %al
je 0x43137
leaq 0x72913(%rip), %rsi     # 0xb59c8
movq %r13, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x3ced2
movq %rax, %r12
leaq 0x18(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x3fdf4
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rcx
movl $0x1, %edx
movq %r13, %rsi
callq 0x436ac
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r12, %rsi
movq %r14, %rcx
movq %rbx, %r8
callq 0x41ffe
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x409e0
movl %eax, %ebx
leaq 0x8(%rsp), %rdi
callq 0x3fe06
leaq 0x28(%rsp), %rdi
callq 0x20952
leaq 0x18(%rsp), %rdi
callq 0x3fe06
jmp 0x4314d
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x42c72
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 0x3fe06
jmp 0x4316f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20952
jmp 0x4317e
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x3fe06
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::pureEquals(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::pureEquals(const symbol_t *b, const token_t *token, trace_t &stack_trace) const
{
	if (d->type != b->d->type)
	{
		return false;
	}
	switch (d->type)
	{
	case value_type_enum::OBJECT:
		return std::get<object_t>(d->value) == std::get<object_t>(b->d->value);
	default:
		return this->equals(b, token, stack_trace);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %rax
movq (%rdi), %rdi
movl (%rdi), %esi
movq (%rbx), %r8
cmpl (%r8), %esi
jne 0x431d6
cmpl $-0x8, %esi
jne 0x431e0
addq $0x8, %rdi
callq 0x43b28
movq %rax, %r14
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x43b28
movq %r14, %rdi
movq %rax, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x3ceb8
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x42c72
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/symbol/symbol.cpp
// Function: symbol_t::shift() const
void symbol_t::shift() const
{
	if (d->type != value_type_enum::FUNCTION)
	{
		return;
	}
	for (auto &e : std::get<wrapper_t>(d->value).map)
	{
		for (auto &f : e.second)
		{
			f.second->shift();
		}
	}
	if (std::get<wrapper_t>(d->value).varg != nullptr)
	{
		std::get<wrapper_t>(d->value).varg->shift();
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
cmpl $-0x6, (%rdi)
jne 0x433ff
addq $0x8, %rdi
callq 0x43bfe
movq %rax, %r14
movq 0x18(%rax), %r15
addq $0x8, %r14
cmpq %r14, %r15
je 0x433ce
movq 0x40(%r15), %r12
leaq 0x30(%r15), %r13
cmpq %r13, %r12
je 0x433be
movq 0x38(%r12), %rdi
callq 0x24e70
movq %r12, %rdi
callq 0x102a0
movq %rax, %r12
cmpq %r13, %rax
jne 0x433a4
movq %r15, %rdi
callq 0x102a0
movq %rax, %r15
cmpq %r14, %rax
jne 0x43397
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x43bfe
cmpq $0x0, 0x30(%rax)
je 0x433ff
movq (%rbx), %rdi
addq $0x8, %rdi
callq 0x43bfe
movq 0x30(%rax), %rdi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x24e70
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/rossa/wrapper/wrapper.cpp
// Function: wrapper_t::hash() const
const unsigned int wrapper_t::hash() const
{
	int h = 0;
	int i = 0;
	for (auto &e : map)
	{
		for (auto &f : e.second)
		{
			h = (h + (f.second->key << i++)) % 0xFFFFFFFF;
		}
	}
	return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rdi), %r14
addq $0x8, %rbx
xorl %r15d, %r15d
cmpq %rbx, %r14
je 0x46e74
movabsq $-0x7fffffff7fffffff, %r13 # imm = 0x8000000080000001
xorl %r12d, %r12d
movq 0x40(%r14), %rdi
leaq 0x30(%r14), %rbp
cmpq %rbp, %rdi
je 0x46e64
movslq %r15d, %rax
movq 0x38(%rdi), %rcx
movq 0x10(%rcx), %rsi
movl %r12d, %ecx
shlq %cl, %rsi
addq %rax, %rsi
movq %rsi, %rax
mulq %r13
incl %r12d
movq %rdx, %r15
shrq $0x1f, %r15
addl %esi, %r15d
callq 0x104b0
movq %rax, %rdi
cmpq %rbp, %rax
jne 0x46e30
movq %r14, %rdi
callq 0x104b0
movq %rax, %r14
cmpq %rbx, %rax
jne 0x46e23
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_O3/Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator=(number_t const&)
void number_t::operator=(const number_t &n) noexcept
{
	type = n.type;
	switch (type)
	{
	case DOUBLE_NUM:
		valueDouble = n.valueDouble;
		break;
	case LONG_NUM:
		valueLong = n.valueLong;
		break;
	}
}

// Assembly:
movl 0x8(%rsi), %eax
movl %eax, 0x8(%rdi)
cmpl $0x1, %eax
je 0x4704c
testl %eax, %eax
jne 0x47052
movsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
retq
movq (%rsi), %rax
movq %rax, (%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator+=(number_t const&)
void number_t::operator+=(const number_t &n) noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		valueDouble += n.getDouble();
		validate();
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			valueDouble = static_cast<long_double_t>(valueLong) + n.valueDouble;
			type = DOUBLE_NUM;
			validate();
			break;
		case LONG_NUM:
			valueLong += n.valueLong;
			break;
		}
	}
}

// Assembly:
movl 0x8(%rdi), %eax
cmpl $0x1, %eax
je 0x47072
testl %eax, %eax
jne 0x470a1
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
je 0x47094
testl %eax, %eax
jne 0x470a2
movsd (%rsi), %xmm0
jmp 0x470aa
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
je 0x4709b
testl %eax, %eax
jne 0x470a1
cvtsi2sdq (%rdi), %xmm0
addsd (%rsi), %xmm0
movsd %xmm0, (%rdi)
movl $0x0, 0x8(%rdi)
jmp 0x470b2
cvtsi2sdq (%rsi), %xmm0
jmp 0x470aa
movq (%rsi), %rax
addq %rax, (%rdi)
retq
movsd 0x3d8d6(%rip), %xmm0    # 0x84980
addsd (%rdi), %xmm0
movsd %xmm0, (%rdi)
cvttsd2si %xmm0, %rax
cvtsi2sd %rax, %xmm1
ucomisd %xmm1, %xmm0
jne 0x470a1
jp 0x470a1
movq %rax, (%rdi)
movl $0x1, 0x8(%rdi)
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator+() const
const number_t number_t::operator+() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return number_t::Double(valueDouble);
	case LONG_NUM:
		return number_t::Long(valueLong);
	}
	return number_t();
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rsi
movl 0x8(%rdi), %eax
cmpl $0x1, %eax
je 0x471bb
testl %eax, %eax
jne 0x471c8
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x46faa
jmp 0x471d5
movq %rsp, %rbx
movq %rbx, %rdi
callq 0x46fd6
jmp 0x471d5
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x46fe4
movq (%rbx), %rax
movl 0x8(%rbx), %edx
addq $0x20, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator-() const
const number_t number_t::operator-() const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		return number_t::Double(-valueDouble);
	case LONG_NUM:
		return number_t::Long(-valueLong);
	}
	return number_t();
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl 0x8(%rdi), %eax
cmpl $0x1, %eax
je 0x47215
testl %eax, %eax
jne 0x47231
movsd (%rdi), %xmm0
xorps 0x3d792(%rip), %xmm0    # 0x84990
leaq 0x8(%rsp), %rsi
movlps %xmm0, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x46faa
jmp 0x4723e
xorl %eax, %eax
subq (%rdi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x46fd6
jmp 0x4723e
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x46fe4
movq (%rbx), %rax
movl 0x8(%rbx), %edx
addq $0x30, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/Nallantli[P]Rossa/main/number/number.cpp
// Function: number_t::operator+(number_t const&) const
const number_t number_t::operator+(const number_t &n) const noexcept
{
	switch (type)
	{
	case DOUBLE_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(valueDouble + n.valueDouble);
		case LONG_NUM:
			return number_t::Double(valueDouble + static_cast<long_double_t>(n.valueLong));
		}
		break;
	case LONG_NUM:
		switch (n.type)
		{
		case DOUBLE_NUM:
			return number_t::Double(static_cast<long_double_t>(valueLong) + n.valueDouble);
		case LONG_NUM:
			return number_t::Long(valueLong + n.valueLong);
		}
	}
	return number_t();
}

// Assembly:
pushq %rbx
subq $0x30, %rsp
movl 0x8(%rdi), %eax
cmpl $0x1, %eax
je 0x4726d
testl %eax, %eax
jne 0x47284
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
je 0x47293
testl %eax, %eax
jne 0x47284
movsd (%rdi), %xmm0
jmp 0x4727e
movl 0x8(%rsi), %eax
cmpl $0x1, %eax
je 0x472b4
testl %eax, %eax
jne 0x47284
cvtsi2sdq (%rdi), %xmm0
addsd (%rsi), %xmm0
jmp 0x4729c
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x46fe4
jmp 0x472cf
cvtsi2sdq (%rsi), %xmm0
addsd (%rdi), %xmm0
leaq 0x8(%rsp), %rsi
movsd %xmm0, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x46faa
jmp 0x472cf
movq (%rsi), %rax
addq (%rdi), %rax
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x46fd6
movq (%rbx), %rax
movl 0x8(%rbx), %edx
addq $0x30, %rsp
popq %rbx
retq
nop