LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq (%rsi), %r15
leaq 0x8(%rsp), %r12
cmpq 0x8(%rbx), %r15
je 0x1371
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1602
movq 0x8(%rsp), %rax
movzwl 0x10(%rsp), %ecx
cmpq %r14, %rax
jne 0x1361
cmpw (%r14), %cx
je 0x136b
movzwl %cx, %ecx
movq 0x10(%rax), %rax
incl (%rax,%rcx,4)
addq $0x4, %r15
jmp 0x1338
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
leaq 0x1a45b(%rip), %rax     # 0x1dc00
movq %rax, (%rdi)
leaq 0x10(%rdi), %rbx
movq 0x18(%rdi), %r15
subq 0x10(%rdi), %r15
sarq $0x3, %r15
xorl %r12d, %r12d
cmpq %r12, %r15
je 0x37d7
movq (%rbx), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x37d2
movq (%rdi), %rax
callq *0x8(%rax)
incq %r12
jmp 0x37bb
addq $0x30, %r14
movq %r14, %rdi
callq 0x3110
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x3ed2
nop
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/ast.cpp
// Function: crl::Node::to_string[abi:cxx11](int) const
std::string Node::to_string(int depth) const{
	std::string aux = "";
	if (this->annotation != "")
		aux = "(" + this->annotation + ") ";
	std::string ret = std::string(depth, ' ') + aux + std::to_string((int) this->type);

	for (Node *n: this->children)
		ret += "\n" + n->to_string(depth + 2);
	return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
leaq 0x11c49(%rip), %r13     # 0x154e4
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %rdx
movq %r13, %rsi
callq 0x3be4
leaq 0x30(%r15), %r12
movq %r12, %rdi
movq %r13, %rsi
callq 0x3c1f
testb %al, %al
je 0x390c
leaq 0x1188d(%rip), %rsi     # 0x15155
leaq -0x58(%rbp), %rdi
movq %r12, %rdx
callq 0x3c55
leaq 0x11729(%rip), %rdx     # 0x15004
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x3c2c
leaq -0x98(%rbp), %rdi
leaq -0x78(%rbp), %r12
movq %r12, %rsi
callq 0x32b0
movq %r12, %rdi
callq 0x3110
leaq -0x58(%rbp), %rdi
callq 0x3110
movslq -0x2c(%rbp), %rsi
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x58(%rbp), %rdi
pushq $0x20
popq %rdx
callq 0x3290
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x3d3c
movl 0x8(%r15), %esi
leaq -0xb8(%rbp), %rdi
callq 0x3d65
leaq -0x78(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
movq -0x38(%rbp), %rdi
callq 0x3ccb
leaq -0xb8(%rbp), %rdi
callq 0x3110
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x3110
leaq -0x58(%rbp), %r13
movq %r13, %rdi
callq 0x3110
movq 0x10(%r15), %rbx
movq 0x18(%r15), %r14
addl $0x2, -0x2c(%rbp)
leaq 0x11b50(%rip), %r15     # 0x154e3
cmpq %r14, %rbx
je 0x39d7
movq (%rbx), %rsi
movq (%rsi), %rax
movq %r13, %rdi
movl -0x2c(%rbp), %edx
callq *0x30(%rax)
movq %r12, %rdi
movq %r15, %rsi
movq %r13, %rdx
callq 0x3dc5
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x3460
movq %r12, %rdi
callq 0x3110
movq %r13, %rdi
callq 0x3110
addq $0x8, %rbx
jmp 0x3993
leaq -0x98(%rbp), %rdi
callq 0x3110
movq -0x38(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3a1c
jmp 0x3a27
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
callq 0x3110
jmp 0x3a11
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x3110
jmp 0x3a1f
movq %rax, %r14
leaq -0x58(%rbp), %rdi
jmp 0x3a4f
jmp 0x3a27
movq %rax, %r14
jmp 0x3a54
movq %rax, %r14
jmp 0x3a4b
movq %rax, %r14
jmp 0x3a42
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x3110
leaq -0x58(%rbp), %rdi
callq 0x3110
movq -0x38(%rbp), %rdi
callq 0x3110
leaq -0x98(%rbp), %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x438e
testq %rax, %rax
je 0x41b6
movq %r12, %rdi
movq %r14, %rsi
callq 0x43f4
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4444
jmp 0x41ee
movq (%r15), %r15
testq %r15, %r15
je 0x41e6
leaq -0x40(%rbp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x32f0
movq %rbx, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x4172
leaq -0x40(%rbp), %rdi
callq 0x3110
jmp 0x41ee
movq %rbx, %rdi
callq 0x43b2
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x1900b(%rip), %rax     # 0x1dcb8
movq %rax, (%rdi)
leaq 0x18(%rdi), %rax
movq %rax, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
leaq 0x8(%rdi), %r14
xorl %eax, %eax
movb %al, 0x18(%rdi)
leaq 0x38(%rdi), %rcx
movq %rcx, 0x28(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x28(%rdi), %r15
movb %al, 0x38(%rdi)
movl %esi, 0x48(%rdi)
movl %edx, 0x4c(%rdi)
leaq 0x1045a(%rip), %rsi     # 0x15141
movq %r14, %rdi
callq 0x3450
leaq 0x107ee(%rip), %rsi     # 0x154e4
movq %r15, %rdi
callq 0x3450
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
movq %r15, %rdi
callq 0x3110
movq %r14, %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3430
movq %r12, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/generator.cpp
// Function: gc_Tracker::expression_reg(crl::Node*, std::__cxx11::basic_stringstream<char, std::char_traits<char>, std::allocator<char>>&)
u32 _gc_Tracker::expression_reg(crl::Node *node, std::stringstream &stream){
	size_t size = node->children.size();
	size_t i = 0;

	u32 reg1 = this->comparison(node->get_child(i++), stream);
	std::string reg_name = reg_tracker.reg_name(reg1);

	for (; i < size; i += 2){
		u32 reg2 = this->comparison(node->get_child(i+1), stream);
		if (get_token(node->get_child(i)).type == crl::Token::Type::LAND)
			stream << "LAND " << reg_name << " " << reg_tracker.reg_name(reg2) << "\n";
		else
			stream << "LOR " << reg_name << " " << reg_tracker.reg_name(reg2) << "\n";
		reg_tracker.free(reg2);
	}
	return reg1; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
movq 0x18(%rsi), %rcx
subq 0x10(%rsi), %rcx
sarq $0x3, %rcx
movq %rcx, -0x58(%rbp)
movq %rsi, %rdi
xorl %esi, %esi
callq *0x18(%rax)
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x6b06
movq %r15, -0x48(%rbp)
leaq 0x500(%r15), %rsi
leaq -0x78(%rbp), %rdi
movq %rsi, -0x30(%rbp)
movl %eax, -0x34(%rbp)
movl %eax, %edx
callq 0xab34
movq %rbx, -0x50(%rbp)
leaq 0x10(%rbx), %rax
movq %rax, -0x40(%rbp)
pushq $0x1
popq %rbx
leaq -0xa8(%rbp), %r15
cmpq -0x58(%rbp), %rbx
jae 0x5a0c
leal 0x1(%rbx), %esi
movq (%r14), %rax
movq %r14, %rdi
callq *0x18(%rax)
movq -0x48(%rbp), %rdi
movq %rax, %rsi
movq -0x50(%rbp), %rdx
callq 0x6b06
movl %eax, %r12d
movq (%r14), %rax
movq %r14, %rdi
movl %ebx, %esi
callq *0x18(%rax)
addq $0x58, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0xb24a
movl -0x88(%rbp), %r13d
movq %r15, %rdi
callq 0x135f8
cmpl $0x36, %r13d
jne 0x5998
movq -0x40(%rbp), %rdi
leaq 0xf9a4(%rip), %rsi      # 0x152ee
callq 0x3230
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x3220
movq %rax, %rdi
leaq 0xf6a0(%rip), %rsi      # 0x15005
callq 0x3230
movq %rax, %r13
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movl %r12d, %edx
callq 0xab34
movq %r13, %rdi
movq %r15, %rsi
callq 0x3220
movq %rax, %rdi
leaq 0xfb52(%rip), %rsi      # 0x154e3
callq 0x3230
jmp 0x59ef
movq -0x40(%rbp), %rdi
leaq 0xf946(%rip), %rsi      # 0x152e9
callq 0x3230
movq %rax, %rdi
leaq -0x78(%rbp), %rsi
callq 0x3220
movq %rax, %rdi
leaq 0xf647(%rip), %rsi      # 0x15005
callq 0x3230
movq %rax, %r13
movq %r15, %rdi
movq -0x30(%rbp), %rsi
movl %r12d, %edx
callq 0xab34
movq %r13, %rdi
movq %r15, %rsi
callq 0x3220
movq %rax, %rdi
leaq 0xfaf9(%rip), %rsi      # 0x154e3
callq 0x3230
movq %r15, %rdi
callq 0x3110
movq -0x30(%rbp), %rdi
movl %r12d, %esi
callq 0xac12
addq $0x2, %rbx
jmp 0x58e7
leaq -0x78(%rbp), %rdi
callq 0x3110
movl -0x34(%rbp), %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5a43
jmp 0x5a43
jmp 0x5a30
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x3110
jmp 0x5a46
jmp 0x5a43
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0xdd6e(%rip), %rsi      # 0x1568e
callq 0x410a
xorl %r14d, %r14d
testb %al, %al
jne 0x79bd
leaq 0xd997(%rip), %rsi      # 0x152ce
movq %rbx, %rdi
callq 0x410a
pushq $0x1
popq %r14
testb %al, %al
jne 0x79bd
leaq 0xdd45(%rip), %rsi      # 0x15693
movq %rbx, %rdi
callq 0x410a
testb %al, %al
jne 0x79bd
leaq 0xdd36(%rip), %rsi      # 0x15697
movq %rbx, %rdi
callq 0x410a
testb %al, %al
jne 0x79bd
leaq 0xdd27(%rip), %rsi      # 0x1569b
movq %rbx, %rdi
callq 0x410a
testb %al, %al
jne 0x79bd
leaq 0xdd19(%rip), %rsi      # 0x156a0
movq %rbx, %rdi
callq 0x410a
pushq $0x2
popq %r14
testb %al, %al
jne 0x79bd
leaq 0xdd06(%rip), %rsi      # 0x156a4
movq %rbx, %rdi
callq 0x410a
testb %al, %al
jne 0x79bd
leaq 0xdcf7(%rip), %rsi      # 0x156a8
movq %rbx, %rdi
callq 0x410a
testb %al, %al
je 0x79cb
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %r14
leaq 0xdccf(%rip), %rsi      # 0x156ac
leaq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x3c55
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x38(%rbp), %rcx
movq %r14, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0x16389(%rip), %rsi     # 0x1dd90
leaq -0x2ad6(%rip), %rdx     # 0x4f38
movq %r14, %rdi
callq 0x33f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3110
testb %r15b, %r15b
jne 0x7a2c
jmp 0x7a34
movq %rax, %rbx
movq %r14, %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x18(%rsi), %r15
subq 0x10(%rsi), %r15
movq 0x5a0(%rdi), %rax
movq %rax, -0x30(%rbp)
sarq $0x3, %r15
leaq 0x318(%rdi), %r12
xorl %r13d, %r13d
cmpq %r13, %r15
je 0x8b2d
movq (%r14), %rax
movq %r14, %rdi
movl %r13d, %esi
callq *0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0x8c48
incq %r13
jmp 0x8b09
addq $0x530, %rbx            # imm = 0x530
movq %rbx, %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xadde
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x18(%rsi), %rax
cmpq 0x10(%rsi), %rax
je 0x8ba0
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x18(%rax)
leaq 0x318(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x73e0
leaq 0x328(%rbx), %rdi
leaq 0xc971(%rip), %rsi      # 0x154fd
callq 0x3230
leaq 0xc96d(%rip), %rsi      # 0x15505
movq %rax, %rdi
callq 0x3230
leaq 0x328(%rbx), %rdi
leaq 0xc967(%rip), %rsi      # 0x15515
callq 0x3230
addq $0x4a0, %rbx            # imm = 0x4A0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x3220
leaq 0xc94e(%rip), %rsi      # 0x1551a
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3230
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/generator.cpp
// Function: gc_Tracker::while_(crl::Node*)
void _gc_Tracker::while_(crl::Node *node){
	std::string	loop_label = label_tracker.name(label_tracker.create());
	std::string end_label	= label_tracker.name(label_tracker.create());
	this->breakable_labels = std::pair(loop_label, end_label);

	stream_funcs <<	loop_label << ":\n";

	u32 reg = this->expression_reg(node->get_child(0), stream_funcs);

	stream_funcs <<
		"CMP " << reg_tracker.reg_name(reg) << " R0\n" <<
		"JMP.Z " << end_label << "\n";
		
	reg_tracker.free(reg);

	this->parse_node(node->get_child(1));

	stream_funcs << "JMP " << loop_label << "\n" <<
		end_label << ":\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x528(%rdi), %r15
movl 0x528(%rdi), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x528(%rdi)
leaq -0x70(%rbp), %rdi
movq %r15, %rsi
callq 0xaf2c
movl 0x528(%rbx), %edx
leal 0x1(%rdx), %eax
movl %eax, 0x528(%rbx)
leaq -0x50(%rbp), %rdi
movq %r15, %rsi
callq 0xaf2c
leaq -0xb0(%rbp), %rdi
leaq -0x70(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xafae
leaq 0x4c0(%rbx), %rdi
leaq -0xb0(%rbp), %r15
movq %r15, %rsi
callq 0xafe4
movq %r15, %rdi
callq 0xb00e
leaq 0x328(%rbx), %r13
leaq -0x70(%rbp), %rsi
movq %r13, %rdi
callq 0x3220
leaq 0xae81(%rip), %rsi      # 0x154a4
movq %rax, %rdi
callq 0x3230
movq (%r14), %rax
movq %r14, %rdi
xorl %esi, %esi
callq *0x18(%rax)
leaq 0x318(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x586e
movl %eax, %r12d
leaq 0xaf9f(%rip), %rsi      # 0x155f1
movq %r13, %rdi
callq 0x3230
movq %rax, %r15
movq %r13, -0x30(%rbp)
leaq 0x500(%rbx), %r13
leaq -0xb0(%rbp), %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0xab34
leaq -0xb0(%rbp), %rsi
movq %r15, %rdi
callq 0x3220
leaq 0xafa2(%rip), %rsi      # 0x15632
movq %rax, %rdi
callq 0x3230
leaq 0xaf57(%rip), %rsi      # 0x155f6
movq %rax, %rdi
callq 0x3230
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x3220
leaq 0xae29(%rip), %rsi      # 0x154e3
movq %rax, %rdi
callq 0x3230
leaq -0xb0(%rbp), %rdi
callq 0x3110
movq %r13, %rdi
movl %r12d, %esi
callq 0xac12
movq -0x30(%rbp), %r15
movq (%r14), %rax
pushq $0x1
popq %rsi
movq %r14, %rdi
callq *0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa56e
leaq 0xae1a(%rip), %rsi      # 0x15515
movq %r15, %rdi
callq 0x3230
leaq -0x70(%rbp), %rsi
movq %rax, %rdi
callq 0x3220
leaq 0xadcd(%rip), %rsi      # 0x154e3
movq %rax, %rdi
callq 0x3230
leaq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x3220
leaq 0xad73(%rip), %rsi      # 0x154a4
movq %rax, %rdi
callq 0x3230
leaq -0x50(%rbp), %rdi
callq 0x3110
leaq -0x70(%rbp), %rdi
callq 0x3110
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa779
jmp 0xa779
movq %rax, %rbx
jmp 0xa785
jmp 0xa779
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x3110
jmp 0xa77c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
leaq -0x70(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rdi
leaq 0xae4a(%rip), %rsi      # 0x155fd
callq 0x3230
leaq 0xae51(%rip), %rsi      # 0x15610
movq %rax, %rdi
callq 0x3230
movq 0x10(%r14), %r15
movq 0x18(%r14), %r14
cmpq %r14, %r15
je 0xa7e5
movq (%r15), %rsi
movq %rbx, %rdi
callq 0xa56e
addq $0x8, %r15
jmp 0xa7cf
movq (%rbx), %r14
leaq 0x20(%rbx), %rsi
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x3370
movq %r14, %rdi
movq %r15, %rsi
callq 0x3220
leaq -0x38(%rbp), %rdi
callq 0x3110
movq (%rbx), %rdi
leaq 0xae03(%rip), %rsi      # 0x15619
callq 0x3230
movq (%rbx), %r14
leaq 0x1a8(%rbx), %rsi
movq %r15, %rdi
callq 0x3370
movq %r14, %rdi
movq %r15, %rsi
callq 0x3220
leaq -0x38(%rbp), %rdi
callq 0x3110
movq (%rbx), %rdi
leaq 0xade4(%rip), %rsi      # 0x1562f
callq 0x3230
leaq 0xade0(%rip), %rsi      # 0x15637
movq %rax, %rdi
callq 0x3230
movq (%rbx), %rdi
leaq 0xadd8(%rip), %rsi      # 0x15641
callq 0x3230
movq (%rbx), %rdi
leaq 0xadce(%rip), %rsi      # 0x15646
callq 0x3230
movq (%rbx), %r14
addq $0x330, %rbx            # imm = 0x330
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3370
movq %r14, %rdi
movq %r15, %rsi
callq 0x3220
leaq -0x38(%rbp), %rdi
callq 0x3110
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa8b5
jmp 0xa8b5
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/generator.cpp
// Function: crl::generate_cas(crl::Node*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void generate_cas(Ast *ast, std::string filename){
	std::ofstream file;
	file.open(filename);

	ASSERT(ast->type == Node::Type::NONE, "Invalid type");
	ASSERT(ast->children.size() == 1, "Invalid size");

	ast = ast->get_child(0); // Program

	_gc_Tracker tracker(&file);


	tracker.parse_node(ast);

	file.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x7f8, %rsp            # imm = 0x7F8
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x258(%rbp), %r15
movq %r15, %rdi
callq 0x33e0
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x3120
cmpl $0x0, 0x8(%rbx)
jne 0xa976
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x8, %rax
jne 0xa9c7
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x18(%rax)
movq %rax, %rbx
leaq -0x810(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0xb02e
leaq -0x810(%rbp), %rdi
movq %rbx, %rsi
callq 0xa56e
leaq -0x258(%rbp), %rdi
callq 0x3300
leaq -0x810(%rbp), %rdi
callq 0xb164
leaq -0x258(%rbp), %rdi
callq 0x3330
addq $0x7f8, %rsp            # imm = 0x7F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %r14
leaq 0xacd1(%rip), %rsi      # 0x15659
leaq -0x58(%rbp), %rdi
leaq -0x810(%rbp), %rdx
callq 0x3be4
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x58(%rbp), %rcx
movq %r14, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0x133da(%rip), %rsi     # 0x1dd90
leaq -0x5a85(%rip), %rdx     # 0x4f38
movq %r14, %rdi
callq 0x33f0
jmp 0xaa16
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %r14
leaq 0xac8d(%rip), %rsi      # 0x15666
leaq -0x38(%rbp), %rdi
leaq -0x810(%rbp), %rdx
callq 0x3be4
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x38(%rbp), %rcx
movq %r14, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0x13389(%rip), %rsi     # 0x1dd90
leaq -0x5ad6(%rip), %rdx     # 0x4f38
movq %r14, %rdi
callq 0x33f0
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xaa28
jmp 0xaa34
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x3110
testb %r15b, %r15b
jne 0xaa37
jmp 0xaa57
movq %rax, %rbx
movq %r14, %rdi
callq 0x31b0
jmp 0xaa57
jmp 0xaa54
movq %rax, %rbx
leaq -0x810(%rbp), %rdi
callq 0xb164
jmp 0xaa57
movq %rax, %rbx
leaq -0x258(%rbp), %rdi
callq 0x3330
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movq 0x10(%rdi), %rax
movl 0x18(%rdi), %ecx
subq (%rdi), %rax
leaq (%rcx,%rax,8), %r15
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0xaac1
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb1c8
testq %rdx, (%rax)
je 0xaaa6
incq %rbx
jmp 0xaa8c
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb1c8
orq %rdx, (%rax)
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %rbx
leaq 0xaba0(%rip), %rsi      # 0x15673
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3be4
movb $0x1, %r15b
pushq $-0x1
popq %rdx
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl %edx, %esi
callq 0x4e88
xorl %r15d, %r15d
leaq 0x13292(%rip), %rsi     # 0x1dd90
leaq -0x5bcd(%rip), %rdx     # 0x4f38
movq %rbx, %rdi
callq 0x33f0
movq %rax, %r14
leaq -0x40(%rbp), %rdi
callq 0x3110
testb %r15b, %r15b
jne 0xab23
jmp 0xab2b
movq %rax, %r14
movq %rbx, %rdi
callq 0x31b0
movq %r14, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %edx, %ebx
movq %rdi, %r15
leaq 0x78(%rdi), %r14
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r14, %rdx
callq 0xb46e
movq %r15, %rdi
movq %r12, %rsi
callq 0xb48c
leaq -0x48(%rbp), %rdi
callq 0x3110
movl (%r14), %eax
addl %eax, %ebx
movl %ebx, (%r14)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, %r15d
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x30(%rdi), %r13
movq %r13, %rdi
callq 0xb270
testq %rax, %rax
jne 0xad32
leaq -0x40(%rbp), %rdx
movq %rdx, 0x8(%rdx)
movq %rdx, (%rdx)
andq $0x0, 0x10(%rdx)
leaq -0x78(%rbp), %rdi
movq %rbx, %rsi
callq 0xb6b8
leaq -0x78(%rbp), %rsi
movq %r13, %rdi
callq 0xb71e
leaq -0x78(%rbp), %rdi
callq 0xb6de
leaq -0x40(%rbp), %rdi
callq 0xb9b6
addl %r12d, 0x80(%r14)
movq %r13, %rdi
movq %rbx, %rsi
callq 0xb294
movl 0x80(%r14), %ecx
leaq -0x78(%rbp), %rsi
movl %ecx, (%rsi)
movb %r15b, 0x4(%rsi)
movq %rax, %rdi
callq 0xb6fe
addq $0x60, %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb70e
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0xb6de
jmp 0xad8c
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xb9b6
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
movq 0x70(%rdi), %r12
movl %esi, %r13d
addq $0x30, %rbx
leaq -0x48(%rbp), %r15
cmpq %r13, %r12
jbe 0xae41
movq (%r14), %rsi
addq $0x10, %rsi
movq %r15, %rdi
callq 0x32f0
movq %r14, %rdi
callq 0xbbcc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb294
movq %rax, %rdi
callq 0xbbda
movq %r15, %rdi
callq 0x3110
decq %r12
jmp 0xae05
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/main.cpp
// Function: main
int main(int argc, char *argv[]){
	if (argc < 3) {std::cout << "Invalid number of command line arguments\n"; return 0;}

	crl::Pproc_lib p;
	p.libc = argc - 3;
	if (argc > 3)
		p.libv = &argv[3];
	else
		p.libv = NULL;
	
	
	try{
		std::vector<crl::Token> vec = crl::tokenize(argv[1]);
		crl::preprocess(vec, p);
		//print_token_vec(vec);
		crl::Ast *ast = crl::generate_ast(vec);
		//std::cout << ast->to_string() << std::endl;
		crl::semantic_check(ast);
		generate_cas(ast, argv[2]);
		delete ast;
	}catch(std::string &e){
		std::cout << e << std::endl;
		return 1;
	}catch(crl::CL_Exception &e){
		std::cout << e.what() << std::endl;
		return 1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
cmpl $0x2, %edi
jg 0xc045
movq 0x11fa4(%rip), %rdi     # 0x1dfd8
leaq 0x967f(%rip), %rsi      # 0x156ba
callq 0x3230
jmp 0xc103
movq %rsi, %rbx
movl %edi, %r14d
leaq 0x18(%rsi), %rax
xorl %r15d, %r15d
cmpl $0x3, %edi
cmovneq %rax, %r15
movq 0x8(%rsi), %rsi
leaq -0x98(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3be4
leaq -0x40(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0x1459c
addl $-0x3, %r14d
leaq -0x98(%rbp), %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xe9a6
leaq -0x58(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0xc200
leaq -0x58(%rbp), %rdi
callq 0xe2d4
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0xc25a
movq %r14, %rdi
callq 0x12adc
movq 0x10(%rbx), %rsi
leaq -0x78(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x3be4
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0xa8c9
leaq -0x78(%rbp), %rdi
callq 0x3110
testq %r14, %r14
je 0xc0fa
movq (%r14), %rax
movq %r14, %rdi
callq *0x8(%rax)
leaq -0x40(%rbp), %rdi
callq 0xc25a
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r14
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x3110
jmp 0xc15b
jmp 0xc155
movq %rdx, %r14
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0xc25a
jmp 0xc15b
jmp 0xc155
movq %rdx, %r14
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x3110
jmp 0xc164
movq %rdx, %r14
movq %rax, %rbx
jmp 0xc164
movq %rdx, %r14
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc25a
cmpl $0x2, %r14d
jne 0xc18b
movq %rbx, %rdi
callq 0x30e0
movq 0x11e5f(%rip), %rdi     # 0x1dfd8
movq %rax, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3130
jmp 0xc1c8
cmpl $0x1, %r14d
jne 0xc1f0
movq %rbx, %rdi
callq 0x30e0
leaq -0x40(%rbp), %rbx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x4d2a
movq 0x11e29(%rip), %rdi     # 0x1dfd8
movq %rbx, %rsi
callq 0x3220
movq %rax, %rdi
callq 0x3130
leaq -0x40(%rbp), %rdi
callq 0x3110
callq 0x33b0
pushq $0x1
popq %rax
jmp 0xc105
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x3110
callq 0x33b0
jmp 0xc1f0
movq %rax, %rbx
callq 0x33b0
movq %rbx, %rdi
callq 0x3410
movq %rax, %rdi
callq 0x3ec4
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %ebx
movl 0x58(%rdi), %r14d
cmpl %esi, %r14d
jne 0xc467
callq 0xc3e0
cmpl %ebx, %r14d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
subq $0xc8, %rsp
movl %esi, %ebx
leaq -0xd0(%rbp), %rsi
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movq %r8, 0x20(%rsi)
movq %r9, 0x28(%rsi)
testb %al, %al
je 0xc4c1
movaps %xmm0, -0xa0(%rbp)
movaps %xmm1, -0x90(%rbp)
movaps %xmm2, -0x80(%rbp)
movaps %xmm3, -0x70(%rbp)
movaps %xmm4, -0x60(%rbp)
movaps %xmm5, -0x50(%rbp)
movaps %xmm6, -0x40(%rbp)
movaps %xmm7, -0x30(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x10(%rbp), %rdx
movq %rdx, -0x18(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x20(%rbp)
pushq $0x10
popq %rax
movl 0x58(%rdi), %ecx
incl %ebx
decl %ebx
testl %ebx, %ebx
jle 0xc512
cmpl $0x28, %eax
ja 0xc4fe
movq %rdx, %r8
movl %eax, %edx
addq %rsi, %rdx
addl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0xc506
leaq 0x8(%rdx), %r8
movq %r8, -0x18(%rbp)
cmpl (%rdx), %ecx
movq %r8, %rdx
jne 0xc4e3
callq 0xc3e0
testl %ebx, %ebx
setg %al
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq -0xe0(%rbp), %rdi
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0xc5d5
movaps %xmm0, -0xb0(%rbp)
movaps %xmm1, -0xa0(%rbp)
movaps %xmm2, -0x90(%rbp)
movaps %xmm3, -0x80(%rbp)
movaps %xmm4, -0x70(%rbp)
movaps %xmm5, -0x60(%rbp)
movaps %xmm6, -0x50(%rbp)
movaps %xmm7, -0x40(%rbp)
movq %rdi, -0x20(%rbp)
leaq 0x10(%rbp), %rdx
movq %rdx, -0x28(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x30(%rbp)
pushq $0x10
popq %rax
movl 0x58(%rbx), %ecx
incl %esi
decl %esi
testl %esi, %esi
jle 0xc635
cmpl $0x28, %eax
ja 0xc612
movq %rdx, %r8
movl %eax, %edx
addq %rdi, %rdx
addl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0xc61a
leaq 0x8(%rdx), %r8
movq %r8, -0x28(%rbp)
cmpl (%rdx), %ecx
movq %r8, %rdx
jne 0xc5f7
movq %rbx, %rdi
callq 0xc3e0
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x50
popq %rdi
callq 0x3140
movq %rax, %r14
addq $0x38, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x4de0
leaq 0x1170a(%rip), %rsi     # 0x1dd60
leaq -0x7725(%rip), %rdx     # 0x4f38
movq %r14, %rdi
callq 0x33f0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31b0
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r15d
movq %rdi, %rbx
pushq $0x58
popq %rdi
callq 0x3240
movq %rax, %r14
movq 0x18(%rbx), %rdx
movq %rax, %rdi
movl %r15d, %esi
callq 0x375c
movq 0x18(%rbx), %rsi
addq $0x10, %rsi
movq %r14, %rdi
addq $0x10, %rdi
callq 0xe320
movq 0x18(%rbx), %rdi
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xc724
movq %rax, 0x18(%rdi)
movq (%rdi), %rax
movq %r14, %rsi
callq *0x10(%rax)
movq %r14, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x3250
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
pushq $0xc
popq %rsi
callq 0xc678
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
leaq -0x80(%rbp), %r14
movq %r14, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc776
leaq -0x80(%rbp), %rdi
callq 0x135f8
pushq $0x20
popq %rsi
movq %rbx, %rdi
callq 0xc522
cmpl $0x21, 0x58(%rbx)
jne 0xc877
movq %rbx, %rdi
callq 0xc3e0
jmp 0xc934
pushq $0x1e
popq %r15
leaq -0x50(%rbp), %r13
leaq -0xb0(%rbp), %r12
pushq $0x29
popq %r14
movq %rbx, %rdi
pushq $0x12
popq %rsi
callq 0xc678
movq %rbx, %rdi
movl %r15d, %esi
callq 0xc450
testb %al, %al
je 0xc902
movq %r13, %rdi
leaq 0x8c72(%rip), %rsi      # 0x15520
leaq -0x29(%rbp), %rdx
callq 0x3be4
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc764
movq %r13, %rdi
callq 0x3110
movq %rbx, %rdi
pushq $0x1
popq %rsi
callq 0xc522
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
movq %r12, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r12, %rsi
callq 0xc776
movq %r12, %rdi
callq 0x135f8
jmp 0xc90a
movq %rbx, %rdi
callq 0xc986
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc450
testb %al, %al
jne 0xc88a
pushq $0x21
popq %rsi
movq %rbx, %rdi
callq 0xc522
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0xc978
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x3110
jmp 0xc97d
movq %rax, %rbx
jmp 0xc97d
movq %rax, %rbx
leaq -0xb0(%rbp), %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0xd
popq %rsi
callq 0xc678
movq %rbx, %rdi
callq 0xcf96
pushq $0x2
popq %r14
pushq $0x36
popq %r15
pushq $0x35
popq %r12
leaq -0x58(%rbp), %r13
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0xc472
testb %al, %al
je 0xca06
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
movq %r13, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc776
movq %r13, %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0xcf96
jmp 0xc9ba
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0xe
popq %rsi
callq 0xc678
movq %rbx, %rdi
callq 0xca36
pushq $0x2
popq %r14
pushq $0x15
popq %r15
pushq $0x1a
popq %r12
leaq -0x58(%rbp), %r13
movq %rbx, %rdi
movl %r14d, %esi
movl %r15d, %edx
movl %r12d, %ecx
xorl %eax, %eax
callq 0xc472
testb %al, %al
je 0xce6c
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
movq %r13, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r13, %rsi
callq 0xc776
movq %r13, %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0xca36
jmp 0xce20
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
pushq $0xd
popq %rsi
callq 0xc678
pushq $0x2
popq %rsi
pushq $0x16
popq %rdx
pushq $0x17
popq %rcx
movq %rbx, %rdi
xorl %eax, %eax
callq 0xc472
testb %al, %al
je 0xceff
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc776
leaq -0x58(%rbp), %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0xcdec
pushq $0x2
popq %r15
pushq $0x16
popq %r12
pushq $0x17
popq %r13
leaq -0x88(%rbp), %r14
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
movl %r13d, %ecx
xorl %eax, %eax
callq 0xc472
testb %al, %al
je 0xcf66
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
movq %r14, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc776
movq %r14, %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0xcdec
jmp 0xcf1a
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xcf83
movq %rax, %rbx
movq %r14, %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
pushq $0x18
popq %rsi
callq 0xc678
movq %rbx, %rdi
callq 0xce9c
pushq $0x34
popq %r12
pushq $0x31
popq %r13
pushq $0x30
popq %r14
leaq -0x58(%rbp), %r15
movq %rbx, %rdi
pushq $0x6
popq %rsi
pushq $0x2f
popq %rdx
movl %r12d, %ecx
movl %r13d, %r8d
movl %r14d, %r9d
xorl %eax, %eax
pushq $0x33
pushq $0x32
callq 0xc472
popq %rcx
popq %rdx
testb %al, %al
je 0xd022
movq (%rbx), %rax
imulq $0x30, 0x28(%rbx), %rcx
leaq (%rax,%rcx), %rsi
addq $-0x30, %rsi
movq %r15, %rdi
callq 0xb24a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc776
movq %r15, %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0xce9c
jmp 0xcfca
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
pushq $0xd
popq %r14
movl %r14d, %esi
callq 0xc678
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0xc678
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc678
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0xc678
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0xc678
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0xc678
movq %rbx, %rdi
callq 0xc986
leaq -0x70(%rbp), %r14
movq %r14, %rdi
callq 0x135b0
movl $0x9, 0x20(%r14)
leaq 0x85cd(%rip), %rsi      # 0x15693
movq %r14, %rdi
callq 0x3450
leaq -0x40(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0xb24a
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
callq 0xc776
leaq -0x40(%rbp), %rdi
callq 0x135f8
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
leaq -0x70(%rbp), %rdi
callq 0x135f8
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x135f8
jmp 0xd133
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0x3410
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
pushq $0x1
popq %rsi
callq 0xc678
pushq $0x3a
popq %r14
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc450
testb %al, %al
jne 0xd173
movq %rbx, %rdi
callq 0xd184
jmp 0xd15a
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movl %esi, %r14d
movq %rdi, %rbx
pushq $0x5
popq %rsi
callq 0xc678
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc450
testb %al, %al
jne 0xd9a8
movq %rbx, %rdi
callq 0xd9ba
jmp 0xd98f
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
addl $-0x2a, %esi
cmpl $0x4, %esi
ja 0xe2b7
leaq 0x74af(%rip), %rax      # 0x1571c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x7267(%rip), %rsi      # 0x154e4
leaq -0xd(%rbp), %rdx
jmp 0xe2c2
leaq 0x733b(%rip), %rsi      # 0x155c5
leaq -0xa(%rbp), %rdx
jmp 0xe2c2
leaq 0x731a(%rip), %rsi      # 0x155b1
leaq -0xc(%rbp), %rdx
jmp 0xe2c2
leaq 0x7317(%rip), %rsi      # 0x155bb
leaq -0xb(%rbp), %rdx
jmp 0xe2c2
leaq 0x72f7(%rip), %rsi      # 0x155a8
leaq -0xe(%rbp), %rdx
jmp 0xe2c2
leaq 0x7226(%rip), %rsi      # 0x154e4
leaq -0x9(%rbp), %rdx
movq %rbx, %rdi
callq 0x3be4
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
andq $0x0, 0x10(%rdi)
movups %xmm0, (%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, %r15
movb $0x0, 0x30(%rdi)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x135b0
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe4ec
pushq $0x58
popq %rdi
callq 0x3240
movq %rax, %r12
movq %rax, %rdi
callq 0x372c
movq %r12, 0x20(%rbx)
movq %r12, 0x18(%rbx)
movq (%r15), %rsi
movq %r14, %rdi
callq 0x3df4
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
pushq $0x58
popq %rsi
movq %r12, %rdi
callq 0x3250
jmp 0xe4b3
movq %rax, %r15
jmp 0xe4bb
movq %rax, %r15
movq %r14, %rdi
callq 0x135f8
movq %rbx, %rdi
callq 0xc25a
movq %r15, %rdi
callq 0x3410
nop
// File: /workspace/github_cpp_makefile_star2_O2/RuiDGPires[P]CrimLang/src/preprocessor.cpp
// Function: include(std::vector<crl::Token, std::allocator<crl::Token>>&, crl::preprocessor_lib, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned long&, unsigned long&)
static void include(std::vector<crl::Token> &current, crl::Pproc_lib lib, std::string other, size_t &begin, size_t &i){
	std::vector<crl::Token> other_file = crl::tokenize(other);
	preprocess(other_file, lib);

	size_t other_size = other_file.size();
	current.erase(current.begin() + begin, current.begin() + begin + 4);
	current.insert(current.begin() + begin, other_file.begin(), other_file.end() - 1);
	i += other_size-2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r9, -0x48(%rbp)
movq %r8, %r15
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r14
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
movq %rcx, %rsi
callq 0x32f0
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x1459c
leaq -0x68(%rbp), %rdi
callq 0x3110
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xe9a6
movq -0x40(%rbp), %rbx
movq -0x38(%rbp), %r12
movq (%r14), %rax
imulq $0x30, (%r15), %rcx
leaq (%rax,%rcx), %rsi
leaq (%rax,%rcx), %rdx
addq $0xc0, %rdx
movq %r14, %rdi
callq 0xf0a4
imulq $0x30, (%r15), %rsi
addq (%r14), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq $-0x30, %rcx
movq %r14, %rdi
callq 0xf0ae
subq %rbx, %r12
pushq $0x30
popq %rcx
movq %r12, %rax
cqto
idivq %rcx
movq -0x48(%rbp), %rdx
movq (%rdx), %rcx
addq %rcx, %rax
addq $-0x2, %rax
movq %rax, (%rdx)
leaq -0x40(%rbp), %rdi
callq 0xc25a
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf078
jmp 0xf078
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xc25a
jmp 0xf092
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x3410