// File: sisong[P]ApkDiffPatch/zlib1.3.1/crc32.c
// Function: crc32_z
unsigned long ZEXPORT crc32_z(unsigned long crc, const unsigned char FAR *buf,
                              z_size_t len) {
    /* Return initial CRC, if requested. */
    if (buf == Z_NULL) return 0;

#ifdef DYNAMIC_CRC_TABLE
    once(&made, make_crc_table);
#endif /* DYNAMIC_CRC_TABLE */

    /* Pre-condition the CRC */
    crc = (~crc) & 0xffffffff;

#ifdef W

    /* If provided enough bytes, do a braided CRC calculation. */
    if (len >= N * W + W - 1) {
        z_size_t blks;
        z_word_t const *words;
        unsigned endian;
        int k;

        /* Compute the CRC up to a z_word_t boundary. */
        while (len && ((z_size_t)buf & (W - 1)) != 0) {
            len--;
            crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        }

        /* Compute the CRC on as many N z_word_t blocks as are available. */
        blks = len / (N * W);
        len -= blks * N * W;
        words = (z_word_t const *)buf;

        /* Do endian check at execution time instead of compile time, since ARM
           processors can change the endianness at execution time. If the
           compiler knows what the endianness will be, it can optimize out the
           check and the unused branch. */
        endian = 1;
        if (*(unsigned char *)&endian) {
            /* Little endian. */

            z_crc_t crc0;
            z_word_t word0;
#if N > 1
            z_crc_t crc1;
            z_word_t word1;
#if N > 2
            z_crc_t crc2;
            z_word_t word2;
#if N > 3
            z_crc_t crc3;
            z_word_t word3;
#if N > 4
            z_crc_t crc4;
            z_word_t word4;
#if N > 5
            z_crc_t crc5;
            z_word_t word5;
#endif
#endif
#endif
#endif
#endif

            /* Initialize the CRC for each braid. */
            crc0 = crc;
#if N > 1
            crc1 = 0;
#if N > 2
            crc2 = 0;
#if N > 3
            crc3 = 0;
#if N > 4
            crc4 = 0;
#if N > 5
            crc5 = 0;
#endif
#endif
#endif
#endif
#endif

            /*
              Process the first blks-1 blocks, computing the CRCs on each braid
              independently.
             */
            while (--blks) {
                /* Load the word for each braid into registers. */
                word0 = crc0 ^ words[0];
#if N > 1
                word1 = crc1 ^ words[1];
#if N > 2
                word2 = crc2 ^ words[2];
#if N > 3
                word3 = crc3 ^ words[3];
#if N > 4
                word4 = crc4 ^ words[4];
#if N > 5
                word5 = crc5 ^ words[5];
#endif
#endif
#endif
#endif
#endif
                words += N;

                /* Compute and update the CRC for each word. The loop should
                   get unrolled. */
                crc0 = crc_braid_table[0][word0 & 0xff];
#if N > 1
                crc1 = crc_braid_table[0][word1 & 0xff];
#if N > 2
                crc2 = crc_braid_table[0][word2 & 0xff];
#if N > 3
                crc3 = crc_braid_table[0][word3 & 0xff];
#if N > 4
                crc4 = crc_braid_table[0][word4 & 0xff];
#if N > 5
                crc5 = crc_braid_table[0][word5 & 0xff];
#endif
#endif
#endif
#endif
#endif
                for (k = 1; k < W; k++) {
                    crc0 ^= crc_braid_table[k][(word0 >> (k << 3)) & 0xff];
#if N > 1
                    crc1 ^= crc_braid_table[k][(word1 >> (k << 3)) & 0xff];
#if N > 2
                    crc2 ^= crc_braid_table[k][(word2 >> (k << 3)) & 0xff];
#if N > 3
                    crc3 ^= crc_braid_table[k][(word3 >> (k << 3)) & 0xff];
#if N > 4
                    crc4 ^= crc_braid_table[k][(word4 >> (k << 3)) & 0xff];
#if N > 5
                    crc5 ^= crc_braid_table[k][(word5 >> (k << 3)) & 0xff];
#endif
#endif
#endif
#endif
#endif
                }
            }

            /*
              Process the last block, combining the CRCs of the N braids at the
              same time.
             */
            crc = crc_word(crc0 ^ words[0]);
#if N > 1
            crc = crc_word(crc1 ^ words[1] ^ crc);
#if N > 2
            crc = crc_word(crc2 ^ words[2] ^ crc);
#if N > 3
            crc = crc_word(crc3 ^ words[3] ^ crc);
#if N > 4
            crc = crc_word(crc4 ^ words[4] ^ crc);
#if N > 5
            crc = crc_word(crc5 ^ words[5] ^ crc);
#endif
#endif
#endif
#endif
#endif
            words += N;
        }
        else {
            /* Big endian. */

            z_word_t crc0, word0, comb;
#if N > 1
            z_word_t crc1, word1;
#if N > 2
            z_word_t crc2, word2;
#if N > 3
            z_word_t crc3, word3;
#if N > 4
            z_word_t crc4, word4;
#if N > 5
            z_word_t crc5, word5;
#endif
#endif
#endif
#endif
#endif

            /* Initialize the CRC for each braid. */
            crc0 = byte_swap(crc);
#if N > 1
            crc1 = 0;
#if N > 2
            crc2 = 0;
#if N > 3
            crc3 = 0;
#if N > 4
            crc4 = 0;
#if N > 5
            crc5 = 0;
#endif
#endif
#endif
#endif
#endif

            /*
              Process the first blks-1 blocks, computing the CRCs on each braid
              independently.
             */
            while (--blks) {
                /* Load the word for each braid into registers. */
                word0 = crc0 ^ words[0];
#if N > 1
                word1 = crc1 ^ words[1];
#if N > 2
                word2 = crc2 ^ words[2];
#if N > 3
                word3 = crc3 ^ words[3];
#if N > 4
                word4 = crc4 ^ words[4];
#if N > 5
                word5 = crc5 ^ words[5];
#endif
#endif
#endif
#endif
#endif
                words += N;

                /* Compute and update the CRC for each word. The loop should
                   get unrolled. */
                crc0 = crc_braid_big_table[0][word0 & 0xff];
#if N > 1
                crc1 = crc_braid_big_table[0][word1 & 0xff];
#if N > 2
                crc2 = crc_braid_big_table[0][word2 & 0xff];
#if N > 3
                crc3 = crc_braid_big_table[0][word3 & 0xff];
#if N > 4
                crc4 = crc_braid_big_table[0][word4 & 0xff];
#if N > 5
                crc5 = crc_braid_big_table[0][word5 & 0xff];
#endif
#endif
#endif
#endif
#endif
                for (k = 1; k < W; k++) {
                    crc0 ^= crc_braid_big_table[k][(word0 >> (k << 3)) & 0xff];
#if N > 1
                    crc1 ^= crc_braid_big_table[k][(word1 >> (k << 3)) & 0xff];
#if N > 2
                    crc2 ^= crc_braid_big_table[k][(word2 >> (k << 3)) & 0xff];
#if N > 3
                    crc3 ^= crc_braid_big_table[k][(word3 >> (k << 3)) & 0xff];
#if N > 4
                    crc4 ^= crc_braid_big_table[k][(word4 >> (k << 3)) & 0xff];
#if N > 5
                    crc5 ^= crc_braid_big_table[k][(word5 >> (k << 3)) & 0xff];
#endif
#endif
#endif
#endif
#endif
                }
            }

            /*
              Process the last block, combining the CRCs of the N braids at the
              same time.
             */
            comb = crc_word_big(crc0 ^ words[0]);
#if N > 1
            comb = crc_word_big(crc1 ^ words[1] ^ comb);
#if N > 2
            comb = crc_word_big(crc2 ^ words[2] ^ comb);
#if N > 3
            comb = crc_word_big(crc3 ^ words[3] ^ comb);
#if N > 4
            comb = crc_word_big(crc4 ^ words[4] ^ comb);
#if N > 5
            comb = crc_word_big(crc5 ^ words[5] ^ comb);
#endif
#endif
#endif
#endif
#endif
            words += N;
            crc = byte_swap(comb);
        }

        /*
          Update the pointer to the remaining bytes to process.
         */
        buf = (unsigned char const *)words;
    }

#endif /* W */

    /* Complete the computation of the CRC on any remaining bytes. */
    while (len >= 8) {
        len -= 8;
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
    }
    while (len) {
        len--;
        crc = (crc >> 8) ^ crc_table[(crc ^ *buf++) & 0xff];
    }

    /* Return the CRC, post-conditioned. */
    return crc ^ 0xffffffff;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x91f1b
movq $0x0, -0x8(%rbp)
jmp 0x928a4
movq -0x10(%rbp), %rax
xorq $-0x1, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x2f, -0x20(%rbp)
jb 0x9265c
jmp 0x91f41
xorl %eax, %eax
cmpq $0x0, -0x20(%rbp)
movb %al, -0xe1(%rbp)
je 0x91f65
movq -0x18(%rbp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
setne %al
movb %al, -0xe1(%rbp)
movb -0xe1(%rbp), %al
testb $0x1, %al
jne 0x91f71
jmp 0x91fb8
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x23f14(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x91f41
movq -0x20(%rbp), %rax
movl $0x28, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, -0x28(%rbp)
imulq $0x5, -0x28(%rbp), %rcx
shlq $0x3, %rcx
movq -0x20(%rbp), %rax
subq %rcx, %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x34(%rbp)
cmpb $0x0, -0x34(%rbp)
je 0x922c7
movq -0x10(%rbp), %rax
movl %eax, -0x3c(%rbp)
movl $0x0, -0x4c(%rbp)
movl $0x0, -0x5c(%rbp)
movl $0x0, -0x6c(%rbp)
movl $0x0, -0x7c(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x9222f
movl -0x3c(%rbp), %eax
movq -0x30(%rbp), %rcx
xorq (%rcx), %rax
movq %rax, -0x48(%rbp)
movl -0x4c(%rbp), %eax
movq -0x30(%rbp), %rcx
xorq 0x8(%rcx), %rax
movq %rax, -0x58(%rbp)
movl -0x5c(%rbp), %eax
movq -0x30(%rbp), %rcx
xorq 0x10(%rcx), %rax
movq %rax, -0x68(%rbp)
movl -0x6c(%rbp), %eax
movq -0x30(%rbp), %rcx
xorq 0x18(%rcx), %rax
movq %rax, -0x78(%rbp)
movl -0x7c(%rbp), %eax
movq -0x30(%rbp), %rcx
xorq 0x20(%rcx), %rax
movq %rax, -0x88(%rbp)
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x48(%rbp), %rcx
andq $0xff, %rcx
leaq 0x24225(%rip), %rax     # 0xb62c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x3c(%rbp)
movq -0x58(%rbp), %rcx
andq $0xff, %rcx
leaq 0x2420d(%rip), %rax     # 0xb62c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x4c(%rbp)
movq -0x68(%rbp), %rcx
andq $0xff, %rcx
leaq 0x241f5(%rip), %rax     # 0xb62c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x5c(%rbp)
movq -0x78(%rbp), %rcx
andq $0xff, %rcx
leaq 0x241dd(%rip), %rax     # 0xb62c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x6c(%rbp)
movq -0x88(%rbp), %rcx
andq $0xff, %rcx
leaq 0x241c2(%rip), %rax     # 0xb62c0
movl (%rax,%rcx,4), %eax
movl %eax, -0x7c(%rbp)
movl $0x1, -0x38(%rbp)
cmpl $0x8, -0x38(%rbp)
jge 0x9222a
movslq -0x38(%rbp), %rcx
leaq 0x241a0(%rip), %rax     # 0xb62c0
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x48(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl -0x3c(%rbp), %eax
movl %eax, -0x3c(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x2416c(%rip), %rax     # 0xb62c0
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x58(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl -0x4c(%rbp), %eax
movl %eax, -0x4c(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x24138(%rip), %rax     # 0xb62c0
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x68(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl -0x5c(%rbp), %eax
movl %eax, -0x5c(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x24104(%rip), %rax     # 0xb62c0
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x78(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl -0x6c(%rbp), %eax
movl %eax, -0x6c(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x240d0(%rip), %rax     # 0xb62c0
shlq $0xa, %rcx
addq %rcx, %rax
movq -0x88(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl -0x7c(%rbp), %eax
movl %eax, -0x7c(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x9210b
jmp 0x9201a
movl -0x3c(%rbp), %eax
movl %eax, %edi
movq -0x30(%rbp), %rax
xorq (%rax), %rdi
callq 0x928c0
movl %eax, %eax
movq %rax, -0x10(%rbp)
movl -0x4c(%rbp), %eax
movl %eax, %edi
movq -0x30(%rbp), %rax
xorq 0x8(%rax), %rdi
xorq -0x10(%rbp), %rdi
callq 0x928c0
movl %eax, %eax
movq %rax, -0x10(%rbp)
movl -0x5c(%rbp), %eax
movl %eax, %edi
movq -0x30(%rbp), %rax
xorq 0x10(%rax), %rdi
xorq -0x10(%rbp), %rdi
callq 0x928c0
movl %eax, %eax
movq %rax, -0x10(%rbp)
movl -0x6c(%rbp), %eax
movl %eax, %edi
movq -0x30(%rbp), %rax
xorq 0x18(%rax), %rdi
xorq -0x10(%rbp), %rdi
callq 0x928c0
movl %eax, %eax
movq %rax, -0x10(%rbp)
movl -0x7c(%rbp), %eax
movl %eax, %edi
movq -0x30(%rbp), %rax
xorq 0x20(%rax), %rdi
xorq -0x10(%rbp), %rdi
callq 0x928c0
movl %eax, %eax
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
jmp 0x92654
movq -0x10(%rbp), %rdi
callq 0x92910
movq %rax, -0x90(%rbp)
movq $0x0, -0xa8(%rbp)
movq $0x0, -0xb8(%rbp)
movq $0x0, -0xc8(%rbp)
movq $0x0, -0xd8(%rbp)
movq -0x28(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0x92596
movq -0x90(%rbp), %rax
movq -0x30(%rbp), %rcx
xorq (%rcx), %rax
movq %rax, -0x98(%rbp)
movq -0xa8(%rbp), %rax
movq -0x30(%rbp), %rcx
xorq 0x8(%rcx), %rax
movq %rax, -0xb0(%rbp)
movq -0xb8(%rbp), %rax
movq -0x30(%rbp), %rcx
xorq 0x10(%rcx), %rax
movq %rax, -0xc0(%rbp)
movq -0xc8(%rbp), %rax
movq -0x30(%rbp), %rcx
xorq 0x18(%rcx), %rax
movq %rax, -0xd0(%rbp)
movq -0xd8(%rbp), %rax
movq -0x30(%rbp), %rcx
xorq 0x20(%rcx), %rax
movq %rax, -0xe0(%rbp)
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0x98(%rbp), %rcx
andq $0xff, %rcx
leaq 0x25f19(%rip), %rax     # 0xb82c0
movq (%rax,%rcx,8), %rax
movq %rax, -0x90(%rbp)
movq -0xb0(%rbp), %rcx
andq $0xff, %rcx
leaq 0x25ef9(%rip), %rax     # 0xb82c0
movq (%rax,%rcx,8), %rax
movq %rax, -0xa8(%rbp)
movq -0xc0(%rbp), %rcx
andq $0xff, %rcx
leaq 0x25ed9(%rip), %rax     # 0xb82c0
movq (%rax,%rcx,8), %rax
movq %rax, -0xb8(%rbp)
movq -0xd0(%rbp), %rcx
andq $0xff, %rcx
leaq 0x25eb9(%rip), %rax     # 0xb82c0
movq (%rax,%rcx,8), %rax
movq %rax, -0xc8(%rbp)
movq -0xe0(%rbp), %rcx
andq $0xff, %rcx
leaq 0x25e99(%rip), %rax     # 0xb82c0
movq (%rax,%rcx,8), %rax
movq %rax, -0xd8(%rbp)
movl $0x1, -0x38(%rbp)
cmpl $0x8, -0x38(%rbp)
jge 0x92591
movslq -0x38(%rbp), %rcx
leaq 0x25e72(%rip), %rax     # 0xb82c0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0x98(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq -0x90(%rbp), %rax
movq %rax, -0x90(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x25e32(%rip), %rax     # 0xb82c0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0xb0(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq -0xa8(%rbp), %rax
movq %rax, -0xa8(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x25df2(%rip), %rax     # 0xb82c0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0xc0(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq -0xb8(%rbp), %rax
movq %rax, -0xb8(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x25db2(%rip), %rax     # 0xb82c0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0xd0(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq -0xc8(%rbp), %rax
movq %rax, -0xc8(%rbp)
movslq -0x38(%rbp), %rcx
leaq 0x25d72(%rip), %rax     # 0xb82c0
shlq $0xb, %rcx
addq %rcx, %rax
movq -0xe0(%rbp), %rdx
movl -0x38(%rbp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq -0xd8(%rbp), %rax
movq %rax, -0xd8(%rbp)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x92439
jmp 0x92303
movq -0x90(%rbp), %rdi
movq -0x30(%rbp), %rax
xorq (%rax), %rdi
callq 0x929c0
movq %rax, -0xa0(%rbp)
movq -0xa8(%rbp), %rdi
movq -0x30(%rbp), %rax
xorq 0x8(%rax), %rdi
xorq -0xa0(%rbp), %rdi
callq 0x929c0
movq %rax, -0xa0(%rbp)
movq -0xb8(%rbp), %rdi
movq -0x30(%rbp), %rax
xorq 0x10(%rax), %rdi
xorq -0xa0(%rbp), %rdi
callq 0x929c0
movq %rax, -0xa0(%rbp)
movq -0xc8(%rbp), %rdi
movq -0x30(%rbp), %rax
xorq 0x18(%rax), %rdi
xorq -0xa0(%rbp), %rdi
callq 0x929c0
movq %rax, -0xa0(%rbp)
movq -0xd8(%rbp), %rdi
movq -0x30(%rbp), %rax
xorq 0x20(%rax), %rdi
xorq -0xa0(%rbp), %rdi
callq 0x929c0
movq %rax, -0xa0(%rbp)
movq -0x30(%rbp), %rax
addq $0x28, %rax
movq %rax, -0x30(%rbp)
movq -0xa0(%rbp), %rdi
callq 0x92910
movq %rax, -0x10(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
jmp 0x9265e
cmpq $0x8, -0x20(%rbp)
jb 0x92842
movq -0x20(%rbp), %rax
subq $0x8, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x2381c(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x237e3(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x237aa(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x23771(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x23738(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x236ff(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x236c6(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x2368d(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x9265e
jmp 0x92844
cmpq $0x0, -0x20(%rbp)
je 0x92892
movq -0x20(%rbp), %rax
addq $-0x1, %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
shrq $0x8, %rax
movq -0x10(%rbp), %rdx
movq -0x18(%rbp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, -0x18(%rbp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x2363a(%rip), %rcx     # 0xb5ec0
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, -0x10(%rbp)
jmp 0x92844
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
xorq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0xf0, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)