LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: VargDefineNode::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 VargDefineNode::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);
	}

	return std::make_shared<VargDefineNode>(path, key, body->fold(consts), captures, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
testb %al, %al
je 0x50611
movq (%r14), %rax
movq %rsp, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x40(%rsp), %rdi
callq 0x361aa
leaq 0x10(%rsp), %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq (%rsp), %rsi
movq (%rsi), %rax
leaq 0x30(%rsp), %rdi
leaq 0x40(%rsp), %rdx
callq *(%rax)
leaq 0x8(%r14), %rsi
addq $0x28, %r14
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %r14, %rcx
callq 0x58a65
leaq 0x58(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x30(%rsp), %rdi
callq 0x39102
leaq 0x10(%rsp), %rdi
callq 0x1cb1a
leaq 0x40(%rsp), %rdi
callq 0x363f2
jmp 0x5066d
leaq 0x8(%r14), %r12
leaq 0xa8(%r14), %r13
movq 0xb0(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rbp
movq %rbp, %rdi
movq %r15, %rdx
callq *0x18(%rax)
leaq 0xc0(%r14), %r8
addq $0x28, %r14
leaq 0x10(%rsp), %rdi
movq %r12, %rsi
movq %r13, %rdx
movq %rbp, %rcx
movq %r14, %r9
callq 0x58c56
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x8(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x39102
jmp 0x5069b
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1cb1a
leaq 0x40(%rsp), %rdi
callq 0x363f2
jmp 0x506b6
jmp 0x506b3
movq %rax, %rbx
leaq 0x8(%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: NewNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void NewNode::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 << "NEW\n";
	object->printTree(indent, false);
	params->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 0x6579c(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x283c0(%rip), %rax     # 0x78bbb
leaq 0x283c3(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x283b3(%rip), %rax     # 0x78bc2
leaq 0x283b6(%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 0x2837e(%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 0x65706(%rip), %rdi     # 0xb5f88
leaq 0x28380(%rip), %rsi     # 0x78c09
callq 0x103b0
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 0x50928
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x50928
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x50923
movq %rax, %rbx
leaq 0x70(%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: ClassNode::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 ClassNode::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));

	if (extends)
		return std::make_shared<ClassNode>(path, key, type, nbody, extends->fold(consts), token);
	else
		return std::make_shared<ClassNode>(path, key, type, nbody, nullptr, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, %r15
movq %rdi, 0x20(%rsp)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0xb8(%rsi), %rbx
movq %rsi, 0x38(%rsp)
movq 0xc0(%rsi), %r14
leaq 0x18(%rsp), %r12
leaq 0x10(%rsp), %rbp
cmpq %r14, %rbx
je 0x50fa0
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 0x50f73
movq 0x38(%rsp), %rbx
movq 0xd0(%rbx), %rsi
testq %rsi, %rsi
je 0x51013
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
leaq 0xb0(%rbx), %rcx
leaq 0xa8(%rbx), %rdx
leaq 0x8(%rbx), %rsi
addq $0x28, %rbx
movq %rbx, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %r8
leaq 0x28(%rsp), %r9
callq 0x58d2b
movq 0x20(%rsp), %rbx
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x30(%rsp), %rdi
jmp 0x5105f
leaq 0x8(%rbx), %rsi
leaq 0xa8(%rbx), %rdx
leaq 0xb0(%rbx), %rcx
leaq 0x28(%rsp), %r9
andq $0x0, (%r9)
addq $0x28, %rbx
movq %rbx, (%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x40(%rsp), %r8
callq 0x58d5c
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movq 0x20(%rsp), %rbx
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x40(%rsp), %rdi
callq 0x2e838
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5108e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0x51099
jmp 0x5108e
movq %rax, %rbx
jmp 0x5109e
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x40(%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: VarNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void VarNode::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 << "VAR : " << keys.size() << "\n";
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x64e25(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x27a49(%rip), %rax     # 0x78bbb
leaq 0x27a4c(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x27a3c(%rip), %rax     # 0x78bc2
leaq 0x27a3f(%rip), %r12     # 0x78bcc
cmovneq %rax, %r12
movq %r15, %rdi
callq 0x103b0
movq %r14, %rdi
movq %r12, %rsi
callq 0x10760
leaq 0x8(%rbx), %rsi
leaq 0x30(%rsp), %r14
movq %r14, %rdi
callq 0x4ea3c
leaq 0x27a07(%rip), %rdx     # 0x78bc3
leaq 0x10(%rsp), %rdi
movq %r14, %rsi
callq 0x1cb3b
leaq 0xc(%rsp), %rsi
movl $0x1f, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x1c84f
leaq 0x10(%rsp), %rdi
callq 0x101d0
leaq 0x30(%rsp), %rdi
callq 0x101d0
movq 0x64d8f(%rip), %rdi     # 0xb5f88
leaq 0x27a2b(%rip), %rsi     # 0x78c2b
callq 0x103b0
movq 0xb0(%rbx), %rsi
subq 0xa8(%rbx), %rsi
sarq $0x3, %rsi
movq %rax, %rdi
callq 0x102a0
leaq 0x268f7(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
addq $0x50, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x5124d
movq %rax, %rbx
leaq 0x30(%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: CallNode::genParser() const
ptr_instruction_t CallNode::genParser() const
{
	auto fcallee = callee->genParser();
	std::vector<ptr_instruction_t> fargs;
	for (auto &c : args)
		fargs.push_back(c->genParser());
	if (fcallee->getType() == INNER)
	{
		return std::make_shared<CallWithInnerI>(fcallee, std::make_shared<SequenceI>(fargs, token), token);
	}
	return std::make_shared<CallI>(fcallee, std::make_shared<SequenceI>(fargs, token), token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, 0x38(%rsp)
movq 0xa8(%rsi), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *(%rax)
xorps %xmm0, %xmm0
leaq 0x40(%rsp), %r12
movaps %xmm0, (%r12)
andq $0x0, 0x10(%r12)
movq 0xb8(%r14), %rbp
movq 0xc0(%r14), %rbx
leaq 0x18(%rsp), %r15
leaq 0x10(%rsp), %r13
cmpq %rbx, %rbp
je 0x5139c
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 0x51372
movq 0x28(%rsp), %rdi
callq 0x646ca
addq $0x28, %r14
cmpl $0x5, %eax
movq 0x38(%rsp), %rbx
jne 0x513db
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rdx
callq 0x58a22
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rcx
callq 0x58dd2
jmp 0x51400
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
movq %r14, %rdx
callq 0x58a22
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
movq %rsp, %rdx
movq %r14, %rcx
callq 0x58df6
leaq 0x18(%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 0x40(%rsp), %rdi
callq 0x58a44
leaq 0x30(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5144c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x51467
jmp 0x5145c
jmp 0x5145c
jmp 0x5145c
movq %rax, %rbx
jmp 0x5146c
movq %rax, %rbx
movq %r15, %rdi
callq 0x1d786
leaq 0x40(%rsp), %rdi
callq 0x58a44
leaq 0x30(%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: CallNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void CallNode::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\n";
	callee->printTree(indent, args.empty());
	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 $0x88, %rsp
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x64ab0(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x276d4(%rip), %rax     # 0x78bbb
leaq 0x276d7(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x276c7(%rip), %rax     # 0x78bc2
leaq 0x276ca(%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 0x27692(%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 0x64a1a(%rip), %rdi     # 0xb5f88
leaq 0x276bd(%rip), %rsi     # 0x78c32
callq 0x103b0
movq 0xa8(%r14), %r15
leaq 0x28(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
callq 0x10550
movq 0xb8(%r14), %rax
xorl %edx, %edx
cmpq 0xc0(%r14), %rax
sete %dl
movq (%r15), %rax
movq %r15, %rdi
movq %r12, %rsi
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 0x51628
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 0x515c4
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x51665
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x101d0
jmp 0x51656
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x51665
movq %rax, %rbx
leaq 0x68(%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: CallNode::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 CallNode::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<CallNode>(path, callee->fold(consts), nargs, 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 0xb8(%rsi), %rbx
movq %rsi, 0x18(%rsp)
movq 0xc0(%rsi), %r14
leaq 0x8(%rsp), %r12
movq %rsp, %rbp
cmpq %r14, %rbx
je 0x516e2
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 0x516b5
movq 0x18(%rsp), %rbx
movq 0xa8(%rbx), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
movq %r15, %rdx
callq *0x18(%rax)
leaq 0x8(%rbx), %rsi
addq $0x28, %rbx
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movq %rbx, %r8
callq 0x58e1a
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 0x51775
jmp 0x5176a
movq %rax, %rbx
jmp 0x5177a
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x30(%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: ExternCallNode::genParser() const
ptr_instruction_t ExternCallNode::genParser() const
{
	std::vector<ptr_instruction_t> fargs;
	for (auto &c : args)
		fargs.push_back(c->genParser());
	return std::make_shared<ExternI>(libname, fname, std::make_shared<SequenceI>(fargs, token), 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 0xe8(%rsi), %rbp
movq 0xf0(%rsi), %rbx
leaq 0x8(%rsp), %r15
movq %rsp, %r13
cmpq %rbx, %rbp
je 0x5189d
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 0x51873
leaq 0x28(%r14), %r15
leaq 0x20(%rsp), %rdi
leaq 0x30(%rsp), %rsi
movq %r15, %rdx
callq 0x58a22
leaq 0xc8(%r14), %rdx
addq $0xa8, %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rcx
movq %r14, %rsi
movq %r15, %r8
callq 0x58e41
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 0x51930
jmp 0x51925
movq %rax, %rbx
jmp 0x51935
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: ExternCallNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ExternCallNode::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 << "EXTERN_CALL : " << libname << "::" << fname << "\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 0x6461f(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x27243(%rip), %rax     # 0x78bbb
leaq 0x27246(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x27236(%rip), %rax     # 0x78bc2
leaq 0x27239(%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 0x27201(%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 0x64589(%rip), %rdi     # 0xb5f88
leaq 0x27232(%rip), %rsi     # 0x78c38
callq 0x103b0
leaq 0xa8(%r14), %rsi
movq %rax, %rdi
callq 0x10370
leaq 0x28d94(%rip), %rsi     # 0x7a7b5
movq %rax, %rdi
callq 0x103b0
leaq 0xc8(%r14), %rsi
movq %rax, %rdi
callq 0x10370
leaq 0x260de(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
xorl %r13d, %r13d
leaq 0x48(%rsp), %r15
xorl %ebp, %ebp
movq 0xe8(%r14), %rax
movq 0xf0(%r14), %rcx
subq %rax, %rcx
sarq $0x4, %rcx
cmpq %rcx, %rbp
jae 0x51ab5
movq (%rax,%r13), %r12
movq %r15, %rdi
movq %rbx, %rsi
callq 0x10550
movq 0xf0(%r14), %rax
subq 0xe8(%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 0x51a51
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 0x51ad6
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x51ae5
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: ExternCallNode::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 ExternCallNode::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<ExternCallNode>(path, libname, fname, 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 0xe8(%rsi), %rbx
movq %rsi, 0x18(%rsp)
movq 0xf0(%rsi), %r14
leaq 0x8(%rsp), %r12
movq %rsp, %rbp
cmpq %r14, %rbx
je 0x51b62
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 0x51b35
movq 0x18(%rsp), %r9
leaq 0x8(%r9), %rsi
leaq 0xa8(%r9), %rdx
leaq 0xc8(%r9), %rcx
addq $0x28, %r9
movq %rsp, %rdi
leaq 0x20(%rsp), %r8
callq 0x58e68
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 0x51bc7
movq %rax, %rbx
jmp 0x51bd7
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x20(%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: CallBuiltNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void CallBuiltNode::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_BUILT : " << std::to_string(t) << "\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 0x63b91(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x267b5(%rip), %rax     # 0x78bbb
leaq 0x267b8(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x267a8(%rip), %rax     # 0x78bc2
leaq 0x267ab(%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 0x26773(%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 0x63afb(%rip), %rdi     # 0xb5f88
leaq 0x26805(%rip), %rsi     # 0x78c99
callq 0x103b0
movq %rax, %r15
movl 0xa8(%r14), %esi
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x1cac0
movq %r15, %rdi
movq %r12, %rsi
callq 0x10370
leaq 0x2565b(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
leaq 0x8(%rsp), %rdi
callq 0x101d0
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 0x52542
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 0x524de
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 0x52563
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0x5257c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x5257c
movq %rax, %rbx
leaq 0x48(%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: CallBuiltNode::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 CallBuiltNode::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<ptr_node_t> nargs;
	for (auto &c : args)
	{
		nargs.push_back(c->fold(consts));
	}

	return std::make_shared<CallBuiltNode>(path, t, nargs, token);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
movq %rsi, %rdi
callq *0x8(%rax)
testb %al, %al
je 0x52654
movq (%r14), %rax
movq %rsp, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x10(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x50(%rsp), %rdi
callq 0x361aa
leaq 0x10(%rsp), %rcx
andq $0x0, 0x10(%rcx)
xorps %xmm0, %xmm0
movaps %xmm0, (%rcx)
movq (%rsp), %rsi
movq (%rsi), %rax
leaq 0x40(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq *(%rax)
leaq 0x8(%r14), %rsi
addq $0x28, %r14
leaq 0x60(%rsp), %rdi
leaq 0x40(%rsp), %rdx
movq %r14, %rcx
callq 0x58a65
leaq 0x68(%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 0x10(%rsp), %rdi
callq 0x1cb1a
leaq 0x50(%rsp), %rdi
callq 0x363f2
leaq 0x8(%rsp), %rdi
callq 0x1d786
jmp 0x526fd
movq %rbx, 0x30(%rsp)
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r13
movaps %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq 0xb0(%r14), %rbx
movq %r14, 0x38(%rsp)
movq 0xb8(%r14), %r14
leaq 0x8(%rsp), %r12
movq %rsp, %rbp
cmpq %r14, %rbx
je 0x526b3
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 0x52686
movq 0x38(%rsp), %r8
leaq 0x8(%r8), %rsi
leaq 0xa8(%r8), %rdx
addq $0x28, %r8
movq %rsp, %rdi
leaq 0x10(%rsp), %rcx
callq 0x58f77
leaq 0x8(%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 0x2e838
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x52748
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
callq 0x39102
jmp 0x52723
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x1cb1a
leaq 0x50(%rsp), %rdi
callq 0x363f2
jmp 0x5273c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d786
jmp 0x52762
movq %rax, %rbx
jmp 0x52758
movq %rax, %rbx
movq %r12, %rdi
callq 0x1d786
leaq 0x10(%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: ReturnNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ReturnNode::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 << "RETURN\n";
	a->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 0x63741(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x26365(%rip), %rax     # 0x78bbb
leaq 0x26368(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x26358(%rip), %rax     # 0x78bc2
leaq 0x2635b(%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 0x26323(%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 0x636ab(%rip), %rdi     # 0xb5f88
leaq 0x263c3(%rip), %rsi     # 0x78ca7
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 0x52947
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x52942
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: ReferNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ReferNode::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 << "REFER\n";
	a->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 0x634cf(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x260f3(%rip), %rax     # 0x78bbb
leaq 0x260f6(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x260e6(%rip), %rax     # 0x78bc2
leaq 0x260e9(%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 0x260b1(%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 0x63439(%rip), %rdi     # 0xb5f88
leaq 0x26159(%rip), %rsi     # 0x78caf
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 0x52bb9
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x52bb4
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: BinOpNode::isConst() const
bool BinOpNode::isConst() const
{
	if (a->isConst() && b->isConst())
	{
		try
		{
			object_t newScope(static_cast<hash_ull>(0));
			trace_t stack_trace;
			genParser()->evaluate(&newScope, stack_trace);
			return true;
		}
		catch (const rossa_error_t &e)
		{
			return false;
		}
	}
	return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movq 0xc8(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x53b49
movq 0xd8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x53b49
movq %rsp, %rsi
andq $0x0, (%rsi)
leaq 0x28(%rsp), %rdi
callq 0x361aa
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
andq $0x0, 0x10(%rsp)
movq (%rbx), %rax
leaq 0x18(%rsp), %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x18(%rsp), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %rsp, %rcx
callq *(%rax)
leaq 0x38(%rsp), %rdi
callq 0x39102
leaq 0x20(%rsp), %rdi
callq 0x1d786
movq %rsp, %rdi
callq 0x1cb1a
leaq 0x28(%rsp), %rdi
callq 0x363f2
movb $0x1, %al
jmp 0x53b4b
movq %rdx, %r14
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1d786
jmp 0x53b1c
movq %rdx, %r14
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1cb1a
leaq 0x28(%rsp), %rdi
callq 0x363f2
jmp 0x53b36
movq %rdx, %r14
movq %rax, %rbx
movq %rbx, %rdi
cmpl $0x1, %r14d
jne 0x53b53
callq 0x10190
callq 0x10680
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
callq 0x106f0
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: BinOpNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void BinOpNode::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 << "BINOP : " << op << "\n";
	a->printTree(indent, false);
	b->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 0x62412(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x25036(%rip), %rax     # 0x78bbb
leaq 0x25039(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x25029(%rip), %rax     # 0x78bc2
leaq 0x2502c(%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 0x24ff4(%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 0x6237c(%rip), %rdi     # 0xb5f88
leaq 0x25112(%rip), %rsi     # 0x78d25
callq 0x103b0
leaq 0xa8(%r14), %rsi
movq %rax, %rdi
callq 0x10370
leaq 0x23eef(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
movq 0xc8(%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 0xd8(%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 0x53cd0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x53cd0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x53ccb
movq %rax, %rbx
leaq 0x70(%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: UnOpNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void UnOpNode::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 << "UNOP : " << op << "\n";
	a->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 0x61471(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x24095(%rip), %rax     # 0x78bbb
leaq 0x24098(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x24088(%rip), %rax     # 0x78bc2
leaq 0x2408b(%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 0x24053(%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 0x613db(%rip), %rdi     # 0xb5f88
leaq 0x24196(%rip), %rsi     # 0x78d4a
callq 0x103b0
leaq 0xa8(%r14), %rsi
movq %rax, %rdi
callq 0x10370
leaq 0x22f4e(%rip), %rsi     # 0x77b1d
movq %rax, %rdi
callq 0x103b0
movq 0xc8(%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 0x54c35
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x54c30
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: UnOpNode::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 UnOpNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	auto na = a->fold(consts);
	auto ru = std::make_shared<UnOpNode>(path, op, na, token);
	if (na->isConst())
	{
		object_t newScope(static_cast<hash_ull>(0));
		trace_t stack_trace;
		auto r = ru->genParser()->evaluate(&newScope, stack_trace);
		return std::make_shared<ContainerNode>(path, r, token);
	}

	return ru;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0xc8(%rsi), %rsi
movq (%rsi), %rax
leaq 0x58(%rsp), %r12
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x8(%r14), %r15
leaq 0xa8(%r14), %rdx
addq $0x28, %r14
movq %rsp, %rdi
movq %r15, %rsi
movq %r12, %rcx
movq %r14, %r8
callq 0x595bd
movq 0x58(%rsp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x54d3c
leaq 0x20(%rsp), %rsi
andq $0x0, (%rsi)
leaq 0x48(%rsp), %rdi
callq 0x361aa
andq $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
movq (%rsp), %rsi
movq (%rsi), %rax
leaq 0x10(%rsp), %rdi
callq *(%rax)
movq 0x10(%rsp), %rsi
movq (%rsi), %rax
leaq 0x38(%rsp), %rdi
leaq 0x48(%rsp), %rdx
leaq 0x20(%rsp), %rcx
callq *(%rax)
leaq 0x18(%rsp), %rdi
callq 0x1d786
leaq 0x10(%rsp), %rdi
leaq 0x38(%rsp), %rdx
movq %r15, %rsi
movq %r14, %rcx
callq 0x58a65
leaq 0x18(%rsp), %rdi
movaps -0x8(%rdi), %xmm0
andq $0x0, (%rdi)
movups %xmm0, (%rbx)
andq $0x0, -0x8(%rdi)
callq 0x1d786
leaq 0x38(%rsp), %rdi
callq 0x39102
leaq 0x20(%rsp), %rdi
callq 0x1cb1a
leaq 0x48(%rsp), %rdi
callq 0x363f2
jmp 0x54d4e
movaps (%rsp), %xmm0
andq $0x0, 0x8(%rsp)
movups %xmm0, (%rbx)
andq $0x0, (%rsp)
leaq 0x8(%rsp), %rdi
callq 0x1d786
leaq 0x60(%rsp), %rdi
callq 0x1d786
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x38(%rsp), %rdi
callq 0x39102
jmp 0x54d92
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x1d786
jmp 0x54d92
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x1cb1a
leaq 0x48(%rsp), %rdi
callq 0x363f2
jmp 0x54dad
jmp 0x54daa
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x1d786
jmp 0x54dbc
movq %rax, %rbx
leaq 0x60(%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: ParenNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ParenNode::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 << "PAREN\n";
	a->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 0x61139(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x23d5d(%rip), %rax     # 0x78bbb
leaq 0x23d60(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x23d50(%rip), %rax     # 0x78bc2
leaq 0x23d53(%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 0x23d1b(%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 0x610a3(%rip), %rdi     # 0xb5f88
leaq 0x23e66(%rip), %rsi     # 0x78d52
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 0x54f4f
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x54f4a
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: InsNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void InsNode::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 << "INS\n";
	callee->printTree(indent, false);
	arg->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 0x60ea2(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x23ac6(%rip), %rax     # 0x78bbb
leaq 0x23ac9(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x23ab9(%rip), %rax     # 0x78bc2
leaq 0x23abc(%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 0x23a84(%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 0x60e0c(%rip), %rdi     # 0xb5f88
leaq 0x23bd6(%rip), %rsi     # 0x78d59
callq 0x103b0
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 0x55222
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x55222
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x5521d
movq %rax, %rbx
leaq 0x70(%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: IfElseNode::isConst() const
bool IfElseNode::isConst() const
{
	if (!ifs->isConst())
	{
		return false;
	}
	if (!body->isConst())
	{
		return false;
	}
	if (elses != nullptr && !elses->isConst())
	{
		return false;
	}
	return true;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0xa8(%rdi), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x55930
movq 0xb8(%rbx), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x55930
movq 0xc8(%rbx), %rdi
testq %rdi, %rdi
je 0x5592c
movq (%rdi), %rax
callq *0x8(%rax)
testb %al, %al
je 0x55930
movb $0x1, %al
jmp 0x55932
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: IfElseNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void IfElseNode::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 << "IF_ELSE\n";
	ifs->printTree(indent, false);
	body->printTree(indent, elses == nullptr);
	if (elses != nullptr)
		elses->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 0x60636(%rip), %r15     # 0xb5f88
movq %r15, %rdi
callq 0x10370
leaq 0x2325a(%rip), %rax     # 0x78bbb
leaq 0x2325d(%rip), %rsi     # 0x78bc5
testl %ebp, %ebp
cmovneq %rax, %rsi
leaq 0x2324d(%rip), %rax     # 0x78bc2
leaq 0x23250(%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 0x23215(%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 0x6059a(%rip), %rdi     # 0xb5f88
leaq 0x23369(%rip), %rsi     # 0x78d5e
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 0x55a98
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 0x55ae0
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x55ae0
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
jmp 0x55ae0
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x101d0
jmp 0x55ad8
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: WhileNode::genParser() const
ptr_instruction_t WhileNode::genParser() const
{
	std::vector<ptr_instruction_t> is;
	for (auto &e : this->body)
	{
		is.push_back(e->genParser());
	}

	return std::make_shared<WhileI>(whiles->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 0xb8(%rsi), %rbp
movq 0xc0(%rsi), %rbx
leaq 0x8(%rsp), %r15
movq %rsp, %r13
cmpq %rbx, %rbp
je 0x55e11
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 0x55de7
movq 0xa8(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *(%rax)
addq $0x28, %r14
movq %rsp, %rdi
leaq 0x20(%rsp), %rsi
leaq 0x30(%rsp), %rdx
movq %r14, %rcx
callq 0x596a1
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 0x55e97
jmp 0x55e8c
movq %rax, %rbx
jmp 0x55e9c
movq %rax, %rbx
movq %r15, %rdi
callq 0x1d786
leaq 0x30(%rsp), %rdi
callq 0x58a44
movq %rbx, %rdi
callq 0x106f0