LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: seg_more
static void
seg_more (int len)
{
    if (optv > 3) {
        printf ("seg_more (+%d (0%04o))\n", len, len);
    }

    if (nsegments) {
        segments [nsegments - 1].nwords += len;
    } else {
        fprintf (stderr, "%s:  seg_more called with no segments in existence\n", progname);
        exit (EXIT_FAILURE);
    }
}

// Assembly:
pushq %rax
cmpl $0x4, 0x8ac2(%rip)      # 0xcf30
jl 0x4488
leaq 0x227f(%rip), %rdi      # 0x66f6
movl $0x1, %esi
movl $0x1, %edx
xorl %eax, %eax
callq 0x30c0
movslq 0xcab9(%rip), %rax      # 0x10f48
testq %rax, %rax
je 0x44a2
movq 0xcaa5(%rip), %rcx      # 0x10f40
incw -0x2(%rcx,%rax,4)
popq %rax
retq
callq 0x34a8
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/d8tape/main.c
// Function: seg_add
static void
seg_add (uint16_t addr, int len)
{
    if (optv > 3) {
        printf ("seg_add (0%04o, %d (0%04o))\n", addr, len, len);
    }

    segments = realloc (segments, (nsegments + 1) * sizeof (segments [0]));
    if (segments == NULL) {
        fprintf (stderr, "%s:  couldn't realloc segments array to be %d elements (%ld bytes) long, errno %d (%s)\n", progname, nsegments + 1, (unsigned long)(nsegments + 1) * sizeof (segments [0]), errno, strerror (errno));
        exit (EXIT_FAILURE);
    }
    segments [nsegments].saddr = addr;
    segments [nsegments].nwords = len;
    nsegments++;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %edi, %ebp
cmpl $0x4, 0x8a7b(%rip)      # 0xcf30
jl 0x44cc
movzwl %bp, %esi
leaq 0x2281(%rip), %rdi      # 0x6742
movl %ebx, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x30c0
movq 0xca6d(%rip), %rdi      # 0x10f40
movslq 0xca6e(%rip), %rax      # 0x10f48
leaq 0x4(,%rax,4), %rsi
callq 0x3150
movq %rax, 0xca52(%rip)      # 0x10f40
testq %rax, %rax
je 0x4513
movslq 0xca4e(%rip), %rcx      # 0x10f48
movw %bp, (%rax,%rcx,4)
movw %bx, 0x2(%rax,%rcx,4)
leal 0x1(%rcx), %eax
movl %eax, 0xca3c(%rip)      # 0x10f48
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
callq 0x34d0
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: fetch_iot
int
fetch_iot (int code, char *dis, char *com)
{
    int     i;

    for (i = 0; i < sizeof (iots) / sizeof (iots [0]); i++) {
        if (code == iots [i].code) {
            if (dis) {
                strcpy (dis, iots [i].mnemonic);
            }
            if (com) {
                strncpy (com, iots [i].comment, COMLEN - 1);
            }
            return (1);
        }
    }
    if (dis) {
        sprintf (dis, "%04o", code);
    }
    if (com) {
        sprintf (com, "unknown IOT");
    }
    return (0);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %edi, %edx
movl $0x18, %r14d
leaq 0x6b81(%rip), %r15      # 0xc120
cmpl %edx, -0x18(%r14,%r15)
je 0x55e9
addq $0x20, %r14
cmpq $0xdf8, %r14            # imm = 0xDF8
jne 0x559f
testq %rsi, %rsi
je 0x55cc
leaq 0x43da(%rip), %rax      # 0x9999
movq %rsi, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x31a0
xorl %ebp, %ebp
testq %rbx, %rbx
je 0x5619
movabsq $0x206e776f6e6b6e75, %rax # imm = 0x206E776F6E6B6E75
movq %rax, (%rbx)
movl $0x544f49, 0x8(%rbx)    # imm = 0x544F49
jmp 0x5619
testq %rsi, %rsi
je 0x55fe
movq -0x8(%r14,%r15), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x3080
movl $0x1, %ebp
testq %rbx, %rbx
je 0x5619
movq (%r14,%r15), %rsi
movl $0x24, %edx
movq %rbx, %rdi
callq 0x3070
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: pad
static void
pad (char *buf, int loc, int pos)
{
    for (; *buf; buf++) {
        if (*buf == '\t') {
            if ((loc & 3) == 0) {
                loc += 4;
            } else {
                loc += 4 - (loc & ~3);
            }
        } else {
            loc++;
        }
    }

    loc = pos / 4 - loc / 4;
    while (loc--) {
        *buf++ = '\t';
    }
    *buf = 0;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x1(%rbx), %rax
movzbl (%rbx), %ecx
cmpl $0x9, %ecx
je 0x5644
testl %ecx, %ecx
je 0x565d
incl %esi
movq %rax, %rbx
jmp 0x562d
movl %esi, %ecx
andl $0x3, %ecx
je 0x5655
orl $0x4, %ecx
movq %rax, %rbx
movl %ecx, %esi
jmp 0x562d
addl $0x4, %esi
movq %rax, %rbx
jmp 0x562d
shrl $0x2, %edx
leal 0x3(%rsi), %eax
testl %esi, %esi
cmovnsl %esi, %eax
sarl $0x2, %eax
subl %eax, %edx
je 0x5688
leal -0x1(%rdx), %r14d
movl %edx, %edx
movq %rbx, %rdi
movl $0x9, %esi
callq 0x30d0
addq %r14, %rbx
incq %rbx
movb $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/AK6DN[P]dec-utilities-for-pdp/d8tape/dasm.c
// Function: disassemble
void
disassemble (void)
{
    int     snum;

    header ();
    for (snum = 0; snum < nsegments; snum++) {
        printf ("\n*%04o\n", segments [snum].saddr);
        disassemble_range (segments [snum].saddr, segments [snum].saddr + segments [snum].nwords);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x3130
movq %rbx, %rdi
callq 0x3050
movq %rax, %r13
xorl %eax, %eax
leaq 0x787e(%rip), %r15      # 0xcf40
leaq 0x9877(%rip), %rcx      # 0xef40
xorl %ebp, %ebp
xorl %ebx, %ebx
xorl %r14d, %r14d
cmpw $0x0, (%r15,%rax,2)
js 0x56e7
incl %r14d
testb $0x1, (%rcx,%rax,2)
jne 0x56e5
incl %ebp
jmp 0x56e7
incl %ebx
incq %rax
cmpq $0x1000, %rax           # imm = 0x1000
jne 0x56d0
leaq 0xb857(%rip), %r12      # 0x10f50
movq (%r12), %rsi
leaq 0x42be(%rip), %rdi      # 0x99c2
xorl %eax, %eax
callq 0x30c0
leaq 0x45a4(%rip), %rdi      # 0x9cb6
callq 0x3090
leaq 0x3f93(%rip), %rdi      # 0x96b1
callq 0x3090
movq (%r12), %rsi
leaq 0x42c3(%rip), %rdi      # 0x99f1
xorl %eax, %eax
callq 0x30c0
movl $0x76c, %esi            # imm = 0x76C
addl 0x14(%r13), %esi
movl 0x10(%r13), %edx
incl %edx
movl 0xc(%r13), %ecx
movl 0x8(%r13), %r8d
movl (%r13), %eax
movl 0x4(%r13), %r9d
movl %eax, (%rsp)
leaq 0x42b2(%rip), %rdi      # 0x9a10
xorl %eax, %eax
callq 0x30c0
leaq 0x7794(%rip), %rax      # 0xcf00
movq (%rax), %rsi
leaq 0x42c5(%rip), %rdi      # 0x9a3b
xorl %eax, %eax
callq 0x30c0
leaq 0x4359(%rip), %rdi      # 0x9add
callq 0x3090
leaq 0x3f21(%rip), %r12      # 0x96b1
movq %r12, %rdi
callq 0x3090
leaq 0x4380(%rip), %rdi      # 0x9b1f
callq 0x3090
leaq 0x4385(%rip), %rdi      # 0x9b30
callq 0x3090
leaq 0x43af(%rip), %rdi      # 0x9b66
callq 0x3090
leaq 0x43c6(%rip), %rdi      # 0x9b89
callq 0x3090
leaq 0x43e2(%rip), %rdi      # 0x9bb1
callq 0x3090
leaq 0x4400(%rip), %rdi      # 0x9bdb
callq 0x3090
leaq 0x4420(%rip), %rdi      # 0x9c07
callq 0x3090
movq %r12, %rdi
callq 0x3090
leaq 0x4424(%rip), %rdi      # 0x9c1f
callq 0x3090
leaq 0x4421(%rip), %rdi      # 0x9c28
callq 0x3090
leaq 0x4437(%rip), %rdi      # 0x9c4a
callq 0x3090
leaq 0x4450(%rip), %rdi      # 0x9c6f
callq 0x3090
movq %r12, %rdi
callq 0x3090
leaq 0x422a(%rip), %rdi      # 0x9a5d
movl %r14d, %esi
movl %ebp, %edx
movl %ebx, %ecx
xorl %eax, %eax
callq 0x30c0
leaq 0x446e(%rip), %rdi      # 0x9cb6
callq 0x3090
leaq 0xb6f4(%rip), %rax      # 0x10f48
cmpl $0x0, (%rax)
jle 0x58b6
leaq 0xb6e0(%rip), %r13      # 0x10f40
leaq 0x412a(%rip), %rbx      # 0x9991
xorl %ebp, %ebp
movq (%r13), %rax
movzwl (%rax,%rbp,4), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x30c0
movq (%r13), %rax
movzwl 0x2(%rax,%rbp,4), %r12d
testq %r12, %r12
je 0x58a4
movzwl (%rax,%rbp,4), %r14d
movzwl (%r15,%r14,2), %esi
movl %r14d, %edi
callq 0x4518
incq %r14
decq %r12
jne 0x588f
incq %rbp
leaq 0xb69a(%rip), %rax      # 0x10f48
movslq (%rax), %rax
cmpq %rax, %rbp
jl 0x5869
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_19/reverse.c
// Function: main
int main(void)
{
  int len;
  char line[MAXLINE];

  while ((len = get_line(line, MAXLINE)) > 0)
  {
    reverse(line);
    printf("%s", line);
  }

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x3e8, %rsp            # imm = 0x3E8
movq %rsp, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11a4
testl %eax, %eax
jle 0x1197
movq %rsp, %rbx
leaq 0xe93(%rip), %r14       # 0x2004
movq %rbx, %rdi
callq 0x121d
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1030
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11a4
testl %eax, %eax
jg 0x1171
xorl %eax, %eax
addq $0x3e8, %rsp            # imm = 0x3E8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_19/reverse.c
// Function: get_line
int get_line(char line[], int max_line_len)
{
  int c, i;

  i = 0;
  while (i < max_line_len - 1 && (c = getchar()) != EOF && c != '\n')
  {
    line[i] = c;
    ++i;
  }

  // flush out input stream if exceeding max_line_len limit
  while (i >= max_line_len - 1 && (c = getchar()) != '\n')
    ;

  if (c == '\n')
  {
    line[i] = '\n';
    ++i;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x2, %esi
jl 0x11f8
movl %esi, %ebp
decl %ebp
movl %ebp, %r15d
movb $0x1, %r14b
xorl %r12d, %r12d
callq 0x1040
cmpl $-0x1, %eax
je 0x11e5
cmpl $0xa, %eax
je 0x11e5
movb %al, (%rbx,%r12)
incq %r12
cmpq %r15, %r12
setb %r14b
jne 0x11c4
jmp 0x11e8
movl %r12d, %ebp
testb $0x1, %r14b
je 0x11f5
cmpl $0xa, %eax
je 0x1205
jmp 0x120d
movl %ebp, %r14d
callq 0x1040
cmpl $0xa, %eax
jne 0x11f8
movl %r14d, %ebp
movl %ebp, %eax
movb $0xa, (%rbx,%rax)
incl %ebp
movslq %ebp, %rax
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_1/exercise_1_19/reverse.c
// Function: reverse
void reverse(char line[])
{
  int i_front = 0;
  int i_back = length(line);
  char temp;

  if(line[i_back - 1] == '\n')
  {
    i_back -= 2;
  }
  else
  {
    i_back -= 1;
  }
  
  while (i_back > i_front)
  {
    temp = line[i_front];
    line[i_front] = line[i_back];
    line[i_back] = temp;

    ++i_front;
    --i_back;
  }
}

// Assembly:
movl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
movq %rdi, %rcx
incl %eax
cmpb $0x0, (%rcx)
leaq 0x1(%rcx), %rcx
jne 0x1225
leal 0x1(%rax), %ecx
movslq %ecx, %rcx
cmpb $0xa, (%rdi,%rcx)
cmovel %eax, %ecx
testl %ecx, %ecx
jle 0x1267
movl %ecx, %eax
movl $0x1, %ecx
movb -0x1(%rdi,%rcx), %dl
movb (%rdi,%rax), %sil
movb %sil, -0x1(%rdi,%rcx)
movb %dl, (%rdi,%rax)
decq %rax
leaq 0x1(%rcx), %rdx
cmpq %rcx, %rax
movq %rdx, %rcx
jg 0x1248
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/bseq.c
// Function: bseq_open
bseq_file_t *bseq_open(const char *fn)
{
	bseq_file_t *fp;
	gzFile f;
	f = fn && strcmp(fn, "-")? gzopen(fn, "r") : gzdopen(fileno(stdin), "r");
	if (f == 0) return 0;
	fp = (bseq_file_t*)calloc(1, sizeof(bseq_file_t));
	fp->fp = f;
	fp->ks = kseq_init(fp->fp);
	return fp;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x33da
cmpb $0x2d, (%rdi)
jne 0x33cc
cmpb $0x0, 0x1(%rdi)
je 0x33da
leaq 0x5355(%rip), %rsi      # 0x8728
callq 0x2230
jmp 0x33f7
movq 0x7be7(%rip), %rax      # 0xafc8
movq (%rax), %rdi
callq 0x21a0
leaq 0x5338(%rip), %rsi      # 0x8728
movl %eax, %edi
callq 0x20a0
movq %rax, %rbx
testq %rax, %rax
je 0x345d
movl $0x1, %edi
movl $0x18, %esi
callq 0x2150
movq %rax, %r14
movq %rbx, 0x8(%rax)
movl $0x1, %edi
movl $0x50, %esi
callq 0x2150
movq %rax, %r15
movl $0x1, %edi
movl $0x20, %esi
callq 0x2150
movq %rax, %r12
movq %rbx, 0x10(%rax)
movl $0x10000, 0x8(%rax)     # imm = 0x10000
movl $0x4000, %edi           # imm = 0x4000
callq 0x21e0
movq %rax, 0x18(%r12)
movq %r12, 0x48(%r15)
movq %r15, 0x10(%r14)
jmp 0x3460
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/index.c
// Function: mm_idx_destroy
void mm_idx_destroy(mm_idx_t *mi)
{
	int i;
	if (mi == 0) return;
	for (i = 0; i < 1<<mi->b; ++i) {
		free(mi->B[i].p);
		free(mi->B[i].a.a);
		kh_destroy(idx, (idxhash_t*)mi->B[i].h);
	}
	free(mi->B);
	if (mi->name)
		for (i = 0; i < mi->n; ++i) free(mi->name[i]);
	free(mi->len); free(mi->name);
	free(mi);
}

// Assembly:
testq %rdi, %rdi
je 0x3cda
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x1f, (%rdi)
je 0x3c84
xorl %r15d, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movq 0x20(%rax,%r15), %rdi
callq 0x2040
movq 0x10(%rbx), %rax
movq 0x10(%rax,%r15), %rdi
callq 0x2040
movq 0x10(%rbx), %rax
movq 0x28(%rax,%r15), %r14
testq %r14, %r14
je 0x3c6d
movq 0x18(%r14), %rdi
callq 0x2040
movq 0x10(%r14), %rdi
callq 0x2040
movq 0x20(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movb (%rbx), %cl
movl $0x1, %eax
shll %cl, %eax
incq %r12
cltq
addq $0x30, %r15
cmpq %rax, %r12
jl 0x3c20
movq 0x10(%rbx), %rdi
callq 0x2040
cmpq $0x0, 0x28(%rbx)
je 0x3cb5
cmpl $0x0, 0xc(%rbx)
je 0x3cb5
xorl %r14d, %r14d
movq 0x28(%rbx), %rax
movq (%rax,%r14,8), %rdi
callq 0x2040
incq %r14
movl 0xc(%rbx), %eax
cmpq %rax, %r14
jb 0x3c9d
movq 0x20(%rbx), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/index.c
// Function: mm_idx_get
const uint64_t *mm_idx_get(const mm_idx_t *mi, uint64_t minier, int *n)
{
	int mask = (1<<mi->b) - 1;
	khint_t k;
	mm_idx_bucket_t *b = &mi->B[minier&mask];
	idxhash_t *h = (idxhash_t*)b->h;
	*n = 0;
	if (h == 0) return 0;
	k = kh_get(idx, h, minier>>mi->b<<1);
	if (k == kh_end(h)) return 0;
	if (kh_key(h, k)&1) {
		*n = 1;
		return &kh_val(h, k);
	} else {
		*n = (uint32_t)kh_val(h, k);
		return &b->p[kh_val(h, k)>>32];
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movb (%rdi), %cl
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
shll %cl, %eax
notl %eax
movq 0x10(%rdi), %r8
movl %esi, %ecx
andl %eax, %ecx
leaq (%rcx,%rcx,2), %r10
shlq $0x4, %r10
movq 0x28(%r8,%r10), %r9
movl $0x0, (%rdx)
xorl %eax, %eax
testq %r9, %r9
je 0x3dc5
movl (%r9), %r11d
testl %r11d, %r11d
je 0x3d87
movb (%rdi), %cl
shrq %cl, %rsi
movq %rsi, %rdi
btrq $0x3f, %rdi
leal -0x1(%r11), %ebx
andl %ebx, %esi
movq 0x10(%r9), %r14
movl $0x1, %ebp
movl %esi, %eax
movl %eax, %ecx
shrl $0x4, %ecx
movl (%r14,%rcx,4), %r15d
leal (%rax,%rax), %ecx
andl $0x1e, %ecx
movl %r15d, %r12d
shrl %cl, %r12d
testb $0x2, %r12b
jne 0x3d7c
testb $0x1, %r12b
jne 0x3d70
movq 0x18(%r9), %r12
movl %eax, %r13d
movq (%r12,%r13,8), %r12
shrq %r12
cmpq %rdi, %r12
je 0x3d7c
addl %ebp, %eax
andl %ebx, %eax
incl %ebp
cmpl %esi, %eax
jne 0x3d3c
jmp 0x3d8c
shrl %cl, %r15d
testb $0x3, %r15b
cmovnel %r11d, %eax
cmpl %r11d, %eax
jne 0x3d90
xorl %eax, %eax
jmp 0x3dc5
movq 0x18(%r9), %rcx
movl %eax, %eax
testb $0x1, (%rcx,%rax,8)
jne 0x3db7
addq %r10, %r8
movq 0x20(%r9), %rcx
movq (%rcx,%rax,8), %rax
movl %eax, (%rdx)
shrq $0x1d, %rax
andq $-0x8, %rax
addq 0x20(%r8), %rax
jmp 0x3dc5
movl $0x1, (%rdx)
shlq $0x3, %rax
addq 0x20(%r9), %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/index.c
// Function: mm_idx_cal_max_occ
uint32_t mm_idx_cal_max_occ(const mm_idx_t *mi, float f)
{
	int i;
	size_t n = 0;
	uint32_t thres;
	khint_t *a, k;
	if (f <= 0.) return UINT32_MAX;
	for (i = 0; i < 1<<mi->b; ++i)
		if (mi->B[i].h) n += kh_size((idxhash_t*)mi->B[i].h);
	a = (uint32_t*)malloc(n * 4);
	for (i = n = 0; i < 1<<mi->b; ++i) {
		idxhash_t *h = (idxhash_t*)mi->B[i].h;
		if (h == 0) continue;
		for (k = 0; k < kh_end(h); ++k) {
			if (!kh_exist(h, k)) continue;
			a[n++] = kh_key(h, k)&1? 1 : (uint32_t)kh_val(h, k);
		}
	}
	thres = ks_ksmall_uint32_t(n, a, (uint32_t)((1. - f) * n)) + 1;
	free(a);
	return thres;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
xorps %xmm1, %xmm1
ucomiss %xmm0, %xmm1
jae 0x3f4b
movq %rdi, %r14
cvtss2sd %xmm0, %xmm0
movl (%rdi), %ebp
movl $0x1, %edx
movl $0x1, %r15d
movl %ebp, %ecx
shll %cl, %r15d
cmpl $0x1f, %ebp
movsd %xmm0, (%rsp)
jne 0x3e22
xorl %r14d, %r14d
xorl %edi, %edi
callq 0x21e0
movsd (%rsp), %xmm2
movq %rax, %rbx
jmp 0x3efc
movq 0x10(%r14), %rax
cmpl $0x2, %r15d
cmovgel %r15d, %edx
shlq $0x4, %rdx
leaq (%rdx,%rdx,2), %rcx
xorl %edx, %edx
xorl %edi, %edi
movq 0x28(%rax,%rdx), %rsi
testq %rsi, %rsi
je 0x3e4a
movl 0x4(%rsi), %esi
addq %rsi, %rdi
addq $0x30, %rdx
cmpq %rdx, %rcx
jne 0x3e3a
shlq $0x2, %rdi
callq 0x21e0
movq %rax, %rbx
cmpl $0x1f, %ebp
jne 0x3e71
xorl %r14d, %r14d
movsd (%rsp), %xmm2
jmp 0x3efc
movq 0x10(%r14), %rax
cmpl $0x2, %r15d
movl $0x1, %edx
cmovgel %r15d, %edx
xorl %esi, %esi
xorl %r14d, %r14d
movsd (%rsp), %xmm2
leaq (%rsi,%rsi,2), %rcx
shlq $0x4, %rcx
movq 0x28(%rax,%rcx), %rdi
testq %rdi, %rdi
je 0x3ef4
movl (%rdi), %r8d
testq %r8, %r8
je 0x3ef4
movq 0x10(%rdi), %r9
xorl %r10d, %r10d
xorl %r11d, %r11d
movq %r11, %rcx
shrq $0x4, %rcx
movl (%r9,%rcx,4), %ebp
movl %r10d, %ecx
andb $0x1e, %cl
shrl %cl, %ebp
testb $0x3, %bpl
jne 0x3ee8
movq 0x18(%rdi), %r15
movl $0x1, %ecx
testb $0x1, (%r15,%r11,8)
jne 0x3ee1
movq 0x20(%rdi), %rcx
movl (%rcx,%r11,8), %ecx
movl %ecx, (%rbx,%r14,4)
incq %r14
incq %r11
addl $0x2, %r10d
cmpq %r8, %r11
jb 0x3eb0
incq %rsi
cmpq %rdx, %rsi
jne 0x3e8c
movsd 0x482c(%rip), %xmm0     # 0x8730
movq %r14, %xmm1
punpckldq 0x483f(%rip), %xmm1 # xmm1 = xmm1[0],mem[0],xmm1[1],mem[1]
subpd 0x4847(%rip), %xmm1     # 0x8760
subsd %xmm2, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
addsd %xmm1, %xmm2
mulsd %xmm0, %xmm2
cvttsd2si %xmm2, %rax
movl %eax, %edx
movq %r14, %rdi
movq %rbx, %rsi
callq 0x32dc
movl %eax, %ebp
incl %ebp
movq %rbx, %rdi
callq 0x2040
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/index.c
// Function: mm_idx_gen
mm_idx_t *mm_idx_gen(bseq_file_t *fp, int w, int k, int b, int tbatch_size, int n_threads, uint64_t ibatch_size, int keep_name)
{
	pipeline_t pl;
	memset(&pl, 0, sizeof(pipeline_t));
	pl.tbatch_size = tbatch_size;
	pl.keep_name = keep_name;
	pl.ibatch_size = ibatch_size;
	pl.fp = fp;
	if (pl.fp == 0) return 0;
	pl.mi = mm_idx_init(w, k, b);

	kt_pipeline(n_threads < 3? n_threads : 3, worker_pipeline, &pl, 3);
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s::%.3f*%.2f] collected minimizers\n", __func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0));

	mm_idx_post(pl.mi, n_threads);
	if (mm_verbose >= 3)
		fprintf(stderr, "[M::%s::%.3f*%.2f] sorted minimizers\n", __func__, realtime() - mm_realtime0, cputime() / (realtime() - mm_realtime0));

	return pl.mi;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %r9d, %ebx
movq 0x50(%rsp), %rax
movl 0x58(%rsp), %r9d
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movl %r8d, (%rsp)
movl %r9d, 0x8(%rsp)
movq %rax, 0x18(%rsp)
movq %rdi, 0x10(%rsp)
testq %rdi, %rdi
je 0x4013
movl %esi, %edi
movl %edx, %esi
movl %ecx, %edx
callq 0x3b98
movq %rsp, %rdx
movq %rax, 0x28(%rdx)
cmpl $0x3, %ebx
movl $0x3, %edi
cmovll %ebx, %edi
leaq 0x5b(%rip), %rsi        # 0x402b
movl $0x3, %ecx
callq 0x6a14
leaq 0x71af(%rip), %r14      # 0xb190
cmpl $0x3, (%r14)
jge 0x401d
movq 0x28(%rsp), %rdx
movb (%rdx), %cl
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rcx
leaq 0xc57(%rip), %rsi       # 0x4c56
movl %ebx, %edi
callq 0x6870
cmpl $0x3, (%r14)
jge 0x4024
movq 0x28(%rsp), %rax
jmp 0x4015
xorl %eax, %eax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
callq 0x264f
jmp 0x3fe7
callq 0x26bc
jmp 0x400c
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/index.c
// Function: mm_idx_build
mm_idx_t *mm_idx_build(const char *fn, int w, int k, int n_threads) // a simpler interface
{
	bseq_file_t *fp;
	mm_idx_t *mi;
	fp = bseq_open(fn);
	if (fp == 0) return 0;
	mi = mm_idx_gen(fp, w, k, MM_IDX_DEF_B, 1<<18, n_threads, UINT64_MAX, 1);
	mm_idx_set_max_occ(mi, 0.001);
	bseq_close(fp);
	return mi;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
callq 0x33b4
testq %rax, %rax
je 0x43c1
movq %rax, %rbx
movq %rax, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl $0xe, %ecx
movl $0x40000, %r8d          # imm = 0x40000
movl %ebp, %r9d
pushq $0x1
pushq $-0x1
callq 0x3f6b
addq $0x10, %rsp
movq %rax, %r14
movl $0x3a83126f, 0x1c(%rax) # imm = 0x3A83126F
movss 0x3c59(%rip), %xmm0     # 0x8004
movq %rax, %rdi
callq 0x3dd0
movl %eax, 0x18(%r14)
movq %rbx, %rdi
callq 0x346f
jmp 0x43c4
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/map.c
// Function: mm_tbuf_destroy
void mm_tbuf_destroy(mm_tbuf_t *b)
{
	if (b == 0) return;
	free(b->mini.a); free(b->coef.a); free(b->intv.a); free(b->reg.a); free(b->reg2mini.a); free(b->rep_aux.a);
	free(b->a); free(b->b); free(b->p);
	sdust_buf_destroy(b->sdb);
	free(b);
}

// Assembly:
testq %rdi, %rdi
je 0x4f91
pushq %rbx
movq %rdi, %rbx
movq 0x10(%rdi), %rdi
callq 0x2040
movq 0x28(%rbx), %rdi
callq 0x2040
movq 0x40(%rbx), %rdi
callq 0x2040
movq 0xb0(%rbx), %rdi
callq 0x2040
movq 0x58(%rbx), %rdi
callq 0x2040
movq 0x70(%rbx), %rdi
callq 0x2040
movq 0x88(%rbx), %rdi
callq 0x2040
movq 0x90(%rbx), %rdi
callq 0x2040
movq 0x98(%rbx), %rdi
callq 0x2040
movq 0x78(%rbx), %rdi
callq 0x734d
movq %rbx, %rdi
popq %rbx
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/map.c
// Function: mm_map_file
int mm_map_file(const mm_idx_t *idx, const char *fn, const mm_mapopt_t *opt, int n_threads, int tbatch_size)
{
	pipeline_t pl;
	memset(&pl, 0, sizeof(pipeline_t));
	pl.fp = bseq_open(fn);
	if (pl.fp == 0) return -1;
	pl.opt = opt, pl.mi = idx;
	pl.n_threads = n_threads, pl.batch_size = tbatch_size;
	kt_pipeline(n_threads == 1? 1 : 2, worker_pipeline, &pl, 3);
	bseq_close(pl.fp);
	return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x30, %rsp
movl %r8d, %ebp
movl %ecx, %ebx
movq %rdx, %r14
movq %rdi, %r15
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq %rsi, %rdi
callq 0x33b4
movq %rax, 0x18(%rsp)
testq %rax, %rax
je 0x6490
movq %rsp, %r12
movq %r14, 0x10(%r12)
movq %r15, 0x20(%r12)
movl %ebx, 0x8(%r12)
movl %ebp, (%r12)
xorl %edi, %edi
cmpl $0x1, %ebx
setne %dil
incl %edi
leaq 0x2d(%rip), %rsi        # 0x64a2
movq %r12, %rdx
movl $0x3, %ecx
callq 0x6a14
movq 0x18(%r12), %rdi
callq 0x346f
xorl %eax, %eax
jmp 0x6495
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/sdust.c
// Function: sdust_buf_init
sdust_buf_t *sdust_buf_init(void)
{
	sdust_buf_t *buf;
	buf = (sdust_buf_t*)calloc(1, sizeof(sdust_buf_t));
	buf->w = kdq_init(int);
	return buf;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, %edi
movl $0x38, %esi
callq 0x2150
movq %rax, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x2150
movq %rax, %r14
movabsq $0x800000000000000, %rax # imm = 0x800000000000000
movq %rax, (%r14)
movq $0x3, 0x10(%r14)
movl $0x10, %edi
callq 0x21e0
movq %rax, 0x18(%r14)
movq %r14, (%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/sdust.c
// Function: sdust_buf_destroy
void sdust_buf_destroy(sdust_buf_t *buf)
{
	if (buf == 0) return;
	kdq_destroy(int, buf->w);
	free(buf->P.a); free(buf->res.a);
	free(buf);
}

// Assembly:
testq %rdi, %rdi
je 0x7393
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x7372
movq 0x18(%r14), %rdi
callq 0x2040
movq %r14, %rdi
callq 0x2040
movq 0x18(%rbx), %rdi
callq 0x2040
movq 0x30(%rbx), %rdi
callq 0x2040
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2040
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]minimap/sdust.c
// Function: sdust
uint64_t *sdust(const uint8_t *seq, int l_seq, int T, int W, int *n)
{
	uint64_t *ret;
	sdust_buf_t *buf;
	buf = sdust_buf_init();
	ret = (uint64_t*)sdust_core(seq, l_seq, T, W, n, buf);
	buf->res.a = 0;
	sdust_buf_destroy(buf);
	return ret;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %r12
callq 0x72f4
movq %rax, %r13
movq %r12, %rdi
movl %r15d, %esi
movl %r14d, %edx
movl %ebp, %ecx
movq %rbx, %r8
movq %rax, %r9
callq 0x7394
movq %rax, %rbx
movq $0x0, 0x30(%r13)
movq %r13, %rdi
callq 0x734d
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/websocket_common.c
// Function: webSocket_serverLinkToClient(int, char*, unsigned int)
int webSocket_serverLinkToClient(int fd, char *recvBuf, unsigned int bufLen)
{
    char *p;
    int ret;
    char recvShakeKey[512], respondPackage[1024];
    if(bufLen == 0)
        return -1;

    if((p = strstr(recvBuf, "Sec-WebSocket-Key: ")) == NULL)
        return -1;
    p += strlen("Sec-WebSocket-Key: ");
    //
    memset(recvShakeKey, 0, sizeof(recvShakeKey));
    sscanf(p, "%s", recvShakeKey);      // 取得握手key
    ret = strlen(recvShakeKey);
    if(ret < 1)
        return -1;
    //
    memset(respondPackage, 0, sizeof(respondPackage));
    webSocket_buildHttpRespond((unsigned char*)recvShakeKey,(unsigned int)ret, ( char *)respondPackage);
    //
    return send(fd, respondPackage, strlen(respondPackage), MSG_NOSIGNAL);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x600, %rsp            # imm = 0x600
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
testl %edx, %edx
je 0x33b6
movl %edi, %ebx
leaq 0x1fad(%rip), %rax      # 0x52c9
movq %rsi, %rdi
movq %rax, %rsi
callq 0x2070
testq %rax, %rax
je 0x33b6
movq %rax, %r15
addq $0x13, %r15
leaq -0x220(%rbp), %r12
movl $0x200, %edx            # imm = 0x200
movq %r12, %rdi
xorl %esi, %esi
callq 0x2110
leaq 0x2074(%rip), %rsi      # 0x53c8
movq %r15, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x21f0
movq %r12, %rdi
callq 0x20f0
movq %rax, %r15
testl %r15d, %r15d
jle 0x33b6
leaq -0x620(%rbp), %r14
movl $0x400, %edx            # imm = 0x400
movq %r14, %rdi
xorl %esi, %esi
callq 0x2110
leaq -0x220(%rbp), %rdi
movl %r15d, %esi
movq %r14, %rdx
callq 0x2a58
movq %r14, %rdi
callq 0x20f0
movl %ebx, %edi
movq %r14, %rsi
movq %rax, %rdx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x2100
movq %rax, %r14
movl %r14d, %eax
addq $0x600, %rsp            # imm = 0x600
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/websocket_common.c
// Function: webSocket_send(int, unsigned char*, unsigned int, bool, Websocket_CommunicationType)
int webSocket_send(int fd, unsigned char *data, unsigned int dataLen, bool mod, Websocket_CommunicationType type)
{
    unsigned char *webSocketPackage;
    unsigned int retLen, ret;
    /* unsigned int i; */

    /* printf("webSocket_send : %d\r\n", dataLen); */
    //---------- websocket数据打包 ----------
    webSocketPackage = (unsigned char *)calloc(1, sizeof(char)*(dataLen + 128));  memset(webSocketPackage, 0, (dataLen + 128));
    retLen = webSocket_enPackage(data, dataLen, webSocketPackage, (dataLen + 128), mod, type);
    
       /* printf("webSocket_send : %d\r\n" , retLen); */
       /* for(i = 0; i < retLen; i ++)  printf("%.2X ", webSocketPackage[i]); */
       /* printf("\r\n"); */
    ret = send(fd, webSocketPackage, retLen, MSG_NOSIGNAL);
    free(webSocketPackage);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %r8d, -0x2c(%rbp)
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movl %edi, -0x30(%rbp)
leal 0x80(%r15), %r13d
movl $0x1, %edi
movq %r13, %rsi
callq 0x2150
movq %rax, %rbx
movq %r12, %rdi
movl %r15d, %esi
movq %rax, %rdx
movl %r13d, %ecx
movl %r14d, %r8d
movl -0x2c(%rbp), %r9d
callq 0x2b03
movl %eax, %edx
movl -0x30(%rbp), %edi
movq %rbx, %rsi
movl $0x4000, %ecx           # imm = 0x4000
callq 0x2100
movq %rax, %r14
movq %rbx, %rdi
callq 0x2220
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_client_main.c
// Function: main
int main(int argc, char *argv[])
{
    char inAddr[INADDR_LEN];
    int port = 0;
    struct event_base *base=NULL;
    struct bufferevent *bev=NULL;
    struct event * sig=NULL;
    struct itimerval timer_out;
    if(argc==3)
    {
        if(strlen(argv[1])>INADDR_LEN)
        {
            printf("输入长度要少于%d\r\n", INADDR_LEN);
            exit(1);
        }
        strcpy(inAddr, argv[1]);
        port =  atoi(argv[2]);
        if(port==0)
        {
            printf("端口输入错误！！\r\n");
            exit(1);
        }
    }
    else
    {
        port = SERVER_PORT;
        strcpy(inAddr, SERVERR_IP);
    }
    base = event_base_new();
    assert(base);

    bev = ev_webSocket_clientLinkToServer(base, inAddr, port,(char *)"/null",bev_read_cd,NULL,bev_event_cd,NULL);
    if(!bev)
    {
        printf("连接服务器错误!\r\n");
        exit(1);
    }
    sig =  evsignal_new(base, SIGALRM, sig_cb, bev);
    if(!sig || event_add(sig, NULL))
    {
        De_fprintf(stderr, "cold not create/add a signal event!");
    }
    else
    {
        memset(&timer_out, 0, sizeof(timer_out));
        timer_out.it_interval.tv_sec = 2;
        timer_out.it_value.tv_sec = 2;
        setitimer(ITIMER_REAL, &timer_out, NULL);
    }
    event_base_dispatch(base);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x60, %rsp
cmpl $0x3, %edi
jne 0x3e85
movq %rsi, %rbx
movq 0x8(%rsi), %r14
movq %r14, %rdi
callq 0x20f0
cmpq $0x33, %rax
jae 0x3f80
leaq -0x50(%rbp), %rdi
movq %r14, %rsi
callq 0x21c0
movq 0x10(%rbx), %rdi
callq 0x22c0
movl %eax, %r14d
testl %eax, %eax
jne 0x3e9a
leaq 0x17db(%rip), %rdi      # 0x565b
jmp 0x3f79
movups 0x169e(%rip), %xmm0     # 0x552a
movaps %xmm0, -0x50(%rbp)
movb $0x0, -0x40(%rbp)
movl $0x1f98, %r14d          # imm = 0x1F98
callq 0x22e0
testq %rax, %rax
je 0x3f53
movq %rax, %rbx
leaq 0x1e6(%rip), %rax       # 0x4098
leaq 0x16af(%rip), %rcx      # 0x5568
leaq 0xdd(%rip), %r8         # 0x3f9d
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
xorl %r9d, %r9d
pushq $0x0
pushq %rax
callq 0x3657
addq $0x10, %rsp
testq %rax, %rax
je 0x3f72
leaq 0x25c(%rip), %rcx       # 0x4145
movq %rbx, %rdi
movl $0xe, %esi
movl $0x18, %edx
movq %rax, %r8
callq 0x21a0
testq %rax, %rax
je 0x3f4c
movq %rax, %rdi
xorl %esi, %esi
callq 0x20e0
testl %eax, %eax
jne 0x3f4c
xorps %xmm0, %xmm0
leaq -0x70(%rbp), %rsi
movups %xmm0, 0x8(%rsi)
movq $0x0, 0x18(%rsi)
movl $0x2, %eax
movq %rax, (%rsi)
movq %rax, 0x10(%rsi)
xorl %edi, %edi
xorl %edx, %edx
callq 0x2290
movq %rbx, %rdi
callq 0x22a0
xorl %eax, %eax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x2435
jmp 0x3f39
leaq 0x15e1(%rip), %rdi      # 0x553b
leaq 0x15df(%rip), %rsi      # 0x5540
leaq 0x15e9(%rip), %rcx      # 0x5551
movl $0x68, %edx
callq 0x2140
leaq 0x16ca(%rip), %rdi      # 0x5643
callq 0x22b0
jmp 0x3f93
leaq 0x1589(%rip), %rdi      # 0x5510
movl $0x32, %esi
xorl %eax, %eax
callq 0x2040
movl $0x1, %edi
callq 0x2230
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_client_main.c
// Function: bev_read_cd(bufferevent*, void*)
static void bev_read_cd(struct bufferevent *bev, void *ctx)
{
    ctx = (void*)ctx;
    char buf[1024];
    int ret = ev_webSocket_recv(bev, (unsigned char*)buf, sizeof(buf));
    if(ret>0)
    {
        printf("client recv : len/%d %s\r\n", ret, buf);
        if(strstr(buf, "Hello") != NULL)
            ret = ev_webSocket_send(bev, (unsigned char *)"I am Client_Test", strlen("I am Client_Test"), true, WCT_TXTDATA);
        else if(strstr(buf, "Server_Test") != NULL)
            ret = ev_webSocket_send(bev, (unsigned char *)"I am carefree !", strlen("I am carefree !"), true, WCT_TXTDATA);
    }
    else
    {
        De_printf("断开连接!\r\n");
        event_base_loopbreak(bufferevent_get_base(bev));
        bufferevent_free(bev);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x400, %rsp            # imm = 0x400
movq %rdi, %rbx
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x3c22
testl %eax, %eax
jle 0x4002
leaq 0x15cd(%rip), %rdi      # 0x5597
leaq -0x410(%rbp), %r14
movl %eax, %esi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2040
leaq 0x15cd(%rip), %rsi      # 0x55b1
movq %r14, %rdi
callq 0x2070
testq %rax, %rax
je 0x4055
leaq 0x15bf(%rip), %rsi      # 0x55b7
movq %rbx, %rdi
movl $0x10, %edx
jmp 0x407c
leaq 0x11a2(%rip), %rdi      # 0x51ab
leaq 0x15d4(%rip), %rsi      # 0x55e4
leaq 0x1529(%rip), %rdx      # 0x5540
movl $0x29, %ecx
xorl %eax, %eax
callq 0x2040
leaq 0x164b(%rip), %rdi      # 0x5675
callq 0x22b0
leaq 0x164c(%rip), %rdi      # 0x5682
callq 0x22b0
movq %rbx, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
callq 0x20a0
jmp 0x408c
leaq 0x156c(%rip), %rsi      # 0x55c8
leaq -0x410(%rbp), %rdi
callq 0x2070
testq %rax, %rax
je 0x408c
leaq 0x1560(%rip), %rsi      # 0x55d4
movq %rbx, %rdi
movl $0xf, %edx
movl $0x1, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x3ba6
addq $0x400, %rsp            # imm = 0x400
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_client_main.c
// Function: bev_event_cd(bufferevent*, short, void*)
static void bev_event_cd(struct bufferevent *bev,short events, void *ctx)
{
    ctx = (void*)ctx;
    if(events & BEV_EVENT_EOF)
        De_printf("断开连接!\r\n");
    else if(events & BEV_EVENT_ERROR)
    {
        De_printf("Got an error on the connection:%s\r\n", strerror(errno));
    }
    event_base_loopbreak(bufferevent_get_base(bev));
    bufferevent_free(bev);

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
testb $0x10, %sil
jne 0x40ee
movzwl %si, %eax
testb $0x20, %al
je 0x4127
leaq 0x10f6(%rip), %rdi      # 0x51ab
leaq 0x1534(%rip), %rsi      # 0x55f0
leaq 0x147d(%rip), %rdx      # 0x5540
movl $0x35, %ecx
xorl %eax, %eax
callq 0x2040
callq 0x2030
movl (%rax), %edi
callq 0x20d0
leaq 0x151b(%rip), %rdi      # 0x55fd
movq %rax, %rsi
xorl %eax, %eax
callq 0x2040
jmp 0x411b
leaq 0x10b6(%rip), %rdi      # 0x51ab
leaq 0x14f4(%rip), %rsi      # 0x55f0
leaq 0x143d(%rip), %rdx      # 0x5540
movl $0x32, %ecx
xorl %eax, %eax
callq 0x2040
leaq 0x155f(%rip), %rdi      # 0x5675
callq 0x22b0
leaq 0x1560(%rip), %rdi      # 0x5682
callq 0x22b0
movq %rbx, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20a0
// File: /workspace/github_c_makefile_star2_O3/sszllzss[P]webSocket_Libevent_ThreadPool/ev_client_main.c
// Function: sig_cb(int, short, void*)
static void sig_cb(evutil_socket_t sig, short events,void *ctx)
{
    int ret;
    if(sig==SIGALRM)
    {
        struct bufferevent *bev=(struct bufferevent *)ctx;
        ret = ev_webSocket_send(bev,(unsigned char *) "#%^#@@@DTG%^&&+_)+(*^%!HHI", strlen("#%^#@@@DTG%^&&+_)+(*^%!HHI"), true, WCT_TXTDATA);
        if(ret < 0)
        {
            
            De_printf("断开连接!\r\n");
            event_base_loopbreak(bufferevent_get_base(bev));
            bufferevent_free(bev);
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
cmpl $0xe, %edi
jne 0x4176
movq %rdx, %rbx
leaq 0x14c7(%rip), %rsi      # 0x5621
movq %rdx, %rdi
movl $0x1a, %edx
movl $0x1, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x3ba6
testl %eax, %eax
js 0x417d
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
leaq 0x1027(%rip), %rdi      # 0x51ab
leaq 0x14b1(%rip), %rsi      # 0x563c
leaq 0x13ae(%rip), %rdx      # 0x5540
movl $0x45, %ecx
xorl %eax, %eax
callq 0x2040
leaq 0x14d0(%rip), %rdi      # 0x5675
callq 0x22b0
leaq 0x14d1(%rip), %rdi      # 0x5682
callq 0x22b0
movq %rbx, %rdi
callq 0x2310
movq %rax, %rdi
callq 0x2250
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20a0
// File: /workspace/github_c_makefile_star2_O3/antonblanchard[P]will-it-scale/tests/tlb_flush2.c
// Function: testcase
void testcase(unsigned long *iteration, unsigned long nr)
{
	unsigned long pgsize = getpagesize();
	unsigned long i;

	while (1) {
		char *addr = mmap(NULL, MEMORYSIZE, PROT_READ|PROT_WRITE,
						MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
		for (i = 0; i < MEMORYSIZE; i += pgsize) {
			*(addr + i) = 1;
			madvise(addr + i, pgsize, MADV_DONTNEED);
			assert(*(addr + i) == 0);
			(*iteration)++;
		}
		munmap(addr, MEMORYSIZE);
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1270
movslq %eax, %r14
movl $0x100000, %esi         # imm = 0x100000
xorl %edi, %edi
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
xorl %r9d, %r9d
callq 0x10f0
movq %rax, %r15
xorl %r12d, %r12d
leaq (%r15,%r12), %rdi
movb $0x1, (%r15,%r12)
movq %r14, %rsi
movl $0x4, %edx
callq 0x1210
cmpb $0x0, (%r15,%r12)
jne 0x1d83
incq (%rbx)
addq %r14, %r12
cmpq $0x100000, %r12         # imm = 0x100000
jb 0x1d48
movl $0x100000, %esi         # imm = 0x100000
movq %r15, %rdi
callq 0x11f0
jmp 0x1d23
leaq 0x52c(%rip), %rdi       # 0x22b6
leaq 0x536(%rip), %rsi       # 0x22c7
leaq 0x542(%rip), %rcx       # 0x22da
movl $0x1b, %edx
callq 0x1130
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/adlist.c
// Function: listDup
list *listDup(list *orig)
{
    list *copy;
    listIter *iter;
    listNode *node;

    if ((copy = listCreate()) == NULL)
        return NULL;
    copy->dup = orig->dup;
    copy->free = orig->free;
    copy->match = orig->match;
    iter = listGetIterator(orig, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {
        void *value;

        if (copy->dup) {
            value = copy->dup(node->value);
            if (value == NULL) {
                listRelease(copy);
                listReleaseIterator(iter);
                return NULL;
            }
        } else
            value = node->value;
        if (listAddNodeTail(copy, value) == NULL) {
            listRelease(copy);
            listReleaseIterator(iter);
            return NULL;
        }
    }
    listReleaseIterator(iter);
    return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %r15
movl $0x30, %edi
callq 0x1fbbd
testq %rax, %rax
je 0x167fe
movq %rax, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, (%rax)
movups 0x10(%r15), %xmm0
movups %xmm0, 0x10(%rax)
movq 0x20(%r15), %rax
movq %rax, 0x20(%rbx)
movl $0x10, %edi
callq 0x1fbbd
movq %rax, %r14
testq %rax, %rax
je 0x167aa
movq (%r15), %rax
movq %rax, (%r14)
movl $0x0, 0x8(%r14)
movq (%r14), %rax
testq %rax, %rax
je 0x167f4
xorl %ecx, %ecx
cmpl $0x0, 0x8(%r14)
sete %cl
movq (%rax,%rcx,8), %rcx
movq %rcx, (%r14)
movq 0x10(%rbx), %rcx
movq 0x10(%rax), %rax
testq %rcx, %rcx
je 0x167da
movq %rax, %rdi
callq *%rcx
testq %rax, %rax
je 0x167ea
movq %rbx, %rdi
movq %rax, %rsi
callq 0x165ab
testq %rax, %rax
jne 0x167aa
movq %rbx, %rdi
callq 0x164fc
xorl %ebx, %ebx
movq %r14, %rdi
callq 0x1fd17
jmp 0x16800
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/adlist.c
// Function: listSearchKey
listNode *listSearchKey(list *list, void *key)
{
    listIter *iter;
    listNode *node;

    iter = listGetIterator(list, AL_START_HEAD);
    while((node = listNext(iter)) != NULL) {
        if (list->match) {
            if (list->match(node->value, key)) {
                listReleaseIterator(iter);
                return node;
            }
        } else {
            if (key == node->value) {
                listReleaseIterator(iter);
                return node;
            }
        }
    }
    listReleaseIterator(iter);
    return NULL;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x10, %edi
callq 0x1fbbd
movq %rax, %rbx
testq %rax, %rax
je 0x1683d
movq (%r15), %r12
movq %r12, (%rbx)
movl $0x0, 0x8(%rbx)
testq %r12, %r12
jne 0x1683d
jmp 0x16876
xorl %eax, %eax
cmpl $0x0, 0x8(%rbx)
sete %al
movq (%r12,%rax,8), %rax
movq %rax, (%rbx)
movq 0x20(%r15), %rcx
movq 0x10(%r12), %rdi
testq %rcx, %rcx
je 0x16869
movq %r14, %rsi
callq *%rcx
testl %eax, %eax
jne 0x16879
movq (%rbx), %rax
jmp 0x1686e
cmpq %r14, %rdi
je 0x16879
movq %rax, %r12
testq %rax, %rax
jne 0x1683d
xorl %r12d, %r12d
movq %rbx, %rdi
callq 0x1fd17
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/ae.c
// Function: aeDeleteTimeEvent
int aeDeleteTimeEvent(aeEventLoop *eventLoop, long long id)
{
    aeTimeEvent *te, *prev = NULL;

    te = eventLoop->timeEventHead;
    while(te) {
        if (te->id == id) {
            if (prev == NULL)
                eventLoop->timeEventHead = te->next;
            else
                prev->next = te->next;
            if (te->finalizerProc)
                te->finalizerProc(eventLoop, te->clientData);
            zfree(te);
            return AE_OK;
        }
        prev = te;
        te = te->next;
    }
    return AE_ERR; /* NO event with the specified ID found */
}

// Assembly:
pushq %rbx
movq 0x28(%rdi), %rbx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rbx, %rbx
je 0x17011
cmpq %rsi, (%rbx)
jne 0x16fcb
xorl %ecx, %ecx
jmp 0x16fe2
movq %rbx, %rdx
movq 0x30(%rdx), %rbx
testq %rbx, %rbx
je 0x17011
movq %rdx, %rcx
movq %rbx, %rdx
cmpq %rsi, (%rbx)
jne 0x16fce
leaq 0x28(%rdi), %rax
leaq 0x30(%rcx), %rdx
testq %rcx, %rcx
cmoveq %rax, %rdx
movq 0x30(%rbx), %rax
movq %rax, (%rdx)
movq 0x20(%rbx), %rax
testq %rax, %rax
je 0x17007
movq 0x28(%rbx), %rsi
callq *%rax
movq %rbx, %rdi
callq 0x1fd17
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/anet.c
// Function: anetSetReuseAddr
static int anetSetReuseAddr(char *err, int fd) {
    int yes = 1;
    /* Make sure connection-intensive things like the discnt benckmark
     * will be able to close/open sockets a zillion of times */
    if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) == -1) {
        anetSetError(err, "setsockopt SO_REUSEADDR: %s", strerror(errno));
        return ANET_ERR;
    }
    return ANET_OK;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl %esi, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x121b0
movl %eax, %ecx
xorl %eax, %eax
cmpl $-0x1, %ecx
jne 0x18402
callq 0x120d0
movl (%rax), %edi
callq 0x128e0
leaq 0x39d96(%rip), %rsi     # 0x52186
movq %rbx, %rdi
movq %rax, %rdx
xorl %eax, %eax
callq 0x174f1
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/dict.c
// Function: dictReplace
int dictReplace(dict *d, void *key, void *val)
{
    dictEntry *entry, *existing, auxentry;

    /* Try to add the element. If the key
     * does not exists dictAdd will suceed. */
    entry = dictAddRaw(d,key,&existing);
    if (entry) {
        dictSetVal(d, entry, val);
        return 1;
    }

    /* Set the new value and free the old one. Note that it is important
     * to do that in this order, as the value may just be exactly the same
     * as the previous one. In this context, think to reference counting,
     * you want to increment (set), and then decrement (free), and not the
     * reverse. */
    auxentry = *existing;
    dictSetVal(d, existing, val);
    dictFreeVal(d, &auxentry);
    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
movq %rsp, %rdx
callq 0x18847
testq %rax, %rax
je 0x18a0e
movq %rax, %r15
movq (%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x18a35
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *%rax
movq %rax, 0x8(%r15)
jmp 0x18a39
movq (%rsp), %rcx
movq 0x8(%rcx), %r15
movq (%rbx), %rax
movq 0x10(%rax), %rax
testq %rax, %rax
je 0x18a40
movq 0x8(%rbx), %rdi
movq %r14, %rsi
callq *%rax
movq (%rsp), %rcx
movq %rax, 0x8(%rcx)
jmp 0x18a44
movq %r14, 0x8(%r15)
movl $0x1, %ebp
jmp 0x18a5b
movq %r14, 0x8(%rcx)
movq (%rbx), %rax
movq 0x28(%rax), %rax
xorl %ebp, %ebp
testq %rax, %rax
je 0x18a5b
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq *%rax
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/dict.c
// Function: dictGenericDelete
static dictEntry *dictGenericDelete(dict *d, const void *key, int nofree) {
    unsigned int h, idx;
    dictEntry *he, *prevHe;
    int table;

    if (d->ht[0].used == 0 && d->ht[1].used == 0) return NULL;

    if (dictIsRehashing(d)) _dictRehashStep(d);
    h = dictHashKey(d, key);

    for (table = 0; table <= 1; table++) {
        idx = h & d->ht[table].sizemask;
        he = d->ht[table].table[idx];
        prevHe = NULL;
        while(he) {
            if (key==he->key || dictCompareKeys(d, key, he->key)) {
                /* Unlink the element from the list */
                if (prevHe)
                    prevHe->next = he->next;
                else
                    d->ht[table].table[idx] = he->next;
                if (!nofree) {
                    dictFreeKey(d, he);
                    dictFreeVal(d, he);
                    zfree(he);
                }
                d->ht[table].used--;
                return he;
            }
            prevHe = he;
            he = he->next;
        }
        if (!dictIsRehashing(d)) break;
    }
    return NULL; /* not found */
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r15
movq %rdi, %rbx
cmpq $0x0, 0x28(%rdi)
jne 0x18ab6
cmpq $0x0, 0x48(%rbx)
je 0x18bf8
movl %edx, 0xc(%rsp)
cmpq $-0x1, 0x50(%rbx)
je 0x18ad5
cmpq $0x0, 0x58(%rbx)
jne 0x18ad5
movq %rbx, %rdi
movl $0x1, %esi
callq 0x185d1
leaq 0x10(%rbx), %r12
movq (%rbx), %rax
movq %r15, %rdi
callq *(%rax)
movb $0x1, %cl
xorl %ebp, %ebp
movq %r12, 0x18(%rsp)
movl %eax, 0x10(%rsp)
movl %ecx, 0x14(%rsp)
shlq $0x5, %rbp
movl 0x10(%r12,%rbp), %ecx
andl %eax, %ecx
movq (%r12,%rbp), %rax
movq %rcx, 0x20(%rsp)
movq (%rax,%rcx,8), %r14
testq %r14, %r14
je 0x18b50
movq (%r14), %rdx
cmpq %r15, %rdx
je 0x18bfd
xorl %r12d, %r12d
movq %r14, %r13
movq (%rbx), %rax
movq 0x18(%rax), %rax
testq %rax, %rax
je 0x18b3a
movq 0x8(%rbx), %rdi
movq %r15, %rsi
callq *%rax
testl %eax, %eax
jne 0x18b7a
movq 0x10(%r13), %r14
testq %r14, %r14
je 0x18b50
movq (%r14), %rdx
movq %r13, %r12
cmpq %r15, %rdx
jne 0x18b1e
jmp 0x18b80
cmpq $-0x1, 0x50(%rbx)
setne %al
movl $0x1, %ebp
xorl %r14d, %r14d
testb %al, 0x14(%rsp)
movl $0x0, %ecx
movq 0x18(%rsp), %r12
movl 0x10(%rsp), %eax
jne 0x18aee
jmp 0x18be6
movq %r13, %r14
movq %r12, %r13
movq 0x18(%rsp), %r15
addq %rbp, %r15
movq 0x10(%r14), %rax
testq %r13, %r13
je 0x18b97
addq $0x10, %r13
jmp 0x18ba3
movq 0x20(%rsp), %r13
shlq $0x3, %r13
addq (%r15), %r13
movl 0xc(%rsp), %ecx
movq %rax, (%r13)
testl %ecx, %ecx
jne 0x18be2
movq (%rbx), %rcx
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x18bc7
movq 0x8(%rbx), %rdi
movq (%r14), %rsi
callq *%rax
movq (%rbx), %rcx
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x18bda
movq 0x8(%rbx), %rdi
movq 0x8(%r14), %rsi
callq *%rax
movq %r14, %rdi
callq 0x1fd17
decq 0x18(%r15)
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %r14d, %r14d
jmp 0x18be6
xorl %r13d, %r13d
jmp 0x18b80
// File: /workspace/github_c_makefile_star2_O3/erikdubbelboer[P]discnt/src/dict.c
// Function: dictFreeUnlinkedEntry
void dictFreeUnlinkedEntry(dict *d, dictEntry *he) {
    if (he == NULL) return;
    dictFreeKey(d, he);
    dictFreeVal(d, he);
    zfree(he);
}

// Assembly:
testq %rsi, %rsi
je 0x18c58
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rcx
movq 0x20(%rcx), %rax
testq %rax, %rax
je 0x18c36
movq 0x8(%r14), %rdi
movq (%rbx), %rsi
callq *%rax
movq (%r14), %rcx
movq 0x28(%rcx), %rax
testq %rax, %rax
je 0x18c49
movq 0x8(%r14), %rdi
movq 0x8(%rbx), %rsi
callq *%rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1fd17
retq