LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc1
static inline asmg_arc_t *asmg_arc1(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 &a[i];

    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 0x98d8
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
cmpq -0x20(%rbp), %rax
jne 0x98c8
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 0x98c8
movq -0x38(%rbp), %rax
imulq $0x30, -0x28(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0x98e0
jmp 0x98ca
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x987c
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: scg_add_utg_p
static inline uint64_t scg_add_utg_p(asmg_t *g, scg_utg_t **p) {
    if (g->n_vtx == g->m_vtx)
        MYEXPAND(g->vtx, g->m_vtx);
    ++g->n_vtx;
    *p = &g->vtx[g->n_vtx-1];
    return g->n_vtx-1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9a19
jmp 0x9937
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq 0x8(%rax), %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x28, 0x8(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x9a19
movq -0x8(%rbp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
imulq $0x28, %rax, %rax
addq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
subq $0x1, %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: vec_add
static inline void vec_add(u64_v_t *v_vec, uint64_t *v, size_t n, int r)
{
    size_t i, j;
    if (r) {
        for (i = 0, j = n-1; i < n; ++i, --j)
            kv_push(uint64_t, *v_vec, v[j]^1);
    } else {
        for (i = 0; i < n; ++i)
            kv_push(uint64_t, *v_vec, v[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x9b5e
movq $0x0, -0x28(%rbp)
movq -0x18(%rbp), %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9b59
jmp 0x9aa5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9b0d
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9ad2
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x38(%rbp)
jmp 0x9add
movl $0x2, %eax
movq %rax, -0x38(%rbp)
jmp 0x9add
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 $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x30(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
xorq $0x1, %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x9b3c
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
movq -0x30(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0x9a95
jmp 0x9c1c
movq $0x0, -0x28(%rbp)
movq -0x28(%rbp), %rax
cmpq -0x18(%rbp), %rax
jae 0x9c1a
jmp 0x9b76
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x9bde
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x9ba3
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x40(%rbp)
jmp 0x9bae
movl $0x2, %eax
movq %rax, -0x40(%rbp)
jmp 0x9bae
movq -0x40(%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 $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
jmp 0x9c09
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x9b66
jmp 0x9c1c
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/./graph.h
// Function: asmg_arc_add
static inline asmg_arc_t *asmg_arc_add(asmg_t *g, uint64_t v, uint64_t w, uint64_t ln, uint64_t ls, uint64_t link_id, uint32_t cov, uint32_t comp)
{
    asmg_arc_t *a;
    if (g->n_arc == g->m_arc)
        MYEXPAND(g->arc, g->m_arc);
    a = &g->arc[g->n_arc++];
    a->v = v;
    a->w = w;
    a->ln = ln;
    a->ls = ls;
    a->link_id = link_id;
    a->cov = cov;
    a->del = 0;
    a->comp = comp;
    return a;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x20(%rcx), %rax
jne 0x9e00
jmp 0x9d1e
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x2, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x4, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x8, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x10, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
shrq $0x20, %rcx
movq -0x8(%rbp), %rax
orq 0x20(%rax), %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
imulq $0x30, 0x20(%rax), %rsi
callq 0x2360
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0x9e00
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq -0x8(%rbp), %rdx
movq 0x18(%rdx), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0x18(%rdx)
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x10(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x30(%rbp), %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x28(%rax)
movl 0x10(%rbp), %edx
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0xbfffffff, %ecx       # imm = 0xBFFFFFFF
orl $0x0, %ecx
movl %ecx, 0x20(%rax)
movl 0x18(%rbp), %edx
movq -0x38(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x1, %edx
shll $0x1f, %edx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
orl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: average_IQR
static double average_IQR(double *a, int n, int sorted)
{
    if (n == 0) return 0.;

    double Q1, Q3, IQR, s;
    int i, n0;
    if (!sorted) qsort(a, n, sizeof(double), dbl_cmpfunc);
    Q1 = quantile(a, n, 0.25, 1);
    Q3 = quantile(a, n, 0.75, 1);
    IQR = Q3 - Q1;
    Q1 -= 1.5 * IQR;
    Q3 += 1.5 * IQR;
    n0 = 0;
    s = 0.;
    for (i = 0; i < n; ++i) {
        if (a[i] >= Q1 && a[i] <= Q3) {
            ++n0;
            s += a[i];
        }
    }
#ifdef DEBUG_UTG_RA_COV
    fprintf(stderr, "[DEBUG_UTG_RA_COV::%s] %d single copy syncmers:",
            __func__, n);
    for (i = 0; i < n; ++i) fprintf(stderr, " %.0f", a[i]);
    fputc('\n', stderr);
    fprintf(stderr, "[DEBUG_UTG_RA_COV::%s] %d outliers out of range [%.3f %.3f] removed\n",
            __func__, n - n0, Q1, Q3);
#endif
    return n0? s / n0 : 0.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
jne 0xbb45
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xbc93
cmpl $0x0, -0x18(%rbp)
jne 0xbb64
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movl $0x8, %edx
leaq -0x8f(%rip), %rcx       # 0xbad0
callq 0x20d0
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd 0x21c3d(%rip), %xmm0    # 0x2d7b0
movl $0x1, %edx
callq 0x10830
movsd %xmm0, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movl -0x14(%rbp), %esi
movsd 0x21c17(%rip), %xmm0    # 0x2d7a8
movl $0x1, %edx
callq 0x10830
movsd %xmm0, -0x28(%rbp)
movsd -0x28(%rbp), %xmm0
subsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x20(%rbp), %xmm1
movsd 0x21bdf(%rip), %xmm2    # 0x2d7a0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x20(%rbp)
movsd -0x30(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
movsd 0x21bb8(%rip), %xmm2    # 0x2d798
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x40(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x38(%rbp)
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0xbc64
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x20(%rbp), %xmm0
jb 0xbc57
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movsd -0x28(%rbp), %xmm0
ucomisd %xmm1, %xmm0
jb 0xbc57
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
addsd -0x38(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xbc59
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0xbc03
cmpl $0x0, -0x40(%rbp)
je 0xbc7f
movsd -0x38(%rbp), %xmm0
cvtsi2sdl -0x40(%rbp), %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0xbc89
xorps %xmm0, %xmm0
movsd %xmm0, -0x48(%rbp)
jmp 0xbc89
movsd -0x48(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x50, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: add_ovl_count
static inline void add_ovl_count(kh_generic_t *h, int key)
{
    int absent;
    khint_t k;
    k = kh_generic_put(h, key, &absent);
    if (absent)
        kh_val(h, k) = 1;
    else
        ++kh_val(h, k);
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x10(%rbp), %rdx
callq 0xe400
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0xe3dd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl $0x1, 0x4(%rax,%rcx,8)
jmp 0xe3f3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: quantile
static double quantile(double *a, int n, double q, int sorted)
{
    if (q < 0 || q > 1.0 || n <= 0) {
        fprintf(stderr, "[E::%s] numeric error", __func__);
        exit(EXIT_FAILURE);
    }
    if (n == 1) return a[0];
    if (!sorted) qsort(a, n, sizeof(double), dbl_cmpfunc);
    double fractpart, intpart;
    fractpart = modf(q * (n - 1), &intpart);
    int i = lround(intpart);
    if (i == n - 1) return a[i];
    return a[i] + (a[i + 1] - a[i]) * fractpart;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movsd %xmm0, -0x20(%rbp)
movl %edx, -0x24(%rbp)
xorps %xmm0, %xmm0
ucomisd -0x20(%rbp), %xmm0
ja 0x1086a
movsd -0x20(%rbp), %xmm0
movsd 0x1cf2a(%rip), %xmm1    # 0x2d788
ucomisd %xmm1, %xmm0
ja 0x1086a
cmpl $0x0, -0x14(%rbp)
jg 0x10893
movq 0x23787(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1d4e5(%rip), %rsi     # 0x2dd60
leaq 0x1d4f4(%rip), %rdx     # 0x2dd76
movb $0x0, %al
callq 0x2290
movl $0x1, %edi
callq 0x2450
cmpl $0x1, -0x14(%rbp)
jne 0x108ab
movq -0x10(%rbp), %rax
movsd (%rax), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x10957
cmpl $0x0, -0x24(%rbp)
jne 0x108ca
movq -0x10(%rbp), %rdi
movslq -0x14(%rbp), %rsi
movl $0x8, %edx
leaq -0x4df5(%rip), %rcx     # 0xbad0
callq 0x20d0
movsd -0x20(%rbp), %xmm0
movl -0x14(%rbp), %eax
subl $0x1, %eax
cvtsi2sd %eax, %xmm1
mulsd %xmm1, %xmm0
leaq -0x38(%rbp), %rdi
callq 0x21b0
movsd %xmm0, -0x30(%rbp)
movsd -0x38(%rbp), %xmm0
callq 0x2110
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x10919
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x10957
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
movsd (%rax,%rcx,8), %xmm1
movq -0x10(%rbp), %rax
movl -0x3c(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movsd (%rax,%rcx,8), %xmm0
movq -0x10(%rbp), %rax
movslq -0x3c(%rbp), %rcx
subsd (%rax,%rcx,8), %xmm0
movsd -0x30(%rbp), %xmm2
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: lcs_backtrace
static void lcs_backtrace(int **L, uint64_t *s_scm, int s_n, uint64_t *u_scm, int u_n, int offset, lcs_block_t *t)
{
    if (s_n == 0 || u_n == 0)
        return;
    if ((s_scm[s_n] >> 1) == (u_scm[u_n] >> 1)) {
        kv_push(uint64_t, *t, (uint64_t) (s_n - 1 + offset) << 32 | 1);
        return lcs_backtrace(L, s_scm, s_n - 1, u_scm, u_n - 1, offset, t);
    }
    if (L[s_n][u_n - 1] > L[s_n - 1][u_n])
        return lcs_backtrace(L, s_scm, s_n, u_scm, u_n - 1, offset, t);
    return lcs_backtrace(L, s_scm, s_n - 1, u_scm, u_n, offset, t);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq %rcx, -0x20(%rbp)
movl %r8d, -0x24(%rbp)
movl %r9d, -0x28(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x10eef
cmpl $0x0, -0x24(%rbp)
jne 0x10ef4
jmp 0x11069
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq %rax
movq -0x20(%rbp), %rcx
movslq -0x24(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq %rcx
cmpq %rcx, %rax
jne 0x10fe6
jmp 0x10f1d
movq 0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0x10f85
movq 0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x10f4a
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rax
shlq %rax
movq %rax, -0x30(%rbp)
jmp 0x10f55
movl $0x2, %eax
movq %rax, -0x30(%rbp)
jmp 0x10f55
movq -0x30(%rbp), %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rbp), %rax
movq 0x8(%rax), %rsi
shlq $0x3, %rsi
callq 0x2360
movq %rax, %rcx
movq 0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
addl -0x28(%rbp), %eax
movslq %eax, %rdx
shlq $0x20, %rdx
orq $0x1, %rdx
movq 0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rbp), %rsi
movq (%rsi), %rcx
movq %rcx, %rdi
addq $0x1, %rdi
movq %rdi, (%rsi)
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
subl $0x1, %r8d
movl -0x28(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x10ec0
jmp 0x11069
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x24(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movq -0x8(%rbp), %rcx
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x24(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x11042
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
subl $0x1, %r8d
movl -0x28(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x10ec0
jmp 0x11069
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
subl $0x1, %edx
movq -0x20(%rbp), %rcx
movl -0x24(%rbp), %r8d
movl -0x28(%rbp), %r9d
movq 0x10(%rbp), %rax
movq %rax, (%rsp)
callq 0x10ec0
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncasm.c
// Function: lcs_block_merge
static void lcs_block_merge(lcs_block_t *blocks)
{
    // merge blocks
    size_t k, p;
    if (blocks->n > 1) {
        for (p = 0, k = 1; k < blocks->n; ++k) {
            if ((blocks->a[p] >> 32) + (uint32_t) blocks->a[p] == (blocks->a[k] >> 32))
                blocks->a[p] += (uint32_t) blocks->a[k];
            else
                blocks->a[++p] = blocks->a[k];
        }
        blocks->n = p + 1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x1, (%rax)
jbe 0x11161
movq $0x0, -0x18(%rbp)
movq $0x1, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x11152
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rax
shrq $0x20, %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movl %ecx, %ecx
addq %rcx, %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movq -0x10(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
shrq $0x20, %rcx
cmpq %rcx, %rax
jne 0x11113
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl %eax, %eax
movl %eax, %edx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x1113f
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movq %rdx, 0x8(%rax,%rcx,8)
jmp 0x11141
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x11096
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: sr_db_clean
void sr_db_clean(sr_db_t *sr_db)
{
    if (!sr_db) return;
    size_t i;
    for (i = 0; i < sr_db->n; ++i)
        sr_destroy(&sr_db->a[i]);
    kv_destroy(*sr_db);
    free(sr_db->stats);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12225
jmp 0x12277
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x1225d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
imulq $0x58, -0x10(%rbp), %rax
addq %rax, %rdi
callq 0x13bd0
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x1222d
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: sr_db_init
void sr_db_init(sr_db_t *sr_db, int k, int s)
{
    if (!sr_db) return;
    kv_init(*sr_db);
    sr_db->k = k;
    sr_db->s = s;
    sr_db->stats = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x12297
jmp 0x122da
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movl -0x10(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x1c(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_ctab_put1
static void kh_ctab_put1(kh_ctab_t *ctab, int c)
{
    int absent;
    khint_t k;
    k = kh_ctab_put(ctab, c, &absent);
    if (absent)
        kh_val(ctab, k) = 1;
    else
        ++kh_val(ctab, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
leaq -0x10(%rbp), %rdx
callq 0x18230
movl %eax, -0x14(%rbp)
cmpl $0x0, -0x10(%rbp)
je 0x12ebd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl $0x1, 0x4(%rax,%rcx,8)
jmp 0x12ed3
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %edx
addl $0x1, %edx
movl %edx, 0x4(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_ctab_stat
static double kh_ctab_stat(kh_ctab_t *ctab, int *uniq, int *singleton)
{
    khint_t k;
    double sum;
    int s, c, n;
    sum = .0;
    n = c = 0;
    if (kh_size(ctab) == 0)
        goto do_assign;

    for (k = (khint_t) 0; k != kh_end(ctab); ++k) {
        if (kh_exist(ctab, k)) {
            s = kh_key(ctab, k);
            c = kh_val(ctab, k);
            sum += (double) s * c;
            n += c;
        }
    }
    k = kh_ctab_get(ctab, 1);
    if (k < kh_end(ctab))
        c = kh_val(ctab, k);

do_assign:
    if (uniq) *uniq = n;
    if (singleton) *singleton = c;
    
    return sum / n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x28(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x12f19
jmp 0x13028
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x12f43
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x3c(%rbp)
jmp 0x12f4a
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x12f4a
movl -0x38(%rbp), %eax
movl -0x3c(%rbp), %ecx
cmpl %ecx, %eax
je 0x12fcf
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x1c(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x1c(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x12fbf
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x30(%rbp)
cvtsi2sdl -0x2c(%rbp), %xmm0
cvtsi2sdl -0x30(%rbp), %xmm2
movsd -0x28(%rbp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x28(%rbp)
movl -0x30(%rbp), %eax
addl -0x34(%rbp), %eax
movl %eax, -0x34(%rbp)
jmp 0x12fc1
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x12f20
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x18890
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13003
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x44(%rbp)
jmp 0x1300a
xorl %eax, %eax
movl %eax, -0x44(%rbp)
jmp 0x1300a
movl -0x40(%rbp), %eax
movl -0x44(%rbp), %ecx
cmpl %ecx, %eax
jae 0x13026
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x30(%rbp)
jmp 0x13028
cmpq $0x0, -0x10(%rbp)
je 0x13038
movl -0x34(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
cmpq $0x0, -0x18(%rbp)
je 0x13048
movl -0x30(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movsd -0x28(%rbp), %xmm0
cvtsi2sdl -0x34(%rbp), %xmm1
divsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: syncmer_s_cmpfunc
static int syncmer_s_cmpfunc(const void *a, const void *b)
{
    uint64_t x, y;
    uint64_t s, t;
    x = ((syncmer_t *) a)->s;
    y = ((syncmer_t *) b)->s;
    s = ((syncmer_t *) a)->h;
    t = ((syncmer_t *) b)->h;
    return x == y? ((s > t) - (s < t)) : ((x > y) - (x < y));
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x130cc
movq -0x28(%rbp), %rax
cmpq -0x30(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x28(%rbp), %rcx
cmpq -0x30(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
jmp 0x130f2
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
seta %al
andb $0x1, %al
movzbl %al, %eax
movq -0x18(%rbp), %rcx
cmpq -0x20(%rbp), %rcx
setb %cl
andb $0x1, %cl
movzbl %cl, %ecx
subl %ecx, %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_ctab_cnt
static int64_t *kh_ctab_cnt(kh_ctab_t *ctab, int max_n)
{
    int64_t *cnt;
    int s, c;
    khint_t k;

    MYCALLOC(cnt, max_n + 1);
    for (k = (khint_t) 0; k != kh_end(ctab); ++k) {
        if (kh_exist(ctab, k)) {
            s = kh_key(ctab, k);
            c = kh_val(ctab, k);
            if (s < max_n)
                cnt[s] = c;
            else
                cnt[max_n] += c;
        }
    }

    return cnt;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movslq %eax, %rdi
movl $0x8, %esi
callq 0x2250
movq %rax, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
movl %eax, -0x28(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x13150
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13157
xorl %eax, %eax
movl %eax, -0x2c(%rbp)
jmp 0x13157
movl -0x28(%rbp), %eax
movl -0x2c(%rbp), %ecx
cmpl %ecx, %eax
je 0x131eb
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x24(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x24(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x131db
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,8), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x24(%rbp), %ecx
movl 0x4(%rax,%rcx,8), %eax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x131c5
movslq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x131d9
movslq -0x20(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
addq (%rax,%rcx,8), %rdx
movq %rdx, (%rax,%rcx,8)
jmp 0x131db
jmp 0x131dd
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1312d
movq -0x18(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_ctab_print
static void kh_ctab_print(kh_ctab_t *ctab, const char *h, FILE *fo, int more)
{
    khint_t k;
    uint32_t i, n = kh_size(ctab);
    int64_t hist[n];
    int s, c;
    i = 0;
    for (k = (khint_t) 0; k != kh_end(ctab); ++k) {
        if (kh_exist(ctab, k)) {
            s = kh_key(ctab, k);
            c = kh_val(ctab, k);
            hist[i++] = (int64_t) s << 32 | c;
        }
    }

    qsort(hist, n, sizeof(int64_t), int64_cmpfunc);
    hist_plot(hist, n, h, fo);

    if (more > 0) {
        for (i = 0; i < n; ++i)
            fprintf(fo, "[M::%s] [%s CNTS] %ld %d\n", __func__, h, hist[i] >> 32, (int) hist[i]);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
movq %rsp, %rcx
movq %rcx, -0x30(%rbp)
leaq 0xf(,%rax,8), %rdx
andq $-0x10, %rdx
movq %rsp, %rcx
subq %rdx, %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, %rsp
movq %rax, -0x38(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0x139a9
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x50(%rbp)
jmp 0x139b0
xorl %eax, %eax
movl %eax, -0x50(%rbp)
jmp 0x139b0
movl -0x4c(%rbp), %eax
movl -0x50(%rbp), %ecx
cmpl %ecx, %eax
je 0x13a34
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0x20(%rbp), %ecx
shrl $0x5, %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl -0x20(%rbp), %ecx
andl $0x1f, %ecx
shrl %cl, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0x13a24
movq -0x48(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x20(%rbp), %edx
movl (%rcx,%rdx,8), %ecx
movl %ecx, -0x3c(%rbp)
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movl -0x20(%rbp), %edx
movl 0x4(%rcx,%rdx,8), %ecx
movl %ecx, -0x40(%rbp)
movslq -0x3c(%rbp), %rdx
shlq $0x20, %rdx
movslq -0x40(%rbp), %rcx
orq %rcx, %rdx
movl -0x24(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x24(%rbp)
movl %ecx, %ecx
movq %rdx, (%rax,%rcx,8)
jmp 0x13a26
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x13986
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %eax
movl %eax, %esi
movl $0x8, %edx
leaq 0x5067(%rip), %rcx      # 0x18ab0
callq 0x20d0
movq -0x48(%rbp), %rdi
movl -0x28(%rbp), %esi
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
callq 0x18b00
cmpl $0x0, -0x1c(%rbp)
jle 0x13aba
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jae 0x13ab8
movq -0x48(%rbp), %rax
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rcx
movl -0x24(%rbp), %edx
movq (%rax,%rdx,8), %r8
sarq $0x20, %r8
movl -0x24(%rbp), %edx
movq (%rax,%rdx,8), %rax
movl %eax, %r9d
leaq 0x1aa03(%rip), %rsi     # 0x2e4a2
leaq 0x1aa16(%rip), %rdx     # 0x2e4bc
movb $0x0, %al
callq 0x2290
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x13a6f
jmp 0x13aba
movq -0x30(%rbp), %rax
movq %rax, %rsp
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: sr_db_validate
int sr_db_validate(sr_db_t *sr_db)
{
    if (sr_db->n > MAX_RD_NUM) {
        fprintf(stderr, "[E::%s] read number exceeds the limit %llu\n", __func__, MAX_RD_NUM);
        return 1;
    }
    size_t i;
    for (i = 0; i < sr_db->n; ++i) {
        sr_t *s = &sr_db->a[i];
        if (s->n > MAX_RD_SCM) {
            fprintf(stderr, "[E::%s] syncmer number (%u) on read exceeds the limit %llu: %s\n", __func__, s->n, MAX_RD_SCM, s->sname);
            return 2;
        }
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmpq %rcx, (%rax)
jbe 0x13b3a
movq 0x204e7(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
leaq 0x1a681(%rip), %rsi     # 0x2e19c
leaq 0x1a6a6(%rip), %rdx     # 0x2e1c8
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
movb $0x0, %al
callq 0x2290
movl $0x1, -0x4(%rbp)
jmp 0x13bc6
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x13bbf
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x58, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movl 0x38(%rax), %eax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jbe 0x13baf
movq 0x2047f(%rip), %rax     # 0x33ff8
movq (%rax), %rdi
movq -0x20(%rbp), %rax
movl 0x38(%rax), %ecx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %r9
leaq 0x1a645(%rip), %rsi     # 0x2e1d7
leaq 0x1a62f(%rip), %rdx     # 0x2e1c8
movl $0x7fffffff, %r8d       # imm = 0x7FFFFFFF
movb $0x0, %al
callq 0x2290
movl $0x2, -0x4(%rbp)
jmp 0x13bc6
jmp 0x13bb1
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x13b42
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: sr_destroy
void sr_destroy(sr_t *sr)
{
    if (!sr) return;
    if (sr->sname) free(sr->sname);
    if (sr->hoco_s) free(sr->hoco_s);
    if (sr->ho_rl) free(sr->ho_rl);
    if (sr->ho_l_rl) free(sr->ho_l_rl);
    if (sr->n_nucl) free(sr->n_nucl);
    if (sr->s_mer) free(sr->s_mer);
    if (sr->k_mer) free(sr->k_mer);
    if (sr->m_pos) free(sr->m_pos);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13be8
jmp 0x13ca8
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x13c00
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x13c18
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0x13c30
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x13c48
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x13c60
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x48(%rax)
je 0x13c78
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0x13c90
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rdi
callq 0x2060
movq -0x8(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0x13ca8
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rdi
callq 0x2060
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: syncmer_db_init
void syncmer_db_init(syncmer_db_t *scm_db)
{
    if (!scm_db) return;
    kv_init(*scm_db);
    scm_db->c = 0;
    scm_db->h = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13cf1
jmp 0x13d2c
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x20(%rax)
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: syncmer_db_clean
void syncmer_db_clean(syncmer_db_t *scm_db)
{
    if (!scm_db) return;
    size_t i;
    for (i = 0; i < scm_db->n; ++i)
        free(scm_db->a[i].m_pos);
    kv_destroy(*scm_db);
    free(scm_db->c);
    free(scm_db->h);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x13d45
jmp 0x13dab
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x13d84
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
shlq $0x5, %rcx
addq %rcx, %rax
movq 0x18(%rax), %rdi
callq 0x2060
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0x13d4d
movq -0x8(%rbp), %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 0x2060
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: print_syncmer_on_seq
void print_syncmer_on_seq(sr_t *sr, uint32_t n, int k, int w, FILE *fo)
{
    if (n >= sr->n) return;
    if ((sr->m_pos[n]>>1) == MAX_RD_LEN) return; // this is a corrected mer
    fprintf(fo, ">%lu_%d_%u_%lu_%u\t", sr->sid, n, sr->m_pos[n] >> 1, sr->s_mer[n] & 1, sr->m_pos[n] & 1);
    fprintf(fo, "RD:Z:%lu\t", sr->sid);
    fprintf(fo, "MM:Z:");
    fputs_smer(sr->s_mer[n] >> 1, k, fo);
    fputc('\t', fo);
    fprintf(fo, "KH:Z:%lu\n", sr->k_mer[n]);
    fputs_kmer(sr->hoco_s, sr->m_pos[n], w, fo);
    fputc('\n', fo);
}

// 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)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x38(%rcx), %eax
jb 0x13e1a
jmp 0x13f36
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl %eax
movl %eax, %eax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x13e39
jmp 0x13f36
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %esi
movl (%rax,%rsi,4), %r8d
shrl %r8d
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0xc(%rbp), %esi
movq (%rax,%rsi,8), %r9
andq $0x1, %r9
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %esi
movl (%rax,%rsi,4), %eax
andl $0x1, %eax
leaq 0x1a393(%rip), %rsi     # 0x2e217
movl %eax, (%rsp)
movb $0x0, %al
callq 0x2290
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
leaq 0x1a38a(%rip), %rsi     # 0x2e22a
movb $0x0, %al
callq 0x2290
movq -0x20(%rbp), %rdi
leaq 0x1a382(%rip), %rsi     # 0x2e234
movb $0x0, %al
callq 0x2290
movq -0x8(%rbp), %rax
movq 0x48(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdi
shrq %rdi
movl -0x10(%rbp), %esi
movq -0x20(%rbp), %rdx
callq 0x13f40
movq -0x20(%rbp), %rsi
movl $0x9, %edi
callq 0x2220
movq -0x20(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x50(%rax), %rax
movl -0xc(%rbp), %ecx
movq (%rax,%rcx,8), %rdx
leaq 0x1a33b(%rip), %rsi     # 0x2e23a
movb $0x0, %al
callq 0x2290
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0xc(%rbp), %ecx
movl (%rax,%rcx,4), %esi
movl -0x14(%rbp), %edx
movq -0x20(%rbp), %rcx
callq 0x13fb0
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x2220
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: print_aligned_syncmers_on_seq
void print_aligned_syncmers_on_seq(sr_t *sr, int w, uint32_t beg, uint32_t end, FILE *fo)
{
    uint32_t i, j, l, n, p;
    kstring_t s = {0, 0, 0};
    l = sr->hoco_l;
    n = sr->n;
    end = MIN(end, n);
    get_hoco_seq(sr, &s);
    fprintf(fo, "%.*s\n", (int) s.l, s.s);
    for (i = beg; i < end; ++i) {
        p = sr->m_pos[i]>>1;
        if (p == MAX_RD_LEN) continue;
        for (j = 0; j < p; ++j) fputc('*', fo);
        fprintf(fo, "%.*s", w, &s.s[p]);
        for (j = p + w; j < l; ++j) fputc('*', fo);
        fputc('\n', fo);
    }
    free(s.s);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
leaq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0x18, %edx
callq 0x21f0
movq -0x8(%rbp), %rax
movl 0x10(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0x30(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x30(%rbp), %eax
jae 0x142fd
movl -0x14(%rbp), %eax
movl %eax, -0x54(%rbp)
jmp 0x14303
movl -0x30(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x14(%rbp)
movq -0x8(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x14400
movq -0x20(%rbp), %rdi
movq -0x50(%rbp), %rax
movl %eax, %edx
movq -0x40(%rbp), %rcx
leaq 0x1a5ac(%rip), %rsi     # 0x2e8d7
movb $0x0, %al
callq 0x2290
movl -0x10(%rbp), %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x143f1
movq -0x8(%rbp), %rax
movq 0x40(%rax), %rax
movl -0x24(%rbp), %ecx
movl (%rax,%rcx,4), %eax
shrl %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpq $0x7fffffff, %rax       # imm = 0x7FFFFFFF
jne 0x14364
jmp 0x143e3
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x34(%rbp), %eax
jae 0x1438c
movq -0x20(%rbp), %rsi
movl $0x2a, %edi
callq 0x2220
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1436b
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %edx
movq -0x40(%rbp), %rcx
movl -0x34(%rbp), %eax
addq %rax, %rcx
leaq 0x19ea0(%rip), %rsi     # 0x2e244
movb $0x0, %al
callq 0x2290
movl -0x34(%rbp), %eax
addl -0xc(%rbp), %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jae 0x143d5
movq -0x20(%rbp), %rsi
movl $0x2a, %edi
callq 0x2220
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x143b4
movq -0x20(%rbp), %rsi
movl $0xa, %edi
callq 0x2220
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x14338
movq -0x40(%rbp), %rdi
callq 0x2060
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: get_kmer_seq
void get_kmer_seq(uint8_t *hoco_s, uint32_t pos, int l, uint32_t rev, uint8_t *kmer_s)
{
    int i, j;
    uint8_t t;
    uint32_t p;
    for (i = 0; i < l; ++i) {
        p = pos + i;
        kmer_s[i] = (hoco_s[p/4]>>(((p&3)^3)<<1))&3;
    }
    if (rev) {
        for (i = 0, j = l - 1; i < j; ++i, --j) {
            t = kmer_s[i];
            kmer_s[i] = (kmer_s[j]^3)&3;
            kmer_s[j] = (t^3)&3;
        }
        if (i == j) kmer_s[i] = (kmer_s[i]^3)&3;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x14685
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl -0x30(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl -0x30(%rbp), %ecx
andl $0x3, %ecx
xorl $0x3, %ecx
shll %ecx
sarl %cl, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1463c
cmpl $0x0, -0x14(%rbp)
je 0x14728
movl $0x0, -0x24(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x146ff
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x29(%rbp)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movzbl (%rax,%rcx), %eax
xorl $0x3, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movzbl -0x29(%rbp), %eax
xorl $0x3, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x1469f
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x14726
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
xorl $0x3, %eax
andl $0x3, %eax
movb %al, %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x14728
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: get_kmer_dna_seq
void get_kmer_dna_seq(uint8_t *hoco_s, uint32_t pos, int l, uint32_t rev, char *dna_seq)
{
    int i, j;
    uint32_t p;
    for (i = 0; i < l; ++i) {
        p = pos + i;
        dna_seq[i] = char_nt4_table[(hoco_s[p/4]>>(((p&3)^3)<<1))&3];
    }
    if (rev) {
        char t;
        for (i = 0, j = l - 1; i < j; ++i, --j) {
            t = dna_seq[i];
            dna_seq[i] = seq_nt4_comp_table[(int) dna_seq[j]];
            dna_seq[j] = seq_nt4_comp_table[(int) t];
        }
        if (i == j) dna_seq[i] = seq_nt4_comp_table[(int) dna_seq[j]];
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movq %r8, -0x20(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x147a0
movl -0xc(%rbp), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x8(%rbp), %rax
movl -0x2c(%rbp), %ecx
shrl $0x2, %ecx
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl -0x2c(%rbp), %ecx
andl $0x3, %ecx
xorl $0x3, %ecx
shll %ecx
sarl %cl, %eax
andl $0x3, %eax
movslq %eax, %rcx
leaq 0x19799(%rip), %rax     # 0x2df20
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1474c
cmpl $0x0, -0x14(%rbp)
je 0x14852
movl $0x0, -0x24(%rbp)
movl -0x10(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x28(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jge 0x14824
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb (%rax,%rcx), %al
movb %al, -0x2d(%rbp)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x196ba(%rip), %rax     # 0x2dea0
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
movsbl -0x2d(%rbp), %eax
movslq %eax, %rcx
leaq 0x1969e(%rip), %rax     # 0x2dea0
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movb %dl, (%rax,%rcx)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x147ba
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jne 0x14850
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movslq %eax, %rcx
leaq 0x1965e(%rip), %rax     # 0x2dea0
movb (%rax,%rcx), %dl
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movb %dl, (%rax,%rcx)
jmp 0x14852
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_scm_add
static inline void kh_scm_add(kh_scm_t *h, uint128_t v_p, uint64_t c)
{
    int absent;
    khint_t k;
    k = kh_scm_put(h, v_p, &absent);
    if (absent)
        kh_val(h, k) = 0;
    kh_val(h, k) += c;
    return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
movq %rdi, -0x18(%rbp)
movq %rdx, -0x28(%rbp)
movq %rax, -0x30(%rbp)
movq %rcx, -0x38(%rbp)
movq -0x18(%rbp), %rdi
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, -0x48(%rbp)
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rsi
movq -0x48(%rbp), %rdx
leaq -0x3c(%rbp), %rcx
callq 0x191e0
movl %eax, -0x40(%rbp)
cmpl $0x0, -0x3c(%rbp)
je 0x16620
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x40(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x40(%rbp), %edx
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/syncmer.c
// Function: kh_kcn_put1
static inline void kh_kcn_put1(kh_kcn_t *k_cn, uint64_t key)
{
    int absent;
    khint_t k;
    k = kh_kcn_put(k_cn, key, &absent);
    if (absent)
        kh_val(k_cn, k) = 1;
    else
        ++kh_val(k_cn, k);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0x19a70
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x14(%rbp)
je 0x16695
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl $0x1, 0x8(%rax)
jmp 0x166b0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rbp), %ecx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x8(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)