// File: /workspace/github_c_makefile_star2_O1/samtools[P]htslib/cram/cram_io.c
// Function: cram_set_voption
int cram_set_voption(cram_fd *fd, enum hts_fmt_option opt, va_list args) {
    refs_t *refs;

    if (!fd) {
        errno = EBADF;
        return -1;
    }

    switch (opt) {
    case CRAM_OPT_DECODE_MD:
        fd->decode_md = va_arg(args, int);
        break;

    case CRAM_OPT_PREFIX:
        if (fd->prefix)
            free(fd->prefix);
        if (!(fd->prefix = strdup(va_arg(args, char *))))
            return -1;
        break;

    case CRAM_OPT_VERBOSITY:
        break;

    case CRAM_OPT_SEQS_PER_SLICE:
        fd->seqs_per_slice = va_arg(args, int);
        if (fd->bases_per_slice == BASES_PER_SLICE)
            fd->bases_per_slice = fd->seqs_per_slice * 500;
        break;

    case CRAM_OPT_BASES_PER_SLICE:
        fd->bases_per_slice = va_arg(args, int);
        break;

    case CRAM_OPT_SLICES_PER_CONTAINER:
        fd->slices_per_container = va_arg(args, int);
        break;

    case CRAM_OPT_EMBED_REF:
        fd->embed_ref = va_arg(args, int);
        break;

    case CRAM_OPT_NO_REF:
        fd->no_ref = va_arg(args, int);
        break;

    case CRAM_OPT_POS_DELTA:
        fd->ap_delta = va_arg(args, int);
        break;

    case CRAM_OPT_IGNORE_MD5:
        fd->ignore_md5 = va_arg(args, int);
        break;

    case CRAM_OPT_LOSSY_NAMES:
        fd->lossy_read_names = va_arg(args, int);
        // Currently lossy read names required paired (attached) reads.
        // TLEN 0 or being 1 out causes read pairs to be detached, breaking
        // the lossy read name compression, so we have extra options to
        // slacken the exact TLEN round-trip checks.
        fd->tlen_approx = fd->lossy_read_names;
        fd->tlen_zero = fd->lossy_read_names;
        break;

    case CRAM_OPT_USE_BZIP2:
        fd->use_bz2 = va_arg(args, int);
        break;

    case CRAM_OPT_USE_RANS:
        fd->use_rans = va_arg(args, int);
        break;

    case CRAM_OPT_USE_TOK:
        fd->use_tok = va_arg(args, int);
        break;

    case CRAM_OPT_USE_FQZ:
        fd->use_fqz = va_arg(args, int);
        break;

    case CRAM_OPT_USE_ARITH:
        fd->use_arith = va_arg(args, int);
        break;

    case CRAM_OPT_USE_LZMA:
        fd->use_lzma = va_arg(args, int);
        break;

    case CRAM_OPT_SHARED_REF:
        fd->shared_ref = 1;
        refs = va_arg(args, refs_t *);
        if (refs != fd->refs) {
            if (fd->refs)
                refs_free(fd->refs);
            fd->refs = refs;
            fd->refs->count++;
        }
        break;

    case CRAM_OPT_RANGE: {
        int r = cram_seek_to_refpos(fd, va_arg(args, cram_range *));
        pthread_mutex_lock(&fd->range_lock);
//        printf("opt range noseek to %p %d:%ld-%ld\n",
//               fd, fd->range.refid, fd->range.start, fd->range.end);
        if (fd->range.refid != -2)
            fd->required_fields |= SAM_POS;
        pthread_mutex_unlock(&fd->range_lock);
        return r;
    }

    case CRAM_OPT_RANGE_NOSEEK: {
        // As per CRAM_OPT_RANGE, but no seeking
        pthread_mutex_lock(&fd->range_lock);
        cram_range *r = va_arg(args, cram_range *);
        fd->range = *r;
        if (r->refid == HTS_IDX_NOCOOR) {
            fd->range.refid = -1;
            fd->range.start = 0;
        } else if (r->refid == HTS_IDX_START || r->refid == HTS_IDX_REST) {
            fd->range.refid = -2; // special case in cram_next_slice
        }
        if (fd->range.refid != -2)
            fd->required_fields |= SAM_POS;
        fd->ooc = 0;
        fd->eof = 0;
        pthread_mutex_unlock(&fd->range_lock);
        return 0;
    }

    case CRAM_OPT_REFERENCE:
        return cram_load_reference(fd, va_arg(args, char *));

    case CRAM_OPT_VERSION: {
        int major, minor;
        char *s = va_arg(args, char *);
        if (2 != sscanf(s, "%d.%d", &major, &minor)) {
            hts_log_error("Malformed version string %s", s);
            return -1;
        }
        if (!((major == 1 &&  minor == 0) ||
              (major == 2 && (minor == 0 || minor == 1)) ||
              (major == 3 && (minor == 0 || minor == 1)) ||
              (major == 4 &&  minor == 0))) {
            hts_log_error("Unknown version string; use 1.0, 2.0, 2.1, 3.0, 3.1 or 4.0");
            errno = EINVAL;
            return -1;
        }

        if (major > 3 || (major == 3 && minor > 1)) {
            hts_log_warning(
                "CRAM version %s is still a draft and subject to change.\n"
                "This is a technology demonstration that should not be "
                "used for archival data.", s);
        }

        fd->version = major*256 + minor;

        fd->use_rans = (CRAM_MAJOR_VERS(fd->version) >= 3) ? 1 : 0;

        fd->use_tok = ((CRAM_MAJOR_VERS(fd->version) == 3 &&
                        CRAM_MINOR_VERS(fd->version) >= 1) ||
                        CRAM_MAJOR_VERS(fd->version) >= 4) ? 1 : 0;
        cram_init_tables(fd);

        break;
    }

    case CRAM_OPT_MULTI_SEQ_PER_SLICE:
        fd->multi_seq_user = fd->multi_seq = va_arg(args, int);
        break;

    case CRAM_OPT_NTHREADS: {
        int nthreads =  va_arg(args, int);
        if (nthreads >= 1) {
            if (!(fd->pool = hts_tpool_init(nthreads)))
                return -1;

            fd->rqueue = hts_tpool_process_init(fd->pool, nthreads*2, 0);
            fd->shared_ref = 1;
            fd->own_pool = 1;
        }
        break;
    }

    case CRAM_OPT_THREAD_POOL: {
        htsThreadPool *p = va_arg(args, htsThreadPool *);
        fd->pool = p ? p->pool : NULL;
        if (fd->pool) {
            fd->rqueue = hts_tpool_process_init(fd->pool,
                                                p->qsize ? p->qsize : hts_tpool_size(fd->pool)*2,
                                                0);
        }
        fd->shared_ref = 1; // Needed to avoid clobbering ref between threads
        fd->own_pool = 0;

        //fd->qsize = 1;
        //fd->decoded = calloc(fd->qsize, sizeof(cram_container *));
        //hts_tpool_dispatch(fd->pool, cram_decoder_thread, fd);
        break;
    }

    case CRAM_OPT_REQUIRED_FIELDS:
        fd->required_fields = va_arg(args, int);
        if (fd->range.refid != -2)
            fd->required_fields |= SAM_POS;
        break;

    case CRAM_OPT_STORE_MD:
        fd->store_md = va_arg(args, int);
        break;

    case CRAM_OPT_STORE_NM:
        fd->store_nm = va_arg(args, int);
        break;

    case HTS_OPT_COMPRESSION_LEVEL:
        fd->level = va_arg(args, int);
        break;

    case HTS_OPT_PROFILE: {
        enum hts_profile_option prof = va_arg(args, int);
        switch (prof) {
        case HTS_PROFILE_FAST:
            if (fd->level == CRAM_DEFAULT_LEVEL) fd->level = 1;
            fd->use_tok = 0;
            fd->seqs_per_slice = 10000;
            break;

        case HTS_PROFILE_NORMAL:
            break;

        case HTS_PROFILE_SMALL:
            if (fd->level == CRAM_DEFAULT_LEVEL) fd->level = 6;
            fd->use_bz2 = 1;
            fd->use_fqz = 1;
            fd->seqs_per_slice = 25000;
            break;

        case HTS_PROFILE_ARCHIVE:
            if (fd->level == CRAM_DEFAULT_LEVEL) fd->level = 7;
            fd->use_bz2 = 1;
            fd->use_fqz = 1;
            fd->use_arith = 1;
            if (fd->level > 7)
                fd->use_lzma = 1;
            fd->seqs_per_slice = 100000;
            break;
        }

        if (fd->bases_per_slice == BASES_PER_SLICE)
            fd->bases_per_slice = fd->seqs_per_slice * 500;
        break;
    }

    default:
        hts_log_error("Unknown CRAM option code %d", opt);
        errno = EINVAL;
        return -1;
    }

    return 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x55edc
movq %rdx, %r14
movl %esi, %ecx
movq %rdi, %rbx
cmpl $0x1b, %esi
ja 0x55ef1
movl %ecx, %eax
leaq 0x47448(%rip), %rcx     # 0x9d2fc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x5646e
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x5647a
callq 0x4050
movl $0x9, (%rax)
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
jmp 0x568fe
cmpl $0x64, %ecx
je 0x560e2
cmpl $0x6a, %ecx
jne 0x56203
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x566ad
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x566b9
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x562b8
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x562c4
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x562d1
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x562dd
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x562ea
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x562f6
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56342
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x5634e
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x5635b
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56367
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56374
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56380
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x5638d
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56399
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x563ae
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x563ba
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x563c7
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x563d3
movq 0x20(%rbx), %rdi
testq %rdi, %rdi
je 0x56047
callq 0x45c0
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x563e0
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x563ec
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56406
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56412
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56426
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56432
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56455
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56461
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56487
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56493
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x564a0
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x564ac
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x564b9
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x564c5
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x564cc
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x564d8
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x5650c
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56518
movl $0x1, 0x248(%rbx)
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56525
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56531
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56558
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56564
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56646
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56652
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56675
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56681
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56694
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x566a0
leaq 0x47ef5(%rip), %rsi     # 0x9e0ff
leaq 0x47fdc(%rip), %rdx     # 0x9e1ed
movl $0x1, %edi
xorl %eax, %eax
callq 0x14378
callq 0x4050
movl $0x16, (%rax)
jmp 0x55ee7
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x566fc
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56708
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x56715
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56721
leaq 0x8918(%rbx), %r15
movq %r15, %rdi
callq 0x4750
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x5673a
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x56746
movl (%r14), %ecx
cmpq $0x28, %rcx
ja 0x567b8
movq %rcx, %rax
addq 0x10(%r14), %rax
addl $0x8, %ecx
movl %ecx, (%r14)
jmp 0x567c4
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x8a10(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x238(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %ebp
testl %ebp, %ebp
jle 0x568fc
movl %ebp, %edi
callq 0x378ae
movq %rax, 0x88b8(%rbx)
testq %rax, %rax
je 0x55ee7
addl %ebp, %ebp
movq %rax, %rdi
movl %ebp, %esi
xorl %edx, %edx
callq 0x3757b
movq %rax, 0x88c0(%rbx)
movl $0x1, %eax
movl %eax, 0x248(%rbx)
movl %eax, 0x88b0(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x224(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x21c(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x230(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %rsi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x51ef0
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x23c(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x240(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %rdi
callq 0x4930
movq %rax, 0x20(%rbx)
testq %rax, %rax
jne 0x568fc
jmp 0x55ee7
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %rax
testq %rax, %rax
je 0x567d1
movq (%rax), %r14
jmp 0x567d4
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x214(%rbx)
cmpl $0x4c4b40, 0x218(%rbx)  # imm = 0x4C4B40
jne 0x568fc
imull $0x1f4, %eax, %eax      # imm = 0x1F4
jmp 0x568f6
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x220(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x210(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x234(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x88(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
jmp 0x568f6
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %rsi
movq %rbx, %rdi
callq 0x4c8a2
movl %eax, %ebp
leaq 0x8918(%rbx), %r14
movq %r14, %rdi
callq 0x4750
cmpl $-0x2, 0x258(%rbx)
je 0x56504
orb $0x8, 0x24c(%rbx)
movq %r14, %rdi
jmp 0x567ae
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x250(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %r14
movq 0x50(%rbx), %rdi
cmpq %rdi, %r14
je 0x568fc
testq %rdi, %rdi
je 0x5654b
callq 0x507eb
movq %r14, 0x50(%rbx)
incl 0x30(%r14)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %r14
leaq 0x47b06(%rip), %rsi     # 0x9e074
leaq 0x4(%rsp), %rdx
movq %rsp, %rcx
movq %r14, %rdi
xorl %eax, %eax
callq 0x44a0
cmpl $0x2, %eax
jne 0x56624
movl 0x4(%rsp), %ecx
movl %ecx, %edx
xorl $0x1, %edx
movl (%rsp), %eax
orl %eax, %edx
jne 0x5684b
cmpl $0x3, %ecx
jg 0x565b1
sete %cl
cmpl $0x2, %eax
setge %al
andb %cl, %al
cmpb $0x1, %al
jne 0x565ce
leaq 0x47b47(%rip), %rsi     # 0x9e0ff
leaq 0x47ba8(%rip), %rdx     # 0x9e167
movl $0x3, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x14378
movl 0x4(%rsp), %eax
shll $0x8, %eax
movl (%rsp), %ecx
addl %ecx, %eax
movl %eax, 0xc(%rbx)
movl $0x300, %edx            # imm = 0x300
xorl %esi, %esi
cmpl %edx, %eax
setge %sil
movl %esi, 0x234(%rbx)
movl %eax, %esi
andl $0xffffff00, %esi       # imm = 0xFFFFFF00
cmpl %edx, %esi
sete %dl
testb %cl, %cl
setne %cl
andb %dl, %cl
cmpl $0x400, %eax            # imm = 0x400
setge %al
orb %cl, %al
movzbl %al, %eax
movl %eax, 0x240(%rbx)
movq %rbx, %rdi
callq 0x554d2
jmp 0x568fc
leaq 0x47ad4(%rip), %rsi     # 0x9e0ff
leaq 0x47ade(%rip), %rdx     # 0x9e110
movl $0x1, %edi
movq %r14, %rcx
xorl %eax, %eax
callq 0x14378
jmp 0x55ee7
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x24c(%rbx)
cmpl $-0x2, 0x258(%rbx)
je 0x568fc
orl $0x8, %eax
movl %eax, 0x24c(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x889c(%rbx)
movl %eax, 0x88a0(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x22c(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
cmpl $0x3, %eax
je 0x56898
cmpl $0x2, %eax
je 0x5681d
testl %eax, %eax
jne 0x568e0
cmpl $0x5, 0x88(%rbx)
jne 0x566e8
movl $0x1, 0x88(%rbx)
movl $0x0, 0x240(%rbx)
movl $0x2710, %eax           # imm = 0x2710
jmp 0x568da
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x254(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x897c(%rbx)
movl %eax, 0x8980(%rbx)
movl %eax, 0x8984(%rbx)
jmp 0x568fc
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movq (%rax), %rcx
leaq 0x258(%rbx), %rax
movq 0x10(%rcx), %rdx
movq %rdx, 0x268(%rbx)
movups (%rcx), %xmm0
movups %xmm0, 0x258(%rbx)
movl (%rcx), %ecx
leal 0x4(%rcx), %edx
cmpl $0x2, %edx
jae 0x56777
movl $0xfffffffe, (%rax)     # imm = 0xFFFFFFFE
jmp 0x56791
cmpl $-0x2, %ecx
jne 0x56791
movl $0xffffffff, 0x258(%rbx) # imm = 0xFFFFFFFF
movq $0x0, 0x260(%rbx)
cmpl $-0x2, (%rax)
je 0x5679d
orb $0x8, 0x24c(%rbx)
xorl %ebp, %ebp
movl %ebp, 0x8978(%rbx)
movl %ebp, 0x8890(%rbx)
movq %r15, %rdi
callq 0x4340
jmp 0x568fe
movq 0x8(%r14), %rax
leaq 0x8(%rax), %rcx
movq %rcx, 0x8(%r14)
movl (%rax), %eax
movl %eax, 0x244(%rbx)
jmp 0x568fc
xorl %r14d, %r14d
movq %r14, 0x88b8(%rbx)
testq %r14, %r14
je 0x56804
movl 0x8(%rax), %esi
testl %esi, %esi
jne 0x567f3
movq %r14, %rdi
callq 0x37f2c
movl %eax, %esi
addl %eax, %esi
movq %r14, %rdi
xorl %edx, %edx
callq 0x3757b
movq %rax, 0x88c0(%rbx)
movl $0x1, 0x248(%rbx)
movl $0x0, 0x88b0(%rbx)
jmp 0x568fc
cmpl $0x5, 0x88(%rbx)
jne 0x56830
movl $0x6, 0x88(%rbx)
movl $0x1, %eax
movl %eax, 0x230(%rbx)
movl %eax, 0x23c(%rbx)
movl $0x61a8, %eax           # imm = 0x61A8
jmp 0x568da
cmpl $0x2, %eax
setb %sil
movl %ecx, %edx
andl $-0x2, %edx
cmpl $0x2, %edx
sete %dil
movl %ecx, %edx
xorl $0x4, %edx
orl %eax, %edx
sete %dl
testb %sil, %dil
jne 0x5659d
testb %dl, %dl
jne 0x5659d
leaq 0x4787f(%rip), %rsi     # 0x9e0ff
leaq 0x478a5(%rip), %rdx     # 0x9e12c
movl $0x1, %edi
xorl %eax, %eax
callq 0x14378
jmp 0x5621d
cmpl $0x5, 0x88(%rbx)
jne 0x568ab
movl $0x7, 0x88(%rbx)
movl $0x1, %eax
movl %eax, 0x230(%rbx)
movl %eax, 0x23c(%rbx)
movl %eax, 0x244(%rbx)
movl $0x186a0, %eax          # imm = 0x186A0
cmpl $0x8, 0x88(%rbx)
jl 0x568da
movl $0x1, 0x238(%rbx)
movl %eax, 0x214(%rbx)
cmpl $0x4c4b40, 0x218(%rbx)  # imm = 0x4C4B40
jne 0x568fc
imull $0x1f4, 0x214(%rbx), %eax # imm = 0x1F4
movl %eax, 0x218(%rbx)
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq