LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/tokuhirom[P]nanouri/t/../nanouri.hpp
// Function: nanouri::Uri::parse(char const*, unsigned long)
bool parse(const char *src, size_t src_len) {
    const char *scheme;
    size_t scheme_len;
    const char *host;
    size_t host_len;
    const char *path_query;
    int path_query_len;
    int ret =
        nanouri_parse_uri(src, src_len, &scheme, &scheme_len, &host, &host_len,
                          &port_, &path_query, &path_query_len);
    if (ret != 0) {
      return false;  // parse error
    }
    uri_.assign(src, src_len);
    host_.assign(host, host_len);
    path_query_.assign(path_query, path_query_len);
    scheme_.assign(scheme, scheme_len);
    return true;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x60(%rdi), %rax
subq $0x8, %rsp
leaq 0x14(%rsp), %r10
leaq 0x18(%rsp), %r11
leaq 0x38(%rsp), %rdx
leaq 0x30(%rsp), %rcx
leaq 0x28(%rsp), %r8
leaq 0x20(%rsp), %r9
movq %rsi, %rdi
movq %r14, %rsi
pushq %r10
pushq %r11
pushq %rax
callq 0x332f
addq $0x20, %rsp
movl %eax, %ebp
testl %eax, %eax
jne 0x31b7
movq 0x8(%rbx), %rdx
movq %rbx, %rdi
xorl %esi, %esi
movq %r15, %rcx
movq %r14, %r8
callq 0x2180
leaq 0x20(%rbx), %rdi
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x28(%rbx), %rdx
xorl %esi, %esi
callq 0x2180
leaq 0x68(%rbx), %rdi
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %r8
movq 0x70(%rbx), %rdx
xorl %esi, %esi
callq 0x2180
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
movq 0x48(%rbx), %rdx
addq $0x40, %rbx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x2180
testl %ebp, %ebp
sete %al
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/tokuhirom[P]nanouri/nanouri.c
// Function: nanouri_parse_uri(char const*, unsigned long, char const**, unsigned long*, char const**, unsigned long*, int*, char const**, int*)
int nanouri_parse_uri(const char* _buf, size_t len, const char** scheme, size_t *scheme_len, const char **host, size_t *host_len, int *port, const char **path_query, int*path_query_len) {
  const char * buf = _buf, * buf_end = buf + len;

  *scheme = buf;
  for (;;++buf) {
    CHECK_EOF();
    if (':' == *buf) {
      break;
    }
  }
  *scheme_len = buf - *scheme;

  EXPECT(':'); EXPECT('/'); EXPECT('/');

  *host = buf;
  *port = 0;
  *host_len = 0;
  *path_query_len = 0;
  for (;;++buf) {
    if (buf == buf_end) {
      *host_len = buf - *host;
      return 0;
    }
    if (':' == *buf) { /* with port */
      *host_len = buf - *host;
      buf++;

      *port = 0;
      for (;'0' <= *buf && *buf <= '9';buf++) {
        if (buf == buf_end) {
          return 0;
        }
        *port = *port * 10 + (*buf - '0');
      }
      if (buf == buf_end) {
        return 0;
      }
      break;
    }
    if ('/' == *buf) { /* no port */
      *host_len = buf - *host;
      break;
    }
  }

  *path_query = buf;
  *path_query_len = buf_end - buf;
  return 0;
}

// Assembly:
movq %rdi, (%rdx)
movl $0xfffffffe, %eax       # imm = 0xFFFFFFFE
testq %rsi, %rsi
je 0x341a
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %r11
movq 0x28(%rsp), %rbx
leaq (%rdi,%rsi), %r10
leaq -0x4(%rsi), %r14
xorl %r15d, %r15d
cmpb $0x3a, (%rdi,%r15)
je 0x3378
decq %r14
incq %r15
cmpq %r15, %rsi
jne 0x3361
jmp 0x3413
movq %r15, (%rcx)
cmpb $0x3a, (%rdi,%r15)
jne 0x340e
leaq -0x1(%rsi), %rcx
cmpq %r15, %rcx
je 0x3413
cmpb $0x2f, 0x1(%rdi,%r15)
jne 0x340e
leaq -0x2(%rsi), %rcx
cmpq %r15, %rcx
je 0x3413
cmpb $0x2f, 0x2(%rdi,%r15)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jne 0x3413
leaq (%rdi,%r15), %rcx
addq $0x3, %rcx
leaq -0x3(%rsi), %r12
movq %rcx, (%r8)
xorl %eax, %eax
movl %eax, (%rbx)
movq $0x0, (%r9)
movl %eax, (%rdx)
cmpq %r15, %r12
je 0x33ff
subq %r15, %rsi
addq $-0x3, %rsi
xorl %r8d, %r8d
leaq (%rdi,%r8), %r12
movzbl 0x3(%r15,%r12), %ecx
cmpl $0x2f, %ecx
je 0x3472
cmpl $0x3a, %ecx
je 0x341b
incq %r8
decq %rsi
jne 0x33dc
movq %r10, %rcx
subq %rdi, %rcx
subq %r15, %rcx
addq $-0x3, %rcx
movq %rcx, (%r9)
jmp 0x3413
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %r8, (%r9)
movl $0x0, (%rbx)
addq %r15, %rdi
leaq (%r8,%rdi), %rcx
addq $0x4, %rcx
movb 0x4(%r15,%r12), %sil
leal -0x30(%rsi), %eax
cmpb $0x9, %al
ja 0x346b
subq %r8, %r14
xorl %eax, %eax
xorl %edi, %edi
testq %r14, %r14
je 0x3413
leal (%rdi,%rdi,4), %edi
addb $-0x30, %sil
movzbl %sil, %esi
leal (%rsi,%rdi,2), %edi
movl %edi, (%rbx)
movb 0x1(%rcx), %sil
incq %rcx
leal -0x30(%rsi), %r8d
decq %r14
cmpb $0xa, %r8b
jb 0x3442
cmpq %r10, %rcx
jne 0x3480
jmp 0x3489
movq %r8, (%r9)
addq %r15, %rdi
leaq (%r8,%rdi), %rcx
addq $0x3, %rcx
movq %rcx, (%r11)
subl %ecx, %r10d
movl %r10d, (%rdx)
xorl %eax, %eax
jmp 0x3413
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/huffman_enc.c
// Function: get_file
char *get_file(char *filename, unsigned int *size)
{
	FILE	*file;
	char	*buffer;
	int	file_size, bytes_read;

	file = fopen(filename, "rb");
	if (file == NULL)
		return 0;
	fseek(file, 0, SEEK_END);
	file_size = ftell(file);
	fseek(file, 0, SEEK_SET);
	buffer = malloc(file_size + 1);
	bytes_read = (int)fread(buffer, sizeof(char), file_size, file);
	if (bytes_read != file_size)
	{
		free((void *)buffer);
		fclose(file);
		return 0;
	}
	fclose(file);
	buffer[file_size] = '\0';

	if (size != NULL)
	{
		*size = file_size;
	}
	return buffer;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
leaq 0xdf0(%rip), %rsi       # 0x2004
callq 0x10d0
testq %rax, %rax
je 0x1299
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movl $0x2, %edx
callq 0x10c0
movq %r14, %rdi
callq 0x10a0
movq %rax, %r12
movq %r14, %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x10c0
leal 0x1(%r12), %eax
movslq %eax, %rdi
callq 0x10b0
movq %rax, %r15
movslq %r12d, %r13
movl $0x1, %esi
movq %rax, %rdi
movq %r13, %rdx
movq %r14, %rcx
callq 0x1050
cmpl %r13d, %eax
jne 0x1289
movq %r14, %rdi
callq 0x1060
movb $0x0, (%r15,%r13)
testq %rbx, %rbx
je 0x129c
movl %r12d, (%rbx)
jmp 0x129c
movq %r15, %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1060
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/huffman_enc.c
// Function: write_file
int write_file(char *filename, const char *bytes, int size)
{
	FILE *fp = fopen(filename, "wb");
	int ret;

	if (fp == NULL)
	{
		perror("Unable to open file for writing");
		return -1;
	}

	ret = fwrite(bytes, sizeof(char), size, fp);

	if (ret != size)
	{
		printf("fwrite didnt write all data\n");
		fclose(fp);
		return -1;
	}
	fclose(fp);
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r15d
movq %rsi, %r14
leaq 0xd42(%rip), %rsi       # 0x2007
callq 0x10d0
testq %rax, %rax
je 0x131d
movq %rax, %rbx
movslq %r15d, %r15
movl $0x1, %esi
movq %r14, %rdi
movq %r15, %rdx
movq %rax, %rcx
callq 0x10f0
cmpl %r15d, %eax
jne 0x12f9
movq %rbx, %rdi
callq 0x1060
xorl %eax, %eax
jmp 0x1312
leaq 0xd7b(%rip), %rdi       # 0x207b
callq 0x1040
movq %rbx, %rdi
callq 0x1060
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0xce6(%rip), %rdi       # 0x200a
callq 0x10e0
jmp 0x130d
// File: /workspace/github_cpp_makefile_star2_O1/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 0x134e
leaq 0xd9a(%rip), %rdi       # 0x20e3
jmp 0x1448
movq %rsi, %rbx
leaq -0x130(%rbp), %rdi
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1090
leaq -0x24(%rbp), %r14
movl $0x0, (%r14)
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x11fc
movq %rax, %r15
movl (%r14), %r12d
addl %r12d, %r12d
movq %r12, %rdi
callq 0x10b0
testq %rax, %rax
je 0x1464
movq %rax, %r14
movq %rax, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x1090
movq 0x8(%rbx), %rsi
leaq 0xc88(%rip), %rdi       # 0x2038
xorl %eax, %eax
callq 0x1070
movl -0x24(%rbp), %ecx
testq %rcx, %rcx
je 0x1438
leaq 0x2cda(%rip), %r8       # 0x40a0
movq %r15, %rdi
movq %rcx, %rsi
movq %r14, %rdx
callq 0x1474
movq %rax, %r15
testl %r15d, %r15d
je 0x1441
movl %r15d, %eax
cvtsi2ss %rax, %xmm0
movl -0x24(%rbp), %esi
cvtsi2ss %rsi, %xmm1
divss %xmm1, %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xc4e(%rip), %rdi       # 0x2049
movl %r15d, %edx
movb $0x1, %al
callq 0x1070
movq 0x8(%rbx), %rcx
leaq 0xc63(%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 0x12ae
jmp 0x1452
leaq 0xc86(%rip), %rdi       # 0x20c5
jmp 0x1448
leaq 0xc4f(%rip), %rdi       # 0x2097
callq 0x1040
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x110, %rsp            # imm = 0x110
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0xbbf(%rip), %rdi       # 0x202a
callq 0x10e0
jmp 0x144d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x17bf
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 0x1724
movq %rbx, %rdx
movl $0x1, %eax
movq -0x40(%rbp), %rcx
shll %cl, %eax
cltq
orq %rax, %r15
movq 0x8(%r12), %r12
movl -0x2c(%rbp), %eax
movl %eax, %r9d
jmp 0x1746
orb $0x1, %cl
movb %cl, (%r13,%rax)
xorl %eax, %eax
movq (%r14), %rcx
leaq 0x1(%rcx), %r10
movq %r10, (%r14)
shrq $0x3, %rcx
cmpq %rdx, %rcx
jae 0x181a
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
cmpq $0x9, %rax
jne 0x17c9
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_O1/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
movq $0x0, (%rsi)
addq $0xa8a8, %r8            # imm = 0xA8A8
movq %r15, %rdx
callq 0x18ec
testq %rax, %rax
je 0x18dd
movq %rax, %rcx
movq -0x28(%rbp), %rdi
xorl %eax, %eax
cmpq $0x0, (%rcx)
je 0x18b9
movq %rcx, %rsi
movq %rdi, %rdx
shrq $0x3, %rdx
cmpq %r15, %rdx
jae 0x18dd
movzbl (%r12,%rdx), %r8d
leaq 0x1(%rdi), %rdx
movq %rdx, -0x28(%rbp)
notb %dil
movzbl %dil, %edi
andl $0x7, %edi
xorl %r9d, %r9d
btl %edi, %r8d
setb %r9b
movq (%rsi,%r9,8), %rsi
cmpq $0x0, (%rsi)
movq %rdx, %rdi
jne 0x187c
jmp 0x18bf
movq %rdi, %rdx
movq %rcx, %rsi
movq 0x28(%rsi), %rsi
cmpq $0x100, %rsi            # imm = 0x100
je 0x18df
cmpq %rbx, %rax
je 0x18dd
movb %sil, (%r14,%rax)
incq %rax
movq %rdx, %rdi
jmp 0x1873
xorl %eax, %eax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x191d
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 0x19a2
movq $0x0, 0x28(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
xorl %ecx, %ecx
movq (%r15), %rax
movq %rax, %rdx
shrq $0x3, %rdx
cmpq %r14, %rdx
jae 0x1909
movzbl (%r12,%rdx), %edx
leaq 0x1(%rax), %rsi
notb %al
movzbl %al, %eax
andl $0x7, %eax
xorl %edi, %edi
btl %eax, %edx
setb %dil
shll %cl, %edi
movq %rsi, (%r15)
orq %rdi, 0x28(%rbx)
incl %ecx
cmpl $0x9, %ecx
jne 0x1964
jmp 0x190b
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq %r8, -0x30(%rbp)
callq 0x18ec
movq %rax, (%rbx)
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %r13, %rcx
movq -0x30(%rbp), %r8
callq 0x18ec
movq %rax, 0x8(%rbx)
cmpq $0x0, (%rbx)
sete %cl
testq %rax, %rax
sete %al
orb %cl, %al
jne 0x1909
jmp 0x190b
// File: /workspace/github_cpp_makefile_star2_O1/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 0xba0a(%rip), %rax      # 0xeb90
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 0x31c4
movq %rax, 0xb0(%rbx)
movq 0xa8(%r14), %rax
testq %rax, %rax
je 0x31d7
movq %rax, 0xa8(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
movl 0xbfd7(%rip), %eax      # 0xf1ec
leal 0x1(%rax), %ecx
movl %ecx, 0xbfce(%rip)      # 0xf1ec
movl $0x1, %ecx
movl %ecx, 0xbfc7(%rip)      # 0xf1f0
movl %ecx, -0x14(%rbp)
testl %eax, %eax
js 0x3297
movq %rdi, %rbx
leaq -0x14(%rbp), %r14
movq 0xbfba(%rip), %rdi      # 0xf1f8
movq 0xbfbb(%rip), %rsi      # 0xf200
movq %r14, %rdx
callq 0x5782
movq 0xbfac(%rip), %rsi      # 0xf200
movl -0x14(%rbp), %ecx
cmpq %rsi, %rax
je 0x326c
leal 0x1(%rcx), %eax
movl %eax, -0x14(%rbp)
cmpl 0xbf84(%rip), %ecx      # 0xf1ec
jl 0x3237
jmp 0x3297
movl %ecx, 0x68(%rbx)
cmpq 0xbf92(%rip), %rsi      # 0xf208
je 0x3287
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0xbf7b(%rip)      # 0xf200
jmp 0x3297
leaq 0xbf6a(%rip), %rdi      # 0xf1f8
leaq -0x14(%rbp), %rdx
callq 0x5824
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %rbx
pushq %rax
movq 0xbf4b(%rip), %rax      # 0xf1f8
movq 0xbf4c(%rip), %rsi      # 0xf200
leaq 0x68(%rdi), %rdx
movq %rax, %rdi
callq 0x5782
movq 0xbf39(%rip), %rdx      # 0xf200
cmpq %rdx, %rax
je 0x32f5
leaq 0x4(%rax), %rsi
cmpq %rdx, %rsi
je 0x32e0
subq %rsi, %rdx
movq %rax, %rdi
callq 0x2300
addq $-0x4, 0xbf18(%rip)     # 0xf200
decl 0xbefe(%rip)            # 0xf1ec
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq 0xbcd4(%rip), %rbx      # 0xefd0
leaq 0x6dcd(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x2110
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xbad6(%rip), %r14      # 0xefd0
leaq 0x6c35(%rip), %rsi      # 0xa136
movl $0x17, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x6c0f(%rip), %rsi      # 0xa14e
movl $0x19, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
leaq 0x6beb(%rip), %rsi      # 0xa168
movl $0xc, %edx
movq %rax, %rdi
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq 0x6bbd(%rip), %rsi      # 0xa175
movl $0x13, %edx
movq %rax, %rdi
callq 0x2240
movq 0xba14(%rip), %rdi      # 0xefe0
leaq -0x1c(%rbp), %r15
movq %r15, %rsi
callq 0x20f0
movl (%r15), %eax
cmpl $0x3, %eax
je 0x3674
cmpl $0x2, %eax
je 0x362f
cmpl $0x1, %eax
jne 0x3639
movl $0x1, 0xbbf8(%rip)      # 0xf1f0
movq 0xb9d1(%rip), %rdi      # 0xefd0
leaq 0x6add(%rip), %rsi      # 0xa0e3
movl $0x1b, %edx
callq 0x2240
addq $0x8, %rbx
movq 0xb9c5(%rip), %rdi      # 0xefe0
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movq %rbx, %rsi
callq 0x2330
jmp 0x3674
movq %rbx, %rdi
callq 0x3204
jmp 0x3674
leaq 0x6b49(%rip), %rsi      # 0xa189
movl $0x11, %edx
movq %r14, %rdi
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/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 0x2320
leaq 0x6645(%rip), %rsi      # 0xa212
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x3bfb
movl 0x6c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2340
jmp 0x3c41
movq 0xb3ce(%rip), %rbx      # 0xefd0
leaq 0x66dc(%rip), %rsi      # 0xa2e5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xb39c(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq -0x210(%rbp), %rdi
callq 0x22b0
movq 0xb374(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2160
leaq -0x118(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/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 0x2230
leaq 0x6545(%rip), %rsi      # 0xa212
movq %r14, %rdi
movl $0x8, %edx
callq 0x2100
addq $0x6c, %rbx
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1f8(%rbp,%rax)
jne 0x3d08
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2060
jmp 0x3cde
leaq -0x218(%rbp), %rdi
callq 0x2080
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3d22
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2320
leaq 0x64b6(%rip), %rsi      # 0xa217
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x3d8f
movl 0x6c(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2340
jmp 0x3dd5
movq 0xb23a(%rip), %rbx      # 0xefd0
leaq 0x6548(%rip), %rsi      # 0xa2e5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xb208(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
leaq -0x210(%rbp), %rdi
callq 0x22b0
movq 0xb1e0(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2160
leaq -0x118(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/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 0x2230
leaq 0x63b6(%rip), %rsi      # 0xa217
movq %r14, %rdi
movl $0x8, %edx
callq 0x2100
addq $0x6c, %rbx
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x1f8(%rbp,%rax)
jne 0x3e9c
movq %r14, %rdi
movq %rbx, %rsi
callq 0x20f0
movq %r14, %rdi
callq 0x2060
jmp 0x3e72
leaq -0x218(%rbp), %rdi
callq 0x2080
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r14
popq %rbp
retq
jmp 0x3eb6
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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), %r14
cmpq 0x8(%rdi), %r14
je 0x3ef3
movq %rdi, %rbx
movq (%r14), %rdi
callq 0x3680
addq $0x8, %r14
cmpq 0x8(%rbx), %r14
jne 0x3ee1
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
movl $0x1, 0xb2e3(%rip)      # 0xf1f0
movq (%rdi), %r12
movq 0x8(%rdi), %rax
cmpq %rax, %r12
je 0x3f39
movq %rdi, %rbx
movl (%rsi), %ecx
leaq 0x8(%r12), %r14
movq (%r12), %rdx
cmpl %ecx, 0x68(%rdx)
je 0x3f87
addq $0x8, %r12
addq $0x8, %r14
cmpq %rax, %r12
jne 0x3f23
movq 0xb090(%rip), %rdi      # 0xefd0
leaq 0x6189(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
callq 0x2240
movq 0xb078(%rip), %rbx      # 0xefd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2110
movq 0xb042(%rip), %r15      # 0xefd0
leaq 0x6288(%rip), %rsi      # 0xa21d
movl $0x18, %edx
movq %r15, %rdi
callq 0x2240
movq (%r12), %rdi
callq 0x3680
callq 0x2290
leaq 0x627f(%rip), %rsi      # 0xa236
movl $0x23, %edx
movq %r15, %rdi
callq 0x2240
callq 0x2290
cmpb $0x6e, %al
jne 0x3fd6
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%r12), %rdi
callq 0x32a0
movq 0x8(%rbx), %rdx
cmpq %rdx, %r14
je 0x3ff7
leaq -0x8(%r14), %rdi
subq %r14, %rdx
movq %r14, %rsi
callq 0x2300
addq $-0x8, 0x8(%rbx)
movq 0xafcd(%rip), %rdi      # 0xefd0
leaq 0x6250(%rip), %rsi      # 0xa25a
movl $0x14, %edx
jmp 0x3f4c
// File: /workspace/github_cpp_makefile_star2_O1/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
movl $0x1, 0xb1c4(%rip)      # 0xf1f0
movq (%rdi), %r13
cmpq 0x8(%rdi), %r13
je 0x40a7
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%r13), %r14
movq 0xaf8a(%rip), %r12      # 0xefd0
movq (%r13), %rdi
addq $0x8, %rdi
movq %r15, %rsi
callq 0x22a0
testl %eax, %eax
jne 0x4099
callq 0x2290
movl $0x18, %edx
movq %r12, %rdi
leaq 0x61af(%rip), %rsi      # 0xa21d
callq 0x2240
movq (%r13), %rdi
callq 0x3680
movl $0x23, %edx
movq %r12, %rdi
leaq 0x61ab(%rip), %rsi      # 0xa236
callq 0x2240
callq 0x2290
cmpb $0x79, %al
je 0x40fb
addq $0x8, %r13
addq $0x8, %r14
cmpq 0x8(%rbx), %r13
jne 0x4046
movq 0xaf22(%rip), %rdi      # 0xefd0
leaq 0x601b(%rip), %rsi      # 0xa0d0
movl $0x12, %edx
callq 0x2240
movq 0xaf0a(%rip), %rbx      # 0xefd0
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2110
movq (%r13), %rdi
callq 0x32a0
movq 0x8(%rbx), %rdx
cmpq %rdx, %r14
je 0x411c
leaq -0x8(%r14), %rdi
subq %r14, %rdx
movq %r14, %rsi
callq 0x2300
addq $-0x8, 0x8(%rbx)
movq 0xaea8(%rip), %rdi      # 0xefd0
leaq 0x612b(%rip), %rsi      # 0xa25a
movl $0x14, %edx
jmp 0x40ba
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x28, %rsp
movq %rdi, %rbx
movq 0xae7f(%rip), %r14      # 0xefd0
movq 0xae88(%rip), %r12      # 0xefe0
leaq -0x2c(%rbp), %r13
movl $0x13, %edx
movq %r14, %rdi
leaq 0x6104(%rip), %rsi      # 0xa26f
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
movl $0x11, %edx
movq %rax, %rdi
leaq 0x60da(%rip), %rsi      # 0xa283
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movq %rax, %r15
movl $0xc, %edx
movq %rax, %rdi
leaq 0x5f81(%rip), %rsi      # 0xa168
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
movl $0x22, %edx
movq %rax, %rdi
leaq 0x6073(%rip), %rsi      # 0xa295
callq 0x2240
movq %r12, %rdi
movq %r13, %rsi
callq 0x20f0
movl -0x2c(%rbp), %eax
cmpl $0x1, %eax
je 0x42bf
cmpl $0x2, %eax
je 0x428c
cmpl $0x3, %eax
je 0x4335
movl $0x11, %edx
movq %r14, %rdi
leaq 0x5f2e(%rip), %rsi      # 0xa189
callq 0x2240
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x415c
movl $0x1d, %edx
movq %r14, %rdi
leaq 0x601d(%rip), %rsi      # 0xa2b8
callq 0x2240
movq %r12, %rdi
leaq -0x30(%rbp), %r15
movq %r15, %rsi
callq 0x20f0
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3ef8
jmp 0x415c
movl $0x1b, %edx
movq %r14, %rdi
leaq 0x5e15(%rip), %rsi      # 0xa0e3
callq 0x2240
movq (%r12), %rax
movq -0x18(%rax), %rax
movq 0x10(%r12,%rax), %r15
movl $0x20, %edx
movq %r12, %rdi
leaq -0x50(%rbp), %rsi
callq 0x2330
movq (%r12), %rax
movq -0x18(%rax), %rax
cmpl $0x0, 0x20(%r12,%rax)
jne 0x431d
addq $-0x21, %r15
cmpq $-0x21, %r15
ja 0x431d
movq 0xe8(%r12,%rax), %rdi
movq 0x10(%rdi), %rax
cmpq 0x18(%rdi), %rax
jae 0x432e
movq %rbx, %rdi
leaq -0x50(%rbp), %rsi
callq 0x4014
jmp 0x415c
callq 0x23a0
jmp 0x431d
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/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 (%rdi), %r15
movq 0x8(%rdi), %r12
cmpq %r12, %r15
je 0x43a4
movq %rsi, %rbx
movq (%r15), %r14
leaq 0x8(%r14), %rdi
movq %rbx, %rsi
callq 0x22a0
testl %eax, %eax
je 0x43e9
addq $0x8, %r15
cmpq %r12, %r15
jne 0x4388
movq 0xac25(%rip), %rbx      # 0xefd0
leaq 0x5f24(%rip), %rsi      # 0xa2d6
movl $0x9, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
xorl %r14d, %r14d
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5ff7(%rip), %rsi      # 0xa407
leaq -0x218(%rbp), %r14
movq %r14, %rdi
movl $0x4, %edx
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x1f8(%rbp,%rax)
je 0x447d
movq 0xab94(%rip), %rbx      # 0xefd0
leaq 0x5e9d(%rip), %rsi      # 0xa2e0
movl $0x11, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xab62(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x44a8
movq (%rbx), %r15
cmpq 0x8(%rbx), %r15
je 0x449c
movq (%r15), %rsi
movl $0xb8, %edx
movq %r14, %rdi
callq 0x2280
addq $0x8, %r15
jmp 0x4480
leaq -0x218(%rbp), %rdi
callq 0x22b0
movq 0xab19(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x210(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x218(%rbp,%rcx)
callq 0x2160
leaq -0x120(%rbp), %rdi
callq 0x20a0
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44ee
movq %rax, %rbx
leaq -0x218(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/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 0x2320
leaq 0x5b89(%rip), %rsi      # 0xa2f2
movq %r14, %rdi
movl $0x1, %edx
callq 0x2040
leaq -0x1a0(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x47f0
leaq 0x5b6c(%rip), %rsi      # 0xa2f9
leaq -0x210(%rbp), %rdi
movl $0x3, %edx
callq 0x2240
movl 0x68(%rbx), %esi
leaq -0x210(%rbp), %rdi
callq 0x2340
movq %rax, %r14
leaq 0x5b46(%rip), %rsi      # 0xa2fd
movl $0x8, %edx
movq %rax, %rdi
callq 0x2240
movl $0x4c4c554e, %eax       # imm = 0x4C4C554E
xorl 0x70(%rbx), %eax
movzbl 0x74(%rbx), %ecx
orl %eax, %ecx
je 0x4838
addq $0x70, %rbx
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
movq %rbx, %rsi
movq %rax, %rdx
callq 0x2240
jmp 0x4852
movq 0xa7d9(%rip), %rbx      # 0xefd0
leaq 0x5ae7(%rip), %rsi      # 0xa2e5
movl $0xc, %edx
movq %rbx, %rdi
callq 0x2240
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0xa7a7(%rip), %rdi      # 0xefd0
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x4866
movq (%r14), %rax
movq -0x18(%rax), %rax
movq %r14, %rdi
addq %rax, %rdi
movl 0x20(%r14,%rax), %esi
orl $0x1, %esi
callq 0x2310
leaq 0x5aad(%rip), %rsi      # 0xa306
movl $0x17, %edx
movq %r14, %rdi
callq 0x2240
leaq -0x210(%rbp), %rdi
callq 0x22b0
movq 0xa74f(%rip), %rax      # 0xefc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x208(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x210(%rbp,%rcx)
callq 0x2160
leaq -0x118(%rbp), %rdi
callq 0x20a0
addq $0x200, %rsp            # imm = 0x200
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x210(%rbp), %rdi
callq 0x22c0
movq %rbx, %rdi
callq 0x2350
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2230
leaq 0x5a00(%rip), %rsi      # 0xa2f2
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2100
leaq -0x1a8(%rbp), %rdi
callq 0x2070
testb %al, %al
je 0x49cd
leaq -0x420(%rbp), %r14
movq 0xa6af(%rip), %r15      # 0xefd0
movq -0x220(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x200(%rbp,%rax)
jne 0x499d
leaq (%rax,%rbp), %rdi
addq $-0x220, %rdi           # imm = 0xFDE0
movl $0xa, %esi
callq 0x21c0
movsbl %al, %ecx
movl $0x1f4, %edx            # imm = 0x1F4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2370
movq %r14, %rdi
callq 0x20c0
movq %r15, %rdi
movq %r14, %rsi
movq %rax, %rdx
callq 0x2240
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2110
jmp 0x4921
movq 0xa62c(%rip), %rdi      # 0xefd0
leaq 0x5973(%rip), %rsi      # 0xa31e
movl $0x4, %edx
callq 0x2240
movq 0xa614(%rip), %rdi      # 0xefd0
leaq 0x5960(%rip), %rsi      # 0xa323
movl $0x3, %edx
callq 0x2240
leaq -0x220(%rbp), %rdi
callq 0x2060
leaq -0x220(%rbp), %rdi
callq 0x2080
addq $0x408, %rsp            # imm = 0x408
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x49f5
movq %rax, %rbx
leaq -0x220(%rbp), %rdi
callq 0x2080
movq %rbx, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/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 %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
movq (%rsi), %r12
cmpq 0x8(%rsi), %r12
je 0x4a9b
movq %rdx, %r14
movq %rsi, %r15
movq (%r12), %rax
leaq 0x48(%rax), %rcx
cmpq %r14, %rcx
jne 0x4a91
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4a86
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4a91
movq %rbx, %rdi
movq %r12, %rdx
callq 0x5946
addq $0x8, %r12
cmpq 0x8(%r15), %r12
jne 0x4a65
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x4abe
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x21f0
movq %r14, %rdi
callq 0x2350
// File: /workspace/github_cpp_makefile_star2_O1/hzy1754785321[P]warehouse-manage-system/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
movups 0x4b3e(%rip), %xmm0     # 0xa0b0
movups %xmm0, 0x48(%rdi)
movups 0x4b43(%rip), %xmm0     # 0xa0c0
movups %xmm0, 0x58(%rdi)
movl $0x0, 0x6c(%rdi)
movups 0x4aa9(%rip), %xmm0     # 0xa038
movups %xmm0, 0x70(%rdi)
movups 0x4aae(%rip), %xmm0     # 0xa048
movups %xmm0, 0x80(%rdi)
movups 0x4ab0(%rip), %xmm0     # 0xa058
movups %xmm0, 0x90(%rdi)
movw $0x0, 0xa0(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0xa8(%rdi)
movl $0x696d6461, %eax       # imm = 0x696D6461
movl %eax, 0x8(%rdi)
movw $0x6e, %cx
movw %cx, 0xc(%rdi)
leaq 0x9637(%rip), %rdx      # 0xec10
movq %rdx, (%rdi)
movw %cx, 0x4c(%rdi)
movl %eax, 0x48(%rdi)
movl $0x1, 0x9c03(%rip)      # 0xf1f0
movq 0x99dc(%rip), %rdi      # 0xefd0
leaq 0x4b1d(%rip), %rsi      # 0xa118
movl $0x1d, %edx
callq 0x2240
leaq 0x28(%rbx), %rsi
movq 0x99d0(%rip), %rdi      # 0xefe0
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
callq 0x2330
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x3204
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3172
leaq 0x95cd(%rip), %rax      # 0xec10
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_O1/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 %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
incl 0x964e(%rip)            # 0xf214
xorl %edi, %edi
callq 0x2190
movl %eax, %edi
callq 0x21b0
leaq 0x9615(%rip), %rax      # 0xf1f0
movl $0x1, (%rax)
movl $0x0, -0x14(%rbp)
cmpl $0x0, 0x9625(%rip)      # 0xf214
jle 0x5c60
leaq -0x14(%rbp), %r14
movq 0x961c(%rip), %rdi      # 0xf218
movq 0x961d(%rip), %rsi      # 0xf220
movq %r14, %rdx
callq 0x5782
cmpq 0x960e(%rip), %rax      # 0xf220
je 0x5c26
movl -0x14(%rbp), %eax
incl %eax
movl %eax, -0x14(%rbp)
cmpl 0x95f2(%rip), %eax      # 0xf214
jl 0x5bf5
jmp 0x5c60
callq 0x2090
movl %eax, 0x44(%rbx)
movq 0x95eb(%rip), %rsi      # 0xf220
cmpq 0x95ec(%rip), %rsi      # 0xf228
je 0x5c50
movl -0x14(%rbp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x95d2(%rip)      # 0xf220
jmp 0x5c60
leaq 0x95c1(%rip), %rdi      # 0xf218
leaq -0x14(%rbp), %rdx
callq 0x5824
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
nop