#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 */

/* Variables and functions */
unsigned int _LZ_StringCompare(unsigned char *, unsigned char *,
                               int /*<<< orphan*/, unsigned int);
scalar_t__ _LZ_WriteVarSize(unsigned int, unsigned char *);
int LZ_Compress(unsigned char *in, unsigned char *out, unsigned int insize) {
  unsigned char marker, symbol;
  unsigned int inpos, outpos, bytesleft, i;
  unsigned int maxoffset, offset, bestoffset;
  unsigned int maxlength, length, bestlength;
  unsigned int histogram[256];
  unsigned char *ptr1, *ptr2;
  if (insize < 1) {
    return 0;
  }
  for (i = 0; i < 256; ++i) {
    histogram[i] = 0;
  }
  for (i = 0; i < insize; ++i) {
    ++histogram[in[i]];
  }
  marker = 0;
  for (i = 1; i < 256; ++i) {
    if (histogram[i] < histogram[marker]) {
      marker = i;
    }
  }
  out[0] = marker;
  inpos = 0;
  outpos = 1;
  bytesleft = insize;
  do {
    if (inpos > 100000)
      maxoffset = 100000;
    else
      maxoffset = inpos;
    ptr1 = &in[inpos];
    bestlength = 3;
    bestoffset = 0;
    for (offset = 3; offset <= maxoffset; ++offset) {
      ptr2 = &ptr1[-(int)offset];
      if ((ptr1[0] == ptr2[0]) && (ptr1[bestlength] == ptr2[bestlength])) {
        maxlength = (bytesleft < offset ? bytesleft : offset);
        length = _LZ_StringCompare(ptr1, ptr2, 0, maxlength);
        if (length > bestlength) {
          bestlength = length;
          bestoffset = offset;
        }
      }
    }
    if ((bestlength >= 8) ||
        ((bestlength == 4) && (bestoffset <= 0x0000007f)) ||
        ((bestlength == 5) && (bestoffset <= 0x00003fff)) ||
        ((bestlength == 6) && (bestoffset <= 0x001fffff)) ||
        ((bestlength == 7) && (bestoffset <= 0x0fffffff))) {
      out[outpos++] = (unsigned char)marker;
      outpos += _LZ_WriteVarSize(bestlength, &out[outpos]);
      outpos += _LZ_WriteVarSize(bestoffset, &out[outpos]);
      inpos += bestlength;
      bytesleft -= bestlength;
    } else {
      symbol = in[inpos++];
      out[outpos++] = symbol;
      if (symbol == marker) {
        out[outpos++] = 0;
      }
      --bytesleft;
    }
  } while (bytesleft > 3);
  while (inpos < insize) {
    if (in[inpos] == marker) {
      out[outpos++] = marker;
      out[outpos++] = 0;
    } else {
      out[outpos++] = in[inpos];
    }
    ++inpos;
  }
  return outpos;
}


