// File: /workspace/github_cpp_makefile_star2_O1/sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflate
int ZEXPORT deflate(z_streamp strm, int flush) {
    int old_flush; /* value of flush param for previous deflate call */
    deflate_state *s;

    if (deflateStateCheck(strm) || flush > Z_BLOCK || flush < 0) {
        return Z_STREAM_ERROR;
    }
    s = strm->state;

    if (strm->next_out == Z_NULL ||
        (strm->avail_in != 0 && strm->next_in == Z_NULL) ||
        (s->status == FINISH_STATE && flush != Z_FINISH)) {
        ERR_RETURN(strm, Z_STREAM_ERROR);
    }
    if (strm->avail_out == 0) ERR_RETURN(strm, Z_BUF_ERROR);

    old_flush = s->last_flush;
    s->last_flush = flush;

    /* Flush as much pending output as possible */
    if (s->pending != 0) {
        flush_pending(strm);
        if (strm->avail_out == 0) {
            /* Since avail_out is 0, deflate will be called again with
             * more output space, but possibly with both pending and
             * avail_in equal to zero. There won't be anything to do,
             * but this is not an error situation so make sure we
             * return OK instead of BUF_ERROR at next call of deflate:
             */
            s->last_flush = -1;
            return Z_OK;
        }

    /* Make sure there is something to do and avoid duplicate consecutive
     * flushes. For repeated and useless calls with Z_FINISH, we keep
     * returning Z_STREAM_END instead of Z_BUF_ERROR.
     */
    } else if (strm->avail_in == 0 && RANK(flush) <= RANK(old_flush) &&
               flush != Z_FINISH) {
        ERR_RETURN(strm, Z_BUF_ERROR);
    }

    /* User must not provide more input after the first FINISH: */
    if (s->status == FINISH_STATE && strm->avail_in != 0) {
        ERR_RETURN(strm, Z_BUF_ERROR);
    }

    /* Write the header */
    if (s->status == INIT_STATE && s->wrap == 0)
        s->status = BUSY_STATE;
    if (s->status == INIT_STATE) {
        /* zlib header */
        uInt header = (Z_DEFLATED + ((s->w_bits - 8) << 4)) << 8;
        uInt level_flags;

        if (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2)
            level_flags = 0;
        else if (s->level < 6)
            level_flags = 1;
        else if (s->level == 6)
            level_flags = 2;
        else
            level_flags = 3;
        header |= (level_flags << 6);
        if (s->strstart != 0) header |= PRESET_DICT;
        header += 31 - (header % 31);

        putShortMSB(s, header);

        /* Save the adler32 of the preset dictionary: */
        if (s->strstart != 0) {
            putShortMSB(s, (uInt)(strm->adler >> 16));
            putShortMSB(s, (uInt)(strm->adler & 0xffff));
        }
        strm->adler = adler32(0L, Z_NULL, 0);
        s->status = BUSY_STATE;

        /* Compression must start with an empty pending buffer */
        flush_pending(strm);
        if (s->pending != 0) {
            s->last_flush = -1;
            return Z_OK;
        }
    }
#ifdef GZIP
    if (s->status == GZIP_STATE) {
        /* gzip header */
        strm->adler = crc32(0L, Z_NULL, 0);
        put_byte(s, 31);
        put_byte(s, 139);
        put_byte(s, 8);
        if (s->gzhead == Z_NULL) {
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, 0);
            put_byte(s, s->level == 9 ? 2 :
                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
                      4 : 0));
            put_byte(s, OS_CODE);
            s->status = BUSY_STATE;

            /* Compression must start with an empty pending buffer */
            flush_pending(strm);
            if (s->pending != 0) {
                s->last_flush = -1;
                return Z_OK;
            }
        }
        else {
            put_byte(s, (s->gzhead->text ? 1 : 0) +
                     (s->gzhead->hcrc ? 2 : 0) +
                     (s->gzhead->extra == Z_NULL ? 0 : 4) +
                     (s->gzhead->name == Z_NULL ? 0 : 8) +
                     (s->gzhead->comment == Z_NULL ? 0 : 16)
                     );
            put_byte(s, (Byte)(s->gzhead->time & 0xff));
            put_byte(s, (Byte)((s->gzhead->time >> 8) & 0xff));
            put_byte(s, (Byte)((s->gzhead->time >> 16) & 0xff));
            put_byte(s, (Byte)((s->gzhead->time >> 24) & 0xff));
            put_byte(s, s->level == 9 ? 2 :
                     (s->strategy >= Z_HUFFMAN_ONLY || s->level < 2 ?
                      4 : 0));
            put_byte(s, s->gzhead->os & 0xff);
            if (s->gzhead->extra != Z_NULL) {
                put_byte(s, s->gzhead->extra_len & 0xff);
                put_byte(s, (s->gzhead->extra_len >> 8) & 0xff);
            }
            if (s->gzhead->hcrc)
                strm->adler = crc32(strm->adler, s->pending_buf,
                                    s->pending);
            s->gzindex = 0;
            s->status = EXTRA_STATE;
        }
    }
    if (s->status == EXTRA_STATE) {
        if (s->gzhead->extra != Z_NULL) {
            ulg beg = s->pending;   /* start of bytes to update crc */
            uInt left = (s->gzhead->extra_len & 0xffff) - s->gzindex;
            while (s->pending + left > s->pending_buf_size) {
                uInt copy = s->pending_buf_size - s->pending;
                zmemcpy(s->pending_buf + s->pending,
                        s->gzhead->extra + s->gzindex, copy);
                s->pending = s->pending_buf_size;
                HCRC_UPDATE(beg);
                s->gzindex += copy;
                flush_pending(strm);
                if (s->pending != 0) {
                    s->last_flush = -1;
                    return Z_OK;
                }
                beg = 0;
                left -= copy;
            }
            zmemcpy(s->pending_buf + s->pending,
                    s->gzhead->extra + s->gzindex, left);
            s->pending += left;
            HCRC_UPDATE(beg);
            s->gzindex = 0;
        }
        s->status = NAME_STATE;
    }
    if (s->status == NAME_STATE) {
        if (s->gzhead->name != Z_NULL) {
            ulg beg = s->pending;   /* start of bytes to update crc */
            int val;
            do {
                if (s->pending == s->pending_buf_size) {
                    HCRC_UPDATE(beg);
                    flush_pending(strm);
                    if (s->pending != 0) {
                        s->last_flush = -1;
                        return Z_OK;
                    }
                    beg = 0;
                }
                val = s->gzhead->name[s->gzindex++];
                put_byte(s, val);
            } while (val != 0);
            HCRC_UPDATE(beg);
            s->gzindex = 0;
        }
        s->status = COMMENT_STATE;
    }
    if (s->status == COMMENT_STATE) {
        if (s->gzhead->comment != Z_NULL) {
            ulg beg = s->pending;   /* start of bytes to update crc */
            int val;
            do {
                if (s->pending == s->pending_buf_size) {
                    HCRC_UPDATE(beg);
                    flush_pending(strm);
                    if (s->pending != 0) {
                        s->last_flush = -1;
                        return Z_OK;
                    }
                    beg = 0;
                }
                val = s->gzhead->comment[s->gzindex++];
                put_byte(s, val);
            } while (val != 0);
            HCRC_UPDATE(beg);
        }
        s->status = HCRC_STATE;
    }
    if (s->status == HCRC_STATE) {
        if (s->gzhead->hcrc) {
            if (s->pending + 2 > s->pending_buf_size) {
                flush_pending(strm);
                if (s->pending != 0) {
                    s->last_flush = -1;
                    return Z_OK;
                }
            }
            put_byte(s, (Byte)(strm->adler & 0xff));
            put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
            strm->adler = crc32(0L, Z_NULL, 0);
        }
        s->status = BUSY_STATE;

        /* Compression must start with an empty pending buffer */
        flush_pending(strm);
        if (s->pending != 0) {
            s->last_flush = -1;
            return Z_OK;
        }
    }
