#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef scalar_t__ out;
typedef scalar_t__ hlist;
typedef int /*<<< orphan*/ hash_table;
typedef int /*<<< orphan*/ data;

/* Variables and functions */
int /*<<< orphan*/ assert(int);
int /*<<< orphan*/ free(int *);
int /*<<< orphan*/ memcpy(unsigned char **, unsigned char **, int);
int /*<<< orphan*/ memmove(int *, unsigned char *, int);
int /*<<< orphan*/ stbi__sbgrowf(void **, int, int);
int stbi__zhash(unsigned char *);
int stbi__zlib_bitrev(int, int);
int stbi__zlib_countm(unsigned char *, unsigned char *, int);
unsigned char *stbi__zlib_flushf(unsigned char *, unsigned int *, int *);
unsigned char *stbi_zlib_compress(unsigned char *data, int data_len,
                                  int *out_len, int quality) {
  static unsigned short lengthc[] = {
      3,  4,  5,  6,  7,  8,  9,  10, 11,  13,  15,  17,  19,  23,  27,
      31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 259};
  static unsigned char lengtheb[] = {0, 0, 0, 0, 0, 0, 0, 0, 1, 1,
                                     1, 1, 2, 2, 2, 2, 3, 3, 3, 3,
                                     4, 4, 4, 4, 5, 5, 5, 5, 0};
  static unsigned short distc[] = {
      1,    2,    3,    4,    5,    7,     9,     13,    17,   25,   33,
      49,   65,   97,   129,  193,  257,   385,   513,   769,  1025, 1537,
      2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 32768};
  static unsigned char disteb[] = {0, 0, 0,  0,  1,  1,  2,  2,  3,  3,
                                   4, 4, 5,  5,  6,  6,  7,  7,  8,  8,
                                   9, 9, 10, 10, 11, 11, 12, 12, 13, 13};
  unsigned int bitbuf = 0;
  int i, j, bitcount = 0;
  unsigned char *out = NULL;
  unsigned char **hash_table[16384];
  if (quality < 5)
    quality = 5;
  ((((out) == 0 || ((int *)(out)-2)[1] + (1) >= ((int *)(out)-2)[0])
        ? stbi__sbgrowf((void **)&(out), (1), sizeof(*(out)))
        : 0),
   (out)[((int *)(out)-2)[1]++] = (0x78));
  ((((out) == 0 || ((int *)(out)-2)[1] + (1) >= ((int *)(out)-2)[0])
        ? stbi__sbgrowf((void **)&(out), (1), sizeof(*(out)))
        : 0),
   (out)[((int *)(out)-2)[1]++] = (0x5e));
  (bitbuf |= (1) << bitcount, bitcount += (1),
   (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)));
  (bitbuf |= (1) << bitcount, bitcount += (2),
   (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)));
  for (i = 0; i < 16384; ++i)
    hash_table[i] = NULL;
  i = 0;
  while (i < data_len - 3) {
    int h = stbi__zhash(data + i) & (16384 - 1), best = 3;
    unsigned char *bestloc = 0;
    unsigned char **hlist = hash_table[h];
    int n = ((hlist) ? ((int *)(hlist)-2)[1] : 0);
    for (j = 0; j < n; ++j) {
      if (hlist[j] - data > i - 32768) {
        int d = stbi__zlib_countm(hlist[j], data + i, data_len - i);
        if (d >= best)
          best = d, bestloc = hlist[j];
      }
    }
    if (hash_table[h] && ((int *)(hash_table[h]) - 2)[1] == 2 * quality) {
      memcpy(hash_table[h], hash_table[h] + quality,
             sizeof(hash_table[h][0]) * quality);
      ((int *)(hash_table[h]) - 2)[1] = quality;
    }
    ((((hash_table[h]) == 0 ||
       ((int *)(hash_table[h]) - 2)[1] + (1) >= ((int *)(hash_table[h]) - 2)[0])
          ? stbi__sbgrowf((void **)&(hash_table[h]), (1),
                          sizeof(*(hash_table[h])))
          : 0),
     (hash_table[h])[((int *)(hash_table[h]) - 2)[1]++] = (data + i));
    if (bestloc) {
      h = stbi__zhash(data + i + 1) & (16384 - 1);
      hlist = hash_table[h];
      n = ((hlist) ? ((int *)(hlist)-2)[1] : 0);
      for (j = 0; j < n; ++j) {
        if (hlist[j] - data > i - 32767) {
          int e = stbi__zlib_countm(hlist[j], data + i + 1, data_len - i - 1);
          if (e > best) {
            bestloc = NULL;
            break;
          }
        }
      }
    }
    if (bestloc) {
      int d = (int)(data + i - bestloc);
      assert(d <= 32767 && best <= 258);
      for (j = 0; best > lengthc[j + 1] - 1; ++j)
        ;
      ((j + 257) <= 143
           ? (bitbuf |= (stbi__zlib_bitrev(0x30 + (j + 257), 8)) << bitcount,
              bitcount += (8),
              (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
       : (j + 257) <= 255
           ? (bitbuf |= (stbi__zlib_bitrev(0x190 + (j + 257) - 144, 9))
                        << bitcount,
              bitcount += (9),
              (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
       : (j + 257) <= 279
           ? (bitbuf |= (stbi__zlib_bitrev(0 + (j + 257) - 256, 7)) << bitcount,
              bitcount += (7),
              (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
           : (bitbuf |= (stbi__zlib_bitrev(0xc0 + (j + 257) - 280, 8))
                        << bitcount,
              bitcount += (8),
              (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))));
      if (lengtheb[j])
        (bitbuf |= (best - lengthc[j]) << bitcount, bitcount += (lengtheb[j]),
         (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)));
      for (j = 0; d > distc[j + 1] - 1; ++j)
        ;
      (bitbuf |= (stbi__zlib_bitrev(j, 5)) << bitcount, bitcount += (5),
       (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)));
      if (disteb[j])
        (bitbuf |= (d - distc[j]) << bitcount, bitcount += (disteb[j]),
         (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)));
      i += best;
    } else {
      ((data[i]) <= 143
           ? (bitbuf |= (stbi__zlib_bitrev(0x30 + (data[i]), 8)) << bitcount,
              bitcount += (8),
              (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
           : (bitbuf |= (stbi__zlib_bitrev(0x190 + (data[i]) - 144, 9))
                        << bitcount,
              bitcount += (9),
              (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))));
      ++i;
    }
  }
  for (; i < data_len; ++i)
    ((data[i]) <= 143
         ? (bitbuf |= (stbi__zlib_bitrev(0x30 + (data[i]), 8)) << bitcount,
            bitcount += (8), (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
         : (bitbuf |= (stbi__zlib_bitrev(0x190 + (data[i]) - 144, 9))
                      << bitcount,
            bitcount += (9),
            (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))));
  ((256) <= 143
       ? (bitbuf |= (stbi__zlib_bitrev(0x30 + (256), 8)) << bitcount,
          bitcount += (8), (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
   : (256) <= 255
       ? (bitbuf |= (stbi__zlib_bitrev(0x190 + (256) - 144, 9)) << bitcount,
          bitcount += (9), (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
   : (256) <= 279
       ? (bitbuf |= (stbi__zlib_bitrev(0 + (256) - 256, 7)) << bitcount,
          bitcount += (7), (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)))
       : (bitbuf |= (stbi__zlib_bitrev(0xc0 + (256) - 280, 8)) << bitcount,
          bitcount += (8), (out = stbi__zlib_flushf(out, &bitbuf, &bitcount))));
  while (bitcount)
    (bitbuf |= (0) << bitcount, bitcount += (1),
     (out = stbi__zlib_flushf(out, &bitbuf, &bitcount)));
  for (i = 0; i < 16384; ++i)
    (void)((hash_table[i]) ? free(((int *)(hash_table[i]) - 2)), 0 : 0);
  {
    unsigned int i = 0, s1 = 1, s2 = 0, blocklen = data_len % 5552;
    int j = 0;
    while (j < data_len) {
      for (i = 0; i < blocklen; ++i)
        s1 += data[j + i], s2 += s1;
      s1 %= 65521, s2 %= 65521;
      j += blocklen;
      blocklen = 5552;
    }
    ((((out) == 0 || ((int *)(out)-2)[1] + (1) >= ((int *)(out)-2)[0])
          ? stbi__sbgrowf((void **)&(out), (1), sizeof(*(out)))
          : 0),
     (out)[((int *)(out)-2)[1]++] = ((unsigned char)(s2 >> 8)));
    ((((out) == 0 || ((int *)(out)-2)[1] + (1) >= ((int *)(out)-2)[0])
          ? stbi__sbgrowf((void **)&(out), (1), sizeof(*(out)))
          : 0),
     (out)[((int *)(out)-2)[1]++] = ((unsigned char)s2));
    ((((out) == 0 || ((int *)(out)-2)[1] + (1) >= ((int *)(out)-2)[0])
          ? stbi__sbgrowf((void **)&(out), (1), sizeof(*(out)))
          : 0),
     (out)[((int *)(out)-2)[1]++] = ((unsigned char)(s1 >> 8)));
    ((((out) == 0 || ((int *)(out)-2)[1] + (1) >= ((int *)(out)-2)[0])
          ? stbi__sbgrowf((void **)&(out), (1), sizeof(*(out)))
          : 0),
     (out)[((int *)(out)-2)[1]++] = ((unsigned char)s1));
  }
  *out_len = ((int *)(out)-2)[1];
  memmove(((int *)(out)-2), out, *out_len);
  return (unsigned char *)((int *)(out)-2);
}


x86 assembly (clang, -O0):
<stbi_zlib_compress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x200a0,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x2c(%rbp)
movq   $0x0,-0x38(%rbp)
cmpl   $0x5,-0x1c(%rbp)
jge    11d0 <stbi_zlib_compress+0x40>
movl   $0x5,-0x1c(%rbp)
cmpq   $0x0,-0x38(%rbp)
je     11f2 <stbi_zlib_compress+0x62>
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    -0x8(%rcx),%eax
jl     1207 <stbi_zlib_compress+0x77>
lea    -0x38(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1080 <stbi__sbgrowf@plt>
jmp    120c <stbi_zlib_compress+0x7c>
jmp    120c <stbi_zlib_compress+0x7c>
mov    -0x38(%rbp),%rax
mov    -0x38(%rbp),%rdx
mov    -0x4(%rdx),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x4(%rdx)
movslq %ecx,%rcx
movb   $0x78,(%rax,%rcx,1)
cmpq   $0x0,-0x38(%rbp)
je     1248 <stbi_zlib_compress+0xb8>
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    -0x8(%rcx),%eax
jl     125d <stbi_zlib_compress+0xcd>
lea    -0x38(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1080 <stbi__sbgrowf@plt>
jmp    1262 <stbi_zlib_compress+0xd2>
jmp    1262 <stbi_zlib_compress+0xd2>
mov    -0x38(%rbp),%rax
mov    -0x38(%rbp),%rdx
mov    -0x4(%rdx),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x4(%rdx)
movslq %ecx,%rcx
movb   $0x5e,(%rax,%rcx,1)
mov    -0x2c(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    -0x2c(%rbp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x4000,-0x24(%rbp)
jge    130a <stbi_zlib_compress+0x17a>
movslq -0x24(%rbp),%rax
movq   $0x0,-0x20040(%rbp,%rax,8)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    12df <stbi_zlib_compress+0x14f>
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0xc(%rbp),%ecx
sub    $0x3,%ecx
cmp    %ecx,%eax
jge    1ae4 <stbi_zlib_compress+0x954>
mov    -0x8(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
call   1050 <stbi__zhash@plt>
and    $0x3fff,%eax
mov    %eax,-0x20044(%rbp)
movl   $0x3,-0x20048(%rbp)
movq   $0x0,-0x20050(%rbp)
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rax
ff
mov    %rax,-0x20058(%rbp)
cmpq   $0x0,-0x20058(%rbp)
je     138b <stbi_zlib_compress+0x1fb>
mov    -0x20058(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x20080(%rbp)
jmp    1398 <stbi_zlib_compress+0x208>
xor    %eax,%eax
mov    %eax,-0x20080(%rbp)
jmp    1398 <stbi_zlib_compress+0x208>
mov    -0x20080(%rbp),%eax
mov    %eax,-0x2005c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2005c(%rbp),%eax
jge    145c <stbi_zlib_compress+0x2cc>
mov    -0x20058(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x8000,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    1449 <stbi_zlib_compress+0x2b9>
mov    -0x20058(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x24(%rbp),%rax
add    %rax,%rsi
mov    -0xc(%rbp),%edx
sub    -0x24(%rbp),%edx
call   1060 <stbi__zlib_countm@plt>
mov    %eax,-0x20060(%rbp)
mov    -0x20060(%rbp),%eax
cmp    -0x20048(%rbp),%eax
jl     1444 <stbi_zlib_compress+0x2b4>
mov    -0x20060(%rbp),%eax
mov    %eax,-0x20048(%rbp)
mov    -0x20058(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x20050(%rbp)
jmp    1449 <stbi_zlib_compress+0x2b9>
jmp    144e <stbi_zlib_compress+0x2be>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    13ab <stbi_zlib_compress+0x21b>
movslq -0x20044(%rbp),%rax
cmpq   $0x0,-0x20040(%rbp,%rax,8)
je     14df <stbi_zlib_compress+0x34f>
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rax
ff
mov    -0x4(%rax),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x1,%ecx
cmp    %ecx,%eax
jne    14df <stbi_zlib_compress+0x34f>
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rdi
ff
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rsi
ff
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
add    %rax,%rsi
movslq -0x1c(%rbp),%rax
shl    $0x3,%rax
mov    %eax,%edx
call   1090 <memcpy@plt>
mov    -0x1c(%rbp),%ecx
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rax
ff
mov    %ecx,-0x4(%rax)
movslq -0x20044(%rbp),%rax
cmpq   $0x0,-0x20040(%rbp,%rax,8)
je     1522 <stbi_zlib_compress+0x392>
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rax
ff
mov    -0x4(%rax),%eax
add    $0x1,%eax
movslq -0x20044(%rbp),%rcx
mov    -0x20040(%rbp,%rcx,8),%rcx
ff
cmp    -0x8(%rcx),%eax
jl     154b <stbi_zlib_compress+0x3bb>
movslq -0x20044(%rbp),%rax
lea    -0x20040(%rbp),%rdi
shl    $0x3,%rax
add    %rax,%rdi
mov    $0x1,%esi
mov    $0x8,%edx
call   1080 <stbi__sbgrowf@plt>
jmp    1550 <stbi_zlib_compress+0x3c0>
jmp    1550 <stbi_zlib_compress+0x3c0>
mov    -0x8(%rbp),%rdx
movslq -0x24(%rbp),%rax
add    %rax,%rdx
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rax
ff
movslq -0x20044(%rbp),%rcx
mov    -0x20040(%rbp,%rcx,8),%rsi
ff
mov    -0x4(%rsi),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x4(%rsi)
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
cmpq   $0x0,-0x20050(%rbp)
je     16bc <stbi_zlib_compress+0x52c>
mov    -0x8(%rbp),%rdi
movslq -0x24(%rbp),%rax
add    %rax,%rdi
add    $0x1,%rdi
call   1050 <stbi__zhash@plt>
and    $0x3fff,%eax
mov    %eax,-0x20044(%rbp)
movslq -0x20044(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rax
ff
mov    %rax,-0x20058(%rbp)
cmpq   $0x0,-0x20058(%rbp)
je     15f1 <stbi_zlib_compress+0x461>
mov    -0x20058(%rbp),%rax
mov    -0x4(%rax),%eax
mov    %eax,-0x20084(%rbp)
jmp    15fe <stbi_zlib_compress+0x46e>
xor    %eax,%eax
mov    %eax,-0x20084(%rbp)
jmp    15fe <stbi_zlib_compress+0x46e>
mov    -0x20084(%rbp),%eax
mov    %eax,-0x2005c(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x2005c(%rbp),%eax
jge    16b7 <stbi_zlib_compress+0x527>
mov    -0x20058(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x8(%rbp),%rcx
sub    %rcx,%rax
mov    -0x24(%rbp),%ecx
sub    $0x7fff,%ecx
movslq %ecx,%rcx
cmp    %rcx,%rax
jle    16a4 <stbi_zlib_compress+0x514>
mov    -0x20058(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x8(%rbp),%rsi
movslq -0x24(%rbp),%rax
add    %rax,%rsi
add    $0x1,%rsi
mov    -0xc(%rbp),%edx
sub    -0x24(%rbp),%edx
sub    $0x1,%edx
call   1060 <stbi__zlib_countm@plt>
mov    %eax,-0x20064(%rbp)
mov    -0x20064(%rbp),%eax
cmp    -0x20048(%rbp),%eax
jle    169f <stbi_zlib_compress+0x50f>
movq   $0x0,-0x20050(%rbp)
jmp    16b7 <stbi_zlib_compress+0x527>
jmp    16a4 <stbi_zlib_compress+0x514>
jmp    16a9 <stbi_zlib_compress+0x519>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1611 <stbi_zlib_compress+0x481>
jmp    16bc <stbi_zlib_compress+0x52c>
cmpq   $0x0,-0x20050(%rbp)
je     1a2d <stbi_zlib_compress+0x89d>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
add    %rcx,%rax
mov    -0x20050(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x20068(%rbp)
xor    %eax,%eax
cmpl   $0x7fff,-0x20068(%rbp)
mov    %al,-0x20085(%rbp)
jg     1710 <stbi_zlib_compress+0x580>
cmpl   $0x102,-0x20048(%rbp)
setle  %al
mov    %al,-0x20085(%rbp)
mov    -0x20085(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1070 <assert@plt>
movl   $0x0,-0x28(%rbp)
mov    -0x20048(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    0x2933(%rip),%rcx
movzwl (%rcx,%rdx,2),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    175f <stbi_zlib_compress+0x5cf>
jmp    1751 <stbi_zlib_compress+0x5c1>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    1727 <stbi_zlib_compress+0x597>
mov    -0x28(%rbp),%eax
add    $0x101,%eax
cmp    $0x8f,%eax
jg     17b6 <stbi_zlib_compress+0x626>
mov    -0x28(%rbp),%edi
add    $0x101,%edi
add    $0x30,%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
jmp    18e5 <stbi_zlib_compress+0x755>
mov    -0x28(%rbp),%eax
add    $0x101,%eax
cmp    $0xff,%eax
jg     181d <stbi_zlib_compress+0x68d>
mov    -0x28(%rbp),%edi
add    $0x101,%edi
add    $0x190,%edi
sub    $0x90,%edi
mov    $0x9,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x9,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    %rax,-0x20090(%rbp)
jmp    18de <stbi_zlib_compress+0x74e>
mov    -0x28(%rbp),%eax
add    $0x101,%eax
cmp    $0x117,%eax
jg     1881 <stbi_zlib_compress+0x6f1>
mov    -0x28(%rbp),%edi
add    $0x101,%edi
add    $0x0,%edi
sub    $0x100,%edi
mov    $0x7,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    %rax,-0x20098(%rbp)
jmp    18d0 <stbi_zlib_compress+0x740>
mov    -0x28(%rbp),%edi
add    $0x101,%edi
add    $0xc0,%edi
sub    $0x118,%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    %rax,-0x20098(%rbp)
mov    -0x20098(%rbp),%rax
mov    %rax,-0x20090(%rbp)
mov    -0x20090(%rbp),%rax
movslq -0x28(%rbp),%rcx
lea    0x27c0(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1946 <stbi_zlib_compress+0x7b6>
mov    -0x20048(%rbp),%eax
movslq -0x28(%rbp),%rdx
lea    0x2765(%rip),%rcx
movzwl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
movslq -0x28(%rbp),%rcx
lea    0x2789(%rip),%rax
movzbl (%rax,%rcx,1),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x20068(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
movslq %ecx,%rdx
lea    0x276d(%rip),%rcx
movzwl (%rcx,%rdx,2),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jle    1985 <stbi_zlib_compress+0x7f5>
jmp    1977 <stbi_zlib_compress+0x7e7>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    194d <stbi_zlib_compress+0x7bd>
mov    -0x28(%rbp),%edi
mov    $0x5,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x5,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
movslq -0x28(%rbp),%rcx
lea    0x274a(%rip),%rax
cmpb   $0x0,(%rax,%rcx,1)
je     1a1c <stbi_zlib_compress+0x88c>
mov    -0x20068(%rbp),%eax
movslq -0x28(%rbp),%rdx
lea    0x26ef(%rip),%rcx
movzwl (%rcx,%rdx,2),%ecx
sub    %ecx,%eax
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
movslq -0x28(%rbp),%rcx
lea    0x2713(%rip),%rax
movzbl (%rax,%rcx,1),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    -0x20048(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1adf <stbi_zlib_compress+0x94f>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x8f,%eax
jg     1a8b <stbi_zlib_compress+0x8fb>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
add    $0x30,%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
jmp    1ad6 <stbi_zlib_compress+0x946>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
add    $0x190,%edi
sub    $0x90,%edi
mov    $0x9,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x9,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1311 <stbi_zlib_compress+0x181>
jmp    1ae9 <stbi_zlib_compress+0x959>
mov    -0x24(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1bac <stbi_zlib_compress+0xa1c>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
cmp    $0x8f,%eax
jg     1b53 <stbi_zlib_compress+0x9c3>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
add    $0x30,%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x8,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
jmp    1b9e <stbi_zlib_compress+0xa0e>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%edi
add    $0x190,%edi
sub    $0x90,%edi
mov    $0x9,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x9,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1ae9 <stbi_zlib_compress+0x959>
xor    %edi,%edi
mov    $0x7,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    -0x2c(%rbp),%ecx
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x7,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
cmpl   $0x0,-0x2c(%rbp)
je     1c1b <stbi_zlib_compress+0xa8b>
mov    -0x2c(%rbp),%ecx
xor    %eax,%eax
shl    %cl,%eax
or     -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x38(%rbp),%rdi
lea    -0x20(%rbp),%rsi
lea    -0x2c(%rbp),%rdx
call   10b0 <stbi__zlib_flushf@plt>
mov    %rax,-0x38(%rbp)
jmp    1be1 <stbi_zlib_compress+0xa51>
movl   $0x0,-0x24(%rbp)
cmpl   $0x4000,-0x24(%rbp)
jge    1c6f <stbi_zlib_compress+0xadf>
movslq -0x24(%rbp),%rax
cmpq   $0x0,-0x20040(%rbp,%rax,8)
je     1c5c <stbi_zlib_compress+0xacc>
movslq -0x24(%rbp),%rax
mov    -0x20040(%rbp,%rax,8),%rdi
ff
add    $0xfffffffffffffff8,%rdi
call   1030 <free@plt>
jmp    1c61 <stbi_zlib_compress+0xad1>
jmp    1c61 <stbi_zlib_compress+0xad1>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1c22 <stbi_zlib_compress+0xa92>
movl   $0x0,-0x2006c(%rbp)
movl   $0x1,-0x20070(%rbp)
movl   $0x0,-0x20074(%rbp)
mov    -0xc(%rbp),%eax
mov    $0x15b0,%ecx
cltd
idiv   %ecx
mov    %edx,-0x20078(%rbp)
movl   $0x0,-0x2007c(%rbp)
mov    -0x2007c(%rbp),%eax
cmp    -0xc(%rbp),%eax
jge    1d66 <stbi_zlib_compress+0xbd6>
movl   $0x0,-0x2006c(%rbp)
mov    -0x2006c(%rbp),%eax
cmp    -0x20078(%rbp),%eax
jae    1d1b <stbi_zlib_compress+0xb8b>
mov    -0x8(%rbp),%rax
mov    -0x2007c(%rbp),%ecx
add    -0x2006c(%rbp),%ecx
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
add    -0x20070(%rbp),%eax
mov    %eax,-0x20070(%rbp)
mov    -0x20070(%rbp),%eax
add    -0x20074(%rbp),%eax
mov    %eax,-0x20074(%rbp)
mov    -0x2006c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x2006c(%rbp)
jmp    1cc1 <stbi_zlib_compress+0xb31>
mov    -0x20070(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,-0x20070(%rbp)
mov    -0x20074(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,-0x20074(%rbp)
mov    -0x20078(%rbp),%eax
add    -0x2007c(%rbp),%eax
mov    %eax,-0x2007c(%rbp)
movl   $0x15b0,-0x20078(%rbp)
jmp    1ca8 <stbi_zlib_compress+0xb18>
cmpq   $0x0,-0x38(%rbp)
je     1d88 <stbi_zlib_compress+0xbf8>
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    -0x8(%rcx),%eax
jl     1d9d <stbi_zlib_compress+0xc0d>
lea    -0x38(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1080 <stbi__sbgrowf@plt>
jmp    1da2 <stbi_zlib_compress+0xc12>
jmp    1da2 <stbi_zlib_compress+0xc12>
mov    -0x20074(%rbp),%eax
shr    $0x8,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x38(%rbp),%rsi
mov    -0x4(%rsi),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x4(%rsi)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
cmpq   $0x0,-0x38(%rbp)
je     1de8 <stbi_zlib_compress+0xc58>
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    -0x8(%rcx),%eax
jl     1dfd <stbi_zlib_compress+0xc6d>
lea    -0x38(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1080 <stbi__sbgrowf@plt>
jmp    1e02 <stbi_zlib_compress+0xc72>
jmp    1e02 <stbi_zlib_compress+0xc72>
mov    -0x20074(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x38(%rbp),%rsi
mov    -0x4(%rsi),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x4(%rsi)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
cmpq   $0x0,-0x38(%rbp)
je     1e45 <stbi_zlib_compress+0xcb5>
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    -0x8(%rcx),%eax
jl     1e5a <stbi_zlib_compress+0xcca>
lea    -0x38(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1080 <stbi__sbgrowf@plt>
jmp    1e5f <stbi_zlib_compress+0xccf>
jmp    1e5f <stbi_zlib_compress+0xccf>
mov    -0x20070(%rbp),%eax
shr    $0x8,%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x38(%rbp),%rsi
mov    -0x4(%rsi),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x4(%rsi)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
cmpq   $0x0,-0x38(%rbp)
je     1ea5 <stbi_zlib_compress+0xd15>
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%eax
add    $0x1,%eax
mov    -0x38(%rbp),%rcx
cmp    -0x8(%rcx),%eax
jl     1eba <stbi_zlib_compress+0xd2a>
lea    -0x38(%rbp),%rdi
mov    $0x1,%edx
mov    %edx,%esi
call   1080 <stbi__sbgrowf@plt>
jmp    1ebf <stbi_zlib_compress+0xd2f>
jmp    1ebf <stbi_zlib_compress+0xd2f>
mov    -0x20070(%rbp),%eax
mov    %al,%dl
mov    -0x38(%rbp),%rax
mov    -0x38(%rbp),%rsi
mov    -0x4(%rsi),%ecx
mov    %ecx,%edi
add    $0x1,%edi
mov    %edi,-0x4(%rsi)
movslq %ecx,%rcx
mov    %dl,(%rax,%rcx,1)
mov    -0x38(%rbp),%rax
mov    -0x4(%rax),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x38(%rbp),%rdi
add    $0xfffffffffffffff8,%rdi
mov    -0x38(%rbp),%rsi
mov    -0x18(%rbp),%rax
mov    (%rax),%edx
call   10a0 <memmove@plt>
mov    -0x38(%rbp),%rax
add    $0xfffffffffffffff8,%rax
add    $0x200a0,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<stbi_zlib_compress>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x20078,%rsp
mov    %rdx,0x60(%rsp)
mov    %rsi,0x20(%rsp)
mov    %rdi,0x18(%rsp)
movl   $0x0,0xc(%rsp)
movl   $0x0,0x8(%rsp)
movq   $0x0,0x10(%rsp)
cmp    $0x6,%ecx
mov    $0x5,%eax
cmovge %ecx,%eax
mov    %rax,0x58(%rsp)
lea    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x10(%rsp),%rax
movslq -0x4(%rax),%rcx
lea    0x1(%rcx),%edx
mov    %edx,-0x4(%rax)
movb   $0x78,(%rax,%rcx,1)
mov    0x10(%rsp),%rax
test   %rax,%rax
je     1225 <stbi_zlib_compress+0x85>
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
cmp    -0x8(%rax),%edx
jl     1244 <stbi_zlib_compress+0xa4>
lea    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x10(%rsp),%rax
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
mov    %edx,-0x4(%rax)
movslq %ecx,%rcx
movb   $0x5e,(%rax,%rcx,1)
mov    0x8(%rsp),%ecx
mov    $0x1,%eax
shl    %cl,%eax
or     %eax,0xc(%rsp)
mov    $0x1,%ebx
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
mov    0x10(%rsp),%rdi
lea    0xc(%rsp),%rbp
lea    0x8(%rsp),%r14
mov    %rbp,%rsi
mov    %r14,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%ebx
or     %ebx,0xc(%rsp)
mov    %rax,0x10(%rsp)
add    $0x2,%ecx
mov    %ecx,0x8(%rsp)
mov    %rax,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
lea    0x70(%rsp),%rdi
xor    %r15d,%r15d
mov    $0x20000,%edx
xor    %esi,%esi
call   1070 <memset@plt>
cmpl   $0x4,0x20(%rsp)
mov    0x18(%rsp),%rcx
jl     172e <stbi_zlib_compress+0x58e>
mov    0x20(%rsp),%rax
add    $0xfffffffd,%eax
mov    %eax,0x54(%rsp)
mov    0x58(%rsp),%rax
lea    (%rax,%rax,1),%edx
mov    %edx,0x50(%rsp)
mov    %eax,%edx
mov    %rdx,0x68(%rsp)
lea    0x0(,%rax,8),%eax
mov    %eax,0x4c(%rsp)
xor    %eax,%eax
jmp    135b <stbi_zlib_compress+0x1bb>
xchg   %ax,%ax
or     $0x100,%edi
mov    $0x9,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x9,%ecx
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
mov    %ecx,0x8(%rsp)
mov    0x10(%rsp),%rdi
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
mov    $0x1,%r15d
mov    0x18(%rsp),%rcx
mov    0x28(%rsp),%rax
add    %eax,%r15d
mov    %r15d,%eax
cmp    0x54(%rsp),%r15d
jge    172e <stbi_zlib_compress+0x58e>
mov    %rax,0x28(%rsp)
movslq %eax,%rdi
add    %rcx,%rdi
mov    %rdi,0x30(%rsp)
call   1050 <stbi__zhash@plt>
and    $0x3fff,%eax
lea    (%rsp,%rax,8),%rbp
add    $0x70,%rbp
mov    0x70(%rsp,%rax,8),%r13
test   %r13,%r13
je     1430 <stbi_zlib_compress+0x290>
mov    -0x4(%r13),%ebx
test   %ebx,%ebx
jle    1440 <stbi_zlib_compress+0x2a0>
mov    %rbp,0x40(%rsp)
mov    0x28(%rsp),%rcx
lea    -0x8000(%rcx),%eax
movslq %eax,%r14
mov    0x20(%rsp),%rax
mov    %eax,%ebp
sub    %ecx,%ebp
mov    $0x3,%r15d
xor    %r12d,%r12d
xor    %eax,%eax
mov    %rax,0x38(%rsp)
mov    0x18(%rsp),%rcx
jmp    13d9 <stbi_zlib_compress+0x239>
nopw   0x0(%rax,%rax,1)
add    $0x1,%r12
cmp    %r12,%rbx
je     1410 <stbi_zlib_compress+0x270>
mov    0x0(%r13,%r12,8),%rdi
mov    %rdi,%rax
sub    %rcx,%rax
cmp    %r14,%rax
jle    13d0 <stbi_zlib_compress+0x230>
mov    0x30(%rsp),%rsi
mov    %ebp,%edx
call   1060 <stbi__zlib_countm@plt>
mov    0x18(%rsp),%rcx
cmp    %r15d,%eax
jl     13d0 <stbi_zlib_compress+0x230>
mov    0x0(%r13,%r12,8),%rdx
mov    %rdx,0x38(%rsp)
mov    %eax,%r15d
jmp    13d0 <stbi_zlib_compress+0x230>
xchg   %ax,%ax
mov    0x40(%rsp),%rbp
mov    0x0(%rbp),%r13
test   %r13,%r13
mov    0x38(%rsp),%rbx
jne    1448 <stbi_zlib_compress+0x2a8>
jmp    149b <stbi_zlib_compress+0x2fb>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x3,%r15d
xor    %ebx,%ebx
jmp    149b <stbi_zlib_compress+0x2fb>
nopw   0x0(%rax,%rax,1)
mov    $0x3,%r15d
xor    %ebx,%ebx
mov    -0x4(%r13),%eax
cmp    0x50(%rsp),%eax
jne    1490 <stbi_zlib_compress+0x2f0>
mov    0x68(%rsp),%rax
lea    0x0(,%rax,8),%rsi
add    %r13,%rsi
mov    %r13,%rdi
mov    0x4c(%rsp),%edx
call   10a0 <memcpy@plt>
mov    0x0(%rbp),%r13
mov    0x58(%rsp),%rax
mov    %eax,-0x4(%r13)
lea    -0x8(%r13),%rcx
jmp    1494 <stbi_zlib_compress+0x2f4>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    -0x8(%r13),%rcx
lea    0x1(%rax),%edx
cmp    (%rcx),%edx
jl     14bc <stbi_zlib_compress+0x31c>
mov    %rbp,%rdi
mov    $0x1,%esi
mov    $0x8,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x0(%rbp),%r13
lea    -0x8(%r13),%rcx
mov    -0x4(%r13),%eax
lea    0x1(%rax),%edx
mov    %edx,0x4(%rcx)
cltq
mov    0x30(%rsp),%rcx
mov    %rcx,0x0(%r13,%rax,8)
mov    %rbx,0x38(%rsp)
test   %rbx,%rbx
je     1560 <stbi_zlib_compress+0x3c0>
mov    0x30(%rsp),%rax
lea    0x1(%rax),%rdi
mov    %rdi,0x40(%rsp)
call   1050 <stbi__zhash@plt>
mov    0x18(%rsp),%rcx
and    $0x3fff,%eax
mov    0x70(%rsp,%rax,8),%rbx
test   %rbx,%rbx
je     15a0 <stbi_zlib_compress+0x400>
mov    -0x4(%rbx),%r13d
test   %r13d,%r13d
jle    15a0 <stbi_zlib_compress+0x400>
mov    0x28(%rsp),%rax
mov    %eax,%r12d
not    %r12d
add    0x20(%rsp),%r12d
add    $0xffff8001,%eax
movslq %eax,%rbp
xor    %r14d,%r14d
jmp    1539 <stbi_zlib_compress+0x399>
xchg   %ax,%ax
add    $0x1,%r14
cmp    %r14,%r13
je     15a0 <stbi_zlib_compress+0x400>
mov    (%rbx,%r14,8),%rdi
mov    %rdi,%rax
sub    %rcx,%rax
cmp    %rbp,%rax
jle    1530 <stbi_zlib_compress+0x390>
mov    0x40(%rsp),%rsi
mov    %r12d,%edx
call   1060 <stbi__zlib_countm@plt>
mov    0x18(%rsp),%rcx
cmp    %r15d,%eax
jle    1530 <stbi_zlib_compress+0x390>
nop
mov    0x30(%rsp),%rax
movzbl (%rax),%edi
cmp    $0x8f,%edi
ja     1300 <stbi_zlib_compress+0x160>
add    $0x30,%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x8,%ecx
jmp    131d <stbi_zlib_compress+0x17d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x30(%rsp),%r13
sub    0x38(%rsp),%r13d
cmp    $0x8000,%r13d
setl   %al
cmp    $0x103,%r15d
setl   %cl
and    %al,%cl
movzbl %cl,%edi
call   1080 <assert@plt>
mov    $0xffffffffffffffff,%rbx
lea    0xc(%rsp),%r14
lea    0x8(%rsp),%r12
lea    0xa20(%rip),%rcx
movzwl 0x4(%rcx,%rbx,2),%eax
add    $0x1,%rbx
cmp    %eax,%r15d
jge    15e0 <stbi_zlib_compress+0x440>
cmp    $0x16,%ebx
ja     1610 <stbi_zlib_compress+0x470>
lea    0x1(%rbx),%edi
mov    $0x7,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x7,%ecx
jmp    162d <stbi_zlib_compress+0x48d>
nop
lea    0xa9(%rbx),%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x8,%ecx
mov    %ecx,0x8(%rsp)
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    %r12,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
mov    %ebx,%edx
lea    -0x1c(%rdx),%rcx
cmp    $0xffffffffffffffec,%rcx
jb     1690 <stbi_zlib_compress+0x4f0>
lea    0x9a7(%rip),%rcx
movzwl (%rcx,%rdx,2),%ecx
mov    %r15d,%esi
sub    %ecx,%esi
mov    0x8(%rsp),%ecx
shl    %cl,%esi
or     %esi,0xc(%rsp)
lea    0x9cd(%rip),%rsi
movzbl (%rdx,%rsi,1),%edx
add    %ecx,%edx
mov    %edx,0x8(%rsp)
mov    %rax,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
mov    $0xffffffffffffffff,%rbp
lea    0x9c2(%rip),%rcx
xchg   %ax,%ax
movzwl 0x4(%rcx,%rbp,2),%eax
add    $0x1,%rbp
cmp    %r13d,%eax
jle    16a0 <stbi_zlib_compress+0x500>
mov    %ebp,%edi
mov    $0x5,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x5,%ecx
mov    %ecx,0x8(%rsp)
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    %r12,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
cmp    $0x4,%ebp
jb     1340 <stbi_zlib_compress+0x1a0>
mov    %ebp,%edx
lea    0x96e(%rip),%rcx
movzwl (%rcx,%rdx,2),%ecx
sub    %ecx,%r13d
mov    0x8(%rsp),%ecx
shl    %cl,%r13d
or     %r13d,0xc(%rsp)
lea    0x994(%rip),%rsi
movzbl (%rdx,%rsi,1),%edx
add    %ecx,%edx
mov    %edx,0x8(%rsp)
mov    %rax,%rdi
mov    %r14,%rsi
mov    %r12,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
jmp    1340 <stbi_zlib_compress+0x1a0>
cmp    0x20(%rsp),%r15d
jge    17c8 <stbi_zlib_compress+0x628>
movslq %r15d,%r13
add    %rcx,%r13
mov    0x20(%rsp),%rbp
sub    %r15d,%ebp
xor    %ebx,%ebx
lea    0xc(%rsp),%r14
lea    0x8(%rsp),%r15
jmp    179e <stbi_zlib_compress+0x5fe>
cs nopw 0x0(%rax,%rax,1)
nop
or     $0x100,%edi
mov    $0x9,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x9,%ecx
mov    %ecx,0x8(%rsp)
mov    0x10(%rsp),%rdi
mov    %r14,%rsi
mov    %r15,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
add    $0x1,%rbx
cmp    %ebx,%ebp
je     17c8 <stbi_zlib_compress+0x628>
movzbl 0x0(%r13,%rbx,1),%edi
cmp    $0x8f,%edi
ja     1760 <stbi_zlib_compress+0x5c0>
add    $0x30,%edi
mov    $0x8,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x8,%ecx
jmp    177d <stbi_zlib_compress+0x5dd>
xor    %edi,%edi
mov    $0x7,%esi
call   1040 <stbi__zlib_bitrev@plt>
mov    0x8(%rsp),%ecx
shl    %cl,%eax
or     %eax,0xc(%rsp)
add    $0x7,%ecx
mov    %ecx,0x8(%rsp)
mov    0x10(%rsp),%rdi
lea    0xc(%rsp),%rsi
lea    0x8(%rsp),%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%ecx
test   %ecx,%ecx
je     1832 <stbi_zlib_compress+0x692>
lea    0xc(%rsp),%r14
lea    0x8(%rsp),%rbp
add    $0x1,%ecx
mov    %ecx,0x8(%rsp)
mov    %rax,%rdi
mov    %r14,%rsi
mov    %rbp,%rdx
call   10c0 <stbi__zlib_flushf@plt>
mov    %rax,0x10(%rsp)
mov    0x8(%rsp),%ecx
test   %ecx,%ecx
jne    1810 <stbi_zlib_compress+0x670>
xor    %ebx,%ebx
mov    0x20(%rsp),%r14
mov    0x18(%rsp),%rbp
jmp    184d <stbi_zlib_compress+0x6ad>
add    $0x1,%rbx
cmp    $0x4000,%rbx
je     1867 <stbi_zlib_compress+0x6c7>
mov    0x70(%rsp,%rbx,8),%rdi
test   %rdi,%rdi
je     1840 <stbi_zlib_compress+0x6a0>
add    $0xfffffffffffffff8,%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rbp
jmp    1840 <stbi_zlib_compress+0x6a0>
test   %r14d,%r14d
jle    1979 <stbi_zlib_compress+0x7d9>
mov    %r14d,%eax
imul   $0x5e6ea9af,%rax,%rax
shr    $0x2b,%rax
imul   $0x15b0,%eax,%ecx
mov    %r14d,%r9d
sub    %ecx,%r9d
mov    $0x1,%edx
xor    %r10d,%r10d
mov    $0x80078071,%r8d
xor    %ebx,%ebx
jmp    18d6 <stbi_zlib_compress+0x736>
nopl   0x0(%rax)
mov    %edx,%eax
imul   %r8,%rax
shr    $0x2f,%rax
imul   $0xfff1,%eax,%eax
sub    %eax,%edx
mov    %ebx,%eax
imul   %r8,%rax
shr    $0x2f,%rax
imul   $0xfff1,%eax,%eax
sub    %eax,%ebx
add    %r9d,%r10d
mov    $0x15b0,%r9d
cmp    %r14d,%r10d
jge    1980 <stbi_zlib_compress+0x7e0>
test   %r9d,%r9d
je     18a0 <stbi_zlib_compress+0x700>
mov    %r9d,%r11d
lea    -0x1(%r11),%rcx
mov    %r11d,%esi
and    $0x3,%esi
cmp    $0x3,%rcx
jae    1900 <stbi_zlib_compress+0x760>
xor    %edi,%edi
jmp    194b <stbi_zlib_compress+0x7ab>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
and    $0x1ffc,%r11d
mov    %r10d,%ecx
xor    %edi,%edi
nopl   0x0(%rax)
mov    %ecx,%eax
movzbl 0x0(%rbp,%rax,1),%eax
add    %edx,%eax
add    %eax,%ebx
lea    0x1(%rcx),%edx
movzbl 0x0(%rbp,%rdx,1),%edx
add    %eax,%edx
add    %edx,%ebx
lea    0x2(%rcx),%eax
movzbl 0x0(%rbp,%rax,1),%eax
add    %edx,%eax
add    %eax,%ebx
lea    0x3(%rcx),%edx
movzbl 0x0(%rbp,%rdx,1),%edx
add    %eax,%edx
add    %edx,%ebx
add    $0x4,%rdi
add    $0x4,%ecx
cmp    %rdi,%r11
jne    1910 <stbi_zlib_compress+0x770>
test   %rsi,%rsi
je     18a0 <stbi_zlib_compress+0x700>
add    %r10d,%edi
nopw   0x0(%rax,%rax,1)
mov    %edi,%eax
movzbl 0x0(%rbp,%rax,1),%eax
add    %eax,%edx
add    %edx,%ebx
add    $0x1,%edi
add    $0xffffffffffffffff,%rsi
jne    1960 <stbi_zlib_compress+0x7c0>
jmp    18a0 <stbi_zlib_compress+0x700>
xor    %ebx,%ebx
mov    $0x1,%edx
mov    %edx,%ebp
mov    0x10(%rsp),%rax
test   %rax,%rax
je     1997 <stbi_zlib_compress+0x7f7>
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
cmp    -0x8(%rax),%edx
jl     19b6 <stbi_zlib_compress+0x816>
lea    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x10(%rsp),%rax
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
mov    %edx,-0x4(%rax)
movslq %ecx,%rcx
mov    %bh,(%rax,%rcx,1)
mov    0x10(%rsp),%rax
test   %rax,%rax
je     19d4 <stbi_zlib_compress+0x834>
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
cmp    -0x8(%rax),%edx
jl     19f3 <stbi_zlib_compress+0x853>
lea    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x10(%rsp),%rax
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
mov    %edx,-0x4(%rax)
movslq %ecx,%rcx
mov    %bl,(%rax,%rcx,1)
mov    0x10(%rsp),%rax
test   %rax,%rax
je     1a11 <stbi_zlib_compress+0x871>
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
cmp    -0x8(%rax),%edx
jl     1a30 <stbi_zlib_compress+0x890>
lea    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x10(%rsp),%rax
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
mov    %edx,-0x4(%rax)
movslq %ecx,%rcx
mov    %ebp,%edx
mov    %dh,(%rax,%rcx,1)
mov    0x10(%rsp),%rax
test   %rax,%rax
je     1a50 <stbi_zlib_compress+0x8b0>
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
cmp    -0x8(%rax),%edx
jl     1a6f <stbi_zlib_compress+0x8cf>
lea    0x10(%rsp),%rdi
mov    $0x1,%esi
mov    $0x1,%edx
call   1090 <stbi__sbgrowf@plt>
mov    0x10(%rsp),%rax
mov    -0x4(%rax),%ecx
lea    0x1(%rcx),%edx
mov    %edx,-0x4(%rax)
movslq %ecx,%rcx
mov    %bpl,(%rax,%rcx,1)
mov    0x10(%rsp),%rsi
mov    -0x4(%rsi),%edx
mov    0x60(%rsp),%rax
mov    %edx,(%rax)
lea    -0x8(%rsi),%rdi
call   10b0 <memmove@plt>
mov    0x10(%rsp),%rax
add    $0xfffffffffffffff8,%rax
add    $0x20078,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@stbi_zlib_compress.lengthc = internal global [30 x i16] [i16 3, i16 4, i16 5, i16 6, i16 7, i16 8, i16 9, i16 10, i16 11, i16 13, i16 15, i16 17, i16 19, i16 23, i16 27, i16 31, i16 35, i16 43, i16 51, i16 59, i16 67, i16 83, i16 99, i16 115, i16 131, i16 163, i16 195, i16 227, i16 258, i16 259]
@stbi_zlib_compress.lengtheb = internal global [29 x i8] c"\00\00\00\00\00\00\00\00\01\01\01\01\02\02\02\02\03\03\03\03\04\04\04\04\05\05\05\05\00"
@stbi_zlib_compress.distc = internal global [31 x i16] [i16 1, i16 2, i16 3, i16 4, i16 5, i16 7, i16 9, i16 13, i16 17, i16 25, i16 33, i16 49, i16 65, i16 97, i16 129, i16 193, i16 257, i16 385, i16 513, i16 769, i16 1025, i16 1537, i16 2049, i16 3073, i16 4097, i16 6145, i16 8193, i16 12289, i16 16385, i16 24577, i16 -32768]
@stbi_zlib_compress.disteb = internal global [30 x i8] c"\00\00\00\00\01\01\02\02\03\03\04\04\05\05\06\06\07\07\08\08\09\09\0A\0A\0B\0B\0C\0C\0D\0D"
define i8* @stbi_zlib_compress(i8* %0, i32 %1, i32* %2, i32 %3) {
%5 = alloca i8*
%6 = alloca i32
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i8*
%14 = alloca [16384 x i8**]
%15 = alloca i32
%16 = alloca i32
%17 = alloca i8*
%18 = alloca i8**
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca i32
%23 = alloca i32
%24 = alloca i32
%25 = alloca i32
%26 = alloca i32
%27 = alloca i32
store i8* %0, i8** %5
store i32 %1, i32* %6
store i32* %2, i32** %7
store i32 %3, i32* %8
store i32 0, i32* %9
store i32 0, i32* %12
store i8* null, i8** %13
%28 = load i32, i32* %8
%29 = icmp slt i32 %28, 5
br i1 %29, label %30, label %31
30: ; preds = %4
store i32 5, i32* %8
br label %31
31: ; preds = %30, %4
%32 = load i8*, i8** %13
%33 = icmp eq i8* %32, null
br i1 %33, label %47, label %34
34: ; preds = %31
%35 = load i8*, i8** %13
%36 = bitcast i8* %35 to i32*
%37 = getelementptr inbounds i32, i32* %36, i64 -2
%38 = getelementptr inbounds i32, i32* %37, i64 1
%39 = load i32, i32* %38
%40 = add nsw i32 %39, 1
%41 = load i8*, i8** %13
%42 = bitcast i8* %41 to i32*
%43 = getelementptr inbounds i32, i32* %42, i64 -2
%44 = getelementptr inbounds i32, i32* %43, i64 0
%45 = load i32, i32* %44
%46 = icmp sge i32 %40, %45
br i1 %46, label %47, label %49
47: ; preds = %34, %31
%48 = call i32 @stbi__sbgrowf(i8** %13, i32 1, i32 1)
br label %50
49: ; preds = %34
br label %50
50: ; preds = %49, %47
%51 = phi i32 [ %48, %47 ], [ 0, %49 ]
%52 = load i8*, i8** %13
%53 = load i8*, i8** %13
%54 = bitcast i8* %53 to i32*
%55 = getelementptr inbounds i32, i32* %54, i64 -2
%56 = getelementptr inbounds i32, i32* %55, i64 1
%57 = load i32, i32* %56
%58 = add nsw i32 %57, 1
store i32 %58, i32* %56
%59 = sext i32 %57 to i64
%60 = getelementptr inbounds i8, i8* %52, i64 %59
store i8 120, i8* %60
%61 = load i8*, i8** %13
%62 = icmp eq i8* %61, null
br i1 %62, label %76, label %63
63: ; preds = %50
%64 = load i8*, i8** %13
%65 = bitcast i8* %64 to i32*
%66 = getelementptr inbounds i32, i32* %65, i64 -2
%67 = getelementptr inbounds i32, i32* %66, i64 1
%68 = load i32, i32* %67
%69 = add nsw i32 %68, 1
%70 = load i8*, i8** %13
%71 = bitcast i8* %70 to i32*
%72 = getelementptr inbounds i32, i32* %71, i64 -2
%73 = getelementptr inbounds i32, i32* %72, i64 0
%74 = load i32, i32* %73
%75 = icmp sge i32 %69, %74
br i1 %75, label %76, label %78
76: ; preds = %63, %50
%77 = call i32 @stbi__sbgrowf(i8** %13, i32 1, i32 1)
br label %79
78: ; preds = %63
br label %79
79: ; preds = %78, %76
%80 = phi i32 [ %77, %76 ], [ 0, %78 ]
%81 = load i8*, i8** %13
%82 = load i8*, i8** %13
%83 = bitcast i8* %82 to i32*
%84 = getelementptr inbounds i32, i32* %83, i64 -2
%85 = getelementptr inbounds i32, i32* %84, i64 1
%86 = load i32, i32* %85
%87 = add nsw i32 %86, 1
store i32 %87, i32* %85
%88 = sext i32 %86 to i64
%89 = getelementptr inbounds i8, i8* %81, i64 %88
store i8 94, i8* %89
%90 = load i32, i32* %12
%91 = shl i32 1, %90
%92 = load i32, i32* %9
%93 = or i32 %92, %91
store i32 %93, i32* %9
%94 = load i32, i32* %12
%95 = add nsw i32 %94, 1
store i32 %95, i32* %12
%96 = load i8*, i8** %13
%97 = call i8* @stbi__zlib_flushf(i8* %96, i32* %9, i32* %12)
store i8* %97, i8** %13
%98 = load i32, i32* %12
%99 = shl i32 1, %98
%100 = load i32, i32* %9
%101 = or i32 %100, %99
store i32 %101, i32* %9
%102 = load i32, i32* %12
%103 = add nsw i32 %102, 2
store i32 %103, i32* %12
%104 = load i8*, i8** %13
%105 = call i8* @stbi__zlib_flushf(i8* %104, i32* %9, i32* %12)
store i8* %105, i8** %13
store i32 0, i32* %10
br label %106
106: ; preds = %113, %79
%107 = load i32, i32* %10
%108 = icmp slt i32 %107, 16384
br i1 %108, label %109, label %116
109: ; preds = %106
%110 = load i32, i32* %10
%111 = sext i32 %110 to i64
%112 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %111
store i8** null, i8*** %112
br label %113
113: ; preds = %109
%114 = load i32, i32* %10
%115 = add nsw i32 %114, 1
store i32 %115, i32* %10
br label %106
116: ; preds = %106
store i32 0, i32* %10
br label %117
117: ; preds = %594, %116
%118 = load i32, i32* %10
%119 = load i32, i32* %6
%120 = sub nsw i32 %119, 3
%121 = icmp slt i32 %118, %120
br i1 %121, label %122, label %595
122: ; preds = %117
%123 = load i8*, i8** %5
%124 = load i32, i32* %10
%125 = sext i32 %124 to i64
%126 = getelementptr inbounds i8, i8* %123, i64 %125
%127 = call i32 @stbi__zhash(i8* %126)
%128 = and i32 %127, 16383
store i32 %128, i32* %15
store i32 3, i32* %16
store i8* null, i8** %17
%129 = load i32, i32* %15
%130 = sext i32 %129 to i64
%131 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %130
%132 = load i8**, i8*** %131
store i8** %132, i8*** %18
%133 = load i8**, i8*** %18
%134 = icmp ne i8** %133, null
br i1 %134, label %135, label %141
135: ; preds = %122
%136 = load i8**, i8*** %18
%137 = bitcast i8** %136 to i32*
%138 = getelementptr inbounds i32, i32* %137, i64 -2
%139 = getelementptr inbounds i32, i32* %138, i64 1
%140 = load i32, i32* %139
br label %142
141: ; preds = %122
br label %142
142: ; preds = %141, %135
%143 = phi i32 [ %140, %135 ], [ 0, %141 ]
store i32 %143, i32* %19
store i32 0, i32* %11
br label %144
144: ; preds = %188, %142
%145 = load i32, i32* %11
%146 = load i32, i32* %19
%147 = icmp slt i32 %145, %146
br i1 %147, label %148, label %191
148: ; preds = %144
%149 = load i8**, i8*** %18
%150 = load i32, i32* %11
%151 = sext i32 %150 to i64
%152 = getelementptr inbounds i8*, i8** %149, i64 %151
%153 = load i8*, i8** %152
%154 = load i8*, i8** %5
%155 = ptrtoint i8* %153 to i64
%156 = ptrtoint i8* %154 to i64
%157 = sub i64 %155, %156
%158 = load i32, i32* %10
%159 = sub nsw i32 %158, 32768
%160 = sext i32 %159 to i64
%161 = icmp sgt i64 %157, %160
br i1 %161, label %162, label %187
162: ; preds = %148
%163 = load i8**, i8*** %18
%164 = load i32, i32* %11
%165 = sext i32 %164 to i64
%166 = getelementptr inbounds i8*, i8** %163, i64 %165
%167 = load i8*, i8** %166
%168 = load i8*, i8** %5
%169 = load i32, i32* %10
%170 = sext i32 %169 to i64
%171 = getelementptr inbounds i8, i8* %168, i64 %170
%172 = load i32, i32* %6
%173 = load i32, i32* %10
%174 = sub nsw i32 %172, %173
%175 = call i32 @stbi__zlib_countm(i8* %167, i8* %171, i32 %174)
store i32 %175, i32* %20
%176 = load i32, i32* %20
%177 = load i32, i32* %16
%178 = icmp sge i32 %176, %177
br i1 %178, label %179, label %186
179: ; preds = %162
%180 = load i32, i32* %20
store i32 %180, i32* %16
%181 = load i8**, i8*** %18
%182 = load i32, i32* %11
%183 = sext i32 %182 to i64
%184 = getelementptr inbounds i8*, i8** %181, i64 %183
%185 = load i8*, i8** %184
store i8* %185, i8** %17
br label %186
186: ; preds = %179, %162
br label %187
187: ; preds = %186, %148
br label %188
188: ; preds = %187
%189 = load i32, i32* %11
%190 = add nsw i32 %189, 1
store i32 %190, i32* %11
br label %144
191: ; preds = %144
%192 = load i32, i32* %15
%193 = sext i32 %192 to i64
%194 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %193
%195 = load i8**, i8*** %194
%196 = icmp ne i8** %195, null
br i1 %196, label %197, label %234
197: ; preds = %191
%198 = load i32, i32* %15
%199 = sext i32 %198 to i64
%200 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %199
%201 = load i8**, i8*** %200
%202 = bitcast i8** %201 to i32*
%203 = getelementptr inbounds i32, i32* %202, i64 -2
%204 = getelementptr inbounds i32, i32* %203, i64 1
%205 = load i32, i32* %204
%206 = load i32, i32* %8
%207 = mul nsw i32 2, %206
%208 = icmp eq i32 %205, %207
br i1 %208, label %209, label %234
209: ; preds = %197
%210 = load i32, i32* %15
%211 = sext i32 %210 to i64
%212 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %211
%213 = load i8**, i8*** %212
%214 = load i32, i32* %15
%215 = sext i32 %214 to i64
%216 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %215
%217 = load i8**, i8*** %216
%218 = load i32, i32* %8
%219 = sext i32 %218 to i64
%220 = getelementptr inbounds i8*, i8** %217, i64 %219
%221 = load i32, i32* %8
%222 = sext i32 %221 to i64
%223 = mul i64 8, %222
%224 = trunc i64 %223 to i32
%225 = call i32 @memcpy(i8** %213, i8** %220, i32 %224)
%226 = load i32, i32* %8
%227 = load i32, i32* %15
%228 = sext i32 %227 to i64
%229 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %228
%230 = load i8**, i8*** %229
%231 = bitcast i8** %230 to i32*
%232 = getelementptr inbounds i32, i32* %231, i64 -2
%233 = getelementptr inbounds i32, i32* %232, i64 1
store i32 %226, i32* %233
br label %234
234: ; preds = %209, %197, %191
%235 = load i32, i32* %15
%236 = sext i32 %235 to i64
%237 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %236
%238 = load i8**, i8*** %237
%239 = icmp eq i8** %238, null
br i1 %239, label %259, label %240
240: ; preds = %234
%241 = load i32, i32* %15
%242 = sext i32 %241 to i64
%243 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %242
%244 = load i8**, i8*** %243
%245 = bitcast i8** %244 to i32*
%246 = getelementptr inbounds i32, i32* %245, i64 -2
%247 = getelementptr inbounds i32, i32* %246, i64 1
%248 = load i32, i32* %247
%249 = add nsw i32 %248, 1
%250 = load i32, i32* %15
%251 = sext i32 %250 to i64
%252 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %251
%253 = load i8**, i8*** %252
%254 = bitcast i8** %253 to i32*
%255 = getelementptr inbounds i32, i32* %254, i64 -2
%256 = getelementptr inbounds i32, i32* %255, i64 0
%257 = load i32, i32* %256
%258 = icmp sge i32 %249, %257
br i1 %258, label %259, label %265
259: ; preds = %240, %234
%260 = load i32, i32* %15
%261 = sext i32 %260 to i64
%262 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %261
%263 = bitcast i8*** %262 to i8**
%264 = call i32 @stbi__sbgrowf(i8** %263, i32 1, i32 8)
br label %266
265: ; preds = %240
br label %266
266: ; preds = %265, %259
%267 = phi i32 [ %264, %259 ], [ 0, %265 ]
%268 = load i8*, i8** %5
%269 = load i32, i32* %10
%270 = sext i32 %269 to i64
%271 = getelementptr inbounds i8, i8* %268, i64 %270
%272 = load i32, i32* %15
%273 = sext i32 %272 to i64
%274 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %273
%275 = load i8**, i8*** %274
%276 = load i32, i32* %15
%277 = sext i32 %276 to i64
%278 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %277
%279 = load i8**, i8*** %278
%280 = bitcast i8** %279 to i32*
%281 = getelementptr inbounds i32, i32* %280, i64 -2
%282 = getelementptr inbounds i32, i32* %281, i64 1
%283 = load i32, i32* %282
%284 = add nsw i32 %283, 1
store i32 %284, i32* %282
%285 = sext i32 %283 to i64
%286 = getelementptr inbounds i8*, i8** %275, i64 %285
store i8* %271, i8** %286
%287 = load i8*, i8** %17
%288 = icmp ne i8* %287, null
br i1 %288, label %289, label %356
289: ; preds = %266
%290 = load i8*, i8** %5
%291 = load i32, i32* %10
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i8, i8* %290, i64 %292
%294 = getelementptr inbounds i8, i8* %293, i64 1
%295 = call i32 @stbi__zhash(i8* %294)
%296 = and i32 %295, 16383
store i32 %296, i32* %15
%297 = load i32, i32* %15
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %298
%300 = load i8**, i8*** %299
store i8** %300, i8*** %18
%301 = load i8**, i8*** %18
%302 = icmp ne i8** %301, null
br i1 %302, label %303, label %309
303: ; preds = %289
%304 = load i8**, i8*** %18
%305 = bitcast i8** %304 to i32*
%306 = getelementptr inbounds i32, i32* %305, i64 -2
%307 = getelementptr inbounds i32, i32* %306, i64 1
%308 = load i32, i32* %307
br label %310
309: ; preds = %289
br label %310
310: ; preds = %309, %303
%311 = phi i32 [ %308, %303 ], [ 0, %309 ]
store i32 %311, i32* %19
store i32 0, i32* %11
br label %312
312: ; preds = %352, %310
%313 = load i32, i32* %11
%314 = load i32, i32* %19
%315 = icmp slt i32 %313, %314
br i1 %315, label %316, label %355
316: ; preds = %312
%317 = load i8**, i8*** %18
%318 = load i32, i32* %11
%319 = sext i32 %318 to i64
%320 = getelementptr inbounds i8*, i8** %317, i64 %319
%321 = load i8*, i8** %320
%322 = load i8*, i8** %5
%323 = ptrtoint i8* %321 to i64
%324 = ptrtoint i8* %322 to i64
%325 = sub i64 %323, %324
%326 = load i32, i32* %10
%327 = sub nsw i32 %326, 32767
%328 = sext i32 %327 to i64
%329 = icmp sgt i64 %325, %328
br i1 %329, label %330, label %351
330: ; preds = %316
%331 = load i8**, i8*** %18
%332 = load i32, i32* %11
%333 = sext i32 %332 to i64
%334 = getelementptr inbounds i8*, i8** %331, i64 %333
%335 = load i8*, i8** %334
%336 = load i8*, i8** %5
%337 = load i32, i32* %10
%338 = sext i32 %337 to i64
%339 = getelementptr inbounds i8, i8* %336, i64 %338
%340 = getelementptr inbounds i8, i8* %339, i64 1
%341 = load i32, i32* %6
%342 = load i32, i32* %10
%343 = sub nsw i32 %341, %342
%344 = sub nsw i32 %343, 1
%345 = call i32 @stbi__zlib_countm(i8* %335, i8* %340, i32 %344)
store i32 %345, i32* %21
%346 = load i32, i32* %21
%347 = load i32, i32* %16
%348 = icmp sgt i32 %346, %347
br i1 %348, label %349, label %350
349: ; preds = %330
store i8* null, i8** %17
br label %355
350: ; preds = %330
br label %351
351: ; preds = %350, %316
br label %352
352: ; preds = %351
%353 = load i32, i32* %11
%354 = add nsw i32 %353, 1
store i32 %354, i32* %11
br label %312
355: ; preds = %349, %312
br label %356
356: ; preds = %355, %266
%357 = load i8*, i8** %17
%358 = icmp ne i8* %357, null
br i1 %358, label %359, label %547
359: ; preds = %356
%360 = load i8*, i8** %5
%361 = load i32, i32* %10
%362 = sext i32 %361 to i64
%363 = getelementptr inbounds i8, i8* %360, i64 %362
%364 = load i8*, i8** %17
%365 = ptrtoint i8* %363 to i64
%366 = ptrtoint i8* %364 to i64
%367 = sub i64 %365, %366
%368 = trunc i64 %367 to i32
store i32 %368, i32* %22
%369 = load i32, i32* %22
%370 = icmp sle i32 %369, 32767
br i1 %370, label %371, label %374
371: ; preds = %359
%372 = load i32, i32* %16
%373 = icmp sle i32 %372, 258
br label %374
374: ; preds = %371, %359
%375 = phi i1 [ false, %359 ], [ %373, %371 ]
%376 = zext i1 %375 to i32
%377 = call i32 @assert(i32 %376)
store i32 0, i32* %11
br label %378
378: ; preds = %389, %374
%379 = load i32, i32* %16
%380 = load i32, i32* %11
%381 = add nsw i32 %380, 1
%382 = sext i32 %381 to i64
%383 = getelementptr inbounds [30 x i16], [30 x i16]* @stbi_zlib_compress.lengthc, i64 0, i64 %382
%384 = load i16, i16* %383
%385 = zext i16 %384 to i32
%386 = sub nsw i32 %385, 1
%387 = icmp sgt i32 %379, %386
br i1 %387, label %388, label %392
388: ; preds = %378
br label %389
389: ; preds = %388
%390 = load i32, i32* %11
%391 = add nsw i32 %390, 1
store i32 %391, i32* %11
br label %378
392: ; preds = %378
%393 = load i32, i32* %11
%394 = add nsw i32 %393, 257
%395 = icmp sle i32 %394, 143
br i1 %395, label %396, label %409
396: ; preds = %392
%397 = load i32, i32* %11
%398 = add nsw i32 %397, 257
%399 = add nsw i32 48, %398
%400 = call i32 @stbi__zlib_bitrev(i32 %399, i32 8)
%401 = load i32, i32* %12
%402 = shl i32 %400, %401
%403 = load i32, i32* %9
%404 = or i32 %403, %402
store i32 %404, i32* %9
%405 = load i32, i32* %12
%406 = add nsw i32 %405, 8
store i32 %406, i32* %12
%407 = load i8*, i8** %13
%408 = call i8* @stbi__zlib_flushf(i8* %407, i32* %9, i32* %12)
store i8* %408, i8** %13
br label %463
409: ; preds = %392
%410 = load i32, i32* %11
%411 = add nsw i32 %410, 257
%412 = icmp sle i32 %411, 255
br i1 %412, label %413, label %427
413: ; preds = %409
%414 = load i32, i32* %11
%415 = add nsw i32 %414, 257
%416 = add nsw i32 400, %415
%417 = sub nsw i32 %416, 144
%418 = call i32 @stbi__zlib_bitrev(i32 %417, i32 9)
%419 = load i32, i32* %12
%420 = shl i32 %418, %419
%421 = load i32, i32* %9
%422 = or i32 %421, %420
store i32 %422, i32* %9
%423 = load i32, i32* %12
%424 = add nsw i32 %423, 9
store i32 %424, i32* %12
%425 = load i8*, i8** %13
%426 = call i8* @stbi__zlib_flushf(i8* %425, i32* %9, i32* %12)
store i8* %426, i8** %13
br label %461
427: ; preds = %409
%428 = load i32, i32* %11
%429 = add nsw i32 %428, 257
%430 = icmp sle i32 %429, 279
br i1 %430, label %431, label %445
431: ; preds = %427
%432 = load i32, i32* %11
%433 = add nsw i32 %432, 257
%434 = add nsw i32 0, %433
%435 = sub nsw i32 %434, 256
%436 = call i32 @stbi__zlib_bitrev(i32 %435, i32 7)
%437 = load i32, i32* %12
%438 = shl i32 %436, %437
%439 = load i32, i32* %9
%440 = or i32 %439, %438
store i32 %440, i32* %9
%441 = load i32, i32* %12
%442 = add nsw i32 %441, 7
store i32 %442, i32* %12
%443 = load i8*, i8** %13
%444 = call i8* @stbi__zlib_flushf(i8* %443, i32* %9, i32* %12)
store i8* %444, i8** %13
br label %459
445: ; preds = %427
%446 = load i32, i32* %11
%447 = add nsw i32 %446, 257
%448 = add nsw i32 192, %447
%449 = sub nsw i32 %448, 280
%450 = call i32 @stbi__zlib_bitrev(i32 %449, i32 8)
%451 = load i32, i32* %12
%452 = shl i32 %450, %451
%453 = load i32, i32* %9
%454 = or i32 %453, %452
store i32 %454, i32* %9
%455 = load i32, i32* %12
%456 = add nsw i32 %455, 8
store i32 %456, i32* %12
%457 = load i8*, i8** %13
%458 = call i8* @stbi__zlib_flushf(i8* %457, i32* %9, i32* %12)
store i8* %458, i8** %13
br label %459
459: ; preds = %445, %431
%460 = phi i8* [ %444, %431 ], [ %458, %445 ]
br label %461
461: ; preds = %459, %413
%462 = phi i8* [ %426, %413 ], [ %460, %459 ]
br label %463
463: ; preds = %461, %396
%464 = phi i8* [ %408, %396 ], [ %462, %461 ]
%465 = load i32, i32* %11
%466 = sext i32 %465 to i64
%467 = getelementptr inbounds [29 x i8], [29 x i8]* @stbi_zlib_compress.lengtheb, i64 0, i64 %466
%468 = load i8, i8* %467
%469 = icmp ne i8 %468, 0
br i1 %469, label %470, label %491
470: ; preds = %463
%471 = load i32, i32* %16
%472 = load i32, i32* %11
%473 = sext i32 %472 to i64
%474 = getelementptr inbounds [30 x i16], [30 x i16]* @stbi_zlib_compress.lengthc, i64 0, i64 %473
%475 = load i16, i16* %474
%476 = zext i16 %475 to i32
%477 = sub nsw i32 %471, %476
%478 = load i32, i32* %12
%479 = shl i32 %477, %478
%480 = load i32, i32* %9
%481 = or i32 %480, %479
store i32 %481, i32* %9
%482 = load i32, i32* %11
%483 = sext i32 %482 to i64
%484 = getelementptr inbounds [29 x i8], [29 x i8]* @stbi_zlib_compress.lengtheb, i64 0, i64 %483
%485 = load i8, i8* %484
%486 = zext i8 %485 to i32
%487 = load i32, i32* %12
%488 = add nsw i32 %487, %486
store i32 %488, i32* %12
%489 = load i8*, i8** %13
%490 = call i8* @stbi__zlib_flushf(i8* %489, i32* %9, i32* %12)
store i8* %490, i8** %13
br label %491
491: ; preds = %470, %463
store i32 0, i32* %11
br label %492
492: ; preds = %503, %491
%493 = load i32, i32* %22
%494 = load i32, i32* %11
%495 = add nsw i32 %494, 1
%496 = sext i32 %495 to i64
%497 = getelementptr inbounds [31 x i16], [31 x i16]* @stbi_zlib_compress.distc, i64 0, i64 %496
%498 = load i16, i16* %497
%499 = zext i16 %498 to i32
%500 = sub nsw i32 %499, 1
%501 = icmp sgt i32 %493, %500
br i1 %501, label %502, label %506
502: ; preds = %492
br label %503
503: ; preds = %502
%504 = load i32, i32* %11
%505 = add nsw i32 %504, 1
store i32 %505, i32* %11
br label %492
506: ; preds = %492
%507 = load i32, i32* %11
%508 = call i32 @stbi__zlib_bitrev(i32 %507, i32 5)
%509 = load i32, i32* %12
%510 = shl i32 %508, %509
%511 = load i32, i32* %9
%512 = or i32 %511, %510
store i32 %512, i32* %9
%513 = load i32, i32* %12
%514 = add nsw i32 %513, 5
store i32 %514, i32* %12
%515 = load i8*, i8** %13
%516 = call i8* @stbi__zlib_flushf(i8* %515, i32* %9, i32* %12)
store i8* %516, i8** %13
%517 = load i32, i32* %11
%518 = sext i32 %517 to i64
%519 = getelementptr inbounds [30 x i8], [30 x i8]* @stbi_zlib_compress.disteb, i64 0, i64 %518
%520 = load i8, i8* %519
%521 = icmp ne i8 %520, 0
br i1 %521, label %522, label %543
522: ; preds = %506
%523 = load i32, i32* %22
%524 = load i32, i32* %11
%525 = sext i32 %524 to i64
%526 = getelementptr inbounds [31 x i16], [31 x i16]* @stbi_zlib_compress.distc, i64 0, i64 %525
%527 = load i16, i16* %526
%528 = zext i16 %527 to i32
%529 = sub nsw i32 %523, %528
%530 = load i32, i32* %12
%531 = shl i32 %529, %530
%532 = load i32, i32* %9
%533 = or i32 %532, %531
store i32 %533, i32* %9
%534 = load i32, i32* %11
%535 = sext i32 %534 to i64
%536 = getelementptr inbounds [30 x i8], [30 x i8]* @stbi_zlib_compress.disteb, i64 0, i64 %535
%537 = load i8, i8* %536
%538 = zext i8 %537 to i32
%539 = load i32, i32* %12
%540 = add nsw i32 %539, %538
store i32 %540, i32* %12
%541 = load i8*, i8** %13
%542 = call i8* @stbi__zlib_flushf(i8* %541, i32* %9, i32* %12)
store i8* %542, i8** %13
br label %543
543: ; preds = %522, %506
%544 = load i32, i32* %16
%545 = load i32, i32* %10
%546 = add nsw i32 %545, %544
store i32 %546, i32* %10
br label %594
547: ; preds = %356
%548 = load i8*, i8** %5
%549 = load i32, i32* %10
%550 = sext i32 %549 to i64
%551 = getelementptr inbounds i8, i8* %548, i64 %550
%552 = load i8, i8* %551
%553 = zext i8 %552 to i32
%554 = icmp sle i32 %553, 143
br i1 %554, label %555, label %572
555: ; preds = %547
%556 = load i8*, i8** %5
%557 = load i32, i32* %10
%558 = sext i32 %557 to i64
%559 = getelementptr inbounds i8, i8* %556, i64 %558
%560 = load i8, i8* %559
%561 = zext i8 %560 to i32
%562 = add nsw i32 48, %561
%563 = call i32 @stbi__zlib_bitrev(i32 %562, i32 8)
%564 = load i32, i32* %12
%565 = shl i32 %563, %564
%566 = load i32, i32* %9
%567 = or i32 %566, %565
store i32 %567, i32* %9
%568 = load i32, i32* %12
%569 = add nsw i32 %568, 8
store i32 %569, i32* %12
%570 = load i8*, i8** %13
%571 = call i8* @stbi__zlib_flushf(i8* %570, i32* %9, i32* %12)
store i8* %571, i8** %13
br label %590
572: ; preds = %547
%573 = load i8*, i8** %5
%574 = load i32, i32* %10
%575 = sext i32 %574 to i64
%576 = getelementptr inbounds i8, i8* %573, i64 %575
%577 = load i8, i8* %576
%578 = zext i8 %577 to i32
%579 = add nsw i32 400, %578
%580 = sub nsw i32 %579, 144
%581 = call i32 @stbi__zlib_bitrev(i32 %580, i32 9)
%582 = load i32, i32* %12
%583 = shl i32 %581, %582
%584 = load i32, i32* %9
%585 = or i32 %584, %583
store i32 %585, i32* %9
%586 = load i32, i32* %12
%587 = add nsw i32 %586, 9
store i32 %587, i32* %12
%588 = load i8*, i8** %13
%589 = call i8* @stbi__zlib_flushf(i8* %588, i32* %9, i32* %12)
store i8* %589, i8** %13
br label %590
590: ; preds = %572, %555
%591 = phi i8* [ %571, %555 ], [ %589, %572 ]
%592 = load i32, i32* %10
%593 = add nsw i32 %592, 1
store i32 %593, i32* %10
br label %594
594: ; preds = %590, %543
br label %117
595: ; preds = %117
br label %596
596: ; preds = %645, %595
%597 = load i32, i32* %10
%598 = load i32, i32* %6
%599 = icmp slt i32 %597, %598
br i1 %599, label %600, label %648
600: ; preds = %596
%601 = load i8*, i8** %5
%602 = load i32, i32* %10
%603 = sext i32 %602 to i64
%604 = getelementptr inbounds i8, i8* %601, i64 %603
%605 = load i8, i8* %604
%606 = zext i8 %605 to i32
%607 = icmp sle i32 %606, 143
br i1 %607, label %608, label %625
608: ; preds = %600
%609 = load i8*, i8** %5
%610 = load i32, i32* %10
%611 = sext i32 %610 to i64
%612 = getelementptr inbounds i8, i8* %609, i64 %611
%613 = load i8, i8* %612
%614 = zext i8 %613 to i32
%615 = add nsw i32 48, %614
%616 = call i32 @stbi__zlib_bitrev(i32 %615, i32 8)
%617 = load i32, i32* %12
%618 = shl i32 %616, %617
%619 = load i32, i32* %9
%620 = or i32 %619, %618
store i32 %620, i32* %9
%621 = load i32, i32* %12
%622 = add nsw i32 %621, 8
store i32 %622, i32* %12
%623 = load i8*, i8** %13
%624 = call i8* @stbi__zlib_flushf(i8* %623, i32* %9, i32* %12)
store i8* %624, i8** %13
br label %643
625: ; preds = %600
%626 = load i8*, i8** %5
%627 = load i32, i32* %10
%628 = sext i32 %627 to i64
%629 = getelementptr inbounds i8, i8* %626, i64 %628
%630 = load i8, i8* %629
%631 = zext i8 %630 to i32
%632 = add nsw i32 400, %631
%633 = sub nsw i32 %632, 144
%634 = call i32 @stbi__zlib_bitrev(i32 %633, i32 9)
%635 = load i32, i32* %12
%636 = shl i32 %634, %635
%637 = load i32, i32* %9
%638 = or i32 %637, %636
store i32 %638, i32* %9
%639 = load i32, i32* %12
%640 = add nsw i32 %639, 9
store i32 %640, i32* %12
%641 = load i8*, i8** %13
%642 = call i8* @stbi__zlib_flushf(i8* %641, i32* %9, i32* %12)
store i8* %642, i8** %13
br label %643
643: ; preds = %625, %608
%644 = phi i8* [ %624, %608 ], [ %642, %625 ]
br label %645
645: ; preds = %643
%646 = load i32, i32* %10
%647 = add nsw i32 %646, 1
store i32 %647, i32* %10
br label %596
648: ; preds = %596
%649 = call i32 @stbi__zlib_bitrev(i32 0, i32 7)
%650 = load i32, i32* %12
%651 = shl i32 %649, %650
%652 = load i32, i32* %9
%653 = or i32 %652, %651
store i32 %653, i32* %9
%654 = load i32, i32* %12
%655 = add nsw i32 %654, 7
store i32 %655, i32* %12
%656 = load i8*, i8** %13
%657 = call i8* @stbi__zlib_flushf(i8* %656, i32* %9, i32* %12)
store i8* %657, i8** %13
br label %658
658: ; preds = %661, %648
%659 = load i32, i32* %12
%660 = icmp ne i32 %659, 0
br i1 %660, label %661, label %670
661: ; preds = %658
%662 = load i32, i32* %12
%663 = shl i32 0, %662
%664 = load i32, i32* %9
%665 = or i32 %664, %663
store i32 %665, i32* %9
%666 = load i32, i32* %12
%667 = add nsw i32 %666, 1
store i32 %667, i32* %12
%668 = load i8*, i8** %13
%669 = call i8* @stbi__zlib_flushf(i8* %668, i32* %9, i32* %12)
store i8* %669, i8** %13
br label %658
670: ; preds = %658
store i32 0, i32* %10
br label %671
671: ; preds = %691, %670
%672 = load i32, i32* %10
%673 = icmp slt i32 %672, 16384
br i1 %673, label %674, label %694
674: ; preds = %671
%675 = load i32, i32* %10
%676 = sext i32 %675 to i64
%677 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %676
%678 = load i8**, i8*** %677
%679 = icmp ne i8** %678, null
br i1 %679, label %680, label %688
680: ; preds = %674
%681 = load i32, i32* %10
%682 = sext i32 %681 to i64
%683 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %14, i64 0, i64 %682
%684 = load i8**, i8*** %683
%685 = bitcast i8** %684 to i32*
%686 = getelementptr inbounds i32, i32* %685, i64 -2
%687 = call i32 @free(i32* %686)
br label %689
688: ; preds = %674
br label %689
689: ; preds = %688, %680
%690 = phi i32 [ 0, %680 ], [ 0, %688 ]
br label %691
691: ; preds = %689
%692 = load i32, i32* %10
%693 = add nsw i32 %692, 1
store i32 %693, i32* %10
br label %671
694: ; preds = %671
store i32 0, i32* %23
store i32 1, i32* %24
store i32 0, i32* %25
%695 = load i32, i32* %6
%696 = srem i32 %695, 5552
store i32 %696, i32* %26
store i32 0, i32* %27
br label %697
697: ; preds = %723, %694
%698 = load i32, i32* %27
%699 = load i32, i32* %6
%700 = icmp slt i32 %698, %699
br i1 %700, label %701, label %731
701: ; preds = %697
store i32 0, i32* %23
br label %702
702: ; preds = %720, %701
%703 = load i32, i32* %23
%704 = load i32, i32* %26
%705 = icmp ult i32 %703, %704
br i1 %705, label %706, label %723
706: ; preds = %702
%707 = load i8*, i8** %5
%708 = load i32, i32* %27
%709 = load i32, i32* %23
%710 = add i32 %708, %709
%711 = zext i32 %710 to i64
%712 = getelementptr inbounds i8, i8* %707, i64 %711
%713 = load i8, i8* %712
%714 = zext i8 %713 to i32
%715 = load i32, i32* %24
%716 = add i32 %715, %714
store i32 %716, i32* %24
%717 = load i32, i32* %24
%718 = load i32, i32* %25
%719 = add i32 %718, %717
store i32 %719, i32* %25
br label %720
720: ; preds = %706
%721 = load i32, i32* %23
%722 = add i32 %721, 1
store i32 %722, i32* %23
br label %702
723: ; preds = %702
%724 = load i32, i32* %24
%725 = urem i32 %724, 65521
store i32 %725, i32* %24
%726 = load i32, i32* %25
%727 = urem i32 %726, 65521
store i32 %727, i32* %25
%728 = load i32, i32* %26
%729 = load i32, i32* %27
%730 = add i32 %729, %728
store i32 %730, i32* %27
store i32 5552, i32* %26
br label %697
731: ; preds = %697
%732 = load i8*, i8** %13
%733 = icmp eq i8* %732, null
br i1 %733, label %747, label %734
734: ; preds = %731
%735 = load i8*, i8** %13
%736 = bitcast i8* %735 to i32*
%737 = getelementptr inbounds i32, i32* %736, i64 -2
%738 = getelementptr inbounds i32, i32* %737, i64 1
%739 = load i32, i32* %738
%740 = add nsw i32 %739, 1
%741 = load i8*, i8** %13
%742 = bitcast i8* %741 to i32*
%743 = getelementptr inbounds i32, i32* %742, i64 -2
%744 = getelementptr inbounds i32, i32* %743, i64 0
%745 = load i32, i32* %744
%746 = icmp sge i32 %740, %745
br i1 %746, label %747, label %749
747: ; preds = %734, %731
%748 = call i32 @stbi__sbgrowf(i8** %13, i32 1, i32 1)
br label %750
749: ; preds = %734
br label %750
750: ; preds = %749, %747
%751 = phi i32 [ %748, %747 ], [ 0, %749 ]
%752 = load i32, i32* %25
%753 = lshr i32 %752, 8
%754 = trunc i32 %753 to i8
%755 = load i8*, i8** %13
%756 = load i8*, i8** %13
%757 = bitcast i8* %756 to i32*
%758 = getelementptr inbounds i32, i32* %757, i64 -2
%759 = getelementptr inbounds i32, i32* %758, i64 1
%760 = load i32, i32* %759
%761 = add nsw i32 %760, 1
store i32 %761, i32* %759
%762 = sext i32 %760 to i64
%763 = getelementptr inbounds i8, i8* %755, i64 %762
store i8 %754, i8* %763
%764 = load i8*, i8** %13
%765 = icmp eq i8* %764, null
br i1 %765, label %779, label %766
766: ; preds = %750
%767 = load i8*, i8** %13
%768 = bitcast i8* %767 to i32*
%769 = getelementptr inbounds i32, i32* %768, i64 -2
%770 = getelementptr inbounds i32, i32* %769, i64 1
%771 = load i32, i32* %770
%772 = add nsw i32 %771, 1
%773 = load i8*, i8** %13
%774 = bitcast i8* %773 to i32*
%775 = getelementptr inbounds i32, i32* %774, i64 -2
%776 = getelementptr inbounds i32, i32* %775, i64 0
%777 = load i32, i32* %776
%778 = icmp sge i32 %772, %777
br i1 %778, label %779, label %781
779: ; preds = %766, %750
%780 = call i32 @stbi__sbgrowf(i8** %13, i32 1, i32 1)
br label %782
781: ; preds = %766
br label %782
782: ; preds = %781, %779
%783 = phi i32 [ %780, %779 ], [ 0, %781 ]
%784 = load i32, i32* %25
%785 = trunc i32 %784 to i8
%786 = load i8*, i8** %13
%787 = load i8*, i8** %13
%788 = bitcast i8* %787 to i32*
%789 = getelementptr inbounds i32, i32* %788, i64 -2
%790 = getelementptr inbounds i32, i32* %789, i64 1
%791 = load i32, i32* %790
%792 = add nsw i32 %791, 1
store i32 %792, i32* %790
%793 = sext i32 %791 to i64
%794 = getelementptr inbounds i8, i8* %786, i64 %793
store i8 %785, i8* %794
%795 = load i8*, i8** %13
%796 = icmp eq i8* %795, null
br i1 %796, label %810, label %797
797: ; preds = %782
%798 = load i8*, i8** %13
%799 = bitcast i8* %798 to i32*
%800 = getelementptr inbounds i32, i32* %799, i64 -2
%801 = getelementptr inbounds i32, i32* %800, i64 1
%802 = load i32, i32* %801
%803 = add nsw i32 %802, 1
%804 = load i8*, i8** %13
%805 = bitcast i8* %804 to i32*
%806 = getelementptr inbounds i32, i32* %805, i64 -2
%807 = getelementptr inbounds i32, i32* %806, i64 0
%808 = load i32, i32* %807
%809 = icmp sge i32 %803, %808
br i1 %809, label %810, label %812
810: ; preds = %797, %782
%811 = call i32 @stbi__sbgrowf(i8** %13, i32 1, i32 1)
br label %813
812: ; preds = %797
br label %813
813: ; preds = %812, %810
%814 = phi i32 [ %811, %810 ], [ 0, %812 ]
%815 = load i32, i32* %24
%816 = lshr i32 %815, 8
%817 = trunc i32 %816 to i8
%818 = load i8*, i8** %13
%819 = load i8*, i8** %13
%820 = bitcast i8* %819 to i32*
%821 = getelementptr inbounds i32, i32* %820, i64 -2
%822 = getelementptr inbounds i32, i32* %821, i64 1
%823 = load i32, i32* %822
%824 = add nsw i32 %823, 1
store i32 %824, i32* %822
%825 = sext i32 %823 to i64
%826 = getelementptr inbounds i8, i8* %818, i64 %825
store i8 %817, i8* %826
%827 = load i8*, i8** %13
%828 = icmp eq i8* %827, null
br i1 %828, label %842, label %829
829: ; preds = %813
%830 = load i8*, i8** %13
%831 = bitcast i8* %830 to i32*
%832 = getelementptr inbounds i32, i32* %831, i64 -2
%833 = getelementptr inbounds i32, i32* %832, i64 1
%834 = load i32, i32* %833
%835 = add nsw i32 %834, 1
%836 = load i8*, i8** %13
%837 = bitcast i8* %836 to i32*
%838 = getelementptr inbounds i32, i32* %837, i64 -2
%839 = getelementptr inbounds i32, i32* %838, i64 0
%840 = load i32, i32* %839
%841 = icmp sge i32 %835, %840
br i1 %841, label %842, label %844
842: ; preds = %829, %813
%843 = call i32 @stbi__sbgrowf(i8** %13, i32 1, i32 1)
br label %845
844: ; preds = %829
br label %845
845: ; preds = %844, %842
%846 = phi i32 [ %843, %842 ], [ 0, %844 ]
%847 = load i32, i32* %24
%848 = trunc i32 %847 to i8
%849 = load i8*, i8** %13
%850 = load i8*, i8** %13
%851 = bitcast i8* %850 to i32*
%852 = getelementptr inbounds i32, i32* %851, i64 -2
%853 = getelementptr inbounds i32, i32* %852, i64 1
%854 = load i32, i32* %853
%855 = add nsw i32 %854, 1
store i32 %855, i32* %853
%856 = sext i32 %854 to i64
%857 = getelementptr inbounds i8, i8* %849, i64 %856
store i8 %848, i8* %857
%858 = load i8*, i8** %13
%859 = bitcast i8* %858 to i32*
%860 = getelementptr inbounds i32, i32* %859, i64 -2
%861 = getelementptr inbounds i32, i32* %860, i64 1
%862 = load i32, i32* %861
%863 = load i32*, i32** %7
store i32 %862, i32* %863
%864 = load i8*, i8** %13
%865 = bitcast i8* %864 to i32*
%866 = getelementptr inbounds i32, i32* %865, i64 -2
%867 = load i8*, i8** %13
%868 = load i32*, i32** %7
%869 = load i32, i32* %868
%870 = call i32 @memmove(i32* %866, i8* %867, i32 %869)
%871 = load i8*, i8** %13
%872 = bitcast i8* %871 to i32*
%873 = getelementptr inbounds i32, i32* %872, i64 -2
%874 = bitcast i32* %873 to i8*
ret i8* %874
}

LLVM IR (-O2):
@stbi_zlib_compress.lengthc = internal unnamed_addr constant [30 x i16] [i16 3, i16 4, i16 5, i16 6, i16 7, i16 8, i16 9, i16 10, i16 11, i16 13, i16 15, i16 17, i16 19, i16 23, i16 27, i16 31, i16 35, i16 43, i16 51, i16 59, i16 67, i16 83, i16 99, i16 115, i16 131, i16 163, i16 195, i16 227, i16 258, i16 259]
@stbi_zlib_compress.lengtheb = internal unnamed_addr constant [29 x i8] c"\00\00\00\00\00\00\00\00\01\01\01\01\02\02\02\02\03\03\03\03\04\04\04\04\05\05\05\05\00"
@stbi_zlib_compress.distc = internal unnamed_addr constant [31 x i16] [i16 1, i16 2, i16 3, i16 4, i16 5, i16 7, i16 9, i16 13, i16 17, i16 25, i16 33, i16 49, i16 65, i16 97, i16 129, i16 193, i16 257, i16 385, i16 513, i16 769, i16 1025, i16 1537, i16 2049, i16 3073, i16 4097, i16 6145, i16 8193, i16 12289, i16 16385, i16 24577, i16 -32768]
@stbi_zlib_compress.disteb = internal unnamed_addr constant [30 x i8] c"\00\00\00\00\01\01\02\02\03\03\04\04\05\05\06\06\07\07\08\08\09\09\0A\0A\0B\0B\0C\0C\0D\0D"
define i8* @stbi_zlib_compress(i8* %0, i32 %1, i32* nocapture writeonly %2, i32 %3) {
%5 = alloca i32
%6 = alloca i32
%7 = alloca i8*
%8 = alloca [16384 x i8**]
%9 = bitcast [16384 x i8**]* %8 to i8*
%10 = bitcast i32* %5 to i8*
store i32 0, i32* %5
%11 = bitcast i32* %6 to i8*
store i32 0, i32* %6
%12 = bitcast i8** %7 to i8*
store i8* null, i8** %7
%13 = icmp sgt i32 %3, 5
%14 = select i1 %13, i32 %3, i32 5
%15 = call i32 @stbi__sbgrowf(i8** %7, i32 1, i32 1)
%16 = load i8*, i8** %7
%17 = getelementptr inbounds i8, i8* %16, i64 -4
%18 = bitcast i8* %17 to i32*
%19 = load i32, i32* %18
%20 = add nsw i32 %19, 1
store i32 %20, i32* %18
%21 = sext i32 %19 to i64
%22 = getelementptr inbounds i8, i8* %16, i64 %21
store i8 120, i8* %22
%23 = load i8*, i8** %7
%24 = icmp eq i8* %23, null
br i1 %24, label %34, label %25
25: ; preds = %4
%26 = getelementptr inbounds i8, i8* %23, i64 -8
%27 = bitcast i8* %26 to i32*
%28 = getelementptr inbounds i8, i8* %23, i64 -4
%29 = bitcast i8* %28 to i32*
%30 = load i32, i32* %29
%31 = add nsw i32 %30, 1
%32 = load i32, i32* %27
%33 = icmp slt i32 %31, %32
br i1 %33, label %41, label %34
34: ; preds = %25, %4
%35 = call i32 @stbi__sbgrowf(i8** %7, i32 1, i32 1)
%36 = load i8*, i8** %7
%37 = getelementptr inbounds i8, i8* %36, i64 -4
%38 = bitcast i8* %37 to i32*
%39 = load i32, i32* %38
%40 = add nsw i32 %39, 1
br label %41
41: ; preds = %25, %34
%42 = phi i32 [ %31, %25 ], [ %40, %34 ]
%43 = phi i32* [ %29, %25 ], [ %38, %34 ]
%44 = phi i32 [ %30, %25 ], [ %39, %34 ]
%45 = phi i8* [ %23, %25 ], [ %36, %34 ]
store i32 %42, i32* %43
%46 = sext i32 %44 to i64
%47 = getelementptr inbounds i8, i8* %45, i64 %46
store i8 94, i8* %47
%48 = load i32, i32* %6
%49 = shl nuw i32 1, %48
%50 = load i32, i32* %5
%51 = or i32 %50, %49
store i32 %51, i32* %5
%52 = add nsw i32 %48, 1
store i32 %52, i32* %6
%53 = load i8*, i8** %7
%54 = call i8* @stbi__zlib_flushf(i8* %53, i32* %5, i32* %6)
store i8* %54, i8** %7
%55 = load i32, i32* %6
%56 = shl nuw i32 1, %55
%57 = load i32, i32* %5
%58 = or i32 %57, %56
store i32 %58, i32* %5
%59 = add nsw i32 %55, 2
store i32 %59, i32* %6
%60 = call i8* @stbi__zlib_flushf(i8* %54, i32* %5, i32* %6)
store i8* %60, i8** %7
%61 = add nsw i32 %1, -3
%62 = icmp sgt i32 %1, 3
br i1 %62, label %63, label %68
63: ; preds = %41
%64 = ptrtoint i8* %0 to i64
%65 = shl nuw nsw i32 %14, 1
%66 = zext i32 %14 to i64
%67 = shl i32 %14, 3
br label %73
68: ; preds = %310, %41
%69 = phi i32 [ 0, %41 ], [ %312, %310 ]
%70 = icmp slt i32 %69, %1
br i1 %70, label %71, label %343
71: ; preds = %68
%72 = sext i32 %69 to i64
br label %314
73: ; preds = %63, %310
%74 = phi i32 [ 0, %63 ], [ %312, %310 ]
%75 = sext i32 %74 to i64
%76 = getelementptr inbounds i8, i8* %0, i64 %75
%77 = call i32 @stbi__zhash(i8* %76)
%78 = and i32 %77, 16383
%79 = zext i32 %78 to i64
%80 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %8, i64 0, i64 %79
%81 = load i8**, i8*** %80
%82 = icmp eq i8** %81, null
br i1 %82, label %140, label %83
83: ; preds = %73
%84 = getelementptr inbounds i8*, i8** %81, i64 -1
%85 = bitcast i8** %84 to i32*
%86 = getelementptr inbounds i32, i32* %85, i64 1
%87 = load i32, i32* %86
%88 = icmp sgt i32 %87, 0
br i1 %88, label %89, label %116
89: ; preds = %83
%90 = add nsw i32 %74, -32768
%91 = sext i32 %90 to i64
%92 = sub nsw i32 %1, %74
%93 = zext i32 %87 to i64
br label %94
94: ; preds = %89, %108
%95 = phi i64 [ 0, %89 ], [ %111, %108 ]
%96 = phi i8* [ null, %89 ], [ %110, %108 ]
%97 = phi i32 [ 3, %89 ], [ %109, %108 ]
%98 = getelementptr inbounds i8*, i8** %81, i64 %95
%99 = load i8*, i8** %98
%100 = ptrtoint i8* %99 to i64
%101 = sub i64 %100, %64
%102 = icmp sgt i64 %101, %91
br i1 %102, label %103, label %108
103: ; preds = %94
%104 = call i32 @stbi__zlib_countm(i8* %99, i8* %76, i32 %92)
%105 = icmp slt i32 %104, %97
br i1 %105, label %108, label %106
106: ; preds = %103
%107 = load i8*, i8** %98
br label %108
108: ; preds = %103, %106, %94
%109 = phi i32 [ %97, %94 ], [ %104, %106 ], [ %97, %103 ]
%110 = phi i8* [ %96, %94 ], [ %107, %106 ], [ %96, %103 ]
%111 = add nuw nsw i64 %95, 1
%112 = icmp eq i64 %111, %93
br i1 %112, label %113, label %94
113: ; preds = %108
%114 = load i8**, i8*** %80
%115 = icmp eq i8** %114, null
br i1 %115, label %140, label %116
116: ; preds = %83, %113
%117 = phi i8* [ %110, %113 ], [ null, %83 ]
%118 = phi i32 [ %109, %113 ], [ 3, %83 ]
%119 = phi i8** [ %114, %113 ], [ %81, %83 ]
%120 = getelementptr inbounds i8*, i8** %119, i64 -1
%121 = bitcast i8** %120 to i32*
%122 = getelementptr inbounds i32, i32* %121, i64 1
%123 = load i32, i32* %122
%124 = icmp eq i32 %123, %65
br i1 %124, label %125, label %133
125: ; preds = %116
%126 = getelementptr inbounds i8*, i8** %119, i64 %66
%127 = call i32 @memcpy(i8** %119, i8** %126, i32 %67)
%128 = bitcast i8*** %80 to i32**
%129 = load i32*, i32** %128
%130 = getelementptr inbounds i32, i32* %129, i64 -1
store i32 %14, i32* %130
%131 = bitcast i32* %129 to i8**
%132 = getelementptr inbounds i32, i32* %129, i64 -2
br label %133
133: ; preds = %116, %125
%134 = phi i32* [ %132, %125 ], [ %121, %116 ]
%135 = phi i8** [ %131, %125 ], [ %119, %116 ]
%136 = phi i32 [ %14, %125 ], [ %123, %116 ]
%137 = add nsw i32 %136, 1
%138 = load i32, i32* %134
%139 = icmp slt i32 %137, %138
br i1 %139, label %151, label %140
140: ; preds = %73, %113, %133
%141 = phi i8* [ %110, %113 ], [ %117, %133 ], [ null, %73 ]
%142 = phi i32 [ %109, %113 ], [ %118, %133 ], [ 3, %73 ]
%143 = bitcast i8*** %80 to i8**
%144 = call i32 @stbi__sbgrowf(i8** %143, i32 1, i32 8)
%145 = load i8**, i8*** %80
%146 = getelementptr inbounds i8*, i8** %145, i64 -1
%147 = bitcast i8** %146 to i32*
%148 = getelementptr inbounds i32, i32* %147, i64 1
%149 = load i32, i32* %148
%150 = add nsw i32 %149, 1
br label %151
151: ; preds = %133, %140
%152 = phi i8* [ %117, %133 ], [ %141, %140 ]
%153 = phi i32 [ %118, %133 ], [ %142, %140 ]
%154 = phi i32 [ %137, %133 ], [ %150, %140 ]
%155 = phi i32* [ %134, %133 ], [ %147, %140 ]
%156 = phi i32 [ %136, %133 ], [ %149, %140 ]
%157 = phi i8** [ %135, %133 ], [ %145, %140 ]
%158 = getelementptr inbounds i32, i32* %155, i64 1
store i32 %154, i32* %158
%159 = sext i32 %156 to i64
%160 = getelementptr inbounds i8*, i8** %157, i64 %159
store i8* %76, i8** %160
%161 = icmp eq i8* %152, null
br i1 %161, label %286, label %162
162: ; preds = %151
%163 = getelementptr inbounds i8, i8* %76, i64 1
%164 = call i32 @stbi__zhash(i8* %163)
%165 = and i32 %164, 16383
%166 = zext i32 %165 to i64
%167 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %8, i64 0, i64 %166
%168 = load i8**, i8*** %167
%169 = icmp eq i8** %168, null
br i1 %169, label %195, label %170
170: ; preds = %162
%171 = getelementptr inbounds i8*, i8** %168, i64 -1
%172 = bitcast i8** %171 to i32*
%173 = getelementptr inbounds i32, i32* %172, i64 1
%174 = load i32, i32* %173
%175 = xor i32 %74, -1
%176 = add i32 %175, %1
%177 = icmp sgt i32 %174, 0
br i1 %177, label %178, label %195
178: ; preds = %170
%179 = add nsw i32 %74, -32767
%180 = sext i32 %179 to i64
%181 = zext i32 %174 to i64
br label %182
182: ; preds = %178, %192
%183 = phi i64 [ 0, %178 ], [ %193, %192 ]
%184 = getelementptr inbounds i8*, i8** %168, i64 %183
%185 = load i8*, i8** %184
%186 = ptrtoint i8* %185 to i64
%187 = sub i64 %186, %64
%188 = icmp sgt i64 %187, %180
br i1 %188, label %189, label %192
189: ; preds = %182
%190 = call i32 @stbi__zlib_countm(i8* %185, i8* %163, i32 %176)
%191 = icmp sgt i32 %190, %153
br i1 %191, label %286, label %192
192: ; preds = %189, %182
%193 = add nuw nsw i64 %183, 1
%194 = icmp eq i64 %193, %181
br i1 %194, label %195, label %182
195: ; preds = %192, %162, %170
%196 = ptrtoint i8* %76 to i64
%197 = ptrtoint i8* %152 to i64
%198 = sub i64 %196, %197
%199 = trunc i64 %198 to i32
%200 = icmp slt i32 %199, 32768
%201 = icmp slt i32 %153, 259
%202 = select i1 %200, i1 %201, i1 false
%203 = zext i1 %202 to i32
%204 = call i32 @assert(i32 %203)
br label %205
205: ; preds = %205, %195
%206 = phi i64 [ %207, %205 ], [ 0, %195 ]
%207 = add nuw nsw i64 %206, 1
%208 = getelementptr inbounds [30 x i16], [30 x i16]* @stbi_zlib_compress.lengthc, i64 0, i64 %207
%209 = load i16, i16* %208
%210 = zext i16 %209 to i32
%211 = icmp slt i32 %153, %210
br i1 %211, label %212, label %205
212: ; preds = %205
%213 = trunc i64 %206 to i32
%214 = icmp ult i32 %213, 23
br i1 %214, label %215, label %223
215: ; preds = %212
%216 = trunc i64 %207 to i32
%217 = call i32 @stbi__zlib_bitrev(i32 %216, i32 7)
%218 = load i32, i32* %6
%219 = shl i32 %217, %218
%220 = load i32, i32* %5
%221 = or i32 %220, %219
store i32 %221, i32* %5
%222 = add nsw i32 %218, 7
br label %231
223: ; preds = %212
%224 = add nuw nsw i32 %213, 169
%225 = call i32 @stbi__zlib_bitrev(i32 %224, i32 8)
%226 = load i32, i32* %6
%227 = shl i32 %225, %226
%228 = load i32, i32* %5
%229 = or i32 %228, %227
store i32 %229, i32* %5
%230 = add nsw i32 %226, 8
br label %231
231: ; preds = %223, %215
%232 = phi i32 [ %222, %215 ], [ %230, %223 ]
store i32 %232, i32* %6
%233 = load i8*, i8** %7
%234 = call i8* @stbi__zlib_flushf(i8* %233, i32* %5, i32* %6)
store i8* %234, i8** %7
%235 = and i64 %206, 4294967295
%236 = add nsw i64 %235, -28
%237 = icmp ult i64 %236, -20
br i1 %237, label %252, label %238
238: ; preds = %231
%239 = getelementptr inbounds [29 x i8], [29 x i8]* @stbi_zlib_compress.lengtheb, i64 0, i64 %235
%240 = getelementptr inbounds [30 x i16], [30 x i16]* @stbi_zlib_compress.lengthc, i64 0, i64 %235
%241 = load i16, i16* %240
%242 = zext i16 %241 to i32
%243 = sub nsw i32 %153, %242
%244 = load i32, i32* %6
%245 = shl i32 %243, %244
%246 = load i32, i32* %5
%247 = or i32 %245, %246
store i32 %247, i32* %5
%248 = load i8, i8* %239
%249 = zext i8 %248 to i32
%250 = add nsw i32 %244, %249
store i32 %250, i32* %6
%251 = call i8* @stbi__zlib_flushf(i8* %234, i32* %5, i32* %6)
store i8* %251, i8** %7
br label %252
252: ; preds = %238, %231
br label %253
253: ; preds = %252, %253
%254 = phi i64 [ %255, %253 ], [ 0, %252 ]
%255 = add nuw nsw i64 %254, 1
%256 = getelementptr inbounds [31 x i16], [31 x i16]* @stbi_zlib_compress.distc, i64 0, i64 %255
%257 = load i16, i16* %256
%258 = zext i16 %257 to i32
%259 = icmp sgt i32 %258, %199
br i1 %259, label %260, label %253
260: ; preds = %253
%261 = trunc i64 %254 to i32
%262 = call i32 @stbi__zlib_bitrev(i32 %261, i32 5)
%263 = load i32, i32* %6
%264 = shl i32 %262, %263
%265 = load i32, i32* %5
%266 = or i32 %265, %264
store i32 %266, i32* %5
%267 = add nsw i32 %263, 5
store i32 %267, i32* %6
%268 = load i8*, i8** %7
%269 = call i8* @stbi__zlib_flushf(i8* %268, i32* %5, i32* %6)
store i8* %269, i8** %7
%270 = and i64 %254, 4294967295
%271 = icmp ult i32 %261, 4
br i1 %271, label %310, label %272
272: ; preds = %260
%273 = getelementptr inbounds [30 x i8], [30 x i8]* @stbi_zlib_compress.disteb, i64 0, i64 %270
%274 = getelementptr inbounds [31 x i16], [31 x i16]* @stbi_zlib_compress.distc, i64 0, i64 %270
%275 = load i16, i16* %274
%276 = zext i16 %275 to i32
%277 = sub nsw i32 %199, %276
%278 = load i32, i32* %6
%279 = shl i32 %277, %278
%280 = load i32, i32* %5
%281 = or i32 %279, %280
store i32 %281, i32* %5
%282 = load i8, i8* %273
%283 = zext i8 %282 to i32
%284 = add nsw i32 %278, %283
store i32 %284, i32* %6
%285 = call i8* @stbi__zlib_flushf(i8* %269, i32* %5, i32* %6)
store i8* %285, i8** %7
br label %310
286: ; preds = %189, %151
%287 = load i8, i8* %76
%288 = zext i8 %287 to i32
%289 = icmp ult i8 %287, -112
br i1 %289, label %290, label %298
290: ; preds = %286
%291 = add nuw nsw i32 %288, 48
%292 = call i32 @stbi__zlib_bitrev(i32 %291, i32 8)
%293 = load i32, i32* %6
%294 = shl i32 %292, %293
%295 = load i32, i32* %5
%296 = or i32 %295, %294
store i32 %296, i32* %5
%297 = add nsw i32 %293, 8
br label %306
298: ; preds = %286
%299 = or i32 %288, 256
%300 = call i32 @stbi__zlib_bitrev(i32 %299, i32 9)
%301 = load i32, i32* %6
%302 = shl i32 %300, %301
%303 = load i32, i32* %5
%304 = or i32 %303, %302
store i32 %304, i32* %5
%305 = add nsw i32 %301, 9
br label %306
306: ; preds = %298, %290
%307 = phi i32 [ %297, %290 ], [ %305, %298 ]
store i32 %307, i32* %6
%308 = load i8*, i8** %7
%309 = call i8* @stbi__zlib_flushf(i8* %308, i32* %5, i32* %6)
store i8* %309, i8** %7
br label %310
310: ; preds = %260, %272, %306
%311 = phi i32 [ 1, %306 ], [ %153, %272 ], [ %153, %260 ]
%312 = add nsw i32 %311, %74
%313 = icmp slt i32 %312, %61
br i1 %313, label %73, label %68
314: ; preds = %71, %336
%315 = phi i64 [ %72, %71 ], [ %340, %336 ]
%316 = getelementptr inbounds i8, i8* %0, i64 %315
%317 = load i8, i8* %316
%318 = zext i8 %317 to i32
%319 = icmp ult i8 %317, -112
br i1 %319, label %320, label %328
320: ; preds = %314
%321 = add nuw nsw i32 %318, 48
%322 = call i32 @stbi__zlib_bitrev(i32 %321, i32 8)
%323 = load i32, i32* %6
%324 = shl i32 %322, %323
%325 = load i32, i32* %5
%326 = or i32 %325, %324
store i32 %326, i32* %5
%327 = add nsw i32 %323, 8
br label %336
328: ; preds = %314
%329 = or i32 %318, 256
%330 = call i32 @stbi__zlib_bitrev(i32 %329, i32 9)
%331 = load i32, i32* %6
%332 = shl i32 %330, %331
%333 = load i32, i32* %5
%334 = or i32 %333, %332
store i32 %334, i32* %5
%335 = add nsw i32 %331, 9
br label %336
336: ; preds = %320, %328
%337 = phi i32 [ %327, %320 ], [ %335, %328 ]
store i32 %337, i32* %6
%338 = load i8*, i8** %7
%339 = call i8* @stbi__zlib_flushf(i8* %338, i32* %5, i32* %6)
store i8* %339, i8** %7
%340 = add nsw i64 %315, 1
%341 = trunc i64 %340 to i32
%342 = icmp eq i32 %341, %1
br i1 %342, label %343, label %314
343: ; preds = %336, %68
%344 = call i32 @stbi__zlib_bitrev(i32 0, i32 7)
%345 = load i32, i32* %6
%346 = shl i32 %344, %345
%347 = load i32, i32* %5
%348 = or i32 %347, %346
store i32 %348, i32* %5
%349 = add nsw i32 %345, 7
store i32 %349, i32* %6
%350 = load i8*, i8** %7
%351 = call i8* @stbi__zlib_flushf(i8* %350, i32* %5, i32* %6)
store i8* %351, i8** %7
%352 = load i32, i32* %6
%353 = icmp eq i32 %352, 0
br i1 %353, label %361, label %354
354: ; preds = %343, %354
%355 = phi i32 [ %359, %354 ], [ %352, %343 ]
%356 = phi i8* [ %358, %354 ], [ %351, %343 ]
%357 = add nsw i32 %355, 1
store i32 %357, i32* %6
%358 = call i8* @stbi__zlib_flushf(i8* %356, i32* %5, i32* %6)
store i8* %358, i8** %7
%359 = load i32, i32* %6
%360 = icmp eq i32 %359, 0
br i1 %360, label %361, label %354
361: ; preds = %354, %343
br label %362
362: ; preds = %361, %371
%363 = phi i64 [ %372, %371 ], [ 0, %361 ]
%364 = getelementptr inbounds [16384 x i8**], [16384 x i8**]* %8, i64 0, i64 %363
%365 = load i8**, i8*** %364
%366 = icmp eq i8** %365, null
br i1 %366, label %371, label %367
367: ; preds = %362
%368 = getelementptr inbounds i8*, i8** %365, i64 -1
%369 = bitcast i8** %368 to i32*
%370 = call i32 @free(i32* %369)
br label %371
371: ; preds = %362, %367
%372 = add nuw nsw i64 %363, 1
%373 = icmp eq i64 %372, 16384
br i1 %373, label %374, label %362
374: ; preds = %371
%375 = icmp sgt i32 %1, 0
br i1 %375, label %376, label %464
376: ; preds = %374
%377 = urem i32 %1, 5552
br label %378
378: ; preds = %376, %457
%379 = phi i32 [ %462, %457 ], [ 0, %376 ]
%380 = phi i32 [ 5552, %457 ], [ %377, %376 ]
%381 = phi i32 [ %461, %457 ], [ 0, %376 ]
%382 = phi i32 [ %460, %457 ], [ 1, %376 ]
%383 = icmp eq i32 %380, 0
br i1 %383, label %457, label %384
384: ; preds = %378
%385 = zext i32 %380 to i64
%386 = add nsw i64 %385, -1
%387 = and i64 %385, 3
%388 = icmp ult i64 %386, 3
br i1 %388, label %434, label %389
389: ; preds = %384
%390 = and i64 %385, 8188
br label %391
391: ; preds = %391, %389
%392 = phi i64 [ 0, %389 ], [ %431, %391 ]
%393 = phi i32 [ %381, %389 ], [ %430, %391 ]
%394 = phi i32 [ %382, %389 ], [ %429, %391 ]
%395 = phi i64 [ 0, %389 ], [ %432, %391 ]
%396 = trunc i64 %392 to i32
%397 = add i32 %379, %396
%398 = zext i32 %397 to i64
%399 = getelementptr inbounds i8, i8* %0, i64 %398
%400 = load i8, i8* %399
%401 = zext i8 %400 to i32
%402 = add i32 %394, %401
%403 = add i32 %402, %393
%404 = trunc i64 %392 to i32
%405 = or i32 %404, 1
%406 = add i32 %379, %405
%407 = zext i32 %406 to i64
%408 = getelementptr inbounds i8, i8* %0, i64 %407
%409 = load i8, i8* %408
%410 = zext i8 %409 to i32
%411 = add i32 %402, %410
%412 = add i32 %411, %403
%413 = trunc i64 %392 to i32
%414 = or i32 %413, 2
%415 = add i32 %379, %414
%416 = zext i32 %415 to i64
%417 = getelementptr inbounds i8, i8* %0, i64 %416
%418 = load i8, i8* %417
%419 = zext i8 %418 to i32
%420 = add i32 %411, %419
%421 = add i32 %420, %412
%422 = trunc i64 %392 to i32
%423 = or i32 %422, 3
%424 = add i32 %379, %423
%425 = zext i32 %424 to i64
%426 = getelementptr inbounds i8, i8* %0, i64 %425
%427 = load i8, i8* %426
%428 = zext i8 %427 to i32
%429 = add i32 %420, %428
%430 = add i32 %429, %421
%431 = add nuw nsw i64 %392, 4
%432 = add i64 %395, 4
%433 = icmp eq i64 %432, %390
br i1 %433, label %434, label %391
434: ; preds = %391, %384
%435 = phi i32 [ undef, %384 ], [ %429, %391 ]
%436 = phi i32 [ undef, %384 ], [ %430, %391 ]
%437 = phi i64 [ 0, %384 ], [ %431, %391 ]
%438 = phi i32 [ %381, %384 ], [ %430, %391 ]
%439 = phi i32 [ %382, %384 ], [ %429, %391 ]
%440 = icmp eq i64 %387, 0
br i1 %440, label %457, label %441
441: ; preds = %434, %441
%442 = phi i64 [ %454, %441 ], [ %437, %434 ]
%443 = phi i32 [ %453, %441 ], [ %438, %434 ]
%444 = phi i32 [ %452, %441 ], [ %439, %434 ]
%445 = phi i64 [ %455, %441 ], [ 0, %434 ]
%446 = trunc i64 %442 to i32
%447 = add i32 %379, %446
%448 = zext i32 %447 to i64
%449 = getelementptr inbounds i8, i8* %0, i64 %448
%450 = load i8, i8* %449
%451 = zext i8 %450 to i32
%452 = add i32 %444, %451
%453 = add i32 %452, %443
%454 = add nuw nsw i64 %442, 1
%455 = add i64 %445, 1
%456 = icmp eq i64 %455, %387
br i1 %456, label %457, label %441
457: ; preds = %434, %441, %378
%458 = phi i32 [ %382, %378 ], [ %435, %434 ], [ %452, %441 ]
%459 = phi i32 [ %381, %378 ], [ %436, %434 ], [ %453, %441 ]
%460 = urem i32 %458, 65521
%461 = urem i32 %459, 65521
%462 = add i32 %379, %380
%463 = icmp slt i32 %462, %1
br i1 %463, label %378, label %464
464: ; preds = %457, %374
%465 = phi i32 [ 1, %374 ], [ %460, %457 ]
%466 = phi i32 [ 0, %374 ], [ %461, %457 ]
%467 = load i8*, i8** %7
%468 = icmp eq i8* %467, null
br i1 %468, label %478, label %469
469: ; preds = %464
%470 = getelementptr inbounds i8, i8* %467, i64 -8
%471 = bitcast i8* %470 to i32*
%472 = getelementptr inbounds i8, i8* %467, i64 -4
%473 = bitcast i8* %472 to i32*
%474 = load i32, i32* %473
%475 = add nsw i32 %474, 1
%476 = load i32, i32* %471
%477 = icmp slt i32 %475, %476
br i1 %477, label %485, label %478
478: ; preds = %469, %464
%479 = call i32 @stbi__sbgrowf(i8** %7, i32 1, i32 1)
%480 = load i8*, i8** %7
%481 = getelementptr inbounds i8, i8* %480, i64 -4
%482 = bitcast i8* %481 to i32*
%483 = load i32, i32* %482
%484 = add nsw i32 %483, 1
br label %485
485: ; preds = %469, %478
%486 = phi i32 [ %475, %469 ], [ %484, %478 ]
%487 = phi i32* [ %473, %469 ], [ %482, %478 ]
%488 = phi i32 [ %474, %469 ], [ %483, %478 ]
%489 = phi i8* [ %467, %469 ], [ %480, %478 ]
%490 = lshr i32 %466, 8
%491 = trunc i32 %490 to i8
store i32 %486, i32* %487
%492 = sext i32 %488 to i64
%493 = getelementptr inbounds i8, i8* %489, i64 %492
store i8 %491, i8* %493
%494 = load i8*, i8** %7
%495 = icmp eq i8* %494, null
br i1 %495, label %505, label %496
496: ; preds = %485
%497 = getelementptr inbounds i8, i8* %494, i64 -8
%498 = bitcast i8* %497 to i32*
%499 = getelementptr inbounds i8, i8* %494, i64 -4
%500 = bitcast i8* %499 to i32*
%501 = load i32, i32* %500
%502 = add nsw i32 %501, 1
%503 = load i32, i32* %498
%504 = icmp slt i32 %502, %503
br i1 %504, label %512, label %505
505: ; preds = %496, %485
%506 = call i32 @stbi__sbgrowf(i8** %7, i32 1, i32 1)
%507 = load i8*, i8** %7
%508 = getelementptr inbounds i8, i8* %507, i64 -4
%509 = bitcast i8* %508 to i32*
%510 = load i32, i32* %509
%511 = add nsw i32 %510, 1
br label %512
512: ; preds = %496, %505
%513 = phi i32 [ %502, %496 ], [ %511, %505 ]
%514 = phi i32* [ %500, %496 ], [ %509, %505 ]
%515 = phi i32 [ %501, %496 ], [ %510, %505 ]
%516 = phi i8* [ %494, %496 ], [ %507, %505 ]
%517 = trunc i32 %466 to i8
store i32 %513, i32* %514
%518 = sext i32 %515 to i64
%519 = getelementptr inbounds i8, i8* %516, i64 %518
store i8 %517, i8* %519
%520 = load i8*, i8** %7
%521 = icmp eq i8* %520, null
br i1 %521, label %531, label %522
522: ; preds = %512
%523 = getelementptr inbounds i8, i8* %520, i64 -8
%524 = bitcast i8* %523 to i32*
%525 = getelementptr inbounds i8, i8* %520, i64 -4
%526 = bitcast i8* %525 to i32*
%527 = load i32, i32* %526
%528 = add nsw i32 %527, 1
%529 = load i32, i32* %524
%530 = icmp slt i32 %528, %529
br i1 %530, label %538, label %531
531: ; preds = %522, %512
%532 = call i32 @stbi__sbgrowf(i8** %7, i32 1, i32 1)
%533 = load i8*, i8** %7
%534 = getelementptr inbounds i8, i8* %533, i64 -4
%535 = bitcast i8* %534 to i32*
%536 = load i32, i32* %535
%537 = add nsw i32 %536, 1
br label %538
538: ; preds = %522, %531
%539 = phi i32 [ %528, %522 ], [ %537, %531 ]
%540 = phi i32* [ %526, %522 ], [ %535, %531 ]
%541 = phi i32 [ %527, %522 ], [ %536, %531 ]
%542 = phi i8* [ %520, %522 ], [ %533, %531 ]
%543 = lshr i32 %465, 8
%544 = trunc i32 %543 to i8
store i32 %539, i32* %540
%545 = sext i32 %541 to i64
%546 = getelementptr inbounds i8, i8* %542, i64 %545
store i8 %544, i8* %546
%547 = load i8*, i8** %7
%548 = icmp eq i8* %547, null
br i1 %548, label %558, label %549
549: ; preds = %538
%550 = getelementptr inbounds i8, i8* %547, i64 -8
%551 = bitcast i8* %550 to i32*
%552 = getelementptr inbounds i8, i8* %547, i64 -4
%553 = bitcast i8* %552 to i32*
%554 = load i32, i32* %553
%555 = add nsw i32 %554, 1
%556 = load i32, i32* %551
%557 = icmp slt i32 %555, %556
br i1 %557, label %565, label %558
558: ; preds = %549, %538
%559 = call i32 @stbi__sbgrowf(i8** %7, i32 1, i32 1)
%560 = load i8*, i8** %7
%561 = getelementptr inbounds i8, i8* %560, i64 -4
%562 = bitcast i8* %561 to i32*
%563 = load i32, i32* %562
%564 = add nsw i32 %563, 1
br label %565
565: ; preds = %549, %558
%566 = phi i32 [ %555, %549 ], [ %564, %558 ]
%567 = phi i32* [ %553, %549 ], [ %562, %558 ]
%568 = phi i32 [ %554, %549 ], [ %563, %558 ]
%569 = phi i8* [ %547, %549 ], [ %560, %558 ]
%570 = trunc i32 %465 to i8
store i32 %566, i32* %567
%571 = sext i32 %568 to i64
%572 = getelementptr inbounds i8, i8* %569, i64 %571
store i8 %570, i8* %572
%573 = bitcast i8** %7 to i32**
%574 = load i32*, i32** %573
%575 = getelementptr inbounds i32, i32* %574, i64 -1
%576 = load i32, i32* %575
store i32 %576, i32* %2
%577 = bitcast i32* %574 to i8*
%578 = getelementptr inbounds i32, i32* %574, i64 -2
%579 = call i32 @memmove(i32* %578, i8* %577, i32 %576)
%580 = load i32*, i32** %573
%581 = getelementptr inbounds i32, i32* %580, i64 -2
%582 = bitcast i32* %581 to i8*
ret i8* %582
}