int KENS_Kosinski(unsigned char *in, int insz, unsigned char *out, int outsz,
                  int Moduled) {
  unsigned short BITFIELD;
  unsigned char BFP;
  unsigned char Bit;
  unsigned char Byte;
  unsigned char Low, High;
  int Pointer;
  long Count = 0;
  long Offset = 0;
  long FullSize = 0;
  long DecBytes = 0;
  unsigned char *p = out;
  if (Moduled) {
    High = *in++;
    Low = *in++;
    FullSize = ((long)High << 8) + (long)Low;
  }
start:
  BITFIELD = *(unsigned short *)in;
  in += 2;
  BFP = 0;
  while (1) {
    if (BITFIELD & (1 << BFP++))
      Bit = 1;
    else
      Bit = 0;
    if (BFP >= 16) {
      BITFIELD = *(unsigned short *)in;
      in += 2;
      BFP = 0;
    }
    if (Bit) {
      Byte = *in++;
      if (p >= (out + outsz))
        return (-1);
      *p++ = Byte;
      DecBytes += 1;
    } else {
      if (BITFIELD & (1 << BFP++))
        Bit = 1;
      else
        Bit = 0;
      if (BFP >= 16) {
        BITFIELD = *(unsigned short *)in;
        in += 2;
        BFP = 0;
      }
      if (Bit) {
        Low = *in++;
        High = *in++;
        Count = (long)(High & 0x07);
        if (Count == 0) {
          Count = *in++;
          if (Count == 0)
            goto end;
          if (Count == 1)
            continue;
        } else {
          Count += 1;
        }
        Offset = 0xFFFFE000 | ((long)(0xF8 & High) << 5) | (long)Low;
      } else {
        if (BITFIELD & (1 << BFP++))
          Low = 1;
        else
          Low = 0;
        if (BFP >= 16) {
          BITFIELD = *(unsigned short *)in;
          in += 2;
          BFP = 0;
        }
        if (BITFIELD & (1 << BFP++))
          High = 1;
        else
          High = 0;
        if (BFP >= 16) {
          BITFIELD = *(unsigned short *)in;
          in += 2;
          BFP = 0;
        }
        Count = ((long)Low) * 2 + ((long)High) + 1;
        Offset = *in++;
        Offset |= 0xFFFFFF00;
      }
      int i;
      for (i = 0; i <= Count; i++) {
        Pointer = (p - out);
        p += Offset;
        Byte = *in++;
        p = out + Pointer;
        if (p >= (out + outsz))
          return (-1);
        *p++ = Byte;
      }
      DecBytes += Count + 1;
    }
  }
end:
  if (Moduled) {
    if (DecBytes < FullSize) {
      do {
        Byte = *in++;
      } while (Byte == 0);
      in--;
      goto start;
    }
  }
  return (p - out);
}


