LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x110, %rsp            # imm = 0x110
cmpl $0x1, %edi
jg 0x1356
leaq 0xd92(%rip), %rdi       # 0x20e3
jmp 0x143f
movq %rsi, %rbx
leaq -0x130(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1090
leaq -0x24(%rbp), %r14
andl $0x0, (%r14)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x120c
movq %rax, %r15
movl (%r14), %esi
addl %esi, %esi
pushq $0x1
popq %rdi
callq 0x10a0
testq %rax, %rax
je 0x1459
movq %rax, %r14
movq 0x8(%rbx), %rsi
leaq 0xc91(%rip), %rdi       # 0x2038
xorl %eax, %eax
callq 0x1070
movl -0x24(%rbp), %ecx
testq %rcx, %rcx
je 0x142f
leaq 0x2cf3(%rip), %r8       # 0x40b0
movq %r15, %rdi
movq %rcx, %rsi
movq %r14, %rdx
callq 0x1468
movq %rax, %r15
testl %r15d, %r15d
je 0x1438
movl %r15d, %eax
cvtsi2ss %rax, %xmm0
movl -0x24(%rbp), %esi
cvtsi2ss %rsi, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xc57(%rip), %rdi       # 0x2049
movl %r15d, %edx
movb $0x1, %al
callq 0x1070
movq 0x8(%rbx), %rcx
leaq 0xc6c(%rip), %rdx       # 0x2073
xorl %ebx, %ebx
leaq -0x130(%rbp), %r12
movl $0xff, %esi
movq %r12, %rdi
xorl %eax, %eax
callq 0x1080
movq %r12, %rdi
movq %r14, %rsi
movl %r15d, %edx
callq 0x12ba
jmp 0x1447
leaq 0xc8f(%rip), %rdi       # 0x20c5
jmp 0x143f
leaq 0xc58(%rip), %rdi       # 0x2097
callq 0x1040
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbca(%rip), %rdi       # 0x202a
callq 0x10f0
jmp 0x1444
nop
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/huffman.c
// Function: huffman_write_tree_and_make_encode_table
static void _huffman_write_tree_and_make_encode_table(unsigned char *out, unsigned long *outbitctr, unsigned long outlen,
 struct _huffman_encode_table *et,unsigned long code,unsigned int bits,struct _huffman_node *t)
{
	struct _huffman_encode_table *eti;
	unsigned int i;
	unsigned long byte_index;

	byte_index = (*outbitctr)++ >> 3;
	byte_index *= (byte_index < outlen);
	if (t->lr[0])
	{
		out[byte_index] <<= 1;
		_huffman_write_tree_and_make_encode_table(out,outbitctr,outlen,et,code,bits + 1,t->lr[0]);
		_huffman_write_tree_and_make_encode_table(out,outbitctr,outlen,et,code | (1 << bits),bits + 1,t->lr[1]);
	}
	else
	{
		out[byte_index] = (out[byte_index] << 1) | 1;
		for(i = 0; i < 9; ++i)
		{
			byte_index = (*outbitctr)++ >> 3;
			if (byte_index >= outlen)
				return;
			out[byte_index] = (out[byte_index] << 1) | ((unsigned char)((t->c >> i) & 1));
		}
		eti = &(et[t->c]);
		eti->code = code;
		eti->bits = bits;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, -0x38(%rbp)
movq %rsi, %r14
movq %rdi, %r13
movq 0x10(%rbp), %r12
movq (%r14), %rax
leaq 0x1(%rax), %rcx
movq %rcx, (%r14)
shrq $0x3, %rax
cmpq %rdx, %rax
movl $0x0, %ecx
cmovaeq %rcx, %rax
movb (%r13,%rax), %cl
addb %cl, %cl
cmpq $0x0, (%r12)
je 0x1773
movb %cl, (%r13,%rax)
leal 0x1(%r9), %r10d
movl %r10d, -0x2c(%rbp)
movq (%r12), %rax
movq %rax, (%rsp)
movq %r13, %rdi
movq %r14, %rsi
movq -0x38(%rbp), %rcx
movq %r15, %r8
movq %r9, -0x40(%rbp)
movl %r10d, %r9d
movq %rdx, %rbx
callq 0x16da
movq %rbx, %rdx
pushq $0x1
popq %rax
movq -0x40(%rbp), %rcx
shll %cl, %eax
cltq
orq %rax, %r15
movq 0x8(%r12), %r12
movl -0x2c(%rbp), %eax
movl %eax, %r9d
jmp 0x16fc
orb $0x1, %cl
movb %cl, (%r13,%rax)
xorl %eax, %eax
cmpq $0x9, %rax
je 0x17b7
movq (%r14), %rcx
leaq 0x1(%rcx), %r10
movq %r10, (%r14)
shrq $0x3, %rcx
cmpq %rdx, %rcx
jae 0x17d0
movb (%r13,%rcx), %bl
addb %bl, %bl
movq 0x28(%r12), %r10
btq %rax, %r10
setb %r10b
orb %bl, %r10b
movb %r10b, (%r13,%rcx)
incq %rax
jmp 0x177d
movq 0x28(%r12), %rax
shlq $0x4, %rax
movq -0x38(%rbp), %rdx
movq %r15, (%rdx,%rax)
movl %r9d, %ecx
movq %rcx, 0x8(%rdx,%rax)
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq -0x30(%rbp), %rcx
movq %r8, (%rcx)
leaq -0x28(%rbp), %rsi
andq $0x0, (%rsi)
addq $0xa8a8, %r8            # imm = 0xA8A8
movq %r15, %rdx
callq 0x1889
testq %rax, %rax
je 0x187a
movq %rax, %rcx
movq -0x28(%rbp), %rdx
xorl %eax, %eax
movq %rcx, %rsi
cmpq $0x0, (%rsi)
je 0x185f
movq %rdx, %rdi
shrq $0x3, %rdi
cmpq %r15, %rdi
jae 0x187a
movzbl (%r12,%rdi), %edi
leaq 0x1(%rdx), %r8
notb %dl
movzbl %dl, %edx
andl $0x7, %edx
xorl %r9d, %r9d
btl %edx, %edi
setb %r9b
movq (%rsi,%r9,8), %rsi
movq %r8, %rdx
jmp 0x1829
movq 0x28(%rsi), %rsi
cmpq $0x100, %rsi            # imm = 0x100
je 0x187c
cmpq %rbx, %rax
je 0x187a
movb %sil, (%r14,%rax)
incq %rax
jmp 0x1826
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/akw0088[P]openssl/huffman.c
// Function: huffman_read_tree
static struct _huffman_node *_huffman_read_tree(const unsigned char *in,unsigned long *inbitctr,unsigned long inlen,unsigned char **heapptr,unsigned char *heapend)
{
	struct _huffman_node *n;
	unsigned int i;
	unsigned long byte_index;

	n = (struct _huffman_node *)(*heapptr);
	*heapptr += sizeof(struct _huffman_node);
	if (*heapptr > heapend)
		 return (struct _huffman_node *)0;

	byte_index = *inbitctr >> 3;
	byte_index *= (byte_index < inlen);
	if (((in[byte_index] >> (~((*inbitctr)++) & 7)) & 1))
	{
		n->lr[0] = (struct _huffman_node *)0;
		n->lr[1] = (struct _huffman_node *)0;
		n->c = 0;
		for(i = 0; i < 9; ++i)
		{
			byte_index = *inbitctr >> 3;
			if (byte_index >= inlen)
				return (struct _huffman_node *)0;
			n->c |= (((unsigned int)(in[byte_index] >> (~((*inbitctr)++) & 7))) & 1) << i;
		}
	}
	else
	{
		n->lr[0] = _huffman_read_tree(in,inbitctr,inlen,heapptr,heapend);
		n->lr[1] = _huffman_read_tree(in,inbitctr,inlen,heapptr,heapend);
		if (!((n->lr[0])&&(n->lr[1])))
			return (struct _huffman_node *)0;
	}

	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq (%rcx), %rbx
leaq 0x30(%rbx), %rax
movq %rax, (%rcx)
cmpq %r8, %rax
jbe 0x18ba
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rcx, %r13
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq (%rsi), %rax
movq %rax, %rcx
shrq $0x3, %rcx
xorl %edx, %edx
cmpq %r14, %rcx
cmovaeq %rdx, %rcx
movzbl (%rdi,%rcx), %ecx
leaq 0x1(%rax), %rdx
movq %rdx, (%rsi)
notb %al
movzbl %al, %eax
andl $0x7, %eax
btl %eax, %ecx
jae 0x1939
andq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ecx, %ecx
cmpl $0x9, %ecx
je 0x18a8
movq (%r15), %rax
movq %rax, %rdx
shrq $0x3, %rdx
cmpq %r14, %rdx
jae 0x18a6
movzbl (%r12,%rdx), %edx
leaq 0x1(%rax), %rsi
movq %rsi, (%r15)
notb %al
movzbl %al, %eax
andl $0x7, %eax
xorl %esi, %esi
btl %eax, %edx
setb %sil
shll %cl, %esi
orq %rsi, 0x28(%rbx)
incl %ecx
jmp 0x18fe
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r8, -0x30(%rbp)
callq 0x1889
movq %rax, (%rbx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq -0x30(%rbp), %r8
callq 0x1889
movq %rax, 0x8(%rbx)
cmpq $0x0, (%rbx)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0x18a6
jmp 0x18a8
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0xa55a(%rip), %rax      # 0xcb98
movq %rax, (%rdi)
addq $0x28, %rdi
addq $0x28, %rsi
callq 0x21a0
movl 0x68(%r14), %eax
movl %eax, 0x68(%rbx)
movl 0x6c(%r14), %eax
movl %eax, 0x6c(%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x8(%r14), %rsi
callq 0x21a0
movq 0xb0(%r14), %rax
testq %rax, %rax
je 0x267c
movq %rax, 0xb0(%rbx)
movq 0xa8(%r14), %rax
testq %rax, %rax
je 0x268f
movq %rax, 0xa8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl 0xaaf4(%rip), %eax      # 0xd1c4
incl %eax
movl %eax, 0xaaec(%rip)      # 0xd1c4
movl $0x1, 0xaae6(%rip)      # 0xd1c8
pushq $0x1
popq %rcx
leaq -0x14(%rbp), %r14
movl %ecx, -0x14(%rbp)
cmpl %eax, %ecx
jg 0x272f
movq 0xaad9(%rip), %rdi      # 0xd1d0
movq 0xaada(%rip), %rsi      # 0xd1d8
movq %r14, %rdx
callq 0x422d
movl -0x14(%rbp), %ecx
cmpq 0xaac8(%rip), %rax      # 0xd1d8
je 0x271c
incl %ecx
movl 0xaaaa(%rip), %eax      # 0xd1c4
jmp 0x26e9
movl %ecx, 0x68(%rbx)
leaq 0xaaaa(%rip), %rdi      # 0xd1d0
leaq -0x14(%rbp), %rsi
callq 0x3f62
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq 0xaa8d(%rip), %rax      # 0xd1d0
movq 0xaa8e(%rip), %rsi      # 0xd1d8
leaq 0x68(%rdi), %rdx
movq %rax, %rdi
callq 0x422d
cmpq 0xaa7b(%rip), %rax      # 0xd1d8
je 0x2776
leaq 0xaa6a(%rip), %rdi      # 0xd1d0
movq %rax, %rsi
callq 0x3f88
decl 0xaa50(%rip)            # 0xd1c4
popq %rbp
retq
movq 0xa853(%rip), %rdi      # 0xcfd0
leaq 0x5939(%rip), %rsi      # 0x80bd
callq 0x21c0
movq %rax, %rdi
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movq 0xa709(%rip), %rdi      # 0xcfd0
leaq 0x5855(%rip), %rsi      # 0x8123
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x5859(%rip), %rsi      # 0x813b
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x585c(%rip), %rsi      # 0x8155
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x5852(%rip), %rsi      # 0x8162
movq %rax, %rdi
callq 0x21c0
movq 0xa6c1(%rip), %rdi      # 0xcfe0
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x2100
movl (%r14), %eax
cmpl $0x3, %eax
je 0x296c
cmpl $0x2, %eax
je 0x2947
cmpl $0x1, %eax
jne 0x2951
movq %rbx, %rdi
callq 0x27a4
jmp 0x296c
movq %rbx, %rdi
callq 0x26bc
jmp 0x296c
movq 0xa678(%rip), %rdi      # 0xcfd0
leaq 0x5817(%rip), %rsi      # 0x8176
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x22e0
leaq 0x54f4(%rip), %rsi      # 0x81ff
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2030
leaq -0x1a0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x2d37
movl 0x6c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2300
jmp 0x2d52
movq 0xa292(%rip), %rdi      # 0xcfd0
leaq 0x558d(%rip), %rsi      # 0x82d2
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq -0x210(%rbp), %rdi
callq 0x2290
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/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
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq -0x218(%rbp), %r14
movq %r14, %rdi
callq 0x2220
leaq 0x544a(%rip), %rsi      # 0x81ff
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2110
addq $0x6c, %rbx
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1f8(%rbp,%rax)
jne 0x2dee
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
movq %r14, %rdi
callq 0x2050
jmp 0x2dc4
leaq -0x218(%rbp), %rdi
callq 0x2070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2e08
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x22e0
leaq 0x53bd(%rip), %rsi      # 0x8204
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2030
leaq -0x1a0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x2e73
movl 0x6c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2300
jmp 0x2e8e
movq 0xa156(%rip), %rdi      # 0xcfd0
leaq 0x5451(%rip), %rsi      # 0x82d2
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq -0x210(%rbp), %rdi
callq 0x2290
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/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
pushq %r14
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rdi, %rbx
leaq -0x218(%rbp), %r14
movq %r14, %rdi
callq 0x2220
leaq 0x5313(%rip), %rsi      # 0x8204
pushq $0x8
popq %rdx
movq %r14, %rdi
callq 0x2110
addq $0x6c, %rbx
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1f8(%rbp,%rax)
jne 0x2f2a
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2100
movq %r14, %rdi
callq 0x2050
jmp 0x2f00
leaq -0x218(%rbp), %rdi
callq 0x2070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x2f44
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %r14
cmpq 0x8(%rbx), %r14
je 0x2f7d
movq (%r14), %rdi
callq 0x2976
addq $0x8, %r14
jmp 0x2f69
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, 0xa22f(%rip)      # 0xd1c8
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movl (%rsi), %ecx
leaq 0x5114(%rip), %rsi      # 0x80bd
cmpq %rax, %r14
je 0x301c
movq (%r14), %rdx
cmpl %ecx, 0x68(%rdx)
je 0x2fbc
addq $0x8, %r14
jmp 0x2fa9
movq 0xa00d(%rip), %r15      # 0xcfd0
leaq 0x5240(%rip), %rsi      # 0x820a
movq %r15, %rdi
callq 0x21c0
movq (%r14), %rdi
callq 0x2976
callq 0x2270
leaq 0x523d(%rip), %rsi      # 0x8223
movq %r15, %rdi
callq 0x21c0
callq 0x2270
cmpb $0x6e, %al
jne 0x3002
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rdi
callq 0x2738
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4008
leaq 0x522b(%rip), %rsi      # 0x8247
movq 0x9fad(%rip), %rdi      # 0xcfd0
callq 0x21c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r12
movq %rdi, %r14
movl $0x1, 0xa170(%rip)      # 0xd1c8
movq (%rdi), %r15
movq 0x9f6e(%rip), %r13      # 0xcfd0
leaq 0x51ba(%rip), %rbx      # 0x8223
cmpq 0x8(%r14), %r15
je 0x30b8
movq (%r15), %rdi
addq $0x8, %rdi
movq %r12, %rsi
callq 0x2280
testl %eax, %eax
jne 0x30b2
callq 0x2270
movq %r13, %rdi
leaq 0x5179(%rip), %rsi      # 0x820a
callq 0x21c0
movq (%r15), %rdi
callq 0x2976
movq %r13, %rdi
movq %rbx, %rsi
callq 0x21c0
callq 0x2270
cmpb $0x79, %al
je 0x30c1
addq $0x8, %r15
jmp 0x3069
leaq 0x4ffe(%rip), %rsi      # 0x80bd
jmp 0x30db
movq (%r15), %rdi
callq 0x2738
movq %r14, %rdi
movq %r15, %rsi
callq 0x4008
leaq 0x516c(%rip), %rsi      # 0x8247
movq 0x9eee(%rip), %rdi      # 0xcfd0
callq 0x21c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, -0x38(%rbp)
movq 0x9eb6(%rip), %r14      # 0xcfd0
leaq 0x5161(%rip), %r15      # 0x8282
movq 0x9eb8(%rip), %r12      # 0xcfe0
leaq -0x2c(%rbp), %r13
movq %r14, %rdi
leaq 0x5126(%rip), %rsi      # 0x825c
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
leaq 0x5123(%rip), %rsi      # 0x8270
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
leaq 0x4ff1(%rip), %rsi      # 0x8155
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21c0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2100
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x31e8
cmpl $0x2, %eax
je 0x31b9
cmpl $0x3, %eax
je 0x3223
movq %r14, %rdi
leaq 0x4fcf(%rip), %rsi      # 0x8176
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x312c
movq %r14, %rdi
leaq 0x50e2(%rip), %rsi      # 0x82a5
callq 0x21c0
movq %r12, %rdi
leaq -0x3c(%rbp), %rbx
movq %rbx, %rsi
callq 0x2100
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2f82
jmp 0x312c
movq %r14, %rdi
leaq 0x4ede(%rip), %rsi      # 0x80d0
callq 0x21c0
movq %r12, %rdi
movq %r13, %rbx
movq %r15, %r13
leaq -0x60(%rbp), %r15
movq %r15, %rsi
callq 0x3fc1
movq -0x38(%rbp), %rdi
movq %r15, %rsi
movq %r13, %r15
movq %rbx, %r13
callq 0x303a
jmp 0x312c
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movl (%rsi), %esi
cmpq %rdx, %rcx
je 0x3252
movq (%rcx), %rax
addq $0x8, %rcx
cmpl %esi, 0x68(%rax)
jne 0x323f
jmp 0x3254
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x3289
movq (%r15), %r14
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x2280
addq $0x8, %r15
testl %eax, %eax
jne 0x326b
jmp 0x32a7
movq 0x9d40(%rip), %rdi      # 0xcfd0
leaq 0x502c(%rip), %rsi      # 0x82c3
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
leaq 0x5126(%rip), %rsi      # 0x83f4
leaq -0x218(%rbp), %r14
pushq $0x4
popq %rdx
movq %r14, %rdi
callq 0x2200
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x330e
movq 0x9cd8(%rip), %rdi      # 0xcfd0
leaq 0x4fce(%rip), %rsi      # 0x82cd
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x3339
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x332d
movq (%r15), %rsi
movl $0xb8, %edx
movq %r14, %rdi
callq 0x2260
addq $0x8, %r15
jmp 0x3311
leaq -0x218(%rbp), %rdi
callq 0x2290
leaq -0x218(%rbp), %rdi
callq 0x22a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3355
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x22a0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/people.cpp
// Function: People::readPeople()
void People::readPeople()
{
		ifstream in("people",ios::binary);
		if(!in)
		{
				cout << "\t\t\t\t\topen failed!" << endl;
				return ;
		}
		else
		{
				delAll();
				vector<Person*>::iterator it;
				it=begin();
				(*it)->number.clear();
				(*it)->peopleMax=0;
				Person *pe;
				while(1)
				{
						pe=new Person;
						in.read((char*)(pe),sizeof(Person));
						if(!in.eof())
						{
								this->push_back(pe);
								pe->number.push_back(pe->getNumber());
						}
						else
						{
								delete(pe);
								break;
						}
						(*it)->peopleMax=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 0x5056(%rip), %rsi      # 0x83f4
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 0x33e1
movq 0x9c08(%rip), %rdi      # 0xcfd0
leaq 0x4efe(%rip), %rsi      # 0x82cd
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x3504
movq (%rbx), %rax
cmpq %rax, 0x8(%rbx)
je 0x33ee
movq %rax, 0x8(%rbx)
movq 0x9ddb(%rip), %rax      # 0xd1d0
cmpq %rax, 0x9ddc(%rip)      # 0xd1d8
je 0x3405
movq %rax, 0x9dd3(%rip)      # 0xd1d8
andl $0x0, 0x9db8(%rip)      # 0xd1c4
leaq -0x30(%rbp), %r15
leaq 0x9db9(%rip), %r12      # 0xd1d0
leaq -0x34(%rbp), %r13
movl $0xb8, %edi
callq 0x21d0
leaq 0x976c(%rip), %rcx      # 0xcb98
movq %rcx, (%rax)
xorps %xmm1, %xmm1
movups %xmm1, 0x8(%rax)
movups %xmm1, 0x18(%rax)
movups 0x4c5c(%rip), %xmm0     # 0x809d
movups %xmm0, 0x48(%rax)
movups 0x4c61(%rip), %xmm0     # 0x80ad
movups %xmm0, 0x58(%rax)
andl $0x0, 0x6c(%rax)
movups 0x4bdd(%rip), %xmm0     # 0x8038
movups %xmm0, 0x70(%rax)
movups 0x4be2(%rip), %xmm0     # 0x8048
movups %xmm0, 0x80(%rax)
andw $0x0, 0xa0(%rax)
movups 0x4bdc(%rip), %xmm0     # 0x8058
movups %xmm0, 0x90(%rax)
movups %xmm1, 0xa8(%rax)
movq %rax, -0x30(%rbp)
movl $0xb8, %edx
movq %r14, %rdi
movq %rax, %rsi
callq 0x2240
movq -0x240(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x220(%rbp,%rax)
jne 0x34e9
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3fe4
movq -0x30(%rbp), %rax
movl 0x68(%rax), %eax
movl %eax, -0x34(%rbp)
movq %r12, %rdi
movq %r13, %rsi
callq 0x4526
movq 0x8(%rbx), %rax
subq (%rbx), %rax
shrq $0x3, %rax
movl %eax, 0x9ce0(%rip)      # 0xd1c4
jmp 0x341b
movq -0x30(%rbp), %rdi
testq %rdi, %rdi
je 0x34f8
movq (%rdi), %rax
callq *0x8(%rax)
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 0x3528
jmp 0x3528
jmp 0x3528
movq %rax, %rbx
leaq -0x240(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x200, %rsp            # imm = 0x200
movq %rdi, %rbx
leaq -0x210(%rbp), %r14
movq %r14, %rdi
callq 0x22e0
leaq 0x4d78(%rip), %rsi      # 0x82df
pushq $0x1
popq %rdx
movq %r14, %rdi
callq 0x2030
leaq -0x1a0(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x35d6
leaq 0x4d5d(%rip), %rsi      # 0x82e6
leaq -0x210(%rbp), %rdi
callq 0x21c0
movl 0x68(%rbx), %esi
movq %rax, %rdi
callq 0x2300
leaq 0x4d43(%rip), %rsi      # 0x82ea
movq %rax, %rdi
callq 0x21c0
movq %rax, %r14
movq %rbx, %rdi
callq 0x2828
movq %r14, %rdi
movq %rax, %rsi
callq 0x21c0
leaq 0x4d27(%rip), %rsi      # 0x82f3
movq %rax, %rdi
callq 0x21c0
jmp 0x35f1
movq 0x99f3(%rip), %rdi      # 0xcfd0
leaq 0x4cee(%rip), %rsi      # 0x82d2
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq -0x210(%rbp), %rdi
callq 0x2290
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
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x408, %rsp            # imm = 0x408
leaq -0x220(%rbp), %rbx
movq %rbx, %rdi
callq 0x2220
leaq 0x4c8d(%rip), %rsi      # 0x82df
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2110
leaq -0x1a8(%rbp), %rdi
callq 0x2060
testb %al, %al
je 0x36db
leaq -0x420(%rbp), %r14
movq 0x9955(%rip), %r15      # 0xcfd0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x200(%rbp,%rax)
jne 0x36b5
movl $0x1f4, %edx            # imm = 0x1F4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x20a0
movq %r15, %rdi
movq %r14, %rsi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x367b
movq 0x9914(%rip), %rdi      # 0xcfd0
leaq 0x4c48(%rip), %rsi      # 0x830b
callq 0x21c0
movq 0x9901(%rip), %rdi      # 0xcfd0
leaq 0x4c3a(%rip), %rsi      # 0x8310
callq 0x21c0
leaq -0x220(%rbp), %rdi
callq 0x2050
leaq -0x220(%rbp), %rdi
callq 0x2070
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3703
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/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
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 0x378e
movq (%r12), %rax
addq $0x48, %rax
cmpq %r14, %rax
jne 0x3788
movq %rbx, %rdi
movq %r12, %rsi
callq 0x3fe4
addq $0x8, %r12
jmp 0x376a
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x4050
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x4611(%rip), %rsi      # 0x83e5
callq 0x25be
leaq 0x8e38(%rip), %rax      # 0xcc18
movq %rax, (%rbx)
movl $0x696d6461, 0x48(%rbx) # imm = 0x696D6461
movw $0x6e, 0x4c(%rbx)
movq %rbx, %rdi
callq 0x2856
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x26bc
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x262a
leaq 0x8dfd(%rip), %rax      # 0xcc18
movq %rax, (%rbx)
movl $0x696d6461, %eax       # imm = 0x696D6461
movl %eax, 0x48(%rbx)
movw $0x6e, %cx
movw %cx, 0x4c(%rbx)
movl %eax, 0x8(%rbx)
movw %cx, 0xc(%rbx)
movl $0x37393931, 0x28(%rbx) # imm = 0x37393931
movb $0x0, 0x2c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
incl 0x8b5f(%rip)            # 0xd1ec
xorl %r15d, %r15d
xorl %edi, %edi
callq 0x2190
movl %eax, %edi
callq 0x21b0
leaq 0x8b23(%rip), %rax      # 0xd1c8
movl $0x1, (%rax)
leaq -0x1c(%rbp), %r14
movl %r15d, -0x1c(%rbp)
cmpl 0x8b32(%rip), %r15d     # 0xd1ec
jge 0x46fc
movq 0x8b2d(%rip), %rdi      # 0xd1f0
movq 0x8b2e(%rip), %rsi      # 0xd1f8
movq %r14, %rdx
callq 0x422d
cmpq 0x8b1f(%rip), %rax      # 0xd1f8
je 0x46e4
movl -0x1c(%rbp), %r15d
incl %r15d
jmp 0x46af
callq 0x2080
movl %eax, 0x44(%rbx)
leaq 0x8afd(%rip), %rdi      # 0xd1f0
leaq -0x1c(%rbp), %rsi
callq 0x3f62
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/product.cpp
// Function: Product::setType()
void Product::setType()
{
		changeFlag=1;
		int flag;
		cout << "\t\t\t\t\t1:clothes" << endl << "\t\t\t\t\t2:food" << endl << "\t\t\t\t\t3:commodity" << endl << "\t\t\t\t\t4:exit" << endl << "\t\t\t\t\tplease choice the type:" ;
		cin >> flag;
		switch(flag)
		{
				case 1://type="clothes";
					   strcpy(type,"clothes");
					   break;
				case 2://type="food";
					   strcpy(type,"food");
					   break;
				case 3://type="commodity";
					   strcpy(type,"commodity");
					   break;
				case 4:return ;
			    default:cout << "input error!" << endl;
						break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0x8a6d(%rip), %rax      # 0xd1c8
movl $0x1, (%rax)
movq 0x8868(%rip), %rdi      # 0xcfd0
leaq 0x3daf(%rip), %rsi      # 0x851e
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x3daa(%rip), %rsi      # 0x852d
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x3d9f(%rip), %rsi      # 0x8539
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x3a1f(%rip), %rsi      # 0x81d0
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x3d82(%rip), %rsi      # 0x854a
movq %rax, %rdi
callq 0x21c0
movq 0x8809(%rip), %rdi      # 0xcfe0
leaq -0x14(%rbp), %r14
movq %r14, %rsi
callq 0x2100
movl (%r14), %eax
decl %eax
cmpl $0x3, %eax
ja 0x4830
leaq 0x3cc8(%rip), %rcx      # 0x84bc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movabsq $0x736568746f6c63, %rax # imm = 0x736568746F6C63
movq %rax, 0x20(%rbx)
jmp 0x484b
movb $0x0, 0x24(%rbx)
movl $0x646f6f66, 0x20(%rbx) # imm = 0x646F6F66
jmp 0x484b
movabsq $0x7469646f6d6d6f63, %rax # imm = 0x7469646F6D6D6F63
movq %rax, 0x20(%rbx)
movw $0x79, 0x28(%rbx)
jmp 0x484b
movq 0x8799(%rip), %rdi      # 0xcfd0
leaq 0x393d(%rip), %rsi      # 0x817b
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x87a5(%rip), %rax      # 0xd1c8
movl $0x1, (%rax)
movq 0x87c0(%rip), %rax      # 0xd1f0
movq 0x87c1(%rip), %rsi      # 0xd1f8
leaq 0x44(%rdi), %rdx
movq %rax, %rdi
callq 0x422d
cmpq 0x87ae(%rip), %rax      # 0xd1f8
je 0x4a63
leaq 0x879d(%rip), %rdi      # 0xd1f0
movq %rax, %rsi
callq 0x3f88
decl 0x878b(%rip)            # 0xd1ec
popq %rbp
retq
movq 0x8566(%rip), %rdi      # 0xcfd0
leaq 0x364c(%rip), %rsi      # 0x80bd
callq 0x21c0
movq %rax, %rdi
popq %rbp
jmp 0x20e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::addProduct()
void Products::addProduct()
{
		Product *p;
		char buf[1000];
		p=new Product;
		p->setId();
		p->setName();
		p->setType();
		p->setPrice();
		p->setLoginTime();
		push_back(p);
	//	return *p;
		sprintf(buf,"qrencode \"name=%s\ttype=%s\tprice=%f\ttime=%s\" -o %d.png",p->getName(),p->getType(),p->getPrice(),p->getLoginTime(),p->getId());
		system(buf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x3f8, %rsp            # imm = 0x3F8
movq %rdi, %rbx
pushq $0x7c
popq %rdi
callq 0x21d0
movq %rax, %r14
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
andq $0x0, 0x40(%rax)
movups %xmm0, 0x30(%rax)
movups 0x3a12(%rip), %xmm0     # 0x84ec
movups %xmm0, 0x48(%rax)
movups 0x3a17(%rip), %xmm0     # 0x84fc
movups %xmm0, 0x58(%rax)
andw $0x0, 0x78(%rax)
movups 0x3a17(%rip), %xmm0     # 0x850c
movups %xmm0, 0x68(%rax)
leaq -0x28(%rbp), %r15
movq %rax, (%r15)
movq %rax, %rdi
callq 0x467a
movq %r14, %rdi
callq 0x4708
movq %r14, %rdi
callq 0x4746
movq %r14, %rdi
callq 0x4854
movq %r14, %rdi
callq 0x4986
movq %rbx, %rdi
movq %r15, %rsi
callq 0x557e
movq (%r15), %rbx
leaq 0x20(%rbx), %r14
cvtss2sd 0x40(%rbx), %xmm0
movsd %xmm0, -0x20(%rbp)
movq %rbx, %rdi
callq 0x49ca
movl 0x44(%rbx), %r9d
leaq 0x3a2d(%rip), %rsi      # 0x8584
leaq -0x410(%rbp), %r15
movq %r15, %rdi
movq %rbx, %rdx
movq %r14, %rcx
movsd -0x20(%rbp), %xmm0
movq %rax, %r8
movb $0x1, %al
callq 0x2040
movq %r15, %rdi
callq 0x2170
addq $0x3f8, %rsp            # imm = 0x3F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::deleteId(int const&)
void Products::deleteId(const int &id)
{
		vector<Product*>::iterator it;
		changeFlag=1;
		char t;
		char buf[50];
		for(it=begin();it!=end();it++)
		{
				if((*it)->getId()==id)
				{
						cout << "the product data is:" ;
						(*it)->show() ;
				//		getchar();
						cout << "do you want to delete it?(y/n)" ;
						t=getchar();
						if(t=='n')
						{
								return ;
						}
						sprintf(buf,"rm %d.png",(*it)->getId());
						system(buf);
						(*it)->deleteId();
						erase(it);
						cout << "\t\t\t\t\tdelete success!" << endl;
						return ;
				}
		}
		cout << "\t\t\t\t\tdelete error!" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
leaq 0x8625(%rip), %rax      # 0xd1c8
movl $0x1, (%rax)
movq (%rdi), %r14
movq 0x8(%rdi), %rax
movl (%rsi), %ecx
leaq 0x3504(%rip), %rsi      # 0x80bd
cmpq %rax, %r14
je 0x4c4e
movq (%r14), %rdx
cmpl %ecx, 0x44(%rdx)
je 0x4bd0
addq $0x8, %r14
jmp 0x4bb9
movq 0x83f9(%rip), %r15      # 0xcfd0
leaq 0x39eb(%rip), %rsi      # 0x85c9
movq %r15, %rdi
callq 0x21c0
movq (%r14), %rdi
callq 0x4896
leaq 0x3633(%rip), %rsi      # 0x8228
movq %r15, %rdi
callq 0x21c0
callq 0x2270
cmpb $0x6e, %al
jne 0x4c11
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq (%r14), %rax
movl 0x44(%rax), %edx
leaq 0x399c(%rip), %rsi      # 0x85ba
leaq -0x50(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
callq 0x2170
movq (%r14), %rdi
callq 0x4a18
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55a2
leaq 0x35f9(%rip), %rsi      # 0x8247
movq 0x837b(%rip), %rdi      # 0xcfd0
callq 0x21c0
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::deleteName(char const*)
void Products::deleteName(const char* name)
{
		vector<Product*>::iterator it;
		changeFlag=1;
		char buf[50];
		char t;
		for(it=begin();it!=end();it++)
		{
				if(strcmp((*it)->getName(),name)==0)
				{
						getchar();
						cout << "\t\t\t\t\tthe product data is:" ;
						(*it)->show() ;
						cout << "\t\t\t\t\tdo you want to delete it?(y/n)" ;
						t=getchar();
						if(t=='y')
						{
						  sprintf(buf,"rm %d.png",(*it)->getId());
						  system(buf);
						  (*it)->deleteId();
					//	 delete(*it);
						   erase(it);
						 cout << "\t\t\t\t\tdelete success!" << endl;
						 return ;
						}
						if(t='n')
						{
								continue;
						}
				}
		}
		cout << "\t\t\t\t\tdelete error!" << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r12
movq %rdi, %rbx
leaq 0x853e(%rip), %rax      # 0xd1c8
movl $0x1, (%rax)
movq (%rdi), %r14
movq 0x8336(%rip), %r13      # 0xcfd0
leaq 0x3582(%rip), %r15      # 0x8223
cmpq 0x8(%rbx), %r14
je 0x4cec
movq (%r14), %rdi
movq %r12, %rsi
callq 0x2280
testl %eax, %eax
jne 0x4ce6
callq 0x2270
movq %r13, %rdi
leaq 0x38ff(%rip), %rsi      # 0x85c4
callq 0x21c0
movq (%r14), %rdi
callq 0x4896
movq %r13, %rdi
movq %r15, %rsi
callq 0x21c0
callq 0x2270
cmpb $0x79, %al
je 0x4cf5
addq $0x8, %r14
jmp 0x4ca1
leaq 0x33ca(%rip), %rsi      # 0x80bd
jmp 0x4d32
movq (%r14), %rax
movl 0x44(%rax), %edx
leaq 0x38b8(%rip), %rsi      # 0x85ba
leaq -0x60(%rbp), %r15
movq %r15, %rdi
xorl %eax, %eax
callq 0x2040
movq %r15, %rdi
callq 0x2170
movq (%r14), %rdi
callq 0x4a18
movq %rbx, %rdi
movq %r14, %rsi
callq 0x55a2
leaq 0x3515(%rip), %rsi      # 0x8247
movq 0x8297(%rip), %rdi      # 0xcfd0
callq 0x21c0
movq %rax, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x20e0
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::deleteAll()
void Products::deleteAll()
{
		int flag,id;
		string scan;
		cout << "\t\t\t\t\tplease scan the qrencode!" << endl;
		cin >> scan;
		char name[32];
		cout << "\t\t\t\t\t1:by the id." << endl << "\t\t\t\t\t2:by the name." << endl << "\t\t\t\t\t3:exit" << endl << "\t\t\t\t\tplease the delete way:" ;
		cin >> flag;
		switch(flag)
		{
				case 1:
		            //   cout << "\t\t\t\t\tplease scan the qrencode!" << endl;
		            //   cin >> scan;
						cout << "\t\t\t\t\tplease input the id:" ;
						cin >> id;
						deleteId(id);
						sleep(1);
						break;
				case 2:
						cout << "\t\t\t\t\tplease input the name:" ;
						cin >> name;
						deleteName(name);
						sleep(1);
						break;
				case 3:return ;
				default:
						cout << "\t\t\t\t\tinput error!" << endl;
						break;
		}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq -0x20(%rbp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
movq 0x8259(%rip), %rdi      # 0xcfd0
leaq 0x3860(%rip), %rsi      # 0x85de
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
movq 0x824e(%rip), %rdi      # 0xcfe0
leaq -0x30(%rbp), %rsi
callq 0x2250
movq 0x822e(%rip), %rdi      # 0xcfd0
leaq 0x3854(%rip), %rsi      # 0x85fd
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x3852(%rip), %rsi      # 0x860f
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x384f(%rip), %rsi      # 0x8623
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
leaq 0x3844(%rip), %rsi      # 0x862f
movq %rax, %rdi
callq 0x21c0
movq 0x81e6(%rip), %rdi      # 0xcfe0
leaq -0x10(%rbp), %rsi
callq 0x2100
movl -0x10(%rbp), %eax
cmpl $0x1, %eax
je 0x4e67
cmpl $0x2, %eax
je 0x4e36
cmpl $0x3, %eax
je 0x4e9e
movq 0x81b0(%rip), %rdi      # 0xcfd0
leaq 0x334f(%rip), %rsi      # 0x8176
callq 0x21c0
movq %rax, %rdi
callq 0x20e0
jmp 0x4e9e
movq 0x8193(%rip), %rdi      # 0xcfd0
leaq 0x328c(%rip), %rsi      # 0x80d0
callq 0x21c0
movq 0x8190(%rip), %rdi      # 0xcfe0
leaq -0x50(%rbp), %rsi
callq 0x3fc1
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0x4c6c
jmp 0x4e96
movq 0x8162(%rip), %rdi      # 0xcfd0
leaq 0x353b(%rip), %rsi      # 0x83b0
callq 0x21c0
movq 0x815f(%rip), %rdi      # 0xcfe0
leaq -0xc(%rbp), %rsi
callq 0x2100
leaq -0xc(%rbp), %rsi
movq %rbx, %rdi
callq 0x4b8c
pushq $0x1
popq %rdi
callq 0x2140
leaq -0x30(%rbp), %rdi
callq 0x20d0
addq $0x48, %rsp
popq %rbx
popq %rbp
retq
jmp 0x4eb0
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::searchId(int const&)
Product* Products::searchId(const int &id)
{
		vector<Product*>::iterator it;
		for(it=begin();it!=end();it++)
		{
				if((*it)->getId()==id)
				{
						return (*it);
				}
		}
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
movl (%rsi), %esi
cmpq %rdx, %rcx
je 0x4ee4
movq (%rcx), %rax
addq $0x8, %rcx
cmpl %esi, 0x44(%rax)
jne 0x4ed1
jmp 0x4ee6
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/hzy1754785321[P]warehouse-manage-system/product.cpp
// Function: Products::searchName(char const*)
Product* Products::searchName(const char* name)
{
		vector<Product*>::iterator it;
		for(it=begin();it!=end();it++)
		{
				if(strcmp((*it)->getName(),name)==0)
				{
						return (*it);
				}
		}
		return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x4f1a
movq (%r15), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2280
addq $0x8, %r15
testl %eax, %eax
jne 0x4efd
jmp 0x4f1d
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop