LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/lh3[P]partig/pdist.c
// Function: pt_match_print
void pt_match_print(FILE *fp, const gfa_t *g, const pt_match_t *ma)
{
	uint32_t i;
	for (i = 0; i < g->n_seg; ++i) {
		const gfa_seg_t *s = &g->seg[i];
		const pt_uinfo_t *u = &ma->info[i];
		fprintf(fp, "C\t%s\t%d\t%d\t%d\n", s->name, s->len, u->cnt2, u->cnt1);
	}
	for (i = 0; i < ma->n_ma; ++i) {
		const pt_match1_t *m = &ma->ma[i];
		fprintf(fp, "S\t%s\t%s\t%c\t%d\t%d\t%d\t%.6f\n", g->seg[m->sid[0]].name, g->seg[m->sid[1]].name,
				"+-"[!!m->rev], ma->info[m->sid[0]].cnt2, ma->info[m->sid[1]].cnt2, m->m, m->sim);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0xb6bd
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x30(%rbp), %rax
movl (%rax), %r8d
movq -0x30(%rbp), %rax
movl 0x4(%rax), %r9d
leaq 0x204d(%rip), %rsi      # 0xd6f8
movb $0x0, %al
callq 0x1170
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb64b
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0xb79d
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movl (%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %ecx
shlq $0x6, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rcx
movq -0x38(%rbp), %rax
cmpl $0x0, 0xc(%rax)
setne %al
xorb $-0x1, %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
movslq %eax, %rsi
leaq 0x1b3e(%rip), %rax      # 0xd27d
movsbl (%rax,%rsi), %r8d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rsi
movl (%rsi), %esi
movl (%rax,%rsi,8), %r9d
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x38(%rbp), %rsi
movl 0x4(%rsi), %esi
movl (%rax,%rsi,8), %r10d
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x38(%rbp), %rsi
movsd 0x10(%rsi), %xmm0
leaq 0x1f87(%rip), %rsi      # 0xd707
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x1, %al
callq 0x1170
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb6c4
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]partig/pdist.c
// Function: pt_pdist_mark_pair
static void pt_pdist_mark_pair(const pt_match_t *ma, uint8_t *mark, uint32_t sid1, uint32_t sid2, uint32_t r)
{
	uint32_t o = ma->idx[sid1] >> 32;
	uint32_t n = (uint32_t)ma->idx[sid1], j;
	for (j = o; j < o + n; ++j)
		if (ma->ma[j].sid[1] == sid2 && ma->ma[j].rev == r)
			mark[j] = 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl %r8d, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x14(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, -0x24(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jae 0xb89d
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0xb890
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x28(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0xc(%rax), %eax
cmpl -0x1c(%rbp), %eax
jne 0xb890
movq -0x10(%rbp), %rax
movl -0x28(%rbp), %ecx
movb $0x1, (%rax,%rcx)
jmp 0xb892
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0xb844
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/lh3[P]partig/main.c
// Function: print_usage
static void print_usage(FILE *fp, const pt_pdopt_t *po)
{
	fprintf(stderr, "Usage: partig [options] <in.gfa>\n");
	fprintf(stderr, "Options:\n");
	fprintf(stderr, "  -k INT     k-mer size [%d]\n", po->k);
	fprintf(stderr, "  -w INT     minimizer window size [%d]\n", po->w);
	fprintf(stderr, "  -c INT     max occurrance [%d]\n", po->max_occ);
	fprintf(stderr, "  -m FLOAT   mini k-mer similarity [%.3g]\n", po->min_sim);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq 0x3e61(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0x1762(%rip), %rsi      # 0xd903
movb $0x0, %al
callq 0x1170
movq 0x3e49(%rip), %rax      # 0xfff8
movq (%rax), %rdi
leaq 0x176c(%rip), %rsi      # 0xd925
movb $0x0, %al
callq 0x1170
movq 0x3e31(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %edx
leaq 0x1758(%rip), %rsi      # 0xd92f
movb $0x0, %al
callq 0x1170
movq 0x3e13(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x4(%rax), %edx
leaq 0x1757(%rip), %rsi      # 0xd94d
movb $0x0, %al
callq 0x1170
movq 0x3df4(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xc(%rax), %edx
leaq 0x1761(%rip), %rsi      # 0xd976
movb $0x0, %al
callq 0x1170
movq 0x3dd5(%rip), %rax      # 0xfff8
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movsd 0x18(%rax), %xmm0
leaq 0x1762(%rip), %rsi      # 0xd998
movb $0x1, %al
callq 0x1170
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/face-extract.c
// Function: getNameFromDetails
char *getNameFromDetails(uint16_t hash) {
	char *retstring = malloc(32);
	unsigned int result;
	result = matchhash(hash, StrCode16("p"), commondic, numcommondic);
	if(result != 0xFFFFFFFF) sprintf(retstring, "%s", commondic[result].name);
	else {
		sprintf( retstring, "%04x.png", hash );
	}
	return retstring;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movw %di, %ax
movw %ax, -0x2(%rbp)
movl $0x20, %edi
callq 0x1150
movq %rax, -0x10(%rbp)
movzwl -0x2(%rbp), %eax
movl %eax, -0x18(%rbp)
leaq 0x1aa4(%rip), %rdi      # 0x1388f
callq 0x12d0
movl -0x18(%rbp), %edi
movl %eax, %esi
movq 0x671c(%rip), %rdx      # 0x18518
movl 0x6726(%rip), %ecx      # 0x18528
callq 0x11d40
movl %eax, -0x14(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x11e3c
movq -0x10(%rbp), %rdi
movq 0x66fd(%rip), %rdx      # 0x18518
movl -0x14(%rbp), %eax
imulq $0x108, %rax, %rax      # imm = 0x108
addq %rax, %rdx
addq $0x8, %rdx
leaq 0x279b(%rip), %rsi      # 0x145ce
movb $0x0, %al
callq 0x11b0
jmp 0x11e52
movq -0x10(%rbp), %rdi
movzwl -0x2(%rbp), %edx
leaq 0x26ce(%rip), %rsi      # 0x14519
movb $0x0, %al
callq 0x11b0
movq -0x10(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/face-extract.c
// Function: generatePalette
uint32_t *generatePalette(uint16_t *source) {
	unsigned int i;
	uint8_t red, green, blue;
	uint32_t *retpal = NULL;
	retpal = malloc(sizeof(uint32_t)*256);
	for(i = 0; i < 256; i++) {
		red = source[i] & 0x1F;
		green = (source[i] >> 5) & 0x1F;
		blue = (source[i] >> 10) & 0x1F;
		retpal[i] = 0xFF000000 | color5to8(red) | color5to8(green) << 8 | color5to8(blue) << 16;
	}
	return retpal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x18(%rbp)
movl $0x400, %edi            # imm = 0x400
callq 0x1150
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x100, -0xc(%rbp)      # imm = 0x100
jae 0x11f53
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
andl $0x1f, %eax
movb %al, -0xd(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
sarl $0x5, %eax
andl $0x1f, %eax
movb %al, -0xe(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
movzwl (%rax,%rcx,2), %eax
sarl $0xa, %eax
andl $0x1f, %eax
movb %al, -0xf(%rbp)
movzbl -0xd(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x28(%rbp)
movzbl -0xd(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x28(%rbp), %eax
addl %ecx, %eax
orl $0xff000000, %eax       # imm = 0xFF000000
movl %eax, -0x24(%rbp)
movzbl -0xe(%rbp), %ecx
shll $0x3, %ecx
movzbl -0xe(%rbp), %eax
movl $0x4, %esi
cltd
idivl %esi
movl %eax, %edx
movl -0x24(%rbp), %eax
addl %edx, %ecx
shll $0x8, %ecx
orl %ecx, %eax
movl %eax, -0x20(%rbp)
movzbl -0xf(%rbp), %eax
shll $0x3, %eax
movl %eax, -0x1c(%rbp)
movzbl -0xf(%rbp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
movl -0x20(%rbp), %edx
movl %eax, %ecx
movl -0x1c(%rbp), %eax
addl %ecx, %eax
shll $0x10, %eax
orl %eax, %edx
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x11e89
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/Joy-Division[P]tools-mgs/face-extract.c
// Function: pixelsToRGBA
unsigned char *pixelsToRGBA(unsigned char *source, uint16_t *paletteData, unsigned int pixelsWidth, unsigned int pixelsHeight) {
	unsigned int i, numPixels = pixelsWidth*pixelsHeight;
	uint8_t *idximage;
	uint32_t *palette = generatePalette(paletteData);
	idximage = source;
	uint32_t *retimage = malloc(sizeof(uint32_t)*numPixels);
	for( i = 0; i < numPixels; i++ ) retimage[i] = palette[idximage[i]];
	free(palette);
	return (unsigned char*)retimage;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl -0x14(%rbp), %eax
imull -0x18(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rdi
callq 0x11e60
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0x20(%rbp), %eax
movl %eax, %edi
shlq $0x2, %rdi
callq 0x1150
movq %rax, -0x38(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jae 0x11fdd
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
movzbl (%rcx,%rdx), %ecx
movl (%rax,%rcx,4), %edx
movq -0x38(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x11fae
movq -0x30(%rbp), %rdi
callq 0x1030
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/vanhauser-thc[P]vulntest/confuse.cpp
// Function: main
int main(int argc, char *argv[]) {
  Base *b1 = new Greeter();
  Base *b2 = new Exec();
  Greeter *g;
  if (argc != 3) {
    printf("Syntax: %s 1|2 greeting\n", argv[0]);
    exit(-1);
  }
  if (argv[1][0] == '1')
    g = static_cast<Greeter *>(b1);
  else if (argv[1][0] == '2')
    g = static_cast<Greeter *>(b2);
  else {
    printf("wrong mode\n");
    exit(-1);
  }
  g->sayHi(argv[2]);
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x8, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, -0x38(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1040
movq -0x38(%rbp), %rdi
callq 0x1300
movq -0x38(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x8, %edi
callq 0x1080
movq %rax, %rdi
movq %rdi, -0x30(%rbp)
xorl %esi, %esi
movl $0x8, %edx
callq 0x1040
movq -0x30(%rbp), %rdi
callq 0x1320
movq -0x30(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $0x3, -0x8(%rbp)
je 0x1297
movq -0x10(%rbp), %rax
movq (%rax), %rsi
leaq 0xd7e(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10a0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x31, %eax
jne 0x12b1
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x12e5
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl (%rax), %eax
cmpl $0x32, %eax
jne 0x12cb
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x12e3
leaq 0xd4b(%rip), %rdi       # 0x201d
movb $0x0, %al
callq 0x1030
movl $0xffffffff, %edi       # imm = 0xFFFFFFFF
callq 0x10a0
jmp 0x12e5
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rdi), %rax
callq *(%rax)
xorl %eax, %eax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex2.c
// Function: func
void* func(void* arg)
{
    dthread_mutex_lock(&lock);
    //a method to get which thread is running
    counter += 1;

    printf("Start: Thread %d \n", counter);
    //critical section
    sleep(2);
    printf("Finish: Thread %d \n", counter);
  
    dthread_mutex_unlock(&lock);
    return NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x251d(%rip), %rdi      # 0x40b0
callq 0x17a0
movl 0x2516(%rip), %eax      # 0x40b4
addl $0x1, %eax
movl %eax, 0x250d(%rip)      # 0x40b4
movl 0x2507(%rip), %esi      # 0x40b4
leaq 0x48d(%rip), %rdi       # 0x2041
movb $0x0, %al
callq 0x1080
movl $0x2, %edi
callq 0x10f0
movl 0x24e9(%rip), %esi      # 0x40b4
leaq 0x482(%rip), %rdi       # 0x2054
movb $0x0, %al
callq 0x1080
leaq 0x24d0(%rip), %rdi      # 0x40b0
callq 0x1840
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/deepika9294[P]Threading-Library/one-one/test/mutex2.c
// Function: main
int main(void)
{
    int i = 0;
    int error;
    dthread_init();
    dthread_mutex_init(&lock);
    printf("\n***** MUTEX TEST : 2 *****\n");
    printf("TEST : Thread Synchronization using a shared resource \"counter \" avoiding race condition\n");

    while (i < 3) {
        error = dthread_create(&(tid[i]),&func, NULL);
        if (error != 0)
            printf("\nError in creation");
        i++;
    }
    dthread_join(tid[0], NULL);
    dthread_join(tid[1], NULL);
    dthread_join(tid[2], NULL);
    printf("\n--------------------------------EXITING MUTEX TEST---------------------------------\n\n");

  
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
callq 0x1200
leaq 0x249e(%rip), %rdi      # 0x40b0
callq 0x1780
leaq 0x44a(%rip), %rdi       # 0x2068
movb $0x0, %al
callq 0x1080
leaq 0x459(%rip), %rdi       # 0x2085
movb $0x0, %al
callq 0x1080
cmpl $0x3, -0x8(%rbp)
jge 0x1c7d
movslq -0x8(%rbp), %rax
leaq 0x247c(%rip), %rdi      # 0x40c0
shlq $0x3, %rax
addq %rax, %rdi
leaq -0xd2(%rip), %rsi       # 0x1b80
xorl %eax, %eax
movl %eax, %edx
callq 0x1370
movl %eax, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1c72
leaq 0x474(%rip), %rdi       # 0x20df
movb $0x0, %al
callq 0x1080
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1c33
movq 0x243c(%rip), %rdi      # 0x40c0
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq 0x2434(%rip), %rdi      # 0x40c8
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
movq 0x242c(%rip), %rdi      # 0x40d0
xorl %eax, %eax
movl %eax, %esi
callq 0x15d0
leaq 0x43e(%rip), %rdi       # 0x20f2
movb $0x0, %al
callq 0x1080
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/dxwc[P]sfeed/sfeed_gph.c
// Function: gphlink
void
gphlink(FILE *fp, const char *s, size_t len)
{
	size_t i;

	for (i = 0; *s && i < len; s++, i++) {
		switch (*s) {
		case '\r': /* ignore CR */
		case '\n': /* ignore LF */
			break;
		case '\t':
			fputs("        ", fp);
			break;
		case '|': /* escape separators */
			fputs("\\|", fp);
			break;
		default:
			fputc(*s, fp);
			break;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x21(%rbp)
je 0x132b
movq -0x20(%rbp), %rax
cmpq -0x18(%rbp), %rax
setb %al
movb %al, -0x21(%rbp)
movb -0x21(%rbp), %al
testb $0x1, %al
jne 0x1337
jmp 0x13bb
movq -0x10(%rbp), %rax
movsbl (%rax), %eax
movl %eax, -0x28(%rbp)
subl $0x9, %eax
je 0x1368
jmp 0x1348
movl -0x28(%rbp), %eax
subl $0xa, %eax
je 0x1366
jmp 0x1352
movl -0x28(%rbp), %eax
subl $0xd, %eax
je 0x1366
jmp 0x135c
movl -0x28(%rbp), %eax
subl $0x7c, %eax
je 0x137a
jmp 0x138c
jmp 0x139c
movq -0x8(%rbp), %rsi
leaq 0x1c91(%rip), %rdi      # 0x3004
callq 0x10d0
jmp 0x139c
movq -0x8(%rbp), %rsi
leaq 0x1c88(%rip), %rdi      # 0x300d
callq 0x10d0
jmp 0x139c
movq -0x10(%rbp), %rax
movsbl (%rax), %edi
movq -0x8(%rbp), %rsi
callq 0x10f0
jmp 0x139e
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x130c
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/giometti[P]mastering_UNIX_programming/chapter_02/dsync.c
// Function: main
int main(int argc, char *argv[])
{
	int fd, n;
	char buf[MAX_SIZE];
	int ret;

	ret = open("data.bin", O_WRONLY | O_CREAT | O_DSYNC,
			S_IWUSR);
	if (ret < 0) {
		perror("open");
		return -1;
	}
	fd = ret;

	for (n = 0; n < 128; n++) {
		ret = write(fd, buf, n);
		if (ret < 0) {
			perror("write");
			return -1;
		}
	}

	close(fd);

	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1030, %rsp           # imm = 0x1030
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq 0xe54(%rip), %rdi       # 0x2004
movl $0x1041, %esi           # imm = 0x1041
movl $0x80, %edx
movb $0x0, %al
callq 0x1070
movl %eax, -0x1024(%rbp)
cmpl $0x0, -0x1024(%rbp)
jge 0x11e5
leaq 0xe36(%rip), %rdi       # 0x200d
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1251
movl -0x1024(%rbp), %eax
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
cmpl $0x80, -0x18(%rbp)
jge 0x1242
movl -0x14(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movslq -0x18(%rbp), %rdx
callq 0x1040
movl %eax, -0x1024(%rbp)
cmpl $0x0, -0x1024(%rbp)
jge 0x1235
leaq 0xdeb(%rip), %rdi       # 0x2012
callq 0x1080
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x1251
jmp 0x1237
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x11f5
movl -0x14(%rbp), %edi
callq 0x1050
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1030, %rsp           # imm = 0x1030
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/bind_sfd.c
// Function: bind_sfd
int bind_sfd(char** arg,int sfd)
{
    struct sockaddr_in server_addr;
    server_addr.sin_addr.s_addr = inet_addr(arg[0]);
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(atoi(arg[1]));
    int ret = bind(sfd,(struct sockaddr*)&server_addr,sizeof(server_addr));
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x21e0
movl %eax, -0x18(%rbp)
movw $0x2, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2310
movzwl %ax, %edi
callq 0x2050
movw %ax, -0x1a(%rbp)
movl -0xc(%rbp), %edi
leaq -0x1c(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rsi
movl $0x10, %edx
callq 0x2060
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/client_get.c
// Function: client_get
int client_get(int client_fd)
{
    MYSQL* connect;
    connect_mysql(&connect);
    int file_id;
    int ret = recv(client_fd,&file_id,sizeof(int),0);
    DISCON_CHECK(ret,0,client_fd);
    int file_name_len;
    ret = recv(client_fd,&file_name_len,sizeof(int),0);
    DISCON_CHECK(ret,0,client_fd);
    int path_len;
    ret = recv(client_fd,&path_len,sizeof(int),0);
    DISCON_CHECK(ret,0,client_fd);
    char file_name[128] = {0};
    ret = recv_client_all(client_fd,file_name,file_name_len);
    DISCON_CHECK(ret,-1,client_fd);
    char path[4096] = {0};
    ret = recv_client_all(client_fd,path,path_len);
    DISCON_CHECK(ret,-1,client_fd);
    printf("%s\n%s\n",file_name,path);
    send_file_to_client(client_fd,file_id,file_name,path,connect);
    close(client_fd);
    mysql_close(connect);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10a0, %rsp           # imm = 0x10A0
movl %edi, -0x8(%rbp)
leaq -0x10(%rbp), %rdi
callq 0x3c20
movl -0x8(%rbp), %edi
leaq -0x14(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x27e7
movl -0x8(%rbp), %edi
callq 0x2380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2919
movl -0x8(%rbp), %edi
leaq -0x1c(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2817
movl -0x8(%rbp), %edi
callq 0x2380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2919
movl -0x8(%rbp), %edi
leaq -0x20(%rbp), %rsi
movl $0x4, %edx
xorl %ecx, %ecx
callq 0x20b0
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jne 0x2847
movl -0x8(%rbp), %edi
callq 0x2380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2919
leaq -0xa0(%rbp), %rdi
xorl %esi, %esi
movl $0x80, %edx
callq 0x2140
movl -0x8(%rbp), %edi
leaq -0xa0(%rbp), %rsi
movl -0x1c(%rbp), %edx
callq 0x5cb0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x2889
movl -0x8(%rbp), %edi
callq 0x2380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2919
leaq -0x10a0(%rbp), %rdi
xorl %esi, %esi
movl $0x1000, %edx           # imm = 0x1000
callq 0x2140
movl -0x8(%rbp), %edi
leaq -0x10a0(%rbp), %rsi
movl -0x20(%rbp), %edx
callq 0x5cb0
movl %eax, -0x18(%rbp)
cmpl $-0x1, -0x18(%rbp)
jne 0x28c8
movl -0x8(%rbp), %edi
callq 0x2380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x2919
leaq -0xa0(%rbp), %rsi
leaq -0x10a0(%rbp), %rdx
leaq 0x47a6(%rip), %rdi      # 0x7083
movb $0x0, %al
callq 0x2040
movl -0x8(%rbp), %edi
movl -0x14(%rbp), %esi
leaq -0xa0(%rbp), %rdx
leaq -0x10a0(%rbp), %rcx
movq -0x10(%rbp), %r8
callq 0x6110
movl -0x8(%rbp), %edi
callq 0x2380
movq -0x10(%rbp), %rdi
callq 0x2260
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10a0, %rsp           # imm = 0x10A0
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/compute_file_md5_2.c
// Function: compute_file_md5_2
int compute_file_md5_2(int fd,char* md5_str,int size)
{
    int i;
	int ret;
	unsigned char data[READ_DATA_SIZE];
	unsigned char md5_value[MD5_SIZE];
	MD5_CTX md5;


	// init md5
	MD5Init(&md5);

    int total = 0;
    while(total < size)
	{
        if(size - total > 4096)
		    ret = read(fd, data, 4096);
        else
            ret = read(fd,data,size - total);
		if (-1 == ret)
		{
			perror("read");
			close(fd);
			return -1;
		}
		MD5Update(&md5, data, ret);
        total += ret;
	}


	MD5Final(&md5, md5_value);

	// convert md5 value to md5 string
	for(i = 0; i < MD5_SIZE; i++)
	{
		snprintf(md5_str + i*2, 2+1, "%02x", md5_value[i]);
	}

	return 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1090, %rsp           # imm = 0x1090
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
leaq -0x1088(%rbp), %rdi
callq 0x4730
movl $0x0, -0x108c(%rbp)
movl -0x108c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x3bb5
movl -0x14(%rbp), %eax
subl -0x108c(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jle 0x3b43
movl -0x8(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl $0x1000, %edx           # imm = 0x1000
callq 0x22b0
movl %eax, -0x1c(%rbp)
jmp 0x3b61
movl -0x8(%rbp), %edi
leaq -0x1020(%rbp), %rsi
movl -0x14(%rbp), %eax
subl -0x108c(%rbp), %eax
movslq %eax, %rdx
callq 0x22b0
movl %eax, -0x1c(%rbp)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmpl -0x1c(%rbp), %eax
jne 0x3b8b
leaq 0x3880(%rip), %rdi      # 0x73f2
callq 0x2190
movl -0x8(%rbp), %edi
callq 0x2380
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3c14
leaq -0x1020(%rbp), %rsi
movl -0x1c(%rbp), %edx
leaq -0x1088(%rbp), %rdi
callq 0x4780
movl -0x1c(%rbp), %eax
addl -0x108c(%rbp), %eax
movl %eax, -0x108c(%rbp)
jmp 0x3b0b
leaq -0x1030(%rbp), %rsi
leaq -0x1088(%rbp), %rdi
callq 0x57d0
movl $0x0, -0x18(%rbp)
cmpl $0x10, -0x18(%rbp)
jge 0x3c0d
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %eax
shll %eax
cltq
addq %rax, %rdi
movslq -0x18(%rbp), %rax
movzbl -0x1030(%rbp,%rax), %ecx
movl $0x3, %esi
leaq 0x37fc(%rip), %rdx      # 0x73f7
movb $0x0, %al
callq 0x2320
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3bcf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x1090, %rsp           # imm = 0x1090
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/connect_mysql.c
// Function: connect_mysql
int connect_mysql(MYSQL** connect)
{
	const char *server = "localhost";
	const char *user = "root";
	const char *password = "Ph981030";
	const char *database = "MyNetdisk";

	*connect = mysql_init(NULL);
    if(!connect)
    {
        printf("MySQL init failed\n");
        return -1;
    }

	if(!mysql_real_connect(*connect, server, user, password, database, 0, NULL, 0))
	{
		printf("Error connecting to database: %s\n", mysql_error(*connect));
		return -1;
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x37c9(%rip), %rax      # 0x73fc
movq %rax, -0x18(%rbp)
leaq 0x37c8(%rip), %rax      # 0x7406
movq %rax, -0x20(%rbp)
leaq 0x37c2(%rip), %rax      # 0x740b
movq %rax, -0x28(%rbp)
leaq 0x36f9(%rip), %rax      # 0x734d
movq %rax, -0x30(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x20e0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
cmpq $0x0, -0x10(%rbp)
jne 0x3c89
leaq 0x379b(%rip), %rdi      # 0x7414
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cee
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x30(%rbp), %r8
xorl %r9d, %r9d
xorl %eax, %eax
movq $0x0, (%rsp)
movq $0x0, 0x8(%rsp)
callq 0x2120
cmpq $0x0, %rax
jne 0x3ce7
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x3750(%rip), %rdi      # 0x7427
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3cee
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/factory_init.c
// Function: factory_init
int factory_init(factory_t *p_fact,int pthread_num,int que_capacity,int epoll_fd)
{
    if(pthread_num < 1 || que_capacity < 1)
    {
        puts("pthread_num or que_capacity error!\n");
        return -1;
    }
    que_init(&p_fact->que,que_capacity);
    pthread_cond_init(&p_fact->cond,NULL);
    pthread_mutex_init(&p_fact->mutex,NULL);
    p_fact->epoll_fd = epoll_fd;
    p_fact->pthread_num = pthread_num;
    p_fact->pthId_arr = (pthread_t*)malloc(sizeof(pthread_t) * pthread_num);
    p_fact->pthread_func = thread_func;
    p_fact->start_flag = 0;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x1, -0x14(%rbp)
jl 0x3d21
cmpl $0x1, -0x18(%rbp)
jge 0x3d36
leaq 0x374c(%rip), %rdi      # 0x7474
callq 0x2300
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3db4
movq -0x10(%rbp), %rdi
addq $0x20, %rdi
movl -0x18(%rbp), %esi
callq 0x5ac0
movq -0x10(%rbp), %rdi
addq $0x60, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2230
movq -0x10(%rbp), %rdi
addq $0x38, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x22d0
movl -0x1c(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0x14(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x4(%rax)
movslq -0x14(%rbp), %rdi
shlq $0x3, %rdi
callq 0x2250
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
leaq 0x21(%rip), %rcx        # 0x3dc0
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movl $0x0, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/factory_start.c
// Function: factory_start
int factory_start(factory_t* p_fact)
{
    if(p_fact->start_flag == 0)
    {
        for(int i = 0; i < p_fact->pthread_num; ++i)
        {
            pthread_create(p_fact->pthId_arr + i,NULL,p_fact->pthread_func,p_fact);
        }
        p_fact->start_flag = 1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0x3fb5
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x3fab
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movslq -0xc(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x8(%rbp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x2340
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3f6c
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
xorl %eax, %eax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/get_crypt_passwd.c
// Function: get_crypt_passwd
const char* get_crypt_passwd(const char* crybuf)
{
    int i; 
    int num = 0;
    for(i = 0; num != 3; ++i)
    {
        if(crybuf[i] == '$')
            ++num;
    }
    return crybuf + i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0x0, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x3, -0x10(%rbp)
je 0x4003
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x24, %eax
jne 0x3ff6
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3ff8
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x3fd6
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/get_file_id.c
// Function: get_file_id
int get_file_id(char* mysql_oper,int user_id,MYSQL* connect)
{
    sprintf(mysql_oper,"select file_id from File where user_id=%d;",user_id);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_ROW row;
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    row = mysql_fetch_row(res);
    int ret = atoi(row[0]);
    mysql_free_result(res);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %edx
leaq 0x348d(%rip), %rsi      # 0x74be
movb $0x0, %al
callq 0x2070
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4071
movq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x3025(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x40a9
movq -0x20(%rbp), %rdi
callq 0x2350
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2310
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x21f0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/get_salt.c
// Function: get_salt
void get_salt(char* str)
{
    srand(time(NULL));
    for(int i = 0; i < 16; ++i)
    {
        switch(rand()%3)
        {
        case 0:
            str[i] = rand()%26 + 'a';
            break;
        case 1:
            str[i] = rand()%26 + 'A';
            break;
        case 2:
            str[i] = rand()%10 + '0';
            break;
        }   
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
movl %eax, %edi
callq 0x21d0
movl $0x0, -0xc(%rbp)
cmpl $0x10, -0xc(%rbp)
jge 0x4190
callq 0x2090
movslq %eax, %rcx
imulq $0x55555556, %rcx, %rdx # imm = 0x55555556
movq %rdx, %rcx
shrq $0x3f, %rcx
shrq $0x20, %rdx
addl %ecx, %edx
movl %edx, %ecx
leal (%rcx,%rcx,2), %ecx
subl %ecx, %eax
movl %eax, -0x10(%rbp)
je 0x412b
jmp 0x4117
movl -0x10(%rbp), %eax
subl $0x1, %eax
je 0x4148
jmp 0x4121
movl -0x10(%rbp), %eax
subl $0x2, %eax
je 0x4165
jmp 0x4180
callq 0x2090
movl $0x1a, %ecx
cltd
idivl %ecx
addl $0x61, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4180
callq 0x2090
movl $0x1a, %ecx
cltd
idivl %ecx
addl $0x41, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4180
callq 0x2090
movl $0xa, %ecx
cltd
idivl %ecx
addl $0x30, %edx
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x4182
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x40e3
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/get_user_id.c
// Function: get_user_id
int get_user_id(char* mysql_oper,const char* user_name,MYSQL* connect)
{
    sprintf(mysql_oper,"select user_id from User where user_name='%s'",user_name);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_ROW row;
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    row = mysql_fetch_row(res);
    int ret = atoi(row[0]);
    mysql_free_result(res);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rdx
leaq 0x3326(%rip), %rsi      # 0x74e9
movb $0x0, %al
callq 0x2070
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x4203
movq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x2e93(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x423b
movq -0x20(%rbp), %rdi
callq 0x2350
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rdi
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rdi
callq 0x2310
movl %eax, -0x3c(%rbp)
movq -0x38(%rbp), %rdi
callq 0x21f0
movl -0x3c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/insert_to_mysql.c
// Function: insert_to_mysql
int insert_to_mysql(const char* mysql_oper,MYSQL* connect)
{
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x4299
movq -0x18(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x2dfd(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x42a0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/is_match.c
// Function: is_match
int is_match(const char* user_name,const char* user_passwd,MYSQL* connect)
{
    char sha512[256] = {0};
    strcpy(sha512,"$6$");
    char mysql_oper[256];
    sprintf(mysql_oper,"select salt,cryptpasswd from User where user_name='%s'",user_name);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    MYSQL_ROW row;
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    row = mysql_fetch_row(res);
    sprintf(sha512 + 3,"%s",row[0]);
    void* crypt_add = NULL;
    int crypt_size = 0;
    crypt_ra(user_passwd,sha512,&crypt_add,&crypt_size);
    int len = strlen(sha512) + 1;
    sha512[len - 1] = '$';
    sprintf(sha512 + len,"%s",row[1]);
    mysql_free_result(res);
    int ret = strcmp(sha512,(const char*)crypt_add);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
leaq -0x120(%rbp), %rdi
xorl %esi, %esi
movl $0x100, %edx            # imm = 0x100
callq 0x2140
leaq -0x120(%rbp), %rdi
leaq 0x306f(%rip), %rsi      # 0x7357
callq 0x21c0
leaq -0x220(%rbp), %rdi
movq -0x10(%rbp), %rdx
leaq 0x3218(%rip), %rsi      # 0x7517
movb $0x0, %al
callq 0x2070
movq -0x20(%rbp), %rdi
leaq -0x220(%rbp), %rsi
callq 0x2150
movl %eax, -0x224(%rbp)
cmpl $0x0, -0x224(%rbp)
je 0x434b
movq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x2d4e(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x4445
movq -0x20(%rbp), %rdi
callq 0x2350
movq %rax, -0x238(%rbp)
movq -0x238(%rbp), %rdi
callq 0x2200
movq %rax, -0x230(%rbp)
leaq -0x120(%rbp), %rdi
addq $0x3, %rdi
movq -0x230(%rbp), %rax
movq (%rax), %rdx
leaq 0x2fb3(%rip), %rsi      # 0x733d
movb $0x0, %al
callq 0x2070
movq $0x0, -0x240(%rbp)
movl $0x0, -0x244(%rbp)
movq -0x18(%rbp), %rdi
leaq -0x120(%rbp), %rsi
leaq -0x240(%rbp), %rdx
leaq -0x244(%rbp), %rcx
callq 0x2240
leaq -0x120(%rbp), %rdi
callq 0x20d0
addq $0x1, %rax
movl %eax, -0x248(%rbp)
movl -0x248(%rbp), %eax
subl $0x1, %eax
cltq
movb $0x24, -0x120(%rbp,%rax)
leaq -0x120(%rbp), %rdi
movslq -0x248(%rbp), %rax
addq %rax, %rdi
movq -0x230(%rbp), %rax
movq 0x8(%rax), %rdx
leaq 0x2f2d(%rip), %rsi      # 0x733d
movb $0x0, %al
callq 0x2070
movq -0x238(%rbp), %rdi
callq 0x21f0
leaq -0x120(%rbp), %rdi
movq -0x240(%rbp), %rsi
callq 0x2290
movl %eax, -0x24c(%rbp)
movl -0x24c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/query.c
// Function: query
MYSQL_RES* query(char* mysql_oper,MYSQL* connect)
{
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return NULL;
    }
    MYSQL_RES* res;
    res = mysql_use_result(connect);
    return res;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5a2a
movq -0x18(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x166d(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x5a3f
movq -0x18(%rbp), %rdi
callq 0x2350
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/query2.c
// Function: query2
MYSQL_RES* query2(char* mysql_oper,MYSQL* connect)
{
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return NULL;
    }
    return mysql_store_result(connect);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x5a9a
movq -0x18(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0x15fd(%rip), %rdi      # 0x7086
movb $0x0, %al
callq 0x2040
movq $0x0, -0x8(%rbp)
jmp 0x5aa7
movq -0x18(%rbp), %rdi
callq 0x2130
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_init
void que_init(que_t* p_queue,int queue_capacity)
{
    p_queue->que_capacity = queue_capacity;
    p_queue->head = NULL;
    p_queue->tail = NULL;
    p_queue->que_size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_push
int que_push(que_t* p_queue,int client_fd,int ctl_no)
{
    if(p_queue->que_size == p_queue->que_capacity)
        return -1;
    struct Queue_node* new_node = (struct Queue_node*)malloc(sizeof(struct Queue_node));
    memset(new_node,0,sizeof(struct Queue_node));
    new_node->client_fd = client_fd;
    new_node->ctl_no = ctl_no;
    if(p_queue->que_size == 0)
    {
        p_queue->head = new_node;
        p_queue->tail = new_node;
    }
    else
    {
        p_queue->tail->next = new_node;
        p_queue->tail = new_node;
    }
    p_queue->que_size++;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x5b2d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5bb2
movl $0x10, %edi
callq 0x2250
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x2140
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x5b82
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x5b9e
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_pop
int que_pop(que_t* p_queue,struct Queue_node** pop_node)
{
    if(p_queue->que_size == 0)
        return -1;
    *pop_node = p_queue->head;
    p_queue->head = p_queue->head->next;
    p_queue->que_size--;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x5bdf
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5c16
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/queue.c
// Function: que_free
void que_free(que_t* p_queue)
{
    if(p_queue->que_size == 0)
        return;
    for(int i = 0;i < p_queue->que_size; ++i)
    {
        struct Queue_node* node = p_queue->head;
        p_queue->head = p_queue->head->next;
        free(node);
    }
    p_queue->head = p_queue->tail = NULL;
    p_queue->que_size = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x5c38
jmp 0x5ca2
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x5c7f
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdi
callq 0x2220
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x5c3f
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/recv_n_bytes.c
// Function: recv_n_bytes
int recv_n_bytes(int fd,void* buf,int len)
{
    int total = 0;
    int ret;
    while(total < len)
    {
        ret = recv(fd,(char*)buf + total,len - total,MSG_WAITALL);
        if(ret == 0)
        {
            printf("server disconnected!\n");
            return -1;
        }
        total += ret;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x5d8d
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x18(%rbp), %rax
addq %rax, %rsi
movl -0x14(%rbp), %eax
subl -0x18(%rbp), %eax
movslq %eax, %rdx
movl $0x100, %ecx            # imm = 0x100
callq 0x20b0
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x5d82
leaq 0x1804(%rip), %rdi      # 0x7576
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5d94
movl -0x1c(%rbp), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
jmp 0x5d39
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/recv_user_file.c
// Function: recv_user_file
int recv_user_file(int client_fd,int file_fd,off_t file_size)
{
    int total = 0;
    int pipefd[2];
    int ret = pipe(pipefd);
    ERROR_CHECK(ret,-1,"pipe");
    while(total < file_size)
    {
        ret = splice(client_fd,NULL,pipefd[1],NULL,4096,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        ret = splice(pipefd[0],NULL,file_fd,NULL,ret,SPLICE_F_MOVE|SPLICE_F_MORE);
        ERROR_CHECK(ret,-1,"splice");
        total += ret;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
leaq -0x24(%rbp), %rdi
callq 0x2270
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x5de3
leaq 0x17ba(%rip), %rdi      # 0x758c
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e7e
jmp 0x5de5
movslq -0x1c(%rbp), %rax
cmpq -0x18(%rbp), %rax
jge 0x5e77
movl -0x8(%rbp), %edi
movl -0x20(%rbp), %edx
xorl %eax, %eax
movl %eax, %ecx
movl $0x1000, %r8d           # imm = 0x1000
movl $0x5, %r9d
movq %rcx, %rsi
callq 0x20f0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x5e2f
leaq 0x1770(%rip), %rdi      # 0x7591
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e7e
movl -0x24(%rbp), %edi
movl -0xc(%rbp), %edx
movslq -0x28(%rbp), %r8
xorl %eax, %eax
movl %eax, %ecx
movl $0x5, %r9d
movq %rcx, %rsi
callq 0x20f0
movl %eax, -0x28(%rbp)
cmpl $-0x1, -0x28(%rbp)
jne 0x5e69
leaq 0x1736(%rip), %rdi      # 0x7591
callq 0x2190
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x5e7e
movl -0x28(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
jmp 0x5de5
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/VeeeectorPan[P]MyNetdisk/SourceFile/update_user_table.c
// Function: update_user_table
int update_user_table(char* mysql_oper,int user_id,int file_id,MYSQL* connect)
{
    sprintf(mysql_oper,"update User set dir_id=%d where user_id=%d;",file_id,user_id);
    int queryResult = mysql_query(connect,mysql_oper);
    if(queryResult)
    {
        printf("%s\n",mysql_error(connect));
        return -1;
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x18(%rbp), %edx
movl -0x14(%rbp), %ecx
leaq 0x10bc(%rip), %rsi      # 0x7623
movb $0x0, %al
callq 0x2070
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2150
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x65a7
movq -0x20(%rbp), %rdi
callq 0x20c0
movq %rax, %rsi
leaq 0xaef(%rip), %rdi       # 0x7086
movb $0x0, %al
callq 0x2040
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x65ae
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)