// File: /workspace/github_c_makefile_star2_O0/genometools[P]genometools/src/external/zlib-1.3.0.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:
subq $0xe8, %rsp
movq %rdi, 0xd8(%rsp)
movq %rsi, 0xd0(%rsp)
movq %rdx, 0xc8(%rsp)
cmpq $0x0, 0xd0(%rsp)
jne 0x107f9b
movq $0x0, 0xe0(%rsp)
jmp 0x108b78
movq 0xd8(%rsp), %rax
xorq $-0x1, %rax
movabsq $0xffffffff, %rcx       # imm = 0xFFFFFFFF
andq %rcx, %rax
movq %rax, 0xd8(%rsp)
cmpq $0x2f, 0xc8(%rsp)
jb 0x10885c
jmp 0x107fcd
xorl %eax, %eax
cmpq $0x0, 0xc8(%rsp)
movb %al, 0x7(%rsp)
je 0x107ff5
movq 0xd0(%rsp), %rax
andq $0x7, %rax
cmpq $0x0, %rax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x107fff
jmp 0x108065
movq 0xc8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xc8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x74d3e(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
jmp 0x107fcd
movq 0xc8(%rsp), %rax
movl $0x28, %ecx
xorl %edx, %edx
divq %rcx
movq %rax, 0xc0(%rsp)
imulq $0x5, 0xc0(%rsp), %rcx
shlq $0x3, %rcx
movq 0xc8(%rsp), %rax
subq %rcx, %rax
movq %rax, 0xc8(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0xb8(%rsp)
movl $0x1, 0xb4(%rsp)
cmpb $0x0, 0xb4(%rsp)
je 0x1084ad
movq 0xd8(%rsp), %rax
movl %eax, 0xac(%rsp)
movl $0x0, 0x9c(%rsp)
movl $0x0, 0x8c(%rsp)
movl $0x0, 0x7c(%rsp)
movl $0x0, 0x6c(%rsp)
movq 0xc0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xc0(%rsp)
cmpq $0x0, %rax
je 0x1083c7
movl 0xac(%rsp), %eax
movq 0xb8(%rsp), %rcx
xorq (%rcx), %rax
movq %rax, 0xa0(%rsp)
movl 0x9c(%rsp), %eax
movq 0xb8(%rsp), %rcx
xorq 0x8(%rcx), %rax
movq %rax, 0x90(%rsp)
movl 0x8c(%rsp), %eax
movq 0xb8(%rsp), %rcx
xorq 0x10(%rcx), %rax
movq %rax, 0x80(%rsp)
movl 0x7c(%rsp), %eax
movq 0xb8(%rsp), %rcx
xorq 0x18(%rcx), %rax
movq %rax, 0x70(%rsp)
movl 0x6c(%rsp), %eax
movq 0xb8(%rsp), %rcx
xorq 0x20(%rcx), %rax
movq %rax, 0x60(%rsp)
movq 0xb8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0xb8(%rsp)
movq 0xa0(%rsp), %rcx
andq $0xff, %rcx
leaq 0x74fd1(%rip), %rax     # 0x17d190
movl (%rax,%rcx,4), %eax
movl %eax, 0xac(%rsp)
movq 0x90(%rsp), %rcx
andq $0xff, %rcx
leaq 0x74fb1(%rip), %rax     # 0x17d190
movl (%rax,%rcx,4), %eax
movl %eax, 0x9c(%rsp)
movq 0x80(%rsp), %rcx
andq $0xff, %rcx
leaq 0x74f91(%rip), %rax     # 0x17d190
movl (%rax,%rcx,4), %eax
movl %eax, 0x8c(%rsp)
movq 0x70(%rsp), %rcx
andq $0xff, %rcx
leaq 0x74f74(%rip), %rax     # 0x17d190
movl (%rax,%rcx,4), %eax
movl %eax, 0x7c(%rsp)
movq 0x60(%rsp), %rcx
andq $0xff, %rcx
leaq 0x74f5a(%rip), %rax     # 0x17d190
movl (%rax,%rcx,4), %eax
movl %eax, 0x6c(%rsp)
movl $0x1, 0xb0(%rsp)
cmpl $0x8, 0xb0(%rsp)
jge 0x1083c2
movslq 0xb0(%rsp), %rcx
leaq 0x74f2b(%rip), %rax     # 0x17d190
shlq $0xa, %rcx
addq %rcx, %rax
movq 0xa0(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl 0xac(%rsp), %eax
movl %eax, 0xac(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x74ee3(%rip), %rax     # 0x17d190
shlq $0xa, %rcx
addq %rcx, %rax
movq 0x90(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl 0x9c(%rsp), %eax
movl %eax, 0x9c(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x74e9b(%rip), %rax     # 0x17d190
shlq $0xa, %rcx
addq %rcx, %rax
movq 0x80(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl 0x8c(%rsp), %eax
movl %eax, 0x8c(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x74e53(%rip), %rax     # 0x17d190
shlq $0xa, %rcx
addq %rcx, %rax
movq 0x70(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl 0x7c(%rsp), %eax
movl %eax, 0x7c(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x74e14(%rip), %rax     # 0x17d190
shlq $0xa, %rcx
addq %rcx, %rax
movq 0x60(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movl (%rax,%rcx,4), %eax
xorl 0x6c(%rsp), %eax
movl %eax, 0x6c(%rsp)
movl 0xb0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb0(%rsp)
jmp 0x108248
jmp 0x1080fd
movl 0xac(%rsp), %eax
movl %eax, %edi
movq 0xb8(%rsp), %rax
xorq (%rax), %rdi
callq 0x108b90
movl %eax, %eax
movq %rax, 0xd8(%rsp)
movl 0x9c(%rsp), %eax
movl %eax, %edi
movq 0xb8(%rsp), %rax
xorq 0x8(%rax), %rdi
xorq 0xd8(%rsp), %rdi
callq 0x108b90
movl %eax, %eax
movq %rax, 0xd8(%rsp)
movl 0x8c(%rsp), %eax
movl %eax, %edi
movq 0xb8(%rsp), %rax
xorq 0x10(%rax), %rdi
xorq 0xd8(%rsp), %rdi
callq 0x108b90
movl %eax, %eax
movq %rax, 0xd8(%rsp)
movl 0x7c(%rsp), %eax
movl %eax, %edi
movq 0xb8(%rsp), %rax
xorq 0x18(%rax), %rdi
xorq 0xd8(%rsp), %rdi
callq 0x108b90
movl %eax, %eax
movq %rax, 0xd8(%rsp)
movl 0x6c(%rsp), %eax
movl %eax, %edi
movq 0xb8(%rsp), %rax
xorq 0x20(%rax), %rdi
xorq 0xd8(%rsp), %rdi
callq 0x108b90
movl %eax, %eax
movq %rax, 0xd8(%rsp)
movq 0xb8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0xb8(%rsp)
jmp 0x10884c
movq 0xd8(%rsp), %rdi
callq 0x108be0
movq %rax, 0x58(%rsp)
movq $0x0, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0xc0(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xc0(%rsp)
cmpq $0x0, %rax
je 0x10878c
movq 0x58(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorq (%rcx), %rax
movq %rax, 0x50(%rsp)
movq 0x40(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorq 0x8(%rcx), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorq 0x10(%rcx), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorq 0x18(%rcx), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0xb8(%rsp), %rcx
xorq 0x20(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0xb8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0xb8(%rsp)
movq 0x50(%rsp), %rcx
andq $0xff, %rcx
leaq 0x76bfb(%rip), %rax     # 0x17f190
movq (%rax,%rcx,8), %rax
movq %rax, 0x58(%rsp)
movq 0x38(%rsp), %rcx
andq $0xff, %rcx
leaq 0x76bdf(%rip), %rax     # 0x17f190
movq (%rax,%rcx,8), %rax
movq %rax, 0x40(%rsp)
movq 0x28(%rsp), %rcx
andq $0xff, %rcx
leaq 0x76bc3(%rip), %rax     # 0x17f190
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rcx
andq $0xff, %rcx
leaq 0x76ba7(%rip), %rax     # 0x17f190
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rcx
andq $0xff, %rcx
leaq 0x76b8b(%rip), %rax     # 0x17f190
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0xb0(%rsp)
cmpl $0x8, 0xb0(%rsp)
jge 0x108787
movslq 0xb0(%rsp), %rcx
leaq 0x76b5a(%rip), %rax     # 0x17f190
shlq $0xb, %rcx
addq %rcx, %rax
movq 0x50(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq 0x58(%rsp), %rax
movq %rax, 0x58(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x76b18(%rip), %rax     # 0x17f190
shlq $0xb, %rcx
addq %rcx, %rax
movq 0x38(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq 0x40(%rsp), %rax
movq %rax, 0x40(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x76ad6(%rip), %rax     # 0x17f190
shlq $0xb, %rcx
addq %rcx, %rax
movq 0x28(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq 0x30(%rsp), %rax
movq %rax, 0x30(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x76a94(%rip), %rax     # 0x17f190
shlq $0xb, %rcx
addq %rcx, %rax
movq 0x18(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
movslq 0xb0(%rsp), %rcx
leaq 0x76a52(%rip), %rax     # 0x17f190
shlq $0xb, %rcx
addq %rcx, %rax
movq 0x8(%rsp), %rdx
movl 0xb0(%rsp), %ecx
shll $0x3, %ecx
movl %ecx, %ecx
shrq %cl, %rdx
movq %rdx, %rcx
andq $0xff, %rcx
movq (%rax,%rcx,8), %rax
xorq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xb0(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xb0(%rsp)
jmp 0x108619
jmp 0x1084e3
movq 0x58(%rsp), %rdi
movq 0xb8(%rsp), %rax
xorq (%rax), %rdi
callq 0x108c90
movq %rax, 0x48(%rsp)
movq 0x40(%rsp), %rdi
movq 0xb8(%rsp), %rax
xorq 0x8(%rax), %rdi
xorq 0x48(%rsp), %rdi
callq 0x108c90
movq %rax, 0x48(%rsp)
movq 0x30(%rsp), %rdi
movq 0xb8(%rsp), %rax
xorq 0x10(%rax), %rdi
xorq 0x48(%rsp), %rdi
callq 0x108c90
movq %rax, 0x48(%rsp)
movq 0x20(%rsp), %rdi
movq 0xb8(%rsp), %rax
xorq 0x18(%rax), %rdi
xorq 0x48(%rsp), %rdi
callq 0x108c90
movq %rax, 0x48(%rsp)
movq 0x10(%rsp), %rdi
movq 0xb8(%rsp), %rax
xorq 0x20(%rax), %rdi
xorq 0x48(%rsp), %rdi
callq 0x108c90
movq %rax, 0x48(%rsp)
movq 0xb8(%rsp), %rax
addq $0x28, %rax
movq %rax, 0xb8(%rsp)
movq 0x48(%rsp), %rdi
callq 0x108be0
movq %rax, 0xd8(%rsp)
movq 0xb8(%rsp), %rax
movq %rax, 0xd0(%rsp)
jmp 0x10885e
cmpq $0x8, 0xc8(%rsp)
jb 0x108aee
movq 0xc8(%rsp), %rax
subq $0x8, %rax
movq %rax, 0xc8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x744d0(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x74483(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x74436(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x743e9(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x7439c(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x7434f(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x74302(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x742b5(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
jmp 0x10885e
jmp 0x108af0
cmpq $0x0, 0xc8(%rsp)
je 0x108b5e
movq 0xc8(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0xc8(%rsp)
movq 0xd8(%rsp), %rax
shrq $0x8, %rax
movq 0xd8(%rsp), %rdx
movq 0xd0(%rsp), %rcx
movq %rcx, %rsi
addq $0x1, %rsi
movq %rsi, 0xd0(%rsp)
movzbl (%rcx), %ecx
xorq %rcx, %rdx
andq $0xff, %rdx
leaq 0x74242(%rip), %rcx     # 0x17cd90
movl (%rcx,%rdx,4), %ecx
xorq %rcx, %rax
movq %rax, 0xd8(%rsp)
jmp 0x108af0
movabsq $0xffffffff, %rax       # imm = 0xFFFFFFFF
xorq 0xd8(%rsp), %rax
movq %rax, 0xe0(%rsp)
movq 0xe0(%rsp), %rax
addq $0xe8, %rsp
retq
nopl (%rax,%rax)