LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Var_Number(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Lexical::Get_Var_Number(std::string s)
{
	if(this->Symbol_Table[s]==0)
	{
		int num=this->Symbol_Table.size();
		this->Symbol_Table[s]=num;
	}
	return this->Symbol_Table[s];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x38, %rdi
callq 0x7320
cmpl $0x0, (%rax)
jne 0x6806
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x7400
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0x38, %rdi
callq 0x7320
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x7320
movl (%rax), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Var(int&)
Word Lexical::Get_Var(int &pos)
{
	if(!isalpha(this->Source[pos]))return Word(-1,0);
	
	std::string s;

	while((pos<this->Source.length())&&(isalpha(this->Source[pos]))||(isdigit(this->Source[pos])))
	{
		s+=this->Source[pos];
		pos++;
	}
	
	return Word(3,this->Get_Var_Number(s));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x78(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsbl (%rax), %edi
callq 0x2310
cmpl $0x0, %eax
jne 0x6baa
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x6d08
leaq -0x40(%rbp), %rdi
callq 0x22c0
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x80(%rbp)
callq 0x22e0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x6c0a
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movq %rax, -0x88(%rbp)
jmp 0x6bec
movq -0x88(%rbp), %rax
movsbl (%rax), %edi
callq 0x2310
movl %eax, %ecx
movb $0x1, %al
cmpl $0x0, %ecx
movb %al, -0x89(%rbp)
jne 0x6c3e
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movq %rax, -0x98(%rbp)
jmp 0x6c23
movq -0x98(%rbp), %rax
movsbl (%rax), %edi
callq 0x21e0
cmpl $0x0, %eax
setne %al
movb %al, -0x89(%rbp)
movb -0x89(%rbp), %al
testb $0x1, %al
jne 0x6c4a
jmp 0x6c96
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movq %rax, -0xa0(%rbp)
jmp 0x6c63
movq -0xa0(%rbp), %rax
movsbl (%rax), %esi
leaq -0x40(%rbp), %rdi
callq 0x2150
jmp 0x6c78
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x6bb3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x6cfd
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x20e0
jmp 0x6ca5
movq -0x78(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x67b0
movl %eax, -0xa4(%rbp)
jmp 0x6cba
movl -0xa4(%rbp), %eax
cvtsi2sd %eax, %xmm0
leaq -0x10(%rbp), %rdi
movl $0x3, %esi
callq 0x7450
jmp 0x6cd4
leaq -0x70(%rbp), %rdi
callq 0x2140
leaq -0x40(%rbp), %rdi
callq 0x2140
jmp 0x6d08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x2140
leaq -0x40(%rbp), %rdi
callq 0x2140
jmp 0x6d19
movl -0x10(%rbp), %eax
movsd -0x8(%rbp), %xmm0
addq $0xb0, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Number(int&)
Word Lexical::Get_Number(int &pos)
{	
	if(!isdigit(this->Source[pos]))return Word(-1,0);
	
	double ret=0;
	
	while((pos<this->Source.length())&&(isdigit(this->Source[pos])))
	{
		ret=ret*10+(this->Source[pos]-'0');
		pos++;
	}
	
	if(this->Source[pos]=='.')
	{
		double k=0.1;
		pos++;
		while((pos<this->Source.length())&&(isdigit(this->Source[pos])))
		{
			ret=ret+(this->Source[pos]-'0')*k;
			pos++;
			k/=10;
		}
	}
	
	return Word(4,ret);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq %rdi, -0x38(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsbl (%rax), %edi
callq 0x21e0
cmpl $0x0, %eax
jne 0x6d77
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x6f15
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x48(%rbp)
callq 0x22e0
movq -0x48(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x39(%rbp)
jae 0x6dc5
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsbl (%rax), %edi
callq 0x21e0
cmpl $0x0, %eax
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x6dce
jmp 0x6e1c
movq -0x38(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x50(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsd -0x50(%rbp), %xmm0
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm1
movsd 0xb2d1(%rip), %xmm2     # 0x120d0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x6d7f
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsbl (%rax), %eax
cmpl $0x2e, %eax
jne 0x6f02
movsd 0xb288(%rip), %xmm0     # 0x120c8
movsd %xmm0, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq %rax, -0x60(%rbp)
callq 0x22e0
movq -0x60(%rbp), %rcx
movq %rax, %rdx
xorl %eax, %eax
cmpq %rdx, %rcx
movb %al, -0x51(%rbp)
jae 0x6e96
movq -0x38(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsbl (%rax), %edi
callq 0x21e0
cmpl $0x0, %eax
setne %al
movb %al, -0x51(%rbp)
movb -0x51(%rbp), %al
testb $0x1, %al
jne 0x6e9f
jmp 0x6f00
movq -0x38(%rbp), %rdi
movsd -0x28(%rbp), %xmm0
movsd %xmm0, -0x68(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsd -0x68(%rbp), %xmm1
movsbl (%rax), %eax
subl $0x30, %eax
cvtsi2sd %eax, %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movsd -0x30(%rbp), %xmm0
movsd 0xb1de(%rip), %xmm1     # 0x120d0
divsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0x6e50
jmp 0x6f02
movsd -0x28(%rbp), %xmm0
leaq -0x10(%rbp), %rdi
movl $0x4, %esi
callq 0x7450
movl -0x10(%rbp), %eax
movsd -0x8(%rbp), %xmm0
addq $0x70, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Symbol(int&)
Word Lexical::Get_Symbol(int &pos)
{
	switch(this->Source[pos])
	{
		case '+':pos++;return Word(5,0);break;
		case '-':pos++;return Word(6,0);break;
		case '*':pos++;return Word(7,0);break;
		case '/':pos++;return Word(8,0);break;
		case '=':pos++;return Word(9,0);break;
		case '(':pos++;return Word(10,0);break;
		case ')':pos++;return Word(11,0);break;
		case ';':pos++;return Word(12,0);break;
		default:return Word(-1,0);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rax
movslq (%rax), %rsi
callq 0x23b0
movsbl (%rax), %eax
addl $-0x28, %eax
movl %eax, %ecx
movq %rcx, -0x28(%rbp)
subl $0x15, %eax
ja 0x7075
movq -0x28(%rbp), %rax
leaq 0xb168(%rip), %rcx      # 0x120d8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0x5, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0x6, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0x7, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0x8, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0x9, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0xa, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0xb, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
leaq -0x10(%rbp), %rdi
movl $0xc, %esi
xorps %xmm0, %xmm0
callq 0x7450
jmp 0x7086
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
callq 0x7450
movl -0x10(%rbp), %eax
movsd -0x8(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Get_Next_Word(int&)
Word Lexical::Get_Next_Word(int &pos)
{
	Word ret;
	
	ret=this->Get_Keyword(pos);
	if(ret.Number!=-1)return ret;
	
	ret=this->Get_Var(pos);
	if(ret.Number!=-1)return ret;
	
	ret=this->Get_Number(pos);
	if(ret.Number!=-1)return ret;
	
	ret=this->Get_Symbol(pos);
	if(ret.Number!=-1)return ret;
	
	return Word(-1,0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movq %rsi, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
xorps %xmm0, %xmm0
callq 0x7450
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6820
movl %eax, -0x40(%rbp)
movsd %xmm0, -0x38(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x30(%rbp)
je 0x7109
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x71d4
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6b60
movl %eax, -0x50(%rbp)
movsd %xmm0, -0x48(%rbp)
movq -0x50(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x30(%rbp)
je 0x7149
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x71d4
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6d30
movl %eax, -0x60(%rbp)
movsd %xmm0, -0x58(%rbp)
movq -0x60(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x30(%rbp)
je 0x7186
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x71d4
movq -0x78(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x6f30
movl %eax, -0x70(%rbp)
movsd %xmm0, -0x68(%rbp)
movq -0x70(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x68(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $-0x1, -0x30(%rbp)
je 0x71c3
movq -0x30(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x71d4
leaq -0x10(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorps %xmm0, %xmm0
callq 0x7450
movl -0x10(%rbp), %eax
movsd -0x8(%rbp), %xmm0
addq $0x80, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Caproner[P]Naive_Compiler/Lexical/Lexical.cpp
// Function: Lexical::Analysis()
bool Lexical::Analysis()
{
	int pos=0;
	while(pos<this->Source.length())
	{
		if(!isgraph(this->Source[pos]))
		{
			pos++;
			continue;
		}
		Word w=this->Get_Next_Word(pos);
		if(w.Number==-1)
		{
			this->Target.List.clear();
			return false;
		} 
		this->Target.List.push_back(w);
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x38(%rbp)
callq 0x22e0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x72e1
movq -0x30(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x23b0
movsbl (%rax), %edi
callq 0x21f0
cmpl $0x0, %eax
jne 0x729d
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x725b
movq -0x30(%rbp), %rdi
leaq -0x14(%rbp), %rsi
callq 0x70a0
movl %eax, -0x28(%rbp)
movsd %xmm0, -0x20(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x72cb
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
callq 0x74a0
movb $0x0, -0x1(%rbp)
jmp 0x72e5
movq -0x30(%rbp), %rdi
addq $0x20, %rdi
leaq -0x28(%rbp), %rsi
callq 0x74c0
jmp 0x725b
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
// File: Caproner[P]Naive_Compiler/Grammar/Grammar.cpp
// Function: Grammar::Input(Word_List)
void Grammar::Input(Word_List WL)
{
	this->Handle_List.clear();
	Word_List PWL;
	
	for(int pos=0;pos<WL.List.size();pos++)
	{
		Word &W=WL.List[pos];
		if(W.Number==12)
		{
			this->Handle_List.push_back(PWL);
			PWL.List.clear();
		}
		else
		{
			PWL.List.push_back(W);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0xa250
leaq -0x28(%rbp), %rdi
callq 0x2ef0
movl $0x0, -0x2c(%rbp)
movq -0x58(%rbp), %rdi
movslq -0x2c(%rbp), %rax
movq %rax, -0x60(%rbp)
callq 0x52e0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x992a
movq -0x58(%rbp), %rdi
movslq -0x2c(%rbp), %rsi
callq 0x9c20
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
cmpl $0xc, (%rax)
jne 0x9909
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xa270
jmp 0x98e7
leaq -0x28(%rbp), %rdi
callq 0x74a0
jmp 0x991a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2dc0
jmp 0x9939
movq -0x38(%rbp), %rsi
leaq -0x28(%rbp), %rdi
callq 0x74c0
jmp 0x9918
jmp 0x991a
jmp 0x991c
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x98a1
leaq -0x28(%rbp), %rdi
callq 0x2dc0
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: Caproner[P]Naive_Compiler/Grammar/Grammar.cpp
// Function: Grammar::Analysis()
bool Grammar::Analysis()
{
	this->Grammar_Forest.forest.clear();
	for(int i=0;i<this->Handle_List.size();i++)
	{
		if(this->Handle_Analysis(i))continue;
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x18, %rdi
callq 0x9e70
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x14(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0xa2e0
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x99b6
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x8d40
testb $0x1, %al
jne 0x99a3
jmp 0x99a5
jmp 0x99ab
movb $0x0, -0x1(%rbp)
jmp 0x99ba
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x9974
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Caproner[P]Naive_Compiler/Semantic/Semantic.cpp
// Function: Semantic::Analysis(Forest&)
bool Semantic::Analysis(Forest &F)
{
	for(int i=0;i<F.forest.size();i++)
	{
		TreeNode *p=F.forest[i];
		if(this->DFS(p))continue;
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movslq -0x1c(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2bf0
movq %rax, %rcx
movq -0x38(%rbp), %rax
cmpq %rcx, %rax
jae 0x10996
movq -0x18(%rbp), %rdi
movslq -0x1c(%rbp), %rsi
callq 0x2c10
movq -0x30(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
callq 0x102a0
testb $0x1, %al
jne 0x10983
jmp 0x10985
jmp 0x1098b
movb $0x0, -0x1(%rbp)
jmp 0x1099a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1093f
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/ex16_14_15_main.cc
// Function: main
int main(int argc, char const *argv[])
{
	Screen<5, 5> scr('c');

	scr.display(std::cout);

	// output src to the screen
	std::cout << scr;

	std::cin >> scr;

	std::cout << scr;

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x60(%rbp)
movl $0x63, %esi
callq 0x12e0
movq -0x60(%rbp), %rdi
movq 0x2d6d(%rip), %rsi      # 0x3fd0
callq 0x1370
jmp 0x126a
movq 0x2d5f(%rip), %rdi      # 0x3fd0
leaq -0x48(%rbp), %rsi
callq 0x13a0
jmp 0x127c
movq 0x2d5d(%rip), %rdi      # 0x3fe0
leaq -0x48(%rbp), %rsi
callq 0x1450
jmp 0x128e
movq 0x2d3b(%rip), %rdi      # 0x3fd0
leaq -0x48(%rbp), %rsi
callq 0x13a0
jmp 0x12a0
movl $0x0, -0x4(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x14f0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x14f0
movq -0x50(%rbp), %rdi
callq 0x10d0
nopw (%rax,%rax)
// File: iZhangHui[P]CppPrimer/CH16_TemplatesAndGenericProgramming/exercises/./ex16_14_15.h
// Function: operator>>(std::istream&, Screen<5u, 5u>&)
std::istream& operator>>(std::istream& is, Screen<H, W>& s)
	{
		char a;
		is >> a;
		std::string temp(H*W, a);
		s.contents = std::move(temp);
		return is;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x11(%rbp), %rsi
callq 0x10b0
movsbl -0x11(%rbp), %eax
movl %eax, -0x5c(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x10e0
movl -0x5c(%rbp), %edx
movq -0x58(%rbp), %rcx
leaq -0x38(%rbp), %rdi
movl $0x19, %esi
callq 0x1040
jmp 0x1498
leaq -0x39(%rbp), %rdi
callq 0x1090
movq -0x10(%rbp), %rdi
addq $0x18, %rdi
leaq -0x38(%rbp), %rsi
callq 0x10a0
movq -0x8(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x1030
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x1090
movq -0x48(%rbp), %rdi
callq 0x10d0
nopl (%rax,%rax)
// File: t0mm4rx[P]piscine_cpp/day02/ex00/main.cpp
// Function: main
int main(void) {
	Fixed a;
	Fixed b(a);
	Fixed c;

	c = b;
	std::cout << a.getRawBits() << std::endl;
	std::cout << b.getRawBits() << std::endl;
	std::cout << c.getRawBits() << std::endl;
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl $0x0, -0x4(%rbp)
leaq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x11c0
movq -0x28(%rbp), %rsi
leaq -0xc(%rbp), %rdi
callq 0x11f0
jmp 0x12bb
leaq -0x20(%rbp), %rdi
callq 0x11c0
jmp 0x12c6
leaq -0x20(%rbp), %rdi
leaq -0xc(%rbp), %rsi
callq 0x1220
jmp 0x12d5
leaq -0x8(%rbp), %rdi
callq 0x1280
movl %eax, -0x2c(%rbp)
jmp 0x12e3
movl -0x2c(%rbp), %esi
movq 0x2ceb(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, -0x38(%rbp)
jmp 0x12f8
movq -0x38(%rbp), %rdi
movq 0x2cc5(%rip), %rsi      # 0x3fc8
callq 0x1040
jmp 0x130a
leaq -0xc(%rbp), %rdi
callq 0x1280
movl %eax, -0x3c(%rbp)
jmp 0x1318
movl -0x3c(%rbp), %esi
movq 0x2cb6(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, -0x48(%rbp)
jmp 0x132d
movq -0x48(%rbp), %rdi
movq 0x2c90(%rip), %rsi      # 0x3fc8
callq 0x1040
jmp 0x133f
leaq -0x20(%rbp), %rdi
callq 0x1280
movl %eax, -0x4c(%rbp)
jmp 0x134d
movl -0x4c(%rbp), %esi
movq 0x2c81(%rip), %rdi      # 0x3fd8
callq 0x1060
movq %rax, -0x58(%rbp)
jmp 0x1362
movq -0x58(%rbp), %rdi
movq 0x2c5b(%rip), %rsi      # 0x3fc8
callq 0x1040
jmp 0x1374
movl $0x0, -0x4(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11e0
leaq -0xc(%rbp), %rdi
callq 0x11e0
leaq -0x8(%rbp), %rdi
callq 0x11e0
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x13d9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
jmp 0x13d0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x11e0
leaq -0xc(%rbp), %rdi
callq 0x11e0
leaq -0x8(%rbp), %rdi
callq 0x11e0
movq -0x18(%rbp), %rdi
callq 0x1070
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolver.cc
// Function: OptimalSolver::OptimalSolver()
OptimalSolver::OptimalSolver() {
	matrix = NULL;
	defaultCells = NULL;
	readLength = 0;
	seedNum = 0;
	matrixSize = 0;
	L0Loaded = false;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movl $0xa, %esi
movl $0x1e, %edx
callq 0xe3d0
movq 0x8(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
callq 0xc060
movq 0x8(%rsp), %rax
movq $0x0, 0x368(%rax)
movq $0x0, 0x388(%rax)
movl $0x0, 0x35c(%rax)
movl $0x0, 0x360(%rax)
movl $0x0, 0x390(%rax)
movb $0x0, 0x358(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolver.cc
// Function: OptimalSolver::~OptimalSolver()
OptimalSolver::~OptimalSolver() {
	if  (matrix != NULL) {
		delete [] matrix;
		matrix = NULL;
	}
	if  (defaultCells != NULL) {
		delete [] defaultCells;
		defaultCells = NULL;
	}

	if (level.size() != 0)
		level.clear();
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x368(%rax)
je 0x609e
movq 0x18(%rsp), %rax
movq 0x368(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x608e
movq 0x10(%rsp), %rdi
callq 0x3410
movq 0x18(%rsp), %rax
movq $0x0, 0x368(%rax)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x388(%rax)
je 0x60de
movq 0x18(%rsp), %rax
movq 0x388(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x60ce
movq 0x8(%rsp), %rdi
callq 0x3410
movq 0x18(%rsp), %rax
movq $0x0, 0x388(%rax)
movq 0x18(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
callq 0xc070
cmpq $0x0, %rax
je 0x6106
movq 0x18(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
callq 0xc090
movq 0x18(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
callq 0xc0b0
movq 0x18(%rsp), %rdi
callq 0xe580
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]optimal-seed-solver/optimalSolver.cc
// Function: OptimalSolver::feedL0()
void OptimalSolver::feedL0() {
	reset();
	tree.setHashLength(10);
	int lvPosCount = readLength + 1 - tree.getHashLength();

	for (int i = 0; i < lvPosCount; i++) {
		for (int j = 0; j < lvPosCount - i; j++) {
			cin >> level[0][i][j].start;
			cin >> level[0][i][j].end;
			cin >> level[0][i][j].frequency;
			cin >> level[0][i][j].isleaf;
#ifdef DEBUG
			cout << "level[0][" << i << "][" << j << "].start=" << level[0][i][j].start << endl;
			cout.flush();
#endif
		}
	}
			L0Loaded = true;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0x69b0
movq 0x8(%rsp), %rdi
movl $0xa, %esi
callq 0xc2e0
movq 0x8(%rsp), %rdi
movl 0x35c(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
callq 0xfad0
movl %eax, %ecx
movl 0x10(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x6b7e
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl 0x18(%rsp), %ecx
cmpl %ecx, %eax
jge 0x6b6c
movq 0x8(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
xorl %eax, %eax
movl %eax, %esi
callq 0xc200
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xc2c0
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
movq 0x1b544(%rip), %rdi     # 0x21fd8
callq 0x3070
movq 0x8(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
xorl %eax, %eax
movl %eax, %esi
callq 0xc200
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xc2c0
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0x4, %rsi
movq 0x1b503(%rip), %rdi     # 0x21fd8
callq 0x3070
movq 0x8(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
xorl %eax, %eax
movl %eax, %esi
callq 0xc200
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xc2c0
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0xc, %rsi
movq 0x1b4c2(%rip), %rdi     # 0x21fd8
callq 0x3070
movq 0x8(%rsp), %rdi
addq $0x370, %rdi            # imm = 0x370
xorl %eax, %eax
movl %eax, %esi
callq 0xc200
movq %rax, %rdi
movslq 0x18(%rsp), %rsi
callq 0xc2c0
movq (%rax), %rsi
movslq 0x14(%rsp), %rax
imulq $0x28, %rax, %rax
addq %rax, %rsi
addq $0x8, %rsi
movq 0x1b481(%rip), %rdi     # 0x21fd8
callq 0x3270
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6a48
jmp 0x6b6e
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6a32
movq 0x8(%rsp), %rax
movb $0x1, 0x358(%rax)
addq $0x28, %rsp
retq
nop
// File: CMU-SAFARI[P]optimal-seed-solver/./optimalSolver.h
// Function: Cell::Cell()
Cell() {
		start = -1;
		end = -1;
		isleaf = false;
		frequency = -1;
		lstart = -1;
		lend = -1;
		lfreq = -1;
		rstart = -1;
		rend = -1;
		rfreq = -1;
	}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movl $0xffffffff, 0x4(%rax)  # imm = 0xFFFFFFFF
movb $0x0, 0x8(%rax)
movl $0xffffffff, 0xc(%rax)  # imm = 0xFFFFFFFF
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x14(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x24(%rax) # imm = 0xFFFFFFFF
retq
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/main.cpp
// Function: reEnableSpecialCharacters()
void reEnableSpecialCharacters() {
    system("stty eof '^d'"  ); // re-enable CTRL+D
    system("stty intr '^c'" ); // re-enable CTRL+C
    system("stty quit '^\\'" ); // re-enable CTRL+backslash
    system("stty susp '^z'" ); // re-enable CTRL+Z
    system("stty dsusp '^y'"); // re-enable CTRL+Y
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x187d9(%rip), %rdi     # 0x1c004
callq 0x3280
leaq 0x187db(%rip), %rdi     # 0x1c012
callq 0x3280
leaq 0x187de(%rip), %rdi     # 0x1c021
callq 0x3280
leaq 0x187e1(%rip), %rdi     # 0x1c030
callq 0x3280
leaq 0x187e4(%rip), %rdi     # 0x1c03f
callq 0x3280
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/main.cpp
// Function: registerSignals()
void registerSignals() {
    struct sigaction act;

    act.sa_handler = signalHandler;
    sigemptyset(&act.sa_mask);
    act.sa_flags = 0;

    sigaction(SIGINT,  &act, 0); // Ctrl-C
    sigaction(SIGQUIT, &act, 0); // Ctrl-backslash
    sigaction(SIGTSTP, &act, 0); // Ctrl-Z
    sigaction(SIGTERM, &act, 0); // Like SIGINT

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
leaq -0x22(%rip), %rax       # 0x3870
movq %rax, -0x98(%rbp)
leaq -0x98(%rbp), %rdi
addq $0x8, %rdi
callq 0x33b0
movl $0x0, -0x10(%rbp)
movl $0x2, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
movl $0x3, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
movl $0x14, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
movl $0xf, %edi
leaq -0x98(%rbp), %rsi
xorl %eax, %eax
movl %eax, %edx
callq 0x33c0
addq $0xa0, %rsp
popq %rbp
retq
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/main.cpp
// Function: disableSpecialCharacters()
void disableSpecialCharacters() {
    system("stty eof undef"  ); // disable CTRL+D
    system("stty intr undef" ); // disable CTRL+C
    system("stty quit undef" ); // disable CTRL+backslash
    system("stty susp undef" ); // disable CTRL+Z
    system("stty dsusp undef"); // disable CTRL+Y
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leaq 0x18734(%rip), %rdi     # 0x1c04f
callq 0x3280
leaq 0x18737(%rip), %rdi     # 0x1c05e
callq 0x3280
leaq 0x1873b(%rip), %rdi     # 0x1c06e
callq 0x3280
leaq 0x1873f(%rip), %rdi     # 0x1c07e
callq 0x3280
leaq 0x18743(%rip), %rdi     # 0x1c08e
callq 0x3280
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/main.cpp
// Function: quitGame(GameMaster*)
void quitGame(GameMaster* gm) {
    reEnableSpecialCharacters();

    if (!gm->getGameFinished()) {
        gm->clearScreen();
        string gaveUp  = "You can't handle this anymore. This house, these ";
               gaveUp += "spirits, they are driving you\n";
               gaveUp += "mad! You've gotten this far, and that feels like an ";
               gaveUp += "achievement in itself.\n\n";
               gaveUp += "Perhaps it's the only achievement left to you. Yes, ";
               gaveUp += "perhaps it is.\n\n";
               gaveUp += "You lay back, allow the failure to fill you up, and ";
               gaveUp += "resign yourself to the\ncoming punishment.\n\n";
               gaveUp += "You have quit the game. Please come back and visit ";
               gaveUp += "the spirits again whenever\n";
               gaveUp += "you can! They'll be waiting...\n\n";

        cout << gaveUp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
callq 0x3820
movq -0x8(%rbp), %rdi
callq 0x55d0
testb $0x1, %al
jne 0x3ac6
movq -0x8(%rbp), %rdi
callq 0x5670
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3520
movq -0x48(%rbp), %rdx
leaq 0x186ec(%rip), %rsi     # 0x1c09f
leaq -0x28(%rbp), %rdi
callq 0x3b80
jmp 0x39be
leaq -0x29(%rbp), %rdi
callq 0x3350
leaq 0x18703(%rip), %rsi     # 0x1c0d1
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x39d9
leaq 0x18710(%rip), %rsi     # 0x1c0f0
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x39eb
leaq 0x18733(%rip), %rsi     # 0x1c125
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x39fd
leaq 0x1873a(%rip), %rsi     # 0x1c13e
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a0f
leaq 0x1875d(%rip), %rsi     # 0x1c173
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a21
leaq 0x1875c(%rip), %rsi     # 0x1c184
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a33
leaq 0x1877f(%rip), %rsi     # 0x1c1b9
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a45
leaq 0x18799(%rip), %rsi     # 0x1c1e5
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a57
leaq 0x187bb(%rip), %rsi     # 0x1c219
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a69
leaq 0x187c5(%rip), %rsi     # 0x1c235
leaq -0x28(%rbp), %rdi
callq 0x32d0
jmp 0x3a7b
movq 0x2353e(%rip), %rdi     # 0x26fc0
leaq -0x28(%rbp), %rsi
callq 0x32b0
jmp 0x3a8d
leaq -0x28(%rbp), %rdi
callq 0x3200
jmp 0x3ac6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x3acc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3200
jmp 0x3acc
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/main.cpp
// Function: main
int main() {
    GameMaster* gm = new GameMaster();

    setUpGame();
    gm->playGame();
    quitGame(gm);

    delete gm;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl $0x128, %edi            # imm = 0x128
callq 0x32f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
callq 0x3ed0
jmp 0x3b0a
movq -0x28(%rbp), %rax
movq %rax, -0x10(%rbp)
callq 0x3960
movq -0x10(%rbp), %rdi
callq 0x7c60
movq -0x10(%rbp), %rdi
callq 0x3970
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x3b4e
movq -0x30(%rbp), %rdi
callq 0x4da0
movq -0x30(%rbp), %rdi
movl $0x128, %esi            # imm = 0x128
callq 0x3300
xorl %eax, %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x128, %esi            # imm = 0x128
callq 0x3300
movq -0x18(%rbp), %rdi
callq 0x3510
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::savePlayerLevel()
void GameMaster::savePlayerLevel() {
    if (currLevel < 0) return; // Let level stay if quit typed on start screen
    string level = to_string(currLevel);

    ofstream out;
    out.open(LEVEL_FILEPATH);
    out << level << endl; // Overwrite with the single integer-as-string
    out.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x240(%rbp)
cmpl $0x0, 0x68(%rax)
jge 0x4ea5
jmp 0x4f35
movq -0x240(%rbp), %rax
movl 0x68(%rax), %esi
leaq -0x28(%rbp), %rdi
callq 0x8620
leaq -0x228(%rbp), %rdi
callq 0x34f0
jmp 0x4ec6
movq -0x240(%rbp), %rsi
addq $0x8, %rsi
leaq -0x228(%rbp), %rdi
movl $0x10, %edx
callq 0x31a0
jmp 0x4ee4
leaq -0x228(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x32b0
movq %rax, -0x248(%rbp)
jmp 0x4efd
movq -0x248(%rbp), %rdi
movq 0x2209d(%rip), %rsi     # 0x26fa8
callq 0x3330
jmp 0x4f12
leaq -0x228(%rbp), %rdi
callq 0x3420
jmp 0x4f20
leaq -0x228(%rbp), %rdi
callq 0x3460
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
jmp 0x4f70
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x230(%rbp)
movl %eax, -0x234(%rbp)
leaq -0x228(%rbp), %rdi
callq 0x3460
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x230(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::releaseMemory()
void GameMaster::releaseMemory() {
    // Delete characters
    delete player;
    delete opponents[0]; // No need to delete opponent4, as it's a duplicate
    delete opponents[1];
    delete opponents[2];
    delete opponents[3];
    // Skipping opponents[4], which was already released by opponents[0]
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x90(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, %rax
je 0x525c
movq -0x10(%rbp), %rdi
callq 0x83a0
movq -0x10(%rbp), %rdi
movl $0xc0, %esi
callq 0x3300
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x8050
movq (%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x5294
movq -0x20(%rbp), %rdi
callq 0x83c0
movq -0x20(%rbp), %rdi
movl $0xc0, %esi
callq 0x3300
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movl $0x1, %esi
callq 0x8050
movq (%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x52cd
movq -0x28(%rbp), %rdi
callq 0x83c0
movq -0x28(%rbp), %rdi
movl $0xc0, %esi
callq 0x3300
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movl $0x2, %esi
callq 0x8050
movq (%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0x5306
movq -0x30(%rbp), %rdi
callq 0x83c0
movq -0x30(%rbp), %rdi
movl $0xc0, %esi
callq 0x3300
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movl $0x3, %esi
callq 0x8050
movq (%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0x533f
movq -0x38(%rbp), %rdi
callq 0x83c0
movq -0x38(%rbp), %rdi
movl $0xc0, %esi
callq 0x3300
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::clearScreen()
void GameMaster::clearScreen() {
    const int BIG_NUMBER = 100;
    string clear = "";
    for (int i = 0; i < BIG_NUMBER; i++) {
        clear += "\n";
    }
    cout << clear;

    printCurrentLevelTitle();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x64, -0xc(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3520
movq -0x50(%rbp), %rdx
leaq 0x16d25(%rip), %rsi     # 0x1c3c8
leaq -0x30(%rbp), %rdi
callq 0x3b80
jmp 0x56ae
leaq -0x31(%rbp), %rdi
callq 0x3350
movl $0x0, -0x48(%rbp)
cmpl $0x64, -0x48(%rbp)
jge 0x5711
leaq 0x16cfc(%rip), %rsi     # 0x1c3c7
leaq -0x30(%rbp), %rdi
callq 0x32d0
jmp 0x56d6
jmp 0x56d8
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x56be
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x3350
jmp 0x573d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3200
jmp 0x573d
movq 0x218a8(%rip), %rdi     # 0x26fc0
leaq -0x30(%rbp), %rsi
callq 0x32b0
jmp 0x5723
movq -0x58(%rbp), %rdi
callq 0x55f0
jmp 0x572e
leaq -0x30(%rbp), %rdi
callq 0x3200
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::getStartingLevel()
int GameMaster::getStartingLevel() {
    string line = "";

    ifstream in(LEVEL_FILEPATH);               // Open file
    getline(in, line);
    in.close();                                // Close file
    return stoi(line);                         // Convert to int
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x258(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x3520
movq -0x250(%rbp), %rdx
leaq 0x16780(%rip), %rsi     # 0x1c3c8
leaq -0x28(%rbp), %rdi
callq 0x3b80
jmp 0x5c53
leaq -0x29(%rbp), %rdi
callq 0x3350
movq -0x258(%rbp), %rsi
addq $0x8, %rsi
leaq -0x248(%rbp), %rdi
movl $0x8, %edx
callq 0x34b0
jmp 0x5c7a
leaq -0x248(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x30b0
jmp 0x5c8c
leaq -0x248(%rbp), %rdi
callq 0x30c0
jmp 0x5c9a
xorl %eax, %eax
movl %eax, %esi
leaq -0x28(%rbp), %rdi
movl $0xa, %edx
callq 0x8850
movl %eax, -0x25c(%rbp)
jmp 0x5cb4
leaq -0x248(%rbp), %rdi
callq 0x30f0
leaq -0x28(%rbp), %rdi
callq 0x3200
movl -0x25c(%rbp), %eax
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x5d1e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x5d15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x30f0
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x3510
nopw (%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::checkpoint()
void GameMaster::checkpoint() {
    string toAdd = "\n\n";
    string anyInputText  = "<RETURN>: next line | \"skip\": next negotiation";

    createTitle('=', WIDTH, anyInputText, toAdd);
    fillCleanUInput();

    if (uInput == "quit") return; // For every new entry, check for quit
    if (uInput == "skip" ) doSkip = true; // Set global flag for future

    clearScreen();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa0(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3520
movq -0x98(%rbp), %rdx
leaq 0x15b1e(%rip), %rsi     # 0x1c3c6
leaq -0x28(%rbp), %rdi
callq 0x3b80
jmp 0x68b3
leaq -0x29(%rbp), %rdi
callq 0x3350
leaq -0x61(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3520
movq -0xa8(%rbp), %rdx
leaq 0x15af9(%rip), %rsi     # 0x1c3d3
leaq -0x60(%rbp), %rdi
callq 0x3b80
jmp 0x68e5
leaq -0x61(%rbp), %rdi
callq 0x3350
movq -0xa0(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0xac(%rbp)
leaq -0x88(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x3170
jmp 0x6910
movl -0xac(%rbp), %edx
movq -0xa0(%rbp), %rdi
movl $0x3d, %esi
leaq -0x88(%rbp), %rcx
leaq -0x28(%rbp), %r8
movl $0x1, %r9d
callq 0x5350
jmp 0x693a
leaq -0x88(%rbp), %rdi
callq 0x3200
movq -0xa0(%rbp), %rdi
callq 0x6b80
jmp 0x6954
movq -0xa0(%rbp), %rdi
addq $0x70, %rdi
leaq 0x15a3a(%rip), %rsi     # 0x1c3a0
callq 0x8a80
movb %al, -0xad(%rbp)
jmp 0x6973
movb -0xad(%rbp), %al
testb $0x1, %al
jne 0x697f
jmp 0x69ed
movl $0x1, -0x8c(%rbp)
jmp 0x6a3b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x6a68
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x61(%rbp), %rdi
callq 0x3350
jmp 0x6a5f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x6a56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x3200
jmp 0x6a56
movq -0xa0(%rbp), %rdi
addq $0x70, %rdi
leaq 0x15a03(%rip), %rsi     # 0x1c402
callq 0x8a80
movb %al, -0xae(%rbp)
jmp 0x6a0c
movb -0xae(%rbp), %al
testb $0x1, %al
jne 0x6a18
jmp 0x6a23
movq -0xa0(%rbp), %rax
movb $0x1, 0x6c(%rax)
movq -0xa0(%rbp), %rdi
callq 0x5670
jmp 0x6a31
movl $0x0, -0x8c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
addq $0xb0, %rsp
popq %rbp
retq
leaq -0x60(%rbp), %rdi
callq 0x3200
leaq -0x28(%rbp), %rdi
callq 0x3200
movq -0x38(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::lower(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
void GameMaster::lower(string &anyString) {
    int i = 0;
    while (anyString[i]) {
        anyString[i] = tolower(anyString[i]);
        i++;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
cmpb $0x0, (%rax)
je 0x6ade
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movsbl (%rax), %edi
callq 0x3440
movb %al, -0x15(%rbp)
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
callq 0x3580
movb -0x15(%rbp), %cl
movb %cl, (%rax)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x6a97
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::fillCleanUInput()
void GameMaster::fillCleanUInput() {
    cout << ">>>> ";
    getline(cin, uInput);

    lower(uInput);
    removeWS(uInput);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq 0x20425(%rip), %rdi     # 0x26fc0
leaq 0x15803(%rip), %rsi     # 0x1c3a5
callq 0x32e0
movq -0x10(%rbp), %rsi
addq $0x70, %rsi
movq 0x20422(%rip), %rdi     # 0x26fd8
callq 0x30b0
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
callq 0x6a80
movq -0x10(%rbp), %rdi
movq %rdi, %rsi
addq $0x70, %rsi
callq 0x6af0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::isAsteriskEntry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool GameMaster::isAsteriskEntry(string line) {
    // Must have three asterisks at beginning AND end of prompt

    const int ASTERISKS_NEEDED = 3;
    if (line.length() <= (ASTERISKS_NEEDED + ASTERISKS_NEEDED)) return false;

    for (int i = 0; i < ASTERISKS_NEEDED; i++) {
        if (line[i] != '*') return false; // Check for asterisks at beginning
        if (line[line.length() - i - 1] != '*') return false; // and at end
    }

    return true;
}

// 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)
movl $0x3, -0x1c(%rbp)
callq 0x3470
cmpq $0x6, %rax
ja 0x6f27
movb $0x0, -0x1(%rbp)
jmp 0x6f8e
movl $0x0, -0x20(%rbp)
cmpl $0x3, -0x20(%rbp)
jge 0x6f8a
movq -0x28(%rbp), %rdi
movslq -0x20(%rbp), %rsi
callq 0x3580
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x6f4f
movb $0x0, -0x1(%rbp)
jmp 0x6f8e
movq -0x28(%rbp), %rdi
callq 0x3470
movq -0x28(%rbp), %rdi
movq %rax, %rsi
movslq -0x20(%rbp), %rax
subq %rax, %rsi
subq $0x1, %rsi
callq 0x3580
movsbl (%rax), %eax
cmpl $0x2a, %eax
je 0x6f7d
movb $0x0, -0x1(%rbp)
jmp 0x6f8e
jmp 0x6f7f
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x6f2e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::runIntro()
void GameMaster::runIntro() {

    player->fillInventory(); // Give player an inventory before the intro
    loadScript("Gen/Intro"); // Early exposition until discovery by Lepha
    if (uInput == "quit") return; // For every new entry, check for quit

    player->initInventory(); // Clear inventory before tutorial level

    bool isPrologue = true;
    runNextLevel(isPrologue);
    if (uInput == "quit") return; // For every new entry, check for quit

    player->fillInventory(); // Refill inventory before Level 1
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movq 0x90(%rax), %rdi
callq 0x1a6d0
leaq -0x29(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x3520
movq -0x48(%rbp), %rdx
leaq 0x14f68(%rip), %rsi     # 0x1c410
leaq -0x28(%rbp), %rdi
callq 0x3b80
jmp 0x74b3
movq -0x50(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x6fa0
jmp 0x74c2
leaq -0x28(%rbp), %rdi
callq 0x3200
leaq -0x29(%rbp), %rdi
callq 0x3350
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
leaq 0x14ebd(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x74ee
jmp 0x751e
jmp 0x756f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x7513
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3200
leaq -0x29(%rbp), %rdi
callq 0x3350
jmp 0x7575
movq -0x50(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x193f0
movq -0x50(%rbp), %rdi
movb $0x1, -0x3d(%rbp)
movb -0x3d(%rbp), %al
andb $0x1, %al
movzbl %al, %esi
callq 0x7580
movq -0x50(%rbp), %rdi
addq $0x70, %rdi
leaq 0x14e4e(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x755d
jmp 0x755f
jmp 0x756f
movq -0x50(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x1a6d0
addq $0x50, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3510
nop
// File: sagardoshi[P]NegotiationsEncounter/src/GameMaster.cpp
// Function: GameMaster::runNextLevel(bool)
void GameMaster::runNextLevel(bool isPrologue) {
    startCurrentLevel(); // Intro text for level

    // Only create level at last possible moment
    levels[currLevel] = new Encounter(player,
                                      opponents[currLevel],
                                      turns[currLevel],
                                      keyPrices[currLevel],
                                      isPrologue);


    bool didNotQuit = levels[currLevel]->runEncounter(wonLevel);
    if (!didNotQuit) { // If quit came from within encounter
        uInput = "quit";
        return; // For every new entry, check for quit
    }

    endCurrentLevel(); // Ending text for level (+ game over ending)

    wonLevel = false; // Reset, even though it will be filled later
    currLevel++; // Advance level after complete

    // Doing this AFTER advancing currLevel
    if (uInput == "quit") return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x7920
movl $0x68, %edi
callq 0x32f0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rcx, -0x40(%rbp)
movq %rcx, -0x50(%rbp)
movq 0x90(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq %rax, %rdi
addq $0x98, %rdi
movslq 0x68(%rax), %rsi
callq 0x8050
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq (%rcx), %rcx
movq %rcx, -0x30(%rbp)
movq %rax, %rdi
addq $0xb0, %rdi
movslq 0x68(%rax), %rsi
callq 0x8cb0
movq %rax, %rcx
movq -0x48(%rbp), %rax
movl (%rcx), %ecx
movl %ecx, -0x24(%rbp)
movq %rax, %rdi
addq $0xc8, %rdi
movslq 0x68(%rax), %rsi
callq 0x8cd0
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movl -0x24(%rbp), %ecx
movss (%rax), %xmm0
movzbl -0x9(%rbp), %r8d
andl $0x1, %r8d
callq 0xead0
jmp 0x763b
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0xe0, %rdi
movslq 0x68(%rax), %rsi
callq 0x8cf0
movq -0x50(%rbp), %rdx
movq %rax, %rcx
movq -0x48(%rbp), %rax
movq %rdx, (%rcx)
movq %rax, %rdi
addq $0xe0, %rdi
movslq 0x68(%rax), %rsi
callq 0x8cf0
movq -0x48(%rbp), %rsi
movq (%rax), %rdi
addq $0x6d, %rsi
callq 0x107b0
andb $0x1, %al
movb %al, -0x1d(%rbp)
testb $0x1, -0x1d(%rbp)
jne 0x76c0
movq -0x48(%rbp), %rdi
addq $0x70, %rdi
leaq 0x14d03(%rip), %rsi     # 0x1c3a0
callq 0x3400
jmp 0x76f2
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
movl $0x68, %esi
callq 0x3300
jmp 0x76f8
movq -0x48(%rbp), %rdi
callq 0x7a90
movq -0x48(%rbp), %rdi
movb $0x0, 0x6d(%rdi)
movl 0x68(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x68(%rdi)
addq $0x70, %rdi
leaq 0x14cbb(%rip), %rsi     # 0x1c3a0
callq 0x8a80
testb $0x1, %al
jne 0x76f0
jmp 0x76f2
jmp 0x76f2
addq $0x50, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3510
nopw %cs:(%rax,%rax)