LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/AK6DN[P]dec-utilities-for-pdp/d8tape/flow.c
// Function: valid_opr
static int
valid_opr (int opr)
{
    // a valid OPR must be 07xxx
    if ((opr & 07000) != 07000) {
        return (0);
    }

    if ((opr & 07400) == 07000) {                       // group 1
        if ((opr & 00014) == 00014) {                   // with both L and R rotate bits on
            return (0);
        }
    } else if ((opr & 07401) == 07400) {                // group 2
        // all ok
    } else if ((opr & 07401) == 07401) {                // EAE
        // if bits 6, 8, 9, or 10 are set...
        if (opr & 00056) {
            return (0);                                     // @@@ we're disabling EAE for now
        }
        // otherwise it's an "MQ microinstruction", which is ok
    }
    return (1);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
andl $0xe00, %eax            # imm = 0xE00
cmpl $0xe00, %eax            # imm = 0xE00
je 0x712f
movl $0x0, -0x4(%rbp)
jmp 0x7195
movl -0x8(%rbp), %eax
andl $0xf00, %eax            # imm = 0xF00
cmpl $0xe00, %eax            # imm = 0xE00
jne 0x7154
movl -0x8(%rbp), %eax
andl $0xc, %eax
cmpl $0xc, %eax
jne 0x7152
movl $0x0, -0x4(%rbp)
jmp 0x7195
jmp 0x718e
movl -0x8(%rbp), %eax
andl $0xf01, %eax            # imm = 0xF01
cmpl $0xf00, %eax            # imm = 0xF00
jne 0x7165
jmp 0x718c
movl -0x8(%rbp), %eax
andl $0xf01, %eax            # imm = 0xF01
cmpl $0xf01, %eax            # imm = 0xF01
jne 0x718a
movl -0x8(%rbp), %eax
andl $0x2e, %eax
cmpl $0x0, %eax
je 0x7188
movl $0x0, -0x4(%rbp)
jmp 0x7195
jmp 0x718a
jmp 0x718c
jmp 0x718e
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x3f0, %rsp            # imm = 0x3F0
movl $0x0, -0x4(%rbp)
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11b0
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x119e
leaq -0x3f0(%rbp), %rdi
callq 0x1280
leaq -0x3f0(%rbp), %rsi
leaq 0xe6f(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1030
jmp 0x1162
xorl %eax, %eax
addq $0x3f0, %rsp            # imm = 0x3F0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x15(%rbp)
jge 0x11f6
callq 0x1040
movl %eax, %ecx
movl %ecx, -0x10(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x11f6
cmpl $0xa, -0x10(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x11ff
jmp 0x121a
movl -0x10(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x11c6
jmp 0x121c
movl -0x14(%rbp), %ecx
movl -0xc(%rbp), %edx
subl $0x1, %edx
xorl %eax, %eax
cmpl %edx, %ecx
movb %al, -0x16(%rbp)
jl 0x123f
callq 0x1040
movl %eax, -0x10(%rbp)
cmpl $0xa, %eax
setne %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
testb $0x1, %al
jne 0x1248
jmp 0x124a
jmp 0x121c
cmpl $0xa, -0x10(%rbp)
jne 0x1265
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0xa, (%rax,%rcx)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x14(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1320
movl %eax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0xa, %eax
jne 0x12c0
movl -0x10(%rbp), %eax
subl $0x2, %eax
movl %eax, -0x10(%rbp)
jmp 0x12c9
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12cb
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x1319
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movb %dl, (%rax,%rcx)
movb -0x11(%rbp), %dl
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x12cb
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x38fe
movq -0x10(%rbp), %rdi
leaq 0x8f7b(%rip), %rsi      # 0xc859
callq 0x2160
cmpl $0x0, %eax
je 0x38fe
movq -0x10(%rbp), %rdi
leaq 0x8d65(%rip), %rsi      # 0xc658
callq 0x2230
movq %rax, -0x28(%rbp)
jmp 0x391f
movq 0xb6c3(%rip), %rax      # 0xefc8
movq (%rax), %rdi
callq 0x21a0
movl %eax, %edi
leaq 0x8d42(%rip), %rsi      # 0xc658
callq 0x20b0
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x3938
movq $0x0, -0x8(%rbp)
jmp 0x3977
movl $0x1, %edi
movl $0x18, %esi
callq 0x2150
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3990
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/bseq.c
// Function: bseq_read
bseq1_t *bseq_read(bseq_file_t *fp, int chunk_size, int *n_)
{
	int size = 0, m, n;
	bseq1_t *seqs;
	kseq_t *ks = fp->ks;
	m = n = 0; seqs = 0;
	while (kseq_read(ks) >= 0) {
		bseq1_t *s;
		assert(ks->seq.l <= INT32_MAX);
		if (n >= m) {
			m = m? m<<1 : 256;
			seqs = (bseq1_t*)realloc(seqs, m * sizeof(bseq1_t));
		}
		s = &seqs[n];
		s->name = strdup(ks->name.s);
		s->seq = strdup(ks->seq.s);
		s->l_seq = ks->seq.l;
		size += seqs[n++].l_seq;
		if (size >= chunk_size) break;
	}
	if (n == 0) fp->is_eof = 1;
	*n_ = n;
	return seqs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movq $0x0, -0x30(%rbp)
movq -0x38(%rbp), %rdi
callq 0x3be0
cmpl $0x0, %eax
jl 0x3bb9
movq -0x38(%rbp), %rax
cmpl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
ja 0x3add
jmp 0x3afc
leaq 0x8b76(%rip), %rdi      # 0xc65a
leaq 0x8b86(%rip), %rsi      # 0xc671
movl $0x2d, %edx
leaq 0x8b81(%rip), %rcx      # 0xc678
callq 0x2120
movl -0x24(%rbp), %eax
cmpl -0x20(%rbp), %eax
jl 0x3b39
cmpl $0x0, -0x20(%rbp)
je 0x3b14
movl -0x20(%rbp), %eax
shll %eax
movl %eax, -0x44(%rbp)
jmp 0x3b1e
movl $0x100, %eax            # imm = 0x100
movl %eax, -0x44(%rbp)
jmp 0x3b1e
movl -0x44(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rdi
movslq -0x20(%rbp), %rax
imulq $0x18, %rax, %rsi
callq 0x2200
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq -0x24(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x22c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x38(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x22c0
movq %rax, %rcx
movq -0x40(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
movq -0x40(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movl -0x24(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x24(%rbp)
movslq %ecx, %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jl 0x3bb4
jmp 0x3bb9
jmp 0x3abc
cmpl $0x0, -0x24(%rbp)
jne 0x3bc9
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/index.c
// Function: mm_idx_init
mm_idx_t *mm_idx_init(int w, int k, int b)
{
	mm_idx_t *mi;
	if (k*2 < b) b = k * 2;
	if (w < 1) w = 1;
	mi = (mm_idx_t*)calloc(1, sizeof(mm_idx_t));
	mi->w = w, mi->k = k, mi->b = b;
	mi->max_occ = UINT32_MAX;
	mi->B = (mm_idx_bucket_t*)calloc(1<<b, sizeof(mm_idx_bucket_t));
	return mi;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl -0x8(%rbp), %eax
shll %eax
cmpl -0xc(%rbp), %eax
jge 0x45e3
movl -0x8(%rbp), %eax
shll %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0x4(%rbp)
jge 0x45f0
movl $0x1, -0x4(%rbp)
movl $0x1, %edi
movl $0x30, %esi
callq 0x2150
movq %rax, -0x18(%rbp)
movl -0x4(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movl -0x8(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x8(%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movl -0xc(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movslq %eax, %rdi
movl $0x30, %esi
callq 0x2150
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4678
jmp 0x4764
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movl (%rcx), %ecx
movl $0x1, %edx
shll %cl, %edx
movl %edx, %ecx
cmpl %ecx, %eax
jge 0x46f4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x28(%rax), %rdi
callq 0x4770
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x467f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x4741
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jae 0x473f
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x2040
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x4713
jmp 0x4741
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x24(%rbp), %rdx
andq %rdx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl $0x0, (%rax)
cmpq $0x0, -0x38(%rbp)
jne 0x482f
movq $0x0, -0x8(%rbp)
jmp 0x48da
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
shrq %cl, %rsi
shlq %rsi
callq 0x48f0
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x4862
movq $0x0, -0x8(%rbp)
jmp 0x48da
movq -0x38(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rax
andq $0x1, %rax
cmpq $0x0, %rax
je 0x489d
movq -0x20(%rbp), %rax
movl $0x1, (%rax)
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x28(%rbp), %ecx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x48da
movq -0x38(%rbp), %rax
movq 0x20(%rax), %rax
movl -0x28(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x38(%rbp), %rcx
movq 0x20(%rcx), %rcx
movl -0x28(%rbp), %edx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movl 0x18(%rbp), %eax
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
leaq -0x58(%rbp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x2140
movl -0x20(%rbp), %eax
movl %eax, -0x58(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x50(%rbp)
movq 0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x4d07
movq $0x0, -0x8(%rbp)
jmp 0x4e4f
movl -0x14(%rbp), %edi
movl -0x18(%rbp), %esi
movl -0x1c(%rbp), %edx
callq 0x45c0
movq %rax, -0x30(%rbp)
cmpl $0x3, -0x24(%rbp)
jge 0x4d27
movl -0x24(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x4d31
movl $0x3, %eax
movl %eax, -0x5c(%rbp)
jmp 0x4d31
movl -0x5c(%rbp), %edi
leaq 0x125(%rip), %rsi       # 0x4e60
leaq -0x58(%rbp), %rdx
movl $0x3, %ecx
callq 0x96d0
leaq 0xa440(%rip), %rax      # 0xf190
cmpl $0x3, (%rax)
jl 0x4dbc
movq 0xa29c(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x70(%rbp)
callq 0x2f60
leaq 0xa539(%rip), %rax      # 0xf2a8
subsd (%rax), %xmm0
movsd %xmm0, -0x68(%rbp)
callq 0x2f00
movsd %xmm0, -0x78(%rbp)
callq 0x2f60
movsd -0x78(%rbp), %xmm1
movq -0x70(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x68(%rbp), %xmm0
leaq 0xa509(%rip), %rax      # 0xf2a8
subsd (%rax), %xmm2
divsd %xmm2, %xmm1
leaq 0x7932(%rip), %rsi      # 0xc6e0
leaq 0x7954(%rip), %rdx      # 0xc709
movb $0x2, %al
callq 0x2180
movq -0x30(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x52b0
leaq 0xa3c1(%rip), %rax      # 0xf190
cmpl $0x3, (%rax)
jl 0x4e47
movq 0xa21d(%rip), %rax      # 0xeff8
movq (%rax), %rax
movq %rax, -0x88(%rbp)
callq 0x2f60
leaq 0xa4b7(%rip), %rax      # 0xf2a8
subsd (%rax), %xmm0
movsd %xmm0, -0x80(%rbp)
callq 0x2f00
movsd %xmm0, -0x90(%rbp)
callq 0x2f60
movsd -0x90(%rbp), %xmm1
movq -0x88(%rbp), %rdi
movaps %xmm0, %xmm2
movsd -0x80(%rbp), %xmm0
leaq 0xa47e(%rip), %rax      # 0xf2a8
subsd (%rax), %xmm2
divsd %xmm2, %xmm1
leaq 0x78db(%rip), %rsi      # 0xc714
leaq 0x78c9(%rip), %rdx      # 0xc709
movb $0x2, %al
callq 0x2180
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x10(%rbp), %rdi
callq 0x38c0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
jne 0x5323
movq $0x0, -0x8(%rbp)
jmp 0x5377
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %esi
movl -0x18(%rbp), %edx
movl -0x1c(%rbp), %r9d
movl $0xe, %ecx
movl $0x40000, %r8d          # imm = 0x40000
movq $-0x1, (%rsp)
movl $0x1, 0x8(%rsp)
callq 0x4ca0
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
movss 0x6ca3(%rip), %xmm0     # 0xc004
callq 0x4c60
movq -0x28(%rbp), %rdi
callq 0x39d0
movq -0x30(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/index.c
// Function: mm_idx_add
static void mm_idx_add(mm_idx_t *mi, int n, const mm128_t *a)
{
	int i, mask = (1<<mi->b) - 1;
	for (i = 0; i < n; ++i) {
		mm128_v *p = &mi->B[a[i].x&mask].a;
		kv_push(mm128_t, *p, a[i]);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
subl $0x1, %eax
movl %eax, -0x20(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x62ca
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rcx
movslq -0x20(%rbp), %rdx
andq %rdx, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rax
movq -0x28(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x627d
movq -0x28(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x6242
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0x624d
movl $0x2, %eax
movq %rax, -0x30(%rbp)
jmp 0x624d
movq -0x30(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x4, %rsi
callq 0x2200
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
shlq $0x4, %rcx
addq %rcx, %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
movq (%rcx), %rdx
movq %rdx, (%rax)
movq 0x8(%rcx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x62bc
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x61dd
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/map.c
// Function: mm_mapopt_init
void mm_mapopt_init(mm_mapopt_t *opt)
{
	opt->radius = 500;
	opt->max_gap = 10000;
	opt->min_cnt = 4;
	opt->min_match = 40;
	opt->sdust_thres = 0;
	opt->flag = MM_F_WITH_REP;
	opt->merge_frac = .5;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1f4, (%rax)          # imm = 0x1F4
movq -0x8(%rbp), %rax
movl $0x2710, 0x4(%rax)      # imm = 0x2710
movq -0x8(%rbp), %rax
movl $0x4, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x28, 0xc(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x14(%rax)
movq -0x8(%rbp), %rax
movss 0x61a3(%rip), %xmm0     # 0xc838
movss %xmm0, 0x18(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x66f8
jmp 0x678f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0xb0(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x58(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x70(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x88(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x90(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x78(%rax), %rdi
callq 0xa670
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movl %r8d, -0x28(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x2140
movq -0x18(%rbp), %rdi
callq 0x38c0
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x7ff8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x804c
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x48(%rbp)
movl -0x28(%rbp), %eax
movl %eax, -0x50(%rbp)
movl -0x24(%rbp), %ecx
movl $0x2, %edi
movl $0x1, %eax
cmpl $0x1, %ecx
cmovel %eax, %edi
leaq 0x32(%rip), %rsi        # 0x8060
leaq -0x50(%rbp), %rdx
movl $0x3, %ecx
callq 0x96d0
movq -0x38(%rbp), %rdi
callq 0x39d0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/map.c
// Function: push_intv
static inline void push_intv(mm128_v *intv, int start, int end, float merge_frac)
{
	mm128_t *p;
	if (intv->n > 0) { // test overlap
		int last_start, last_end, min;
		p = &intv->a[intv->n-1];
		last_start = p->y, last_end = p->x + last_start;
		min = end - start < last_end - last_start? end - start : last_end - last_start;
		if (last_end > start && last_end - start > min * merge_frac) { // large overlap; then merge
			p->x = end - last_start;
			return;
		}
	}
	kv_pushp(mm128_t, *intv, &p); // a new interval
	p->x = end - start, p->y = start;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movss %xmm0, -0x14(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, (%rax)
jbe 0x85b1
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
subq $0x1, %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl %eax, -0x24(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movslq -0x24(%rbp), %rcx
addq %rcx, %rax
movl %eax, -0x28(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl -0x28(%rbp), %ecx
subl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jge 0x856a
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movl %eax, -0x30(%rbp)
jmp 0x8573
movl -0x28(%rbp), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x30(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl -0x28(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x85af
movl -0x28(%rbp), %eax
subl -0xc(%rbp), %eax
cvtsi2ss %eax, %xmm0
cvtsi2ssl -0x2c(%rbp), %xmm1
mulss -0x14(%rbp), %xmm1
ucomiss %xmm1, %xmm0
jbe 0x85af
movl -0x10(%rbp), %eax
subl -0x24(%rbp), %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
jmp 0x865b
jmp 0x85b1
jmp 0x85b3
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x861b
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x85e0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x85eb
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x85eb
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x4, %rsi
callq 0x2200
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq (%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, (%rdx)
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x10(%rbp), %eax
subl -0xc(%rbp), %eax
movslq %eax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movslq -0xc(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/map.c
// Function: worker_for
static void worker_for(void *_data, long i, int tid) // kt_for() callback
{
    step_t *step = (step_t*)_data;
	const mm_reg1_t *regs;
	int n_regs;

	regs = mm_map(step->p->mi, step->seq[i].l_seq, step->seq[i].seq, &n_regs, step->buf[tid], step->p->opt, step->seq[i].name);
	step->n_reg[i] = n_regs;
	if (n_regs > 0) {
		step->reg[i] = (mm_reg1_t*)malloc(n_regs * sizeof(mm_reg1_t));
		memcpy(step->reg[i], regs, n_regs * sizeof(mm_reg1_t));
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x10(%rax), %rdx
movq -0x20(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %r8
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %r9
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
leaq -0x2c(%rbp), %rcx
movq %rax, (%rsp)
callq 0x75c0
movq %rax, -0x28(%rbp)
movl -0x2c(%rbp), %edx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x0, -0x2c(%rbp)
jle 0x94c5
movslq -0x2c(%rbp), %rax
imulq $0x1c, %rax, %rdi
callq 0x21e0
movq %rax, %rdx
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x28(%rbp), %rsi
movslq -0x2c(%rbp), %rax
imulq $0x1c, %rax, %rdx
callq 0x2190
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xa685
jmp 0xa6b4
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0xa6c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2040
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/lh3[P]minimap/sdust.c
// Function: shift_window
static inline void shift_window(int t, kdq_t(int) *w, int T, int W, int *L, int *rw, int *rv, int *cw, int *cv)
{
	int s;
	if (kdq_size(w) >= W - SD_WLEN + 1) { // TODO: is this right for SD_WLEN!=3?
		s = *kdq_shift(int, w);
		*rw -= --cw[s];
		if (*L > kdq_size(w))
			--*L, *rv -= --cv[s];
	}
	kdq_push(int, w, t);
	++*L;
	*rw += cw[t]++;
	*rv += cv[t]++;
	if (cv[t] * 10 > T<<1) {
		do {
			s = kdq_at(w, kdq_size(w) - *L);
			*rv -= --cv[s];
			--*L;
		} while (s != t);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq 0x20(%rbp), %rax
movq 0x18(%rbp), %rax
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movq %r8, -0x20(%rbp)
movq %r9, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x18(%rbp), %ecx
subl $0x3, %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
cmpq %rcx, %rax
jb 0xace4
movq -0x10(%rbp), %rdi
callq 0xb310
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq 0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0xace2
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movq 0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
jmp 0xace4
movq -0x10(%rbp), %rdi
movl -0x4(%rbp), %esi
callq 0xb3f0
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movq 0x18(%rbp), %rax
movslq -0x4(%rbp), %rdx
movl (%rax,%rdx,4), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq -0x28(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rbp), %rax
movslq -0x4(%rbp), %rdx
movl (%rax,%rdx,4), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, (%rax,%rdx,4)
movq 0x10(%rbp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x20(%rbp), %rax
movslq -0x4(%rbp), %rcx
imull $0xa, (%rax,%rcx,4), %eax
movl -0x14(%rbp), %ecx
shll %ecx
cmpl %ecx, %eax
jle 0xadb4
jmp 0xad48
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rdx
movabsq $0x3ffffffffffffff, %rcx # imm = 0x3FFFFFFFFFFFFFF
andq (%rdx), %rcx
movq -0x10(%rbp), %rdx
movq 0x8(%rdx), %rdx
movq -0x20(%rbp), %rsi
movslq (%rsi), %rsi
subq %rsi, %rdx
addq %rdx, %rcx
movq -0x10(%rbp), %rdx
andq 0x10(%rdx), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x2c(%rbp)
movq 0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rbp), %rax
movl (%rax), %ecx
subl %edx, %ecx
movl %ecx, (%rax)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
addl $-0x1, %ecx
movl %ecx, (%rax)
movl -0x2c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jne 0xad48
jmp 0xadb4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
callq 0xa630
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %r8
movq -0x30(%rbp), %r9
callq 0xa700
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x30(%rbp), %rdi
callq 0xa670
movq -0x28(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x640, %rsp            # imm = 0x640
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0x3ae7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bcc
movq -0x10(%rbp), %rdi
leaq 0x17f5(%rip), %rsi      # 0x52e7
callq 0x2080
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
jne 0x3b0d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bcc
movq -0x20(%rbp), %rax
addq $0x13, %rax
movq %rax, -0x20(%rbp)
leaq -0x230(%rbp), %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2130
movq -0x20(%rbp), %rdi
leaq -0x230(%rbp), %rdx
leaq 0x18ac(%rip), %rsi      # 0x53ea
movb $0x0, %al
callq 0x2210
leaq -0x230(%rbp), %rdi
callq 0x2100
movl %eax, -0x24(%rbp)
cmpl $0x1, -0x24(%rbp)
jge 0x3b63
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x3bcc
leaq -0x630(%rbp), %rdi
xorl %esi, %esi
movl $0x400, %edx            # imm = 0x400
callq 0x2130
leaq -0x230(%rbp), %rdi
movl -0x24(%rbp), %esi
leaq -0x630(%rbp), %rdx
callq 0x2cd0
movl -0x8(%rbp), %eax
movl %eax, -0x63c(%rbp)
leaq -0x630(%rbp), %rax
movq %rax, -0x638(%rbp)
leaq -0x630(%rbp), %rdi
callq 0x2100
movl -0x63c(%rbp), %edi
movq -0x638(%rbp), %rsi
movq %rax, %rdx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x2120
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x640, %rsp            # imm = 0x640
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movb %cl, %al
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
andb $0x1, %al
movb %al, -0x15(%rbp)
movl %r8d, -0x1c(%rbp)
movl -0x14(%rbp), %eax
addl $0x80, %eax
movl %eax, %eax
movl %eax, %esi
shlq $0x0, %rsi
movl $0x1, %edi
callq 0x2170
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
movl -0x14(%rbp), %eax
addl $0x80, %eax
movl %eax, %eax
movl %eax, %edx
xorl %esi, %esi
callq 0x2130
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movq -0x28(%rbp), %rdx
movl -0x14(%rbp), %ecx
addl $0x80, %ecx
movb -0x15(%rbp), %al
movl -0x1c(%rbp), %r9d
andb $0x1, %al
movzbl %al, %r8d
callq 0x2da0
movl %eax, -0x2c(%rbp)
movl -0x4(%rbp), %edi
movq -0x28(%rbp), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
movl $0x4000, %ecx           # imm = 0x4000
callq 0x2120
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rdi
callq 0x2240
movl -0x30(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x420, %rsp            # imm = 0x420
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x410(%rbp), %rsi
movl $0x400, %edx            # imm = 0x400
callq 0x46e0
movl %eax, -0x414(%rbp)
cmpl $0x0, -0x414(%rbp)
jle 0x4c62
movl -0x414(%rbp), %esi
leaq -0x410(%rbp), %rdx
leaq 0x9c5(%rip), %rdi       # 0x559c
movb $0x0, %al
callq 0x2040
leaq -0x410(%rbp), %rdi
leaq 0x9ca(%rip), %rsi       # 0x55b6
callq 0x2080
cmpq $0x0, %rax
je 0x4c1f
movq -0x8(%rbp), %rdi
leaq 0x9ba(%rip), %rsi       # 0x55bc
movl $0x10, %edx
movl $0x1, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x4630
movl %eax, -0x414(%rbp)
jmp 0x4c60
leaq -0x410(%rbp), %rdi
leaq 0x9a0(%rip), %rsi       # 0x55cd
callq 0x2080
cmpq $0x0, %rax
je 0x4c5e
movq -0x8(%rbp), %rdi
leaq 0x996(%rip), %rsi       # 0x55d9
movl $0xf, %edx
movl $0x1, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x4630
movl %eax, -0x414(%rbp)
jmp 0x4c60
jmp 0x4cbb
jmp 0x4c64
leaq 0x530(%rip), %rdi       # 0x519b
leaq 0x977(%rip), %rsi       # 0x55e9
leaq 0x8b3(%rip), %rdx       # 0x552c
movl $0x29, %ecx
movb $0x0, %al
callq 0x2040
leaq 0x969(%rip), %rdi       # 0x55f5
movb $0x0, %al
callq 0x2040
leaq 0x674(%rip), %rdi       # 0x530e
movb $0x0, %al
callq 0x2040
movq -0x8(%rbp), %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2270
movq -0x8(%rbp), %rdi
callq 0x20b0
addq $0x420, %rsp            # imm = 0x420
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movswl -0xa(%rbp), %eax
andl $0x10, %eax
cmpl $0x0, %eax
je 0x4d3c
jmp 0x4cfd
leaq 0x497(%rip), %rdi       # 0x519b
leaq 0x8fa(%rip), %rsi       # 0x5605
leaq 0x81a(%rip), %rdx       # 0x552c
movl $0x32, %ecx
movb $0x0, %al
callq 0x2040
leaq 0x8d0(%rip), %rdi       # 0x55f5
movb $0x0, %al
callq 0x2040
leaq 0x5db(%rip), %rdi       # 0x530e
movb $0x0, %al
callq 0x2040
jmp 0x4d9a
movswl -0xa(%rbp), %eax
andl $0x20, %eax
cmpl $0x0, %eax
je 0x4d98
jmp 0x4d4a
leaq 0x44a(%rip), %rdi       # 0x519b
leaq 0x8ad(%rip), %rsi       # 0x5605
leaq 0x7cd(%rip), %rdx       # 0x552c
movl $0x35, %ecx
movb $0x0, %al
callq 0x2040
callq 0x2030
movl (%rax), %edi
callq 0x20e0
movq %rax, %rsi
leaq 0x891(%rip), %rdi       # 0x5612
movb $0x0, %al
callq 0x2040
leaq 0x57f(%rip), %rdi       # 0x530e
movb $0x0, %al
callq 0x2040
jmp 0x4d98
jmp 0x4d9a
movq -0x8(%rbp), %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2270
movq -0x8(%rbp), %rdi
callq 0x20b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movw %si, %ax
movl %edi, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movq %rdx, -0x10(%rbp)
cmpl $0xe, -0x4(%rbp)
jne 0x4e6c
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
leaq 0x843(%rip), %rsi       # 0x5636
movl $0x1a, %edx
movl $0x1, %ecx
movl $0xffffffed, %r8d       # imm = 0xFFFFFFED
callq 0x4630
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x14(%rbp)
jge 0x4e6a
jmp 0x4e13
leaq 0x381(%rip), %rdi       # 0x519b
leaq 0x830(%rip), %rsi       # 0x5651
leaq 0x704(%rip), %rdx       # 0x552c
movl $0x45, %ecx
movb $0x0, %al
callq 0x2040
leaq 0x7ba(%rip), %rdi       # 0x55f5
movb $0x0, %al
callq 0x2040
leaq 0x4c5(%rip), %rdi       # 0x530e
movb $0x0, %al
callq 0x2040
movq -0x20(%rbp), %rdi
callq 0x2320
movq %rax, %rdi
callq 0x2270
movq -0x20(%rbp), %rdi
callq 0x20b0
jmp 0x4e6c
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1260
cltq
movq %rax, -0x18(%rbp)
xorl %eax, %eax
movl %eax, %r9d
movl $0x100000, %esi         # imm = 0x100000
movl $0x3, %edx
movl $0x22, %ecx
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq %r9, %rdi
callq 0x10e0
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
cmpq $0x100000, -0x20(%rbp)  # imm = 0x100000
jae 0x20f3
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movb $0x1, (%rax,%rcx)
movq -0x28(%rbp), %rdi
addq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x4, %edx
callq 0x1200
movq -0x28(%rbp), %rax
movq -0x20(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x20b8
jmp 0x20d7
leaq 0x11c7(%rip), %rdi      # 0x3286
leaq 0x11d1(%rip), %rsi      # 0x3297
movl $0x1b, %edx
leaq 0x11d8(%rip), %rcx      # 0x32aa
callq 0x1120
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
addq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x2079
movq -0x28(%rbp), %rdi
movl $0x100000, %esi         # imm = 0x100000
callq 0x11e0
jmp 0x204b
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
callq 0x12b00
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jne 0x130d8
movq $0x0, -0x8(%rbp)
jmp 0x131c5
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x12f70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x131b4
movq -0x18(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13174
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rdi
callq *%rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
jne 0x13172
movq -0x18(%rbp), %rdi
callq 0x12b80
movq -0x20(%rbp), %rdi
callq 0x12fe0
movq $0x0, -0x8(%rbp)
jmp 0x131c5
jmp 0x13180
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rsi
callq 0x12ce0
cmpq $0x0, %rax
jne 0x131af
movq -0x18(%rbp), %rdi
callq 0x12b80
movq -0x20(%rbp), %rdi
callq 0x12fe0
movq $0x0, -0x8(%rbp)
jmp 0x131c5
jmp 0x13117
movq -0x20(%rbp), %rdi
callq 0x12fe0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x12f70
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x13060
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x13262
movq -0x10(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x1323d
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x10(%rcx), %rdi
movq -0x18(%rbp), %rsi
callq *%rax
cmpl $0x0, %eax
je 0x1323b
movq -0x20(%rbp), %rdi
callq 0x12fe0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13273
jmp 0x13260
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x1325e
movq -0x20(%rbp), %rdi
callq 0x12fe0
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x13273
jmp 0x13260
jmp 0x131ef
movq -0x20(%rbp), %rdi
callq 0x12fe0
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)