LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: akw0088[P]openssl/huffman_enc.c
// Function: main
int main(int argc, char *argv[])
{
	if (argc < 2)
	{
		printf("Usage: huffman_enc file.bin\r\n");
		return -1;
	}

	char filename[256] = {0};

	unsigned int size = 0;

	char *encode = get_file(argv[1], &size);

	char *buffer = (char *)malloc(2 * size);
	if (buffer == NULL)
	{
		perror("malloc failed");
		return -1;
	}

	memset(buffer, 0, 2 * size);
	printf("Compressing %s\r\n", argv[1]);
	if (size == 0)
	{
		printf("Error: input file is 0 bytes\r\n");
		return -1;
	}

	unsigned int compressed_size = huffman_compress((unsigned char *)encode, size, (unsigned char *)buffer, size, huffbuf);
	if (compressed_size == 0)
	{
		printf("huffman_compress failed (file became larger)\r\n");
		return -1;
	}
	printf("Original size %d compressed %d ratio %f\r\n", size, compressed_size, (float) compressed_size / size);

	snprintf(filename, 255, "%s.huff", argv[1]);

	write_file(filename, buffer, compressed_size);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x2, -0x8(%rbp)
jge 0x13b9
leaq 0xca1(%rip), %rdi       # 0x2047
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1540
leaq -0x110(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x1080
movl $0x0, -0x114(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
leaq -0x114(%rbp), %rsi
callq 0x11f0
movq %rax, -0x120(%rbp)
movl -0x114(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %edi
callq 0x10a0
movq %rax, -0x128(%rbp)
cmpq $0x0, -0x128(%rbp)
jne 0x142b
leaq 0xc4b(%rip), %rdi       # 0x2065
callq 0x10d0
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1540
movq -0x128(%rbp), %rdi
movl -0x114(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x1080
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
leaq 0xc1f(%rip), %rdi       # 0x2073
movb $0x0, %al
callq 0x1060
cmpl $0x0, -0x114(%rbp)
jne 0x147e
leaq 0xc19(%rip), %rdi       # 0x2084
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1540
movq -0x120(%rbp), %rdi
movl -0x114(%rbp), %eax
movl %eax, %esi
movq -0x128(%rbp), %rdx
movl -0x114(%rbp), %eax
movl %eax, %ecx
leaq 0x2bfd(%rip), %r8       # 0x40a0
callq 0x1550
movl %eax, -0x12c(%rbp)
cmpl $0x0, -0x12c(%rbp)
jne 0x14ce
leaq 0xbe5(%rip), %rdi       # 0x20a3
movb $0x0, %al
callq 0x1060
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1540
movl -0x114(%rbp), %eax
movl %eax, %esi
movl -0x12c(%rbp), %ecx
movl %ecx, %edx
cvtsi2ss %rcx, %xmm0
cvtsi2ss %rax, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xbdb(%rip), %rdi       # 0x20d2
movb $0x1, %al
callq 0x1060
leaq -0x110(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movl $0xff, %esi
leaq 0xbe3(%rip), %rdx       # 0x20fc
movb $0x0, %al
callq 0x1070
leaq -0x110(%rbp), %rdi
movq -0x128(%rbp), %rsi
movl -0x12c(%rbp), %edx
callq 0x12e0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopl (%rax)
// File: akw0088[P]openssl/huffman.c
// Function: huffman_decompress
unsigned long huffman_decompress(const unsigned char *in,unsigned long inlen,unsigned char *out,unsigned long outlen,void *huffheap)
{
	struct _huffman_node *t,*n;
	unsigned char *heapptr = (unsigned char *)huffheap;
	unsigned long inbitctr,outptr,byte_index = 0;

	inbitctr = 0;
	t = _huffman_read_tree(in,&inbitctr,inlen,&heapptr,heapptr + HUFFHEAP_SIZE);
	if (!t) return 0;
	outptr = 0;
	for(;;)
	{
		n = t;
		while (n->lr[0])
		{
			byte_index = inbitctr >> 3;
			if (byte_index >= inlen)
				return 0;
			n = n->lr[((unsigned long)(in[byte_index] >> (~(inbitctr++) & 7))) & 1];
		}
		if (n->c == 256)
			return outptr;
		if (outptr == outlen)
			return 0;
		out[outptr++] = (unsigned char)n->c;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movq %r8, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x48(%rbp)
movq $0x0, -0x60(%rbp)
movq $0x0, -0x50(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x48(%rbp), %r8
addq $0xa8a8, %r8            # imm = 0xA8A8
leaq -0x50(%rbp), %rsi
leaq -0x48(%rbp), %rcx
callq 0x1e00
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x1d2c
movq $0x0, -0x8(%rbp)
jmp 0x1df6
movq $0x0, -0x58(%rbp)
movq -0x38(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
cmpq $0x0, (%rax)
je 0x1da5
movq -0x50(%rbp), %rax
shrq $0x3, %rax
movq %rax, -0x60(%rbp)
movq -0x60(%rbp), %rax
cmpq -0x18(%rbp), %rax
jb 0x1d69
movq $0x0, -0x8(%rbp)
jmp 0x1df6
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
movq -0x60(%rbp), %rdx
movzbl (%rcx,%rdx), %edx
movq -0x50(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x50(%rbp)
xorq $-0x1, %rcx
andq $0x7, %rcx
sarl %cl, %edx
movl %edx, %ecx
movslq %ecx, %rcx
andq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x40(%rbp)
jmp 0x1d3c
movq -0x40(%rbp), %rax
cmpq $0x100, 0x28(%rax)      # imm = 0x100
jne 0x1dbd
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x1df6
movq -0x58(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x1dd1
movq $0x0, -0x8(%rbp)
jmp 0x1df6
movq -0x40(%rbp), %rax
movq 0x28(%rax), %rax
movb %al, %dl
movq -0x20(%rbp), %rax
movq -0x58(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x58(%rbp)
movb %dl, (%rax,%rcx)
jmp 0x1d34
movq -0x8(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::Person(Person*)
Person::Person(Person *ps)
{
		//passwd=ps->getPasswd();
		strcpy(passwd,ps->getPasswd());
		id=ps->getNumber();
		stop=ps->getStop();
//		name=ps->getName();
		strcpy(name,ps->getName());
		if(ps->pp!=NULL)
				pp=ps->pp;
		if(ps->temp!=NULL)
				temp=ps->temp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq 0x12381(%rip), %rcx     # 0x14b80
addq $0x10, %rcx
movq %rcx, (%rax)
addq $0x28, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
callq 0x28c0
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq -0x10(%rbp), %rdi
callq 0x28e0
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x68(%rax)
movq -0x10(%rbp), %rdi
callq 0x2900
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x6c(%rax)
addq $0x8, %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2920
movq -0x18(%rbp), %rdi
movq %rax, %rsi
callq 0x21c0
movq -0x10(%rbp), %rax
cmpq $0x0, 0xb0(%rax)
je 0x2888
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xb0(%rcx), %rcx
movq %rcx, 0xb0(%rax)
movq -0x10(%rbp), %rax
cmpq $0x0, 0xa8(%rax)
je 0x28ac
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0xa8(%rcx), %rcx
movq %rcx, 0xa8(%rax)
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::setNumber()
void Person::setNumber()
{
		peopleMax++;
		changeFlag=1;
		vector<int>::iterator it;
		for(int i=1;i<peopleMax+1;i++)
		{
				it=find(number.begin(),number.end(),i);
				if(it==number.end())
				{
						id=i;
						number.push_back(i);
						return;
				}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
movl 0x1288a(%rip), %eax     # 0x151e4
addl $0x1, %eax
movl %eax, 0x12881(%rip)     # 0x151e4
movl $0x1, 0x1287b(%rip)     # 0x151e8
leaq -0x10(%rbp), %rdi
callq 0x5280
movl $0x1, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl 0x1285e(%rip), %ecx     # 0x151e4
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2a1d
leaq 0x12858(%rip), %rdi     # 0x151f0
callq 0x52f0
movq %rax, -0x28(%rbp)
leaq 0x12848(%rip), %rdi     # 0x151f0
callq 0x5320
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x52a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1281b(%rip), %rdi     # 0x151f0
callq 0x5320
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5350
testb $0x1, %al
jne 0x29f1
jmp 0x2a0d
movq -0x40(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, 0x68(%rax)
leaq 0x127ee(%rip), %rdi     # 0x151f0
leaq -0x14(%rbp), %rsi
callq 0x5390
jmp 0x2a1d
jmp 0x2a0f
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x297d
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::deleteId()
void Person::deleteId()
{
		vector<int>::iterator it;
		it=find(number.begin(),number.end(),id);
		if(it!=number.end())
		{
				number.erase(it);
				peopleMax--;
		}
		else
		{
				cout << "\t\t\t\t\tdelete error!" << endl;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5280
leaq 0x1279c(%rip), %rdi     # 0x151f0
callq 0x52f0
movq %rax, -0x20(%rbp)
leaq 0x1278c(%rip), %rdi     # 0x151f0
callq 0x5320
movq -0x48(%rbp), %rdx
movq %rax, -0x28(%rbp)
addq $0x68, %rdx
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x52a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0x1275b(%rip), %rdi     # 0x151f0
callq 0x5320
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5400
testb $0x1, %al
jne 0x2ab1
jmp 0x2ae3
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x54b0
movq -0x38(%rbp), %rsi
leaq 0x12727(%rip), %rdi     # 0x151f0
callq 0x5440
movq %rax, -0x40(%rbp)
movl 0x1270c(%rip), %eax     # 0x151e4
addl $-0x1, %eax
movl %eax, 0x12703(%rip)     # 0x151e4
jmp 0x2b05
movq 0x124e6(%rip), %rdi     # 0x14fd0
leaq 0xb5ff(%rip), %rsi      # 0xe0f0
callq 0x21e0
movq %rax, %rdi
movq 0x124c0(%rip), %rsi     # 0x14fc0
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::changeInfo()
void Person::changeInfo()
{
		int flag;
		cout << "\t\t\t\t\t1:change the name." << endl << "\t\t\t\t\t2:change the Number." << endl << "\t\t\t\t\t3:exit." << endl <<  "\t\t\t\t\tplease choice:" ;
		cin >> flag;
		switch(flag)
		{
				case 1: setName();
						break;
				case 2:	setNumber();
						break;
				case 3: return ;
				default:cout << "\t\t\t\t\tinput error!" << endl;
						break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq 0x12315(%rip), %rdi     # 0x14fd0
leaq 0xb494(%rip), %rsi      # 0xe156
callq 0x21e0
movq %rax, %rdi
movq 0x122ef(%rip), %rsi     # 0x14fc0
movq %rsi, -0x18(%rbp)
callq 0x2210
movq %rax, %rdi
leaq 0xb48a(%rip), %rsi      # 0xe16e
callq 0x21e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0xb489(%rip), %rsi      # 0xe188
callq 0x21e0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0xb47b(%rip), %rsi      # 0xe195
callq 0x21e0
movq 0x122ba(%rip), %rdi     # 0x14fe0
leaq -0xc(%rbp), %rsi
callq 0x20f0
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x1, %eax
je 0x2d50
jmp 0x2d3c
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x2d5b
jmp 0x2d46
movl -0x10(%rbp), %eax
subl $0x3, %eax
je 0x2d66
jmp 0x2d68
movq -0x20(%rbp), %rdi
callq 0x2b30
jmp 0x2d8a
movq -0x20(%rbp), %rdi
callq 0x2940
jmp 0x2d8a
jmp 0x2d8a
movq 0x12261(%rip), %rdi     # 0x14fd0
leaq 0xb433(%rip), %rsi      # 0xe1a9
callq 0x21e0
movq %rax, %rdi
movq 0x1223b(%rip), %rsi     # 0x14fc0
callq 0x2210
addq $0x20, %rsp
popq %rbp
retq
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::writeStop()
void Person::writeStop()
{
		ofstream st;
		st.open("stop",ios::out);
		if(st.is_open())
		{
				st << stop;
		}
		else
				cout << "open failed!" << endl;
		st.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x2320
movq -0x220(%rbp), %rdi
leaq 0xb137(%rip), %rsi      # 0xe232
movl $0x10, %edx
callq 0x2030
jmp 0x3107
leaq -0x208(%rbp), %rdi
callq 0x2150
movb %al, -0x229(%rbp)
jmp 0x311b
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x3127
jmp 0x3161
movq -0x228(%rbp), %rax
movl 0x6c(%rax), %esi
leaq -0x208(%rbp), %rdi
callq 0x2340
jmp 0x313f
jmp 0x3194
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22d0
jmp 0x31b7
movq 0x11e68(%rip), %rdi     # 0x14fd0
leaq 0xb196(%rip), %rsi      # 0xe305
callq 0x21e0
movq %rax, -0x238(%rbp)
jmp 0x317d
movq -0x238(%rbp), %rdi
movq 0x11e35(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x3192
jmp 0x3194
leaq -0x208(%rbp), %rdi
callq 0x22c0
jmp 0x31a2
leaq -0x208(%rbp), %rdi
callq 0x22d0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::readStop()
void Person::readStop()
{
		ifstream st;
		st.open("stop",ios::in);
		while(!st.eof())
		{
				st >> stop;
				st.close();
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x2240
movq -0x228(%rbp), %rdi
leaq 0xb027(%rip), %rsi      # 0xe232
movl $0x8, %edx
callq 0x2110
jmp 0x3217
jmp 0x3219
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x2370
movb %al, -0x231(%rbp)
jmp 0x3239
movb -0x231(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3247
jmp 0x3290
movq -0x230(%rbp), %rsi
addq $0x6c, %rsi
leaq -0x210(%rbp), %rdi
callq 0x20f0
jmp 0x3260
leaq -0x210(%rbp), %rdi
callq 0x2060
jmp 0x326e
jmp 0x3219
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2070
jmp 0x32a5
leaq -0x210(%rbp), %rdi
callq 0x2070
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::writestop()
void Person::writestop()
{
		ofstream st;
		st.open("stop1",ios::out);
		if(st.is_open())
		{
				st << stop;
		}
		else
				cout << "open failed!" << endl;
		st.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x2320
movq -0x220(%rbp), %rdi
leaq 0xaf3c(%rip), %rsi      # 0xe237
movl $0x10, %edx
callq 0x2030
jmp 0x3307
leaq -0x208(%rbp), %rdi
callq 0x2150
movb %al, -0x229(%rbp)
jmp 0x331b
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x3327
jmp 0x3361
movq -0x228(%rbp), %rax
movl 0x6c(%rax), %esi
leaq -0x208(%rbp), %rdi
callq 0x2340
jmp 0x333f
jmp 0x3394
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22d0
jmp 0x33b7
movq 0x11c68(%rip), %rdi     # 0x14fd0
leaq 0xaf96(%rip), %rsi      # 0xe305
callq 0x21e0
movq %rax, -0x238(%rbp)
jmp 0x337d
movq -0x238(%rbp), %rdi
movq 0x11c35(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x3392
jmp 0x3394
leaq -0x208(%rbp), %rdi
callq 0x22c0
jmp 0x33a2
leaq -0x208(%rbp), %rdi
callq 0x22d0
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::readstop()
void Person::readstop()
{
		ifstream st;
		st.open("stop1",ios::in);
		while(!st.eof())
		{
				st >> stop;
				st.close();
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x240, %rsp            # imm = 0x240
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x230(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x228(%rbp)
callq 0x2240
movq -0x228(%rbp), %rdi
leaq 0xae2c(%rip), %rsi      # 0xe237
movl $0x8, %edx
callq 0x2110
jmp 0x3417
jmp 0x3419
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x2370
movb %al, -0x231(%rbp)
jmp 0x3439
movb -0x231(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3447
jmp 0x3490
movq -0x230(%rbp), %rsi
addq $0x6c, %rsi
leaq -0x210(%rbp), %rdi
callq 0x20f0
jmp 0x3460
leaq -0x210(%rbp), %rdi
callq 0x2060
jmp 0x346e
jmp 0x3419
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x218(%rbp)
movl %eax, -0x21c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2070
jmp 0x34a5
leaq -0x210(%rbp), %rdi
callq 0x2070
addq $0x240, %rsp            # imm = 0x240
popq %rbp
retq
movq -0x218(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::showAll()
void People::showAll()
{
	//	cout << "test 169" << endl;
		vector<Person*>::iterator it;
		for(it=begin();it!=end();it++)
		{
				(*it)->show();
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x55d0
movq -0x30(%rbp), %rdi
callq 0x55f0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rdi
callq 0x5660
movq %rax, -0x20(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x3512
jmp 0x3534
leaq -0x10(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2d90
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x28(%rbp)
jmp 0x34f2
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::deleteNumber(int const&)
void People::deleteNumber(const int &id)
{
		vector<Person*>::iterator it;
		changeFlag=1;
		char t;
	 	for(it=begin();it!=end();it++)
		{
				if((*it)->getNumber()==id)
				{
						cout << "\t\t\t\t\tthe person data is:" ;
						(*it)->show() ; 
						getchar();
						cout << "\t\t\t\t\tdo you want to delete it?(y/n)" ;
						t=getchar();
						if(t=='n')
						{
								return ;
						}
						(*it)->deleteId();
		  //               cout << "test 187" << endl;
				//		delete(*it);
		    //             cout << "test 189" << endl;
						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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x55d0
movq -0x50(%rbp), %rdi
movl $0x1, 0x11c79(%rip)     # 0x151e8
callq 0x55f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x35a3
jmp 0x367b
leaq -0x18(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x28e0
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x3665
movq 0x11a09(%rip), %rdi     # 0x14fd0
leaq 0xac6f(%rip), %rsi      # 0xe23d
callq 0x21e0
leaq -0x18(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2d90
callq 0x22a0
movq 0x119e0(%rip), %rdi     # 0x14fd0
leaq 0xac5f(%rip), %rsi      # 0xe256
callq 0x21e0
callq 0x22a0
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x6e, %eax
jne 0x3612
jmp 0x369d
leaq -0x18(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2a30
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5760
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x56f0
movq %rax, -0x40(%rbp)
movq 0x11988(%rip), %rdi     # 0x14fd0
leaq 0xac2b(%rip), %rsi      # 0xe27a
callq 0x21e0
movq %rax, %rdi
movq 0x11962(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x369d
jmp 0x3667
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x48(%rbp)
jmp 0x3580
movq 0x1194e(%rip), %rdi     # 0x14fd0
leaq 0xaa67(%rip), %rsi      # 0xe0f0
callq 0x21e0
movq %rax, %rdi
movq 0x11928(%rip), %rsi     # 0x14fc0
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::deleteName(char const*)
void People::deleteName(const char* name)
{
		vector<Person*>::iterator it;
		changeFlag=1;
		char t;
		for(it=begin();it!=end();it++)
		{
				if(strcmp((*it)->getName(),name)==0)
				{
						getchar();
						cout << "\t\t\t\t\tthe person data is:";
						(*it)->show();
						cout << "\t\t\t\t\tdo you want to delete it?(y/n)";
						t=getchar();
						if(t=='y')
						{
						(*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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x55d0
movq -0x50(%rbp), %rdi
movl $0x1, 0x11b09(%rip)     # 0x151e8
callq 0x55f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x50(%rbp), %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x3713
jmp 0x37fc
leaq -0x18(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2920
movq %rax, %rdi
movq -0x10(%rbp), %rsi
callq 0x22b0
cmpl $0x0, %eax
jne 0x37e6
callq 0x22a0
movq 0x1188b(%rip), %rdi     # 0x14fd0
leaq 0xaaf1(%rip), %rsi      # 0xe23d
callq 0x21e0
leaq -0x18(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2d90
movq 0x11867(%rip), %rdi     # 0x14fd0
leaq 0xaae6(%rip), %rsi      # 0xe256
callq 0x21e0
callq 0x22a0
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x79, %eax
jne 0x37d9
leaq -0x18(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2a30
leaq -0x38(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x5760
movq -0x50(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x56f0
movq %rax, -0x40(%rbp)
movq 0x11814(%rip), %rdi     # 0x14fd0
leaq 0xaab7(%rip), %rsi      # 0xe27a
callq 0x21e0
movq %rax, %rdi
movq 0x117ee(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x381e
movsbl -0x19(%rbp), %eax
cmpl $0x6e, %eax
jne 0x37e4
jmp 0x37e8
jmp 0x37e6
jmp 0x37e8
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x48(%rbp)
jmp 0x36f0
movq 0x117cd(%rip), %rdi     # 0x14fd0
leaq 0xa8e6(%rip), %rsi      # 0xe0f0
callq 0x21e0
movq %rax, %rdi
movq 0x117a7(%rip), %rsi     # 0x14fc0
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::deletePeople()
void People::deletePeople()
{
		int flag,id;
		char name[32];
		while(1)
		{
			cout << "\t\t\t\t\t1:by the name." << endl << "\t\t\t\t\t2:by the id." << endl << "\t\t\t\t\t3:exit." << endl << "\t\t\t\t\tplease choice the delete way:" ;
			cin >> flag;
			switch(flag)
			{
					case 1:
						   cout << "\t\t\t\t\tplease input the name:";
						   cin >> name;
					   	deleteName(name);
					   	break;
			    	case 2:
						   cout << "\t\t\t\t\tplease input the number:";
					   	   cin >> id;
					  	   deleteNumber(id);
					  	   break;
					case 3:return ;
					default:
						   cout << "\t\t\t\t\tinput error!" << endl;
					   	   break;
			}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x11785(%rip), %rdi     # 0x14fd0
leaq 0xaa3d(%rip), %rsi      # 0xe28f
callq 0x21e0
movq %rax, %rdi
movq 0x1175f(%rip), %rsi     # 0x14fc0
movq %rsi, -0x48(%rbp)
callq 0x2210
movq %rax, %rdi
leaq 0xaa2f(%rip), %rsi      # 0xe2a3
callq 0x21e0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0xa8f9(%rip), %rsi      # 0xe188
callq 0x21e0
movq -0x48(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0xaa0b(%rip), %rsi      # 0xe2b5
callq 0x21e0
movq 0x1172a(%rip), %rdi     # 0x14fe0
leaq -0xc(%rbp), %rsi
callq 0x20f0
movl -0xc(%rbp), %eax
movl %eax, -0x3c(%rbp)
subl $0x1, %eax
je 0x38e0
jmp 0x38cc
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x3912
jmp 0x38d6
movl -0x3c(%rbp), %eax
subl $0x3, %eax
je 0x3944
jmp 0x394a
movq 0x116e9(%rip), %rdi     # 0x14fd0
leaq 0xa815(%rip), %rsi      # 0xe103
callq 0x21e0
leaq -0x30(%rbp), %rsi
movq 0x116e2(%rip), %rdi     # 0x14fe0
callq 0x5510
movq -0x38(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x36b0
jmp 0x396c
movq 0x116b7(%rip), %rdi     # 0x14fd0
leaq 0xa9b8(%rip), %rsi      # 0xe2d8
callq 0x21e0
movq 0x116b4(%rip), %rdi     # 0x14fe0
leaq -0x10(%rbp), %rsi
callq 0x20f0
movq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x3540
jmp 0x396c
addq $0x50, %rsp
popq %rbp
retq
movq 0x1167f(%rip), %rdi     # 0x14fd0
leaq 0xa851(%rip), %rsi      # 0xe1a9
callq 0x21e0
movq %rax, %rdi
movq 0x11659(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x3844
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::searchNumber(int const&)
Person* People::searchNumber(const int &id)
{
	//	cout << "111111" << endl;
		vector<Person*>::iterator it;
		for(it=begin();it!=end();it++)
		{
				if((*it)->getNumber()==id)
				{
						return (*it);
				}
		}
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x55d0
movq -0x40(%rbp), %rdi
callq 0x55f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x39d6
jmp 0x3a14
leaq -0x20(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x28e0
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x3a01
leaq -0x20(%rbp), %rdi
callq 0x5690
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3a1c
jmp 0x3a03
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x38(%rbp)
jmp 0x39b6
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::searchName(char const*)
Person* People::searchName(const char* name)
{
//		cout << "1111111" <<endl
		vector<Person*>::iterator it;
	//	it=begin();
	//	string name1;
	//	name1=(*it)->getName();
	//	cout << name1 <<endl;
	//	cout << "22222" << endl;
		for(it=begin();it!=end();it++)
		{
			if(strcmp((*it)->getName(),name)==0)
						return (*it);
		}
		cout << "\t\t\t\t\tNULL" << endl;
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x55d0
movq -0x40(%rbp), %rdi
callq 0x55f0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rdi
callq 0x5660
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x3a86
jmp 0x3acd
leaq -0x20(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x2920
movq %rax, %rdi
movq -0x18(%rbp), %rsi
callq 0x22b0
cmpl $0x0, %eax
jne 0x3aba
leaq -0x20(%rbp), %rdi
callq 0x5690
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x3af7
jmp 0x3abc
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x38(%rbp)
jmp 0x3a66
movq 0x114fc(%rip), %rdi     # 0x14fd0
leaq 0xa81b(%rip), %rsi      # 0xe2f6
callq 0x21e0
movq %rax, %rdi
movq 0x114d6(%rip), %rsi     # 0x14fc0
callq 0x2210
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::writePeople()
void People::writePeople()
{
		ofstream out("people",ios::binary);
		if(!out)
		{
				cout << "\t\t\t\t\topen failed!" << endl;
				return ;
		}
		else
		{
				vector<Person*>::iterator it;
				for(it=begin();it!=end();it++)
				{
						out.write((char*)(*it),sizeof(Person));
				}
		}
		out.close();
		//cout << "\t\t\t\t\twrite success!" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x248(%rbp)
leaq 0xa8f6(%rip), %rsi      # 0xe427
leaq -0x208(%rbp), %rdi
movl $0x4, %edx
callq 0x2220
movq -0x208(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x208(%rbp,%rax), %rdi
callq 0x20d0
movb %al, -0x239(%rbp)
jmp 0x3b62
movb -0x239(%rbp), %al
testb $0x1, %al
jne 0x3b6e
jmp 0x3bd1
movq 0x1145b(%rip), %rdi     # 0x14fd0
leaq 0xa784(%rip), %rsi      # 0xe300
callq 0x21e0
movq %rax, -0x250(%rbp)
jmp 0x3b8a
movq -0x250(%rbp), %rdi
movq 0x11428(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x3b9f
movl $0x1, -0x218(%rbp)
jmp 0x3c7f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22d0
jmp 0x3c94
leaq -0x220(%rbp), %rdi
callq 0x55d0
movq -0x248(%rbp), %rdi
callq 0x55f0
movq %rax, -0x228(%rbp)
movq -0x228(%rbp), %rax
movq %rax, -0x220(%rbp)
movq -0x248(%rbp), %rdi
callq 0x5660
movq %rax, -0x230(%rbp)
leaq -0x220(%rbp), %rdi
leaq -0x230(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x3c2a
jmp 0x3c65
leaq -0x220(%rbp), %rdi
callq 0x5690
movq (%rax), %rsi
leaq -0x208(%rbp), %rdi
movl $0xb8, %edx
callq 0x2280
jmp 0x3c4c
jmp 0x3c4e
leaq -0x220(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x238(%rbp)
jmp 0x3bfe
jmp 0x3c67
leaq -0x208(%rbp), %rdi
callq 0x22c0
jmp 0x3c75
movl $0x0, -0x218(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22d0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x2350
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::writeRecord()
void Person::writeRecord()
{
		ofstream record;
	//	int gn;
	//	char gt[50];
	//	gn=getNumber();
	//	gt=getTime();
		record.open("record",ios::app);
		if(record.is_open())
		{
					record << "Id:"  << getNumber() << "   time:" << getTime() << "  login in the system!\n"  ;
			/*	if(i==2)
				{
						record << "Id:" << getNumber() << "   time:" << pt->getLoginTime() << "   incoming:" << pt->getId() << "\n" ; 
				}
				if(i==3)
				{
						record << "Id:" << getNumber() << "   time:" << pt->getLoginTime() << "   outcoming:" << pt->getId() << "\n" ;
				}*/
		}
		else
				cout <<"open failed!" << endl;
		record.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x260, %rsp            # imm = 0x260
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x228(%rbp)
leaq -0x208(%rbp), %rdi
movq %rdi, -0x220(%rbp)
callq 0x2320
movq -0x220(%rbp), %rdi
leaq 0xa377(%rip), %rsi      # 0xe312
movl $0x1, %edx
callq 0x2030
jmp 0x3fa7
leaq -0x208(%rbp), %rdi
callq 0x2150
movb %al, -0x229(%rbp)
jmp 0x3fbb
movb -0x229(%rbp), %al
testb $0x1, %al
jne 0x3fca
jmp 0x4080
leaq 0xa348(%rip), %rsi      # 0xe319
leaq -0x208(%rbp), %rdi
callq 0x21e0
movq %rax, -0x238(%rbp)
jmp 0x3fe6
movq -0x228(%rbp), %rdi
callq 0x28e0
movq -0x238(%rbp), %rdi
movl %eax, %esi
callq 0x2340
movq %rax, -0x240(%rbp)
jmp 0x4009
movq -0x240(%rbp), %rdi
leaq 0xa306(%rip), %rsi      # 0xe31d
callq 0x21e0
movq %rax, -0x248(%rbp)
jmp 0x4025
movq -0x228(%rbp), %rdi
callq 0x2bd0
movq -0x248(%rbp), %rdi
movq %rax, %rsi
callq 0x21e0
movq %rax, -0x250(%rbp)
jmp 0x4049
movq -0x250(%rbp), %rdi
leaq 0xa2cf(%rip), %rsi      # 0xe326
callq 0x21e0
jmp 0x405e
jmp 0x40b3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x210(%rbp)
movl %eax, -0x214(%rbp)
leaq -0x208(%rbp), %rdi
callq 0x22d0
jmp 0x40d6
movq 0x10f49(%rip), %rdi     # 0x14fd0
leaq 0xa277(%rip), %rsi      # 0xe305
callq 0x21e0
movq %rax, -0x258(%rbp)
jmp 0x409c
movq -0x258(%rbp), %rdi
movq 0x10f16(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x40b1
jmp 0x40b3
leaq -0x208(%rbp), %rdi
callq 0x22c0
jmp 0x40c1
leaq -0x208(%rbp), %rdi
callq 0x22d0
addq $0x260, %rsp            # imm = 0x260
popq %rbp
retq
movq -0x210(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Person::readRecord()
void Person::readRecord()
{
		ifstream record;
		char rec[500];
		record.open("record",ios::in);
		if(record.is_open())
		{
				while(!record.eof())
				{
					record.getline(rec,sizeof(rec));
					cout << rec << endl;
				}
				cout << "\033[1A" ;
				cout << "\033[K";
//				cout << endl;
		}
		record.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x440, %rsp            # imm = 0x440
movq %rdi, -0x8(%rbp)
leaq -0x210(%rbp), %rdi
movq %rdi, -0x428(%rbp)
callq 0x2240
movq -0x428(%rbp), %rdi
leaq 0xa1f2(%rip), %rsi      # 0xe312
movl $0x8, %edx
callq 0x2110
jmp 0x412c
leaq -0x210(%rbp), %rdi
callq 0x2300
movb %al, -0x429(%rbp)
jmp 0x4140
movb -0x429(%rbp), %al
testb $0x1, %al
jne 0x414f
jmp 0x4218
jmp 0x4151
movq -0x210(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x210(%rbp,%rax), %rdi
callq 0x2370
movb %al, -0x42a(%rbp)
jmp 0x4171
movb -0x42a(%rbp), %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x417f
jmp 0x41ec
leaq -0x210(%rbp), %rdi
leaq -0x410(%rbp), %rsi
movl $0x1f4, %edx            # imm = 0x1F4
callq 0x20a0
jmp 0x4199
movq 0x10e30(%rip), %rdi     # 0x14fd0
leaq -0x410(%rbp), %rsi
callq 0x21e0
movq %rax, -0x438(%rbp)
jmp 0x41b5
movq -0x438(%rbp), %rdi
movq 0x10dfd(%rip), %rsi     # 0x14fc0
callq 0x2210
jmp 0x41ca
jmp 0x4151
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x418(%rbp)
movl %eax, -0x41c(%rbp)
leaq -0x210(%rbp), %rdi
callq 0x2070
jmp 0x423b
movq 0x10ddd(%rip), %rdi     # 0x14fd0
leaq 0xa144(%rip), %rsi      # 0xe33e
callq 0x21e0
jmp 0x4201
movq 0x10dc8(%rip), %rdi     # 0x14fd0
leaq 0xa134(%rip), %rsi      # 0xe343
callq 0x21e0
jmp 0x4216
jmp 0x4218
leaq -0x210(%rbp), %rdi
callq 0x2060
jmp 0x4226
leaq -0x210(%rbp), %rdi
callq 0x2070
addq $0x440, %rsp            # imm = 0x440
popq %rbp
retq
movq -0x418(%rbp), %rdi
callq 0x2350
nopw (%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::searchType(char const*)
People People::searchType(const char* type)
{
		vector<Person*>::iterator it;
		People p2;
		for(it=begin();it!=end();it++)
		{
				if((*it)->getType()==type)
						p2.push_back(*it);
		}
		return p2;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x70, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x68(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x58(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x55d0
movq -0x60(%rbp), %rdi
movb $0x0, -0x21(%rbp)
callq 0x2b10
movq -0x58(%rbp), %rdi
callq 0x55f0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x58(%rbp), %rdi
callq 0x5660
movq %rax, -0x38(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5620
testb $0x1, %al
jne 0x4342
jmp 0x439c
leaq -0x20(%rbp), %rdi
callq 0x5690
movq (%rax), %rdi
callq 0x42b0
cmpq -0x18(%rbp), %rax
jne 0x4389
leaq -0x20(%rbp), %rdi
callq 0x5690
movq -0x60(%rbp), %rdi
movq %rax, %rsi
callq 0x5560
jmp 0x4370
jmp 0x4389
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
callq 0x5830
jmp 0x43b9
jmp 0x438b
leaq -0x20(%rbp), %rdi
xorl %esi, %esi
callq 0x56b0
movq %rax, -0x50(%rbp)
jmp 0x4322
movb $0x1, -0x21(%rbp)
testb $0x1, -0x21(%rbp)
jne 0x43af
movq -0x60(%rbp), %rdi
callq 0x5830
movq -0x68(%rbp), %rax
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Admin::Admin()
Admin::Admin():Person((char*)("admin"))
{
		strcpy(department,"admin");
		setPasswd();
		setNumber();
		//setStop();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
leaq 0x961d(%rip), %rsi      # 0xe418
movq %rsi, -0x28(%rbp)
callq 0x2740
movq -0x28(%rbp), %rsi
movq -0x20(%rbp), %rdi
leaq 0xfdfd(%rip), %rax      # 0x14c10
movq %rax, (%rdi)
addq $0x48, %rdi
callq 0x21c0
movq -0x20(%rbp), %rdi
callq 0x2c20
jmp 0x4e2a
movq -0x20(%rbp), %rdi
callq 0x2940
jmp 0x4e35
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x2700
movq -0x10(%rbp), %rdi
callq 0x2350
nopl (%rax)
// File: hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: Admin::Admin(Person*)
Admin::Admin(Person* ps):Person(ps)
{
	//	cout << "test " << endl;
		strcpy(department,"admin");
		strcpy(name,"admin");
		strcpy(passwd,"1997");
		//stop=0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movq -0x10(%rbp), %rsi
callq 0x27e0
movq -0x18(%rbp), %rdi
leaq 0xfd74(%rip), %rax      # 0x14c00
addq $0x10, %rax
movq %rax, (%rdi)
addq $0x48, %rdi
leaq 0x957a(%rip), %rsi      # 0xe418
callq 0x21c0
movq -0x18(%rbp), %rdi
addq $0x8, %rdi
leaq 0x9566(%rip), %rsi      # 0xe418
callq 0x21c0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
leaq 0x95d8(%rip), %rsi      # 0xe49e
callq 0x21c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Product::setId()
void Product::setId()
{
		productMax++;
		srand((unsigned)time(NULL));
		changeFlag=1;
		vector<int>::iterator it;
//		for(int i=10000;i<productMax+10000;i++)
		for(int i=0;i<productMax;i++)
		{
				it=find(number.begin(),number.end(),i);
				if(it==number.end())
				{
						while(1)
						{
						id=rand();
						for(it=number.begin();it!=number.end();it++)
						{
								if(id==(*it))
								{
										break;
								}
						}
						number.push_back(i);
						return ;
						}
				}
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movl 0xd142(%rip), %eax      # 0x1520c
addl $0x1, %eax
movl %eax, 0xd139(%rip)      # 0x1520c
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
leaq 0xd0fe(%rip), %rax      # 0x151e8
movl $0x1, (%rax)
leaq -0x10(%rbp), %rdi
callq 0x5280
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0xd103(%rip), %eax      # 0x1520c
jge 0x8211
leaq 0xd0fa(%rip), %rdi      # 0x15210
callq 0x52f0
movq %rax, -0x28(%rbp)
leaq 0xd0ea(%rip), %rdi      # 0x15210
callq 0x5320
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
movq -0x30(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x52a0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xd0bd(%rip), %rdi      # 0x15210
callq 0x5320
movq %rax, -0x38(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x5350
testb $0x1, %al
jne 0x8172
jmp 0x8201
jmp 0x8174
callq 0x2080
movl %eax, %ecx
movq -0x58(%rbp), %rax
movl %ecx, 0x44(%rax)
leaq 0xd087(%rip), %rdi      # 0x15210
callq 0x52f0
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xd06f(%rip), %rdi      # 0x15210
callq 0x5320
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x5400
testb $0x1, %al
jne 0x81bd
jmp 0x81ef
movq -0x58(%rbp), %rax
movl 0x44(%rax), %eax
movl %eax, -0x5c(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x68d0
movq %rax, %rcx
movl -0x5c(%rbp), %eax
cmpl (%rcx), %eax
jne 0x81dc
jmp 0x81ef
jmp 0x81de
leaq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x9c40
movq %rax, -0x50(%rbp)
jmp 0x819a
leaq 0xd01a(%rip), %rdi      # 0x15210
leaq -0x14(%rbp), %rsi
callq 0x5390
jmp 0x8211
jmp 0x8203
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x8100
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
leaq 0xcf5d(%rip), %rax      # 0x151e8
movl $0x1, (%rax)
movq 0xcd38(%rip), %rdi      # 0x14fd0
leaq 0x62b3(%rip), %rsi      # 0xe552
callq 0x21e0
movq %rax, %rdi
movq 0xcd12(%rip), %rsi      # 0x14fc0
movq %rsi, -0x20(%rbp)
callq 0x2210
movq %rax, %rdi
leaq 0x62a0(%rip), %rsi      # 0xe561
callq 0x21e0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0x6291(%rip), %rsi      # 0xe56d
callq 0x21e0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0x5f0c(%rip), %rsi      # 0xe203
callq 0x21e0
movq -0x20(%rbp), %rsi
movq %rax, %rdi
callq 0x2210
movq %rax, %rdi
leaq 0x626c(%rip), %rsi      # 0xe57e
callq 0x21e0
movq 0xccc2(%rip), %rdi      # 0x14fe0
leaq -0xc(%rbp), %rsi
callq 0x20f0
movl -0xc(%rbp), %eax
decl %eax
movl %eax, %ecx
movq %rcx, -0x18(%rbp)
subl $0x3, %eax
ja 0x838f
movq -0x18(%rbp), %rax
leaq 0x61ae(%rip), %rcx      # 0xe4f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
leaq 0x61ff(%rip), %rsi      # 0xe559
callq 0x21c0
jmp 0x83b1
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
leaq 0x639f(%rip), %rsi      # 0xe70f
callq 0x21c0
jmp 0x83b1
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
leaq 0x61ee(%rip), %rsi      # 0xe574
callq 0x21c0
jmp 0x83b1
jmp 0x83b1
movq 0xcc3a(%rip), %rdi      # 0x14fd0
leaq 0x5e11(%rip), %rsi      # 0xe1ae
callq 0x21e0
movq %rax, %rdi
movq 0xcc14(%rip), %rsi      # 0x14fc0
callq 0x2210
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x48(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x5280
leaq 0xcba4(%rip), %rax      # 0x151e8
movl $0x1, (%rax)
leaq 0xcbbf(%rip), %rdi      # 0x15210
callq 0x52f0
movq %rax, -0x20(%rbp)
leaq 0xcbaf(%rip), %rdi      # 0x15210
callq 0x5320
movq -0x48(%rbp), %rdx
movq %rax, -0x28(%rbp)
addq $0x44, %rdx
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0x52a0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x10(%rbp)
leaq 0xcb7e(%rip), %rdi      # 0x15210
callq 0x5320
movq %rax, -0x30(%rbp)
leaq -0x10(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x5400
testb $0x1, %al
jne 0x86ae
jmp 0x86e0
leaq -0x38(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x54b0
movq -0x38(%rbp), %rsi
leaq 0xcb4a(%rip), %rdi      # 0x15210
callq 0x5440
movq %rax, -0x40(%rbp)
movl 0xcb37(%rip), %eax      # 0x1520c
addl $-0x1, %eax
movl %eax, 0xcb2e(%rip)      # 0x1520c
jmp 0x8702
movq 0xc8e9(%rip), %rdi      # 0x14fd0
leaq 0x5a02(%rip), %rsi      # 0xe0f0
callq 0x21e0
movq %rax, %rdi
movq 0xc8c3(%rip), %rsi      # 0x14fc0
callq 0x2210
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x450, %rsp            # imm = 0x450
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x420(%rbp)
movl $0x7c, %edi
callq 0x21f0
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x418(%rbp)
callq 0x8000
jmp 0x8778
movq -0x418(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x80b0
movq -0x10(%rbp), %rdi
callq 0x8220
movq -0x10(%rbp), %rdi
callq 0x8270
movq -0x10(%rbp), %rdi
callq 0x83c0
movq -0x10(%rbp), %rdi
callq 0x8530
movq -0x420(%rbp), %rdi
leaq -0x10(%rbp), %rsi
callq 0x9ca0
leaq -0x400(%rbp), %rax
movq %rax, -0x448(%rbp)
movq -0x10(%rbp), %rdi
callq 0x85d0
movq %rax, -0x440(%rbp)
movq -0x10(%rbp), %rdi
callq 0x85e0
movq %rax, -0x438(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8600
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x430(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8580
movq %rax, -0x428(%rbp)
movq -0x10(%rbp), %rdi
callq 0x8510
movq -0x448(%rbp), %rdi
movq -0x440(%rbp), %rdx
movq -0x438(%rbp), %rcx
movsd -0x430(%rbp), %xmm0
movq -0x428(%rbp), %r8
movl %eax, %r9d
leaq 0x5d6e(%rip), %rsi      # 0xe5b8
movb $0x1, %al
callq 0x2040
leaq -0x400(%rbp), %rdi
callq 0x2190
addq $0x450, %rsp            # imm = 0x450
popq %rbp
retq
movq -0x418(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x408(%rbp)
movl %eax, -0x40c(%rbp)
movl $0x7c, %esi
callq 0x2200
movq -0x408(%rbp), %rdi
callq 0x2350
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9d10
movq -0x80(%rbp), %rdi
leaq 0xc919(%rip), %rax      # 0x151e8
movl $0x1, (%rax)
callq 0x9d30
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x80(%rbp), %rdi
callq 0x9da0
movq %rax, -0x60(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x9d60
testb $0x1, %al
jne 0x8909
jmp 0x8a18
leaq -0x18(%rbp), %rdi
callq 0x9dd0
movq (%rax), %rdi
callq 0x8510
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x8a02
movq 0xc6a3(%rip), %rdi      # 0x14fd0
leaq 0x5cc9(%rip), %rsi      # 0xe5fd
callq 0x21e0
leaq -0x18(%rbp), %rdi
callq 0x9dd0
movq (%rax), %rdi
callq 0x8410
movq 0xc67f(%rip), %rdi      # 0x14fd0
leaq 0x5903(%rip), %rsi      # 0xe25b
callq 0x21e0
callq 0x22a0
movb %al, -0x19(%rbp)
movsbl -0x19(%rbp), %eax
cmpl $0x6e, %eax
jne 0x8973
jmp 0x8a3a
leaq -0x50(%rbp), %rax
movq %rax, -0x88(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x9dd0
movq (%rax), %rdi
callq 0x8510
movq -0x88(%rbp), %rdi
movl %eax, %edx
leaq 0x5c4f(%rip), %rsi      # 0xe5ee
movb $0x0, %al
callq 0x2040
leaq -0x50(%rbp), %rdi
callq 0x2190
leaq -0x18(%rbp), %rdi
callq 0x9dd0
movq (%rax), %rdi
callq 0x8620
leaq -0x68(%rbp), %rdi
leaq -0x18(%rbp), %rsi
callq 0x9e60
movq -0x80(%rbp), %rdi
movq -0x68(%rbp), %rsi
callq 0x9df0
movq %rax, -0x70(%rbp)
movq 0xc5eb(%rip), %rdi      # 0x14fd0
leaq 0x588e(%rip), %rsi      # 0xe27a
callq 0x21e0
movq %rax, %rdi
movq 0xc5c5(%rip), %rsi      # 0x14fc0
callq 0x2210
jmp 0x8a3a
jmp 0x8a04
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0x9ea0
movq %rax, -0x78(%rbp)
jmp 0x88e6
movq 0xc5b1(%rip), %rdi      # 0x14fd0
leaq 0x56ca(%rip), %rsi      # 0xe0f0
callq 0x21e0
movq %rax, %rdi
movq 0xc58b(%rip), %rsi      # 0x14fc0
callq 0x2210
addq $0x90, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)