LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::DexIDToTypeVectorMapHelper(std::map<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::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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>&)
void MapGenerator::DexIDToTypeVectorMapHelper(map<string,vector<string> > &m) {
	m.clear();
	ifstream fin(TYPESFILE);
	string type;
	string DexID;
	int numTypes;
	while(fin >> DexID) {
		fin >> numTypes;
		for(int i = 0; i < numTypes; i++) {
			fin >> type;
			m[DexID].push_back(type);
		}		
	}
	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 0x8d30
leaq 0x12c5e(%rip), %rsi     # 0x16034
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 -0x50(%rbp), %r15
leaq -0x70(%rbp), %r13
movq %r14, %rdi
movq %r15, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x346a
movq %r14, %rdi
leaq -0x2c(%rbp), %rsi
callq 0x2110
cmpl $0x0, -0x2c(%rbp)
jle 0x3410
xorl %r12d, %r12d
movq %r14, %rdi
movq %r13, %rsi
callq 0x2220
movq %rbx, %rdi
movq %r15, %rsi
callq 0x589a
movq %rax, %rdi
movq %r13, %rsi
callq 0x591a
incl %r12d
cmpl -0x2c(%rbp), %r12d
jl 0x343e
jmp 0x3410
leaq -0x278(%rbp), %rdi
callq 0x2060
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x348f
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x34a8
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 0x34ca
jmp 0x34ca
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x34e6
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x34ff
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x278(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::NameToEntryIDVectorMapHelper(std::map<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::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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>&)
void MapGenerator::NameToEntryIDVectorMapHelper(map<string, vector<string> > &m) {
	m.clear();
	//ifstream fin(ENTRYFILE);
	map<string, string> dtn;
	DexIDToNameMap(dtn);
	map<string, vector<string> > dte;
	DexIDToEntryIDVectorMap(dte);
	for( 	map<string, vector<string> >::iterator it = dte.begin(); it != dte.end(); it++) {
		m[dtn[it->first]] = it->second;
	}
	//fin.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x8d30
leaq -0x78(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x1b49d(%rip), %rsi     # 0x1f218
leaq -0x80(%rbp), %rdi
callq 0x673c
leaq -0x48(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x1b4cb(%rip), %rsi     # 0x1f278
leaq -0x50(%rbp), %rdi
callq 0x6acc
movq -0x38(%rbp), %r14
cmpq %r12, %r14
je 0x3df6
leaq -0x80(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x581a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x589a
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x5966
movq %r14, %rdi
callq 0x2130
movq %rax, %r14
cmpq %r12, %rax
jne 0x3dc3
leaq -0x50(%rbp), %rdi
callq 0x62b4
leaq -0x80(%rbp), %rdi
callq 0x6204
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3e1c
movq %rax, %rbx
jmp 0x3e28
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x62b4
leaq -0x80(%rbp), %rdi
callq 0x6204
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/chulchultrain[P]FactoryHead/MapGenerator/MapGenerator.cpp
// Function: MapGenerator::MoveNameToEntryIDVectorMapHelper(std::map<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::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<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::allocator<std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>>>>>>&)
void MapGenerator::MoveNameToEntryIDVectorMapHelper(map<string, vector<string> > &m) {
	m.clear();
	map<string, MoveData> midtmd; 
	MoveIDToMoveDataMap(midtmd);
	map<string, vector<string> > midteid;
	MoveIDtoEntryIDVectorMap(midteid);
	for( 	map<string, vector<string> >::iterator it = midteid.begin(); it != midteid.end(); it++) {
		m[midtmd[it->first].name] = it->second;
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x8d30
leaq -0x78(%rbp), %rax
movl $0x0, (%rax)
xorl %ecx, %ecx
movq %rcx, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
movq %rcx, 0x20(%rax)
leaq 0x1b53d(%rip), %rsi     # 0x1f3c8
leaq -0x80(%rbp), %rdi
callq 0x73e8
leaq -0x48(%rbp), %r12
movl $0x0, (%r12)
xorl %eax, %eax
movq %rax, 0x8(%r12)
movq %r12, 0x10(%r12)
movq %r12, 0x18(%r12)
movq %rax, 0x20(%r12)
leaq 0x1b41b(%rip), %rsi     # 0x1f2d8
leaq -0x50(%rbp), %rdi
callq 0x6acc
movq -0x38(%rbp), %r14
cmpq %r12, %r14
je 0x3f0a
leaq -0x80(%rbp), %r15
leaq 0x20(%r14), %rsi
movq %r15, %rdi
callq 0x5b14
addq $0x20, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x589a
leaq 0x40(%r14), %rsi
movq %rax, %rdi
callq 0x5966
movq %r14, %rdi
callq 0x2130
movq %rax, %r14
cmpq %r12, %rax
jne 0x3ed3
leaq -0x50(%rbp), %rdi
callq 0x62b4
leaq -0x80(%rbp), %rdi
callq 0x6400
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3f30
movq %rax, %rbx
jmp 0x3f3c
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
callq 0x62b4
leaq -0x80(%rbp), %rdi
callq 0x6400
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x248, %rsp            # imm = 0x248
movq %rsi, %rbx
movq %rsi, %rdi
callq 0x97d4
leaq 0x11e92(%rip), %rsi     # 0x16078
leaq -0x268(%rbp), %rdi
movl $0x8, %edx
callq 0x22f0
leaq -0x38(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movl $0x18, %edi
callq 0x21a0
leaq -0x60(%rbp), %r14
movq %rax, (%r14)
movq %rax, %rcx
addq $0x18, %rcx
movq %rcx, 0x10(%r14)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq $0x0, 0x10(%rax)
movq %rcx, 0x8(%r14)
leaq -0x268(%rbp), %r15
leaq -0x48(%rbp), %r12
movq %r15, %rdi
movq %r12, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x4290
xorl %r13d, %r13d
movq -0x60(%rbp), %rsi
addq %r13, %rsi
movq %r15, %rdi
callq 0x2110
addq $0x4, %r13
cmpq $0x18, %r13
jne 0x425f
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5b94
movq %rax, %rdi
movq %r14, %rsi
callq 0x5c14
jmp 0x4243
leaq -0x268(%rbp), %rdi
callq 0x2060
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
leaq -0x38(%rbp), %rbx
je 0x42b5
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %rbx, %rdi
je 0x42ca
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x268(%rbp), %rdi
callq 0x2070
addq $0x248, %rsp            # imm = 0x248
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x42f5
movq %rax, %rbx
leaq -0x38(%rbp), %r14
jmp 0x4311
jmp 0x42f5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
testq %rdi, %rdi
leaq -0x38(%rbp), %r14
je 0x4311
movq -0x50(%rbp), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x48(%rbp), %rdi
cmpq %r14, %rdi
je 0x4326
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x268(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa3bc
leaq 0x10ddd(%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 0x5378
movq %r14, %rdi
movq %r12, %rsi
callq 0x2110
movq %rax, %rdi
movq %r13, %rsi
callq 0x2110
movq %rbx, %rdi
movq %r15, %rsi
callq 0x600e
movq %rax, %rdi
movq %r12, %rsi
callq 0x608e
movl $0x1, (%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x600e
movq %rax, %rdi
movq %r13, %rsi
callq 0x608e
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
jmp 0x530f
leaq -0x258(%rbp), %rdi
callq 0x2060
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x539d
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 0x53bd
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x53d9
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_O3/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 0x10c1a(%rip), %rsi     # 0x16091
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x21e0
movq 0x19f81(%rip), %rbx     # 0x1f410
leaq 0x19f6a(%rip), %r15     # 0x1f400
cmpq %r15, %rbx
je 0x54be
leaq -0x218(%rbp), %r14
leaq 0x40(%rbx), %rdx
movq %r14, %rsi
callq 0x5528
movq %rbx, %rdi
callq 0x2130
movq %rax, %rbx
cmpq %r15, %rax
jne 0x54a2
leaq -0x218(%rbp), %rdi
callq 0x2230
movq 0x19aff(%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 0x5510
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x558e
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 0x5619
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_O3/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 0xa9a0
leaq 0x10a30(%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 0x572d
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 0x60f6
movq %rax, %rdi
movq %r12, %rsi
callq 0x6176
movl %r13d, (%rax)
jmp 0x56de
leaq -0x278(%rbp), %rdi
callq 0x2060
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x5752
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x576b
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 0x578b
movq %rax, %rbx
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0x57a7
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21b0
movq -0x70(%rbp), %rdi
leaq -0x60(%rbp), %rax
cmpq %rax, %rdi
je 0x57c0
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_O3/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 0xaf73
movq (%r13), %rsi
incq %rsi
callq 0x21b0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0xaf8f
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xafab
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x48(%rbp), %rdi
je 0xafc3
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb54c(%rip), %rcx      # 0x16588
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2280
movq 0x28(%rbx), %rdx
leaq 0xb535(%rip), %rcx      # 0x16588
movq -0x40(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2280
movq 0x48(%rbx), %rdx
leaq 0xb51c(%rip), %rcx      # 0x16588
movq %r15, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2280
movq 0x68(%rbx), %rdx
leaq 0xb504(%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 0xb0c2
movq (%r14), %rsi
incq %rsi
callq 0x21b0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0xb0d6
movq (%r13), %rsi
incq %rsi
callq 0x21b0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0xb0f2
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xb10a
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x48(%rbp), %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5966
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 0x5c14
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 0xb2e3
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq -0x50(%rbp), %rax
movq (%rax), %rdi
cmpq -0x30(%rbp), %rdi
je 0xb2ff
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x38(%rbp), %rdi
je 0xb31b
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x60(%rbp), %rdi
callq 0x5fa0
movq -0x68(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xb340
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x48(%rbp), %rdi
je 0xb358
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r13, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb17f(%rip), %rcx      # 0x16588
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2280
movq 0x28(%rbx), %rdx
leaq 0xad42(%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 0xb145(%rip), %rdx      # 0x16588
leaq -0x80(%rbp), %rdi
movq %rdx, %rsi
callq 0x9c10
leaq -0x80(%rbp), %rdx
movl $0x4, %esi
movq -0x60(%rbp), %rdi
callq 0xb69a
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xb476
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
movq 0x80(%rbx), %rdx
leaq 0xb104(%rip), %rcx      # 0x16588
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
movq %r15, %r12
callq 0x2280
movq 0x60(%rbx), %rdx
leaq 0xb0e9(%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 0xb6d8
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xb4f5
movq %rax, -0x30(%rbp)
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xb4f9
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0xb4f9
jmp 0xb4f5
movq %r12, %r15
movq %rax, -0x30(%rbp)
movq (%r14), %rdi
testq %rdi, %rdi
je 0xb510
movq 0xa8(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%r13), %rdi
cmpq -0x38(%rbp), %rdi
je 0xb529
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xb545
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x60(%rbp), %rdi
callq 0x5fa0
movq (%r15), %rdi
cmpq -0x48(%rbp), %rdi
je 0xb566
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0xb57e
movq -0x50(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq -0x30(%rbp), %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/chulchultrain[P]FactoryHead/EntryData/EntryData.cpp
// Function: operator==(EntryData const&, EntryData const&)
bool operator == (const EntryData &lhs, const EntryData &rhs) {
	if(lhs.ID != rhs.ID) {
	//	cout << "FAIL HERE\n";
		return false;

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

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

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq 0x8(%rdi), %rdx
cmpq 0x8(%rsi), %rdx
jne 0xb691
movq %rsi, %rbx
movq %rdi, %r14
testq %rdx, %rdx
je 0xb5ba
movq (%rbx), %rsi
movq (%r14), %rdi
callq 0x21c0
testl %eax, %eax
jne 0xb691
movq 0x28(%r14), %rdx
cmpq 0x28(%rbx), %rdx
jne 0xb691
testq %rdx, %rdx
je 0xb5e2
movq 0x20(%rbx), %rsi
movq 0x20(%r14), %rdi
callq 0x21c0
testl %eax, %eax
jne 0xb691
movq 0x40(%r14), %rdi
movq 0x48(%r14), %rsi
movq %rsi, %rax
subq %rdi, %rax
movq 0x40(%rbx), %rdx
movq 0x48(%rbx), %rcx
subq %rdx, %rcx
cmpq %rcx, %rax
jne 0xb691
callq 0xbdee
testb %al, %al
je 0xb691
movq 0x80(%r14), %rdx
cmpq 0x80(%rbx), %rdx
jne 0xb691
testq %rdx, %rdx
je 0xb637
movq 0x78(%rbx), %rsi
movq 0x78(%r14), %rdi
callq 0x21c0
testl %eax, %eax
jne 0xb691
movq 0x60(%r14), %rdx
cmpq 0x60(%rbx), %rdx
jne 0xb691
testq %rdx, %rdx
je 0xb657
movq 0x58(%rbx), %rsi
movq 0x58(%r14), %rdi
callq 0x21c0
testl %eax, %eax
jne 0xb691
movq 0x98(%r14), %rdi
movq 0xa0(%r14), %rax
movq %rax, %rdx
subq %rdi, %rdx
movq 0x98(%rbx), %rsi
movq 0xa0(%rbx), %rcx
subq %rsi, %rcx
cmpq %rcx, %rdx
jne 0xb691
movb $0x1, %bl
cmpq %rdi, %rax
je 0xb693
callq 0x21c0
testl %eax, %eax
je 0xb693
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x1374e(%rip)     # 0x1f5e0
jne 0xbea0
callq 0xbf3c
movb $0x1, 0x13740(%rip)     # 0x1f5e0
leaq -0xd8(%rbp), %rdi
callq 0xb360
leaq -0xd8(%rbp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xbfce
leaq -0xd8(%rbp), %rdi
callq 0x5f04
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xbeee
movq %rax, %r14
leaq -0xd8(%rbp), %rdi
callq 0x5f04
jmp 0xbef1
movq %rax, %r14
leaq 0x20(%rbx), %r13
leaq 0x38(%rbx), %r15
leaq 0x50(%rbx), %rdi
callq 0x5fa0
movq %r15, %rdi
callq 0xdfa4
movq (%r13), %rdi
testq %rdi, %rdi
je 0xbf1f
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xbf33
movq (%r12), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xe020
leaq 0x1353b(%rip), %rsi     # 0x1f490
movq %rbx, %rdi
callq 0x2e1c
leaq 0x135bc(%rip), %rsi     # 0x1f520
movq %rbx, %rdi
callq 0x41ac
leaq 0x1360d(%rip), %rsi     # 0x1f580
movq %rbx, %rdi
callq 0x4994
leaq 0x135ce(%rip), %rsi     # 0x1f550
movq %rbx, %rdi
callq 0x339c
leaq 0x1361f(%rip), %rsi     # 0x1f5b0
movq %rbx, %rdi
callq 0x3198
leaq 0x13520(%rip), %rsi     # 0x1f4c0
movq %rbx, %rdi
callq 0x3f4e
leaq 0x13669(%rip), %rsi     # 0x1f618
movq %rbx, %rdi
callq 0x566a
leaq 0x13532(%rip), %rsi     # 0x1f4f0
movq %rbx, %rdi
callq 0x3f62
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x13362(%rip)     # 0x1f5e0
jne 0xc28c
callq 0xbf3c
movb $0x1, 0x13354(%rip)     # 0x1f5e0
leaq 0x132ed(%rip), %rdi     # 0x1f580
movq %r15, %rsi
callq 0x5e84
leaq -0xd8(%rbp), %rdi
movq %rax, %rsi
callq 0x7bf6
leaq -0xd8(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xbfce
leaq -0xd8(%rbp), %rdi
callq 0x5f04
addq $0xb8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc2ed
movq %rax, %r14
leaq -0xd8(%rbp), %rdi
callq 0x5f04
jmp 0xc2f0
movq %rax, %r14
leaq 0x20(%rbx), %r13
leaq 0x38(%rbx), %r15
leaq 0x50(%rbx), %rdi
callq 0x5fa0
movq %r15, %rdi
callq 0xdfa4
movq (%r13), %rdi
testq %rdi, %rdi
je 0xc31e
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xc332
movq (%r12), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x13249(%rip)     # 0x1f5e0
jne 0xc3a5
callq 0xbf3c
movb $0x1, 0x1323b(%rip)     # 0x1f5e0
movq %r14, %rdi
movq %r15, %rsi
movl %r12d, %edx
callq 0xbfce
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq %r13, %rdi
callq 0x5fa0
movq -0x30(%rbp), %rdi
callq 0xdfa4
movq -0x38(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
je 0xc3ee
movq 0x30(%r14), %rsi
subq %rdi, %rsi
callq 0x21b0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23b8
movq %r15, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, 0x1317a(%rip)     # 0x1f5e0
movq %rdi, -0x40(%rbp)
jne 0xc478
callq 0xbf3c
movb $0x1, 0x13168(%rip)     # 0x1f5e0
movq %rbx, %rdi
movq %r12, %rsi
callq 0x20f0
movq -0x48(%rbp), %rdi
movq %r14, %rsi
callq 0x5c14
movq (%r15), %rsi
movq %r15, %rdi
callq 0xe280
movq (%r13), %rax
cmpq %rax, 0x8(%r13)
je 0xc4f6
movl $0x1, %ebx
xorl %esi, %esi
leaq 0x1303e(%rip), %r14     # 0x1f4f0
leaq 0x13007(%rip), %r12     # 0x1f4c0
shlq $0x5, %rsi
addq %rax, %rsi
movq %r14, %rdi
callq 0x581a
movq %r12, %rdi
movq %rax, %rsi
callq 0x5b14
movq %r15, %rdi
movq %rax, %rsi
callq 0xdfe2
movl %ebx, %esi
movq (%r13), %rax
movq 0x8(%r13), %rcx
subq %rax, %rcx
sarq $0x5, %rcx
incl %ebx
cmpq %rsi, %rcx
ja 0xc4b9
leaq 0x12f93(%rip), %rdi     # 0x1f490
movq -0x40(%rbp), %rsi
callq 0x581a
leaq 0x13043(%rip), %rdi     # 0x1f550
movq %rax, %rsi
callq 0x589a
movq -0x38(%rbp), %rdi
movq %rax, %rsi
callq 0x5966
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xc532
movq %rax, %r14
movq -0x38(%rbp), %rdi
callq 0x5fa0
movq %r15, %rdi
callq 0xdfa4
movq -0x48(%rbp), %rax
movq (%rax), %rdi
testq %rdi, %rdi
movq -0x40(%rbp), %rbx
je 0xc562
movq 0x30(%rbx), %rsi
subq %rdi, %rsi
callq 0x21b0
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0xc57a
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0xafcc
testl %r14d, %r14d
js 0xc62d
movq 0x38(%r15), %rsi
movq 0x40(%r15), %rax
subq %rsi, %rax
shrq $0x3, %rax
imull $0xf0f0f0f1, %eax, %eax # imm = 0xF0F0F0F1
cmpl %r14d, %eax
jle 0xc62d
movl %r14d, %eax
movq %rax, %rcx
shlq $0x7, %rcx
leaq (%rcx,%rax,8), %rax
addq %rax, %rsi
movq %rbx, %rdi
callq 0x776c
leaq -0x30(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc73e
movq -0x30(%rbp), %rsi
incq %rsi
callq 0x21b0
jmp 0xc73e
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
leaq -0x90(%rbp), %rcx
movq -0x10(%rcx), %rdx
cmpq %rcx, %rdx
je 0xc654
movq %rdx, (%rbx)
movq -0x90(%rbp), %rax
movq %rax, 0x10(%rbx)
jmp 0xc65a
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 0xc695
movq %rdx, 0x20(%rbx)
movq -0x70(%rbp), %rcx
movq %rcx, 0x30(%rbx)
jmp 0xc69b
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 0xc6d6
movq %rdx, 0x40(%rbx)
movq -0x50(%rbp), %rax
movq %rax, 0x50(%rbx)
jmp 0xc6dc
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 0xc717
movq %rdx, 0x60(%rbx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x70(%rbx)
jmp 0xc71d
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 -0x50(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc757
movq -0x50(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x70(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc770
movq -0x70(%rbp), %rsi
incq %rsi
callq 0x21b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xc78f
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 0x5d02
movq %rbx, %rdi
callq 0x22d0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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), %rbx
movq %rdi, -0x30(%rbp)
movq 0x40(%rdi), %rax
subq %rbx, %rax
je 0xc85a
movq %rdx, %r15
sarq $0x3, %rax
movabsq $-0xf0f0f0f0f0f0f0f, %r14 # imm = 0xF0F0F0F0F0F0F0F1
imulq %rax, %r14
movq 0x8(%rdx), %r13
xorl %r12d, %r12d
movq %r12, %rax
shlq $0x7, %rax
leaq (%rax,%r12,8), %rax
cmpq %r13, 0x28(%rbx,%rax)
jne 0xc850
testq %r13, %r13
je 0xc85d
addq %rbx, %rax
addq $0x20, %rax
movq (%r15), %rsi
movq (%rax), %rdi
movq %r13, %rdx
callq 0x21c0
testl %eax, %eax
je 0xc85d
incl %r12d
cmpq %r12, %r14
ja 0xc820
jmp 0xc85d
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 0xc87c
nop
// File: /workspace/github_cpp_makefile_star2_O3/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, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x38(%rbp)
movq %rax, (%rdi)
leaq 0x86db(%rip), %rdx      # 0x16588
movq %rdx, %rsi
callq 0x9c10
testl %r15d, %r15d
je 0xdf6d
movl %r15d, %r14d
negl %r14d
movl %r15d, -0x2c(%rbp)
cmovsl %r15d, %r14d
movl $0xcccccccd, %r12d      # imm = 0xCCCCCCCD
leaq -0x58(%rbp), %r15
movl %r14d, %r13d
imulq %r12, %r13
shrq $0x23, %r13
leal (,%r13,2), %eax
leal (%rax,%rax,4), %eax
movl %r14d, %ecx
subl %eax, %ecx
orb $0x30, %cl
movzbl %cl, %esi
movq %r15, %rdi
movq %rbx, %rdx
callq 0xe16e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2210
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xdf26
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21b0
cmpl $0xa, %r14d
movl %r13d, %r14d
jae 0xded6
cmpl $0x0, -0x2c(%rbp)
jns 0xdf6d
leaq -0x58(%rbp), %rdi
movl $0x2d, %esi
movq %rbx, %rdx
callq 0xe16e
leaq -0x58(%rbp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2210
movq (%r14), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xdf6d
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 0xdf81
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x38(%rbp), %rdi
je 0xdf9c
movq -0x38(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x21b0
movq %r14, %rdi
callq 0x22d0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1145a(%rip), %r14     # 0x1f488
cmpb $0x0, (%r14)
jne 0xe11d
movq %rdi, %rbx
leaq 0x11176(%rip), %rsi     # 0x1f1b8
callq 0x2e30
leaq 0x1119a(%rip), %rsi     # 0x1f1e8
movq %rbx, %rdi
callq 0x3034
leaq 0x1130b(%rip), %rsi     # 0x1f368
movq %rbx, %rdi
callq 0x3f76
leaq 0x111ac(%rip), %rsi     # 0x1f218
movq %rbx, %rdi
callq 0x31ac
leaq 0x111cd(%rip), %rsi     # 0x1f248
movq %rbx, %rdi
callq 0x33b0
leaq 0x111ee(%rip), %rsi     # 0x1f278
movq %rbx, %rdi
callq 0x3528
leaq 0x1126f(%rip), %rsi     # 0x1f308
movq %rbx, %rdi
callq 0x3d3e
leaq 0x112f0(%rip), %rsi     # 0x1f398
movq %rbx, %rdi
callq 0x41c0
leaq 0x11311(%rip), %rsi     # 0x1f3c8
movq %rbx, %rdi
callq 0x433a
leaq 0x11332(%rip), %rsi     # 0x1f3f8
movq %rbx, %rdi
callq 0x49a8
leaq 0x11353(%rip), %rsi     # 0x1f428
movq %rbx, %rdi
callq 0x52b6
leaq 0x111c4(%rip), %rsi     # 0x1f2a8
movq %rbx, %rdi
callq 0x3772
leaq 0x111e5(%rip), %rsi     # 0x1f2d8
movq %rbx, %rdi
callq 0x3a6e
leaq 0x11236(%rip), %rsi     # 0x1f338
movq %rbx, %rdi
callq 0x3e4e
leaq 0x11347(%rip), %rsi     # 0x1f458
movq %rbx, %rdi
callq 0x567e
movb $0x1, (%r14)
popq %rbx
popq %r14
popq %rbp
retq