LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: IDNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void IDNode::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 << "ID : " << ROSSA_DEHASH(key) << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x11111d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd3eb6
movq 0x11110b(%rip), %rdi    # 0x1e4fa0
leaq 0x7f8cc(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x7f8c0(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd3edc
movq 0x1110e3(%rip), %rdi    # 0x1e4fa0
leaq 0x7f8ae(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x7f8a2(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd27b0
movq -0xa0(%rbp), %rsi
leaq 0x7f86b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd3f10
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd3f26
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x111061(%rip), %rdi    # 0x1e4fa0
leaq 0x7f860(%rip), %rsi     # 0x1537a6
callq 0x11560
movq -0x90(%rbp), %rdx
movq %rax, -0xb8(%rbp)
addq $0xa8, %rdx
leaq 0x111b31(%rip), %rsi    # 0x1e5a98
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x2d270
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x114e0
movq %rax, -0xa8(%rbp)
jmp 0xd3f96
movq -0xa8(%rbp), %rdi
leaq 0x7e531(%rip), %rsi     # 0x1524d5
callq 0x11560
jmp 0xd3fab
leaq -0x88(%rbp), %rdi
callq 0x11360
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd3fe3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xd4006
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nop
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: BIDNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void BIDNode::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 << "BID : " << key << "\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x78(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x110a53(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd457d
movq 0x110a41(%rip), %rdi    # 0x1e4fa0
leaq 0x7f202(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7f1f9(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd45a0
movq 0x110a1c(%rip), %rdi    # 0x1e4fa0
leaq 0x7f1e7(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7f1de(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x70(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xd27b0
movq -0x80(%rbp), %rsi
leaq 0x7f1b0(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd45cb
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd45e1
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x1109a6(%rip), %rdi    # 0x1e4fa0
leaq 0x7f1a4(%rip), %rsi     # 0x1537a5
callq 0x11560
movq -0x70(%rbp), %rsi
movq %rax, %rdi
addq $0xa8, %rsi
callq 0x114e0
movq %rax, %rdi
leaq 0x7deb2(%rip), %rsi     # 0x1524d5
callq 0x11560
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd4654
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xd5372
jmp 0xd548e
movq -0xb0(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x28(%rbp), %rdi
callq *%rax
movq $0x0, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x7d410
jmp 0xd539c
leaq -0x68(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x24b80
leaq -0x28(%rbp), %rdi
callq 0x2d300
movq -0xc8(%rbp), %rcx
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rdx
callq *%rax
jmp 0xd53d1
movq -0xb0(%rbp), %rcx
movq %rcx, %rsi
addq $0x8, %rsi
addq $0x28, %rcx
leaq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rdx
callq 0xe5670
jmp 0xd53f5
movq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x571a0
leaq -0x88(%rbp), %rdi
callq 0x571d0
leaq -0x78(%rbp), %rdi
callq 0x86dc0
leaq -0x68(%rbp), %rdi
callq 0x24e60
leaq -0x38(%rbp), %rdi
callq 0x7d790
leaq -0x28(%rbp), %rdi
callq 0x2a4e0
jmp 0xd555c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xd5480
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0xd546e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x86dc0
leaq -0x68(%rbp), %rdi
callq 0x24e60
leaq -0x38(%rbp), %rdi
callq 0x7d790
leaq -0x28(%rbp), %rdi
callq 0x2a4e0
jmp 0xd556c
movq -0xb0(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0xd8(%rbp)
addq $0xb0, %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq *%rax
movq -0xb0(%rbp), %r9
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movq -0xd0(%rbp), %rcx
movq %r9, %r8
addq $0xc0, %r8
addq $0x28, %r9
leaq -0x98(%rbp), %rdi
callq 0xe6030
jmp 0xd5515
movq -0xc0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x58340
leaq -0x98(%rbp), %rdi
callq 0x58370
leaq -0xa8(%rbp), %rdi
callq 0x24b20
jmp 0xd555c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x24b20
jmp 0xd556c
movq -0xb8(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xb8(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq 0x10f86d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd5766
movq 0x10f85b(%rip), %rdi    # 0x1e4fa0
leaq 0x7e01c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0xb8(%rbp), %rdi
leaq 0x7e010(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd578c
movq 0x10f833(%rip), %rdi    # 0x1e4fa0
leaq 0x7dffe(%rip), %rsi     # 0x153772
callq 0x11560
movq -0xb8(%rbp), %rdi
leaq 0x7dff2(%rip), %rsi     # 0x153779
callq 0x11540
movq -0xb0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xd27b0
movq -0xc0(%rbp), %rsi
leaq 0x7dfbb(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd57c0
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd57d6
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x10f7b1(%rip), %rdi    # 0x1e4fa0
leaq 0x7dfc0(%rip), %rsi     # 0x1537b6
callq 0x11560
movq -0xb0(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2d030
movq -0xb8(%rbp), %rsi
movq %rax, -0xd0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x11250
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
xorl %edx, %edx
callq *%rax
jmp 0xd584a
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0xb0(%rbp), %rdi
addq $0xb8, %rdi
callq 0x2d030
movq -0xb8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x11250
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xd58a8
leaq -0xa8(%rbp), %rdi
callq 0x11360
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd58e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xd591d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
jmp 0xd591d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x78(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x70(%rbp)
movq 0x10e8e3(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd66ed
movq 0x10e8d1(%rip), %rdi    # 0x1e4fa0
leaq 0x7d092(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7d089(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd6710
movq 0x10e8ac(%rip), %rdi    # 0x1e4fa0
leaq 0x7d077(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x78(%rbp), %rdi
leaq 0x7d06e(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x70(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0xd27b0
movq -0x80(%rbp), %rsi
leaq 0x7d040(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd673b
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd6751
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x10e836(%rip), %rdi    # 0x1e4fa0
leaq 0x7d067(%rip), %rsi     # 0x1537d8
callq 0x11560
movq -0x70(%rbp), %rdi
movq %rax, -0x88(%rbp)
addq $0xa8, %rdi
callq 0x2e4d0
movq -0x88(%rbp), %rdi
movq %rax, %rsi
callq 0x11110
movq %rax, %rdi
leaq 0x7bd2f(%rip), %rsi     # 0x1524d5
callq 0x11560
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd67d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x57390
movq -0x98(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5310
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5340
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xd6f9a
jmp 0xd7014
leaq -0x40(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xd6fc6
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57650
jmp 0xd6fd5
leaq -0x60(%rbp), %rdi
callq 0x24b20
leaq -0x40(%rbp), %rdi
callq 0xe5430
jmp 0xd6f87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xd70cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x24b20
jmp 0xd70cc
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
addq $0xa8, %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
jmp 0xd704e
movq -0xb0(%rbp), %rsi
movq -0x98(%rbp), %r8
addq $0x28, %r8
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xe6860
jmp 0xd7076
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0xe68f0
leaq -0x80(%rbp), %rdi
callq 0x57920
leaq -0x90(%rbp), %rdi
callq 0x24b20
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x24b20
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0x68(%rbp), %rdi
callq 0x119c0
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe52f0
movq -0x90(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5310
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xd7246
jmp 0xd72bb
leaq -0x38(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xd726d
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe5400
jmp 0xd727c
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
leaq -0x38(%rbp), %rdi
callq 0xe5430
jmp 0xd7233
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd7379
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
jmp 0xd7379
movq -0x90(%rbp), %rdx
movq %rdx, %rax
addq $0xa8, %rax
movq %rax, -0xb0(%rbp)
movq %rdx, %rax
addq $0xc8, %rax
movq %rax, -0xa8(%rbp)
addq $0x28, %rdx
leaq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe5520
jmp 0xd72f8
movq -0xa8(%rbp), %rdx
movq -0xb0(%rbp), %rsi
movq -0x90(%rbp), %r8
addq $0x28, %r8
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rcx
callq 0xe6920
jmp 0xd7323
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe69b0
leaq -0x78(%rbp), %rdi
callq 0xe69e0
leaq -0x88(%rbp), %rdi
callq 0xe55d0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0xe55d0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x57390
movq -0x88(%rbp), %rax
addq $0xe8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5310
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5340
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xd76aa
jmp 0xd771e
leaq -0x40(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xd76d6
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57650
jmp 0xd76e5
leaq -0x60(%rbp), %rdi
callq 0x24b20
leaq -0x40(%rbp), %rdi
callq 0xe5430
jmp 0xd7697
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xd7785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x24b20
jmp 0xd7785
movq -0x88(%rbp), %r9
movq %r9, %rsi
addq $0x8, %rsi
movq %r9, %rdx
addq $0xa8, %rdx
movq %r9, %rcx
addq $0xc8, %rcx
addq $0x28, %r9
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %r8
callq 0xe6a00
jmp 0xd7753
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x57a90
leaq -0x80(%rbp), %rdi
callq 0x57ac0
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0x68(%rbp), %rdi
callq 0x119c0
nopw (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: CallBuiltNode::isConst() const
bool CallBuiltNode::isConst() const
{
	for (auto &arg : args)
	{
		if (!arg->isConst())
		{
			return false;
		}
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xb0, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe5310
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe5340
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xd8e77
jmp 0xd8ead
leaq -0x20(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xd8ea0
movb $0x0, -0x1(%rbp)
jmp 0xd8eb1
jmp 0xd8ea2
leaq -0x20(%rbp), %rdi
callq 0xe5430
jmp 0xd8e64
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x10b9ed(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd95e6
movq 0x10b9db(%rip), %rdi    # 0x1e4fa0
leaq 0x7a19c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x7a190(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd960c
movq 0x10b9b3(%rip), %rdi    # 0x1e4fa0
leaq 0x7a17e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x7a172(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd27b0
movq -0xa0(%rbp), %rsi
leaq 0x7a13b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd9640
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd9656
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x10b931(%rip), %rdi    # 0x1e4fa0
leaq 0x7a1de(%rip), %rsi     # 0x153854
callq 0x11560
movq -0x90(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2d030
movq -0x98(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x11250
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xd96cd
leaq -0x88(%rbp), %rdi
callq 0x11360
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd9705
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xd9728
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x10b65d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xd9976
movq 0x10b64b(%rip), %rdi    # 0x1e4fa0
leaq 0x79e0c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x79e00(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xd999c
movq 0x10b623(%rip), %rdi    # 0x1e4fa0
leaq 0x79dee(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x79de2(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd27b0
movq -0xa0(%rbp), %rsi
leaq 0x79dab(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xd99d0
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xd99e6
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x10b5a1(%rip), %rdi    # 0x1e4fa0
leaq 0x79e56(%rip), %rsi     # 0x15385c
callq 0x11560
movq -0x90(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2d030
movq -0x98(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x11250
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xd9a5d
leaq -0x88(%rbp), %rdi
callq 0x11360
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xd9a95
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xd9ab8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0xc8, %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xdc3a5
jmp 0xdc4ac
movq -0x80(%rbp), %rdi
addq $0xd8, %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xdc3c7
jmp 0xdc4ac
movq $0x0, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x7d410
jmp 0xdc3de
leaq -0x50(%rbp), %rdi
callq 0x24b80
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0xdc3f9
leaq -0x70(%rbp), %rdi
callq 0x2d300
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x60(%rbp), %rdi
leaq -0x20(%rbp), %rdx
leaq -0x50(%rbp), %rcx
callq *%rax
jmp 0xdc41b
leaq -0x60(%rbp), %rdi
callq 0x86dc0
leaq -0x70(%rbp), %rdi
callq 0x2a4e0
movb $0x1, -0x1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x24e60
leaq -0x20(%rbp), %rdi
callq 0x7d790
jmp 0xdc4b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xdc488
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0xdc476
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2a4e0
leaq -0x50(%rbp), %rdi
callq 0x24e60
leaq -0x20(%rbp), %rdi
callq 0x7d790
movl -0x34(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0xdc4be
movq -0x30(%rbp), %rdi
callq 0x11220
movq %rax, -0x78(%rbp)
movb $0x0, -0x1(%rbp)
callq 0x11910
jmp 0xdc4b0
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x119c0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xb8(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq 0x108a9d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xdc536
movq 0x108a8b(%rip), %rdi    # 0x1e4fa0
leaq 0x7724c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0xb8(%rbp), %rdi
leaq 0x77240(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xdc55c
movq 0x108a63(%rip), %rdi    # 0x1e4fa0
leaq 0x7722e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0xb8(%rbp), %rdi
leaq 0x77222(%rip), %rsi     # 0x153779
callq 0x11540
movq -0xb0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xd27b0
movq -0xc0(%rbp), %rsi
leaq 0x771eb(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xdc590
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xdc5a6
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x1089e1(%rip), %rdi    # 0x1e4fa0
leaq 0x7730c(%rip), %rsi     # 0x1538d2
callq 0x11560
movq -0xb0(%rbp), %rsi
movq %rax, %rdi
addq $0xa8, %rsi
callq 0x114e0
movq %rax, %rdi
leaq 0x75eea(%rip), %rsi     # 0x1524d5
callq 0x11560
movq -0xb0(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2d030
movq -0xb8(%rbp), %rsi
movq %rax, -0xd0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x11250
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
xorl %edx, %edx
callq *%rax
jmp 0xdc63f
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0xb0(%rbp), %rdi
addq $0xd8, %rdi
callq 0x2d030
movq -0xb8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x11250
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xdc69d
leaq -0xa8(%rbp), %rdi
callq 0x11360
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xdc6d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xdc712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
jmp 0xdc712
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x1069cd(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xde606
movq 0x1069bb(%rip), %rdi    # 0x1e4fa0
leaq 0x7517c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x75170(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xde62c
movq 0x106993(%rip), %rdi    # 0x1e4fa0
leaq 0x7515e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x75152(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd27b0
movq -0xa0(%rbp), %rsi
leaq 0x7511b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xde660
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xde676
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x106911(%rip), %rdi    # 0x1e4fa0
leaq 0x75261(%rip), %rsi     # 0x1538f7
callq 0x11560
movq -0x90(%rbp), %rsi
movq %rax, %rdi
addq $0xa8, %rsi
callq 0x114e0
movq %rax, %rdi
leaq 0x73e1a(%rip), %rsi     # 0x1524d5
callq 0x11560
movq -0x90(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2d030
movq -0x98(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x11250
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xde712
leaq -0x88(%rbp), %rdi
callq 0x11360
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xde74a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xde76d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0x98(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x10649d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xdeb36
movq 0x10648b(%rip), %rdi    # 0x1e4fa0
leaq 0x74c4c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x74c40(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xdeb5c
movq 0x106463(%rip), %rdi    # 0x1e4fa0
leaq 0x74c2e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x74c22(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x90(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0xd27b0
movq -0xa0(%rbp), %rsi
leaq 0x74beb(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xdeb90
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xdeba6
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x1063e1(%rip), %rdi    # 0x1e4fa0
leaq 0x74d39(%rip), %rsi     # 0x1538ff
callq 0x11560
movq -0x90(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2d030
movq -0x98(%rbp), %rsi
movq %rax, -0xb0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x11250
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xdec1d
leaq -0x88(%rbp), %rdi
callq 0x11360
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xdec55
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xdec78
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0xb8(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xb0(%rbp)
movq 0x10603d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xdef96
movq 0x10602b(%rip), %rdi    # 0x1e4fa0
leaq 0x747ec(%rip), %rsi     # 0x153768
callq 0x11560
movq -0xb8(%rbp), %rdi
leaq 0x747e0(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xdefbc
movq 0x106003(%rip), %rdi    # 0x1e4fa0
leaq 0x747ce(%rip), %rsi     # 0x153772
callq 0x11560
movq -0xb8(%rbp), %rdi
leaq 0x747c2(%rip), %rsi     # 0x153779
callq 0x11540
movq -0xb0(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0xd27b0
movq -0xc0(%rbp), %rsi
leaq 0x7478b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xdeff0
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xdf006
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x105f81(%rip), %rdi    # 0x1e4fa0
leaq 0x748e0(%rip), %rsi     # 0x153906
callq 0x11560
movq -0xb0(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2d030
movq -0xb8(%rbp), %rsi
movq %rax, -0xd0(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x11250
movq -0xd0(%rbp), %rdi
movq -0xc8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
xorl %edx, %edx
callq *%rax
jmp 0xdf07a
leaq -0x88(%rbp), %rdi
callq 0x11360
movq -0xb0(%rbp), %rdi
addq $0xb8, %rdi
callq 0x2d030
movq -0xb8(%rbp), %rsi
movq %rax, -0xe0(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x11250
movq -0xe0(%rbp), %rdi
movq -0xd8(%rbp), %rsi
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl $0x1, %edx
callq *%rax
jmp 0xdf0d8
leaq -0xa8(%rbp), %rdi
callq 0x11360
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xdf110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
jmp 0xdf14d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x11360
jmp 0xdf14d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x11360
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0xa8, %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xdfd63
movb $0x0, -0x1(%rbp)
jmp 0xdfdc7
movq -0x18(%rbp), %rdi
addq $0xb8, %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xdfd86
movb $0x0, -0x1(%rbp)
jmp 0xdfdc7
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0xe53d0
testb $0x1, %al
jne 0xdfda0
jmp 0xdfdc3
movq -0x18(%rbp), %rdi
addq $0xc8, %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xdfdc3
movb $0x0, -0x1(%rbp)
jmp 0xdfdc7
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe52f0
movq -0x90(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5310
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xe0596
jmp 0xe060b
leaq -0x38(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xe05bd
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe5400
jmp 0xe05cc
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
leaq -0x38(%rbp), %rdi
callq 0xe5430
jmp 0xe0583
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe06a9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
jmp 0xe06a9
movq -0x90(%rbp), %rdi
addq $0xa8, %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0xe0632
movq -0x90(%rbp), %rcx
addq $0x28, %rcx
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rsi
leaq -0x28(%rbp), %rdx
callq 0xe9600
jmp 0xe0653
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe9680
leaq -0x78(%rbp), %rdi
callq 0xe96b0
leaq -0x88(%rbp), %rdi
callq 0x2a4e0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x98(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2a4e0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: WhileNode::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 WhileNode::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<WhileNode>(path, whiles->fold(consts), nbody, token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x57390
movq -0x98(%rbp), %rax
addq $0xb8, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5310
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5340
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xe0a0a
jmp 0xe0a84
leaq -0x40(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xe0a36
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57650
jmp 0xe0a45
leaq -0x60(%rbp), %rdi
callq 0x24b20
leaq -0x40(%rbp), %rdi
callq 0xe5430
jmp 0xe09f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xe0b3c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x24b20
jmp 0xe0b3c
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xb0(%rbp)
addq $0xa8, %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
jmp 0xe0abe
movq -0xb0(%rbp), %rsi
movq -0x98(%rbp), %r8
addq $0x28, %r8
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rdx
leaq -0x30(%rbp), %rcx
callq 0xe96d0
jmp 0xe0ae6
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x59c70
leaq -0x80(%rbp), %rdi
callq 0x59ca0
leaq -0x90(%rbp), %rdi
callq 0x24b20
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x24b20
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0x68(%rbp), %rdi
callq 0x119c0
nop
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa0(%rbp)
movq %rdi, %rax
movq %rax, -0x98(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe52f0
movq -0x90(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5310
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rdi
callq 0xe5340
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xe0c86
jmp 0xe0cfb
leaq -0x38(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x58(%rbp), %rdi
callq *%rax
jmp 0xe0cad
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe5400
jmp 0xe0cbc
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
leaq -0x38(%rbp), %rdi
callq 0xe5430
jmp 0xe0c73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe0db0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
jmp 0xe0db0
movq -0x90(%rbp), %rdi
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0xa8(%rbp)
addq $0xb0, %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x88(%rbp), %rdi
callq *%rax
jmp 0xe0d32
movq -0xa8(%rbp), %rsi
movq -0x90(%rbp), %r8
addq $0x28, %r8
leaq -0x78(%rbp), %rdi
leaq -0x88(%rbp), %rdx
leaq -0x28(%rbp), %rcx
callq 0xe9760
jmp 0xe0d5a
movq -0xa0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xe97f0
leaq -0x78(%rbp), %rdi
callq 0xe9820
leaq -0x88(%rbp), %rdi
callq 0x2a4e0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x98(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2a4e0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x57390
movq -0x98(%rbp), %rax
addq $0xc0, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5310
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
callq 0xe5340
movq %rax, -0x48(%rbp)
leaq -0x40(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0xe5370
testb $0x1, %al
jne 0xe11aa
jmp 0xe1224
leaq -0x40(%rbp), %rdi
callq 0xe53b0
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x60(%rbp), %rdi
callq *%rax
jmp 0xe11d6
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57650
jmp 0xe11e5
leaq -0x60(%rbp), %rdi
callq 0x24b20
leaq -0x40(%rbp), %rdi
callq 0xe5430
jmp 0xe1197
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xe12f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x24b20
jmp 0xe12f3
movq -0x98(%rbp), %rdi
movq %rdi, %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movq %rdi, %rax
addq $0xa8, %rax
movq %rax, -0xb0(%rbp)
addq $0xb0, %rdi
callq 0x2d030
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq -0x90(%rbp), %rdi
callq *%rax
jmp 0xe126e
movq -0xb0(%rbp), %rdx
movq -0xb8(%rbp), %rsi
movq -0x98(%rbp), %r9
addq $0x28, %r9
leaq -0x80(%rbp), %rdi
leaq -0x90(%rbp), %rcx
leaq -0x30(%rbp), %r8
callq 0xe9840
jmp 0xe129d
movq -0xa8(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x59d60
leaq -0x80(%rbp), %rdi
callq 0x59d90
leaq -0x90(%rbp), %rdi
callq 0x24b20
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0xa0(%rbp), %rax
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x24b20
leaq -0x30(%rbp), %rdi
callq 0x574c0
movq -0x68(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)