#endif

    /* Start a new block or continue the current one.
     */
    if (strm->avail_in != 0 || s->lookahead != 0 ||
        (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) {
        block_state bstate;

        bstate = s->level == 0 ? deflate_stored(s, flush) :
                 s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) :
                 s->strategy == Z_RLE ? deflate_rle(s, flush) :
                 (*(configuration_table[s->level].func))(s, flush);

        if (bstate == finish_started || bstate == finish_done) {
            s->status = FINISH_STATE;
        }
        if (bstate == need_more || bstate == finish_started) {
            if (strm->avail_out == 0) {
                s->last_flush = -1; /* avoid BUF_ERROR next call, see above */
            }
            return Z_OK;
            /* If flush != Z_NO_FLUSH && avail_out == 0, the next call
             * of deflate should use the same flush parameter to make sure
             * that the flush is complete. So we don't have to output an
             * empty block here, this will be done at next call. This also
             * ensures that for a very small output buffer, we emit at most
             * one empty block.
             */
        }
        if (bstate == block_done) {
            if (flush == Z_PARTIAL_FLUSH) {
                _tr_align(s);
            } else if (flush != Z_BLOCK) { /* FULL_FLUSH or SYNC_FLUSH */
                _tr_stored_block(s, (char*)0, 0L, 0);
                /* For a full flush, this empty block will be recognized
                 * as a special marker by inflate_sync().
                 */
                if (flush == Z_FULL_FLUSH) {
                    CLEAR_HASH(s);             /* forget history */
                    if (s->lookahead == 0) {
                        s->strstart = 0;
                        s->block_start = 0L;
                        s->insert = 0;
                    }
                }
            }
            flush_pending(strm);
            if (strm->avail_out == 0) {
              s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
              return Z_OK;
            }
        }
    }

    if (flush != Z_FINISH) return Z_OK;
    if (s->wrap <= 0) return Z_STREAM_END;

    /* Write the trailer */
