LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::NatureToStatMultiplierMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::map<int, int, std::less<int>, std::allocator<std::pair<int 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<int, int, std::less<int>, std::allocator<std::pair<int const, int>>>>>>&)
void MapGenerator::NatureToStatMultiplierMapHelper(map <string, map<int, int> > &m) {
	m.clear();
	ifstream fin(NATUREFILE);
	string nature;
	int incStat,decStat;
	while(fin >> nature) {
		fin >> incStat >> decStat;
	//	cout << nature << " " << incStat << " " << decStat << '\n';
		m[nature][incStat] = 1;
		m[nature][decStat] = -1;
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x238, %rsp            # imm = 0x238
movq %rsi, %rbx
movq %rsi, %rdi
callq 0xa3c6
leaq 0x10dfb(%rip), %rsi     # 0x160b9
leaq -0x258(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0x48(%rbp), %r15
leaq -0x50(%rbp), %r12
leaq -0x4c(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x535a
movq %r14, %rdi
movq %r12, %rsi
callq 0x2110
movq %rax, %rdi
movq %r13, %rsi
callq 0x2110
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fbc
movq %rax, %rdi
movq %r12, %rsi
callq 0x603c
movl $0x1, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x5fbc
movq %rax, %rdi
movq %r13, %rsi
callq 0x603c
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x52f1
leaq -0x258(%rbp), %rdi
callq 0x2060
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x537f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x258(%rbp), %rdi
callq 0x2070
addq $0x238, %rsp            # imm = 0x238
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x539f
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x53bb
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x258(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::SaveChangesToFile()
void MapGenerator::SaveChangesToFile() {
	ofstream fout(OUTPUTENTRYFILE);
	for(map<string, EntryData>::iterator it = EntryIDToEntryData.begin(); it != EntryIDToEntryData.end(); it++) {
		PrintEntryData(fout,it->second);
	}

	fout.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
leaq 0x10c38(%rip), %rsi     # 0x16091
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x21e0
movq 0x19f9f(%rip), %rbx     # 0x1f410
leaq 0x19f88(%rip), %r15     # 0x1f400
cmpq %r15, %rbx
je 0x54a0
leaq -0x218(%rbp), %r14
leaq 0x40(%rbx), %rdx
movq %r14, %rsi
callq 0x550a
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq %r15, %rax
jne 0x5484
leaq -0x218(%rbp), %rdi
callq 0x2230
movq 0x19b1d(%rip), %rax     # 0x1efd0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x210(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x218(%rbp,%rcx)
callq 0x2170
leaq -0x120(%rbp), %rdi
callq 0x20b0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54f2
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::PrintEntryData(std::basic_ofstream<char, std::char_traits<char>>&, EntryData const&)
void MapGenerator::PrintEntryData(ofstream &fout, const EntryData &ed) {
	fout << ed.ID << '\n';
	fout << ed.DexID << '\n';
	for(unsigned i = 0; i < 4; i++) {
		fout << ed.moveID[i] << '\n';
	}
	fout << ed.item << '\n';
	fout << ed.nature << '\n';
	for(unsigned i = 0; i < 6; i++) {
		fout << ed.EV[i] << '\n';
	}
	fout << '\n';
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq (%rdx), %rsi
movq 0x8(%rdx), %rdx
movq %rbx, %rdi
callq 0x2200
movb $0xa, %r15b
leaq -0x23(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x2200
leaq -0x24(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
xorl %r12d, %r12d
leaq -0x21(%rbp), %r15
movq 0x40(%r14), %rax
movq (%rax,%r12), %rsi
movq 0x8(%rax,%r12), %rdx
movq %rbx, %rdi
callq 0x2200
movb $0xa, -0x21(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
addq $0x20, %r12
cmpq $0x80, %r12
jne 0x5570
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
movq %rbx, %rdi
callq 0x2200
movb $0xa, %r15b
leaq -0x25(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
movq %rbx, %rdi
callq 0x2200
leaq -0x26(%rbp), %rsi
movb %r15b, (%rsi)
movl $0x1, %edx
movq %rax, %rdi
callq 0x2200
xorl %r12d, %r12d
leaq -0x22(%rbp), %r15
movq 0x98(%r14), %rax
movl (%rax,%r12,4), %esi
movq %rbx, %rdi
callq 0x22c0
movb $0xa, -0x22(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2200
incq %r12
cmpq $0x6, %r12
jne 0x55fb
leaq -0x27(%rbp), %rsi
movb $0xa, (%rsi)
movl $0x1, %edx
movq %rbx, %rdi
callq 0x2200
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa9c6
leaq 0x10a4e(%rip), %rsi     # 0x160d4
leaq -0x278(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x60(%rbp), %rcx
movq %rcx, -0x10(%rcx)
xorl %eax, %eax
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
leaq -0x40(%rbp), %rcx
movq %rcx, -0x10(%rcx)
movq %rax, -0x8(%rcx)
movb %al, (%rcx)
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 0x570f
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2110
movl -0x2c(%rbp), %r13d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x60a4
movq %rax, %rdi
movq %r12, %rsi
callq 0x6124
movl %r13d, (%rax)
jmp 0x56c0
leaq -0x278(%rbp), %rdi
callq 0x2060
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5734
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x574d
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
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 0x576d
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5789
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x57a2
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %r9d, -0x2c(%rbp)
movq %r8, -0x60(%rbp)
movq %rcx, %r14
movq %rdx, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x48(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x58(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, -0x50(%rbp)
leaq 0x50(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x70(%rdi), %r13
movq %r13, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0x60(%rdi), %r15
callq 0x20f0
movq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x20f0
movq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x20f0
movq %r15, %rdi
movq -0x60(%rbp), %rsi
callq 0x20f0
movl -0x2c(%rbp), %eax
movl %eax, 0x80(%rbx)
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%r15), %rdi
cmpq %r13, %rdi
je 0xafab
movq (%r13), %rsi
incq %rsi
callq 0x21b0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0xafc7
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xafe3
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x48(%rbp), %rdi
je 0xaffb
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %r15
leaq 0x50(%rdi), %r13
movq %r13, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movb %al, 0x50(%rdi)
leaq 0x60(%rdi), %r12
leaq 0x70(%rdi), %r14
movq %r14, 0x60(%rdi)
movq %rax, 0x68(%rdi)
movb %al, 0x70(%rdi)
leaq 0xb514(%rip), %rcx      # 0x16588
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2280
movq 0x28(%rbx), %rdx
leaq 0xb4fd(%rip), %rcx      # 0x16588
movq -0x40(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2280
movq 0x48(%rbx), %rdx
leaq 0xb4e4(%rip), %rcx      # 0x16588
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2280
movq 0x68(%rbx), %rdx
leaq 0xb4cc(%rip), %rcx      # 0x16588
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2280
movl $0x0, 0x80(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, -0x48(%rbp)
movq (%r12), %rdi
cmpq %r14, %rdi
je 0xb0fa
movq (%r14), %rsi
incq %rsi
callq 0x21b0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0xb10e
movq (%r13), %rsi
incq %rsi
callq 0x21b0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0xb12a
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xb142
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x48(%rbp), %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %r9, -0x70(%rbp)
movq %r8, %r15
movq %rcx, %r13
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x48(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x68(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, -0x60(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x68(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x88(%rdi), %rcx
movq %rcx, -0x30(%rbp)
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb %al, 0x88(%rdi)
movq %rax, 0xa8(%rdi)
leaq 0x58(%rdi), %rax
movq %rax, -0x58(%rbp)
movups %xmm0, 0x98(%rdi)
leaq 0x78(%rdi), %rax
movq %rax, -0x50(%rbp)
leaq 0x98(%rdi), %r12
callq 0x20f0
movq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x20f0
movq -0x60(%rbp), %rdi
movq %r13, %rsi
callq 0x5948
movq -0x58(%rbp), %rdi
movq %r15, %rsi
callq 0x20f0
movq -0x50(%rbp), %rdi
movq -0x70(%rbp), %rsi
callq 0x20f0
movq 0x10(%rbp), %rsi
movq %r12, %rdi
callq 0x5bd6
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r13
movq (%r12), %rdi
testq %rdi, %rdi
je 0xb31b
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0xb337
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0xb353
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x60(%rbp), %rdi
callq 0x5f52
movq -0x68(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xb378
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x48(%rbp), %rdi
je 0xb390
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r13, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %r12
leaq 0x30(%rdi), %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
leaq 0x40(%rdi), %rcx
movq %rcx, -0x60(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x58(%rbp)
leaq 0x68(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x78(%rdi), %r13
leaq 0x88(%rdi), %rcx
movq %rcx, -0x38(%rbp)
movq %rcx, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb %al, 0x88(%rdi)
leaq 0x98(%rdi), %r14
movups %xmm0, 0x98(%rdi)
movq %rax, 0xa8(%rdi)
leaq 0xb147(%rip), %rcx      # 0x16588
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2280
movq 0x28(%rbx), %rdx
leaq 0xad0a(%rip), %rcx      # 0x16162
movl $0x3, %r8d
movq %r12, %rdi
xorl %esi, %esi
callq 0x2280
movq %r12, %r15
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0xb10d(%rip), %rdx      # 0x16588
leaq -0x80(%rbp), %rdi
movq %rdx, %rsi
callq 0x9c0a
leaq -0x80(%rbp), %rdx
movl $0x4, %esi
movq -0x60(%rbp), %rdi
callq 0xb6d8
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xb4ae
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
movq 0x80(%rbx), %rdx
leaq 0xb0cc(%rip), %rcx      # 0x16588
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
movq %r15, %r12
callq 0x2280
movq 0x60(%rbx), %rdx
leaq 0xb0b1(%rip), %rcx      # 0x16588
movq -0x58(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2280
leaq -0x80(%rbp), %rdx
movl $0x0, (%rdx)
movl $0x6, %esi
movq %r14, %rdi
callq 0xb716
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb52d
movq %rax, -0x30(%rbp)
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xb531
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0xb531
jmp 0xb52d
movq %r12, %r15
movq %rax, -0x30(%rbp)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb548
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%r13), %rdi
cmpq -0x38(%rbp), %rdi
je 0xb561
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xb57d
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x60(%rbp), %rdi
callq 0x5f52
movq (%r15), %rdi
cmpq -0x48(%rbp), %rdi
je 0xb59e
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0xb5b6
movq -0x50(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x30(%rbp), %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
cmpb $0x0, 0x136e6(%rip)     # 0x1f5e0
jne 0xbf08
callq 0xbfa4
movb $0x1, 0x136d8(%rip)     # 0x1f5e0
leaq -0xd8(%rbp), %rdi
callq 0xb398
leaq -0xd8(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xc036
leaq -0xd8(%rbp), %rdi
callq 0x5eb6
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbf56
movq %rax, %r14
leaq -0xd8(%rbp), %rdi
callq 0x5eb6
jmp 0xbf59
movq %rax, %r14
leaq 0x20(%rbx), %r13
leaq 0x38(%rbx), %r15
leaq 0x50(%rbx), %rdi
callq 0x5f52
movq %r15, %rdi
callq 0xdfec
movq (%r13), %rdi
testq %rdi, %rdi
je 0xbf87
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xbf9b
movq (%r12), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe068
leaq 0x134d3(%rip), %rsi     # 0x1f490
movq %rbx, %rdi
callq 0x2dec
leaq 0x13554(%rip), %rsi     # 0x1f520
movq %rbx, %rdi
callq 0x417c
leaq 0x135a5(%rip), %rsi     # 0x1f580
movq %rbx, %rdi
callq 0x4972
leaq 0x13566(%rip), %rsi     # 0x1f550
movq %rbx, %rdi
callq 0x336c
leaq 0x135b7(%rip), %rsi     # 0x1f5b0
movq %rbx, %rdi
callq 0x3168
leaq 0x134b8(%rip), %rsi     # 0x1f4c0
movq %rbx, %rdi
callq 0x3f1e
leaq 0x13601(%rip), %rsi     # 0x1f618
movq %rbx, %rdi
callq 0x564c
leaq 0x134ca(%rip), %rsi     # 0x1f4f0
movq %rbx, %rdi
callq 0x3f32
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x78, %rsp
movl %edx, %r12d
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x20(%rsi), %r15
leaq 0x134c5(%rip), %rdi     # 0x1f520
movq %r15, %rsi
callq 0x5b56
leaq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x72f8
leaq 0x134da(%rip), %rdi     # 0x1f550
movq %r15, %rsi
callq 0x587c
leaq 0x50(%r14), %rdi
movq %rax, %rsi
callq 0x5948
leaq 0x98(%rbx), %rsi
leaq -0x48(%rbp), %rdi
callq 0x72f8
leaq -0x70(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x78(%rbx), %rsi
movq 0x80(%rbx), %rdx
addq %rsi, %rdx
leaq -0x80(%rbp), %rdi
callq 0x8870
leaq -0x98(%rbp), %rdi
leaq -0x60(%rbp), %rsi
leaq -0x48(%rbp), %rdx
leaq -0x80(%rbp), %r8
movl %r12d, %ecx
callq 0xe88c
leaq 0x20(%r14), %rdi
leaq -0x98(%rbp), %r12
movq %r12, %rsi
callq 0xe698
movq (%r12), %rdi
testq %rdi, %rdi
je 0xc0ff
movq -0x88(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0xc114
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xc129
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
leaq 0x38(%r14), %rdi
movl $0x4, %esi
movq %rdi, -0x30(%rbp)
callq 0xe16a
leaq 0x1346e(%rip), %rdi     # 0x1f5b0
movq %r15, %rsi
callq 0x57fc
movq %r14, %rdi
movq %rax, %rsi
callq 0x20f0
movq %rbx, %r12
xorl %r13d, %r13d
xorl %ebx, %ebx
movq 0x40(%r12), %rsi
addq %rbx, %rsi
leaq 0x13354(%rip), %rdi     # 0x1f4c0
callq 0x5ad6
movq %rax, %r15
movq -0x30(%rbp), %rax
movq (%rax), %r14
leaq (%r14,%r13), %rdi
movq %r15, %rsi
callq 0x20f0
leaq (%r14,%r13), %rdi
addq $0x20, %rdi
leaq 0x20(%r15), %rsi
callq 0x20f0
leaq (%r14,%r13), %rdi
addq $0x40, %rdi
leaq 0x40(%r15), %rsi
callq 0x20f0
leaq (%r14,%r13), %rdi
addq $0x60, %rdi
movq %r15, %rsi
addq $0x60, %rsi
callq 0x20f0
movl 0x80(%r15), %eax
movl %eax, 0x80(%r14,%r13)
addq $0x20, %rbx
addq $0x88, %r13
movl $0x80, %eax
cmpq %rax, %rbx
jne 0xc15d
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xc1fa
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r13, %rdi
je 0xc226
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0xc226
movq %rax, %rbx
movq -0x48(%rbp), %rdi
testq %rdi, %rdi
je 0xc244
movq -0x38(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
jmp 0xc244
jmp 0xc241
jmp 0xc241
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
je 0xc259
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xb8, %rsp
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
cmpb $0x0, 0x13332(%rip)     # 0x1f5e0
jne 0xc2bc
callq 0xbfa4
movb $0x1, 0x13324(%rip)     # 0x1f5e0
leaq 0x132bd(%rip), %rdi     # 0x1f580
movq %r15, %rsi
callq 0x5e36
leaq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x7ba4
leaq -0xd8(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xc036
leaq -0xd8(%rbp), %rdi
callq 0x5eb6
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc31d
movq %rax, %r14
leaq -0xd8(%rbp), %rdi
callq 0x5eb6
jmp 0xc320
movq %rax, %r14
leaq 0x20(%rbx), %r13
leaq 0x38(%rbx), %r15
leaq 0x50(%rbx), %rdi
callq 0x5f52
movq %r15, %rdi
callq 0xdfec
movq (%r13), %rdi
testq %rdi, %rdi
je 0xc34e
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xc362
movq (%r12), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %edx, %r12d
movq %rsi, %r15
movq %rdi, %r14
leaq 0x10(%rdi), %rbx
movq %rbx, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x38(%rbp)
leaq 0x38(%rdi), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x50(%rdi), %r13
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
cmpb $0x0, 0x13219(%rip)     # 0x1f5e0
jne 0xc3d5
callq 0xbfa4
movb $0x1, 0x1320b(%rip)     # 0x1f5e0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xc036
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
callq 0x5f52
movq -0x30(%rbp), %rdi
callq 0xdfec
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xc41e
movq 0x30(%r14), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2380
movq %r15, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x48(%rbp)
leaq 0x38(%rdi), %r15
leaq 0x50(%rdi), %rcx
movq %rcx, -0x38(%rbp)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
movups %xmm0, 0x30(%rdi)
movups %xmm0, 0x40(%rdi)
movups %xmm0, 0x50(%rdi)
movq %rax, 0x60(%rdi)
cmpb $0x0, 0x1314a(%rip)     # 0x1f5e0
movq %rdi, -0x40(%rbp)
jne 0xc4a8
callq 0xbfa4
movb $0x1, 0x13138(%rip)     # 0x1f5e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20f0
movq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x5bd6
movq (%r15), %rsi
movq %r15, %rdi
callq 0xe2c8
movq (%r13), %rax
cmpq %rax, 0x8(%r13)
je 0xc526
movl $0x1, %ebx
xorl %esi, %esi
leaq 0x1300e(%rip), %r14     # 0x1f4f0
leaq 0x12fd7(%rip), %r12     # 0x1f4c0
shlq $0x5, %rsi
addq %rax, %rsi
movq %r14, %rdi
callq 0x57fc
movq %r12, %rdi
movq %rax, %rsi
callq 0x5ad6
movq %r15, %rdi
movq %rax, %rsi
callq 0xe02a
movl %ebx, %esi
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebx
cmpq %rsi, %rcx
ja 0xc4e9
leaq 0x12f63(%rip), %rdi     # 0x1f490
movq -0x40(%rbp), %rsi
callq 0x57fc
leaq 0x13013(%rip), %rdi     # 0x1f550
movq %rax, %rsi
callq 0x587c
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5948
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc562
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x5f52
movq %r15, %rdi
callq 0xdfec
movq -0x48(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
movq -0x40(%rbp), %rbx
je 0xc592
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xc5aa
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb004
testl %r14d, %r14d
js 0xc640
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
cmpl %r14d, %eax
jle 0xc640
movl %r14d, %eax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x771a
jmp 0xc751
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x90(%rbp), %rcx
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0xc667
movq %rdx, (%rbx)
movq -0x90(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0xc66d
movups (%rcx), %xmm0
movups %xmm0, (%rax)
leaq -0x70(%rbp), %rax
movq -0x28(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, -0x30(%rax)
movq $0x0, -0x28(%rax)
movb $0x0, -0x20(%rax)
leaq 0x30(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xc6a8
movq %rdx, 0x20(%rbx)
movq -0x70(%rbp), %rcx
movq %rcx, 0x30(%rbx)
jmp 0xc6ae
movups (%rax), %xmm0
movups %xmm0, (%rcx)
leaq -0x50(%rbp), %rcx
movq -0x28(%rcx), %rdx
movq %rdx, 0x28(%rbx)
movq %rax, -0x30(%rcx)
movq $0x0, -0x28(%rcx)
movb $0x0, -0x20(%rcx)
leaq 0x50(%rbx), %rax
movq %rax, 0x40(%rbx)
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0xc6e9
movq %rdx, 0x40(%rbx)
movq -0x50(%rbp), %rax
movq %rax, 0x50(%rbx)
jmp 0xc6ef
movups (%rcx), %xmm0
movups %xmm0, (%rax)
leaq -0x30(%rbp), %rax
movq -0x28(%rax), %rdx
movq %rdx, 0x48(%rbx)
movq %rcx, -0x30(%rax)
movq $0x0, -0x28(%rax)
movb $0x0, -0x20(%rax)
leaq 0x70(%rbx), %rcx
movq %rcx, 0x60(%rbx)
movq -0x10(%rax), %rdx
cmpq %rax, %rdx
je 0xc72a
movq %rdx, 0x60(%rbx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x70(%rbx)
jmp 0xc730
movups (%rax), %xmm0
movups %xmm0, (%rcx)
movq -0x38(%rbp), %rcx
movq %rcx, 0x68(%rbx)
movq %rax, -0x40(%rbp)
movq $0x0, -0x38(%rbp)
movb $0x0, -0x30(%rbp)
movl -0x20(%rbp), %eax
movl %eax, 0x80(%rbx)
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc76a
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc783
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc79c
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc7bb
movq -0x90(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
callq 0x5cb6
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
subq $0x18, %rsp
movq %rsi, -0x38(%rbp)
movq 0x38(%rdi), %r13
movq %rdi, -0x30(%rbp)
movq 0x40(%rdi), %rax
subq %r13, %rax
je 0xc886
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0xf0f0f0f0f0f0f0f, %rbx # imm = 0xF0F0F0F0F0F0F0F1
imulq %rax, %rbx
movq 0x8(%rdx), %r14
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x7, %rax
leaq (%rax,%r12,8), %rax
movq 0x28(%r13,%rax), %rdx
cmpq %r14, %rdx
jne 0xc87c
testq %rdx, %rdx
je 0xc889
addq %r13, %rax
addq $0x20, %rax
movq (%r15), %rsi
movq (%rax), %rdi
callq 0x21c0
testl %eax, %eax
je 0xc889
incl %r12d
cmpq %r12, %rbx
ja 0xc84c
jmp 0xc889
xorl %r12d, %r12d
movq -0x30(%rbp), %rdi
movq -0x38(%rbp), %rsi
movl %r12d, %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc8a8
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x38, %rsp
movl %edx, %r14d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
leaq 0x868f(%rip), %rdx      # 0x16588
movq %rdx, %rsi
callq 0x9c0a
movl %r14d, -0x2c(%rbp)
testl %r14d, %r14d
je 0xdf76
movl -0x2c(%rbp), %eax
movl %eax, %r13d
negl %r13d
cmovsl %eax, %r13d
movl $0xcccccccd, %r14d      # imm = 0xCCCCCCCD
leaq -0x58(%rbp), %r15
movl %r13d, %r12d
imulq %r14, %r12
shrq $0x23, %r12
leal (%r12,%r12), %eax
leal (%rax,%rax,4), %eax
movl %r13d, %ecx
subl %eax, %ecx
orb $0x30, %cl
movzbl %cl, %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe1b6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xdf6d
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21b0
cmpl $0xa, %r13d
movl %r12d, %r13d
jae 0xdf21
cmpl $0x0, -0x2c(%rbp)
jns 0xdfb4
leaq -0x58(%rbp), %rdi
movl $0x2d, %esi
movq %rbx, %rdx
callq 0xe1b6
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xdfb4
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdfc8
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xdfe3
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x11412(%rip), %r14     # 0x1f488
cmpb $0x0, (%r14)
jne 0xe165
movq %rdi, %rbx
leaq 0x1112e(%rip), %rsi     # 0x1f1b8
callq 0x2e00
leaq 0x11152(%rip), %rsi     # 0x1f1e8
movq %rbx, %rdi
callq 0x3004
leaq 0x112c3(%rip), %rsi     # 0x1f368
movq %rbx, %rdi
callq 0x3f46
leaq 0x11164(%rip), %rsi     # 0x1f218
movq %rbx, %rdi
callq 0x317c
leaq 0x11185(%rip), %rsi     # 0x1f248
movq %rbx, %rdi
callq 0x3380
leaq 0x111a6(%rip), %rsi     # 0x1f278
movq %rbx, %rdi
callq 0x34f8
leaq 0x11227(%rip), %rsi     # 0x1f308
movq %rbx, %rdi
callq 0x3d0e
leaq 0x112a8(%rip), %rsi     # 0x1f398
movq %rbx, %rdi
callq 0x4190
leaq 0x112c9(%rip), %rsi     # 0x1f3c8
movq %rbx, %rdi
callq 0x4318
leaq 0x112ea(%rip), %rsi     # 0x1f3f8
movq %rbx, %rdi
callq 0x4986
leaq 0x1130b(%rip), %rsi     # 0x1f428
movq %rbx, %rdi
callq 0x5298
leaq 0x1117c(%rip), %rsi     # 0x1f2a8
movq %rbx, %rdi
callq 0x3742
leaq 0x1119d(%rip), %rsi     # 0x1f2d8
movq %rbx, %rdi
callq 0x3a3e
leaq 0x111ee(%rip), %rsi     # 0x1f338
movq %rbx, %rdi
callq 0x3e1e
leaq 0x112ff(%rip), %rsi     # 0x1f458
movq %rbx, %rdi
callq 0x5660
movb $0x1, (%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x58, %rsp
movq %r8, %r14
movq %rcx, -0x40(%rbp)
movq %rdx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movq %rdi, %r15
xorl %ebx, %ebx
movq %rbx, 0x10(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movl $0x18, %edi
callq 0x21a0
movq %rax, (%r15)
movq %rax, 0x8(%r15)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rax, -0x38(%rbp)
movq %rbx, 0x10(%rax)
movq %rcx, 0x8(%r15)
cmpb $0x0, 0x10d9b(%rip)     # 0x1f688
jne 0xe90f
leaq -0x29(%rbp), %rdi
callq 0xe068
leaq 0x10d59(%rip), %rsi     # 0x1f658
leaq -0x29(%rbp), %rdi
callq 0x5284
movb $0x1, 0x10d79(%rip)     # 0x1f688
movq %r15, -0x78(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rax
movq -0x50(%rbp), %rcx
movq (%rcx), %rcx
movl (%rcx), %ecx
leal 0x3(%rcx), %edx
testl %ecx, %ecx
cmovnsl %ecx, %edx
movl (%rax), %eax
sarl $0x2, %edx
movq -0x40(%rbp), %rcx
leal (%rcx,%rax,2), %eax
addl %edx, %eax
addl $0x6e, %eax
movq -0x38(%rbp), %rcx
movl %eax, (%rcx)
movl $0x1, %ebx
leaq -0x70(%rbp), %r15
movq -0x48(%rbp), %rax
movq (%rax), %rax
movl (%rax,%rbx,4), %r12d
movq -0x50(%rbp), %rax
movq (%rax), %rax
movl (%rax,%rbx,4), %r13d
leaq -0x60(%rbp), %rax
movq %rax, -0x70(%rbp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x8870
movl %ebx, %edi
movl %r12d, %esi
movl %r13d, %edx
movq -0x40(%rbp), %rcx
movl $0x64, %r8d
movq %r15, %r9
callq 0xea66
movq -0x38(%rbp), %rcx
movl %eax, (%rcx,%rbx,4)
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xe9b5
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
incq %rbx
cmpq $0x6, %rbx
jne 0xe94b
movq -0x78(%rbp), %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe9d3
movq %rax, %rbx
jmp 0xe9f4
movq %rax, %rbx
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0xe9f4
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
movl $0x18, %esi
movq -0x38(%rbp), %rdi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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
leal 0x3(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
leal (%rdx,%rdi,2), %edx
sarl $0x2, %eax
addl %edx, %eax
imull %ecx, %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rdx
shrq $0x3f, %rdx
sarq $0x25, %rax
addl %edx, %eax
addl %ecx, %eax
addl $0xa, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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)
movq %rcx, -0x40(%rbp)
movl %edx, %r12d
movl %esi, %r15d
movl %edi, %r13d
leaq -0x50(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r9), %rsi
movq 0x8(%r9), %rdx
addq %rsi, %rdx
leaq -0x60(%rbp), %rbx
movq %rbx, %rdi
callq 0x8870
movl %r13d, %edi
movq %rbx, %rsi
callq 0xf140
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xead0
movq -0x50(%rbp), %rsi
incq %rsi
movsd %xmm0, -0x38(%rbp)
callq 0x21b0
movsd -0x38(%rbp), %xmm0
leal 0x3(%r12), %eax
testl %r12d, %r12d
cmovnsl %r12d, %eax
movq -0x40(%rbp), %rcx
leal (%rcx,%r15,2), %ecx
sarl $0x2, %eax
addl %ecx, %eax
imull -0x2c(%rbp), %eax
cltq
imulq $0x51eb851f, %rax, %rax # imm = 0x51EB851F
movq %rax, %rcx
sarq $0x25, %rcx
shrq $0x3f, %rax
addl %ecx, %eax
addl $0x5, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
cvttsd2si %xmm0, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r14, %rdi
je 0xeb39
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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, %r12
movq %rdx, -0x38(%rbp)
movq %rsi, %r15
movq %rdi, %rbx
cmpb $0x0, 0x10b22(%rip)     # 0x1f688
jne 0xeb8a
leaq -0x29(%rbp), %r13
movq %r13, %rdi
callq 0xe068
leaq 0x10add(%rip), %rsi     # 0x1f658
movq %r13, %rdi
callq 0x5284
movb $0x1, 0x10afe(%rip)     # 0x1f688
leaq -0x68(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %r13
movq %r13, %rdi
callq 0x8870
movq %r15, %rdi
movq -0x38(%rbp), %rsi
movq %r13, %rdx
callq 0xec9a
movl %eax, %r13d
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0xebd1
movq -0x68(%rbp), %rsi
incq %rsi
callq 0x21b0
cmpl $-0x1, %r13d
je 0xec23
leaq -0x48(%rbp), %r14
movq %r14, -0x10(%r14)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x8870
movq %rbx, %rdi
movq %r15, %rsi
movq -0x38(%rbp), %rdx
movl %r13d, %ecx
movq %r12, %r8
callq 0xedc5
movq -0x58(%rbp), %rdi
cmpq %r14, %rdi
je 0xec60
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0xec60
pxor %xmm0, %xmm0
movdqu %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movl $0x18, %edi
callq 0x21a0
movq %rax, (%rbx)
movq %rax, 0x8(%rbx)
leaq 0x18(%rax), %rcx
movq %rcx, 0x10(%rbx)
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rax)
movq $-0x1, 0x10(%rax)
movq %rcx, 0x8(%rbx)
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0xec82
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r14, %rdi
je 0xec92
movq (%r14), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x48, %rsp
movq %rdx, -0x48(%rbp)
movq %rsi, -0x40(%rbp)
movq %rdi, -0x38(%rbp)
xorl %ebx, %ebx
leaq -0x58(%rbp), %r12
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl (%rax), %eax
leal (%rbx,%rax,2), %eax
addl $0x6e, %eax
movq -0x38(%rbp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
je 0xed94
movl $0x1, %r13d
xorl %ecx, %ecx
movl %ecx, -0x30(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r13,4), %r15d
movq %r12, -0x68(%rbp)
movq -0x48(%rbp), %rax
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq -0x68(%rbp), %r14
movq %r14, %rdi
callq 0x8870
movl %r13d, %edi
movl %r15d, %esi
xorl %edx, %edx
movl %ebx, %ecx
movl $0x64, %r8d
movq %r14, %r9
callq 0xea66
movl %eax, %r15d
movq %rbx, %r14
movq -0x38(%rbp), %rax
movq (%rax), %rax
movl (%rax,%r13,4), %ebx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xed4d
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
cmpl %ebx, %r15d
je 0xed6f
cmpq $0x5, %r13
leaq 0x1(%r13), %rax
setae %cl
movq %rax, %r13
cmpq $0x6, %rax
movq %r14, %rbx
jne 0xece3
jmp 0xed78
movq %r14, %rbx
movl %ebx, -0x2c(%rbp)
movl -0x30(%rbp), %ecx
testb $0x1, %cl
je 0xed8f
incl %ebx
cmpl $0x20, %ebx
jne 0xecbd
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0xed94
movl -0x2c(%rbp), %eax
movl %eax, %ebx
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r12, %rdi
je 0xedbd
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21b0
movq %rbx, %rdi
callq 0x22d0