LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::MoveNameToMoveIDMapHelper(std::map<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::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::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>&)
void MapGenerator::MoveNameToMoveIDMapHelper(map <string, string> &m) {
	m.clear();
	ifstream fin(MOVESFILE);
	string MoveID;
	string moveName;
	string discard;
	while(getline(fin,MoveID) ) {
		getline(fin,moveName);
		getline(fin,discard);
		while(discard != "") {
			getline(fin,discard);
		}
		m[moveName] = MoveID;
	}
	fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x6920
leaq -0x218(%rbp), %rdi
leaq 0x2a0eb(%rip), %rsi     # 0x2f045
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x278(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3080
movq %rax, -0x290(%rbp)
jmp 0x4fa4
movq -0x290(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x291(%rbp)
jmp 0x4fc2
movb -0x291(%rbp), %al
testb $0x1, %al
jne 0x4fd1
jmp 0x50b2
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3080
jmp 0x4fe6
leaq -0x218(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x3080
jmp 0x4ffb
jmp 0x4ffd
leaq 0x2a55c(%rip), %rsi     # 0x2f560
leaq -0x278(%rbp), %rdi
callq 0x6bc0
movb %al, -0x292(%rbp)
jmp 0x5018
movb -0x292(%rbp), %al
testb $0x1, %al
jne 0x5024
jmp 0x507f
leaq -0x218(%rbp), %rdi
leaq -0x278(%rbp), %rsi
callq 0x3080
jmp 0x5039
jmp 0x4ffd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x280(%rbp)
movl %eax, -0x284(%rbp)
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x50f9
movq -0x10(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x6940
movq %rax, -0x2a0(%rbp)
jmp 0x5098
movq -0x2a0(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3050
jmp 0x50ad
jmp 0x4f88
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x50c0
leaq -0x278(%rbp), %rdi
callq 0x3180
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x280(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::DexIDToBaseStatsMapHelper(std::map<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<int, std::allocator<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::vector<int, std::allocator<int>>>>>&)
void MapGenerator::DexIDToBaseStatsMapHelper(map <string, vector<int> > &m) {
	m.clear();
	ifstream fin(STATSFILE);
	string DexID;
	
	vector<int> s(6);
	while(fin >> DexID) {
		for(int i = 0; i < 6; i++)
			fin >> s[i];
		
		m[DexID] = s;
	}
	fin.close();
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7080
leaq 0x29ef9(%rip), %rsi     # 0x2f05c
leaq -0x218(%rbp), %rdi
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x251(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x70a0
movq -0x270(%rbp), %rdx
leaq -0x250(%rbp), %rdi
movl $0x6, %esi
callq 0x70c0
jmp 0x51ad
leaq -0x251(%rbp), %rdi
callq 0x7130
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3320
movq %rax, -0x278(%rbp)
jmp 0x51d5
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x279(%rbp)
jmp 0x51f3
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x5202
jmp 0x52c2
movl $0x0, -0x268(%rbp)
cmpl $0x6, -0x268(%rbp)
jge 0x528f
movslq -0x268(%rbp), %rsi
leaq -0x250(%rbp), %rdi
callq 0x7150
movq %rax, %rsi
leaq -0x218(%rbp), %rdi
callq 0x3170
jmp 0x5239
jmp 0x523b
movl -0x268(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x268(%rbp)
jmp 0x520c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x251(%rbp), %rdi
callq 0x7130
jmp 0x52fd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x260(%rbp)
movl %eax, -0x264(%rbp)
leaq -0x250(%rbp), %rdi
callq 0x74a0
jmp 0x52fd
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x7170
movq %rax, -0x288(%rbp)
jmp 0x52a8
movq -0x288(%rbp), %rdi
leaq -0x250(%rbp), %rsi
callq 0x7250
jmp 0x52bd
jmp 0x51b9
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x52d0
leaq -0x250(%rbp), %rdi
callq 0x74a0
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
movq -0x260(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x290, %rsp            # imm = 0x290
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7bf0
leaq -0x218(%rbp), %rdi
leaq 0x28f53(%rip), %rsi     # 0x2f09d
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3320
movq %rax, -0x258(%rbp)
jmp 0x617c
movq -0x258(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x259(%rbp)
jmp 0x619a
movb -0x259(%rbp), %al
testb $0x1, %al
jne 0x61a9
jmp 0x628f
leaq -0x218(%rbp), %rdi
leaq -0x23c(%rbp), %rsi
callq 0x3170
movq %rax, -0x268(%rbp)
jmp 0x61c5
movq -0x268(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x3170
jmp 0x61da
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x7c10
movq %rax, -0x270(%rbp)
jmp 0x61f3
movq -0x270(%rbp), %rdi
leaq -0x23c(%rbp), %rsi
callq 0x7cf0
movq %rax, -0x278(%rbp)
jmp 0x620f
movq -0x278(%rbp), %rax
movl $0x1, (%rax)
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x7c10
movq %rax, -0x280(%rbp)
jmp 0x6235
movq -0x280(%rbp), %rdi
leaq -0x240(%rbp), %rsi
callq 0x7cf0
movq %rax, -0x288(%rbp)
jmp 0x6251
movq -0x288(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x6160
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x248(%rbp)
movl %eax, -0x24c(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x62be
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x629d
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x248(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
leaq -0x208(%rbp), %rdi
leaq 0x28d3d(%rip), %rsi     # 0x2f075
movl $0x10, %edx
callq 0x32a0
leaq 0x41157(%rip), %rdi     # 0x474a0
callq 0x7dd0
movq %rax, -0x210(%rbp)
leaq 0x41144(%rip), %rdi     # 0x474a0
callq 0x7e30
movq %rax, -0x218(%rbp)
leaq -0x210(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x7e00
testb $0x1, %al
jne 0x6381
jmp 0x63e2
leaq -0x210(%rbp), %rdi
callq 0x7e60
movq -0x238(%rbp), %rdi
movq %rax, %rdx
addq $0x20, %rdx
leaq -0x208(%rbp), %rsi
callq 0x6420
jmp 0x63a9
jmp 0x63ab
leaq -0x210(%rbp), %rdi
xorl %esi, %esi
callq 0x7e80
movq %rax, -0x230(%rbp)
jmp 0x6355
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x3390
jmp 0x6405
leaq -0x208(%rbp), %rdi
callq 0x3370
jmp 0x63f0
leaq -0x208(%rbp), %rdi
callq 0x3390
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x3210
movq %rax, %rdi
movl $0xa, %esi
callq 0x32d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x3210
movq %rax, %rdi
movl $0xa, %esi
callq 0x32d0
movl $0x0, -0x1c(%rbp)
cmpl $0x4, -0x1c(%rbp)
jae 0x64b7
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rdi
addq $0x40, %rdi
movl -0x1c(%rbp), %eax
movl %eax, %esi
callq 0x80d0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x3210
movq %rax, %rdi
movl $0xa, %esi
callq 0x32d0
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6473
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x58, %rsi
callq 0x3210
movq %rax, %rdi
movl $0xa, %esi
callq 0x32d0
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
callq 0x3210
movq %rax, %rdi
movl $0xa, %esi
callq 0x32d0
movl $0x0, -0x20(%rbp)
cmpl $0x6, -0x20(%rbp)
jae 0x6540
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
addq $0x98, %rdi
movl -0x20(%rbp), %eax
movl %eax, %esi
callq 0x80f0
movq -0x30(%rbp), %rdi
movl (%rax), %esi
callq 0x3400
movq %rax, %rdi
movl $0xa, %esi
callq 0x32d0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x64fa
movq -0x10(%rbp), %rdi
movl $0xa, %esi
callq 0x32d0
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x2a0, %rsp            # imm = 0x2A0
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x7ef0
leaq -0x218(%rbp), %rdi
leaq 0x28afe(%rip), %rsi     # 0x2f0b8
movl $0x8, %edx
callq 0x3440
leaq -0x238(%rbp), %rdi
callq 0x3360
leaq -0x258(%rbp), %rdi
callq 0x3360
leaq -0x218(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3320
movq %rax, -0x278(%rbp)
jmp 0x65f8
movq -0x278(%rbp), %rdi
movq (%rdi), %rax
movq -0x18(%rax), %rax
addq %rax, %rdi
callq 0x3310
movb %al, -0x279(%rbp)
jmp 0x6616
movb -0x279(%rbp), %al
testb $0x1, %al
jne 0x6625
jmp 0x66dc
leaq -0x218(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x3320
jmp 0x663a
leaq -0x218(%rbp), %rdi
leaq -0x25c(%rbp), %rsi
callq 0x3170
jmp 0x664f
movl -0x25c(%rbp), %eax
movl %eax, -0x28c(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x7f10
movq %rax, -0x288(%rbp)
jmp 0x6674
movq -0x288(%rbp), %rdi
leaq -0x258(%rbp), %rsi
callq 0x7ff0
movq %rax, -0x298(%rbp)
jmp 0x6690
movq -0x298(%rbp), %rax
movl -0x28c(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x65dc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x268(%rbp)
movl %eax, -0x26c(%rbp)
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
jmp 0x6717
leaq -0x218(%rbp), %rdi
callq 0x3090
jmp 0x66ea
leaq -0x258(%rbp), %rdi
callq 0x3180
leaq -0x238(%rbp), %rdi
callq 0x3180
leaq -0x218(%rbp), %rdi
callq 0x30a0
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbp
retq
movq -0x268(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x48(%rbp)
movq %rdx, -0x88(%rbp)
movq %rcx, -0x80(%rbp)
movq %r8, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x70(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3050
jmp 0x1a18c
movq -0x88(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x20, %rdi
callq 0x3050
jmp 0x1a1a2
movq -0x80(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x40, %rdi
callq 0x3050
jmp 0x1a1b5
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
addq $0x60, %rdi
callq 0x3050
jmp 0x1a1c8
movq -0x70(%rbp), %rax
movl -0x2c(%rbp), %ecx
movl %ecx, 0x80(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x3180
movq -0x60(%rbp), %rdi
callq 0x3180
movq -0x68(%rbp), %rdi
callq 0x3180
movq -0x50(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: chulchultrain[P]FactoryHead/MoveData/MoveData.cpp
// Function: MoveData::MoveData()
MoveData::MoveData() {
	ID = "";
	name = "";
	type = "";
	category = "";
	damage = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x3360
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x38(%rbp)
callq 0x3360
movq -0x20(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x30(%rbp)
callq 0x3360
movq -0x20(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3360
movq -0x20(%rbp), %rdi
leaq 0x152e2(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a285
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
leaq 0x152cc(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a29b
movq -0x40(%rbp), %rdi
addq $0x40, %rdi
leaq 0x152b6(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a2b1
movq -0x40(%rbp), %rdi
addq $0x60, %rdi
leaq 0x152a0(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a2c7
movq -0x40(%rbp), %rax
movl $0x0, 0x80(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x3180
movq -0x30(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x3180
movq -0x20(%rbp), %rdi
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a343
jmp 0x1a34c
movb $0x0, -0x1(%rbp)
jmp 0x1a3cf
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a367
jmp 0x1a36d
movb $0x0, -0x1(%rbp)
jmp 0x1a3cf
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a388
jmp 0x1a38e
movb $0x0, -0x1(%rbp)
jmp 0x1a3cf
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
movq -0x18(%rbp), %rsi
addq $0x60, %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a3a9
jmp 0x1a3af
movb $0x0, -0x1(%rbp)
jmp 0x1a3cf
movq -0x10(%rbp), %rax
movl 0x80(%rax), %eax
movq -0x18(%rbp), %rcx
cmpl 0x80(%rcx), %eax
je 0x1a3cb
movb $0x0, -0x1(%rbp)
jmp 0x1a3cf
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %r9, -0x98(%rbp)
movq %r8, -0x90(%rbp)
movq %rdx, -0x88(%rbp)
movq %rsi, -0x48(%rbp)
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x78(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x70(%rbp)
callq 0x12040
movq -0x50(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x68(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3360
movq -0x50(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x58(%rbp)
callq 0x14de0
movq -0x50(%rbp), %rdi
movq -0x48(%rbp), %rsi
callq 0x3050
jmp 0x1a5db
movq -0x88(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x20, %rdi
callq 0x3050
jmp 0x1a5f1
movq -0x80(%rbp), %rdi
movq -0x20(%rbp), %rsi
addq $0x40, %rdi
callq 0x6ce0
jmp 0x1a604
movq -0x90(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x58, %rdi
callq 0x3050
jmp 0x1a61a
movq -0x98(%rbp), %rsi
movq -0x80(%rbp), %rdi
addq $0x78, %rdi
callq 0x3050
jmp 0x1a630
movq -0x80(%rbp), %rdi
movq 0x10(%rbp), %rsi
addq $0x98, %rdi
callq 0x7250
jmp 0x1a646
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
callq 0x74a0
movq -0x60(%rbp), %rdi
callq 0x3180
movq -0x68(%rbp), %rdi
callq 0x3180
movq -0x70(%rbp), %rdi
callq 0x7b40
movq -0x78(%rbp), %rdi
callq 0x3180
movq -0x50(%rbp), %rdi
callq 0x3180
movq -0x38(%rbp), %rdi
callq 0x3410
nopw (%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
callq 0x3360
movq -0x48(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x70(%rbp)
callq 0x3360
movq -0x48(%rbp), %rdi
addq $0x40, %rdi
movq %rdi, -0x68(%rbp)
callq 0x12040
movq -0x48(%rbp), %rdi
addq $0x58, %rdi
movq %rdi, -0x60(%rbp)
callq 0x3360
movq -0x48(%rbp), %rdi
addq $0x78, %rdi
movq %rdi, -0x58(%rbp)
callq 0x3360
movq -0x48(%rbp), %rdi
addq $0x98, %rdi
movq %rdi, -0x50(%rbp)
callq 0x14de0
movq -0x48(%rbp), %rdi
leaq 0x14e3a(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a72d
movq -0x78(%rbp), %rdi
addq $0x20, %rdi
leaq 0x14a0a(%rip), %rsi     # 0x2f146
callq 0x3350
jmp 0x1a743
movq -0x78(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x88(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3420
movq -0x80(%rbp), %rdx
leaq 0x14df6(%rip), %rsi     # 0x2f560
leaq -0x38(%rbp), %rdi
callq 0x7770
jmp 0x1a775
movq -0x88(%rbp), %rdi
movl $0x4, %esi
leaq -0x38(%rbp), %rdx
callq 0x1a960
jmp 0x1a78c
leaq -0x38(%rbp), %rdi
callq 0x3180
leaq -0x39(%rbp), %rdi
callq 0x3290
movq -0x78(%rbp), %rdi
addq $0x78, %rdi
leaq 0x14db3(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a7b4
movq -0x78(%rbp), %rdi
addq $0x58, %rdi
leaq 0x14d9d(%rip), %rsi     # 0x2f560
callq 0x3350
jmp 0x1a7ca
movq -0x78(%rbp), %rdi
addq $0x98, %rdi
movl $0x0, -0x40(%rbp)
movl $0x6, %esi
leaq -0x40(%rbp), %rdx
callq 0x1aa10
jmp 0x1a7ec
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1a82f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1a826
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3180
leaq -0x39(%rbp), %rdi
callq 0x3290
movq -0x50(%rbp), %rdi
callq 0x74a0
movq -0x58(%rbp), %rdi
callq 0x3180
movq -0x60(%rbp), %rdi
callq 0x3180
movq -0x68(%rbp), %rdi
callq 0x7b40
movq -0x70(%rbp), %rdi
callq 0x3180
movq -0x48(%rbp), %rdi
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x3410
nop
// File: 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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a893
jmp 0x1a89c
movb $0x0, -0x1(%rbp)
jmp 0x1a94e
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a8b7
jmp 0x1a8c0
movb $0x0, -0x1(%rbp)
jmp 0x1a94e
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movq -0x18(%rbp), %rsi
addq $0x40, %rsi
callq 0x1aac0
testb $0x1, %al
jne 0x1a8db
jmp 0x1a8e1
movb $0x0, -0x1(%rbp)
jmp 0x1a94e
movq -0x10(%rbp), %rdi
addq $0x78, %rdi
movq -0x18(%rbp), %rsi
addq $0x78, %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a8fc
jmp 0x1a902
movb $0x0, -0x1(%rbp)
jmp 0x1a94e
movq -0x10(%rbp), %rdi
addq $0x58, %rdi
movq -0x18(%rbp), %rsi
addq $0x58, %rsi
callq 0x1a3e0
testb $0x1, %al
jne 0x1a91d
jmp 0x1a923
movb $0x0, -0x1(%rbp)
jmp 0x1a94e
movq -0x10(%rbp), %rdi
addq $0x98, %rdi
movq -0x18(%rbp), %rsi
addq $0x98, %rsi
callq 0x1aaf0
testb $0x1, %al
jne 0x1a944
jmp 0x1a94a
movb $0x0, -0x1(%rbp)
jmp 0x1a94e
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0xf0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x3360
movq -0xd8(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xe8(%rbp)
callq 0x14de0
movq -0xd8(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xe0(%rbp)
callq 0x1eb90
movq -0xd8(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0xd0(%rbp)
callq 0x12040
testb $0x1, 0x2aacd(%rip)     # 0x47688
jne 0x1cbe2
movq -0xd8(%rbp), %rdi
callq 0x1cc70
jmp 0x1cbcb
movb $0x1, 0x2aab6(%rip)     # 0x47688
jmp 0x1cbe2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
jmp 0x1cc34
leaq -0xc8(%rbp), %rdi
callq 0x1a6a0
jmp 0x1cbf0
movq -0xd8(%rbp), %rdi
leaq -0xc8(%rbp), %rsi
xorl %edx, %edx
callq 0x1cd10
jmp 0x1cc07
leaq -0xc8(%rbp), %rdi
callq 0x7ad0
addq $0xf0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x7ad0
movq -0xd0(%rbp), %rdi
callq 0x7b40
movq -0xe0(%rbp), %rdi
callq 0x1ebb0
movq -0xe8(%rbp), %rdi
callq 0x74a0
movq -0xd8(%rbp), %rdi
callq 0x3180
movq -0x10(%rbp), %rdi
callq 0x3410
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq -0x9(%rbp), %rdi
callq 0x1eca0
leaq -0x9(%rbp), %rdi
leaq 0x2a8a8(%rip), %rsi     # 0x47538
callq 0x3c60
leaq -0x9(%rbp), %rdi
leaq 0x2a928(%rip), %rsi     # 0x475c8
callq 0x5110
leaq -0x9(%rbp), %rdi
leaq 0x2a978(%rip), %rsi     # 0x47628
callq 0x56f0
leaq -0x9(%rbp), %rdi
leaq 0x2a938(%rip), %rsi     # 0x475f8
callq 0x41d0
leaq -0x9(%rbp), %rdi
leaq 0x2a988(%rip), %rsi     # 0x47658
callq 0x4000
leaq -0x9(%rbp), %rdi
leaq 0x2a888(%rip), %rsi     # 0x47568
callq 0x4ed0
leaq -0x9(%rbp), %rdi
leaq 0x2a9d0(%rip), %rsi     # 0x476c0
callq 0x6560
leaq -0x9(%rbp), %rdi
leaq 0x2a898(%rip), %rsi     # 0x47598
callq 0x4f00
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq 0x2a888(%rip), %rdi     # 0x475c8
callq 0x7170
movq %rax, %rsi
leaq -0x30(%rbp), %rdi
callq 0xc3e0
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq 0x2a898(%rip), %rdi     # 0x475f8
callq 0x6a70
movq %rax, -0xa0(%rbp)
jmp 0x1cd6e
movq -0xa0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
addq $0x50, %rdi
callq 0x6ce0
jmp 0x1cd87
movq -0x10(%rbp), %rsi
addq $0x98, %rsi
leaq -0x70(%rbp), %rdi
callq 0xc3e0
jmp 0x1cd9d
movl -0x14(%rbp), %eax
movl %eax, -0xac(%rbp)
movq -0x10(%rbp), %rsi
addq $0x78, %rsi
leaq -0x90(%rbp), %rdi
callq 0x3100
jmp 0x1cdbc
movl -0xac(%rbp), %ecx
leaq -0x58(%rbp), %rdi
leaq -0x30(%rbp), %rsi
leaq -0x70(%rbp), %rdx
leaq -0x90(%rbp), %r8
callq 0x20370
jmp 0x1cddc
movq -0xa8(%rbp), %rdi
addq $0x20, %rdi
leaq -0x58(%rbp), %rsi
movq %rsi, -0xb8(%rbp)
callq 0x1eea0
movq -0xb8(%rbp), %rdi
callq 0x74a0
leaq -0x90(%rbp), %rdi
callq 0x3180
leaq -0x70(%rbp), %rdi
callq 0x74a0
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
movl $0x4, %esi
callq 0x1eed0
jmp 0x1ce2f
movq -0x10(%rbp), %rsi
addq $0x20, %rsi
leaq 0x2a81a(%rip), %rdi     # 0x47658
callq 0x6940
movq %rax, -0xc0(%rbp)
jmp 0x1ce4c
movq -0xc0(%rbp), %rsi
movq -0xa8(%rbp), %rdi
callq 0x3050
jmp 0x1ce61
movl $0x0, -0x94(%rbp)
cmpl $0x4, -0x94(%rbp)
jae 0x1cf20
movq -0x10(%rbp), %rdi
addq $0x40, %rdi
movl -0x94(%rbp), %eax
movl %eax, %esi
callq 0x6c10
movq %rax, %rsi
leaq 0x2a6d1(%rip), %rdi     # 0x47568
callq 0x6f70
movq %rax, -0xc8(%rbp)
jmp 0x1cea5
movq -0xa8(%rbp), %rdi
addq $0x38, %rdi
movl -0x94(%rbp), %eax
movl %eax, %esi
callq 0x1ee00
movq -0xc8(%rbp), %rsi
movq %rax, %rdi
callq 0x7550
jmp 0x1cece
jmp 0x1ced0
movl -0x94(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x94(%rbp)
jmp 0x1ce6b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1cf32
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1cf15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x3180
leaq -0x70(%rbp), %rdi
callq 0x74a0
jmp 0x1cf32
leaq -0x30(%rbp), %rdi
callq 0x74a0
addq $0xd0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x74a0
movq -0x38(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x110, %rsp            # imm = 0x110
movq %rsi, -0x100(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3360
movq -0xe8(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0xf8(%rbp)
callq 0x14de0
movq -0xe8(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0xf0(%rbp)
callq 0x1eb90
movq -0xe8(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0xe0(%rbp)
callq 0x12040
testb $0x1, 0x2a6bf(%rip)     # 0x47688
jne 0x1cff0
movq -0xe8(%rbp), %rdi
callq 0x1cc70
jmp 0x1cfd9
movb $0x1, 0x2a6a8(%rip)     # 0x47688
jmp 0x1cff0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x1d066
movq -0x100(%rbp), %rsi
leaq 0x2a62a(%rip), %rdi     # 0x47628
callq 0x7950
movq %rax, -0x108(%rbp)
jmp 0x1d00c
movq -0x108(%rbp), %rsi
leaq -0xd8(%rbp), %rdi
callq 0xdf20
jmp 0x1d021
movq -0xe8(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq -0xd8(%rbp), %rsi
callq 0x1cd10
jmp 0x1d039
leaq -0xd8(%rbp), %rdi
callq 0x7ad0
addq $0x110, %rsp            # imm = 0x110
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0xd8(%rbp), %rdi
callq 0x7ad0
movq -0xe0(%rbp), %rdi
callq 0x7b40
movq -0xf0(%rbp), %rdi
callq 0x1ebb0
movq -0xf8(%rbp), %rdi
callq 0x74a0
movq -0xe8(%rbp), %rdi
callq 0x3180
movq -0x20(%rbp), %rdi
callq 0x3410
nop
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x3360
movq -0x38(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x48(%rbp)
callq 0x14de0
movq -0x38(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x40(%rbp)
callq 0x1eb90
movq -0x38(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x30(%rbp)
callq 0x12040
testb $0x1, 0x2a58e(%rip)     # 0x47688
jne 0x1d142
movq -0x38(%rbp), %rdi
callq 0x1cc70
jmp 0x1d107
movb $0x1, 0x2a57a(%rip)     # 0x47688
jmp 0x1d142
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x7b40
movq -0x40(%rbp), %rdi
callq 0x1ebb0
movq -0x48(%rbp), %rdi
callq 0x74a0
movq -0x38(%rbp), %rdi
callq 0x3180
jmp 0x1d15a
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x1cd10
jmp 0x1d154
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3410
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rsi, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x40(%rbp)
callq 0x3360
movq -0x40(%rbp), %rdi
addq $0x20, %rdi
movq %rdi, -0x50(%rbp)
callq 0x14de0
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
movq %rdi, -0x48(%rbp)
callq 0x1eb90
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
movq %rdi, -0x38(%rbp)
callq 0x12040
testb $0x1, 0x2a4b2(%rip)     # 0x47688
jne 0x1d221
movq -0x40(%rbp), %rdi
callq 0x1cc70
jmp 0x1d1e3
movb $0x1, 0x2a49e(%rip)     # 0x47688
jmp 0x1d221
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x7b40
movq -0x48(%rbp), %rdi
callq 0x1ebb0
movq -0x50(%rbp), %rdi
callq 0x74a0
movq -0x40(%rbp), %rdi
callq 0x3180
jmp 0x1d322
movq -0x58(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x3050
jmp 0x1d230
movq -0x40(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x20, %rdi
callq 0x7250
jmp 0x1d243
movq -0x40(%rbp), %rdi
addq $0x38, %rdi
callq 0x1ec10
movl $0x0, -0x30(%rbp)
movl -0x30(%rbp), %eax
movq %rax, -0x60(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6bf0
movq %rax, %rcx
movq -0x60(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d2d4
movq -0x40(%rbp), %rax
addq $0x38, %rax
movq %rax, -0x70(%rbp)
movq -0x20(%rbp), %rdi
movl -0x30(%rbp), %eax
movl %eax, %esi
callq 0x6c10
movq %rax, %rsi
leaq 0x2a301(%rip), %rdi     # 0x47598
callq 0x6940
movq %rax, -0x68(%rbp)
jmp 0x1d2a2
movq -0x68(%rbp), %rsi
leaq 0x2a2bb(%rip), %rdi     # 0x47568
callq 0x6f70
movq %rax, -0x78(%rbp)
jmp 0x1d2b8
movq -0x78(%rbp), %rsi
movq -0x70(%rbp), %rdi
callq 0x1ec30
jmp 0x1d2c7
jmp 0x1d2c9
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1d257
movq -0x40(%rbp), %rsi
leaq 0x2a259(%rip), %rdi     # 0x47538
callq 0x6940
movq %rax, -0x80(%rbp)
jmp 0x1d2ea
movq -0x80(%rbp), %rsi
leaq 0x2a303(%rip), %rdi     # 0x475f8
callq 0x6a70
movq %rax, -0x88(%rbp)
jmp 0x1d303
movq -0x88(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x50, %rdi
callq 0x6ce0
jmp 0x1d319
addq $0x90, %rsp
popq %rbp
retq
movq -0x28(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: 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
subq $0xd0, %rsp
movq %rdi, -0xc8(%rbp)
movq %rdi, %rax
movq %rax, -0xc0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xb8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x1a220
cmpl $0x0, -0x14(%rbp)
jl 0x1d41b
movq -0xb8(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, -0xcc(%rbp)
addq $0x38, %rdi
callq 0x1edd0
movq %rax, %rcx
movl -0xcc(%rbp), %eax
cmpl %ecx, %eax
jge 0x1d41b
movq -0xb8(%rbp), %rdi
addq $0x38, %rdi
movslq -0x14(%rbp), %rsi
callq 0x1ee00
movq -0xc8(%rbp), %rdi
movq %rax, %rsi
callq 0xd530
jmp 0x1d3ef
movl $0x1, -0xb0(%rbp)
jmp 0x1d438
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0xa8(%rbp)
movl %eax, -0xac(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x75d0
jmp 0x1d454
movq -0xc8(%rbp), %rdi
leaq -0xa0(%rbp), %rsi
callq 0x1ee20
movl $0x1, -0xb0(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x75d0
movq -0xc0(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x3410
// File: chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::getStat(int)
int PokemonEntry::getStat(int which) {
	if(ws.size() == 6 && which >= 0 && which < 6)
		return ws[which];
	else
		return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x20, %rdi
callq 0xc4d0
cmpq $0x6, %rax
jne 0x1d4aa
cmpl $0x0, -0x14(%rbp)
jl 0x1d4aa
cmpl $0x6, -0x14(%rbp)
jge 0x1d4aa
movq -0x20(%rbp), %rdi
addq $0x20, %rdi
movslq -0x14(%rbp), %rsi
callq 0x7150
movl (%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x1d4b1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x30(%rbp), %rdi
movl -0x28(%rbp), %eax
movq %rax, -0x40(%rbp)
addq $0x38, %rdi
callq 0x1edd0
movq %rax, %rcx
movq -0x40(%rbp), %rax
cmpq %rcx, %rax
jae 0x1d544
movq -0x30(%rbp), %rdi
addq $0x38, %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
callq 0x1ee00
movq -0x38(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rdi
callq 0x1a410
testb $0x1, %al
jne 0x1d52f
jmp 0x1d537
movl -0x28(%rbp), %eax
movl %eax, -0x24(%rbp)
jmp 0x1d544
jmp 0x1d539
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1d4e7
movq -0x30(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl -0x24(%rbp), %edx
callq 0x1d570
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: chulchultrain[P]FactoryHead/PokemonEntry/PokemonEntry.cpp
// Function: PokemonEntry::dmgMultiplier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
double PokemonEntry::dmgMultiplier(string att, string def) {
	int code = typeMul[att][def];
	switch(code) {
		case 0: return 1;
		case 1: return .5;
		case 2: return 2;
		case 3: return 0;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdx, -0x38(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq 0x29dc1(%rip), %rdi     # 0x476c0
callq 0x7f10
movq -0x38(%rbp), %rsi
movq %rax, %rdi
callq 0x7ff0
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq %rax, -0x30(%rbp)
subq $0x3, %rax
ja 0x1d96d
movq -0x30(%rbp), %rax
leaq 0x1186b(%rip), %rcx     # 0x2f198
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movsd 0x11852(%rip), %xmm0    # 0x2f190
movsd %xmm0, -0x8(%rbp)
jmp 0x1d975
movsd 0x1183b(%rip), %xmm0    # 0x2f188
movsd %xmm0, -0x8(%rbp)
jmp 0x1d975
movsd 0x1180c(%rip), %xmm0    # 0x2f168
movsd %xmm0, -0x8(%rbp)
jmp 0x1d975
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x1d975
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
// File: 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
subq $0x90, %rsp
movq %rdi, -0x88(%rbp)
movq %rdi, %rax
movq %rax, -0x90(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x15(%rbp)
leaq -0x16(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x3420
movq -0x88(%rbp), %rdi
movq -0x80(%rbp), %rdx
leaq 0x10b26(%rip), %rsi     # 0x2f560
callq 0x7770
jmp 0x1ea41
leaq -0x16(%rbp), %rdi
callq 0x3290
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
movb $0x0, -0x29(%rbp)
cmpl $0x0, -0x28(%rbp)
jge 0x1ea81
imull $-0x1, -0x28(%rbp), %eax
movl %eax, -0x28(%rbp)
movb $0x1, -0x29(%rbp)
jmp 0x1ea81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x16(%rbp), %rdi
callq 0x3290
jmp 0x1eb82
movb $0x0, -0x31(%rbp)
cmpl $0x0, -0x28(%rbp)
jle 0x1eb26
movq -0x88(%rbp), %rdx
movslq -0x28(%rbp), %rcx
movl %ecx, %eax
imulq $0x66666667, %rcx, %rsi # imm = 0x66666667
movq %rsi, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rsi
addl %ecx, %esi
addl %esi, %esi
movl %esi, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
movl %eax, -0x30(%rbp)
movslq -0x28(%rbp), %rax
imulq $0x66666667, %rax, %rax # imm = 0x66666667
movq %rax, %rcx
shrq $0x3f, %rcx
sarq $0x22, %rax
addl %ecx, %eax
movl %eax, -0x28(%rbp)
movb -0x30(%rbp), %al
addb $0x30, %al
movb %al, -0x31(%rbp)
movsbl -0x31(%rbp), %esi
leaq -0x58(%rbp), %rdi
callq 0x1f0e0
jmp 0x1eaee
movq -0x88(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x32f0
leaq -0x58(%rbp), %rdi
callq 0x3180
jmp 0x1ea85
movq -0x88(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x3180
jmp 0x1eb82
testb $0x1, -0x29(%rbp)
je 0x1eb5c
movq -0x88(%rbp), %rdx
leaq -0x78(%rbp), %rdi
movl $0x2d, %esi
callq 0x1f0e0
jmp 0x1eb43
movq -0x88(%rbp), %rdi
leaq -0x78(%rbp), %rsi
callq 0x32f0
leaq -0x78(%rbp), %rdi
callq 0x3180
movb $0x1, -0x15(%rbp)
testb $0x1, -0x15(%rbp)
jne 0x1eb72
movq -0x88(%rbp), %rdi
callq 0x3180
movq -0x90(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3410
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x28875(%rip), %rax     # 0x47530
testb $0x1, (%rax)
jne 0x1edbe
movq -0x10(%rbp), %rdi
leaq 0x28591(%rip), %rsi     # 0x47260
callq 0x3c90
movq -0x10(%rbp), %rdi
leaq 0x285b1(%rip), %rsi     # 0x47290
callq 0x3e60
movq -0x10(%rbp), %rdi
leaq 0x28721(%rip), %rsi     # 0x47410
callq 0x4f30
movq -0x10(%rbp), %rdi
leaq 0x285c1(%rip), %rsi     # 0x472c0
callq 0x4030
movq -0x10(%rbp), %rdi
leaq 0x285e1(%rip), %rsi     # 0x472f0
callq 0x4200
movq -0x10(%rbp), %rdi
leaq 0x28601(%rip), %rsi     # 0x47320
callq 0x43d0
movq -0x10(%rbp), %rdi
leaq 0x28681(%rip), %rsi     # 0x473b0
callq 0x4b60
movq -0x10(%rbp), %rdi
leaq 0x28701(%rip), %rsi     # 0x47440
callq 0x5140
movq -0x10(%rbp), %rdi
leaq 0x28721(%rip), %rsi     # 0x47470
callq 0x5330
movq -0x10(%rbp), %rdi
leaq 0x28741(%rip), %rsi     # 0x474a0
callq 0x5720
movq -0x10(%rbp), %rdi
leaq 0x28761(%rip), %rsi     # 0x474d0
callq 0x6120
movq -0x10(%rbp), %rdi
leaq 0x285d1(%rip), %rsi     # 0x47350
callq 0x45e0
movq -0x10(%rbp), %rdi
leaq 0x285f1(%rip), %rsi     # 0x47380
callq 0x48f0
movq -0x10(%rbp), %rdi
leaq 0x28641(%rip), %rsi     # 0x473e0
callq 0x4d30
movq -0x10(%rbp), %rdi
leaq 0x28751(%rip), %rsi     # 0x47500
callq 0x6590
leaq 0x28775(%rip), %rax     # 0x47530
movb $0x1, (%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop