LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/lib/alarm.cpp
// Function: Morat::Alarm::Handler::reset(int)
void Alarm::Handler::reset(int signum){
	Time now;

	double next = 0;
	for(std::vector<Entry>::iterator a = alarms.begin(); a != alarms.end(); ++a){
		double cur = a->timeout - now;
		if(cur <= 0 || signum == SIGUSR1){
			if(!a->called){
				a->fn();
				a->called = true;
			}
		}else{
			if(next == 0 || next > cur)
				next = cur;
		}
	}

	if(next > 0){
		struct itimerval timeout;
		timeout.it_interval.tv_usec = 0;
		timeout.it_interval.tv_sec = 0;
		timeout.it_value.tv_usec = (next - (int)next)*1000000;
		timeout.it_value.tv_sec = next;
		setitimer(ITIMER_REAL, &timeout, NULL);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
xorl %esi, %esi
callq 0x55b0
movq 0x8(%r14), %r15
vxorpd %xmm2, %xmm2, %xmm2
cmpq 0x10(%r14), %r15
je 0x30215
vcvtsi2sdq 0x20(%rsp), %xmm0, %xmm0
vcvtsi2sdq 0x28(%rsp), %xmm1, %xmm1
vdivsd 0xe64(%rip), %xmm1, %xmm1 # 0x31008
vaddsd %xmm0, %xmm1, %xmm1
vxorpd %xmm3, %xmm3, %xmm3
vmovsd %xmm1, 0x8(%rsp)
cmpl $0xa, %ebx
je 0x301da
vmovsd 0x28(%r15), %xmm0
vsubsd %xmm1, %xmm0, %xmm0
vucomisd %xmm0, %xmm3
jae 0x301da
vcmpeqsd %xmm3, %xmm2, %k1
vminsd %xmm2, %xmm0, %xmm2
vmovsd %xmm0, %xmm2, %xmm2 {%k1}
jmp 0x3020b
cmpb $0x0, 0x4(%r15)
jne 0x3020b
vmovapd %xmm2, 0x10(%rsp)
cmpq $0x0, 0x18(%r15)
je 0x30262
leaq 0x8(%r15), %rdi
callq *0x20(%r15)
movb $0x1, 0x4(%r15)
vmovapd 0x10(%rsp), %xmm2
vmovsd 0x8(%rsp), %xmm1
vxorpd %xmm3, %xmm3, %xmm3
addq $0x30, %r15
cmpq 0x10(%r14), %r15
jne 0x301b2
vucomisd 0x2033(%rip), %xmm2     # 0x32250
jbe 0x30258
vcvttpd2dq %xmm2, %xmm0
vcvtdq2pd %xmm0, %xmm0
vsubsd %xmm0, %xmm2, %xmm0
vmulsd 0xdd5(%rip), %xmm0, %xmm0 # 0x31008
vxorpd %xmm1, %xmm1, %xmm1
leaq 0x20(%rsp), %rsi
vmovapd %xmm1, (%rsi)
vunpcklpd %xmm0, %xmm2, %xmm0 # xmm0 = xmm2[0],xmm0[0]
vcvttpd2qq %xmm0, %xmm0
vmovapd %xmm0, 0x10(%rsi)
xorl %edi, %edi
xorl %edx, %edx
callq 0x54d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x5100
nop
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/lib/alarm.cpp
// Function: Morat::Alarm::Handler::add(Morat::Time, std::function<void ()>)
int Alarm::Handler::add(Time timeout, callback_t fn){
	Entry entry(nextid, fn, timeout);
	alarms.push_back(entry);

	nextid = (nextid + 1) & 0x3FFFFFFF; //sets a limit of 2^30 alarms, but keeps them in the positive range

	reset(SIGALRM);

	return entry.id;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x58, %rsp
vmovsd %xmm0, (%rsp)
movq %rdi, %r14
movl (%rdi), %ebp
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x144e2
leaq 0x30(%rsp), %rbx
movl %ebp, -0x8(%rbx)
movb $0x0, -0x4(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x144e2
vmovsd (%rsp), %xmm0
vmovsd %xmm0, 0x50(%rsp)
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x302fe
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
leaq 0x8(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x30402
movl (%r14), %eax
incl %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, (%r14)
movq %r14, %rdi
movl $0xe, %esi
callq 0x30162
movl 0x28(%rsp), %ebp
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x30341
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x30394
jmp 0x30394
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x3038c
leaq 0x8(%rsp), %rdi
movq %rdi, %rsi
movl $0x3, %edx
callq *%rax
jmp 0x3038c
jmp 0x30394
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x3038c
movq %rbx, %rdi
movq %rbx, %rsi
movl $0x3, %edx
callq *%rax
movq %r14, %rdi
callq 0x5670
movq %rax, %rdi
callq 0xa7e4
// File: /workspace/github_cpp_makefile_star2_O1/tewalds[P]morat/lib/alarm.cpp
// Function: Morat::Alarm::Handler::cancel(int)
bool Alarm::Handler::cancel(int id){
	if(id < 0)
		return false;
	bool found = false;
	for(std::vector<Entry>::iterator a = alarms.begin(); a != alarms.end(); ){
		if(a->id == id){
			a->called = true;
			found = true;
		}
		if(a->called)
			a = alarms.erase(a);
		else
			++a;
	}
	return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
js 0x303e5
movq %rdi, %r14
movq 0x8(%rdi), %rax
cmpq 0x10(%rdi), %rax
je 0x303e5
movl %esi, %ebp
leaq 0x8(%r14), %r15
xorl %ebx, %ebx
cmpl %ebp, (%rax)
jne 0x303c6
movb $0x1, 0x4(%rax)
movb $0x1, %bl
cmpb $0x1, 0x4(%rax)
jne 0x303d9
movq %r15, %rdi
movq %rax, %rsi
callq 0x30724
jmp 0x303dd
addq $0x30, %rax
cmpq 0x10(%r14), %rax
jne 0x303bc
jmp 0x303e7
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1f34e(%rip), %rax     # 0x22be8
movq %rax, (%rdi)
movq 0x18(%rdi), %r14
subq 0x10(%rdi), %r14
je 0x38d1
sarq $0x3, %r14
cmpq $0x1, %r14
adcq $0x0, %r14
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x38c9
movq (%rdi), %rax
callq *0x8(%rax)
incq %r15
cmpq %r15, %r14
jne 0x38b6
movq 0x30(%rbx), %rdi
leaq 0x40(%rbx), %rax
cmpq %rax, %rdi
je 0x38e9
movq (%rax), %rsi
incq %rsi
callq 0x3230
movq 0x10(%rbx), %rdi
testq %rdi, %rdi
je 0x3908
movq 0x20(%rbx), %rsi
subq %rdi, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x3230
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r12
movq %r12, %rdi
movq %rdx, %rsi
callq 0x4de4
leaq 0x10(%r15), %rcx
cmpq %rcx, %rax
je 0x44e6
movq %r12, %rdi
movq %r14, %rsi
callq 0x47b8
movq %rax, %r15
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %r13
movq %r13, 0x8(%rbx)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %rdi, -0x30(%rbp)
callq 0x4d4a
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %r14
movq %r14, 0x28(%rbx)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4d4a
movb 0x50(%r15), %al
movb %al, 0x50(%rbx)
movq 0x48(%r15), %rax
movq %rax, 0x48(%rbx)
leaq 0x58(%rbx), %rdi
addq $0x58, %r15
movq %r15, %rsi
callq 0x4ad0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq (%r15), %r15
testq %r15, %r15
je 0x4531
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4d4a
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x442e
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0x44d4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x44d4
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x10(%rbx)
movb %al, 0x18(%rbx)
leaq 0x38(%rbx), %rcx
movq %rcx, 0x28(%rbx)
movq %rax, 0x30(%rbx)
movb %al, 0x38(%rbx)
movb %al, 0x48(%rbx)
movl %eax, 0x4c(%rbx)
movb %al, 0x50(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x58(%rbx)
movq %rax, 0x68(%rbx)
movl %eax, (%rbx)
jmp 0x44d4
movq %rax, %rbx
movq -0x50(%rbp), %rdi
jmp 0x4598
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x4591
movq (%r14), %rsi
incq %rsi
callq 0x3230
jmp 0x4591
movq %rax, %rbx
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq %r13, %rdi
je 0x45a9
movq (%r13), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1da80(%rip), %rax     # 0x22ca0
movq %rax, (%rdi)
leaq 0x8(%rdi), %r14
leaq 0x18(%rdi), %r15
movq %r15, 0x8(%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movb %al, 0x18(%rdi)
leaq 0x28(%rdi), %r12
leaq 0x38(%rdi), %r13
movq %r13, 0x28(%rdi)
movq %rax, 0x30(%rdi)
movb %al, 0x38(%rdi)
movl %esi, 0x48(%rdi)
movl %edx, 0x4c(%rdi)
leaq 0x15ee9(%rip), %rcx     # 0x1b141
movl $0x12, %r8d
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x3340
movq 0x30(%rbx), %rdx
leaq 0x1626f(%rip), %rcx     # 0x1b4e4
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x3340
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x30(%rbp)
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x52aa
movq (%r13), %rsi
incq %rsi
callq 0x3230
movq %r14, %rdi
movq %r15, %rsi
callq 0x3481
movq %rbx, %rdi
callq 0x3410
movq -0x30(%rbp), %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0x122a0(%rip), %rsi     # 0x1b68e
callq 0x30a0
testl %eax, %eax
je 0x94ee
leaq 0x11ecc(%rip), %rsi     # 0x1b2ce
movq %rbx, %rdi
callq 0x30a0
movl $0x1, %r14d
testl %eax, %eax
je 0x94f1
leaq 0x12274(%rip), %rsi     # 0x1b693
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94f1
leaq 0x12261(%rip), %rsi     # 0x1b697
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94f1
leaq 0x1224e(%rip), %rsi     # 0x1b69b
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94f1
leaq 0x1223c(%rip), %rsi     # 0x1b6a0
movq %rbx, %rdi
callq 0x30a0
movl $0x2, %r14d
testl %eax, %eax
je 0x94f1
leaq 0x12227(%rip), %rsi     # 0x1b6a4
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94f1
leaq 0x12218(%rip), %rsi     # 0x1b6a8
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94f1
movl $0x50, %edi
callq 0x3120
movq %rax, %r14
leaq 0x121fc(%rip), %rsi     # 0x1b6ac
leaq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x40f6
movb $0x1, %r15b
leaq -0x38(%rbp), %rcx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0x19899(%rip), %rsi     # 0x22d78
leaq -0x3f00(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
xorl %r14d, %r14d
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9523
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x9523
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0x9530
movq %r14, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %r14
movq 0x5a0(%rdi), %rax
movq %rax, -0x30(%rbp)
movq 0x18(%rsi), %rbx
subq 0x10(%rsi), %rbx
je 0xae17
movq %rsi, %r15
sarq $0x3, %rbx
leaq 0x318(%r14), %r12
cmpq $0x1, %rbx
adcq $0x0, %rbx
xorl %r13d, %r13d
movq (%r15), %rax
movq %r15, %rdi
movl %r13d, %esi
callq *0x18(%rax)
movq %r14, %rdi
movq %rax, %rsi
movq %r12, %rdx
callq 0xaf60
incq %r13
cmpq %r13, %rbx
jne 0xadf5
addq $0x530, %r14            # imm = 0x530
movq %r14, %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xe1d2
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0x18(%rsi), %rax
cmpq 0x10(%rsi), %rax
je 0xae98
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x18(%rax)
leaq 0x318(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8c94
leaq 0x328(%rbx), %r14
leaq 0x10686(%rip), %rsi     # 0x1b4fd
movl $0x7, %edx
movq %r14, %rdi
callq 0x3280
leaq 0x1067a(%rip), %rsi     # 0x1b505
movl $0xf, %edx
movq %r14, %rdi
callq 0x3280
leaq 0x328(%rbx), %r14
leaq 0x1066f(%rip), %rsi     # 0x1b515
movl $0x4, %edx
movq %r14, %rdi
callq 0x3280
movq 0x4a0(%rbx), %rsi
movq 0x4a8(%rbx), %rdx
movq %r14, %rdi
callq 0x3280
leaq 0x1064a(%rip), %rsi     # 0x1b51a
movl $0x5, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %r15
leaq 0xdd18(%rip), %rsi      # 0x1b5fd
movl $0x12, %edx
movq %r15, %rdi
callq 0x3280
leaq 0xdd17(%rip), %rsi      # 0x1b610
movl $0x8, %edx
movq %r15, %rdi
callq 0x3280
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
cmpq %r12, %r15
je 0xd931
leaq 0x318(%rbx), %r14
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xaf60
addq $0x8, %r15
cmpq %r12, %r15
jne 0xd91a
movq (%rbx), %r14
leaq 0x20(%rbx), %rsi
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x3370
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3280
leaq -0x30(%rbp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0xd96d
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq (%rbx), %rdi
leaq 0xdca2(%rip), %rsi      # 0x1b619
movl $0x15, %edx
callq 0x3280
movq (%rbx), %r14
leaq 0x1a8(%rbx), %rsi
movq %r15, %rdi
callq 0x3370
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3280
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xd9b7
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq (%rbx), %r14
leaq 0xdc6e(%rip), %rsi      # 0x1b62f
movl $0x7, %edx
movq %r14, %rdi
callq 0x3280
leaq 0xdc62(%rip), %rsi      # 0x1b637
movl $0x9, %edx
movq %r14, %rdi
callq 0x3280
movq (%rbx), %rdi
leaq 0xdc55(%rip), %rsi      # 0x1b641
movl $0x4, %edx
callq 0x3280
movq (%rbx), %rdi
leaq 0xdc46(%rip), %rsi      # 0x1b646
movl $0x12, %edx
callq 0x3280
movq (%rbx), %r14
addq $0x330, %rbx            # imm = 0x330
movq %r15, %rdi
movq %rbx, %rsi
callq 0x3370
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %rdi
callq 0x3280
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xda43
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xda52
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xda6a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
movq %rax, %rbx
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xda5e
jmp 0xda6a
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x800, %rsp            # imm = 0x800
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x260(%rbp), %r15
movq %r15, %rdi
callq 0x33c0
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x3100
cmpl $0x0, 0x8(%rbx)
jne 0xdb6c
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x8, %rax
jne 0xdbcd
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x18(%rax)
movq %rax, %rbx
leaq -0x818(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0xe678
leaq -0x500(%rbp), %rdx
leaq -0x818(%rbp), %rdi
movq %rbx, %rsi
callq 0xaf60
leaq -0x260(%rbp), %rdi
callq 0x32f0
leaq -0x818(%rbp), %rdi
callq 0xe850
movq 0x1549b(%rip), %rax     # 0x22fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x258(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x260(%rbp,%rcx)
callq 0x31e0
leaq -0x168(%rbp), %rdi
callq 0x30c0
addq $0x800, %rsp            # imm = 0x800
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x3120
movq %rax, %r14
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xdad0(%rip), %rsi      # 0x1b659
leaq 0xdad5(%rip), %rdx      # 0x1b665
leaq -0x60(%rbp), %rdi
callq 0x433a
movb $0x1, %r15b
leaq -0x60(%rbp), %rcx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0x151bc(%rip), %rsi     # 0x22d78
leaq -0x85dd(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
jmp 0xdc2c
movl $0x50, %edi
callq 0x3120
movq %rax, %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xda7c(%rip), %rsi      # 0x1b666
leaq 0xda81(%rip), %rdx      # 0x1b672
leaq -0x40(%rbp), %rdi
callq 0x433a
movb $0x1, %r15b
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0x1515b(%rip), %rsi     # 0x22d78
leaq -0x863e(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xdc60
movq -0x30(%rbp), %rsi
jmp 0xdc50
jmp 0xdc5a
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xdc60
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0xdc60
movq %rax, %rbx
movb $0x1, %r15b
testb %r15b, %r15b
je 0xdc85
movq %r14, %rdi
callq 0x31a0
jmp 0xdc85
jmp 0xdc82
movq %rax, %rbx
leaq -0x818(%rbp), %rdi
callq 0xe850
jmp 0xdc85
movq %rax, %rbx
leaq -0x260(%rbp), %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq (%rdi), %rax
movq 0x10(%rdi), %rsi
movl 0x18(%rdi), %ecx
subq %rax, %rsi
shlq $0x3, %rsi
addq %rcx, %rsi
setne %dl
je 0xdd3d
movq (%rax), %r10
testb $0x1, %r10b
jne 0xdcd7
movl $0x1, %r9d
xorl %ecx, %ecx
xorl %esi, %esi
jmp 0xdd34
movabsq $-0x8000000000000000, %rdi # imm = 0x8000000000000000
xorl %ecx, %ecx
leaq 0x3f(%rdi), %r8
incq %rcx
cmpq %rsi, %rcx
setb %dl
jae 0xdd3d
leaq 0x3f(%rcx), %r10
testq %rcx, %rcx
cmovnsq %rcx, %r10
sarq $0x6, %r10
movq %rcx, %r9
andq %r8, %r9
xorl %r11d, %r11d
cmpq %rdi, %r9
setbe %r11b
movl $0x1, %r9d
shlq %cl, %r9
leaq (%rax,%r10,8), %rbx
movq -0x8(%rbx,%r11,8), %r10
btq %rcx, %r10
jb 0xdce7
leaq -0x8(,%r11,8), %rsi
movq %rbx, %rax
orq %r10, %r9
movq %r9, (%rax,%rsi)
jmp 0xdd3d
testb %dl, %dl
je 0xdd50
movl %ecx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x50, %edi
callq 0x3120
movq %rax, %rbx
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xd906(%rip), %rsi      # 0x1b673
leaq 0xd917(%rip), %rdx      # 0x1b68b
leaq -0x40(%rbp), %rdi
callq 0x433a
movb $0x1, %r15b
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r15d, %r15d
leaq 0x14fd8(%rip), %rsi     # 0x22d78
leaq -0x87c1(%rip), %rdx     # 0x55e6
movq %rbx, %rdi
callq 0x33d0
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xddcf
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0xddcf
movq %rax, %r14
movb $0x1, %r15b
testb %r15b, %r15b
je 0xdddc
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
leaq -0x38(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x48(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4d4a
movl 0x78(%r14), %eax
movl %eax, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xeb42
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdf46
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movl 0x78(%r14), %eax
addl %eax, %ebx
movl %ebx, 0x78(%r14)
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdf75
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movl %ecx, %r14d
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0xe9aa
leaq 0x38(%rbx), %rcx
cmpq %rcx, %rax
movq %r12, -0x40(%rbp)
jne 0xe0c7
movq %r15, -0x38(%rbp)
movl %r14d, -0x2c(%rbp)
xorps %xmm0, %xmm0
leaq -0x60(%rbp), %r15
movaps %xmm0, (%r15)
movq $0x0, 0x10(%r15)
movq %r15, 0x8(%r15)
movq %r15, (%r15)
leaq -0x98(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xed5e
movl %r13d, %r14d
leaq -0x98(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xee28
leaq -0x78(%rbp), %r13
movq (%r13), %rdi
cmpq %r13, %rdi
je 0xe07b
movq (%rdi), %r12
movl $0x18, %esi
callq 0x3230
movq %r12, %rdi
cmpq %r13, %r12
jne 0xe066
leaq -0x88(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
movl %r14d, %r13d
je 0xe09d
movq -0x88(%rbp), %rsi
incq %rsi
callq 0x3230
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xe0bb
movq (%rdi), %r12
movl $0x18, %esi
callq 0x3230
movq %r12, %rdi
cmpq %r15, %r12
jne 0xe0a6
movl -0x2c(%rbp), %r14d
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r15
addl %r13d, 0x80(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe94c
movq %rax, %r15
movl 0x80(%rbx), %r13d
movq (%rax), %r12
movl $0x18, %edi
callq 0x3220
movzbl %r14b, %ecx
shlq $0x20, %rcx
orq %r13, %rcx
movq %rcx, 0x10(%rax)
movq %rax, %rdi
movq %r12, %rsi
callq 0x3040
incq 0x10(%r15)
leaq 0x60(%rbx), %rdi
movq 0x60(%rbx), %r15
movq -0x40(%rbp), %rsi
callq 0xf0cc
movq %rax, %rdi
movq %r15, %rsi
callq 0x3040
incq 0x70(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0xedcc
jmp 0xe151
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xe16f
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3230
movq %r14, %rdi
cmpq %r15, %r14
jne 0xe15a
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x70(%rdi), %r13
movl %esi, %eax
movq %rax, -0x30(%rbp)
cmpq %rax, %r13
jbe 0xe26f
movq %rdi, %rbx
leaq 0x60(%rdi), %r14
leaq -0x40(%rbp), %r12
addq $0x30, %rbx
movq (%r14), %rax
movq %r12, -0x50(%rbp)
movq 0x10(%rax), %rsi
movq 0x18(%rax), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x4d4a
movq (%r14), %rsi
movq %r14, %rdi
callq 0xf11e
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe94c
movq (%rax), %r15
decq 0x10(%rax)
movq %r15, %rdi
callq 0x3390
movl $0x18, %esi
movq %r15, %rdi
callq 0x3230
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xe266
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3230
decq %r13
cmpq -0x30(%rbp), %r13
ja 0xe201
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0xe296
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf961
callq 0xf8a4
cmpl %ebx, %r14d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq -0xd0(%rbp), %r10
movq %rdx, 0x10(%r10)
movq %rcx, 0x18(%r10)
movq %r8, 0x20(%r10)
movq %r9, 0x28(%r10)
testb %al, %al
je 0xf9b9
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 %r10, -0x10(%rbp)
leaq 0x10(%rbp), %r8
movq %r8, -0x18(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x20(%rbp)
movl $0x10, %eax
movl 0x58(%rdi), %ecx
incl %esi
xorl %ebx, %ebx
movl $0x1, %edx
decl %esi
testl %esi, %esi
jle 0xfa16
cmpl $0x28, %eax
ja 0xfa00
movq %r8, %r9
movl %eax, %r8d
addq %r10, %r8
addl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0xfa08
leaq 0x8(%r8), %r9
movq %r9, -0x18(%rbp)
cmpl (%r8), %ecx
movzbl %bl, %ebx
cmovel %edx, %ebx
movq %r9, %r8
jne 0xf9e4
testb $0x1, %bl
je 0xfa20
callq 0xf8a4
andb $0x1, %bl
movl %ebx, %eax
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfae5
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), %r9
movq %r9, -0x28(%rbp)
movabsq $0x3000000010, %rax     # imm = 0x3000000010
movq %rax, -0x30(%rbp)
movl $0x10, %ecx
movl 0x58(%rbx), %edx
incl %esi
xorl %eax, %eax
movl $0x1, %r8d
decl %esi
testl %esi, %esi
jle 0xfb44
cmpl $0x28, %ecx
ja 0xfb2d
movq %r9, %r10
movl %ecx, %r9d
addq %rdi, %r9
addl $0x8, %ecx
movl %ecx, -0x30(%rbp)
jmp 0xfb35
leaq 0x8(%r9), %r10
movq %r10, -0x28(%rbp)
cmpl (%r9), %edx
movzbl %al, %eax
cmovel %r8d, %eax
movq %r10, %r9
jne 0xfb11
testb $0x1, %al
je 0xfb5c
movq %rbx, %rdi
callq 0xf8a4
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movl $0x50, %edi
callq 0x3120
movq %rax, %r14
addq $0x38, %rbx
movq %rax, %rdi
movq %rbx, %rsi
callq 0x53b0
leaq 0x131c9(%rip), %rsi     # 0x22d48
leaq -0xa5a0(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movl $0x58, %edi
callq 0x3220
movq %rax, %rbx
movq 0x18(%r14), %rdx
movq %rax, %rdi
movl %r15d, %esi
callq 0x3852
movq 0x18(%r14), %rsi
addq $0x10, %rsi
movq %rbx, %rdi
addq $0x10, %rdi
callq 0x12292
movq 0x18(%r14), %rdi
movq 0x10(%rdi), %rax
cmpq %rax, 0x18(%rdi)
je 0xfc54
movq %rax, 0x18(%rdi)
movq (%rdi), %rax
movq %rbx, %rsi
callq *0x10(%rax)
movq %rbx, 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0x58, %esi
movq %rbx, %rdi
callq 0x3230
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xc, %esi
callq 0xfba2
movq (%rbx), %r15
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r12
shlq $0x4, %r12
leaq -0x98(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x30(%r15,%r12), %rsi
movq -0x28(%r15,%r12), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %r14
movq %r14, %rdi
callq 0x4d4a
movl -0x8(%r15,%r12), %eax
movl %eax, 0x28(%r14)
movq -0x10(%r15,%r12), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfca8
leaq -0xa8(%rbp), %rdi
callq 0x192b0
movq %rbx, %rdi
movl $0x20, %esi
callq 0xfa30
cmpl $0x21, 0x58(%rbx)
jne 0xfdfe
movq %rbx, %rdi
callq 0xf8a4
jmp 0xff06
leaq -0x38(%rbp), %r14
leaq -0x78(%rbp), %r12
movq %rbx, %rdi
movl $0x12, %esi
callq 0xfba2
cmpl $0x1e, 0x58(%rbx)
jne 0xfed2
movq %rbx, %rdi
callq 0xf8a4
movq %r14, -0x48(%rbp)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
leaq 0xb6e9(%rip), %rsi      # 0x1b520
leaq 0xb6e5(%rip), %rdx      # 0x1b523
callq 0x433a
movq 0x18(%rbx), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x3150
movq %r12, %r15
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xfe6b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
movl $0x1, %esi
callq 0xfa30
movq (%rbx), %r14
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r12
shlq $0x4, %r12
leaq -0x68(%rbp), %r13
movq %r13, -0x78(%rbp)
movq -0x30(%r14,%r12), %rsi
movq -0x28(%r14,%r12), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x4d4a
movl -0x8(%r14,%r12), %eax
movl %eax, 0x18(%r13)
movq -0x10(%r14,%r12), %rax
movq %r15, %r12
movq %rax, 0x10(%r13)
movq %rbx, %rdi
movq %r15, %rsi
callq 0xfca8
movq %r12, %rdi
callq 0x192b0
leaq -0x38(%rbp), %r14
jmp 0xfeda
movq %rbx, %rdi
callq 0xff5e
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
cmpl $0x29, 0x58(%rbx)
jne 0xfef9
movq %rbx, %rdi
callq 0xf8a4
jmp 0xfe06
movq %rbx, %rdi
movl $0x21, %esi
callq 0xfa30
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 -0xa8(%rbp), %rdi
jmp 0xff51
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xff56
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0xff56
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xd, %esi
callq 0xfba2
movq %rbx, %rdi
callq 0x107d6
movq %rbx, %rdi
movl $0x2, %esi
movl $0x36, %edx
movl $0x35, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
je 0x1001b
leaq -0x48(%rbp), %r15
leaq -0x58(%rbp), %r14
movq (%rbx), %r12
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movq %r15, -0x58(%rbp)
movq -0x30(%r12,%r13), %rsi
movq -0x28(%r12,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d4a
movl -0x8(%r12,%r13), %eax
movl %eax, 0x18(%r15)
movq -0x10(%r12,%r13), %rax
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfca8
movq %r14, %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x107d6
movq %rbx, %rdi
movl $0x2, %esi
movl $0x36, %edx
movl $0x35, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
jne 0xffa9
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 0x192b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xe, %esi
callq 0xfba2
movq %rbx, %rdi
callq 0x1004a
movq %rbx, %rdi
movl $0x2, %esi
movl $0x15, %edx
movl $0x1a, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
je 0x10641
leaq -0x48(%rbp), %r15
leaq -0x58(%rbp), %r14
movq (%rbx), %r12
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movq %r15, -0x58(%rbp)
movq -0x30(%r12,%r13), %rsi
movq -0x28(%r12,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d4a
movl -0x8(%r12,%r13), %eax
movl %eax, 0x18(%r15)
movq -0x10(%r12,%r13), %rax
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfca8
movq %r14, %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x1004a
movq %rbx, %rdi
movl $0x2, %esi
movl $0x15, %edx
movl $0x1a, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
jne 0x105cf
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 0x192b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xd, %esi
callq 0xfba2
movq %rbx, %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
je 0x10707
movq (%rbx), %r15
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r12
shlq $0x4, %r12
leaq -0x78(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x30(%r15,%r12), %rsi
movq -0x28(%r15,%r12), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x4d4a
movl -0x8(%r15,%r12), %eax
movl %eax, 0x28(%r14)
movq -0x10(%r15,%r12), %rax
movq %rax, 0x20(%r14)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfca8
leaq -0x88(%rbp), %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x10584
movq %rbx, %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
je 0x107a6
leaq -0x48(%rbp), %r15
leaq -0x58(%rbp), %r14
movq (%rbx), %r12
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movq %r15, -0x58(%rbp)
movq -0x30(%r12,%r13), %rsi
movq -0x28(%r12,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d4a
movl -0x8(%r12,%r13), %eax
movl %eax, 0x18(%r15)
movq -0x10(%r12,%r13), %rax
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfca8
movq %r14, %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x10584
movq %rbx, %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
xorl %eax, %eax
callq 0xf96c
testb %al, %al
jne 0x10734
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 0x107c3
movq %rax, %rbx
movq %r14, %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x18, %esi
callq 0xfba2
movq %rbx, %rdi
callq 0x10670
movq %rbx, %rdi
movl $0x6, %esi
movl $0x2f, %edx
movl $0x34, %ecx
movl $0x31, %r8d
movl $0x30, %r9d
xorl %eax, %eax
pushq $0x33
pushq $0x32
callq 0xf96c
addq $0x10, %rsp
testb %al, %al
je 0x108c3
leaq -0x48(%rbp), %r15
leaq -0x58(%rbp), %r14
movq (%rbx), %r12
movq 0x28(%rbx), %rax
leaq (%rax,%rax,2), %r13
shlq $0x4, %r13
movq %r15, -0x58(%rbp)
movq -0x30(%r12,%r13), %rsi
movq -0x28(%r12,%r13), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d4a
movl -0x8(%r12,%r13), %eax
movl %eax, 0x18(%r15)
movq -0x10(%r12,%r13), %rax
movq %rax, 0x10(%r15)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xfca8
movq %r14, %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x10670
movq %rbx, %rdi
movl $0x6, %esi
movl $0x2f, %edx
movl $0x34, %ecx
movl $0x31, %r8d
movl $0x30, %r9d
xorl %eax, %eax
pushq $0x33
pushq $0x32
callq 0xf96c
addq $0x10, %rsp
testb %al, %al
jne 0x10839
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 0x192b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0xd, %esi
callq 0xfba2
movq %rbx, %rdi
movl $0x18, %esi
callq 0xfba2
movq %rbx, %rdi
movl $0xd, %esi
callq 0xfba2
movq %rbx, %rdi
movl $0xe, %esi
callq 0xfba2
movq %rbx, %rdi
movl $0xf, %esi
callq 0xfba2
movq %rbx, %rdi
movl $0x15, %esi
callq 0xfba2
movq %rbx, %rdi
callq 0xff5e
leaq -0x40(%rbp), %r14
movq %r14, %rdi
callq 0x19244
movl $0x9, 0x20(%r14)
movq 0x8(%r14), %rdx
leaq 0xad21(%rip), %rcx      # 0x1b693
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x3340
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
addq %rsi, %rdx
leaq -0x70(%rbp), %rdi
callq 0x4d4a
leaq -0x20(%rbp), %rax
movl 0x8(%rax), %ecx
leaq -0x70(%rbp), %rsi
movl %ecx, 0x28(%rsi)
movq (%rax), %rax
movq %rax, 0x20(%rsi)
movq %rbx, %rdi
callq 0xfca8
leaq -0x70(%rbp), %rdi
callq 0x192b0
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
leaq -0x40(%rbp), %rdi
callq 0x192b0
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x192b0
jmp 0x10a1b
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %esi
callq 0xfba2
cmpl $0x3a, 0x58(%rbx)
je 0x10a4f
movq %rbx, %rdi
callq 0x10a6a
jmp 0x10a3f
movq %rbx, %rdi
callq 0xf8a4
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x5, %esi
callq 0xfba2
cmpl %r14d, 0x58(%rbx)
je 0x11691
movq %rbx, %rdi
callq 0x116aa
jmp 0x11681
movq %rbx, %rdi
callq 0xf8a4
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_O1/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
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
addl $-0x2a, %esi
cmpl $0x4, %esi
ja 0x121d6
leaq 0x954f(%rip), %rax      # 0x1b71c
movslq (%rax,%rsi,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x9307(%rip), %rdx      # 0x1b4e4
movq %rbx, %rdi
movq %rdx, %rsi
jmp 0x12226
leaq 0x93d9(%rip), %rsi      # 0x1b5c5
leaq 0x93d7(%rip), %rdx      # 0x1b5ca
jmp 0x12223
leaq 0x93b5(%rip), %rsi      # 0x1b5b1
leaq 0x93b3(%rip), %rdx      # 0x1b5b6
jmp 0x12223
leaq 0x93af(%rip), %rsi      # 0x1b5bb
leaq 0x93ad(%rip), %rdx      # 0x1b5c0
jmp 0x12223
leaq 0x938c(%rip), %rsi      # 0x1b5a8
leaq 0x9389(%rip), %rdx      # 0x1b5ac
movq %rbx, %rdi
callq 0x433a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
xorl %eax, %eax
movq %rax, 0x10(%rdi)
movq %rax, 0x28(%rdi)
movb $0x0, 0x30(%rdi)
leaq 0x38(%rdi), %r14
movq %r14, %rdi
callq 0x19244
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1248e
movl $0x58, %edi
callq 0x3220
movq %rax, %r12
movq %rax, %rdi
callq 0x381c
movq %r12, 0x20(%rbx)
movq %r12, 0x18(%rbx)
movq (%r15), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x3150
movl 0x28(%r15), %eax
movl %eax, 0x60(%rbx)
movq 0x20(%r15), %rax
movq %rax, 0x58(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movl $0x58, %esi
movq %r12, %rdi
callq 0x3230
jmp 0x12475
movq %rax, %r15
jmp 0x1247d
movq %rax, %r15
movq %r14, %rdi
callq 0x192b0
movq %rbx, %rdi
callq 0xf780
movq %r15, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq (%rcx), %rsi
movq 0x8(%rcx), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %rbx
movq %rbx, %rdi
callq 0x4d4a
leaq -0x40(%rbp), %rdi
movq %rbx, %rsi
callq 0x1a546
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x13505
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3230
leaq -0x40(%rbp), %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x12a0c
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %rbx
movq (%r14), %rax
movq (%r15), %rcx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
leaq (%rax,%rcx), %rsi
leaq (%rax,%rcx), %rdx
addq $0xc0, %rdx
movq %r14, %rdi
callq 0x135d8
movq (%r15), %rax
leaq (%rax,%rax,2), %rsi
shlq $0x4, %rsi
addq (%r14), %rsi
movq -0x40(%rbp), %rdx
movq -0x38(%rbp), %rcx
addq $-0x30, %rcx
movq %r14, %rdi
callq 0x13690
subq %r12, %rbx
sarq $0x4, %rbx
movabsq $-0x5555555555555555, %rax # imm = 0xAAAAAAAAAAAAAAAB
imulq %rbx, %rax
movq -0x48(%rbp), %rdx
movq (%rdx), %rcx
addq %rcx, %rax
addq $-0x2, %rax
movq %rax, (%rdx)
leaq -0x40(%rbp), %rdi
callq 0xf780
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x135a5
jmp 0x135a5
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0xf780
movq %rbx, %rdi
callq 0x33f0
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x135b1
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x135b1
nop