LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Side::to_s[abi:cxx11]() const
std::string Side::to_s() const {
	if(*this == UNDEF) return "never";
	if(*this == NONE)  return "none";
	if(*this == P1)    return "white";
	if(*this == P2)    return "black";
	if(*this == BOTH)  return "both";
	return "unknown";
}

// Assembly:
pushq %rbx
movzbl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rdi, %rbx
movq %rcx, (%rdi)
cmpq $0x3, %rax
ja 0x2f416
leaq 0x6f7b(%rip), %rcx      # 0x36378
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x3375(%rip), %rsi      # 0x32782
leaq 0x3372(%rip), %rdx      # 0x32786
jmp 0x2f46b
cmpl $0xfc, %eax
jne 0x2f42d
leaq 0x6f91(%rip), %rsi      # 0x363b5
leaq 0x6f8f(%rip), %rdx      # 0x363ba
jmp 0x2f46b
leaq 0x3346(%rip), %rsi      # 0x3277a
leaq 0x3346(%rip), %rdx      # 0x32781
jmp 0x2f46b
leaq 0x2039(%rip), %rsi      # 0x3147d
leaq 0x2037(%rip), %rdx      # 0x31482
jmp 0x2f46b
leaq 0x6f67(%rip), %rsi      # 0x363bb
leaq 0x6f64(%rip), %rdx      # 0x363bf
jmp 0x2f46b
leaq 0x1fe3(%rip), %rsi      # 0x31447
leaq 0x1fe1(%rip), %rdx      # 0x3144c
movq %rbx, %rdi
callq 0xb1dc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Outcome::to_s[abi:cxx11]() const
std::string Outcome::to_s() const {
	if(*this == UNDEF)   return "undefined";
	if(*this == UNKNOWN) return "unknown";
	if(*this == P2_DRAW) return "black_or_draw";
	if(*this == P1_DRAW) return "white_or_draw";
	if(*this == DRAW ||
	   *this == DRAW2)   return "draw"; // simultaneous win
	if(*this == P1)      return "white";
	if(*this == P2)      return "black";
    return "unknown";
}

// Assembly:
pushq %rbx
movzbl (%rsi), %eax
movq %rdi, %rbx
cmpq $0x3, %rax
jbe 0x2f51c
addl $0xffffff04, %eax       # imm = 0xFFFFFF04
cmpl $0x3, %eax
ja 0x2f540
leaq 0x6e9c(%rip), %rcx      # 0x36398
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
leaq 0x6eb4(%rip), %rsi      # 0x363c4
leaq 0x6eb6(%rip), %rdx      # 0x363cd
jmp 0x2f5a2
leaq 0x6e65(%rip), %rcx      # 0x36388
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x10(%rbx), %rax
leaq 0x6ed3(%rip), %rsi      # 0x3640a
leaq 0x6ed0(%rip), %rdx      # 0x3640e
jmp 0x2f5a2
leaq 0x10(%rbx), %rax
leaq 0x322f(%rip), %rsi      # 0x3277a
leaq 0x322f(%rip), %rdx      # 0x32781
jmp 0x2f5a2
leaq 0x10(%rbx), %rax
leaq 0x1ee8(%rip), %rsi      # 0x31447
leaq 0x1ee6(%rip), %rdx      # 0x3144c
jmp 0x2f5a2
leaq 0x10(%rbx), %rax
leaq 0x6e5b(%rip), %rsi      # 0x363ce
leaq 0x6e61(%rip), %rdx      # 0x363db
jmp 0x2f5a2
leaq 0x10(%rbx), %rax
leaq 0x1ef6(%rip), %rsi      # 0x3147d
leaq 0x1ef4(%rip), %rdx      # 0x31482
jmp 0x2f5a2
leaq 0x10(%rbx), %rax
leaq 0x6e41(%rip), %rsi      # 0x363dc
leaq 0x6e47(%rip), %rdx      # 0x363e9
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xb1dc
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Side::to_s_short[abi:cxx11]() const
std::string Side::to_s_short() const {
	if(*this == NONE)  return "N";
	if(*this == P1)    return "W";
	if(*this == P2)    return "B";
	return "U";
}

