LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_add_seg1
uint32_t asg_add_seg1(asg_t *g, char *name, char *seq, uint32_t len, uint64_t cov, int allow_dups)
{
    uint32_t k = asg_add_seg(g, name, allow_dups);
    asg_seg_t *s = &g->seg[k];
    s->seq = strdup(seq);
    s->len = len;
    s->cov = cov;
    return k;
}

// 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)
movq %r8, -0x28(%rbp)
movl %r9d, -0x2c(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x2c(%rbp), %edx
callq 0xb300
movl %eax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x30(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2470
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x8(%rax)
movl -0x1c(%rbp), %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movl %ecx, 0x14(%rax)
movl -0x30(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_make_asmg_copy
asmg_t *asg_make_asmg_copy(asmg_t *g, asmg_t *_g)
{
    asmg_t *g1;
    
    if (_g)
        g1 = _g;
    else
        MYCALLOC(g1, 1);
    
    g1->n_vtx = g1->m_vtx = g->n_vtx;
    MYCALLOC(g1->vtx, g1->n_vtx);
    // this works as a and seq are always 0
    memcpy(g1->vtx, g->vtx, sizeof(asmg_vtx_t) * g1->n_vtx);
    g1->n_arc = g1->m_arc = g->n_arc;
    MYCALLOC(g1->arc, g1->n_arc);
    memcpy(g1->arc, g->arc, sizeof(asmg_arc_t) * g1->n_arc);

    uint64_t n_vtx = asmg_vtx_n(g1);
    MYCALLOC(g1->idx_p, n_vtx);
    memcpy(g1->idx_p, g->idx_p, sizeof(uint64_t) * n_vtx);
    MYCALLOC(g1->idx_n, n_vtx);
    memcpy(g1->idx_n, g->idx_n, sizeof(uint64_t) * n_vtx);
    
    return g1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xb631
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0xb644
movl $0x1, %edi
movl $0x40, %esi
callq 0x2240
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq -0x18(%rbp), %rax
movq (%rax), %rdi
movl $0x28, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rsi
movq -0x18(%rbp), %rax
imulq $0x28, (%rax), %rdx
callq 0x22c0
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
movl $0x30, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rsi
movq -0x18(%rbp), %rax
imulq $0x30, 0x18(%rax), %rdx
callq 0x22c0
movq -0x18(%rbp), %rax
movq (%rax), %rax
shlq %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rsi
movq -0x20(%rbp), %rdx
shlq $0x3, %rdx
callq 0x22c0
movq -0x20(%rbp), %rdi
movl $0x8, %esi
callq 0x2240
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rsi
movq -0x20(%rbp), %rdx
shlq $0x3, %rdx
callq 0x22c0
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_make_copy
asg_t *asg_make_copy(asg_t *asg)
{
    uint64_t i;
    khint_t k;
    int absent;

    // seg sequence not copied
    asg_t *asg1 = asg_init();
    asg_seg_t *seg, *seg1;
    asg1->m_seg = asg1->n_seg = asg->n_seg;
    MYCALLOC(asg1->seg, asg1->n_seg);
    kh_sdict_t *h_seg = (kh_sdict_t *) asg1->h_seg;
    for (i = 0; i < asg1->n_seg; ++i) {
        seg = &asg->seg[i];
        seg1 = &asg1->seg[i];
        seg1->name = strdup(seg->name);
        seg1->len = seg->len;
        seg1->cov = seg->cov;
        k = kh_sdict_put(h_seg, seg1->name, &absent);
        kh_val(h_seg, k) = i;
    }
    asg_make_asmg_copy(asg->asmg, asg1->asmg);

    return asg1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
callq 0xb1a0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x18, %esi
callq 0x2240
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x38(%rbp)
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xb87c
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x10(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x28(%rbp), %rax
movq (%rax), %rdi
callq 0x2470
movq %rax, %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movl 0x10(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x28(%rbp), %rax
movl 0x14(%rax), %ecx
movq -0x30(%rbp), %rax
movl %ecx, 0x14(%rax)
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rax
movq (%rax), %rsi
leaq -0x18(%rbp), %rdx
callq 0xb520
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movl %eax, %ecx
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x14(%rbp), %edx
imulq $0xc, %rdx, %rdx
addq %rdx, %rax
movl %ecx, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xb7cd
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0xb610
movq -0x20(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: sequence_covered_by_path
double sequence_covered_by_path(asg_t *asg, path_t *path, uint32_t len)
{
    uint32_t i, n, l, *v;
    uint8_t *flag;
    MYCALLOC(flag, asg->n_seg);
    v = path->v;
    l = 0;
    for (i = 0, n = path->nv; i < n; ++i) {
        if (!flag[v[i]>>1]) {
            l += asg->seg[v[i]>>1].len;
            flag[v[i]>>1] = 1;
        }
    }
    free(flag);
    return (double) l / len;
}

// 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 0x8(%rax), %rdi
movl $0x1, %esi
callq 0x2240
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
andl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
movl %eax, -0x1c(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jae 0xc23b
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
movl %ecx, %ecx
cmpb $0x0, (%rax,%rcx)
jne 0xc22e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
movl %ecx, %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
addl -0x20(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movq -0x28(%rbp), %rcx
movl -0x18(%rbp), %edx
movl (%rcx,%rdx,4), %ecx
shrl %ecx
movl %ecx, %ecx
movb $0x1, (%rax,%rcx)
jmp 0xc230
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0xc1d2
movq -0x30(%rbp), %rdi
callq 0x2060
movl -0x20(%rbp), %eax
cvtsi2sd %rax, %xmm0
movl -0x14(%rbp), %eax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: is_valid_gfa_tag
int is_valid_gfa_tag(const char *tag)
{
    int is_valid = 0;
    if (strlen(tag) != 4)
        return is_valid;
    is_valid = isalpha(tag[0]) && 
        (isalpha(tag[1]) || isdigit(tag[1])) && 
        (tag[2] == ':') &&
        (tag[3] == 'A' || tag[3] == 'i' || tag[3] == 'f' || tag[3] == 'Z' || tag[3] == 'B');
    return is_valid;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x10(%rbp), %rdi
callq 0x2130
cmpq $0x4, %rax
je 0xc28d
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xc381
callq 0x24d0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x400, %ecx            # imm = 0x400
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xc370
callq 0x24d0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x400, %eax            # imm = 0x400
cmpl $0x0, %eax
jne 0xc2ff
callq 0x24d0
movq (%rax), %rax
movq -0x10(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %ecx
andl $0x800, %ecx            # imm = 0x800
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
je 0xc370
movq -0x10(%rbp), %rax
movsbl 0x2(%rax), %ecx
xorl %eax, %eax
cmpl $0x3a, %ecx
movb %al, -0x15(%rbp)
jne 0xc370
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %ecx
movb $0x1, %al
cmpl $0x41, %ecx
movb %al, -0x16(%rbp)
je 0xc36a
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %ecx
movb $0x1, %al
cmpl $0x69, %ecx
movb %al, -0x16(%rbp)
je 0xc36a
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %ecx
movb $0x1, %al
cmpl $0x66, %ecx
movb %al, -0x16(%rbp)
je 0xc36a
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %ecx
movb $0x1, %al
cmpl $0x5a, %ecx
movb %al, -0x16(%rbp)
je 0xc36a
movq -0x10(%rbp), %rax
movsbl 0x3(%rax), %eax
cmpl $0x42, %eax
sete %al
movb %al, -0x16(%rbp)
movb -0x16(%rbp), %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_update_seg_seq
static void asg_update_seg_seq(asg_seg_t *seg, uint32_t l, char *s)
{
    if (seg->seq) free(seg->seq);
    MYMALLOC(seg->seq, l+1);
    memcpy(seg->seq, s, l);
    seg->seq[l] = 0;
    seg->len = l;
    seg->cov = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xc7db
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x2060
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %edi
shlq $0x0, %rdi
callq 0x22f0
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x18(%rbp), %rsi
movl -0xc(%rbp), %eax
movl %eax, %edx
callq 0x22c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl -0xc(%rbp), %ecx
movb $0x0, (%rax,%rcx)
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x10(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x14(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_parse_fa_hdr
static int asg_parse_fa_hdr(asg_t *g, char *s, asg_seg_t **seg)
{
    uint64_t i;
    char *c = s;
    while (*c != 0 && !isspace(*c))
        ++c;
    *c = 0;
    if (c - s == 1) // empty
        return PARSE_A_ERR;
    i = asg_add_seg(g, s + 1, 0);
    *seg = &g->seg[i];
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movsbl (%rax), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x31(%rbp)
je 0xc893
callq 0x24d0
movq (%rax), %rax
movq -0x30(%rbp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0xc89c
jmp 0xc8aa
movq -0x30(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x30(%rbp)
jmp 0xc85c
movq -0x30(%rbp), %rax
movb $0x0, (%rax)
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
subq %rcx, %rax
cmpq $0x1, %rax
jne 0xc8cb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0xc902
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
xorl %edx, %edx
callq 0xb300
movl %eax, %eax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rcx
imulq $0x18, -0x28(%rbp), %rax
addq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_finalize_asmg
static void asg_finalize_asmg(asg_t *g)
{
    if (g->asmg == 0)
        MYCALLOC(g->asmg, 1);
    asmg_t *asmg = g->asmg;
    uint64_t i;
    asmg_vtx_t *vtx;
    asmg->n_vtx = asmg->m_vtx = g->n_seg;
    MYCALLOC(asmg->vtx, g->n_seg);
    for (i = 0; i < g->n_seg; ++i) {
        vtx = &asmg->vtx[i];
        // will never need vtx->a
        // seg and vtx indices are consistent
        //vtx->n = 1;
        //MYMALLOC(vtx->a, 1);
        //vtx->a[0] = i;
        vtx->len = g->seg[i].len;
        vtx->cov = g->seg[i].cov;
    }
    asmg_finalize(asmg, 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
jne 0xd711
movl $0x1, %edi
movl $0x40, %esi
callq 0x2240
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movl $0x28, %esi
callq 0x2240
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd7d1
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x18(%rbp), %rcx
addq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %eax
movl %eax, %ecx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x18(%rbp), %rcx
addq %rcx, %rax
movl 0x14(%rax), %edx
movq -0x20(%rbp), %rax
movl 0x20(%rax), %ecx
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
andl $0xc0000000, %ecx       # imm = 0xC0000000
orl %edx, %ecx
movl %ecx, 0x20(%rax)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0xd759
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x18500
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_print_fa
void asg_print_fa(asg_t *g, FILE *fo, int line_wd)
{
    uint64_t i, l;
    for (i = 0; i < g->n_seg; ++i) {
        if (g->asmg && g->asmg->vtx[i].del)
            continue;
        if (g->seg[i].seq == 0)
            fprintf(stderr, "[W::%s] skip empty sequence: %s\n", __func__, g->seg[i].name);
        fprintf(fo, ">%s\n", g->seg[i].name);
        l = 0;
        put_chars(g->seg[i].seq, g->seg[i].len, 0, 0, fo, &l, line_wd);
        if (l % line_wd != 0) fputc('\n', fo);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jae 0xd937
movq -0x8(%rbp), %rax
cmpq $0x0, 0x20(%rax)
je 0xd84f
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
imulq $0x28, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x20(%rax), %eax
shrl $0x1e, %eax
andl $0x1, %eax
cmpl $0x0, %eax
je 0xd84f
jmp 0xd926
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
cmpq $0x0, 0x8(%rax)
jne 0xd898
movq 0x1c78b(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rcx
leaq 0x16343(%rip), %rsi     # 0x23bcd
leaq 0x1635d(%rip), %rdx     # 0x23bee
movb $0x0, %al
callq 0x2290
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq (%rax), %rdx
leaq 0x16345(%rip), %rsi     # 0x23bfb
movb $0x0, %al
callq 0x2290
movq $0x0, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movq 0x8(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
imulq $0x18, -0x20(%rbp), %rcx
addq %rcx, %rax
movl 0x10(%rax), %esi
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %eax
xorl %ecx, %ecx
leaq -0x28(%rbp), %r9
movl %ecx, %edx
movl %eax, (%rsp)
callq 0xa740
movq -0x28(%rbp), %rax
movslq -0x14(%rbp), %rcx
xorl %edx, %edx
divq %rcx
cmpq $0x0, %rdx
je 0xd924
movq -0x10(%rbp), %rsi
movl $0xa, %edi
callq 0x2210
jmp 0xd926
movq -0x20(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x20(%rbp)
jmp 0xd80b
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: og_component_v_destroy
void og_component_v_destroy(og_component_v *component_v)
{
    if (!component_v) return;
    size_t i;
    for (i = 0; i < component_v->n; ++i)
        og_component_destroy(&component_v->a[i]);
    if (component_v->a)
        free(component_v->a);
    free(component_v);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0xd9b5
jmp 0xda11
movq $0x0, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0xd9f0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rax
shlq $0x6, %rax
addq %rax, %rdi
callq 0xd940
movq -0x10(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x10(%rbp)
jmp 0xd9bd
movq -0x8(%rbp), %rax
cmpq $0x0, 0x10(%rax)
je 0xda08
movq -0x8(%rbp), %rax
movq 0x10(%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/path.c
// Function: max2
static uint32_t max2(double *a, uint32_t n, uint32_t *_smax)
{
    uint32_t i, imax, smax;
    double max_a, smax_a;
    imax = smax = 0;
    max_a = smax_a = -DBL_MAX;
    for (i = 0; i < n; ++i) {
        if (a[i] > max_a) {
            smax = imax;
            smax_a = max_a;
            imax = i;
            max_a = a[i];
        } else if (a[i] > smax_a) {
            smax = i;
            smax_a = a[i];
        }
    }
    if (_smax) *_smax = smax;
    return imax;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x24(%rbp)
movl $0x0, -0x20(%rbp)
movsd 0x14f2b(%rip), %xmm0    # 0x23520
movsd %xmm0, -0x38(%rbp)
movsd 0x14f1e(%rip), %xmm0    # 0x23520
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jae 0xe68b
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x30(%rbp), %xmm0
jbe 0xe652
movl -0x20(%rbp), %eax
movl %eax, -0x24(%rbp)
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rbp)
jmp 0xe67e
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
ucomisd -0x38(%rbp), %xmm0
jbe 0xe67c
movl -0x1c(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
movl -0x1c(%rbp), %ecx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x38(%rbp)
jmp 0xe67e
jmp 0xe680
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xe60e
cmpq $0x0, -0x18(%rbp)
je 0xe69b
movl -0x24(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0x20(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: asg_vtx_name_list
char **asg_vtx_name_list(asg_t *g, uint64_t *_n)
{
    if (_n) *_n = 0;
    uint64_t i, n = 0;
    uint64_t *vlist = asmg_vtx_list(g->asmg, &n);
    char **names = 0;
    if (n) {
        MYMALLOC(names, n);
        for (i = 0; i < n; ++i)
            names[i] = g->seg[vlist[i]].name;
    }
    free(vlist);
    if (_n) *_n = n;
    return names;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x13692
movq -0x10(%rbp), %rax
movq $0x0, (%rax)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rdi
leaq -0x20(%rbp), %rsi
callq 0x18aa0
movq %rax, -0x28(%rbp)
movq $0x0, -0x30(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x13718
movq -0x20(%rbp), %rdi
shlq $0x3, %rdi
callq 0x22f0
movq %rax, -0x30(%rbp)
movq $0x0, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jae 0x13716
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rdx
imulq $0x18, (%rcx,%rdx,8), %rcx
addq %rcx, %rax
movq (%rax), %rdx
movq -0x30(%rbp), %rax
movq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x18(%rbp)
jmp 0x136d7
jmp 0x13718
movq -0x28(%rbp), %rdi
callq 0x2060
cmpq $0x0, -0x10(%rbp)
je 0x13733
movq -0x20(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x30(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: fvals
static inline double fvals(func_t *funcs, int n_func)
{
    int i;
    double fval = 0.;
    for (i = 0; i < n_func; ++i) {
        FVAL(&funcs[i]);
        fval += funcs[i].VAL;
    }
    return fval;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13925
jmp 0x137ac
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movl 0x18(%rax), %eax
movl %eax, -0x20(%rbp)
leaq -0x30(%rbp), %rdi
xorl %esi, %esi
movl $0x10, %edx
callq 0x21c0
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
jge 0x13851
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movq -0x8(%rbp), %rcx
movslq -0x10(%rbp), %rdx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
movq 0x20(%rcx), %rcx
movslq -0x1c(%rbp), %rdx
movl (%rcx,%rdx,4), %ecx
sarl %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
cvtsi2sdl 0x4(%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq 0x20(%rax), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %eax
andl $0x1, %eax
cltq
addsd -0x30(%rbp,%rax,8), %xmm0
movsd %xmm0, -0x30(%rbp,%rax,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x137d8
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd (%rax), %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm1
subsd -0x30(%rbp), %xmm1
movaps 0xfcdc(%rip), %xmm2     # 0x23560
pand %xmm2, %xmm1
movsd 0xfc88(%rip), %xmm2     # 0x23518
divsd %xmm2, %xmm1
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd 0x8(%rax), %xmm2
subsd -0x28(%rbp), %xmm2
movaps 0xfcac(%rip), %xmm3     # 0x23560
pand %xmm3, %xmm2
movsd 0xfc58(%rip), %xmm3     # 0x23518
divsd %xmm3, %xmm2
addsd %xmm2, %xmm1
movsd -0x30(%rbp), %xmm2
subsd -0x28(%rbp), %xmm2
movaps 0xfc87(%rip), %xmm3     # 0x23560
pand %xmm3, %xmm2
addsd %xmm2, %xmm1
mulsd %xmm1, %xmm0
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd %xmm0, 0x28(%rax)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movsd 0x28(%rax), %xmm0
addsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x18(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1379e
movsd -0x18(%rbp), %xmm0
addq $0x30, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: random_walk_to_neighbour
static inline void random_walk_to_neighbour(var_t **var)
{
    if (rand() < RAND_MAX>>1) {
        // move to prev
        *var = (*var)->B == 0? (*var)->next : (*var)->prev;
    } else {
        // move to next
        *var = (*var)->next->B == 0? (*var)->prev : (*var)->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
callq 0x24c0
cmpl $0x3fffffff, %eax       # imm = 0x3FFFFFFF
jge 0x139d1
movq -0x8(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jne 0x139b5
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x139c4
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
jmp 0x13a0c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
cmpl $0x0, (%rax)
jne 0x139f2
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x13a01
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: set_vars
static void set_vars(var_t **vars, int n_var, int *res)
{
    int i;
    for (i = 0; i < n_var; ++i) {
        while (vars[i]->D != res[i])
            vars[i] = vars[i]->next;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x13a87
jmp 0x13a40
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x4(%rax), %eax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
je 0x13a7a
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rdx
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x13a40
jmp 0x13a7c
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x13a36
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: path_contain_vertex
KDQ_INIT(llnodep)

static int path_contain_vertex(llnode *node, uint32_t v)
{
    int contained = 0;
    while (node != NULL) {
        if ((node->v >> 1) == (v >> 1)) {
            contained = 1;
            break;
        }
        node = node->prev;
    }

    return contained;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x14861
movq -0x8(%rbp), %rax
movl (%rax), %eax
shrl %eax
movl -0xc(%rbp), %ecx
shrl %ecx
cmpl %ecx, %eax
jne 0x14853
movl $0x1, -0x10(%rbp)
jmp 0x14861
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x14832
movl -0x10(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: swap
static void swap(uint32_t arr[], uint32_t f, uint32_t s, uint32_t d)
{
    // swaps d elements starting at index f with d elements starting at index s
    uint32_t i, temp;
    for(i = 0; i < d; i++) {
        temp = arr[f + i];
        arr[f + i] = arr[s + i];
        arr[s + i] = temp;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jae 0x15f1d
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %eax
movl %eax, -0x1c(%rbp)
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movl (%rax,%rcx,4), %edx
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x1c(%rbp), %edx
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
addl -0x18(%rbp), %ecx
movl %ecx, %ecx
movl %edx, (%rax,%rcx,4)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x15ec8
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: gfa_aux_get
static uint8_t *gfa_aux_get(int l_data, const uint8_t *data, const char tag[2])
{
    const uint8_t *s = data;
    int y = tag[0]<<8 | tag[1];
    while (s < data + l_data) {
        int x = (int)s[0]<<8 | s[1];
        s += 2;
        if (x == y) return (uint8_t*)s;
        __skip_tag(s);
    }
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0xc(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movsbl (%rax), %eax
shll $0x8, %eax
movq -0x20(%rbp), %rcx
movsbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0xc(%rbp), %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jae 0x172d7
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
shll $0x8, %eax
movq -0x28(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x30(%rbp)
movq -0x28(%rbp), %rax
addq $0x2, %rax
movq %rax, -0x28(%rbp)
movl -0x30(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x17242
movq -0x28(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x172df
jmp 0x17244
movq -0x28(%rbp), %rax
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
cmpl $0x5a, -0x34(%rbp)
jne 0x17287
jmp 0x17262
movq -0x28(%rbp), %rax
cmpb $0x0, (%rax)
je 0x17279
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x17262
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x172d0
cmpl $0x42, -0x34(%rbp)
jne 0x172b6
movq -0x28(%rbp), %rax
movzbl (%rax), %edi
callq 0x17750
movl %eax, %ecx
movq -0x28(%rbp), %rax
imull 0x1(%rax), %ecx
addl $0x5, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x172ce
movl -0x34(%rbp), %edi
callq 0x17750
movl %eax, %ecx
movq -0x28(%rbp), %rax
movslq %ecx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
jmp 0x172d0
jmp 0x172d2
jmp 0x171f2
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: gfa_aux_decimal_value
static double gfa_aux_decimal_value(uint8_t *aux)
{
    double val = .0;
    if (*aux == 'c') val = aux_decimal_val(int8_t, aux + 1);
    else if (*aux == 'C') val = aux_decimal_val(uint8_t, aux + 1);
    else if (*aux == 's') val = aux_decimal_val(int16_t, aux + 1);
    else if (*aux == 'S') val = aux_decimal_val(uint16_t, aux + 1);
    else if (*aux == 'i') val = aux_decimal_val(int64_t, aux + 1);
    else if (*aux == 'I') val = aux_decimal_val(uint64_t, aux + 1);
    else if (*aux == 'f') val = aux_decimal_val(double, aux + 1);
    return val;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x63, %eax
jne 0x17322
movq -0x8(%rbp), %rax
movsbl 0x1(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x17406
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x43, %eax
jne 0x17344
movq -0x8(%rbp), %rax
movzbl 0x1(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x17404
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x73, %eax
jne 0x17366
movq -0x8(%rbp), %rax
movswl 0x1(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x17402
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x53, %eax
jne 0x17385
movq -0x8(%rbp), %rax
movzwl 0x1(%rax), %eax
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x17400
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x69, %eax
jne 0x173a2
movq -0x8(%rbp), %rax
cvtsi2sdq 0x1(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x173fe
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x49, %eax
jne 0x173e0
movq -0x8(%rbp), %rax
movq 0x1(%rax), %xmm0
movaps 0xc1b2(%rip), %xmm1     # 0x23570
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0xc1b6(%rip), %xmm1     # 0x23580
subpd %xmm1, %xmm0
movaps %xmm0, %xmm1
unpckhpd %xmm0, %xmm0            # xmm0 = xmm0[1,1]
addsd %xmm1, %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x173fc
movq -0x8(%rbp), %rax
movzbl (%rax), %eax
cmpl $0x66, %eax
jne 0x173fa
movq -0x8(%rbp), %rax
movsd 0x1(%rax), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x173fc
jmp 0x173fe
jmp 0x17400
jmp 0x17402
jmp 0x17404
jmp 0x17406
movsd -0x10(%rbp), %xmm0
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c-zhou[P]oatk/path.c
// Function: gfa_aux_type2size
static inline int gfa_aux_type2size(int x)
{
    if (x == 'C' || x == 'c' || x == 'A') return 1;
    else if (x == 'S' || x == 's') return 2;
    else if (x == 'I' || x == 'i' || x == 'f') return 8;
    else return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
cmpl $0x43, -0x8(%rbp)
je 0x17769
cmpl $0x63, -0x8(%rbp)
je 0x17769
cmpl $0x41, -0x8(%rbp)
jne 0x17772
movl $0x1, -0x4(%rbp)
jmp 0x177a9
cmpl $0x53, -0x8(%rbp)
je 0x1777e
cmpl $0x73, -0x8(%rbp)
jne 0x17787
movl $0x2, -0x4(%rbp)
jmp 0x177a9
cmpl $0x49, -0x8(%rbp)
je 0x17799
cmpl $0x69, -0x8(%rbp)
je 0x17799
cmpl $0x66, -0x8(%rbp)
jne 0x177a2
movl $0x8, -0x4(%rbp)
jmp 0x177a9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: atomic_int_create
atomic_int	*
atomic_int_create(uint32_t val)
{
	atomic_int *ai = malloc(sizeof(atomic_int));
	ai->val = val;
	pthread_mutex_init(&ai->lock,0);
	return(ai);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x30, %edi
callq 0x2310
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movq 0x8(%rsp), %rdi
addq $0x8, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2430
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: atomic_int_add
uint32_t
atomic_int_add(atomic_int *ai, uint32_t val)
{
	uint32_t	rv;
	pthread_mutex_lock(&ai->lock);
	ai->val += val;
	rv = ai->val;
	pthread_mutex_unlock(&ai->lock);
	return(rv);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x23e0
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
addl (%rax), %ecx
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x2190
movl 0x8(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: atomic_int_get
uint32_t		
atomic_int_get(atomic_int *ai)
{
	uint32_t	val;
	pthread_mutex_lock(&ai->lock);
	val = ai->val;
	pthread_mutex_unlock(&ai->lock);
	return(val);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x23e0
movq 0x10(%rsp), %rax
movl (%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
callq 0x2190
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: counter_fn
void *
counter_fn(void *arg)
{
	counter_thread_control *ctc = (counter_thread_control *) arg;
	
	uint64_t last_t = 0;
	
	while (ctc->death == 0) {
		
		sleep(1);
		
		int keys = atomic_int_get(ctc->keys);
		int tps = keys - last_t;
		last_t = keys;
		
		if ((ctc->gen_errs == 0) || (atomic_int_get(ctc->gen_errs) == 0) ) 
			fprintf(stderr, "%s: %d (tps %d)\n",ctc->msg,keys,tps);
		else
			fprintf(stderr, "%s: %d (tps %d) gen-errs %d\n",ctc->msg,keys,tps,atomic_int_get(ctc->gen_errs));
	}
	return(0);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x18(%rax)
jne 0x287a
movl $0x1, %edi
callq 0x2180
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x2730
movl %eax, 0x1c(%rsp)
movslq 0x1c(%rsp), %rax
subq 0x20(%rsp), %rax
movl %eax, 0x18(%rsp)
movslq 0x1c(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x27ee
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2730
cmpl $0x0, %eax
jne 0x2819
movq 0x207eb(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
movq 0x28(%rsp), %rax
movq (%rax), %rdx
movl 0x1c(%rsp), %ecx
movl 0x18(%rsp), %r8d
leaq 0x1991c(%rip), %rsi     # 0x1c12c
movb $0x0, %al
callq 0x23b0
jmp 0x2875
movq 0x207c0(%rip), %rax     # 0x22fe0
movq (%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x2730
movq (%rsp), %rdi
movq 0x8(%rsp), %rdx
movl 0x10(%rsp), %ecx
movl 0x14(%rsp), %r8d
movl %eax, %r9d
leaq 0x198cf(%rip), %rsi     # 0x1c13d
movb $0x0, %al
callq 0x23b0
jmp 0x278c
xorl %eax, %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: start_counter_thread
void *
start_counter_thread(char *msg, atomic_int *keys, atomic_int *gen_errs)
{
	counter_thread_control *ctc = (counter_thread_control *) malloc(sizeof(counter_thread_control));
	ctc->keys = keys;
	ctc->gen_errs = gen_errs;
	ctc->msg = strdup(msg);

	ctc->death = 0;
	pthread_create(&ctc->th, 0, counter_fn, ctc);
	return(ctc);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movl $0x28, %edi
callq 0x2310
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rdi
callq 0x2520
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq 0x8(%rsp), %rdi
addq $0x20, %rdi
movq 0x8(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
leaq -0x198(%rip), %rdx      # 0x2770
callq 0x2500
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/main.c
// Function: rand_64
uint64_t
rand_64()
{
	pthread_mutex_lock(&rand_buf_lock);
	if (rand_buf_off < sizeof(uint64_t) ) {
		if (seeded == 0) {
			int rfd = open("/dev/urandom",	O_RDONLY);
			int rsz = read(rfd, rand_buf, SEED_SZ);
			if (rsz < SEED_SZ) {
				fprintf(stderr, "warning! can't seed random number generator");
				return(0);
			}
			close(rfd);
			RAND_seed(rand_buf, rsz);
			seeded = 1;
		}
		if (1 != RAND_bytes(rand_buf, sizeof(rand_buf))) {
			fprintf(stderr, "RAND_bytes not so happy.\n");
			pthread_mutex_unlock(&rand_buf_lock);
			return(0);
		}
		rand_buf_off = sizeof(rand_buf);
	}
	
	rand_buf_off -= sizeof(uint64_t);
	uint64_t r = *(uint64_t *) (&rand_buf[rand_buf_off]);
	pthread_mutex_unlock(&rand_buf_lock);
	return(r);
}

// Assembly:
subq $0x18, %rsp
leaq 0x20995(%rip), %rdi     # 0x23300
callq 0x23e0
movl 0x209b2(%rip), %eax     # 0x23328
cmpq $0x8, %rax
jae 0x2a5b
cmpl $0x0, 0x209a5(%rip)     # 0x2332c
jne 0x2a06
leaq 0x197ca(%rip), %rdi     # 0x1c15a
xorl %esi, %esi
movb $0x0, %al
callq 0x24d0
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %edi
leaq 0x20988(%rip), %rsi     # 0x23330
movl $0x40, %edx
callq 0x23c0
movl %eax, 0x8(%rsp)
cmpl $0x40, 0x8(%rsp)
jge 0x29e3
movq 0x2061c(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
leaq 0x19799(%rip), %rsi     # 0x1c167
movb $0x0, %al
callq 0x23b0
movq $0x0, 0x10(%rsp)
jmp 0x2a97
movl 0xc(%rsp), %edi
callq 0x2570
movl 0x8(%rsp), %esi
leaq 0x20939(%rip), %rdi     # 0x23330
callq 0x24c0
movl $0x1, 0x20926(%rip)     # 0x2332c
leaq 0x20923(%rip), %rdi     # 0x23330
movl $0x2000, %esi           # imm = 0x2000
callq 0x2400
movl %eax, %ecx
movl $0x1, %eax
cmpl %ecx, %eax
je 0x2a51
movq 0x205b7(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
leaq 0x19760(%rip), %rsi     # 0x1c193
movb $0x0, %al
callq 0x23b0
leaq 0x208bf(%rip), %rdi     # 0x23300
callq 0x2190
movq $0x0, 0x10(%rsp)
jmp 0x2a97
movl $0x2000, 0x208cd(%rip)  # imm = 0x2000
movl 0x208c7(%rip), %eax     # 0x23328
subq $0x8, %rax
movl %eax, 0x208bd(%rip)     # 0x23328
movl 0x208b7(%rip), %eax     # 0x23328
movl %eax, %ecx
leaq 0x208b6(%rip), %rax     # 0x23330
movq (%rax,%rcx), %rax
movq %rax, (%rsp)
leaq 0x20877(%rip), %rdi     # 0x23300
callq 0x2190
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/key.c
// Function: dump_buf
static void
dump_buf(char *msg, uint8_t *buf, size_t buf_len)
{
	fprintf(stderr, "dump_buf: %s\n",msg);
	uint i;
	for (i=0;i<buf_len;i++) {
		if (i % 16 == 8)
			fprintf(stderr, " : ");
		if (i && (i % 16 == 0))
			fprintf(stderr, "\n");
		fprintf(stderr, "%02x ",buf[i]);
	}
	fprintf(stderr, "\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x1ebd6(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
movq 0x20(%rsp), %rdx
leaq 0x18abf(%rip), %rsi     # 0x1ced8
movb $0x0, %al
callq 0x23b0
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpq 0x10(%rsp), %rax
jae 0x44bb
movl 0xc(%rsp), %eax
andl $0xf, %eax
cmpl $0x8, %eax
jne 0x445b
movq 0x1eb96(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
leaq 0x18a92(%rip), %rsi     # 0x1cee6
movb $0x0, %al
callq 0x23b0
cmpl $0x0, 0xc(%rsp)
je 0x4486
movl 0xc(%rsp), %eax
andl $0xf, %eax
cmpl $0x0, %eax
jne 0x4486
movq 0x1eb6b(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
leaq 0x18f56(%rip), %rsi     # 0x1d3d5
movb $0x0, %al
callq 0x23b0
movq 0x1eb53(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movl 0xc(%rsp), %ecx
movzbl (%rax,%rcx), %edx
leaq 0x18a46(%rip), %rsi     # 0x1ceea
movb $0x0, %al
callq 0x23b0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x4428
movq 0x1eb1e(%rip), %rax     # 0x22fe0
movq (%rax), %rdi
leaq 0x18f09(%rip), %rsi     # 0x1d3d5
movb $0x0, %al
callq 0x23b0
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: histogram_create
histogram* histogram_create() {
	histogram* h = malloc(sizeof(histogram));

	if (h) {
		h->n_counts = 0;
		memset(&h->count, 0, sizeof(h->count));
	}

	return (h);
}

// Assembly:
pushq %rax
movl $0x208, %edi            # imm = 0x208
callq 0x2310
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x6ee5
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rdi
addq $0x8, %rdi
xorl %esi, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x2150
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: histogram_dump
void histogram_dump(histogram* h, const char* p_tag) {
	char printbuf[100];
	int pos = 0; // location to print from
	printbuf[0] = '\0';

	fprintf(stdout, "%s (%zu total)\n", p_tag, h->n_counts);

	int i, j;
	int k = 0;

	for (j = N_COUNTS-1 ; j >= 0 ; j--) {
		if (h->count[j]) break;
	}

	for (i = 0; i < N_COUNTS; i++) {
		if (h->count[i]) break;
	}

	for (; i <= j; i++) {
		if (h->count[i] > 0) { // print only non zero columns
			int bytes = sprintf(
				(char*)(printbuf + pos), " (%02d: %010zu) ", i, h->count[i]);

			if (bytes <= 0) {
				fprintf(stdout, "ERROR: printing histogram\n");
				return;
			}

			pos += bytes;

		    if (k % 4 == 3) {
		    	 fprintf(stdout, "%s\n", (char*)printbuf);
		    	 pos = 0;
		    	 printbuf[0] = '\0';
		    }

		    k++;
		}
	}

	if (pos > 0) {
	    fprintf(stdout, "%s\n", (char*)printbuf);
	}
}

// Assembly:
subq $0x98, %rsp
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movl $0x0, 0x1c(%rsp)
movb $0x0, 0x20(%rsp)
movq 0x1c0a5(%rip), %rax     # 0x22fc0
movq (%rax), %rdi
movq 0x88(%rsp), %rdx
movq 0x90(%rsp), %rax
movq (%rax), %rcx
leaq 0x160b8(%rip), %rsi     # 0x1cff0
movb $0x0, %al
callq 0x23b0
movl $0x0, 0x10(%rsp)
movl $0x3f, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jl 0x6f7f
movq 0x90(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
cmpq $0x0, %rax
je 0x6f70
jmp 0x6f7f
jmp 0x6f72
movl 0x14(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x6f4f
movl $0x0, 0x18(%rsp)
cmpl $0x40, 0x18(%rsp)
jge 0x6fb7
movq 0x90(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
cmpq $0x0, %rax
je 0x6fa8
jmp 0x6fb7
jmp 0x6faa
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6f87
jmp 0x6fb9
movl 0x18(%rsp), %eax
cmpl 0x14(%rsp), %eax
jg 0x70a0
movq 0x90(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rax
cmpq $0x0, %rax
jbe 0x708e
leaq 0x20(%rsp), %rdi
movslq 0x1c(%rsp), %rax
addq %rax, %rdi
movl 0x18(%rsp), %edx
movq 0x90(%rsp), %rax
movslq 0x18(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
leaq 0x15ff3(%rip), %rsi     # 0x1d000
movb $0x0, %al
callq 0x2090
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jg 0x703c
movq 0x1bf9a(%rip), %rax     # 0x22fc0
movq (%rax), %rdi
leaq 0x15fe1(%rip), %rsi     # 0x1d011
movb $0x0, %al
callq 0x23b0
jmp 0x70c4
movl 0xc(%rsp), %eax
addl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movl 0x10(%rsp), %eax
movl $0x4, %ecx
cltd
idivl %ecx
cmpl $0x3, %edx
jne 0x7083
movq 0x1bf60(%rip), %rax     # 0x22fc0
movq (%rax), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x15a4a(%rip), %rsi     # 0x1cab9
movb $0x0, %al
callq 0x23b0
movl $0x0, 0x1c(%rsp)
movb $0x0, 0x20(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x7090
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x6fb9
cmpl $0x0, 0x1c(%rsp)
jle 0x70c4
movq 0x1bf12(%rip), %rax     # 0x22fc0
movq (%rax), %rdi
leaq 0x20(%rsp), %rdx
leaq 0x159fc(%rip), %rsi     # 0x1cab9
movb $0x0, %al
callq 0x23b0
addq $0x98, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: histogram_insert_data_point
void histogram_insert_data_point(histogram* h, uint64_t delta_ms) {
	cf_atomic_int_incr(&h->n_counts);

	int index = bits_find_last_set_64(delta_ms);

	if (index < 0) {
		index = 0;
	}

	if ((int64_t)delta_ms < 0) {
	    // Need to investigate why in some cases start is a couple of ms greater than end
		// Could it be rounding error (usually the difference is 1 but sometimes I have seen 2
	    // fprintf(stdout, "start = %"PRIu64" > end = %"PRIu64"", start, end);
		index = 0;
	}

	cf_atomic_int_incr(&h->count[index]);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movl $0x1, %esi
callq 0x7140
movq 0x8(%rsp), %rdi
callq 0x7180
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0x710a
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0x711a
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rdi
addq $0x8, %rdi
movslq 0x4(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl $0x1, %esi
callq 0x7140
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: bits_find_last_set_64
static int bits_find_last_set_64(uint64_t v) {
	uint64_t t;

	if ((t = v >> 32) != 0) {
		return (bits_find_last_set(t) + 32);
	}
	else {
		return (bits_find_last_set(v));
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
shrq $0x20, %rax
movq %rax, (%rsp)
cmpq $0x0, %rax
je 0x71b0
movq (%rsp), %rax
movl %eax, %edi
callq 0x71d0
addl $0x20, %eax
movl %eax, 0x14(%rsp)
jmp 0x71c0
movq 0x8(%rsp), %rax
movl %eax, %edi
callq 0x71d0
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/sharpyfox[P]citrusleaf-client/tests/key_c/src/histogram.c
// Function: bits_find_last_set
static int bits_find_last_set(uint32_t v) {
	int r;
	uint32_t t, tt;

	if ((tt = v >> 16) != 0) {
		r = (t = tt >> 8) ? (24 + LogTable256[t]) : (16 + LogTable256[tt]);
	}
	else {
		r = (t = v >> 8) ? (8 + LogTable256[t]) : LogTable256[v];
	}

	return (r);
}

// Assembly:
movl %edi, -0x4(%rsp)
movl -0x4(%rsp), %eax
shrl $0x10, %eax
movl %eax, -0x10(%rsp)
cmpl $0x0, %eax
je 0x7230
movl -0x10(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, %eax
je 0x720e
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x15cef(%rip), %rax     # 0x1cef0
movsbl (%rax,%rcx), %eax
addl $0x18, %eax
movl %eax, -0x14(%rsp)
jmp 0x7226
movl -0x10(%rsp), %eax
movl %eax, %ecx
leaq 0x15cd5(%rip), %rax     # 0x1cef0
movsbl (%rax,%rcx), %eax
addl $0x10, %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
movl %eax, -0x8(%rsp)
jmp 0x7277
movl -0x4(%rsp), %eax
shrl $0x8, %eax
movl %eax, -0xc(%rsp)
cmpl $0x0, %eax
je 0x725a
movl -0xc(%rsp), %eax
movl %eax, %ecx
leaq 0x15ca3(%rip), %rax     # 0x1cef0
movsbl (%rax,%rcx), %eax
addl $0x8, %eax
movl %eax, -0x18(%rsp)
jmp 0x726f
movl -0x4(%rsp), %eax
movl %eax, %ecx
leaq 0x15c89(%rip), %rax     # 0x1cef0
movsbl (%rax,%rcx), %eax
movl %eax, -0x18(%rsp)
movl -0x18(%rsp), %eax
movl %eax, -0x8(%rsp)
movl -0x8(%rsp), %eax
retq
nopl (%rax)