#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 lzo_adler32(unsigned int adler, const char *buf,
                         unsigned int len) {
  unsigned int s1 = adler & 0xffff;
  unsigned int s2 = (adler >> 16) & 0xffff;
  int k;
  if (buf == NULL)
    return 1;
  while (len > 0) {
    k = len < 5552 ? (int)len : 5552;
    len -= k;
    if (k >= 16)
      do {
        {
          s1 += buf[0];
          s2 += s1;
        };
        {
          s1 += buf[0 + 1];
          s2 += s1;
        };
        ;
        {
          s1 += buf[0 + 2];
          s2 += s1;
        };
        {
          s1 += buf[0 + 2 + 1];
          s2 += s1;
        };
        ;
        ;
        {
          s1 += buf[0 + 4];
          s2 += s1;
        };
        {
          s1 += buf[0 + 4 + 1];
          s2 += s1;
        };
        ;
        {
          s1 += buf[0 + 4 + 2];
          s2 += s1;
        };
        {
          s1 += buf[0 + 4 + 2 + 1];
          s2 += s1;
        };
        ;
        ;
        ;
        {
          s1 += buf[0 + 8];
          s2 += s1;
        };
        {
          s1 += buf[0 + 8 + 1];
          s2 += s1;
        };
        ;
        {
          s1 += buf[0 + 8 + 2];
          s2 += s1;
        };
        {
          s1 += buf[0 + 8 + 2 + 1];
          s2 += s1;
        };
        ;
        ;
        {
          s1 += buf[0 + 8 + 4];
          s2 += s1;
        };
        {
          s1 += buf[0 + 8 + 4 + 1];
          s2 += s1;
        };
        ;
        {
          s1 += buf[0 + 8 + 4 + 2];
          s2 += s1;
        };
        {
          s1 += buf[0 + 8 + 4 + 2 + 1];
          s2 += s1;
        };
        ;
        ;
        ;
        ;
        buf += 16;
        k -= 16;
      } while (k >= 16);
    if (k != 0)
      do {
        s1 += *buf++;
        s2 += s1;
      } while (--k > 0);
    s1 %= 65521u;
    s2 %= 65521u;
  }
  return (s2 << 16) | s1;
}


