// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/htscodecs/htscodecs/rANS_static.c
// Function: rans_uncompress_O1
static
unsigned char *rans_uncompress_O1(unsigned char *in, unsigned int in_size,
                                  unsigned int *out_size) {
    /* Load in the static tables */
    unsigned char *cp = in + 9;
    unsigned char *ptr_end = in + in_size;
    int i, j = -999, rle_i, rle_j;
    unsigned int x;
    unsigned int out_sz, in_sz;
    char *out_buf = NULL;

    // Sanity checking
    if (in_size < 27) // Need at least this many bytes to start
        return NULL;

    if (*in++ != 1) // Order-1 check
        return NULL;

    in_sz  = ((in[0])<<0) | ((in[1])<<8) | ((in[2])<<16) | (((uint32_t)in[3])<<24);
    out_sz = ((in[4])<<0) | ((in[5])<<8) | ((in[6])<<16) | (((uint32_t)in[7])<<24);
    if (in_sz != in_size-9)
        return NULL;

    if (out_sz >= INT_MAX)
        return NULL; // protect against some overflow cases

    // For speeding up the fuzzer only.
    // Small input can lead to large uncompressed data.
    // We reject this as it just slows things up instead of testing more code
    // paths (once we've verified a few times for large data).
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
    if (out_sz > 100000)
        return NULL;
#endif

    // Allocate decoding lookup tables
    RansDecSymbol32 (*syms)[256];
    uint8_t *mem = htscodecs_tls_calloc(256, sizeof(ari_decoder)
                                        + sizeof(*syms));
    if (!mem)
        return NULL;
    ari_decoder *const D = (ari_decoder *)mem;
    syms = (RansDecSymbol32 (*)[256])(mem + 256*sizeof(ari_decoder));
    int16_t map[256], map_i = 0;
    
    memset(map, -1, 256*sizeof(*map));

    if (!D) goto cleanup;
    /* These memsets prevent illegal memory access in syms due to
       broken compressed data.  As D is calloc'd, all illegal transitions
       will end up in either row or column 0 of syms. */
    memset(&syms[0], 0, sizeof(syms[0]));
    for (i = 0; i < 256; i++)
        memset(&syms[i][0], 0, sizeof(syms[0][0]));

    //fprintf(stderr, "out_sz=%d\n", out_sz);

    //i = *cp++;
    rle_i = 0;
    i = *cp++;
    do {
        // Map arbitrary a,b,c to 0,1,2 to improve cache locality.
        if (map[i] == -1)
            map[i] = map_i++;
        int m_i = map[i];

        rle_j = x = 0;
        j = *cp++;
        do {
            if (map[j] == -1)
                map[j] = map_i++;

            int F, C;
            if (cp > ptr_end - 16) goto cleanup; // Not enough input bytes left
            if ((F = *cp++) >= 128) {
                F &= ~128;
                F = ((F & 127) << 8) | *cp++;
            }
            C = x;

            //fprintf(stderr, "i=%d j=%d F=%d C=%d\n", i, j, F, C);

            if (unlikely(!F))
                F = TOTFREQ;

            RansDecSymbolInit32(&syms[m_i][j], C, F);

            /* Build reverse lookup table */
            //if (!D[i].R) D[i].R = (unsigned char *)malloc(TOTFREQ);
            if (x + F > TOTFREQ)
                goto cleanup;

            memset(&D[m_i].R[x], j, F);
            x += F;

            if (!rle_j && j+1 == *cp) {
                j = *cp++;
                rle_j = *cp++;
            } else if (rle_j) {
                rle_j--;
                j++;
                if (j > 255)
                    goto cleanup;
            } else {
                j = *cp++;
            }
        } while(j);

        if (x < TOTFREQ-1 || x > TOTFREQ)
            goto cleanup;
        if (x < TOTFREQ) // historically we fill 4095, not 4096
            D[i].R[x] = D[i].R[x-1];

        if (!rle_i && i+1 == *cp) {
            i = *cp++;
            rle_i = *cp++;
        } else if (rle_i) {
            rle_i--;
            i++;
            if (i > 255)
                goto cleanup;
        } else {
            i = *cp++;
        }
    } while (i);
    for (i = 0; i < 256; i++)
        if (map[i] == -1)
            map[i] = 0;

    RansState rans0, rans1, rans2, rans3;
    uint8_t *ptr = cp;
    if (cp > ptr_end - 16) goto cleanup; // Not enough input bytes left
    RansDecInit(&rans0, &ptr); if (rans0 < RANS_BYTE_L) goto cleanup;
    RansDecInit(&rans1, &ptr); if (rans1 < RANS_BYTE_L) goto cleanup;
    RansDecInit(&rans2, &ptr); if (rans2 < RANS_BYTE_L) goto cleanup;
    RansDecInit(&rans3, &ptr); if (rans3 < RANS_BYTE_L) goto cleanup;

    RansState R[4];
    R[0] = rans0;
    R[1] = rans1;
    R[2] = rans2;
    R[3] = rans3;

    unsigned int isz4 = out_sz>>2;
    uint32_t l0 = 0;
    uint32_t l1 = 0;
    uint32_t l2 = 0;
    uint32_t l3 = 0;
    
    unsigned int i4[] = {0*isz4, 1*isz4, 2*isz4, 3*isz4};

    /* Allocate output buffer */
    out_buf = malloc(out_sz);
    if (!out_buf) goto cleanup;

    uint8_t cc0 = D[map[l0]].R[R[0] & ((1u << TF_SHIFT)-1)];
    uint8_t cc1 = D[map[l1]].R[R[1] & ((1u << TF_SHIFT)-1)];
    uint8_t cc2 = D[map[l2]].R[R[2] & ((1u << TF_SHIFT)-1)];
    uint8_t cc3 = D[map[l3]].R[R[3] & ((1u << TF_SHIFT)-1)];

    ptr_end -= 8;
    for (; likely(i4[0] < isz4); i4[0]++, i4[1]++, i4[2]++, i4[3]++) {
        // seq4-head2: file q40b
        //          O3      O2
        // gcc7     296/291 290/260
        // gcc10    292/292 290/261
        // gcc11    293/293 290/265
        // gcc12    293/290 291/266
        // clang10  293/290 296/272
        // clang13  300/290 290/266
        out_buf[i4[0]] = cc0;
        out_buf[i4[1]] = cc1;
        out_buf[i4[2]] = cc2;
        out_buf[i4[3]] = cc3;

        RansDecSymbol32 s[4] = {
            syms[l0][cc0],
            syms[l1][cc1],
            syms[l2][cc2],
            syms[l3][cc3],
        };
        RansDecAdvanceStep(&R[0], s[0].start, s[0].freq, TF_SHIFT);
        RansDecAdvanceStep(&R[1], s[1].start, s[1].freq, TF_SHIFT);
        RansDecAdvanceStep(&R[2], s[2].start, s[2].freq, TF_SHIFT);
        RansDecAdvanceStep(&R[3], s[3].start, s[3].freq, TF_SHIFT);

        // Likely here helps speed of high-entropy data by 10-11%,
        // but harms low entropy-data speed by 3-4%.
        if ((ptr < ptr_end)) {
            RansDecRenorm2(&R[0], &R[1], &ptr);
            RansDecRenorm2(&R[2], &R[3], &ptr);
        } else {
            RansDecRenormSafe(&R[0], &ptr, ptr_end+8);
            RansDecRenormSafe(&R[1], &ptr, ptr_end+8);
            RansDecRenormSafe(&R[2], &ptr, ptr_end+8);
            RansDecRenormSafe(&R[3], &ptr, ptr_end+8);
        }

        l0 = map[cc0];
        l1 = map[cc1];
        l2 = map[cc2];
        l3 = map[cc3];

        cc0 = D[l0].R[R[0] & ((1u << TF_SHIFT)-1)];
        cc1 = D[l1].R[R[1] & ((1u << TF_SHIFT)-1)];
        cc2 = D[l2].R[R[2] & ((1u << TF_SHIFT)-1)];
        cc3 = D[l3].R[R[3] & ((1u << TF_SHIFT)-1)];
    }

    // Remainder
    for (; i4[3] < out_sz; i4[3]++) {
        unsigned char c3 = D[l3].R[RansDecGet(&R[3], TF_SHIFT)];
        out_buf[i4[3]] = c3;

        uint32_t m = R[3] & ((1u << TF_SHIFT)-1);
        R[3] = syms[l3][c3].freq * (R[3]>>TF_SHIFT) + m - syms[l3][c3].start;
        RansDecRenormSafe(&R[3], &ptr, ptr_end+8);
        l3 = map[c3];
    }
    
    *out_size = out_sz;

 cleanup:
    htscodecs_tls_free(D);

    return (unsigned char *)out_buf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x320, %rsp            # imm = 0x320
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
addq $0x9, %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %ecx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movl $0xfffffc19, -0x38(%rbp) # imm = 0xFFFFFC19
movq $0x0, -0x58(%rbp)
cmpl $0x1b, -0x14(%rbp)
jae 0xc5432
movq $0x0, -0x8(%rbp)
jmp 0xc5fdb
movq -0x10(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x10(%rbp)
movzbl (%rax), %eax
cmpl $0x1, %eax
je 0xc5456
movq $0x0, -0x8(%rbp)
jmp 0xc5fdb
movq -0x10(%rbp), %rax
movzbl (%rax), %eax
shll $0x0, %eax
movq -0x10(%rbp), %rcx
movzbl 0x1(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x2(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x3(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
movzbl 0x4(%rax), %eax
shll $0x0, %eax
movq -0x10(%rbp), %rcx
movzbl 0x5(%rcx), %ecx
shll $0x8, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x6(%rcx), %ecx
shll $0x10, %ecx
orl %ecx, %eax
movq -0x10(%rbp), %rcx
movzbl 0x7(%rcx), %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x48(%rbp)
movl -0x4c(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x9, %ecx
cmpl %ecx, %eax
je 0xc54d9
movq $0x0, -0x8(%rbp)
jmp 0xc5fdb
cmpl $0x7fffffff, -0x48(%rbp) # imm = 0x7FFFFFFF
jb 0xc54ef
movq $0x0, -0x8(%rbp)
jmp 0xc5fdb
movl $0x100, %edi            # imm = 0x100
movl $0x1800, %esi           # imm = 0x1800
callq 0xce8a0
movq %rax, -0x68(%rbp)
cmpq $0x0, -0x68(%rbp)
jne 0xc5516
movq $0x0, -0x8(%rbp)
jmp 0xc5fdb
movq -0x68(%rbp), %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rax
addq $0x100000, %rax         # imm = 0x100000
movq %rax, -0x60(%rbp)
movw $0x0, -0x272(%rbp)
leaq -0x270(%rbp), %rdi
movl $0xff, %esi
movl $0x200, %edx            # imm = 0x200
callq 0x4250
cmpq $0x0, -0x70(%rbp)
jne 0xc5557
jmp 0xc5fca
movq -0x60(%rbp), %rdi
xorl %esi, %esi
movl $0x800, %edx            # imm = 0x800
callq 0x4250
movl $0x0, -0x34(%rbp)
cmpl $0x100, -0x34(%rbp)     # imm = 0x100
jge 0xc559d
movq -0x60(%rbp), %rdi
movslq -0x34(%rbp), %rax
shlq $0xb, %rax
addq %rax, %rdi
xorl %esi, %esi
movl $0x8, %edx
callq 0x4250
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc556e
movl $0x0, -0x3c(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movslq -0x34(%rbp), %rax
movswl -0x270(%rbp,%rax,2), %eax
cmpl $-0x1, %eax
jne 0xc55eb
movw -0x272(%rbp), %cx
movw %cx, %ax
addw $0x1, %ax
movw %ax, -0x272(%rbp)
movslq -0x34(%rbp), %rax
movw %cx, -0x270(%rbp,%rax,2)
movslq -0x34(%rbp), %rax
movswl -0x270(%rbp,%rax,2), %eax
movl %eax, -0x278(%rbp)
movl $0x0, -0x44(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x38(%rbp)
movslq -0x38(%rbp), %rax
movswl -0x270(%rbp,%rax,2), %eax
cmpl $-0x1, %eax
jne 0xc5652
movw -0x272(%rbp), %cx
movw %cx, %ax
addw $0x1, %ax
movw %ax, -0x272(%rbp)
movslq -0x38(%rbp), %rax
movw %cx, -0x270(%rbp,%rax,2)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
jbe 0xc5668
jmp 0xc5fca
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x27c(%rbp)
cmpl $0x80, %eax
jl 0xc56be
movl -0x27c(%rbp), %eax
andl $0xffffff7f, %eax       # imm = 0xFFFFFF7F
movl %eax, -0x27c(%rbp)
movl -0x27c(%rbp), %eax
andl $0x7f, %eax
shll $0x8, %eax
movq -0x28(%rbp), %rcx
movq %rcx, %rdx
addq $0x1, %rdx
movq %rdx, -0x28(%rbp)
movzbl (%rcx), %ecx
orl %ecx, %eax
movl %eax, -0x27c(%rbp)
movl -0x44(%rbp), %eax
movl %eax, -0x280(%rbp)
cmpl $0x0, -0x27c(%rbp)
setne %al
xorb $-0x1, %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc56ea
movl $0x1000, -0x27c(%rbp)   # imm = 0x1000
movq -0x60(%rbp), %rdi
movslq -0x278(%rbp), %rax
shlq $0xb, %rax
addq %rax, %rdi
movslq -0x38(%rbp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movl -0x280(%rbp), %esi
movl -0x27c(%rbp), %edx
callq 0xc7710
movl -0x44(%rbp), %eax
addl -0x27c(%rbp), %eax
cmpl $0x1000, %eax           # imm = 0x1000
jbe 0xc572d
jmp 0xc5fca
movq -0x70(%rbp), %rdi
movslq -0x278(%rbp), %rax
shlq $0xc, %rax
addq %rax, %rdi
movl -0x44(%rbp), %eax
addq %rax, %rdi
movl -0x38(%rbp), %eax
movslq -0x27c(%rbp), %rdx
movzbl %al, %esi
callq 0x4250
movl -0x27c(%rbp), %eax
addl -0x44(%rbp), %eax
movl %eax, -0x44(%rbp)
cmpl $0x0, -0x40(%rbp)
jne 0xc57a6
movl -0x38(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xc57a6
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x40(%rbp)
jmp 0xc57e5
cmpl $0x0, -0x40(%rbp)
je 0xc57ce
movl -0x40(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x40(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
cmpl $0xff, -0x38(%rbp)
jle 0xc57cc
jmp 0xc5fca
jmp 0xc57e3
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0xc57e5
jmp 0xc57e7
cmpl $0x0, -0x38(%rbp)
jne 0xc5620
cmpl $0xfff, -0x44(%rbp)     # imm = 0xFFF
jb 0xc5803
cmpl $0x1000, -0x44(%rbp)    # imm = 0x1000
jbe 0xc5808
jmp 0xc5fca
cmpl $0x1000, -0x44(%rbp)    # imm = 0x1000
jae 0xc5840
movq -0x70(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x44(%rbp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movb (%rax,%rcx), %dl
movq -0x70(%rbp), %rax
movslq -0x34(%rbp), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x44(%rbp), %ecx
movb %dl, (%rax,%rcx)
cmpl $0x0, -0x3c(%rbp)
jne 0xc5883
movl -0x34(%rbp), %eax
addl $0x1, %eax
movq -0x28(%rbp), %rcx
movzbl (%rcx), %ecx
cmpl %ecx, %eax
jne 0xc5883
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x3c(%rbp)
jmp 0xc58c2
cmpl $0x0, -0x3c(%rbp)
je 0xc58ab
movl -0x3c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x3c(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
cmpl $0xff, -0x34(%rbp)
jle 0xc58a9
jmp 0xc5fca
jmp 0xc58c0
movq -0x28(%rbp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, -0x28(%rbp)
movzbl (%rax), %eax
movl %eax, -0x34(%rbp)
jmp 0xc58c2
jmp 0xc58c4
cmpl $0x0, -0x34(%rbp)
jne 0xc55b9
movl $0x0, -0x34(%rbp)
cmpl $0x100, -0x34(%rbp)     # imm = 0x100
jge 0xc590a
movslq -0x34(%rbp), %rax
movswl -0x270(%rbp,%rax,2), %eax
cmpl $-0x1, %eax
jne 0xc58fd
movslq -0x34(%rbp), %rax
movw $0x0, -0x270(%rbp,%rax,2)
jmp 0xc58ff
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0xc58d5
movq -0x28(%rbp), %rax
movq %rax, -0x298(%rbp)
movq -0x28(%rbp), %rax
movq -0x30(%rbp), %rcx
addq $-0x10, %rcx
cmpq %rcx, %rax
jbe 0xc592b
jmp 0xc5fca
leaq -0x284(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0xc77a0
cmpl $0x800000, -0x284(%rbp) # imm = 0x800000
jae 0xc594f
jmp 0xc5fca
leaq -0x288(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0xc77a0
cmpl $0x800000, -0x288(%rbp) # imm = 0x800000
jae 0xc5973
jmp 0xc5fca
leaq -0x28c(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0xc77a0
cmpl $0x800000, -0x28c(%rbp) # imm = 0x800000
jae 0xc5997
jmp 0xc5fca
leaq -0x290(%rbp), %rdi
leaq -0x298(%rbp), %rsi
callq 0xc77a0
cmpl $0x800000, -0x290(%rbp) # imm = 0x800000
jae 0xc59bb
jmp 0xc5fca
movl -0x284(%rbp), %eax
movl %eax, -0x2b0(%rbp)
movl -0x288(%rbp), %eax
movl %eax, -0x2ac(%rbp)
movl -0x28c(%rbp), %eax
movl %eax, -0x2a8(%rbp)
movl -0x290(%rbp), %eax
movl %eax, -0x2a4(%rbp)
movl -0x48(%rbp), %eax
shrl $0x2, %eax
movl %eax, -0x2b4(%rbp)
movl $0x0, -0x2b8(%rbp)
movl $0x0, -0x2bc(%rbp)
movl $0x0, -0x2c0(%rbp)
movl $0x0, -0x2c4(%rbp)
imull $0x0, -0x2b4(%rbp), %eax
movl %eax, -0x2e0(%rbp)
movl -0x2b4(%rbp), %eax
shll $0x0, %eax
movl %eax, -0x2dc(%rbp)
movl -0x2b4(%rbp), %eax
shll %eax
movl %eax, -0x2d8(%rbp)
imull $0x3, -0x2b4(%rbp), %eax
movl %eax, -0x2d4(%rbp)
movl -0x48(%rbp), %eax
movl %eax, %edi
callq 0x4650
movq %rax, -0x58(%rbp)
cmpq $0x0, -0x58(%rbp)
jne 0xc5a70
jmp 0xc5fca
movq -0x70(%rbp), %rax
movl -0x2b8(%rbp), %ecx
movswq -0x270(%rbp,%rcx,2), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2b0(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e1(%rbp)
movq -0x70(%rbp), %rax
movl -0x2bc(%rbp), %ecx
movswq -0x270(%rbp,%rcx,2), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2ac(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e2(%rbp)
movq -0x70(%rbp), %rax
movl -0x2c0(%rbp), %ecx
movswq -0x270(%rbp,%rcx,2), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2a8(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e3(%rbp)
movq -0x70(%rbp), %rax
movl -0x2c4(%rbp), %ecx
movswq -0x270(%rbp,%rcx,2), %rcx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2a4(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e4(%rbp)
movq -0x30(%rbp), %rax
addq $-0x8, %rax
movq %rax, -0x30(%rbp)
movl -0x2e0(%rbp), %eax
cmpl -0x2b4(%rbp), %eax
setb %al
andb $0x1, %al
movzbl %al, %eax
cltq
cmpq $0x0, %rax
je 0xc5eb4
movb -0x2e1(%rbp), %dl
movq -0x58(%rbp), %rax
movl -0x2e0(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x2e2(%rbp), %dl
movq -0x58(%rbp), %rax
movl -0x2dc(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x2e3(%rbp), %dl
movq -0x58(%rbp), %rax
movl -0x2d8(%rbp), %ecx
movb %dl, (%rax,%rcx)
movb -0x2e4(%rbp), %dl
movq -0x58(%rbp), %rax
movl -0x2d4(%rbp), %ecx
movb %dl, (%rax,%rcx)
movq -0x60(%rbp), %rax
movl -0x2b8(%rbp), %ecx
shlq $0xb, %rcx
addq %rcx, %rax
movzbl -0x2e1(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x310(%rbp)
movq -0x60(%rbp), %rax
movl -0x2bc(%rbp), %ecx
shlq $0xb, %rcx
addq %rcx, %rax
movzbl -0x2e2(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x308(%rbp)
movq -0x60(%rbp), %rax
movl -0x2c0(%rbp), %ecx
shlq $0xb, %rcx
addq %rcx, %rax
movzbl -0x2e3(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x300(%rbp)
movq -0x60(%rbp), %rax
movl -0x2c4(%rbp), %ecx
shlq $0xb, %rcx
addq %rcx, %rax
movzbl -0x2e4(%rbp), %ecx
movq (%rax,%rcx,8), %rax
movq %rax, -0x2f8(%rbp)
leaq -0x2b0(%rbp), %rdi
movl -0x30c(%rbp), %esi
movl -0x310(%rbp), %edx
movl $0xc, %ecx
callq 0xc7820
leaq -0x2b0(%rbp), %rdi
addq $0x4, %rdi
movl -0x304(%rbp), %esi
movl -0x308(%rbp), %edx
movl $0xc, %ecx
callq 0xc7820
leaq -0x2b0(%rbp), %rdi
addq $0x8, %rdi
movl -0x2fc(%rbp), %esi
movl -0x300(%rbp), %edx
movl $0xc, %ecx
callq 0xc7820
leaq -0x2b0(%rbp), %rdi
addq $0xc, %rdi
movl -0x2f4(%rbp), %esi
movl -0x2f8(%rbp), %edx
movl $0xc, %ecx
callq 0xc7820
movq -0x298(%rbp), %rax
cmpq -0x30(%rbp), %rax
jae 0xc5d07
leaq -0x2b0(%rbp), %rdi
leaq -0x2b0(%rbp), %rsi
addq $0x4, %rsi
leaq -0x298(%rbp), %rdx
callq 0xc7880
leaq -0x2b0(%rbp), %rdi
addq $0x8, %rdi
leaq -0x2b0(%rbp), %rsi
addq $0xc, %rsi
leaq -0x298(%rbp), %rdx
callq 0xc7880
jmp 0xc5d7f
leaq -0x2b0(%rbp), %rdi
movq -0x30(%rbp), %rdx
addq $0x8, %rdx
leaq -0x298(%rbp), %rsi
callq 0xc7950
leaq -0x2b0(%rbp), %rdi
addq $0x4, %rdi
movq -0x30(%rbp), %rdx
addq $0x8, %rdx
leaq -0x298(%rbp), %rsi
callq 0xc7950
leaq -0x2b0(%rbp), %rdi
addq $0x8, %rdi
movq -0x30(%rbp), %rdx
addq $0x8, %rdx
leaq -0x298(%rbp), %rsi
callq 0xc7950
leaq -0x2b0(%rbp), %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rdx
addq $0x8, %rdx
leaq -0x298(%rbp), %rsi
callq 0xc7950
movzbl -0x2e1(%rbp), %eax
movswl -0x270(%rbp,%rax,2), %eax
movl %eax, -0x2b8(%rbp)
movzbl -0x2e2(%rbp), %eax
movswl -0x270(%rbp,%rax,2), %eax
movl %eax, -0x2bc(%rbp)
movzbl -0x2e3(%rbp), %eax
movswl -0x270(%rbp,%rax,2), %eax
movl %eax, -0x2c0(%rbp)
movzbl -0x2e4(%rbp), %eax
movswl -0x270(%rbp,%rax,2), %eax
movl %eax, -0x2c4(%rbp)
movq -0x70(%rbp), %rax
movl -0x2b8(%rbp), %ecx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2b0(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e1(%rbp)
movq -0x70(%rbp), %rax
movl -0x2bc(%rbp), %ecx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2ac(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e2(%rbp)
movq -0x70(%rbp), %rax
movl -0x2c0(%rbp), %ecx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2a8(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e3(%rbp)
movq -0x70(%rbp), %rax
movl -0x2c4(%rbp), %ecx
shlq $0xc, %rcx
addq %rcx, %rax
movl -0x2a4(%rbp), %ecx
andl $0xfff, %ecx            # imm = 0xFFF
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x2e4(%rbp)
movl -0x2e0(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2e0(%rbp)
movl -0x2dc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2dc(%rbp)
movl -0x2d8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2d8(%rbp)
movl -0x2d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2d4(%rbp)
jmp 0xc5b40
jmp 0xc5eb6
movl -0x2d4(%rbp), %eax
cmpl -0x48(%rbp), %eax
jae 0xc5fc1
movq -0x70(%rbp), %rax
movl -0x2c4(%rbp), %ecx
shlq $0xc, %rcx
addq %rcx, %rax
movq %rax, -0x320(%rbp)
leaq -0x2b0(%rbp), %rdi
addq $0xc, %rdi
movl $0xc, %esi
callq 0xc79f0
movl %eax, %ecx
movq -0x320(%rbp), %rax
movl %ecx, %ecx
movb (%rax,%rcx), %al
movb %al, -0x311(%rbp)
movb -0x311(%rbp), %dl
movq -0x58(%rbp), %rax
movl -0x2d4(%rbp), %ecx
movb %dl, (%rax,%rcx)
movl -0x2a4(%rbp), %eax
andl $0xfff, %eax            # imm = 0xFFF
movl %eax, -0x318(%rbp)
movq -0x60(%rbp), %rax
movl -0x2c4(%rbp), %ecx
shlq $0xb, %rcx
addq %rcx, %rax
movzbl -0x311(%rbp), %ecx
movl (%rax,%rcx,8), %eax
movl -0x2a4(%rbp), %ecx
shrl $0xc, %ecx
imull %ecx, %eax
addl -0x318(%rbp), %eax
movq -0x60(%rbp), %rcx
movl -0x2c4(%rbp), %edx
shlq $0xb, %rdx
addq %rdx, %rcx
movzbl -0x311(%rbp), %edx
subl 0x4(%rcx,%rdx,8), %eax
movl %eax, -0x2a4(%rbp)
leaq -0x2b0(%rbp), %rdi
addq $0xc, %rdi
movq -0x30(%rbp), %rdx
addq $0x8, %rdx
leaq -0x298(%rbp), %rsi
callq 0xc7950
movzbl -0x311(%rbp), %eax
movswl -0x270(%rbp,%rax,2), %eax
movl %eax, -0x2c4(%rbp)
movl -0x2d4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2d4(%rbp)
jmp 0xc5eb6
movl -0x48(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x70(%rbp), %rdi
callq 0xce8f0
movq -0x58(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x320, %rsp            # imm = 0x320
popq %rbp
retq
nopl (%rax,%rax)