LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chulchultrain[P]FactoryHead/WorkingStats/WorkingStats.cpp
// Function: CalcWorkingStats(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>>, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> CalcWorkingStats(const vector<int> &bs, vector<int> EV, int IV, string nature) {
	vector<int> stats(6);
	if(!mapsInitialized) {
		initializeWorkingStatsMaps();
		mapsInitialized = true;
	}
	//stats.resize(6);
	stats[0] = CalcHP(bs[0],EV[0],IV,100);
	for(unsigned i = 1; i < 6; i++) {
		stats[i] = CalcNonHP(i,bs[i],EV[i],IV,100,nature);
	}	
	return stats;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movq %r8, -0x88(%rbp)
movq %rdx, -0x80(%rbp)
movq %rdi, -0x70(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
leaq -0x2a(%rbp), %rdi
movq %rdi, -0x68(%rbp)
callq 0x70a0
movq -0x70(%rbp), %rdi
movq -0x68(%rbp), %rdx
movl $0x6, %esi
callq 0x70c0
jmp 0x203c9
leaq -0x2a(%rbp), %rdi
callq 0x7130
testb $0x1, 0x27357(%rip)     # 0x47730
jne 0x20416
callq 0x20580
jmp 0x203e2
movb $0x1, 0x27347(%rip)     # 0x47730
jmp 0x20416
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x2a(%rbp), %rdi
callq 0x7130
jmp 0x2056e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x20565
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0x98(%rbp)
callq 0x80f0
movq -0x80(%rbp), %rdi
movq -0x98(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x90(%rbp)
callq 0x7150
movl -0x90(%rbp), %edi
movl (%rax), %esi
movl -0x1c(%rbp), %edx
movl $0x64, %ecx
callq 0x205b0
movl %eax, -0x8c(%rbp)
jmp 0x2045f
movq -0x70(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x7150
movl -0x8c(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, -0x40(%rbp)
cmpl $0x6, -0x40(%rbp)
jae 0x20545
movl -0x40(%rbp), %eax
movl %eax, -0xa8(%rbp)
movq -0x10(%rbp), %rdi
movl %eax, %esi
callq 0x80f0
movq -0x80(%rbp), %rdi
movl (%rax), %eax
movl %eax, -0xa4(%rbp)
movl -0x40(%rbp), %eax
movl %eax, %esi
callq 0x7150
movq -0x88(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0xa0(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x9c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3100
jmp 0x204d2
movl -0x9c(%rbp), %ecx
movl -0xa0(%rbp), %edx
movl -0xa4(%rbp), %esi
movl -0xa8(%rbp), %edi
movl $0x64, %r8d
leaq -0x60(%rbp), %r9
callq 0x20610
movl %eax, -0xac(%rbp)
jmp 0x20501
movq -0x70(%rbp), %rdi
movl -0x40(%rbp), %eax
movl %eax, %esi
callq 0x7150
movl -0xac(%rbp), %ecx
movl %ecx, (%rax)
leaq -0x60(%rbp), %rdi
callq 0x3180
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x2047b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3180
jmp 0x20565
movb $0x1, -0x29(%rbp)
testb $0x1, -0x29(%rbp)
jne 0x20558
movq -0x70(%rbp), %rdi
callq 0x74a0
movq -0x78(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0x70(%rbp), %rdi
callq 0x74a0
movq -0x38(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: chulchultrain[P]FactoryHead/WorkingStats/WorkingStats.cpp
// Function: CalcHP(int, int, int, int)
int CalcHP(int base, int EV, int IV,int level) {
	int res = 2 * base + IV + EV / 4;
	res *= level;
	res /= 100;
	res += (level + 10);
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl -0x4(%rbp), %eax
shll %eax
addl -0xc(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x8(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x18(%rbp), %eax
addl %ecx, %eax
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
imull -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl $0x64, %ecx
cltd
idivl %ecx
movl %eax, -0x14(%rbp)
movl -0x10(%rbp), %eax
addl $0xa, %eax
addl -0x14(%rbp), %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: chulchultrain[P]FactoryHead/WorkingStats/WorkingStats.cpp
// Function: CalcNonHP(int, int, int, int, int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int CalcNonHP(int which, int base, int EV, int IV, int level,string nature) {
	int res = 2 * base + IV + EV / 4;
	res *= level;
	res /= 100;
	res += 5;
	double natureMultiplier = CalcNatureMultiplier(which,nature);
	res = int( double(res) * natureMultiplier);
	return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %r9, -0x80(%rbp)
movl %esi, %eax
movq -0x80(%rbp), %rsi
movl %edi, -0x4(%rbp)
movl %eax, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movl %r8d, -0x14(%rbp)
movq %rsi, -0x20(%rbp)
movl -0x8(%rbp), %eax
movl -0x10(%rbp), %edx
movl %eax, %ecx
movl %edx, %eax
leal (%rax,%rcx,2), %eax
movl -0xc(%rbp), %ecx
movl %ecx, %edx
addl $0x3, %edx
testl %ecx, %ecx
cmovsl %edx, %ecx
sarl $0x2, %ecx
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x14(%rbp), %ecx
movl -0x24(%rbp), %eax
imull %ecx, %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rax
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x25, %rax
addl %ecx, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $0x5, %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3100
movl -0x74(%rbp), %edi
movq -0x70(%rbp), %rsi
callq 0x20f70
movsd %xmm0, -0x68(%rbp)
jmp 0x206b1
leaq -0x50(%rbp), %rdi
callq 0x3180
movsd -0x68(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
cvtsi2sdl -0x24(%rbp), %xmm0
mulsd -0x30(%rbp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x3180
movq -0x58(%rbp), %rdi
callq 0x3410
nop
// File: chulchultrain[P]FactoryHead/WorkingStats/WorkingStats.cpp
// Function: CalculateEVs(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
vector<int> CalculateEVs(const vector<int> &ws, const vector<int> &bs, string nature) {
//	cout << natureMul[nature][5] << endl;
	if(!mapsInitialized) {
		initializeWorkingStatsMaps();
		mapsInitialized = true;
	}

	int iv = CalculateIVs(ws, bs,nature);
	//cout << iv << endl;
	if(iv == -1)
		return vector<int>(6,-1);
	return CalculateEVs(ws, bs,iv,nature);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rcx, -0x98(%rbp)
movq %rdi, -0x90(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
testb $0x1, 0x26ff6(%rip)     # 0x47730
jne 0x20748
callq 0x20580
movb $0x1, 0x26fe8(%rip)     # 0x47730
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xb0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3100
movq -0xb8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
callq 0x208c0
movl %eax, -0x9c(%rbp)
jmp 0x20797
leaq -0x48(%rbp), %rdi
callq 0x3180
movl -0x9c(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $-0x1, -0x24(%rbp)
jne 0x20826
movl $0xffffffff, -0x58(%rbp) # imm = 0xFFFFFFFF
leaq -0x59(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
callq 0x70a0
movq -0x90(%rbp), %rdi
movq -0xc0(%rbp), %rcx
movl $0x6, %esi
leaq -0x58(%rbp), %rdx
callq 0x78d0
jmp 0x207e4
leaq -0x59(%rbp), %rdi
callq 0x7130
jmp 0x208a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x208b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x59(%rbp), %rdi
callq 0x7130
jmp 0x208b7
movq -0x98(%rbp), %rsi
movq -0x10(%rbp), %rax
movq %rax, -0xe0(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0xcc(%rbp)
leaq -0x80(%rbp), %rdi
movq %rdi, -0xc8(%rbp)
callq 0x3100
movq -0x90(%rbp), %rdi
movq -0xe0(%rbp), %rsi
movq -0xd8(%rbp), %rdx
movl -0xcc(%rbp), %ecx
movq -0xc8(%rbp), %r8
callq 0x20a10
jmp 0x20885
leaq -0x80(%rbp), %rdi
callq 0x3180
jmp 0x208a7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3180
jmp 0x208b7
movq -0x88(%rbp), %rax
addq $0xe0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
// File: chulchultrain[P]FactoryHead/WorkingStats/WorkingStats.cpp
// Function: CalculateIVs(std::vector<int, std::allocator<int>> const&, std::vector<int, std::allocator<int>> const&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int  CalculateIVs(const vector<int> &ws, const vector<int> &bs,string nature) {
	for(int i = 0; i <= 31; i++) {
		if( CalcHP(bs[0],0,i,100) == ws[0]) {
		//	cout << "HP FAIL\n";
			return i;
		}
		for(int j = 1; j < 6; j++) {
			if(CalcNonHP(j,bs[j],0,i,100,nature) == ws[j]) {
			//	cout << j << " FAIL\n";
				return i;
			}
		} 

	}
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdx, -0x60(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
cmpl $0x1f, -0x24(%rbp)
jg 0x209f1
movq -0x18(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x80f0
movl (%rax), %edi
movl -0x24(%rbp), %edx
xorl %esi, %esi
movl $0x64, %ecx
callq 0x205b0
movl %eax, -0x64(%rbp)
movq -0x10(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x80f0
movq %rax, %rcx
movl -0x64(%rbp), %eax
cmpl (%rcx), %eax
jne 0x2092f
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x209f8
movl $0x1, -0x28(%rbp)
cmpl $0x6, -0x28(%rbp)
jge 0x209e1
movl -0x28(%rbp), %eax
movl %eax, -0x7c(%rbp)
movq -0x18(%rbp), %rdi
movslq %eax, %rsi
callq 0x80f0
movq -0x60(%rbp), %rsi
movl (%rax), %eax
movl %eax, -0x78(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x74(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3100
movl -0x7c(%rbp), %edi
movl -0x78(%rbp), %esi
movl -0x74(%rbp), %ecx
movq -0x70(%rbp), %r9
xorl %edx, %edx
movl $0x64, %r8d
callq 0x20610
movl %eax, -0x68(%rbp)
jmp 0x2098d
movq -0x10(%rbp), %rdi
movslq -0x28(%rbp), %rsi
callq 0x80f0
movl (%rax), %eax
movl %eax, -0x80(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
movl -0x80(%rbp), %ecx
movl -0x68(%rbp), %eax
cmpl %ecx, %eax
jne 0x209d1
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x209f8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x3180
jmp 0x20a04
jmp 0x209d3
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x20936
jmp 0x209e3
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x208e2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x80, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: chulchultrain[P]FactoryHead/WorkingStats/WorkingStats.cpp
// Function: CalcNatureMultiplier(int, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double CalcNatureMultiplier(int which, string nature) {
	int code = natureMul[nature][which];
	switch(code) {
		case -1: return .9;
		case 1: return 1.1;
		default: return 1;
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
leaq 0x2677a(%rip), %rdi     # 0x47700
callq 0x7c10
movq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0x7cf0
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
subl $-0x1, %eax
je 0x20fb3
jmp 0x20fa9
movl -0x20(%rbp), %eax
subl $0x1, %eax
je 0x20fc2
jmp 0x20fd1
movsd 0xe23d(%rip), %xmm0     # 0x2f1f8
movsd %xmm0, -0x8(%rbp)
jmp 0x20fde
movsd 0xe226(%rip), %xmm0     # 0x2f1f0
movsd %xmm0, -0x8(%rbp)
jmp 0x20fde
movsd 0xe1b7(%rip), %xmm0     # 0x2f190
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: chulchultrain[P]FactoryHead/EntryFilter/EntryFilter.cpp
// Function: MergeVectors(std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>&, std::vector<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>, std::allocator<std::vector<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>&)
void MergeVectors(vector<string> &res, vector<vector<string> > &temp) {
	map<string, unsigned int> rMap;
	for(unsigned int i = 0; i < temp.size(); i++)
		for(unsigned int j = 0; j < temp[i].size(); j++)
			rMap[temp[i][j]]++;
	res.clear();
	for( map<string,unsigned int>::iterator it = rMap.begin(); it != rMap.end(); it++)
		if( it->second == temp.size())
			res.push_back(it->first);

	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21d80
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq %rax, -0x78(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21da0
movq %rax, %rcx
movq -0x78(%rbp), %rax
cmpq %rcx, %rax
jae 0x21876
movl $0x0, -0x48(%rbp)
movl -0x48(%rbp), %eax
movq %rax, -0x80(%rbp)
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x21dd0
movq %rax, %rdi
callq 0x6bf0
movq %rax, %rcx
movq -0x80(%rbp), %rax
cmpq %rcx, %rax
jae 0x21866
movq -0x10(%rbp), %rdi
movl -0x44(%rbp), %eax
movl %eax, %esi
callq 0x21dd0
movq %rax, %rdi
movl -0x48(%rbp), %eax
movl %eax, %esi
callq 0x6c10
movq %rax, %rsi
leaq -0x40(%rbp), %rdi
callq 0x21df0
movq %rax, -0x88(%rbp)
jmp 0x21833
movq -0x88(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x217da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21fe0
jmp 0x21926
jmp 0x21868
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x217b3
movq -0x8(%rbp), %rdi
callq 0x21ed0
leaq -0x40(%rbp), %rdi
callq 0x21ef0
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x21f50
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x21f20
testb $0x1, %al
jne 0x218ac
jmp 0x21914
leaq -0x60(%rbp), %rdi
callq 0x21f80
movl 0x20(%rax), %eax
movq %rax, -0x90(%rbp)
movq -0x10(%rbp), %rdi
callq 0x21da0
movq %rax, %rcx
movq -0x90(%rbp), %rax
cmpq %rcx, %rax
jne 0x218fe
movq -0x8(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x21f80
movq -0x98(%rbp), %rdi
movq %rax, %rsi
callq 0x6b50
jmp 0x218fc
jmp 0x218fe
jmp 0x21900
leaq -0x60(%rbp), %rdi
xorl %esi, %esi
callq 0x21fa0
movq %rax, -0x70(%rbp)
jmp 0x2188c
leaq -0x40(%rbp), %rdi
callq 0x21fe0
addq $0xa0, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nop
// File: chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::SetCriteria(std::ostream&, std::istream&)
void BattleSim::SetCriteria(ostream &pout, istream &fin) {
	//TODO: FIX MAGIC NUMBER of 2
	string whichEntry;
	int whichEntryInt;

	pout << "Enter Which Entry To Modify\n";
	getline(fin,whichEntry);
	whichEntryInt = StringToIntHelper(whichEntry);
	if(whichEntryInt >= 0 && whichEntryInt < be.size() ) {
		SetCriterion(pout,fin,whichEntryInt);
	} else {
		pout << "Invalid Choice\n"; //TODO: TELL SIZE?
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xad86(%rip), %rsi      # 0x2f476
callq 0x3220
jmp 0x246f7
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3080
jmp 0x24706
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x5c(%rbp)
jmp 0x24718
movl -0x5c(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
jl 0x24771
movq -0x58(%rbp), %rdi
movl -0x3c(%rbp), %eax
movl %eax, -0x64(%rbp)
callq 0x270b0
movl %eax, -0x60(%rbp)
jmp 0x24738
movl -0x64(%rbp), %eax
movl -0x60(%rbp), %ecx
cmpl %ecx, %eax
jge 0x24771
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x252e0
jmp 0x24758
jmp 0x24785
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x24794
movq -0x10(%rbp), %rdi
leaq 0xabe2(%rip), %rsi      # 0x2f35e
callq 0x3220
jmp 0x24783
jmp 0x24785
leaq -0x38(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xacf5(%rip), %rsi      # 0x2f4c5
callq 0x3220
jmp 0x247d7
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3080
jmp 0x247e6
movq -0x50(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x54(%rbp)
jmp 0x247f8
movl -0x54(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0x2480a
cmpl $0x1, -0x48(%rbp)
jne 0x24835
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x48(%rbp), %edx
callq 0x25510
jmp 0x2481c
jmp 0x24849
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x24858
movq -0x10(%rbp), %rdi
leaq 0xaca9(%rip), %rsi      # 0x2f4e9
callq 0x3220
jmp 0x24847
jmp 0x24849
leaq -0x38(%rbp), %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xac89(%rip), %rsi      # 0x2f529
callq 0x3220
jmp 0x248a7
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3080
jmp 0x248b6
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x5c(%rbp)
jmp 0x248c8
movl -0x5c(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x248da
cmpl $0x1, -0x3c(%rbp)
jne 0x24909
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x3c(%rbp), %ecx
callq 0x25630
jmp 0x248f0
jmp 0x2491d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x2492c
movq -0x10(%rbp), %rdi
leaq 0xac35(%rip), %rsi      # 0x2f549
callq 0x3220
jmp 0x2491b
jmp 0x2491d
leaq -0x38(%rbp), %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xab2c(%rip), %rsi      # 0x2f493
callq 0x3220
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x3360
movq -0x50(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x3080
jmp 0x24988
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x5c(%rbp)
jmp 0x2499a
movl -0x5c(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x48(%rbp)
je 0x249ac
cmpl $0x1, -0x48(%rbp)
jne 0x249d7
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x48(%rbp), %edx
callq 0x25480
jmp 0x249be
jmp 0x249eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x249fa
movq -0x10(%rbp), %rdi
leaq 0xaad2(%rip), %rsi      # 0x2f4b4
callq 0x3220
jmp 0x249e9
jmp 0x249eb
leaq -0x38(%rbp), %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xaab9(%rip), %rsi      # 0x2f4f9
callq 0x3220
jmp 0x24a47
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3080
jmp 0x24a56
movq -0x58(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x5c(%rbp)
jmp 0x24a68
movl -0x5c(%rbp), %eax
movl %eax, -0x3c(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x24a7a
cmpl $0x1, -0x3c(%rbp)
jne 0x24aa5
movq -0x58(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x3c(%rbp), %edx
callq 0x25540
jmp 0x24a8c
jmp 0x24ab9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x24ac8
movq -0x10(%rbp), %rdi
leaq 0xaa04(%rip), %rsi      # 0x2f4b4
callq 0x3220
jmp 0x24ab7
jmp 0x24ab9
leaq -0x38(%rbp), %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3360
movl $0x0, -0x34(%rbp)
cmpl $0x2, -0x34(%rbp)
jae 0x24b67
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %esi
leaq -0x30(%rbp), %rdx
callq 0x26da0
jmp 0x24b20
movq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3210
movq %rax, -0x58(%rbp)
jmp 0x24b33
movq -0x58(%rbp), %rdi
movl $0xa, %esi
callq 0x32d0
jmp 0x24b43
jmp 0x24b45
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x24b08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x3180
jmp 0x24b86
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x32d0
jmp 0x24b77
leaq -0x30(%rbp), %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3410
nop
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xa9bb(%rip), %rsi      # 0x2f57f
callq 0x3220
jmp 0x24bcb
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x24bda
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x64(%rbp)
jmp 0x24bec
movl -0x64(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa9a2(%rip), %rsi      # 0x2f59f
callq 0x3220
jmp 0x24c04
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x24c13
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x68(%rbp)
jmp 0x24c25
movl -0x68(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x24c7e
cmpl $0x1, -0x44(%rbp)
jg 0x24c7e
cmpl $0x0, -0x48(%rbp)
jl 0x24c7e
cmpl $0x1, -0x48(%rbp)
jg 0x24c7e
movq -0x60(%rbp), %rdi
movl -0x44(%rbp), %esi
movl -0x48(%rbp), %edx
callq 0x26e10
jmp 0x24c54
movq -0x60(%rbp), %rdi
movl -0x48(%rbp), %esi
movl -0x44(%rbp), %edx
callq 0x26e10
jmp 0x24c65
jmp 0x24c92
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x24ca1
movq -0x10(%rbp), %rdi
leaq 0xa937(%rip), %rsi      # 0x2f5c0
callq 0x3220
jmp 0x24c90
jmp 0x24c92
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xa89b(%rip), %rsi      # 0x2f57f
callq 0x3220
jmp 0x24ceb
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x24cfa
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x64(%rbp)
jmp 0x24d0c
movl -0x64(%rbp), %eax
movl %eax, -0x44(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa882(%rip), %rsi      # 0x2f59f
callq 0x3220
jmp 0x24d24
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x24d33
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x68(%rbp)
jmp 0x24d45
movl -0x68(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x44(%rbp)
jl 0x24d96
cmpl $0x1, -0x44(%rbp)
jg 0x24d96
cmpl $0x0, -0x48(%rbp)
jl 0x24d96
cmpl $0x1, -0x48(%rbp)
jg 0x24d96
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl -0x44(%rbp), %ecx
movl -0x48(%rbp), %r8d
callq 0x25710
jmp 0x24d7d
jmp 0x24daa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x24db9
movq -0x10(%rbp), %rdi
leaq 0xa81f(%rip), %rsi      # 0x2f5c0
callq 0x3220
jmp 0x24da8
jmp 0x24daa
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xa568(%rip), %rsi      # 0x2f36e
callq 0x3220
jmp 0x24e0d
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x24e1c
movq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3100
jmp 0x24e3c
movl -0x7c(%rbp), %esi
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x26110
jmp 0x24e51
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x24e8f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movq -0x10(%rbp), %rdi
leaq 0xa49d(%rip), %rsi      # 0x2f37a
callq 0x3220
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x3080
jmp 0x24efe
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x64(%rbp)
jmp 0x24f10
movl -0x64(%rbp), %eax
movl %eax, -0x50(%rbp)
cmpl $0x0, -0x50(%rbp)
jl 0x24f58
cmpl $0x4, -0x50(%rbp)
jge 0x24f58
movq -0x60(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movl -0x50(%rbp), %r8d
callq 0x25070
jmp 0x24f3c
jmp 0x24fc1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x24fd3
movq -0x10(%rbp), %rdi
leaq 0xa445(%rip), %rsi      # 0x2f3a8
callq 0x3220
movq %rax, -0x70(%rbp)
jmp 0x24f6e
movq -0x70(%rbp), %rdi
xorl %esi, %esi
callq 0x3400
movq %rax, -0x78(%rbp)
jmp 0x24f7f
movq -0x78(%rbp), %rdi
leaq 0xa451(%rip), %rsi      # 0x2f3db
callq 0x3220
movq %rax, -0x80(%rbp)
jmp 0x24f95
movq -0x80(%rbp), %rdi
movl $0x4, %esi
callq 0x3400
movq %rax, -0x88(%rbp)
jmp 0x24fac
movq -0x88(%rbp), %rdi
movl $0xa, %esi
callq 0x32d0
jmp 0x24fbf
jmp 0x24fc1
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x90, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x18(%rbp), %rdi
callq 0x31b0
movl %eax, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x25056
imull $0xa, -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x32e0
movsbl (%rax), %eax
subl $0x30, %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
jge 0x25049
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2505c
jmp 0x2504b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x25011
movl -0x24(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xa337(%rip), %rsi      # 0x2f3e1
callq 0x3220
jmp 0x250b1
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x250c0
movq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x80(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3100
jmp 0x250e6
movl -0x7c(%rbp), %edx
movl -0x80(%rbp), %esi
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rcx
callq 0x26210
jmp 0x250fe
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2513c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
movq -0x48(%rbp), %rdi
callq 0x3410
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0xa267(%rip), %rsi      # 0x2f3ed
callq 0x3220
jmp 0x2518d
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x2519c
movq -0x78(%rbp), %rax
movq %rax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x7c(%rbp)
leaq -0x70(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3100
jmp 0x251bc
movl -0x7c(%rbp), %esi
movq -0x88(%rbp), %rdi
leaq -0x70(%rbp), %rdx
callq 0x261b0
jmp 0x251d1
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x2520f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x3180
leaq -0x40(%rbp), %rdi
callq 0x3180
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x58(%rbp), %rsi
movq -0x18(%rbp), %rdi
callq 0x3080
jmp 0x2526b
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x64(%rbp)
jmp 0x2527d
movl -0x64(%rbp), %eax
movl %eax, -0x50(%rbp)
cmpl $-0x1, -0x50(%rbp)
je 0x252b3
movq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x50(%rbp), %edx
callq 0x26290
jmp 0x2529a
jmp 0x252c7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x252d6
movq -0x10(%rbp), %rdi
leaq 0xa13b(%rip), %rsi      # 0x2f3f9
callq 0x3220
jmp 0x252c5
jmp 0x252c7
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nop
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movl $0x0, -0x44(%rbp)
cmpl $0xd, -0x44(%rbp)
je 0x2545a
movq -0x10(%rbp), %rdi
leaq 0xa105(%rip), %rsi      # 0x2f42c
callq 0x3220
jmp 0x2532e
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x2533d
leaq -0x78(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3100
jmp 0x2534c
movq -0x80(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x244c0
movl %eax, -0x84(%rbp)
jmp 0x25361
movl -0x84(%rbp), %eax
movl %eax, -0x44(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3180
movl -0x44(%rbp), %eax
addl $-0x9, %eax
movl %eax, %ecx
movq %rcx, -0x90(%rbp)
subl $0x4, %eax
ja 0x25441
movq -0x90(%rbp), %rax
leaq 0x9f27(%rip), %rcx      # 0x2f2c0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2546c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3180
jmp 0x2546c
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x24dd0
jmp 0x253e3
jmp 0x25455
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x24eb0
jmp 0x253fb
jmp 0x25455
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x25150
jmp 0x25413
jmp 0x25455
movq -0x80(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
callq 0x25230
jmp 0x2542b
jmp 0x25455
movq -0x10(%rbp), %rdi
leaq 0xa02a(%rip), %rsi      # 0x2f462
callq 0x3220
jmp 0x2543f
jmp 0x25455
movq -0x10(%rbp), %rdi
leaq 0x9f12(%rip), %rsi      # 0x2f35e
callq 0x3220
jmp 0x25453
jmp 0x25455
jmp 0x25312
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x90, %rsp
popq %rbp
retq
leaq -0x40(%rbp), %rdi
callq 0x3180
movq -0x50(%rbp), %rdi
callq 0x3410
nop
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x58(%rbp)
movl -0x14(%rbp), %esi
callq 0x26be0
movl %eax, -0x18(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3360
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jge 0x255da
movq -0x58(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x3c(%rbp), %edx
leaq -0x38(%rbp), %rcx
callq 0x26c40
jmp 0x25593
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3210
movq %rax, -0x60(%rbp)
jmp 0x255a6
movq -0x60(%rbp), %rdi
movl $0xa, %esi
callq 0x32d0
jmp 0x255b6
jmp 0x255b8
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x25576
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x255e9
leaq -0x38(%rbp), %rdi
callq 0x3180
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3360
movq -0x10(%rbp), %rdi
leaq 0x9efe(%rip), %rsi      # 0x2f561
callq 0x3220
jmp 0x2566a
movq -0x18(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x3080
jmp 0x25679
movq -0x60(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x24fe0
movl %eax, -0x64(%rbp)
jmp 0x2568b
movq -0x60(%rbp), %rdi
movl -0x64(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x1c(%rbp), %esi
callq 0x26be0
movl %eax, -0x68(%rbp)
jmp 0x256a2
movl -0x68(%rbp), %eax
cmpl -0x44(%rbp), %eax
jle 0x256da
cmpl $0x0, -0x44(%rbp)
jl 0x256da
movq -0x60(%rbp), %rdi
movl -0x1c(%rbp), %esi
movl -0x44(%rbp), %edx
callq 0x26cf0
jmp 0x256c1
jmp 0x256ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x256fd
movq -0x10(%rbp), %rdi
leaq 0x9c79(%rip), %rsi      # 0x2f35e
callq 0x3220
jmp 0x256ec
jmp 0x256ee
leaq -0x40(%rbp), %rdi
callq 0x3180
addq $0x70, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x25980
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
movl -0x1c(%rbp), %edx
movl -0x20(%rbp), %ecx
callq 0x27060
jmp 0x25755
leaq -0x38(%rbp), %rdi
callq 0x25870
jmp 0x25760
movq -0x58(%rbp), %rdi
movl -0x20(%rbp), %edx
movl -0x1c(%rbp), %ecx
leaq -0x38(%rbp), %rsi
callq 0x27060
jmp 0x25775
leaq -0x38(%rbp), %rdi
callq 0x25870
jmp 0x25780
leaq -0x38(%rbp), %rdi
callq 0x259a0
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x259a0
movq -0x40(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq 0x21811(%rip), %rdi     # 0x46fd8
callq 0x3210
movq %rax, %rdi
leaq 0x9dfb(%rip), %rsi      # 0x2f5d1
callq 0x3220
movq %rax, %rdi
movq -0x8(%rbp), %rsi
addq $0x20, %rsi
callq 0x3210
movq %rax, %rdi
leaq 0x9de1(%rip), %rsi      # 0x2f5d6
callq 0x3220
movq -0x8(%rbp), %rsi
addq $0x40, %rsi
movq 0x217cf(%rip), %rdi     # 0x46fd8
callq 0x3210
movq %rax, %rdi
leaq 0x9dc7(%rip), %rsi      # 0x2f5df
callq 0x3220
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x60(%rax), %esi
callq 0x3400
movq %rax, %rdi
leaq 0x9d9b(%rip), %rsi      # 0x2f5d1
callq 0x3220
movq %rax, %rdi
movq -0x8(%rbp), %rax
movl 0x64(%rax), %esi
callq 0x3400
movq 0x21787(%rip), %rdi     # 0x46fd8
leaq 0x9c6a(%rip), %rsi      # 0x2f4c2
callq 0x3220
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x420, %rsp            # imm = 0x420
movl $0x0, -0x4(%rbp)
leaq -0x200(%rbp), %rdi
callq 0x24280
leaq 0x996f(%rip), %rsi      # 0x2f6b4
leaq -0x408(%rbp), %rdi
movl $0x8, %edx
callq 0x3440
jmp 0x25d58
movq 0x21279(%rip), %rcx     # 0x46fd8
leaq -0x200(%rbp), %rdi
leaq -0x408(%rbp), %rdx
movq %rcx, %rsi
callq 0x242b0
jmp 0x25d77
movl $0x0, -0x4(%rbp)
leaq -0x408(%rbp), %rdi
callq 0x30a0
leaq -0x200(%rbp), %rdi
callq 0x25df0
movl -0x4(%rbp), %eax
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
jmp 0x25dd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x410(%rbp)
movl %eax, -0x414(%rbp)
leaq -0x408(%rbp), %rdi
callq 0x30a0
leaq -0x200(%rbp), %rdi
callq 0x25df0
movq -0x410(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x1a0, %rdi            # imm = 0x1A0
movslq -0xc(%rbp), %rsi
callq 0x27920
movq -0x20(%rbp), %rdi
addq $0x188, %rdi            # imm = 0x188
movslq -0xc(%rbp), %rsi
callq 0x279b0
movq -0x20(%rbp), %rdi
addq $0x1b8, %rdi            # imm = 0x1B8
movslq -0xc(%rbp), %rsi
callq 0x273d0
movq -0x20(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0xc(%rbp), %rsi
callq 0x27a40
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x25fc6
movq -0x20(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0x10(%rbp), %rsi
callq 0x275e0
movq %rax, %rdi
movslq -0xc(%rbp), %rsi
callq 0x27ad0
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x25fb9
movq -0x20(%rbp), %rdi
addq $0x1d0, %rdi            # imm = 0x1D0
movslq -0x10(%rbp), %rsi
callq 0x275e0
movq %rax, %rdi
movslq -0x14(%rbp), %rsi
callq 0x27600
movq %rax, %rdi
movl $0x4, %esi
callq 0x27b60
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x25f79
jmp 0x25fbb
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25f4a
movq -0x20(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0x1e8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)