// File: /workspace/github_cpp_makefile_star2_O1/chhylp123[P]hifiasm/gfa_ut.cpp
// Function: integer_realign_g(ul_resolve_t*, usg_t*, uinfo_srt_warp_t*, unsigned int, integer_t*)
void integer_realign_g(ul_resolve_t *uidx, usg_t *ng, uinfo_srt_warp_t *seq, uint32_t seq_id, integer_t *buf)
{
    if(seq->n < 2) return;
    // if(seq_id != 1137) return;
    uint64_t *srt, *track, k, z, m, t, i, l, seq_n, j, sc, csc, mm_sc, mm_idx, n_v, n_u, n_v0, *p, lin, pn;
    uint32_t vi, vj; mmap_t *zm, *zt; 
    ///ng->map: the nodes in the new graph that are mapped to the initial HiFi graph 
    for (i = seq_n = 0; i < seq->n; ++i) seq_n += ng->mp.a[seq->a[i].v>>1].n;
    // fprintf(stderr, "[M::%s::] seq_id::%u, seq_n::%u, seq->n::%u\n", 
    // __func__, seq_id, (uint32_t)seq_n, (uint32_t)seq->n);

    buf->o.n = buf->u.n = 0; 
    kv_resize(uint64_t, buf->o, (seq_n<<1)); 
    srt = buf->o.a; track = buf->o.a + seq_n;

    for (z = l = 0; z < seq->n; ++z) {
        csc = seq->a[z].n; 
        zm = &(ng->mp.a[seq->a[z].v>>1]);///current 
        zt = ((z>0)?(&(ng->mp.a[seq->a[z-1].v>>1])):(NULL));///prefix
        for (m = 0; m < zm->n; m++) {
            i = l + m; mm_sc = csc; mm_idx = ((uint64_t)0x7FFFFFFF); 
            vi = (zm->a[m]<<1)|(seq->a[z].v&1);
            if(zt && zt->n > 0) {
                for (t = 0; t < zt->n; t++) {
                    j = l + t - zt->n;
                    vj = (zt->a[t]<<1)|(seq->a[z-1].v&1);
                    if(check_hybrid_connect(ng, seq_id, vj, z-1, vi, z)) {///seq_id:: integer contig id
                        sc = csc + (((uint32_t)-1) - (track[j]>>32));
                        if(sc > mm_sc) {
                            mm_sc = sc; mm_idx = j;
                        }
                    }
                }
            }
            mm_sc = ((uint32_t)-1) - mm_sc;
            track[i] = mm_sc; track[i] <<= 32; track[i] |= mm_idx;
            srt[i] = track[i]>>32; srt[i] <<= 32; srt[i] |= i;
        }
        l += zm->n;
    }
    assert(l == seq_n);

    radix_sort_srt64(srt, srt + seq_n); 
    kv_resize(uint64_t, buf->res_dump, buf->res_dump.n + seq_n); 
    l = buf->res_dump.n; m = buf->u.n;
    for (k = n_v = n_u = 0; k < seq_n; k++) {
        n_v0 = n_v; i = (uint32_t)srt[k];
        for (; i != ((uint64_t)0x7FFFFFFF) && (!(track[i]&((uint64_t)0x80000000)));) {
            kv_push(uint64_t, buf->res_dump, i); n_v++; 
            track[i] |= ((uint64_t)0x80000000);
            i = track[i]&((uint64_t)0x7FFFFFFF); 
        }
        if(n_v - n_v0 <= 1) {///not useful to resolve anything if the UL covers less than 1 nodes 
            buf->res_dump.n -= (n_v-n_v0); n_v = n_v0;
            continue;
        }
        kv_pushp(uint64_t, buf->u, &p); n_u++; 
        (*p) = n_v-n_v0; (*p) = ((uint32_t)-1) - (*p); (*p) <<= 32; (*p) |= ((uint64_t)(l+n_v0));
    }

    for (z = i = 0; z < seq->n; ++z) {
        zm = &(ng->mp.a[seq->a[z].v>>1]);
        for (k = 0; k < zm->n; k++, i++) {
            srt[i] = z; srt[i] <<= 32; srt[i] |= ((zm->a[k]<<1)|(seq->a[z].v&1));
        }
    }
    assert(i == seq_n);
    ///srt[]: (idx in seq)|(node id)
    uint64_t *r, nt;
    for (k = n_u = nt = 0; k < buf->u.n; k++) {
        n_v0 = (uint32_t)buf->u.a[k]; r = buf->res_dump.a + n_v0; 
        n_v = (((uint32_t)-1) - (buf->u.a[k]>>32));
        // if(n_v < 2) continue;
        // fprintf(stderr, "+[M::%s::k->%lu] buf->u.n::%u, n_v0::%lu, n_v::%lu, nt::%lu\n", 
        // __func__, k, (uint32_t)buf->u.n, n_v0, n_v, nt);
        assert(n_v >= 2);
        buf->u.a[n_u] = nt<<32;
        for (i = 0; i < n_v; i++, nt++) {
            // fprintf(stderr, ">[M::%s::] i::%lu, nt::%lu, n_v-i-1::%lu, r[n_v-i-1]::%lu\n", 
            //         __func__, i, nt, n_v-i-1, r[n_v-i-1]);
            track[nt] = srt[r[n_v-i-1]];
        }
        buf->u.a[n_u] |= nt; n_u++;
        // fprintf(stderr, "-[M::%s::k->%lu] buf->u.n::%u, n_v0::%lu, n_v::%lu, nt::%lu\n", 
        // __func__, k, (uint32_t)buf->u.n, n_v0, n_v, nt);
    }
    buf->u.n = n_u;

    uint64_t ceq_s, ceq_e, peq_s, peq_e, min_e, max_s;
    for (k = n_u = 0; k < buf->u.n; k++) {
        n_v0 = buf->u.a[k]>>32; n_v = (uint32_t)buf->u.a[k];///[n_v0, n_v)
        ceq_s = track[n_v0]>>32; ceq_e = (track[n_v-1]>>32) + 1;
        assert((ceq_e-ceq_s) == (n_v-n_v0));
        for (z = 0; z < n_u; z++) {
            n_v0 = buf->u.a[z]>>32; n_v = (uint32_t)buf->u.a[z];
            peq_s = track[n_v0]>>32; peq_e = (track[n_v-1]>>32) + 1;
            assert((peq_e-peq_s) == (n_v-n_v0));
            max_s = MAX(peq_s, ceq_s); min_e = MIN(peq_e, ceq_e);
            if(min_e > max_s) break;
        }
        if(z < n_u) continue;
        buf->u.a[n_u++] = buf->u.a[k];
    }
    buf->u.n = n_u; buf->res_dump.n = l;
    for (k = n_u = 0; k < buf->u.n; k++) {
        // t = (uint32_t)-1; t <<= 32; 
        t = seq_id; t <<= 32; t |= ((uint64_t)0x8000000000000000);
        t |= (((uint32_t)buf->u.a[k])-(buf->u.a[k]>>32)); 
        pn = buf->res_dump.n; kv_push(uint64_t, buf->res_dump, t);
        n_v0 = buf->u.a[k]>>32; n_v = (uint32_t)buf->u.a[k];
        for (z = n_v0, lin = 1; z < n_v; z++) {
            if(lin && (z > n_v0)) {
                if((usg_arc_occ(ng, ((uint32_t)track[z])^1) > 1) || 
                            (usg_arc_occ(ng, ((uint32_t)track[z-1])) > 1)) {
                    lin = 0;
                }
            }
            kv_push(uint64_t, buf->res_dump, (uint32_t)track[z]);
        }

        if(lin == 1) buf->res_dump.n = pn;
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rcx, 0x50(%rsp)
movq %rsi, 0x18(%rsp)
movq (%rdx), %rax
cmpq $0x2, %rax
jb 0x20d10c
movq %r8, %r15
movq %rdx, %r12
movq 0x18(%rsp), %rcx
movq 0x28(%rcx), %rcx
movq 0x10(%rdx), %rdx
xorl %esi, %esi
movq %rsi, %rbx
movl (%rdx), %esi
shrl %esi
leaq (%rsi,%rsi,2), %rsi
movq 0x8(%rcx,%rsi,8), %r14
leaq (%r14,%rbx), %rsi
addq $0x10, %rdx
decq %rax
jne 0x20c836
xorl %eax, %eax
movq %rax, 0x90(%r15)
movq %rax, 0x78(%r15)
movq %rsi, 0x28(%rsp)
leaq (%rsi,%rsi), %rax
cmpq %rax, 0x80(%r15)
jae 0x20c8cc
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x80(%r15)
movq 0x88(%r15), %rdi
leaq 0x8(,%rcx,8), %rsi
callq 0x2370
movq %rax, 0x88(%r15)
movq 0x88(%r15), %r13
movq 0x28(%rsp), %rax
leaq (,%rax,8), %rsi
addq %r13, %rsi
cmpq $0x0, (%r12)
movq %r15, 0x70(%rsp)
movq %rsi, 0x8(%rsp)
movq %r12, 0x58(%rsp)
movq %r13, 0x78(%rsp)
je 0x20cb7d
movq 0x10(%r12), %rdx
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rdi
addq %rbx, %r14
leaq (,%r14,8), %rax
addq %r13, %rax
movq %rax, 0x90(%rsp)
xorl %ecx, %ecx
movq $0x0, 0x10(%rsp)
movq %rdx, 0x60(%rsp)
movq %rdi, 0x98(%rsp)
movq %rcx, %rax
shlq $0x4, %rax
testq %rcx, %rcx
movq %rcx, 0x68(%rsp)
je 0x20c962
leaq (%rdx,%rax), %rcx
movl -0x10(%rcx), %ecx
shrl %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,8), %r8
jmp 0x20c965
xorl %r8d, %r8d
movl (%rdx,%rax), %ecx
movq %rcx, 0x38(%rsp)
shrl %ecx
leaq (%rcx,%rcx,2), %rcx
leaq (%rdi,%rcx,8), %rcx
movq %rcx, 0x80(%rsp)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x20cb4e
movq 0x60(%rsp), %rcx
movl 0xc(%rcx,%rax), %eax
movq %rax, 0x30(%rsp)
movq 0x80(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xb0(%rsp)
movq 0x38(%rsp), %rax
andl $0x1, %eax
movq %rax, 0x38(%rsp)
movq 0x68(%rsp), %rax
decq %rax
movq %rax, 0x48(%rsp)
shlq $0x4, %rax
addq %rcx, %rax
movq %rax, 0xa8(%rsp)
movq 0x10(%rsp), %rax
movq 0x90(%rsp), %rcx
leaq (%rcx,%rax,8), %rax
movq %rax, 0xa0(%rsp)
movq $0x0, 0x40(%rsp)
movq %r8, 0x88(%rsp)
movl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
testq %r8, %r8
je 0x20cae7
movq 0x8(%r8), %r15
movq 0x30(%rsp), %rbx
testq %r15, %r15
je 0x20caec
movq 0xb0(%rsp), %rax
movq 0x40(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x38(%rsp), %rcx
leal (%rcx,%rax,2), %eax
movl %eax, 0x20(%rsp)
movq 0x88(%rsp), %rax
movq (%rax), %r12
movq 0xa8(%rsp), %rax
movl (%rax), %r13d
andl $0x1, %r13d
movq 0x10(%rsp), %rax
subq %r15, %rax
movq %rax, 0xc0(%rsp)
leaq (,%r15,8), %rax
movq 0xa0(%rsp), %rcx
subq %rax, %rcx
movq %rcx, 0xb8(%rsp)
xorl %ebp, %ebp
movq 0x30(%rsp), %rbx
movl (%r12,%rbp,4), %eax
leal (%r13,%rax,2), %edx
movq 0x18(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rcx
movl 0x20(%rsp), %r8d
callq 0x20c704
testl %eax, %eax
je 0x20cadd
movq 0xc0(%rsp), %rax
addq %rbp, %rax
movq 0xb8(%rsp), %rcx
movq (%rcx,%rbp,8), %rcx
notq %rcx
shrq $0x20, %rcx
addq 0x30(%rsp), %rcx
cmpq %rbx, %rcx
cmovaq %rax, %r14
cmovaq %rcx, %rbx
incq %rbp
cmpq %rbp, %r15
jne 0x20ca89
jmp 0x20caec
movq 0x30(%rsp), %rbx
movq 0x10(%rsp), %rax
movq 0x40(%rsp), %rdi
addq %rdi, %rax
shlq $0x20, %rbx
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
movq %rdx, %rcx
subq %rbx, %rcx
orq %r14, %rcx
movq 0x8(%rsp), %rsi
movq %rcx, (%rsi,%rax,8)
andq %rdx, %rcx
orq %rax, %rcx
movq 0x78(%rsp), %r13
movq %rcx, (%r13,%rax,8)
incq %rdi
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rdi, 0x40(%rsp)
cmpq %rcx, %rdi
movq 0x88(%rsp), %r8
jb 0x20ca00
addq %rcx, 0x10(%rsp)
movq 0x68(%rsp), %rcx
incq %rcx
movq 0x58(%rsp), %rax
cmpq (%rax), %rcx
movq 0x70(%rsp), %r15
movq 0x60(%rsp), %rdx
movq 0x98(%rsp), %rdi
jb 0x20c93e
jmp 0x20cb86
movq $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rbx
cmpq %rbx, 0x10(%rsp)
jne 0x20d17b
movq %r13, %rdi
callq 0x1e3b6a
movq 0x300(%r15), %rax
addq %rbx, %rax
cmpq %rax, 0x308(%r15)
jae 0x20cc0b
decq %rax
movq %rax, %rcx
shrq %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x2, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x4, %rcx
orq %rax, %rcx
movq %rcx, %rax
shrq $0x8, %rax
orq %rcx, %rax
movq %rax, %rcx
shrq $0x10, %rcx
orq %rax, %rcx
leaq 0x1(%rcx), %rax
movq %rax, 0x308(%r15)
movq 0x310(%r15), %rdi
leaq 0x8(,%rcx,8), %rsi
callq 0x2370
movq %rax, 0x310(%r15)
movq 0x300(%r15), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x28(%rsp)
movq 0x8(%rsp), %r11
je 0x20cd7c
xorl %ebx, %ebx
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
xorl %r12d, %r12d
movl (%r13,%rbx,8), %r14d
movq %r12, %r13
cmpq $0x7fffffff, %r14       # imm = 0x7FFFFFFF
je 0x20ccd8
movq %r12, %r13
testb $-0x80, 0x3(%r11,%r14,8)
jne 0x20ccd8
movq 0x308(%r15), %rax
cmpq %rax, 0x300(%r15)
jne 0x20cc99
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x308(%r15)
movq 0x310(%r15), %rdi
shlq $0x3, %rsi
callq 0x2370
movq 0x8(%rsp), %r11
movq %rax, 0x310(%r15)
movq 0x300(%r15), %rax
movq 0x310(%r15), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x300(%r15)
movq %r14, (%rcx,%rax,8)
incq %r13
movq (%r11,%r14,8), %rax
movq %rax, %rcx
btsq $0x1f, %rcx
movq %rcx, (%r11,%r14,8)
andq %rbp, %rax
movq %rax, %r14
cmpq %rbp, %rax
jne 0x20cc4a
movq %r13, %r14
subq %r12, %r14
cmpq $0x1, %r14
ja 0x20cced
subq %r14, 0x300(%r15)
jmp 0x20cd69
movq 0x98(%r15), %rax
cmpq %rax, 0x90(%r15)
jne 0x20cd30
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x98(%r15)
movq 0xa0(%r15), %rdi
shlq $0x3, %rsi
callq 0x2370
movq 0x8(%rsp), %r11
movq %rax, 0xa0(%r15)
movq 0x90(%r15), %rax
movq 0xa0(%r15), %rcx
leaq 0x1(%rax), %rdx
movq %rdx, 0x90(%r15)
shlq $0x20, %r14
movabsq $-0x100000000, %rdx     # imm = 0xFFFFFFFF00000000
subq %r14, %rdx
addq 0x20(%rsp), %r12
orq %rdx, %r12
movq %r12, (%rcx,%rax,8)
movq %r13, %r12
incq %rbx
cmpq 0x28(%rsp), %rbx
movq 0x78(%rsp), %r13
jne 0x20cc32
movq 0x58(%rsp), %r12
cmpq $0x0, (%r12)
je 0x20ce03
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rcx
movq 0x10(%r12), %rdx
xorl %esi, %esi
xorl %eax, %eax
movq %rsi, %rdi
shlq $0x4, %rdi
movl (%rdx,%rdi), %edi
movl %edi, %r8d
shrl %r8d
leaq (%r8,%r8,2), %r8
cmpq $0x0, 0x8(%rcx,%r8,8)
je 0x20cdf8
leaq (%rcx,%r8,8), %r8
movq %rsi, %r9
shlq $0x20, %r9
movq (%r8), %r10
andl $0x1, %edi
leaq (,%rax,8), %r11
addq %r13, %r11
xorl %ebx, %ebx
movq %r9, (%r11,%rbx,8)
movl (%r10,%rbx,4), %r14d
leal (%rdi,%r14,2), %r14d
orq %r9, %r14
movq %r14, (%r11,%rbx,8)
incq %rbx
cmpq 0x8(%r8), %rbx
jb 0x20cdd4
addq %rbx, %rax
movq 0x8(%rsp), %r11
incq %rsi
cmpq (%r12), %rsi
jb 0x20cd9a
jmp 0x20ce05
xorl %eax, %eax
cmpq 0x28(%rsp), %rax
jne 0x20d19a
cmpq $0x0, 0x90(%r15)
je 0x20ce8a
movq 0xa0(%r15), %rcx
movq 0x310(%r15), %rdx
addq $-0x8, %rdx
xorl %eax, %eax
xorl %esi, %esi
movq (%rcx,%rax,8), %r8
movq %r8, %rdi
shrq $0x21, %rdi
cmpl $0x7fffffff, %edi       # imm = 0x7FFFFFFF
jae 0x20d13d
movq %r8, %rdi
notq %rdi
shrq $0x20, %rdi
movl %r8d, %r8d
movq %rsi, %r9
shlq $0x20, %r9
movq %r9, (%rcx,%rax,8)
leaq (%rdx,%r8,8), %r8
movq (%r8,%rdi,8), %r9
movq (%r13,%r9,8), %r9
movq %r9, (%r11,%rsi,8)
incq %rsi
decq %rdi
jne 0x20ce63
orq %rsi, (%rcx,%rax,8)
incq %rax
cmpq 0x90(%r15), %rax
jb 0x20ce30
jmp 0x20ce8c
xorl %eax, %eax
movq %rax, 0x90(%r15)
testq %rax, %rax
je 0x20cf59
movq 0xa0(%r15), %rcx
xorl %edx, %edx
xorl %eax, %eax
movq (%rcx,%rdx,8), %rsi
movq %rsi, %r9
shrq $0x20, %r9
movl %esi, %r10d
movq (%r11,%r9,8), %rdi
shrq $0x20, %rdi
movl -0x4(%r11,%r10,8), %r8d
incq %r8
movq %r8, %r11
subq %rdi, %r11
subq %r9, %r10
cmpq %r10, %r11
jne 0x20d15c
testq %rax, %rax
movq 0x8(%rsp), %r11
je 0x20cf39
xorl %r9d, %r9d
movq (%rcx,%r9,8), %r10
movl %r10d, %ebx
movq %r10, %r14
shrq $0x20, %r14
movq (%r11,%r14,8), %r10
shrq $0x20, %r10
movl -0x4(%r11,%rbx,8), %r11d
incq %r11
movq %r11, %r15
subq %r10, %r15
subq %r14, %rbx
cmpq %rbx, %r15
jne 0x20d11e
cmpq %rdi, %r10
cmovbeq %rdi, %r10
cmpq %r8, %r11
cmovaeq %r8, %r11
cmpq %r10, %r11
movq 0x70(%rsp), %r15
ja 0x20cf42
incq %r9
cmpq %r9, %rax
movq 0x8(%rsp), %r11
jne 0x20cee4
movq %rsi, (%rcx,%rax,8)
incq %rax
jmp 0x20cf47
movq 0x8(%rsp), %r11
incq %rdx
cmpq 0x90(%r15), %rdx
jb 0x20cea7
jmp 0x20cf5b
xorl %eax, %eax
movq %rax, 0x90(%r15)
movq 0x20(%rsp), %rcx
movq %rcx, 0x300(%r15)
testq %rax, %rax
je 0x20d10c
shlq $0x20, 0x50(%rsp)
xorl %r14d, %r14d
movq 0xa0(%r15), %rax
movq (%rax,%r14,8), %rbx
movq 0x300(%r15), %r12
movq 0x308(%r15), %rax
cmpq %rax, %r12
jne 0x20cfd1
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x308(%r15)
movq 0x310(%r15), %rdi
shlq $0x3, %rsi
callq 0x2370
movq 0x8(%rsp), %r11
movq %rax, 0x310(%r15)
movl %ebx, %eax
shrq $0x20, %rbx
subq %rbx, %rax
orq 0x50(%rsp), %rax
btsq $0x3f, %rax
movq 0x300(%r15), %rcx
movq 0x310(%r15), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x300(%r15)
movq %rax, (%rdx,%rcx,8)
movq 0xa0(%r15), %rax
movq (%rax,%r14,8), %r13
movl %r13d, %ebx
shrq $0x20, %r13
cmpq %rbx, %r13
jae 0x20d0f5
movq %r12, 0x48(%rsp)
movq %r14, 0x20(%rsp)
movl $0x1, %r14d
movq %r13, %rbp
testq %r14, %r14
je 0x20d070
movl $0x1, %r14d
movb $0x1, %r12b
cmpq %r13, %rbp
jbe 0x20d076
movl (%r11,%rbp,8), %esi
xorl $0x1, %esi
movq 0x18(%rsp), %rdi
callq 0x20c7b9
cmpl $0x1, %eax
ja 0x20d070
movq 0x8(%rsp), %rax
movl -0x8(%rax,%rbp,8), %esi
movq 0x18(%rsp), %rdi
callq 0x20c7b9
cmpl $0x2, %eax
jb 0x20d076
xorl %r12d, %r12d
xorl %r14d, %r14d
movq 0x308(%r15), %rax
cmpq %rax, 0x300(%r15)
jne 0x20d0b4
leaq (%rax,%rax), %rsi
testq %rax, %rax
movl $0x2, %eax
cmoveq %rax, %rsi
movq %rsi, 0x308(%r15)
movq 0x310(%r15), %rdi
shlq $0x3, %rsi
callq 0x2370
movq %rax, 0x310(%r15)
movq 0x8(%rsp), %r11
movl (%r11,%rbp,8), %eax
movq 0x300(%r15), %rcx
movq 0x310(%r15), %rdx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x300(%r15)
movq %rax, (%rdx,%rcx,8)
incq %rbp
cmpq %rbp, %rbx
jne 0x20d02f
testb %r12b, %r12b
movq 0x20(%rsp), %r14
movq 0x48(%rsp), %r12
je 0x20d0fc
movq %r12, 0x300(%r15)
incq %r14
cmpq 0x90(%r15), %r14
jb 0x20cf80
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2f3ea(%rip), %rdi     # 0x23c50f
leaq 0x2c1f9(%rip), %rsi     # 0x239325
leaq 0x2f351(%rip), %rcx     # 0x23c484
movl $0x2eee, %edx           # imm = 0x2EEE
callq 0x2110
leaq 0x2f3a6(%rip), %rdi     # 0x23c4ea
leaq 0x2c1da(%rip), %rsi     # 0x239325
leaq 0x2f332(%rip), %rcx     # 0x23c484
movl $0x2ed9, %edx           # imm = 0x2ED9
callq 0x2110
leaq 0x2f390(%rip), %rdi     # 0x23c4f3
leaq 0x2c1bb(%rip), %rsi     # 0x239325
leaq 0x2f313(%rip), %rcx     # 0x23c484
movl $0x2eea, %edx           # imm = 0x2EEA
callq 0x2110
leaq 0x2f2f7(%rip), %rdi     # 0x23c479
leaq 0x2c19c(%rip), %rsi     # 0x239325
leaq 0x2f2f4(%rip), %rcx     # 0x23c484
movl $0x2eb6, %edx           # imm = 0x2EB6
callq 0x2110
leaq 0x2f33e(%rip), %rdi     # 0x23c4df
leaq 0x2c17d(%rip), %rsi     # 0x239325
leaq 0x2f2d5(%rip), %rcx     # 0x23c484
movl $0x2ed0, %edx           # imm = 0x2ED0
callq 0x2110