LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: MapNode::genParser() const
ptr_instruction_t MapNode::genParser() const
{
	std::map<std::string, ptr_instruction_t> is;
	for (auto &e : this->args)
	{
		is[e.first] = e.second->genParser();
	}
	return std::make_shared<MapI>(is, 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 -0x10(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x40(%rbp), %rdi
callq 0xe9e70
movq -0x98(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
callq 0xe9e90
movq %rax, -0x50(%rbp)
movq -0x48(%rbp), %rdi
callq 0xe9ec0
movq %rax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe9ef0
testb $0x1, %al
jne 0xe1ef9
jmp 0xe1f83
leaq -0x50(%rbp), %rdi
callq 0xe9f30
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
addq $0x20, %rdi
callq 0x2d030
movq %rax, %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x70(%rbp), %rdi
callq *%rax
jmp 0xe1f24
movq -0x60(%rbp), %rsi
leaq -0x40(%rbp), %rdi
callq 0xe9f50
movq %rax, -0xb0(%rbp)
jmp 0xe1f3a
movq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xea030
leaq -0x70(%rbp), %rdi
callq 0x2a4e0
leaq -0x50(%rbp), %rdi
callq 0xea060
jmp 0xe1ee3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0xe1fd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2a4e0
jmp 0xe1fd8
movq -0x98(%rbp), %rdx
addq $0x28, %rdx
leaq -0x90(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xea080
jmp 0xe1fa0
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0xea100
leaq -0x90(%rbp), %rdi
callq 0xea130
leaq -0x40(%rbp), %rdi
callq 0xea150
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0xea150
movq -0x78(%rbp), %rdi
callq 0x119c0
nopw (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: MapNode::isConst() const
bool MapNode::isConst() const
{
	for (auto &c : args)
		if (!c.second->isConst())
			return false;
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
addq $0xa8, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe9e90
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0xe9ec0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xe9ef0
testb $0x1, %al
jne 0xe2037
jmp 0xe2071
leaq -0x20(%rbp), %rdi
callq 0xe9f30
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x2d030
movq %rax, %rdi
movq (%rdi), %rax
callq *0x8(%rax)
testb $0x1, %al
jne 0xe2064
movb $0x0, -0x1(%rbp)
jmp 0xe2075
jmp 0xe2066
leaq -0x20(%rbp), %rdi
callq 0xea060
jmp 0xe2024
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: MapNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void MapNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "MAP\n";
	for (size_t i = 0; i < args.size(); i++)
		args[i].second->printTree(indent, i == args.size() - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa0(%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, -0x98(%rbp)
movq 0x102eed(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xe20e6
movq 0x102edb(%rip), %rdi    # 0x1e4fa0
leaq 0x7169c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0xa0(%rbp), %rdi
leaq 0x71690(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xe210c
movq 0x102eb3(%rip), %rdi    # 0x1e4fa0
leaq 0x7167e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0xa0(%rbp), %rdi
leaq 0x71672(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x98(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xd27b0
movq -0xa8(%rbp), %rsi
leaq 0x7163b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xe2140
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xe2156
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x102e31(%rip), %rdi    # 0x1e4fa0
leaq 0x717b3(%rip), %rsi     # 0x153929
callq 0x11560
movq $0x0, -0x70(%rbp)
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0xa8, %rdi
callq 0x6fe20
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0xe22aa
movq -0x98(%rbp), %rdi
addq $0xa8, %rdi
movq %rdi, -0xd0(%rbp)
movq -0x70(%rbp), %rsi
callq 0xea170
movq %rax, %rdi
addq $0x20, %rdi
callq 0x2d030
movq -0xa0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x11250
movq -0xd0(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x6fe20
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rcx
movq -0xb8(%rbp), %rax
decq %rcx
subq %rcx, %rax
sete %cl
movq (%rdi), %rax
movq 0x10(%rax), %rax
movzbl %cl, %edx
callq *%rax
jmp 0xe2245
leaq -0x90(%rbp), %rdi
callq 0x11360
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xe2183
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe2285
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 0xe22b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x11360
jmp 0xe22b3
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: ThrowNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void ThrowNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "THROW\n";
	throws->printTree(indent, true);
}

// Assembly:
pushq %rbp
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 0x10112d(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xe3ea6
movq 0x10111b(%rip), %rdi    # 0x1e4fa0
leaq 0x6f8dc(%rip), %rsi     # 0x153768
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x6f8d0(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xe3ecc
movq 0x1010f3(%rip), %rdi    # 0x1e4fa0
leaq 0x6f8be(%rip), %rsi     # 0x153772
callq 0x11560
movq -0x98(%rbp), %rdi
leaq 0x6f8b2(%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 0x6f87b(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xe3f00
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xe3f16
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x101071(%rip), %rdi    # 0x1e4fa0
leaq 0x6fa0d(%rip), %rsi     # 0x153943
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 0xe3f8d
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 0xe3fc5
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 0xe3fe8
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: CallOpNode::genParser() const
ptr_instruction_t CallOpNode::genParser() const
{
	std::vector<ptr_instruction_t> fargs;
	for (auto &c : args)
		fargs.push_back(c->genParser());
	return std::make_shared<CallOpI>(id, fargs, token);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x28(%rbp), %rdi
callq 0xe52f0
movq -0x80(%rbp), %rax
addq $0xb0, %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 0xe41d0
jmp 0xe423f
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 0xe41f7
leaq -0x28(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0xe5400
jmp 0xe4206
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
leaq -0x38(%rbp), %rdi
callq 0xe5430
jmp 0xe41bd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe4292
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x2a4e0
jmp 0xe4292
movq -0x80(%rbp), %rcx
movq %rcx, %rsi
addq $0xa8, %rsi
addq $0x28, %rcx
leaq -0x78(%rbp), %rdi
leaq -0x28(%rbp), %rdx
callq 0xeab20
jmp 0xe4260
movq -0x90(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0xeaba0
leaq -0x78(%rbp), %rdi
callq 0xeabd0
leaq -0x28(%rbp), %rdi
callq 0xe55f0
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
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: CallOpNode::printTree(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool) const
void CallOpNode::printTree(std::string indent, bool last) const
{
	std::cout << indent;
	if (last)
	{
		std::cout << "└─";
		indent += "  ";
	}
	else
	{
		std::cout << "├─";
		indent += "│ ";
	}
	printc(deHashVec(path) + " ", RED_TEXT);
	std::cout << "CALL_OP : " << id << "\n";
	for (size_t i = 0; i < args.size(); i++)
		args[i]->printTree(indent, i == args.size() - 1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa0(%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, -0x98(%rbp)
movq 0x100cad(%rip), %rdi    # 0x1e4fa0
callq 0x114e0
testb $0x1, -0x11(%rbp)
je 0xe4326
movq 0x100c9b(%rip), %rdi    # 0x1e4fa0
leaq 0x6f45c(%rip), %rsi     # 0x153768
callq 0x11560
movq -0xa0(%rbp), %rdi
leaq 0x6f450(%rip), %rsi     # 0x15376f
callq 0x11540
jmp 0xe434c
movq 0x100c73(%rip), %rdi    # 0x1e4fa0
leaq 0x6f43e(%rip), %rsi     # 0x153772
callq 0x11560
movq -0xa0(%rbp), %rdi
leaq 0x6f432(%rip), %rsi     # 0x153779
callq 0x11540
movq -0x98(%rbp), %rsi
addq $0x8, %rsi
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0xd27b0
movq -0xa8(%rbp), %rsi
leaq 0x6f3fb(%rip), %rdx     # 0x153770
leaq -0x38(%rbp), %rdi
callq 0x24ec0
jmp 0xe4380
movl $0x1f, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x247f0
jmp 0xe4396
leaq -0x38(%rbp), %rdi
callq 0x11360
leaq -0x58(%rbp), %rdi
callq 0x11360
movq 0x100bf1(%rip), %rdi    # 0x1e4fa0
leaq 0x6f594(%rip), %rsi     # 0x15394a
callq 0x11560
movq %rax, %rdi
movq -0x98(%rbp), %rax
movq 0xa8(%rax), %rsi
callq 0x11110
movq %rax, %rdi
leaq 0x6e0fa(%rip), %rsi     # 0x1524d5
callq 0x11560
movq $0x0, -0x70(%rbp)
movq -0x98(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0xb0(%rbp)
addq $0xb0, %rdi
callq 0x593c0
movq %rax, %rcx
movq -0xb0(%rbp), %rax
cmpq %rcx, %rax
jae 0xe450b
movq -0x98(%rbp), %rdi
addq $0xb0, %rdi
movq %rdi, -0xd0(%rbp)
movq -0x70(%rbp), %rsi
callq 0xe5650
movq %rax, %rdi
callq 0x2d030
movq -0xa0(%rbp), %rsi
movq %rax, -0xc8(%rbp)
leaq -0x90(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x11250
movq -0xd0(%rbp), %rdi
movq -0x70(%rbp), %rax
movq %rax, -0xb8(%rbp)
callq 0x593c0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq %rax, %rcx
movq -0xb8(%rbp), %rax
decq %rcx
subq %rcx, %rax
sete %cl
movq (%rdi), %rax
movq 0x10(%rax), %rax
movzbl %cl, %edx
callq *%rax
jmp 0xe44a6
leaq -0x90(%rbp), %rdi
callq 0x11360
movq -0x70(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x70(%rbp)
jmp 0xe43e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0xe44e6
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 0xe4514
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x11360
jmp 0xe4514
addq $0xd0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x119c0
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/node/node.cpp
// Function: CallOpNode::fold(std::vector<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>, std::allocator<std::pair<std::vector<unsigned long long, std::allocator<unsigned long long>>, symbol_t>>> const&) const
const ptr_node_t CallOpNode::fold(const std::vector<std::pair<std::vector<hash_ull>, symbol_t>> &consts) const
{
	std::vector<ptr_node_t> nargs;
	for (auto &c : args)
		nargs.push_back(c->fold(consts));

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

// Assembly:
pushq %rbp
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 $0xb0, %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 0xe459a
jmp 0xe460e
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 0xe45c6
leaq -0x30(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x57650
jmp 0xe45d5
leaq -0x60(%rbp), %rdi
callq 0x24b20
leaq -0x40(%rbp), %rdi
callq 0xe5430
jmp 0xe4587
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0xe466b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x24b20
jmp 0xe466b
movq -0x88(%rbp), %r8
movq %r8, %rsi
addq $0x8, %rsi
movq %r8, %rdx
addq $0xa8, %rdx
addq $0x28, %r8
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rcx
callq 0xeabf0
jmp 0xe4639
movq -0x98(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x57b70
leaq -0x80(%rbp), %rdi
callq 0x57ba0
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
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: IfThenElseI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t IfThenElseI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const object_t newScope(scope, 0);
	if (ifs->evaluate(&newScope, stack_trace).getBool(&token, stack_trace))
	{
		return body->evaluate(&newScope, stack_trace);
	}
	return elses->evaluate(&newScope, stack_trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x38(%rbp), %rdx
callq 0x7d4e0
movq -0x68(%rbp), %rdi
addq $0x90, %rdi
callq 0x2d300
movq -0x60(%rbp), %rdx
movq %rax, %rsi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x128ed4
movq -0x68(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x881f0
movb %al, -0x79(%rbp)
jmp 0x128eee
leaq -0x48(%rbp), %rdi
callq 0x86dc0
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x128f00
jmp 0x128f57
movq -0x68(%rbp), %rdi
addq $0xa0, %rdi
callq 0x2d300
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdx
callq *%rax
jmp 0x128f29
movl $0x1, -0x58(%rbp)
jmp 0x128f87
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x128f9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x86dc0
jmp 0x128f9d
movq -0x68(%rbp), %rdi
addq $0xb0, %rdi
callq 0x2d300
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdx
callq *%rax
jmp 0x128f80
movl $0x1, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7d790
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x7d790
movq -0x50(%rbp), %rdi
callq 0x119c0
nop
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: IfThenI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t IfThenI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const object_t newScope(scope, 0);
	if (ifs->evaluate(&newScope, stack_trace).getBool(&token, stack_trace))
	{
		return body->evaluate(&newScope, stack_trace);
	}
	return symbol_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq $0x0, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
leaq -0x38(%rbp), %rdx
callq 0x7d4e0
movq -0x68(%rbp), %rdi
addq $0x90, %rdi
callq 0x2d300
movq -0x60(%rbp), %rdx
movq %rax, %rsi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x48(%rbp), %rdi
callq *%rax
jmp 0x129094
movq -0x68(%rbp), %rsi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
leaq -0x48(%rbp), %rdi
callq 0x881f0
movb %al, -0x79(%rbp)
jmp 0x1290ae
leaq -0x48(%rbp), %rdi
callq 0x86dc0
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x1290c0
jmp 0x129117
movq -0x68(%rbp), %rdi
addq $0xa0, %rdi
callq 0x2d300
movq -0x78(%rbp), %rdi
movq %rax, %rsi
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdx
callq *%rax
jmp 0x1290e9
movl $0x1, -0x58(%rbp)
jmp 0x129129
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x12913f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x86dc0
jmp 0x12913f
movq -0x78(%rbp), %rdi
callq 0x86580
jmp 0x129122
movl $0x1, -0x58(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x7d790
movq -0x70(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x7d790
movq -0x50(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: AndI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t AndI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	if (!a->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(false);
	if (b->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(true);
	return symbol_t::Boolean(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x90, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x881f0
movb %al, -0x53(%rbp)
jmp 0x12be4f
movb -0x53(%rbp), %al
xorb $-0x1, %al
movb %al, -0x79(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x86dc0
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x12be69
jmp 0x12be99
movq -0x78(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq -0x3d(%rbp), %rsi
callq 0x86c20
jmp 0x12bf31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x86dc0
jmp 0x12bf3e
movq -0x68(%rbp), %rdi
addq $0xa0, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x68(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x881f0
movb %al, -0x7a(%rbp)
jmp 0x12bee4
leaq -0x50(%rbp), %rdi
callq 0x86dc0
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0x12bef6
jmp 0x12bf20
movq -0x78(%rbp), %rdi
movb $0x1, -0x51(%rbp)
leaq -0x51(%rbp), %rsi
callq 0x86c20
jmp 0x12bf31
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86dc0
jmp 0x12bf3e
movq -0x78(%rbp), %rdi
movb $0x0, -0x52(%rbp)
leaq -0x52(%rbp), %rsi
callq 0x86c20
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x119c0
nopw (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: OrI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t OrI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	if (a->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(true);
	if (b->evaluate(scope, stack_trace).getBool(&token, stack_trace))
		return symbol_t::Boolean(true);
	return symbol_t::Boolean(false);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x90, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq *%rax
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x881f0
movb %al, -0x53(%rbp)
jmp 0x12c01f
leaq -0x30(%rbp), %rdi
callq 0x86dc0
movb -0x53(%rbp), %al
testb $0x1, %al
jne 0x12c031
jmp 0x12c061
movq -0x78(%rbp), %rdi
movb $0x1, -0x3d(%rbp)
leaq -0x3d(%rbp), %rsi
callq 0x86c20
jmp 0x12c0f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x86dc0
jmp 0x12c106
movq -0x68(%rbp), %rdi
addq $0xa0, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq *%rax
movq -0x68(%rbp), %rsi
movq -0x88(%rbp), %rdi
addq $0x8, %rsi
movq -0x20(%rbp), %rdx
callq 0x881f0
movb %al, -0x79(%rbp)
jmp 0x12c0ac
leaq -0x50(%rbp), %rdi
callq 0x86dc0
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0x12c0be
jmp 0x12c0e8
movq -0x78(%rbp), %rdi
movb $0x1, -0x51(%rbp)
leaq -0x51(%rbp), %rsi
callq 0x86c20
jmp 0x12c0f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86dc0
jmp 0x12c106
movq -0x78(%rbp), %rdi
movb $0x0, -0x52(%rbp)
leaq -0x52(%rbp), %rsi
callq 0x86c20
movq -0x70(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x119c0
nop
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: ScopeI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t ScopeI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	for (const ptr_instruction_t &e : children)
	{
		const symbol_t eval = e->evaluate(scope, stack_trace);
		if (eval.getSymbolType() != symbol_t::type_t::ID_CASUAL)
			return eval;
	}
	return symbol_t();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1367a0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x1367d0
movq %rax, -0x38(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x136800
testb $0x1, %al
jne 0x131a21
jmp 0x131abd
leaq -0x30(%rbp), %rdi
callq 0x136840
movq %rax, -0x40(%rbp)
movb $0x0, -0x41(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2d300
movq -0x68(%rbp), %rdi
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
callq *%rax
movq -0x68(%rbp), %rdi
callq 0x879c0
movl %eax, -0x6c(%rbp)
jmp 0x131a60
movl -0x6c(%rbp), %eax
cmpl $0x3, %eax
je 0x131a8c
movb $0x1, -0x41(%rbp)
movl $0x1, -0x58(%rbp)
jmp 0x131a93
movq -0x68(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
callq 0x86dc0
jmp 0x131ad0
movl $0x0, -0x58(%rbp)
testb $0x1, -0x41(%rbp)
jne 0x131aa2
movq -0x68(%rbp), %rdi
callq 0x86dc0
movl -0x58(%rbp), %eax
testl %eax, %eax
je 0x131aad
jmp 0x131aab
jmp 0x131ac6
jmp 0x131aaf
leaq -0x30(%rbp), %rdi
callq 0x136860
jmp 0x131a0b
movq -0x68(%rbp), %rdi
callq 0x86580
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x119c0
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: MapI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t MapI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::map<const std::string, const symbol_t> evals;
	for (auto &&e : children)
	{
		const symbol_t eval = e.second->evaluate(scope, stack_trace);
		if (eval.getValueType() == value_type_enum::NIL)
			continue;
		evals.insert({e.first, eval});
	}
	return symbol_t::Dictionary(evals);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0xe8(%rbp)
movq %rdi, %rax
movq %rax, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8c490
movq -0xd8(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x136a70
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x136aa0
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x136ad0
testb $0x1, %al
jne 0x131be1
jmp 0x131d22
leaq -0x60(%rbp), %rdi
callq 0x136b00
movq %rax, -0x70(%rbp)
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x80(%rbp), %rdi
callq *%rax
jmp 0x131c14
leaq -0x80(%rbp), %rdi
callq 0x883e0
movl %eax, -0xec(%rbp)
jmp 0x131c25
movl -0xec(%rbp), %eax
cmpl $-0x1, %eax
jne 0x131c6d
movl $0x3, -0x90(%rbp)
jmp 0x131cd2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x131d57
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x131d17
movq -0x70(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
leaq -0x80(%rbp), %rdx
callq 0x136b30
jmp 0x131c83
leaq -0x50(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x8c550
movb %dl, -0xf9(%rbp)
movq %rax, -0xf8(%rbp)
jmp 0x131ca2
movb -0xf9(%rbp), %al
movq -0xf8(%rbp), %rcx
movq %rcx, -0xd0(%rbp)
movb %al, -0xc8(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8c5f0
movl $0x0, -0x90(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x86dc0
movl -0x90(%rbp), %eax
testl %eax, %eax
je 0x131ce9
jmp 0x131ce7
jmp 0x131ceb
jmp 0x131ceb
leaq -0x60(%rbp), %rdi
callq 0x136b90
jmp 0x131bcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x8c5f0
leaq -0x80(%rbp), %rdi
callq 0x86dc0
jmp 0x131d57
movq -0xe8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x86d50
jmp 0x131d34
movl $0x1, -0x90(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x8c530
movq -0xe0(%rbp), %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x50(%rbp), %rdi
callq 0x8c530
movq -0x88(%rbp), %rdi
callq 0x119c0
nopl (%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: CharNI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t CharNI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	const std::string evalA = a->evaluate(scope, stack_trace).getString(&token, stack_trace);
	std::vector<symbol_t> nv;
	for (auto &&c : evalA)
		nv.push_back(symbol_t::Number(number_t::Long(c)));
	return symbol_t::Array(nv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
addq $0x90, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x50(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq *%rax
movq -0xe0(%rbp), %rdx
movq -0xd8(%rbp), %rsi
addq $0x8, %rdx
movq -0x20(%rbp), %rcx
leaq -0x40(%rbp), %rdi
callq 0x880d0
jmp 0x132ab2
leaq -0x50(%rbp), %rdi
callq 0x86dc0
leaq -0x78(%rbp), %rdi
callq 0x2cc30
leaq -0x40(%rbp), %rax
movq %rax, -0x80(%rbp)
movq -0x80(%rbp), %rdi
callq 0x11530
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
callq 0x11a30
movq %rax, -0x90(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x9a680
testb $0x1, %al
jne 0x132b08
jmp 0x132be3
leaq -0x88(%rbp), %rdi
callq 0x9a6c0
movq %rax, -0x98(%rbp)
movq -0x98(%rbp), %rax
movsbq (%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x9c540
movl %edx, -0xc8(%rbp)
movq %rax, -0xd0(%rbp)
movl -0xc8(%rbp), %eax
movl %eax, -0xb0(%rbp)
movq -0xd0(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xa8(%rbp), %rdi
leaq -0xb8(%rbp), %rsi
callq 0x86bf0
jmp 0x132b75
leaq -0x78(%rbp), %rdi
leaq -0xa8(%rbp), %rsi
callq 0x2cc50
jmp 0x132b87
leaq -0xa8(%rbp), %rdi
callq 0x86dc0
leaq -0x88(%rbp), %rdi
callq 0x9a6e0
jmp 0x132aec
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x86dc0
jmp 0x132c29
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x132c17
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x86dc0
jmp 0x132c17
movq -0xf0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x86c50
jmp 0x132bf5
leaq -0x78(%rbp), %rdi
callq 0x2cf10
leaq -0x40(%rbp), %rdi
callq 0x11360
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
leaq -0x78(%rbp), %rdi
callq 0x2cf10
leaq -0x40(%rbp), %rdi
callq 0x11360
movq -0x58(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: DeclareVarsI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t DeclareVarsI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	std::vector<symbol_t> newvs;
	for (const hash_ull &k : keys)
		newvs.push_back(scope->createVariable(k, &token));
	return symbol_t::Array(newvs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2cc30
movq -0x70(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2e5d0
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
callq 0x2e600
movq %rax, -0x50(%rbp)
leaq -0x48(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xe4f20
testb $0x1, %al
jne 0x1331b2
jmp 0x133213
leaq -0x48(%rbp), %rdi
callq 0xe4f60
movq -0x70(%rbp), %rdx
movq %rax, -0x58(%rbp)
movq -0x18(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x8, %rdx
callq 0x7de10
movq %rax, -0x88(%rbp)
jmp 0x1331dd
movq -0x88(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2cc50
jmp 0x1331ef
jmp 0x1331f1
leaq -0x48(%rbp), %rdi
callq 0xe4f80
jmp 0x13319f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2cf10
jmp 0x133238
movq -0x80(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x86c50
jmp 0x133222
leaq -0x38(%rbp), %rdi
callq 0x2cf10
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/instruction/instruction.cpp
// Function: BNotI::evaluate(object_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&) const
const symbol_t BNotI::evaluate(const object_t *scope, trace_t &stack_trace) const
{
	return operation::bnot(
		scope,
		a->evaluate(scope, stack_trace),
		&token,
		stack_trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x58(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x90, %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x30(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq *%rax
movq -0x60(%rbp), %rcx
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
addq $0x8, %rcx
movq -0x20(%rbp), %r8
callq 0x14adb0
jmp 0x133799
leaq -0x30(%rbp), %rdi
callq 0x86dc0
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x86dc0
movq -0x38(%rbp), %rdi
callq 0x119c0
nopw (%rax,%rax)
// File: Nallantli[P]Rossa/main/rossa/operation/operation.cpp
// Function: operation::call(object_t const*, std::shared_ptr<Instruction const> const&, std::vector<symbol_t, std::allocator<symbol_t>> const&, token_t const*, std::vector<std::pair<token_t, function_t>, std::allocator<std::pair<token_t, function_t>>>&)
const symbol_t operation::call(const object_t *scope, const ptr_instruction_t &a, const std::vector<symbol_t> &args, const token_t *token, trace_t &stack_trace)
{
	const symbol_t evalA = a->evaluate(scope, stack_trace);

	if (evalA.getValueType() == value_type_enum::OBJECT)
	{
		const auto &o = evalA.getObject(token, stack_trace);
		if (o->hasValue(parser_t::HASH_CALL))
			return o->getVariable(parser_t::HASH_CALL, token, stack_trace).call(args, token, stack_trace);
	}

	return evalA.call(args, token, stack_trace);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2d300
movq %rax, %rsi
movq -0x10(%rbp), %rdx
movq -0x30(%rbp), %rcx
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x40(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq *%rax
movq -0x70(%rbp), %rdi
callq 0x883e0
movl %eax, -0x68(%rbp)
jmp 0x13c380
movl -0x68(%rbp), %eax
cmpl $-0x8, %eax
jne 0x13c444
movq -0x28(%rbp), %rsi
movq -0x30(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x882f0
movq %rax, -0x88(%rbp)
jmp 0x13c3a6
movq -0x88(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x60(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq (%rax), %rdi
leaq 0xa97b1(%rip), %rsi     # 0x1e5b78
callq 0x7dd00
movb %al, -0x89(%rbp)
jmp 0x13c3d4
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x13c3e0
jmp 0x13c442
movq -0x58(%rbp), %rax
movq (%rax), %rdi
movq -0x28(%rbp), %rdx
movq -0x30(%rbp), %rcx
leaq 0xa9782(%rip), %rsi     # 0x1e5b78
callq 0x7ddd0
movq %rax, -0x98(%rbp)
jmp 0x13c404
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
callq 0x89e20
jmp 0x13c422
movl $0x1, -0x64(%rbp)
jmp 0x13c466
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x86dc0
jmp 0x13c47c
jmp 0x13c444
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
leaq -0x40(%rbp), %rsi
callq 0x89e20
jmp 0x13c45f
movl $0x1, -0x64(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x86dc0
movq -0x78(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x119c0
nopw %cs:(%rax,%rax)
// File: pollow[P]MIPSClide/simulator.cpp
// Function: Simulator::run()
void Simulator::run() {
    while (pc < statements.size()) {
        cout << statements[pc] << endl;
        tick();
    }

    for(auto i : reg_name) {
        cout << i.first << " : " << dec << regs[i.second] << endl;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rdi
movq 0x98(%rdi), %rax
movq %rax, -0x68(%rbp)
addq $0x20, %rdi
callq 0x12e30
movq %rax, %rcx
movq -0x68(%rbp), %rax
cmpq %rcx, %rax
jae 0x1116b
movq -0x60(%rbp), %rax
movq %rax, %rdi
addq $0x20, %rdi
movq 0x98(%rax), %rsi
callq 0x12e50
movq %rax, %rsi
movq 0x5fe44(%rip), %rdi     # 0x70f90
callq 0x63f0
movq %rax, %rdi
movq 0x5fe05(%rip), %rsi     # 0x70f60
callq 0x64a0
movq -0x60(%rbp), %rdi
callq 0x11290
jmp 0x11107
leaq 0x6073e(%rip), %rax     # 0x718b0
movq %rax, -0x10(%rbp)
leaq 0x60733(%rip), %rdi     # 0x718b0
callq 0x12e70
movq %rax, -0x18(%rbp)
leaq 0x60723(%rip), %rdi     # 0x718b0
callq 0x12ea0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x12ed0
testb $0x1, %al
jne 0x111ac
jmp 0x11270
leaq -0x18(%rbp), %rdi
callq 0x12f00
movq %rax, %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x12f20
movq -0x78(%rbp), %rsi
movq 0x5fdc0(%rip), %rdi     # 0x70f90
callq 0x63f0
movq %rax, -0x70(%rbp)
jmp 0x111db
movq -0x70(%rbp), %rdi
leaq 0x3df0f(%rip), %rsi     # 0x4f0f5
callq 0x6450
movq %rax, -0x80(%rbp)
jmp 0x111f1
movq -0x80(%rbp), %rdi
leaq 0x1d64(%rip), %rsi      # 0x12f60
callq 0x6160
movq %rax, -0x88(%rbp)
jmp 0x1120a
movq -0x88(%rbp), %rdi
movq -0x60(%rbp), %rax
movl -0x28(%rbp), %ecx
movl 0xc0(%rax,%rcx,4), %esi
callq 0x6790
movq %rax, -0x90(%rbp)
jmp 0x1122d
movq -0x90(%rbp), %rdi
movq 0x5fd25(%rip), %rsi     # 0x70f60
callq 0x64a0
jmp 0x11242
leaq -0x48(%rbp), %rdi
callq 0x12f90
leaq -0x18(%rbp), %rdi
callq 0x12fb0
jmp 0x11196
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x12f90
jmp 0x11279
addq $0x90, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x67c0
nopw %cs:(%rax,%rax)
// File: pollow[P]MIPSClide/simulator.cpp
// Function: Simulator::init()
void Simulator::init() {
    origin.assign(statements.begin(), statements.end());
    split();
    trim();
    format();
    calc_label();
    parse();
    
    memory = new int32_t[300000];
    memset(memory, 0, sizeof(int32_t) * 300000);
    memset(regs, 0, sizeof(int32_t) * 32);
    pc = 0;

    print("plain", cout);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
addq $0xa0, %rax
movq %rax, -0x88(%rbp)
addq $0x20, %rdi
movq %rdi, -0x90(%rbp)
callq 0x13060
movq -0x90(%rbp), %rdi
movq %rax, -0x10(%rbp)
callq 0x13090
movq -0x88(%rbp), %rdi
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x13020
movq -0x78(%rbp), %rdi
callq 0x1c840
movq -0x78(%rbp), %rdi
callq 0x1c650
movq -0x78(%rbp), %rdi
callq 0x1c9e0
movq -0x78(%rbp), %rdi
callq 0x1c3f0
movq -0x78(%rbp), %rdi
callq 0x19e20
movl $0x124f80, %edi         # imm = 0x124F80
movq %rdi, -0x80(%rbp)
callq 0x6040
movq -0x80(%rbp), %rdx
movq %rax, %rcx
movq -0x78(%rbp), %rax
movq %rcx, 0xb8(%rax)
movq 0xb8(%rax), %rdi
xorl %esi, %esi
callq 0x6250
movq -0x78(%rbp), %rax
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movups %xmm0, 0x130(%rax)
movups %xmm0, 0x120(%rax)
movups %xmm0, 0x110(%rax)
movups %xmm0, 0x100(%rax)
movups %xmm0, 0xf0(%rax)
movups %xmm0, 0xe0(%rax)
movups %xmm0, 0xd0(%rax)
movups %xmm0, 0xc0(%rax)
movq $0x0, 0x98(%rax)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x67d0
movq -0x58(%rbp), %rdx
leaq 0x3cbf9(%rip), %rsi     # 0x4f0f9
leaq -0x38(%rbp), %rdi
callq 0x6600
jmp 0x1250b
movq -0x78(%rbp), %rdi
movq 0x5ea7a(%rip), %rdx     # 0x70f90
leaq -0x38(%rbp), %rsi
callq 0x1ce10
jmp 0x12521
leaq -0x38(%rbp), %rdi
callq 0x62b0
leaq -0x39(%rbp), %rdi
callq 0x64c0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1255f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x62b0
leaq -0x39(%rbp), %rdi
callq 0x64c0
movq -0x48(%rbp), %rdi
callq 0x67c0
nopw %cs:(%rax,%rax)
// File: ksherlock[P]wdc-utils/link.cpp
// Function: reserve_symbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, bool)
symbol &reserve_symbol(const std::string &name, bool open = true) {

	auto iter = symbol_map.find(name);
	if (iter != symbol_map.end()) return symbols[iter->second];

	if (open) undefined_symbols.emplace(name);
	else undefined_symbols.erase(name);

	symbols.emplace_back();
	auto &sym = symbols.back();

	sym.name = name;
	sym.type = S_UND;
	sym.section = symbols.size() - 1;

	symbol_map.emplace(name, sym.section);

	return sym;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rsi
leaq 0x395d9(%rip), %rdi     # 0x3f3f8
callq 0xa1e0
movq %rax, -0x20(%rbp)
leaq 0x395c9(%rip), %rdi     # 0x3f3f8
callq 0xa240
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xbfa0
testb $0x1, %al
jne 0x5e4b
jmp 0x5e6d
leaq -0x20(%rbp), %rdi
callq 0xa500
movslq 0x20(%rax), %rsi
leaq 0x395d1(%rip), %rdi     # 0x3f430
callq 0x9fb0
movq %rax, -0x8(%rbp)
jmp 0x5f0d
testb $0x1, -0x11(%rbp)
je 0x5e8c
movq -0x10(%rbp), %rsi
leaq 0x395ca(%rip), %rdi     # 0x3f448
callq 0xbfd0
movq %rax, -0x38(%rbp)
movb %dl, -0x30(%rbp)
jmp 0x5e9c
movq -0x10(%rbp), %rsi
leaq 0x395b1(%rip), %rdi     # 0x3f448
callq 0xa770
leaq 0x3958d(%rip), %rdi     # 0x3f430
callq 0xc020
leaq 0x39581(%rip), %rdi     # 0x3f430
callq 0xc090
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3040
movq -0x40(%rbp), %rax
movb $0x0, 0x20(%rax)
leaq 0x3955c(%rip), %rdi     # 0x3f430
callq 0xa400
subq $0x1, %rax
movl %eax, %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x10(%rbp), %rsi
movq -0x40(%rbp), %rdx
addq $0x28, %rdx
leaq 0x394ff(%rip), %rdi     # 0x3f3f8
callq 0xc0d0
movq %rax, -0x50(%rbp)
movb %dl, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: ksherlock[P]wdc-utils/link.cpp
// Function: generate_end()
void generate_end() {

/*
	const std::string names[] = {
			"_END_PAGE0",
			"_END_CODE",
			"_END_KDATA"
			"_END_DATA"
			"_END_UDATA"	
	};
*/
	/*
	for (int i = 0; i < 5; ++i) {
		symbol s;
		s.section = i;
		s.type = S_REL;
		s.flags = SF_DEF | SF_GBL;
		s.offset = sections[i].size; // data.size() doesn't word w/ ref_only

		symbols[i * 2 + 1] = s;
	}

	*/

	for (const auto &s : sections) {

		// if there is an undefined symbol matching the section name, add it.
		if ((s.flags & SEC_NONAME) == 0) {

			auto iter = symbol_map.find(s.name);
			if (iter != symbol_map.end()) {

				symbol &sym = symbols[iter->second];
				if (sym.type == S_UND) {
					undefined_symbols.erase(s.name);
					sym.section = s.number;
					sym.type = S_REL;
					sym.flags = SF_DEF | SF_GBL;
					sym.offset = 0;
				}
			}
		}


		if (s.end_symbol) {

			symbol &sym = symbols[s.end_symbol];

			sym.section = s.number;
			sym.type = S_REL;
			sym.flags = SF_DEF | SF_GBL;
			sym.offset = s.size;
		}
	}


}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
leaq 0x394b1(%rip), %rax     # 0x3f3e0
movq %rax, -0x8(%rbp)
leaq 0x394a6(%rip), %rdi     # 0x3f3e0
callq 0x9d70
movq %rax, -0x10(%rbp)
leaq 0x39496(%rip), %rdi     # 0x3f3e0
callq 0x9da0
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9dd0
testb $0x1, %al
jne 0x5f69
jmp 0x6087
leaq -0x10(%rbp), %rdi
callq 0x9e10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movzbl 0x20(%rax), %eax
andl $0x40, %eax
cmpl $0x0, %eax
jne 0x6028
movq -0x20(%rbp), %rsi
leaq 0x39463(%rip), %rdi     # 0x3f3f8
callq 0xa1e0
movq %rax, -0x28(%rbp)
leaq 0x39453(%rip), %rdi     # 0x3f3f8
callq 0xa240
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xbfa0
testb $0x1, %al
jne 0x5fc1
jmp 0x6026
leaq -0x28(%rbp), %rdi
callq 0xa500
movslq 0x20(%rax), %rsi
leaq 0x3945b(%rip), %rdi     # 0x3f430
callq 0x9fb0
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movzbl 0x20(%rax), %eax
cmpl $0x0, %eax
jne 0x6024
movq -0x20(%rbp), %rsi
leaq 0x39452(%rip), %rdi     # 0x3f448
callq 0xa770
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x38(%rbp), %rax
movb $0x2, 0x20(%rax)
movq -0x38(%rbp), %rax
movb $0x3, 0x21(%rax)
movq -0x38(%rbp), %rax
movl $0x0, 0x24(%rax)
jmp 0x6026
jmp 0x6028
movq -0x20(%rbp), %rax
cmpl $0x0, 0x60(%rax)
je 0x6077
movq -0x20(%rbp), %rax
movl 0x60(%rax), %eax
movl %eax, %esi
leaq 0x393ee(%rip), %rdi     # 0x3f430
callq 0x9fb0
movq %rax, -0x40(%rbp)
movq -0x20(%rbp), %rax
movl 0x2c(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x28(%rax)
movq -0x40(%rbp), %rax
movb $0x2, 0x20(%rax)
movq -0x40(%rbp), %rax
movb $0x3, 0x21(%rax)
movq -0x20(%rbp), %rax
movl 0x28(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, 0x24(%rax)
jmp 0x6079
leaq -0x10(%rbp), %rdi
callq 0xa070
jmp 0x5f53
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)