LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::TypeMultiplierMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, std::less<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>, std::allocator<std::pair<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const, int>>>>>>&)
void MapGenerator::TypeMultiplierMapHelper(map<string, map<string,int> > &m) {
	m.clear();
	ifstream fin(TYPECHARTFILE);
	string atype,dtype;
	int code;
	while(fin >> atype) {
		fin >> dtype;
		fin >> code;
		m[atype][dtype] = code;
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x9b8a
leaq 0xd9ee(%rip), %rsi      # 0x120b8
leaq -0x278(%rbp), %r14
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2300
leaq -0x60(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq -0x70(%rbp), %r15
leaq -0x50(%rbp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4753
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2120
movl -0x2c(%rbp), %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4fbc
movq %rax, %rdi
movq %r12, %rsi
callq 0x5026
movl %r13d, (%rax)
jmp 0x4704
leaq -0x278(%rbp), %rdi
callq 0x2060
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x278(%rbp), %rdi
callq 0x2070
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4791
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
callq 0x20e0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MoveData/MoveData.cpp
// Function: MoveData::MoveData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
MoveData::MoveData(string x1, string x2, string x3, string x4, int x5) {
	ID = x1;
	name = x2;
	type = x3;
	category = x4;
	damage = x5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, -0x40(%rbp)
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r13
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movb %al, 0x70(%rdi)
callq 0x2110
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x2110
movq %r13, %rdi
movq %r14, %rsi
callq 0x2110
movq %r15, %rdi
movq -0x40(%rbp), %rsi
callq 0x2110
movl -0x2c(%rbp), %eax
movl %eax, 0x80(%rbx)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r15, %rdi
callq 0x20e0
movq %r13, %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MoveData/MoveData.cpp
// Function: MoveData::MoveData()
MoveData::MoveData() {
	ID = "";
	name = "";
	type = "";
	category = "";
	damage = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x20(%rdi), %r14
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x50(%rdi), %rcx
movq %rcx, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x70(%rdi), %rcx
movq %rcx, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x834f(%rip), %rsi      # 0x12570
callq 0x2310
leaq 0x8343(%rip), %rsi      # 0x12570
movq %r14, %rdi
callq 0x2310
leaq 0x8334(%rip), %rsi      # 0x12570
movq %r15, %rdi
callq 0x2310
leaq 0x8325(%rip), %rsi      # 0x12570
movq %r12, %rdi
callq 0x2310
andl $0x0, 0x80(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq %r12, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r13, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MoveData/MoveData.cpp
// Function: operator==(MoveData const&, MoveData const&)
bool operator == (const MoveData &lhs, const MoveData &rhs) {
	if(lhs.ID != rhs.ID) {
		//cout << "FAIL HERE\n";
		return false;

	}
	if(lhs.name != rhs.name) {
		//cout << "FAIL HERE 2\n";
		return false;
	}
	if(lhs.type != rhs.type){
		//cout << "FAIL HERE 3\n";
		return false;
	}
	if(lhs.category != rhs.category){
		//cout << "FAIL HERE 4\n";
		return false;
	}
	if(lhs.damage != rhs.damage){
		//cout << "FAIL HERE 5\n";
		return false;
	}
	return true;
//	return lhs.ID == rhs.ID && lhs.name == rhs.name && lhs.type == rhs.type && lhs.category == rhs.category && lhs.damage == rhs.damage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa2f6
testb %al, %al
jne 0xa2dd
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0xa2f6
testb %al, %al
jne 0xa2dd
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0xa2f6
testb %al, %al
jne 0xa2dd
leaq 0x60(%r14), %rdi
leaq 0x60(%rbx), %rsi
callq 0xa2f6
testb %al, %al
je 0xa2e4
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl 0x80(%r14), %eax
cmpl 0x80(%rbx), %eax
sete %al
jmp 0xa2df
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/EntryData/EntryData.cpp
// Function: EntryData::EntryData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, 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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>&)
EntryData::EntryData(string x1, string x2, vector<string> &x3, string x4, string x5, vector<int> &x6) {
	ID = x1;
	DexID = x2;
	moveID = x3;
	item = x4;
	nature = x5;
	EV = x6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r9, -0x48(%rbp)
movq %r8, -0x50(%rbp)
movq %rcx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x40(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movb %al, 0x68(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x78(%rdi), %r15
movb %al, 0x88(%rdi)
leaq 0x98(%rdi), %r12
movups %xmm0, 0x98(%rdi)
andq $0x0, 0xa8(%rdi)
callq 0x2110
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x2110
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x491c
movq -0x30(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x2110
movq %r15, %rdi
movq -0x48(%rbp), %rsi
callq 0x2110
movq 0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x4b16
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %r12, %rdi
callq 0x6248
movq %r15, %rdi
callq 0x20e0
movq -0x30(%rbp), %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x4ed4
movq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/EntryData/EntryData.cpp
// Function: EntryData::EntryData()
EntryData::EntryData() {
	ID = "";
	DexID = "001";
	moveID.resize(4,"");
	nature = "";
	item = "";
	EV.resize(6,0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x40(%rdi), %r15
movb %al, 0x68(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, 0x78(%rdi)
andq $0x0, 0x80(%rdi)
leaq 0x58(%rdi), %r12
leaq 0x78(%rdi), %r13
movb %al, 0x88(%rdi)
leaq 0x98(%rdi), %r14
movups %xmm0, 0x98(%rdi)
andq $0x0, 0xa8(%rdi)
leaq 0x8057(%rip), %rsi      # 0x12570
callq 0x2310
leaq 0x7c21(%rip), %rsi      # 0x12146
movq -0x40(%rbp), %rdi
callq 0x2310
leaq 0x803b(%rip), %rsi      # 0x12570
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x4cd4
pushq $0x4
popq %rsi
leaq -0x60(%rbp), %rdx
movq %r15, %rdi
callq 0xa666
leaq -0x60(%rbp), %rdi
callq 0x20e0
leaq 0x800f(%rip), %rsi      # 0x12570
movq %r13, %rdi
callq 0x2310
leaq 0x8000(%rip), %rsi      # 0x12570
movq %r12, %rdi
callq 0x2310
leaq -0x60(%rbp), %rdx
andl $0x0, (%rdx)
pushq $0x6
popq %rsi
movq %r14, %rdi
callq 0xa6a4
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xa5ac
movq %rax, -0x38(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0xa5b0
jmp 0xa5ac
movq %rax, -0x38(%rbp)
movq %r14, %rdi
callq 0x6248
movq %r13, %rdi
callq 0x20e0
movq %r12, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x4ed4
movq -0x40(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/EntryData/EntryData.cpp
// Function: operator==(EntryData const&, EntryData const&)
bool operator == (const EntryData &lhs, const EntryData &rhs) {
	if(lhs.ID != rhs.ID) {
	//	cout << "FAIL HERE\n";
		return false;

	}
	if(lhs.DexID != rhs.DexID) {
	//	cout << "FAIL HERE2\n";
		return false;
	}	
	if(lhs.moveID != rhs.moveID) {
	///	cout << "FAIL HERE3\n";
		return false;
	}
	if(lhs.nature != rhs.nature) {
	//	cout << "FAIL HERE4\n";
		return false;
	}

	if(lhs.item != rhs.item) {
		return false;
	}	

	if(lhs.EV != rhs.EV) {
	//	cout << "FAIL HERE5\n";
		return false;
	}
	return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa2f6
testb %al, %al
jne 0xa644
leaq 0x20(%r14), %rdi
leaq 0x20(%rbx), %rsi
callq 0xa2f6
testb %al, %al
jne 0xa644
leaq 0x40(%r14), %rdi
leaq 0x40(%rbx), %rsi
callq 0xa6de
testb %al, %al
jne 0xa644
leaq 0x78(%r14), %rdi
leaq 0x78(%rbx), %rsi
callq 0xa2f6
testb %al, %al
jne 0xa644
leaq 0x58(%r14), %rdi
leaq 0x58(%rbx), %rsi
callq 0xa2f6
testb %al, %al
je 0xa64b
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
retq
movl $0x98, %eax
addq %rax, %r14
addq %rax, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa6eb
xorb $0x1, %al
jmp 0xa646
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::PokemonEntry()
PokemonEntry::PokemonEntry() {
	if(!initialized) {
		InitializeMaps();
		initialized = true;
	}
	EntryData ed;
	Construct(ed,0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x60(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
cmpb $0x0, 0x12830(%rip)     # 0x1d5e8
jne 0xadc6
callq 0xae46
movb $0x1, 0x12822(%rip)     # 0x1d5e8
leaq -0xd0(%rbp), %rdi
callq 0xa47e
leaq -0xd0(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xaed8
leaq -0xd0(%rbp), %rdi
callq 0x4e8c
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xae12
movq %rax, %r14
leaq -0xd0(%rbp), %rdi
callq 0x4e8c
jmp 0xae15
movq %rax, %r14
leaq 0x20(%rbx), %r15
leaq 0x50(%rbx), %rdi
leaq 0x38(%rbx), %r12
callq 0x4ed4
movq %r12, %rdi
callq 0xbe10
movq %r15, %rdi
callq 0x6248
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::InitializeMaps()
void PokemonEntry::InitializeMaps() {
	MapGenerator mg;
	mg.NameToDexIDMap(NameToDexID);
	mg.DexIDToBaseStatsMap(DexIDToBaseStats);
	mg.EntryIDToEntryDataMap(EntryIDToEntryData);
	mg.DexIDToTypeVectorMap(DexIDToTypes);
	mg.DexIDToNameMap(DexIDToName);
	mg.MoveIDToMoveDataMap(MoveIDToMoveData);
	mg.TypeMultiplierMap(typeMul);
	mg.MoveNameToMoveIDMap(MoveNameToMoveID);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq -0x9(%rbp), %rbx
movq %rbx, %rdi
callq 0xbe88
leaq 0x12639(%rip), %rsi     # 0x1d498
movq %rbx, %rdi
callq 0x2bec
leaq 0x126ba(%rip), %rsi     # 0x1d528
movq %rbx, %rdi
callq 0x39dc
leaq 0x1270b(%rip), %rsi     # 0x1d588
movq %rbx, %rdi
callq 0x3e26
leaq 0x126cc(%rip), %rsi     # 0x1d558
movq %rbx, %rdi
callq 0x2fbe
leaq 0x1271d(%rip), %rsi     # 0x1d5b8
movq %rbx, %rdi
callq 0x2e6e
leaq 0x1261e(%rip), %rsi     # 0x1d4c8
movq %rbx, %rdi
callq 0x3850
leaq 0x12767(%rip), %rsi     # 0x1d620
movq %rbx, %rdi
callq 0x4690
leaq 0x12630(%rip), %rsi     # 0x1d4f8
movq %rbx, %rdi
callq 0x3864
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::Construct(EntryData&, int)
void PokemonEntry::Construct(EntryData &ed,int IV) {
	vector<int> bs = DexIDToBaseStats[ed.DexID];
	types = DexIDToTypes[ed.DexID];
	ws = CalcWorkingStats(bs,ed.EV,IV,ed.nature);
	moves.resize(4);
	name = DexIDToName[ed.DexID];
	for(unsigned i = 0; i < 4; i++) {
		moves[i] = MoveIDToMoveData[ed.moveID[i]];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %r15
leaq 0x1262b(%rip), %rdi     # 0x1d528
movq %r15, %rsi
callq 0x4aac
leaq -0x58(%rbp), %rdi
movq %rax, %rsi
callq 0x61f0
leaq 0x12640(%rip), %rdi     # 0x1d558
movq %r15, %rsi
callq 0x486a
leaq 0x50(%r14), %rdi
movq %rax, %rsi
callq 0x491c
leaq 0x98(%rbx), %rsi
leaq -0x40(%rbp), %rdi
callq 0x61f0
leaq 0x78(%rbx), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2240
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rsi
leaq -0x40(%rbp), %rdx
leaq -0x78(%rbp), %r8
movl %r12d, %ecx
callq 0xc5d4
leaq 0x20(%r14), %rdi
leaq -0x90(%rbp), %r12
movq %r12, %rsi
callq 0xc3ee
movq %r12, %rdi
callq 0x6248
leaq -0x78(%rbp), %rdi
callq 0x20e0
leaq -0x40(%rbp), %rdi
callq 0x6248
leaq 0x38(%r14), %r12
pushq $0x4
popq %rsi
movq %r12, %rdi
callq 0xbfd6
leaq 0x12611(%rip), %rdi     # 0x1d5b8
movq %r15, %rsi
callq 0x4800
movq %r14, %rdi
movq %rax, %rsi
callq 0x2110
xorl %r15d, %r15d
leaq 0x12504(%rip), %r14     # 0x1d4c8
xorl %r13d, %r13d
cmpq $0x220, %r13            # imm = 0x220
je 0xaffb
movq 0x40(%rbx), %rsi
addq %r15, %rsi
movq %r14, %rdi
callq 0x49f0
movq (%r12), %rdi
addq %r13, %rdi
movq %rax, %rsi
callq 0x4bea
addq $0x88, %r13
addq $0x20, %r15
jmp 0xafc7
leaq -0x58(%rbp), %rdi
callq 0x6248
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20e0
jmp 0xb024
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
callq 0x6248
jmp 0xb036
jmp 0xb033
jmp 0xb033
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x6248
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::PokemonEntry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
PokemonEntry::PokemonEntry(string id,int IV) {
	if(!initialized) {
		InitializeMaps();
		initialized = true;
	}
	
	EntryData ed = EntryIDToEntryData[id];
	Construct(ed,IV);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xb0, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rsi, %r15
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x60(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
cmpb $0x0, 0x12556(%rip)     # 0x1d5e8
jne 0xb0a0
callq 0xae46
movb $0x1, 0x12548(%rip)     # 0x1d5e8
leaq 0x124e1(%rip), %rdi     # 0x1d588
movq %r15, %rsi
callq 0x4dc2
leaq -0xd0(%rbp), %rdi
movq %rax, %rsi
callq 0x6b08
leaq -0xd0(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xaed8
leaq -0xd0(%rbp), %rdi
callq 0x4e8c
addq $0xb0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb0ff
movq %rax, %r14
leaq -0xd0(%rbp), %rdi
callq 0x4e8c
jmp 0xb102
movq %rax, %r14
leaq 0x20(%rbx), %r15
leaq 0x50(%rbx), %rdi
leaq 0x38(%rbx), %r12
callq 0x4ed4
movq %r12, %rdi
callq 0xbe10
movq %r15, %rdi
callq 0x6248
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::PokemonEntry(EntryData&, int)
PokemonEntry::PokemonEntry(EntryData &edata,int IV) {
	if(!initialized) {
		InitializeMaps();
		initialized = true;
	}
	Construct(edata,IV);	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x60(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
cmpb $0x0, 0x1246d(%rip)     # 0x1d5e8
jne 0xb189
callq 0xae46
movb $0x1, 0x1245f(%rip)     # 0x1d5e8
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
callq 0xaed8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x50(%rbx), %rdi
leaq 0x38(%rbx), %r12
callq 0x4ed4
movq %r12, %rdi
callq 0xbe10
movq %r14, %rdi
callq 0x6248
movq %rbx, %rdi
callq 0x20e0
movq %r15, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::PokemonEntry(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<int>>&, 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>>>>&)
PokemonEntry::PokemonEntry(string knownName, vector<int> &stats, vector<string> &knownMoves)  {
	if(!initialized) {
		InitializeMaps();
		initialized = true;
	}
	name = knownName;
	ws = stats;
	moves.clear();
	for(unsigned i = 0; i < knownMoves.size(); i++) {
		moves.push_back( MoveIDToMoveData[MoveNameToMoveID[knownMoves[i]]]);
	}	
	
	types = DexIDToTypes[NameToDexID[name]];

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r13
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movq %rdx, %r14
movq %rsi, %r12
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, -0x40(%rbp)
leaq 0x38(%rdi), %r15
leaq 0x50(%rdi), %rax
movq %rax, -0x30(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
andq $0x0, 0x60(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
cmpb $0x0, 0x123b8(%rip)     # 0x1d5e8
movq %rdi, -0x38(%rbp)
jne 0xb242
callq 0xae46
movb $0x1, 0x123a6(%rip)     # 0x1d5e8
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2110
movq -0x40(%rbp), %rdi
movq %r14, %rsi
callq 0x4b16
movq %r15, %rdi
callq 0xbe3c
xorl %ebx, %ebx
leaq 0x1228e(%rip), %r14     # 0x1d4f8
leaq 0x12257(%rip), %r12     # 0x1d4c8
movl %ebx, %ebx
movq (%r13), %rsi
movq 0x8(%r13), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %rbx, %rax
jbe 0xb2b3
movq %rbx, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r14, %rdi
callq 0x4800
movq %r12, %rdi
movq %rax, %rsi
callq 0x49f0
movq %r15, %rdi
movq %rax, %rsi
callq 0xbe4a
incl %ebx
jmp 0xb271
leaq 0x121de(%rip), %rdi     # 0x1d498
movq -0x38(%rbp), %rsi
callq 0x4800
leaq 0x1228e(%rip), %rdi     # 0x1d558
movq %rax, %rsi
callq 0x486a
movq -0x30(%rbp), %rdi
movq %rax, %rsi
callq 0x491c
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb2ef
movq %rax, %r14
movq -0x30(%rbp), %rdi
callq 0x4ed4
movq %r15, %rdi
callq 0xbe10
movq -0x40(%rbp), %rdi
callq 0x6248
movq -0x38(%rbp), %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::getMove(int)
MoveData PokemonEntry::getMove(int which) {
	MoveData mm;
	if(which >= 0 && which < (int)moves.size())
		return moves[which];
	else 
		return mm;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq -0xa0(%rbp), %rdi
callq 0xa1bc
testl %r14d, %r14d
js 0xb391
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rax
subq %rsi, %rax
movl $0x88, %ecx
cqto
idivq %rcx
cmpl %r14d, %eax
jle 0xb391
movl %r14d, %eax
imulq $0x88, %rax, %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x66ba
jmp 0xb3a0
leaq -0xa0(%rbp), %rsi
movq %rbx, %rdi
callq 0xbf8a
leaq -0xa0(%rbp), %rdi
callq 0x4c38
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x4c38
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::getMoveDamageRange(PokemonEntry&, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
pair<int,int> PokemonEntry::getMoveDamageRange(PokemonEntry &defender, string moveName) {
	int chosen;
	for(unsigned i = 0; i < moves.size(); i++) {
		if(moves[i].name == moveName) {
			chosen = i;
			break;
		}
	}
	return getMoveDamageRange(defender,chosen);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
xorl %r14d, %r14d
movl $0x88, %r13d
movl %r14d, %r14d
movq 0x38(%r15), %rcx
movq 0x40(%r15), %rax
subq %rcx, %rax
cqto
idivq %r13
cmpq %r14, %rax
jbe 0xb452
imulq $0x88, %r14, %rax
leaq (%rcx,%rax), %rdi
addq $0x20, %rdi
movq %r12, %rsi
callq 0xa303
testb %al, %al
jne 0xb452
incl %r14d
jmp 0xb41a
movq %r15, %rdi
movq %rbx, %rsi
movl %r14d, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xb46e
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::IntToStringHelper[abi:cxx11](int)
string PokemonEntry::IntToStringHelper(int a) {
	string result = "";
	int temp = a;
	bool neg = false;
	if(temp < 0) {
		temp *= -1;
		neg = true;
	}
	int digN;
	char dig = 0;
	while(temp > 0) {
		digN = temp % 10;
		temp /= 10;
		dig = digN + '0';
		result = dig + result;
	}
	if(neg)
		result = '-' + result;
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x6802(%rip), %rsi      # 0x12570
leaq -0x48(%rbp), %r15
movq %r15, %rdx
callq 0x4cd4
movl %r14d, %r12d
negl %r12d
cmovsl %r14d, %r12d
pushq $0xa
popq %r13
testl %r12d, %r12d
je 0xbdbe
movl %r12d, %eax
xorl %edx, %edx
divl %r13d
orb $0x30, %dl
movzbl %dl, %esi
movl %eax, %r12d
movq %r15, %rdi
movq %rbx, %rdx
callq 0xc0b6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq %r15, %rdi
callq 0x20e0
jmp 0xbd88
testl %r14d, %r14d
jns 0xbde9
leaq -0x48(%rbp), %rdi
pushq $0x2d
popq %rsi
movq %rbx, %rdx
callq 0xc0b6
leaq -0x48(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq %r14, %rdi
callq 0x20e0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbdfd
movq %rax, %r14
movq %rbx, %rdi
callq 0x20e0
movq %r14, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.h
// Function: MapGenerator::MapGenerator()
MapGenerator() {
			if(!mapsInitialized) {
				NameToDexIDMapHelper(NameToDexID);
				TypeToDexIDVectorMapHelper(TypeToDexIDVector);
				MoveNameToMoveIDMapHelper(MoveNameToMoveID);
				DexIDToNameMapHelper(DexIDToName);
				DexIDToTypeVectorMapHelper(DexIDToTypeVector);
				DexIDToEntryIDVectorMapHelper(DexIDToEntryIDVector);
				NameToEntryIDVectorMapHelper(NameToEntryIDVector);
				DexIDToBaseStatsMapHelper(DexIDToBaseStats);
				MoveIDToMoveDataMapHelper(MoveIDToMoveData);
				EntryIDToEntryDataMapHelper(EntryIDToEntryData);
				NatureToStatMultiplierMapHelper(NatureToStatMultiplier);
				TypeToEntryIDVectorMapHelper(TypeToEntryIDVector);
				MoveIDtoEntryIDVectorMapHelper(MoveIDtoEntryIDVector);
				MoveNameToEntryIDVectorMapHelper(MoveNameToEntryIDVector);
				TypeMultiplierMapHelper(TypeMultiplier);
				mapsInitialized = true;
			}

		}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x115fa(%rip), %r14     # 0x1d490
cmpb $0x0, (%r14)
jne 0xbf85
movq %rdi, %rbx
leaq 0x11316(%rip), %rsi     # 0x1d1c0
callq 0x2c00
leaq 0x1133a(%rip), %rsi     # 0x1d1f0
movq %rbx, %rdi
callq 0x2d50
leaq 0x114ab(%rip), %rsi     # 0x1d370
movq %rbx, %rdi
callq 0x3878
leaq 0x1134c(%rip), %rsi     # 0x1d220
movq %rbx, %rdi
callq 0x2e82
leaq 0x1136d(%rip), %rsi     # 0x1d250
movq %rbx, %rdi
callq 0x2fd2
leaq 0x1138e(%rip), %rsi     # 0x1d280
movq %rbx, %rdi
callq 0x3104
leaq 0x1140f(%rip), %rsi     # 0x1d310
movq %rbx, %rdi
callq 0x3654
leaq 0x11490(%rip), %rsi     # 0x1d3a0
movq %rbx, %rdi
callq 0x39f0
leaq 0x114b1(%rip), %rsi     # 0x1d3d0
movq %rbx, %rdi
callq 0x3b12
leaq 0x114d2(%rip), %rsi     # 0x1d400
movq %rbx, %rdi
callq 0x3e3a
leaq 0x114f3(%rip), %rsi     # 0x1d430
movq %rbx, %rdi
callq 0x43e6
leaq 0x11364(%rip), %rsi     # 0x1d2b0
movq %rbx, %rdi
callq 0x327c
leaq 0x11385(%rip), %rsi     # 0x1d2e0
movq %rbx, %rdi
callq 0x349e
leaq 0x113d6(%rip), %rsi     # 0x1d340
movq %rbx, %rdi
callq 0x375a
leaq 0x114e7(%rip), %rsi     # 0x1d460
movq %rbx, %rdi
callq 0x46a4
movb $0x1, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %r8, -0x50(%rbp)
movq %rcx, -0x40(%rbp)
movq %rdx, -0x48(%rbp)
movq %rsi, %r13
pushq $0x6
popq %rsi
leaq -0x29(%rbp), %rdx
movq %rdi, -0x38(%rbp)
callq 0x4a5a
cmpb $0x0, 0x11085(%rip)     # 0x1d690
jne 0xc619
callq 0xc6d5
movb $0x1, 0x11077(%rip)     # 0x1d690
movq (%r13), %rax
movl (%rax), %ecx
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
pushq $0x4
popq %rsi
cltd
idivl %esi
movq -0x40(%rbp), %rdx
leal (%rdx,%rcx,2), %ecx
addl %ecx, %eax
addl $0x6e, %eax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx)
pushq $0x1
popq %rbx
leaq -0x70(%rbp), %r14
cmpq $0x6, %rbx
je 0xc69e
movq (%r13), %rax
movl (%rax,%rbx,4), %r15d
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl (%rax,%rbx,4), %r12d
movq %r14, %rdi
movq -0x50(%rbp), %rsi
callq 0x2240
movl %ebx, %edi
movl %r15d, %esi
movl %r12d, %edx
movq -0x40(%rbp), %rcx
pushq $0x64
popq %r8
movq %r14, %r9
callq 0xc722
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
movl %eax, (%rcx,%rbx,4)
movq %r14, %rdi
callq 0x20e0
incq %rbx
jmp 0xc64a
movq -0x38(%rbp), %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc6b3
movq %rax, %rbx
jmp 0xc6c4
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20e0
movq -0x38(%rbp), %rdi
callq 0x6248
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %esi, %eax
leal (%rdx,%rdi,2), %esi
movl $0x4, %edi
cltd
idivl %edi
addl %esi, %eax
imull %ecx, %eax
movl $0x64, %esi
cltd
idivl %esi
addl %ecx, %eax
addl $0xa, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %r8d, -0x2c(%rbp)
movl %ecx, %r15d
movl %edx, %r14d
movl %esi, %r12d
movl %edi, %r13d
leaq -0x58(%rbp), %rbx
movq %rbx, %rdi
movq %r9, %rsi
callq 0x2240
movl %r13d, %edi
movq %rbx, %rsi
callq 0xcbfc
movsd %xmm0, -0x38(%rbp)
leal (%r15,%r12,2), %ecx
pushq $0x4
popq %rsi
movl %r14d, %eax
cltd
idivl %esi
addl %ecx, %eax
imull -0x2c(%rbp), %eax
pushq $0x64
popq %rcx
cltd
idivl %ecx
movl %eax, %ebx
addl $0x5, %ebx
leaq -0x58(%rbp), %rdi
callq 0x20e0
cvtsi2sd %ebx, %xmm0
movsd -0x38(%rbp), %xmm1
mulsd %xmm0, %xmm1
cvttsd2si %xmm1, %eax
addq $0x38, %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/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, -0x38(%rbp)
cmpb $0x0, 0x10eae(%rip)     # 0x1d690
jne 0xc7f0
callq 0xc6d5
movb $0x1, 0x10ea0(%rip)     # 0x1d690
leaq -0x80(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2240
movq %r12, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0xc88f
movl %eax, %ebx
leaq -0x80(%rbp), %rdi
callq 0x20e0
cmpl $-0x1, %ebx
je 0xc84e
leaq -0x60(%rbp), %r15
movq %r15, %rdi
movq %r13, %rsi
callq 0x2240
movq -0x38(%rbp), %r13
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
movq %r15, %r8
callq 0xc967
leaq -0x60(%rbp), %rdi
callq 0x20e0
jmp 0xc868
leaq -0x3c(%rbp), %rdx
orl $-0x1, (%rdx)
pushq $0x6
popq %rsi
leaq -0x29(%rbp), %rcx
movq -0x38(%rbp), %r13
movq %r13, %rdi
callq 0x4d62
movq %r13, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc87c
movq %rax, %rbx
movq %r15, %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, -0x40(%rbp)
movq %rsi, -0x38(%rbp)
movq %rdi, -0x30(%rbp)
xorl %r15d, %r15d
pushq $0x1
popq %r14
leaq -0x60(%rbp), %rbx
cmpl $0x20, %r15d
je 0xc94e
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
leal (%r15,%rax,2), %eax
addl $0x6e, %eax
movq -0x30(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0xc93c
cmpq $0x6, %r14
je 0xc930
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r14,4), %r12d
movq %rbx, %rdi
movq -0x40(%rbp), %rsi
callq 0x2240
movl %r14d, %edi
movl %r12d, %esi
xorl %edx, %edx
movl %r15d, %ecx
pushq $0x64
popq %r8
movq %rbx, %r9
callq 0xc722
movl %eax, %r12d
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r14,4), %r13d
movq %rbx, %rdi
callq 0x20e0
incq %r14
cmpl %r13d, %r12d
jne 0xc8dc
jmp 0xc93c
incl %r15d
pushq $0x1
popq %r14
jmp 0xc8b7
movl %r15d, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
jmp 0xc93f
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x20e0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %rbx
movq %rdi, -0x30(%rbp)
leaq -0x58(%rbp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq (%rsi), %rcx
xorl %r14d, %r14d
pushq $0x18
popq %r12
leaq -0x60(%rbp), %r15
movl %r14d, %r14d
movq 0x8(%rbx), %rax
subq %rcx, %rax
cqto
idivq %r12
cmpq %r14, %rax
jbe 0xd103
xorl %r12d, %r12d
imulq $0x18, %r14, %r13
movl %r12d, %r12d
movq (%rcx,%r13), %rsi
movq 0x8(%rcx,%r13), %rax
subq %rsi, %rax
sarq $0x5, %rax
cmpq %r12, %rax
jbe 0xd0fa
movq %r12, %rax
shlq $0x5, %rax
addq %rax, %rsi
movq %r15, %rdi
callq 0xd3bc
incl (%rax)
incl %r12d
movq (%rbx), %rcx
jmp 0xd0c6
incl %r14d
pushq $0x18
popq %r12
jmp 0xd0ab
movq -0x30(%rbp), %r14
movq %r14, %rdi
callq 0xd426
movq -0x48(%rbp), %r15
leaq -0x58(%rbp), %rax
cmpq %rax, %r15
je 0xd14a
movl 0x40(%r15), %ecx
movq 0x8(%rbx), %rax
subq (%rbx), %rax
cqto
idivq %r12
cmpq %rcx, %rax
jne 0xd13d
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x48d4
movq %r15, %rdi
callq 0x2130
movq %rax, %r15
jmp 0xd113
leaq -0x60(%rbp), %rdi
callq 0xd532
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd164
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0xd532
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/EntryFilter/EntryFilter.cpp
// Function: EntryFilter::Evaluate(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 EntryFilter::Evaluate(vector<string> &res) {
	res.clear();
	vector< vector<string> > totalTemp;
	vector<string> temp;
	if(name != "") {
		nte.EvalToken(name,temp);
		totalTemp.push_back(temp);
	}
	for(unsigned int i = 0; i < 4; i++) {
		if(moves[i] != "") {
			mte.EvalToken(moves[i],temp);
			totalTemp.push_back(temp);
		}
	}
	for(unsigned int i = 0; i < 2; i++) {
		if(types[i] != "") {
			tte.EvalToken(types[i],temp);
			totalTemp.push_back(temp);
		}
	}
	MergeVectors(res,totalTemp);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq %rsi, %rdi
callq 0xd426
xorps %xmm0, %xmm0
movaps %xmm0, -0x70(%rbp)
andq $0x0, -0x60(%rbp)
movaps %xmm0, -0x50(%rbp)
andq $0x0, -0x40(%rbp)
leaq 0x80(%r14), %rbx
leaq 0x53b3(%rip), %rsi      # 0x12570
movq %rbx, %rdi
callq 0x490f
testb %al, %al
je 0xd208
leaq -0x98(%rbp), %rdi
movq %rbx, %rsi
callq 0x2240
leaq 0x118(%r14), %rdi
leaq -0x98(%rbp), %rsi
leaq -0x50(%rbp), %rdx
callq 0xdd1c
leaq -0x98(%rbp), %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0xd434
movq %r15, -0x78(%rbp)
leaq 0x150(%r14), %rax
movq %rax, -0x30(%rbp)
xorl %r12d, %r12d
leaq -0xd8(%rbp), %r13
leaq -0x50(%rbp), %rbx
cmpq $0x80, %r12
je 0xd279
leaq (%r14,%r12), %r15
movq %r15, %rdi
leaq 0x5334(%rip), %rsi      # 0x12570
callq 0x490f
testb %al, %al
je 0xd273
movq %r13, %rdi
movq %r15, %rsi
callq 0x2240
movq -0x30(%rbp), %rdi
movq %r13, %rsi
movq %rbx, %rdx
callq 0xdda4
movq %r13, %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0xd434
addq $0x20, %r12
jmp 0xd225
leaq 0xa0(%r14), %r15
addq $0xe0, %r14
movq %r14, -0x30(%rbp)
xorl %r13d, %r13d
leaq -0xb8(%rbp), %r12
leaq -0x50(%rbp), %r14
cmpq $0x40, %r13
je 0xd2ed
leaq (%r15,%r13), %rbx
movq %rbx, %rdi
leaq 0x52c3(%rip), %rsi      # 0x12570
callq 0x490f
testb %al, %al
je 0xd2e7
movq %r12, %rdi
movq %rbx, %rsi
callq 0x2240
movq -0x30(%rbp), %rdi
movq %r12, %rsi
movq %r14, %rbx
movq %r14, %rdx
callq 0xdc94
movq %r12, %rdi
callq 0x20e0
leaq -0x70(%rbp), %rdi
movq %rbx, %rsi
callq 0xd434
addq $0x20, %r13
jmp 0xd299
leaq -0x70(%rbp), %rsi
movq -0x78(%rbp), %rdi
callq 0xd06c
leaq -0x50(%rbp), %rdi
callq 0x4ed4
leaq -0x70(%rbp), %rdi
callq 0xd470
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
jmp 0xd342
jmp 0xd34b
movq %rax, %rbx
leaq -0xb8(%rbp), %rdi
jmp 0xd342
movq %rax, %rbx
leaq -0xd8(%rbp), %rdi
callq 0x20e0
jmp 0xd34e
jmp 0xd34b
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x4ed4
leaq -0x70(%rbp), %rdi
callq 0xd470
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::Menu(std::ostream&, std::istream&, std::ostream&)
void BattleSim::Menu(ostream &pout, istream &fin, ostream &fout) {
	string option;
	str_code sc = INITCODE;
	while(sc != EXIT) {	
		pout << "Enter Choice: SETCRITERIA,EVALUATECRITERIA,SETPARTICIPANTS\n";
		pout << "PRINTCRITERIA, PRINTCANDIDATES, PRINTPARTICIPANTS, SIMULATE\n";
		pout << "RETRIEVERESULTS\n";
		getline(fin,option);
	
		sc = HashString(option);
		//TODO: EVALUATE CRITERIA OPTION, print results option
		switch(sc) {
			case SETCRITERIA:
				SetCriteria(pout,fin); break;
			case EVALUATECRITERIA:
				EvaluateCriteria(pout,fin); break;
			case SETPARTICIPANTS:
				SetParticipants(pout,fin); break;
			case PRINTCRITERIA:
				PrintCriteria(pout,fin); break;
			case PRINTCANDIDATES:
				PrintCandidates(pout,fin); break;
			case PRINTPARTICIPANTS:
				PrintParticipants(pout); break;
			case SIMULATE:
				Simulate(pout,fin,fout); break;
			case RETRIEVERESULTS:
				RetrieveResults(pout,fin,fout); break; 
			case EXIT: break;
			default:
				pout << "Invalid Choice\n";

		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rcx, -0x38(%rbp)
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, -0x30(%rbp)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %r12d, %r12d
leaq -0x58(%rbp), %rbx
leaq -0x78(%rbp), %r13
cmpl $0xd, %r12d
je 0xdf51
movq %r15, %rdi
leaq 0x44b2(%rip), %rsi      # 0x122e4
callq 0x2190
movq %r15, %rdi
leaq 0x44df(%rip), %rsi      # 0x12320
callq 0x2190
movq %r15, %rdi
leaq 0x450d(%rip), %rsi      # 0x1235d
callq 0x2190
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2050
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2240
movq %r13, %rsi
callq 0xdf7e
movl %eax, %r12d
movq %r13, %rdi
callq 0x20e0
movl %r12d, %eax
decl %eax
cmpl $0xc, %eax
ja 0xdf3d
leaq 0x4409(%rip), %rcx      # 0x1229c
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe2c2
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe22a
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe48a
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe196
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq -0x38(%rbp), %rcx
callq 0xe560
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe0ea
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xe35a
jmp 0xde1e
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0xe3f0
jmp 0xde1e
movq %r15, %rdi
leaq 0x4427(%rip), %rsi      # 0x1236e
callq 0x2190
jmp 0xde1e
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
nop
// File: /workspace/github_cpp_makefile_star2_O2/chulchultrain[P]FactoryHead/BattleSim/BattleSim.cpp
// Function: BattleSim::HashString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
BattleSim::str_code BattleSim::HashString(string s) {
	if(s == "INITCODE")
		return INITCODE;
	else if(s == "SETCRITERIA")
		return SETCRITERIA;
	else if(s == "SETNAME")
		return SETNAME;
	else if(s == "SETMOVE")
		return SETMOVE;
	else if(s == "SETTYPE")
		return SETTYPE;
	else if(s == "SETIV")
		return SETIV;
	else if(s == "EVALUATECRITERIA")
		return EVALUATECRITERIA;
	else if(s == "SETPARTICIPANTS")
		return SETPARTICIPANTS;
	else if(s == "EXIT")
		return EXIT;
	else if(s == "PRINTCANDIDATES")
		return PRINTCANDIDATES;
	else if(s == "PRINTPARTICIPANTS")
		return PRINTPARTICIPANTS;
	else if(s == "PRINTCRITERIA")
		return PRINTCRITERIA;
	else if(s == "SIMULATE")
		return SIMULATE;
	else if(s == "RETRIEVERESULTS")
		return RETRIEVERESULTS;
	else 
		return INVALID;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0x4694(%rip), %rsi      # 0x12622
movq %rbx, %rdi
callq 0x827a
movl %eax, %ecx
xorl %eax, %eax
testb %cl, %cl
jne 0xe0c7
leaq 0x4682(%rip), %rsi      # 0x1262b
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xdfbc
pushq $0x8
jmp 0xe0c6
leaq 0x4674(%rip), %rsi      # 0x12637
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xdfd6
pushq $0x9
jmp 0xe0c6
leaq 0x4662(%rip), %rsi      # 0x1263f
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xdff0
pushq $0xa
jmp 0xe0c6
leaq 0x4650(%rip), %rsi      # 0x12647
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe00a
pushq $0xb
jmp 0xe0c6
leaq 0x463e(%rip), %rsi      # 0x1264f
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe024
pushq $0xc
jmp 0xe0c6
leaq 0x462a(%rip), %rsi      # 0x12655
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe03e
pushq $0x2
jmp 0xe0c6
leaq 0x4621(%rip), %rsi      # 0x12666
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe055
pushq $0x3
jmp 0xe0c6
leaq 0x461a(%rip), %rsi      # 0x12676
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe06c
pushq $0xd
jmp 0xe0c6
leaq 0x4608(%rip), %rsi      # 0x1267b
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe083
pushq $0x4
jmp 0xe0c6
leaq 0x4601(%rip), %rsi      # 0x1268b
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe09a
pushq $0x5
jmp 0xe0c6
leaq 0x45fc(%rip), %rsi      # 0x1269d
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe0b1
pushq $0x1
jmp 0xe0c6
leaq 0x45f3(%rip), %rsi      # 0x126ab
movq %rbx, %rdi
callq 0x827a
testb %al, %al
je 0xe0ce
pushq $0x6
popq %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x45df(%rip), %rsi      # 0x126b4
movq %rbx, %rdi
callq 0x827a
testb %al, %al
pushq $0x7
popq %rcx
pushq $0xe
popq %rax
cmovnel %ecx, %eax
jmp 0xe0c7
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
leaq -0x30(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x436d(%rip), %rsi      # 0x12486
movq %rbx, %rdi
callq 0x2190
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
callq 0x2050
leaq -0x40(%rbp), %rsi
callq 0xe798
movl %eax, %r12d
testl %eax, %eax
js 0xe15d
movq %r15, %rdi
callq 0xfaec
cmpl %eax, %r12d
jge 0xe15d
movq %r15, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movl %r12d, %ecx
callq 0xe9b6
jmp 0xe16c
leaq 0x420a(%rip), %rsi      # 0x1236e
movq %rbx, %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