LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/netutils.cpp
// Function: SerialBuffer::read_compressed(char*)
bool SerialBuffer::read_compressed(char *buffer)
{
	// read the size of the block:
	unsigned short sh = read_sh();
	uLongf res_size = BUFFER_SIZE;
	int r = uncompress((Bytef*)buffer, &res_size, (Bytef*)pos, sh);
	if(r == Z_BUF_ERROR || r == Z_DATA_ERROR)
		return true;
	// Z_MEM_ERROR (insufficient memory) is highly unlikely and would cause more
	// general problems.
	pos += res_size;
	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
movq (%rdi), %rdx
movzwl (%rdx), %ecx
addq $0x2, %rdx
rolw $0x8, %cx
movq %rdx, (%rdi)
leaq -0x10(%rbp), %rsi
movq $0x800, (%rsi)          # imm = 0x800
movzwl %cx, %ecx
movq %rax, %rdi
callq 0x4160
cmpl $-0x5, %eax
je 0xf534
cmpl $-0x3, %eax
je 0xf534
movq -0x10(%rbp), %rcx
addq %rcx, (%rbx)
addl $0x5, %eax
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
sete %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: del(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, int)
void del(string &s, const int n)
{
	string::iterator i = s.begin();
	advance(i, s, n);
	for(char c = seq_len(*i); c > 0; --c)
	{
		if((i = s.erase(i)) == s.end())
			break; /* If this happens, string is not proper UTF-8!
		            * We can't really do anything with such a string;
					* this is just to avoid nasty segfaults. */
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %rax
leaq -0x20(%rbp), %r14
movq %rax, (%r14)
movswl %si, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xf5d8
movq (%r14), %r14
movsbl (%r14), %edi
callq 0xf690
movl %eax, %r15d
subq (%rbx), %r14
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4450
cmpq 0x8(%rbx), %r14
je 0xf5cd
addq (%rbx), %r14
leal -0x1(%r15), %eax
cmpb $0x1, %r15b
movl %eax, %r15d
jg 0xf5a4
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: (anonymous namespace)::advance(__gnu_cxx::__normal_iterator<char*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, short)
void advance(string::iterator &i, string &s, short num)
{
	char l;
	for(; num > 0; --num)
	{
		l = seq_len(*i);
		do { ++i; --l; }
		while(l > 0 // sequence is ready,
			&& i != s.end() // premature end of string,
			&& !invalid_cont_byte(*i)); // non-first byte invalid for continuation

#ifdef DEBUG
		if(l > 0) // if was broken for some other reason than this, something is wrong
		{
			cerr << inv_utf8_warning << endl;
			return;
		}
#endif
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
testw %r14w, %r14w
jle 0xf637
movq %rsi, %rbx
movq %rdi, %r15
movq (%r15), %rax
movsbl (%rax), %edi
callq 0xf690
movq (%r15), %rdx
movq (%rbx), %rcx
addq 0x8(%rbx), %rcx
incq %rdx
movq %rdx, (%r15)
cmpb $0x2, %al
jl 0xf629
movl %eax, %esi
cmpq %rcx, %rdx
je 0xf623
cmpb $-0x40, (%rdx)
leaq 0x1(%rdx), %rdx
leal -0x1(%rsi), %eax
jl 0xf609
cmpb $0x2, %sil
jge 0xf642
leal -0x1(%r14), %eax
cmpw $0x1, %r14w
movl %eax, %r14d
jg 0xf5f1
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0xb087(%rip), %rsi      # 0x1a6d0
movq 0xb088(%rip), %rdx      # 0x1a6d8
movq 0x7999(%rip), %rdi      # 0x16ff0
callq 0x4420
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x4250
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: (anonymous namespace)::seq_len(char)
char seq_len(char leadch) // determine the length of the sequence starting with leadch
{
	unsigned char lead = static_cast<unsigned char>(leadch);
	if(lead < 0x80)
		return 1;
	if(lead >= 0xC2 && lead <= 0xDF)
		return 2;
	if(lead >= 0xE0 && lead <= 0xEF)
		return 3;
	if(lead >= 0xF0 && lead <= 0xF4)
		return 4;
#ifdef DEBUG
	cerr << inv_utf8_warning << endl;
#endif
	return 1; // invalid lead!
}

// Assembly:
movb $0x1, %al
testb %dil, %dil
js 0xf698
retq
leal 0x3e(%rdi), %ecx
movb $0x2, %al
cmpb $0x1e, %cl
jb 0xf697
movl %edi, %ecx
andb $-0x10, %cl
movb $0x3, %al
cmpb $-0x20, %cl
je 0xf697
addb $0x10, %dil
movb $0x4, %al
cmpb $0x5, %dil
jb 0xf697
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0xb009(%rip), %rsi      # 0x1a6d0
movq 0xb00a(%rip), %rdx      # 0x1a6d8
movq 0x791b(%rip), %rdi      # 0x16ff0
callq 0x4420
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x4370
movsbl %al, %esi
movq %rbx, %rdi
callq 0x4040
movq %rax, %rdi
callq 0x4250
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: ins(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, unsigned int, int)
void ins(string &s, const unsigned int c, const int n)
{
	// First interpret "n symbols" in terms of a string iterator:
	string::iterator i = s.begin();
	advance(i, s, n);
	if(c < 0x80) // single byte
		s.insert(i, static_cast<unsigned char>(c));
	else if(c < 0x800) // 2 bytes
	{
		i = s.insert(i, static_cast<unsigned char>((c >> 6) | 0xc0));
		s.insert(++i, static_cast<unsigned char>((c & 0x3f) | 0x80));
	}
	else if(c < 0x10000) // 3
	{
		i = s.insert(i, static_cast<unsigned char>((c >> 12) | 0xe0));
		i = s.insert(++i, static_cast<unsigned char>(((c >> 6) & 0x3f) | 0x80));
		s.insert(++i, static_cast<unsigned char>((c & 0x3f) | 0x80));
	}
	else // 4
	{
		i = s.insert(i, static_cast<unsigned char>((c >> 18) | 0xf0));
		i = s.insert(++i, static_cast<unsigned char>(((c >> 12) & 0x3f) | 0x80));
		i = s.insert(++i, static_cast<unsigned char>(((c >> 6) & 0x3f) | 0x80));
		s.insert(++i, static_cast<unsigned char>((c & 0x3f) | 0x80));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %r14d
movq %rdi, %rbx
movq (%rdi), %rax
leaq -0x20(%rbp), %rdi
movq %rax, (%rdi)
movswl %dx, %edx
movq %rbx, %rsi
callq 0xf5d8
cmpl $0x7f, %r14d
ja 0xf744
movq -0x20(%rbp), %rsi
movq (%rbx), %rax
jmp 0xf87c
cmpl $0x7ff, %r14d           # imm = 0x7FF
ja 0xf781
movq -0x20(%rbp), %r15
movl %r14d, %eax
shrl $0x6, %eax
orb $-0x40, %al
subq (%rbx), %r15
movsbl %al, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x46e0
movq (%rbx), %rax
leaq (%rax,%r15), %rsi
incq %rsi
jmp 0xf870
movq -0x20(%rbp), %r15
subq (%rbx), %r15
movl %r14d, %eax
cmpl $0xffff, %r14d          # imm = 0xFFFF
ja 0xf7ed
shrl $0xc, %eax
orb $-0x20, %al
movsbl %al, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x46e0
movq (%rbx), %rax
addq %r15, %rax
incq %rax
movq %rax, -0x20(%rbp)
movl %r14d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
leaq 0x1(%r15), %rsi
movsbl %al, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x46e0
movq (%rbx), %rax
leaq (%rax,%r15), %rsi
addq $0x2, %rsi
jmp 0xf870
shrl $0x12, %eax
orb $-0x10, %al
movsbl %al, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x46e0
movq (%rbx), %rax
addq %r15, %rax
incq %rax
movq %rax, -0x20(%rbp)
movl %r14d, %eax
shrl $0xc, %eax
andb $0x3f, %al
orb $-0x80, %al
leaq 0x1(%r15), %rsi
movsbl %al, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x46e0
movq (%rbx), %rax
addq %r15, %rax
addq $0x2, %rax
movq %rax, -0x20(%rbp)
movl %r14d, %eax
shrl $0x6, %eax
andb $0x3f, %al
orb $-0x80, %al
leaq 0x2(%r15), %rsi
movsbl %al, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
callq 0x46e0
movq (%rbx), %rax
leaq (%rax,%r15), %rsi
addq $0x3, %rsi
movq %rsi, -0x20(%rbp)
andb $0x3f, %r14b
orb $-0x80, %r14b
subq %rax, %rsi
movsbl %r14b, %r8d
movl $0x1, %ecx
movq %rbx, %rdi
xorl %edx, %edx
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x46e0
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: num_syms(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
short num_syms(const string &s)
{
	// we assume the string is valid UTF-8, and can hence simply count the non-continuation bytes
	int n = 0;
	for(string::const_iterator i = s.begin(); i != s.end(); ++i)
	{
		if(static_cast<unsigned char>(*i) < 0x80 || static_cast<unsigned char>(*i) > 0xBF)
			++n;
	}
	return n;
}

// Assembly:
movq 0x8(%rdi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xf8c5
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rdx
xorl %esi, %esi
xorl %edi, %edi
cmpb $-0x40, (%rdx,%rsi)
setge %dil
addl %edi, %eax
incq %rsi
cmpq %rsi, %rcx
jne 0xf8b0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: ind_of_sym(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int)
short ind_of_sym(const string &s, int n)
{
	short b = 0;
	for(; n > 0; --n)
		b += seq_len(s[b]);
	return b;
}

// Assembly:
testl %esi, %esi
jle 0xf97c
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
incl %ebx
xorl %r15d, %r15d
movswq %r15w, %rax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edi
callq 0xf690
movzbl %al, %eax
addl %r15d, %eax
decl %ebx
movl %eax, %r15d
cmpl $0x1, %ebx
jg 0xf951
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: mb_substr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, short, short)
std::string mb_substr(const string &s, const short beg, short len)
{
	short b = ind_of_sym(s, beg);
	short e = 0;
	for(; len > 0; --len)
		e += seq_len(s[b+e]);
	return s.substr(b, e);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rsi, %r14
movq %rdi, %rbx
testw %dx, %dx
jle 0xfa0b
movzwl %dx, %r12d
incl %r12d
xorl %r13d, %r13d
movswq %r13w, %rax
movq (%r14), %rcx
movsbl (%rcx,%rax), %edi
callq 0xf690
movzbl %al, %eax
addl %r13d, %eax
movl %eax, %r13d
decl %r12d
cmpl $0x1, %r12d
jg 0xf9e3
movswq %r13w, %r12
jmp 0xfa0e
xorl %r12d, %r12d
testw %r15w, %r15w
jle 0xfa46
incl %r15d
xorl %r13d, %r13d
movswq %r13w, %rax
movq (%r14), %rcx
addq %r12, %rcx
movsbl (%rax,%rcx), %edi
callq 0xf690
movzbl %al, %eax
addl %r13d, %eax
movl %eax, %r13d
decl %r15d
cmpw $0x1, %r15w
jg 0xfa1a
movswq %r13w, %rcx
jmp 0xfa48
xorl %ecx, %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x43c0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/utfstr.cpp
// Function: low_bound(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, short)
short low_bound(const std::string &s, const short n)
{
	short a = n;
	while(!invalid_cont_byte(s[a]))
		--a;
	if(a + seq_len(s[a]) > n)
		return a;
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq (%rdi), %rcx
movl %ebx, %r14d
movswq %r14w, %rax
movb (%rcx,%rax), %al
decl %r14d
cmpb $-0x40, %al
jl 0xfa7a
incl %r14d
movswl %r14w, %r15d
movsbl %al, %edi
callq 0xf690
movzbl %al, %ecx
addl %r15d, %ecx
movswl %bx, %eax
cmpl %eax, %ecx
cmovgl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/confdir.cpp
// Function: get_conf_dir[abi:cxx11]()
std::string get_conf_dir()
{
	std::string s;
	char *tmp = getenv("HOME");
	if(tmp && tmp[0])
		s = std::string(tmp);
	else
	{
		std::cerr << "HOME not defined!" << std::endl;
		exit(1);
	}
	s += "/.config/yuxtapa/";
	return s;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x3621(%rip), %rdi      # 0x13101
callq 0x4480
testq %rax, %rax
je 0xfb57
movq %rax, %r14
cmpb $0x0, (%rax)
je 0xfb57
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq %r14, %rdi
callq 0x41b0
movq %r14, %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x8912
leaq -0x40(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4490
movq (%r14), %rdi
cmpq %r12, %rdi
je 0xfb38
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x43a0
leaq 0x35d9(%rip), %rsi      # 0x13118
movq %rbx, %rdi
callq 0x46f0
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x7492(%rip), %rdi      # 0x16ff0
leaq 0x35a1(%rip), %rsi      # 0x13106
movl $0x11, %edx
callq 0x4420
movq 0x747a(%rip), %rdi      # 0x16ff0
callq 0x41d0
movl $0x1, %edi
callq 0x4470
jmp 0xfb87
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0xfb9d
movq (%r15), %rsi
incq %rsi
callq 0x43a0
movq %r14, %rdi
callq 0x4670
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/coords.cpp
// Function: Coords::in(e_Dir) const
Coords Coords::in(const e_Dir d) const
{
	Coords c(x,y);
	switch(d)
	{
		case D_N: c.y--; break;
		case D_NE: c.x++; c.y--; break;
		case D_E: c.x++; break;
		case D_SE: c.x++; c.y++; break;
		case D_S: c.y++; break;
		case D_SW: c.x--; c.y++; break;
		case D_W: c.x--; break;
		case D_NW: c.x--; c.y--; break;
		default: /*assert(0)*/;
	}
	return c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movzwl (%rsi), %edi
movzwl 0x2(%rsi), %ecx
movw %di, (%rax)
movw %cx, 0x2(%rax)
cmpl $0x7, %edx
ja 0xfcd5
movl %edx, %edx
leaq 0x3487(%rip), %rsi      # 0x1312c
movslq (%rsi,%rdx,4), %rdx
addq %rsi, %rdx
jmpq *%rdx
incl %edi
jmp 0xfcbc
incl %edi
jmp 0xfcc5
incl %edi
jmp 0xfcd2
decl %edi
movw %di, (%rax)
decl %ecx
jmp 0xfcca
decl %edi
movw %di, (%rax)
incl %ecx
movw %cx, 0x2(%rax)
jmp 0xfcd5
decl %edi
movw %di, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/coords.cpp
// Function: Coords::unitise()
void Coords::unitise()
{
	short len = short(dist_eucl(Coords(0,0)));
	if(len)
	{
		x /= len;
		y /= len;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movswl (%rdi), %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm1
movswl 0x2(%rdi), %eax
cvtsi2sd %eax, %xmm0
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0xfd0c
sqrtsd %xmm0, %xmm0
jmp 0xfd11
callq 0x42e0
cvtsd2ss %xmm0, %xmm0
cvttss2si %xmm0, %eax
testw %ax, %ax
je 0xfd35
movswl %ax, %ecx
movswl (%rbx), %eax
cltd
idivl %ecx
movw %ax, (%rbx)
movswl 0x2(%rbx), %eax
cltd
idivl %ecx
movw %ax, 0x2(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/coords.cpp
// Function: Coords::dir_of(Coords) const
e_Dir Coords::dir_of(Coords ref) const
{
	// Basically, we construct the vector from *this to ref and
	// shrink it (in a Euclidian fashion) to a unit vector, which
	// we then interpret as a direction:
	ref.x -= x;
	ref.y -= y;
	ref.unitise();
	switch(ref.x + ref.y)
	{
	case 2: return D_SE;
	case -2: return D_NW;
	case 1: if(ref.x) return D_E;
		return D_S;
	case -1: if(ref.x) return D_W;
		return D_N;
	case 0: if(ref.x == 1) return D_NE;
		return D_SW;
	}
	return D_N; // reaching this line is an error!
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
movzwl (%rdi), %eax
subw %ax, (%rsi)
movzwl 0x2(%rdi), %eax
subw %ax, 0x2(%rsi)
movq %rsi, %rdi
callq 0xfcd8
movswl (%rbx), %eax
movswl 0x2(%rbx), %ecx
addl %eax, %ecx
addl $0x2, %ecx
cmpl $0x4, %ecx
ja 0xfdbc
leaq 0x33d9(%rip), %rdx      # 0x1314c
movslq (%rdx,%rcx,4), %rcx
addq %rdx, %rcx
jmpq *%rcx
movl $0x7, %eax
jmp 0xfdbe
movl $0x3, %eax
jmp 0xfdbe
xorl %ecx, %ecx
cmpw $0x1, %ax
setne %cl
leal 0x1(,%rcx,4), %eax
jmp 0xfdbe
xorl %ecx, %ecx
testw %ax, %ax
sete %cl
leal 0x2(,%rcx,2), %eax
jmp 0xfdbe
xorl %ecx, %ecx
testw %ax, %ax
movl $0x6, %eax
cmovel %ecx, %eax
jmp 0xfdbe
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/lotuskip[P]yuxtapa/common/util.cpp
// Function: trim_str(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void trim_str(string &s)
{
	while(!s.empty() && s[0] == ' ')
		s.erase(0,1);
	while(!s.empty() && s[s.size()-1] == ' ')
		s.erase(s.size()-1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x8(%rdi)
je 0xfe73
movq (%rbx), %rax
cmpb $0x20, (%rax)
jne 0xfe73
movl $0x1, %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x40d0
cmpq $0x0, 0x8(%rbx)
jne 0xfe3e
jmp 0xfe73
movq (%rbx), %rcx
cmpb $0x20, -0x1(%rcx,%rax)
jne 0xfe7c
decq %rax
movq %rax, 0x8(%rbx)
movb $0x0, (%rcx,%rax)
movq 0x8(%rbx), %rax
testq %rax, %rax
jne 0xfe5e
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/error.cpp
// Function: printCachedErrors()
bool printCachedErrors()
{
    if (cached_errors.size() != 0) {
        std::cout << "compile terminated with error(s):" << std::endl;
        int count = 0;
        for (std::string msg : cached_errors) {
            if (count == 6) {
                std::cout << "Ommited " << (cached_errors.size() - 0) 
                    << "+ more errors" << std::endl;
                break;
            }
            std::cout << msg;
            count++;
        }
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq 0x16a24(%rip), %rax     # 0x24118
movq 0x16a15(%rip), %rcx     # 0x24110
movq %rax, -0x38(%rbp)
movq %rcx, -0x30(%rbp)
cmpq %rcx, %rax
je 0xd842
movq 0x158bd(%rip), %rbx     # 0x22fd0
leaq 0xea94(%rip), %rsi      # 0x1c1ae
movl $0x21, %edx
movq %rbx, %rdi
callq 0x3340
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq 0x169bb(%rip), %r15     # 0x24110
movq 0x169bc(%rip), %r12     # 0x24118
cmpq %r12, %r15
je 0xd842
xorl %r14d, %r14d
leaq -0x48(%rbp), %rbx
movq %rbx, -0x58(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %rdi
callq 0xe4c0
cmpl $0x6, %r14d
jne 0xd806
movl $0x8, %edx
movq 0x1583b(%rip), %rdi     # 0x22fd0
leaq 0xea34(%rip), %rsi      # 0x1c1d0
callq 0x3340
movq 0x16970(%rip), %rsi     # 0x24118
subq 0x16961(%rip), %rsi     # 0x24110
sarq $0x5, %rsi
movq 0x15816(%rip), %rdi     # 0x22fd0
callq 0x31c0
movq %rax, %r13
movl $0xd, %edx
movq %rax, %rdi
leaq 0xea08(%rip), %rsi      # 0x1c1d9
callq 0x3340
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %r13, %rdi
callq 0x3030
movl $0x6, %r13d
movq %rax, %rdi
callq 0x31d0
jmp 0xd81e
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rdx
movq 0x157bb(%rip), %rdi     # 0x22fd0
callq 0x3340
leal 0x1(%r14), %r13d
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0xd82c
callq 0x32a0
cmpl $0x6, %r14d
je 0xd842
addq $0x20, %r15
movl %r13d, %r14d
cmpq %r12, %r15
jne 0xd76c
movq -0x30(%rbp), %rax
cmpq %rax, -0x38(%rbp)
setne %al
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x58(%rbp), %rdi
cmpq %rbx, %rdi
je 0xd86d
callq 0x32a0
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/error.cpp
// Function: skip(Symset)
void skip(Symset fsys)
{
    //bool skipped = false;
    while (!fsys.contains(g_sym)) {
        //skipped = true;
        // TODO: underline for skipped words
        readSymbol();
    }
    //if (skipped) std::cout << std::endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x1bdad(%rip), %r14     # 0x29630
movl (%r14), %eax
btq %rax, %rdi
jb 0xd89d
movq %rdi, %rbx
callq 0x19e44
movl (%r14), %eax
btq %rax, %rbx
jae 0xd88f
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/error.cpp
// Function: test(Symset, Symset)
void test(Symset s1, Symset s2)
{
    if (!s1.contains(g_sym)) {
        std::vector<int> syms = s1.toVector();
        std::stringstream buffer;
        buffer << "error: expected ";
        for (unsigned int i = 0; i < syms.size(); i++) {
            if (i != 0) buffer << "|";
            buffer << sym2str[syms[i]];
        }
        buffer << " before " << sym2str[g_sym];
        printError(buffer.str());
        skip(s1 + s2);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1c8, %rsp            # imm = 0x1C8
movq %rdi, -0x30(%rbp)
leaq 0x1bd6f(%rip), %rax     # 0x29630
movl (%rax), %eax
btq %rax, %rdi
jb 0xda12
movq %rsi, %rbx
leaq -0x48(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xe00a
leaq -0x1f0(%rbp), %rdi
callq 0x31f0
leaq -0x1e0(%rbp), %r14
leaq 0xe8f0(%rip), %rsi      # 0x1c1e7
movl $0x10, %edx
movq %r14, %rdi
callq 0x3340
movq -0x40(%rbp), %rax
cmpq -0x48(%rbp), %rax
je 0xd96c
movl $0x1, %r13d
xorl %r15d, %r15d
leaq 0x15e72(%rip), %r12     # 0x23790
cmpl $0x1, %r13d
je 0xd938
movl $0x1, %edx
movq %r14, %rdi
leaq 0xe8c5(%rip), %rsi      # 0x1c1f8
callq 0x3340
movq -0x48(%rbp), %rax
movslq (%rax,%r15,4), %rax
shlq $0x5, %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r14, %rdi
callq 0x3340
movq -0x40(%rbp), %rax
subq -0x48(%rbp), %rax
movl %r13d, %r15d
sarq $0x2, %rax
incl %r13d
cmpq %r15, %rax
ja 0xd91e
leaq 0xe887(%rip), %rsi      # 0x1c1fa
movl $0x8, %edx
movq %r14, %rdi
callq 0x3340
leaq 0x1bca9(%rip), %r15     # 0x29630
movl (%r15), %eax
shlq $0x5, %rax
leaq 0x15dfb(%rip), %rcx     # 0x23790
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r14, %rdi
callq 0x3340
leaq -0x1d8(%rbp), %rsi
leaq -0x68(%rbp), %rdi
callq 0x3420
leaq -0x68(%rbp), %rdi
callq 0xda7c
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd9d1
callq 0x32a0
orq -0x30(%rbp), %rbx
movl (%r15), %eax
btq %rax, %rbx
jb 0xd9e5
callq 0x19e44
jmp 0xd9d5
movq 0x155b4(%rip), %rsi     # 0x22fa0
leaq -0x1f0(%rbp), %rdi
callq 0x3210
leaq -0x170(%rbp), %rdi
callq 0x30e0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xda12
callq 0x32a0
addq $0x1c8, %rsp            # imm = 0x1C8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda47
callq 0x32a0
jmp 0xda47
movq %rax, %rbx
jmp 0xda66
jmp 0xda44
jmp 0xda44
movq %rax, %rbx
movq 0x15552(%rip), %rsi     # 0x22fa0
leaq -0x1f0(%rbp), %rdi
callq 0x3210
leaq -0x170(%rbp), %rdi
callq 0x30e0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xda74
callq 0x32a0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/error.cpp
// Function: expect(Symbol)
void expect(Symbol sym)
{
    if (g_sym != sym) {
        std::cout << "Error: expect " << sym2str[sym]
            << " but got " << sym2str[g_sym];
        if (g_sym == IDENTSY)
            std::cout << "<" << g_id << ">";
        std::cout << std::endl;
        std::exit(1);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x1b8f9(%rip), %r15     # 0x29630
cmpl %edi, (%r15)
jne 0xdd45
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl %edi, %ebx
movq 0x15282(%rip), %r14     # 0x22fd0
leaq 0xe4b6(%rip), %rsi      # 0x1c20b
movl $0xe, %edx
movq %r14, %rdi
callq 0x3340
movl %ebx, %eax
shlq $0x5, %rax
leaq 0x15a21(%rip), %r12     # 0x23790
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %r14, %rdi
callq 0x3340
movq %rax, %rbx
leaq 0xe495(%rip), %rsi      # 0x1c21f
movl $0x9, %edx
movq %rax, %rdi
callq 0x3340
movl (%r15), %eax
shlq $0x5, %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x3340
cmpl $0x0, (%r15)
jne 0xddfa
movq 0x15214(%rip), %rbx     # 0x22fd0
leaq 0xe457(%rip), %rsi      # 0x1c21a
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3340
leaq 0x1b861(%rip), %rax     # 0x29638
movq (%rax), %rsi
movq 0x8(%rax), %rdx
movq %rbx, %rdi
callq 0x3340
leaq 0xe42f(%rip), %rsi      # 0x1c21c
movl $0x1, %edx
movq %rax, %rdi
callq 0x3340
movq 0x151cf(%rip), %rdi     # 0x22fd0
callq 0x3130
movl $0x1, %edi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/error.cpp
// Function: expectMul(int, ...)
void expectMul(int num, ...) 
{
    va_list valist;
    va_start(valist, num);
    for (int i = 0; i < num; i++) {
        Symbol sym = (Symbol)va_arg(valist, int);
        if (g_sym == sym) {
            va_end(valist);
            return;
        }
    }
    va_end(valist);
    std::cout << "Error: expect ";
    va_start(valist, num);
    for (int i = 0; i < num; i++) {
        if (i != 0)
            std::cout << "|";
        std::cout << sym2str[va_arg(valist, int)];
    }
    va_end(valist);
    std::cout << ", but got " << sym2str[g_sym] << std::endl;
    std::exit(1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movl %edi, %ebx
leaq -0xf0(%rbp), %r14
movq %rsi, 0x8(%r14)
movq %rdx, 0x10(%r14)
movq %rcx, 0x18(%r14)
movq %r8, 0x20(%r14)
movq %r9, 0x28(%r14)
testb %al, %al
je 0xde71
movaps %xmm0, -0xc0(%rbp)
movaps %xmm1, -0xb0(%rbp)
movaps %xmm2, -0xa0(%rbp)
movaps %xmm3, -0x90(%rbp)
movaps %xmm4, -0x80(%rbp)
movaps %xmm5, -0x70(%rbp)
movaps %xmm6, -0x60(%rbp)
movaps %xmm7, -0x50(%rbp)
movq %r14, -0x30(%rbp)
leaq 0x10(%rbp), %r15
movq %r15, -0x38(%rbp)
movabsq $0x3000000008, %r12     # imm = 0x3000000008
movq %r12, -0x40(%rbp)
testl %edi, %edi
jle 0xded1
movl -0x40(%rbp), %eax
movq -0x30(%rbp), %rcx
leaq 0x1b793(%rip), %rdx     # 0x29630
movl (%rdx), %edx
movq -0x38(%rbp), %rdi
movl %ebx, %esi
cmpl $0x28, %eax
ja 0xdeba
movq %rdi, %r8
movl %eax, %edi
addq %rcx, %rdi
addl $0x8, %eax
movl %eax, -0x40(%rbp)
jmp 0xdec2
leaq 0x8(%rdi), %r8
movq %r8, -0x38(%rbp)
cmpl (%rdi), %edx
je 0xdfaa
movq %r8, %rdi
decl %esi
jne 0xdea5
movq 0x150f8(%rip), %rdi     # 0x22fd0
leaq 0xe32c(%rip), %rsi      # 0x1c20b
movl $0xe, %edx
callq 0x3340
movq %r12, -0x40(%rbp)
movq %r15, -0x38(%rbp)
movq %r14, -0x30(%rbp)
leaq 0x15894(%rip), %r14     # 0x23790
testl %ebx, %ebx
jle 0xdf6a
xorl %r13d, %r13d
movq 0x150c6(%rip), %r15     # 0x22fd0
leaq 0xe2e7(%rip), %r12      # 0x1c1f8
testl %r13d, %r13d
je 0xdf26
movl $0x1, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x3340
movl -0x40(%rbp), %ecx
cmpq $0x28, %rcx
ja 0xdf3e
movq %rcx, %rax
addq -0x30(%rbp), %rax
addl $0x8, %ecx
movl %ecx, -0x40(%rbp)
jmp 0xdf4a
movq -0x38(%rbp), %rax
leaq 0x8(%rax), %rcx
movq %rcx, -0x38(%rbp)
movslq (%rax), %rax
shlq $0x5, %rax
movq (%rax,%r14), %rsi
movq 0x8(%rax,%r14), %rdx
movq %r15, %rdi
callq 0x3340
incl %r13d
cmpl %r13d, %ebx
jne 0xdf11
movq 0x1505f(%rip), %rdi     # 0x22fd0
leaq 0xe2a6(%rip), %rsi      # 0x1c21e
callq 0x32c0
leaq 0x1b6ac(%rip), %rcx     # 0x29630
movl (%rcx), %ecx
shlq $0x5, %rcx
addq %rcx, %r14
movq %rax, %rdi
movq %r14, %rsi
callq 0x3280
movq %rax, %rdi
callq 0x3130
movl $0x1, %edi
callq 0x3360
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/symbol.h
// Function: Symset::toVector()
std::vector<int> toVector() {
        std::vector<int> res;
        for (int i = 0; i < 64; i++) {
            if (contains(i))
                res.push_back(i);
        }
        return res;
    }

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq -0x1c(%rbp), %r15
movl $0x0, (%r15)
xorl %eax, %eax
movq (%r14), %rcx
btq %rax, %rcx
jae 0xe05f
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0xe054
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0xe05f
movq %rbx, %rdi
movq %r15, %rdx
callq 0xe11e
movl -0x1c(%rbp), %ecx
leal 0x1(%rcx), %eax
movl %eax, -0x1c(%rbp)
cmpl $0x3f, %ecx
jl 0xe035
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0xe08b
callq 0x32a0
movq %r14, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/grammar.cpp
// Function: pSignedInteger()
static void pSignedInteger() 
{
    int negtive = 1;
    if (g_sym == PLUS || g_sym == MINUS) {
        negtive = g_sym == MINUS ? -1 : 1;
        readSymbol();
    }
    test3(Symset({INTVALUE}));
    g_num *= negtive;
    readSymbol();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
leaq 0x1654b(%rip), %rax     # 0x29630
movl (%rax), %eax
leal -0x13(%rax), %ecx
movl $0x1, %r13d
cmpl $0x1, %ecx
ja 0x1310a
xorl %ecx, %ecx
cmpl $0x14, %eax
setne %cl
leal -0x1(,%rcx,2), %r13d
callq 0x19e44
movl $0x11, %r12d
leaq -0x2c(%rbp), %rbx
movl %r12d, (%rbx)
leaq -0x48(%rbp), %r14
movl $0x1, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x13eac
movabsq $0x2600000022, %rax     # imm = 0x2600000022
leaq -0x38(%rbp), %rsi
movq %rax, (%rsi)
leaq -0x40(%rbp), %r15
movl $0x2, %edx
movq %r15, %rdi
callq 0x13eac
movq (%r14), %rdi
movq (%r15), %rsi
callq 0xd8a2
movl %r12d, (%rbx)
leaq -0x38(%rbp), %rbx
leaq -0x2c(%rbp), %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x13eac
movq (%rbx), %rax
leaq 0x164b6(%rip), %rcx     # 0x29630
movl (%rcx), %ecx
btq %rcx, %rax
jae 0x13190
leaq 0x164d3(%rip), %rax     # 0x2965c
imull (%rax), %r13d
movl %r13d, (%rax)
callq 0x19e44
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/symbol.h
// Function: Symset::Symset(std::initializer_list<int>)
Symset(std::initializer_list<int> il) {
        bitmap = 0LL;
        for (auto itm : il) {
            if (itm < 0 || itm >= 64) {
                std::cout << "values of symset must between 1 and 64"
                    << std::endl;
                exit(1);
            }
            // (long long) is important
            bitmap |= (long long)1 << itm;
        }
    }

// Assembly:
movq $0x0, (%rdi)
testq %rdx, %rdx
je 0x13eda
shlq $0x2, %rdx
xorl %eax, %eax
xorl %ecx, %ecx
movl (%rsi,%rax), %r8d
cmpq $0x40, %r8
jae 0x13edb
btsq %r8, %rcx
movq %rcx, (%rdi)
addq $0x4, %rax
cmpq %rax, %rdx
jne 0x13ec0
retq
pushq %rbp
movq %rsp, %rbp
movq 0xf0ea(%rip), %rdi      # 0x22fd0
leaq 0x8464(%rip), %rsi      # 0x1c351
callq 0x32c0
movq %rax, %rdi
callq 0x3130
movl $0x1, %edi
callq 0x3360
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/midcode.cpp
// Function: flushCachedMidCode()
void flushCachedMidCode()
{
    int t = cachedMidCode.size();
    assert(t > 0); // t must > 0
    std::vector<FourTuple> &cached = cachedMidCode[t - 1];
    for (const auto &item : cached) {
        genMidCode(item.op, item.a, item.b, item.res);
    }
    cachedMidCode.pop_back();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x11a8f(%rip), %rdx     # 0x27670
movq 0x11a80(%rip), %rax     # 0x27668
subq %rax, %rdx
sarq $0x3, %rdx
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
testl %ecx, %ecx
jle 0x15c4a
decl %ecx
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rbx
movq 0x8(%rax,%rcx,8), %r14
cmpq %r14, %rbx
je 0x15c2f
leaq 0x8(%rbx), %rsi
leaq 0x28(%rbx), %rdx
leaq 0x48(%rbx), %rcx
movq %rbx, %rdi
callq 0x151b0
addq $0x68, %rbx
jmp 0x15c10
movq 0x11a3a(%rip), %rdi     # 0x27670
addq $-0x18, %rdi
movq %rdi, 0x11a2f(%rip)     # 0x27670
popq %rbx
popq %r14
popq %rbp
jmp 0x1405c
leaq 0x6ca6(%rip), %rdi      # 0x1c8f7
leaq 0x6fb9(%rip), %rsi      # 0x1cc11
leaq 0x6fdd(%rip), %rcx      # 0x1cc3c
movl $0x48, %edx
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/midcode.cpp
// Function: isConstValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, int&)
bool isConstValue(const std::string &t, int &val)
{
    if (t[0] == '\'') {
        assert(t[2] == '\'');
        val = t[1];
        return true;
    } else if (std::isdigit(t[0]) || t[0] == '-') {
        val = std::stoi(t);
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq (%rdi), %r15
movsbl (%r15), %eax
cmpl $0x27, %eax
jne 0x16473
cmpb $0x27, 0x2(%r15)
jne 0x164e0
movsbl 0x1(%r15), %eax
jmp 0x164c9
movl %eax, %ecx
addl $-0x30, %ecx
cmpl $0xa, %ecx
setae %cl
cmpb $0x2d, %al
setne %al
testb %cl, %al
jne 0x164cf
callq 0x3050
movq %rax, %r14
movl (%rax), %r13d
movl $0x0, (%rax)
leaq -0x30(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
movl $0xa, %edx
callq 0x33a0
cmpq %r15, (%r12)
je 0x164ff
movslq %eax, %rcx
cmpq %rax, %rcx
jne 0x1650b
movl (%r14), %ecx
cmpl $0x22, %ecx
je 0x1650b
testl %ecx, %ecx
jne 0x164c9
movl %r13d, (%r14)
movl %eax, (%rbx)
movb $0x1, %al
jmp 0x164d1
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x678c(%rip), %rdi      # 0x1cc73
leaq 0x6723(%rip), %rsi      # 0x1cc11
leaq 0x678b(%rip), %rcx      # 0x1cc80
movl $0xb3, %edx
callq 0x31b0
leaq 0x681d(%rip), %rdi      # 0x1cd23
callq 0x3180
leaq 0x6811(%rip), %rdi      # 0x1cd23
callq 0x33b0
cmpl $0x0, (%r14)
jne 0x16520
movl %r13d, (%r14)
movq %rax, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/mips.cpp
// Function: gen_END()
static void gen_END()
{
    // loads $ra from memory
    MIPS(T << "lw" << HT << "$ra, " << cur_func_size - 4 << "($sp)");
    // restore $sp 
    MIPS(T << "addiu" << HT << "$sp, $sp, " << cur_func_size);
    MIPS(T << "jr" << HT << "$ra");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xed8e(%rip), %rbx      # 0x285c0
leaq 0x359e(%rip), %rsi      # 0x1cdd7
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3340
leaq 0x35cc(%rip), %r14      # 0x1ce19
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3340
leaq 0x3600(%rip), %rsi      # 0x1ce64
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3340
movl 0xef3d(%rip), %esi      # 0x287b4
addl $-0x4, %esi
movq %rbx, %rdi
callq 0x3470
movq %rax, %r15
leaq 0x35de(%rip), %rsi      # 0x1ce6a
movl $0x5, %edx
movq %rax, %rdi
callq 0x3340
movq %r15, %rdi
callq 0x16f37
leaq 0x35ab(%rip), %rsi      # 0x1ce53
movl $0x5, %edx
movq %rbx, %rdi
callq 0x3340
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3340
leaq 0x358d(%rip), %rsi      # 0x1ce59
movl $0xa, %edx
movq %rbx, %rdi
callq 0x3340
movl 0xeed5(%rip), %esi      # 0x287b4
movq %rbx, %rdi
callq 0x3470
movq %rax, %rdi
callq 0x16f37
leaq 0x3972(%rip), %rsi      # 0x1d268
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3340
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3340
leaq 0x3951(%rip), %rsi      # 0x1d26b
movl $0x3, %edx
movq %rbx, %rdi
callq 0x3340
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x16f37
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/mips.cpp
// Function: loadToReg(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&)
static void loadToReg(const std::string &reg, const std::string &t)
{
    TabEntry entry;
    int val;

    if (isConstValue(t, val)) {
        MIPS(T << "li" << HT << reg << ", " << val);
        return;
    }
    bool flag = tabFind(t, entry);
    assert(flag == true);
    if (entry.scope == GLOBAL) {
        MIPS(T << "lw" << HT << reg << ", " << t);
    } else {
        MIPS(T << "lw" << HT << reg << ", " << entry.addr << "($sp)");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x24(%rbp), %rsi
movq %rbx, %rdi
callq 0x16448
testb %al, %al
je 0x199c3
leaq 0xec5b(%rip), %rbx      # 0x285c0
leaq 0x34c6(%rip), %rsi      # 0x1ce32
movl $0x2, %edx
movq %rbx, %rdi
callq 0x3340
leaq 0x3499(%rip), %rsi      # 0x1ce19
movl $0x1, %edx
movq %rbx, %rdi
callq 0x3340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x3340
movq %rax, %rbx
leaq 0x3715(%rip), %rsi      # 0x1d0bb
movl $0x2, %edx
movq %rax, %rdi
callq 0x3340
movl -0x24(%rbp), %esi
movq %rbx, %rdi
callq 0x3470
jmp 0x19a68
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x1a8c5
testb %al, %al
je 0x19a80
movl -0x38(%rbp), %r12d
leaq 0xebde(%rip), %r15      # 0x285c0
leaq 0x33ee(%rip), %rsi      # 0x1cdd7
movl $0x2, %edx
movq %r15, %rdi
callq 0x3340
leaq 0x341c(%rip), %rsi      # 0x1ce19
movl $0x1, %edx
movq %r15, %rdi
callq 0x3340
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x3340
movq %rax, %r14
leaq 0x3698(%rip), %rsi      # 0x1d0bb
movl $0x2, %edx
movq %rax, %rdi
callq 0x3340
testl %r12d, %r12d
je 0x19a59
movl -0x28(%rbp), %esi
movq %r14, %rdi
callq 0x3470
movq %rax, %rbx
leaq 0x3420(%rip), %rsi      # 0x1ce6a
movl $0x5, %edx
movq %rax, %rdi
callq 0x3340
jmp 0x19a6b
movq (%rbx), %rsi
movq 0x8(%rbx), %rdx
movq %r14, %rdi
callq 0x3340
movq %rax, %rbx
movq %rbx, %rdi
callq 0x16f37
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3495(%rip), %rdi      # 0x1cf1c
leaq 0x3327(%rip), %rsi      # 0x1cdb5
leaq 0x3494(%rip), %rcx      # 0x1cf29
movl $0x1d4, %edx            # imm = 0x1D4
callq 0x31b0
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/mips.cpp
// Function: getVariableAddr(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
static std::string getVariableAddr(const std::string &t)
{
    TabEntry entry;
    bool flag = tabFind(t, entry);
    if (!flag) {
        std::cout << "Did you forget the TEMP mid-code for temp var?"
                  << std::endl;
    }
    assert(flag == true);
    if (entry.scope == GLOBAL) {
        return t;
    } else {
        return std::to_string(entry.addr) + "($sp)";
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x5c(%rbp), %rsi
movq %r14, %rdi
callq 0x1a8c5
testb %al, %al
je 0x19bf9
cmpl $0x0, -0x5c(%rbp)
je 0x19b2b
movl -0x4c(%rbp), %r13d
movl %r13d, %r14d
negl %r14d
cmovsl %r13d, %r14d
movl $0x1, %r15d
cmpl $0xa, %r14d
jb 0x19b52
movl $0x4, %r15d
movl $0xd1b71759, %eax       # imm = 0xD1B71759
movl %r14d, %ecx
cmpl $0x63, %ecx
jbe 0x19b49
cmpl $0x3e7, %ecx            # imm = 0x3E7
jbe 0x19b4f
cmpl $0x2710, %ecx           # imm = 0x2710
jb 0x19b52
movl %ecx, %edx
imulq %rax, %rdx
shrq $0x2d, %rdx
addl $0x4, %r15d
cmpl $0x1869f, %ecx          # imm = 0x1869F
movl %edx, %ecx
ja 0x19af8
addl $-0x3, %r15d
jmp 0x19b52
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0xe4c0
jmp 0x19be7
addl $-0x2, %r15d
jmp 0x19b52
decl %r15d
shrl $0x1f, %r13d
movl %r13d, %esi
addl %r15d, %esi
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movl $0x2d, %edx
callq 0x3350
movq (%r12), %rdi
addq %r13, %rdi
movl %r15d, %esi
movl %r14d, %edx
callq 0x13f04
leaq 0x32dc(%rip), %rsi      # 0x1ce6a
movq %r12, %rdi
callq 0x34c0
leaq 0x10(%rbx), %rdx
movq %rdx, (%rbx)
movq (%rax), %rsi
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rsi
je 0x19bb8
movq %rsi, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x19bbe
movups (%rcx), %xmm0
movups %xmm0, (%rdx)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x19be7
callq 0x32a0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x93d0(%rip), %rdi      # 0x22fd0
leaq 0x335b(%rip), %rsi      # 0x1cf62
callq 0x32c0
movq %rax, %rdi
callq 0x3130
leaq 0x3301(%rip), %rdi      # 0x1cf1c
leaq 0x3193(%rip), %rsi      # 0x1cdb5
leaq 0x3368(%rip), %rcx      # 0x1cf91
movl $0x1e9, %edx            # imm = 0x1E9
callq 0x31b0
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x19c48
callq 0x32a0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/symbol.cpp
// Function: extraCodeChecking()
void extraCodeChecking()
{
    check_remaining_flag = true;
    while (nextch()) {
        if (!isBlankCharacter(ch)) {
            error(ERR_REDUNDENT_CODE);
            printCachedErrors();
            std::exit(1);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movb $0x1, 0xf0be(%rip)      # 0x296ac
callq 0x1a3ba
testb %al, %al
je 0x1a64d
movzbl 0x8c82(%rip), %eax      # 0x23280
leal -0x9(%rax), %ecx
cmpl $0x2, %ecx
jb 0x1a5ee
cmpl $0x20, %eax
je 0x1a5ee
leaq -0x20(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x2c95(%rip), %rsi      # 0x1d2af
leaq 0x2cac(%rip), %rdx      # 0x1d2cd
leaq -0x30(%rbp), %rbx
movq %rbx, %rdi
callq 0x14454
movq %rbx, %rdi
callq 0xdcc8
leaq -0x30(%rbp), %rdi
callq 0x34d8
callq 0xd6dc
movl $0x1, %edi
callq 0x3360
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
cmpq %r14, %rdi
je 0x1a667
callq 0x32a0
movq %rbx, %rdi
callq 0x3480
nop
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/table.cpp
// Function: tabInsertParam(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, DataType&)
void tabInsertParam(const std::string &id, DataType &dtype)
{
    std::unordered_map<std::string, std::vector
        <DataType>>::iterator it;
    if ((it = funcParams.find(id)) == funcParams.end()) {
        std::vector<DataType> params;
        params.push_back(dtype);
        funcParams[id] = params;
    } 
    else {
        std::vector<DataType> &params = (*it).second;
        params.push_back(dtype);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xfa88(%rip), %rdi      # 0x2a250
movq %rbx, %rsi
callq 0x1b090
testq %rax, %rax
je 0x1a7ee
movq 0x30(%rax), %rsi
cmpq 0x38(%rax), %rsi
je 0x1a815
movl (%r14), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x30(%rax)
jmp 0x1a861
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x28(%rbp), %rsi
testq %rsi, %rsi
je 0x1a82c
movl (%r14), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, -0x28(%rbp)
jmp 0x1a838
addq $0x28, %rax
movq %rax, %rdi
movq %r14, %rdx
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x1b19c
leaq -0x30(%rbp), %rdi
movq %r14, %rdx
callq 0x1b19c
leaq 0xfa11(%rip), %rdi      # 0x2a250
movq %rbx, %rsi
callq 0x1b2d4
leaq -0x30(%rbp), %rsi
movq %rax, %rdi
callq 0x1acf4
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1a861
callq 0x32a0
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x1a87b
callq 0x32a0
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/table.cpp
// Function: tabGetParams(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
const std::vector<DataType> & tabGetParams(const std::string &id) 
{
    const static std::vector<DataType> EMPTY_PARAMS;
    std::unordered_map<std::string, std::vector
        <DataType>>::iterator it;
    if ((it = funcParams.find(id)) != funcParams.end()) {
        return (*it).second;
    }
    else return EMPTY_PARAMS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb 0xfa0e(%rip), %al       # 0x2a2a0
testb %al, %al
je 0x1a8be
leaq 0xf9b3(%rip), %rdi      # 0x2a250
movq %rbx, %rsi
callq 0x1b090
leaq 0x28(%rax), %rcx
testq %rax, %rax
leaq 0xf9d5(%rip), %rax      # 0x2a288
cmovneq %rcx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x359b
jmp 0x1a896
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/table.cpp
// Function: tabFind(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&, _TabEntry&)
bool tabFind(const std::string &id, TabEntry &entry)
{
    std::unordered_map<std::string, TabEntry>::iterator it;
    // find in local
    if ((it = symbolTableL.find(id)) != symbolTableL.end()) {
        entry = (*it).second;
        return true;
    }
    // find in global
    if ((it = symbolTableG.find(id)) != symbolTableG.end()) {
        entry = (*it).second;
        return true;
    }
    return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xf93f(%rip), %rdi      # 0x2a218
movq %r14, %rsi
callq 0x1b630
testq %rax, %rax
jne 0x1a8fa
leaq 0xf8f3(%rip), %rdi      # 0x2a1e0
movq %r14, %rsi
callq 0x1b630
testq %rax, %rax
je 0x1a90e
movl 0x38(%rax), %ecx
movl %ecx, 0x10(%rbx)
movups 0x28(%rax), %xmm0
movups %xmm0, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x1a909
// File: /workspace/github_cpp_makefile_star2_O1/fondoger[P]C0-Compiler/src/table.cpp
// Function: printSymbolTable(IdentScope)
void printSymbolTable(IdentScope scope)
{
    std::cout << (scope == GLOBAL ? 
        "##############Global table##############\n":
        "##############Local table###############\n");
    const std::unordered_map<std::string, TabEntry> &symbolTable =
        (scope == GLOBAL) ? symbolTableG : symbolTableL;
    int count = 0;
    for (auto const& item : symbolTable) {
        count++;
        std::cout << count << ":";
        printTabEntry(item.first, item.second);
    }
    std::cout << "################Table End###########\n";
    count = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testl %edi, %edi
leaq 0x2a34(%rip), %rax      # 0x1d35d
leaq 0x2a57(%rip), %rsi      # 0x1d387
cmoveq %rax, %rsi
leaq 0xf8b5(%rip), %rax      # 0x2a1f0
leaq 0xf8e6(%rip), %r14      # 0x2a228
cmoveq %rax, %r14
movq 0x8683(%rip), %rbx      # 0x22fd0
movl $0x29, %edx
movq %rbx, %rdi
callq 0x3340
movq (%r14), %r15
testq %r15, %r15
je 0x1aaa3
movl $0x1, %r14d
leaq 0x2748(%rip), %r12      # 0x1d0bb
movq %rbx, %rdi
movl %r14d, %esi
callq 0x3470
movl $0x1, %edx
movq %rax, %rdi
leaq 0x1841(%rip), %rsi      # 0x1c1ce
callq 0x3340
movq 0x8(%r15), %rsi
movq 0x10(%r15), %rdx
movq %rbx, %rdi
callq 0x3340
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
movl 0x2c(%r15), %eax
shlq $0x5, %rax
leaq 0xf6bc(%rip), %rcx      # 0x2a080
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r13, %rdi
callq 0x3340
movq %rax, %r13
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
movl 0x30(%r15), %eax
shlq $0x5, %rax
leaq 0xf6e9(%rip), %rcx      # 0x2a0e0
movq (%rax,%rcx), %rsi
movq 0x8(%rax,%rcx), %rdx
movq %r13, %rdi
callq 0x3340
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x3340
cmpl $0x0, 0x2c(%r15)
je 0x1aa25
movl 0x34(%r15), %esi
jmp 0x1aa30
movl 0x34(%r15), %esi
cmpl $0x1, 0x30(%r15)
jne 0x1aa8c
movq %rbx, %rdi
callq 0x3470
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3340
movl 0x38(%r15), %esi
movq %rbx, %rdi
callq 0x3470
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x32b0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x3030
movq %rax, %rdi
callq 0x31d0
movq (%r15), %r15
incl %r14d
testq %r15, %r15
jne 0x1a973
jmp 0x1aaa3
movb %sil, -0x29(%rbp)
movl $0x1, %edx
movq %rbx, %rdi
leaq -0x29(%rbp), %rsi
callq 0x3340
jmp 0x1aa38
movq 0x8526(%rip), %rdi      # 0x22fd0
leaq 0x2900(%rip), %rsi      # 0x1d3b1
movl $0x25, %edx
callq 0x3340
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq