// File: tomfunkhouser[P]gaps/pkgs/png/deflate.c
// Function: deflate
int ZEXPORT deflate (strm, flush)
    z_streamp strm;
    int flush;
{
    int old_flush; /* value of flush param for previous deflate call */
    deflate_state *s;

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

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

    s->strm = strm; /* just in case */
    old_flush = s->last_flush;
    s->last_flush = flush;

    /* Write the header */
    if (s->status == INIT_STATE) {
#ifdef GZIP
        if (s->wrap == 2) {
            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;
            }
            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;
            }
        }
        else
#endif
        {
            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);

            s->status = BUSY_STATE;
            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);
        }
    }
#ifdef GZIP
    if (s->status == EXTRA_STATE) {
        if (s->gzhead->extra != Z_NULL) {
            uInt beg = s->pending;  /* start of bytes to update crc */

            while (s->gzindex < (s->gzhead->extra_len & 0xffff)) {
                if (s->pending == s->pending_buf_size) {
                    if (s->gzhead->hcrc && s->pending > beg)
                        strm->adler = crc32(strm->adler, s->pending_buf + beg,
                                            s->pending - beg);
                    flush_pending(strm);
                    beg = s->pending;
                    if (s->pending == s->pending_buf_size)
                        break;
                }
                put_byte(s, s->gzhead->extra[s->gzindex]);
                s->gzindex++;
            }
            if (s->gzhead->hcrc && s->pending > beg)
                strm->adler = crc32(strm->adler, s->pending_buf + beg,
                                    s->pending - beg);
            if (s->gzindex == s->gzhead->extra_len) {
                s->gzindex = 0;
                s->status = NAME_STATE;
            }
        }
        else
            s->status = NAME_STATE;
    }
    if (s->status == NAME_STATE) {
        if (s->gzhead->name != Z_NULL) {
            uInt beg = s->pending;  /* start of bytes to update crc */
            int val;

            do {
                if (s->pending == s->pending_buf_size) {
                    if (s->gzhead->hcrc && s->pending > beg)
                        strm->adler = crc32(strm->adler, s->pending_buf + beg,
                                            s->pending - beg);
                    flush_pending(strm);
                    beg = s->pending;
                    if (s->pending == s->pending_buf_size) {
                        val = 1;
                        break;
                    }
                }
                val = s->gzhead->name[s->gzindex++];
                put_byte(s, val);
            } while (val != 0);
            if (s->gzhead->hcrc && s->pending > beg)
                strm->adler = crc32(strm->adler, s->pending_buf + beg,
                                    s->pending - beg);
            if (val == 0) {
                s->gzindex = 0;
                s->status = COMMENT_STATE;
            }
        }
        else
            s->status = COMMENT_STATE;
    }
    if (s->status == COMMENT_STATE) {
        if (s->gzhead->comment != Z_NULL) {
            uInt beg = s->pending;  /* start of bytes to update crc */
            int val;

            do {
                if (s->pending == s->pending_buf_size) {
                    if (s->gzhead->hcrc && s->pending > beg)
                        strm->adler = crc32(strm->adler, s->pending_buf + beg,
                                            s->pending - beg);
                    flush_pending(strm);
                    beg = s->pending;
                    if (s->pending == s->pending_buf_size) {
                        val = 1;
                        break;
                    }
                }
                val = s->gzhead->comment[s->gzindex++];
                put_byte(s, val);
            } while (val != 0);
            if (s->gzhead->hcrc && s->pending > beg)
                strm->adler = crc32(strm->adler, s->pending_buf + beg,
                                    s->pending - beg);
            if (val == 0)
                s->status = HCRC_STATE;
        }
        else
            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 + 2 <= s->pending_buf_size) {
                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;
            }
        }
        else
            s->status = BUSY_STATE;
    }
#endif

    /* 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 && flush <= 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);
    }

    /* 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->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;
                    }
                }
            }
            flush_pending(strm);
            if (strm->avail_out == 0) {
              s->last_flush = -1; /* avoid BUF_ERROR at next call, see above */
              return Z_OK;
            }
        }
    }
    Assert(strm->avail_out > 0, "bug2");

    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:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