// Assembly:
pushq %rbx
movzbl (%rsi), %eax
leaq 0x10(%rdi), %rcx
movq %rdi, %rbx
movq %rcx, (%rdi)
cmpl $0x2, %eax
je 0x2f5ee
cmpl $0x1, %eax
je 0x2f5de
testl %eax, %eax
jne 0x2f5fe
leaq 0x6deb(%rip), %rsi      # 0x363c0
leaq 0x6de5(%rip), %rdx      # 0x363c1
jmp 0x2f60c
leaq 0x3e0c(%rip), %rsi      # 0x333f1
leaq 0x3e06(%rip), %rdx      # 0x333f2
jmp 0x2f60c
leaq 0x3dfe(%rip), %rsi      # 0x333f3
leaq 0x3df8(%rip), %rdx      # 0x333f4
jmp 0x2f60c
leaq 0x6dbd(%rip), %rsi      # 0x363c2
leaq 0x6db7(%rip), %rdx      # 0x363c3
movq %rbx, %rdi
callq 0xb1dc
movq %rbx, %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/outcome.cpp
// Function: Morat::Outcome::to_s_rel[abi:cxx11](Morat::Side) const
std::string Outcome::to_s_rel(Side to_play) const {
	if(*this == Outcome::DRAW)  return "draw";
	if(*this == Outcome::DRAW2) return "draw by simultaneous win";
	if(*this == +to_play)       return "win";
	if(*this == +~to_play)      return "loss";
	if(*this == -~to_play)      return "win or draw";
	if(*this == -to_play)       return "loss or draw";
	return "unkown";
}

// Assembly:
pushq %rbx
movzbl (%rsi), %eax
movq %rdi, %rbx
cmpl $0x3, %eax
je 0x2f63e
testl %eax, %eax
jne 0x2f652
leaq 0x10(%rbx), %rax
leaq 0x6dd5(%rip), %rsi      # 0x3640a
leaq 0x6dd2(%rip), %rdx      # 0x3640e
jmp 0x2f69e
leaq 0x10(%rbx), %rax
leaq 0x6da1(%rip), %rsi      # 0x363ea
leaq 0x6db2(%rip), %rdx      # 0x36402
jmp 0x2f69e
cmpb %dl, %al
jne 0x2f66a
leaq 0x10(%rbx), %rax
leaq 0x6d9e(%rip), %rsi      # 0x363ff
leaq 0x6d9a(%rip), %rdx      # 0x36402
jmp 0x2f69e
movb $0x3, %cl
subb %dl, %cl
cmpb %cl, %al
jne 0x2f686
leaq 0x10(%rbx), %rax
leaq 0x5f44(%rip), %rsi      # 0x355c1
leaq 0x5f41(%rip), %rdx      # 0x355c5
jmp 0x2f69e
movl %eax, %ecx
addb %dl, %cl
jne 0x2f6ae
leaq 0x10(%rbx), %rax
leaq 0x6d6c(%rip), %rsi      # 0x36403
leaq 0x6d70(%rip), %rdx      # 0x3640e
movq %rax, (%rbx)
movq %rbx, %rdi
callq 0xb1dc
movq %rbx, %rax
popq %rbx
retq
leaq 0x10(%rbx), %rcx
addb $-0x3, %dl
movq %rcx, (%rbx)
cmpb %dl, %al
jne 0x2f6cc
leaq 0x6d4c(%rip), %rsi      # 0x3640f
leaq 0x6d51(%rip), %rdx      # 0x3641b
jmp 0x2f6a1
leaq 0x6d49(%rip), %rsi      # 0x3641c
leaq 0x6d48(%rip), %rdx      # 0x36422
jmp 0x2f6a1
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/string.cpp
// Function: Morat::to_str[abi:cxx11](double, int)
string to_str(double a, int prec){
	double p = pow(10.0, prec);
	a = round(a*p)/p;

	stringstream out;
	out << a;
	return out.str();
}

