LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/havluj[P]spreadsheet/src/CExpressionParser.cpp
// Function: CExpressionParser::ReplaceAll(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, 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>> const&)
void CExpressionParser::ReplaceAll(std::string& str, const std::string& from,
	  const std::string& to) {
    size_t start_pos = 0;

    while ((start_pos = str.find(from, start_pos)) != std::string::npos) {
	  str.replace(start_pos, from.length(), to);
	  start_pos += to.length(); // ...
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
xorl %r12d, %r12d
movq %r15, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x4650
cmpq $-0x1, %rax
je 0xa633
movq %rax, %r12
movq 0x8(%r14), %rdx
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rcx
callq 0x40f0
addq 0x8(%rbx), %r12
jmp 0xa604
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./init.cpp
// Function: main
int main(int argc, char** argv) {
	if(argc != 2){
		std::cout << "Usage ./pdg_cs17 [FileName]\n";
		return 1;
	}
	PDG p(argv[1]);
	if(!p.is_valid()) return print_exit();
	p.cdg();
	p.print_cdg();
	p.plot_cdg();
	p.ddg();
	if(!p.is_valid()) return print_exit();
	p.print_ddg();
	p.plot_ddg();
    return 0;
}

// Assembly:
pushq %rbx
subq $0x2a0, %rsp            # imm = 0x2A0
cmpl $0x2, %edi
jne 0x258e
movq 0x8(%rsi), %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x25ec
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x26c0
leaq 0x10(%rsp), %rdi
callq 0x2100
leaq 0x30(%rsp), %rdi
callq 0x2c46
testb %al, %al
je 0x25a6
leaq 0x30(%rsp), %rdi
callq 0x2c4e
leaq 0x30(%rsp), %rdi
callq 0x2de8
leaq 0x30(%rsp), %rdi
callq 0x2eb6
leaq 0x30(%rsp), %rdi
callq 0x30f8
leaq 0x30(%rsp), %rdi
callq 0x2c46
testb %al, %al
je 0x25a6
leaq 0x30(%rsp), %rdi
callq 0x35a2
xorl %ebx, %ebx
leaq 0x30(%rsp), %rdi
callq 0x3672
jmp 0x25ae
movq 0x5a43(%rip), %rdi      # 0x7fd8
leaq 0x2a78(%rip), %rsi      # 0x5014
callq 0x21b0
pushq $0x1
popq %rbx
jmp 0x25b8
callq 0x24dc
pushq $0x1
popq %rbx
leaq 0x30(%rsp), %rdi
callq 0x2a86
movl %ebx, %eax
addq $0x2a0, %rsp            # imm = 0x2A0
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2100
jmp 0x25e4
movq %rax, %rbx
jmp 0x25e4
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x2a86
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::PDG(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
PDG::PDG(std::string file_name){
 	valid = false;
 	in.open(file_name,std::ios::in);
 	if(in.fail()){
 		std::cout << "Could not open file\n" << file_name << std::endl;
 		return;
 	} else valid = true;
 	total_lines = 0;
 	if(make_program_map())
 		valid = true;
 	else return;
 	if(!allocate_g_cdg())
 		valid = false;
 }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x2220
xorps %xmm0, %xmm0
andq $0x0, 0x228(%rbx)
movups %xmm0, 0x218(%rbx)
andl $0x0, 0x238(%rbx)
andq $0x0, 0x240(%rbx)
leaq 0x218(%rbx), %r14
leaq 0x238(%rbx), %rax
movq %rax, 0x248(%rbx)
movq %rax, 0x250(%rbx)
andq $0x0, 0x258(%rbx)
movb $0x0, 0x210(%rbx)
pushq $0x8
popq %rdx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2290
movq (%rbx), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x20(%rbx,%rax)
je 0x2760
movq 0x5899(%rip), %rdi      # 0x7fd8
leaq 0x292a(%rip), %rsi      # 0x5070
callq 0x21b0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x2110
jmp 0x2794
movb $0x1, 0x210(%rbx)
andl $0x0, 0x214(%rbx)
movq %rbx, %rdi
callq 0x27c2
testb %al, %al
je 0x2794
movb $0x1, 0x210(%rbx)
movq %rbx, %rdi
callq 0x29f6
testb %al, %al
jne 0x2794
movb $0x0, 0x210(%rbx)
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x230(%rbx), %rdi
callq 0x3baa
movq %r14, %rdi
callq 0x3ca6
movq %rbx, %rdi
callq 0x20a0
movq %r15, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::allocate_g_cdg()
bool PDG::allocate_g_cdg(){
 	/* Allocate a graph of total_lines^2 size to **g_cdg */
 	g_cdg = (int**)malloc(sizeof(int*) * (total_lines + 1));
 	if(g_cdg == nullptr) return false;
 	for(int i = 0; i <= total_lines;i++){
 		g_cdg[i] = (int*) malloc(sizeof(int)*(total_lines+1));
 		for(int j = 0;j <= total_lines;j++) g_cdg[i][j] = 0;
 		if(g_cdg[i] == nullptr) return false;
 	}
 	return true;
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x214(%rdi), %r15
leaq 0x8(,%r15,8), %rdi
callq 0x2270
movq %rax, 0x260(%rbx)
testq %rax, %rax
je 0x2a73
movq %rax, %r14
xorl %r12d, %r12d
movslq %r15d, %rax
cmpq %rax, %r12
setg %bpl
jg 0x2a77
leaq 0x4(,%rax,4), %rdi
callq 0x2270
movq %rax, (%r14,%r12,8)
movq 0x260(%rbx), %r14
movq (%r14,%r12,8), %rax
xorl %ecx, %ecx
movslq %r15d, %rdx
cmpq %rdx, %rcx
jg 0x2a69
andl $0x0, (%rax,%rcx,4)
incq %rcx
movl 0x214(%rbx), %r15d
jmp 0x2a51
incq %r12
testq %rax, %rax
jne 0x2a27
jmp 0x2a7a
xorl %ebp, %ebp
jmp 0x2a7a
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::get_line_type(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Line_Type PDG::get_line_type(std::string s){
 	decltype(s.find("")) f;
 	/* Check if string is an if */
 	if((f = s.find("if")) != std::string::npos){
 		if(s[f+2] == ' ' || s[f+2] == '(')
 			return Line_Type::IF;
 	} 	/* Check for else */
 	else if ((f = s.find("else"))!= std::string::npos){
 		if(s[f+4] == ' ' || s[f+4] == '(')
 			return Line_Type::ELSE;
 	} 	/* Checking for while */
 	else if ((f = s.find("while")) != std::string::npos){
 		if(s[f+5] == ' ' || s[f+5] == '(')
 			return Line_Type::WHILE;
 	} 	/* Checking for assignment */
 	else if((f = s.find("=")) != std::string::npos){
 		if(s[f+1]!= '=' && s[f-1] != '!')
 			return Line_Type::ASSIGNMENT;
 	} 	/* Checking for blocl close */
 	else if((f = s.find("}"))!= std::string::npos){
 		return Line_Type::SCOPE_CLOSE;
 	}
 	return ERROR;
 }

// Assembly:
pushq %rbx
movq %rsi, %rbx
leaq 0x25f4(%rip), %rsi      # 0x50cf
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
je 0x2b07
movq (%rbx), %rcx
movb 0x2(%rcx,%rax), %al
andb $-0x9, %al
xorl %ecx, %ecx
cmpb $0x20, %al
setne %cl
leal 0x1(,%rcx,4), %eax
jmp 0x2bb3
leaq 0x25c4(%rip), %rsi      # 0x50d2
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
je 0x2b36
movq (%rbx), %rcx
movb 0x4(%rcx,%rax), %al
andb $-0x9, %al
xorl %ecx, %ecx
cmpb $0x20, %al
setne %cl
leal (%rcx,%rcx,2), %eax
addl $0x2, %eax
jmp 0x2bb3
leaq 0x259a(%rip), %rsi      # 0x50d7
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
je 0x2b66
movq (%rbx), %rcx
movb 0x5(%rcx,%rax), %al
andb $-0x9, %al
xorl %ecx, %ecx
cmpb $0x20, %al
setne %cl
leal 0x3(,%rcx,2), %eax
jmp 0x2bb3
leaq 0x2570(%rip), %rsi      # 0x50dd
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
je 0x2b95
movq %rax, %rcx
movq (%rbx), %rdx
cmpb $0x3d, 0x1(%rdx,%rax)
je 0x2bb0
xorl %eax, %eax
cmpb $0x21, -0x1(%rdx,%rcx)
jne 0x2bb3
jmp 0x2bb0
leaq 0x2543(%rip), %rsi      # 0x50df
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2370
cmpq $-0x1, %rax
je 0x2bb0
pushq $0x4
jmp 0x2bb2
pushq $0x5
popq %rax
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::allocate_g_ddg()
bool PDG::allocate_g_ddg(){
 	/* Allocate a graph of total_lines^2 size to **g_cdg */
 	g_ddg = (int**)malloc(sizeof(int*) * (total_lines+1));
 	if(g_ddg == nullptr) return false;
 	for(int i = 0; i <= total_lines;i++){
 		g_ddg[i] = (int*) malloc(sizeof(int)*(total_lines+1));
 		for(int j = 0;j <= total_lines;j++) g_ddg[i][j] = 0;
 		if(g_ddg[i] == nullptr) return false;
 	}
 	return true;
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
movslq 0x214(%rdi), %r15
leaq 0x8(,%r15,8), %rdi
callq 0x2270
movq %rax, 0x268(%rbx)
testq %rax, %rax
je 0x2c33
movq %rax, %r14
xorl %r12d, %r12d
movslq %r15d, %rax
cmpq %rax, %r12
setg %bpl
jg 0x2c37
leaq 0x4(,%rax,4), %rdi
callq 0x2270
movq %rax, (%r14,%r12,8)
movq 0x268(%rbx), %r14
movq (%r14,%r12,8), %rax
xorl %ecx, %ecx
movslq %r15d, %rdx
cmpq %rdx, %rcx
jg 0x2c29
andl $0x0, (%rax,%rcx,4)
incq %rcx
movl 0x214(%rbx), %r15d
jmp 0x2c11
incq %r12
testq %rax, %rax
jne 0x2be7
jmp 0x2c3a
xorl %ebp, %ebp
jmp 0x2c3a
movb $0x1, %bpl
movl %ebp, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::print_cdg()
void PDG::print_cdg(){
 	std::printf("CDG\n   ");
 	for(int i = 0; i <= total_lines;i++)
 		std::printf("%3d ",i);
 	std::cout << std::endl;
 	for(int i = 0; i <= total_lines;i++){
 		std::printf("%3d",i);
 		std::cout.flush();
 		for(int j = 0; j <= total_lines; j++){
 			std::printf("%3d ",g_cdg[i][j]);
 			std::cout.flush();
 		}
 		std::cout << std::endl;
 	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2307(%rip), %rdi      # 0x5104
xorl %eax, %eax
callq 0x2040
leaq 0x2301(%rip), %r14      # 0x510c
xorl %ebp, %ebp
cmpl 0x214(%rbx), %ebp
jg 0x2e25
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2040
incl %ebp
jmp 0x2e0d
movq 0x51ac(%rip), %r14      # 0x7fd8
movq %r14, %rdi
callq 0x2110
leaq 0x22d6(%rip), %r15      # 0x5111
leaq 0x22ca(%rip), %r12      # 0x510c
xorl %r13d, %r13d
movslq 0x214(%rbx), %rax
cmpq %rax, %r13
jg 0x2ea6
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x2040
movq %r14, %rdi
callq 0x2130
xorl %ebp, %ebp
movslq 0x214(%rbx), %rax
cmpq %rax, %rbp
jg 0x2e99
movq 0x260(%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbp,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2040
movq %r14, %rdi
callq 0x2130
incq %rbp
jmp 0x2e68
movq %r14, %rdi
callq 0x2110
incq %r13
jmp 0x2e45
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::plot_ddg()
void PDG::ddg(){
	if(!allocate_g_ddg())
 		valid = false;
 	if(make_variable_map())
 		valid = true;
 }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xe8, %rsp
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movq %rdi, %rbx
movb $0x0, (%rax)
movl 0x214(%rdi), %eax
pushq $0x1
popq %r12
leaq 0xa8(%rsp), %r15
movslq %eax, %rcx
cmpq %rcx, %r12
jg 0x384c
pushq $0x1
popq %rbp
movslq %eax, %rcx
cmpq %rcx, %rbp
jg 0x3844
movq 0x268(%rbx), %rax
movq (%rax,%r12,8), %rax
cmpl $0x0, (%rax,%rbp,4)
je 0x3836
cmpq %rbp, %r12
jae 0x3771
movq %r15, %rdi
movl %r12d, %esi
callq 0x3a7f
leaq 0xc8(%rsp), %r13
movq %r13, %rdi
leaq 0x1a13(%rip), %rsi      # 0x5115
movq %r15, %rdx
callq 0x3a5b
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
leaq 0x19fe(%rip), %rdx      # 0x5117
callq 0x395f
movq %r13, %r15
leaq 0x68(%rsp), %r13
movq %r13, %rdi
movl %ebp, %esi
callq 0x3a7f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
movq %r13, %rdx
callq 0x39f4
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
leaq 0x19c2(%rip), %rdx      # 0x5119
callq 0x395f
leaq 0x88(%rsp), %rdi
movq %r13, %rsi
callq 0x2360
jmp 0x37f8
movq %r15, %rdi
movl %r12d, %esi
callq 0x3a7f
leaq 0xc8(%rsp), %r13
movq %r13, %rdi
leaq 0x1987(%rip), %rsi      # 0x5115
movq %r15, %rdx
callq 0x3a5b
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
leaq 0x1972(%rip), %rdx      # 0x5117
callq 0x395f
movq %r13, %r15
leaq 0x68(%rsp), %r13
movq %r13, %rdi
movl %ebp, %esi
callq 0x3a7f
leaq 0x8(%rsp), %r14
movq %r14, %rdi
leaq 0x28(%rsp), %rsi
movq %r13, %rdx
callq 0x39f4
leaq 0x48(%rsp), %r13
movq %r13, %rdi
movq %r14, %rsi
leaq 0x1936(%rip), %rdx      # 0x5119
callq 0x395f
leaq 0x88(%rsp), %rdi
movq %r13, %rsi
callq 0x2360
movq %r13, %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x68(%rsp), %rdi
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x2100
movq %r15, %rdi
callq 0x2100
leaq 0xa8(%rsp), %r15
movq %r15, %rdi
callq 0x2100
incq %rbp
movl 0x214(%rbx), %eax
jmp 0x36bb
incq %r12
jmp 0x36ac
leaq 0x18c9(%rip), %rsi      # 0x511c
leaq 0x8(%rsp), %rdi
leaq 0x88(%rsp), %rdx
callq 0x397e
leaq 0x18d0(%rip), %rdx      # 0x513c
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x395f
leaq 0x8(%rsp), %rdi
callq 0x2100
movq 0x48(%rsp), %rdi
callq 0x2180
leaq 0x48(%rsp), %rdi
callq 0x2100
leaq 0x88(%rsp), %rdi
callq 0x2100
addq $0xe8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x393a
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x393a
jmp 0x38eb
jmp 0x38eb
jmp 0x38d6
jmp 0x38f5
jmp 0x38dd
movq %rax, %rbx
jmp 0x3911
jmp 0x38e4
movq %rax, %rbx
jmp 0x391b
jmp 0x38f0
movq %rax, %rbx
jmp 0x3925
jmp 0x38fa
movq %rax, %rbx
jmp 0x393f
movq %rax, %rbx
jmp 0x3932
movq %rax, %rbx
jmp 0x3907
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x2100
leaq 0x8(%rsp), %rdi
callq 0x2100
leaq 0x68(%rsp), %rdi
callq 0x2100
leaq 0x28(%rsp), %rdi
callq 0x2100
leaq 0xc8(%rsp), %rdi
callq 0x2100
leaq 0xa8(%rsp), %rdi
callq 0x2100
leaq 0x88(%rsp), %rdi
callq 0x2100
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O2/metastableB[P]Program-Dependence-Graph-Creator/./pdg.cpp
// Function: PDG::print_ddg()
void PDG::print_ddg(){
 	std::printf("\nDDG\n   ");
 	for(int i = 1; i <= total_lines;i++)
 		std::printf("%3d ",i);
 	std::cout << std::endl;
 	for(int i = 1; i <= total_lines;i++){
 		std::printf("%3d",i);
 		std::cout.flush();
 		for(int j = 1; j <= total_lines; j++){
 			std::printf("%3d ",g_ddg[i][j]);
 			std::cout.flush();
 		}
 		std::cout << std::endl;
 	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1bd0(%rip), %rdi      # 0x5187
xorl %eax, %eax
callq 0x2040
pushq $0x1
popq %rbp
leaq 0x1b44(%rip), %r14      # 0x510c
cmpl 0x214(%rbx), %ebp
jg 0x35e0
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x2040
incl %ebp
jmp 0x35c8
movq 0x49f1(%rip), %r14      # 0x7fd8
movq %r14, %rdi
callq 0x2110
pushq $0x1
popq %r15
leaq 0x1b12(%rip), %r12      # 0x510c
movq %r15, %r13
movslq 0x214(%rbx), %rax
cmpq %rax, %r13
jg 0x3663
leaq 0x1b01(%rip), %rdi      # 0x5111
movl %r13d, %esi
xorl %eax, %eax
callq 0x2040
movq %r14, %rdi
callq 0x2130
movq %r15, %rbp
movslq 0x214(%rbx), %rax
cmpq %rax, %rbp
jg 0x3656
movq 0x268(%rbx), %rax
movq (%rax,%r13,8), %rax
movl (%rax,%rbp,4), %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x2040
movq %r14, %rdi
callq 0x2130
incq %rbp
jmp 0x3625
movq %r14, %rdi
callq 0x2110
incq %r13
jmp 0x35fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/kdungs[P]codecon/src/compliance.cc
// Function: main
int main() {
  auto word = std::string{};
  std::cin >> word;

  if (check(word)) {
    std::cout << "yes\n";
  } else {
    std::cout << "no\n";
  }
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
leaq 0x10(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x2cd6(%rip), %rdi      # 0x3fe0
movq %rsp, %rsi
callq 0x1100
movq %rsp, %rdi
callq 0x125c
leaq 0xce3(%rip), %rcx       # 0x2004
leaq 0xce1(%rip), %rsi       # 0x2009
testb %al, %al
cmovneq %rcx, %rsi
movq 0x2c9b(%rip), %rdi      # 0x3fd0
callq 0x10b0
movq %rsp, %rdi
callq 0x1070
xorl %eax, %eax
addq $0x20, %rsp
popq %rbx
retq
movq %rax, %rbx
movq %rsp, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/main/db_lsm.cc
// Function: main
int main(int argc, char **argv){
	if (argc <= 3){
		printUsage(argv[0]);
		return 1;
	}

	// =======================

	const auto op		= argv[1];
	const auto path		= argv[2];

	size_t const keyCount	= (size_t) argc - 3;
	char **keys		= & argv[3];

	// =======================

	using DirectoryTableLoader = hm3::tableloader::DirectoryTableLoader;
	using MyLSMTable = hm3::LSMTable<DirectoryTableLoader::container_type>;

	DirectoryTableLoader dl{ path };
	MyLSMTable mtlist(*dl);

	// =======================

	switch(op[0]){
	case 'r':	return op_filesearch(mtlist, keyCount, keys);
	case 'l':	return op_list(mtlist, keyCount, keys);
	}

	printUsage(argv[0]);
	return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x118, %rsp            # imm = 0x118
movq %rsi, %rbx
cmpl $0x3, %edi
jg 0x2505
movq (%rbx), %rdi
callq 0x26ea
pushq $0x1
popq %rbx
jmp 0x268a
movq 0x8(%rbx), %r15
movq 0x10(%rbx), %rsi
movl %edi, %eax
movq %rax, 0x8(%rsp)
leaq 0x98(%rsp), %r14
movq %r14, %rdi
callq 0x27e8
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x2818
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
movzbl (%r15), %eax
cmpl $0x6c, %eax
je 0x25a1
cmpl $0x72, %eax
jne 0x2675
pushq $0x3
popq %rbp
leaq 0x98(%rsp), %r14
leaq 0x58(%rsp), %r15
movq %rsp, %r12
cmpq %rbp, 0x8(%rsp)
je 0x2671
movq (%rbx,%rbp,8), %rsi
movq %r14, %rdi
callq 0x27e8
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x2a0c
cmpq $0x0, 0x58(%rsp)
je 0x2594
movq %r15, %rdi
callq 0x4470
movq %r15, %rdi
callq 0x42b4
incq %rbp
jmp 0x255f
addq $-0x3, 0x8(%rsp)
leaq 0x98(%rsp), %r12
leaq 0x58(%rsp), %rbp
leaq 0xd8(%rsp), %r14
xorl %r15d, %r15d
cmpq 0x8(%rsp), %r15
je 0x2671
movq 0x18(%rbx,%r15,8), %rsi
leaq 0x10(%rsp), %rdi
callq 0x27e8
cmpq $0x1, 0x10(%rsp)
jne 0x25f8
movq 0x18(%rsp), %rax
cmpb $0x2d, (%rax)
jne 0x25f8
movq %r12, %rdi
movq %rsp, %rsi
callq 0x2a64
jmp 0x2609
movq (%rsp), %rsi
movq %r12, %rdi
leaq 0x10(%rsp), %rdx
callq 0x32d0
movq %rbp, %rdi
movq %rsp, %rsi
callq 0x2a78
movq %r14, %rdi
movq %r12, %rsi
callq 0x2a8c
pushq $0xa
popq %r13
movq %r14, %rdi
movq %rbp, %rsi
callq 0x2ad0
testb %al, %al
je 0x2651
movq %r14, %rdi
callq 0x364c
movq %rax, %rdi
callq 0x4470
decq %r13
je 0x2651
movq %r14, %rdi
callq 0x2ada
jmp 0x2623
movq %r14, %rdi
callq 0x2b18
movq %rbp, %rdi
callq 0x2b18
movq %r12, %rdi
callq 0x2b18
incq %r15
jmp 0x25bf
xorl %ebx, %ebx
jmp 0x2680
movq (%rbx), %rdi
callq 0x26ea
pushq $0x1
popq %rbx
leaq 0x20(%rsp), %rdi
callq 0x285e
movl %ebx, %eax
addq $0x118, %rsp            # imm = 0x118
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x26ac
movq %rax, %rbx
jmp 0x26cb
movq %rax, %rbx
jmp 0x26c1
jmp 0x26ac
movq %rax, %rbx
jmp 0x26d8
movq %rax, %rbx
leaq 0xd8(%rsp), %rdi
callq 0x2b18
leaq 0x58(%rsp), %rdi
callq 0x2b18
leaq 0x98(%rsp), %rdi
callq 0x2b18
leaq 0x20(%rsp), %rdi
callq 0x285e
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/nmmmnu[P]HM3/hm3/main/db_lsm.cc
// Function: printUsage(char const*)
static void printUsage(const char *cmd){
	std::cout
		<< "Usage:"	<< '\n'
		<< "\t"		<< cmd	<< " r [lsm_path] [key] - load lsm_path, then search for the key"	<< '\n'
		<< "\t"		<< cmd	<< " l [lsm_path] -     - load lsm_path, then list using iterator"	<< '\n'
		<< "\t"		<< cmd	<< " l [lsm_path] [key] - load lsm_path, then list using iterator"	<< '\n'

		<< "\t\tPath names must be written without extention"		<< '\n'
		<< "\t\tExample 'directory/file.*'"				<< '\n'

		<< '\n';
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r14
movq 0x78d7(%rip), %rdi      # 0x9fd0
leaq 0x3904(%rip), %rsi      # 0x6004
callq 0x21c0
pushq $0xa
popq %rbx
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x38f2(%rip), %r15      # 0x600b
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x38d7(%rip), %rsi      # 0x600d
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x38e5(%rip), %rsi      # 0x604a
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
leaq 0x38f4(%rip), %rsi      # 0x6088
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x3919(%rip), %rsi      # 0x60c6
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
leaq 0x392f(%rip), %rsi      # 0x60f5
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
movl %ebx, %esi
callq 0x2210
movq %rax, %rdi
movl %ebx, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x2210
nop
// File: /workspace/github_cpp_makefile_star2_O2/btbujiangjun[P]abcdl/example/sessionq.cpp
// Function: SessionQ::pass(abcdl::algebra::Matrix<float>, abcdl::algebra::Matrix<float>, abcdl::algebra::Matrix<float>, abcdl::algebra::Matrix<float>)
void pass(abcdl::algebra::Mat train_data,
              abcdl::algebra::Mat train_label,
              abcdl::algebra::Mat test_data,
              abcdl::algebra::Mat test_label){
        real loss = 0;
        fnn.train(train_data, train_label);
        fnn.evaluate(test_data, test_label, &loss);
        fnn.write_model();
    }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdi, %r15
leaq 0x4(%rsp), %r12
andl $0x0, (%r12)
callq 0x22744
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0x22e62
movq %r15, %rdi
callq 0x1347c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: Get(hlkvds::DB*)
void Get(hlkvds::DB *db) {
    int key_len;
    for (int index = 0; index < TEST_RECORD_NUM; index++) {
        stringstream key_ss;
        key_ss << index;
        std::string key(key_ss.str());
        key_len = key.length();
        std::string get_data;
        db->Get(key.c_str(), key_len, get_data);
        std::cout << "Get Item Success. key = " << key << " ,value = "
                << get_data << std::endl;
    }

}

// Assembly:
pushq %rbx
subq $0x1e0, %rsp            # imm = 0x1E0
movq %rdi, %rbx
leaq 0x58(%rsp), %rdi
callq 0x62e0
leaq 0x68(%rsp), %rdi
xorl %esi, %esi
callq 0x66c0
leaq 0x70(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6620
leaq 0x38(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movl 0x10(%rsp), %ecx
movb $0x0, (%rax)
movq 0x8(%rsp), %rdx
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %r8
movq %rbx, %rsi
callq 0x101f6
movq 0x2a541(%rip), %rdi     # 0x30fd0
leaq 0x1756e(%rip), %rsi     # 0x1e004
callq 0x6420
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x63d0
leaq 0x1756e(%rip), %rsi     # 0x1e01d
movq %rax, %rdi
callq 0x6420
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x63d0
movq %rax, %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x67d8
leaq 0x8(%rsp), %rdi
callq 0x67d8
leaq 0x58(%rsp), %rdi
callq 0x6350
addq $0x1e0, %rsp            # imm = 0x1E0
popq %rbx
retq
jmp 0x6af5
movq %rax, %rbx
jmp 0x6b11
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x67d8
leaq 0x8(%rsp), %rdi
callq 0x67d8
leaq 0x58(%rsp), %rdi
callq 0x6350
movq %rbx, %rdi
callq 0x66d0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: Insert(hlkvds::DB*)
void Insert(hlkvds::DB *db) {
    int key_len;
    int value_len;
    for (int index = 0; index < TEST_RECORD_NUM; index++) {
        stringstream key_ss;
        key_ss << index;
        std::string key(key_ss.str());
        std::string value = "Begin" + key + "End";
        key_len = key.length();
        value_len = value.length();
        db->Insert(key.c_str(), key_len, value.c_str(), value_len);
        std::cout << "Insert Item Success. key = " << key << " ,value = "
                << value << std::endl;
    }

}

// Assembly:
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq 0x78(%rsp), %rdi
callq 0x62e0
leaq 0x88(%rsp), %rdi
xorl %esi, %esi
callq 0x66c0
leaq 0x90(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6620
leaq 0x174c8(%rip), %rsi     # 0x1e028
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0x6e66
leaq 0x174b8(%rip), %rdx     # 0x1e02e
leaq 0x28(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0x6e47
leaq 0x48(%rsp), %rdi
callq 0x67d8
movl 0x10(%rsp), %ecx
movzwl 0x30(%rsp), %r9d
movq 0x8(%rsp), %rdx
movq 0x28(%rsp), %r8
andl $0x0, (%rsp)
leaq 0x68(%rsp), %rdi
movq %rbx, %rsi
callq 0x10182
movq 0x2a415(%rip), %rdi     # 0x30fd0
leaq 0x17470(%rip), %rsi     # 0x1e032
callq 0x6420
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x63d0
leaq 0x17442(%rip), %rsi     # 0x1e01d
movq %rax, %rdi
callq 0x6420
leaq 0x28(%rsp), %rsi
movq %rax, %rdi
callq 0x63d0
movq %rax, %rdi
callq 0x61d0
leaq 0x28(%rsp), %rdi
callq 0x67d8
leaq 0x8(%rsp), %rdi
callq 0x67d8
leaq 0x78(%rsp), %rdi
callq 0x6350
addq $0x200, %rsp            # imm = 0x200
popq %rbx
retq
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0x6c3d
movq %rax, %rbx
jmp 0x6c42
jmp 0x6c30
movq %rax, %rbx
jmp 0x6c4c
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x67d8
leaq 0x8(%rsp), %rdi
callq 0x67d8
leaq 0x78(%rsp), %rdi
callq 0x6350
movq %rbx, %rdi
callq 0x66d0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: Delete(hlkvds::DB*)
void Delete(hlkvds::DB *db) {
    int key_len;
    for (int index = 0; index < TEST_RECORD_NUM; index++) {
        stringstream key_ss;
        key_ss << index;
        std::string key(key_ss.str());
        key_len = key.length();
        db->Delete(key.c_str(), key_len);
        std::cout << "Delete Item Success. key = " << key << std::endl;
    }

}

// Assembly:
pushq %rbx
subq $0x1c0, %rsp            # imm = 0x1C0
movq %rdi, %rbx
leaq 0x38(%rsp), %rdi
callq 0x62e0
leaq 0x48(%rsp), %rdi
xorl %esi, %esi
callq 0x66c0
leaq 0x50(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0x6620
movl 0x10(%rsp), %ecx
movq 0x8(%rsp), %rdx
leaq 0x28(%rsp), %rdi
movq %rbx, %rsi
callq 0x101c4
movq 0x2a325(%rip), %rdi     # 0x30fd0
leaq 0x1739c(%rip), %rsi     # 0x1e04e
callq 0x6420
leaq 0x8(%rsp), %rsi
movq %rax, %rdi
callq 0x63d0
movq %rax, %rdi
callq 0x61d0
leaq 0x8(%rsp), %rdi
callq 0x67d8
leaq 0x38(%rsp), %rdi
callq 0x6350
addq $0x1c0, %rsp            # imm = 0x1C0
popq %rbx
retq
jmp 0x6ceb
movq %rax, %rbx
jmp 0x6cfd
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x67d8
leaq 0x38(%rsp), %rdi
callq 0x6350
movq %rbx, %rdi
callq 0x66d0
// File: /workspace/github_cpp_makefile_star2_O2/yangwanyuan[P]HLKVDS/tools/ExampleKV.cc
// Function: OpenExample(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void OpenExample(string filename) {
    hlkvds::DB *db;

    if (!hlkvds::DB::OpenDB(filename, &db)) {
        return;
    }

    Get(db);
    Insert(db);
    //sleep(2);
    Get(db);
    Delete(db);
    //sleep(2);
    Get(db);
    Insert(db);
    //sleep(2);
    Get(db);

    delete db;
}

// Assembly:
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rsi
leaq 0x60(%rsp), %rdi
callq 0x6550
leaq 0x80(%rsp), %rdi
callq 0x14774
pushq $0xa
popq %rcx
leaq 0x80(%rsp), %rsi
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0x60(%rsp), %rdi
leaq 0x58(%rsp), %rsi
callq 0x10044
movl %eax, %ebx
leaq 0x60(%rsp), %rdi
callq 0x67d8
testb %bl, %bl
je 0x6db7
movq 0x58(%rsp), %rdi
callq 0x6a2c
movq 0x58(%rsp), %rdi
callq 0x6b23
movq 0x58(%rsp), %rdi
callq 0x6a2c
movq 0x58(%rsp), %rdi
callq 0x6c5e
movq 0x58(%rsp), %rdi
callq 0x6a2c
movq 0x58(%rsp), %rdi
callq 0x6b23
movq 0x58(%rsp), %rdi
callq 0x6a2c
movq 0x58(%rsp), %rdi
testq %rdi, %rdi
je 0x6db7
movq (%rdi), %rax
callq *0x8(%rax)
addq $0xd0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x67d8
movq %rbx, %rdi
callq 0x66d0
// File: /workspace/github_cpp_makefile_star2_O2/ArashPartow[P]exprtk/exprtk_simple_example_20.cpp
// Function: vector_access_rtc::handle_runtime_violation(exprtk::vector_access_runtime_check::violation_context&)
bool handle_runtime_violation(violation_context& context)
   {
      const map_t::iterator itr     = vector_map.find(static_cast<void*>(context.base_ptr));
      const std::string vector_name = (itr != vector_map.end()) ?
                                      itr->second : "Unknown"   ;

      printf("Runtime vector access violation\n"
             "Vector: %s base: %p end: %p access: %p typesize: %d\n",
             vector_name.c_str(),
             context.base_ptr   ,
             context.end_ptr    ,
             context.access_ptr ,
             static_cast<unsigned int>(context.type_size));

      throw std::runtime_error
         ("Runtime vector access violation. Vector: " + vector_name);

      return false;
   }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rsi, %rbx
movq %rdi, %r14
addq $0x8, %rdi
movq (%rsi), %rax
movq %rsp, %rsi
movq %rax, (%rsi)
callq 0x111808
addq $0x10, %r14
cmpq %r14, %rax
jne 0x1116e9
leaq 0x129b33(%rip), %rsi    # 0x23b20d
movq %rsp, %rdi
leaq 0x20(%rsp), %rdx
callq 0x1102c8
jmp 0x1116f8
addq $0x28, %rax
movq %rsp, %rdi
movq %rax, %rsi
callq 0x10e2b0
movq %rsp, %r14
movq (%r14), %rsi
movq (%rbx), %rdx
movq 0x8(%rbx), %rcx
movq 0x10(%rbx), %r8
movl 0x18(%rbx), %r9d
leaq 0x129b01(%rip), %rdi    # 0x23b215
xorl %eax, %eax
callq 0x10e060
pushq $0x10
popq %rdi
callq 0x10e1e0
movq %rax, %rbx
leaq 0x129b3d(%rip), %rsi    # 0x23b26a
leaq 0x20(%rsp), %rdi
movq %r14, %rdx
callq 0x111791
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x10e150
xorl %ebp, %ebp
movq 0x2b2895(%rip), %rsi    # 0x3c3fe8
movq 0x2b2886(%rip), %rdx    # 0x3c3fe0
movq %rbx, %rdi
callq 0x10e2f0
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x10e5c8
testb %bpl, %bpl
jne 0x111779
jmp 0x111781
movq %rax, %r14
movq %rbx, %rdi
callq 0x10e450
movq %rsp, %rdi
callq 0x10e5c8
movq %r14, %rdi
callq 0x10e320
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: operator==(Action const&, Action const&)
bool operator==(const Action& lhs, const Action& rhs) {
  return lhs.type == rhs.type &&
    lhs.system == rhs.system &&
    lhs.ship == rhs.ship &&
    lhs.system_target == rhs.system_target &&
    lhs.target == rhs.target;
}

// Assembly:
movl 0x4(%rdi), %eax
cmpl 0x4(%rsi), %eax
jne 0x258a
movl 0x8(%rdi), %eax
cmpl 0x8(%rsi), %eax
jne 0x258a
movq 0xc(%rdi), %xmm0
movq 0xc(%rsi), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x258a
movl 0x14(%rdi), %eax
cmpl 0x14(%rsi), %eax
jne 0x258a
movq 0x18(%rdi), %xmm0
movq 0x18(%rsi), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: operator<(Action const&, Action const&)
bool operator<(const Action& lhs, const Action& rhs) {
  if (lhs.type < rhs.type) return true;
  if (lhs.type > rhs.type) return false;
  if (lhs.system < rhs.system) return true;
  if (lhs.system > rhs.system) return false;
  if (lhs.ship < rhs.ship) return true;
  if (!(lhs.ship == rhs.ship)) return false;
  if (lhs.system_target < rhs.system_target) return true;
  if (lhs.system_target > rhs.system_target) return false;
  if (lhs.target < rhs.target) return true;
  return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl 0x4(%rdi), %eax
movl 0x4(%rsi), %ecx
movb $0x1, %bl
cmpl %ecx, %eax
jl 0x25b8
jle 0x25a8
xorl %ebx, %ebx
jmp 0x25b8
movq %rsi, %r14
movq %rdi, %r15
movl 0x8(%rdi), %eax
movl 0x8(%rsi), %ecx
cmpl %ecx, %eax
jge 0x25c4
movl %ebx, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jg 0x25a4
leaq 0xc(%r15), %r12
leaq 0xc(%r14), %r13
movq %r12, %rdi
movq %r13, %rsi
callq 0x24f8
testb %al, %al
jne 0x25b8
movq (%r12), %xmm0
movq (%r13), %xmm1
pcmpeqd %xmm0, %xmm1
pshufd $0x50, %xmm1, %xmm0     # xmm0 = xmm1[0,0,1,1]
movmskpd %xmm0, %eax
cmpl $0x3, %eax
jne 0x25a4
movl 0x14(%r15), %eax
movl 0x14(%r14), %ecx
cmpl %ecx, %eax
jl 0x25b8
jg 0x25a4
addq $0x18, %r15
addq $0x18, %r14
movq %r15, %rdi
movq %r14, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x24f8
nop
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::Game(int)
Game::Game(int num_players) :
    num_players_(num_players),
    cur_player_(1),
    done_main_action_(false),
    homeworlds_built_(0),
    next_system_(1),
    sacrifice_actions_(0),
    sacrifice_colour_(RED) {
  for (const auto colour : { RED, YELLOW, GREEN, BLUE }) {
    for (const auto size : { SMALL, MEDIUM, LARGE }) {
      Pyramid p { size, colour };
      stash_[p] = 1 + num_players;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %ebx
movl %esi, (%rdi)
movl $0x1, 0x4(%rdi)
movb $0x0, 0x8(%rdi)
movsd 0x79c5(%rip), %xmm0     # 0xa010
movups %xmm0, 0xc(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rdi)
andq $0x0, 0x30(%rdi)
leaq 0x40(%rdi), %rax
andl $0x0, 0x40(%rdi)
andq $0x0, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rax, 0x58(%rdi)
andq $0x0, 0x60(%rdi)
leaq 0x20(%rdi), %rax
movq %rax, 0x8(%rsp)
leaq 0x38(%rdi), %r15
movaps 0x7997(%rip), %xmm0     # 0xa020
movaps %xmm0, 0x20(%rsp)
incl %ebx
xorl %r13d, %r13d
movq %rsp, %r12
cmpq $0x10, %r13
je 0x26e5
movl 0x20(%rsp,%r13), %r14d
movabsq $0x200000001, %rax      # imm = 0x200000001
movq %rax, 0x14(%rsp)
movl $0x3, 0x1c(%rsp)
xorl %ebp, %ebp
cmpq $0xc, %rbp
je 0x26df
movl 0x14(%rsp,%rbp), %eax
movl %eax, (%rsp)
movl %r14d, 0x4(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x3e88
movl %ebx, (%rax)
addq $0x4, %rbp
jmp 0x26ba
addq $0x4, %r13
jmp 0x2696
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %r15, %rdi
callq 0x40f6
movq 0x8(%rsp), %rdi
callq 0x3eee
movq %rbx, %rdi
callq 0x2300
nop
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::winner() const
int Game::winner() const {
  if (homeworlds_built_ < num_players_ || sacrifice_actions_ > 0) {
    return 0;
  }
  int w = -1;
  for (const System& s : systems_) {
    if (s.player != 0 && find_if(s.ships.begin(), s.ships.end(), [&s](const Ship& ship) {
            return ship.player == s.player; 
          }) != s.ships.end()) {
      if (w == -1) {
        w = s.player;
      } else {
        return 0;
      }
    }
  }
  return w;
}

// Assembly:
movl 0xc(%rdi), %eax
xorl %ecx, %ecx
cmpl (%rdi), %eax
jl 0x2846
cmpl $0x0, 0x14(%rdi)
jg 0x2846
pushq %r14
pushq %rbx
movq 0x20(%rdi), %r8
movq 0x28(%rdi), %rdi
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movabsq $0xc, %r9
cmpq %rdi, %r8
je 0x2840
movl 0x4(%r8), %r11d
testl %r11d, %r11d
je 0x2831
movq 0x20(%r8), %rbx
movq 0x28(%r8), %r14
movq %r14, %rsi
subq %rbx, %rsi
movq %rsi, %rax
cqto
idivq %r9
sarq $0x2, %rax
testq %rax, %rax
jle 0x27df
cmpl %r11d, (%rbx)
je 0x2824
cmpl %r11d, 0xc(%rbx)
je 0x2814
cmpl %r11d, 0x18(%rbx)
je 0x281a
cmpl %r11d, 0x24(%rbx)
je 0x2820
addq $0x30, %rbx
decq %rax
addq $-0x30, %rsi
jmp 0x27b6
movq %rsi, %rax
cqto
idivq %r9
cmpq $0x1, %rax
je 0x280b
cmpq $0x2, %rax
je 0x2802
cmpq $0x3, %rax
jne 0x2831
cmpl %r11d, (%rbx)
je 0x2824
addq $0xc, %rbx
cmpl %r11d, (%rbx)
je 0x2824
addq $0xc, %rbx
cmpl %r11d, (%rbx)
cmovneq %r14, %rbx
jmp 0x2824
addq $0xc, %rbx
jmp 0x2824
addq $0x18, %rbx
jmp 0x2824
addq $0x24, %rbx
cmpq %r14, %rbx
je 0x2831
cmpl $-0x1, %r10d
je 0x2834
jmp 0x2843
movl %r10d, %r11d
addq $0x38, %r8
movl %r11d, %r10d
jmp 0x2786
movl %r10d, %ecx
popq %rbx
popq %r14
movl %ecx, %eax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::get_system(int) const
const System& Game::get_system(int id) const {
  for (const System& system : systems_) {
    if (system.id == id) {
      return system;
    }
  }
  throw "system not found";
}

// Assembly:
pushq %rax
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
cmpq %rcx, %rax
je 0x2864
cmpl %esi, (%rax)
je 0x2862
addq $0x38, %rax
jmp 0x2853
popq %rcx
retq
pushq $0x8
popq %rdi
callq 0x20f0
leaq 0x7825(%rip), %rcx      # 0xa098
movq %rcx, (%rax)
movq 0xd743(%rip), %rsi      # 0xffc0
movq %rax, %rdi
xorl %edx, %edx
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::smallest_of_colour(Colour) const
Pyramid Game::smallest_of_colour(Colour colour) const {
  for (const auto& it : stash_) {
    if (it.first.colour == colour && it.second > 0) {
      return it.first;
    }
  }
  return Pyramid{ZERO, colour};
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movq 0x50(%rdi), %rax
addq $0x40, %r14
xorl %r15d, %r15d
cmpq %r14, %rax
je 0x28bf
movl 0x24(%rax), %ecx
cmpl %ebx, %ecx
jne 0x28af
cmpl $0x0, 0x28(%rax)
jg 0x28b9
movq %rax, %rdi
callq 0x2210
jmp 0x289d
movl 0x20(%rax), %r15d
movl %ecx, %ebx
shlq $0x20, %rbx
orq %r15, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::hash() const
int Game::hash() const {
  int systems = 0;
  for (const System& system : systems_) {
    systems += ::hash(system);
  }
  return systems ^ (PLAYER_HASH[num_players_] + PLAYER_HASH[cur_player_]) ^
    SIZE_HASH[sacrifice_actions_] ^ COLOUR_HASH[sacrifice_colour_] ^
    (31 * PLAYER_HASH[homeworlds_built_]) ^ (done_main_action_ ? 0xd7067b50 : 0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x20(%rdi), %r14
movq 0x28(%rdi), %r15
xorl %ebp, %ebp
cmpq %r15, %r14
je 0x28f9
movq %r14, %rdi
callq 0x2953
addl %eax, %ebp
addq $0x38, %r14
jmp 0x28e4
movslq (%rbx), %rax
leaq 0x7789(%rip), %rcx      # 0xa08c
movslq 0x4(%rbx), %rdx
movl (%rcx,%rdx,4), %edx
addl (%rcx,%rax,4), %edx
movslq 0x14(%rbx), %rsi
leaq 0x7718(%rip), %rdi      # 0xa030
movslq 0xc(%rbx), %rax
imull $0x1f, (%rcx,%rax,4), %ecx
movl 0x18(%rbx), %r8d
xorl %r9d, %r9d
cmpb $0x0, 0x8(%rbx)
leaq 0x770e(%rip), %r10      # 0xa040
movl $0xd7067b50, %eax       # imm = 0xD7067B50
cmovel %r9d, %eax
xorl (%rdi,%rsi,4), %edx
xorl (%r10,%r8,4), %edx
xorl %ecx, %edx
xorl %ebp, %eax
xorl %edx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: hash(System const&)
int hash(const System& system) {
  int ships = SHIPS_HASH;
  int stars = STARS_HASH;
  for (const Pyramid& star : system.stars) {
    stars += hash(star);
  }
  for (const Ship& ship : system.ships) {
    ships += hash(ship);
  }
  return ships ^ stars ^ PLAYER_HASH[system.player];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %r14
movq 0x8(%rdi), %rax
movq 0x10(%rdi), %rcx
movl $0xd9a110c5, %ebx       # imm = 0xD9A110C5
leaq 0x76be(%rip), %rdx      # 0xa030
leaq 0x76c7(%rip), %rsi      # 0xa040
cmpq %rcx, %rax
je 0x2995
movl (%rax), %edi
movl 0x4(%rax), %r8d
movl (%rsi,%r8,4), %r8d
xorl (%rdx,%rdi,4), %r8d
addl %r8d, %ebx
addq $0x8, %rax
jmp 0x2979
movq 0x20(%r14), %r15
movq 0x28(%r14), %r12
movl $0x12ec3a54, %ebp       # imm = 0x12EC3A54
cmpq %r12, %r15
je 0x29b7
movq %r15, %rdi
callq 0x3e1b
addl %eax, %ebp
addq $0xc, %r15
jmp 0x29a2
movslq 0x4(%r14), %rax
leaq 0x76ca(%rip), %rcx      # 0xa08c
xorl (%rcx,%rax,4), %ebx
xorl %ebp, %ebx
movl %ebx, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::hash_string[abi:cxx11]() const
std::string Game::hash_string() const {
  std::string h = "";
  // maximum compression! fails for more than 7 players
  // TODO: adapt for more than 7 players, or forbid games from having more than
  // 7 players
  h += (char)(num_players_ << 4 | cur_player_);
  h += (char)(done_main_action_ << 7 | homeworlds_built_ << 4 |
              sacrifice_actions_ << 2 | sacrifice_colour_);
  std::set<std::string> system_hashes;
  for (const System& system : systems_) {
    system_hashes.insert(::hash_string(system));
  }
  for (std::string str : system_hashes) {
    h += str;
  }
  return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x77cc(%rip), %rsi      # 0xa1b9
leaq 0x28(%rsp), %rdx
callq 0x3f10
movl (%r14), %eax
shll $0x4, %eax
orl 0x4(%r14), %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21a0
movl 0x8(%r14), %eax
movl 0xc(%r14), %ecx
shll $0x7, %eax
shll $0x4, %ecx
orl %eax, %ecx
movl 0x14(%r14), %eax
shll $0x2, %eax
orl %ecx, %eax
orl 0x18(%r14), %eax
movsbl %al, %esi
movq %rbx, %rdi
callq 0x21a0
leaq 0x30(%rsp), %r13
andl $0x0, (%r13)
andq $0x0, 0x8(%r13)
movq %r13, 0x10(%r13)
movq %r13, 0x18(%r13)
andq $0x0, 0x20(%r13)
movq 0x20(%r14), %r15
movq 0x28(%r14), %rbp
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r12
cmpq %rbp, %r15
je 0x2a8b
movq %r14, %rdi
movq %r15, %rsi
callq 0x2b17
movq %r12, %rdi
movq %r14, %rsi
callq 0x46a0
movq %r14, %rdi
callq 0x20c0
addq $0x38, %r15
jmp 0x2a62
movq 0x40(%rsp), %r15
leaq 0x8(%rsp), %r14
cmpq %r13, %r15
je 0x2ac6
leaq 0x20(%r15), %rsi
movq %r14, %rdi
callq 0x2260
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2330
movq %r14, %rdi
callq 0x20c0
movq %r15, %rdi
callq 0x2210
movq %rax, %r15
jmp 0x2a95
leaq 0x28(%rsp), %rdi
callq 0x414e
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x2b07
jmp 0x2aeb
jmp 0x2af0
movq %rax, %r14
jmp 0x2afd
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
leaq 0x28(%rsp), %rdi
callq 0x414e
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: hash_string[abi:cxx11](System const&)
std::string hash_string(const System& system) {
  std::set<char> chars;
  for (const Pyramid& pyramid : system.stars) {
    chars.insert(hash_string(Ship{system.player, pyramid}));
  }
  for (const Ship& ship : system.ships) {
    chars.insert(0x80 | hash_string(ship));
  }
  return std::string(chars.begin(), chars.end());
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x10(%rsp), %rax
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x10(%rax)
movq %rax, 0x18(%rax)
andq $0x0, 0x20(%rax)
movq 0x8(%rsi), %rbp
movq 0x10(%rsi), %r14
leaq 0x8(%rsp), %r12
leaq 0x7(%rsp), %r13
cmpq %r14, %rbp
je 0x2b8b
movb 0x4(%r15), %al
movq (%rbp), %rcx
leal (,%rcx,4), %edx
shrq $0x20, %rcx
shlb $0x4, %al
orb %cl, %al
orb %dl, %al
movb %al, 0x7(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x55d4
addq $0x8, %rbp
jmp 0x2b57
movq 0x20(%r15), %r14
movq 0x28(%r15), %r13
leaq 0x8(%rsp), %r15
leaq 0x7(%rsp), %r12
cmpq %r13, %r14
je 0x2bcc
movb (%r14), %al
movl 0x4(%r14), %ecx
shll $0x2, %ecx
orl 0x8(%r14), %ecx
shlb $0x4, %al
orb %cl, %al
orb $-0x80, %al
movb %al, 0x7(%rsp)
movq %r15, %rdi
movq %r12, %rsi
callq 0x55d4
addq $0xc, %r14
jmp 0x2b9d
movq 0x20(%rsp), %rsi
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq %rbx, %rdi
leaq 0x10(%rsp), %rdx
callq 0x572a
leaq 0x8(%rsp), %rdi
callq 0x4246
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2c05
jmp 0x2c05
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x4246
movq %rbx, %rdi
callq 0x2300
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: colour_available(System const&, int, Colour, bool)
bool colour_available(const System& system, int player, Colour colour,
    bool include_stars) {
  if (include_stars) {
    for (const Pyramid& star : system.stars) {
      if (star.colour == colour) {
        return true;
      }
    }
  }

  for (const Ship& ship : system.ships) {
    if (ship.player == player && ship.pyramid.colour == colour) {
      return true;
    }
  }

  return false;
}

// Assembly:
testl %ecx, %ecx
je 0x3263
movq 0x8(%rdi), %rcx
movq 0x10(%rdi), %rax
cmpq %rax, %rcx
je 0x3263
leaq 0x8(%rcx), %r8
cmpl %edx, 0x4(%rcx)
movq %r8, %rcx
jne 0x324f
movb $0x1, %al
retq
movq 0x20(%rdi), %r8
movq 0x28(%rdi), %rcx
cmpq %rcx, %r8
setne %al
je 0x3283
movq %r8, %rdi
addq $0xc, %r8
cmpl %esi, (%rdi)
jne 0x326b
cmpl %edx, 0x8(%rdi)
jne 0x326b
retq
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::advance_cur_player()
void Game::advance_cur_player() {
  cur_player_ = (cur_player_ % num_players_) + 1;
  if (winner() == 0) {
    done_main_action_ = false;
    sacrifice_actions_ = 0;
    // TODO: handle eliminated players in games with more than two players
  }
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x4(%rdi), %eax
cltd
idivl (%rdi)
incl %edx
movl %edx, 0x4(%rdi)
callq 0x2754
testl %eax, %eax
jne 0x367c
movb $0x0, 0x8(%rbx)
andl $0x0, 0x14(%rbx)
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::remove_ship(int, Ship const&)
Ship Game::remove_ship(int system_id, const Ship& ship) {
  auto system = find_if(systems_.begin(), systems_.end(),
      [system_id](const System& s) {
        return s.id == system_id;
      });
  const auto& it = find_if(system->ships.begin(), system->ships.end(),
      [&ship](const Ship& ship2) {
        return ship == ship2;
      });
  if (it != system->ships.end()) {
    stash_[ship.pyramid]++;
    system->ships.erase(it);
  }
  return ship;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq 0x20(%rdi), %r8
movq 0x28(%rdi), %r10
movq %r10, %rcx
subq %r8, %rcx
pushq $0x38
popq %r9
movq %rcx, %rax
cqto
idivq %r9
sarq $0x2, %rax
movq %rdi, 0x10(%rsp)
testq %rax, %rax
jle 0x36e4
cmpl %esi, (%r8)
je 0x372c
cmpl %esi, 0x38(%r8)
je 0x3719
cmpl %esi, 0x70(%r8)
je 0x371f
cmpl %esi, 0xa8(%r8)
je 0x3725
addq $0xe0, %r8
decq %rax
addq $-0xe0, %rcx
jmp 0x36b2
movq %rcx, %rax
cqto
idivq %r9
cmpq $0x1, %rax
je 0x3710
cmpq $0x2, %rax
je 0x3707
cmpq $0x3, %rax
jne 0x372f
cmpl %esi, (%r8)
je 0x372c
addq $0x38, %r8
cmpl %esi, (%r8)
je 0x372c
addq $0x38, %r8
cmpl %esi, (%r8)
cmoveq %r8, %r10
jmp 0x372f
addq $0x38, %r8
jmp 0x372c
addq $0x70, %r8
jmp 0x372c
addq $0xa8, %r8
movq %r8, %r10
leaq 0x20(%r10), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%r10), %r15
movq 0x28(%r10), %r14
movq %r14, %r13
subq %r15, %r13
pushq $0xc
popq %rcx
movq %r13, %rax
cqto
idivq %rcx
movq %rax, %rbp
sarq $0x2, %rbp
testq %rbp, %rbp
jle 0x37ba
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2511
testb %al, %al
jne 0x380e
leaq 0xc(%r15), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2511
testb %al, %al
jne 0x3811
leaq 0x18(%r15), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2511
testb %al, %al
jne 0x3811
leaq 0x24(%r15), %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2511
testb %al, %al
jne 0x3811
addq $0x30, %r15
decq %rbp
addq $-0x30, %r13
jmp 0x3758
movq %r13, %rax
cqto
pushq $0xc
popq %rcx
idivq %rcx
cmpq $0x1, %rax
je 0x37fd
cmpq $0x2, %rax
je 0x37ea
cmpq $0x3, %rax
jne 0x3837
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2511
testb %al, %al
jne 0x380e
addq $0xc, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2511
testb %al, %al
jne 0x380e
addq $0xc, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2511
testb %al, %al
cmoveq %r14, %r15
movq %r15, %r12
cmpq %r14, %r12
je 0x3837
movq 0x10(%rsp), %rdi
addq $0x38, %rdi
leaq 0x4(%rbx), %rsi
callq 0x3e88
incl (%rax)
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0x40a6
movq (%rbx), %rax
movl 0x8(%rbx), %edx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/czinn[P]homeworlds/game.cc
// Function: Game::add_ship(int, Ship const&)
void Game::add_ship(int system_id, const Ship& ship) {
  auto it = find_if(systems_.begin(), systems_.end(),
      [system_id](const System& s) {
        return s.id == system_id;
      });
  it->ships.push_back(ship);
  stash_[ship.pyramid]--;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movq 0x20(%rdi), %r8
movq 0x28(%rdi), %rdi
movq %rdi, %rcx
subq %r8, %rcx
pushq $0x38
popq %r9
movq %rcx, %rax
cqto
idivq %r9
sarq $0x2, %rax
testq %rax, %rax
jle 0x38a6
cmpl %esi, (%r8)
je 0x38ee
cmpl %esi, 0x38(%r8)
je 0x38db
cmpl %esi, 0x70(%r8)
je 0x38e1
cmpl %esi, 0xa8(%r8)
je 0x38e7
addq $0xe0, %r8
decq %rax
addq $-0xe0, %rcx
jmp 0x3874
movq %rcx, %rax
cqto
idivq %r9
cmpq $0x1, %rax
je 0x38d2
cmpq $0x2, %rax
je 0x38c9
cmpq $0x3, %rax
jne 0x38f1
cmpl %esi, (%r8)
je 0x38ee
addq $0x38, %r8
cmpl %esi, (%r8)
je 0x38ee
addq $0x38, %r8
cmpl %esi, (%r8)
cmoveq %r8, %rdi
jmp 0x38f1
addq $0x38, %r8
jmp 0x38ee
addq $0x70, %r8
jmp 0x38ee
addq $0xa8, %r8
movq %r8, %rdi
addq $0x20, %rdi
movq %rbx, %rsi
callq 0x4082
addq $0x38, %r14
addq $0x4, %rbx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3e88
decl (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
retq