cmpq $0x0, 0x48(%rsp)
je 0x115caf
movq 0x48(%rsp), %rax
cmpq $0x0, 0x38(%rax)
je 0x115caf
cmpl $0x5, 0x44(%rsp)
jg 0x115caf
cmpl $0x0, 0x44(%rsp)
jge 0x115cbc
movl $0xfffffffe, 0x54(%rsp) # imm = 0xFFFFFFFE
jmp 0x116e62
movq 0x48(%rsp), %rax
movq 0x38(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x115d01
movq 0x48(%rsp), %rax
cmpq $0x0, (%rax)
jne 0x115cec
movq 0x48(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x115d01
movq 0x38(%rsp), %rax
cmpl $0x29a, 0x8(%rax)       # imm = 0x29A
jne 0x115d22
cmpl $0x4, 0x44(%rsp)
je 0x115d22
leaq 0x58fe8(%rip), %rax     # 0x16ecf0
movq 0x20(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0xfffffffe, 0x54(%rsp) # imm = 0xFFFFFFFE
jmp 0x116e62
movq 0x48(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x115d4e
leaq 0x58fbc(%rip), %rax     # 0x16ecf0
movq 0x38(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0xfffffffb, 0x54(%rsp) # imm = 0xFFFFFFFB
jmp 0x116e62
movq 0x48(%rsp), %rcx
movq 0x38(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movl 0x40(%rax), %eax
movl %eax, 0x40(%rsp)
movl 0x44(%rsp), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x40(%rax)
movq 0x38(%rsp), %rax
cmpl $0x2a, 0x8(%rax)
jne 0x11638a
movq 0x38(%rsp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0x116254
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x1f, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $-0x75, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x8, (%rax,%rcx)
movq 0x38(%rsp), %rax
cmpq $0x0, 0x30(%rax)
jne 0x115f5c
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x0, (%rax,%rcx)
movq 0x38(%rsp), %rax
cmpl $0x9, 0xb4(%rax)
jne 0x115ecc
movl $0x2, %eax
movl %eax, 0x14(%rsp)
jmp 0x115f08
movq 0x38(%rsp), %rcx
movb $0x1, %al
cmpl $0x2, 0xb8(%rcx)
movb %al, 0x13(%rsp)
jge 0x115ef3
movq 0x38(%rsp), %rax
cmpl $0x2, 0xb4(%rax)
setl %al
movb %al, 0x13(%rsp)
movb 0x13(%rsp), %dl
xorl %eax, %eax
movl $0x4, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x28(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x28(%rdx)
movl %ecx, %ecx
movb $0x3, (%rax,%rcx)
movq 0x38(%rsp), %rax
movl $0x71, 0x8(%rax)
jmp 0x11624f
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rcx
movl 0x44(%rcx), %esi
xorl %ecx, %ecx
movl $0x2, %edx
cmpl $0x0, %esi
cmovnel %edx, %ecx
addl %ecx, %eax
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x18(%rcx), %rsi
movl $0x4, %ecx
xorl %edx, %edx
cmpq $0x0, %rsi
cmovel %edx, %ecx
addl %ecx, %eax
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x28(%rcx), %rsi
movl $0x8, %ecx
xorl %edx, %edx
cmpq $0x0, %rsi
cmovel %edx, %ecx
addl %ecx, %eax
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rcx
movq 0x38(%rcx), %rsi
movl $0x10, %ecx
xorl %edx, %edx
cmpq $0x0, %rsi
cmovel %edx, %ecx
addl %ecx, %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
cmpl $0x9, 0xb4(%rax)
jne 0x1160f7
movl $0x2, %eax
movl %eax, 0xc(%rsp)
jmp 0x116133
movq 0x38(%rsp), %rcx
movb $0x1, %al
cmpl $0x2, 0xb8(%rcx)
movb %al, 0xb(%rsp)
jge 0x11611e
movq 0x38(%rsp), %rax
cmpl $0x2, 0xb4(%rax)
setl %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %dl
xorl %eax, %eax
movl $0x4, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x14(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x1161fd
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x20(%rax), %eax
andl $0xff, %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movl 0x20(%rax), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x116237
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x38(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x38(%rsp), %rax
movl $0x45, 0x8(%rax)
jmp 0x116388
movq 0x38(%rsp), %rax
movl 0x48(%rax), %eax
subl $0x8, %eax
shll $0x4, %eax
addl $0x8, %eax
shll $0x8, %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x2, 0xb8(%rax)
jge 0x116288
movq 0x38(%rsp), %rax
cmpl $0x2, 0xb4(%rax)
jge 0x116292
movl $0x0, 0x30(%rsp)
jmp 0x1162ce
movq 0x38(%rsp), %rax
cmpl $0x6, 0xb4(%rax)
jge 0x1162aa
movl $0x1, 0x30(%rsp)
jmp 0x1162cc
movq 0x38(%rsp), %rax
cmpl $0x6, 0xb4(%rax)
jne 0x1162c2
movl $0x2, 0x30(%rsp)
jmp 0x1162ca
movl $0x3, 0x30(%rsp)
jmp 0x1162cc
jmp 0x1162ce
movl 0x30(%rsp), %eax
shll $0x6, %eax
orl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x1162f6
movl 0x34(%rsp), %eax
orl $0x20, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
movl $0x1f, %ecx
xorl %edx, %edx
divl %ecx
movl $0x1f, %eax
subl %edx, %eax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rax
movl $0x71, 0x8(%rax)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x117130
movq 0x38(%rsp), %rax
cmpl $0x0, 0x9c(%rax)
je 0x11636e
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
shrq $0x10, %rax
movl %eax, %esi
callq 0x117130
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %esi
callq 0x117130
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x131400
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
jmp 0x11638a
movq 0x38(%rsp), %rax
cmpl $0x45, 0x8(%rax)
jne 0x11654c
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x18(%rax)
je 0x11653e
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movl 0x38(%rax), %eax
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rcx
movl 0x20(%rcx), %ecx
andl $0xffff, %ecx           # imm = 0xFFFF
cmpl %ecx, %eax
jae 0x1164bb
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x116472
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x116445
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x2c(%rsp), %eax
jbe 0x116445
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x2c(%rsp), %eax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
subl 0x2c(%rsp), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x116470
jmp 0x1164bb
jmp 0x116472
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x18(%rax), %rax
movq 0x38(%rsp), %rcx
movl 0x38(%rcx), %ecx
movb (%rax,%rcx), %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x38(%rsp), %rax
movl 0x38(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x38(%rax)
jmp 0x1163b9
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x11650e
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x2c(%rsp), %eax
jbe 0x11650e
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x2c(%rsp), %eax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
subl 0x2c(%rsp), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x38(%rsp), %rax
movl 0x38(%rax), %eax
movq 0x38(%rsp), %rcx
movq 0x30(%rcx), %rcx
cmpl 0x20(%rcx), %eax
jne 0x11653c
movq 0x38(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x38(%rsp), %rax
movl $0x49, 0x8(%rax)
jmp 0x11654a
movq 0x38(%rsp), %rax
movl $0x49, 0x8(%rax)
jmp 0x11654c
movq 0x38(%rsp), %rax
cmpl $0x49, 0x8(%rax)
jne 0x1166f2
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x28(%rax)
je 0x1166e4
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x11661a
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x1165e5
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x28(%rsp), %eax
jbe 0x1165e5
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x28(%rsp), %eax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
subl 0x28(%rsp), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x116618
movl $0x1, 0x24(%rsp)
jmp 0x116670
jmp 0x11661a
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x28(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x38(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x38(%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
cmpl $0x0, 0x24(%rsp)
jne 0x11657b
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x1166c3
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x28(%rsp), %eax
jbe 0x1166c3
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x28(%rsp), %eax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
subl 0x28(%rsp), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
cmpl $0x0, 0x24(%rsp)
jne 0x1166e2
movq 0x38(%rsp), %rax
movl $0x0, 0x38(%rax)
movq 0x38(%rsp), %rax
movl $0x5b, 0x8(%rax)
jmp 0x1166f0
movq 0x38(%rsp), %rax
movl $0x5b, 0x8(%rax)
jmp 0x1166f2
movq 0x38(%rsp), %rax
cmpl $0x5b, 0x8(%rax)
jne 0x11688c
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x38(%rax)
je 0x11687e
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x1167c0
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x11678b
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x20(%rsp), %eax
jbe 0x11678b
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x20(%rsp), %eax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
subl 0x20(%rsp), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jne 0x1167be
movl $0x1, 0x1c(%rsp)
jmp 0x116816
jmp 0x1167c0
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rax
movq 0x38(%rsp), %rdx
movl 0x38(%rdx), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0x38(%rdx)
movl %ecx, %ecx
movzbl (%rax,%rcx), %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
cmpl $0x0, 0x1c(%rsp)
jne 0x116721
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x116869
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
cmpl 0x20(%rsp), %eax
jbe 0x116869
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
movl 0x20(%rsp), %eax
addq %rax, %rsi
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
subl 0x20(%rsp), %edx
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
cmpl $0x0, 0x1c(%rsp)
jne 0x11687c
movq 0x38(%rsp), %rax
movl $0x67, 0x8(%rax)
jmp 0x11688a
movq 0x38(%rsp), %rax
movl $0x67, 0x8(%rax)
jmp 0x11688c
movq 0x38(%rsp), %rax
cmpl $0x67, 0x8(%rax)
jne 0x116984
movq 0x38(%rsp), %rax
movq 0x30(%rax), %rax
cmpl $0x0, 0x44(%rax)
je 0x116976
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
jbe 0x1168d0
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x38(%rsp), %rax
movl 0x28(%rax), %eax
addl $0x2, %eax
movl %eax, %eax
movq 0x38(%rsp), %rcx
cmpq 0x18(%rcx), %rax
ja 0x116974
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
xorl %eax, %eax
movl %eax, %esi
xorl %edx, %edx
movq %rsi, %rdi
callq 0x113da0
movq %rax, %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x60(%rax)
movq 0x38(%rsp), %rax
movl $0x71, 0x8(%rax)
jmp 0x116982
movq 0x38(%rsp), %rax
movl $0x71, 0x8(%rax)
jmp 0x116984
movq 0x38(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x1169bf
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x48(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x1169bd
movq 0x38(%rsp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x54(%rsp)
jmp 0x116e62
jmp 0x1169fe
movq 0x48(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x1169fc
movl 0x44(%rsp), %eax
cmpl 0x40(%rsp), %eax
jg 0x1169fc
cmpl $0x4, 0x44(%rsp)
je 0x1169fc
leaq 0x5830e(%rip), %rax     # 0x16ecf0
movq 0x38(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0xfffffffb, 0x54(%rsp) # imm = 0xFFFFFFFB
jmp 0x116e62
jmp 0x1169fe
movq 0x38(%rsp), %rax
cmpl $0x29a, 0x8(%rax)       # imm = 0x29A
jne 0x116a38
movq 0x48(%rsp), %rax
cmpl $0x0, 0x8(%rax)
je 0x116a38
leaq 0x582d2(%rip), %rax     # 0x16ecf0
movq 0x38(%rax), %rcx
movq 0x48(%rsp), %rax
movq %rcx, 0x30(%rax)
movl $0xfffffffb, 0x54(%rsp) # imm = 0xFFFFFFFB
jmp 0x116e62
movq 0x48(%rsp), %rax
cmpl $0x0, 0x8(%rax)
jne 0x116a6e
movq 0x38(%rsp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x116a6e
cmpl $0x0, 0x44(%rsp)
je 0x116c21
movq 0x38(%rsp), %rax
cmpl $0x29a, 0x8(%rax)       # imm = 0x29A
je 0x116c21
movq 0x38(%rsp), %rax
cmpl $0x2, 0xb8(%rax)
jne 0x116a90
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x117290
movl %eax, 0x4(%rsp)
jmp 0x116ae4
movq 0x38(%rsp), %rax
cmpl $0x3, 0xb8(%rax)
jne 0x116ab1
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
callq 0x117570
movl %eax, (%rsp)
jmp 0x116add
movq 0x38(%rsp), %rax
movslq 0xb4(%rax), %rcx
leaq 0x5818c(%rip), %rax     # 0x16ec50
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq 0x38(%rsp), %rdi
movl 0x44(%rsp), %esi
callq *%rax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl %eax, 0x18(%rsp)
cmpl $0x2, 0x18(%rsp)
je 0x116afa
cmpl $0x3, 0x18(%rsp)
jne 0x116b06
movq 0x38(%rsp), %rax
movl $0x29a, 0x8(%rax)       # imm = 0x29A
cmpl $0x0, 0x18(%rsp)
je 0x116b14
cmpl $0x2, 0x18(%rsp)
jne 0x116b38
movq 0x48(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x116b2b
movq 0x38(%rsp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x54(%rsp)
jmp 0x116e62
cmpl $0x1, 0x18(%rsp)
jne 0x116c1f
cmpl $0x1, 0x44(%rsp)
jne 0x116b59
movq 0x38(%rsp), %rdi
callq 0x11f0b0
jmp 0x116bef
cmpl $0x5, 0x44(%rsp)
je 0x116bed
movq 0x38(%rsp), %rdi
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
movq %rdx, %rsi
callq 0x11edf0
cmpl $0x3, 0x44(%rsp)
jne 0x116beb
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rax
movq 0x38(%rsp), %rcx
movl 0x74(%rcx), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
movw $0x0, (%rax,%rcx,2)
movq 0x38(%rsp), %rax
movq 0x68(%rax), %rdi
movq 0x38(%rsp), %rax
movl 0x74(%rax), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %edx
shlq %rdx
xorl %esi, %esi
callq 0xf280
movq 0x38(%rsp), %rax
cmpl $0x0, 0xa4(%rax)
jne 0x116be9
movq 0x38(%rsp), %rax
movl $0x0, 0x9c(%rax)
movq 0x38(%rsp), %rax
movq $0x0, 0x88(%rax)
jmp 0x116beb
jmp 0x116bed
jmp 0x116bef
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x48(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jne 0x116c1d
movq 0x38(%rsp), %rax
movl $0xffffffff, 0x40(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x54(%rsp)
jmp 0x116e62
jmp 0x116c1f
jmp 0x116c21
cmpl $0x4, 0x44(%rsp)
je 0x116c35
movl $0x0, 0x54(%rsp)
jmp 0x116e62
movq 0x38(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jg 0x116c4d
movl $0x1, 0x54(%rsp)
jmp 0x116e62
movq 0x38(%rsp), %rax
cmpl $0x2, 0x2c(%rax)
jne 0x116dee
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
shrq $0x8, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
shrq $0x10, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
shrq $0x18, %rax
andq $0xff, %rax
movb %al, %dl
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rsi
movl 0x28(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x28(%rsi)
movl %ecx, %ecx
movb %dl, (%rax,%rcx)
jmp 0x116e22
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
shrq $0x10, %rax
movl %eax, %esi
callq 0x117130
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x60(%rax), %rax
andq $0xffff, %rax           # imm = 0xFFFF
movl %eax, %esi
callq 0x117130
movq 0x48(%rsp), %rdi
callq 0x117190
movq 0x38(%rsp), %rax
cmpl $0x0, 0x2c(%rax)
jle 0x116e49
movq 0x38(%rsp), %rax
xorl %ecx, %ecx
subl 0x2c(%rax), %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x2c(%rax)
movq 0x38(%rsp), %rax
movl 0x28(%rax), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovnel %ecx, %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)