LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
andq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq 0x8(%r15), %r12
je 0x4f77
movq (%r12), %rdi
addq $0x20, %rdi
movq %r14, %rsi
callq 0x2280
testl %eax, %eax
jne 0x4f71
movq %rbx, %rdi
movq %r12, %rsi
callq 0x557e
addq $0x8, %r12
jmp 0x4f4c
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x55dc
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x28, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
andq $0x0, -0x20(%rbp)
movq 0x801b(%rip), %rdi      # 0xcfd0
leaq 0x32e9(%rip), %rsi      # 0x82a5
callq 0x21c0
movq 0x8018(%rip), %rdi      # 0xcfe0
leaq -0xc(%rbp), %rsi
callq 0x2100
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x4ec4
testq %rax, %rax
je 0x4fec
movq %rax, %rdi
callq 0x4896
jmp 0x5007
movq 0x7fdd(%rip), %rdi      # 0xcfd0
leaq 0x3651(%rip), %rsi      # 0x864b
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq -0x30(%rbp), %rdi
callq 0x55dc
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x55dc
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0x8(%rdi), %rax
cmpq %r14, %rax
je 0x5312
movq %rdi, %rbx
cmpq %rax, %r14
je 0x530d
movq (%r14), %rdi
callq 0x4896
addq $0x8, %r14
movq 0x8(%rbx), %rax
jmp 0x52f6
popq %rbx
popq %r14
popq %rbp
retq
movq 0x7cb7(%rip), %rdi      # 0xcfd0
leaq 0x33cf(%rip), %rsi      # 0x86ef
callq 0x21c0
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x339c(%rip), %rsi      # 0x8700
leaq -0x240(%rbp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x2320
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x220(%rbp,%rax)
je 0x53a7
movq 0x7c42(%rip), %rdi      # 0xcfd0
leaq 0x3373(%rip), %rsi      # 0x8708
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x5485
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x53b4
movq %rax, 0x8(%rbx)
pushq $0x7c
popq %r14
leaq -0x240(%rbp), %r15
leaq 0x7e2a(%rip), %r13      # 0xd1f0
leaq -0x34(%rbp), %r12
movq %r14, %rdi
callq 0x21d0
xorps %xmm0, %xmm0
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x40(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movups 0x30fc(%rip), %xmm0     # 0x84ec
movups %xmm0, 0x48(%rax)
movups 0x3101(%rip), %xmm0     # 0x84fc
movups %xmm0, 0x58(%rax)
movups 0x3106(%rip), %xmm0     # 0x850c
movups %xmm0, 0x68(%rax)
andw $0x0, 0x78(%rax)
movq %rax, -0x30(%rbp)
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
callq 0x2240
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x220(%rbp,%rax)
jne 0x545c
movq %rbx, %rdi
leaq -0x30(%rbp), %rsi
callq 0x557e
movq -0x30(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x34(%rbp)
movq %r13, %rdi
movq %r12, %rsi
callq 0x4526
jmp 0x53ca
movq -0x30(%rbp), %rdi
pushq $0x7c
popq %rsi
callq 0x21e0
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
movl %eax, 0x7d73(%rip)      # 0xd1ec
leaq -0x240(%rbp), %rdi
callq 0x2050
leaq -0x240(%rbp), %rdi
callq 0x2070
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x54a7
jmp 0x54a7
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq 0x3226(%rip), %rsi      # 0x8700
leaq -0x220(%rbp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x2200
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x200(%rbp,%rax)
je 0x551a
movq 0x7acc(%rip), %rdi      # 0xcfd0
leaq 0x31fd(%rip), %rsi      # 0x8708
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x5548
movq (%rbx), %r12
pushq $0x7c
popq %r15
cmpq 0x8(%rbx), %r12
je 0x553c
movq (%r12), %rsi
movq %r14, %rdi
movq %r15, %rdx
callq 0x2260
addq $0x8, %r12
jmp 0x5521
leaq -0x220(%rbp), %rdi
callq 0x2290
leaq -0x220(%rbp), %rdi
callq 0x22a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x5566
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x77c7(%rip), %rbx      # 0xcfd0
leaq 0x2fed(%rip), %r14      # 0x87fd
leaq 0x295f(%rip), %r15      # 0x8176
callq 0x2270
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21c0
callq 0x2270
cmpb $0x6e, %al
je 0x5852
movzbl %al, %eax
cmpl $0x79, %eax
je 0x584d
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x5817
pushq $0x1
popq %rax
jmp 0x5854
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x22e0
leaq 0x2972(%rip), %rsi      # 0x81ff
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2030
leaq -0x1a0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x58b9
movl 0x8(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2300
jmp 0x58d4
movq 0x7710(%rip), %rdi      # 0xcfd0
leaq 0x2a0b(%rip), %rsi      # 0x82d2
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq -0x210(%rbp), %rdi
callq 0x22a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x48, %rsp
leaq -0x10(%rbp), %rbx
movq %rbx, %rdi
callq 0x2190
movq %rbx, %rdi
callq 0x2120
leaq 0x22dc(%rip), %rdx      # 0x80ec
leaq -0x50(%rbp), %rbx
pushq $0x32
popq %rsi
movq %rbx, %rdi
movq %rax, %rcx
callq 0x2160
movq 0x71a7(%rip), %rdi      # 0xcfd0
leaq 0x2c7f(%rip), %rsi      # 0x8aaf
callq 0x21c0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2420(%rip), %rdi      # 0x881c
callq 0x2170
callq 0x5dec
movq 0x10(%rbx), %rdi
callq 0x371a
leaq 0x280a(%rip), %r12      # 0x8c20
movq 0x6bc3(%rip), %r13      # 0xcfe0
leaq -0x2c(%rbp), %r14
leaq 0x2320(%rip), %r15      # 0x8748
leaq 0x23ed(%rip), %rdi      # 0x881c
callq 0x2170
movq 0x6b95(%rip), %rdi      # 0xcfd0
leaq 0x2676(%rip), %rsi      # 0x8ab8
callq 0x21c0
movq %rax, %rdi
leaq 0x26b2(%rip), %rsi      # 0x8b03
callq 0x21c0
movq %rax, %rdi
leaq 0x26c6(%rip), %rsi      # 0x8b26
callq 0x21c0
movq %rax, %rdi
leaq 0x26da(%rip), %rsi      # 0x8b49
callq 0x21c0
movq %rax, %rdi
leaq 0x26ee(%rip), %rsi      # 0x8b6c
callq 0x21c0
movq %rax, %rdi
leaq 0x2702(%rip), %rsi      # 0x8b8f
callq 0x21c0
movq %rax, %rdi
leaq 0x2716(%rip), %rsi      # 0x8bb2
callq 0x21c0
movq %rax, %rdi
leaq 0x272a(%rip), %rsi      # 0x8bd5
callq 0x21c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq %r13, %rdi
movq %r14, %rsi
callq 0x2100
movl -0x2c(%rbp), %eax
decl %eax
cmpl $0x5, %eax
ja 0x6428
movslq (%r15,%rax,4), %rax
addq %r15, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x3e5a
jmp 0x6523
movq 0x10(%rbx), %rdi
callq 0x371a
leaq 0x6cd0(%rip), %rax      # 0xd1c8
andl $0x0, (%rax)
jmp 0x6428
movq %rbx, %rdi
callq 0x7090
jmp 0x6428
movq %rbx, %rdi
callq 0x7148
jmp 0x6428
movq 0x10(%rbx), %rdi
callq 0x3e6c
pushq $0x1
popq %rdi
callq 0x2140
jmp 0x6428
callq 0x57f8
testl %eax, %eax
je 0x6542
movq 0x10(%rbx), %rdi
callq 0x371a
leaq 0x6c7f(%rip), %rax      # 0xd1c8
andl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/menu.cpp
// Function: MenuOut::menuShow()
void MenuOut::menuShow()
{
		int flag;
		pp.readPeople();
		system("clear");
		showTime();
		outPeople->pp->writePeople();
		while(1)
		{
				system("clear");
		cout << "\t\t\t\t\t◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎\n"
			 <<	"\t\t\t\t\t◎ 1:delete Product    ◎\n"
			 << "\t\t\t\t\t◎ 2:show information  ◎\n"
			 << "\t\t\t\t\t◎ 3:change passwd     ◎\n"
			 << "\t\t\t\t\t◎ 4:save              ◎\n"
			 << "\t\t\t\t\t◎ 5:exit              ◎\n"
			 << "\t\t\t\t\t◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎◎\n"
			 << "\t\t\t\t\tplease input your choice(1-5):" ;
		cin >> flag;
		switch(flag)
		{
				case 1:outPeople->deleteProduct();
					   break;
				case 2:outPeople->show();
					   system_pause();
					   break;
				case 3:outPeople->setPasswd();
					   break;
				case 4:outPeople->pp->writePeople();
					   outPeople->writeProductInfo();
					   changeFlag=0;
					   break;
				case 5:if(askForSave())
					   {
							   outPeople->pp->writePeople();
							   outPeople->writeProductInfo();
							   changeFlag=0;
					   }
					   return ;
				default:cout << "input error!" << endl;
						break;
		}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x3380
leaq 0x1beb(%rip), %rdi      # 0x881c
callq 0x2170
callq 0x5dec
movq 0x10(%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x32b4
movq 0x637e(%rip), %r15      # 0xcfd0
leaq 0x2288(%rip), %r12      # 0x8ee1
leaq -0x2c(%rbp), %r14
leaq 0x1b28(%rip), %r13      # 0x878c
leaq 0x1bb1(%rip), %rdi      # 0x881c
callq 0x2170
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x22a8(%rip), %rsi      # 0x8f2d
callq 0x21c0
movq %rax, %rdi
leaq 0x22bb(%rip), %rsi      # 0x8f4f
callq 0x21c0
movq %rax, %rdi
leaq 0x22ce(%rip), %rsi      # 0x8f71
callq 0x21c0
movq %rax, %rdi
leaq 0x22e1(%rip), %rsi      # 0x8f93
callq 0x21c0
movq %rax, %rdi
leaq 0x22f4(%rip), %rsi      # 0x8fb5
callq 0x21c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x21d5(%rip), %rsi      # 0x8eb0
callq 0x21c0
movq 0x62f9(%rip), %rdi      # 0xcfe0
movq %r14, %rsi
callq 0x2100
movl -0x2c(%rbp), %eax
decl %eax
cmpl $0x4, %eax
ja 0x6d5a
movslq (%r13,%rax,4), %rax
addq %r13, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x3d8e
jmp 0x6c64
movq 0x10(%rbx), %rdi
callq 0x2856
jmp 0x6c64
movq 0x10(%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x32b4
movq 0x10(%rbx), %rdi
callq 0x3ee2
leaq 0x6489(%rip), %rax      # 0xd1c8
andl $0x0, (%rax)
jmp 0x6c64
movq 0x10(%rbx), %rdi
callq 0x2976
callq 0x7266
jmp 0x6c64
movq %r15, %rdi
leaq 0x1417(%rip), %rsi      # 0x817b
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x6c64
callq 0x57f8
testl %eax, %eax
je 0x6da2
movq 0x10(%rbx), %rax
movq 0xb0(%rax), %rdi
callq 0x32b4
movq 0x10(%rbx), %rdi
callq 0x3ee2
leaq 0x6429(%rip), %rax      # 0xd1c8
andl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x1bc9(%rip), %r14      # 0x8c71
leaq 0x1bcf(%rip), %r15      # 0x8c7e
movq 0x5f2a(%rip), %r12      # 0xcfe0
leaq -0x2c(%rbp), %r13
leaq 0x175b(%rip), %rdi      # 0x881c
callq 0x2170
movq 0x5f03(%rip), %rdi      # 0xcfd0
leaq 0x1b70(%rip), %rsi      # 0x8c44
callq 0x21c0
movq %rax, %rdi
leaq 0x1b77(%rip), %rsi      # 0x8c5a
callq 0x21c0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x7128
cmpl $0x2, %eax
je 0x711d
cmpl $0x3, %eax
jne 0x70ba
jmp 0x7138
movq 0x10(%rbx), %rdi
callq 0x3ef4
jmp 0x7131
movq 0x10(%rbx), %rdi
callq 0x3e7e
callq 0x7266
jmp 0x70ba
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x5e70(%rip), %r15      # 0xcfd0
leaq 0x1b3b(%rip), %r12      # 0x8ca2
leaq -0x2c(%rbp), %r13
leaq 0x1642(%rip), %r14      # 0x87b4
leaq 0x16a3(%rip), %rdi      # 0x881c
callq 0x2170
movq %r15, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x1b58(%rip), %rsi      # 0x8ceb
callq 0x21c0
movq %rax, %rdi
leaq 0x1b6a(%rip), %rsi      # 0x8d0c
callq 0x21c0
movq %rax, %rdi
leaq 0x1b7c(%rip), %rsi      # 0x8d2d
callq 0x21c0
movq %rax, %rdi
leaq 0x1b8e(%rip), %rsi      # 0x8d4e
callq 0x21c0
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq %rax, %rdi
leaq 0x1b95(%rip), %rsi      # 0x8d6f
callq 0x21c0
movq 0x5dfa(%rip), %rdi      # 0xcfe0
movq %r13, %rsi
callq 0x2100
movl -0x2c(%rbp), %eax
decl %eax
cmpl $0x3, %eax
ja 0x723a
movslq (%r14,%rax,4), %rax
addq %r14, %rax
jmpq *%rax
movq 0x10(%rbx), %rdi
callq 0x3e90
callq 0x7266
jmp 0x7172
movq 0x10(%rbx), %rdi
callq 0x362c
callq 0x7266
jmp 0x7172
movq 0x10(%rbx), %rdi
callq 0x3e48
callq 0x7266
jmp 0x7172
movq %r15, %rdi
leaq 0xf32(%rip), %rsi       # 0x8176
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x7172
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x2270
leaq 0x2070(%rip), %rdi      # 0x92e6
callq 0x22c0
leaq 0x2081(%rip), %rdi      # 0x9303
callq 0x2170
callq 0x2270
leaq 0x2079(%rip), %rdi      # 0x930c
popq %rbp
jmp 0x2170
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4ae2
leaq 0x8(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x4b1c
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %r15, %rdi
callq 0x4ae2
movq %r15, %rdi
callq 0x4c7c
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
subq %rsi, %rdx
movq %rbx, %rdi
callq 0x4c90
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x4c90
movq %rbx, %rdi
callq 0x4ccc
leaq 0x8(%rsp), %rdi
callq 0x3110
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x3110
movq %rbx, %rdi
callq 0x34b0
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1b0(%rdi), %r14
xorl %r15d, %r15d
movq 0x1b8(%rbx), %rax
subq 0x1b0(%rbx), %rax
sarq $0x4, %rax
cmpq %rax, %r15
jae 0x41cf
movq %r14, %rdi
movq %r15, %rsi
callq 0x5ae2
movq (%rax), %rax
cmpq $0x0, 0x160(%rax)
jne 0x41b4
incq %r15
jmp 0x4180
movq %r14, %rdi
movq %r15, %rsi
callq 0x5ae2
movq (%rax), %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x5dbc
movq 0xae02(%rip), %rax      # 0xefd8
movq (%rax), %rcx
leaq 0x62fe(%rip), %rdi      # 0xa4de
pushq $0x33
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3510
// File: /workspace/github_cpp_makefile_star2_O2/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), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4d3c
movb $0x1, 0x1a8(%rbx)
leaq 0x178(%rbx), %rdi
callq 0x3490
movq %r14, %rdi
callq 0x4e0e
pushq $0x5
popq %r14
movq 0xada0(%rip), %r12      # 0xefd8
leaq 0x631b(%rip), %r15      # 0xa55a
cmpq $0x5, %r14
jne 0x4256
movq %rbx, %rdi
callq 0x3f28
decq %r14
testl %eax, %eax
je 0x423f
jmp 0x4284
testq %r14, %r14
je 0x426e
movq (%r12), %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %eax, %eax
callq 0x33a0
jmp 0x4245
movq (%r12), %rcx
leaq 0x6299(%rip), %rdi      # 0xa512
pushq $0x47
popq %rsi
pushq $0x1
popq %rdx
callq 0x3510
addq $0x1b0, %rbx            # imm = 0x1B0
movq %rbx, %rdi
callq 0x5dde
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
movq %rbx, %rdi
callq 0x3100
movq %rax, %r13
xorl %r12d, %r12d
leaq 0xa4d8(%rip), %rbp      # 0xecb0
xorl %r14d, %r14d
cmpq $0x18, %r12
je 0x4812
movslq %r14d, %r14
leaq (%rbx,%r14), %rdi
movq (%r12,%rbp), %r15
movq %r15, %rsi
callq 0x3040
addl %eax, %r14d
movslq %r14d, %r14
leaq (%rbx,%r14), %rdi
movq %r15, %rsi
callq 0x30f0
addl %eax, %r14d
addq $0x8, %r12
cmpl %r13d, %r14d
jl 0x47db
movl %r14d, 0x4(%rsp)
subl %r14d, %r13d
jle 0x4892
movslq %r14d, %rax
addq %rax, %rbx
leaq 0x5834(%rip), %rsi      # 0xa05d
xorl %r15d, %r15d
leaq 0x4(%rsp), %rcx
movq %rbx, %rdi
movq 0x20(%rsp), %rdx
xorl %eax, %eax
callq 0x3230
cmpl $0x1, %eax
jne 0x48b0
movslq 0x4(%rsp), %rdx
addq %rbx, %rdx
movq 0x8(%rsp), %rdi
movq %rbx, %rsi
callq 0x4acc
movslq 0x4(%rsp), %rsi
addq %rbx, %rsi
movq 0x10(%rsp), %rdi
callq 0x34f0
movq 0x18(%rsp), %rdi
movq (%rdi), %rdx
addq 0x8(%rdi), %rdx
movq %rbx, %rsi
callq 0x3060
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xa73f(%rip), %rax      # 0xefd8
movq (%rax), %rcx
leaq 0x5a03(%rip), %rdi      # 0xa2a6
pushq $0x22
popq %rsi
pushq $0x1
popq %rdx
callq 0x3510
jmp 0x48ce
movq 0xa721(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x5a08(%rip), %rsi      # 0xa2c9
movl %r13d, %edx
movq %rbx, %rcx
xorl %eax, %eax
callq 0x33a0
pushq $0x1
popq %r15
jmp 0x4880
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4b04
leaq 0x14(%r15), %rdi
callq 0x31f0
movb $0x1, 0x74(%r15)
addq $0x14, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x3080
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4cb5
movb $0x1, 0x40(%r15)
leaq 0x48(%r15), %rdi
pushq $0x40
popq %rsi
callq 0x5eb5
addq $0x48, %r15
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
popq %rbx
popq %r14
popq %r15
jmp 0x5fe2
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
callq 0x5574
movl $0x150, %esi            # imm = 0x150
addq (%rbx), %rsi
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x4d3c
movb $0x0, 0x148(%rbx)
movl $0x178, %edi            # imm = 0x178
addq (%rbx), %rdi
callq 0x3490
movq %r14, %rdi
callq 0x4e0e
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 0x55c0
movq (%rbx), %rax
movq 0x130(%rax), %rsi
movq %rbx, %rdi
callq 0x5600
testl %eax, %eax
jne 0x55b7
incq 0x10(%rbx)
movq 0x140(%rbx), %rsi
incq %rsi
jmp 0x5589
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
andq $0x0, (%rcx)
testq %rdx, %rdx
je 0x5a00
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, 0x10(%rsp)
pushq $0x1
popq %r13
subq %rdi, %r13
pushq $-0x1
popq %rax
movl %eax, 0xc(%rsp)
xorl %ebx, %ebx
pushq $0x40
popq %rbp
xorl %eax, %eax
cmpq $0x3f, %rax
ja 0x59ed
leaq (%r12,%rax), %rdi
movzbl (%r15), %esi
movq %rbp, %rdx
subq %rax, %rdx
callq 0x3290
testq %rax, %rax
je 0x59ed
addq %r13, %rax
pushq $0x1
popq %rcx
cmpq $0x3f, %rax
ja 0x59d3
cmpq %r14, %rcx
jae 0x59d3
movb (%r15,%rcx), %dl
cmpb (%r12,%rax), %dl
jne 0x59d3
incq %rcx
incq %rax
jmp 0x59b6
cmpq %rbx, %rcx
jbe 0x5992
movl %eax, %edx
subl %ecx, %edx
movl %edx, 0xc(%rsp)
movq 0x10(%rsp), %rdx
movq %rcx, (%rdx)
movq %rcx, %rbx
jmp 0x5992
movl 0xc(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $-0x1
popq %rax
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
xorl %r15d, %r15d
movl $0xf8, %edx
xorl %esi, %esi
callq 0x3180
leaq 0x48c7(%rip), %rax      # 0xa740
cmpq $0x40, %r15
je 0x5e8d
movq (%r15,%rax), %rcx
movq %rcx, (%rbx,%r15)
addq $0x8, %r15
jmp 0x5e79
xorl %eax, %eax
cmpq $0x8, %rax
je 0x5ea2
movq (%r14,%rax,8), %rcx
xorq %rcx, (%rbx,%rax,8)
incq %rax
jmp 0x5e8f
movzbl (%r14), %eax
movq %rax, 0xe8(%rbx)
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/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), %rax
cmpq $-0x40, %rax
jae 0x5ec3
pushq $-0x1
popq %rax
retq
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 0x5e58
xorl %eax, %eax
addq $0x48, %rsp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $-0x1
popq %rbp
cmpq $-0x40, %rax
jb 0x5fd0
movq %rcx, %r14
movq %rdx, %r15
testq %rdx, %rdx
sete %al
addq $-0x41, %rcx
cmpq $-0x40, %rcx
setb %cl
orb %al, %cl
jne 0x5fd0
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 0x5e58
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 0x3200
movl $0x80, %edx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5fe2
movq 0x8dbe(%rip), %rax      # 0xed80
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
// File: /workspace/github_cpp_makefile_star2_O2/ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_update
int blake2b_update( blake2b_state *S, const void *pin, size_t inlen )
{
  const unsigned char * in = (const unsigned char *)pin;
  if( inlen > 0 )
  {
    size_t left = S->buflen;
    size_t fill = BLAKE2B_BLOCKBYTES - left;
    if( inlen > fill )
    {
      S->buflen = 0;
      memcpy( S->buf + left, in, fill ); /* Fill buffer */
      blake2b_increment_counter( S, BLAKE2B_BLOCKBYTES );
      blake2b_compress( S, S->buf ); /* Compress */
      in += fill; inlen -= fill;
      while(inlen > BLAKE2B_BLOCKBYTES) {
        blake2b_increment_counter(S, BLAKE2B_BLOCKBYTES);
        blake2b_compress( S, in );
        in += BLAKE2B_BLOCKBYTES;
        inlen -= BLAKE2B_BLOCKBYTES;
      }
    }
    memcpy( S->buf + S->buflen, in, inlen );
    S->buflen += inlen;
  }
  return 0;
}

// Assembly:
testq %rdx, %rdx
je 0x60bd
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0xe0(%rdi), %rax
movl $0x80, %ebp
movl $0x80, %r12d
subq %rax, %r12
movq %rdx, %r15
subq %r12, %r15
jbe 0x6092
andq $0x0, 0xe0(%rbx)
leaq 0x60(%rbx), %r13
leaq (%rbx,%rax), %rdi
addq $0x60, %rdi
movq %r14, %rsi
movq %r12, %rdx
callq 0x3200
movq 0x40(%rbx), %rax
subq $-0x80, %rax
movq %rax, 0x40(%rbx)
sbbq $-0x1, 0x48(%rbx)
movq %rbx, %rdi
movq %r13, %rsi
callq 0x60c0
addq %r12, %r14
cmpq $0x81, %r15
jb 0x6089
movq 0x40(%rbx), %rax
leaq (%rax,%rbp), %rcx
movq %rcx, 0x40(%rbx)
cmpq $-0x80, %rax
sbbq $-0x1, 0x48(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x60c0
addq %rbp, %r14
addq $-0x80, %r15
jmp 0x6057
movq 0xe0(%rbx), %rax
jmp 0x6095
movq %rdx, %r15
leaq (%rbx,%rax), %rdi
addq $0x60, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x3200
addq %r15, 0xe0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %eax, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O2/ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b_final
int blake2b_final( blake2b_state *S, void *out, size_t outlen )
{
  uint8_t buffer[BLAKE2B_OUTBYTES] = {0};
  size_t i;

  if( out == NULL || outlen < S->outlen )
    return -1;

  if( blake2b_is_lastblock( S ) )
    return -1;

  blake2b_increment_counter( S, S->buflen );
  blake2b_set_lastblock( S );
  memset( S->buf + S->buflen, 0, BLAKE2B_BLOCKBYTES - S->buflen ); /* Padding */
  blake2b_compress( S, S->buf );

  for( i = 0; i < 8; ++i ) /* Output full hash to temp buffer */
    store64( buffer + sizeof( S->h[i] ) * i, S->h[i] );

  memcpy( out, buffer, S->outlen );
  secure_zero_memory(buffer, sizeof(buffer));
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x20(%rsp)
movaps %xmm0, 0x10(%rsp)
movaps %xmm0, (%rsp)
pushq $-0x1
popq %rbp
testq %rsi, %rsi
je 0x7af8
movq %rdi, %r14
cmpq %rdx, 0xe8(%rdi)
ja 0x7af8
cmpq $0x0, 0x50(%r14)
jne 0x7af8
movq %rsi, %rbx
movq 0xe0(%r14), %rax
addq %rax, 0x40(%r14)
adcq $0x0, 0x48(%r14)
cmpb $0x0, 0xf0(%r14)
je 0x7a8f
orq $-0x1, 0x58(%r14)
orq $-0x1, 0x50(%r14)
leaq 0x60(%r14), %r15
leaq (%r14,%rax), %rdi
addq $0x60, %rdi
movl $0x80, %edx
subq %rax, %rdx
xorl %r12d, %r12d
xorl %esi, %esi
callq 0x3180
movq %r14, %rdi
movq %r15, %rsi
callq 0x60c0
cmpq $0x8, %r12
je 0x7ad0
movq (%r14,%r12,8), %rax
movq %rax, (%rsp,%r12,8)
incq %r12
jmp 0x7abd
movq 0xe8(%r14), %rdx
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x3200
movq 0x7294(%rip), %rax      # 0xed80
xorl %ebp, %ebp
pushq $0x40
popq %rdx
movq %r14, %rdi
xorl %esi, %esi
callq *%rax
movl %ebp, %eax
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/ndsol[P]git-mine/blake2b-ref.c
// Function: blake2b
int blake2b( void *out, size_t outlen, const void *in, size_t inlen, const void *key, size_t keylen )
{
  blake2b_state S[1];

  /* Verify parameters */
  if ( NULL == in && inlen > 0 ) return -1;

  if ( NULL == out ) return -1;

  if( NULL == key && keylen > 0 ) return -1;

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

  if( keylen > BLAKE2B_KEYBYTES ) return -1;

  if( keylen > 0 )
  {
    if( blake2b_init_key( S, outlen, key, keylen ) < 0 ) return -1;
  }
  else
  {
    if( blake2b_init( S, outlen ) < 0 ) return -1;
  }

  blake2b_update( S, ( const uint8_t * )in, inlen );
  blake2b_final( S, out, outlen );
  return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rcx, %r12
testq %rdx, %rdx
sete %al
testq %rcx, %rcx
setne %cl
pushq $-0x1
popq %rbx
testq %rdi, %rdi
je 0x7b9d
andb %cl, %al
jne 0x7b9d
testq %r8, %r8
sete %al
testq %r9, %r9
setne %cl
cmpq $0x40, %r9
ja 0x7b9d
movq %rdx, %r13
movq %rsi, %r14
leaq -0x41(%rsi), %rdx
cmpq $-0x40, %rdx
jb 0x7b9d
andb %cl, %al
jne 0x7b9d
movq %rdi, %r15
movq %rsp, %rdi
movq %r14, %rsi
testq %r9, %r9
je 0x7b73
movq %r8, %rdx
movq %r9, %rcx
callq 0x5ef9
jmp 0x7b78
callq 0x5eb5
testl %eax, %eax
js 0x7b9d
movq %rsp, %rbx
movq %rbx, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0x5fe2
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x7a24
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/ndsol[P]git-mine/hashapi.cpp
// Function: hexdump(char*, unsigned long, unsigned char*, unsigned long)
int hexdump(char* buf, size_t buflen, uint8_t* bytes, size_t byteslen) {
  char* p = buf;
  size_t len = buflen;
  for (size_t i = 0; len > 0 && i < byteslen; i++) {
    size_t r = snprintf(p, len, "%02x", bytes[i]);
    if (r < len) {
      p += r;
      len -= r;
    } else {
      fprintf(stderr, "overflow on byte %zu\n", i);
      return 1;
    }
  }
  if (len) {
    *p = 0;
  }
  return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r12
movq %rdx, %r13
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x2baa(%rip), %rbp      # 0xa780
xorl %r15d, %r15d
testq %r14, %r14
je 0x7c08
cmpq %r12, %r15
jae 0x7c08
movzbl (%r13,%r15), %ecx
movq %rbx, %rdi
movq %r14, %rsi
movq %rbp, %rdx
xorl %eax, %eax
callq 0x3430
cltq
subq %rax, %r14
jbe 0x7c21
addq %rax, %rbx
incq %r15
jmp 0x7bd9
xorl %eax, %eax
testq %r14, %r14
je 0x7c12
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x73b0(%rip), %rax      # 0xefd8
movq (%rax), %rdi
leaq 0x2b53(%rip), %rsi      # 0xa785
movq %r15, %rdx
xorl %eax, %eax
callq 0x33a0
pushq $0x1
popq %rax
jmp 0x7c12
// File: /workspace/github_cpp_makefile_star2_O2/Sherhang[P]redis-for-cpp/demo1.cpp
// Function: main
int main()
{
    redisContext *conn = redisConnect("127.0.0.1", 6379);
    if (conn != NULL && conn->err) {
        printf("connection error: %s\n", conn->errstr);
        return 0;
    }

    redisReply *reply;
    reply = (redisReply*)redisCommand(conn, "SET %s %s", "foo", "bar");
    freeReplyObject(reply);

    reply =(redisReply*) redisCommand(conn, "GET %s", "foo");
    std::cout<< reply->str<<std::endl;
    reply = (redisReply*) redisCommand(conn, "lrange list1 0 %s","-1");
    cout<<reply->str<<endl;
    freeReplyObject(reply);
    redisFree(conn);
    return 0;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
leaq 0xd86c(%rip), %rdi      # 0x11004
movl $0x18eb, %esi           # imm = 0x18EB
callq 0xa020
movq %rax, %rbx
testq %rax, %rax
je 0x37c9
cmpl $0x0, (%rbx)
je 0x37c9
addq $0x4, %rbx
leaq 0xd854(%rip), %rdi      # 0x1100e
movq %rbx, %rsi
xorl %eax, %eax
callq 0x3050
jmp 0x3861
leaq 0xd854(%rip), %rsi      # 0x11024
leaq 0xd857(%rip), %r14      # 0x1102e
leaq 0xd854(%rip), %rcx      # 0x11032
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xab20
movq %rax, %rdi
callq 0x8470
leaq 0xd83c(%rip), %rsi      # 0x11036
movq %rbx, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0xab20
movq 0x18(%rax), %rsi
movq 0x137c6(%rip), %r14     # 0x16fd8
movq %r14, %rdi
callq 0x3340
movq %rax, %rdi
callq 0x3190
leaq 0xd814(%rip), %rsi      # 0x1103d
leaq 0xd81f(%rip), %rdx      # 0x1104f
movq %rbx, %rdi
xorl %eax, %eax
callq 0xab20
movq %rax, %r15
movq 0x18(%rax), %rsi
movq %r14, %rdi
callq 0x3340
movq %rax, %rdi
callq 0x3190
movq %r15, %rdi
callq 0x8470
movq %rbx, %rdi
callq 0x9d60
xorl %eax, %eax
popq %rbx
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Diggie-Bro[P]StreamCode/test/../misc/../src/builtin/io.h
// Function: getIOModule()
struct Module getIOModule() {
    struct Module ioModule;
    ioModule.module_names_ = "io";
    ioModule.configure_file_ = "io/config.strmcode";

    vector<string> module_vector;
    module_vector.push_back("io/cio.h");
    ioModule.module_files_ = module_vector;
    
    return ioModule;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x30(%rdi), %rcx
movq %rcx, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
andq $0x0, 0x50(%rdi)
leaq 0x2c67(%rip), %rsi      # 0x5024
callq 0x2210
leaq 0x20(%rbx), %rdi
leaq 0x2c5a(%rip), %rsi      # 0x5027
callq 0x2210
xorps %xmm0, %xmm0
movaps %xmm0, -0x30(%rbp)
andq $0x0, -0x20(%rbp)
leaq 0x2c55(%rip), %rsi      # 0x503a
leaq -0x50(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x2070
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x3a5a
leaq 0x40(%rbx), %r14
leaq -0x50(%rbp), %rdi
callq 0x20a0
leaq -0x30(%rbp), %rsi
movq %r14, %rdi
callq 0x28fc
leaq -0x30(%rbp), %rdi
callq 0x29c6
movq %rbx, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x243d
movq %rax, %r14
leaq -0x50(%rbp), %rdi
callq 0x20a0
jmp 0x2440
movq %rax, %r14
leaq -0x30(%rbp), %rdi
callq 0x29c6
jmp 0x244e
movq %rax, %r14
movq %rbx, %rdi
callq 0x29f2
movq %r14, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/Diggie-Bro[P]StreamCode/test/../misc/../src/builtin/io.h
// Function: executor(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<Variables, std::allocator<Variables>>)
struct Variables executor(string function, vector<struct Variables> param) {
    if (function == "print") {
        cio_std_out(param.at(0));
        struct Variables return_variable;
        return_variable.type = VOID;
        return_variable.value = "";
        return return_variable;
    } else {
        struct Variables return_variable;
        return_variable.type = VOID;
        return_variable.value = "";
        return return_variable;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdx, %r14
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x2bca(%rip), %rsi      # 0x5043
movq %rax, %rdi
callq 0x2a1b
testb %al, %al
je 0x24db
movq %r14, %rdi
xorl %esi, %esi
callq 0x2a2c
leaq -0x38(%rbp), %r14
movq %r14, %rdi
movq %rax, %rsi
callq 0x2a4a
movq %r14, %rdi
callq 0x235c
leaq -0x30(%rbp), %rdi
callq 0x20a0
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %r14
movb $0x0, 0x18(%rbx)
movl $0x4, (%rbx)
leaq 0x2c73(%rip), %rsi      # 0x5144
movq %r14, %rdi
callq 0x2210
jmp 0x2505
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
andq $0x0, 0x10(%rbx)
leaq 0x8(%rbx), %r14
movb $0x0, 0x18(%rbx)
movl $0x4, (%rbx)
leaq 0x2c47(%rip), %rsi      # 0x5144
movq %r14, %rdi
callq 0x2210
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2513
movq %rax, %rbx
movq %r14, %rdi
jmp 0x2522
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20a0
movq %rbx, %rdi
callq 0x21f0
// File: /workspace/github_cpp_makefile_star2_O2/Diggie-Bro[P]StreamCode/test/../misc/../src/runtime/memory.h
// Function: VariableManager::editVariable(VariableMem*, Variables&)
void editVariable(struct VariableMem* mem, struct Variables& variable) {
            if (variable.type != mem->type) return;
            if (mem->type == INT) {
                int nvariable = mem->integerMem;
                nvariable = atoi(variable.value.c_str());
            } else if (mem->type == DOUBLE) {
                double nvariable = mem->doubleMem;
                nvariable = atof(variable.value.c_str());
            } else if (mem->type == STRING) {
                string nvariable = mem->stringMem;
            } else if (mem->type == BOOL) {
                bool nvariable = mem->booleanMem;
                nvariable = variable.value == "false" ? false : true;
            }
        }

// Assembly:
movl (%rdx), %eax
cmpl (%rsi), %eax
jne 0x3091
cmpl $0x3, %eax
je 0x3092
cmpl $0x2, %eax
jne 0x3091
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x28, %rsp
addq $0x38, %rsi
leaq -0x28(%rbp), %rbx
movq %rbx, %rdi
callq 0x2180
movq %rbx, %rdi
callq 0x20a0
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
addq $0x8, %rdx
leaq 0x1ffb(%rip), %rsi      # 0x5098
movq %rdx, %rdi
jmp 0x2a1b
nop