x86 assembly (clang, -O0):
<KENS_Kosinski>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x10(%rbp)
mov    %esi,-0x14(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %ecx,-0x24(%rbp)
mov    %r8d,-0x28(%rbp)
movq   $0x0,-0x40(%rbp)
movq   $0x0,-0x48(%rbp)
movq   $0x0,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpl   $0x0,-0x28(%rbp)
je     1183 <KENS_Kosinski+0x83>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2f(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2e(%rbp)
movzbl -0x2f(%rbp),%eax
shl    $0x8,%rax
movzbl -0x2e(%rbp),%ecx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
jmp    1188 <KENS_Kosinski+0x88>
mov    -0x10(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
movb   $0x0,-0x2b(%rbp)
movzwl -0x2a(%rbp),%eax
mov    -0x2b(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0x2b(%rbp)
movzbl %cl,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     11d2 <KENS_Kosinski+0xd2>
movb   $0x1,-0x2c(%rbp)
jmp    11d6 <KENS_Kosinski+0xd6>
movb   $0x0,-0x2c(%rbp)
movzbl -0x2b(%rbp),%eax
cmp    $0x10,%eax
jl     11fe <KENS_Kosinski+0xfe>
mov    -0x10(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
movb   $0x0,-0x2b(%rbp)
cmpb   $0x0,-0x2c(%rbp)
je     1265 <KENS_Kosinski+0x165>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2d(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jb     1240 <KENS_Kosinski+0x140>
movl   $0xffffffff,-0x4(%rbp)
jmp    1581 <KENS_Kosinski+0x481>
mov    -0x2d(%rbp),%cl
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    %cl,(%rax)
mov    -0x58(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x58(%rbp)
jmp    151a <KENS_Kosinski+0x41a>
movzwl -0x2a(%rbp),%eax
mov    -0x2b(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0x2b(%rbp)
movzbl %cl,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1294 <KENS_Kosinski+0x194>
movb   $0x1,-0x2c(%rbp)
jmp    1298 <KENS_Kosinski+0x198>
movb   $0x0,-0x2c(%rbp)
movzbl -0x2b(%rbp),%eax
cmp    $0x10,%eax
jl     12c0 <KENS_Kosinski+0x1c0>
mov    -0x10(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
movb   $0x0,-0x2b(%rbp)
cmpb   $0x0,-0x2c(%rbp)
je     137d <KENS_Kosinski+0x27d>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2e(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2f(%rbp)
movzbl -0x2f(%rbp),%eax
and    $0x7,%eax
cltq
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    1345 <KENS_Kosinski+0x245>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x40(%rbp)
cmpq   $0x0,-0x40(%rbp)
jne    1330 <KENS_Kosinski+0x230>
jmp    151f <KENS_Kosinski+0x41f>
cmpq   $0x1,-0x40(%rbp)
jne    1340 <KENS_Kosinski+0x240>
jmp    11a3 <KENS_Kosinski+0xa3>
jmp    1351 <KENS_Kosinski+0x251>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
movzbl -0x2f(%rbp),%eax
and    $0xf8,%eax
cltq
shl    $0x5,%rax
movabs $0xffffe000,%rcx
or     %rcx,%rax
movzbl -0x2e(%rbp),%ecx
or     %rcx,%rax
mov    %rax,-0x48(%rbp)
jmp    1472 <KENS_Kosinski+0x372>
movzwl -0x2a(%rbp),%eax
mov    -0x2b(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0x2b(%rbp)
movzbl %cl,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     13ac <KENS_Kosinski+0x2ac>
movb   $0x1,-0x2e(%rbp)
jmp    13b0 <KENS_Kosinski+0x2b0>
movb   $0x0,-0x2e(%rbp)
movzbl -0x2b(%rbp),%eax
cmp    $0x10,%eax
jl     13d8 <KENS_Kosinski+0x2d8>
mov    -0x10(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
movb   $0x0,-0x2b(%rbp)
movzwl -0x2a(%rbp),%eax
mov    -0x2b(%rbp),%cl
mov    %cl,%dl
add    $0x1,%dl
mov    %dl,-0x2b(%rbp)
movzbl %cl,%ecx
mov    $0x1,%edx
shl    %cl,%edx
mov    %edx,%ecx
and    %ecx,%eax
cmp    $0x0,%eax
je     1407 <KENS_Kosinski+0x307>
movb   $0x1,-0x2f(%rbp)
jmp    140b <KENS_Kosinski+0x30b>
movb   $0x0,-0x2f(%rbp)
movzbl -0x2b(%rbp),%eax
cmp    $0x10,%eax
jl     1433 <KENS_Kosinski+0x333>
mov    -0x10(%rbp),%rax
mov    (%rax),%ax
mov    %ax,-0x2a(%rbp)
mov    -0x10(%rbp),%rax
add    $0x2,%rax
mov    %rax,-0x10(%rbp)
movb   $0x0,-0x2b(%rbp)
movzbl -0x2e(%rbp),%eax
shl    $0x1,%rax
movzbl -0x2f(%rbp),%ecx
add    %rcx,%rax
add    $0x1,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
mov    %rax,-0x48(%rbp)
movabs $0xffffff00,%rax
or     -0x48(%rbp),%rax
mov    %rax,-0x48(%rbp)
movl   $0x0,-0x64(%rbp)
movslq -0x64(%rbp),%rax
cmp    -0x40(%rbp),%rax
jg     150a <KENS_Kosinski+0x40a>
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x34(%rbp)
mov    -0x48(%rbp),%rax
add    -0x60(%rbp),%rax
mov    %rax,-0x60(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2d(%rbp)
mov    -0x20(%rbp),%rax
movslq -0x34(%rbp),%rcx
add    %rcx,%rax
mov    %rax,-0x60(%rbp)
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
movslq -0x24(%rbp),%rdx
add    %rdx,%rcx
cmp    %rcx,%rax
jb     14e8 <KENS_Kosinski+0x3e8>
movl   $0xffffffff,-0x4(%rbp)
jmp    1581 <KENS_Kosinski+0x481>
mov    -0x2d(%rbp),%cl
mov    -0x60(%rbp),%rax
mov    %rax,%rdx
add    $0x1,%rdx
mov    %rdx,-0x60(%rbp)
mov    %cl,(%rax)
mov    -0x64(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x64(%rbp)
jmp    1479 <KENS_Kosinski+0x379>
mov    -0x40(%rbp),%rax
add    $0x1,%rax
add    -0x58(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    11a3 <KENS_Kosinski+0xa3>
cmpl   $0x0,-0x28(%rbp)
je     1573 <KENS_Kosinski+0x473>
mov    -0x58(%rbp),%rax
cmp    -0x50(%rbp),%rax
jge    156e <KENS_Kosinski+0x46e>
jmp    153c <KENS_Kosinski+0x43c>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
mov    (%rax),%al
mov    %al,-0x2d(%rbp)
movzbl -0x2d(%rbp),%eax
cmp    $0x0,%eax
je     153c <KENS_Kosinski+0x43c>
mov    -0x10(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x10(%rbp)
jmp    1188 <KENS_Kosinski+0x88>
jmp    1573 <KENS_Kosinski+0x473>
mov    -0x60(%rbp),%rax
mov    -0x20(%rbp),%rcx
sub    %rcx,%rax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<KENS_Kosinski>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
test   %r8d,%r8d
je     1120 <KENS_Kosinski+0x20>
movzwl (%rdi),%r9d
add    $0x2,%rdi
shl    $0x30,%r9
bswap  %r9
jmp    1123 <KENS_Kosinski+0x23>
xor    %r9d,%r9d
test   %r8d,%r8d
setne  %r8b
movslq %ecx,%r14
lea    (%rdx,%r14,1),%r10
xor    %r11d,%r11d
mov    %rdx,%rax
movzwl (%rdi),%ebp
add    $0x2,%rdi
xor    %ecx,%ecx
mov    $0x1,%ebx
shl    %cl,%ebx
movzwl %bp,%esi
add    $0x1,%ecx
and    %esi,%ebx
cmp    $0x10,%cl
jb     115d <KENS_Kosinski+0x5d>
movzwl (%rdi),%ebp
add    $0x2,%rdi
xor    %ecx,%ecx
mov    %rdi,%rsi
test   %ebx,%ebx
jne    11d0 <KENS_Kosinski+0xd0>
mov    $0x1,%edi
shl    %cl,%edi
movzwl %bp,%ebx
and    %ebx,%edi
cmp    $0xf,%cl
jb     1190 <KENS_Kosinski+0x90>
movzwl (%rsi),%ebp
add    $0x2,%rsi
xor    %ecx,%ecx
test   %edi,%edi
jne    1197 <KENS_Kosinski+0x97>
jmp    1200 <KENS_Kosinski+0x100>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
add    $0x1,%cl
test   %edi,%edi
je     1200 <KENS_Kosinski+0x100>
movzbl 0x1(%rsi),%ebx
and    $0x7,%bl
jne    1230 <KENS_Kosinski+0x130>
lea    0x3(%rsi),%rdi
movzbl 0x2(%rsi),%ebx
cmp    $0x1,%bl
je     1140 <KENS_Kosinski+0x40>
test   %bl,%bl
je     12c0 <KENS_Kosinski+0x1c0>
movzbl %bl,%r15d
jmp    1280 <KENS_Kosinski+0x180>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
cmp    %r10,%rax
jae    12ef <KENS_Kosinski+0x1ef>
mov    (%rsi),%bl
add    $0x1,%rsi
mov    %bl,(%rax)
add    $0x1,%rax
add    $0x1,%r11
mov    %rsi,%rdi
jmp    1140 <KENS_Kosinski+0x40>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzwl %bp,%r15d
mov    $0x1,%r13d
shl    %cl,%r13d
cmp    $0xf,%cl
jb     1240 <KENS_Kosinski+0x140>
movzwl (%rsi),%ebp
add    $0x2,%rsi
movzwl %bp,%r12d
xor    %ecx,%ecx
jmp    1246 <KENS_Kosinski+0x146>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
add    $0x2,%rsi
add    $0x1,%bl
mov    %rsi,%rdi
movzbl %bl,%r15d
jmp    1280 <KENS_Kosinski+0x180>
add    $0x1,%cl
mov    %r15d,%r12d
movzbl %cl,%ebx
xor    %edi,%edi
bt     %ebx,%r12d
setb   %r12b
cmp    $0xf,%cl
jb     1263 <KENS_Kosinski+0x163>
movzwl (%rsi),%ebp
add    $0x2,%rsi
xor    %ecx,%ecx
jmp    1266 <KENS_Kosinski+0x166>
add    $0x1,%cl
mov    %r12b,%dil
xor    %ebx,%ebx
test   %r15d,%r13d
setne  %bl
lea    (%rdi,%rbx,2),%r15
add    $0x1,%r15
add    $0x1,%rsi
mov    %rsi,%rdi
lea    0x1(%r15),%rsi
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
sub    %edx,%eax
cltq
cmp    %r14,%rax
jge    12ef <KENS_Kosinski+0x1ef>
add    %rdx,%rax
movzbl (%rdi),%ebx
add    $0x1,%rdi
mov    %bl,(%rax)
add    $0x1,%rax
add    $0xffffffffffffffff,%rsi
jne    1290 <KENS_Kosinski+0x190>
add    %r15,%r11
add    $0x1,%r11
jmp    1140 <KENS_Kosinski+0x40>
nopl   0x0(%rax,%rax,1)
cmp    %r9,%r11
setl   %cl
and    %r8b,%cl
cmp    $0x1,%cl
jne    12ff <KENS_Kosinski+0x1ff>
add    $0x2,%rsi
mov    %rsi,%rdi
cs nopw 0x0(%rax,%rax,1)
nop
cmpb   $0x0,0x1(%rdi)
lea    0x1(%rdi),%rdi
je     12e0 <KENS_Kosinski+0x1e0>
jmp    1137 <KENS_Kosinski+0x37>
mov    $0xffffffff,%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
sub    %edx,%eax
jmp    12f4 <KENS_Kosinski+0x1f4>

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

LLVM IR (-O2):
define i32 @KENS_Kosinski(i8* nocapture %0, i32 %1, i8* %2, i32 %3, i32 %4) {
%6 = icmp eq i32 %4, 0
br i1 %6, label %16, label %7
7: ; preds = %5
%8 = getelementptr inbounds i8, i8* %0, i64 1
%9 = load i8, i8* %0
%10 = getelementptr inbounds i8, i8* %0, i64 2
%11 = load i8, i8* %8
%12 = zext i8 %9 to i64
%13 = shl nuw nsw i64 %12, 8
%14 = zext i8 %11 to i64
%15 = or i64 %13, %14
br label %16
16: ; preds = %7, %5
%17 = phi i8* [ %10, %7 ], [ %0, %5 ]
%18 = phi i64 [ %15, %7 ], [ 0, %5 ]
%19 = sext i32 %3 to i64
%20 = getelementptr inbounds i8, i8* %2, i64 %19
%21 = ptrtoint i8* %2 to i64
%22 = xor i1 %6, true
br label %23
23: ; preds = %162, %16
%24 = phi i8* [ %17, %16 ], [ %163, %162 ]
%25 = phi i64 [ 0, %16 ], [ %34, %162 ]
%26 = phi i8* [ %2, %16 ], [ %35, %162 ]
%27 = bitcast i8* %24 to i16*
%28 = load i16, i16* %27
%29 = getelementptr inbounds i8, i8* %24, i64 2
br label %30
30: ; preds = %153, %23
%31 = phi i8* [ %29, %23 ], [ %154, %153 ]
%32 = phi i16 [ %28, %23 ], [ %155, %153 ]
%33 = phi i8 [ 0, %23 ], [ %156, %153 ]
%34 = phi i64 [ %25, %23 ], [ %157, %153 ]
%35 = phi i8* [ %26, %23 ], [ %158, %153 ]
br label %36
36: ; preds = %30, %84
%37 = phi i8* [ %85, %84 ], [ %31, %30 ]
%38 = phi i16 [ %76, %84 ], [ %32, %30 ]
%39 = phi i8 [ %77, %84 ], [ %33, %30 ]
%40 = zext i16 %38 to i32
%41 = add i8 %39, 1
%42 = zext i8 %39 to i32
%43 = shl nuw i32 1, %42
%44 = and i32 %43, %40
%45 = icmp eq i32 %44, 0
%46 = icmp ugt i8 %41, 15
br i1 %46, label %47, label %51
47: ; preds = %36
%48 = bitcast i8* %37 to i16*
%49 = load i16, i16* %48
%50 = getelementptr inbounds i8, i8* %37, i64 2
br label %51
51: ; preds = %47, %36
%52 = phi i8* [ %50, %47 ], [ %37, %36 ]
%53 = phi i16 [ %49, %47 ], [ %38, %36 ]
%54 = phi i8 [ 0, %47 ], [ %41, %36 ]
br i1 %45, label %62, label %55
55: ; preds = %51
%56 = icmp ult i8* %35, %20
br i1 %56, label %57, label %171
57: ; preds = %55
%58 = load i8, i8* %52
%59 = getelementptr inbounds i8, i8* %52, i64 1
%60 = getelementptr inbounds i8, i8* %35, i64 1
store i8 %58, i8* %35
%61 = add nsw i64 %34, 1
br label %153
62: ; preds = %51
%63 = zext i16 %53 to i32
%64 = add nuw nsw i8 %54, 1
%65 = zext i8 %54 to i32
%66 = shl nuw nsw i32 1, %65
%67 = and i32 %66, %63
%68 = icmp eq i32 %67, 0
%69 = icmp ugt i8 %54, 14
br i1 %69, label %70, label %74
70: ; preds = %62
%71 = bitcast i8* %52 to i16*
%72 = load i16, i16* %71
%73 = getelementptr inbounds i8, i8* %52, i64 2
br label %74
74: ; preds = %70, %62
%75 = phi i8* [ %73, %70 ], [ %52, %62 ]
%76 = phi i16 [ %72, %70 ], [ %53, %62 ]
%77 = phi i8 [ 0, %70 ], [ %64, %62 ]
br i1 %68, label %93, label %78
78: ; preds = %74
%79 = getelementptr inbounds i8, i8* %75, i64 1
%80 = getelementptr inbounds i8, i8* %75, i64 2
%81 = load i8, i8* %79
%82 = and i8 %81, 7
%83 = icmp eq i8 %82, 0
br i1 %83, label %84, label %87
84: ; preds = %78
%85 = getelementptr inbounds i8, i8* %75, i64 3
%86 = load i8, i8* %80
switch i8 %86, label %89 [
i8 0, label %159
i8 1, label %36
]
87: ; preds = %78
%88 = add nuw nsw i8 %82, 1
br label %89
89: ; preds = %84, %87
%90 = phi i8* [ %80, %87 ], [ %85, %84 ]
%91 = phi i8 [ %88, %87 ], [ %86, %84 ]
%92 = zext i8 %91 to i64
br label %129
93: ; preds = %74
%94 = zext i16 %76 to i32
%95 = add nuw nsw i8 %77, 1
%96 = zext i8 %77 to i32
%97 = shl nuw nsw i32 1, %96
%98 = and i32 %97, %94
%99 = icmp eq i32 %98, 0
%100 = icmp ugt i8 %77, 14
br i1 %100, label %101, label %106
101: ; preds = %93
%102 = bitcast i8* %75 to i16*
%103 = load i16, i16* %102
%104 = getelementptr inbounds i8, i8* %75, i64 2
%105 = zext i16 %103 to i32
br label %106
106: ; preds = %101, %93
%107 = phi i32 [ %105, %101 ], [ %94, %93 ]
%108 = phi i8* [ %104, %101 ], [ %75, %93 ]
%109 = phi i16 [ %103, %101 ], [ %76, %93 ]
%110 = phi i8 [ 0, %101 ], [ %95, %93 ]
%111 = add nuw nsw i8 %110, 1
%112 = zext i8 %110 to i32
%113 = shl nuw nsw i32 1, %112
%114 = and i32 %113, %107
%115 = icmp ne i32 %114, 0
%116 = zext i1 %115 to i64
%117 = icmp ugt i8 %110, 14
br i1 %117, label %118, label %122
118: ; preds = %106
%119 = bitcast i8* %108 to i16*
%120 = load i16, i16* %119
%121 = getelementptr inbounds i8, i8* %108, i64 2
br label %122
122: ; preds = %118, %106
%123 = phi i8* [ %121, %118 ], [ %108, %106 ]
%124 = phi i16 [ %120, %118 ], [ %109, %106 ]
%125 = phi i8 [ 0, %118 ], [ %111, %106 ]
%126 = select i1 %99, i64 1, i64 3
%127 = add nuw nsw i64 %126, %116
%128 = getelementptr inbounds i8, i8* %123, i64 1
br label %129
129: ; preds = %122, %89
%130 = phi i8* [ %90, %89 ], [ %128, %122 ]
%131 = phi i16 [ %76, %89 ], [ %124, %122 ]
%132 = phi i8 [ %77, %89 ], [ %125, %122 ]
%133 = phi i64 [ %92, %89 ], [ %127, %122 ]
br label %134
134: ; preds = %129, %144
%135 = phi i64 [ 0, %129 ], [ %148, %144 ]
%136 = phi i8* [ %35, %129 ], [ %147, %144 ]
%137 = phi i8* [ %130, %129 ], [ %145, %144 ]
%138 = ptrtoint i8* %136 to i64
%139 = sub i64 %138, %21
%140 = shl i64 %139, 32
%141 = ashr exact i64 %140, 32
%142 = getelementptr inbounds i8, i8* %2, i64 %141
%143 = icmp slt i64 %141, %19
br i1 %143, label %144, label %171
144: ; preds = %134
%145 = getelementptr inbounds i8, i8* %137, i64 1
%146 = load i8, i8* %137
%147 = getelementptr inbounds i8, i8* %142, i64 1
store i8 %146, i8* %142
%148 = add nuw nsw i64 %135, 1
%149 = icmp eq i64 %135, %133
br i1 %149, label %150, label %134
150: ; preds = %144
%151 = add i64 %34, 1
%152 = add i64 %151, %133
br label %153
153: ; preds = %150, %57
%154 = phi i8* [ %59, %57 ], [ %145, %150 ]
%155 = phi i16 [ %53, %57 ], [ %131, %150 ]
%156 = phi i8 [ %54, %57 ], [ %132, %150 ]
%157 = phi i64 [ %61, %57 ], [ %152, %150 ]
%158 = phi i8* [ %60, %57 ], [ %147, %150 ]
br label %30
159: ; preds = %84
%160 = icmp slt i64 %34, %18
%161 = select i1 %22, i1 %160, i1 false
br i1 %161, label %162, label %167
162: ; preds = %159, %162
%163 = phi i8* [ %164, %162 ], [ %85, %159 ]
%164 = getelementptr inbounds i8, i8* %163, i64 1
%165 = load i8, i8* %163
%166 = icmp eq i8 %165, 0
br i1 %166, label %162, label %23
167: ; preds = %159
%168 = ptrtoint i8* %35 to i64
%169 = sub i64 %168, %21
%170 = trunc i64 %169 to i32
br label %171
171: ; preds = %55, %134, %167
%172 = phi i32 [ %170, %167 ], [ -1, %134 ], [ -1, %55 ]
ret i32 %172
}