LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::EvaluateCriteria(std::ostream&, std::istream&)
void BattleSim::EvaluateCriteria(ostream &pout, istream &fin) {
	string whichCriteria;
	pout << "Enter which criterion to evaluate.\n";
	getline(fin,whichCriteria);
	
	int wcInt = StringToIntHelper(whichCriteria);
	if(wcInt == 0 || wcInt == 1) { //TODO::MAGIC NUMBER HERE
		EvaluateCriterion(pout,wcInt);
	} else {
		pout << "Invalid choice\n"; //TODO: TELL SIZE?
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x4312(%rip), %rsi      # 0x124d5
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x38(%rbp), %rsi
callq 0xe798
cmpl $0x1, %eax
ja 0xe1f1
movq %r14, %rdi
movl %eax, %esi
callq 0xf5c0
jmp 0xe200
leaq 0x4301(%rip), %rsi      # 0x124f9
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe216
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetParticipants(std::ostream&, std::istream&)
void BattleSim::SetParticipants(ostream &pout,istream &fin) {
	string whichEntry;
	int whichEntryInt;
	
	pout << "Enter which participant to set\n";
	getline(fin,whichEntry);
	whichEntryInt = StringToIntHelper(whichEntry);
	if(whichEntryInt == 0 || whichEntryInt == 1) {  //TODO::MAGIC NUMBER HERE
		SetParticipant(pout, fin, whichEntryInt);
	} else {
		pout << "Invalid choice(0 or 1)\n"; //TODO: TELL SIZE?
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x42e2(%rip), %rsi      # 0x12539
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %r14, %rdi
callq 0x2050
leaq -0x38(%rbp), %rsi
callq 0xe798
cmpl $0x1, %eax
ja 0xe28b
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %eax, %ecx
callq 0xec10
jmp 0xe29a
leaq 0x42c7(%rip), %rsi      # 0x12559
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::PrintCriteria(std::ostream&, std::istream&)
void BattleSim::PrintCriteria(ostream &pout, istream &fin) {
	/*
		Prompt:
		Get Input Number:
		Call PrintCriterion Function with param
	*/
	pout << "Enter which criterion to print.\n";
	string whichCriterion;
	getline(fin,whichCriterion);	
	int wcInt = StringToIntHelper(whichCriterion);
	if(wcInt == 0 || wcInt == 1) { //TODO::MAGIC NUMBER HERE
		PrintCriterion(pout, wcInt);
	} else {
		pout << "Invalid Choice.\n"; //TODO: TELL SIZE?
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x41c4(%rip), %rsi      # 0x124a3
movq %rbx, %rdi
callq 0x2190
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x38(%rbp), %rsi
callq 0xe798
cmpl $0x1, %eax
ja 0xe320
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xeaec
jmp 0xe32f
leaq 0x419d(%rip), %rsi      # 0x124c4
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe345
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::PrintCandidates(std::ostream&, std::istream&)
void BattleSim::PrintCandidates(ostream &pout, istream &fin) {
	string whichEntry;
	int whichEntryInt;

	pout << "Enter Which Candidate List to Print from\n";
	getline(fin,whichEntry);
	whichEntryInt = StringToIntHelper(whichEntry);
	if(whichEntryInt == 0 || whichEntryInt == 1) { //TODO::MAGIC NUMBER HERE
		PrintAllCandidates(pout, whichEntryInt);
	} else {
		pout << "Invalid Choice.\n"; //TODO: TELL SIZE?
	}
		
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x4182(%rip), %rsi      # 0x12509
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x38(%rbp), %rsi
callq 0xe798
cmpl $0x1, %eax
ja 0xe3b8
movq %r14, %rdi
movq %rbx, %rsi
movl %eax, %edx
callq 0xeb5a
jmp 0xe3c7
leaq 0x4105(%rip), %rsi      # 0x124c4
movq %rbx, %rdi
callq 0x2190
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::PrintParticipants(std::ostream&)
void BattleSim::PrintParticipants(ostream &pout) {
	string res;
	for(unsigned i = 0; i < 2; i++) {
		be.ParticipantDescription(i,res);
		pout << res << '\n';
	}
	pout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r15d, %r15d
leaq -0x48(%rbp), %r12
pushq $0xa
popq %r13
cmpl $0x2, %r15d
je 0xe451
movq %r14, %rdi
movl %r15d, %esi
movq %r12, %rdx
callq 0xf8e6
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %rdi
movl %r13d, %esi
callq 0x21f0
incl %r15d
jmp 0xe422
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x21f0
leaq -0x48(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe476
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::Simulate(std::ostream&, std::istream&, std::ostream&)
void BattleSim::Simulate(ostream &pout,istream &fin, ostream &fout) {
	//TODO:
	string whichEntry;
	int whichEntryInt1,whichEntryInt2;
	
	pout << "Enter first participant to set\n";
	getline(fin,whichEntry);
	whichEntryInt1 = StringToIntHelper(whichEntry);	
	pout << "Enter second participant to set\n";
	getline(fin,whichEntry);
	whichEntryInt2 = StringToIntHelper(whichEntry);
	if(whichEntryInt1 >= 0 && whichEntryInt1 <= 1 && whichEntryInt2 >= 0 && whichEntryInt2 <= 1) { //TODO::MAGIC NUMBER HERE
		be.Evaluate(whichEntryInt1,whichEntryInt2);
		be.Evaluate(whichEntryInt2,whichEntryInt1);
	} else {
		pout << "Invalid Choices\n"; //TODO: TELL SIZE?
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x40d6(%rip), %rsi      # 0x1258f
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
movl %eax, %r15d
leaq 0x40cf(%rip), %rsi      # 0x125af
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
movl %eax, %r12d
orl %r15d, %eax
cmpl $0x1, %eax
ja 0xe526
movq %rbx, %rdi
movl %r15d, %esi
movl %r12d, %edx
callq 0xf936
movq %rbx, %rdi
movl %r12d, %esi
movl %r15d, %edx
callq 0xf936
jmp 0xe535
leaq 0x40a3(%rip), %rsi      # 0x125d0
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::RetrieveResults(std::ostream&, std::istream&, std::ostream&)
void BattleSim::RetrieveResults(ostream &pout,istream &fin, ostream &fout) {
	string whichEntry;
	int whichEntryInt1,whichEntryInt2;
	
	pout << "Enter first participant to set\n";
	getline(fin,whichEntry);
	whichEntryInt1 = StringToIntHelper(whichEntry);	
	pout << "Enter second participant to set\n";
	getline(fin,whichEntry);
	whichEntryInt2 = StringToIntHelper(whichEntry);	
	if(whichEntryInt1 >= 0 && whichEntryInt1 <= 1 && whichEntryInt2 >= 0 && whichEntryInt2 <= 1) {
		RetrieveResult(pout,fout,whichEntryInt1,whichEntryInt2);
	} else {
		pout << "Invalid Choices\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x4000(%rip), %rsi      # 0x1258f
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
movl %eax, %r12d
leaq 0x3ff9(%rip), %rsi      # 0x125af
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
movl %eax, %ecx
orl %r12d, %ecx
cmpl $0x1, %ecx
ja 0xe5ed
movq %rbx, %rdi
movl %r12d, %ecx
movl %eax, %r8d
callq 0xecbe
jmp 0xe5fc
leaq 0x3fdc(%rip), %rsi      # 0x125d0
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetName(std::ostream&, std::istream&, int)
void BattleSim::SetName(ostream &pout, istream &fin, int whichCriteria) {
	string name;
	pout << "Enter Name\n";
	getline(fin,name);
	be.SetName(whichCriteria,name);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
leaq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x3d29(%rip), %rsi      # 0x1237e
movq %rax, %rdi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2240
leaq -0x58(%rbp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0xf26c
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
jmp 0xe6b2
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetMoves(std::ostream&, std::istream&, int)
void BattleSim::SetMoves(ostream &pout, istream &fin, int whichCriteria) {
	pout << "Enter the number of the move to change.(0-4)\n";
	string whichMove;
	getline(fin,whichMove);
	int whichMoveInt = StringToIntHelper(whichMove);
	if(whichMoveInt >= 0 && whichMoveInt < 4) {
		SetMove(pout,fin,whichCriteria,whichMoveInt);
		
	} else {
		pout << "Incorrect Move Choice. You have to choose between " << 0 << " and " << 4 << '\n';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %r14d
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r12
leaq 0x3ca4(%rip), %rsi      # 0x1238a
movq %rbx, %rdi
callq 0x2190
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x40(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
cmpl $0x3, %eax
ja 0xe72e
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
movl %r14d, %ecx
movl %eax, %r8d
callq 0xe7ea
jmp 0xe76c
leaq 0x3c83(%rip), %rsi      # 0x123b8
movq %rbx, %rdi
callq 0x2190
movq %rax, %rdi
xorl %esi, %esi
callq 0x22d0
leaq 0x3c9d(%rip), %rsi      # 0x123eb
movq %rax, %rdi
callq 0x2190
pushq $0x4
popq %rsi
movq %rax, %rdi
callq 0x22d0
pushq $0xa
popq %rsi
movq %rax, %rdi
callq 0x21f0
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe784
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::StringToIntHelper(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&)
int BattleSim::StringToIntHelper(const string &a) {
	unsigned i = 0;
	unsigned len = a.size();
	int res = 0;
	for(i = 0; i < len; i++) {
		res *= 10;
		res += (int)(a.at(i) - '0');
		if(res < 0)
			return -1;
	}
	return res;
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movl 0x8(%rsi), %r15d
xorl %r14d, %r14d
pushq $-0x1
popq %r12
xorl %eax, %eax
cmpq %r14, %r15
je 0xe7db
imull $0xa, %eax, %r13d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2200
movsbl (%rax), %eax
addl %r13d, %eax
incq %r14
addl $-0x30, %eax
jns 0xe7b6
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetMove(std::ostream&, std::istream&, int, int)
void BattleSim::SetMove(ostream &pout, istream &fin, int whichCriteria, int whichMove) {
	string move;
	pout <<"Enter Move\n";
	getline(fin,move);
	be.SetMove(whichCriteria,whichMove,move);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movl %r8d, %ebx
movl %ecx, %r14d
movq %rdx, %r12
movq %rsi, %rax
movq %rdi, %r15
leaq -0x30(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x3bd2(%rip), %rsi      # 0x123f1
movq %rax, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x2050
leaq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x2240
leaq -0x60(%rbp), %rcx
movq %r15, %rdi
movl %r14d, %esi
movl %ebx, %edx
callq 0xf2de
leaq -0x60(%rbp), %rdi
callq 0x20e0
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0xe881
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetType(std::ostream&, std::istream&, int)
void BattleSim::SetType(ostream &pout, istream &fin, int whichCriteria) {
	string type;
	pout << "Enter Type\n";
	getline(fin,type);
	be.SetType(whichCriteria,type);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movl %ecx, %ebx
movq %rdx, %r15
movq %rsi, %rax
movq %rdi, %r14
leaq -0x28(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb $0x0, (%rcx)
leaq 0x3b3c(%rip), %rsi      # 0x123fd
movq %rax, %rdi
callq 0x2190
leaq -0x38(%rbp), %rsi
movq %r15, %rdi
callq 0x2050
leaq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x2240
leaq -0x58(%rbp), %rdx
movq %r14, %rdi
movl %ebx, %esi
callq 0xf2ae
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
jmp 0xe91e
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetIV(std::ostream&, std::istream&, int)
void BattleSim::SetIV(ostream &pout, istream &fin, int whichCriteria) {
	string iv;
	getline(fin,iv);
	int ivInt = StringToIntHelper(iv);
	if(ivInt != -1) {
		be.SetIVs(whichCriteria,ivInt);
	} else {
		pout << "Enter valid value for IV(positive integer 0 - 31)\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %ecx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq -0x28(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x38(%rbp), %rsi
movq %rdx, %rdi
callq 0x2050
leaq -0x38(%rbp), %rsi
callq 0xe798
cmpl $-0x1, %eax
je 0xe97d
movq %r15, %rdi
movl %ebx, %esi
movl %eax, %edx
callq 0xf316
jmp 0xe98c
leaq 0x3a85(%rip), %rsi      # 0x12409
movq %r14, %rdi
callq 0x2190
leaq -0x38(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe9a2
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetCriterion(std::ostream&, std::istream&, int)
void BattleSim::SetCriterion(ostream &pout, istream &fin, int whichCriteria) {

	string option;
	str_code sc = INITCODE;
	while(sc != EXIT) {
		pout << "Enter what to change.(SETNAME,SETMOVE,SETTYPE,SETIV)\n";
		getline(fin,option);
		sc = HashString(option);
		switch(sc) {
			case SETNAME:
				SetName(pout,fin,whichCriteria); break;
			case SETMOVE: 
				SetMoves(pout,fin,whichCriteria); break;
			case SETTYPE:
				SetType(pout,fin,whichCriteria); break;
			case SETIV:
				SetIV(pout,fin,whichCriteria); break;
			case EXIT:
				pout << "Exit Criteria Menu\n"; break;
			default:
				pout << "Invalid Choice\n"; break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movl %ecx, -0x2c(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x38(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r12d, %r12d
leaq -0x58(%rbp), %r13
leaq -0x78(%rbp), %rbx
cmpl $0xd, %r12d
je 0xeac0
movq %r15, %rdi
leaq 0x3a39(%rip), %rsi      # 0x1243c
callq 0x2190
movq %r14, %rdi
movq %r13, %rsi
callq 0x2050
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2240
movq %rbx, %rsi
callq 0xdf7e
movl %eax, %r12d
movq %rbx, %rdi
callq 0x20e0
movl %r12d, %eax
addl $-0x9, %eax
cmpl $0x4, %eax
ja 0xeaac
leaq 0x388d(%rip), %rcx      # 0x122d0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
leaq 0x3a21(%rip), %rsi      # 0x12472
jmpq *%rax
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl -0x2c(%rbp), %ecx
callq 0xe626
jmp 0xe9ef
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl -0x2c(%rbp), %ecx
callq 0xe930
jmp 0xe9ef
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl -0x2c(%rbp), %ecx
callq 0xe6c4
jmp 0xe9ef
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movl -0x2c(%rbp), %ecx
callq 0xe892
jmp 0xe9ef
leaq 0x38bb(%rip), %rsi      # 0x1236e
movq %r15, %rdi
callq 0x2190
jmp 0xe9ef
leaq -0x58(%rbp), %rdi
callq 0x20e0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::PrintAllCandidates(std::ostream&, int)
void BattleSim::PrintAllCandidates(ostream &pout,int whichCriteria) {

	int sz = be.CandidateListSize(whichCriteria);
	string res;
	//TODO::ADD COUNTERS / A HEADER TO PRINT???
	for(int i = 0; i < sz; i++) {
		be.CandidateDescription(whichCriteria,i,res);
		pout << res << '\n';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %ebx
movq %rsi, -0x30(%rbp)
movq %rdi, %r15
movl %edx, %esi
callq 0xf7d6
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movl %eax, %r12d
movb $0x0, (%rcx)
xorl %r13d, %r13d
testl %eax, %eax
cmovlel %r13d, %r12d
leaq -0x50(%rbp), %r14
cmpl %r13d, %r12d
je 0xebcc
movq %r15, %rdi
movl %ebx, %esi
movl %r13d, %edx
movq %r14, %rcx
callq 0xf812
movq -0x30(%rbp), %rdi
movq %r14, %rsi
callq 0x2180
movq %rax, %rdi
pushq $0xa
popq %rsi
callq 0x21f0
incl %r13d
jmp 0xeb9b
leaq -0x50(%rbp), %rdi
callq 0x20e0
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetParticipant(std::ostream&, std::istream&, int)
void BattleSim::SetParticipant(ostream &pout, istream &fin, int whichEntryInt) {
	string whichChoice;
	int whichChoiceInt;
	pout << "Enter which Candidate to set\n";
	getline(fin,whichChoice);
	whichChoiceInt = StringToIntHelper(whichChoice);

	if(be.CandidateListSize(whichEntryInt) > whichChoiceInt && whichChoiceInt >= 0) {
		be.SetParticipant(whichEntryInt,whichChoiceInt);
	} else {
		pout << "Invalid Choice\n";
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r14
movq %rdi, %r15
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x3930(%rip), %rsi      # 0x12571
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r12, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
movl %eax, %r12d
movq %r15, %rdi
movl %ebx, %esi
callq 0xf7d6
testl %r12d, %r12d
js 0xec84
cmpl %r12d, %eax
jle 0xec84
movq %r15, %rdi
movl %ebx, %esi
movl %r12d, %edx
callq 0xf886
jmp 0xec93
leaq 0x36e3(%rip), %rsi      # 0x1236e
movq %r14, %rdi
callq 0x2190
leaq -0x40(%rbp), %rdi
callq 0x20e0
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::RetrieveResult(std::ostream&, std::ostream&, int, int)
void BattleSim::RetrieveResult(ostream &pout, ostream &fout, int wcInt1, int wcInt2) {
	vector<BattleEvaluator::MoveResult> rr;
	be.RetrieveResults(rr,wcInt1,wcInt2);
	PrintRes(rr);
	be.RetrieveResults(rr,wcInt2,wcInt1);
	PrintRes(rr);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x18, %rsp
movl %r8d, %r14d
movl %ecx, %ebx
movq %rdi, %r15
xorps %xmm0, %xmm0
leaq -0x30(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movl %ecx, %edx
movl %r8d, %ecx
callq 0xfac2
leaq -0x30(%rbp), %rdi
callq 0xedda
leaq -0x30(%rbp), %rsi
movq %r15, %rdi
movl %r14d, %edx
movl %ebx, %ecx
callq 0xfac2
leaq -0x30(%rbp), %rdi
callq 0xedda
leaq -0x30(%rbp), %rdi
callq 0xee7e
addq $0x18, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0xee7e
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: PrintMoveRes(BattleEvaluator::MoveResult&)
void PrintMoveRes(BattleEvaluator::MoveResult &r) {
	//TODO::Replace cout. probably have to make it part of BS
	cout << r.participants.first << " to " << r.participants.second << " using: ";
	cout << r.moveName << " does " << r.damage.first << " to " << r.damage.second;
	cout << ".\n";
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0xe28d(%rip), %rbx      # 0x1cfd8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
leaq 0x3884(%rip), %r15      # 0x125e1
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x2180
leaq 0x386b(%rip), %rsi      # 0x125e6
movq %rax, %rdi
callq 0x2190
leaq 0x40(%r14), %rsi
movq %rbx, %rdi
callq 0x2180
leaq 0x3859(%rip), %rsi      # 0x125ef
movq %rax, %rdi
callq 0x2190
movl 0x60(%r14), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
movq %r15, %rsi
callq 0x2190
movl 0x64(%r14), %esi
movq %rax, %rdi
callq 0x22d0
leaq 0x370a(%rip), %rsi      # 0x124d2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2190
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSimulator.cpp
// Function: main
int main() {
	BattleSim bs;
	//bs.Menu(cout,cin,cout);
	ifstream fin("BSTestData.txt");
	bs.Menu(cout,fin,cout);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
leaq -0x200(%rbp), %rdi
callq 0xddc8
leaq 0x3751(%rip), %rsi      # 0x126c4
leaq -0x408(%rbp), %rdi
pushq $0x8
popq %rdx
callq 0x2300
movq 0xe04f(%rip), %rcx      # 0x1cfd8
leaq -0x200(%rbp), %rdi
leaq -0x408(%rbp), %rdx
movq %rcx, %rsi
callq 0xdde4
leaq -0x408(%rbp), %rdi
callq 0x2070
leaq -0x200(%rbp), %rdi
callq 0xf224
xorl %eax, %eax
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x408(%rbp), %rdi
callq 0x2070
jmp 0xefd7
movq %rax, %rbx
leaq -0x200(%rbp), %rdi
callq 0xf224
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleEvaluator/BattleEvaluator.cpp
// Function: BattleEvaluator::resize(int)
void BattleEvaluator::resize(int n) {
	crit.resize(n);
	candidates.resize(n);
	participants.resize(n);
	res.resize(n);
	for(int i = 0; i < n; i++) {
		res[i].resize(n);
		for(int j = 0; j < n; j++)
			res[i][j].resize(4);
	}
	numCriteria = n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %esi, %ebx
movq %rdi, %r14
addq $0x1a0, %rdi            # imm = 0x1A0
movslq %esi, %r15
movq %r15, %rsi
callq 0xfe1e
leaq 0x188(%r14), %rdi
movq %r15, %rsi
callq 0xfe60
leaq 0x1b8(%r14), %rdi
movq %r15, %rsi
callq 0xfc1a
movq %r14, -0x38(%rbp)
leaq 0x1d0(%r14), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0xfea2
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %eax
movl %ebx, -0x2c(%rbp)
cmovgl %ebx, %eax
movq %rax, -0x48(%rbp)
movq %r15, -0x40(%rbp)
movl %r15d, %eax
imulq $0x18, %rax, %r15
pushq $0x4
popq %r13
cmpq -0x48(%rbp), %rcx
je 0xf15c
movq %rcx, -0x50(%rbp)
imulq $0x18, %rcx, %r14
movq (%r12), %rdi
addq %r14, %rdi
movq -0x40(%rbp), %rsi
callq 0xfee4
xorl %ebx, %ebx
cmpq %rbx, %r15
je 0xf153
movq (%r12), %rax
movq (%rax,%r14), %rdi
addq %rbx, %rdi
movq %r13, %rsi
callq 0xff26
addq $0x18, %rbx
jmp 0xf135
movq -0x50(%rbp), %rcx
incq %rcx
jmp 0xf115
movl -0x2c(%rbp), %eax
movq -0x38(%rbp), %rcx
movl %eax, 0x1e8(%rcx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleEvaluator/BattleEvaluator.cpp
// Function: BattleEvaluator::Criteria::toString[abi:cxx11]()
string BattleEvaluator::Criteria::toString() {
	string res = "Name: ";
	res += (name + string("\n") );
	res += (string("Type: ") + type + string("\n")  );
	for(unsigned i = 0; i < moves.size(); i++) {
		res += (string("Move: ") + moves[i] + string("\n") );
	}
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, %r14
leaq 0x3327(%rip), %rsi      # 0x126d3
leaq -0x78(%rbp), %rdx
movq %rdi, -0x38(%rbp)
callq 0x4cd4
leaq 0x31af(%rip), %rsi      # 0x1256f
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rdx
callq 0x4cd4
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r14, %rsi
callq 0xc017
leaq -0x78(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2320
leaq -0x78(%rbp), %rdi
callq 0x20e0
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq 0x32d4(%rip), %rsi      # 0x126da
leaq -0x98(%rbp), %rdi
leaq -0x2a(%rbp), %rdx
callq 0x4cd4
leaq 0x20(%r14), %rdx
leaq -0x58(%rbp), %rdi
leaq -0x98(%rbp), %rsi
callq 0xff68
leaq 0x313e(%rip), %rsi      # 0x1256f
leaq -0xb8(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x4cd4
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0xb8(%rbp), %rdx
callq 0xc045
leaq -0x78(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2320
leaq -0x78(%rbp), %rdi
callq 0x20e0
leaq -0xb8(%rbp), %r12
movq %r12, %rdi
callq 0x20e0
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x98(%rbp), %rbx
movq %rbx, %rdi
callq 0x20e0
xorl %r15d, %r15d
movl %r15d, %r15d
movq 0x48(%r14), %rax
subq 0x40(%r14), %rax
sarq $0x5, %rax
cmpq %r15, %rax
jbe 0xf535
movq %rbx, %rdi
leaq 0x322a(%rip), %rsi      # 0x126e1
leaq -0x2a(%rbp), %rdx
callq 0x4cd4
movq %r15, %rdx
shlq $0x5, %rdx
addq 0x40(%r14), %rdx
leaq -0x58(%rbp), %rdi
movq %rbx, %rsi
callq 0xff68
movq %r12, %rdi
leaq 0x308e(%rip), %rsi      # 0x1256f
leaq -0x29(%rbp), %rdx
callq 0x4cd4
movq %r12, %rdx
leaq -0x78(%rbp), %r13
movq %r13, %rdi
leaq -0x58(%rbp), %rsi
movq %rdx, %r12
callq 0xc045
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x2320
movq %r13, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20e0
leaq -0x58(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
incl %r15d
jmp 0xf495
movq -0x38(%rbp), %rax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xf56e
jmp 0xf57c
jmp 0xf592
jmp 0xf58d
jmp 0xf5ac
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x20e0
jmp 0xf566
movq %rax, %r14
leaq -0x58(%rbp), %rdi
jmp 0xf5a5
jmp 0xf5ac
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x20e0
jmp 0xf57f
movq %rax, %r14
leaq -0xb8(%rbp), %rdi
callq 0x20e0
jmp 0xf595
movq %rax, %r14
jmp 0xf59e
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x20e0
leaq -0x98(%rbp), %rdi
callq 0x20e0
jmp 0xf5af
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleEvaluator/BattleEvaluator.cpp
// Function: BattleEvaluator::EvaluateCriteria(int)
void BattleEvaluator::EvaluateCriteria(int whichCriteria) {
	if(inBoundCriteria(whichCriteria) ) {
		ef.ResetAllFilters();
		ef.SetNameFilter(crit[whichCriteria].name);
		for(unsigned j = 0; j < crit[whichCriteria].moves.size(); j++) {
			ef.SetMoveFilter(j,crit[whichCriteria].moves[j]);
		}	
		ef.SetTypeFilter(0,crit[whichCriteria].type); //Take note will only set first type.
		vector<string> resIDs;
		ef.Evaluate(resIDs);
		candidates[whichCriteria].resize(resIDs.size());
		int IV = crit[whichCriteria].IV;
		
		for(unsigned x = 0; x < resIDs.size(); x++) {
			candidates[whichCriteria][x] = PokemonEntry(resIDs[x],IV); 
		}		
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
testl %esi, %esi
js 0xf777
movl %esi, %r14d
movq %rdi, %rbx
cmpl %esi, 0x1e8(%rdi)
jle 0xf777
movq %rbx, %rdi
callq 0xcf60
movl %r14d, %r13d
imulq $0x60, %r13, %r12
movq 0x1a0(%rbx), %rsi
addq %r12, %rsi
leaq -0x88(%rbp), %r14
movq %r14, %rdi
callq 0x2240
movq %rbx, %rdi
movq %r14, %rsi
callq 0xd040
leaq -0x88(%rbp), %rdi
callq 0x20e0
xorl %r14d, %r14d
leaq -0xc8(%rbp), %r15
movl %r14d, %r14d
movq 0x1a0(%rbx), %rsi
movq 0x40(%rsi,%r12), %rax
movq 0x48(%rsi,%r12), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
cmpq %r14, %rcx
jbe 0xf687
movq %r14, %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq %r15, %rdi
movq %rax, %rsi
callq 0x2240
movq %rbx, %rdi
movl %r14d, %esi
movq %r15, %rdx
callq 0xd028
movq %r15, %rdi
callq 0x20e0
incl %r14d
jmp 0xf637
addq %r12, %rsi
addq $0x20, %rsi
leaq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x2240
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
callq 0xd04e
leaq -0x68(%rbp), %rdi
callq 0x20e0
xorps %xmm0, %xmm0
leaq -0x40(%rbp), %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
movq %rbx, %rdi
callq 0xd178
imulq $0x18, %r13, %rcx
movq 0x188(%rbx), %rdi
movq %rcx, -0x48(%rbp)
addq %rcx, %rdi
movq -0x38(%rbp), %rsi
subq -0x40(%rbp), %rsi
sarq $0x5, %rsi
callq 0xfc1a
movq 0x1a0(%rbx), %rax
movl 0x58(%rax,%r12), %r14d
xorl %eax, %eax
leaq -0xa8(%rbp), %r15
leaq -0x130(%rbp), %r12
movl %eax, %r13d
movq -0x40(%rbp), %rsi
movq -0x38(%rbp), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r13, %rax
jbe 0xf76e
movq %r13, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0x2240
movq %r12, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0xb048
movq 0x188(%rbx), %rax
imulq $0x68, %r13, %rdi
movq -0x48(%rbp), %rcx
addq (%rax,%rcx), %rdi
movq %r12, %rsi
callq 0xfc5c
movq %r12, %rdi
callq 0xfca0
movq %r15, %rdi
callq 0x20e0
leal 0x1(%r13), %eax
jmp 0xf706
leaq -0x40(%rbp), %rdi
callq 0x4ed4
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0xf7c9
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
jmp 0xf7c9
jmp 0xf7b1
movq %rax, %rbx
leaq -0xa8(%rbp), %rdi
callq 0x20e0
jmp 0xf7b4
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x4ed4
jmp 0xf7ce
movq %rax, %rbx
leaq -0xc8(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleEvaluator/BattleEvaluator.cpp
// Function: BattleEvaluator::Evaluate(int, int)
void BattleEvaluator::Evaluate(int i, int j) {

		
	for(int x = 0; x < 4; x++) {
		res[i][j][x].damage = participants[i].getMoveDamageRange(participants[j],x);
		res[i][j][x].participants = make_pair(participants[i].getName(),participants[j].getName() );
		res[i][j][x].moveName = participants[i].getMove(x).name;
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
movq %rdi, %r12
movslq %esi, %rax
movslq %edx, %rcx
xorl %r14d, %r14d
imulq $0x68, %rax, %rdx
movq %rdx, -0x38(%rbp)
imulq $0x68, %rcx, %rdx
movq %rdx, -0x40(%rbp)
imulq $0x18, %rax, %rax
imulq $0x18, %rcx, %rbx
xorl %edx, %edx
movq %rax, -0x30(%rbp)
cmpq $0x4, %rdx
je 0xfa9c
movq 0x1b8(%r12), %rsi
movq -0x38(%rbp), %r15
leaq (%rsi,%r15), %rdi
movq %rax, %r13
addq -0x40(%rbp), %rsi
movq %rdx, -0x48(%rbp)
callq 0xb46e
movq 0x1d0(%r12), %rcx
movq (%rcx,%r13), %rcx
movq %rbx, %r13
movq (%rcx,%rbx), %rcx
movq %rax, 0x60(%rcx,%r14)
movq 0x1b8(%r12), %rsi
addq %r15, %rsi
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0xb31e
movq 0x1b8(%r12), %rsi
addq -0x40(%rbp), %rsi
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0xb31e
leaq -0x110(%rbp), %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x10380
movq 0x1d0(%r12), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx), %rax
movq (%rax,%r13), %rdi
addq %r14, %rdi
leaq -0x110(%rbp), %r15
movq %r15, %rsi
callq 0xfd16
movq %r15, %rdi
callq 0xef18
movq %rbx, %rdi
callq 0x20e0
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq 0x1b8(%r12), %rsi
addq -0x38(%rbp), %rsi
movq %r15, %rdi
movq -0x48(%rbp), %rbx
movl %ebx, %edx
callq 0xb336
movq 0x1d0(%r12), %rax
movq -0x30(%rbp), %r15
movq (%rax,%r15), %rax
movq (%rax,%r13), %rax
leaq (%rax,%r14), %rdi
addq $0x40, %rdi
leaq -0xf0(%rbp), %rsi
callq 0x2210
leaq -0x110(%rbp), %rdi
callq 0x4c38
movq %rbx, %rdx
incq %rdx
addq $0x68, %r14
movq %r15, %rax
movq %r13, %rbx
jmp 0xf974
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initRookMasks()
void Attacks::initRookMasks()
{
    for (int i = 0; i <= 63; i++)
    {
        rookMasks[i] =  Rays::getRay(NORTH, i) & ~rank_bb[RANK_8] |
                        Rays::getRay(SOUTH, i) & ~rank_bb[RANK_1] |
                        Rays::getRay(WEST, i) & ~file_bb[FILE_A]  |
                        Rays::getRay(EAST, i) & ~file_bb[FILE_H];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x9a67(%rip), %r15      # 0xc1e0
xorl %ebx, %ebx
movabsq $0x7f7f7f7f7f7f7f7f, %r12 # imm = 0x7F7F7F7F7F7F7F7F
cmpq $0x40, %rbx
je 0x27f4
xorl %edi, %edi
movl %ebx, %esi
callq 0x7493
movq %rax, %r13
movabsq $0xffffffffffffff, %rax # imm = 0xFFFFFFFFFFFFFF
andq %rax, %r13
pushq $0x2
popq %rdi
movl %ebx, %esi
callq 0x7493
movq %rax, %r14
andq $-0x100, %r14
orq %r13, %r14
pushq $0x3
popq %rdi
movl %ebx, %esi
callq 0x7493
movq %rax, %r13
movabsq $-0x101010101010102, %rax # imm = 0xFEFEFEFEFEFEFEFE
andq %rax, %r13
pushq $0x1
popq %rdi
movl %ebx, %esi
callq 0x7493
andq %r12, %rax
orq %r13, %rax
orq %r14, %rax
movq %rax, (%r15)
incq %rbx
addq $0x8, %r15
jmp 0x2785
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initBishopMasks()
void Attacks::initBishopMasks()
{
    for (int i = 0; i <= 63; i++)
    {
        bishopMasks[i] =   (Rays::getRay(NORTH_EAST, i) | Rays::getRay(NORTH_WEST, i)  |
                            Rays::getRay(SOUTH_EAST, i) | Rays::getRay(SOUTH_WEST, i)) &
                            ~(file_bb[FILE_H] | file_bb[FILE_A] | rank_bb[RANK_1] | rank_bb[RANK_8]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x9bc8(%rip), %r12      # 0xc3e0
xorl %ebx, %ebx
movabsq $0x7e7e7e7e7e7e00, %r13 # imm = 0x7E7E7E7E7E7E00
cmpq $0x40, %rbx
je 0x2874
pushq $0x4
popq %rdi
movl %ebx, %esi
callq 0x7493
movq %rax, %r14
pushq $0x5
popq %rdi
movl %ebx, %esi
callq 0x7493
movq %rax, %r15
orq %r14, %r15
pushq $0x6
popq %rdi
movl %ebx, %esi
callq 0x7493
movq %rax, %r14
pushq $0x7
popq %rdi
movl %ebx, %esi
callq 0x7493
orq %r14, %rax
orq %r15, %rax
andq %r13, %rax
movq %rax, (%r12)
incq %rbx
addq $0x8, %r12
jmp 0x2824
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initRookMagics()
void Attacks::initRookMagics()
{
    for(int sq = 0; sq <= 63; sq++)
    {
        for(int i = 0; i < (1 << countBits(Attacks::rookMasks[sq])); i++)
        {
            U64 blockers = Attacks::genBlockers(i, Attacks::rookMasks[sq]);

            Attacks::rookTable[sq][(blockers * Attacks::rookMagics[sq]) >> (64 - countBits(Attacks::rookMasks[sq]))] = Attacks::getRookAttacksRays(sq, blockers);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x9946(%rip), %r13      # 0xc1e0
cmpq $0x40, %rbx
je 0x291a
xorl %r14d, %r14d
movq %rbx, %rcx
shlq $0xf, %rcx
leaq 0x9d2f(%rip), %rax      # 0xc5e0
addq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq (%r13,%rbx,8), %rdi
callq 0x7544
pushq $0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
cmpl %edx, %r14d
jge 0x2915
movq (%r13,%rbx,8), %rsi
movl %r14d, %edi
callq 0x2bc7
movq %rax, %r15
movl %ebx, %edi
movq %rax, %rsi
callq 0x2c05
movq %rax, %r12
leaq 0x583e(%rip), %rax      # 0x8130
imulq (%rax,%rbx,8), %r15
movq (%r13,%rbx,8), %rdi
callq 0x7544
negb %al
movl %eax, %ecx
shrq %cl, %r15
movq -0x30(%rbp), %rax
movq %r12, (%rax,%r15,8)
incl %r14d
jmp 0x28b8
incq %rbx
jmp 0x289a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initBishopMagics()
void Attacks::initBishopMagics()
{
    for(int sq = 0; sq <= 63; sq++)
    {
        for(int i = 0; i < (1 << countBits(Attacks::bishopMasks[sq])); i++)
        {
            U64 blockers = Attacks::genBlockers(i, Attacks::bishopMasks[sq]);

            Attacks::bishopTable[sq][(blockers * Attacks::bishopMagics[sq]) >> (64 - countBits(Attacks::bishopMasks[sq]))] = Attacks::getBishopAttacksRays(sq, blockers);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x9aa0(%rip), %r13      # 0xc3e0
cmpq $0x40, %rbx
je 0x29c0
xorl %r14d, %r14d
movq %rbx, %rcx
shlq $0xd, %rcx
leaq 0x209c89(%rip), %rax    # 0x20c5e0
addq %rax, %rcx
movq %rcx, -0x30(%rbp)
movq (%r13,%rbx,8), %rdi
callq 0x7544
pushq $0x1
popq %rdx
movl %eax, %ecx
shll %cl, %edx
cmpl %edx, %r14d
jge 0x29bb
movq (%r13,%rbx,8), %rsi
movl %r14d, %edi
callq 0x2bc7
movq %rax, %r15
movl %ebx, %edi
movq %rax, %rsi
callq 0x2cde
movq %rax, %r12
leaq 0x5998(%rip), %rax      # 0x8330
imulq (%rax,%rbx,8), %r15
movq (%r13,%rbx,8), %rdi
callq 0x7544
negb %al
movl %eax, %ecx
shrq %cl, %r15
movq -0x30(%rbp), %rax
movq %r12, (%rax,%r15,8)
incl %r14d
jmp 0x295e
incq %rbx
jmp 0x2940
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initPawnAttacks()
void Attacks::initPawnAttacks()
{
    for (int i = 0; i <= 63; i++)
    {
        U64 pos = (U64)1 << i;

        U64 wpAttacks = ((pos << 9) & ~file_bb[FILE_A]) | ((pos << 7) & ~file_bb[FILE_H]);  //White pawn attacks, checking for no wraparound
        U64 bpAttacks = ((pos >> 7) & ~file_bb[FILE_A]) | ((pos >> 9) & ~file_bb[FILE_H]);  //Black pawn attacks, checking for no wraparound

        nonSlidingAttacks[WHITE][PAWN][i] = wpAttacks;
        nonSlidingAttacks[BLACK][PAWN][i] = bpAttacks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
xorl %ecx, %ecx
movabsq $0x1, %rax
movabsq $-0x101010101010200, %rdx # imm = 0xFEFEFEFEFEFEFE00
movabsq $0x7f7f7f7f7f7f7f00, %rsi # imm = 0x7F7F7F7F7F7F7F00
movabsq $0xfefefefefefefe, %rdi # imm = 0xFEFEFEFEFEFEFE
movabsq $0x7f7f7f7f7f7f7f, %r8  # imm = 0x7F7F7F7F7F7F7F
leaq 0x289bd1(%rip), %r9     # 0x28c5e0
cmpq $0x40, %rcx
je 0x2a5a
movq %rax, %r10
shlq %cl, %r10
movl $0x200, %r11d           # imm = 0x200
shlq %cl, %r11
movl $0x80, %ebx
shlq %cl, %rbx
andq %rdx, %r11
andq %rsi, %rbx
orq %r11, %rbx
movq %r10, %r11
shrq $0x7, %r11
andq %rdi, %r11
shrq $0x9, %r10
andq %r8, %r10
orq %r11, %r10
movq %rbx, 0xc00(%r9,%rcx,8)
movq %r10, (%r9,%rcx,8)
incq %rcx
jmp 0x2a0f
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initKnightAttacks()
void Attacks::initKnightAttacks()
{
    for (int i = 0; i <= 63; i++)
    {
        U64 pos = (U64)1 << i;

        U64 kAttacks =  (((pos >> 6) | (pos << 10)) & ~(file_bb[FILE_B] | file_bb[FILE_A])) |   //Knight moves two to the left
                        (((pos << 6) | (pos >> 10)) & ~(file_bb[FILE_H] | file_bb[FILE_G])) |   //Knight moves two to the right
                        (((pos >> 15) | (pos << 17)) & ~(file_bb[FILE_A])) |                    //Knight moves one to the left
                        (((pos << 15) | (pos >> 17)) & ~(file_bb[FILE_H]));                     //Knight moves one to the right

        nonSlidingAttacks[WHITE][KNIGHT][i] = kAttacks;
        nonSlidingAttacks[BLACK][KNIGHT][i] = kAttacks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
xorl %ecx, %ecx
movabsq $0x1, %rax
movabsq $-0x303030303030304, %rdx # imm = 0xFCFCFCFCFCFCFCFC
movabsq $0x40, %rsi
movabsq $0x3f3f3f3f3f3f3f3f, %rdi # imm = 0x3F3F3F3F3F3F3F3F
movabsq $-0x101010101010102, %r8 # imm = 0xFEFEFEFEFEFEFEFE
movabsq $0x7f7f7f7f7f7f7f7f, %r9 # imm = 0x7F7F7F7F7F7F7F7F
leaq 0x289b35(%rip), %r10    # 0x28c5e0
cmpq $0x40, %rcx
je 0x2b27
movq %rax, %r11
shlq %cl, %r11
movl $0x400, %r14d           # imm = 0x400
shlq %cl, %r14
movq %r11, %rbx
shrq $0x6, %rbx
orq %rbx, %r14
movq %rsi, %r15
shlq %cl, %r15
andq %rdx, %r14
movq %r11, %rbx
shrq $0xa, %rbx
orq %r15, %rbx
andq %rdi, %rbx
orq %r14, %rbx
movq %r11, %r14
movl $0x20000, %r15d         # imm = 0x20000
shlq %cl, %r15
shrq $0xf, %r14
orq %r14, %r15
andq %r8, %r15
movl $0x8000, %r14d          # imm = 0x8000
shlq %cl, %r14
shrq $0x11, %r11
orq %r14, %r11
andq %r9, %r11
orq %r15, %r11
orq %rbx, %r11
movq %r11, 0xe00(%r10,%rcx,8)
movq %r11, 0x200(%r10,%rcx,8)
incq %rcx
jmp 0x2aab
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::initKingAttacks()
void Attacks::initKingAttacks()
{
    for (int i = 0; i <= 63; i++)
    {
        U64 pos = (U64)1 << i;

        U64 kAttacks =  ((pos << 7) | (pos >> 1) | (pos >> 9)) & ~file_bb[FILE_H] | //King moves to the right
                        ((pos >> 7) | (pos << 1) | (pos << 9)) & ~file_bb[FILE_A] | //King moves to the left
                        ((pos >> 8) | (pos << 8));                                  //King moves up and down | easy, no bounds checking :^)

        nonSlidingAttacks[WHITE][KING][i] = kAttacks;
        nonSlidingAttacks[BLACK][KING][i] = kAttacks;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
movabsq $0x1, %rax
movabsq $0x7f7f7f7f7f7f7f7f, %rdx # imm = 0x7F7F7F7F7F7F7F7F
movabsq $-0x101010101010102, %rsi # imm = 0xFEFEFEFEFEFEFEFE
leaq 0x289a87(%rip), %rdi    # 0x28c5e0
cmpq $0x40, %rcx
je 0x2bc5
movq %rax, %r8
shlq %cl, %r8
movl $0x80, %r9d
shlq %cl, %r9
movq %r8, %r10
shrq %r10
orq %r9, %r10
movq %r8, %r9
shrq $0x9, %r9
orq %r10, %r9
andq %rdx, %r9
movl $0x202, %r10d           # imm = 0x202
shlq %cl, %r10
movq %r8, %r11
shrq $0x7, %r11
orq %r11, %r10
movl $0x100, %r11d           # imm = 0x100
shlq %cl, %r11
andq %rsi, %r10
shrq $0x8, %r8
orq %r8, %r11
orq %r10, %r11
orq %r9, %r11
movq %r11, 0x1600(%rdi,%rcx,8)
movq %r11, 0xa00(%rdi,%rcx,8)
incq %rcx
jmp 0x2b59
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::genBlockers(int, unsigned long long)
U64 Attacks::genBlockers(int index, U64 mask)
{
    U64 blockerBoard = (U64)0;

    int bitIndex = 0;
    for(int i = 0; i <= 63; i++)
    {
        if(mask & (U64)1 << i)
        {
            if(index & (1 << bitIndex))
            {
                blockerBoard |= ((U64)1 << i);
            }

            bitIndex++;
        }
    }

    return blockerBoard;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %edx, %edx
movabsq $0x1, %r8
xorl %ecx, %ecx
xorl %eax, %eax
xorl %r9d, %r9d
cmpq $0x40, %rcx
je 0x2c03
movq %r8, %r10
shlq %cl, %r10
btq %rcx, %rsi
jae 0x2bfe
btl %r9d, %edi
cmovaeq %rdx, %r10
orq %r10, %rax
incl %r9d
incq %rcx
jmp 0x2bde
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/niekh1234[P]nnchesslib/attacks.cpp
// Function: nnchesslib::Attacks::getRookAttacksRays(int, unsigned long long)
U64 Attacks::getRookAttacksRays(int sq, U64 blockers)
{
    U64 combinedAttacks = (U64)0;

    // north attacks
    U64 rookAttacksNorth = Rays::getRay(NORTH, sq);
    U64 northBlocker = rookAttacksNorth & blockers;
    if(blockers)
    {
        int index = bitScanForward(northBlocker);
        rookAttacksNorth ^= Rays::getRay(NORTH, index);
    }
    combinedAttacks |= rookAttacksNorth;

    // south attacks
    U64 rookAttacksSouth = Rays::getRay(SOUTH, sq);
    U64 southBlocker = rookAttacksSouth & blockers;
    if(blockers)
    {
        int index = bitScanReverse(southBlocker);
        rookAttacksSouth ^= Rays::getRay(SOUTH, index);
    }
    combinedAttacks |= rookAttacksSouth;

    // east attacks
    U64 rookAttacksEast = Rays::getRay(EAST, sq);
    U64 eastBlocker = rookAttacksEast & blockers;
    if(blockers)
    {
        int index = bitScanForward(eastBlocker);
        rookAttacksEast ^= Rays::getRay(EAST, index);
    }
    combinedAttacks |= rookAttacksEast;

    // west attacks
    U64 rookAttacksWest = Rays::getRay(WEST, sq);
    U64 westBlocker = rookAttacksWest & blockers;
    if(blockers)
    {
        int index = bitScanReverse(westBlocker);
        rookAttacksWest ^= Rays::getRay(WEST, index);
    }
    combinedAttacks |= rookAttacksWest;

    return combinedAttacks;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movl %edi, %r15d
xorl %edi, %edi
movl %r15d, %esi
callq 0x7493
movq %rax, %rbx
testq %r14, %r14
je 0x2c42
movq %rbx, %rdi
andq %r14, %rdi
callq 0x755c
xorl %edi, %edi
movl %eax, %esi
callq 0x7493
xorq %rax, %rbx
pushq $0x2
popq %rdi
movl %r15d, %esi
callq 0x7493
movq %rax, %r12
testq %r14, %r14
je 0x2c6d
movq %r12, %rdi
andq %r14, %rdi
callq 0x7570
pushq $0x2
popq %rdi
movl %eax, %esi
callq 0x7493
xorq %rax, %r12
pushq $0x1
popq %rdi
movl %r15d, %esi
callq 0x7493
movq %rax, %r13
testq %r14, %r14
je 0x2c98
movq %r13, %rdi
andq %r14, %rdi
callq 0x755c
pushq $0x1
popq %rdi
movl %eax, %esi
callq 0x7493
xorq %rax, %r13
pushq $0x3
popq %rdi
movl %r15d, %esi
callq 0x7493
movq %rax, %r15
testq %r14, %r14
je 0x2cc3
andq %r15, %r14
movq %r14, %rdi
callq 0x7570
pushq $0x3
popq %rdi
movl %eax, %esi
callq 0x7493
xorq %rax, %r15
orq %r15, %r13
orq %rbx, %r12
orq %r13, %r12
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq