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


x86 assembly (clang, -O0):
<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 <adler32+0x3e>
movl   $0x1,-0x4(%rbp)
jmp    1392 <adler32+0x292>
jmp    1143 <adler32+0x43>
cmpl   $0x0,-0x14(%rbp)
jbe    1386 <adler32+0x286>
cmpl   $0x15b0,-0x14(%rbp)
jae    1165 <adler32+0x65>
mov    -0x14(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <adler32+0x72>
mov    $0x15b0,%eax
mov    %eax,-0x24(%rbp)
jmp    1172 <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     1316 <adler32+0x216>
mov    -0x10(%rbp),%rax
movzbl (%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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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
movzbl 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)
jmp    1183 <adler32+0x83>
cmpl   $0x0,-0x20(%rbp)
je     135d <adler32+0x25d>
jmp    1325 <adler32+0x225>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%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
jne    1325 <adler32+0x225>
jmp    135d <adler32+0x25d>
mov    -0x18(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x1c(%rbp)
jmp    1143 <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):
<adler32>:
test   %rsi,%rsi
je     12d8 <adler32+0x1d8>
push   %rbx
mov    %edi,%eax
movzwl %ax,%ecx
shr    $0x10,%eax
test   %edx,%edx
je     12d1 <adler32+0x1d1>
mov    $0x80078071,%r8d
mov    %edx,%r9d
jmp    1167 <adler32+0x67>
cs nopw 0x0(%rax,%rax,1)
nop
add    %r10,%rsi
add    $0x1,%rsi
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     12d1 <adler32+0x1d1>
cmp    $0x15b0,%edx
mov    $0x15b0,%edi
cmovb  %edx,%edi
sub    %edi,%r9d
cmp    $0x10,%edi
jb     1230 <adler32+0x130>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x1(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x2(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x3(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x4(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x5(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x6(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x7(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x8(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x9(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0xa(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0xb(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0xc(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0xd(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0xe(%rsi),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0xf(%rsi),%ecx
add    %edx,%ecx
add    %ecx,%eax
add    $0x10,%rsi
add    $0xfffffff0,%edi
cmp    $0xf,%edi
ja     1190 <adler32+0x90>
test   %edi,%edi
jne    1232 <adler32+0x132>
jmp    1137 <adler32+0x37>
nopl   0x0(%rax,%rax,1)
mov    %edx,%edi
lea    -0x1(%rdi),%r10d
test   $0x3,%dil
je     1280 <adler32+0x180>
mov    %edi,%r11d
and    $0x3,%r11d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi,%rdx,1),%ebx
add    %ebx,%ecx
add    %ecx,%eax
add    $0x1,%rdx
cmp    %edx,%r11d
jne    1250 <adler32+0x150>
lea    (%rsi,%rdx,1),%rbx
sub    %edx,%edi
cmp    $0x3,%r10d
jb     1130 <adler32+0x30>
jmp    128d <adler32+0x18d>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
mov    %rsi,%rbx
cmp    $0x3,%r10d
jb     1130 <adler32+0x30>
mov    %edi,%r11d
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rbx,%rdi,1),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x1(%rbx,%rdi,1),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x2(%rbx,%rdi,1),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x3(%rbx,%rdi,1),%ecx
add    %edx,%ecx
add    %ecx,%eax
add    $0x4,%rdi
cmp    %edi,%r11d
jne    12a0 <adler32+0x1a0>
jmp    1130 <adler32+0x30>
shl    $0x10,%eax
or     %ecx,%eax
pop    %rbx
ret
mov    $0x1,%eax
ret

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