LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Product::setType()
void Product::setType()
{
		changeFlag=1;
		int flag;
		cout << "\t\t\t\t\t1:clothes" << endl << "\t\t\t\t\t2:food" << endl << "\t\t\t\t\t3:commodity" << endl << "\t\t\t\t\t4:exit" << endl << "\t\t\t\t\tplease choice the type:" ;
		cin >> flag;
		switch(flag)
		{
				case 1://type="clothes";
					   strcpy(type,"clothes");
					   break;
				case 2://type="food";
					   strcpy(type,"food");
					   break;
				case 3://type="commodity";
					   strcpy(type,"commodity");
					   break;
				case 4:return ;
			    default:cout << "input error!" << endl;
						break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x9524(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movq 0x92f7(%rip), %rbx      # 0xefd0
leaq 0x4822(%rip), %rsi      # 0xa502
movl $0xe, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x47f3(%rip), %rsi      # 0xa511
movl $0xb, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x47c1(%rip), %rsi      # 0xa51d
movl $0x10, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x4449(%rip), %rsi      # 0xa1e3
movl $0xb, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x4759(%rip), %rsi      # 0xa52e
movl $0x1c, %edx
movq %rax, %rdi
callq 0x2240
movq 0x91f7(%rip), %rdi      # 0xefe0
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x20f0
movl (%r15), %eax
decl %eax
cmpl $0x3, %eax
ja 0x5e45
leaq 0x469a(%rip), %rcx      # 0xa4a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x736568746f6c63, %rax # imm = 0x736568746F6C63
movq %rax, 0x20(%r14)
jmp 0x5e80
movb $0x0, 0x24(%r14)
movl $0x646f6f66, 0x20(%r14) # imm = 0x646F6F66
jmp 0x5e80
movabsq $0x7469646f6d6d6f63, %rax # imm = 0x7469646F6D6D6F63
movq %rax, 0x20(%r14)
movw $0x79, 0x28(%r14)
jmp 0x5e80
leaq 0x4342(%rip), %rsi      # 0xa18e
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Product::deleteId()
void Product::deleteId()
{
		vector<int>::iterator it;
		changeFlag=1;
		it=find(number.begin(),number.end(),id);
		if(it!=number.end())
		{
				number.erase(it);
				productMax--;
		}
		else
				cout << "\t\t\t\t\tdelete error!"  << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x9123(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movq 0x913e(%rip), %rax      # 0xf218
movq 0x913f(%rip), %rsi      # 0xf220
leaq 0x44(%rdi), %rdx
movq %rax, %rdi
callq 0x5782
movq 0x912c(%rip), %rdx      # 0xf220
cmpq %rdx, %rax
je 0x6122
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x610d
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2300
addq $-0x4, 0x910b(%rip)     # 0xf220
decl 0x90f9(%rip)            # 0xf214
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0x8ea7(%rip), %rbx      # 0xefd0
leaq 0x3fa0(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::addProduct()
void Products::addProduct()
{
		Product *p;
		char buf[1000];
		p=new Product;
		p->setId();
		p->setName();
		p->setType();
		p->setPrice();
		p->setLoginTime();
		push_back(p);
	//	return *p;
		sprintf(buf,"qrencode \"name=%s\ttype=%s\tprice=%f\ttime=%s\" -o %d.png",p->getName(),p->getType(),p->getPrice(),p->getLoginTime(),p->getId());
		system(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
movl $0x7c, %edi
callq 0x21e0
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movq $0x0, 0x40(%rax)
movups 0x4304(%rip), %xmm0     # 0xa4d0
movups %xmm0, 0x48(%rax)
movups 0x4309(%rip), %xmm0     # 0xa4e0
movups %xmm0, 0x58(%rax)
movups 0x430e(%rip), %xmm0     # 0xa4f0
movups %xmm0, 0x68(%rax)
movw $0x0, 0x78(%rax)
movq %rax, -0x30(%rbp)
movq %rax, %rdi
callq 0x5bb2
movq -0x30(%rbp), %r15
leaq 0x8fed(%rip), %r13      # 0xf1f0
movl $0x1, %r14d
movl %r14d, (%r13)
movq 0x8dbc(%rip), %rdi      # 0xefd0
leaq 0x3ec8(%rip), %rsi      # 0xa0e3
movl $0x1b, %edx
callq 0x2240
movq 0x8db4(%rip), %r12      # 0xefe0
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movq %r12, %rdi
movq %r15, %rsi
callq 0x2330
movq -0x30(%rbp), %rdi
callq 0x5cb8
movq -0x30(%rbp), %r15
movl %r14d, (%r13)
leaq 0x42f2(%rip), %rsi      # 0xa54b
movl $0x1c, %edx
movq 0x8d6b(%rip), %rdi      # 0xefd0
callq 0x2240
addq $0x40, %r15
movq %r12, %rdi
movq %r15, %rsi
callq 0x2380
movq -0x30(%rbp), %rdi
callq 0x603c
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x629a
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x62a6
leaq -0x30(%rbp), %rdx
movq %rbx, %rdi
callq 0x72fe
movq -0x30(%rbp), %rdx
leaq 0x20(%rdx), %rcx
xorps %xmm0, %xmm0
cvtss2sd 0x40(%rdx), %xmm0
leaq 0x48(%rdx), %rax
movl $0x4c4c554e, %esi       # imm = 0x4C4C554E
xorl 0x48(%rdx), %esi
movzbl 0x4c(%rdx), %edi
xorl %r8d, %r8d
orl %esi, %edi
cmovneq %rax, %r8
movl 0x44(%rdx), %r9d
leaq 0x428e(%rip), %rsi      # 0xa568
leaq -0x420(%rbp), %rbx
movq %rbx, %rdi
movb $0x1, %al
callq 0x2050
movq %rbx, %rdi
callq 0x2170
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::deleteId(int const&)
void Products::deleteId(const int &id)
{
		vector<Product*>::iterator it;
		changeFlag=1;
		char t;
		char buf[50];
		for(it=begin();it!=end();it++)
		{
				if((*it)->getId()==id)
				{
						cout << "the product data is:" ;
						(*it)->show() ;
				//		getchar();
						cout << "do you want to delete it?(y/n)" ;
						t=getchar();
						if(t=='n')
						{
								return ;
						}
						sprintf(buf,"rm %d.png",(*it)->getId());
						system(buf);
						(*it)->deleteId();
						erase(it);
						cout << "\t\t\t\t\tdelete success!" << endl;
						return ;
				}
		}
		cout << "\t\t\t\t\tdelete error!" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
leaq 0x8ed4(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movq (%rdi), %r12
movq 0x8(%rdi), %rax
cmpq %rax, %r12
je 0x634e
movq %rdi, %rbx
movl (%rsi), %ecx
leaq 0x8(%r12), %r14
movq (%r12), %rdx
cmpl %ecx, 0x44(%rdx)
je 0x63a0
addq $0x8, %r12
addq $0x8, %r14
cmpq %rax, %r12
jne 0x6338
movq 0x8c7b(%rip), %rdi      # 0xefd0
leaq 0x3d74(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
callq 0x2240
movq 0x8c63(%rip), %rbx      # 0xefd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2110
movq 0x8c29(%rip), %r15      # 0xefd0
leaq 0x41ff(%rip), %rsi      # 0xa5ad
movl $0x14, %edx
movq %r15, %rdi
callq 0x2240
movq (%r12), %rdi
callq 0x5ed4
leaq 0x3e70(%rip), %rsi      # 0xa23b
movl $0x1e, %edx
movq %r15, %rdi
callq 0x2240
callq 0x2290
cmpb $0x6e, %al
jne 0x63ee
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rax
movl 0x44(%rax), %edx
leaq 0x41a2(%rip), %rsi      # 0xa59e
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2170
movq (%r12), %rdi
callq 0x60c0
movq 0x8(%rbx), %rdx
cmpq %rdx, %r14
je 0x6433
leaq -0x8(%r14), %rdi
subq %r14, %rdx
movq %r14, %rsi
callq 0x2300
addq $-0x8, 0x8(%rbx)
movq 0x8b91(%rip), %rdi      # 0xefd0
leaq 0x3e14(%rip), %rsi      # 0xa25a
movl $0x14, %edx
jmp 0x6361
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::deleteName(char const*)
void Products::deleteName(const char* name)
{
		vector<Product*>::iterator it;
		changeFlag=1;
		char buf[50];
		char t;
		for(it=begin();it!=end();it++)
		{
				if(strcmp((*it)->getName(),name)==0)
				{
						getchar();
						cout << "\t\t\t\t\tthe product data is:" ;
						(*it)->show() ;
						cout << "\t\t\t\t\tdo you want to delete it?(y/n)" ;
						t=getchar();
						if(t=='y')
						{
						  sprintf(buf,"rm %d.png",(*it)->getId());
						  system(buf);
						  (*it)->deleteId();
					//	 delete(*it);
						   erase(it);
						 cout << "\t\t\t\t\tdelete success!" << endl;
						 return ;
						}
						if(t='n')
						{
								continue;
						}
				}
		}
		cout << "\t\t\t\t\tdelete error!" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
leaq 0x8d88(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movq (%rdi), %r13
cmpq 0x8(%rdi), %r13
je 0x64e5
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%r13), %r14
movq 0x8b48(%rip), %r12      # 0xefd0
movq (%r13), %rdi
movq %r15, %rsi
callq 0x22a0
testl %eax, %eax
jne 0x64d7
callq 0x2290
movl $0x19, %edx
movq %r12, %rdi
leaq 0x40fc(%rip), %rsi      # 0xa5a8
callq 0x2240
movq (%r13), %rdi
callq 0x5ed4
movl $0x23, %edx
movq %r12, %rdi
leaq 0x3d6d(%rip), %rsi      # 0xa236
callq 0x2240
callq 0x2290
cmpb $0x79, %al
je 0x6539
addq $0x8, %r13
addq $0x8, %r14
cmpq 0x8(%rbx), %r13
jne 0x6488
movq 0x8ae4(%rip), %rdi      # 0xefd0
leaq 0x3bdd(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
callq 0x2240
movq 0x8acc(%rip), %rbx      # 0xefd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
movq (%r13), %rax
movl 0x44(%rax), %edx
leaq 0x4057(%rip), %rsi      # 0xa59e
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2050
movq %r15, %rdi
callq 0x2170
movq (%r13), %rdi
callq 0x60c0
movq 0x8(%rbx), %rdx
cmpq %rdx, %r14
je 0x657e
leaq -0x8(%r14), %rdi
subq %r14, %rdx
movq %r14, %rsi
callq 0x2300
addq $-0x8, 0x8(%rbx)
movq 0x8a46(%rip), %rdi      # 0xefd0
leaq 0x3cc9(%rip), %rsi      # 0xa25a
movl $0x14, %edx
jmp 0x64f8
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::searchName(char const*)
Product* Products::searchName(const char* name)
{
		vector<Product*>::iterator it;
		for(it=begin();it!=end();it++)
		{
				if(strcmp((*it)->getName(),name)==0)
				{
						return (*it);
				}
		}
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x68dd
movq %rsi, %rbx
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22a0
testl %eax, %eax
je 0x68e0
addq $0x8, %r15
cmpq %r12, %r15
jne 0x68c2
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::searchType(char const*)
Products Products::searchType(const char* Type)
{
		vector<Product*>::iterator it;
		Products pts;
		for(it=begin();it!=end();it++)
		{
				if(strcmp((*it)->getType(),Type)==0)
				{
					pts.push_back(*it);	
				}
		}
		return pts;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq 0x8(%rsi), %r12
je 0x6957
movq %rdx, %r14
movq %rsi, %r15
movq (%r12), %r13
leaq 0x20(%r13), %rdi
movq %r14, %rsi
callq 0x22a0
testl %eax, %eax
jne 0x694d
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x6942
movq %r13, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x694d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x72fe
addq $0x8, %r12
cmpq 0x8(%r15), %r12
jne 0x691a
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x6980
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::commonSearch()
void  Products::commonSearch()
{
		int id;
		Products s;
		Product *p;
		cout << "\t\t\t\t\tplease input the number:" ;
		cin >> id;
		p=searchId(id);
		if(p!=NULL)
		{	
				p->show();
	   }
		else
		{
				cout << "\t\t\t\t\tit is not in the warehouse!" << endl;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
movq 0x8633(%rip), %rbx      # 0xefd0
leaq 0x3914(%rip), %rsi      # 0xa2b8
movl $0x1d, %edx
movq %rbx, %rdi
callq 0x2240
movq 0x8628(%rip), %rdi      # 0xefe0
leaq -0x14(%rbp), %rsi
callq 0x20f0
movq (%r14), %rax
movq 0x8(%r14), %rcx
cmpq %rcx, %rax
je 0x69e1
movl -0x14(%rbp), %edx
movq (%rax), %rdi
cmpl %edx, 0x44(%rdi)
je 0x69e3
addq $0x8, %rax
cmpq %rcx, %rax
jne 0x69d0
xorl %edi, %edi
testq %rdi, %rdi
je 0x69ef
callq 0x5ed4
jmp 0x6a2a
leaq 0x3c39(%rip), %rsi      # 0xa62f
movl $0x20, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::showAll()
void Products::showAll()
{
		vector<Product*>::iterator it;
		if(this->size()==0)
		{
				cout << "\t\t\t\t\tno product!" << endl;
				return ;
		}
		else
				for(it=begin();it!=end();it++)
						(*it)->show();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq (%rdi), %r14
cmpq %r14, 0x8(%rdi)
je 0x6fae
movq %rdi, %rbx
cmpq 0x8(%rbx), %r14
je 0x6fa9
movq (%r14), %rdi
callq 0x5ed4
addq $0x8, %r14
jmp 0x6f95
popq %rbx
popq %r14
popq %rbp
retq
movq 0x801b(%rip), %rbx      # 0xefd0
leaq 0x3717(%rip), %rsi      # 0xa6d3
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2110
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::readProduct()
void Products::readProduct()
{
		ifstream in("product",ios::binary);
		if(!in)
		{
				cout << "\t\t\t\t\topen failed" << endl ;
				return ;
		}
		else
		{
		    delAll();
			Product *p;
			vector<Product*>::iterator it;
			it=begin();
			while(1)
			{
					p=new Product;
					in.read((char*)(p),sizeof(Product));
					if(!in.eof())
					{
							this->push_back(p);
							p->number.push_back(p->getId());
					}
					else
					{
							delete(p);
							break;
					}
			}
			(*it)->productMax=this->size();
		}
		in.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
leaq 0x36be(%rip), %rsi      # 0xa6e4
leaq -0x240(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x2360
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x220(%rbp,%rax)
je 0x7096
movq 0x7f7e(%rip), %rbx      # 0xefd0
leaq 0x3693(%rip), %rsi      # 0xa6ec
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x7f4c(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x71b5
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x70a3
movq %rax, 0x8(%rbx)
leaq -0x30(%rbp), %r15
leaq 0x816a(%rip), %r12      # 0xf218
leaq -0x34(%rbp), %r13
movl $0x7c, %edi
callq 0x21e0
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movq $0x0, 0x40(%rax)
movups 0x33f3(%rip), %xmm0     # 0xa4d0
movups %xmm0, 0x48(%rax)
movups 0x33f8(%rip), %xmm0     # 0xa4e0
movups %xmm0, 0x58(%rax)
movups 0x33fd(%rip), %xmm0     # 0xa4f0
movups %xmm0, 0x68(%rax)
movw $0x0, 0x78(%rax)
movq %rax, -0x30(%rbp)
movl $0x7c, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2260
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x220(%rbp,%rax)
jne 0x7185
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x713e
movq -0x30(%rbp), %rax
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x7149
movq %rbx, %rdi
movq %r15, %rdx
callq 0x72fe
movq -0x30(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x34(%rbp)
movq 0x80c6(%rip), %rsi      # 0xf220
cmpq 0x80c7(%rip), %rsi      # 0xf228
je 0x7175
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x80b0(%rip)      # 0xf220
jmp 0x70b2
movq %r12, %rdi
movq %r13, %rdx
callq 0x5a86
jmp 0x70b2
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x7198
movl $0x7c, %esi
callq 0x21f0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
movl %eax, 0x806b(%rip)      # 0xf214
leaq -0x240(%rbp), %rdi
callq 0x2060
leaq -0x240(%rbp), %rdi
callq 0x2080
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x71d7
jmp 0x71d7
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::writeProduct()
void Products::writeProduct()
{
		ofstream out("product",ios::binary);
		if(!out)
		{
				cout << "\t\t\t\t\topen failed" << endl;
				return ;
		}
		else
		{
				vector<Product*>::iterator it;
				for(it=begin();it!=end();it++)
				{
						out.write((char*)(*it),sizeof(Product));
				}
		}
		out.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x34dc(%rip), %rsi      # 0xa6e4
leaq -0x218(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x7275
movq 0x7d9c(%rip), %rbx      # 0xefd0
leaq 0x34b1(%rip), %rsi      # 0xa6ec
movl $0x10, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x7d6a(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x72a0
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x7294
movq (%r15), %rsi
movl $0x7c, %edx
movq %r14, %rdi
callq 0x2280
addq $0x8, %r15
jmp 0x7278
leaq -0x218(%rbp), %rdi
callq 0x22b0
movq 0x7d21(%rip), %rax      # 0xefc8
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 0x2160
leaq -0x120(%rbp), %rdi
callq 0x20a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x72e6
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: askForSave()
int askForSave()
{
		char t;
		if(changeFlag==1)
		{
				while(1)
				{
					getchar();
					cout << "\t\t\t\t\tdo you want to save?(y/n)" ;
					t=getchar();
					if(t=='n')
					{
							return 0;
					}
					else if(t=='y')
					{
							return 1;
					}
					else 
					{
							cout << "\t\t\t\t\tinput error!" << endl;
					}
				}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x7b68(%rip), %rbx      # 0xefd0
leaq 0x3342(%rip), %r14      # 0xa7b1
leaq 0x2d13(%rip), %r15      # 0xa189
callq 0x2290
movl $0x1e, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2240
callq 0x2290
cmpb $0x6e, %al
je 0x74dc
movzbl %al, %eax
cmpl $0x79, %eax
je 0x74d5
movl $0x11, %edx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x7476
movl $0x1, %eax
jmp 0x74de
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: Menu::writeStop()
void Menu::writeStop()
{
		ofstream st;
		st.open("stop",ios::out);
		if(st.is_open())
		{
				st << stop;
		}
		else
				cout << "open failed!" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x2320
leaq 0x2cfb(%rip), %rsi      # 0xa212
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x7545
movl 0x8(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2340
jmp 0x758b
movq 0x7a84(%rip), %rbx      # 0xefd0
leaq 0x2d92(%rip), %rsi      # 0xa2e5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x7a52(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq 0x7a36(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2160
leaq -0x118(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: Menu::showTime()
void Menu::showTime()
{
		char showtime[50];
		time_t t;
		struct tm *timeinfo;
		time(&t);
		timeinfo=localtime(&t);
		strftime(showtime,50,"%Y年%m月%d日-%H:%M:%S",timeinfo);
		cout << "\t\t\t\t\t   " << showtime << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
leaq -0x18(%rbp), %rbx
movq %rbx, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2120
leaq 0x248b(%rip), %rdx      # 0xa0ff
leaq -0x50(%rbp), %r14
movl $0x32, %esi
movq %r14, %rdi
movq %rax, %rcx
callq 0x2150
movq 0x7341(%rip), %rbx      # 0xefd0
leaq 0x2dcd(%rip), %rsi      # 0xaa63
movl $0x8, %edx
movq %rbx, %rdi
callq 0x2240
movq %r14, %rdi
callq 0x20c0
movq %rbx, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: MenuAdmin::menuShow()
void MenuAdmin::menuShow()
{
		int flag;
		system("clear");
		showTime();
		admin->writePeopleInfo();
		while(1)
		{system("clear");
		cout << "\t\t\t\t\t  ↖↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↑↗\n"           
			 <<	"\t\t\t\t\t  ←       1:add        →\n" 
			 << "\t\t\t\t\t  ←       2:delete     →\n" 
			 << "\t\t\t\t\t  ←       3:search     →\n"
			 << "\t\t\t\t\t  ←       4:show       →\n"
			 << "\t\t\t\t\t  ←       5:save       →\n" 
			 << "\t\t\t\t\t  ←       6:exit       →\n"
			 << "\t\t\t\t\t  ↙↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↓↘\n"
			 << "\t\t\t\t\tplease input your choice(1-6):" ;
		cin >> flag;
		switch(flag)
		{
				case 1:admin->addPerson();
					   sleep(1);
					   break;
				case 2:admin->deletePerson();
					   sleep(1);
					   break;
				case 3://admin->searchPerson();
					   search();
					   break;
				case 4:show();
					   break;
				case 5:admin->writePeopleInfo();
					   changeFlag=0;
					   break;
				case 6:if(askForSave())
							   admin->writePeopleInfo();
					   changeFlag=0;
					   return;
		}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2ace(%rip), %rdi      # 0xa7d0
callq 0x2170
callq 0x7c4e
movq 0x10(%rbx), %rdi
callq 0x4a0c
movq 0x72b4(%rip), %r15      # 0xefd0
movq 0x72bd(%rip), %r12      # 0xefe0
leaq -0x2c(%rbp), %r13
leaq 0x29e6(%rip), %r14      # 0xa714
leaq 0x2a9b(%rip), %rdi      # 0xa7d0
callq 0x2170
movl $0x4a, %edx
movq %r15, %rdi
leaq 0x2d23(%rip), %rsi      # 0xaa6c
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x2d5a(%rip), %rsi      # 0xaab7
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x2d69(%rip), %rsi      # 0xaada
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x2d78(%rip), %rsi      # 0xaafd
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x2d87(%rip), %rsi      # 0xab20
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x2d96(%rip), %rsi      # 0xab43
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x2da5(%rip), %rsi      # 0xab66
callq 0x2240
movl $0x4a, %edx
movq %r15, %rdi
leaq 0x2db4(%rip), %rsi      # 0xab89
callq 0x2240
movl $0x23, %edx
movq %r15, %rdi
leaq 0x2deb(%rip), %rsi      # 0xabd4
callq 0x2240
movq %r12, %rdi
movq %r13, %rsi
callq 0x20f0
movl -0x2c(%rbp), %eax
decl %eax
cmpl $0x5, %eax
ja 0x7d2e
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x5682
jmp 0x7e59
movq 0x10(%rbx), %rdi
callq 0x4a0c
leaq 0x73c5(%rip), %rax      # 0xf1f0
movl $0x0, (%rax)
jmp 0x7d2e
movq %rbx, %rdi
callq 0x8f20
jmp 0x7d2e
movq %rbx, %rdi
callq 0x8fee
jmp 0x7d2e
movq 0x10(%rbx), %rdi
callq 0x5694
movl $0x1, %edi
callq 0x2130
jmp 0x7d2e
callq 0x7457
testl %eax, %eax
je 0x7e7a
movq 0x10(%rbx), %rdi
callq 0x4a0c
leaq 0x736f(%rip), %rax      # 0xf1f0
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: MenuAdmin::search()
void MenuAdmin::search()
{
		int flag;
		while(1)
		{
				system("clear");
				cout << "\t\t\t\t\t1:search people\n"
					 << "\t\t\t\t\t2:search product\n"
					 << "\t\t\t\t\t3:exit\n"
					 << "\t\t\t\t\tplease input your choice(1-3):";
				cin >> flag;
				switch(flag)
				{
						case 1:admin->searchPerson();
							   system_pause();
							   break;
						case 2:admin->searchProduct();
							   system_pause();
							   break;
						case 3:return ;
					    deafault:cout << "\t\t\t\t\tinput error!" << endl;
							     break;
				}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x6098(%rip), %r15      # 0xefd0
leaq 0x1cf3(%rip), %r12      # 0xac32
movq 0x609a(%rip), %r13      # 0xefe0
leaq -0x2c(%rbp), %r14
leaq 0x187f(%rip), %rdi      # 0xa7d0
callq 0x2170
movl $0x15, %edx
movq %r15, %rdi
leaq 0x1c93(%rip), %rsi      # 0xabf8
callq 0x2240
movl $0x16, %edx
movq %r15, %rdi
leaq 0x1c95(%rip), %rsi      # 0xac0e
callq 0x2240
movl $0xc, %edx
movq %r15, %rdi
leaq 0x1c98(%rip), %rsi      # 0xac25
callq 0x2240
movl $0x23, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
movq %r13, %rdi
movq %r14, %rsi
callq 0x20f0
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x8fcc
cmpl $0x2, %eax
je 0x8fc1
cmpl $0x3, %eax
jne 0x8f4a
jmp 0x8fdf
movq 0x10(%rbx), %rdi
callq 0x5734
jmp 0x8fd5
movq 0x10(%rbx), %rdi
callq 0x56a6
callq 0x9152
jmp 0x8f4a
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: MenuAdmin::show()
void MenuAdmin::show()
{
		int flag;
		while(1)
		{
				system("clear");
		cout << "\t\t\t\t\t◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇\n"
			 <<	"\t\t\t\t\t◇1:show the people   ◇\n"  
			 << "\t\t\t\t\t◇2:show the product  ◇\n" 
			 << "\t\t\t\t\t◇3:show the record   ◇\n" 
			 << "\t\t\t\t\t◇4:exit              ◇\n"
			 << "\t\t\t\t\t◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇◇\n"
			 << "\t\t\t\t\tplease input the choice(1-4):" ;
		cin >> flag;
		switch(flag)
		{
				case 1:admin->showPerson();
					   system_pause();
					   break;
				case 2:admin->showProduct();
					   system_pause();
					 //  admin->temp->showAll();
					   break;
				case 3:admin->readRecord();
					   system_pause();
					   break;
				case 4:return ;
				default:cout << "\t\t\t\t\tinput error!" << endl;
						break;
		
		}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x5fca(%rip), %r15      # 0xefd0
leaq 0x1c49(%rip), %r12      # 0xac56
leaq -0x2c(%rbp), %r13
leaq 0x1750(%rip), %r14      # 0xa768
leaq 0x17b1(%rip), %rdi      # 0xa7d0
callq 0x2170
movl $0x48, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
movl $0x20, %edx
movq %r15, %rdi
leaq 0x1c5c(%rip), %rsi      # 0xac9f
callq 0x2240
movl $0x20, %edx
movq %r15, %rdi
leaq 0x1c69(%rip), %rsi      # 0xacc0
callq 0x2240
movl $0x20, %edx
movq %r15, %rdi
leaq 0x1c76(%rip), %rsi      # 0xace1
callq 0x2240
movl $0x20, %edx
movq %r15, %rdi
leaq 0x1c83(%rip), %rsi      # 0xad02
callq 0x2240
movl $0x48, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x2240
movl $0x22, %edx
movq %r15, %rdi
leaq 0x1c80(%rip), %rsi      # 0xad23
callq 0x2240
movq 0x5f31(%rip), %rdi      # 0xefe0
movq %r13, %rsi
callq 0x20f0
movl -0x2c(%rbp), %eax
decl %eax
cmpl $0x3, %eax
ja 0x9103
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x56b8
callq 0x9152
jmp 0x9018
movq 0x10(%rbx), %rdi
callq 0x48cc
callq 0x9152
jmp 0x9018
movq 0x10(%rbx), %rdi
callq 0x5670
callq 0x9152
jmp 0x9018
movl $0x11, %edx
movq %r15, %rdi
leaq 0x1077(%rip), %rsi      # 0xa189
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x9018
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: Menu::system_pause()
void Menu::system_pause()
{
		getchar();
		puts("Press any key to continue...");
		system("stty raw");
		getchar();
		system("stty cooked");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
callq 0x2290
leaq 0x2138(%rip), %rdi      # 0xb29a
callq 0x22e0
leaq 0x2149(%rip), %rdi      # 0xb2b7
callq 0x2170
callq 0x2290
leaq 0x2141(%rip), %rdi      # 0xb2c0
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/./hashapi.h
// Function: CommitMessage::hash(Sha1Hash&, Blake2Hash&)
int hash(Sha1Hash& sha, Blake2Hash& b2h) {
    // header.data() contains a \x00 character, so leave it out of string s.
    sha.update(header.data(), header.size());
    std::string s = toRawString();
    sha.update(s.c_str(), s.size());
    sha.flush();
    b2h.update(header.data(), header.size());
    b2h.update(s.c_str(), s.size());
    b2h.flush();
    return 0;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x8(%rdi), %rsi
movq 0x10(%rdi), %rdx
subq %rsi, %rdx
movq %r15, %rdi
callq 0x688c
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x68c6
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x688c
leaq 0x14(%r15), %rsi
movq %r15, %rdi
callq 0x3440
movb $0x0, 0x74(%r15)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x6c9a
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x6c9a
leaq 0x48(%rbx), %rdi
movl $0x40, %edx
movq %rbx, %rsi
callq 0xad4c
movb $0x0, 0x40(%rbx)
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5a80
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3240
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x5aac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x3240
movq %rbx, %rdi
callq 0x3480
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/git-mine.cpp
// Function: MineBoss::commitMatch()
void commitMatch() {
    for (size_t i = 0; i < pool.size(); i++) {
      if (pool.at(i)->matchFound) {
        commitMatchWith(*pool.at(i));
        return;
      }
    }
    fprintf(stderr, "A thread set searchDone but didn't set matchFound.\n");
  }

// Assembly:
pushq %rbx
movq 0x1b0(%rdi), %rdx
movq 0x1b8(%rdi), %rax
subq %rdx, %rax
setne %bl
je 0x5fff
sarq $0x4, %rax
cmpq $0x1, %rax
movq %rax, %rsi
adcq $0x0, %rsi
movq (%rdx), %rcx
cmpq $0x0, 0x160(%rcx)
jne 0x5fdb
addq $0x10, %rdx
decq %rsi
xorl %edi, %edi
cmpq %rdi, %rsi
je 0x5fff
movq (%rdx), %rcx
addq $0x10, %rdx
incq %rdi
cmpq $0x0, 0x160(%rcx)
je 0x5fbc
cmpq %rax, %rdi
setb %bl
movq 0x150(%rcx), %rdi
leaq 0x180(%rcx), %rsi
leaq 0x1f8(%rcx), %rdx
addq $0x18, %rcx
callq 0x3998
testb %bl, %bl
je 0x5fff
popq %rbx
retq
callq 0x3647
jmp 0x5ffd
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/git-mine.cpp
// Function: MineBoss::stop()
void stop() {
    { // Signal all threads to quit.
      std::unique_lock<std::mutex> lock(bossMutex);
      stopRequested = true;
      cond.notify_all();
    }
    // Wait for threads to quit.
    for (size_t patience = 5; ; patience--) {
      if (!patience) {
        fprintf(stderr,
                "Out of patience! Use ctrl+C to kill me.\n"
                "Threads seem to be deadlocked.\n");
        break;
      }
      if (patience != 5) {
        fprintf(stderr, "stop: wait %zus:", patience);
      }
      if (printProgressAt1Hz()) {
        break;
      }
    }
    // Print something if thread cleanup hangs process.
    if (0) fprintf(stderr, "Cleaning up threads.\n");
    // Join (reap) threads in ThreadLocal::~ThreadLocal().
    pool.clear();
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x150(%rdi), %rax
leaq 0x8(%rsp), %r14
movq %rax, (%r14)
movb $0x0, 0x8(%r14)
movq %r14, %rdi
callq 0x6e94
movb $0x1, %al
movb %al, 0x8(%r14)
movb %al, 0x1a8(%rbx)
leaq 0x178(%rbx), %rdi
callq 0x3450
movq %r14, %rdi
callq 0x6e7e
movl $0x5, %r14d
movq 0x9f73(%rip), %r12      # 0xffd0
leaq 0x6520(%rip), %r15      # 0xc584
cmpq $0x5, %r14
jne 0x607b
movq %rbx, %rdi
callq 0x5d6a
decq %r14
testl %eax, %eax
je 0x6064
jmp 0x6098
testq %r14, %r14
je 0x6093
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x3340
jmp 0x606a
callq 0x3663
addq $0x1b0, %rbx            # imm = 0x1B0
movq %rbx, %rdi
callq 0x808a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/./hashapi.h
// Function: CommitMessage::parseTimestamp(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>>*, long long*)
static int parseTimestamp(std::string* packed, std::string* thetime,
                            std::string* thetz, long long* binarytime) {
    const char* s = packed->c_str();
    int n = 0;
    int limit = strlen(s);
    // The timestamp is after <email-id> and some whitespace.
    const char* token[] = {"<", ">", " "};
    for (size_t i = 0; i < sizeof(token)/sizeof(token[0]); i++) {
      n += strcspn(s + n, token[i]);
      n += strspn(s + n, token[i]);
      if (n >= limit) {
        break;
      }
    }
    if (n >= limit) {
      fprintf(stderr, "invalid timestamp - overran limit\n");
      return 1;
    }
    s += n;
    limit -= n;
    if (sscanf(s, "%lld%n", binarytime, &n) != 1) {
      fprintf(stderr, "invalid timestamp: \"%.*s\"\n", limit, s);
      return 1;
    }
    thetime->assign(s, s + n);
    thetz->assign(s + n);
    packed->erase(packed->begin() + (s - packed->c_str()), packed->end());
    return 0;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, 0x20(%rsp)
movq %rdx, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdi, 0x18(%rsp)
movq (%rdi), %rbx
movl $0x0, 0x4(%rsp)
movq %rbx, %rdi
callq 0x3100
movq %rax, %r13
xorl %r15d, %r15d
leaq 0x96d4(%rip), %r12      # 0xfc70
xorl %r14d, %r14d
movslq %r14d, %r14
leaq (%rbx,%r14), %rdi
movq (%r15,%r12), %rbp
movq %rbp, %rsi
callq 0x3040
addl %eax, %r14d
movl %r14d, 0x4(%rsp)
movslq %r14d, %r14
leaq (%rbx,%r14), %rdi
movq %rbp, %rsi
callq 0x30f0
addl %eax, %r14d
movl %r14d, 0x4(%rsp)
cmpl %r13d, %r14d
jge 0x65e3
leaq 0x8(%r15), %rax
cmpq $0x10, %r15
movq %rax, %r15
jne 0x659f
movslq 0x4(%rsp), %r15
cmpl %r15d, %r13d
jle 0x667d
addq %r15, %rbx
leaq 0x5a62(%rip), %rsi      # 0xc05d
xorl %ebp, %ebp
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
movq 0x20(%rsp), %rdx
xorl %eax, %eax
callq 0x3210
cmpl $0x1, %eax
jne 0x6684
movslq 0x4(%rsp), %r8
movq 0x8(%rsp), %rdi
movq 0x8(%rdi), %rdx
xorl %esi, %esi
movq %rbx, %rcx
callq 0x3280
movslq 0x4(%rsp), %r12
addq %rbx, %r12
movq 0x10(%rsp), %r14
movq 0x8(%r14), %r13
movq %r12, %rdi
callq 0x3100
movq %r14, %rdi
xorl %esi, %esi
movq %r13, %rdx
movq %r12, %rcx
movq %rax, %r8
callq 0x33a0
movq %rbx, %rax
movq 0x18(%rsp), %rcx
subq (%rcx), %rax
movq %rax, 0x8(%rcx)
movb $0x0, (%rbx)
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x36a7
jmp 0x66a5
subl %r15d, %r13d
movq 0x9942(%rip), %rax      # 0xffd0
movq (%rax), %rdi
leaq 0x5c31(%rip), %rsi      # 0xc2c9
movl %r13d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x3340
movl $0x1, %ebp
jmp 0x666c
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/./hashapi.h
// Function: Sha1Hash::update(char const*, unsigned long)
void update(const char* data, size_t len) {
    if (!init_done) {
      SHA1_Init(&ctx);
      init_done = true;
    }
    SHA1_Update(&ctx, reinterpret_cast<const void*>(data), len);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0x74(%rdi)
jne 0x68ae
leaq 0x14(%r15), %rdi
callq 0x31d0
movb $0x1, 0x74(%r15)
addq $0x14, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3070
nop
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/./hashapi.h
// Function: Blake2Hash::update(char const*, unsigned long)
void update(const char* data, size_t len) {
    if (!init_done) {
      init_done = true;
      blake2b_init(&ctx, sizeof(result));
    }
    blake2b_update(&ctx, reinterpret_cast<const void*>(data), len);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpb $0x0, 0x40(%rdi)
jne 0x6cc1
movb $0x1, 0x40(%r15)
leaq 0x48(%r15), %rdi
movl $0x40, %esi
callq 0x8181
addq $0x48, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x82b1
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/git-mine.cpp
// Function: MineBoss::ThreadLocal::worker()
void worker() {
      doWork();
      std::unique_lock<std::mutex> lock(parent->bossMutex);
      go = false;
      parent->cond.notify_all();
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
callq 0x76ec
movl $0x150, %eax            # imm = 0x150
addq (%rbx), %rax
movq %rsp, %r14
movq %rax, (%r14)
xorl %ebp, %ebp
movb %bpl, 0x8(%r14)
movq %r14, %rdi
callq 0x6e94
movb $0x1, 0x8(%r14)
movb %bpl, 0x148(%rbx)
movl $0x178, %edi            # imm = 0x178
addq (%rbx), %rdi
callq 0x3450
movq %r14, %rdi
callq 0x6e7e
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/git-mine.cpp
// Function: MineBoss::ThreadLocal::doWork()
void doWork() {
      noodle.set_ctime(parent->ctime_hint);
      for (;;) {
        if (search(parent->atime_hint)) {
          return;
        }

        // Increment ctime and try again.
        commit_delta++;
        noodle.set_ctime(noodle.ctime() + 1);
      }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x18(%rdi), %r14
movq (%rdi), %rax
movq 0x138(%rax), %rsi
movq %r14, %rdi
callq 0x7738
movq (%rbx), %rax
movq 0x130(%rax), %rsi
movq %rbx, %rdi
callq 0x782a
testl %eax, %eax
jne 0x772f
incq 0x10(%rbx)
movq 0x140(%rbx), %rsi
incq %rsi
jmp 0x7701
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/./hashapi.h
// Function: Blake2Hash::instr(unsigned char*, unsigned long, unsigned long*)
int instr(uint8_t* want, size_t wantlen, size_t* matchlen) {
    int best = -1;
    *matchlen = 0;
    if (!wantlen) {
      return best;
    }
    for (size_t n = 0; n < sizeof(result); ) {
      size_t i = 0;
      void* p = memchr(&result[n], want[i], sizeof(result) - n);
      if (!p) {
        return best;
      }
      // memchr matched one byte.
      n = (reinterpret_cast<uint8_t*>(p) - result) + 1;
      i++;
      // Check how many bytes long this match is.
      while (n < sizeof(result) && i < wantlen && want[i] == result[n]) {
        i++;
        n++;
      }
      if (i > *matchlen) {
        best = n - i;
        *matchlen = i;
      }
    }
    return best;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq $0x0, (%rcx)
testq %rdx, %rdx
je 0x7ca8
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0xffffffff, %r13d      # imm = 0xFFFFFFFF
xorl %ebp, %ebp
cmpq $0x3f, %rbp
ja 0x7cb2
leaq (%r12,%rbp), %rdi
movzbl (%r15), %esi
movl $0x40, %edx
subq %rbp, %rdx
callq 0x3260
testq %rax, %rax
je 0x7c98
cmpq $0x1, %r14
sete %sil
movq %rax, %rdx
subq %r12, %rdx
incq %rdx
cmpq $0x40, %rdx
setae %dil
movl $0x1, %ecx
orb %sil, %dil
jne 0x7c85
movb (%r15,%rcx), %sil
cmpb (%r12,%rdx), %sil
jne 0x7c85
incq %rcx
leaq 0x1(%rdx), %rbp
cmpq $0x3e, %rdx
ja 0x7c88
movq %rbp, %rdx
cmpq %r14, %rcx
jb 0x7c64
jmp 0x7c88
movq %rdx, %rbp
cmpq (%rbx), %rcx
jbe 0x7c9d
movl %ebp, %r13d
subl %ecx, %r13d
movq %rcx, (%rbx)
jmp 0x7c9d
movl %r13d, 0x4(%rsp)
testq %rax, %rax
jne 0x7c1d
jmp 0x7cb7
movl $0xffffffff, 0x4(%rsp)  # imm = 0xFFFFFFFF
jmp 0x7cb7
movl %r13d, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_init_param
int blake2b_init_param( blake2b_state *S, const blake2b_param *P )
{
  const uint8_t *p = ( const uint8_t * )( P );
  size_t i;

  blake2b_init0( S );

  /* IV XOR ParamBlock */
  for( i = 0; i < 8; ++i )
    S->h[i] ^= load64( p + sizeof( S->h[i] ) * i );

  S->outlen = P->digest_length;
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x40, %rdi
xorl %r15d, %r15d
movl $0xb8, %edx
xorl %esi, %esi
callq 0x3170
movaps 0x4637(%rip), %xmm0     # 0xc770
movups %xmm0, (%rbx)
movaps 0x463d(%rip), %xmm0     # 0xc780
movups %xmm0, 0x10(%rbx)
movaps 0x4642(%rip), %xmm0     # 0xc790
movups %xmm0, 0x20(%rbx)
movaps 0x4647(%rip), %xmm0     # 0xc7a0
movups %xmm0, 0x30(%rbx)
movq (%r14,%r15,8), %rax
xorq %rax, (%rbx,%r15,8)
incq %r15
cmpq $0x8, %r15
jne 0x815d
movzbl (%r14), %eax
movq %rax, 0xe8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_init
int blake2b_init( blake2b_state *S, size_t outlen )
{
  blake2b_param P[1];

  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;

  P->digest_length = (uint8_t)outlen;
  P->key_length    = 0;
  P->fanout        = 1;
  P->depth         = 1;
  store32( &P->leaf_length, 0 );
  store32( &P->node_offset, 0 );
  store32( &P->xof_length, 0 );
  P->node_depth    = 0;
  P->inner_length  = 0;
  memset( P->reserved, 0, sizeof( P->reserved ) );
  memset( P->salt,     0, sizeof( P->salt ) );
  memset( P->personal, 0, sizeof( P->personal ) );
  return blake2b_init_param( S, P );
}

// Assembly:
leaq -0x41(%rsi), %rcx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpq $-0x40, %rcx
jb 0x81c5
subq $0x48, %rsp
movq %rsp, %rax
movb %sil, (%rax)
movw $0x100, 0x1(%rax)       # imm = 0x100
movb $0x1, 0x3(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movups %xmm0, 0x14(%rax)
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x30(%rax)
movq %rax, %rsi
callq 0x8114
xorl %eax, %eax
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_init_key
int blake2b_init_key( blake2b_state *S, size_t outlen, const void *key, size_t keylen )
{
  blake2b_param P[1];

  if ( ( !outlen ) || ( outlen > BLAKE2B_OUTBYTES ) ) return -1;

  if ( !key || !keylen || keylen > BLAKE2B_KEYBYTES ) return -1;

  P->digest_length = (uint8_t)outlen;
  P->key_length    = (uint8_t)keylen;
  P->fanout        = 1;
  P->depth         = 1;
  store32( &P->leaf_length, 0 );
  store32( &P->node_offset, 0 );
  store32( &P->xof_length, 0 );
  P->node_depth    = 0;
  P->inner_length  = 0;
  memset( P->reserved, 0, sizeof( P->reserved ) );
  memset( P->salt,     0, sizeof( P->salt ) );
  memset( P->personal, 0, sizeof( P->personal ) );

  if( blake2b_init_param( S, P ) < 0 ) return -1;

  {
    uint8_t block[BLAKE2B_BLOCKBYTES];
    memset( block, 0, BLAKE2B_BLOCKBYTES );
    memcpy( block, key, keylen );
    blake2b_update( S, block, BLAKE2B_BLOCKBYTES );
    secure_zero_memory( block, BLAKE2B_BLOCKBYTES ); /* Burn the key from stack */
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc0, %rsp
leaq -0x41(%rsi), %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
cmpq $-0x40, %rax
jb 0x829f
movq %rcx, %r14
movq %rdx, %r15
testq %rdx, %rdx
sete %al
addq $-0x41, %rcx
cmpq $-0x40, %rcx
setb %cl
orb %al, %cl
jne 0x829f
movq %rdi, %rbx
movq %rsp, %rax
movb %sil, (%rax)
movb %r14b, 0x1(%rax)
movw $0x101, 0x2(%rax)       # imm = 0x101
xorps %xmm0, %xmm0
movups %xmm0, 0x4(%rax)
movups %xmm0, 0x14(%rax)
movups %xmm0, 0x24(%rax)
movups %xmm0, 0x30(%rax)
movq %rax, %rsi
callq 0x8114
leaq 0x40(%rsp), %r12
xorps %xmm0, %xmm0
movaps %xmm0, 0x70(%r12)
movaps %xmm0, 0x60(%r12)
movaps %xmm0, 0x50(%r12)
movaps %xmm0, 0x40(%r12)
movaps %xmm0, 0x30(%r12)
movaps %xmm0, 0x20(%r12)
movaps %xmm0, 0x10(%r12)
movaps %xmm0, (%r12)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x31e0
movl $0x80, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x82b1
movq 0x7ae7(%rip), %rax      # 0xfd78
xorl %ebp, %ebp
movl $0x80, %edx
movq %r12, %rdi
xorl %esi, %esi
callq *%rax
movl %ebp, %eax
addq $0xc0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq