LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_kcn_get1
static inline int kh_kcn_get1(kh_kcn_t *k_cn, uint64_t key)
{
    khint_t k;
    k = kh_kcn_get(k_cn, key);
    if (k < kh_end(k_cn))
        return kh_val(k_cn, k);
    else
        return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x1a130
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x16703
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x24(%rbp)
jmp 0x1670a
xorl %eax, %eax
movl %eax, -0x24(%rbp)
jmp 0x1670a
movl -0x20(%rbp), %eax
movl -0x24(%rbp), %ecx
cmpl %ecx, %eax
jae 0x1672e
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, -0x4(%rbp)
jmp 0x16735
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: ha_hist_line
static void ha_hist_line(int c, int x, int exceed, int64_t cnt)
{
    int j;
    if (c >= 0)
        fprintf(stderr, "[M::%s] %5d: ", __func__, c);
    else 
        fprintf(stderr, "[M::%s] %5s: ", __func__, "rest");
    for (j = 0; j < x; ++j) fputc('*', stderr);
    if (exceed) fputc('>', stderr);
    fprintf(stderr, " %lld\n", (long long)cnt);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movq %rcx, -0x18(%rbp)
cmpl $0x0, -0x4(%rbp)
jl 0x18a1f
movq 0x1b5f6(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
movl -0x4(%rbp), %ecx
leaq 0x15a5e(%rip), %rsi     # 0x2e46d
leaq 0x15a65(%rip), %rdx     # 0x2e47b
movb $0x0, %al
callq 0x2290
jmp 0x18a45
movq 0x1b5d2(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x15a58(%rip), %rsi     # 0x2e488
leaq 0x15a44(%rip), %rdx     # 0x2e47b
leaq 0x15a58(%rip), %rcx     # 0x2e496
movb $0x0, %al
callq 0x2290
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jge 0x18a73
movq 0x1b59d(%rip), %rax     # 0x33ff8
movq (%rax), %rsi
movl $0x2a, %edi
callq 0x2220
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x18a4c
cmpl $0x0, -0xc(%rbp)
je 0x18a8d
movq 0x1b578(%rip), %rax     # 0x33ff8
movq (%rax), %rsi
movl $0x3e, %edi
callq 0x2220
movq 0x1b564(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x159f9(%rip), %rsi     # 0x2e49b
movb $0x0, %al
callq 0x2290
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: equal_array
static inline int equal_array(void *a, void *b, int n)
{
    uint64_t *x = (uint64_t *) a;
    uint64_t *y = (uint64_t *) b;
    int i;
    for (i = 0; i < n; ++i)
        if (x[i] != y[i])
            return 0;
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1912e
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x30(%rbp), %rcx
movslq -0x34(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x19121
movl $0x0, -0x4(%rbp)
jmp 0x19135
jmp 0x19123
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x190f6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncerr.c
// Function: dfs_info_reset
static void dfs_info_reset(dfs_info_t *dfs)
{
    if (!dfs) return;
    dfs->status = EC_FAILURE;
    dfs->n_path = 0;
    dfs->edist = INT32_MAX;
    dfs->s_edist = INT32_MAX;
    dfs->c_seq.l = 0;
    dfs->opt_seq.l = 0;
    dfs->c_path.n = 0;
    dfs->opt_path.n = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1a491
jmp 0x1a4ec
movq -0x8(%rbp), %rax
movl $0x0, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rbp), %rax
movl $0x7fffffff, 0x8(%rax)  # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movl $0x7fffffff, 0xc(%rax)  # imm = 0x7FFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x58(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncerr.c
// Function: dfs_info_destroy
static void dfs_info_destroy(dfs_info_t *dfs)
{
    if (!dfs) return;
    free(dfs->c_seq.s);
    free(dfs->opt_seq.s);
    free(dfs->c_path.a);
    free(dfs->opt_path.a);
    free(dfs);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x1d685
jmp 0x1d6c2
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x68(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncerr.c
// Function: kputsn_rev
static inline int kputsn_rev(const char *p, int l, kstring_t *s)
{
    if (s->l + l + 1 >= s->m) {
        s->m = s->l + l + 2;
        kroundup32(s->m);
        MYREALLOC(s->s, s->m);
    }
    int i, j;
    for (i = l - 1, j = s->l; i >= 0; --i, ++j) s->s[j] = seq_nt4_comp_table[(int) p[i]];
    s->l += l;
    s->s[s->l] = 0;
    return l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movslq -0xc(%rbp), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq -0x18(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jb 0x1d7d8
movq -0x18(%rbp), %rax
movq (%rax), %rcx
movslq -0xc(%rbp), %rax
addq %rax, %rcx
addq $0x2, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x18(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x18(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x18(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x18(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x18(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0xc(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq (%rax), %rax
movl %eax, -0x20(%rbp)
cmpl $0x0, -0x1c(%rbp)
jl 0x1d82d
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x10699(%rip), %rax     # 0x2dea0
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x20(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1d7eb
movslq -0xc(%rbp), %rcx
movq -0x18(%rbp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncerr.c
// Function: kvcmp
static int kvcmp(kvec64_t *a, kvec64_t *b)
{
    if (a->n != b->n)
        return 1;
    size_t i, n;
    for (i = 0, n = a->n; i < n; ++i)
        if (a->a[i] != b->a[i])
            return 1;
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq -0x18(%rbp), %rcx
cmpq (%rcx), %rax
je 0x1d9d5
movl $0x1, -0x4(%rbp)
jmp 0x1da34
movq $0x0, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1da2d
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x18(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x20(%rbp), %rdx
cmpq (%rcx,%rdx,8), %rax
je 0x1da1d
movl $0x1, -0x4(%rbp)
jmp 0x1da34
jmp 0x1da1f
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1d9e8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_del_v
static inline void asmg_arc_del_v(asmg_t *g, uint64_t v, uint32_t del)
{
    uint64_t i, nv = asmg_arc_n(g, v);
    asmg_arc_t *av = asmg_arc_a(g, v);
    for (i = 0; i < nv; ++i) {
        av[i].del = del;
        asmg_arc_del(g, av[i].w^1, v^1, del);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq $0x30, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x1daf2
movl -0x14(%rbp), %edx
movq -0x30(%rbp), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
andl $0x1, %edx
shll $0x1e, %edx
andl $0xbfffffff, %ecx       # imm = 0xBFFFFFFF
orl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rsi
xorq $0x1, %rsi
movq -0x10(%rbp), %rdx
xorq $0x1, %rdx
movl -0x14(%rbp), %ecx
callq 0x1db00
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1da8f
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_del
static inline void asmg_arc_del(asmg_t *g, uint64_t v, uint64_t w, uint32_t del)
{
    uint64_t i, nv = asmg_arc_n(g, v);
    asmg_arc_t *av = asmg_arc_a(g, v);
    for (i = 0; i < nv; ++i)
        if (av[i].w == w)
            av[i].del = del;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x10(%rbp), %rdx
imulq $0x30, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x1dba2
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x18(%rbp), %rax
jne 0x1db92
movl -0x1c(%rbp), %edx
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %ecx
andl $0x1, %edx
shll $0x1e, %edx
andl $0xbfffffff, %ecx       # imm = 0xBFFFFFFF
orl %edx, %ecx
movl %ecx, 0x20(%rax)
jmp 0x1db94
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x1db4f
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_tb_destroy
void wf_tb_destroy(wf_tb_t *wf_tb)
{
    if (wf_tb) {
        size_t i;
        for (i = 0; i < wf_tb->n; ++i)
            free(wf_tb->a[i].a);
        free(wf_tb->a);
    }
    free(wf_tb);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1dd00
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0x1dcf3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
callq 0x2060
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1dcbb
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_config_destroy
void wf_config_destroy(wf_config_t *conf, int clean_seq)
{
    if (clean_seq) {
        free(conf->ts);
        free(conf->qs);
    }
    if (conf->wf_diag) {
        free(conf->wf_diag->a);
        free(conf->wf_diag);
    }
    wf_tb_destroy(conf->wf_tb);
    free(conf->cigar);
    free(conf);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1dd3e
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x1dd67
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x1dca0
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_print_cigar
void wf_print_cigar(uint32_t *cigar, int32_t n_cigar, FILE *fo)
{
    if (!cigar || !n_cigar)
        return;

    int32_t i;
    fprintf(fo, "CIGAR_STR [%d]: ", n_cigar);
    for (i = 0; i < n_cigar; ++i) {
        fprintf(fo, "%d%c", cigar[i]>>4, "MIDNSHP=XB"[cigar[i]&0xf]);
    }
    fputc('\n', fo);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x1ec10
cmpl $0x0, -0xc(%rbp)
jne 0x1ec12
jmp 0x1ec8c
movq -0x18(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq 0xfdc7(%rip), %rsi      # 0x2e9e7
movb $0x0, %al
callq 0x2290
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1ec7e
movq -0x18(%rbp), %rdi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
shrl $0x4, %edx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0xf, %eax
movl %eax, %eax
movl %eax, %ecx
leaq 0xfd9c(%rip), %rax      # 0x2e9fd
movsbl (%rax,%rcx), %ecx
leaq 0xfd8c(%rip), %rsi      # 0x2e9f8
movb $0x0, %al
callq 0x2290
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1ec2e
movq -0x18(%rbp), %rsi
movl $0xa, %edi
callq 0x2220
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: kputcn_
static inline void kputcn_(int c, int l, kstring_t *s)
{
    if (s->l + l > s->m) {
        s->m = s->l + l;
        kroundup32(s->m);
        MYREALLOC(s->s, s->m);
    }
    while(l-- > 0) s->s[s->l++] = c;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movslq -0x8(%rbp), %rcx
addq %rcx, %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1f2ff
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movslq -0x8(%rbp), %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x10(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x0, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1f301
movl -0x8(%rbp), %eax
movl %eax, %ecx
addl $-0x1, %ecx
movl %ecx, -0x8(%rbp)
cmpl $0x0, %eax
jle 0x1f334
movl -0x4(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movb %dl, (%rax,%rcx)
jmp 0x1f301
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_extend
static inline int32_t wf_extend(int32_t tl, const char *ts, int32_t ql, const char *qs, const wf_diag1_t *p)
{
    int32_t k = p->k;
    const char *ts_, *qs_;
    uint64_t cmp = 0;
    int32_t max_k = (ql - p->d < tl? ql - p->d : tl) - 1;
    ts_ = ts + 1;
    qs_ = qs + p->d + 1;
    while (k + 7 < max_k) {
        uint64_t x = *(uint64_t*)(ts_ + k); // warning: unaligned memory access
        uint64_t y = *(uint64_t*)(qs_ + k);
        cmp = x ^ y;
        if (cmp == 0) k += 8;
        else break;
    }
    if (cmp)
        k += __builtin_ctzl(cmp) >> 3; // on x86, this is done via the BSR instruction: https://www.felixcloutier.com/x86/bsr
    else if (k + 7 >= max_k)
        while (k < max_k && *(ts_ + k) == *(qs_ + k)) // use this for generic CPUs. It is slightly faster than the unoptimized version
            ++k;
    return k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq $0x0, -0x48(%rbp)
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
cmpl -0x4(%rbp), %eax
jge 0x1f5d4
movl -0x14(%rbp), %eax
movq -0x28(%rbp), %rcx
subl (%rcx), %eax
movl %eax, -0x64(%rbp)
jmp 0x1f5da
movl -0x4(%rbp), %eax
movl %eax, -0x64(%rbp)
movl -0x64(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movslq (%rcx), %rcx
addq %rcx, %rax
addq $0x1, %rax
movq %rax, -0x40(%rbp)
movl -0x2c(%rbp), %eax
addl $0x7, %eax
cmpl -0x4c(%rbp), %eax
jge 0x1f652
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x58(%rbp)
movq -0x40(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq (%rax,%rcx), %rax
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rax
xorq -0x60(%rbp), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, -0x48(%rbp)
jne 0x1f64e
movl -0x2c(%rbp), %eax
addl $0x8, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f650
jmp 0x1f652
jmp 0x1f605
cmpq $0x0, -0x48(%rbp)
je 0x1f66d
movq -0x48(%rbp), %rax
tzcntq %rax, %rax
sarl $0x3, %eax
addl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f6bf
movl -0x2c(%rbp), %eax
addl $0x7, %eax
cmpl -0x4c(%rbp), %eax
jl 0x1f6bd
jmp 0x1f67a
movl -0x2c(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4c(%rbp), %ecx
movb %al, -0x65(%rbp)
jge 0x1f6a7
movq -0x38(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x40(%rbp), %rcx
movslq -0x2c(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x65(%rbp)
movb -0x65(%rbp), %al
testb $0x1, %al
jne 0x1f6b0
jmp 0x1f6bb
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f67a
jmp 0x1f6bd
jmp 0x1f6bf
movl -0x2c(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_prune_bw
static inline void wf_prune_bw(int32_t tl, int32_t ql, int32_t is_ext, int32_t bw, int32_t *st, int32_t *en, const wf_diag1_t *b)
{
    int32_t min_d, max_d, s = *st, e = *en;
    if (is_ext) {
        min_d = -bw, max_d = bw;
    } else {
        min_d = ql < tl? ql - tl - bw : tl - ql - bw;
        max_d = tl > ql? tl - ql + bw : ql - tl + bw;
    }
    min_d = min_d > -tl? min_d : -tl;
    max_d = max_d >  ql? max_d :  ql;
    while (b[s].d < min_d) ++s;
    while (b[e - 1].d > max_d) --e;
    *st = s, *en = e;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x10(%rbp), %rax
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl %edx, -0xc(%rbp)
movl %ecx, -0x10(%rbp)
movq %r8, -0x18(%rbp)
movq %r9, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x1f714
xorl %eax, %eax
subl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x28(%rbp)
jmp 0x1f764
movl -0x8(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1f72a
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x1f736
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
subl -0x10(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x1f752
movl -0x4(%rbp), %eax
subl -0x8(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
jmp 0x1f75e
movl -0x8(%rbp), %eax
subl -0x4(%rbp), %eax
addl -0x10(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x38(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
xorl %ecx, %ecx
subl -0x4(%rbp), %ecx
cmpl %ecx, %eax
jle 0x1f778
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x1f780
xorl %eax, %eax
subl -0x4(%rbp), %eax
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x8(%rbp), %eax
jle 0x1f796
movl -0x28(%rbp), %eax
movl %eax, -0x40(%rbp)
jmp 0x1f79c
movl -0x8(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %eax
movl %eax, -0x28(%rbp)
movq 0x10(%rbp), %rax
movslq -0x2c(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x24(%rbp), %eax
jge 0x1f7c3
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1f7a2
jmp 0x1f7c5
movq 0x10(%rbp), %rax
movl -0x30(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %eax
cmpl -0x28(%rbp), %eax
jle 0x1f7eb
movl -0x30(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x1f7c5
movl -0x2c(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x30(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_tb_add
static void wf_tb_add(wf_tb_t *tb, int32_t m)
{
    wf_tb1_t *p;
    if (tb->n == tb->m) {
        tb->m = tb->m + (tb->m>>1) + 4;
        MYREALLOC(tb->a, tb->m);
    }
    p = &tb->a[tb->n++];
    p->n = m;
    MYCALLOC(p->a, (m + 31) / 32);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x1f862
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
shrq %rax
addq %rax, %rcx
addq $0x4, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rsi
shlq $0x4, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x8(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x8(%rdx)
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %eax
addl $0x1f, %eax
movl $0x20, %ecx
cltd
idivl %ecx
movslq %eax, %rdi
movl $0x8, %esi
callq 0x2250
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/levdist.c
// Function: wf_cigar_push1
static void wf_cigar_push1(wf_cigar_t *c, int32_t op, int32_t len)
{
    if (c->n && op == (c->cigar[c->n-1]&0xf)) {
        c->cigar[c->n-1] += len<<4;
    } else {
        if (c->n == c->m) {
            c->m = c->m + (c->m>>1) + 4;
            MYREALLOC(c->cigar, c->m);
        }
        c->cigar[c->n++] = len<<4 | op;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
je 0x1f921
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
movq 0x8(%rcx), %rcx
movq -0x8(%rbp), %rdx
movl 0x4(%rdx), %edx
subl $0x1, %edx
movslq %edx, %rdx
movl (%rcx,%rdx,4), %ecx
andl $0xf, %ecx
cmpl %ecx, %eax
jne 0x1f921
movl -0x10(%rbp), %edx
shll $0x4, %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movl 0x4(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
addl (%rax,%rcx,4), %edx
movl %edx, (%rax,%rcx,4)
jmp 0x1f992
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x1f96c
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movl (%rax), %eax
sarl %eax
addl %eax, %ecx
addl $0x4, %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x10(%rbp), %edx
shll $0x4, %edx
orl -0xc(%rbp), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rsi
movl 0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_destroy
void asmg_destroy(asmg_t *g)
{
    uint64_t i;
    for (i = 0; i < g->n_vtx; ++i)
        asmg_vtx_destroy(&g->vtx[i]);
    if (g->vtx) free(g->vtx);
    if (g->arc) free(g->arc);
    if (g->idx_p) free(g->idx_p);
    if (g->idx_n) free(g->idx_n);
    free(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1f9e4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x28, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x1fa60
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1f9b4
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1f9fc
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1fa14
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1fa2c
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x1fa44
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_arc_is_sorted
int asmg_arc_is_sorted(asmg_t *g)
{
    uint64_t e;
    for (e = 1; e < g->n_arc; ++e)
        if (g->arc[e-1].v > g->arc[e].v ||
                (g->arc[e-1].v == g->arc[e].v && g->arc[e-1].w > g->arc[e].w))
            break;
    return (e == g->n_arc);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x1fb76
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
imulq $0x30, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
ja 0x1fb61
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
imulq $0x30, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
jne 0x1fb63
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
subq $0x1, %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
imulq $0x30, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jbe 0x1fb63
jmp 0x1fb76
jmp 0x1fb65
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1fac0
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
sete %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_arc_index
void asmg_arc_index(asmg_t *g)
{
    uint64_t i, last, n, v, *idx_p, *idx_n;
    asmg_arc_t *a;

    if (g->idx_p) {
        free(g->idx_p);
        free(g->idx_n);
    }

    MYCALLOC(idx_p, g->n_vtx * 2);
    MYCALLOC(idx_n, g->n_vtx * 2);
    g->idx_p = idx_p;
    g->idx_n = idx_n;

    if (!g->n_arc) return;

    a = g->arc;
    n = g->n_arc;
    v = asmg_arc_head(a[0]);
    for (i = 1, last = 0; i < n; ++i) {
        if (v != asmg_arc_head(a[i])) {
            idx_p[v] = last;
            idx_n[v] = i - last;
            last = i;
            v = asmg_arc_head(a[i]);
        }
    }
    idx_p[v] = last;
    idx_n[v] = i - last;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1fca1
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq (%rax), %rdi
shlq %rdi
movl $0x8, %esi
callq 0x2250
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
shlq %rdi
movl $0x8, %esi
callq 0x2250
movq %rax, -0x38(%rbp)
movq -0x30(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x38(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x1fcf9
jmp 0x1fdbe
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq $0x1, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x1fd9a
movq -0x28(%rbp), %rax
movq -0x40(%rbp), %rcx
imulq $0x30, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq (%rcx), %rax
je 0x1fd8a
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
subq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x40(%rbp), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x1fd8c
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1fd2c
movq -0x18(%rbp), %rdx
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rdx
subq -0x18(%rbp), %rdx
movq -0x38(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_max_link_id
uint64_t asmg_max_link_id(asmg_t *g)
{
    uint64_t i, n, link_id;

    link_id = 0;
    for (i = 0, n = g->n_arc; i < n; ++i)
        link_id = MAX(link_id, g->arc[i].link_id);

    return link_id;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1fe50
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x28(%rcx), %rcx
imulq $0x30, -0x10(%rbp), %rdx
addq %rdx, %rcx
cmpq 0x28(%rcx), %rax
jbe 0x1fe22
movq -0x20(%rbp), %rax
movq %rax, -0x28(%rbp)
jmp 0x1fe3a
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq 0x28(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1fdf4
movq -0x20(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_shrink_link_id
void asmg_shrink_link_id(asmg_t *g)
{
    uint64_t i, n, link_id;
    asmg_arc_t *a;
    
    for (i = 0, n = g->n_arc; i < n; ++i)
        g->arc[i].link_id |= 0x8000000000000000;

    link_id = 0;
    for (i = 0, n = g->n_arc; i < n; ++i) {
        a = &g->arc[i];
        if (a->link_id & 0x8000000000000000) {
            a->link_id = link_id;
            a = asmg_arc(g, a->w^1, a->v^1);
            a->link_id = link_id;
            ++link_id;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1feba
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
orq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1fe80
movq $0x0, -0x20(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x1ff6b
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rcx
movabsq $-0x8000000000000000, %rax # imm = 0x8000000000000000
andq 0x28(%rcx), %rax
cmpq $0x0, %rax
je 0x1ff58
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rsi
xorq $0x1, %rsi
movq -0x28(%rbp), %rax
movq (%rax), %rdx
xorq $0x1, %rdx
callq 0x1ff80
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rcx
movq -0x28(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x1ff5a
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1fed6
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_arc_fix_cov
void asmg_arc_fix_cov(asmg_t *g)
{
    uint64_t i, n;
    uint32_t c;
    asmg_arc_t *arc;
    for (i = 0, n = g->n_arc; i < n; ++i) {
        arc = &g->arc[i];
        if (arc->del) continue;
        c = MIN(g->vtx[arc->v >> 1].cov, g->vtx[arc->w >> 1].cov);
        if (c < arc->cov) arc->cov = c;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x20150
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
imulq $0x30, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x20075
jmp 0x2013f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x28(%rbp), %rdx
movq 0x8(%rdx), %rdx
shrq %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl 0x20(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
jge 0x200e3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq (%rcx), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x2c(%rbp)
jmp 0x20108
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq 0x8(%rcx), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x28(%rbp), %rcx
movl 0x20(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
cmpl %ecx, %eax
jae 0x2013d
movl -0x1c(%rbp), %edx
movq -0x28(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl %edx, %ecx
movl %ecx, 0x20(%rax)
jmp 0x2013f
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x2003c
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_finalize
void asmg_finalize(asmg_t *g, int do_cleanup) 
{
    // TODO fix multi-arc
    uint32_t symm_fix;
    if (do_cleanup) asmg_cleanup(g);
    asmg_arc_sort(g);
    asmg_arc_index(g);
    symm_fix = asmg_arc_fix_symm(g);
    if (symm_fix > 0) {
        asmg_arc_sort(g);
        asmg_arc_index(g);
    }
    asmg_shrink_link_id(g);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x2017e
movq -0x8(%rbp), %rdi
callq 0x201d0
movq -0x8(%rbp), %rdi
callq 0x1fb90
movq -0x8(%rbp), %rdi
callq 0x1fc70
movq -0x8(%rbp), %rdi
callq 0x20510
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jbe 0x201b4
movq -0x8(%rbp), %rdi
callq 0x1fb90
movq -0x8(%rbp), %rdi
callq 0x1fc70
movq -0x8(%rbp), %rdi
callq 0x1fe60
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_vtx_list
uint64_t *asmg_vtx_list(asmg_t *g, uint64_t *_n)
{
    uint64_t i;
    u64_v_t vlist = {0, 0, 0};
    for (i = 0; i < g->n_vtx; ++i)
        if (!g->vtx[i].del)
            kv_push(uint64_t, vlist, i);
    MYREALLOC(vlist.a, vlist.n);
    
    if (_n) *_n = vlist.n;

    return vlist.a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x21f0
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x207cf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x207bc
jmp 0x20759
movq -0x30(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x2079f
cmpq $0x0, -0x28(%rbp)
je 0x20777
movq -0x28(%rbp), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x20782
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x20782
movq -0x38(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdx
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x30(%rbp)
movq %rdx, (%rax,%rcx,8)
jmp 0x207bc
jmp 0x207be
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x20728
movq -0x20(%rbp), %rdi
movq -0x30(%rbp), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x207f6
movq -0x30(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_a1
static inline asmg_arc_t *asmg_arc_a1(asmg_t *g, uint64_t v)
{
    uint64_t i, n;
    asmg_arc_t *a;

    a = asmg_arc_a(g, v);
    n = asmg_arc_n(g, v);
    for (i = 0; i < n; ++i)
        if (!a[i].del)
            return &a[i];

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x18(%rbp), %rdx
imulq $0x30, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jae 0x2114e
movq -0x30(%rbp), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2113e
movq -0x30(%rbp), %rax
imulq $0x30, -0x20(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x21156
jmp 0x21140
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0x21108
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_cwt_len
static uint64_t asmg_cwt_len(asmg_t *g, uint64_t *v, uint64_t nv)
{
    if (nv == 0) return 0;
    uint64_t i, wt_l, ov_l;
    wt_l = g->vtx[v[0]>>1].len * g->vtx[v[0]>>1].cov;
    for (i = 1; i < nv; ++i) {
        ov_l = asmg_arc(g, v[i-1], v[i])->ls;
        wt_l += (g->vtx[v[i]>>1].len - ov_l) * g->vtx[v[i]>>1].cov;
    }
    return wt_l;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x21758
movq $0x0, -0x8(%rbp)
jmp 0x21858
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rcx), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rdx), %rdx
shrq %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl 0x20(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movl %ecx, %ecx
imulq %rcx, %rax
movq %rax, -0x30(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x21850
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rsi
movq -0x18(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
callq 0x1ff80
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq -0x28(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rax
subq -0x38(%rbp), %rax
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq -0x28(%rbp), %rsi
movq (%rdx,%rsi,8), %rdx
shrq %rdx
imulq $0x28, %rdx, %rdx
addq %rdx, %rcx
movl 0x20(%rcx), %ecx
andl $0x3fffffff, %ecx       # imm = 0x3FFFFFFF
movl %ecx, %ecx
imulq %rcx, %rax
addq -0x30(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x217a9
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/c-zhou[P]oatk/graph.c
// Function: asmg_tbuf_init
static asmg_tbuf_t *asmg_tbuf_init(asmg_t *g)
{
    uint64_t v, n_vtx;
    n_vtx = asmg_vtx_n(g);
    asmg_tbuf_t *b;
    MYCALLOC(b, 1);
    MYCALLOC(b->a, n_vtx);
    for (v = 0; v < n_vtx; ++v)
        b->a[v].p = UINT64_MAX;
    return b;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
shlq %rax
movq %rax, -0x18(%rbp)
movl $0x1, %edi
movl $0x78, %esi
callq 0x2250
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rdi
movl $0x20, %esi
callq 0x2250
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x21f3e
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq $-0x1, (%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x21f0d
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_bub_pop1
static uint64_t asmg_bub_pop1(asmg_t *g, uint64_t v0, uint64_t radius, uint64_t max_del, int protect_tip, int protect_super_bubble, asmg_tbuf_t *b)
{
    uint64_t ret = 0;
    if (asmg_arc_n1(g, v0) < 2) return 0; // no bubbles
    asmg_topo_ext(g, v0, g->vtx[v0>>1].len + radius, protect_tip? 0 : ASMG_TE_THRU_SHORT_TIP, b);
    if (b->n_sink) {
        ret = asmg_bub_backtrack(g, v0, max_del, protect_super_bubble, b);
        if (ret) ret |= (uint64_t) b->n_short_tip << 32;
    }
    asmg_tbuf_reset(b);
    return ret;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq %rcx, -0x28(%rbp)
movl %r8d, -0x2c(%rbp)
movl %r9d, -0x30(%rbp)
movq $0x0, -0x38(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x21690
cmpq $0x2, %rax
jae 0x21f9c
movq $0x0, -0x8(%rbp)
jmp 0x22034
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
shrq %rcx
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdx
addq -0x20(%rbp), %rdx
movl -0x2c(%rbp), %r8d
movl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %r8d
cmovnel %eax, %ecx
movq 0x10(%rbp), %r8
callq 0x24bc0
movq 0x10(%rbp), %rax
cmpq $0x0, 0x58(%rax)
je 0x22023
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdx
movl -0x30(%rbp), %ecx
movq 0x10(%rbp), %r8
callq 0x25490
cltq
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x22021
movq 0x10(%rbp), %rax
movq 0x50(%rax), %rax
shlq $0x20, %rax
orq -0x38(%rbp), %rax
movq %rax, -0x38(%rbp)
jmp 0x22023
movq 0x10(%rbp), %rdi
callq 0x259d0
movq -0x38(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/graph.c
// Function: asmg_tbuf_destroy
static void asmg_tbuf_destroy(asmg_tbuf_t *b)
{
    if (b == 0)
        return;
    free(b->a);
    free(b->S.a);
    free(b->b.a);
    free(b->e.a);
    free(b);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x22055
jmp 0x22091
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_exist1
static inline int asmg_arc_exist1(asmg_t *g, uint64_t v, uint64_t w)
{
    uint64_t i, n;
    asmg_arc_t *a;

    a = asmg_arc_a(g, v);
    n = asmg_arc_n(g, v);
    for (i = 0; i < n; ++i)
        if (a[i].w == w && !a[i].del)
            return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x30(%rcx), %rcx
movq -0x18(%rbp), %rdx
imulq $0x30, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0x2357f
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x2356f
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
jne 0x2356f
movl $0x1, -0x4(%rbp)
jmp 0x23586
jmp 0x23571
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2352c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)