LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: WhileNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void WhileNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "WHILE\n";
	whiles->printTree(indent, false);
	for (size_t i = 0; i < body.size(); i++)
		body[i]->printTree(indent, i == body.size() - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x600b6(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x22cda(%rip), %rax     # 0x78bbb
leaq 0x22cdd(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x22ccd(%rip), %rax     # 0x78bc2
leaq 0x22cd0(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x22c98(%rip), %rdx     # 0x78bc3
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0x4(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x1c84f
leaq 0x8(%rsp), %rdi
callq 0x101d0
leaq 0x48(%rsp), %rdi
callq 0x101d0
movq 0x60020(%rip), %rdi     # 0xb5f88
leaq 0x22df8(%rip), %rsi     # 0x78d67
callq 0x103b0
movq 0xa8(%r14), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x101d0
xorl %r13d, %r13d
leaq 0x68(%rsp), %r15
xorl %ebp, %ebp
movq 0xb8(%r14), %rax
movq 0xc0(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rbp
jae 0x56011
movq (%rax,%r13), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq 0xc0(%r14), %rax
subq 0xb8(%r14), %rax
sarq $0x4, %rax
decq %rax
xorl %edx, %edx
cmpq %rax, %rbp
sete %dl
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %r15, %rdi
callq 0x101d0
incq %rbp
addq $0x10, %r13
jmp 0x55fad
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x5604e
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d0
jmp 0x5603f
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x5604e
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ForNode::genParser() const
ptr_instruction_t ForNode::genParser() const
{
	std::vector<ptr_instruction_t> is;
	for (auto &e : this->body)
	{
		is.push_back(e->genParser());
	}

	return std::make_shared<ForI>(id, fors->genParser(), is, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq 0xc0(%rsi), %rbp
movq 0xc8(%rsi), %rbx
leaq 0x8(%rsp), %r15
movq %rsp, %r13
cmpq %rbx, %rbp
je 0x56269
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5a2b6
movq %r15, %rdi
callq 0x1d786
addq $0x10, %rbp
jmp 0x5623f
movq 0xb0(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *(%rax)
leaq 0xa8(%r14), %rsi
addq $0x28, %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %r14, %r8
callq 0x596ec
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x18(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
leaq 0x30(%rsp), %rdi
callq 0x58a44
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x562f6
jmp 0x562eb
movq %rax, %rbx
jmp 0x562fb
movq %rax, %rbx
movq %r15, %rdi
callq 0x1d786
leaq 0x30(%rsp), %rdi
callq 0x58a44
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ForNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ForNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "FOR : " << ROSSA_DEHASH(id) << "\n";
	fors->printTree(indent, false);
	for (size_t i = 0; i < body.size(); i++)
		body[i]->printTree(indent, i == body.size() - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5fc56(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x2287a(%rip), %rax     # 0x78bbb
leaq 0x2287d(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x2286d(%rip), %rax     # 0x78bc2
leaq 0x22870(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x22838(%rip), %rdx     # 0x78bc3
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0x4(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x1c84f
leaq 0x8(%rsp), %rdi
callq 0x101d0
leaq 0x48(%rsp), %rdi
callq 0x101d0
movq 0x5fbc0(%rip), %rdi     # 0xb5f88
leaq 0x2299f(%rip), %rsi     # 0x78d6e
callq 0x103b0
movq %rax, %r15
leaq 0xa8(%r14), %rdx
leaq 0x60523(%rip), %rsi     # 0xb6908
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1f164
movq %r15, %rdi
movq %r12, %rsi
callq 0x10370
leaq 0x21719(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
leaq 0x8(%rsp), %rdi
callq 0x101d0
movq 0xb0(%r14), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *0x10(%rax)
leaq 0x28(%rsp), %rdi
callq 0x101d0
xorl %r13d, %r13d
leaq 0x68(%rsp), %r15
xorl %ebp, %ebp
movq 0xc0(%r14), %rax
movq 0xc8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rbp
jae 0x564b3
movq (%rax,%r13), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq 0xc8(%r14), %rax
subq 0xc0(%r14), %rax
sarq $0x4, %rax
decq %rax
xorl %edx, %edx
cmpq %rax, %rbp
sete %dl
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %r15, %rdi
callq 0x101d0
incq %rbp
addq $0x10, %r13
jmp 0x5644f
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x564fa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d0
jmp 0x564e1
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x564fa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x564fa
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ForNode::fold(std::vector<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>, std::allocator<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>>> const&) const
const ptr_node_t ForNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	std::vector<ptr_node_t> nbody;
	for (auto &c : body)
		nbody.push_back(c->fold(consts));
	return std::make_shared<ForNode>(path, id, fors->fold(consts), nbody, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r15
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0xc0(%rsi), %rbx
movq %rsi, 0x18(%rsp)
movq 0xc8(%rsi), %r14
leaq 0x8(%rsp), %r12
movq %rsp, %rbp
cmpq %r14, %rbx
je 0x56578
movq (%rbx), %rsi
movq (%rsi), %rax
movq %rbp, %rdi
movq %r15, %rdx
callq *0x18(%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2e880
movq %r12, %rdi
callq 0x1d786
addq $0x10, %rbx
jmp 0x5654b
movq 0x18(%rsp), %rbx
movq 0xb0(%rbx), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
leaq 0xa8(%rbx), %rdx
leaq 0x8(%rbx), %rsi
addq $0x28, %rbx
movq %rsp, %rdi
leaq 0x20(%rsp), %rcx
leaq 0x30(%rsp), %r8
movq %rbx, %r9
callq 0x59713
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x10(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
leaq 0x30(%rsp), %rdi
callq 0x2e838
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x56612
jmp 0x56607
movq %rax, %rbx
jmp 0x56617
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x30(%rsp), %rdi
callq 0x2e838
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: UntilNode::genParser() const
ptr_instruction_t UntilNode::genParser() const
{
	if (inclusive)
	{
		if (step == nullptr)
			return std::make_shared<UntilNoStepIncI>(a->genParser(), b->genParser(), token);
		else
			return std::make_shared<UntilStepIncI>(a->genParser(), b->genParser(), step->genParser(), token);
	}
	if (step == nullptr)
		return std::make_shared<UntilNoStepExcI>(a->genParser(), b->genParser(), token);
	else
		return std::make_shared<UntilStepExcI>(a->genParser(), b->genParser(), step->genParser(), token);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc8(%rsi), %rax
cmpb $0x1, 0xd8(%rsi)
jne 0x56725
testq %rax, %rax
je 0x567a1
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0xb8(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *(%rax)
movq 0xc8(%r14), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
callq *(%rax)
addq $0x28, %r14
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x38(%rsp), %rcx
movq %r14, %r8
callq 0x59765
jmp 0x5677d
testq %rax, %rax
je 0x567dc
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0xb8(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *(%rax)
movq 0xc8(%r14), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
callq *(%rax)
addq $0x28, %r14
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
leaq 0x38(%rsp), %rcx
movq %r14, %r8
callq 0x597b0
leaq 0x28(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x40(%rsp), %rdi
jmp 0x5682a
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0xb8(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *(%rax)
addq $0x28, %r14
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rcx
callq 0x59741
jmp 0x56815
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0xb8(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *(%rax)
addq $0x28, %r14
leaq 0x20(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rcx
callq 0x5978c
leaq 0x28(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x8(%rsp), %rdi
callq 0x1d786
leaq 0x18(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
jmp 0x56869
jmp 0x56869
jmp 0x5687a
jmp 0x5687a
jmp 0x56858
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x1d786
jmp 0x5686c
jmp 0x56869
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d786
jmp 0x5687d
jmp 0x5687a
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: UntilNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void UntilNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "UNTIL\n";
	a->printTree(indent, false);
	b->printTree(indent, step == nullptr);
	if (step != nullptr)
		step->printTree(indent, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5f6d6(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x222fa(%rip), %rax     # 0x78bbb
leaq 0x222fd(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x222ed(%rip), %rax     # 0x78bc2
leaq 0x222f0(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x90(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x222b5(%rip), %rdx     # 0x78bc3
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0xc(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1c84f
leaq 0x10(%rsp), %rdi
callq 0x101d0
leaq 0x90(%rsp), %rdi
callq 0x101d0
movq 0x5f63a(%rip), %rdi     # 0xb5f88
leaq 0x22420(%rip), %rsi     # 0x78d75
callq 0x103b0
movq 0xa8(%r14), %r15
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *0x10(%rax)
leaq 0x70(%rsp), %rdi
callq 0x101d0
movq 0xb8(%r14), %r15
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
xorl %edx, %edx
cmpq $0x0, 0xc8(%r14)
sete %dl
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq 0xc8(%r14), %r14
testq %r14, %r14
je 0x569f8
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r14), %rax
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x101d0
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x56a40
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x56a40
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x56a40
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x56a38
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: UntilNode::fold(std::vector<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>, std::allocator<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>>> const&) const
const ptr_node_t UntilNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	if (step == nullptr)
		return std::make_shared<UntilNode>(path, a->fold(consts), b->fold(consts), nullptr, inclusive, token);
	else
		return std::make_shared<UntilNode>(path, a->fold(consts), b->fold(consts), step->fold(consts), inclusive, token);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0xc8(%rsi)
je 0x56afa
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
movq 0xb8(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
movq 0xc8(%r14), %rsi
movq (%rsi), %rax
leaq 0x30(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
leaq 0x8(%r14), %rsi
leaq 0xd8(%r14), %r9
addq $0x28, %r14
movq %r14, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %r8
callq 0x59808
leaq 0x48(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x38(%rsp), %rdi
jmp 0x56b69
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
movq 0xb8(%r14), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
leaq 0x30(%rsp), %r8
andq $0x0, (%r8)
leaq 0x8(%r14), %rsi
leaq 0xd8(%r14), %r9
addq $0x28, %r14
movq %r14, (%rsp)
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x597d7
leaq 0x48(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x18(%rsp), %rdi
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x56ba2
jmp 0x56bb1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1d786
jmp 0x56ba5
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x56bb4
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x1d786
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: MapNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void MapNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "MAP\n";
	for (size_t i = 0; i < args.size(); i++)
		args[i].second->printTree(indent, i == args.size() - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5f225(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x21e49(%rip), %rax     # 0x78bbb
leaq 0x21e4c(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x21e3c(%rip), %rax     # 0x78bc2
leaq 0x21e3f(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, 0x8(%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x38(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x21e02(%rip), %rdx     # 0x78bc3
leaq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0x14(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x18(%rsp), %rdi
callq 0x1c84f
leaq 0x18(%rsp), %rdi
callq 0x101d0
leaq 0x38(%rsp), %rdi
callq 0x101d0
movq 0x5f18a(%rip), %rdi     # 0xb5f88
leaq 0x21f77(%rip), %rsi     # 0x78d7c
callq 0x103b0
pushq $0x20
popq %r13
xorl %ebp, %ebp
pushq $0x30
popq %rbx
leaq 0x58(%rsp), %r15
movq 0xa8(%r14), %rcx
movq 0xb0(%r14), %rax
subq %rcx, %rax
cqto
idivq %rbx
cmpq %rax, %rbp
jae 0x56e80
movq (%rcx,%r13), %r12
movq %r15, %rdi
movq 0x8(%rsp), %rsi
callq 0x10550
movq 0xb0(%r14), %rax
subq 0xa8(%r14), %rax
cqto
idivq %rbx
decq %rax
xorl %edx, %edx
cmpq %rax, %rbp
sete %dl
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %r15, %rdi
callq 0x101d0
incq %rbp
addq $0x30, %r13
jmp 0x56e18
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x101d0
jmp 0x56ea1
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
jmp 0x56eb0
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: MapNode::fold(std::vector<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>, std::allocator<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>>> const&) const
const ptr_node_t MapNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	if (isConst())
	{
		auto i = genParser();
		object_t newScope(static_cast<hash_ull>(0));
		trace_t stack_trace;
		auto r = i->evaluate(&newScope, stack_trace);
		return std::make_shared<ContainerNode>(path, r, token);
	}

	std::vector<std::pair<std::string, ptr_node_t>> nargs;
	for (auto &c : args)
		nargs.push_back({c.first, c.second->fold(consts)});
	return std::make_shared<MapNode>(path, nargs, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
testb %al, %al
je 0x56f8e
movq (%r14), %rax
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x50(%rsp), %rsi
andq $0x0, (%rsi)
movq %rsp, %rdi
callq 0x361aa
leaq 0x50(%rsp), %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
movq %rsp, %rdx
callq *(%rax)
leaq 0x8(%r14), %rsi
addq $0x28, %r14
leaq 0x80(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rcx
callq 0x58a65
leaq 0x88(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x40(%rsp), %rdi
callq 0x39102
leaq 0x50(%rsp), %rdi
callq 0x1cb1a
movq %rsp, %rdi
callq 0x363f2
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x5704b
movq %rbx, 0x30(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0xa8(%r14), %rbp
movq %r14, 0x38(%rsp)
movq 0xb0(%r14), %r15
movq %rsp, %rbx
leaq 0x50(%rsp), %r14
cmpq %r15, %rbp
je 0x57006
movq 0x20(%rbp), %rsi
movq (%rsi), %rax
movq %rbx, %rdi
movq %r12, %rdx
callq *0x18(%rax)
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
callq 0x5991c
movq %r13, %rdi
movq %r14, %rsi
callq 0x63000
movq %r14, %rdi
callq 0x2ef8c
leaq 0x8(%rsp), %rdi
callq 0x1d786
addq $0x30, %rbp
jmp 0x56fc0
movq 0x38(%rsp), %rcx
leaq 0x8(%rcx), %rsi
addq $0x28, %rcx
leaq 0x50(%rsp), %rdi
leaq 0x10(%rsp), %rdx
callq 0x59941
leaq 0x58(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x30(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x10(%rsp), %rdi
callq 0x2efc6
movq %rbx, %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x57097
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x39102
jmp 0x57074
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x1cb1a
movq %rsp, %rdi
callq 0x363f2
jmp 0x5708b
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x570c2
movq %rax, %rbx
jmp 0x570b8
movq %rax, %rbx
jmp 0x570ae
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x2ef8c
leaq 0x8(%rsp), %rdi
callq 0x1d786
leaq 0x10(%rsp), %rdi
callq 0x2efc6
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: TryCatchNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void TryCatchNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "TRY_CATCH : " << ROSSA_DEHASH(key) << "\n";
	trys->printTree(indent, false);
	catchs->printTree(indent, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x90, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5e3ac(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x20fd0(%rip), %rax     # 0x78bbb
leaq 0x20fd3(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x20fc3(%rip), %rax     # 0x78bc2
leaq 0x20fc6(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x70(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x20f8e(%rip), %rdx     # 0x78bc3
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0xc(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1c84f
leaq 0x10(%rsp), %rdi
callq 0x101d0
leaq 0x70(%rsp), %rdi
callq 0x101d0
movq 0x5e316(%rip), %rdi     # 0xb5f88
leaq 0x21110(%rip), %rsi     # 0x78d89
callq 0x103b0
movq %rax, %r15
leaq 0xc8(%r14), %rdx
leaq 0x5ec79(%rip), %rsi     # 0xb6908
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1f164
movq %r15, %rdi
movq %r12, %rsi
callq 0x10370
leaq 0x1fe6f(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
leaq 0x10(%rsp), %rdi
callq 0x101d0
movq 0xa8(%r14), %r15
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq *0x10(%rax)
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq 0xb8(%r14), %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r14), %rax
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x101d0
addq $0x90, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x57d64
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x57d64
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x57d55
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x57d64
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ThrowNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ThrowNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "THROW\n";
	throws->printTree(indent, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5e07f(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x20ca3(%rip), %rax     # 0x78bbb
leaq 0x20ca6(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x20c96(%rip), %rax     # 0x78bc2
leaq 0x20c99(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x50(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x20c61(%rip), %rdx     # 0x78bc3
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0xc(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1c84f
leaq 0x10(%rsp), %rdi
callq 0x101d0
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq 0x5dfe9(%rip), %rdi     # 0xb5f88
leaq 0x20df0(%rip), %rsi     # 0x78d96
callq 0x103b0
movq 0xa8(%r14), %r14
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r14), %rax
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x101d0
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x58009
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x58004
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: CallOpNode::genParser() const
ptr_instruction_t CallOpNode::genParser() const
{
	std::vector<ptr_instruction_t> fargs;
	for (auto &c : args)
		fargs.push_back(c->genParser());
	return std::make_shared<CallOpI>(id, fargs, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, 0x18(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq 0xb0(%rsi), %rbp
movq 0xb8(%rsi), %rbx
leaq 0x8(%rsp), %r15
movq %rsp, %r13
cmpq %rbx, %rbp
je 0x58171
movq (%rbp), %rsi
movq (%rsi), %rax
movq %r13, %rdi
callq *(%rax)
movq %r12, %rdi
movq %r13, %rsi
callq 0x5a2b6
movq %r15, %rdi
callq 0x1d786
addq $0x10, %rbp
jmp 0x58147
leaq 0xa8(%r14), %rsi
addq $0x28, %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
movq %r14, %rcx
callq 0x59b45
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x18(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x58a44
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x581c9
movq %rax, %rbx
jmp 0x581d9
movq %rax, %rbx
movq %r15, %rdi
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x58a44
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: CallOpNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void CallOpNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "CALL_OP : " << id << "\n";
	for (size_t i = 0; i < args.size(); i++)
		args[i]->printTree(indent, i == args.size() - 1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5dd7b(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x2099f(%rip), %rax     # 0x78bbb
leaq 0x209a2(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x20992(%rip), %rax     # 0x78bc2
leaq 0x20995(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x2095d(%rip), %rdx     # 0x78bc3
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0x4(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x8(%rsp), %rdi
callq 0x1c84f
leaq 0x8(%rsp), %rdi
callq 0x101d0
leaq 0x28(%rsp), %rdi
callq 0x101d0
movq 0x5dce5(%rip), %rdi     # 0xb5f88
leaq 0x20af3(%rip), %rsi     # 0x78d9d
callq 0x103b0
movq 0xa8(%r14), %rsi
movq %rax, %rdi
callq 0x102a0
leaq 0x1f858(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
xorl %r13d, %r13d
leaq 0x48(%rsp), %r15
xorl %ebp, %ebp
movq 0xb0(%r14), %rax
movq 0xb8(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rbp
jae 0x5833b
movq (%rax,%r13), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq 0xb8(%r14), %rax
subq 0xb0(%r14), %rax
sarq $0x4, %rax
decq %rax
xorl %edx, %edx
cmpq %rax, %rbp
sete %dl
movq (%r12), %rax
movq %r12, %rdi
movq %r15, %rsi
callq *0x10(%rax)
movq %r15, %rdi
callq 0x101d0
incq %rbp
addq $0x10, %r13
jmp 0x582d7
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d0
jmp 0x5835c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x5836b
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: CallOpNode::fold(std::vector<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>, std::allocator<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>>> const&) const
const ptr_node_t CallOpNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	std::vector<ptr_node_t> nargs;
	for (auto &c : args)
		nargs.push_back(c->fold(consts));

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rdi, 0x10(%rsp)
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0xb0(%rsi), %rbx
movq %rsi, 0x18(%rsp)
movq 0xb8(%rsi), %r14
leaq 0x8(%rsp), %r12
movq %rsp, %rbp
cmpq %r14, %rbx
je 0x583e8
movq (%rbx), %rsi
movq (%rsi), %rax
movq %rbp, %rdi
movq %r15, %rdx
callq *0x18(%rax)
movq %r13, %rdi
movq %rbp, %rsi
callq 0x2e880
movq %r12, %rdi
callq 0x1d786
addq $0x10, %rbx
jmp 0x583bb
movq 0x18(%rsp), %r8
leaq 0x8(%r8), %rsi
leaq 0xa8(%r8), %rdx
addq $0x28, %r8
movq %rsp, %rdi
leaq 0x20(%rsp), %rcx
callq 0x59b69
leaq 0x8(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x10(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x2e838
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x58446
movq %rax, %rbx
jmp 0x58456
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x20(%rsp), %rdi
callq 0x2e838
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: EachNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void EachNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "FOR : " << ROSSA_DEHASH(id) << "\n";
	eachs->printTree(indent, wheres == nullptr && body == nullptr);
	if (wheres)
		wheres->printTree(indent, body == nullptr);
	if (body)
		body->printTree(indent, true);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x5d980(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x205a4(%rip), %rax     # 0x78bbb
leaq 0x205a7(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x20597(%rip), %rax     # 0x78bc2
leaq 0x2059a(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%r14), %rsi
leaq 0x90(%rsp), %r15
movq %r15, %rdi
callq 0x4ea3c
leaq 0x2055f(%rip), %rdx     # 0x78bc3
leaq 0x10(%rsp), %rdi
movq %r15, %rsi
callq 0x1cb3b
leaq 0xc(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1c84f
leaq 0x10(%rsp), %rdi
callq 0x101d0
leaq 0x90(%rsp), %rdi
callq 0x101d0
movq 0x5d8e4(%rip), %rdi     # 0xb5f88
leaq 0x206c3(%rip), %rsi     # 0x78d6e
callq 0x103b0
movq %rax, %r15
leaq 0xa8(%r14), %rdx
leaq 0x5e247(%rip), %rsi     # 0xb6908
leaq 0x10(%rsp), %r12
movq %r12, %rdi
callq 0x1f164
movq %r15, %rdi
movq %r12, %rsi
callq 0x10370
leaq 0x1f43d(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
leaq 0x10(%rsp), %rdi
callq 0x101d0
movq 0xb0(%r14), %r15
leaq 0x70(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
movq 0xd0(%r14), %rax
xorl %edx, %edx
orq 0xc0(%r14), %rax
sete %dl
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
leaq 0x70(%rsp), %rdi
callq 0x101d0
movq 0xc0(%r14), %r15
testq %r15, %r15
je 0x58771
leaq 0x50(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
xorl %edx, %edx
cmpq $0x0, 0xd0(%r14)
sete %dl
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
callq *0x10(%rax)
leaq 0x50(%rsp), %rdi
callq 0x101d0
movq 0xd0(%r14), %r14
testq %r14, %r14
je 0x587a6
leaq 0x30(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq (%r14), %rax
pushq $0x1
popq %rdx
movq %r14, %rdi
movq %r15, %rsi
callq *0x10(%rax)
leaq 0x30(%rsp), %rdi
callq 0x101d0
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x587f8
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x587f8
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x587f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x587e6
movq %rax, %rbx
leaq 0x90(%rsp), %rdi
jmp 0x587f8
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: DefineI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t DefineI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::map<const hash_ull, const symbol_t> capturedVars;
	for (const hash_ull &e : captures)
	{
		capturedVars[e].set(&scope->getVariable(e, &token, stack_trace), &token, stack_trace);
	}
	ptr_function_t f = std::make_shared<function_t>(key, scope->getPtr(), params, body, capturedVars);
	if (key > 0)
	{
		return scope->createVariable(key, symbol_t::FunctionSIG(ftype, f), &token);
	}
	return symbol_t::FunctionSIG(ftype, f);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
leaq 0x40(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0xd8(%rsi), %rbp
movq 0xe0(%rsi), %rbx
movq %rsi, 0x10(%rsp)
leaq 0x8(%rsi), %r12
cmpq %rbx, %rbp
je 0x6496f
leaq 0x38(%rsp), %rdi
movq %rbp, %rsi
callq 0x37c1e
movq %rax, %r15
movq %r14, %rdi
movq %rbp, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x366ec
movq %r15, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %r13, %rcx
callq 0x3927a
addq $0x8, %rbp
jmp 0x64932
movq %r14, %rdi
callq 0x36744
movq 0x10(%rsp), %rsi
leaq 0x90(%rsi), %rbx
leaq 0x18(%rsp), %rdx
movq %rax, (%rdx)
leaq 0xb0(%rsi), %rcx
leaq 0xc8(%rsi), %r8
leaq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %r9
movq %rbx, %rsi
callq 0x6becf
cmpq $0x0, (%rbx)
je 0x649fd
movq 0x10(%rsp), %rsi
addq $0x98, %rsi
leaq 0x18(%rsp), %rdi
leaq 0x28(%rsp), %rdx
callq 0x390b8
leaq 0x18(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rcx
callq 0x366fc
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x390f0
leaq 0x18(%rsp), %rdi
callq 0x39102
movq 0x8(%rsp), %rbx
jmp 0x64a1b
movq 0x10(%rsp), %rsi
addq $0x98, %rsi
leaq 0x28(%rsp), %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x390b8
leaq 0x30(%rsp), %rdi
callq 0x1d786
leaq 0x38(%rsp), %rdi
callq 0x1df58
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x64a43
movq %rax, %rbx
jmp 0x64a55
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x39102
leaq 0x30(%rsp), %rdi
callq 0x1d786
jmp 0x64a66
jmp 0x64a63
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x1df58
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: VargDefineI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t VargDefineI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::map<const hash_ull, const symbol_t> capturedVars;
	for (const hash_ull &e : captures)
	{
		capturedVars[e].set(&scope->getVariable(e, &token, stack_trace), &token, stack_trace);
	}
	ptr_function_t f = std::make_shared<function_t>(key, scope->getPtr(), body, capturedVars);
	if (key > 0)
	{
		return scope->createVariable(key, symbol_t::FunctionVARG(static_cast<ptr_function_t>(f)), &token);
	}
	return symbol_t::FunctionVARG(static_cast<ptr_function_t>(f));
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, 0x8(%rsp)
leaq 0x50(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0xa8(%rsi), %rbp
movq 0xb0(%rsi), %rbx
movq %rsi, 0x30(%rsp)
leaq 0x8(%rsi), %r15
cmpq %rbx, %rbp
je 0x64b89
leaq 0x48(%rsp), %rdi
movq %rbp, %rsi
callq 0x37c1e
movq %rax, %r12
movq %r14, %rdi
movq %rbp, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x366ec
movq %r12, %rdi
movq %rax, %rsi
movq %r15, %rdx
movq %r13, %rcx
callq 0x3927a
addq $0x8, %rbp
jmp 0x64b4c
movq %r14, %rdi
callq 0x36744
movq 0x30(%rsp), %rcx
leaq 0x90(%rcx), %rbx
leaq 0x10(%rsp), %rdx
movq %rax, (%rdx)
addq $0x98, %rcx
leaq 0x20(%rsp), %rdi
leaq 0x48(%rsp), %r8
movq %rbx, %rsi
callq 0x6befd
cmpq $0x0, (%rbx)
je 0x64c14
leaq 0x38(%rsp), %r12
leaq 0x20(%rsp), %rsi
movq %r12, %rdi
callq 0x38c1a
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x390c6
leaq 0x10(%rsp), %rdx
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rcx
callq 0x366fc
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x390f0
leaq 0x10(%rsp), %rdi
callq 0x39102
leaq 0x40(%rsp), %rdi
jmp 0x64c38
leaq 0x10(%rsp), %rbx
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x38c1a
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x390c6
leaq 0x18(%rsp), %rdi
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
leaq 0x48(%rsp), %rdi
callq 0x1df58
movq 0x8(%rsp), %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
jmp 0x64c86
movq %rax, %rbx
jmp 0x64c81
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39102
leaq 0x40(%rsp), %rdi
callq 0x1d786
leaq 0x28(%rsp), %rdi
callq 0x1d786
jmp 0x64c9c
jmp 0x64c99
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x1df58
movq %rbx, %rdi
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: SequenceI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t SequenceI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::vector<symbol_t> evals;
	for (const ptr_instruction_t &e : children)
	{
		switch (e->getType())
		{
		case UNTIL_STEP_EXC_I:
		case UNTIL_NO_STEP_EXC_I:
		case UNTIL_STEP_INC_I:
		case UNTIL_NO_STEP_INC_I:
		case EACH_I:
		{
			std::vector<symbol_t> v = e->evaluate(scope, stack_trace).getVector(&token, stack_trace);
			for (auto &&ve : v)
			{
				evals.push_back(ve);
			}
			break;
		}
		default:
			evals.push_back(e->evaluate(scope, stack_trace));
			break;
		}
	}
	return symbol_t::Array(evals);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r14
movq %rdx, 0x8(%rsp)
movq %rdi, 0x28(%rsp)
leaq 0x40(%rsp), %r13
andq $0x0, 0x10(%r13)
xorps %xmm0, %xmm0
movaps %xmm0, (%r13)
movq 0x90(%rsi), %r15
movq 0x98(%rsi), %rax
movq %rax, 0x38(%rsp)
addq $0x8, %rsi
movq %rsi, 0x30(%rsp)
leaq 0x58(%rsp), %rbx
cmpq 0x38(%rsp), %r15
je 0x64e0c
movq (%r15), %rsi
movl 0x88(%rsi), %eax
addl $-0x13, %eax
cmpl $0x2e, %eax
ja 0x64de2
movabsq $0x40000000000f, %rcx   # imm = 0x40000000000F
btq %rax, %rcx
jae 0x64de2
movq (%rsi), %rax
movq %rbx, %rdi
movq 0x8(%rsp), %rdx
movq %r14, %rcx
callq *(%rax)
movq %rbx, %rdi
movq 0x30(%rsp), %rsi
movq %r14, %rdx
callq 0x39a02
leaq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x3bbc0
movq %rbx, %rdi
callq 0x39102
movq 0x10(%rsp), %r12
movq 0x18(%rsp), %rbp
cmpq %rbp, %r12
je 0x64dcf
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f00a
addq $0x10, %r12
jmp 0x64db9
leaq 0x10(%rsp), %rdi
callq 0x1f0b8
addq $0x10, %r15
jmp 0x64d4e
movq (%rsi), %rax
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq 0x8(%rsp), %rdx
movq %r14, %rcx
callq *(%rax)
movq %r13, %rdi
movq %r12, %rsi
callq 0x1f00a
movq %r12, %rdi
callq 0x39102
jmp 0x64dd9
leaq 0x40(%rsp), %rsi
movq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0x3909c
leaq 0x40(%rsp), %rdi
callq 0x1f0b8
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x64e48
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x64e55
jmp 0x64e48
movq %rax, %rbx
jmp 0x64e69
movq %rax, %rbx
leaq 0x58(%rsp), %rdi
callq 0x39102
jmp 0x64e69
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1f0b8
leaq 0x40(%rsp), %rdi
callq 0x1f0b8
movq %rbx, %rdi
callq 0x106f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: IfThenElseI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t IfThenElseI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const object_t newScope(scope, 0);
	if (ifs->evaluate(&newScope, stack_trace).getBool(&token, stack_trace))
	{
		return body->evaluate(&newScope, stack_trace);
	}
	return elses->evaluate(&newScope, stack_trace);
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, 0x8(%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, (%rsp)
leaq 0x8(%rsi), %rax
movq %rax, 0x30(%rsp)
leaq 0x10(%rsp), %rbp
leaq 0x38(%rsp), %r13
movq %rdx, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x90(%r12), %rsi
movq (%rsi), %rax
movq %rbp, %rdi
movq %r14, %rdx
movq 0x8(%rsp), %rbx
movq %rbx, %rcx
callq *(%rax)
movq %rbp, %rdi
movq 0x30(%rsp), %rsi
movq %rbx, %rdx
callq 0x39b5c
movl %eax, %r15d
movq %rbp, %rdi
callq 0x39102
testb %r15b, %r15b
je 0x6528c
andq $0x0, 0x38(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
movq %r13, %rdx
callq 0x36228
movq 0xa0(%r12), %r15
movq 0xa8(%r12), %rbx
cmpq %rbx, %r15
je 0x65266
movq (%r15), %rsi
movq (%rsi), %rax
movq %r13, %rdi
leaq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq *(%rax)
movq %r13, %rdi
callq 0x39682
xorl %ebp, %ebp
movb $0x1, %r12b
xorl %r14d, %r14d
cmpl $0x4, %eax
ja 0x65250
movl %eax, %eax
leaq 0x1514b(%rip), %rcx     # 0x7a368
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x390f0
jmp 0x65247
movb $0x1, %r14b
xorl %r12d, %r12d
pushq $0x4
jmp 0x6524f
movq (%rsp), %rdi
callq 0x38d00
xorl %r12d, %r12d
xorl %r14d, %r14d
pushq $0x1
popq %rbp
movq %r13, %rdi
callq 0x39102
addq $0x10, %r15
testb %r12b, %r12b
jne 0x651e5
testb %r14b, %r14b
je 0x65268
xorl %ebp, %ebp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x363f2
testl %ebp, %ebp
movq %rbx, %rbp
movq 0x28(%rsp), %r14
movq 0x20(%rsp), %r12
je 0x65182
jmp 0x65295
movq (%rsp), %rdi
callq 0x38d00
movq (%rsp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x39102
jmp 0x652d3
movq %rax, %rbx
jmp 0x652c9
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39102
leaq 0x10(%rsp), %rdi
callq 0x363f2
movq %rbx, %rdi
callq 0x106f0
nop