// File: /workspace/github_c_makefile_star2_O0/samtools[P]htslib/cram/cram_encode.c
// Function: cram_compress_slice
static int cram_compress_slice(cram_fd *fd, cram_container *c, cram_slice *s) {
    int level = fd->level, i;
    int method = 1<<GZIP | 1<<GZIP_RLE, methodF = method;
    int v31_or_above = (fd->version >= (3<<8)+1);

    /* Compress the CORE Block too, with minimal zlib level */
    if (level > 5 && s->block[0]->uncomp_size > 500)
        cram_compress_block2(fd, s, s->block[0], NULL, 1<<GZIP, 1);

    if (fd->use_bz2)
        method |= 1<<BZIP2;

    int method_rans   = (1<<RANS0) | (1<<RANS1);
    int method_ranspr = method_rans;

    if (fd->use_rans) {
        method_ranspr = (1<<RANS_PR0)   | (1<<RANS_PR1);
        if (level > 1)
            method_ranspr |=
                  (1<<RANS_PR64)  | (1<<RANS_PR9)
                | (1<<RANS_PR128) | (1<<RANS_PR193);
        if (level > 5)
            method_ranspr |= (1<<RANS_PR129) | (1<<RANS_PR192);
    }

    if (fd->use_rans) {
        methodF |= v31_or_above ? method_ranspr : method_rans;
        method  |= v31_or_above ? method_ranspr : method_rans;
    }

    int method_arith   = 0;
    if (fd->use_arith) {
        method_arith = (1<<ARITH_PR0)   | (1<<ARITH_PR1);
        if (level > 1)
            method_arith |=
                  (1<<ARITH_PR64)  | (1<<ARITH_PR9)
                | (1<<ARITH_PR128) | (1<<ARITH_PR129)
                | (1<<ARITH_PR192) | (1u<<ARITH_PR193);
    }
    if (fd->use_arith && v31_or_above) {
        methodF |= method_arith;
        method  |= method_arith;
    }

    if (fd->use_lzma)
        method |= (1<<LZMA);

    /* Faster method for data series we only need entropy encoding on */
    methodF = method & ~(1<<GZIP | 1<<BZIP2 | 1<<LZMA);
    if (level >= 5) {
        method |= 1<<GZIP_1;
        methodF = method;
    }
    if (level == 1) {
        method &= ~(1<<GZIP);
        method |=   1<<GZIP_1;
        methodF = method;
    }

    int qmethod  = method;
    int qmethodF = method;
    if (v31_or_above && fd->use_fqz) {
        qmethod  |= 1<<FQZ;
        qmethodF |= 1<<FQZ;
        if (fd->level > 4) {
            qmethod  |= 1<<FQZ_b;
            qmethodF |= 1<<FQZ_b;
        }
        if (fd->level > 6) {
            qmethod  |= (1<<FQZ_c) | (1<<FQZ_d);
            qmethodF |= (1<<FQZ_c) | (1<<FQZ_d);
        }
    }

    pthread_mutex_lock(&fd->metrics_lock);
    for (i = 0; i < DS_END; i++)
        if (c->stats[i] && c->stats[i]->nvals > 16)
            fd->m[i]->unpackable = 1;
    pthread_mutex_unlock(&fd->metrics_lock);

    /* Specific compression methods for certain block types */
    if (cram_compress_block2(fd, s, s->block[DS_IN], fd->m[DS_IN], //IN (seq)
                             method, level))
        return -1;

    if (fd->level == 0) {
        /* Do nothing */
    } else if (fd->level == 1) {
        if (cram_compress_block2(fd, s, s->block[DS_QS], fd->m[DS_QS],
                                 qmethodF, 1))
            return -1;
        for (i = DS_aux; i <= DS_aux_oz; i++) {
            if (s->block[i])
                if (cram_compress_block2(fd, s, s->block[i], fd->m[i],
                                         method, 1))
                    return -1;
        }
    } else if (fd->level < 3) {
        if (cram_compress_block2(fd, s, s->block[DS_QS], fd->m[DS_QS],
                                 qmethod, 1))
            return -1;
        if (cram_compress_block2(fd, s, s->block[DS_BA], fd->m[DS_BA],
                                 method, 1))
            return -1;
        if (s->block[DS_BB])
            if (cram_compress_block2(fd, s, s->block[DS_BB], fd->m[DS_BB],
                                     method, 1))
                return -1;
        for (i = DS_aux; i <= DS_aux_oz; i++) {
            if (s->block[i])
                if (cram_compress_block2(fd, s, s->block[i], fd->m[i],
                                         method, level))
                    return -1;
        }
    } else {
        if (cram_compress_block2(fd, s, s->block[DS_QS], fd->m[DS_QS],
                                 qmethod, level))
            return -1;
        if (cram_compress_block2(fd, s, s->block[DS_BA], fd->m[DS_BA],
                                 method, level))
            return -1;
        if (s->block[DS_BB])
            if (cram_compress_block2(fd, s, s->block[DS_BB], fd->m[DS_BB],
                                     method, level))
                return -1;
        for (i = DS_aux; i <= DS_aux_oz; i++) {
            if (s->block[i])
                if (cram_compress_block2(fd, s, s->block[i], fd->m[i],
                                         method, level))
                    return -1;
        }
    }

    // NAME: best is generally xz, bzip2, zlib then rans1
    int method_rn = method & ~(method_rans | method_ranspr | 1<<GZIP_RLE);
    if (fd->version >= (3<<8)+1 && fd->use_tok)
        method_rn |= fd->use_arith ? (1<<TOKA) : (1<<TOK3);
    if (cram_compress_block2(fd, s, s->block[DS_RN], fd->m[DS_RN],
                             method_rn, level))
        return -1;

    // NS shows strong local correlation as rearrangements are localised
    if (s->block[DS_NS] && s->block[DS_NS] != s->block[0])
        if (cram_compress_block2(fd, s, s->block[DS_NS], fd->m[DS_NS],
                                 method, level))
            return -1;


    /*
     * Compress any auxiliary tags with their own per-tag metrics
     */
    {
        int i;
        for (i = DS_END /*num_blk - naux_blk*/; i < s->hdr->num_blocks; i++) {
            if (!s->block[i] || s->block[i] == s->block[0])
                continue;

            if (s->block[i]->method != RAW)
                continue;

            if (cram_compress_block2(fd, s, s->block[i], s->block[i]->m,
                                     method, level))
                return -1;
        }
    }

    /*
     * Minimal compression of any block still uncompressed, bar CORE
     */
    {
        int i;
        for (i = 1; i < s->hdr->num_blocks && i < DS_END; i++) {
            if (!s->block[i] || s->block[i] == s->block[0])
                continue;

            if (s->block[i]->method != RAW)
                continue;

            if (cram_compress_block2(fd, s, s->block[i], fd->m[i],
                                    methodF, level))
                return -1;
        }
    }

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rax
movl 0x88(%rax), %eax
movl %eax, -0x24(%rbp)
movl $0x802, -0x2c(%rbp)     # imm = 0x802
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x301, 0xc(%rax)       # imm = 0x301
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x34(%rbp)
cmpl $0x5, -0x24(%rbp)
jle 0x65c16
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpl $0x1f4, 0x14(%rax)      # imm = 0x1F4
jle 0x65c16
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdx
xorl %eax, %eax
movl %eax, %ecx
movl $0x2, %r8d
movl $0x1, %r9d
callq 0x70210
movq -0x10(%rbp), %rax
cmpl $0x0, 0x230(%rax)
je 0x65c2c
movl -0x2c(%rbp), %eax
orl $0x4, %eax
movl %eax, -0x2c(%rbp)
movl $0x10010, -0x38(%rbp)   # imm = 0x10010
movl -0x38(%rbp), %eax
movl %eax, -0x3c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x234(%rax)
je 0x65c71
movl $0x20020, -0x3c(%rbp)   # imm = 0x20020
cmpl $0x1, -0x24(%rbp)
jle 0x65c5e
movl -0x3c(%rbp), %eax
orl $0x9c0000, %eax         # imm = 0x9C0000
movl %eax, -0x3c(%rbp)
cmpl $0x5, -0x24(%rbp)
jle 0x65c6f
movl -0x3c(%rbp), %eax
orl $0x600000, %eax         # imm = 0x600000
movl %eax, -0x3c(%rbp)
jmp 0x65c71
movq -0x10(%rbp), %rax
cmpl $0x0, 0x234(%rax)
je 0x65cb8
cmpl $0x0, -0x34(%rbp)
je 0x65c8c
movl -0x3c(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x65c92
movl -0x38(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x65ca9
movl -0x3c(%rbp), %eax
movl %eax, -0x5c(%rbp)
jmp 0x65caf
movl -0x38(%rbp), %eax
movl %eax, -0x5c(%rbp)
movl -0x5c(%rbp), %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x244(%rax)
je 0x65ce6
movl $0x2000040, -0x40(%rbp) # imm = 0x2000040
cmpl $0x1, -0x24(%rbp)
jle 0x65ce4
movl -0x40(%rbp), %eax
orl $0xfc000000, %eax       # imm = 0xFC000000
movl %eax, -0x40(%rbp)
jmp 0x65ce6
movq -0x10(%rbp), %rax
cmpl $0x0, 0x244(%rax)
je 0x65d0b
cmpl $0x0, -0x34(%rbp)
je 0x65d0b
movl -0x40(%rbp), %eax
orl -0x30(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x40(%rbp), %eax
orl -0x2c(%rbp), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, 0x238(%rax)
je 0x65d21
movl -0x2c(%rbp), %eax
orl $0x8, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
andl $-0xf, %eax
movl %eax, -0x30(%rbp)
cmpl $0x5, -0x24(%rbp)
jl 0x65d41
movl -0x2c(%rbp), %eax
orl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
cmpl $0x1, -0x24(%rbp)
jne 0x65d61
movl -0x2c(%rbp), %eax
andl $-0x3, %eax
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
orl $0x1000, %eax           # imm = 0x1000
movl %eax, -0x2c(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x30(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x2c(%rbp), %eax
movl %eax, -0x48(%rbp)
cmpl $0x0, -0x34(%rbp)
je 0x65dde
movq -0x10(%rbp), %rax
cmpl $0x0, 0x23c(%rax)
je 0x65dde
movl -0x44(%rbp), %eax
orl $0x80, %eax
movl %eax, -0x44(%rbp)
movl -0x48(%rbp), %eax
orl $0x80, %eax
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4, 0x88(%rax)
jle 0x65db9
movl -0x44(%rbp), %eax
orl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x44(%rbp)
movl -0x48(%rbp), %eax
orl $0x2000, %eax           # imm = 0x2000
movl %eax, -0x48(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x6, 0x88(%rax)
jle 0x65ddc
movl -0x44(%rbp), %eax
orl $0xc000, %eax           # imm = 0xC000
movl %eax, -0x44(%rbp)
movl -0x48(%rbp), %eax
orl $0xc000, %eax           # imm = 0xC000
movl %eax, -0x48(%rbp)
jmp 0x65dde
movq -0x10(%rbp), %rdi
addq $0x88c8, %rdi           # imm = 0x88C8
callq 0x4730
movl $0x0, -0x28(%rbp)
cmpl $0x2f, -0x28(%rbp)
jge 0x65e4e
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, 0xf8(%rax,%rcx,8)
je 0x65e41
movq -0x18(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0xf8(%rax,%rcx,8), %rax
cmpl $0x10, 0x100c(%rax)
jle 0x65e41
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rax
movl $0x1, 0x220(%rax)
jmp 0x65e43
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x65df5
movq -0x10(%rbp), %rdi
addq $0x88c8, %rdi           # imm = 0x88C8
callq 0x4330
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x68(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0xf8(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x65e9b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movq -0x10(%rbp), %rax
cmpl $0x0, 0x88(%rax)
jne 0x65ead
jmp 0x66227
movq -0x10(%rbp), %rax
cmpl $0x1, 0x88(%rax)
jne 0x65f79
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
movl -0x48(%rbp), %r8d
movl $0x1, %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x65efd
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movl $0x1, -0x28(%rbp)
cmpl $0x9, -0x28(%rbp)
jg 0x65f74
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x65f67
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rcx
movl -0x2c(%rbp), %r8d
movl $0x1, %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x65f65
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x65f67
jmp 0x65f69
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x65f04
jmp 0x66225
movq -0x10(%rbp), %rax
cmpl $0x3, 0x88(%rax)
jge 0x660db
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
movl -0x44(%rbp), %r8d
movl $0x1, %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x65fc9
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xf0(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl $0x1, %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x6600b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x128(%rax)
je 0x66061
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x128(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl $0x1, %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x6605f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x66061
movl $0x1, -0x28(%rbp)
cmpl $0x9, -0x28(%rbp)
jg 0x660d6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x660c9
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x660c7
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x660c9
jmp 0x660cb
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x66068
jmp 0x66223
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x60(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0xf0(%rax), %rcx
movl -0x44(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x66118
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xf0(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x180(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x66158
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0x128(%rax)
je 0x661ac
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x128(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x1b8(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x661aa
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x661ac
movl $0x1, -0x28(%rbp)
cmpl $0x9, -0x28(%rbp)
jg 0x66221
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x66214
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x66212
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x66214
jmp 0x66216
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x661b3
jmp 0x66223
jmp 0x66225
jmp 0x66227
movl -0x2c(%rbp), %eax
movl -0x38(%rbp), %ecx
orl -0x3c(%rbp), %ecx
orl $0x800, %ecx            # imm = 0x800
xorl $-0x1, %ecx
andl %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x301, 0xc(%rax)       # imm = 0x301
jl 0x66278
movq -0x10(%rbp), %rax
cmpl $0x0, 0x240(%rax)
je 0x66278
movq -0x10(%rbp), %rax
movl 0x244(%rax), %edx
movl $0x100, %eax            # imm = 0x100
movl $0x1000000, %ecx        # imm = 0x1000000
cmpl $0x0, %edx
cmovnel %ecx, %eax
orl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0xe8(%rax), %rcx
movl -0x4c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x662b5
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
cmpq $0x0, 0xa0(%rax)
je 0x66325
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xa0(%rax), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
je 0x66325
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq 0xa0(%rax), %rdx
movq -0x10(%rbp), %rax
movq 0x130(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x66323
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x66325
movl $0x2f, -0x50(%rbp)
movl -0x50(%rbp), %eax
movq -0x20(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x28(%rcx), %eax
jge 0x663e2
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x50(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x6636f
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x66371
jmp 0x663d4
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, (%rax)
je 0x66388
jmp 0x663d4
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x50(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x40(%rax), %rcx
movl -0x2c(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x663d2
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x663d4
movl -0x50(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x50(%rbp)
jmp 0x6632c
movl $0x1, -0x54(%rbp)
movl -0x54(%rbp), %ecx
movq -0x20(%rbp), %rax
movq (%rax), %rdx
xorl %eax, %eax
cmpl 0x28(%rdx), %ecx
movb %al, -0x5d(%rbp)
jge 0x66407
cmpl $0x2f, -0x54(%rbp)
setl %al
movb %al, -0x5d(%rbp)
movb -0x5d(%rbp), %al
testb $0x1, %al
jne 0x66413
jmp 0x664af
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x54(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x66443
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
movq 0x10(%rcx), %rcx
cmpq (%rcx), %rax
jne 0x66445
jmp 0x664a1
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, (%rax)
je 0x6645c
jmp 0x664a1
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rsi
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x54(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x10(%rbp), %rax
movslq -0x54(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rcx
movl -0x30(%rbp), %r8d
movl -0x24(%rbp), %r9d
callq 0x70210
cmpl $0x0, %eax
je 0x6649f
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
jmp 0x664b6
jmp 0x664a1
movl -0x54(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x54(%rbp)
jmp 0x663e9
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nop