// Assembly:
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
vmovsd %xmm0, (%rsp)
vcvtsi2sd %esi, %xmm1, %xmm1
vmovsd 0x6d27(%rip), %xmm0     # 0x36428
movq %rdi, %rbx
callq 0x5650
vmulsd (%rsp), %xmm0, %xmm1
vpbroadcastq 0x6d19(%rip), %xmm2 # 0x36430
leaq 0x8(%rsp), %rdi
vpternlogq $0xf8, 0x6d11(%rip){1to2}, %xmm1, %xmm2 # 0x36438
vaddsd %xmm2, %xmm1, %xmm1
vroundsd $0xb, %xmm1, %xmm1, %xmm1
vdivsd %xmm0, %xmm1, %xmm0
vmovsd %xmm0, (%rsp)
callq 0x5200
leaq 0x18(%rsp), %rdi
vmovsd (%rsp), %xmm0
callq 0x55a0
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x5590
movq 0x19836(%rip), %rsi     # 0x48f98
leaq 0x8(%rsp), %rdi
callq 0x5220
leaq 0x88(%rsp), %rdi
callq 0x50d0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
retq
movq 0x1980c(%rip), %rsi     # 0x48f98
leaq 0x8(%rsp), %rdi
movq %rax, %rbx
callq 0x5220
leaq 0x88(%rsp), %rdi
callq 0x50d0
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/string.cpp
// Function: Morat::to_str_hex[abi:cxx11](unsigned long)
std::string to_str_hex(uint64_t a) {
	static const char hexlookup[] = "0123456789abcdef";
	char buf[19] = "0x";
	for (int i = 15; i >= 0; i--) {
		buf[i+2] = hexlookup[a & 15];
		a >>= 4;
	}
	buf[18] = '\0';
	return (char *)buf;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
vmovaps 0x6ca3(%rip), %xmm0     # 0x36460
movl $0x11, %eax
leaq 0x6c77(%rip), %rcx      # 0x36440
movq %rdi, %rbx
vmovaps %xmm0, (%rsp)
movl $0x0, 0xf(%rsp)
movl %esi, %edx
andl $0xf, %edx
shrq $0x4, %rsi
movb (%rdx,%rcx), %dl
movb %dl, (%rsp,%rax)
decq %rax
cmpq $0x1, %rax
jne 0x2f7d9
leaq 0x10(%rbx), %rax
movq %rsp, %r14
movq %r14, %rdi
movb $0x0, 0x12(%r14)
movq %rax, (%rbx)
callq 0x5140
leaq (%rsp,%rax), %rdx
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb1dc
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/string.cpp
// Function: Morat::explode(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
vecstr explode(const string & str, const string & sep, int count){
	vecstr ret;
	string::size_type old = 0, pos = 0;
	while((pos = str.find(sep, old)) != string::npos && --count != 0){
		ret.push_back(str.substr(old, pos - old));
		old = pos + sep.length();
	}
	ret.push_back(str.substr(old));
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
vxorps %xmm0, %xmm0, %xmm0
movq $0x0, 0x10(%rdi)
movl %ecx, %ebp
movq %rsi, %r14
movq %rdx, %r15
movq %rdi, (%rsp)
xorl %r12d, %r12d
vmovups %xmm0, (%rdi)
movq %r14, %rdi
movq (%rdx), %rsi
movq 0x8(%rdx), %rcx
xorl %edx, %edx
callq 0x5630
cmpq $-0x1, %rax
je 0x2f9b4
leaq 0x8(%rsp), %r13
movq %rax, %rbx
xorl %r12d, %r12d
decl %ebp
je 0x2f9b4
movq %rbx, %rcx
subq %r12, %rcx
movq %r13, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x5340
movq (%rsp), %rdi
movq %r13, %rsi
callq 0x2fc5c
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2f993
callq 0x52e0
movq 0x8(%r15), %rcx
movq (%r15), %rsi
movq %rbx, %r12
movq %r14, %rdi
addq %rcx, %r12
movq %r12, %rdx
callq 0x5630
movq %rax, %rbx
cmpq $-0x1, %rax
jne 0x2f95b
leaq 0x8(%rsp), %rdi
movq $-0x1, %rcx
movq %r14, %rsi
movq %r12, %rdx
callq 0x5340
movq (%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x2fc5c
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2f9ec
callq 0x52e0
movq (%rsp), %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
jmp 0x2fa1c
jmp 0x2fa28
movq 0x8(%rsp), %rdi
movq %rax, %rbx
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2fa2b
callq 0x52e0
jmp 0x2fa2b
movq %rax, %rbx
movq (%rsp), %rdi
callq 0xaa7e
movq %rbx, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/string.cpp
// Function: Morat::implode(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
string implode(const vecstr & vec, const string & sep){
	string ret;
	if(vec.size() == 0)
		return ret;
	ret += vec[0];
	for(unsigned int i = 1; i < vec.size(); i++){
		ret += sep;
		ret += vec[i];
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x10(%rdi), %r12
movq %rdi, %rbx
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq (%rsi), %rax
cmpq %rax, 0x8(%rsi)
je 0x2facf
movq %rdx, %r14
movq 0x8(%rax), %rdx
movq %rsi, %r15
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x50c0
movq 0x8(%r15), %rax
subq (%r15), %rax
cmpq $0x21, %rax
jb 0x2facf
movl $0x1, %r13d
movl $0x2, %ebp
movq 0x8(%r14), %rdx
movq (%r14), %rsi
movq %rbx, %rdi
callq 0x50c0
movq (%r15), %rax
shlq $0x5, %r13
movq 0x8(%rax,%r13), %rdx
movq (%rax,%r13), %rsi
movq %rbx, %rdi
callq 0x50c0
movq 0x8(%r15), %rax
movl %ebp, %r13d
incl %ebp
subq (%r15), %rax
sarq $0x5, %rax
cmpq %r13, %rax
ja 0x2fa93
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2fae3
movq (%rbx), %rdi
movq %rax, %r14
cmpq %r12, %rdi
je 0x2faf3
callq 0x52e0
movq %r14, %rdi
callq 0x5670
// File: /workspace/github_cpp_makefile_star2_O3/tewalds[P]morat/lib/string.cpp
// Function: Morat::parse_dict(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
dictstr parse_dict(const std::string & str, const std::string & sep1, const std::string & sep2) {
	dictstr ret;
	auto parts = explode(str, sep1);
	for(auto & p : parts){
		auto kv = explode(p, sep2, 2);
		ret[kv[0]] = (kv.size() == 2 ? kv[1] : "");
	}
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
leaq 0x30(%rdi), %rax
vxorps %xmm0, %xmm0, %xmm0
movq %rcx, %r14
movq %rdi, (%rsp)
movq %rax, (%rdi)
movq $0x1, 0x8(%rdi)
vmovups %xmm0, 0x10(%rdi)
movl $0x3f800000, 0x20(%rdi) # imm = 0x3F800000
vmovups %xmm0, 0x28(%rdi)
leaq 0x20(%rsp), %rdi
xorl %ecx, %ecx
callq 0x2f90c
movq 0x20(%rsp), %r15
movq 0x28(%rsp), %rbx
cmpq %rbx, %r15
je 0x2fbf6
leaq 0x48(%rsp), %rbp
leaq 0x8(%rsp), %r12
leaq 0x38(%rsp), %r13
movl $0x2, %ecx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x2f90c
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
subq %rax, %rcx
cmpq $0x40, %rcx
jne 0x2fba2
movq %rbp, 0x38(%rsp)
movq 0x20(%rax), %rsi
movq 0x28(%rax), %rdx
addq %rsi, %rdx
movq %r13, %rdi
callq 0xa930
jmp 0x2fbb9
movq %rbp, 0x38(%rsp)
leaq 0x1d59(%rip), %rdx      # 0x31907
movq %r13, %rdi
movq %rdx, %rsi
callq 0xb1dc
movq 0x8(%rsp), %rsi
movq (%rsp), %rdi
callq 0x2fea8
movq %rax, %rdi
movq %r13, %rsi
callq 0x5430
movq 0x38(%rsp), %rdi
cmpq %rbp, %rdi
je 0x2fbe1
callq 0x52e0
movq %r12, %rdi
callq 0xaa7e
addq $0x20, %r15
cmpq %rbx, %r15
jne 0x2fb62
leaq 0x20(%rsp), %rdi
callq 0xaa7e
movq (%rsp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2fc4a
jmp 0x2fc1a
movq %rax, %r14
jmp 0x2fc36
movq %rax, %r14
jmp 0x2fc40
movq 0x38(%rsp), %rdi
movq %rax, %r14
cmpq %rbp, %rdi
je 0x2fc36
callq 0x52e0
leaq 0x8(%rsp), %rdi
callq 0xaa7e
leaq 0x20(%rsp), %rdi
callq 0xaa7e
movq (%rsp), %rdi
callq 0x13554
movq %r14, %rdi
callq 0x5670
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rdi, %r14
leaq 0x20(%rsp), %rdi
movl %esi, %ebx
xorl %esi, %esi
callq 0x55b0
movq 0x8(%r14), %r15
movq 0x10(%r14), %rax
cmpq %rax, %r15
je 0x30122
vcvtsi2sdq 0x20(%rsp), %xmm0, %xmm0
vxorpd %xmm3, %xmm3, %xmm3
vxorpd %xmm2, %xmm2, %xmm2
vcvtsi2sdq 0x28(%rsp), %xmm1, %xmm1
vdivsd 0xf99(%rip), %xmm1, %xmm1 # 0x31008
vaddsd %xmm0, %xmm1, %xmm1
vmovsd %xmm1, 0x8(%rsp)
cmpl $0xa, %ebx
je 0x300a1
vmovsd 0x28(%r15), %xmm0
vsubsd %xmm1, %xmm0, %xmm0
vucomisd %xmm0, %xmm3
jae 0x300a1
vcmpeqsd %xmm3, %xmm2, %k1
vminsd %xmm2, %xmm0, %xmm2
vmovsd %xmm0, %xmm2, %xmm2 {%k1}
jmp 0x300d6
cmpb $0x0, 0x4(%r15)
jne 0x300d6
cmpq $0x0, 0x18(%r15)
vmovapd %xmm2, 0x10(%rsp)
je 0x3012c
leaq 0x8(%r15), %rdi
callq *0x20(%r15)
vmovapd 0x10(%rsp), %xmm2
vmovsd 0x8(%rsp), %xmm1
movb $0x1, 0x4(%r15)
vxorpd %xmm3, %xmm3, %xmm3
movq 0x10(%r14), %rax
addq $0x30, %r15
cmpq %rax, %r15
jne 0x30079
vxorpd %xmm0, %xmm0, %xmm0
vucomisd %xmm0, %xmm2
jbe 0x30122
vcvttpd2dq %xmm2, %xmm0
vxorpd %xmm1, %xmm1, %xmm1
leaq 0x20(%rsp), %rsi
xorl %edi, %edi
xorl %edx, %edx
vmovapd %xmm1, (%rsi)
vcvtdq2pd %xmm0, %xmm0
vsubsd %xmm0, %xmm2, %xmm0
vmulsd 0xefa(%rip), %xmm0, %xmm0 # 0x31008
vunpcklpd %xmm0, %xmm2, %xmm0 # xmm0 = xmm2[0],xmm0[0]
vcvttpd2qq %xmm0, %xmm0
vmovapd %xmm0, 0x10(%rsi)
callq 0x54d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
callq 0x5100
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl (%rdi), %ebp
leaq 0x8(%rsp), %r15
movq %rdi, %r14
vmovsd %xmm0, (%rsp)
movq %r15, %rdi
callq 0x145de
leaq 0x30(%rsp), %rbx
movl %ebp, -0x8(%rbx)
movb $0x0, -0x4(%rbx)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x145de
vmovsd (%rsp), %xmm0
movq 0x18(%rsp), %rax
vmovsd %xmm0, 0x50(%rsp)
testq %rax, %rax
je 0x301c8
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
movq %rdi, %rsi
callq *%rax
leaq 0x8(%r14), %rdi
leaq 0x28(%rsp), %rsi
callq 0x302d6
movl (%r14), %eax
incl %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, (%r14)
movl $0xe, %esi
movq %r14, %rdi
callq 0x30026
movl 0x28(%rsp), %ebp
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x3020b
movl $0x3, %edx
movq %rbx, %rdi
movq %rbx, %rsi
callq *%rax
movl %ebp, %eax
addq $0x58, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3025e
jmp 0x3025e
movq %rax, %r14
movq 0x18(%rsp), %rax
testq %rax, %rax
je 0x30256
leaq 0x8(%rsp), %rdi
movl $0x3, %edx
movq %rdi, %rsi
callq *%rax
jmp 0x30256
jmp 0x3025e
movq %rax, %r14
movq 0x40(%rsp), %rax
testq %rax, %rax
je 0x30256
movl $0x3, %edx
movq %rbx, %rdi
movq %rbx, %rsi
callq *%rax
movq %r14, %rdi
callq 0x5670
movq %rax, %rdi
callq 0xa8ae
// File: /workspace/github_cpp_makefile_star2_O3/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 0x302b8
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movq %rdi, %r14
cmpq %rcx, %rax
je 0x302b8
leaq 0x8(%r14), %r15
movl %esi, %ebx
xorl %ebp, %ebp
cmpl %ebx, (%rax)
jne 0x30296
movb $0x1, 0x4(%rax)
movb $0x1, %bpl
jmp 0x3029c
testb $0x1, 0x4(%rax)
je 0x302ad
movq %r15, %rdi
movq %rax, %rsi
callq 0x305da
movq 0x10(%r14), %rcx
jmp 0x302b1
addq $0x30, %rax
cmpq %rcx, %rax
jne 0x30289
jmp 0x302ba
xorl %ebp, %ebp
andb $0x1, %bpl
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4df0
leaq 0x10(%r15), %rcx
cmpq %rcx, %rax
je 0x44e9
movq %r12, %rdi
movq %r14, %rsi
callq 0x47c6
movq %rax, %r15
movl (%rax), %eax
movl %eax, (%rbx)
leaq 0x8(%rbx), %r14
leaq 0x18(%rbx), %rax
movq %rax, -0x30(%rbp)
movq %rax, 0x8(%rbx)
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
addq %rsi, %rdx
movq %r14, %rdi
callq 0x4d52
leaq 0x28(%rbx), %r12
leaq 0x38(%rbx), %r13
movq %r13, 0x28(%rbx)
movq 0x28(%r15), %rsi
movq 0x30(%r15), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x4d52
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 0x4ade
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 0x4535
leaq -0x40(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r14
movq %r14, %rdi
callq 0x4d52
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x442e
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x44d7
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0x44d7
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 0x44d7
movq %rax, %rbx
movq -0x50(%rbp), %rdi
cmpq %r12, %rdi
je 0x45b7
movq -0x40(%rbp), %rsi
jmp 0x45af
movq %rax, %rbx
movq (%r12), %rdi
cmpq %r13, %rdi
je 0x459f
movq (%r13), %rsi
incq %rsi
callq 0x3230
jmp 0x459f
movq %rax, %rbx
movq (%r14), %rdi
cmpq -0x30(%rbp), %rdi
je 0x45b7
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x122e2(%rip), %rsi     # 0x1b68e
callq 0x30a0
testl %eax, %eax
je 0x94ac
leaq 0x11f0e(%rip), %rsi     # 0x1b2ce
movq %rbx, %rdi
callq 0x30a0
movl $0x1, %r14d
testl %eax, %eax
je 0x94af
leaq 0x122b6(%rip), %rsi     # 0x1b693
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94af
leaq 0x122a3(%rip), %rsi     # 0x1b697
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94af
leaq 0x12290(%rip), %rsi     # 0x1b69b
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94af
leaq 0x1227e(%rip), %rsi     # 0x1b6a0
movq %rbx, %rdi
callq 0x30a0
movl $0x2, %r14d
testl %eax, %eax
je 0x94af
leaq 0x12269(%rip), %rsi     # 0x1b6a4
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94af
leaq 0x1225a(%rip), %rsi     # 0x1b6a8
movq %rbx, %rdi
callq 0x30a0
testl %eax, %eax
je 0x94af
movl $0x50, %edi
callq 0x3120
movq %rax, %r14
leaq 0x1223e(%rip), %rsi     # 0x1b6ac
leaq -0x38(%rbp), %rdi
movq %rbx, %rdx
callq 0x40f1
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 0x198db(%rip), %rsi     # 0x22d78
leaq -0x3ebe(%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 0x94d9
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x3230
testb %r15b, %r15b
jne 0x94e3
jmp 0x94eb
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xadb3
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 0xaefc
incq %r13
cmpq %r13, %rbx
jne 0xad91
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 0xe184
// File: /workspace/github_cpp_makefile_star2_O3/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 0xae34
movq (%rsi), %rax
movq %rsi, %rdi
xorl %esi, %esi
callq *0x18(%rax)
leaq 0x318(%rbx), %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8c5c
leaq 0x328(%rbx), %r14
leaq 0x106ea(%rip), %rsi     # 0x1b4fd
movl $0x7, %edx
movq %r14, %rdi
callq 0x3280
leaq 0x106de(%rip), %rsi     # 0x1b505
movl $0xf, %edx
movq %r14, %rdi
callq 0x3280
leaq 0x328(%rbx), %r14
leaq 0x106d3(%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 0x106ae(%rip), %rsi     # 0x1b51a
movl $0x5, %edx
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3280
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdd2a(%rip), %rsi      # 0x1b5fd
movl $0x12, %edx
movq %r15, %rdi
callq 0x3280
leaq 0xdd29(%rip), %rsi      # 0x1b610
movl $0x8, %edx
movq %r15, %rdi
callq 0x3280
movq 0x10(%r14), %r15
movq 0x18(%r14), %r12
cmpq %r12, %r15
je 0xd91f
leaq 0x318(%rbx), %r14
movq (%r15), %rsi
movq %rbx, %rdi
movq %r14, %rdx
callq 0xaefc
addq $0x8, %r15
cmpq %r12, %r15
jne 0xd908
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 0xd95b
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq (%rbx), %rdi
leaq 0xdcb4(%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 0xd9a5
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
movq (%rbx), %r14
leaq 0xdc80(%rip), %rsi      # 0x1b62f
movl $0x7, %edx
movq %r14, %rdi
callq 0x3280
leaq 0xdc74(%rip), %rsi      # 0x1b637
movl $0x9, %edx
movq %r14, %rdi
callq 0x3280
movq (%rbx), %rdi
leaq 0xdc67(%rip), %rsi      # 0x1b641
movl $0x4, %edx
callq 0x3280
movq (%rbx), %rdi
leaq 0xdc58(%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 0xda31
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xda40
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xda58
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 0xda4c
jmp 0xda58
// File: /workspace/github_cpp_makefile_star2_O3/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 0xdb5a
movq 0x18(%rbx), %rax
subq 0x10(%rbx), %rax
cmpq $0x8, %rax
jne 0xdbba
movq (%rbx), %rax
movq %rbx, %rdi
xorl %esi, %esi
callq *0x18(%rax)
movq %rax, %rbx
leaq -0x818(%rbp), %rdi
leaq -0x260(%rbp), %rsi
callq 0xe618
leaq -0x500(%rbp), %rdx
leaq -0x818(%rbp), %rdi
movq %rbx, %rsi
callq 0xaefc
leaq -0x260(%rbp), %rdi
callq 0x32f0
leaq -0x818(%rbp), %rdi
callq 0xe7f0
movq 0x154ad(%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), %r15
movq %r15, -0x10(%r15)
leaq 0xdae3(%rip), %rsi      # 0x1b659
leaq 0xdae8(%rip), %rdx      # 0x1b665
leaq -0x60(%rbp), %rdi
callq 0x4336
movb $0x1, %r12b
leaq -0x60(%rbp), %rcx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r12d, %r12d
leaq 0x151cf(%rip), %rsi     # 0x22d78
leaq -0x85ca(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
jmp 0xdc18
movl $0x50, %edi
callq 0x3120
movq %rax, %r14
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xda90(%rip), %rsi      # 0x1b666
leaq 0xda95(%rip), %rdx      # 0x1b672
leaq -0x40(%rbp), %rdi
callq 0x4336
movb $0x1, %r12b
leaq -0x40(%rbp), %rcx
movq %r14, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r12d, %r12d
leaq 0x1516f(%rip), %rsi     # 0x22d78
leaq -0x862a(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xdc44
movq -0x30(%rbp), %rsi
jmp 0xdc3c
jmp 0xdc4b
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r15, %rdi
je 0xdc44
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x3230
testb %r12b, %r12b
jne 0xdc4e
jmp 0xdc6e
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
jmp 0xdc6e
jmp 0xdc6b
movq %rax, %rbx
leaq -0x818(%rbp), %rdi
callq 0xe7f0
jmp 0xdc6e
movq %rax, %rbx
leaq -0x260(%rbp), %rdi
callq 0x3320
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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), %rdx
movl 0x18(%rdi), %ecx
subq %rax, %rdx
shlq $0x3, %rdx
addq %rcx, %rdx
je 0xdcf6
movabsq $-0x8000000000000000, %rsi # imm = 0x8000000000000000
xorl %ecx, %ecx
leaq 0x3f(%rsi), %rdi
leaq 0x3f(%rcx), %r10
testq %rcx, %rcx
cmovnsq %rcx, %r10
sarq $0x6, %r10
movq %rcx, %r9
andq %rdi, %r9
xorl %r8d, %r8d
cmpq %rsi, %r9
setbe %r8b
movl $0x1, %r9d
shlq %cl, %r9
leaq (%rax,%r10,8), %r10
movq -0x8(%r10,%r8,8), %r11
btq %rcx, %r11
jae 0xdd54
incq %rcx
cmpq %rdx, %rcx
jb 0xdcb7
movl $0x50, %edi
callq 0x3120
movq %rax, %rbx
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0xd961(%rip), %rsi      # 0x1b673
leaq 0xd972(%rip), %rdx      # 0x1b68b
leaq -0x40(%rbp), %rdi
callq 0x4336
movb $0x1, %r12b
leaq -0x40(%rbp), %rcx
movq %rbx, %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x5470
xorl %r12d, %r12d
leaq 0x15033(%rip), %rsi     # 0x22d78
leaq -0x8766(%rip), %rdx     # 0x55e6
movq %rbx, %rdi
callq 0x33d0
leaq -0x8(,%r8,8), %rax
orq %r9, %r11
movq %r11, (%r10,%rax)
movl %ecx, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xdd8a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x3230
testb %r12b, %r12b
jne 0xdd94
jmp 0xdd9c
movq %rax, %r14
movq %rbx, %rdi
callq 0x31a0
movq %r14, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4d52
movl 0x78(%r14), %eax
movl %eax, 0x20(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0xeae2
movq -0x48(%rbp), %rdi
cmpq %r12, %rdi
je 0xdf06
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 0xdf35
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x68, %rsp
movl %ecx, %r14d
movl %edx, %r13d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0xe94a
leaq 0x38(%rbx), %rcx
cmpq %rcx, %rax
movq %r12, -0x40(%rbp)
jne 0xe07a
movq %r15, -0x38(%rbp)
movl %r14d, -0x2c(%rbp)
leaq -0x58(%rbp), %r15
movq %r15, 0x8(%r15)
movq %r15, (%r15)
movq $0x0, 0x10(%r15)
leaq -0x90(%rbp), %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0xecf4
movl %r13d, %r14d
leaq -0x90(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0xedbe
leaq -0x70(%rbp), %r13
movq (%r13), %rdi
cmpq %r13, %rdi
je 0xe034
movq (%rdi), %r12
movl $0x18, %esi
callq 0x3230
movq %r12, %rdi
cmpq %r13, %r12
jne 0xe01f
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
movl %r14d, %r13d
je 0xe050
movq -0x80(%rbp), %rsi
incq %rsi
callq 0x3230
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0xe06e
movq (%rdi), %r12
movl $0x18, %esi
callq 0x3230
movq %r12, %rdi
cmpq %r15, %r12
jne 0xe059
movl -0x2c(%rbp), %r14d
movq -0x40(%rbp), %r12
movq -0x38(%rbp), %r15
addl %r13d, 0x80(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0xe8ec
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 0xf056
movq %rax, %rdi
movq %r15, %rsi
callq 0x3040
incq 0x70(%rbx)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
callq 0xed62
jmp 0xe104
movq %rax, %rbx
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0xe122
movq (%rdi), %r14
movl $0x18, %esi
callq 0x3230
movq %r14, %rdi
cmpq %r15, %r14
jne 0xe10d
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe221
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 0x4d52
movq (%r14), %rsi
movq %r14, %rdi
callq 0xf0a8
movq %rbx, %rdi
movq %r15, %rsi
callq 0xe8ec
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 0xe218
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3230
decq %r13
cmpq -0x30(%rbp), %r13
ja 0xe1b3
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 0xe248
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf8e1
callq 0xf824
cmpl %ebx, %r14d
sete %al
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xf93b
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)
movl $0x10, %eax
movl 0x58(%rdi), %ecx
incl %ebx
decl %ebx
testl %ebx, %ebx
jle 0xf98e
cmpl $0x28, %eax
ja 0xf97a
movq %rdx, %r8
movl %eax, %edx
addq %rsi, %rdx
addl $0x8, %eax
movl %eax, -0x20(%rbp)
jmp 0xf982
leaq 0x8(%rdx), %r8
movq %r8, -0x18(%rbp)
cmpl (%rdx), %ecx
movq %r8, %rdx
jne 0xf95f
callq 0xf824
testl %ebx, %ebx
setg %al
addq $0xc8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfa53
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)
movl $0x10, %eax
movl 0x58(%rbx), %ecx
incl %esi
decl %esi
testl %esi, %esi
jle 0xfab5
cmpl $0x28, %eax
ja 0xfa92
movq %rdx, %r8
movl %eax, %edx
addq %rdi, %rdx
addl $0x8, %eax
movl %eax, -0x30(%rbp)
jmp 0xfa9a
leaq 0x8(%rdx), %r8
movq %r8, -0x28(%rbp)
cmpl (%rdx), %ecx
movq %r8, %rdx
jne 0xfa77
movq %rbx, %rdi
callq 0xf824
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 0x13270(%rip), %rsi     # 0x22d48
leaq -0xa4f9(%rip), %rdx     # 0x55e6
movq %r14, %rdi
callq 0x33d0
movq %rax, %rbx
movq %r14, %rdi
callq 0x31a0
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfafa
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 0x4d52
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 0xfc00
leaq -0xa8(%rbp), %rdi
callq 0x191f8
movq %rbx, %rdi
movl $0x20, %esi
callq 0xf99e
cmpl $0x21, 0x58(%rbx)
jne 0xfd56
movq %rbx, %rdi
callq 0xf824
jmp 0xfe5e
leaq -0x38(%rbp), %r14
leaq -0x78(%rbp), %r12
movq %rbx, %rdi
movl $0x12, %esi
callq 0xfafa
cmpl $0x1e, 0x58(%rbx)
jne 0xfe2a
movq %rbx, %rdi
callq 0xf824
movq %r14, -0x48(%rbp)
leaq -0x48(%rbp), %r15
movq %r15, %rdi
leaq 0xb791(%rip), %rsi      # 0x1b520
leaq 0xb78d(%rip), %rdx      # 0x1b523
callq 0x4336
movq 0x18(%rbx), %rdi
addq $0x30, %rdi
movq %r15, %rsi
callq 0x3150
movq %r12, %r15
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xfdc3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
movq %rbx, %rdi
movl $0x1, %esi
callq 0xf99e
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 0x4d52
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 0xfc00
movq %r12, %rdi
callq 0x191f8
leaq -0x38(%rbp), %r14
jmp 0xfe32
movq %rbx, %rdi
callq 0xfeb6
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq %rax, 0x18(%rbx)
cmpl $0x29, 0x58(%rbx)
jne 0xfe51
movq %rbx, %rdi
callq 0xf824
jmp 0xfd5e
movq %rbx, %rdi
movl $0x21, %esi
callq 0xf99e
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 0xfea9
movq %rax, %rbx
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0xfeae
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x3230
jmp 0xfeae
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x191f8
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfafa
movq %rbx, %rdi
callq 0x1072e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x36, %edx
movl $0x35, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
je 0xff73
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 0x4d52
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 0xfc00
movq %r14, %rdi
callq 0x191f8
movq %rbx, %rdi
callq 0x1072e
movq %rbx, %rdi
movl $0x2, %esi
movl $0x36, %edx
movl $0x35, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
jne 0xff01
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 0x191f8
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfafa
movq %rbx, %rdi
callq 0xffa2
movq %rbx, %rdi
movl $0x2, %esi
movl $0x15, %edx
movl $0x1a, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
je 0x10599
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 0x4d52
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 0xfc00
movq %r14, %rdi
callq 0x191f8
movq %rbx, %rdi
callq 0xffa2
movq %rbx, %rdi
movl $0x2, %esi
movl $0x15, %edx
movl $0x1a, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
jne 0x10527
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 0x191f8
movq %rbx, %rdi
callq 0x33f0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xfafa
movq %rbx, %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
je 0x1065f
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 0x4d52
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 0xfc00
leaq -0x88(%rbp), %rdi
callq 0x191f8
movq %rbx, %rdi
callq 0x104dc
movq %rbx, %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
je 0x106fe
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 0x4d52
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 0xfc00
movq %r14, %rdi
callq 0x191f8
movq %rbx, %rdi
callq 0x104dc
movq %rbx, %rdi
movl $0x2, %esi
movl $0x16, %edx
movl $0x17, %ecx
xorl %eax, %eax
callq 0xf8ec
testb %al, %al
jne 0x1068c
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 0x1071b
movq %rax, %rbx
movq %r14, %rdi
callq 0x191f8
movq %rbx, %rdi
callq 0x33f0