LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: dadocolussi[P]gdc-nanomap/demo/demo.cpp
// Function: run_um(std::unordered_map<int, int, std::hash<int>, std::equal_to<int>, std::allocator<std::pair<int const, int>>>&, std::vector<int, std::allocator<int>> const&)
void
run_um(um& needles, const std::vector<int>& haystack)
{
	for (auto hit = haystack.cbegin(); hit != haystack.cend(); ++hit)
	{
		auto nit = needles.find(*hit);
		
		if (nit != needles.end())
		{
			++(nit->second);
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1ac0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1b30
movq %rax, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
leaq 0x18(%rsp), %rsi
callq 0x1af0
testb $0x1, %al
jne 0x1341
jmp 0x13ad
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
leaq 0x20(%rsp), %rdi
callq 0x1b90
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x1b60
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1bc0
movq %rax, 0x8(%rsp)
leaq 0x10(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1ba0
testb $0x1, %al
jne 0x1389
jmp 0x139c
leaq 0x10(%rsp), %rdi
callq 0x1bf0
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
jmp 0x139e
leaq 0x20(%rsp), %rdi
callq 0x1c10
jmp 0x131d
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: dadocolussi[P]gdc-nanomap/demo/demo.cpp
// Function: run_nm(gdc::nanomap<int, int, std::equal_to<int>>&, std::vector<int, std::allocator<int>> const&)
void
run_nm(nm& needles, const std::vector<int>& haystack)
{
	for (auto hit = haystack.cbegin(); hit != haystack.cend(); ++hit)
	{
		auto nit = needles.find(*hit);
		
		if (nit != needles.end())
		{
			++(nit.value());
		}
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1ac0
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1b30
movq %rax, 0x28(%rsp)
leaq 0x30(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x1af0
testb $0x1, %al
jne 0x1401
jmp 0x146b
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rdi
callq 0x1b90
movq (%rsp), %rsi
movq %rax, %rdx
leaq 0x18(%rsp), %rdi
callq 0x1c30
movq 0x40(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x1cf0
leaq 0x18(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x1c80
testb $0x1, %al
jne 0x1449
jmp 0x145a
leaq 0x18(%rsp), %rdi
callq 0x1d40
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x145c
leaq 0x30(%rsp), %rdi
callq 0x1c10
jmp 0x13dd
addq $0x48, %rsp
retq
// File: RuiDGPires[P]CrimLang/src/ast.cpp
// Function: crl::Node::~Node()
Node::~Node(){
	size_t size = this->children.size();
	for (size_t i = 0; i < size; i++)
		if (this->children[i] != NULL)
			delete this->children[i];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x351c5(%rip), %rax     # 0x39be0
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x10, %rdi
callq 0x51d0
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x4a92
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x51f0
cmpq $0x0, (%rax)
je 0x4a82
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
movq -0x18(%rbp), %rsi
callq 0x51f0
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x4a80
movq -0x28(%rbp), %rdi
movq (%rdi), %rax
callq *0x8(%rax)
jmp 0x4a82
jmp 0x4a84
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x4a37
movq -0x20(%rbp), %rdi
addq $0x30, %rdi
callq 0x41e0
movq -0x20(%rbp), %rdi
addq $0x10, %rdi
callq 0x5210
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/context.cpp
// Function: Context::seek(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Context::Item Context::seek(std::string name){
	if (!this->table.count(name))
		if (parent != NULL)
			return parent->seek(name);
		else 
			return Context::Item();
	else
		return this->table.at(name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rsi, %rax
movq -0x68(%rbp), %rsi
movq %rdi, -0x60(%rbp)
movq %rdi, %rcx
movq %rcx, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x8, %rdi
callq 0x6bd0
cmpq $0x0, %rax
jne 0x68da
movq -0x50(%rbp), %rax
cmpq $0x0, (%rax)
je 0x68cf
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x78(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4150
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x6830
jmp 0x68ad
leaq -0x38(%rbp), %rdi
callq 0x41e0
jmp 0x68f7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41e0
jmp 0x6904
movq -0x60(%rbp), %rdi
callq 0x6c30
jmp 0x68f7
movq -0x68(%rbp), %rsi
movq -0x50(%rbp), %rdi
addq $0x8, %rdi
callq 0x6c90
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x6d30
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/exceptions.cpp
// Function: crl::CL_Exception::CL_Exception(int, int)
CL_Exception::CL_Exception(int line, int column){
		this->line = line;
		this->column = column;
		this->name = "CrimLang Exception";
		this->msg = "";
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
callq 0x91d0
movq -0x30(%rbp), %rdi
leaq 0x30e5e(%rip), %rax     # 0x39ca8
movq %rax, (%rdi)
addq $0x8, %rdi
movq %rdi, -0x28(%rbp)
callq 0x4450
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x38(%rbp)
callq 0x4450
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rdi
movl -0xc(%rbp), %ecx
movl %ecx, 0x48(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0x4c(%rax)
leaq 0x222bb(%rip), %rsi     # 0x2b141
callq 0x4440
jmp 0x8e8d
movq -0x30(%rbp), %rdi
addq $0x28, %rdi
leaq 0x22648(%rip), %rsi     # 0x2b4e4
callq 0x4440
jmp 0x8ea3
addq $0x40, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x41e0
movq -0x28(%rbp), %rdi
callq 0x41e0
movq -0x30(%rbp), %rdi
callq 0x45b0
movq -0x18(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: size_of(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
static u32 size_of(std::string type){
	if (type == "void")
		return 0;
	else if (type == "i32" || type == "u32" || type == "f32" || type == "char")
		return 1;
	else if (type == "i64" || type == "u64" || type == "f64")
		return 2;	
	else ASSERT(false, "Unkown type: " + type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x1da47(%rip), %rsi     # 0x2b68e
callq 0x66e0
testb $0x1, %al
jne 0xdc52
jmp 0xdc5e
movl $0x0, -0x4(%rbp)
jmp 0xdd97
movq -0x48(%rbp), %rdi
leaq 0x1d665(%rip), %rsi     # 0x2b2ce
callq 0x66e0
testb $0x1, %al
jne 0xdcb0
movq -0x48(%rbp), %rdi
leaq 0x1da16(%rip), %rsi     # 0x2b693
callq 0x66e0
testb $0x1, %al
jne 0xdcb0
movq -0x48(%rbp), %rdi
leaq 0x1da06(%rip), %rsi     # 0x2b697
callq 0x66e0
testb $0x1, %al
jne 0xdcb0
movq -0x48(%rbp), %rdi
leaq 0x1d9f6(%rip), %rsi     # 0x2b69b
callq 0x66e0
testb $0x1, %al
jne 0xdcb0
jmp 0xdcbc
movl $0x1, -0x4(%rbp)
jmp 0xdd97
movq -0x48(%rbp), %rdi
leaq 0x1d9d9(%rip), %rsi     # 0x2b6a0
callq 0x66e0
testb $0x1, %al
jne 0xdcfa
movq -0x48(%rbp), %rdi
leaq 0x1d9c9(%rip), %rsi     # 0x2b6a4
callq 0x66e0
testb $0x1, %al
jne 0xdcfa
movq -0x48(%rbp), %rdi
leaq 0x1d9b9(%rip), %rsi     # 0x2b6a8
callq 0x66e0
testb $0x1, %al
jne 0xdcfa
jmp 0xdd06
movl $0x2, -0x4(%rbp)
jmp 0xdd97
movb $0x1, -0x3d(%rbp)
movl $0x50, %edi
callq 0x4190
movq -0x48(%rbp), %rdx
movq %rax, -0x50(%rbp)
leaq 0x1d989(%rip), %rsi     # 0x2b6ac
leaq -0x30(%rbp), %rdi
callq 0x5410
jmp 0xdd2e
movq -0x50(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq -0x30(%rbp), %rcx
movl %edx, %esi
callq 0x9140
jmp 0xdd44
movq -0x50(%rbp), %rdi
movb $0x0, -0x3d(%rbp)
leaq 0x2c02d(%rip), %rsi     # 0x39d80
leaq -0x4a4a(%rip), %rdx     # 0x9310
callq 0x4550
jmp 0xdda9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xdd84
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x41e0
testb $0x1, -0x3d(%rbp)
jne 0xdd8c
jmp 0xdd95
movq -0x50(%rbp), %rdi
callq 0x4230
jmp 0xdda0
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: gc_Tracker::block(crl::Node*)
void _gc_Tracker::block(crl::Node *node){
	size_t s = symb_tracker.check();

	size_t size = node->children.size();
	for (size_t i = 0; i < size; i++)
		parse_node(node->get_child(i), stream_funcs);

	symb_tracker.clean(s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
addq $0x530, %rdi            # imm = 0x530
callq 0x135a0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x51d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0xf8bf
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl %eax, %esi
movq (%rdi), %rax
callq *0x18(%rax)
movq -0x30(%rbp), %rdi
movq %rax, %rsi
movq %rdi, %rdx
addq $0x318, %rdx            # imm = 0x318
callq 0xfa40
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0xf881
movq -0x30(%rbp), %rdi
addq $0x530, %rdi            # imm = 0x530
movq -0x18(%rbp), %rax
movl %eax, %esi
callq 0x135c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: gc_Tracker::return_(crl::Node*)
void _gc_Tracker::return_(crl::Node *node){
	if (node->children.size() > 0){
		this->expression(node->get_child(0), stream_funcs);
		stream_funcs << 
			"POP R1\n" <<
			"STORE m[RF] R1\n";
	}

	stream_funcs << 
		"JMP " << current_func_name << "-end\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x51d0
cmpq $0x0, %rax
jbe 0xf957
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
xorl %esi, %esi
callq *0x18(%rax)
movq -0x18(%rbp), %rdi
movq %rax, %rsi
movq %rdi, %rdx
addq $0x318, %rdx            # imm = 0x318
callq 0xd440
movq -0x18(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
addq $0x10, %rdi
leaq 0x1bbba(%rip), %rsi     # 0x2b4fd
callq 0x42e0
movq %rax, %rdi
leaq 0x1bbb3(%rip), %rsi     # 0x2b505
callq 0x42e0
movq -0x18(%rbp), %rdi
addq $0x318, %rdi            # imm = 0x318
addq $0x10, %rdi
leaq 0x1bba8(%rip), %rsi     # 0x2b515
callq 0x42e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x4a0, %rsi            # imm = 0x4A0
callq 0x42c0
movq %rax, %rdi
leaq 0x1bb8b(%rip), %rsi     # 0x2b51a
callq 0x42e0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: gc_Tracker::program(crl::Node*)
void _gc_Tracker::program(crl::Node *node){
	*(this->file) << 
		";-----HEADER-----\n"<< 
		"_start:\n";


	for (crl::Node *child : node->children)
		this->parse_node(child);

	*(this->file) << stream_defines.str();
	*(this->file) << 
		"\n;---GLOBAL-INITS---\n";

	*(this->file) << stream_global_vars.str();
	*(this->file) << "PSH R0\n" << "JMP main\n";
	*(this->file) << "END\n";
	*(this->file) << 
		";--END-OF-HEADER-\n";

	*(this->file) << stream_funcs.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq (%rax), %rdi
leaq 0x18c35(%rip), %rsi     # 0x2b5fd
callq 0x42e0
movq %rax, %rdi
leaq 0x18c39(%rip), %rsi     # 0x2b610
callq 0x42e0
movq -0x10(%rbp), %rax
addq $0x10, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6070
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x5f00
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x139f0
testb $0x1, %al
jne 0x12a15
jmp 0x12a40
leaq -0x20(%rbp), %rdi
callq 0x13a30
movq -0xa8(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rsi
callq 0x12630
leaq -0x20(%rbp), %rdi
callq 0x13a50
jmp 0x12a02
movq -0xa8(%rbp), %rsi
movq (%rsi), %rax
movq %rax, -0xb8(%rbp)
addq $0x8, %rsi
leaq -0x50(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x42d0
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x42c0
jmp 0x12a7a
leaq -0x50(%rbp), %rdi
callq 0x41e0
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
leaq 0x18b85(%rip), %rsi     # 0x2b619
callq 0x42e0
movq -0xa8(%rbp), %rsi
movq (%rsi), %rax
movq %rax, -0xc8(%rbp)
addq $0x190, %rsi            # imm = 0x190
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x42d0
movq -0xc8(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x42c0
jmp 0x12ad6
leaq -0x80(%rbp), %rdi
callq 0x41e0
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
leaq 0x18b3f(%rip), %rsi     # 0x2b62f
callq 0x42e0
movq %rax, %rdi
leaq 0x18b38(%rip), %rsi     # 0x2b637
callq 0x42e0
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
leaq 0x18b2c(%rip), %rsi     # 0x2b641
callq 0x42e0
movq -0xa8(%rbp), %rax
movq (%rax), %rdi
leaq 0x18b1b(%rip), %rsi     # 0x2b646
callq 0x42e0
movq -0xa8(%rbp), %rsi
movq (%rsi), %rax
movq %rax, -0xd8(%rbp)
addq $0x318, %rsi            # imm = 0x318
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x42d0
movq -0xd8(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0x42c0
jmp 0x12b70
leaq -0xa0(%rbp), %rdi
callq 0x41e0
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x41e0
jmp 0x12bcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x41e0
jmp 0x12bcb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x41e0
movq -0x58(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: RegTracker::alloc()
int alloc(){
			size_t size = regs.size();
			for (size_t i = 0; i < size; i++) if (!regs[i]){
				regs[i] = true; return i;
			}
			ASSERT(false, "Unable to alloc register");
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x13c80
movq %rax, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
jae 0x12f78
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d00
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x13d60
xorb $-0x1, %al
testb $0x1, %al
jne 0x12f38
jmp 0x12f68
movq -0x78(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x13d00
movq %rax, -0x38(%rbp)
movq %rdx, -0x30(%rbp)
leaq -0x38(%rbp), %rdi
movl $0x1, %esi
callq 0x13d90
movq -0x18(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
jmp 0x12f6a
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x12f08
movb $0x1, -0x6d(%rbp)
movl $0x50, %edi
callq 0x4190
movq %rax, -0x88(%rbp)
leaq -0x59(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x4590
movq -0x80(%rbp), %rdx
leaq 0x186ce(%rip), %rsi     # 0x2b673
leaq -0x58(%rbp), %rdi
callq 0x52e0
jmp 0x12fb0
movq -0x88(%rbp), %rdi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
leaq -0x58(%rbp), %rcx
movl %edx, %esi
callq 0x9140
jmp 0x12fc9
movq -0x88(%rbp), %rdi
movb $0x0, -0x6d(%rbp)
leaq 0x26da5(%rip), %rsi     # 0x39d80
leaq -0x9cd2(%rip), %rdx     # 0x9310
callq 0x4550
jmp 0x13034
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
jmp 0x1300c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x41e0
leaq -0x59(%rbp), %rdi
callq 0x4360
testb $0x1, -0x6d(%rbp)
jne 0x1301d
jmp 0x13029
movq -0x88(%rbp), %rdi
callq 0x4230
jmp 0x1302b
movq -0x68(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
nop
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: SymbTracker::global_create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int)
u32 global_create(std::string name, u32 size){
			this->global_table.insert(std::pair(name, static_mem_pointer));	 // Add to the global table
			u32 res = this->static_mem_pointer;
			this->static_mem_pointer += size;
			return res;
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdx
movq %rdx, -0x88(%rbp)
addq $0x78, %rdx
leaq -0x40(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x14ef0
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x14eb0
movb %dl, -0x71(%rbp)
movq %rax, -0x70(%rbp)
jmp 0x132cb
movb -0x71(%rbp), %al
movq -0x70(%rbp), %rcx
movq %rcx, -0x60(%rbp)
movb %al, -0x58(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x14f30
movq -0x88(%rbp), %rax
movl 0x78(%rax), %ecx
movl %ecx, -0x64(%rbp)
movl -0x14(%rbp), %ecx
addl 0x78(%rax), %ecx
movl %ecx, 0x78(%rax)
movl -0x64(%rbp), %eax
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x14f30
movq -0x48(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: SymbTracker::arg_create(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int, bool)
void arg_create(std::string name, u32 size, bool is_pointer){
			if (this->local_table.count(name) == 0) this->local_table.insert(std::pair(name, std::list<std::pair<u32, bool>>()));
			frame_offset += size;
			this->local_table.at(name).push_front(std::pair(frame_offset, is_pointer));
			local_names.push_front(name);
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rsi, -0xa8(%rbp)
movb %cl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
addq $0x30, %rdi
callq 0x141b0
cmpq $0x0, %rax
jne 0x134a7
movq -0xa0(%rbp), %rax
addq $0x30, %rax
movq %rax, -0xb8(%rbp)
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
movq $0x0, -0x60(%rbp)
leaq -0x70(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x157d0
movq -0xa8(%rbp), %rsi
movq -0xb0(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x157f0
jmp 0x1342c
movq -0xb8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x15790
movb %dl, -0xc1(%rbp)
movq %rax, -0xc0(%rbp)
jmp 0x1344b
movb -0xc1(%rbp), %al
movq -0xc0(%rbp), %rcx
movq %rcx, -0x90(%rbp)
movb %al, -0x88(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x15830
leaq -0x70(%rbp), %rdi
callq 0x15860
jmp 0x134a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x1349c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x15830
leaq -0x70(%rbp), %rdi
callq 0x15860
jmp 0x13525
movq -0xa8(%rbp), %rsi
movq -0xa0(%rbp), %rdi
movl -0x14(%rbp), %eax
addl 0x80(%rdi), %eax
movl %eax, 0x80(%rdi)
addq $0x30, %rdi
callq 0x14210
movq -0xa0(%rbp), %rsi
movq %rax, -0xd0(%rbp)
addq $0x80, %rsi
leaq -0x98(%rbp), %rdi
leaq -0x15(%rbp), %rdx
callq 0x158c0
movq -0xd0(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x15880
movq -0xa0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
addq $0x60, %rdi
callq 0x158f0
addq $0xd0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x4580
nop
// File: RuiDGPires[P]CrimLang/src/generator.cpp
// Function: SymbTracker::clean(unsigned int)
void clean(u32 local_size){
			size_t size = local_names.size();
			for (; size > local_size; size--){
				std::string name = local_names.front();
				local_names.pop_front();

				local_table.at(name).pop_front();
			}
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
addq $0x60, %rdi
callq 0x16c80
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
cmpq %rcx, %rax
jbe 0x13668
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x68(%rbp)
callq 0x16cf0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4150
movq -0x68(%rbp), %rdi
callq 0x16d20
movq -0x50(%rbp), %rdi
movq -0x60(%rbp), %rsi
addq $0x30, %rdi
callq 0x14210
movq %rax, -0x58(%rbp)
jmp 0x13631
movq -0x58(%rbp), %rdi
callq 0x16d50
leaq -0x38(%rbp), %rdi
callq 0x41e0
movq -0x18(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x135e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x41e0
jmp 0x1366e
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopw (%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::accept(crl::Token::Type)
bool _ps_Tracker::accept(crl::Token::Type t){
	bool res = t == this->current.type;
	if (res)
			this->next();
		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movl -0xc(%rbp), %eax
cmpl 0x58(%rcx), %eax
sete %al
andb $0x1, %al
movb %al, -0xd(%rbp)
testb $0x1, -0xd(%rbp)
je 0x18d54
movq -0x18(%rbp), %rdi
callq 0x18c60
movb -0xd(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nop
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::accept(int, ...)
bool _ps_Tracker::accept(int n, ...){
		va_list args;
		va_start(args, n);
		bool res = false;
		while(n > 0){
			int t = va_arg(args, int);
			if ((int) this->current.type == t){
				res = true;
				break;
			}
			n--;
		}
		va_end(args);
		if (res)
			this->next();
		return res;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x110, %rsp            # imm = 0x110
testb %al, %al
je 0x18d9b
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r9, -0xc8(%rbp)
movq %r8, -0xd0(%rbp)
movq %rcx, -0xd8(%rbp)
movq %rdx, -0xe0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xf8(%rbp)
leaq -0x30(%rbp), %rax
leaq -0xf0(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movb $0x0, -0x31(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x18e82
leaq -0x30(%rbp), %rax
movq %rax, -0x108(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0xfc(%rbp)
cmpl $0x28, %eax
ja 0x18e36
movq -0x108(%rbp), %rcx
movl -0xfc(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x110(%rbp)
jmp 0x18e53
movq -0x108(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x110(%rbp)
movq -0xf8(%rbp), %rax
movq -0x110(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x38(%rbp)
movl 0x58(%rax), %eax
cmpl -0x38(%rbp), %eax
jne 0x18e74
movb $0x1, -0x31(%rbp)
jmp 0x18e82
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18df1
leaq -0x30(%rbp), %rax
testb $0x1, -0x31(%rbp)
je 0x18e98
movq -0xf8(%rbp), %rdi
callq 0x18c60
movb -0x31(%rbp), %al
andb $0x1, %al
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::expect(int, ...)
void _ps_Tracker::expect(int n, ...){
		va_list args;
		va_start(args, n);
		bool res = false;
		while(n > 0){
			int t = va_arg(args, int);
			if ((int) this->current.type == t){
				res = true;
				break;
			}
			n--;
		}
		va_end(args);
		if (!res) throw crl::UnexpectedToken(this->current); 
		this->next();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
testb %al, %al
je 0x18f7e
movaps %xmm0, -0xd0(%rbp)
movaps %xmm1, -0xc0(%rbp)
movaps %xmm2, -0xb0(%rbp)
movaps %xmm3, -0xa0(%rbp)
movaps %xmm4, -0x90(%rbp)
movaps %xmm5, -0x80(%rbp)
movaps %xmm6, -0x70(%rbp)
movaps %xmm7, -0x60(%rbp)
movq %r9, -0xd8(%rbp)
movq %r8, -0xe0(%rbp)
movq %rcx, -0xe8(%rbp)
movq %rdx, -0xf0(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x108(%rbp)
leaq -0x30(%rbp), %rax
leaq -0x100(%rbp), %rcx
movq %rcx, 0x10(%rax)
leaq 0x10(%rbp), %rcx
movq %rcx, 0x8(%rax)
movl $0x30, 0x4(%rax)
movl $0x10, (%rax)
movb $0x0, -0x31(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x19065
leaq -0x30(%rbp), %rax
movq %rax, -0x118(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x10c(%rbp)
cmpl $0x28, %eax
ja 0x19019
movq -0x118(%rbp), %rcx
movl -0x10c(%rbp), %edx
movslq %edx, %rax
addq 0x10(%rcx), %rax
addl $0x8, %edx
movl %edx, (%rcx)
movq %rax, -0x120(%rbp)
jmp 0x19036
movq -0x118(%rbp), %rcx
movq 0x8(%rcx), %rax
movq %rax, %rdx
addq $0x8, %rdx
movq %rdx, 0x8(%rcx)
movq %rax, -0x120(%rbp)
movq -0x108(%rbp), %rax
movq -0x120(%rbp), %rcx
movl (%rcx), %ecx
movl %ecx, -0x38(%rbp)
movl 0x58(%rax), %eax
cmpl -0x38(%rbp), %eax
jne 0x19057
movb $0x1, -0x31(%rbp)
jmp 0x19065
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x18fd4
leaq -0x30(%rbp), %rax
testb $0x1, -0x31(%rbp)
jne 0x190cc
movl $0x50, %edi
callq 0x4190
movq -0x108(%rbp), %rsi
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x128(%rbp)
addq $0x38, %rsi
callq 0x9030
jmp 0x19098
movq -0x128(%rbp), %rdi
leaq 0x20caa(%rip), %rsi     # 0x39d50
leaq -0xfe3d(%rip), %rdx     # 0x9270
callq 0x4550
movq -0x128(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x4230
jmp 0x190e1
movq -0x108(%rbp), %rdi
callq 0x18c60
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopw (%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::wrap(crl::Node::Type)
void _ps_Tracker::wrap(crl::Node::Type t){
		crl::Node * node = new crl::Node(t, this->ast);
		node->children = this->ast->children;
		this->ast->children.clear();
		this->ast->add_child(node);
		this->ast = node;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x58, %edi
callq 0x42f0
movq %rax, %rdi
movq -0x38(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movl -0xc(%rbp), %esi
movq 0x18(%rax), %rdx
callq 0x49a0
jmp 0x191bd
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, -0x18(%rbp)
movq 0x18(%rax), %rsi
addq $0x10, %rsi
movq -0x18(%rbp), %rdi
addq $0x10, %rdi
callq 0x1bf70
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
addq $0x10, %rdi
callq 0x1c1c0
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x18(%rbp), %rsi
movq (%rdi), %rax
callq *0x10(%rax)
movq -0x38(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rcx, 0x18(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x58, %esi
callq 0x4300
movq -0x20(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::func_call()
void _ps_Tracker::func_call(){
		this->enter(crl::Node::Type::CALL);
		this->add(this->previous());
		this->expect(crl::Token::Type::LPAREN);
		if (this->current.type != crl::Token::Type::RPAREN){
			do{
				this->enter(crl::Node::Type::ARG);
				if (this->accept(crl::Token::Type::AND)){
					this->annotate("ref");
					this->expect(crl::Token::IDENT);
					this->add(this->previous());
				} else
					this->expression();
				this->leave();
			}while(this->accept(crl::Token::Type::COMMA));
			expect(crl::Token::Type::RPAREN);
		}else{
			this->next();
		}
		this->leave();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
movl $0xc, %esi
callq 0x190f0
movq -0xb0(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x14170
movq -0xb0(%rbp), %rdi
movq -0xa8(%rbp), %rsi
callq 0x19290
jmp 0x193c8
leaq -0x38(%rbp), %rdi
callq 0x285a0
movq -0xb0(%rbp), %rdi
movl $0x20, %esi
callq 0x18eb0
movq -0xb0(%rbp), %rax
cmpl $0x21, 0x58(%rax)
je 0x19569
jmp 0x193f5
movq -0xb0(%rbp), %rdi
movl $0x12, %esi
callq 0x190f0
movq -0xb0(%rbp), %rdi
movl $0x1e, %esi
callq 0x18d20
testb $0x1, %al
jne 0x19420
jmp 0x19525
leaq -0x69(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4590
movq -0xb8(%rbp), %rdx
leaq 0x120e2(%rip), %rsi     # 0x2b520
leaq -0x68(%rbp), %rdi
callq 0x52e0
jmp 0x19449
movq -0xb0(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x19260
jmp 0x1945b
leaq -0x68(%rbp), %rdi
callq 0x41e0
leaq -0x69(%rbp), %rdi
callq 0x4360
movq -0xb0(%rbp), %rdi
movl $0x1, %esi
callq 0x18eb0
movq -0xb0(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x14170
movq -0xb0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
callq 0x19290
jmp 0x194b5
leaq -0xa0(%rbp), %rdi
callq 0x285a0
jmp 0x19531
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x285a0
jmp 0x1958a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x19500
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x41e0
leaq -0x69(%rbp), %rdi
callq 0x4360
jmp 0x1958a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x285a0
jmp 0x1958a
movq -0xb0(%rbp), %rdi
callq 0x195a0
movq -0xb0(%rbp), %rdi
callq 0x19240
movq -0xb0(%rbp), %rdi
movl $0x29, %esi
callq 0x18d20
testb $0x1, %al
jne 0x193f5
movq -0xb0(%rbp), %rdi
movl $0x21, %esi
callq 0x18eb0
jmp 0x19575
movq -0xb0(%rbp), %rdi
callq 0x18c60
movq -0xb0(%rbp), %rdi
callq 0x19240
addq $0xc0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::expression()
void _ps_Tracker::expression(){
	this->enter(crl::Node::Type::EXPRESSION);
	this->comparison();
	while(accept TYPE_LOGIC()){
		this->add(this->previous());
		this->comparison();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0xd, %esi
callq 0x190f0
movq -0x50(%rbp), %rdi
callq 0x19e10
movq -0x50(%rbp), %rdi
movl $0x2, %esi
movl $0x36, %edx
movl $0x35, %ecx
movb $0x0, %al
callq 0x18d60
testb $0x1, %al
jne 0x195e7
jmp 0x1963a
movq -0x50(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x14170
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x19290
jmp 0x1960f
leaq -0x38(%rbp), %rdi
callq 0x285a0
movq -0x50(%rbp), %rdi
callq 0x19e10
jmp 0x195c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x285a0
jmp 0x19649
movq -0x50(%rbp), %rdi
callq 0x19240
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::term()
void _ps_Tracker::term(){
	this->enter(crl::Node::Type::TERM);
	this->factor();
	while(this->accept(2, crl::Token::Type::TIMES, crl::Token::Type::SLASH)){
		this->add(this->previous());
		this->factor();
	}
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0xe, %esi
callq 0x190f0
movq -0x50(%rbp), %rdi
callq 0x19660
movq -0x50(%rbp), %rdi
movl $0x2, %esi
movl $0x15, %edx
movl $0x1a, %ecx
movb $0x0, %al
callq 0x18d60
testb $0x1, %al
jne 0x19c57
jmp 0x19caa
movq -0x50(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x14170
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x19290
jmp 0x19c7f
leaq -0x38(%rbp), %rdi
callq 0x285a0
movq -0x50(%rbp), %rdi
callq 0x19660
jmp 0x19c37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x285a0
jmp 0x19cb9
movq -0x50(%rbp), %rdi
callq 0x19240
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::basic_expression()
void _ps_Tracker::basic_expression(){
	this->enter(crl::Node::Type::EXPRESSION);
	if ACC_AND_ADD_VAR((2, crl::Token::Type::PLUS, crl::Token::Type::MINUS));
	this->term();
	while(accept(2, crl::Token::Type::PLUS, crl::Token::Type::MINUS)){
		this->add(this->previous());
		this->term();
	}
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
movl $0xd, %esi
callq 0x190f0
movq -0x80(%rbp), %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
movb $0x0, %al
callq 0x18d60
testb $0x1, %al
jne 0x19d11
jmp 0x19d64
movq -0x80(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x14170
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
callq 0x19290
jmp 0x19d3f
leaq -0x38(%rbp), %rdi
callq 0x285a0
jmp 0x19d64
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x285a0
jmp 0x19df8
movq -0x80(%rbp), %rdi
callq 0x19c10
movq -0x80(%rbp), %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
movb $0x0, %al
callq 0x18d60
testb $0x1, %al
jne 0x19d8d
jmp 0x19de6
movq -0x80(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0x78(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x14170
movq -0x80(%rbp), %rdi
movq -0x90(%rbp), %rsi
callq 0x19290
jmp 0x19dbb
leaq -0x78(%rbp), %rdi
callq 0x285a0
movq -0x80(%rbp), %rdi
callq 0x19c10
jmp 0x19d6d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x285a0
jmp 0x19df8
movq -0x80(%rbp), %rdi
callq 0x19240
addq $0x90, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopw %cs:(%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::comparison()
void _ps_Tracker::comparison(){
	this->enter(crl::Node::Type::COMPARISON);
	this->basic_expression();
	while(accept TYPE_EQ()){
		this->add(this->previous());
		this->basic_expression();
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movl $0x18, %esi
callq 0x190f0
movq -0x50(%rbp), %rdi
callq 0x19cd0
movq -0x50(%rbp), %rdi
movl $0x6, %esi
movl $0x2f, %edx
movl $0x34, %ecx
movl $0x31, %r8d
movl $0x30, %r9d
movl $0x32, (%rsp)
movl $0x33, 0x8(%rsp)
movb $0x0, %al
callq 0x18d60
testb $0x1, %al
jne 0x19e72
jmp 0x19ec5
movq -0x50(%rbp), %rdi
callq 0x18cf0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x14170
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x19290
jmp 0x19e9a
leaq -0x38(%rbp), %rdi
callq 0x285a0
movq -0x50(%rbp), %rdi
callq 0x19cd0
jmp 0x19e37
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x285a0
jmp 0x19ed4
movq -0x50(%rbp), %rdi
callq 0x19240
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::casted_expression()
void _ps_Tracker::casted_expression(){
	this->enter(crl::Node::Type::EXPRESSION);
	this->enter(crl::Node::Type::COMPARISON);
	this->enter(crl::Node::Type::EXPRESSION);
	this->enter(crl::Node::Type::TERM);
	this->enter(crl::Node::Type::FACTOR);
	this->enter(crl::Node::Type::CAST);

	this->expression();

	crl::Token t;
	t.type = crl::Token::Type::U32; t.str = "u32";
	this->add(t);
	this->leave();
	this->leave();
	this->leave();
	this->leave();
	this->leave();
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
movl $0xd, %esi
movl %esi, -0x8c(%rbp)
callq 0x190f0
movq -0x88(%rbp), %rdi
movl $0x18, %esi
callq 0x190f0
movl -0x8c(%rbp), %esi
movq -0x88(%rbp), %rdi
callq 0x190f0
movq -0x88(%rbp), %rdi
movl $0xe, %esi
callq 0x190f0
movq -0x88(%rbp), %rdi
movl $0xf, %esi
callq 0x190f0
movq -0x88(%rbp), %rdi
movl $0x15, %esi
callq 0x190f0
movq -0x88(%rbp), %rdi
callq 0x195a0
leaq -0x38(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x28530
movq -0x80(%rbp), %rdi
movl $0x9, -0x18(%rbp)
leaq 0x11708(%rip), %rsi     # 0x2b693
callq 0x4440
jmp 0x19f92
leaq -0x78(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x14170
jmp 0x19fa1
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x19290
jmp 0x19fb3
leaq -0x78(%rbp), %rdi
callq 0x285a0
movq -0x88(%rbp), %rdi
callq 0x19240
movq -0x88(%rbp), %rdi
callq 0x19240
movq -0x88(%rbp), %rdi
callq 0x19240
movq -0x88(%rbp), %rdi
callq 0x19240
movq -0x88(%rbp), %rdi
callq 0x19240
movq -0x88(%rbp), %rdi
callq 0x19240
leaq -0x38(%rbp), %rdi
callq 0x285a0
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1a039
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x285a0
leaq -0x38(%rbp), %rdi
callq 0x285a0
movq -0x40(%rbp), %rdi
callq 0x4580
nopl (%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::program()
void _ps_Tracker::program(){
	this->enter(crl::Node::Type::PROGRAM);
	while(!accept(crl::Token::Type::EOF_)){
		this->declaration();
	}
	
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x1, %esi
callq 0x190f0
movq -0x10(%rbp), %rdi
movl $0x3a, %esi
callq 0x18d20
xorb $-0x1, %al
testb $0x1, %al
jne 0x1a084
jmp 0x1a08f
movq -0x10(%rbp), %rdi
callq 0x1a0a0
jmp 0x1a06e
movq -0x10(%rbp), %rdi
callq 0x19240
addq $0x10, %rsp
popq %rbp
retq
nop
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::block(crl::Token::Type)
void _ps_Tracker::block(crl::Token::Type t){
	this->enter(crl::Node::Type::BLOCK);
	while(!accept(t))
		statement();		
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x5, %esi
callq 0x190f0
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x18d20
xorb $-0x1, %al
testb $0x1, %al
jne 0x1ae25
jmp 0x1ae30
movq -0x18(%rbp), %rdi
callq 0x1ae40
jmp 0x1ae11
movq -0x18(%rbp), %rdi
callq 0x19240
addq $0x20, %rsp
popq %rbp
retq
nop
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: parse_assign[abi:cxx11](crl::Token::Type)
std::string parse_assign(crl::Token::Type t){
	switch (t){
		case crl::Token::Type::PLEQ:
			return "plus";	
		case crl::Token::Type::BECOMES:
			return "";	
		case crl::Token::Type::MIEQ:
			return "minus";	
		case crl::Token::Type::TIEQ:
			return "times";	
		case crl::Token::Type::SLEQ:
			return "slash";	
		default:
			return "";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $-0x2a, %eax
movl %eax, %ecx
movq %rcx, -0x30(%rbp)
subl $0x4, %eax
ja 0x1be74
movq -0x30(%rbp), %rax
leaq 0xfa22(%rip), %rcx      # 0x2b71c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq -0xd(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x4590
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rdx
leaq 0xf889(%rip), %rsi      # 0x2b5a8
callq 0x52e0
jmp 0x1bd26
leaq -0xd(%rbp), %rdi
callq 0x4360
jmp 0x1beb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0xd(%rbp), %rdi
callq 0x4360
jmp 0x1bec3
leaq -0x1d(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4590
movq -0x40(%rbp), %rdi
movq -0x50(%rbp), %rdx
leaq 0xf77a(%rip), %rsi      # 0x2b4e4
callq 0x52e0
jmp 0x1bd71
leaq -0x1d(%rbp), %rdi
callq 0x4360
jmp 0x1beb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1d(%rbp), %rdi
callq 0x4360
jmp 0x1bec3
leaq -0x1e(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x4590
movq -0x40(%rbp), %rdi
movq -0x58(%rbp), %rdx
leaq 0xf7fc(%rip), %rsi      # 0x2b5b1
callq 0x52e0
jmp 0x1bdbc
leaq -0x1e(%rbp), %rdi
callq 0x4360
jmp 0x1beb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1e(%rbp), %rdi
callq 0x4360
jmp 0x1bec3
leaq -0x1f(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x4590
movq -0x40(%rbp), %rdi
movq -0x60(%rbp), %rdx
leaq 0xf7bb(%rip), %rsi      # 0x2b5bb
callq 0x52e0
jmp 0x1be07
leaq -0x1f(%rbp), %rdi
callq 0x4360
jmp 0x1beb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x1f(%rbp), %rdi
callq 0x4360
jmp 0x1bec3
leaq -0x20(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x4590
movq -0x40(%rbp), %rdi
movq -0x68(%rbp), %rdx
leaq 0xf77a(%rip), %rsi      # 0x2b5c5
callq 0x52e0
jmp 0x1be52
leaq -0x20(%rbp), %rdi
callq 0x4360
jmp 0x1beb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x4360
jmp 0x1bec3
leaq -0x21(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4590
movq -0x40(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0xf654(%rip), %rsi      # 0x2b4e4
callq 0x52e0
jmp 0x1be97
leaq -0x21(%rbp), %rdi
callq 0x4360
jmp 0x1beb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x21(%rbp), %rdi
callq 0x4360
jmp 0x1bec3
movq -0x38(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/parser.cpp
// Function: ps_Tracker::_ps_Tracker(std::vector<crl::Token, std::allocator<crl::Token>>&)
_ps_Tracker(std::vector<crl::Token> &tl){
			this->token_list = tl; 
			this->aux = new crl::Node();
			this->ast = aux;
			this->current = tl[0];
		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x1c1e0
movq -0x30(%rbp), %rdi
movq $0x0, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
addq $0x38, %rdi
movq %rdi, -0x28(%rbp)
callq 0x28530
jmp 0x1c2b3
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x1c420
jmp 0x1c2c2
movl $0x58, %edi
callq 0x42f0
movq %rax, -0x40(%rbp)
jmp 0x1c2d2
movq -0x40(%rbp), %rdi
callq 0x4940
jmp 0x1c2dd
movq -0x38(%rbp), %rax
movq -0x40(%rbp), %rcx
movq %rcx, 0x20(%rax)
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x1bf50
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x38, %rdi
callq 0x5900
jmp 0x1c310
addq $0x40, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1c355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x1c34c
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x58, %esi
callq 0x4300
movq -0x28(%rbp), %rdi
callq 0x285a0
movq -0x30(%rbp), %rdi
callq 0x18470
movq -0x18(%rbp), %rdi
callq 0x4580
nopw (%rax,%rax)
// File: RuiDGPires[P]CrimLang/src/semantic_analiser.cpp
// Function: sc_Tracker::block(crl::Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void _sc_Tracker::block(crl::Node *node, std::string annotation){
	this->enter();
	size_t size = node->children.size();
	for (size_t i = 0; i < size; i++){
		this->statement(node->get_child(i), annotation);
	}
	this->leave();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x20060
movq -0x10(%rbp), %rdi
addq $0x10, %rdi
callq 0x51d0
movq %rax, -0x20(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x20d31
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %esi
movq (%rdi), %rax
movq 0x18(%rax), %rax
callq *%rax
movq -0x68(%rbp), %rsi
movq %rax, -0x78(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x4150
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdx
callq 0x226b0
jmp 0x20d03
leaq -0x48(%rbp), %rdi
callq 0x41e0
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x20cc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x41e0
jmp 0x20d43
movq -0x60(%rbp), %rdi
callq 0x200d0
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x4580
nopl (%rax)
// File: RuiDGPires[P]CrimLang/src/token.cpp
// Function: crl::Token::Token()
crl::Token::Token(){
	this->type = crl::Token::Type::NONE;
	this->str = "";
	this->line = 0;
	this->column = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x4450
movq -0x20(%rbp), %rdi
movl $0x0, 0x20(%rdi)
leaq 0x2f82(%rip), %rsi      # 0x2b4e4
callq 0x4440
jmp 0x28569
movq -0x28(%rbp), %rax
movl $0x0, 0x24(%rax)
movl $0x0, 0x28(%rax)
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x41e0
movq -0x10(%rbp), %rdi
callq 0x4580
nop
// File: RuiDGPires[P]CrimLang/src/tokenizer.cpp
// Function: crl::tokenize(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::vector<crl::Token> crl::tokenize(std::string filename){
	std::ifstream file;
	file.open(filename);

	Tracker tracker;	
	char c;
	while (file >> std::noskipws >> c){
		tracker.take(c);
	}
	// TODO : Is this needed?
	tracker.take(c);

	tracker.dump_eof();
	file.close();

	return tracker.get_result();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2d0, %rsp            # imm = 0x2D0
movq %rsi, -0x298(%rbp)
movq %rdi, -0x2b0(%rbp)
movq %rdi, %rax
movq %rax, -0x2a8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x2a0(%rbp)
callq 0x4390
movq -0x2a0(%rbp), %rdi
movq -0x298(%rbp), %rsi
movl $0x8, %edx
callq 0x42a0
jmp 0x2a1d8
leaq -0x288(%rbp), %rdi
callq 0x2a3a0
jmp 0x2a1e6
jmp 0x2a1e8
leaq 0x201(%rip), %rsi       # 0x2a3f0
leaq -0x218(%rbp), %rdi
callq 0x4530
movq %rax, -0x2b8(%rbp)
jmp 0x2a204
movq -0x2b8(%rbp), %rdi
leaq -0x289(%rbp), %rsi
callq 0x4410
movq %rax, -0x2c0(%rbp)
jmp 0x2a220
movq -0x2c0(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x43e0
movb %al, -0x2c1(%rbp)
jmp 0x2a23e
movb -0x2c1(%rbp), %al
testb $0x1, %al
jne 0x2a24a
jmp 0x2a298
movsbl -0x289(%rbp), %esi
leaq -0x288(%rbp), %rdi
callq 0x29040
jmp 0x2a25f
jmp 0x2a1e8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x2a306
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x288(%rbp), %rdi
callq 0x2a420
jmp 0x2a306
movsbl -0x289(%rbp), %esi
leaq -0x288(%rbp), %rdi
callq 0x29040
jmp 0x2a2ad
leaq -0x288(%rbp), %rdi
callq 0x29000
jmp 0x2a2bb
leaq -0x218(%rbp), %rdi
callq 0x40a0
jmp 0x2a2c9
movq -0x2b0(%rbp), %rdi
leaq -0x288(%rbp), %rsi
callq 0x2a150
jmp 0x2a2de
leaq -0x288(%rbp), %rdi
callq 0x2a420
leaq -0x218(%rbp), %rdi
callq 0x40e0
movq -0x2a8(%rbp), %rax
addq $0x2d0, %rsp            # imm = 0x2D0
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x40e0
movq -0x220(%rbp), %rdi
callq 0x4580
nop
// File: tomfunkhouser[P]gaps/apps/scninfo/scninfo.cpp
// Function: main
int main(int argc, char **argv)
{
  // Parse program arguments
  if (!ParseArgs(argc, argv)) exit(-1);

  // Read scene
  R3Scene *scene = ReadScene(input_scene_name);
  if (!scene) exit(-1);

  // Read categories
  if (input_categories_name) {
    if (!ReadCategories(scene, input_categories_name)) exit(-1);
  }

  // Print scene
  if (!PrintScene(scene)) exit(-1);

  // Return success 
  return 0;
}

// Assembly:
subq $0x18, %rsp
movl $0x0, 0x14(%rsp)
movl %edi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl 0x10(%rsp), %edi
movq 0x8(%rsp), %rsi
callq 0x26d20
cmpl $0x0, %eax
jne 0x26cb2
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c00
movq 0x1d2e3f(%rip), %rdi    # 0x1f9af8
callq 0x27040
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
jne 0x26cd3
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c00
cmpq $0x0, 0x1d2e25(%rip)    # 0x1f9b00
je 0x26cfe
movq (%rsp), %rdi
movq 0x1d2e18(%rip), %rsi    # 0x1f9b00
callq 0x27160
cmpl $0x0, %eax
jne 0x26cfc
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c00
jmp 0x26cfe
movq (%rsp), %rdi
callq 0x271a0
cmpl $0x0, %eax
jne 0x26d16
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x22c00
xorl %eax, %eax
addq $0x18, %rsp
retq
nopl (%rax)