x86 assembly (clang, -O0):
<LZ_Compress>:
push   %rbp
mov    %rsp,%rbp
sub    $0x470,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jae    114c <LZ_Compress+0x2c>
movl   $0x0,-0x4(%rbp)
jmp    1508 <LZ_Compress+0x3e8>
movl   $0x0,-0x30(%rbp)
cmpl   $0x100,-0x30(%rbp)
jae    117c <LZ_Compress+0x5c>
mov    -0x30(%rbp),%eax
movl   $0x0,-0x450(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1153 <LZ_Compress+0x33>
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    11b9 <LZ_Compress+0x99>
mov    -0x10(%rbp),%rax
mov    -0x30(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x450(%rbp,%rax,4),%ecx
add    $0x1,%ecx
mov    %ecx,-0x450(%rbp,%rax,4)
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1183 <LZ_Compress+0x63>
movb   $0x0,-0x1d(%rbp)
movl   $0x1,-0x30(%rbp)
cmpl   $0x100,-0x30(%rbp)
jae    1205 <LZ_Compress+0xe5>
mov    -0x30(%rbp),%eax
mov    -0x450(%rbp,%rax,4),%eax
movzbl -0x1d(%rbp),%ecx
cmp    -0x450(%rbp,%rcx,4),%eax
jae    11f2 <LZ_Compress+0xd2>
mov    -0x30(%rbp),%eax
mov    %al,-0x1d(%rbp)
jmp    11f7 <LZ_Compress+0xd7>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    11c4 <LZ_Compress+0xa4>
mov    -0x1d(%rbp),%cl
mov    -0x18(%rbp),%rax
mov    %cl,(%rax)
movl   $0x0,-0x24(%rbp)
movl   $0x1,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
cmpl   $0x186a0,-0x24(%rbp)
jbe    123b <LZ_Compress+0x11b>
movl   $0x186a0,-0x34(%rbp)
jmp    1241 <LZ_Compress+0x121>
mov    -0x24(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x458(%rbp)
movl   $0x3,-0x48(%rbp)
movl   $0x0,-0x3c(%rbp)
movl   $0x3,-0x38(%rbp)
mov    -0x38(%rbp),%eax
cmp    -0x34(%rbp),%eax
ja     1343 <LZ_Compress+0x223>
mov    -0x458(%rbp),%rax
xor    %ecx,%ecx
sub    -0x38(%rbp),%ecx
movslq %ecx,%rcx
add    %rcx,%rax
mov    %rax,-0x460(%rbp)
mov    -0x458(%rbp),%rax
movzbl (%rax),%eax
mov    -0x460(%rbp),%rcx
movzbl (%rcx),%ecx
cmp    %ecx,%eax
jne    1330 <LZ_Compress+0x210>
mov    -0x458(%rbp),%rax
mov    -0x48(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x460(%rbp),%rcx
mov    -0x48(%rbp),%edx
movzbl (%rcx,%rdx,1),%ecx
cmp    %ecx,%eax
jne    1330 <LZ_Compress+0x210>
mov    -0x2c(%rbp),%eax
cmp    -0x38(%rbp),%eax
jae    12e6 <LZ_Compress+0x1c6>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x464(%rbp)
jmp    12ef <LZ_Compress+0x1cf>
mov    -0x38(%rbp),%eax
mov    %eax,-0x464(%rbp)
mov    -0x464(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x458(%rbp),%rdi
mov    -0x460(%rbp),%rsi
mov    -0x40(%rbp),%ecx
xor    %edx,%edx
call   1040 <_LZ_StringCompare@plt>
mov    %eax,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x48(%rbp),%eax
jbe    132b <LZ_Compress+0x20b>
mov    -0x44(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x38(%rbp),%eax
mov    %eax,-0x3c(%rbp)
jmp    1330 <LZ_Compress+0x210>
jmp    1335 <LZ_Compress+0x215>
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    1267 <LZ_Compress+0x147>
cmpl   $0x8,-0x48(%rbp)
jae    13a6 <LZ_Compress+0x286>
cmpl   $0x4,-0x48(%rbp)
jne    1361 <LZ_Compress+0x241>
cmpl   $0x7f,-0x3c(%rbp)
jbe    13a6 <LZ_Compress+0x286>
cmpl   $0x5,-0x48(%rbp)
jne    1378 <LZ_Compress+0x258>
cmpl   $0x3fff,-0x3c(%rbp)
jbe    13a6 <LZ_Compress+0x286>
cmpl   $0x6,-0x48(%rbp)
jne    138f <LZ_Compress+0x26f>
cmpl   $0x1fffff,-0x3c(%rbp)
jbe    13a6 <LZ_Compress+0x286>
cmpl   $0x7,-0x48(%rbp)
jne    1412 <LZ_Compress+0x2f2>
cmpl   $0xfffffff,-0x3c(%rbp)
ja     1412 <LZ_Compress+0x2f2>
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x48(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%eax
add    %rax,%rsi
call   1030 <_LZ_WriteVarSize@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%eax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x3c(%rbp),%edi
mov    -0x18(%rbp),%rsi
mov    -0x28(%rbp),%eax
add    %rax,%rsi
call   1030 <_LZ_WriteVarSize@plt>
mov    %rax,%rcx
mov    -0x28(%rbp),%eax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    146e <LZ_Compress+0x34e>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
mov    (%rax,%rcx,1),%al
mov    %al,-0x1e(%rbp)
mov    -0x1e(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
movzbl -0x1e(%rbp),%eax
movzbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jne    1465 <LZ_Compress+0x345>
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
jmp    1473 <LZ_Compress+0x353>
cmpl   $0x3,-0x2c(%rbp)
ja     1222 <LZ_Compress+0x102>
jmp    1482 <LZ_Compress+0x362>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1502 <LZ_Compress+0x3e2>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
movzbl -0x1d(%rbp),%ecx
cmp    %ecx,%eax
jne    14d6 <LZ_Compress+0x3b6>
mov    -0x1d(%rbp),%dl
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x28(%rbp)
mov    %ecx,%ecx
movb   $0x0,(%rax,%rcx,1)
jmp    14f4 <LZ_Compress+0x3d4>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    (%rax,%rcx,1),%dl
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
mov    %ecx,%esi
add    $0x1,%esi
mov    %esi,-0x28(%rbp)
mov    %ecx,%ecx
mov    %dl,(%rax,%rcx,1)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1482 <LZ_Compress+0x362>
mov    -0x28(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x470,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<LZ_Compress>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x458,%rsp
test   %edx,%edx
je     147c <LZ_Compress+0x34c>
mov    %edx,%ebp
mov    %rsi,%r14
mov    %rdi,%r13
lea    0x50(%rsp),%rdi
xor    %ebx,%ebx
mov    $0x400,%edx
xor    %esi,%esi
call   1030 <memset@plt>
mov    %ebp,%edx
lea    -0x1(%rdx),%rcx
mov    %edx,%eax
and    $0x3,%eax
cmp    $0x3,%rcx
mov    %rdx,0x38(%rsp)
jb     11c5 <LZ_Compress+0x95>
mov    %edx,%ecx
and    $0xfffffffc,%ecx
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl 0x0(%r13,%rbx,1),%edx
addl   $0x1,0x50(%rsp,%rdx,4)
movzbl 0x1(%r13,%rbx,1),%edx
addl   $0x1,0x50(%rsp,%rdx,4)
movzbl 0x2(%r13,%rbx,1),%edx
addl   $0x1,0x50(%rsp,%rdx,4)
movzbl 0x3(%r13,%rbx,1),%edx
addl   $0x1,0x50(%rsp,%rdx,4)
add    $0x4,%rbx
cmp    %rbx,%rcx
jne    1190 <LZ_Compress+0x60>
mov    %ebp,0x4(%rsp)
test   %rax,%rax
je     11f2 <LZ_Compress+0xc2>
add    %r13,%rbx
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rbx,%rcx,1),%edx
addl   $0x1,0x50(%rsp,%rdx,4)
add    $0x1,%rcx
cmp    %rcx,%rax
jne    11e0 <LZ_Compress+0xb0>
mov    $0x3,%eax
mov    $0x1,%cl
xor    %r15d,%r15d
jmp    120f <LZ_Compress+0xdf>
xchg   %ax,%ax
add    $0x3,%rax
add    $0x3,%cl
cmp    $0x102,%rax
je     1248 <LZ_Compress+0x118>
movzbl %r15b,%edx
mov    0x48(%rsp,%rax,4),%esi
cmp    0x50(%rsp,%rdx,4),%esi
jae    1220 <LZ_Compress+0xf0>
movzbl %cl,%edx
mov    0x4c(%rsp,%rax,4),%esi
movzbl %dl,%edi
cmp    0x50(%rsp,%rdi,4),%esi
jae    1233 <LZ_Compress+0x103>
lea    0x1(%rcx),%edx
movzbl %dl,%edx
mov    0x50(%rsp,%rax,4),%esi
movzbl %dl,%edi
mov    %eax,%r15d
cmp    0x50(%rsp,%rdi,4),%esi
jb     1200 <LZ_Compress+0xd0>
mov    %edx,%r15d
jmp    1200 <LZ_Compress+0xd0>
mov    %r15b,(%r14)
lea    -0x3(%r13),%rax
mov    %rax,0x40(%rsp)
xor    %edx,%edx
mov    $0x1,%ecx
mov    0x4(%rsp),%esi
mov    %r14,0x18(%rsp)
mov    %r13,0x10(%rsp)
mov    %r15d,0x8(%rsp)
jmp    128c <LZ_Compress+0x15c>
add    $0xffffffff,%esi
mov    $0x1,%r12d
mov    %eax,%ecx
mov    0x30(%rsp),%rdx
add    %r12d,%edx
cmp    $0x3,%esi
jbe    145a <LZ_Compress+0x32a>
cmp    $0x186a0,%edx
mov    $0x186a0,%eax
cmovb  %edx,%eax
mov    %edx,%edx
mov    %rdx,0x30(%rsp)
lea    (%rdx,%r13,1),%rdi
mov    %rcx,0x28(%rsp)
mov    %ecx,%ebx
cmp    $0x3,%eax
jae    12e0 <LZ_Compress+0x1b0>
mov    (%rdi),%cl
mov    0x28(%rsp),%rdx
lea    0x1(%rdx),%eax
mov    %cl,(%r14,%rbx,1)
mov    0x8(%rsp),%r15d
cmp    %r15b,%cl
jne    1270 <LZ_Compress+0x140>
add    $0x2,%edx
mov    %eax,%eax
movb   $0x0,(%r14,%rax,1)
mov    %edx,%eax
jmp    1270 <LZ_Compress+0x140>
nopw   0x0(%rax,%rax,1)
mov    %rbx,0x20(%rsp)
mov    %esi,%ecx
mov    %rcx,0x48(%rsp)
add    $0x1,%eax
mov    0x30(%rsp),%rcx
mov    0x40(%rsp),%rdx
lea    (%rdx,%rcx,1),%rbx
mov    $0x3,%r13d
mov    $0x3,%r12d
sub    %rax,%r12
xor    %edx,%edx
mov    $0x3,%ebp
mov    %esi,0xc(%rsp)
jmp    1336 <LZ_Compress+0x206>
nopl   0x0(%rax)
add    $0xffffffffffffffff,%rbx
lea    (%r12,%r13,1),%rax
add    $0x1,%rax
add    $0x1,%r13
cmp    $0x3,%rax
je     1380 <LZ_Compress+0x250>
movzbl (%rdi),%eax
cmp    (%rbx),%al
jne    1320 <LZ_Compress+0x1f0>
mov    %ebp,%eax
movzbl (%rdi,%rax,1),%ecx
cmp    (%rbx,%rax,1),%cl
jne    1320 <LZ_Compress+0x1f0>
cmp    0x48(%rsp),%r13
mov    %r13d,%ecx
cmova  %esi,%ecx
mov    %rbx,%rsi
mov    %edx,%r15d
xor    %edx,%edx
mov    %rdi,%r14
call   1050 <_LZ_StringCompare@plt>
mov    %r14,%rdi
mov    %r15d,%edx
mov    0xc(%rsp),%esi
cmp    %ebp,%eax
cmova  %r13d,%edx
cmova  %eax,%ebp
jmp    1320 <LZ_Compress+0x1f0>
nopl   0x0(%rax,%rax,1)
cmp    $0x7,%ebp
jbe    13a0 <LZ_Compress+0x270>
mov    %ebp,%r12d
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
mov    0x20(%rsp),%rbx
jmp    1410 <LZ_Compress+0x2e0>
nopl   0x0(%rax)
cmp    $0x4,%ebp
mov    0x18(%rsp),%r14
mov    0x10(%rsp),%r13
mov    0x20(%rsp),%rbx
jne    13c2 <LZ_Compress+0x292>
mov    $0x4,%r12d
cmp    $0x80,%edx
jb     1410 <LZ_Compress+0x2e0>
cmp    $0x5,%ebp
jne    13d5 <LZ_Compress+0x2a5>
mov    $0x5,%r12d
cmp    $0x4000,%edx
jb     1410 <LZ_Compress+0x2e0>
cmp    $0x6,%ebp
jne    13e8 <LZ_Compress+0x2b8>
mov    $0x6,%r12d
cmp    $0x200000,%edx
jb     1410 <LZ_Compress+0x2e0>
cmp    $0x7,%ebp
jne    12b1 <LZ_Compress+0x181>
mov    $0x7,%r12d
cmp    $0xfffffff,%edx
ja     12b1 <LZ_Compress+0x181>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    0x28(%rsp),%rbp
mov    %rbx,%rdi
mov    %r13,%rbx
lea    0x1(%rbp),%esi
mov    0x8(%rsp),%r15d
mov    %r15b,(%r14,%rdi,1)
add    %r14,%rsi
mov    %r12d,%edi
mov    %edx,%r13d
call   1040 <_LZ_WriteVarSize@plt>
add    %eax,%ebp
add    $0x1,%ebp
lea    (%r14,%rbp,1),%rsi
mov    %r13d,%edi
call   1040 <_LZ_WriteVarSize@plt>
mov    0xc(%rsp),%esi
mov    %rbx,%r13
mov    %rax,%rcx
add    %ebp,%ecx
sub    %r12d,%esi
jmp    127b <LZ_Compress+0x14b>
cmp    0x4(%rsp),%edx
jae    1480 <LZ_Compress+0x350>
mov    %edx,%edi
mov    0x38(%rsp),%rbp
mov    %ebp,%eax
sub    %edx,%eax
mov    %rdi,%rdx
not    %rdx
test   $0x1,%al
jne    1494 <LZ_Compress+0x364>
add    %rbp,%rdx
jne    14d4 <LZ_Compress+0x3a4>
jmp    1482 <LZ_Compress+0x352>
xor    %eax,%eax
jmp    1482 <LZ_Compress+0x352>
mov    %ecx,%eax
add    $0x458,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
mov    0x0(%r13,%rdi,1),%al
cmp    %r15b,%al
jne    14a9 <LZ_Compress+0x379>
mov    %ecx,%eax
add    $0x1,%ecx
mov    %r15b,(%r14,%rax,1)
xor    %eax,%eax
mov    %ecx,%esi
mov    %al,(%r14,%rsi,1)
add    $0x1,%ecx
add    $0x1,%rdi
mov    %ecx,%eax
add    %rbp,%rdx
jne    14d4 <LZ_Compress+0x3a4>
jmp    1482 <LZ_Compress+0x352>
nop
mov    %eax,%esi
mov    %dl,(%r14,%rsi,1)
add    $0x1,%eax
add    $0x2,%rdi
mov    %eax,%ecx
cmp    %rdi,%rbp
je     1482 <LZ_Compress+0x352>
movzbl 0x0(%r13,%rdi,1),%eax
cmp    %r15b,%al
jne    14ea <LZ_Compress+0x3ba>
mov    %ecx,%eax
add    $0x1,%ecx
mov    %r15b,(%r14,%rax,1)
xor    %eax,%eax
mov    %ecx,%edx
mov    %al,(%r14,%rdx,1)
lea    0x1(%rcx),%eax
movzbl 0x1(%r13,%rdi,1),%edx
cmp    %r15b,%dl
jne    14c0 <LZ_Compress+0x390>
add    $0x2,%ecx
mov    %eax,%eax
mov    %r15b,(%r14,%rax,1)
xor    %edx,%edx
mov    %ecx,%eax
jmp    14c0 <LZ_Compress+0x390>

LLVM IR (-O0):
define i32 @LZ_Compress(i8* %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i8
%9 = alloca i8
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
%14 = alloca i32
%15 = alloca i32
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca [256 x i32]
%21 = alloca i8*
%22 = alloca i8*
store i8* %0, i8** %5
store i8* %1, i8** %6
store i32 %2, i32* %7
%23 = load i32, i32* %7
%24 = icmp ult i32 %23, 1
br i1 %24, label %25, label %26
25: ; preds = %3
store i32 0, i32* %4
br label %284
26: ; preds = %3
store i32 0, i32* %13
br label %27
27: ; preds = %34, %26
%28 = load i32, i32* %13
%29 = icmp ult i32 %28, 256
br i1 %29, label %30, label %37
30: ; preds = %27
%31 = load i32, i32* %13
%32 = zext i32 %31 to i64
%33 = getelementptr inbounds [256 x i32], [256 x i32]* %20, i64 0, i64 %32
store i32 0, i32* %33
br label %34
34: ; preds = %30
%35 = load i32, i32* %13
%36 = add i32 %35, 1
store i32 %36, i32* %13
br label %27
37: ; preds = %27
store i32 0, i32* %13
br label %38
38: ; preds = %52, %37
%39 = load i32, i32* %13
%40 = load i32, i32* %7
%41 = icmp ult i32 %39, %40
br i1 %41, label %42, label %55
42: ; preds = %38
%43 = load i8*, i8** %5
%44 = load i32, i32* %13
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds i8, i8* %43, i64 %45
%47 = load i8, i8* %46
%48 = zext i8 %47 to i64
%49 = getelementptr inbounds [256 x i32], [256 x i32]* %20, i64 0, i64 %48
%50 = load i32, i32* %49
%51 = add i32 %50, 1
store i32 %51, i32* %49
br label %52
52: ; preds = %42
%53 = load i32, i32* %13
%54 = add i32 %53, 1
store i32 %54, i32* %13
br label %38
55: ; preds = %38
store i8 0, i8* %8
store i32 1, i32* %13
br label %56
56: ; preds = %73, %55
%57 = load i32, i32* %13
%58 = icmp ult i32 %57, 256
br i1 %58, label %59, label %76
59: ; preds = %56
%60 = load i32, i32* %13
%61 = zext i32 %60 to i64
%62 = getelementptr inbounds [256 x i32], [256 x i32]* %20, i64 0, i64 %61
%63 = load i32, i32* %62
%64 = load i8, i8* %8
%65 = zext i8 %64 to i64
%66 = getelementptr inbounds [256 x i32], [256 x i32]* %20, i64 0, i64 %65
%67 = load i32, i32* %66
%68 = icmp ult i32 %63, %67
br i1 %68, label %69, label %72
69: ; preds = %59
%70 = load i32, i32* %13
%71 = trunc i32 %70 to i8
store i8 %71, i8* %8
br label %72
72: ; preds = %69, %59
br label %73
73: ; preds = %72
%74 = load i32, i32* %13
%75 = add i32 %74, 1
store i32 %75, i32* %13
br label %56
76: ; preds = %56
%77 = load i8, i8* %8
%78 = load i8*, i8** %6
%79 = getelementptr inbounds i8, i8* %78, i64 0
store i8 %77, i8* %79
store i32 0, i32* %10
store i32 1, i32* %11
%80 = load i32, i32* %7
store i32 %80, i32* %12
br label %81
81: ; preds = %238, %76
%82 = load i32, i32* %10
%83 = icmp ugt i32 %82, 100000
br i1 %83, label %84, label %85
84: ; preds = %81
store i32 100000, i32* %14
br label %87
85: ; preds = %81
%86 = load i32, i32* %10
store i32 %86, i32* %14
br label %87
87: ; preds = %85, %84
%88 = load i8*, i8** %5
%89 = load i32, i32* %10
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds i8, i8* %88, i64 %90
store i8* %91, i8** %21
store i32 3, i32* %19
store i32 0, i32* %16
store i32 3, i32* %15
br label %92
92: ; preds = %147, %87
%93 = load i32, i32* %15
%94 = load i32, i32* %14
%95 = icmp ule i32 %93, %94
br i1 %95, label %96, label %150
96: ; preds = %92
%97 = load i8*, i8** %21
%98 = load i32, i32* %15
%99 = sub nsw i32 0, %98
%100 = sext i32 %99 to i64
%101 = getelementptr inbounds i8, i8* %97, i64 %100
store i8* %101, i8** %22
%102 = load i8*, i8** %21
%103 = getelementptr inbounds i8, i8* %102, i64 0
%104 = load i8, i8* %103
%105 = zext i8 %104 to i32
%106 = load i8*, i8** %22
%107 = getelementptr inbounds i8, i8* %106, i64 0
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = icmp eq i32 %105, %109
br i1 %110, label %111, label %146
111: ; preds = %96
%112 = load i8*, i8** %21
%113 = load i32, i32* %19
%114 = zext i32 %113 to i64
%115 = getelementptr inbounds i8, i8* %112, i64 %114
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
%118 = load i8*, i8** %22
%119 = load i32, i32* %19
%120 = zext i32 %119 to i64
%121 = getelementptr inbounds i8, i8* %118, i64 %120
%122 = load i8, i8* %121
%123 = zext i8 %122 to i32
%124 = icmp eq i32 %117, %123
br i1 %124, label %125, label %146
125: ; preds = %111
%126 = load i32, i32* %12
%127 = load i32, i32* %15
%128 = icmp ult i32 %126, %127
br i1 %128, label %129, label %131
129: ; preds = %125
%130 = load i32, i32* %12
br label %133
131: ; preds = %125
%132 = load i32, i32* %15
br label %133
133: ; preds = %131, %129
%134 = phi i32 [ %130, %129 ], [ %132, %131 ]
store i32 %134, i32* %17
%135 = load i8*, i8** %21
%136 = load i8*, i8** %22
%137 = load i32, i32* %17
%138 = call i32 @_LZ_StringCompare(i8* %135, i8* %136, i32 0, i32 %137)
store i32 %138, i32* %18
%139 = load i32, i32* %18
%140 = load i32, i32* %19
%141 = icmp ugt i32 %139, %140
br i1 %141, label %142, label %145
142: ; preds = %133
%143 = load i32, i32* %18
store i32 %143, i32* %19
%144 = load i32, i32* %15
store i32 %144, i32* %16
br label %145
145: ; preds = %142, %133
br label %146
146: ; preds = %145, %111, %96
br label %147
147: ; preds = %146
%148 = load i32, i32* %15
%149 = add i32 %148, 1
store i32 %149, i32* %15
br label %92
150: ; preds = %92
%151 = load i32, i32* %19
%152 = icmp uge i32 %151, 8
br i1 %152, label %177, label %153
153: ; preds = %150
%154 = load i32, i32* %19
%155 = icmp eq i32 %154, 4
br i1 %155, label %156, label %159
156: ; preds = %153
%157 = load i32, i32* %16
%158 = icmp ule i32 %157, 127
br i1 %158, label %177, label %159
159: ; preds = %156, %153
%160 = load i32, i32* %19
%161 = icmp eq i32 %160, 5
br i1 %161, label %162, label %165
162: ; preds = %159
%163 = load i32, i32* %16
%164 = icmp ule i32 %163, 16383
br i1 %164, label %177, label %165
165: ; preds = %162, %159
%166 = load i32, i32* %19
%167 = icmp eq i32 %166, 6
br i1 %167, label %168, label %171
168: ; preds = %165
%169 = load i32, i32* %16
%170 = icmp ule i32 %169, 2097151
br i1 %170, label %177, label %171
171: ; preds = %168, %165
%172 = load i32, i32* %19
%173 = icmp eq i32 %172, 7
br i1 %173, label %174, label %210
174: ; preds = %171
%175 = load i32, i32* %16
%176 = icmp ule i32 %175, 268435455
br i1 %176, label %177, label %210
177: ; preds = %174, %168, %162, %156, %150
%178 = load i8, i8* %8
%179 = load i8*, i8** %6
%180 = load i32, i32* %11
%181 = add i32 %180, 1
store i32 %181, i32* %11
%182 = zext i32 %180 to i64
%183 = getelementptr inbounds i8, i8* %179, i64 %182
store i8 %178, i8* %183
%184 = load i32, i32* %19
%185 = load i8*, i8** %6
%186 = load i32, i32* %11
%187 = zext i32 %186 to i64
%188 = getelementptr inbounds i8, i8* %185, i64 %187
%189 = call i64 @_LZ_WriteVarSize(i32 %184, i8* %188)
%190 = load i32, i32* %11
%191 = zext i32 %190 to i64
%192 = add nsw i64 %191, %189
%193 = trunc i64 %192 to i32
store i32 %193, i32* %11
%194 = load i32, i32* %16
%195 = load i8*, i8** %6
%196 = load i32, i32* %11
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds i8, i8* %195, i64 %197
%199 = call i64 @_LZ_WriteVarSize(i32 %194, i8* %198)
%200 = load i32, i32* %11
%201 = zext i32 %200 to i64
%202 = add nsw i64 %201, %199
%203 = trunc i64 %202 to i32
store i32 %203, i32* %11
%204 = load i32, i32* %19
%205 = load i32, i32* %10
%206 = add i32 %205, %204
store i32 %206, i32* %10
%207 = load i32, i32* %19
%208 = load i32, i32* %12
%209 = sub i32 %208, %207
store i32 %209, i32* %12
br label %237
210: ; preds = %174, %171
%211 = load i8*, i8** %5
%212 = load i32, i32* %10
%213 = add i32 %212, 1
store i32 %213, i32* %10
%214 = zext i32 %212 to i64
%215 = getelementptr inbounds i8, i8* %211, i64 %214
%216 = load i8, i8* %215
store i8 %216, i8* %9
%217 = load i8, i8* %9
%218 = load i8*, i8** %6
%219 = load i32, i32* %11
%220 = add i32 %219, 1
store i32 %220, i32* %11
%221 = zext i32 %219 to i64
%222 = getelementptr inbounds i8, i8* %218, i64 %221
store i8 %217, i8* %222
%223 = load i8, i8* %9
%224 = zext i8 %223 to i32
%225 = load i8, i8* %8
%226 = zext i8 %225 to i32
%227 = icmp eq i32 %224, %226
br i1 %227, label %228, label %234
228: ; preds = %210
%229 = load i8*, i8** %6
%230 = load i32, i32* %11
%231 = add i32 %230, 1
store i32 %231, i32* %11
%232 = zext i32 %230 to i64
%233 = getelementptr inbounds i8, i8* %229, i64 %232
store i8 0, i8* %233
br label %234
234: ; preds = %228, %210
%235 = load i32, i32* %12
%236 = add i32 %235, -1
store i32 %236, i32* %12
br label %237
237: ; preds = %234, %177
br label %238
238: ; preds = %237
%239 = load i32, i32* %12
%240 = icmp ugt i32 %239, 3
br i1 %240, label %81, label %241
241: ; preds = %238
br label %242
242: ; preds = %279, %241
%243 = load i32, i32* %10
%244 = load i32, i32* %7
%245 = icmp ult i32 %243, %244
br i1 %245, label %246, label %282
246: ; preds = %242
%247 = load i8*, i8** %5
%248 = load i32, i32* %10
%249 = zext i32 %248 to i64
%250 = getelementptr inbounds i8, i8* %247, i64 %249
%251 = load i8, i8* %250
%252 = zext i8 %251 to i32
%253 = load i8, i8* %8
%254 = zext i8 %253 to i32
%255 = icmp eq i32 %252, %254
br i1 %255, label %256, label %268
256: ; preds = %246
%257 = load i8, i8* %8
%258 = load i8*, i8** %6
%259 = load i32, i32* %11
%260 = add i32 %259, 1
store i32 %260, i32* %11
%261 = zext i32 %259 to i64
%262 = getelementptr inbounds i8, i8* %258, i64 %261
store i8 %257, i8* %262
%263 = load i8*, i8** %6
%264 = load i32, i32* %11
%265 = add i32 %264, 1
store i32 %265, i32* %11
%266 = zext i32 %264 to i64
%267 = getelementptr inbounds i8, i8* %263, i64 %266
store i8 0, i8* %267
br label %279
268: ; preds = %246
%269 = load i8*, i8** %5
%270 = load i32, i32* %10
%271 = zext i32 %270 to i64
%272 = getelementptr inbounds i8, i8* %269, i64 %271
%273 = load i8, i8* %272
%274 = load i8*, i8** %6
%275 = load i32, i32* %11
%276 = add i32 %275, 1
store i32 %276, i32* %11
%277 = zext i32 %275 to i64
%278 = getelementptr inbounds i8, i8* %274, i64 %277
store i8 %273, i8* %278
br label %279
279: ; preds = %268, %256
%280 = load i32, i32* %10
%281 = add i32 %280, 1
store i32 %281, i32* %10
br label %242
282: ; preds = %242
%283 = load i32, i32* %11
store i32 %283, i32* %4
br label %284
284: ; preds = %282, %25
%285 = load i32, i32* %4
ret i32 %285
}

LLVM IR (-O2):
define i32 @LZ_Compress(i8* %0, i8* %1, i32 %2) {
%4 = alloca [256 x i32]
%5 = bitcast [256 x i32]* %4 to i8*
%6 = icmp eq i32 %2, 0
br i1 %6, label %256, label %7
7: ; preds = %3
%8 = zext i32 %2 to i64
%9 = add nsw i64 %8, -1
%10 = and i64 %8, 3
%11 = icmp ult i64 %9, 3
br i1 %11, label %47, label %12
12: ; preds = %7
%13 = and i64 %8, 4294967292
br label %14
14: ; preds = %14, %12
%15 = phi i64 [ 0, %12 ], [ %44, %14 ]
%16 = phi i64 [ 0, %12 ], [ %45, %14 ]
%17 = getelementptr inbounds i8, i8* %0, i64 %15
%18 = load i8, i8* %17
%19 = zext i8 %18 to i64
%20 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %19
%21 = load i32, i32* %20
%22 = add i32 %21, 1
store i32 %22, i32* %20
%23 = or i64 %15, 1
%24 = getelementptr inbounds i8, i8* %0, i64 %23
%25 = load i8, i8* %24
%26 = zext i8 %25 to i64
%27 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %26
%28 = load i32, i32* %27
%29 = add i32 %28, 1
store i32 %29, i32* %27
%30 = or i64 %15, 2
%31 = getelementptr inbounds i8, i8* %0, i64 %30
%32 = load i8, i8* %31
%33 = zext i8 %32 to i64
%34 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %33
%35 = load i32, i32* %34
%36 = add i32 %35, 1
store i32 %36, i32* %34
%37 = or i64 %15, 3
%38 = getelementptr inbounds i8, i8* %0, i64 %37
%39 = load i8, i8* %38
%40 = zext i8 %39 to i64
%41 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %40
%42 = load i32, i32* %41
%43 = add i32 %42, 1
store i32 %43, i32* %41
%44 = add nuw nsw i64 %15, 4
%45 = add i64 %16, 4
%46 = icmp eq i64 %45, %13
br i1 %46, label %47, label %14
47: ; preds = %14, %7
%48 = phi i64 [ 0, %7 ], [ %44, %14 ]
%49 = icmp eq i64 %10, 0
br i1 %49, label %62, label %50
50: ; preds = %47, %50
%51 = phi i64 [ %59, %50 ], [ %48, %47 ]
%52 = phi i64 [ %60, %50 ], [ 0, %47 ]
%53 = getelementptr inbounds i8, i8* %0, i64 %51
%54 = load i8, i8* %53
%55 = zext i8 %54 to i64
%56 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %55
%57 = load i32, i32* %56
%58 = add i32 %57, 1
store i32 %58, i32* %56
%59 = add nuw nsw i64 %51, 1
%60 = add i64 %52, 1
%61 = icmp eq i64 %60, %10
br i1 %61, label %62, label %50
62: ; preds = %50, %47
br label %63
63: ; preds = %63, %62
%64 = phi i64 [ 1, %62 ], [ %95, %63 ]
%65 = phi i8 [ 0, %62 ], [ %94, %63 ]
%66 = phi i32 [ 1, %62 ], [ %96, %63 ]
%67 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %64
%68 = load i32, i32* %67
%69 = zext i8 %65 to i64
%70 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %69
%71 = load i32, i32* %70
%72 = icmp ult i32 %68, %71
%73 = trunc i32 %66 to i8
%74 = select i1 %72, i8 %73, i8 %65
%75 = add nuw nsw i64 %64, 1
%76 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %75
%77 = load i32, i32* %76
%78 = zext i8 %74 to i64
%79 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %78
%80 = load i32, i32* %79
%81 = icmp ult i32 %77, %80
%82 = trunc i32 %66 to i8
%83 = add i8 %82, 1
%84 = select i1 %81, i8 %83, i8 %74
%85 = add nuw nsw i64 %64, 2
%86 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %85
%87 = load i32, i32* %86
%88 = zext i8 %84 to i64
%89 = getelementptr inbounds [256 x i32], [256 x i32]* %4, i64 0, i64 %88
%90 = load i32, i32* %89
%91 = icmp ult i32 %87, %90
%92 = trunc i32 %66 to i8
%93 = add i8 %92, 2
%94 = select i1 %91, i8 %93, i8 %84
%95 = add nuw nsw i64 %64, 3
%96 = add nuw nsw i32 %66, 3
%97 = icmp eq i64 %95, 256
br i1 %97, label %98, label %63
98: ; preds = %63
store i8 %94, i8* %1
br label %99
99: ; preds = %188, %98
%100 = phi i32 [ %2, %98 ], [ %189, %188 ]
%101 = phi i32 [ 1, %98 ], [ %190, %188 ]
%102 = phi i32 [ 0, %98 ], [ %192, %188 ]
%103 = icmp ult i32 %102, 100000
%104 = select i1 %103, i32 %102, i32 100000
%105 = zext i32 %102 to i64
%106 = getelementptr inbounds i8, i8* %0, i64 %105
%107 = icmp ult i32 %104, 3
br i1 %107, label %175, label %108
108: ; preds = %99
%109 = zext i32 %100 to i64
%110 = add nuw nsw i32 %104, 1
%111 = zext i32 %110 to i64
br label %112
112: ; preds = %108, %136
%113 = phi i64 [ 3, %108 ], [ %139, %136 ]
%114 = phi i32 [ 3, %108 ], [ %138, %136 ]
%115 = phi i32 [ 0, %108 ], [ %137, %136 ]
%116 = sub nsw i64 0, %113
%117 = getelementptr inbounds i8, i8* %106, i64 %116
%118 = load i8, i8* %106
%119 = load i8, i8* %117
%120 = icmp eq i8 %118, %119
br i1 %120, label %121, label %136
121: ; preds = %112
%122 = zext i32 %114 to i64
%123 = getelementptr inbounds i8, i8* %106, i64 %122
%124 = load i8, i8* %123
%125 = getelementptr inbounds i8, i8* %117, i64 %122
%126 = load i8, i8* %125
%127 = icmp eq i8 %124, %126
br i1 %127, label %128, label %136
128: ; preds = %121
%129 = icmp ugt i64 %113, %109
%130 = trunc i64 %113 to i32
%131 = select i1 %129, i32 %100, i32 %130
%132 = tail call i32 @_LZ_StringCompare(i8* %106, i8* %117, i32 0, i32 %131)
%133 = icmp ugt i32 %132, %114
%134 = select i1 %133, i32 %130, i32 %115
%135 = select i1 %133, i32 %132, i32 %114
br label %136
136: ; preds = %128, %112, %121
%137 = phi i32 [ %115, %121 ], [ %115, %112 ], [ %134, %128 ]
%138 = phi i32 [ %114, %121 ], [ %114, %112 ], [ %135, %128 ]
%139 = add nuw nsw i64 %113, 1
%140 = icmp eq i64 %139, %111
br i1 %140, label %141, label %112
141: ; preds = %136
%142 = icmp ugt i32 %138, 7
br i1 %142, label %159, label %143
143: ; preds = %141
%144 = icmp eq i32 %138, 4
%145 = icmp ult i32 %137, 128
%146 = select i1 %144, i1 %145, i1 false
br i1 %146, label %159, label %147
147: ; preds = %143
%148 = icmp eq i32 %138, 5
%149 = icmp ult i32 %137, 16384
%150 = select i1 %148, i1 %149, i1 false
br i1 %150, label %159, label %151
151: ; preds = %147
%152 = icmp eq i32 %138, 6
%153 = icmp ult i32 %137, 2097152
%154 = select i1 %152, i1 %153, i1 false
br i1 %154, label %159, label %155
155: ; preds = %151
%156 = icmp eq i32 %138, 7
%157 = icmp ult i32 %137, 268435456
%158 = select i1 %156, i1 %157, i1 false
br i1 %158, label %159, label %175
159: ; preds = %155, %151, %147, %143, %141
%160 = phi i32 [ 7, %155 ], [ 6, %151 ], [ 5, %147 ], [ 4, %143 ], [ %138, %141 ]
%161 = add i32 %101, 1
%162 = zext i32 %101 to i64
%163 = getelementptr inbounds i8, i8* %1, i64 %162
store i8 %94, i8* %163
%164 = zext i32 %161 to i64
%165 = getelementptr inbounds i8, i8* %1, i64 %164
%166 = tail call i64 @_LZ_WriteVarSize(i32 %160, i8* %165)
%167 = trunc i64 %166 to i32
%168 = add i32 %161, %167
%169 = zext i32 %168 to i64
%170 = getelementptr inbounds i8, i8* %1, i64 %169
%171 = tail call i64 @_LZ_WriteVarSize(i32 %137, i8* %170)
%172 = trunc i64 %171 to i32
%173 = add i32 %168, %172
%174 = sub i32 %100, %160
br label %188
175: ; preds = %99, %155
%176 = load i8, i8* %106
%177 = add i32 %101, 1
%178 = zext i32 %101 to i64
%179 = getelementptr inbounds i8, i8* %1, i64 %178
store i8 %176, i8* %179
%180 = icmp eq i8 %176, %94
br i1 %180, label %181, label %185
181: ; preds = %175
%182 = add i32 %101, 2
%183 = zext i32 %177 to i64
%184 = getelementptr inbounds i8, i8* %1, i64 %183
store i8 0, i8* %184
br label %185
185: ; preds = %181, %175
%186 = phi i32 [ %182, %181 ], [ %177, %175 ]
%187 = add i32 %100, -1
br label %188
188: ; preds = %159, %185
%189 = phi i32 [ %174, %159 ], [ %187, %185 ]
%190 = phi i32 [ %173, %159 ], [ %186, %185 ]
%191 = phi i32 [ %160, %159 ], [ 1, %185 ]
%192 = add i32 %191, %102
%193 = icmp ugt i32 %189, 3
br i1 %193, label %99, label %194
194: ; preds = %188
%195 = icmp ult i32 %192, %2
br i1 %195, label %196, label %256
196: ; preds = %194
%197 = zext i32 %192 to i64
%198 = zext i32 %2 to i64
%199 = sub nsw i64 %8, %197
%200 = xor i64 %197, -1
%201 = and i64 %199, 1
%202 = icmp eq i64 %201, 0
br i1 %202, label %218, label %203
203: ; preds = %196
%204 = getelementptr inbounds i8, i8* %0, i64 %197
%205 = load i8, i8* %204
%206 = icmp eq i8 %205, %94
br i1 %206, label %207, label %211
207: ; preds = %203
%208 = add i32 %190, 1
%209 = zext i32 %190 to i64
%210 = getelementptr inbounds i8, i8* %1, i64 %209
store i8 %94, i8* %210
br label %211
211: ; preds = %207, %203
%212 = phi i32 [ %208, %207 ], [ %190, %203 ]
%213 = phi i8 [ 0, %207 ], [ %205, %203 ]
%214 = zext i32 %212 to i64
%215 = getelementptr inbounds i8, i8* %1, i64 %214
store i8 %213, i8* %215
%216 = add i32 %212, 1
%217 = add nuw nsw i64 %197, 1
br label %218
218: ; preds = %211, %196
%219 = phi i32 [ undef, %196 ], [ %216, %211 ]
%220 = phi i64 [ %197, %196 ], [ %217, %211 ]
%221 = phi i32 [ %190, %196 ], [ %216, %211 ]
%222 = sub nsw i64 0, %8
%223 = icmp eq i64 %200, %222
br i1 %223, label %256, label %224
224: ; preds = %218, %248
%225 = phi i64 [ %254, %248 ], [ %220, %218 ]
%226 = phi i32 [ %253, %248 ], [ %221, %218 ]
%227 = getelementptr inbounds i8, i8* %0, i64 %225
%228 = load i8, i8* %227
%229 = icmp eq i8 %228, %94
br i1 %229, label %230, label %234
230: ; preds = %224
%231 = add i32 %226, 1
%232 = zext i32 %226 to i64
%233 = getelementptr inbounds i8, i8* %1, i64 %232
store i8 %94, i8* %233
br label %234
234: ; preds = %224, %230
%235 = phi i32 [ %231, %230 ], [ %226, %224 ]
%236 = phi i8 [ 0, %230 ], [ %228, %224 ]
%237 = zext i32 %235 to i64
%238 = getelementptr inbounds i8, i8* %1, i64 %237
store i8 %236, i8* %238
%239 = add i32 %235, 1
%240 = add nuw nsw i64 %225, 1
%241 = getelementptr inbounds i8, i8* %0, i64 %240
%242 = load i8, i8* %241
%243 = icmp eq i8 %242, %94
br i1 %243, label %244, label %248
244: ; preds = %234
%245 = add i32 %235, 2
%246 = zext i32 %239 to i64
%247 = getelementptr inbounds i8, i8* %1, i64 %246
store i8 %94, i8* %247
br label %248
248: ; preds = %244, %234
%249 = phi i32 [ %245, %244 ], [ %239, %234 ]
%250 = phi i8 [ 0, %244 ], [ %242, %234 ]
%251 = zext i32 %249 to i64
%252 = getelementptr inbounds i8, i8* %1, i64 %251
store i8 %250, i8* %252
%253 = add i32 %249, 1
%254 = add nuw nsw i64 %225, 2
%255 = icmp eq i64 %254, %198
br i1 %255, label %256, label %224
256: ; preds = %218, %248, %194, %3
%257 = phi i32 [ 0, %3 ], [ %190, %194 ], [ %219, %218 ], [ %253, %248 ]
ret i32 %257
}