LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: registerInterval::add_predecessor(registerInterval*)
void registerInterval::add_predecessor(registerInterval* i){
	bool found = false;
	for (int j = 0; j < predecessors.size(); j++){
		if (predecessors[j] == i)
			found = true;
	}

	if (!found)
		predecessors.push_back(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x90, %rdi
callq 0xbc10
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3b85
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbc30
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3b78
movb $0x1, -0x11(%rbp)
jmp 0x3b7a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3b33
testb $0x1, -0x11(%rbp)
jne 0x3b9f
movq -0x20(%rbp), %rdi
addq $0x90, %rdi
leaq -0x10(%rbp), %rsi
callq 0xbc50
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: registerInterval::add_successors(registerInterval*)
void registerInterval::add_successors(registerInterval* i){
	bool found = false;
	for (int j = 0; j < successors.size(); j++){
		if (successors[j] == i)
			found = true;
	}

	if (!found)
		successors.push_back(i);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0xa8, %rdi
callq 0xbc10
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x3c25
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbc30
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x3c18
movb $0x1, -0x11(%rbp)
jmp 0x3c1a
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3bd3
testb $0x1, -0x11(%rbp)
jne 0x3c3f
movq -0x20(%rbp), %rdi
addq $0xa8, %rdi
leaq -0x10(%rbp), %rsi
callq 0xbc50
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::basicBlock()
basicBlock::basicBlock(){
	ID = IDgenerator++;
	NumberOfInstructions = 0;
	controlBB = false;
	controling_basicBlock = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x8, %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
addq $0x28, %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
callq 0xbdb0
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
callq 0xbdb0
movq -0x10(%rbp), %rdi
addq $0x90, %rdi
callq 0xb630
movq -0x10(%rbp), %rdi
addq $0xc0, %rdi
callq 0xb630
movq -0x10(%rbp), %rax
movl 0x1e50a(%rip), %ecx     # 0x22288
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1e4ff(%rip)     # 0x22288
movl %ecx, (%rax)
movl $0x0, 0x48(%rax)
movb $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::basicBlock(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
basicBlock::basicBlock(string s){
	ID = IDgenerator++;
	name = s;
	NumberOfInstructions = 0;
	controlBB = false;
	controling_basicBlock = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x8, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3360
movq -0x38(%rbp), %rdi
addq $0x28, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3360
movq -0x38(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x58(%rbp)
callq 0xbdb0
movq -0x38(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x50(%rbp)
callq 0xbdb0
movq -0x38(%rbp), %rdi
addq $0x90, %rdi
movq %rdi, -0x48(%rbp)
callq 0xb630
movq -0x38(%rbp), %rdi
addq $0xc0, %rdi
movq %rdi, -0x40(%rbp)
callq 0xb630
movq -0x38(%rbp), %rax
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rsi
movl 0x1e3d2(%rip), %ecx     # 0x22288
movl %ecx, %edx
incl %edx
movl %edx, 0x1e3c8(%rip)     # 0x22288
movl %ecx, (%rax)
callq 0x3040
jmp 0x3ec9
movq -0x38(%rbp), %rax
movl $0x0, 0x48(%rax)
movb $0x0, 0x50(%rax)
movq $0x0, 0x58(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0xb6d0
movq -0x48(%rbp), %rdi
callq 0xb6d0
movq -0x50(%rbp), %rdi
callq 0xbdd0
movq -0x58(%rbp), %rdi
callq 0xbdd0
movq -0x60(%rbp), %rdi
callq 0x31a0
movq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x18(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::basicBlock(int)
basicBlock::basicBlock(int i){
	ID = IDgenerator2++;
	ABB = i;
	NumberOfInstructions = 0;
	controlBB = false;
	exit_state = false;
	controling_basicBlock = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
callq 0x3360
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
callq 0x3360
movq -0x18(%rbp), %rdi
addq $0x60, %rdi
callq 0xbdb0
movq -0x18(%rbp), %rdi
addq $0x78, %rdi
callq 0xbdb0
movq -0x18(%rbp), %rdi
addq $0x90, %rdi
callq 0xb630
movq -0x18(%rbp), %rdi
addq $0xc0, %rdi
callq 0xb630
movq -0x18(%rbp), %rax
movl 0x1e2db(%rip), %ecx     # 0x2228c
movl %ecx, %edx
addl $0x1, %edx
movl %edx, 0x1e2d0(%rip)     # 0x2228c
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4c(%rax)
movl $0x0, 0x48(%rax)
movb $0x0, 0x50(%rax)
movb $0x0, 0x51(%rax)
movq $0x0, 0x58(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::set_code(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void basicBlock::set_code(string s)
{
	code = s;
	NumberOfInstructions = 0;

	int found = 0;
	found = code.find(";", found + 1, 1);
	while (found != string::npos){
		NumberOfInstructions++;
		found = code.find(";", found + 1, 1);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x28, %rdi
callq 0x3040
movq -0x20(%rbp), %rdi
movl $0x0, 0x48(%rdi)
movl $0x0, -0x14(%rbp)
addq $0x28, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0x140aa(%rip), %rsi     # 0x18111
movl $0x1, %ecx
callq 0x3430
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rax
cmpq $-0x1, %rax
je 0x40ae
movq -0x20(%rbp), %rdi
movl 0x48(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x48(%rdi)
addq $0x28, %rdi
movl -0x14(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdx
leaq 0x14072(%rip), %rsi     # 0x18111
movl $0x1, %ecx
callq 0x3430
movl %eax, -0x14(%rbp)
jmp 0x4074
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::add_predecessor(basicBlock*)
void basicBlock::add_predecessor(basicBlock* b)
{
	bool found = false;
	for (int i = 0; i < predecessors.size(); i++){
		if (predecessors[i] == b)
			found = true;
	}

	if (!found)
		predecessors.push_back(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0xbe80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x417f
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbea0
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4172
movb $0x1, -0x11(%rbp)
jmp 0x4174
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x4133
testb $0x1, -0x11(%rbp)
jne 0x4196
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
leaq -0x10(%rbp), %rsi
callq 0xbec0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::add_successor(basicBlock*)
void basicBlock::add_successor(basicBlock* b)
{
	bool found = false;
	for (int i = 0; i < successors.size(); i++){
		if (successors[i] == b)
			found = true;
	}

	if (!found)
		successors.push_back(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movb $0x0, -0x11(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x20(%rbp), %rdi
movslq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x78, %rdi
callq 0xbe80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x420f
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
movslq -0x18(%rbp), %rsi
callq 0xbea0
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x4202
movb $0x1, -0x11(%rbp)
jmp 0x4204
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x41c3
testb $0x1, -0x11(%rbp)
jne 0x4226
movq -0x20(%rbp), %rdi
addq $0x78, %rdi
leaq -0x10(%rbp), %rsi
callq 0xbec0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/../interface/../implementation/ControlFlowGraph.cpp
// Function: basicBlock::delete_successor(basicBlock*)
void basicBlock::delete_successor(basicBlock* b){
	vector<basicBlock*>::iterator it;
	for (it = successors.begin(); it != successors.end(); it++){
		if(*it == b){
			successors.erase(it);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc180
movq -0x48(%rbp), %rdi
addq $0x78, %rdi
callq 0xc1a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x48(%rbp), %rdi
addq $0x78, %rdi
callq 0xc210
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc1d0
testb $0x1, %al
jne 0x42be
jmp 0x430f
leaq -0x18(%rbp), %rdi
callq 0xc240
movq (%rax), %rax
cmpq -0x10(%rbp), %rax
jne 0x42fc
movq -0x48(%rbp), %rax
addq $0x78, %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0xc2d0
movq -0x50(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0xc260
movq %rax, -0x38(%rbp)
jmp 0x430f
jmp 0x42fe
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc310
movq %rax, -0x40(%rbp)
jmp 0x429a
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/RegisterIntervalCreation.cpp
// Function: RegisterIntervalCreationPass::visit_all_predecessors(basicBlock*)
void RegisterIntervalCreationPass::visit_all_predecessors(basicBlock* BB){
	for(int i=0; i < basic_blocks.size(); i++)
		mark.push_back(false);

	for(int i=0;i<basic_blocks.size(); i++){
		mark[i] = false;
	}

	visit_predecessors(BB);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1bc0e(%rip), %rdi     # 0x22290
callq 0xbe80
movq %rax, %rcx
movq -0x28(%rbp), %rax
cmpq %rcx, %rax
jae 0x66ac
leaq 0x1bc76(%rip), %rdi     # 0x22310
xorl %esi, %esi
callq 0xb920
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x6673
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq 0x1bbce(%rip), %rdi     # 0x22290
callq 0xbe80
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
jae 0x6701
movslq -0x10(%rbp), %rsi
leaq 0x1bc32(%rip), %rdi     # 0x22310
callq 0xbb30
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xbb90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x66b3
movq -0x8(%rbp), %rdi
callq 0x7b70
addq $0x30, %rsp
popq %rbp
retq
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/RegisterIntervalCreation.cpp
// Function: RegisterIntervalCreationPass::visit_registerInterval_all_predecessors(registerInterval*)
void RegisterIntervalCreationPass::visit_registerInterval_all_predecessors(registerInterval* in){
	for(int j=0; j < RegisterIntervals[0]->getID() + RegisterIntervals.size(); j++)
		registerInterval_mark.push_back(false);

	for(int i=0; i < RegisterIntervals[0]->getID() + RegisterIntervals.size(); i++){
		registerInterval_mark[i] = false;
	}

	registerInterval_visit_predecessors(in);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0x1a816(%rip), %rdi     # 0x222a8
xorl %eax, %eax
movl %eax, %esi
callq 0xbc30
movq (%rax), %rdi
callq 0x37f0
cltq
movq %rax, -0x30(%rbp)
leaq 0x1a7f8(%rip), %rdi     # 0x222a8
callq 0xbc10
movq -0x30(%rbp), %rcx
movq %rax, %rdx
movq -0x28(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x7ae1
leaq 0x1a869(%rip), %rdi     # 0x22338
xorl %esi, %esi
callq 0xb920
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x7a83
movl $0x0, -0x10(%rbp)
movslq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq 0x1a7b1(%rip), %rdi     # 0x222a8
xorl %eax, %eax
movl %eax, %esi
callq 0xbc30
movq (%rax), %rdi
callq 0x37f0
cltq
movq %rax, -0x40(%rbp)
leaq 0x1a793(%rip), %rdi     # 0x222a8
callq 0xbc10
movq -0x40(%rbp), %rcx
movq %rax, %rdx
movq -0x38(%rbp), %rax
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x7b5b
movslq -0x10(%rbp), %rsi
leaq 0x1a800(%rip), %rdi     # 0x22338
callq 0xbb30
movq %rax, -0x20(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0xbb90
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x7ae8
movq -0x8(%rbp), %rdi
callq 0x7c90
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/RegisterIntervalCreation.cpp
// Function: RegisterIntervalCreationPass::visit_predecessors(basicBlock*)
void RegisterIntervalCreationPass::visit_predecessors(basicBlock* BB){
	mark[BB->getID()] = true;
	auto P = BB->get_predecessors();
	for(int i=0;i<P.size();i++){
		if(!mark[P[i]->getID()])
			visit_predecessors(P[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x4350
movslq %eax, %rsi
leaq 0x1a781(%rip), %rdi     # 0x22310
callq 0xbb30
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xbb90
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x44a0
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbe80
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x7c6e
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbea0
movq (%rax), %rdi
callq 0x4350
movslq %eax, %rsi
leaq 0x1a712(%rip), %rdi     # 0x22310
callq 0xbb30
movq %rdx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
jmp 0x7c0d
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc5b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x7c2e
jmp 0x7c5e
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbea0
movq (%rax), %rdi
callq 0x7b70
jmp 0x7c45
jmp 0x7c5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbdd0
jmp 0x7c7d
jmp 0x7c60
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7bbe
leaq -0x30(%rbp), %rdi
callq 0xbdd0
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: CMU-SAFARI[P]Register-Interval/./src/implementation/RegisterIntervalCreation.cpp
// Function: RegisterIntervalCreationPass::registerInterval_visit_predecessors(registerInterval*)
void RegisterIntervalCreationPass::registerInterval_visit_predecessors(registerInterval* in){
	registerInterval_mark[in->getID()] = true;
	auto P = in->get_predecessors();
	for(int i=0;i<P.size();i++){
		if(!registerInterval_mark[P[i]->getID()])
			registerInterval_visit_predecessors(P[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0x37f0
movslq %eax, %rsi
leaq 0x1a689(%rip), %rdi     # 0x22338
callq 0xbb30
movq %rax, -0x18(%rbp)
movq %rdx, -0x10(%rbp)
leaq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0xbb90
movq -0x8(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3c50
movl $0x0, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xbc10
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x7d8e
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbc30
movq (%rax), %rdi
callq 0x37f0
movslq %eax, %rsi
leaq 0x1a61a(%rip), %rdi     # 0x22338
callq 0xbb30
movq %rdx, -0x70(%rbp)
movq %rax, -0x68(%rbp)
jmp 0x7d2d
movq -0x70(%rbp), %rax
movq -0x68(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x40(%rbp)
leaq -0x48(%rbp), %rdi
callq 0xc5b0
xorb $-0x1, %al
testb $0x1, %al
jne 0x7d4e
jmp 0x7d7e
movslq -0x34(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0xbc30
movq (%rax), %rdi
callq 0x7c90
jmp 0x7d65
jmp 0x7d7e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x30(%rbp), %rdi
callq 0xb670
jmp 0x7d9d
jmp 0x7d80
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x7cde
leaq -0x30(%rbp), %rdi
callq 0xb670
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3440
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Main/MainHelpers.cc
// Function: getValidCoords()
vector<int> getValidCoords() {
	// safety check no necessary assuming there is enough room for spawning
	vector<int> tempCoordinates;
	do {
		tempCoordinates = rng.genCoordinates(floorDimensions);

		// reroll if coordinates are not for a FloorTile
		// or has an occupant already
	} while (!(isValidCoordinates(tempCoordinates))
	|| isOccupied(tempCoordinates));

	return tempCoordinates;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x98(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movb $0x0, -0x9(%rbp)
callq 0x19550
leaq 0x47a50(%rip), %rsi     # 0x68150
leaq -0x40(%rbp), %rdi
callq 0x19880
jmp 0x2070b
leaq 0x477ce(%rip), %rsi     # 0x67ee0
leaq -0x28(%rbp), %rdi
leaq -0x40(%rbp), %rdx
callq 0x34160
jmp 0x20721
movq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x19610
leaq -0x28(%rbp), %rdi
callq 0x19640
leaq -0x40(%rbp), %rdi
callq 0x19640
movq -0x98(%rbp), %rsi
movb $0x0, -0x81(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x19880
jmp 0x2075c
leaq -0x68(%rbp), %rdi
callq 0x20420
movb %al, -0x99(%rbp)
jmp 0x2076d
movb -0x99(%rbp), %cl
movb $0x1, %al
testb $0x1, %cl
movb %al, -0x9a(%rbp)
jne 0x20782
jmp 0x207ba
movq -0x98(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x19880
jmp 0x20794
movb $0x1, -0x81(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x204d0
movb %al, -0x9b(%rbp)
jmp 0x207ac
movb -0x9b(%rbp), %al
movb %al, -0x9a(%rbp)
jmp 0x207ba
movb -0x9a(%rbp), %al
movb %al, -0x9c(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x207d1
jmp 0x207da
leaq -0x80(%rbp), %rdi
callq 0x19640
leaq -0x68(%rbp), %rdi
callq 0x19640
movb -0x9c(%rbp), %al
testb $0x1, %al
jne 0x206f9
movb $0x1, -0x9(%rbp)
testb $0x1, -0x9(%rbp)
jne 0x20869
jmp 0x2085d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x20879
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x19640
jmp 0x20879
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x20852
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
testb $0x1, -0x81(%rbp)
jne 0x20847
jmp 0x20850
leaq -0x80(%rbp), %rdi
callq 0x19640
jmp 0x20852
leaq -0x68(%rbp), %rdi
callq 0x19640
jmp 0x20879
movq -0x98(%rbp), %rdi
callq 0x19640
movq -0x90(%rbp), %rax
addq $0xa0, %rsp
popq %rbp
retq
movq -0x98(%rbp), %rdi
callq 0x19640
movq -0x48(%rbp), %rdi
callq 0x6550
nop
// File: XxAdi101xX[P]ChamberCrawler/Main/MainHelpers.cc
// Function: hasActed(std::shared_ptr<Character>)
bool hasActed(shared_ptr<Character> character) {
	for (auto actedCharacter: alreadyActed) {
		if (actedCharacter == character) {
			return true;
		}

	}

	return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, -0x10(%rbp)
leaq 0x47539(%rip), %rax     # 0x681a0
movq %rax, -0x18(%rbp)
leaq 0x4752e(%rip), %rdi     # 0x681a0
callq 0x1fd20
movq %rax, -0x20(%rbp)
leaq 0x4751e(%rip), %rdi     # 0x681a0
callq 0x1fb60
movq %rax, -0x28(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x21850
testb $0x1, %al
jne 0x20c9e
jmp 0x20cfb
leaq -0x20(%rbp), %rdi
callq 0x202c0
movq %rax, %rsi
leaq -0x38(%rbp), %rdi
callq 0x1a350
movq -0x48(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x21890
testb $0x1, %al
jne 0x20cc6
jmp 0x20cd3
movb $0x1, -0x1(%rbp)
movl $0x1, -0x3c(%rbp)
jmp 0x20cda
movl $0x0, -0x3c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x19530
movl -0x3c(%rbp), %eax
testl %eax, %eax
je 0x20cee
jmp 0x20cec
jmp 0x20cff
jmp 0x20cf0
leaq -0x20(%rbp), %rdi
callq 0x218d0
jmp 0x20c8b
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Main/MainHelpers.cc
// Function: getNormalOrSmallGoldPile()
int getNormalOrSmallGoldPile () {
	int tempAmount = 0;
	do {
		tempAmount = rng.genGold();

		// reroll if value is not small or not normal
	} while (tempAmount != GOLD_PILE_SMALL_VALUE
		&& tempAmount != GOLD_PILE_NORMAL_VALUE);

	return tempAmount;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
leaq 0x46e4a(%rip), %rdi     # 0x67ee0
callq 0x340a0
movl %eax, -0x4(%rbp)
xorl %eax, %eax
cmpl $0x1, -0x4(%rbp)
movb %al, -0x5(%rbp)
je 0x210b3
cmpl $0x2, -0x4(%rbp)
setne %al
movb %al, -0x5(%rbp)
movb -0x5(%rbp), %al
testb $0x1, %al
jne 0x2108f
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Main/MainHelpers.cc
// Function: reset()
void reset() {
	floorCount = 0;
	theTextDisplay.setFloorNumber(0);
	currentFloor.resetFloorNumber();

	NPCMovementPaused = false;
	merchantsAngered = false;

	usedPotions.clear();

	player = nullptr;

	playerHasBeenPlaced = false;

	alreadyActed.clear();

	playerHasActed = false;

	numberOfSpawnedPotions = 0;
	numberOfSpawnedGoldPiles = 0;
	numberOfSpawnedNPCs = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, 0x46da6(%rip)     # 0x68168
leaq 0x46b1f(%rip), %rdi     # 0x67ee8
xorl %esi, %esi
callq 0x3d010
leaq 0x46d39(%rip), %rdi     # 0x68110
callq 0x3f6a0
movb $0x0, 0x46d89(%rip)     # 0x6816c
movb $0x0, 0x46d83(%rip)     # 0x6816d
leaq 0x46d7f(%rip), %rdi     # 0x68170
callq 0x223d0
leaq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x194e0
leaq 0x46d7e(%rip), %rdi     # 0x68188
leaq -0x10(%rbp), %rsi
callq 0x19500
leaq -0x10(%rbp), %rdi
callq 0x19530
movb $0x0, 0x46d75(%rip)     # 0x68198
leaq 0x46d76(%rip), %rdi     # 0x681a0
callq 0x1a500
movb $0x0, 0x46d82(%rip)     # 0x681b8
movl $0x0, 0x46d7c(%rip)     # 0x681bc
movl $0x0, 0x46d76(%rip)     # 0x681c0
movl $0x0, 0x46d70(%rip)     # 0x681c4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Cell/Cell.cc
// Function: Cell::getNeighbour(Direction) const
shared_ptr<Cell> Cell::getNeighbour(Direction direction) const {
	// The neighbours are always placed in a particular order in the vector
	if (direction == Direction::North) {
		return (getNeighbours()[0]);
	}
	else if (direction == Direction::NorthWest) {
		return (getNeighbours()[1]);
	}
	else if (direction == Direction::West) {
		return (getNeighbours()[2]);
	}
	else if (direction == Direction::SouthWest) {
		 return (getNeighbours()[3]);
	}
	else if (direction == Direction::South) {
		return (getNeighbours()[4]);
	}
	else if (direction == Direction::SouthEast) {
		return (getNeighbours()[5]);
	}
	else if (direction == Direction::East) {
		return (getNeighbours()[6]);
	}
	else {
		return (getNeighbours()[7]); // NorthEast
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0xf0(%rbp)
movq %rdi, %rax
movq %rax, -0xe8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x2cd12
movq -0xe0(%rbp), %rsi
leaq -0x30(%rbp), %rdi
callq 0x2cf00
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0x30(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
cmpl $0x1, -0x14(%rbp)
jne 0x2cd53
movq -0xe0(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2cf00
leaq -0x48(%rbp), %rdi
movl $0x1, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0x48(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
cmpl $0x2, -0x14(%rbp)
jne 0x2cd94
movq -0xe0(%rbp), %rsi
leaq -0x60(%rbp), %rdi
callq 0x2cf00
leaq -0x60(%rbp), %rdi
movl $0x2, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0x60(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
cmpl $0x7, -0x14(%rbp)
jne 0x2cdd5
movq -0xe0(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2cf00
leaq -0x78(%rbp), %rdi
movl $0x3, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0x78(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
cmpl $0x5, -0x14(%rbp)
jne 0x2ce1f
movq -0xe0(%rbp), %rsi
leaq -0x90(%rbp), %rdi
callq 0x2cf00
leaq -0x90(%rbp), %rdi
movl $0x4, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0x90(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
cmpl $0x6, -0x14(%rbp)
jne 0x2ce69
movq -0xe0(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
callq 0x2cf00
leaq -0xa8(%rbp), %rdi
movl $0x5, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0xa8(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
cmpl $0x3, -0x14(%rbp)
jne 0x2ceb0
movq -0xe0(%rbp), %rsi
leaq -0xc0(%rbp), %rdi
callq 0x2cf00
leaq -0xc0(%rbp), %rdi
movl $0x6, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0xc0(%rbp), %rdi
callq 0x1a2f0
jmp 0x2ceef
movq -0xe0(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0x2cf00
leaq -0xd8(%rbp), %rdi
movl $0x7, %esi
callq 0x2da40
movq -0xf0(%rbp), %rdi
movq %rax, %rsi
callq 0x19e60
leaq -0xd8(%rbp), %rdi
callq 0x1a2f0
movq -0xe8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nop
// File: XxAdi101xX[P]ChamberCrawler/Character/Character.cc
// Function: Character::applyItem(std::shared_ptr<Item>)
void Character::applyItem(shared_ptr<Item> item) {
    // gets the item type
    ItemType itemType = item->getItemType();

    // if item is GoldPile
    if (itemType == ItemType::GoldPile) {
        // if GoldPile is not bound
        if (!(static_pointer_cast<GoldPile>(item)->getBoundState())) {
                this->addGold(item->getValue());
        }

    }

    // if item is Potion
    else if (itemType == ItemType::Potion) {
        this->applyPotion(static_pointer_cast<Potion>(item));
    }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rsi, -0x60(%rbp)
movq %rdi, %rax
movq -0x60(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
callq 0x2dc20
movq %rax, %rdi
callq 0x33d60
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x300c8
movq -0x58(%rbp), %rsi
leaq -0x28(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x318e0
movq -0x70(%rbp), %rdi
callq 0x31930
movq %rax, %rdi
callq 0x33cd0
movb %al, -0x61(%rbp)
jmp 0x30077
movb -0x61(%rbp), %al
xorb $-0x1, %al
movb %al, -0x71(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x19be0
movb -0x71(%rbp), %al
testb $0x1, %al
jne 0x30091
jmp 0x300c6
movq -0x58(%rbp), %rdi
callq 0x2dc20
movq %rax, %rdi
callq 0x33d80
movq -0x50(%rbp), %rdi
movl %eax, %esi
callq 0x301e0
jmp 0x300c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x19be0
jmp 0x3011b
jmp 0x30112
cmpl $0x1, -0x14(%rbp)
jne 0x30110
movq -0x58(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x31970
movq -0x50(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x2e900
jmp 0x300ee
leaq -0x48(%rbp), %rdi
callq 0x19b20
jmp 0x30110
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x19b20
jmp 0x3011b
jmp 0x30112
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x6550
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Character/Character.cc
// Function: Character::addGold(int)
void Character::addGold(int amount) {
	this->wallet += amount;
	this->score += amount;

	this->addAction(makeMsg(this->name, WORD_GAIN_PAST_TENSE, to_string(amount)
		+ " " + WORD_GOLD_NOUN));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xe8(%rbp)
movl -0xc(%rbp), %ecx
movl 0x60(%rsi), %eax
addl %ecx, %eax
movl %eax, 0x60(%rsi)
movl -0xc(%rbp), %ecx
movl 0x64(%rsi), %eax
addl %ecx, %eax
movl %eax, 0x64(%rsi)
addq $0x88, %rsi
leaq -0x50(%rbp), %rdi
callq 0x6160
leaq 0x390ee(%rip), %rsi     # 0x69318
leaq -0x70(%rbp), %rdi
callq 0x6160
jmp 0x30235
movl -0xc(%rbp), %esi
leaq -0xe0(%rbp), %rdi
callq 0x31790
jmp 0x30246
leaq 0x14932(%rip), %rdx     # 0x44b7f
leaq -0xc0(%rbp), %rdi
leaq -0xe0(%rbp), %rsi
callq 0x19360
jmp 0x30262
leaq 0x390cf(%rip), %rdx     # 0x69338
leaq -0xa0(%rbp), %rdi
leaq -0xc0(%rbp), %rsi
callq 0x315f0
jmp 0x3027e
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0xa0(%rbp), %rcx
callq 0x343f0
jmp 0x30298
movq -0xe8(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x2eb60
jmp 0x302aa
leaq -0x30(%rbp), %rdi
callq 0x65e8
leaq -0xa0(%rbp), %rdi
callq 0x65e8
leaq -0xc0(%rbp), %rdi
callq 0x65e8
leaq -0xe0(%rbp), %rdi
callq 0x65e8
leaq -0x70(%rbp), %rdi
callq 0x65e8
leaq -0x50(%rbp), %rdi
callq 0x65e8
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x3037a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x30371
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x30365
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x30359
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
jmp 0x3034d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x78(%rbp)
movl %eax, -0x7c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x65e8
leaq -0xa0(%rbp), %rdi
callq 0x65e8
leaq -0xc0(%rbp), %rdi
callq 0x65e8
leaq -0xe0(%rbp), %rdi
callq 0x65e8
leaq -0x70(%rbp), %rdi
callq 0x65e8
leaq -0x50(%rbp), %rdi
callq 0x65e8
movq -0x78(%rbp), %rdi
callq 0x6550
nopl (%rax)
// File: XxAdi101xX[P]ChamberCrawler/Character/Character.cc
// Function: Character::setPlayer()
void Character::setPlayer() {
	this->isPlayer = true;
	this->isHostile = false;
	this->wallet = 0;
	this->name = NAME_PLAYER;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movb $0x1, 0x49(%rdi)
movb $0x0, 0x48(%rdi)
movl $0x0, 0x60(%rdi)
addq $0x88, %rdi
leaq 0x3845b(%rip), %rsi     # 0x695d8
callq 0x6050
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Character/Elf.cc
// Function: Elf::postAttackRoutine(Character&, bool, Generator&)
void Elf::postAttackRoutine(Character& defender, bool hit, Generator& rng) {
	// not attacking again if already attacked or target is Drow
	if (extraAttacks == 0 || defender.getRace() == Race::Drow) {
		this->extraAttacks = ELF_NUMBER_OF_EXTRA_ATTACKS;
		return;
	}

	--(this->extraAttacks);

	// recursive call to attack, attack will
	// call postAttackRoutine again, but
	// will get stopped by base case
	this->attack(defender, rng);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpl $0x0, 0xa8(%rax)
je 0x32eba
movq -0x10(%rbp), %rdi
callq 0x31240
cmpl $0x1, %eax
jne 0x32eca
movq -0x28(%rbp), %rax
movl $0x1, 0xa8(%rax)
jmp 0x32eea
movq -0x28(%rbp), %rdi
movl 0xa8(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0xa8(%rdi)
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x30500
addq $0x30, %rsp
popq %rbp
retq
// File: XxAdi101xX[P]ChamberCrawler/Character/Merchant.cc
// Function: Merchant::doStartTurnRoutine(Generator&)
void Merchant::doStartTurnRoutine(Generator& rng) {
	// makes merchant hostile if
	// player has killed a merchant before
	if (merchantsAngered) {
		this->setHostile();
	}

	if (this->getHP() != MERCHANT_HP_MAX) {
		merchantsAngered = true;
		this->setHostile();
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
leaq 0x34c6e(%rip), %rax     # 0x6816d
testb $0x1, (%rax)
je 0x33512
movq -0x18(%rbp), %rdi
movl $0x1, %esi
callq 0x301c0
movq -0x18(%rbp), %rdi
callq 0x2eb40
cmpl $0x1e, %eax
je 0x33538
movq -0x18(%rbp), %rdi
leaq 0x34c42(%rip), %rax     # 0x6816d
movb $0x1, (%rax)
movl $0x1, %esi
callq 0x301c0
addq $0x20, %rsp
popq %rbp
retq
nop
// File: XxAdi101xX[P]ChamberCrawler/Character/Orc.cc
// Function: Orc::dealDamageTo(Character&, int&, Generator&)
bool Orc::dealDamageTo(Character& defender, int& damage, Generator& rng) {
	// if race is goblin, deal 50% more damage
	if (defender.getRace() == Race::Goblin) {
		damage *= 1.5;
	}

	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31240
cmpl $0x4, %eax
jne 0x33950
movq -0x18(%rbp), %rax
cvtsi2sdl (%rax), %xmm0
movsd 0x118ba(%rip), %xmm1    # 0x45200
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movl %ecx, (%rax)
movb $0x1, %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Character/Vampire.cc
// Function: Vampire::postAttackRoutine(Character&, bool, Generator&)
void Vampire::postAttackRoutine(Character& defender, bool hit, Generator& rng) {
	// calculates potential HP gain/loss
	int HPToBeAdded = defender.getRace() == Race::Dwarf
		? -1 * VAMPIRE_ON_HIT_HEAL : VAMPIRE_ON_HIT_HEAL;

	// only add if actually hit enemy
	if (hit) {
		this->addHP(HPToBeAdded);
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rdi
callq 0x31240
movl %eax, %edx
movl $0x5, %eax
movl $0xfffffffb, %ecx       # imm = 0xFFFFFFFB
cmpl $0x6, %edx
cmovel %ecx, %eax
movl %eax, -0x24(%rbp)
testb $0x1, -0x11(%rbp)
je 0x33bb3
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x2f3c0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: XxAdi101xX[P]ChamberCrawler/Items/Potion.cc
// Function: Potion::potionTypeToPotency(PotionType)
int Potion::potionTypeToPotency(PotionType potionType) {
	// Different potion potencies layed out in if statements so they can
	// easily be changed/added if required

	if (potionType == PotionType::RestoreHealth) {
		return POTION_POTENCY_RESTORE_HEALTH;
	}
	else if (potionType == PotionType::PoisonHealth) {
    	return POTION_POTENCY_POISON_HEALTH;
  	}
	else if (potionType == PotionType::BoostAttack) {
    	return POTION_POTENCY_BOOST_ATTACK;
  	}
	else if (potionType == PotionType::BoostDefence) {
    	return POTION_POTENCY_BOOST_DEFENSE;
  	}
	else if (potionType == PotionType::WoundAttack) {
    	return POTION_POTENCY_WOUND_ATTACK;
  	}
	else if (potionType == PotionType::WoundDefence) {
    	return POTION_POTENCY_WOUND_DEFENSE;
  	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x33e3a
movl $0xa, -0x4(%rbp)
jmp 0x33e96
cmpl $0x1, -0x14(%rbp)
jne 0x33e49
movl $0xfffffff6, -0x4(%rbp) # imm = 0xFFFFFFF6
jmp 0x33e96
cmpl $0x2, -0x14(%rbp)
jne 0x33e58
movl $0x5, -0x4(%rbp)
jmp 0x33e96
cmpl $0x3, -0x14(%rbp)
jne 0x33e67
movl $0x5, -0x4(%rbp)
jmp 0x33e96
cmpl $0x4, -0x14(%rbp)
jne 0x33e76
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x33e96
cmpl $0x5, -0x14(%rbp)
jne 0x33e85
movl $0xfffffffb, -0x4(%rbp) # imm = 0xFFFFFFFB
jmp 0x33e96
jmp 0x33e87
jmp 0x33e89
jmp 0x33e8b
jmp 0x33e8d
jmp 0x33e8f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Generator/Generator.cc
// Function: Generator::genNPCRace()
Race Generator::genNPCRace() {
    float r = (float)rand()/INT_MAX;


    r -= HUMAN_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Human;
    }

    r-= DWARF_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Dwarf;
    }

    r-= HALFLING_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Halfling;
    }

    r -= ELF_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Elf;
    }

    r-= ORC_SPAWN_CHANCE;
    if (r < 0) {
        return Race::Orc;
    }



    return Race::Merchant;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x60f0
cvtsi2ss %eax, %xmm0
movss 0x112c3(%rip), %xmm1    # 0x45240
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movss 0x112a9(%rip), %xmm1    # 0x4523c
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x33fb1
movl $0x5, -0x4(%rbp)
jmp 0x34058
movss -0x14(%rbp), %xmm0
movss 0x11286(%rip), %xmm1    # 0x45244
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x33fd9
movl $0x6, -0x4(%rbp)
jmp 0x34058
movss -0x14(%rbp), %xmm0
movss 0x11262(%rip), %xmm1    # 0x45248
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x34001
movl $0xb, -0x4(%rbp)
jmp 0x34058
movss -0x14(%rbp), %xmm0
movss 0x1123e(%rip), %xmm1    # 0x4524c
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x34029
movl $0x7, -0x4(%rbp)
jmp 0x34058
movss -0x14(%rbp), %xmm0
movss 0x11216(%rip), %xmm1    # 0x4524c
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x34051
movl $0x8, -0x4(%rbp)
jmp 0x34058
movl $0x9, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Generator/Generator.cc
// Function: Generator::genGold()
int Generator::genGold() {
    float r = (float)rand()/INT_MAX;

    r -= GOLD_PILE_SMALL_SPAWN_CHANCE;

    if (r < 0)
        return GOLD_PILE_SMALL_VALUE;

    r -= GOLD_PILE_NORMAL_SPAWN_CHANCE;

    if (r < 0)
        return GOLD_PILE_NORMAL_VALUE;

    return GOLD_PILE_DRAGON_HOARD_VALUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
callq 0x60f0
cvtsi2ss %eax, %xmm0
movss 0x11183(%rip), %xmm1    # 0x45240
divss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
movss -0x14(%rbp), %xmm0
movss 0x1117d(%rip), %xmm1    # 0x45250
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x340ee
movl $0x1, -0x4(%rbp)
jmp 0x3411d
movss -0x14(%rbp), %xmm0
movss 0x11159(%rip), %xmm1    # 0x45254
subss %xmm1, %xmm0
movss %xmm0, -0x14(%rbp)
xorps %xmm0, %xmm0
ucomiss -0x14(%rbp), %xmm0
jbe 0x34116
movl $0x2, -0x4(%rbp)
jmp 0x3411d
movl $0x6, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: XxAdi101xX[P]ChamberCrawler/Generator/Generator.cc
// Function: Generator::genNeighbourCoord(std::vector<int, std::allocator<int>>)
std::vector<int> Generator::genNeighbourCoord(std::vector<int> base) {
    Direction d = genDirection();
    switch (d) {
        case Direction::North:
            ++base[0];
            break;
        case Direction::NorthEast:
            ++base[0];
            ++base[1];
            break;
        case Direction::East:
            ++base[1];
            break;
        case Direction::SouthEast:
            --base[0];
            ++base[1];
            break;
        case Direction::South:
            --base[0];
            break;
        case Direction::SouthWest:
            --base[0];
            --base[1];
            break;
        case Direction::West:
            --base[1];
            break;
        case Direction::NorthWest:
            ++base[0];
            --base[1];
            break;
        default:
            break;
    }
    return base;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x34240
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq %rax, -0x28(%rbp)
subq $0x7, %rax
ja 0x343d6
movq -0x28(%rbp), %rax
leaq 0x10f9d(%rip), %rcx     # 0x45258
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq -0x40(%rbp), %rdi
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %esi
callq 0x19850
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x19850
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq -0x40(%rbp), %rdi
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %esi
callq 0x19850
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq -0x40(%rbp), %rdi
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %esi
callq 0x19850
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
movl $0x1, %esi
callq 0x19850
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
movq -0x40(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x19850
movq -0x40(%rbp), %rdi
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl $0x1, %esi
callq 0x19850
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
jmp 0x343d8
jmp 0x343d8
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x23b60
movq -0x30(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: XxAdi101xX[P]ChamberCrawler/Messaging/Messaging.cc
// Function: potionToText[abi:cxx11](std::shared_ptr<Potion>)
string potionToText(const shared_ptr<Potion> potion) {
	PotionType type = potion->getPotionType();
	bool used = false;

	// check if player has used potion
	for (auto usedPotion: usedPotions) {
		if (usedPotion == type) {
			used = true;
			break;
		}

	}

	if (used) {
		return potionTypes[type] + " " + NAME_ITEM_POTION;
	}

	return NAME_POTION_UNKNOWN + " " + NAME_ITEM_POTION;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rsi, -0xa0(%rbp)
movq %rdi, %rax
movq -0xa0(%rbp), %rdi
movq %rax, -0x98(%rbp)
movq %rax, %rcx
movq %rcx, -0x90(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
callq 0x31520
movq %rax, %rdi
callq 0x33ef0
movl %eax, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq 0x33a50(%rip), %rax     # 0x68170
movq %rax, -0x20(%rbp)
leaq 0x33a45(%rip), %rdi     # 0x68170
callq 0x32060
movq %rax, -0x28(%rbp)
leaq 0x33a35(%rip), %rdi     # 0x68170
callq 0x31eb0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x352f0
testb $0x1, %al
jne 0x34757
jmp 0x34780
leaq -0x28(%rbp), %rdi
callq 0x32440
movl (%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x34773
movb $0x1, -0x15(%rbp)
jmp 0x34780
jmp 0x34775
leaq -0x28(%rbp), %rdi
callq 0x35330
jmp 0x34744
testb $0x1, -0x15(%rbp)
je 0x347ee
leaq 0x35f9b(%rip), %rdi     # 0x6a728
leaq -0x14(%rbp), %rsi
callq 0x35350
movq %rax, %rsi
leaq 0x103df(%rip), %rdx     # 0x44b7f
leaq -0x58(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x31710
movq -0x98(%rbp), %rdi
movq -0xa8(%rbp), %rsi
leaq 0x35e73(%rip), %rdx     # 0x6a638
callq 0x315f0
jmp 0x347cc
leaq -0x58(%rbp), %rdi
callq 0x65e8
jmp 0x34853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x58(%rbp), %rdi
callq 0x65e8
jmp 0x34863
leaq 0x35e23(%rip), %rsi     # 0x6a618
leaq 0x10383(%rip), %rdx     # 0x44b7f
leaq -0x88(%rbp), %rdi
movq %rdi, -0xb0(%rbp)
callq 0x31710
movq -0x98(%rbp), %rdi
movq -0xb0(%rbp), %rsi
leaq 0x35e14(%rip), %rdx     # 0x6a638
callq 0x315f0
jmp 0x3482b
leaq -0x88(%rbp), %rdi
callq 0x65e8
jmp 0x34853
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x65e8
jmp 0x34863
movq -0x90(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x6550
nopl (%rax)
// File: XxAdi101xX[P]ChamberCrawler/Messaging/Messaging.cc
// Function: itemToText[abi:cxx11](std::shared_ptr<Item>)
string itemToText(const shared_ptr<Item> item) {
    if (item == nullptr) {
        return "";
    }

    else if (item->getItemType() == ItemType::GoldPile) {
        return goldPileToText(static_pointer_cast<GoldPile>(item));
    }

    else if (item->getItemType() == ItemType::Potion) {
        return potionToText(static_pointer_cast<Potion>(item));
    }

	return "";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x68(%rbp)
movq %rdi, %rax
movq -0x68(%rbp), %rdi
movq %rax, -0x60(%rbp)
movq %rax, %rcx
movq %rcx, -0x58(%rbp)
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
xorl %eax, %eax
movl %eax, %esi
callq 0x35430
testb $0x1, %al
jne 0x348a8
jmp 0x348f3
leaq -0x11(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x6560
movq -0x60(%rbp), %rdi
movq -0x70(%rbp), %rdx
leaq 0x109b5(%rip), %rsi     # 0x45279
callq 0x191f0
jmp 0x348cb
leaq -0x11(%rbp), %rdi
callq 0x6370
jmp 0x349f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x11(%rbp), %rdi
callq 0x6370
jmp 0x34a05
movq -0x68(%rbp), %rdi
callq 0x2dc20
movq %rax, %rdi
callq 0x33d60
cmpl $0x0, %eax
jne 0x34951
movq -0x68(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x318e0
movq -0x60(%rbp), %rdi
movq -0x78(%rbp), %rsi
callq 0x34670
jmp 0x34929
leaq -0x38(%rbp), %rdi
callq 0x19be0
jmp 0x349f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x19be0
jmp 0x34a05
movq -0x68(%rbp), %rdi
callq 0x2dc20
movq %rax, %rdi
callq 0x33d60
cmpl $0x1, %eax
jne 0x349a9
movq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x31970
movq -0x60(%rbp), %rdi
movq -0x80(%rbp), %rsi
callq 0x346d0
jmp 0x34987
leaq -0x48(%rbp), %rdi
callq 0x19b20
jmp 0x349f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x19b20
jmp 0x34a05
jmp 0x349ab
jmp 0x349ad
leaq -0x49(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x6560
movq -0x60(%rbp), %rdi
movq -0x88(%rbp), %rdx
leaq 0x108aa(%rip), %rsi     # 0x45279
callq 0x191f0
jmp 0x349d6
leaq -0x49(%rbp), %rdi
callq 0x6370
jmp 0x349f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x49(%rbp), %rdi
callq 0x6370
jmp 0x34a05
movq -0x58(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x6550
nop