#ifdef GZIP
    if (s->wrap == 2) {
        put_byte(s, (Byte)(strm->adler & 0xff));
        put_byte(s, (Byte)((strm->adler >> 8) & 0xff));
        put_byte(s, (Byte)((strm->adler >> 16) & 0xff));
        put_byte(s, (Byte)((strm->adler >> 24) & 0xff));
        put_byte(s, (Byte)(strm->total_in & 0xff));
        put_byte(s, (Byte)((strm->total_in >> 8) & 0xff));
        put_byte(s, (Byte)((strm->total_in >> 16) & 0xff));
        put_byte(s, (Byte)((strm->total_in >> 24) & 0xff));
    }
    else
#endif
    {
        putShortMSB(s, (uInt)(strm->adler >> 16));
        putShortMSB(s, (uInt)(strm->adler & 0xffff));
    }
    flush_pending(strm);
    /* If avail_out is zero, the application will call deflate again
     * to flush the rest.
     */
    if (s->wrap > 0) s->wrap = -s->wrap; /* write the trailer only once! */
    return s->pending != 0 ? Z_OK : Z_STREAM_END;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %esi, %r15d
movq %rdi, %rbx
callq 0x4b13a
movl $0xfffffffe, %r12d      # imm = 0xFFFFFFFE
cmpl $0x5, %r15d
ja 0x4b7bd
testl %eax, %eax
jne 0x4b7bd
cmpq $0x0, 0x18(%rbx)
je 0x4b7ae
movq 0x38(%rbx), %r14
movl 0x8(%rbx), %ecx
testl %ecx, %ecx
je 0x4b79e
cmpq $0x0, (%rbx)
je 0x4b7ae
cmpl $0x4, %r15d
je 0x4b7cf
cmpl $0x29a, 0x8(%r14)       # imm = 0x29A
jne 0x4b7cf
leaq 0x3058b(%rip), %rax     # 0x7bd40
movq 0x20(%rax), %rax
movq %rax, 0x30(%rbx)
movl %r12d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x0, 0x20(%rbx)
je 0x4bc61
movl 0x4c(%r14), %eax
movl %r15d, 0x4c(%r14)
cmpq $0x0, 0x28(%r14)
je 0x4b803
movq %rbx, %rdi
callq 0x4c46a
cmpl $0x0, 0x20(%rbx)
jne 0x4b80b
movl $0xffffffff, 0x4c(%r14) # imm = 0xFFFFFFFF
xorl %r12d, %r12d
jmp 0x4b7bd
testl %ecx, %ecx
je 0x4bc25
movl 0x8(%r14), %eax
cmpl $0x2a, %eax
je 0x4b82a
cmpl $0x29a, %eax            # imm = 0x29A
jne 0x4b839
cmpl $0x0, 0x8(%rbx)
jne 0x4bc61
cmpl $0x2a, %eax
jne 0x4b839
cmpl $0x0, 0x30(%r14)
jne 0x4b839
movl $0x71, 0x8(%r14)
cmpl $0x2a, 0x8(%r14)
jne 0x4b971
movl 0x54(%r14), %eax
shll $0xc, %eax
addl $0xffff8800, %eax       # imm = 0xFFFF8800
xorl %ecx, %ecx
cmpl $0x1, 0xc8(%r14)
jg 0x4b87e
movl 0xc4(%r14), %edx
cmpl $0x2, %edx
jl 0x4b87e
movl $0x40, %ecx
cmpl $0x6, %edx
jl 0x4b87e
setne %cl
movzbl %cl, %ecx
orl $0x2, %ecx
shll $0x6, %ecx
movl %ecx, %edx
orl %eax, %edx
cmpl $0x0, 0xac(%r14)
leal 0x20(%rcx,%rax), %eax
cmovel %edx, %eax
imulq $0x8421085, %rax, %rcx  # imm = 0x8421085
shrq $0x20, %rcx
movl %eax, %edx
subl %ecx, %edx
shrl %edx
addl %ecx, %edx
shrl $0x4, %edx
movl %edx, %ecx
shll $0x5, %ecx
subl %ecx, %edx
addl %eax, %edx
orl %eax, %edx
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%r14)
movb %ah, (%rcx,%rsi)
xorb $0x1f, %dl
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x28(%r14)
movb %dl, (%rax,%rcx)
cmpl $0x0, 0xac(%r14)
je 0x4b93b
movb 0x62(%rbx), %al
movb 0x63(%rbx), %cl
movq 0x10(%r14), %rdx
movq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%r14)
movb %cl, (%rdx,%rsi)
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x60(%rbx), %rax
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %ah, (%rcx,%rdx)
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
xorl %r12d, %r12d
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a3fc
movq %rax, 0x60(%rbx)
movl $0x71, 0x8(%r14)
movq %rbx, %rdi
callq 0x4c46a
cmpq $0x0, 0x28(%r14)
je 0x4b971
movl $0xffffffff, 0x4c(%r14) # imm = 0xFFFFFFFF
jmp 0x4b7bd
cmpl $0x39, 0x8(%r14)
jne 0x4bb42
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
movb $0x1f, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
movb $-0x75, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
movb $0x8, (%rax,%rcx)
movq 0x38(%r14), %rax
testq %rax, %rax
je 0x4bc7b
cmpl $0x0, (%rax)
setne %cl
cmpl $0x0, 0x44(%rax)
setne %dl
addb %dl, %dl
orb %cl, %dl
cmpq $0x0, 0x18(%rax)
setne %cl
shlb $0x2, %cl
orb %dl, %cl
cmpq $0x0, 0x28(%rax)
setne %dl
shlb $0x3, %dl
orb %cl, %dl
cmpq $0x0, 0x38(%rax)
setne %al
shlb $0x4, %al
orb %dl, %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
movb 0x8(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
movb 0x9(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
movb 0xa(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
movb 0xb(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movl 0xc4(%r14), %ecx
movb $0x2, %al
cmpl $0x9, %ecx
je 0x4baab
cmpl $0x2, 0xc8(%r14)
setge %dl
cmpl $0x2, %ecx
setl %al
orb %dl, %al
shlb $0x2, %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
movb 0x14(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
cmpq $0x0, 0x18(%rax)
je 0x4bb13
movb 0x20(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
movb 0x21(%rax), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x38(%r14), %rax
cmpl $0x0, 0x44(%rax)
je 0x4bb32
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
movl 0x28(%r14), %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movq $0x0, 0x40(%r14)
movl $0x45, 0x8(%r14)
cmpl $0x45, 0x8(%r14)
jne 0x4bdb3
movq 0x38(%r14), %rax
cmpq $0x0, 0x18(%rax)
je 0x4bdab
movq %r15, 0x10(%rsp)
movq 0x28(%r14), %rcx
movq %rcx, (%rsp)
movzwl 0x20(%rax), %eax
subl 0x40(%r14), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%r14), %r15
movq 0x28(%r14), %rdi
movl 0xc(%rsp), %r12d
leaq (%rdi,%r12), %rbp
cmpq %r15, %rbp
jbe 0x4bd47
movq %r15, %r13
subq %rdi, %r13
addq 0x10(%r14), %rdi
movq 0x38(%r14), %rax
movq 0x18(%rax), %rsi
addq 0x40(%r14), %rsi
movl %r13d, %r12d
movq %r12, %rdx
callq 0x4290
movq 0x18(%r14), %rdx
movq 0x38(%r14), %rax
movq %rdx, 0x28(%r14)
cmpl $0x0, 0x44(%rax)
setne %al
cmpq (%rsp), %rdx
seta %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x4bbeb
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
movq (%rsp), %rax
addq %rax, %rsi
subl %eax, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
addq %r12, 0x40(%r14)
movq %rbx, %rdi
callq 0x4c46a
movq 0x28(%r14), %rax
testq %rax, %rax
je 0x4bc0a
movl $0xffffffff, 0x4c(%r14) # imm = 0xFFFFFFFF
jmp 0x4bc17
subl %r13d, 0xc(%rsp)
movq $0x0, (%rsp)
testq %rax, %rax
je 0x4bb75
jmp 0x4bd9d
xorl %esi, %esi
cmpl $0x5, %r15d
setl %dil
xorl %ecx, %ecx
cmpl $0x5, %eax
setl %dl
cmpl $0x4, %r15d
je 0x4b80b
movb %dil, %sil
leal (%rsi,%rsi,8), %esi
leal (%rsi,%r15,2), %esi
addl $-0x9, %esi
movb %dl, %cl
leal (%rcx,%rcx,8), %ecx
leal (%rcx,%rax,2), %eax
addl $-0x9, %eax
cmpl %eax, %esi
jg 0x4b80b
leaq 0x300d8(%rip), %rax     # 0x7bd40
movq 0x38(%rax), %rax
movq %rax, 0x30(%rbx)
movl $0xfffffffb, %r12d      # imm = 0xFFFFFFFB
jmp 0x4b7bd
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
xorl %edx, %edx
movb %dl, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x28(%r14)
movb %dl, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x28(%r14)
movb %dl, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x28(%r14)
movb %dl, (%rax,%rcx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rsi
movq %rsi, 0x28(%r14)
movb %dl, (%rax,%rcx)
movl 0xc4(%r14), %ecx
movb $0x2, %al
cmpl $0x9, %ecx
je 0x4bd00
cmpl $0x2, 0xc8(%r14)
setge %dl
cmpl $0x2, %ecx
setl %al
orb %dl, %al
shlb $0x2, %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rcx
leaq 0x1(%rcx), %rdx
movq %rdx, 0x28(%r14)
movb $0x3, (%rax,%rcx)
movl $0x71, 0x8(%r14)
movq %rbx, %rdi
callq 0x4c46a
cmpq $0x0, 0x28(%r14)
jne 0x4b7f6
jmp 0x4bb42
addq 0x10(%r14), %rdi
movq 0x38(%r14), %rax
movq 0x18(%rax), %rsi
addq 0x40(%r14), %rsi
movq %r12, %rdx
callq 0x4290
addq 0x28(%r14), %r12
movq %r12, 0x28(%r14)
movq 0x38(%r14), %rax
cmpl $0x0, 0x44(%rax)
je 0x4bd95
cmpq (%rsp), %r12
jbe 0x4bd95
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
movq (%rsp), %rax
addq %rax, %rsi
subl %eax, %r12d
movl %r12d, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movq $0x0, 0x40(%r14)
cmpq %r15, %rbp
movq 0x10(%rsp), %r15
ja 0x4b7fe
movl $0x49, 0x8(%r14)
cmpl $0x49, 0x8(%r14)
jne 0x4be88
movq 0x38(%r14), %rax
cmpq $0x0, 0x28(%rax)
je 0x4be80
movq 0x28(%r14), %rax
movq 0x28(%r14), %rdx
cmpq 0x18(%r14), %rdx
jne 0x4be21
movq 0x38(%r14), %rcx
cmpl $0x0, 0x44(%rcx)
setne %cl
cmpq %rax, %rdx
seta %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x4be0c
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
addq %rax, %rsi
subl %eax, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0x4c46a
cmpq $0x0, 0x28(%r14)
jne 0x4b7f6
xorl %eax, %eax
movq 0x38(%r14), %rcx
movq 0x28(%rcx), %rcx
movq 0x40(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x40(%r14)
movb (%rcx,%rdx), %cl
movq 0x10(%r14), %rdx
movq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%r14)
movb %cl, (%rdx,%rsi)
testb %cl, %cl
jne 0x4bdd1
movq 0x38(%r14), %rcx
cmpl $0x0, 0x44(%rcx)
je 0x4be78
movq 0x28(%r14), %rdx
cmpq %rax, %rdx
jbe 0x4be78
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
addq %rax, %rsi
subl %eax, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movq $0x0, 0x40(%r14)
movl $0x5b, 0x8(%r14)
cmpl $0x5b, 0x8(%r14)
jne 0x4bf55
movq 0x38(%r14), %rax
cmpq $0x0, 0x38(%rax)
je 0x4bf4d
movq 0x28(%r14), %rax
movq 0x28(%r14), %rdx
cmpq 0x18(%r14), %rdx
jne 0x4bef6
movq 0x38(%r14), %rcx
cmpl $0x0, 0x44(%rcx)
setne %cl
cmpq %rax, %rdx
seta %sil
andb %cl, %sil
cmpb $0x1, %sil
jne 0x4bee1
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
addq %rax, %rsi
subl %eax, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movq %rbx, %rdi
callq 0x4c46a
cmpq $0x0, 0x28(%r14)
jne 0x4b7f6
xorl %eax, %eax
movq 0x38(%r14), %rcx
movq 0x38(%rcx), %rcx
movq 0x40(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x40(%r14)
movb (%rcx,%rdx), %cl
movq 0x10(%r14), %rdx
movq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%r14)
movb %cl, (%rdx,%rsi)
testb %cl, %cl
jne 0x4bea6
movq 0x38(%r14), %rcx
cmpl $0x0, 0x44(%rcx)
je 0x4bf4d
movq 0x28(%r14), %rdx
cmpq %rax, %rdx
jbe 0x4bf4d
movq 0x60(%rbx), %rdi
movq 0x10(%r14), %rsi
addq %rax, %rsi
subl %eax, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movl $0x67, 0x8(%r14)
cmpl $0x67, 0x8(%r14)
jne 0x4bfe1
movq 0x38(%r14), %rax
cmpl $0x0, 0x44(%rax)
je 0x4bfc6
movq 0x28(%r14), %rax
addq $0x2, %rax
cmpq 0x18(%r14), %rax
jbe 0x4bf8b
movq %rbx, %rdi
callq 0x4c46a
cmpq $0x0, 0x28(%r14)
jne 0x4b7f6
movb 0x60(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x61(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
xorl %edi, %edi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4a9cf
movq %rax, 0x60(%rbx)
movl $0x71, 0x8(%r14)
movq %rbx, %rdi
callq 0x4c46a
cmpq $0x0, 0x28(%r14)
jne 0x4b7f6
cmpl $0x0, 0x8(%rbx)
jne 0x4bff5
cmpl $0x0, 0xb4(%r14)
je 0x4c09c
movslq 0xc4(%r14), %rax
testq %rax, %rax
je 0x4c01f
movl 0xc8(%r14), %ecx
cmpl $0x3, %ecx
je 0x4c02c
cmpl $0x2, %ecx
jne 0x4c039
movq %r14, %rdi
movl %r15d, %esi
callq 0x4c914
jmp 0x4c04e
movq %r14, %rdi
movl %r15d, %esi
callq 0x4c4cc
jmp 0x4c04e
movq %r14, %rdi
movl %r15d, %esi
callq 0x4cafd
jmp 0x4c04e
shlq $0x4, %rax
leaq 0x2fbfc(%rip), %rcx     # 0x7bc40
movq %r14, %rdi
movl %r15d, %esi
callq *0x8(%rax,%rcx)
movl %eax, %ecx
andl $-0x2, %ecx
cmpl $0x2, %ecx
jne 0x4c060
movl $0x29a, 0x8(%r14)       # imm = 0x29A
testl $0xfffffffd, %eax       # imm = 0xFFFFFFFD
je 0x4c08a
cmpl $0x1, %eax
jne 0x4c116
cmpl $0x5, %r15d
je 0x4c104
movq %r14, %rdi
cmpl $0x1, %r15d
jne 0x4c0b1
callq 0x51adc
jmp 0x4c104
xorl %r12d, %r12d
cmpl $0x0, 0x20(%rbx)
jne 0x4b7bd
jmp 0x4b964
testl %r15d, %r15d
je 0x4c116
cmpl $0x29a, 0x8(%r14)       # imm = 0x29A
jne 0x4bff5
jmp 0x4c116
xorl %esi, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x518d6
cmpl $0x3, %r15d
jne 0x4c104
movq 0x78(%r14), %rdi
movl 0x84(%r14), %edx
decl %edx
movw $0x0, (%rdi,%rdx,2)
addq %rdx, %rdx
xorl %ebp, %ebp
xorl %esi, %esi
callq 0x41c0
cmpl $0x0, 0xb4(%r14)
jne 0x4c104
movl %ebp, 0xac(%r14)
movq $0x0, 0x98(%r14)
movl %ebp, 0x172c(%r14)
movq %rbx, %rdi
callq 0x4c46a
cmpl $0x0, 0x20(%rbx)
je 0x4b7f6
cmpl $0x4, %r15d
jne 0x4b7fe
movl 0x30(%r14), %ecx
testl %ecx, %ecx
jle 0x4c1da
movq 0x60(%rbx), %rax
cmpl $0x2, %ecx
jne 0x4c1e5
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x61(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x62(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x63(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x10(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x11(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movb 0x12(%rbx), %al
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq 0x10(%rbx), %rax
shrq $0x18, %rax
jmp 0x4c22a
movl $0x1, %r12d
jmp 0x4b7bd
movl %eax, %ecx
shrl $0x10, %ecx
shrl $0x18, %eax
movq 0x10(%r14), %rdx
movq 0x28(%r14), %rsi
leaq 0x1(%rsi), %rdi
movq %rdi, 0x28(%r14)
movb %al, (%rdx,%rsi)
movq 0x10(%r14), %rax
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %cl, (%rax,%rdx)
movq 0x60(%rbx), %rax
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %ah, (%rcx,%rdx)
movq 0x10(%r14), %rcx
movq 0x28(%r14), %rdx
leaq 0x1(%rdx), %rsi
movq %rsi, 0x28(%r14)
movb %al, (%rcx,%rdx)
movq %rbx, %rdi
callq 0x4c46a
movl 0x30(%r14), %eax
testl %eax, %eax
jle 0x4c253
negl %eax
movl %eax, 0x30(%r14)
xorl %r12d, %r12d
cmpq $0x0, 0x28(%r14)
sete %r12b
jmp 0x4b7bd