x86 assembly (clang, -O0):
<lzo_adler32>:
push   %rbp
mov    %rsp,%rbp
mov    %edi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    -0x8(%rbp),%eax
and    $0xffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
shr    $0x10,%eax
and    $0xffff,%eax
mov    %eax,-0x1c(%rbp)
cmpq   $0x0,-0x10(%rbp)
jne    113e <lzo_adler32+0x3e>
movl   $0x1,-0x4(%rbp)
jmp    139b <lzo_adler32+0x29b>
jmp    1143 <lzo_adler32+0x43>
cmpl   $0x0,-0x14(%rbp)
jbe    138f <lzo_adler32+0x28f>
cmpl   $0x15b0,-0x14(%rbp)
jae    1165 <lzo_adler32+0x65>
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <lzo_adler32+0x72>
mov    $0x15b0,%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <lzo_adler32+0x72>
mov    -0x24(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x14(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x14(%rbp)
cmpl   $0x10,-0x20(%rbp)
jl     1325 <lzo_adler32+0x225>
jmp    1192 <lzo_adler32+0x92>
mov    -0x10(%rbp),%rax
movsbl (%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x1(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x2(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x3(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x4(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x5(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x6(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x7(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x8(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0x9(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0xa(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0xb(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0xc(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0xd(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0xe(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movsbl 0xf(%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x20(%rbp)
cmpl   $0x10,-0x20(%rbp)
jge    1192 <lzo_adler32+0x92>
jmp    1325 <lzo_adler32+0x225>
cmpl   $0x0,-0x20(%rbp)
je     136c <lzo_adler32+0x26c>
jmp    1334 <lzo_adler32+0x234>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movsbl (%rax),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x20(%rbp)
cmp    $0x0,%eax
jg     1334 <lzo_adler32+0x234>
jmp    136c <lzo_adler32+0x26c>
mov    -0x18(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %ecx
mov    %edx,-0x1c(%rbp)
jmp    1143 <lzo_adler32+0x43>
mov    -0x1c(%rbp),%eax
shl    $0x10,%eax
or     -0x18(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<lzo_adler32>:
test   %rsi,%rsi
je     1257 <lzo_adler32+0x157>
mov    %edi,%eax
movzwl %ax,%ecx
shr    $0x10,%eax
test   %edx,%edx
je     1251 <lzo_adler32+0x151>
mov    $0x80078071,%r8d
mov    %edx,%r9d
jmp    1160 <lzo_adler32+0x60>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    %ecx,%edx
imul   %r8,%rdx
shr    $0x2f,%rdx
imul   $0xfff1,%edx,%edx
sub    %edx,%ecx
mov    %eax,%edx
imul   %r8,%rdx
shr    $0x2f,%rdx
imul   $0xfff1,%edx,%edx
sub    %edx,%eax
mov    %r9d,%edx
test   %r9d,%r9d
je     1251 <lzo_adler32+0x151>
cmp    $0x15b0,%edx
mov    $0x15b0,%edi
cmovb  %edx,%edi
sub    %edi,%r9d
cmp    $0x10,%edi
jb     1220 <lzo_adler32+0x120>
nopw   0x0(%rax,%rax,1)
mov    %edi,%edx
movsbl (%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0x1(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0x2(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0x3(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0x4(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0x5(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0x6(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0x7(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0x8(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0x9(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0xa(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0xb(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0xc(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0xd(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movsbl 0xe(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movsbl 0xf(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
add    $0x10,%rsi
lea    -0x10(%rdx),%edi
cmp    $0x1f,%edx
ja     1180 <lzo_adler32+0x80>
test   %edi,%edi
jne    1222 <lzo_adler32+0x122>
jmp    1130 <lzo_adler32+0x30>
nopw   0x0(%rax,%rax,1)
mov    %edx,%edi
lea    -0x1(%rdi),%r10d
add    $0x1,%edi
mov    %rsi,%rdx
nopl   0x0(%rax)
movsbl (%rdx),%r11d
add    $0x1,%rdx
add    %r11d,%ecx
add    %ecx,%eax
add    $0xffffffff,%edi
cmp    $0x1,%edi
ja     1230 <lzo_adler32+0x130>
add    %r10,%rsi
add    $0x1,%rsi
jmp    1130 <lzo_adler32+0x30>
shl    $0x10,%eax
or     %ecx,%eax
ret
mov    $0x1,%eax
ret

LLVM IR (-O0):
define i32 @lzo_adler32(i32 %0, i8* %1, i32 %2) {
%4 = alloca i32
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
store i32 %0, i32* %5
store i8* %1, i8** %6
store i32 %2, i32* %7
%11 = load i32, i32* %5
%12 = and i32 %11, 65535
store i32 %12, i32* %8
%13 = load i32, i32* %5
%14 = lshr i32 %13, 16
%15 = and i32 %14, 65535
store i32 %15, i32* %9
%16 = load i8*, i8** %6
%17 = icmp eq i8* %16, null
br i1 %17, label %18, label %19
18: ; preds = %3
store i32 1, i32* %4
br label %219
19: ; preds = %3
br label %20
20: ; preds = %209, %19
%21 = load i32, i32* %7
%22 = icmp ugt i32 %21, 0
br i1 %22, label %23, label %214
23: ; preds = %20
%24 = load i32, i32* %7
%25 = icmp ult i32 %24, 5552
br i1 %25, label %26, label %28
26: ; preds = %23
%27 = load i32, i32* %7
br label %29
28: ; preds = %23
br label %29
29: ; preds = %28, %26
%30 = phi i32 [ %27, %26 ], [ 5552, %28 ]
store i32 %30, i32* %10
%31 = load i32, i32* %10
%32 = load i32, i32* %7
%33 = sub i32 %32, %31
store i32 %33, i32* %7
%34 = load i32, i32* %10
%35 = icmp sge i32 %34, 16
br i1 %35, label %36, label %190
36: ; preds = %29
br label %37
37: ; preds = %186, %36
%38 = load i8*, i8** %6
%39 = getelementptr inbounds i8, i8* %38, i64 0
%40 = load i8, i8* %39
%41 = sext i8 %40 to i32
%42 = load i32, i32* %8
%43 = add i32 %42, %41
store i32 %43, i32* %8
%44 = load i32, i32* %8
%45 = load i32, i32* %9
%46 = add i32 %45, %44
store i32 %46, i32* %9
%47 = load i8*, i8** %6
%48 = getelementptr inbounds i8, i8* %47, i64 1
%49 = load i8, i8* %48
%50 = sext i8 %49 to i32
%51 = load i32, i32* %8
%52 = add i32 %51, %50
store i32 %52, i32* %8
%53 = load i32, i32* %8
%54 = load i32, i32* %9
%55 = add i32 %54, %53
store i32 %55, i32* %9
%56 = load i8*, i8** %6
%57 = getelementptr inbounds i8, i8* %56, i64 2
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = load i32, i32* %8
%61 = add i32 %60, %59
store i32 %61, i32* %8
%62 = load i32, i32* %8
%63 = load i32, i32* %9
%64 = add i32 %63, %62
store i32 %64, i32* %9
%65 = load i8*, i8** %6
%66 = getelementptr inbounds i8, i8* %65, i64 3
%67 = load i8, i8* %66
%68 = sext i8 %67 to i32
%69 = load i32, i32* %8
%70 = add i32 %69, %68
store i32 %70, i32* %8
%71 = load i32, i32* %8
%72 = load i32, i32* %9
%73 = add i32 %72, %71
store i32 %73, i32* %9
%74 = load i8*, i8** %6
%75 = getelementptr inbounds i8, i8* %74, i64 4
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = load i32, i32* %8
%79 = add i32 %78, %77
store i32 %79, i32* %8
%80 = load i32, i32* %8
%81 = load i32, i32* %9
%82 = add i32 %81, %80
store i32 %82, i32* %9
%83 = load i8*, i8** %6
%84 = getelementptr inbounds i8, i8* %83, i64 5
%85 = load i8, i8* %84
%86 = sext i8 %85 to i32
%87 = load i32, i32* %8
%88 = add i32 %87, %86
store i32 %88, i32* %8
%89 = load i32, i32* %8
%90 = load i32, i32* %9
%91 = add i32 %90, %89
store i32 %91, i32* %9
%92 = load i8*, i8** %6
%93 = getelementptr inbounds i8, i8* %92, i64 6
%94 = load i8, i8* %93
%95 = sext i8 %94 to i32
%96 = load i32, i32* %8
%97 = add i32 %96, %95
store i32 %97, i32* %8
%98 = load i32, i32* %8
%99 = load i32, i32* %9
%100 = add i32 %99, %98
store i32 %100, i32* %9
%101 = load i8*, i8** %6
%102 = getelementptr inbounds i8, i8* %101, i64 7
%103 = load i8, i8* %102
%104 = sext i8 %103 to i32
%105 = load i32, i32* %8
%106 = add i32 %105, %104
store i32 %106, i32* %8
%107 = load i32, i32* %8
%108 = load i32, i32* %9
%109 = add i32 %108, %107
store i32 %109, i32* %9
%110 = load i8*, i8** %6
%111 = getelementptr inbounds i8, i8* %110, i64 8
%112 = load i8, i8* %111
%113 = sext i8 %112 to i32
%114 = load i32, i32* %8
%115 = add i32 %114, %113
store i32 %115, i32* %8
%116 = load i32, i32* %8
%117 = load i32, i32* %9
%118 = add i32 %117, %116
store i32 %118, i32* %9
%119 = load i8*, i8** %6
%120 = getelementptr inbounds i8, i8* %119, i64 9
%121 = load i8, i8* %120
%122 = sext i8 %121 to i32
%123 = load i32, i32* %8
%124 = add i32 %123, %122
store i32 %124, i32* %8
%125 = load i32, i32* %8
%126 = load i32, i32* %9
%127 = add i32 %126, %125
store i32 %127, i32* %9
%128 = load i8*, i8** %6
%129 = getelementptr inbounds i8, i8* %128, i64 10
%130 = load i8, i8* %129
%131 = sext i8 %130 to i32
%132 = load i32, i32* %8
%133 = add i32 %132, %131
store i32 %133, i32* %8
%134 = load i32, i32* %8
%135 = load i32, i32* %9
%136 = add i32 %135, %134
store i32 %136, i32* %9
%137 = load i8*, i8** %6
%138 = getelementptr inbounds i8, i8* %137, i64 11
%139 = load i8, i8* %138
%140 = sext i8 %139 to i32
%141 = load i32, i32* %8
%142 = add i32 %141, %140
store i32 %142, i32* %8
%143 = load i32, i32* %8
%144 = load i32, i32* %9
%145 = add i32 %144, %143
store i32 %145, i32* %9
%146 = load i8*, i8** %6
%147 = getelementptr inbounds i8, i8* %146, i64 12
%148 = load i8, i8* %147
%149 = sext i8 %148 to i32
%150 = load i32, i32* %8
%151 = add i32 %150, %149
store i32 %151, i32* %8
%152 = load i32, i32* %8
%153 = load i32, i32* %9
%154 = add i32 %153, %152
store i32 %154, i32* %9
%155 = load i8*, i8** %6
%156 = getelementptr inbounds i8, i8* %155, i64 13
%157 = load i8, i8* %156
%158 = sext i8 %157 to i32
%159 = load i32, i32* %8
%160 = add i32 %159, %158
store i32 %160, i32* %8
%161 = load i32, i32* %8
%162 = load i32, i32* %9
%163 = add i32 %162, %161
store i32 %163, i32* %9
%164 = load i8*, i8** %6
%165 = getelementptr inbounds i8, i8* %164, i64 14
%166 = load i8, i8* %165
%167 = sext i8 %166 to i32
%168 = load i32, i32* %8
%169 = add i32 %168, %167
store i32 %169, i32* %8
%170 = load i32, i32* %8
%171 = load i32, i32* %9
%172 = add i32 %171, %170
store i32 %172, i32* %9
%173 = load i8*, i8** %6
%174 = getelementptr inbounds i8, i8* %173, i64 15
%175 = load i8, i8* %174
%176 = sext i8 %175 to i32
%177 = load i32, i32* %8
%178 = add i32 %177, %176
store i32 %178, i32* %8
%179 = load i32, i32* %8
%180 = load i32, i32* %9
%181 = add i32 %180, %179
store i32 %181, i32* %9
%182 = load i8*, i8** %6
%183 = getelementptr inbounds i8, i8* %182, i64 16
store i8* %183, i8** %6
%184 = load i32, i32* %10
%185 = sub nsw i32 %184, 16
store i32 %185, i32* %10
br label %186
186: ; preds = %37
%187 = load i32, i32* %10
%188 = icmp sge i32 %187, 16
br i1 %188, label %37, label %189
189: ; preds = %186
br label %190
190: ; preds = %189, %29
%191 = load i32, i32* %10
%192 = icmp ne i32 %191, 0
br i1 %192, label %193, label %209
193: ; preds = %190
br label %194
194: ; preds = %204, %193
%195 = load i8*, i8** %6
%196 = getelementptr inbounds i8, i8* %195, i32 1
store i8* %196, i8** %6
%197 = load i8, i8* %195
%198 = sext i8 %197 to i32
%199 = load i32, i32* %8
%200 = add i32 %199, %198
store i32 %200, i32* %8
%201 = load i32, i32* %8
%202 = load i32, i32* %9
%203 = add i32 %202, %201
store i32 %203, i32* %9
br label %204
204: ; preds = %194
%205 = load i32, i32* %10
%206 = add nsw i32 %205, -1
store i32 %206, i32* %10
%207 = icmp sgt i32 %206, 0
br i1 %207, label %194, label %208
208: ; preds = %204
br label %209
209: ; preds = %208, %190
%210 = load i32, i32* %8
%211 = urem i32 %210, 65521
store i32 %211, i32* %8
%212 = load i32, i32* %9
%213 = urem i32 %212, 65521
store i32 %213, i32* %9
br label %20
214: ; preds = %20
%215 = load i32, i32* %9
%216 = shl i32 %215, 16
%217 = load i32, i32* %8
%218 = or i32 %216, %217
store i32 %218, i32* %4
br label %219
219: ; preds = %214, %18
%220 = load i32, i32* %4
ret i32 %220
}

LLVM IR (-O2):
define i32 @lzo_adler32(i32 %0, i8* %1, i32 %2) {
%4 = and i32 %0, 65535
%5 = lshr i32 %0, 16
%6 = icmp eq i8* %1, null
br i1 %6, label %141, label %7
7: ; preds = %3
%8 = icmp eq i32 %2, 0
br i1 %8, label %136, label %9
9: ; preds = %7, %129
%10 = phi i32 [ %134, %129 ], [ %5, %7 ]
%11 = phi i32 [ %133, %129 ], [ %4, %7 ]
%12 = phi i32 [ %16, %129 ], [ %2, %7 ]
%13 = phi i8* [ %130, %129 ], [ %1, %7 ]
%14 = icmp ult i32 %12, 5552
%15 = select i1 %14, i32 %12, i32 5552
%16 = sub i32 %12, %15
%17 = icmp ugt i32 %15, 15
br i1 %17, label %18, label %107
18: ; preds = %9, %18
%19 = phi i8* [ %102, %18 ], [ %13, %9 ]
%20 = phi i32 [ %100, %18 ], [ %11, %9 ]
%21 = phi i32 [ %101, %18 ], [ %10, %9 ]
%22 = phi i32 [ %103, %18 ], [ %15, %9 ]
%23 = load i8, i8* %19
%24 = sext i8 %23 to i32
%25 = add i32 %20, %24
%26 = add i32 %25, %21
%27 = getelementptr inbounds i8, i8* %19, i64 1
%28 = load i8, i8* %27
%29 = sext i8 %28 to i32
%30 = add i32 %25, %29
%31 = add i32 %26, %30
%32 = getelementptr inbounds i8, i8* %19, i64 2
%33 = load i8, i8* %32
%34 = sext i8 %33 to i32
%35 = add i32 %30, %34
%36 = add i32 %31, %35
%37 = getelementptr inbounds i8, i8* %19, i64 3
%38 = load i8, i8* %37
%39 = sext i8 %38 to i32
%40 = add i32 %35, %39
%41 = add i32 %36, %40
%42 = getelementptr inbounds i8, i8* %19, i64 4
%43 = load i8, i8* %42
%44 = sext i8 %43 to i32
%45 = add i32 %40, %44
%46 = add i32 %41, %45
%47 = getelementptr inbounds i8, i8* %19, i64 5
%48 = load i8, i8* %47
%49 = sext i8 %48 to i32
%50 = add i32 %45, %49
%51 = add i32 %46, %50
%52 = getelementptr inbounds i8, i8* %19, i64 6
%53 = load i8, i8* %52
%54 = sext i8 %53 to i32
%55 = add i32 %50, %54
%56 = add i32 %51, %55
%57 = getelementptr inbounds i8, i8* %19, i64 7
%58 = load i8, i8* %57
%59 = sext i8 %58 to i32
%60 = add i32 %55, %59
%61 = add i32 %56, %60
%62 = getelementptr inbounds i8, i8* %19, i64 8
%63 = load i8, i8* %62
%64 = sext i8 %63 to i32
%65 = add i32 %60, %64
%66 = add i32 %61, %65
%67 = getelementptr inbounds i8, i8* %19, i64 9
%68 = load i8, i8* %67
%69 = sext i8 %68 to i32
%70 = add i32 %65, %69
%71 = add i32 %66, %70
%72 = getelementptr inbounds i8, i8* %19, i64 10
%73 = load i8, i8* %72
%74 = sext i8 %73 to i32
%75 = add i32 %70, %74
%76 = add i32 %71, %75
%77 = getelementptr inbounds i8, i8* %19, i64 11
%78 = load i8, i8* %77
%79 = sext i8 %78 to i32
%80 = add i32 %75, %79
%81 = add i32 %76, %80
%82 = getelementptr inbounds i8, i8* %19, i64 12
%83 = load i8, i8* %82
%84 = sext i8 %83 to i32
%85 = add i32 %80, %84
%86 = add i32 %81, %85
%87 = getelementptr inbounds i8, i8* %19, i64 13
%88 = load i8, i8* %87
%89 = sext i8 %88 to i32
%90 = add i32 %85, %89
%91 = add i32 %86, %90
%92 = getelementptr inbounds i8, i8* %19, i64 14
%93 = load i8, i8* %92
%94 = sext i8 %93 to i32
%95 = add i32 %90, %94
%96 = add i32 %91, %95
%97 = getelementptr inbounds i8, i8* %19, i64 15
%98 = load i8, i8* %97
%99 = sext i8 %98 to i32
%100 = add i32 %95, %99
%101 = add i32 %96, %100
%102 = getelementptr inbounds i8, i8* %19, i64 16
%103 = add nsw i32 %22, -16
%104 = icmp ugt i32 %22, 31
br i1 %104, label %18, label %105
105: ; preds = %18
%106 = icmp eq i32 %103, 0
br i1 %106, label %129, label %107
107: ; preds = %9, %105
%108 = phi i32 [ %103, %105 ], [ %12, %9 ]
%109 = phi i32 [ %101, %105 ], [ %10, %9 ]
%110 = phi i32 [ %100, %105 ], [ %11, %9 ]
%111 = phi i8* [ %102, %105 ], [ %13, %9 ]
%112 = add i32 %108, -1
%113 = zext i32 %112 to i64
br label %114
114: ; preds = %107, %114
%115 = phi i8* [ %119, %114 ], [ %111, %107 ]
%116 = phi i32 [ %122, %114 ], [ %110, %107 ]
%117 = phi i32 [ %123, %114 ], [ %109, %107 ]
%118 = phi i32 [ %124, %114 ], [ %108, %107 ]
%119 = getelementptr inbounds i8, i8* %115, i64 1
%120 = load i8, i8* %115
%121 = sext i8 %120 to i32
%122 = add i32 %116, %121
%123 = add i32 %122, %117
%124 = add nsw i32 %118, -1
%125 = icmp ugt i32 %118, 1
br i1 %125, label %114, label %126
126: ; preds = %114
%127 = getelementptr i8, i8* %111, i64 1
%128 = getelementptr i8, i8* %127, i64 %113
br label %129
129: ; preds = %126, %105
%130 = phi i8* [ %102, %105 ], [ %128, %126 ]
%131 = phi i32 [ %100, %105 ], [ %122, %126 ]
%132 = phi i32 [ %101, %105 ], [ %123, %126 ]
%133 = urem i32 %131, 65521
%134 = urem i32 %132, 65521
%135 = icmp eq i32 %16, 0
br i1 %135, label %136, label %9
136: ; preds = %129, %7
%137 = phi i32 [ %4, %7 ], [ %133, %129 ]
%138 = phi i32 [ %5, %7 ], [ %134, %129 ]
%139 = shl nuw i32 %138, 16
%140 = or i32 %139, %137
br label %141
141: ; preds = %3, %136
%142 = phi i32 [ %140, %136 ], [ 1, %3 ]
ret i32 %142
}