LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/heap.c
// Function: heap_insert
void heap_insert(struct _heap * heap, void * item) {
    size_t s = heap->item_size;

    if (heap->limit == 0 && heap->n_max == heap->n_items) {
        heap->n_max *= HEAP_RESIZE_FACTOR;
        heap->items = realloc(heap->items, heap->n_max * s);
    }

    // move to tail
    memcpy(heap->items + heap->n_items * s, item, s);

    // index
    if (heap->ht != NULL) 
        hash_add(heap->ht, item, &heap->n_items);

    /* 

    A little trick here:
    we invoke heap_update with NULL to specify
    that we don't need an assignment and value check.

    */

    if (heap->limit == 0 || heap->n_items < heap->limit) {
        heap_update(heap, NULL, heap->n_items++);
    } else {
        heap_delete_max(heap);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x610c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jne 0x610c
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
shlq %rcx
movq %rcx, 0x8(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rsi
imulq -0x18(%rbp), %rsi
callq 0x1140
movq %rax, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x1110
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6150
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rdx
callq 0x20e0
movq -0x8(%rbp), %rax
cmpq $0x0, 0x18(%rax)
je 0x616c
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x18(%rcx), %rax
jae 0x618c
movq -0x8(%rbp), %rdi
movq -0x8(%rbp), %rax
movq (%rax), %rdx
movq %rdx, %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
xorl %eax, %eax
movl %eax, %esi
callq 0x61a0
jmp 0x6195
movq -0x8(%rbp), %rdi
callq 0x6320
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/heap.c
// Function: heap_update
void heap_update(struct _heap * heap, void * item, size_t i) { 
    char * items = heap->items;
    size_t s = heap->item_size;
    size_t j;
    
    // remove assertion for equality
    assert ( i < heap->n_items );

    if (item != NULL) {  // if invoked directly
        // check if we reducing the priority and 
        // not increasing it
        assert( heap->cmp(item, items + i*s) );
        memcpy(items + i*s, item, s);

        // index
        if (heap->ht != NULL) 
            hash_add(heap->ht, item, &i);
    }

    while (i > 0 && heap->cmp(items + i*s, items + HEAP_PARENT(i)*s)) {
        j = HEAP_PARENT(i);
        heap_items_swap(heap, i, j);

        i = j;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
jae 0x61db
jmp 0x61fa
leaq 0x22f8(%rip), %rdi      # 0x84da
leaq 0x22b1(%rip), %rsi      # 0x849a
movl $0xee, %edx
leaq 0x2321(%rip), %rcx      # 0x8516
callq 0x10b0
cmpq $0x0, -0x10(%rbp)
je 0x6288
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rsi
callq *%rax
cmpl $0x0, %eax
je 0x622a
jmp 0x6249
leaq 0x2316(%rip), %rdi      # 0x8547
leaq 0x2262(%rip), %rsi      # 0x849a
movl $0xf3, %edx
leaq 0x22d2(%rip), %rcx      # 0x8516
callq 0x10b0
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rax
imulq -0x28(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rdx
callq 0x1110
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6286
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x20e0
jmp 0x6288
jmp 0x628a
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x31(%rbp)
jbe 0x62d4
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rdi
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
addq $0x1, %rcx
shrq %rcx
subq $0x1, %rcx
imulq -0x28(%rbp), %rcx
addq %rcx, %rsi
callq *%rax
cmpl $0x0, %eax
setne %al
movb %al, -0x31(%rbp)
movb -0x31(%rbp), %al
testb $0x1, %al
jne 0x62dd
jmp 0x630e
movq -0x18(%rbp), %rax
addq $0x1, %rax
shrq %rax
subq $0x1, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x30(%rbp), %rdx
callq 0x5fa0
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x628a
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/heap.c
// Function: heap_delete_max
static void heap_delete_max(struct _heap * heap) {
    // using linear search to find max element
    char * items = heap->items; 
    size_t s = heap->item_size;

    size_t m = 0; 
    for (size_t i = 1; i < heap->n_items + 1; ++i) {
        if ( heap->cmp(items +m*s, items + i*s))  m = i;
    }

    // replace with the last element 
    if (m != heap->n_items) {  // is already the last, do nothing
        memcpy(items + m*s, items + heap->n_items*s, s); 

        // index 
        if (heap->ht != NULL) 
            hash_add(heap->ht, items + m*s, &m);

        heap_update(heap, NULL, m);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq $0x1, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movq (%rcx), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jae 0x63af
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rdi
movq -0x10(%rbp), %rsi
movq -0x28(%rbp), %rcx
imulq -0x18(%rbp), %rcx
addq %rcx, %rsi
callq *%rax
cmpl $0x0, %eax
je 0x639f
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
jmp 0x63a1
movq -0x28(%rbp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x6354
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq (%rcx), %rax
je 0x6425
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
addq %rax, %rdi
movq -0x10(%rbp), %rsi
movq -0x8(%rbp), %rax
movq (%rax), %rax
imulq -0x18(%rbp), %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
callq 0x1110
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
je 0x6414
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rdi
movq -0x10(%rbp), %rsi
movq -0x20(%rbp), %rax
imulq -0x18(%rbp), %rax
addq %rax, %rsi
leaq -0x20(%rbp), %rdx
callq 0x20e0
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rdx
xorl %eax, %eax
movl %eax, %esi
callq 0x61a0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/iter.c
// Function: fst_iter_create
struct _fst_iter * fst_iter_create(const struct _fst * fst) {
    struct _fst_iter * iter;
    iter = malloc(sizeof(struct _fst_iter));
    iter->fst = fst;
    iter->state = fst->start;
    iter->marked = bitset_create(fst->n_states);
    iter->queue = queue_create(sizeof(state_t));

    queue_enque(iter->queue, &iter->state);
    bitset_set(iter->marked, iter->state);

    return iter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x20, %edi
callq 0x1120
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl 0x4(%rax), %edi
callq 0x3d00
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x4, %edi
callq 0x3aa0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
addq $0x18, %rsi
callq 0x3b00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0x18(%rax), %esi
callq 0x3dd0
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/iter.c
// Function: fst_iter_remove
void fst_iter_remove(struct _fst_iter * iter) {
    bitset_remove(iter->marked); 
    queue_remove(iter->queue);
    iter->fst = NULL;
    free(iter);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x3da0
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x3cd0
movq -0x8(%rbp), %rax
movq $0x0, (%rax)
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/iter.c
// Function: fst_iter_next
state_t fst_iter_next(struct _fst_iter * iter) {
    struct _arc * arc;
    struct _state * state;
    state_t s;
    arc_t a;
    
    if((queue_deque(iter->queue, &s)) != NULL) {
        iter->state = s; 
        state = &iter->fst->states[s]; 
        for(a=0; a < state->n_arcs; ++a) {
            arc = &state->arcs[a];
            if (bitset_get(iter->marked, arc->state) == 0) {
                queue_enque(iter->queue, &arc->state);
                bitset_set(iter->marked, arc->state);
            }
        }
    } else {
        iter->state = -1;
    }

    return iter->state;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3bd0
cmpq $0x0, %rax
je 0x662d
movl -0x1c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, 0x18(%rax)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x662b
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x20(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x3ec0
cmpl $0x0, %eax
jne 0x661e
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x3b00
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x10(%rbp), %rax
movl (%rax), %esi
callq 0x3dd0
jmp 0x6620
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x65c1
jmp 0x6638
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x18(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movl 0x18(%rax), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/test.c
// Function: assert_arc_equal
void assert_arc_equal(const struct _arc * arc_a, const struct _arc * arc_b) {
    assert ( arc_a->state == arc_b->state ); 
    assert ( arc_a->ilabel == arc_b->ilabel ); 
    assert ( arc_a->olabel == arc_b->olabel ); 
    assert ( arc_a->weight == arc_b->weight ); 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jne 0x66a0
jmp 0x66bf
leaq 0x1f00(%rip), %rdi      # 0x85a7
leaq 0x1f16(%rip), %rsi      # 0x85c4
movl $0x7, %edx
leaq 0x1f15(%rip), %rcx      # 0x85cf
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0x8(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0x8(%rcx), %eax
jne 0x66d1
jmp 0x66f0
leaq 0x1f37(%rip), %rdi      # 0x860f
leaq 0x1ee5(%rip), %rsi      # 0x85c4
movl $0x8, %edx
leaq 0x1ee4(%rip), %rcx      # 0x85cf
callq 0x10b0
movq -0x8(%rbp), %rax
movl 0xc(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xc(%rcx), %eax
jne 0x6702
jmp 0x6721
leaq 0x1f25(%rip), %rdi      # 0x862e
leaq 0x1eb4(%rip), %rsi      # 0x85c4
movl $0x9, %edx
leaq 0x1eb3(%rip), %rcx      # 0x85cf
callq 0x10b0
movq -0x8(%rbp), %rax
movss 0x4(%rax), %xmm0
movq -0x10(%rbp), %rax
ucomiss 0x4(%rax), %xmm0
jne 0x6738
jp 0x6738
jmp 0x6757
leaq 0x1f0e(%rip), %rdi      # 0x864d
leaq 0x1e7e(%rip), %rsi      # 0x85c4
movl $0xa, %edx
leaq 0x1e7d(%rip), %rcx      # 0x85cf
callq 0x10b0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/trim.c
// Function: fst_close
void fst_close(struct _fst * fst, struct _queue * finals) {
    /*
    This methods replace multiple final states with
    a single final state. 

    */
    if ( finals->n_items < 2)
        return;    

    struct _state * state;
    struct _sr sr = sr_get(fst->sr_type); 
    state_t final;
    state_t s;

    final = fst_add_state(fst);
    fst_set_final(fst, final, sr.one);


    while(queue_deque(finals, &s) != NULL) {
        state = &fst->states[s];
        state->final = 0;
        fst_add_arc(    fst,
                        s,
                        final,
                        EPS,
                        EPS,
                        state->weight);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x2, 0x18(%rax)
jae 0x69a0
jmp 0x6a22
movq -0x8(%rbp), %rax
leaq -0x30(%rbp), %rdi
movzbl 0xc(%rax), %esi
callq 0x26a0
movq -0x8(%rbp), %rdi
callq 0x27a0
movl %eax, -0x34(%rbp)
movq -0x8(%rbp), %rdi
movl -0x34(%rbp), %esi
movss -0x1c(%rbp), %xmm0
callq 0x2a30
movq -0x10(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3bd0
cmpq $0x0, %rax
je 0x6a22
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x38(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rbp), %rdi
movl -0x38(%rbp), %esi
movl -0x34(%rbp), %edx
movq -0x18(%rbp), %rax
movss 0x8(%rax), %xmm0
xorl %r8d, %r8d
movl %r8d, %ecx
callq 0x2870
jmp 0x69ce
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/trim.c
// Function: fst_reverse
void fst_reverse(struct _fst * fst) {
    struct _sr sr = sr_get(fst->sr_type); 
    struct _state * state;
    struct _arc * arc;
    struct _fst * orig = fst_create();
    state_t s;
    state_t start_s = fst->start;

    fst_copy(fst, orig);

    for(s=0; s < fst->n_states; ++s ) {
        state = &fst->states[s];

        // 'delete' arcs from each of the automaton states
        state->n_arcs = 0;
       
        // change start to final 
        // NOTE: fst should have only 1 start state
        if (state->final) {
            fst->start = s;
            state->final = 0;
        }
    }

    // set start as final
    fst_set_final(fst, start_s, sr.one);

    // add reversed arcs to the automaton
    for(s=0; s < orig->n_states; ++s) {
        state = &orig->states[s];         

        for(arc_t a=0; a < state->n_arcs; ++a) { 
            arc = &state->arcs[a];
            fst_add_arc(    fst, 
                            arc->state, 
                            s, 
                            arc->ilabel, 
                            arc->olabel, 
                            arc->weight);
        }
    }

    fst_remove(orig);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
leaq -0x20(%rbp), %rdi
movzbl 0xc(%rax), %esi
callq 0x26a0
movb $0x0, %al
callq 0x2740
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x40(%rbp)
movq -0x8(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x3030
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x6acc
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x3c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl $0x0, (%rax)
movq -0x28(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x6abf
movl -0x3c(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movl $0x0, 0xc(%rax)
jmp 0x6ac1
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6a75
movq -0x8(%rbp), %rdi
movl -0x40(%rbp), %esi
movss -0xc(%rbp), %xmm0
callq 0x2a30
movl $0x0, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
movq -0x38(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x6b77
movq -0x38(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x3c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x44(%rbp)
movl -0x44(%rbp), %eax
movq -0x28(%rbp), %rcx
cmpl (%rcx), %eax
jae 0x6b67
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x44(%rbp), %ecx
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movq -0x30(%rbp), %rax
movl (%rax), %esi
movl -0x3c(%rbp), %edx
movq -0x30(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x30(%rbp), %rax
movl 0xc(%rax), %r8d
movq -0x30(%rbp), %rax
movss 0x4(%rax), %xmm0
callq 0x2870
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x6b11
jmp 0x6b69
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x6ae4
movq -0x38(%rbp), %rdi
callq 0x2950
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/trim.c
// Function: fst_trim
struct _fst * fst_trim(struct _fst * fst) {
    struct _queue * finals = queue_create(sizeof(state_t));

    /*
    Before trimming check that we have at least one final states.
    If not then all the states are not co-accessible and
    there resulting automaton should be empty.
    */

    fst_get_finals(fst, finals);

    if (finals->n_items == 0) {
        fst_empty(fst);
         
    } else { 

        if (finals->n_items > 1) {
            fst_close(fst, finals);
        }

        /* 
        First lets traverse it directly and remove
        all the unreachable states    
        */

        struct _fst_iter * iter = fst_iter_create(fst);
        while ( fst_iter_next(iter) != -1 ) 
            ;
        
        /* 
        Then inverse the arcs and traverse starting
        from the final states of the original transducer
        
        NOTE: we should refresh finals queue
        */

        fst_reverse(fst);

        struct _fst_iter * iter_rev = fst_iter_create(fst);
        while ( fst_iter_next(iter_rev) != -1 ) 
            ;

        /* Reverse it back */
        fst_reverse(fst);

        /* Remove non accessible and non coacessible states */

        bitset_intersect(iter->marked, iter_rev->marked);

        bitset_toggle_all(iter->marked);

        //fst_rm_states(fst, bitset_toggle_all(iter->marked));
        fst_rm_states(fst, iter->marked);


        fst_iter_remove(iter_rev);
        fst_iter_remove(iter);
    }

    queue_remove(finals);

    return fst;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x4, %edi
callq 0x3aa0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6e70
movq -0x10(%rbp), %rax
cmpq $0x0, 0x18(%rax)
jne 0x6db0
movq -0x8(%rbp), %rdi
callq 0x2980
jmp 0x6e59
movq -0x10(%rbp), %rax
cmpq $0x1, 0x18(%rax)
jbe 0x6dc8
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x6980
movq -0x8(%rbp), %rdi
callq 0x6490
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x6570
cmpl $-0x1, %eax
je 0x6de5
jmp 0x6dd5
movq -0x8(%rbp), %rdi
callq 0x6a30
movq -0x8(%rbp), %rdi
callq 0x6490
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x6570
cmpl $-0x1, %eax
je 0x6e0b
jmp 0x6dfb
movq -0x8(%rbp), %rdi
callq 0x6a30
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x3ff0
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x4080
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rsi
callq 0x6b90
movq -0x20(%rbp), %rdi
callq 0x6530
movq -0x18(%rbp), %rdi
callq 0x6530
movq -0x10(%rbp), %rdi
callq 0x3cd0
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/c0stya[P]fslib/src/trim.c
// Function: fst_get_finals
static void fst_get_finals(struct _fst * fst, struct _queue * finals) {
    struct _state * state;

    for (state_t s=0; s < fst->n_states; ++s) {
        state = fst->states + s;
        if (state->final)
            queue_enque(finals, &s);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl 0x4(%rcx), %eax
jae 0x6ecd
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movl -0x1c(%rbp), %ecx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x0, 0xc(%rax)
je 0x6ec0
movq -0x10(%rbp), %rdi
leaq -0x1c(%rbp), %rsi
callq 0x3b00
jmp 0x6ec2
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6e87
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/kthread.c
// Function: kt_for
void kt_for(int n_threads, void (*func)(void*,long,int), void *data, long n)
{
	int i;
	kt_for_t t;
	pthread_t *tid;
	t.func = func, t.data = data, t.n_threads = n_threads, t.n = n;
	t.w = (ktf_worker_t*)alloca(n_threads * sizeof(ktf_worker_t));
	tid = (pthread_t*)alloca(n_threads * sizeof(pthread_t));
	for (i = 0; i < n_threads; ++i)
		t.w[i].t = &t, t.w[i].i = i;
	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktf_worker, &t.w[i]);
	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x50(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x48(%rbp)
movslq -0x4(%rbp), %rcx
shlq $0x4, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x40(%rbp)
movslq -0x4(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x58(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x244e
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
leaq -0x50(%rbp), %rcx
movq %rcx, (%rax)
movslq -0x24(%rbp), %rcx
movq -0x40(%rbp), %rax
movslq -0x24(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x240e
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x2496
movq -0x58(%rbp), %rdi
movslq -0x24(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x40(%rbp), %rcx
movslq -0x24(%rbp), %rax
shlq $0x4, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x4a(%rip), %rdx        # 0x24d0
callq 0x21f0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2455
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x24c5
movq -0x58(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2250
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x249d
movq %rbp, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/kthread.c
// Function: ktf_worker
static void *ktf_worker(void *data)
{
	ktf_worker_t *w = (ktf_worker_t*)data;
	long i;
	for (;;) {
		i = __sync_fetch_and_add(&w->i, w->t->n_threads);
		if (i >= w->t->n) break;
		w->t->func(w->t->data, i, w - w->t->w);
	}
	while ((i = steal_work(w->t)) >= 0)
		w->t->func(w->t->data, i, w - w->t->w);
	pthread_exit(0);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rcx
movq (%rcx), %rax
movslq (%rax), %rax
lock
xaddq %rax, 0x8(%rcx)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpq 0x8(%rcx), %rax
jl 0x250b
jmp 0x2541
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq 0x10(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movl %ecx, %edx
callq *%rax
jmp 0x24e4
jmp 0x2543
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x2980
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
jl 0x258f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
movq 0x20(%rcx), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rcx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movq 0x10(%rdx), %rdx
subq %rdx, %rcx
sarq $0x4, %rcx
movl %ecx, %edx
callq *%rax
jmp 0x2543
xorl %eax, %eax
movl %eax, %edi
callq 0x21b0
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/kthread.c
// Function: kt_pipeline
void kt_pipeline(int n_threads, void *(*func)(void*, int, void*), void *shared_data, int n_steps)
{
	ktp_t aux;
	pthread_t *tid;
	int i;

	if (n_threads < 1) n_threads = 1;
	aux.n_workers = n_threads;
	aux.n_steps = n_steps;
	aux.func = func;
	aux.shared = shared_data;
	pthread_mutex_init(&aux.mutex, 0);
	pthread_cond_init(&aux.cv, 0);

	aux.workers = alloca(n_threads * sizeof(ktp_worker_t));
	for (i = 0; i < n_threads; ++i) {
		ktp_worker_t *w = &aux.workers[i];
		w->step = w->running = 0; w->pl = &aux; w->data = 0;
	}

	tid = alloca(n_threads * sizeof(pthread_t));
	for (i = 0; i < n_threads; ++i) pthread_create(&tid[i], 0, ktp_worker, &aux.workers[i]);
	for (i = 0; i < n_threads; ++i) pthread_join(tid[i], 0);

	pthread_mutex_destroy(&aux.mutex);
	pthread_cond_destroy(&aux.cv);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x1, -0x4(%rbp)
jge 0x25c6
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, -0x88(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x84(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x78(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
movq %rsi, -0xb8(%rbp)
callq 0x2270
movq -0xb8(%rbp), %rsi
leaq -0x50(%rbp), %rdi
callq 0x2190
movslq -0x4(%rbp), %rax
leaq (%rax,%rax,2), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0x80(%rbp)
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x26ae
movq -0x80(%rbp), %rax
movslq -0xa4(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0xb0(%rbp)
movq -0xb0(%rbp), %rax
movl $0x0, 0xc(%rax)
movq -0xb0(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0xb0(%rbp), %rax
leaq -0x98(%rbp), %rcx
movq %rcx, (%rax)
movq -0xb0(%rbp), %rax
movq $0x0, 0x10(%rax)
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x263d
movslq -0x4(%rbp), %rax
leaq 0xf(,%rax,8), %rcx
andq $-0x10, %rcx
movq %rsp, %rax
subq %rcx, %rax
movq %rax, %rsp
movq %rax, -0xa0(%rbp)
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x272b
movq -0xa0(%rbp), %rdi
movslq -0xa4(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq -0x80(%rbp), %rcx
movslq -0xa4(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rcx
xorl %eax, %eax
movl %eax, %esi
leaq 0x8b(%rip), %rdx        # 0x27a0
callq 0x21f0
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x26d8
movl $0x0, -0xa4(%rbp)
movl -0xa4(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x276c
movq -0xa0(%rbp), %rax
movslq -0xa4(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x2250
movl -0xa4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xa4(%rbp)
jmp 0x2735
leaq -0x98(%rbp), %rdi
addq $0x20, %rdi
callq 0x20f0
leaq -0x98(%rbp), %rdi
addq $0x48, %rdi
callq 0x2220
movq %rbp, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/kthread.c
// Function: steal_work
static inline long steal_work(kt_for_t *t)
{
	int i, min_i = -1;
	long k, min = LONG_MAX;
	for (i = 0; i < t->n_threads; ++i)
		if (min > t->w[i].i) min = t->w[i].i, min_i = i;
	k = __sync_fetch_and_add(&t->w[min_i].i, t->n_threads);
	return k >= t->n? -1 : k;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl $0xffffffff, -0x10(%rbp) # imm = 0xFFFFFFFF
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
movq %rax, -0x20(%rbp)
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x29fa
movq -0x20(%rbp), %rax
movq -0x8(%rbp), %rcx
movq 0x10(%rcx), %rcx
movslq -0xc(%rbp), %rdx
shlq $0x4, %rdx
addq %rdx, %rcx
cmpq 0x8(%rcx), %rax
jle 0x29ed
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0xc(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
jmp 0x29ef
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x29a4
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rcx
movslq -0x10(%rbp), %rdx
shlq $0x4, %rdx
movslq (%rax), %rax
lock
xaddq %rax, 0x8(%rcx,%rdx)
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jl 0x2a33
movq $-0x1, %rax
movq %rax, -0x28(%rbp)
jmp 0x2a3b
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_sc_add_core
void lt_sc_add_core(lt_seqcloud_t *sc, uint64_t s)
{
	int i, absent;
	sc->s = s = s & ((1ULL<<sc->l*2) - 1);
	for (i = 0; i < sc->l; ++i) {
		int i2 = i * 2, a, c = s>>i2&3;
		for (a = 1; a < 4; ++a) {
			uint64_t x = (s & ~(3ULL << i2)) | (uint64_t)((a+c)&3) << i2;
			kh_put(s64, sc->mm, x, &absent);
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq -0x8(%rbp), %rax
movl (%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq -0x38(%rbp), %rcx
subq $0x1, %rax
andq %rax, %rcx
movq %rcx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq -0x8(%rbp), %rcx
cmpl (%rcx), %eax
jge 0x2bb4
movl -0x14(%rbp), %eax
shll %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
shrq %cl, %rax
andq $0x3, %rax
movl %eax, -0x24(%rbp)
movl $0x1, -0x20(%rbp)
cmpl $0x4, -0x20(%rbp)
jge 0x2ba4
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
movl $0x3, %edx
shlq %cl, %rdx
movq %rdx, %rcx
xorq $-0x1, %rcx
andq %rcx, %rax
movl -0x20(%rbp), %ecx
addl -0x24(%rbp), %ecx
andl $0x3, %ecx
movslq %ecx, %rdx
movl -0x1c(%rbp), %ecx
shlq %cl, %rdx
movq %rdx, %rcx
orq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x30(%rbp), %rsi
leaq -0x18(%rbp), %rdx
callq 0x2bc0
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x2b49
jmp 0x2ba6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x2b1a
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_sc_gen
lt_seqcloud_t *lt_sc_gen(const char *s)
{
	lt_seqcloud_t *sc;
	uint64_t x = 0;
	int i;
	sc = lt_sc_init();
	sc->l = strlen(s);
	for (i = 0; s[i] && i < sc->l; ++i) {
		int c = seq_nt4_table[(uint8_t)s[i]];
		if (c > 3) {
			lt_sc_destroy(sc);
			return 0;
		}
		x = x << 2 | c;
	}
	lt_sc_add_core(sc, x);
	return sc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq $0x0, -0x20(%rbp)
callq 0x2fd0
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x20d0
movl %eax, %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl $0x0, -0x24(%rbp)
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x29(%rbp)
je 0x2f4a
movl -0x24(%rbp), %eax
movq -0x18(%rbp), %rcx
cmpl (%rcx), %eax
setl %al
movb %al, -0x29(%rbp)
movb -0x29(%rbp), %al
testb $0x1, %al
jne 0x2f53
jmp 0x2fa9
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x7208(%rip), %rax      # 0xa170
movzbl (%rax,%rcx), %eax
movl %eax, -0x28(%rbp)
cmpl $0x3, -0x28(%rbp)
jle 0x2f88
movq -0x18(%rbp), %rdi
callq 0x2a50
movq $0x0, -0x8(%rbp)
jmp 0x2fbe
movq -0x20(%rbp), %rax
shlq $0x2, %rax
movslq -0x28(%rbp), %rcx
orq %rcx, %rax
movq %rax, -0x20(%rbp)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x2f25
movq -0x18(%rbp), %rdi
movq -0x20(%rbp), %rsi
callq 0x2ad0
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_sc_test
int lt_sc_test(const lt_seqcloud_t *sc, const char *seq, int max_hits, lt_sc_hit_t *hits)
{
	int i, l, n = 0;
	uint64_t x = 0, mask = (1ULL << sc->l*2) - 1;
	for (i = l = 0; seq[i]; ++i) {
		int c = seq_nt4_table[(uint8_t)seq[i]];
		if (c < 4) {
			x = (x << 2 | c) & mask;
			if (++l >= sc->l) {
				if (x == sc->s || kh_get(s64, sc->mm, x) != kh_end(sc->mm)) {
					hits[n].pos = i - (sc->l - 1);
					hits[n++].type = x == sc->s? 0 : 1;
					if (n == max_hits) return n;
				}
			}
		} else l = 0, x = 0;
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movq %rcx, -0x28(%rbp)
movl $0x0, -0x34(%rbp)
movq $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
subq $0x1, %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x30(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
cmpb $0x0, (%rax,%rcx)
je 0x318d
movq -0x18(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x70e9(%rip), %rax      # 0xa170
movzbl (%rax,%rcx), %eax
movl %eax, -0x4c(%rbp)
cmpl $0x4, -0x4c(%rbp)
jge 0x316e
movq -0x40(%rbp), %rax
shlq $0x2, %rax
movslq -0x4c(%rbp), %rcx
orq %rcx, %rax
andq -0x48(%rbp), %rax
movq %rax, -0x40(%rbp)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jl 0x316c
movq -0x40(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
je 0x30ef
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x40(%rbp), %rsi
callq 0x31a0
movq -0x10(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpl (%rcx), %eax
je 0x316a
movl -0x2c(%rbp), %esi
movq -0x10(%rbp), %rax
movl (%rax), %eax
subl $0x1, %eax
subl %eax, %esi
movq -0x28(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %edx
andl $0x3fffffff, %esi       # imm = 0x3FFFFFFF
andl $0xc0000000, %edx       # imm = 0xC0000000
orl %esi, %edx
movl %edx, (%rax,%rcx,4)
movq -0x40(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdx
movl $0x1, %esi
xorl %eax, %eax
cmpq %rdx, %rcx
cmovel %eax, %esi
movq -0x28(%rbp), %rax
movl -0x34(%rbp), %ecx
movl %ecx, %edx
addl $0x1, %edx
movl %edx, -0x34(%rbp)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
andl $0x3, %esi
shll $0x1e, %esi
andl $0x3fffffff, %edx       # imm = 0x3FFFFFFF
orl %esi, %edx
movl %edx, (%rax,%rcx,4)
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x3168
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3193
jmp 0x316a
jmp 0x316c
jmp 0x317d
movl $0x0, -0x30(%rbp)
movq $0x0, -0x40(%rbp)
jmp 0x317f
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x3060
movl -0x34(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_seq_rev
void lt_seq_rev(int l, const char *f, char *r)
{
	int i;
	for (i = 0; i < l; ++i)
		r[l - i - 1] = f[i];
	r[l] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x3347
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movb (%rax,%rcx), %dl
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3316
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_seq_revcomp
void lt_seq_revcomp(int l, const char *f, char *r)
{
	int i;
	for (i = 0; i < l; ++i)
		r[l - i - 1] = (uint8_t)f[i] >= 128? 'N' : comp_tab[(uint8_t)f[i]];
	r[l] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x33da
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
cmpl $0x80, %eax
jl 0x339b
movl $0x4e, %eax
movl %eax, -0x20(%rbp)
jmp 0x33b7
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movzbl (%rax,%rcx), %eax
movl %eax, %ecx
leaq 0x6ec0(%rip), %rax      # 0xa270
movsbl (%rax,%rcx), %eax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
movb %al, %dl
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
subl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3376
movq -0x18(%rbp), %rax
movslq -0x4(%rbp), %rcx
movb $0x0, (%rax,%rcx)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_ue_for1
int lt_ue_for1(int l1, const char *s1, const char *q1, int l2, const char *s2, const char *q2, int min_len, int max_pen)
{
	int i, pen = 0;
	for (i = 0; i < l1 && i < l2; ++i) {
		if (s1[i] != s2[i]) {
			pen += q1[i] >= LT_QUAL_THRES && (q2 == 0 || q2[i] >= LT_QUAL_THRES)? LT_HIGH_PEN : LT_LOW_PEN;
			if (i <= min_len && pen > max_pen) break;
			if (i > min_len && pen * min_len > i * max_pen) break; // in effect: pen > max_pen * ((double)i / min_len)
		}
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x39(%rbp)
jge 0x3437
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3443
jmp 0x34f9
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movslq -0x34(%rbp), %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x34e9
movq -0x18(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x35, %ecx
movb %al, -0x3a(%rbp)
jl 0x34a0
movb $0x1, %al
cmpq $0x0, -0x30(%rbp)
movb %al, -0x3b(%rbp)
je 0x349a
movq -0x30(%rbp), %rax
movslq -0x34(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x35, %eax
setge %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %dl
movl $0x1, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
jg 0x34cb
movl -0x38(%rbp), %eax
cmpl 0x18(%rbp), %eax
jle 0x34cb
jmp 0x34f9
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
jle 0x34e7
movl -0x38(%rbp), %eax
imull 0x10(%rbp), %eax
movl -0x34(%rbp), %ecx
imull 0x18(%rbp), %ecx
cmpl %ecx, %eax
jle 0x34e7
jmp 0x34f9
jmp 0x34e9
jmp 0x34eb
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x341e
movl -0x34(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_ue_rev1
int lt_ue_rev1(int l1, const char *s1, const char *q1, int l2, const char *s2, const char *q2, int min_len, int max_pen)
{
	int i, pen = 0;
	for (i = 0; i < l1 && i < l2; ++i) {
		if (s1[l1-1-i] != s2[l2-1-i]) {
			pen += q1[l1-1-i] >= LT_QUAL_THRES && (q2 == 0 || q2[l2-1-i] >= LT_QUAL_THRES)? LT_HIGH_PEN : LT_LOW_PEN;
			if (i <= min_len && pen > max_pen) break;
			if (i > min_len && pen * min_len > i * max_pen) break;
		}
	}
	return i;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %ecx
xorl %eax, %eax
cmpl -0x4(%rbp), %ecx
movb %al, -0x39(%rbp)
jge 0x3547
movl -0x34(%rbp), %eax
cmpl -0x1c(%rbp), %eax
setl %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %al
testb $0x1, %al
jne 0x3553
jmp 0x3629
movq -0x10(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %edx
subl $0x1, %edx
subl -0x34(%rbp), %edx
movslq %edx, %rdx
movsbl (%rcx,%rdx), %ecx
cmpl %ecx, %eax
je 0x3619
movq -0x18(%rbp), %rax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
subl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %ecx
xorl %eax, %eax
cmpl $0x35, %ecx
movb %al, -0x3a(%rbp)
jl 0x35d0
movb $0x1, %al
cmpq $0x0, -0x30(%rbp)
movb %al, -0x3b(%rbp)
je 0x35ca
movq -0x30(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
subl -0x34(%rbp), %ecx
movslq %ecx, %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x35, %eax
setge %al
movb %al, -0x3b(%rbp)
movb -0x3b(%rbp), %al
movb %al, -0x3a(%rbp)
movb -0x3a(%rbp), %dl
movl $0x1, %eax
movl $0x3, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
addl -0x38(%rbp), %eax
movl %eax, -0x38(%rbp)
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
jg 0x35fb
movl -0x38(%rbp), %eax
cmpl 0x18(%rbp), %eax
jle 0x35fb
jmp 0x3629
movl -0x34(%rbp), %eax
cmpl 0x10(%rbp), %eax
jle 0x3617
movl -0x38(%rbp), %eax
imull 0x10(%rbp), %eax
movl -0x34(%rbp), %ecx
imull 0x18(%rbp), %ecx
cmpl %ecx, %eax
jle 0x3617
jmp 0x3629
jmp 0x3619
jmp 0x361b
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x352e
movl -0x34(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_ue_for
int lt_ue_for(int l1, const char *s1, const char *q1, int l2, const char *s2, const char *q2, int max_pen, int min_len, int max_pos, uint64_t *pos)
{
	int i, n = 0;
	for (i = min_len; i <= l1; ++i) {
		int l;
		l = lt_ue_for1(i, s1 + l1 - i, q1 + l1 - i, l2, s2, q2, min_len, max_pen);
		if (l >= min_len && (l == i || l == l2)) {
			pos[n++] = (uint64_t)(l1 - i) << 32 | l;
			if (n == max_pos) return n;
		}
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x372b
movl -0x34(%rbp), %edi
movq -0x10(%rbp), %rsi
movslq -0x8(%rbp), %rax
addq %rax, %rsi
movslq -0x34(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movq -0x18(%rbp), %rdx
movslq -0x8(%rbp), %rax
addq %rax, %rdx
movslq -0x34(%rbp), %rcx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl 0x18(%rbp), %r10d
movl 0x10(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x33f0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jl 0x371b
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x36df
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x371b
movl -0x8(%rbp), %eax
subl -0x34(%rbp), %eax
movslq %eax, %rdx
shlq $0x20, %rdx
movslq -0x3c(%rbp), %rax
orq %rax, %rdx
movq 0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x38(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
cmpl 0x20(%rbp), %eax
jne 0x3719
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x3731
jmp 0x371b
jmp 0x371d
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3668
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_ue_rev
int lt_ue_rev(int l1, const char *s1, const char *q1, int l2, const char *s2, const char *q2, int max_pen, int min_len, int max_pos, uint64_t *pos)
{
	int i, n = 0;
	for (i = min_len; i <= l1; ++i) {
		int l;
		l = lt_ue_rev1(i, s1, q1, l2, s2, q2, min_len, max_pen);
		if (l >= min_len && (l == i || l == l2)) {
			pos[n++] = (uint64_t)(l1 - i) << 32 | l;
			if (n == max_pos) return n;
		}
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x28(%rbp), %rax
movl 0x20(%rbp), %eax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl 0x18(%rbp), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x8(%rbp), %eax
jg 0x3815
movl -0x34(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
movq -0x28(%rbp), %r8
movq -0x30(%rbp), %r9
movl 0x18(%rbp), %r10d
movl 0x10(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x3500
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl 0x18(%rbp), %eax
jl 0x3805
movl -0x3c(%rbp), %eax
cmpl -0x34(%rbp), %eax
je 0x37c9
movl -0x3c(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jne 0x3805
movl -0x8(%rbp), %eax
subl -0x34(%rbp), %eax
movslq %eax, %rdx
shlq $0x20, %rdx
movslq -0x3c(%rbp), %rax
orq %rax, %rdx
movq 0x28(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x38(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
cmpl 0x20(%rbp), %eax
jne 0x3803
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x381b
jmp 0x3805
jmp 0x3807
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3778
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/DReichLab[P]adna/trim.c
// Function: lt_ue_contained
int lt_ue_contained(int l1, const char *s1, const char *q1, int l2, const char *s2, const char *q2, int max_pen, int max_pos, uint64_t *pos)
{
	int i, n = 0;
	for (i = 1; i < l2 - l1; ++i) {
		int l;
		l = lt_ue_for1(l1, s1, q1, l2 - i, s2 + i, q2 + i, l1, max_pen);
		if (l == l1) {
			pos[n++] = (uint64_t)i << 32 | l;
			if (n == max_pos) return n;
		}
	}
	return n;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq 0x20(%rbp), %rax
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq %r8, -0x28(%rbp)
movq %r9, -0x30(%rbp)
movl $0x0, -0x38(%rbp)
movl $0x1, -0x34(%rbp)
movl -0x34(%rbp), %eax
movl -0x1c(%rbp), %ecx
subl -0x8(%rbp), %ecx
cmpl %ecx, %eax
jge 0x3904
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rdx
movl -0x1c(%rbp), %ecx
subl -0x34(%rbp), %ecx
movq -0x28(%rbp), %r8
movslq -0x34(%rbp), %rax
addq %rax, %r8
movq -0x30(%rbp), %r9
movslq -0x34(%rbp), %rax
addq %rax, %r9
movl -0x8(%rbp), %r10d
movl 0x10(%rbp), %eax
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x33f0
movl %eax, -0x3c(%rbp)
movl -0x3c(%rbp), %eax
cmpl -0x8(%rbp), %eax
jne 0x38f4
movslq -0x34(%rbp), %rdx
shlq $0x20, %rdx
movslq -0x3c(%rbp), %rax
orq %rax, %rdx
movq 0x20(%rbp), %rax
movl -0x38(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x38(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movl -0x38(%rbp), %eax
cmpl 0x18(%rbp), %eax
jne 0x38f2
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x390a
jmp 0x38f4
jmp 0x38f6
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x3866
movl -0x38(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)