// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.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:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
subq $0x5, %rax
movq 0x58(%rsp), %rcx
movl 0x50(%rcx), %ecx
cmpq %rcx, %rax
jbe 0xd3096
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movq %rax, 0x30(%rsp)
jmp 0xd30a8
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
subq $0x5, %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
movl %eax, 0x50(%rsp)
movl $0x0, 0x40(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x3c(%rsp)
movl $0xffff, 0x4c(%rsp)     # imm = 0xFFFF
movq 0x58(%rsp), %rax
movl 0x1734(%rax), %eax
addl $0x2a, %eax
sarl $0x3, %eax
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
cmpl 0x44(%rsp), %eax
jae 0xd30fb
jmp 0xd33b3
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %eax
subl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movq 0x58(%rsp), %rcx
subq 0x98(%rcx), %rax
movl %eax, 0x48(%rsp)
movl 0x4c(%rsp), %eax
movl 0x48(%rsp), %ecx
movq 0x58(%rsp), %rdx
movq (%rdx), %rdx
movl 0x8(%rdx), %edx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0xd3157
movl 0x48(%rsp), %eax
movq 0x58(%rsp), %rcx
movq (%rcx), %rcx
addl 0x8(%rcx), %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jbe 0xd3169
movl 0x44(%rsp), %eax
movl %eax, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x50(%rsp), %eax
jae 0xd31a4
cmpl $0x0, 0x4c(%rsp)
jne 0xd3181
cmpl $0x4, 0x54(%rsp)
jne 0xd319f
cmpl $0x0, 0x54(%rsp)
je 0xd319f
movl 0x4c(%rsp), %eax
movl 0x48(%rsp), %ecx
movq 0x58(%rsp), %rdx
movq (%rdx), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
je 0xd31a4
jmp 0xd33b3
xorl %eax, %eax
cmpl $0x4, 0x54(%rsp)
movb %al, 0x2f(%rsp)
jne 0xd31cd
movl 0x4c(%rsp), %eax
movl 0x48(%rsp), %ecx
movq 0x58(%rsp), %rdx
movq (%rdx), %rdx
addl 0x8(%rdx), %ecx
cmpl %ecx, %eax
sete %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movl 0x40(%rsp), %ecx
xorl %eax, %eax
movl %eax, %edx
movq %rdx, %rsi
callq 0xd6450
movl 0x4c(%rsp), %eax
movb %al, %dl
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq $0x4, %rcx
movb %dl, (%rax,%rcx)
movl 0x4c(%rsp), %eax
shrl $0x8, %eax
movb %al, %dl
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq $0x3, %rcx
movb %dl, (%rax,%rcx)
movl 0x4c(%rsp), %eax
xorl $-0x1, %eax
movb %al, %dl
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq $0x2, %rcx
movb %dl, (%rax,%rcx)
movl 0x4c(%rsp), %eax
xorl $-0x1, %eax
shrl $0x8, %eax
movb %al, %dl
movq 0x58(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x58(%rsp), %rcx
movq 0x28(%rcx), %rcx
subq $0x1, %rcx
movb %dl, (%rax,%rcx)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0xd2f00
cmpl $0x0, 0x48(%rsp)
je 0xd333f
movl 0x48(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jbe 0xd32a9
movl 0x4c(%rsp), %eax
movl %eax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rdi
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x58(%rsp), %rax
addq 0x98(%rax), %rsi
movl 0x48(%rsp), %eax
movl %eax, %edx
callq 0xb500
movl 0x48(%rsp), %edx
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl 0x48(%rsp), %edx
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movl 0x48(%rsp), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
movq (%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
movl 0x48(%rsp), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movl 0x48(%rsp), %ecx
movl 0x4c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x4c(%rsp)
cmpl $0x0, 0x4c(%rsp)
je 0xd33a6
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rsi
movl 0x4c(%rsp), %edx
callq 0xd4910
movl 0x4c(%rsp), %edx
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movl %edx, %edx
addq %rdx, %rcx
movq %rcx, 0x18(%rax)
movl 0x4c(%rsp), %edx
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0x20(%rax)
movl 0x4c(%rsp), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
movq (%rax), %rax
addq 0x28(%rax), %rcx
movq %rcx, 0x28(%rax)
jmp 0xd33a8
cmpl $0x0, 0x40(%rsp)
je 0xd30c8
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %ecx
movl 0x3c(%rsp), %eax
subl %ecx, %eax
movl %eax, 0x3c(%rsp)
cmpl $0x0, 0x3c(%rsp)
je 0xd35cd
movl 0x3c(%rsp), %eax
movq 0x58(%rsp), %rcx
cmpl 0x50(%rcx), %eax
jb 0xd3453
movq 0x58(%rsp), %rax
movl $0x2, 0x1728(%rax)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, %edx
callq 0xb500
movq 0x58(%rsp), %rax
movl 0x50(%rax), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0xac(%rax)
movq 0x58(%rsp), %rax
movl 0xac(%rax), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x172c(%rax)
jmp 0xd35b4
movq 0x58(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x58(%rsp), %rcx
movl 0xac(%rcx), %ecx
subq %rcx, %rax
movl 0x3c(%rsp), %ecx
cmpq %rcx, %rax
ja 0xd3513
movq 0x58(%rsp), %rax
movl 0x50(%rax), %edx
movq 0x58(%rsp), %rax
movl 0xac(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xac(%rax)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
addq %rax, %rsi
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, %edx
callq 0xb500
movq 0x58(%rsp), %rax
cmpl $0x2, 0x1728(%rax)
jae 0xd34e3
movq 0x58(%rsp), %rax
movl 0x1728(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1728(%rax)
movq 0x58(%rsp), %rax
movl 0x172c(%rax), %eax
movq 0x58(%rsp), %rcx
cmpl 0xac(%rcx), %eax
jbe 0xd3511
movq 0x58(%rsp), %rax
movl 0xac(%rax), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x172c(%rax)
jmp 0xd3513
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
addq %rax, %rdi
movq 0x58(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rsi
movl 0x3c(%rsp), %eax
movl %eax, %ecx
xorl %eax, %eax
subq %rcx, %rax
addq %rax, %rsi
movl 0x3c(%rsp), %eax
movl %eax, %edx
callq 0xb500
movl 0x3c(%rsp), %ecx
movq 0x58(%rsp), %rax
addl 0xac(%rax), %ecx
movl %ecx, 0xac(%rax)
movl 0x3c(%rsp), %eax
movq 0x58(%rsp), %rcx
movl 0x50(%rcx), %ecx
movq 0x58(%rsp), %rdx
subl 0x172c(%rdx), %ecx
cmpl %ecx, %eax
jbe 0xd3597
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movq 0x58(%rsp), %rcx
subl 0x172c(%rcx), %eax
movl %eax, 0x28(%rsp)
jmp 0xd359f
movl 0x3c(%rsp), %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %ecx
movq 0x58(%rsp), %rax
addl 0x172c(%rax), %ecx
movl %ecx, 0x172c(%rax)
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
movq %rcx, 0x98(%rax)
movq 0x58(%rsp), %rax
movq 0x1738(%rax), %rax
movq 0x58(%rsp), %rcx
movl 0xac(%rcx), %ecx
cmpq %rcx, %rax
jae 0xd3602
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
movq %rcx, 0x1738(%rax)
cmpl $0x0, 0x40(%rsp)
je 0xd3616
movl $0x3, 0x64(%rsp)
jmp 0xd3a11
cmpl $0x0, 0x54(%rsp)
je 0xd3658
cmpl $0x4, 0x54(%rsp)
je 0xd3658
movq 0x58(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0xd3658
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movq 0x58(%rsp), %rcx
cmpq 0x98(%rcx), %rax
jne 0xd3658
movl $0x1, 0x64(%rsp)
jmp 0xd3a11
movq 0x58(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x58(%rsp), %rcx
movl 0xac(%rcx), %ecx
subq %rcx, %rax
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
cmpl 0x44(%rsp), %eax
jbe 0xd3771
movq 0x58(%rsp), %rax
movq 0x98(%rax), %rax
movq 0x58(%rsp), %rcx
movl 0x50(%rcx), %ecx
cmpq %rcx, %rax
jl 0xd3771
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, %edx
movq 0x58(%rsp), %rax
movq 0x98(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x98(%rax)
movq 0x58(%rsp), %rax
movl 0x50(%rax), %edx
movq 0x58(%rsp), %rax
movl 0xac(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xac(%rax)
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
addq %rax, %rsi
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, %edx
callq 0xb500
movq 0x58(%rsp), %rax
cmpl $0x2, 0x1728(%rax)
jae 0xd3731
movq 0x58(%rsp), %rax
movl 0x1728(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1728(%rax)
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rax
movl 0x172c(%rax), %eax
movq 0x58(%rsp), %rcx
cmpl 0xac(%rcx), %eax
jbe 0xd376f
movq 0x58(%rsp), %rax
movl 0xac(%rax), %ecx
movq 0x58(%rsp), %rax
movl %ecx, 0x172c(%rax)
jmp 0xd3771
movl 0x44(%rsp), %eax
movq 0x58(%rsp), %rcx
movq (%rcx), %rcx
cmpl 0x8(%rcx), %eax
jbe 0xd3791
movq 0x58(%rsp), %rax
movq (%rax), %rax
movl 0x8(%rax), %eax
movl %eax, 0x44(%rsp)
cmpl $0x0, 0x44(%rsp)
je 0xd382a
movq 0x58(%rsp), %rax
movq (%rax), %rdi
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
addq %rax, %rsi
movl 0x44(%rsp), %edx
callq 0xd4910
movl 0x44(%rsp), %ecx
movq 0x58(%rsp), %rax
addl 0xac(%rax), %ecx
movl %ecx, 0xac(%rax)
movl 0x44(%rsp), %eax
movq 0x58(%rsp), %rcx
movl 0x50(%rcx), %ecx
movq 0x58(%rsp), %rdx
subl 0x172c(%rdx), %ecx
cmpl %ecx, %eax
jbe 0xd380d
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movq 0x58(%rsp), %rcx
subl 0x172c(%rcx), %eax
movl %eax, 0x24(%rsp)
jmp 0xd3815
movl 0x44(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %ecx
movq 0x58(%rsp), %rax
addl 0x172c(%rax), %ecx
movl %ecx, 0x172c(%rax)
movq 0x58(%rsp), %rax
movq 0x1738(%rax), %rax
movq 0x58(%rsp), %rcx
movl 0xac(%rcx), %ecx
cmpq %rcx, %rax
jae 0xd385f
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
movq %rcx, 0x1738(%rax)
movq 0x58(%rsp), %rax
movl 0x1734(%rax), %eax
addl $0x2a, %eax
sarl $0x3, %eax
movl %eax, 0x44(%rsp)
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x44(%rsp), %ecx
subq %rcx, %rax
cmpq $0xffff, %rax           # imm = 0xFFFF
jbe 0xd3898
movl $0xffff, %eax           # imm = 0xFFFF
movq %rax, 0x18(%rsp)
jmp 0xd38ad
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x44(%rsp), %ecx
subq %rcx, %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x58(%rsp), %rcx
cmpl 0x50(%rcx), %eax
jbe 0xd38d2
movq 0x58(%rsp), %rax
movl 0x50(%rax), %eax
movl %eax, 0x14(%rsp)
jmp 0xd38da
movl 0x44(%rsp), %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movl 0xac(%rax), %eax
movq 0x58(%rsp), %rcx
subq 0x98(%rcx), %rax
movl %eax, 0x48(%rsp)
movl 0x48(%rsp), %eax
cmpl 0x50(%rsp), %eax
jae 0xd3944
cmpl $0x0, 0x48(%rsp)
jne 0xd3919
cmpl $0x4, 0x54(%rsp)
jne 0xd39fc
cmpl $0x0, 0x54(%rsp)
je 0xd39fc
movq 0x58(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, 0x8(%rax)
jne 0xd39fc
movl 0x48(%rsp), %eax
cmpl 0x44(%rsp), %eax
ja 0xd39fc
movl 0x48(%rsp), %eax
cmpl 0x44(%rsp), %eax
jbe 0xd3958
movl 0x44(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0xd3960
movl 0x48(%rsp), %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
movl %eax, 0x4c(%rsp)
xorl %eax, %eax
cmpl $0x4, 0x54(%rsp)
movb %al, 0xf(%rsp)
jne 0xd3998
movq 0x58(%rsp), %rax
movq (%rax), %rcx
xorl %eax, %eax
cmpl $0x0, 0x8(%rcx)
movb %al, 0xf(%rsp)
jne 0xd3998
movl 0x4c(%rsp), %eax
cmpl 0x48(%rsp), %eax
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x40(%rsp)
movq 0x58(%rsp), %rdi
movq 0x58(%rsp), %rax
movq 0x60(%rax), %rsi
movq 0x58(%rsp), %rax
addq 0x98(%rax), %rsi
movl 0x4c(%rsp), %eax
movl %eax, %edx
movl 0x40(%rsp), %ecx
callq 0xd6450
movl 0x4c(%rsp), %eax
movl %eax, %ecx
movq 0x58(%rsp), %rax
addq 0x98(%rax), %rcx
movq %rcx, 0x98(%rax)
movq 0x58(%rsp), %rax
movq (%rax), %rdi
callq 0xd2f00
movl 0x40(%rsp), %edx
xorl %eax, %eax
movl $0x2, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopw (%rax,%rax)