// File: sisong[P]ApkDiffPatch/zlib1.3.1/deflate.c
// Function: deflate_stored
local block_state deflate_stored(deflate_state *s, int flush) {
    /* Smallest worthy block size when not flushing or finishing. By default
     * this is 32K. This can be as small as 507 bytes for memLevel == 1. For
     * large input and output buffers, the stored block size will be larger.
     */
    unsigned min_block = MIN(s->pending_buf_size - 5, s->w_size);

    /* Copy as many min_block or larger stored blocks directly to next_out as
     * possible. If flushing, copy the remaining available input to next_out as
     * stored blocks, if there is enough space.
     */
    unsigned len, left, have, last = 0;
    unsigned used = s->strm->avail_in;
    do {
        /* Set len to the maximum size block that we can copy directly with the
         * available input data and output space. Set left to how much of that
         * would be copied from what's left in the window.
         */
        len = MAX_STORED;       /* maximum deflate stored block length */
        have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
        if (s->strm->avail_out < have)          /* need room for header */
            break;
            /* maximum stored block length that will fit in avail_out: */
        have = s->strm->avail_out - have;
        left = s->strstart - s->block_start;    /* bytes left in window */
        if (len > (ulg)left + s->strm->avail_in)
            len = left + s->strm->avail_in;     /* limit len to the input */
        if (len > have)
            len = have;                         /* limit len to the output */

        /* If the stored block would be less than min_block in length, or if
         * unable to copy all of the available input when flushing, then try
         * copying to the window and the pending buffer instead. Also don't
         * write an empty block when flushing -- deflate() does that.
         */
        if (len < min_block && ((len == 0 && flush != Z_FINISH) ||
                                flush == Z_NO_FLUSH ||
                                len != left + s->strm->avail_in))
            break;

        /* Make a dummy stored block in pending to get the header bytes,
         * including any pending bits. This also updates the debugging counts.
         */
        last = flush == Z_FINISH && len == left + s->strm->avail_in ? 1 : 0;
        _tr_stored_block(s, (char *)0, 0L, last);

        /* Replace the lengths in the dummy stored block with len. */
        s->pending_buf[s->pending - 4] = len;
        s->pending_buf[s->pending - 3] = len >> 8;
        s->pending_buf[s->pending - 2] = ~len;
        s->pending_buf[s->pending - 1] = ~len >> 8;

        /* Write the stored block header bytes. */
        flush_pending(s->strm);

#ifdef ZLIB_DEBUG
        /* Update debugging counts for the data about to be copied. */
        s->compressed_len += len << 3;
        s->bits_sent += len << 3;
#endif

        /* Copy uncompressed bytes from the window to next_out. */
        if (left) {
            if (left > len)
                left = len;
            zmemcpy(s->strm->next_out, s->window + s->block_start, left);
            s->strm->next_out += left;
            s->strm->avail_out -= left;
            s->strm->total_out += left;
            s->block_start += left;
            len -= left;
        }

        /* Copy uncompressed bytes directly from next_in to next_out, updating
         * the check value.
         */
        if (len) {
            read_buf(s->strm, s->strm->next_out, len);
            s->strm->next_out += len;
            s->strm->avail_out -= len;
            s->strm->total_out += len;
        }
    } while (last == 0);

    /* Update the sliding window with the last s->w_size bytes of the copied
     * data, or append all of the copied data to the existing window if less
     * than s->w_size bytes were copied. Also update the number of bytes to
     * insert in the hash tables, in the event that deflateParams() switches to
     * a non-zero compression level.
     */
    used -= s->strm->avail_in;      /* number of input bytes directly copied */
    if (used) {
        /* If any input was used, then no unused input remains in the window,
         * therefore s->block_start == s->strstart.
         */
        if (used >= s->w_size) {    /* supplant the previous history */
            s->matches = 2;         /* clear hash */
            zmemcpy(s->window, s->strm->next_in - s->w_size, s->w_size);
            s->strstart = s->w_size;
            s->insert = s->strstart;
        }
        else {
            if (s->window_size - s->strstart <= used) {
                /* Slide the window down. */
                s->strstart -= s->w_size;
                zmemcpy(s->window, s->window + s->w_size, s->strstart);
                if (s->matches < 2)
                    s->matches++;   /* add a pending slide_hash() */
                if (s->insert > s->strstart)
                    s->insert = s->strstart;
            }
            zmemcpy(s->window + s->strstart, s->strm->next_in - used, used);
            s->strstart += used;
            s->insert += MIN(used, s->w_size - s->insert);
        }
        s->block_start = s->strstart;
    }
    if (s->high_water < s->strstart)
        s->high_water = s->strstart;

    /* If the last block was written to next_out, then done. */
    if (last)
        return finish_done;

    /* If flushing and all input has been consumed, then done. */
    if (flush != Z_NO_FLUSH && flush != Z_FINISH &&
        s->strm->avail_in == 0 && (long)s->strstart == s->block_start)
        return block_done;

    /* Fill the window with any remaining input. */
    have = s->window_size - s->strstart;
    if (s->strm->avail_in > have && s->block_start >= (long)s->w_size) {
        /* Slide the window down. */
        s->block_start -= s->w_size;
        s->strstart -= s->w_size;
        zmemcpy(s->window, s->window + s->w_size, s->strstart);
        if (s->matches < 2)
            s->matches++;           /* add a pending slide_hash() */
        have += s->w_size;          /* more space now */
        if (s->insert > s->strstart)
            s->insert = s->strstart;
    }
    if (have > s->strm->avail_in)
        have = s->strm->avail_in;
    if (have) {
        read_buf(s->strm, s->window + s->strstart, have);
        s->strstart += have;
        s->insert += MIN(have, s->w_size - s->insert);
    }
    if (s->high_water < s->strstart)
        s->high_water = s->strstart;

    /* There was not enough avail_out to write a complete worthy or flushed
     * stored block to next_out. Write a stored block to pending instead, if we
     * have enough input for a worthy block, or if flushing and there is enough
     * room for the remaining input as a stored block in the pending buffer.
     */
    have = (s->bi_valid + 42) >> 3;         /* number of header bytes */
        /* maximum stored block length that will fit in pending: */
    have = MIN(s->pending_buf_size - have, MAX_STORED);
    min_block = MIN(have, s->w_size);
    left = s->strstart - s->block_start;
    if (left >= min_block ||
        ((left || flush == Z_FINISH) && flush != Z_NO_FLUSH &&
         s->strm->avail_in == 0 && left <= have)) {
        len = MIN(left, have);
        last = flush == Z_FINISH && s->strm->avail_in == 0 &&
               len == left ? 1 : 0;
        _tr_stored_block(s, (charf *)s->window + s->block_start, len, last);
        s->block_start += len;
        flush_pending(s->strm);
    }

    /* We've done all we can with the available input and output. */
    return last ? finish_started : need_more;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x5, %rax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
cmpq %rcx, %rax
jbe 0x95a04
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq %rax, -0x38(%rbp)
jmp 0x95a14
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
subq $0x5, %rax
movq %rax, -0x38(%rbp)
movq -0x38(%rbp), %rax
movl %eax, -0x18(%rbp)
movl $0x0, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x2c(%rbp)
movl $0xffff, -0x1c(%rbp)    # imm = 0xFFFF
movq -0x10(%rbp), %rax
movl 0x1734(%rax), %eax
addl $0x2a, %eax
sarl $0x3, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
cmpl -0x24(%rbp), %eax
jae 0x95a5d
jmp 0x95cc7
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
subl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movq -0x10(%rbp), %rcx
subq 0x98(%rcx), %rax
movl %eax, -0x20(%rbp)
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x95aad
movl -0x20(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
addl 0x8(%rcx), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x95abb
movl -0x24(%rbp), %eax
movl %eax, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x95aee
cmpl $0x0, -0x1c(%rbp)
jne 0x95acf
cmpl $0x4, -0x14(%rbp)
jne 0x95ae9
cmpl $0x0, -0x14(%rbp)
je 0x95ae9
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
je 0x95aee
jmp 0x95cc7
xorl %eax, %eax
cmpl $0x4, -0x14(%rbp)
movb %al, -0x39(%rbp)
jne 0x95b11
movl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rdx
movq (%rdx), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movl -0x28(%rbp), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0x9ed70
movl -0x1c(%rbp), %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x4, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x3, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
xorl $-0x1, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x2, %rcx
movb %dl, (%rax,%rcx)
movl -0x1c(%rbp), %eax
xorl $-0x1, %eax
shrl $0x8, %eax
movb %al, %dl
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rbp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x95880
cmpl $0x0, -0x20(%rbp)
je 0x95c5e
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jbe 0x95bd7
movl -0x1c(%rbp), %eax
movl %eax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x98(%rax), %rsi
movl -0x20(%rbp), %eax
movl %eax, %edx
callq 0x4320
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl -0x20(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movl -0x20(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movl -0x20(%rbp), %ecx
movl -0x1c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
je 0x95cbb
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
movl -0x1c(%rbp), %edx
callq 0x97050
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl -0x1c(%rbp), %edx
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq (%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
jmp 0x95cbd
cmpl $0x0, -0x28(%rbp)
je 0x95a2f
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movl -0x2c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x2c(%rbp)
cmpl $0x0, -0x2c(%rbp)
je 0x95eb0
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jb 0x95d58
movq -0x10(%rbp), %rax
movl $0x2, 0x1728(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %edx
callq 0x4320
movq -0x10(%rbp), %rax
movl 0x50(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0xac(%rax)
movq -0x10(%rbp), %rax
movl 0xac(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x172c(%rax)
jmp 0x95e99
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xac(%rcx), %ecx
subq %rcx, %rax
movl -0x2c(%rbp), %ecx
cmpq %rcx, %rax
ja 0x95e09
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edx
movq -0x10(%rbp), %rax
movl 0xac(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xac(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, %edx
callq 0x4320
movq -0x10(%rbp), %rax
cmpl $0x2, 0x1728(%rax)
jae 0x95ddd
movq -0x10(%rbp), %rax
movl 0x1728(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1728(%rax)
movq -0x10(%rbp), %rax
movl 0x172c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xac(%rcx), %eax
jbe 0x95e07
movq -0x10(%rbp), %rax
movl 0xac(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x172c(%rax)
jmp 0x95e09
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
addq %rax, %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movl -0x2c(%rbp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl -0x2c(%rbp), %eax
movl %eax, %edx
callq 0x4320
movl -0x2c(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0xac(%rax), %ecx
movl %ecx, 0xac(%rax)
movl -0x2c(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x172c(%rdx), %ecx
cmpl %ecx, %eax
jbe 0x95e80
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x172c(%rcx), %eax
movl %eax, -0x40(%rbp)
jmp 0x95e86
movl -0x2c(%rbp), %eax
movl %eax, -0x40(%rbp)
movl -0x40(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x172c(%rax), %ecx
movl %ecx, 0x172c(%rax)
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq 0x1738(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xac(%rcx), %ecx
cmpq %rcx, %rax
jae 0x95ee1
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x1738(%rax)
cmpl $0x0, -0x28(%rbp)
je 0x95ef3
movl $0x3, -0x4(%rbp)
jmp 0x9627b
cmpl $0x0, -0x14(%rbp)
je 0x95f2f
cmpl $0x4, -0x14(%rbp)
je 0x95f2f
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x95f2f
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movq -0x10(%rbp), %rcx
cmpq 0x98(%rcx), %rax
jne 0x95f2f
movl $0x1, -0x4(%rbp)
jmp 0x9627b
movq -0x10(%rbp), %rax
movq 0x68(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xac(%rcx), %ecx
subq %rcx, %rax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x24(%rbp), %eax
jbe 0x96030
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
cmpq %rcx, %rax
jl 0x96030
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, %edx
movq -0x10(%rbp), %rax
movq 0x98(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %edx
movq -0x10(%rbp), %rax
movl 0xac(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xac(%rax)
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
addq %rax, %rsi
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, %edx
callq 0x4320
movq -0x10(%rbp), %rax
cmpl $0x2, 0x1728(%rax)
jae 0x95ff7
movq -0x10(%rbp), %rax
movl 0x1728(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1728(%rax)
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
addl -0x24(%rbp), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movl 0x172c(%rax), %eax
movq -0x10(%rbp), %rcx
cmpl 0xac(%rcx), %eax
jbe 0x9602e
movq -0x10(%rbp), %rax
movl 0xac(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x172c(%rax)
jmp 0x96030
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jbe 0x9604c
movq -0x10(%rbp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, -0x24(%rbp)
je 0x960d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
addq %rax, %rsi
movl -0x24(%rbp), %edx
callq 0x97050
movl -0x24(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0xac(%rax), %ecx
movl %ecx, 0xac(%rax)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
movl 0x50(%rcx), %ecx
movq -0x10(%rbp), %rdx
subl 0x172c(%rdx), %ecx
cmpl %ecx, %eax
jbe 0x960b7
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movq -0x10(%rbp), %rcx
subl 0x172c(%rcx), %eax
movl %eax, -0x44(%rbp)
jmp 0x960bd
movl -0x24(%rbp), %eax
movl %eax, -0x44(%rbp)
movl -0x44(%rbp), %ecx
movq -0x10(%rbp), %rax
addl 0x172c(%rax), %ecx
movl %ecx, 0x172c(%rax)
movq -0x10(%rbp), %rax
movq 0x1738(%rax), %rax
movq -0x10(%rbp), %rcx
movl 0xac(%rcx), %ecx
cmpq %rcx, %rax
jae 0x96101
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
movq %rcx, 0x1738(%rax)
movq -0x10(%rbp), %rax
movl 0x1734(%rax), %eax
addl $0x2a, %eax
sarl $0x3, %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
subq %rcx, %rax
cmpq $0xffff, %rax           # imm = 0xFFFF
jbe 0x96135
movl $0xffff, %eax           # imm = 0xFFFF
movq %rax, -0x50(%rbp)
jmp 0x96147
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl -0x24(%rbp), %ecx
subq %rcx, %rax
movq %rax, -0x50(%rbp)
movq -0x50(%rbp), %rax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
movq -0x10(%rbp), %rcx
cmpl 0x50(%rcx), %eax
jbe 0x96166
movq -0x10(%rbp), %rax
movl 0x50(%rax), %eax
movl %eax, -0x54(%rbp)
jmp 0x9616c
movl -0x24(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x54(%rbp), %eax
movl %eax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0xac(%rax), %eax
movq -0x10(%rbp), %rcx
subq 0x98(%rcx), %rax
movl %eax, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x18(%rbp), %eax
jae 0x961c9
cmpl $0x0, -0x20(%rbp)
jne 0x961a2
cmpl $0x4, -0x14(%rbp)
jne 0x96268
cmpl $0x0, -0x14(%rbp)
je 0x96268
movq -0x10(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0x96268
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
ja 0x96268
movl -0x20(%rbp), %eax
cmpl -0x24(%rbp), %eax
jbe 0x961d9
movl -0x24(%rbp), %eax
movl %eax, -0x58(%rbp)
jmp 0x961df
movl -0x20(%rbp), %eax
movl %eax, -0x58(%rbp)
movl -0x58(%rbp), %eax
movl %eax, -0x1c(%rbp)
xorl %eax, %eax
cmpl $0x4, -0x14(%rbp)
movb %al, -0x59(%rbp)
jne 0x9620e
movq -0x10(%rbp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x0, 0x8(%rcx)
movb %al, -0x59(%rbp)
jne 0x9620e
movl -0x1c(%rbp), %eax
cmpl -0x20(%rbp), %eax
sete %al
movb %al, -0x59(%rbp)
movb -0x59(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x60(%rax), %rsi
movq -0x10(%rbp), %rax
addq 0x98(%rax), %rsi
movl -0x1c(%rbp), %eax
movl %eax, %edx
movl -0x28(%rbp), %ecx
callq 0x9ed70
movl -0x1c(%rbp), %eax
movl %eax, %ecx
movq -0x10(%rbp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x95880
movl -0x28(%rbp), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)