LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0x30, %rsp
movw %dx, %ax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movswl -0x12(%rbp), %eax
cmpl $0x0, %eax
jle 0x1a404
movq -0x8(%rbp), %rdi
callq 0x18170
movsbl (%rax), %edi
callq 0x1a410
movb %al, -0x13(%rbp)
movq -0x8(%rbp), %rdi
callq 0x18110
movb -0x13(%rbp), %al
addb $-0x1, %al
movb %al, -0x13(%rbp)
movsbl -0x13(%rbp), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
jle 0x1a3bd
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x52c0
movq -0x30(%rbp), %rdi
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rsi
callq 0x17ab0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x21(%rbp)
jne 0x1a3a7
jmp 0x1a3bd
movq -0x8(%rbp), %rdi
callq 0x18170
movsbl (%rax), %edi
callq 0x1ab40
xorb $-0x1, %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1a358
movsbl -0x13(%rbp), %eax
cmpl $0x0, %eax
jle 0x1a3f1
movq 0xdc14(%rip), %rdi      # 0x27fe8
leaq 0x11455(%rip), %rsi     # 0x2b830
callq 0x5430
movq %rax, %rdi
movq 0xdbb6(%rip), %rsi      # 0x27fa0
callq 0x5510
jmp 0x1a404
jmp 0x1a3f3
movw -0x12(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x12(%rbp)
jmp 0x1a337
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
movb %al, -0x3(%rbp)
movzbl -0x3(%rbp), %eax
cmpl $0x80, %eax
jge 0x1a435
movb $0x1, -0x1(%rbp)
jmp 0x1a4af
movzbl -0x3(%rbp), %eax
cmpl $0xc2, %eax
jl 0x1a451
movzbl -0x3(%rbp), %eax
cmpl $0xdf, %eax
jg 0x1a451
movb $0x2, -0x1(%rbp)
jmp 0x1a4af
movzbl -0x3(%rbp), %eax
cmpl $0xe0, %eax
jl 0x1a46d
movzbl -0x3(%rbp), %eax
cmpl $0xef, %eax
jg 0x1a46d
movb $0x3, -0x1(%rbp)
jmp 0x1a4af
movzbl -0x3(%rbp), %eax
cmpl $0xf0, %eax
jl 0x1a489
movzbl -0x3(%rbp), %eax
cmpl $0xf4, %eax
jg 0x1a489
movb $0x4, -0x1(%rbp)
jmp 0x1a4af
movq 0xdb58(%rip), %rdi      # 0x27fe8
leaq 0x11399(%rip), %rsi     # 0x2b830
callq 0x5430
movq %rax, %rdi
movq 0xdafa(%rip), %rsi      # 0x27fa0
callq 0x5510
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5470
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x58b0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1abc0
testb $0x1, %al
jne 0x1a840
jmp 0x1a87c
leaq -0x18(%rbp), %rdi
callq 0x1ac00
movzbl (%rax), %eax
cmpl $0x80, %eax
jl 0x1a866
leaq -0x18(%rbp), %rdi
callq 0x1ac00
movzbl (%rax), %eax
cmpl $0xbf, %eax
jle 0x1a86f
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a871
leaq -0x18(%rbp), %rdi
callq 0x1ac20
jmp 0x1a820
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movw $0x0, -0xe(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1a959
movq -0x8(%rbp), %rdi
movswq -0xe(%rbp), %rsi
callq 0x5570
movsbl (%rax), %edi
callq 0x1a410
movsbl %al, %ecx
movswl -0xe(%rbp), %eax
addl %ecx, %eax
movw %ax, -0xe(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1a925
movw -0xe(%rbp), %ax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x28(%rbp)
movw %cx, %ax
movw %dx, %cx
movq %rdi, %rdx
movq %rdx, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movw %cx, -0x12(%rbp)
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movswl -0x12(%rbp), %esi
callq 0x1a910
movw %ax, -0x16(%rbp)
movw $0x0, -0x18(%rbp)
movswl -0x14(%rbp), %eax
cmpl $0x0, %eax
jle 0x1aa72
movq -0x10(%rbp), %rdi
movswl -0x16(%rbp), %eax
movswl -0x18(%rbp), %ecx
addl %ecx, %eax
movslq %eax, %rsi
callq 0x5570
movsbl (%rax), %edi
callq 0x1a410
movsbl %al, %ecx
movswl -0x18(%rbp), %eax
addl %ecx, %eax
movw %ax, -0x18(%rbp)
movw -0x14(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x1aa30
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rsi
movswq -0x16(%rbp), %rdx
movswq -0x18(%rbp), %rcx
callq 0x54e0
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x10(%rbp)
movw %ax, -0x12(%rbp)
movw -0x12(%rbp), %ax
movw %ax, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movswq -0x14(%rbp), %rsi
callq 0x5570
movsbl (%rax), %edi
callq 0x1ab40
xorb $-0x1, %al
testb $0x1, %al
jne 0x1aad9
jmp 0x1aae7
movw -0x14(%rbp), %ax
addw $-0x1, %ax
movw %ax, -0x14(%rbp)
jmp 0x1aabb
movswl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movswq -0x14(%rbp), %rsi
callq 0x5570
movsbl (%rax), %edi
callq 0x1a410
movb %al, %cl
movl -0x18(%rbp), %eax
movsbl %cl, %ecx
addl %ecx, %eax
movswl -0x12(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1ab20
movw -0x14(%rbp), %ax
movw %ax, -0x2(%rbp)
jmp 0x1ab28
movw -0x12(%rbp), %ax
movw %ax, -0x2(%rbp)
movw -0x2(%rbp), %ax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x80, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x56f0
leaq 0x4407(%rip), %rdi      # 0x1f071
callq 0x55f0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x1ace3
movq -0x18(%rbp), %rax
cmpb $0x0, (%rax)
je 0x1ace3
movq -0x18(%rbp), %rax
movq %rax, -0x70(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x5840
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdx
leaq -0x38(%rbp), %rdi
callq 0xa030
jmp 0x1acab
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5600
leaq -0x38(%rbp), %rdi
callq 0x5968
leaq -0x39(%rbp), %rdi
callq 0x5540
jmp 0x1ad26
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x5540
jmp 0x1ad58
movq 0xd2fe(%rip), %rdi      # 0x27fe8
leaq 0x4385(%rip), %rsi      # 0x1f076
callq 0x54b0
movq %rax, -0x78(%rbp)
jmp 0x1acfc
movq -0x78(%rbp), %rdi
movq 0xd299(%rip), %rsi      # 0x27fa0
callq 0x5510
jmp 0x1ad0e
movl $0x1, %edi
callq 0x55e0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1ad58
movq -0x60(%rbp), %rdi
leaq 0x4357(%rip), %rsi      # 0x1f088
callq 0x5480
jmp 0x1ad38
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x1ad4b
movq -0x60(%rbp), %rdi
callq 0x5968
movq -0x58(%rbp), %rax
addq $0x80, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x5968
movq -0x48(%rbp), %rdi
callq 0x5830
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movb $0x0, -0x15(%rbp)
movswl (%rax), %esi
movswl 0x2(%rax), %edx
callq 0x1ae10
movl -0x14(%rbp), %eax
movq %rax, -0x20(%rbp)
subq $0x7, %rax
ja 0x1b041
movq -0x20(%rbp), %rax
leaq 0x412a(%rip), %rcx      # 0x1f0a8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rax
movw 0x2(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movw 0x2(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw (%rax), %cx
addw $0x1, %cx
movw %cx, (%rax)
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw (%rax), %cx
addw $-0x1, %cx
movw %cx, (%rax)
movw 0x2(%rax), %cx
addw $0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw (%rax), %cx
addw $-0x1, %cx
movw %cx, (%rax)
jmp 0x1b043
movq -0x30(%rbp), %rax
movw (%rax), %cx
addw $-0x1, %cx
movw %cx, (%rax)
movw 0x2(%rax), %cx
addw $-0x1, %cx
movw %cx, 0x2(%rax)
jmp 0x1b043
jmp 0x1b043
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1b056
movq -0x30(%rbp), %rdi
callq 0x1ae40
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0xe(%rbp), %rdi
movq %rdi, -0x18(%rbp)
xorl %edx, %edx
movl %edx, %esi
callq 0x1ae10
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1ae50
cvttss2si %xmm0, %eax
movw %ax, -0x10(%rbp)
leaq -0xe(%rbp), %rdi
callq 0x1ae40
movw -0x10(%rbp), %ax
movw %ax, -0xa(%rbp)
cmpw $0x0, -0xa(%rbp)
je 0x1b0de
movq -0x20(%rbp), %rax
movswl -0xa(%rbp), %ecx
movswl (%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movw %cx, (%rax)
movswl -0xa(%rbp), %ecx
movswl 0x2(%rax), %eax
cltd
idivl %ecx
movl %eax, %ecx
movq -0x20(%rbp), %rax
movw %cx, 0x2(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, %rax
movq -0x30(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq %rax, -0x10(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movzwl (%rax), %edx
movzwl (%rdi), %ecx
subl %edx, %ecx
movw %cx, (%rdi)
movzwl 0x2(%rax), %ecx
movzwl 0x2(%rdi), %eax
subl %ecx, %eax
movw %ax, 0x2(%rdi)
callq 0x1b060
movq -0x28(%rbp), %rsi
movswl (%rsi), %edx
movswl 0x2(%rsi), %eax
movl %eax, %ecx
movl %edx, %eax
leal 0x2(%rax,%rcx), %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x4, %eax
ja 0x1b1cb
movq -0x20(%rbp), %rax
leaq 0x3f6e(%rip), %rcx      # 0x1f0c8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x3, -0x4(%rbp)
jmp 0x1b1d2
movl $0x7, -0x4(%rbp)
jmp 0x1b1d2
movq -0x28(%rbp), %rax
cmpw $0x0, (%rax)
je 0x1b188
movl $0x2, -0x4(%rbp)
jmp 0x1b1d2
movl $0x4, -0x4(%rbp)
jmp 0x1b1d2
movq -0x28(%rbp), %rax
cmpw $0x0, (%rax)
je 0x1b1a4
movl $0x6, -0x4(%rbp)
jmp 0x1b1d2
movl $0x0, -0x4(%rbp)
jmp 0x1b1d2
movq -0x28(%rbp), %rax
movswl (%rax), %eax
cmpl $0x1, %eax
jne 0x1b1c2
movl $0x1, -0x4(%rbp)
jmp 0x1b1d2
movl $0x5, -0x4(%rbp)
jmp 0x1b1d2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x57f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x9(%rbp)
jne 0x1b30a
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x5930
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0x9(%rbp)
movb -0x9(%rbp), %al
testb $0x1, %al
jne 0x1b313
jmp 0x1b327
movq -0x8(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0x1, %edx
callq 0x5120
jmp 0x1b2dc
jmp 0x1b329
movq -0x8(%rbp), %rdi
callq 0x57f0
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0xa(%rbp)
jne 0x1b36b
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5350
movq -0x18(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
callq 0x5930
movsbl (%rax), %eax
cmpl $0x20, %eax
sete %al
movb %al, -0xa(%rbp)
movb -0xa(%rbp), %al
testb $0x1, %al
jne 0x1b374
jmp 0x1b39e
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x5350
movq -0x20(%rbp), %rdi
movq %rax, %rsi
subq $0x1, %rsi
movq $-0x1, %rdx
callq 0x5120
jmp 0x1b329
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
leaq 0x2e1e1(%rip), %rdi     # 0x46190
callq 0x18a40
cmpq $0x0, %rax
je 0x1810e
movq 0x2d003(%rip), %rdi     # 0x44fc8
leaq 0x1d22e(%rip), %rsi     # 0x351fa
callq 0x3300
movq %rax, %rdi
movq 0x2cfcd(%rip), %rsi     # 0x44fa8
callq 0x3360
movl $0x0, -0x8(%rbp)
leaq 0x2e1a2(%rip), %rax     # 0x46190
movq %rax, -0x10(%rbp)
leaq 0x2e197(%rip), %rdi     # 0x46190
callq 0x18a60
movq %rax, -0x18(%rbp)
leaq 0x2e187(%rip), %rdi     # 0x46190
callq 0x18a90
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18ac0
testb $0x1, %al
jne 0x18028
jmp 0x18108
leaq -0x18(%rbp), %rdi
callq 0x18b00
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x3140
cmpl $0x6, -0x8(%rbp)
jne 0x180c2
movq 0x2cf7e(%rip), %rdi     # 0x44fc8
leaq 0x1d1cb(%rip), %rsi     # 0x3521c
callq 0x3300
movq %rax, -0x58(%rbp)
jmp 0x1805c
leaq 0x2e12d(%rip), %rdi     # 0x46190
callq 0x18a40
movq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x30b0
movq %rax, -0x60(%rbp)
jmp 0x1807a
movq -0x60(%rbp), %rdi
leaq 0x1d1a0(%rip), %rsi     # 0x35225
callq 0x3300
movq %rax, -0x68(%rbp)
jmp 0x18090
movq -0x68(%rbp), %rdi
movq 0x2cf0d(%rip), %rsi     # 0x44fa8
callq 0x3360
jmp 0x180a2
movl $0x2, -0x50(%rbp)
jmp 0x180e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35e8
jmp 0x1811d
movq 0x2ceff(%rip), %rdi     # 0x44fc8
leaq -0x40(%rbp), %rsi
callq 0x32c0
jmp 0x180d4
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
movl $0x0, -0x50(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x35e8
movl -0x50(%rbp), %eax
testl %eax, %eax
je 0x180f8
jmp 0x180f6
jmp 0x18108
jmp 0x180fa
leaq -0x18(%rbp), %rdi
callq 0x18b20
jmp 0x18012
movb $0x1, -0x1(%rbp)
jmp 0x18112
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0x210, %rsp            # imm = 0x210
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0x33526(%rip), %rax     # 0x4b6b0
movl (%rax), %esi
leaq -0x8(%rbp), %rdi
callq 0x18b40
testb $0x1, %al
jne 0x18390
leaq -0x28(%rbp), %rdi
leaq -0x8(%rbp), %rsi
callq 0x18b80
leaq -0x1b0(%rbp), %rdi
callq 0x3270
jmp 0x181b8
leaq -0x1a0(%rbp), %rdi
leaq 0x1d06d(%rip), %rsi     # 0x35233
callq 0x3300
jmp 0x181cd
movl $0x0, -0x1c0(%rbp)
movl -0x1c0(%rbp), %eax
movq %rax, -0x1f0(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x18c30
movq %rax, %rcx
movq -0x1f0(%rbp), %rax
cmpq %rcx, %rax
jae 0x182a2
cmpl $0x0, -0x1c0(%rbp)
je 0x1824e
leaq -0x1a0(%rbp), %rdi
leaq 0x1d02d(%rip), %rsi     # 0x35244
callq 0x3300
jmp 0x1821e
jmp 0x1824e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x18385
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
jmp 0x18379
leaq -0x1a0(%rbp), %rax
movq %rax, -0x1f8(%rbp)
movl -0x1c0(%rbp), %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
callq 0x18c50
movq -0x1f8(%rbp), %rdi
movslq (%rax), %rax
shlq $0x5, %rax
leaq 0x2d58e(%rip), %rsi     # 0x45810
addq %rax, %rsi
callq 0x32c0
jmp 0x1828c
jmp 0x1828e
movl -0x1c0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c0(%rbp)
jmp 0x181d7
leaq -0x1a0(%rbp), %rdi
leaq 0x1cf96(%rip), %rsi     # 0x35246
callq 0x3300
movq %rax, -0x200(%rbp)
jmp 0x182be
movq -0x200(%rbp), %rdi
leaq 0x333e4(%rip), %rax     # 0x4b6b0
movl (%rax), %eax
shlq $0x5, %rax
leaq 0x2d537(%rip), %rsi     # 0x45810
addq %rax, %rsi
callq 0x32c0
jmp 0x182e3
leaq -0x1e0(%rbp), %rdi
leaq -0x1b0(%rbp), %rsi
callq 0x32f0
jmp 0x182f8
leaq -0x1e0(%rbp), %rdi
callq 0x183b0
jmp 0x18306
leaq -0x1e0(%rbp), %rdi
callq 0x35e8
leaq -0x8(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x18c70
movq %rax, -0x208(%rbp)
jmp 0x18328
movq -0x208(%rbp), %rax
movq %rax, -0x1e8(%rbp)
movq -0x1e8(%rbp), %rdi
callq 0x18130
jmp 0x18344
leaq -0x1b0(%rbp), %rdi
callq 0x35f0
leaq -0x28(%rbp), %rdi
callq 0x18cb0
jmp 0x18390
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x1b8(%rbp)
movl %eax, -0x1bc(%rbp)
leaq -0x1e0(%rbp), %rdi
callq 0x35e8
leaq -0x1b0(%rbp), %rdi
callq 0x35f0
leaq -0x28(%rbp), %rdi
callq 0x18cb0
jmp 0x18399
addq $0x210, %rsp            # imm = 0x210
popq %rbp
retq
movq -0x1b8(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
leaq 0x3301e(%rip), %rax     # 0x4b6b0
movl (%rax), %eax
cmpl -0x4(%rbp), %eax
je 0x18751
movq 0x2c924(%rip), %rdi     # 0x44fc8
leaq 0x1cbac(%rip), %rsi     # 0x35257
callq 0x3300
movq %rax, %rdi
movl -0x4(%rbp), %eax
leaq 0x2d153(%rip), %rsi     # 0x45810
shlq $0x5, %rax
addq %rax, %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x1cb98(%rip), %rsi     # 0x3526b
callq 0x3300
movq %rax, %rdi
leaq 0x32fce(%rip), %rax     # 0x4b6b0
movl (%rax), %eax
leaq 0x2d125(%rip), %rsi     # 0x45810
shlq $0x5, %rax
addq %rax, %rsi
callq 0x32c0
leaq 0x32fb2(%rip), %rax     # 0x4b6b0
cmpl $0x0, (%rax)
jne 0x18734
movq 0x2c8be(%rip), %rdi     # 0x44fc8
leaq 0x1cb55(%rip), %rsi     # 0x35266
callq 0x3300
movq %rax, %rdi
leaq 0x32f98(%rip), %rsi     # 0x4b6b8
callq 0x32c0
movq %rax, %rdi
leaq 0x1cb39(%rip), %rsi     # 0x35268
callq 0x3300
movq 0x2c88d(%rip), %rdi     # 0x44fc8
movq 0x2c866(%rip), %rsi     # 0x44fa8
callq 0x3360
movl $0x1, %edi
callq 0x33c0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x18ed0
movl $0x0, -0x18(%rbp)
cmpl $0x40, -0x18(%rbp)
jge 0x18c00
movq -0x30(%rbp), %rdi
movl -0x18(%rbp), %esi
callq 0x18b40
testb $0x1, %al
jne 0x18bcb
jmp 0x18bf3
movq -0x40(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x18ef0
jmp 0x18bda
jmp 0x18bf3
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x18cb0
jmp 0x18c1d
jmp 0x18bf5
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x18bb3
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x18c13
movq -0x40(%rbp), %rdi
callq 0x18cb0
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movl $0x1, -0x4(%rbp)
leaq 0x2a7ca(%rip), %rax     # 0x4b6b0
cmpl $0x13, (%rax)
je 0x20ef7
leaq 0x2a7be(%rip), %rax     # 0x4b6b0
cmpl $0x14, (%rax)
jne 0x20f18
leaq 0x2a7b2(%rip), %rax     # 0x4b6b0
movl (%rax), %edx
movl $0x1, %eax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpl $0x14, %edx
cmovel %ecx, %eax
movl %eax, -0x4(%rbp)
callq 0x2e050
jmp 0x20f1a
movl $0x11, -0x24(%rbp)
leaq -0x24(%rbp), %rax
movq %rax, -0x20(%rbp)
movq $0x1, -0x18(%rbp)
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rdx
leaq -0x10(%rbp), %rdi
callq 0x227f0
movl $0x22, -0x48(%rbp)
movl $0x26, -0x44(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x2, -0x38(%rbp)
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdx
leaq -0x30(%rbp), %rdi
callq 0x227f0
movq -0x10(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x18170
movl $0x11, -0x64(%rbp)
leaq -0x64(%rbp), %rax
movq %rax, -0x60(%rbp)
movq $0x1, -0x58(%rbp)
movq -0x60(%rbp), %rsi
movq -0x58(%rbp), %rdx
leaq -0x50(%rbp), %rdi
callq 0x227f0
leaq 0x2a703(%rip), %rax     # 0x4b6b0
movl (%rax), %esi
leaq -0x50(%rbp), %rdi
callq 0x18b40
xorb $-0x1, %al
testb $0x1, %al
jne 0x20fc0
jmp 0x20fc7
callq 0x2e050
jmp 0x20fe4
jmp 0x20fc9
movl -0x4(%rbp), %ecx
leaq 0x2a709(%rip), %rax     # 0x4b6dc
imull (%rax), %ecx
leaq 0x2a6ff(%rip), %rax     # 0x4b6dc
movl %ecx, (%rax)
callq 0x2e050
addq $0x70, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq $0x0, (%rax)
leaq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x228d0
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x228f0
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
je 0x228a6
movq -0x28(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x34(%rbp)
cmpl $0x0, -0x34(%rbp)
jl 0x22854
cmpl $0x40, -0x34(%rbp)
jl 0x22880
movq 0x2276d(%rip), %rdi     # 0x44fc8
leaq 0x12b8e(%rip), %rsi     # 0x353f0
callq 0x3300
movq %rax, %rdi
movq 0x22737(%rip), %rsi     # 0x44fa8
callq 0x3360
movl $0x1, %edi
callq 0x33c0
movq -0x40(%rbp), %rax
movl -0x34(%rbp), %ecx
movl $0x1, %edx
shlq %cl, %rdx
movq %rdx, %rcx
orq (%rax), %rcx
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
addq $0x4, %rax
movq %rax, -0x28(%rbp)
jmp 0x22835
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/midcode.cpp
// Function: genMidCode(OpCode 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&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
void genMidCode(
    const OpCode &op,
    const std::string &a,
    const std::string &b,
    const std::string &res)
{
    FourTuple t = { op, a, b, res };
    // cache_depth usually is 0
    if (cache_depth != 0) {
        // NOTE: do use reference here
        std::vector<FourTuple> &cache = 
            cachedMidCode[cache_depth - 1];
        cache.push_back(t);
        return;
    }
    midcode_stream << convertFormat(t) << std::endl;
    mid_codes.push_back(t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x88(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
movq -0x10(%rbp), %rsi
callq 0x3140
leaq -0x60(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
movq -0x18(%rbp), %rsi
callq 0x3140
jmp 0x26391
leaq -0x40(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x3140
jmp 0x263a0
cmpl $0x0, 0x23359(%rip)     # 0x49700
je 0x26449
movl 0x2334d(%rip), %eax     # 0x49700
decl %eax
movslq %eax, %rsi
leaq 0x23329(%rip), %rdi     # 0x496e8
callq 0x278e0
movq %rax, -0xa0(%rbp)
movq -0xa0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x27900
jmp 0x263e0
movl $0x1, -0xa4(%rbp)
jmp 0x264ba
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x26421
movq -0xd0(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
callq 0x35e8
movq -0xd8(%rbp), %rdi
callq 0x35e8
jmp 0x264f9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
jmp 0x264ed
leaq -0xc8(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x26510
jmp 0x2645e
leaq 0x21eab(%rip), %rdi     # 0x48310
leaq -0xc8(%rbp), %rsi
callq 0x32c0
movq %rax, -0xe0(%rbp)
jmp 0x2647a
movq -0xe0(%rbp), %rdi
movq 0x1eb20(%rip), %rsi     # 0x44fa8
callq 0x3360
jmp 0x2648f
leaq -0xc8(%rbp), %rdi
callq 0x35e8
leaq 0x2322e(%rip), %rdi     # 0x496d0
leaq -0x88(%rbp), %rsi
callq 0x27900
jmp 0x264b0
movl $0x0, -0xa4(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x22d60
addq $0xe0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x90(%rbp)
movl %eax, -0x94(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x35e8
leaq -0x88(%rbp), %rdi
callq 0x22d60
movq -0x90(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
leaq 0x225e9(%rip), %rdi     # 0x496e8
callq 0x279e0
movl %eax, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x2710f
jmp 0x2712e
leaq 0xe9d7(%rip), %rdi      # 0x35aed
leaq 0xece0(%rip), %rsi      # 0x35dfd
movl $0x48, %edx
leaq 0xecff(%rip), %rcx      # 0x35e28
callq 0x3230
movl -0x4(%rbp), %eax
subl $0x1, %eax
movslq %eax, %rsi
leaq 0x225aa(%rip), %rdi     # 0x496e8
callq 0x278e0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22da0
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
callq 0x22dd0
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x22e00
testb $0x1, %al
jne 0x2717c
jmp 0x271b5
leaq -0x20(%rbp), %rdi
callq 0x22e40
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movq -0x30(%rbp), %rsi
addq $0x8, %rsi
movq -0x30(%rbp), %rdx
addq $0x28, %rdx
movq -0x30(%rbp), %rcx
addq $0x48, %rcx
callq 0x26340
leaq -0x20(%rbp), %rdi
callq 0x22e60
jmp 0x27169
leaq 0x2252c(%rip), %rdi     # 0x496e8
callq 0x27a10
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3380
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x277f9
movq -0x10(%rbp), %rdi
movl $0x2, %esi
callq 0x3380
movsbl (%rax), %eax
cmpl $0x27, %eax
jne 0x277bd
jmp 0x277dc
leaq 0xe69b(%rip), %rdi      # 0x35e5f
leaq 0xe632(%rip), %rsi      # 0x35dfd
movl $0xb3, %edx
leaq 0xe695(%rip), %rcx      # 0x35e6c
callq 0x3230
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x3380
movsbl (%rax), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2784e
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3380
movsbl (%rax), %edi
callq 0x32d0
cmpl $0x0, %eax
jne 0x27828
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3380
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x27848
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x27ae0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movb $0x1, -0x1(%rbp)
jmp 0x2784e
jmp 0x2784a
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/mips.cpp
// Function: convertToMIPS()
void convertToMIPS()
{
    m = mid_codes.begin();

    MIPS(T << ".data");
    indent();
    gen_global_variables();
    gen_strings();
    unindent();
    MIPS(T << ".text");
    // jump to main function
    indent();
    gen_start_code();
    unindent();
    // conver functions
    assert((*m).op == FUNC);
    while (m != mid_codes.end() && (*m).op == FUNC)
        gen_FUNC();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x20571(%rip), %rdi     # 0x496d0
callq 0x22da0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, 0x21665(%rip)     # 0x4a7d8
leaq 0x214b6(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0xcdef(%rip), %rsi      # 0x35f74
callq 0x3300
movq %rax, %rdi
callq 0x29270
callq 0x29930
callq 0x29950
callq 0x29b00
callq 0x29bc0
leaq 0x21483(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0xcdc2(%rip), %rsi      # 0x35f7a
callq 0x3300
movq %rax, %rdi
callq 0x29270
callq 0x29930
callq 0x29c00
callq 0x29bc0
leaq 0x215fd(%rip), %rdi     # 0x4a7d8
callq 0x22e40
cmpl $0x5, (%rax)
jne 0x291e7
jmp 0x29206
leaq 0xcd92(%rip), %rdi      # 0x35f80
leaq 0xcd9b(%rip), %rsi      # 0x35f90
movl $0xb7, %edx
leaq 0xcd9c(%rip), %rcx      # 0x35f9d
callq 0x3230
jmp 0x29208
leaq 0x204c1(%rip), %rdi     # 0x496d0
callq 0x22dd0
movq %rax, -0x10(%rbp)
leaq 0x215b9(%rip), %rdi     # 0x4a7d8
leaq -0x10(%rbp), %rsi
callq 0x22e00
movb %al, %cl
xorl %eax, %eax
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x29236
jmp 0x2924b
leaq 0x2159b(%rip), %rdi     # 0x4a7d8
callq 0x22e40
cmpl $0x5, (%rax)
sete %al
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x29254
jmp 0x2925b
callq 0x29cb0
jmp 0x29208
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: fondoger[P]C0-Compiler/src/mips.cpp
// Function: gen_global_variables()
static void gen_global_variables()
{
    while ((*m).op == GVAR) {
        const FourTuple &ft = *m;
        // format: GVAR, int|char, id, NONE
        assert(ft.a == "int" || ft.a == "char");
        // use same size for char and int
        // TODO: might use .byte for char
        if (ft.res != "") {
            // array, ft.res is the size of array
            MIPS(T << ft.b << ":" << HT << ".word" << HT << "0:" << ft.res);
        } else {
            // normal variable
            MIPS(T << ft.b << ":" << HT << ".word" << HT << "0");
        }
        m++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x20e79(%rip), %rdi     # 0x4a7d8
callq 0x22e40
cmpl $0x7, (%rax)
jne 0x29af7
leaq 0x20e64(%rip), %rdi     # 0x4a7d8
callq 0x22e40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xbe1d(%rip), %rsi      # 0x357a9
callq 0x2d280
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x11(%rbp)
jne 0x299b4
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xb707(%rip), %rsi      # 0x350b3
callq 0x2d280
movb %al, -0x11(%rbp)
movb -0x11(%rbp), %al
testb $0x1, %al
jne 0x299bd
jmp 0x299bf
jmp 0x299de
leaq 0xc5f2(%rip), %rdi      # 0x35fb8
leaq 0xc5c3(%rip), %rsi      # 0x35f90
movl $0x89, %edx
leaq 0xc5ff(%rip), %rcx      # 0x35fd8
callq 0x3230
movq -0x8(%rbp), %rdi
addq $0x48, %rdi
leaq 0xc608(%rip), %rsi      # 0x35ff5
callq 0x2d2b0
testb $0x1, %al
jne 0x299f8
jmp 0x29a75
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq 0x20c29(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
callq 0x32c0
movq %rax, %rdi
leaq 0xb800(%rip), %rsi      # 0x3521a
callq 0x3300
movq %rax, %rdi
leaq 0xc5cb(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xc5be(%rip), %rsi      # 0x35ff6
callq 0x3300
movq %rax, %rdi
leaq 0xc5ad(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xc5a6(%rip), %rsi      # 0x35ffc
callq 0x3300
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x48, %rsi
callq 0x32c0
movq %rax, %rdi
callq 0x29270
jmp 0x29ae0
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq 0x20bac(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
callq 0x32c0
movq %rax, %rdi
leaq 0xb783(%rip), %rsi      # 0x3521a
callq 0x3300
movq %rax, %rdi
leaq 0xc54e(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xc541(%rip), %rsi      # 0x35ff6
callq 0x3300
movq %rax, %rdi
leaq 0xc530(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xc328(%rip), %rsi      # 0x35dfb
callq 0x3300
movq %rax, %rdi
callq 0x29270
leaq 0x20cf1(%rip), %rdi     # 0x4a7d8
xorl %esi, %esi
callq 0x2d2e0
movq %rax, -0x10(%rbp)
jmp 0x29958
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/mips.cpp
// Function: gen_strings()
static void gen_strings()
{
    extern std::map<std::string, std::string> strings_table;
    for (auto const& item : strings_table) {
        MIPS(T << item.second << ": " << ".asciiz \""
               << item.first << "\"");
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
leaq 0x22819(%rip), %rax     # 0x4c328
movq %rax, -0x8(%rbp)
leaq 0x2280e(%rip), %rdi     # 0x4c328
callq 0x2d320
movq %rax, -0x10(%rbp)
leaq 0x227fe(%rip), %rdi     # 0x4c328
callq 0x2d350
movq %rax, -0x18(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x2d380
testb $0x1, %al
jne 0x29b46
jmp 0x29bba
leaq -0x10(%rbp), %rdi
callq 0x2d3b0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rsi
addq $0x20, %rsi
leaq 0x20ace(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
callq 0x32c0
movq %rax, %rdi
leaq 0xb6df(%rip), %rsi      # 0x35254
callq 0x3300
movq %rax, %rdi
leaq 0xc47b(%rip), %rsi      # 0x35fff
callq 0x3300
movq %rax, %rdi
movq -0x20(%rbp), %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0xc468(%rip), %rsi      # 0x36007
callq 0x3300
movq %rax, %rdi
callq 0x29270
leaq -0x10(%rbp), %rdi
callq 0x2d3e0
jmp 0x29b33
addq $0x20, %rsp
popq %rbp
retq
// File: fondoger[P]C0-Compiler/src/mips.cpp
// Function: gen_PUSH(_FourTuple const&)
static void gen_PUSH(const FourTuple &ft)
{
    DataType dtype = (ft.a == "int" ? DT_INT : DT_CHAR);
    prev_para_addr -= (dtype == DT_INT ? SIZE_INT : SIZE_CHAR);
    loadToReg("$v0", ft.b);
    MIPS(T << "sw" << HT << "$v0, " << prev_para_addr << "($sp)");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xa76e(%rip), %rsi      # 0x357a9
callq 0x2d280
movzbl %al, %ecx
movl $0x2, %eax
subl %ecx, %eax
movl %eax, -0xc(%rbp)
movl 0x1f7e5(%rip), %eax     # 0x4a838
addl $-0x4, %eax
movl %eax, 0x1f7dc(%rip)     # 0x4a838
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3570
movq -0x50(%rbp), %rdx
leaq 0xb07b(%rip), %rsi      # 0x360ef
leaq -0x30(%rbp), %rdi
callq 0x3440
jmp 0x2b07f
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq -0x30(%rbp), %rdi
callq 0x2cf90
jmp 0x2b092
leaq -0x30(%rbp), %rdi
callq 0x35e8
leaq -0x31(%rbp), %rdi
callq 0x3370
leaq 0x1f585(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0xaeff(%rip), %rsi      # 0x35fb5
callq 0x3300
movq %rax, %rdi
leaq 0xaf2f(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xaf3c(%rip), %rsi      # 0x36010
callq 0x3300
movq %rax, %rdi
movl 0x1f756(%rip), %esi     # 0x4a838
callq 0x3550
movq %rax, %rdi
leaq 0xaf54(%rip), %rsi      # 0x36045
callq 0x3300
movq %rax, %rdi
callq 0x29270
addq $0x50, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2b127
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x35e8
leaq -0x31(%rbp), %rdi
callq 0x3370
movq -0x40(%rbp), %rdi
callq 0x3560
nopl (%rax)
// File: fondoger[P]C0-Compiler/src/mips.cpp
// Function: gen_READ(_FourTuple const&)
static void gen_READ(const FourTuple &ft)
{
    assert(ft.a == "int" || ft.a == "char");
    if (ft.a == "int") {
        MIPS(T << "li" << HT << "$v0, 5");
    } 
    else {
        MIPS(T << "li" << HT << "$v0, 12");
    }
    MIPS(T << "syscall");
    MIPS(T << "sw" << HT << "$v0, " << getVariableAddr(ft.b));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xa2ee(%rip), %rsi      # 0x357a9
callq 0x2d280
movb %al, %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x35(%rbp)
jne 0x2b4e3
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0x9bd8(%rip), %rsi      # 0x350b3
callq 0x2d280
movb %al, -0x35(%rbp)
movb -0x35(%rbp), %al
testb $0x1, %al
jne 0x2b4ec
jmp 0x2b4ee
jmp 0x2b50d
leaq 0xaac3(%rip), %rdi      # 0x35fb8
leaq 0xaa94(%rip), %rsi      # 0x35f90
movl $0x147, %edx            # imm = 0x147
leaq 0xada4(%rip), %rcx      # 0x362ac
callq 0x3230
movq -0x8(%rbp), %rdi
addq $0x8, %rdi
leaq 0xa28d(%rip), %rsi      # 0x357a9
callq 0x2d280
testb $0x1, %al
jne 0x2b527
jmp 0x2b566
leaq 0x1f102(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0xaad4(%rip), %rsi      # 0x3600d
callq 0x3300
movq %rax, %rdi
leaq 0xaaac(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xad76(%rip), %rsi      # 0x362cd
callq 0x3300
movq %rax, %rdi
callq 0x29270
jmp 0x2b5a3
leaq 0x1f0c3(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0xaa95(%rip), %rsi      # 0x3600d
callq 0x3300
movq %rax, %rdi
leaq 0xaa6d(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xad3e(%rip), %rsi      # 0x362d4
callq 0x3300
movq %rax, %rdi
callq 0x29270
leaq 0x1f096(%rip), %rdi     # 0x4a640
movq %rdi, -0x58(%rbp)
leaq 0xaa61(%rip), %rsi      # 0x36016
callq 0x3300
movq %rax, %rdi
callq 0x29270
movq -0x58(%rbp), %rdi
leaq 0xa9e8(%rip), %rsi      # 0x35fb5
callq 0x3300
movq %rax, %rdi
leaq 0xaa18(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
leaq 0xaa25(%rip), %rsi      # 0x36010
callq 0x3300
movq %rax, -0x50(%rbp)
movq -0x8(%rbp), %rsi
addq $0x28, %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x2d120
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x32c0
movq %rax, -0x40(%rbp)
jmp 0x2b61c
movq -0x40(%rbp), %rdi
callq 0x29270
jmp 0x2b627
leaq -0x28(%rbp), %rdi
callq 0x35e8
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x35e8
movq -0x30(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x27780
testb $0x1, %al
jne 0x2cfb3
jmp 0x2d00c
leaq 0x1d676(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0x9048(%rip), %rsi      # 0x3600d
callq 0x3300
movq %rax, %rdi
leaq 0x9020(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x92a7(%rip), %rsi      # 0x36296
callq 0x3300
movq %rax, %rdi
movl -0x28(%rbp), %esi
callq 0x3550
movq %rax, %rdi
callq 0x29270
jmp 0x2d10c
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x2f100
andb $0x1, %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2d02d
jmp 0x2d04c
leaq 0x90c3(%rip), %rdi      # 0x360f7
leaq 0x8f55(%rip), %rsi      # 0x35f90
movl $0x1d4, %edx            # imm = 0x1D4
leaq 0x90bd(%rip), %rcx      # 0x36104
callq 0x3230
cmpl $0x0, -0x24(%rbp)
jne 0x2d0a9
leaq 0x1d5d7(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0x8f4e(%rip), %rsi      # 0x35fb2
callq 0x3300
movq %rax, %rdi
leaq 0x8f81(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x9208(%rip), %rsi      # 0x36296
callq 0x3300
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x32c0
movq %rax, %rdi
callq 0x29270
jmp 0x2d10c
leaq 0x1d580(%rip), %rdi     # 0x4a630
addq $0x10, %rdi
leaq 0x8ef7(%rip), %rsi      # 0x35fb2
callq 0x3300
movq %rax, %rdi
leaq 0x8f2a(%rip), %rsi      # 0x35ff4
callq 0x3300
movq %rax, %rdi
movq -0x8(%rbp), %rsi
callq 0x32c0
movq %rax, %rdi
leaq 0x91b1(%rip), %rsi      # 0x36296
callq 0x3300
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x3550
movq %rax, %rdi
leaq 0x8f46(%rip), %rsi      # 0x36045
callq 0x3300
movq %rax, %rdi
callq 0x29270
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x68(%rbp)
movq %rdi, %rax
movq %rax, -0x60(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x24(%rbp), %rsi
callq 0x2f100
andb $0x1, %al
movb %al, -0x25(%rbp)
testb $0x1, -0x25(%rbp)
jne 0x2d175
movq 0x17e6e(%rip), %rdi     # 0x44fc8
leaq 0x8fdc(%rip), %rsi      # 0x3613d
callq 0x3300
movq %rax, %rdi
movq 0x17e38(%rip), %rsi     # 0x44fa8
callq 0x3360
movb -0x25(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x1, %eax
jne 0x2d184
jmp 0x2d1a3
leaq 0x8f6c(%rip), %rdi      # 0x360f7
leaq 0x8dfe(%rip), %rsi      # 0x35f90
movl $0x1e9, %edx            # imm = 0x1E9
leaq 0x8fce(%rip), %rcx      # 0x3616c
callq 0x3230
cmpl $0x0, -0x24(%rbp)
jne 0x2d1b8
movq -0x68(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x3140
jmp 0x2d200
movl -0x14(%rbp), %esi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x22950
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
leaq 0x8e6e(%rip), %rdx      # 0x36045
callq 0x2e000
jmp 0x2d1de
leaq -0x48(%rbp), %rdi
callq 0x35e8
jmp 0x2d200
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x35e8
jmp 0x2d20a
movq -0x60(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3560
nopw %cs:(%rax,%rax)