unsigned int adler32(unsigned int adler, const unsigned char *buf,
                     unsigned int len) {
  unsigned int sum2;
  unsigned n;
  sum2 = (adler >> 16) & 0xffff;
  adler &= 0xffff;
  if (len == 1) {
    adler += buf[0];
    if (adler >= 65521UL)
      adler -= 65521UL;
    sum2 += adler;
    if (sum2 >= 65521UL)
      sum2 -= 65521UL;
    return adler | (sum2 << 16);
  }
  if (buf == 0)
    return 1L;
  if (len < 16) {
    while (len--) {
      adler += *buf++;
      sum2 += adler;
    }
    if (adler >= 65521UL)
      adler -= 65521UL;
    sum2 %= 65521UL;
    return adler | (sum2 << 16);
  }
  while (len >= 5552) {
    len -= 5552;
    n = 5552 / 16;
    do {
      {
        adler += (buf)[0];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[0 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      {
        adler += (buf)[0 + 4];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 4 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[0 + 4 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 4 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      ;
      {
        adler += (buf)[8];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[8 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      {
        adler += (buf)[8 + 4];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 4 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[8 + 4 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 4 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      ;
      ;
      buf += 16;
    } while (--n);
    adler %= 65521UL;
    sum2 %= 65521UL;
  }
  if (len) {
    while (len >= 16) {
      len -= 16;
      {
        adler += (buf)[0];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[0 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      {
        adler += (buf)[0 + 4];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 4 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[0 + 4 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[0 + 4 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      ;
      {
        adler += (buf)[8];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[8 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      {
        adler += (buf)[8 + 4];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 4 + 1];
        sum2 += adler;
      };
      ;
      {
        adler += (buf)[8 + 4 + 2];
        sum2 += adler;
      };
      {
        adler += (buf)[8 + 4 + 2 + 1];
        sum2 += adler;
      };
      ;
      ;
      ;
      ;
      buf += 16;
    }
    while (len--) {
      adler += *buf++;
      sum2 += adler;
    }
    adler %= 65521UL;
    sum2 %= 65521UL;
  }
  return adler | (sum2 << 16);
}


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
shr    $0x10,%eax
and    $0xffff,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
and    $0xffff,%eax
mov    %eax,-0x8(%rbp)
cmpl   $0x1,-0x14(%rbp)
jne    1190 <adler32+0x90>
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
cmp    $0xfff1,%rax
jb     1159 <adler32+0x59>
mov    -0x8(%rbp),%eax
sub    $0xfff1,%rax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x18(%rbp),%eax
cmp    $0xfff1,%rax
jb     117d <adler32+0x7d>
mov    -0x18(%rbp),%eax
sub    $0xfff1,%rax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    161d <adler32+0x51d>
cmpq   $0x0,-0x10(%rbp)
jne    11a7 <adler32+0xa7>
movl   $0x1,-0x4(%rbp)
jmp    161d <adler32+0x51d>
cmpl   $0x10,-0x14(%rbp)
jae    1230 <adler32+0x130>
jmp    11b6 <adler32+0xb6>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     11f0 <adler32+0xf0>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    11b6 <adler32+0xb6>
mov    -0x8(%rbp),%eax
cmp    $0xfff1,%rax
jb     120b <adler32+0x10b>
mov    -0x8(%rbp),%eax
sub    $0xfff1,%rax
mov    %eax,-0x8(%rbp)
mov    -0x18(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x4(%rbp)
jmp    161d <adler32+0x51d>
jmp    1235 <adler32+0x135>
cmpl   $0x15b0,-0x14(%rbp)
jb     140a <adler32+0x30a>
mov    -0x14(%rbp),%eax
sub    $0x15b0,%eax
mov    %eax,-0x14(%rbp)
movl   $0x15b,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
mov    -0x1c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x1c(%rbp)
cmp    $0x0,%eax
jne    1254 <adler32+0x154>
mov    -0x8(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x8(%rbp)
mov    -0x18(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x18(%rbp)
jmp    1235 <adler32+0x135>
cmpl   $0x0,-0x14(%rbp)
je     160f <adler32+0x50f>
jmp    1419 <adler32+0x319>
cmpl   $0x10,-0x14(%rbp)
jb     15ac <adler32+0x4ac>
mov    -0x14(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x14(%rbp)
mov    -0x10(%rbp),%rax
movzbl (%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x2(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x4(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x5(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x6(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x7(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0x9(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xa(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xb(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xc(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xd(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xe(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
movzbl 0xf(%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x10(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x10(%rbp)
jmp    1419 <adler32+0x319>
jmp    15b1 <adler32+0x4b1>
mov    -0x14(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x14(%rbp)
cmp    $0x0,%eax
je     15eb <adler32+0x4eb>
mov    -0x10(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x10(%rbp)
movzbl (%rax),%eax
add    -0x8(%rbp),%eax
mov    %eax,-0x8(%rbp)
mov    -0x8(%rbp),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
jmp    15b1 <adler32+0x4b1>
mov    -0x8(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x8(%rbp)
mov    -0x18(%rbp),%eax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %edx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x8(%rbp),%eax
mov    -0x18(%rbp),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<adler32>:
movzwl %di,%r11d
mov    %edi,%eax
shr    $0x10,%eax
cmp    $0x1,%edx
jne    113e <adler32+0x3e>
movzbl (%rsi),%edx
lea    (%r11,%rdx,1),%esi
cmp    $0xfff1,%esi
lea    -0xfff1(%r11,%rdx,1),%ecx
ff
cmovb  %esi,%ecx
add    %ecx,%eax
mov    %eax,%edx
shl    $0x10,%edx
cmp    $0xfff1,%eax
lea    0xf0000(%rdx),%eax
cmovb  %edx,%eax
or     %ecx,%eax
ret
test   %rsi,%rsi
je     11ff <adler32+0xff>
cmp    $0x10,%edx
jae    1205 <adler32+0x105>
test   %edx,%edx
je     11d0 <adler32+0xd0>
lea    -0x1(%rdx),%r8d
test   $0x3,%dl
je     118a <adler32+0x8a>
mov    %edx,%r9d
and    $0x3,%r9d
xor    %r10d,%r10d
nopw   0x0(%rax,%rax,1)
movzbl (%rsi,%r10,1),%edi
add    %edi,%r11d
add    %r11d,%eax
add    $0x1,%r10
cmp    %r10d,%r9d
jne    1170 <adler32+0x70>
sub    %r10d,%edx
add    %r10,%rsi
cmp    $0x3,%r8d
jb     11d0 <adler32+0xd0>
mov    %edx,%r8d
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nop
movzbl (%rsi,%rdi,1),%edx
add    %r11d,%edx
add    %edx,%eax
movzbl 0x1(%rsi,%rdi,1),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x2(%rsi,%rdi,1),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x3(%rsi,%rdi,1),%r11d
add    %edx,%r11d
add    %r11d,%eax
add    $0x4,%rdi
cmp    %edi,%r8d
jne    11a0 <adler32+0xa0>
lea    -0xfff1(%r11),%edx
cmp    $0xfff1,%r11d
cmovb  %r11d,%edx
mov    %eax,%ecx
mov    $0x80078071,%esi
imul   %rcx,%rsi
shr    $0x2f,%rsi
imul   $0xfff1,%esi,%ecx
sub    %ecx,%eax
shl    $0x10,%eax
or     %edx,%eax
ret
mov    $0x1,%eax
ret
cmp    $0x15b0,%edx
jb     1340 <adler32+0x240>
mov    $0x80078071,%r8d
nopw   0x0(%rax,%rax,1)
add    $0xffffea50,%edx
xor    %edi,%edi
nopl   0x0(%rax,%rax,1)
movzbl (%rsi,%rdi,1),%ecx
add    %r11d,%ecx
add    %ecx,%eax
movzbl 0x1(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0x2(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0x3(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0x4(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0x5(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0x6(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0x7(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0x8(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0x9(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0xa(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0xb(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0xc(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0xd(%rsi,%rdi,1),%r9d
add    %ecx,%r9d
add    %r9d,%eax
movzbl 0xe(%rsi,%rdi,1),%ecx
add    %r9d,%ecx
add    %ecx,%eax
movzbl 0xf(%rsi,%rdi,1),%r11d
add    %ecx,%r11d
add    %r11d,%eax
add    $0x10,%rdi
cmp    $0x15b0,%edi
jne    1230 <adler32+0x130>
add    $0x15b0,%rsi
mov    %r11d,%ecx
imul   %r8,%rcx
shr    $0x2f,%rcx
imul   $0xfff1,%ecx,%ecx
sub    %ecx,%r11d
mov    %eax,%ecx
imul   %r8,%rcx
shr    $0x2f,%rcx
imul   $0xfff1,%ecx,%ecx
sub    %ecx,%eax
cmp    $0x15af,%edx
ja     1220 <adler32+0x120>
test   %edx,%edx
je     147b <adler32+0x37b>
cmp    $0x10,%edx
jb     13d7 <adler32+0x2d7>
nopl   0x0(%rax)
add    $0xfffffff0,%edx
movzbl (%rsi),%ecx
add    %r11d,%ecx
add    %ecx,%eax
movzbl 0x1(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0x2(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0x3(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0x4(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0x5(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0x6(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0x7(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0x8(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0x9(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0xa(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0xb(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0xc(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0xd(%rsi),%edi
add    %ecx,%edi
add    %edi,%eax
movzbl 0xe(%rsi),%ecx
add    %edi,%ecx
add    %ecx,%eax
movzbl 0xf(%rsi),%r11d
add    %ecx,%r11d
add    %r11d,%eax
add    $0x10,%rsi
cmp    $0xf,%edx
ja     1340 <adler32+0x240>
test   %edx,%edx
je     1450 <adler32+0x350>
lea    -0x1(%rdx),%r8d
test   $0x3,%dl
je     1408 <adler32+0x308>
mov    %edx,%r9d
and    $0x3,%r9d
xor    %edi,%edi
nopl   0x0(%rax)
movzbl (%rsi,%rdi,1),%ecx
add    %ecx,%r11d
add    %r11d,%eax
add    $0x1,%rdi
cmp    %edi,%r9d
jne    13f0 <adler32+0x2f0>
sub    %edi,%edx
add    %rdi,%rsi
cmp    $0x3,%r8d
jb     1450 <adler32+0x350>
mov    %edx,%r8d
xor    %edi,%edi
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
movzbl (%rsi,%rdi,1),%ecx
add    %r11d,%ecx
add    %ecx,%eax
movzbl 0x1(%rsi,%rdi,1),%edx
add    %ecx,%edx
add    %edx,%eax
movzbl 0x2(%rsi,%rdi,1),%ecx
add    %edx,%ecx
add    %ecx,%eax
movzbl 0x3(%rsi,%rdi,1),%r11d
add    %ecx,%r11d
add    %r11d,%eax
add    $0x4,%rdi
cmp    %edi,%r8d
jne    1420 <adler32+0x320>
mov    %r11d,%ecx
mov    $0x80078071,%edx
imul   %rdx,%rcx
shr    $0x2f,%rcx
imul   $0xfff1,%ecx,%ecx
sub    %ecx,%r11d
mov    %eax,%ecx
imul   %rdx,%rcx
shr    $0x2f,%rcx
imul   $0xfff1,%ecx,%ecx
sub    %ecx,%eax
shl    $0x10,%eax
or     %r11d,%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
store i32 %0, i32* %5
store i8* %1, i8** %6
store i32 %2, i32* %7
%10 = load i32, i32* %5
%11 = lshr i32 %10, 16
%12 = and i32 %11, 65535
store i32 %12, i32* %8
%13 = load i32, i32* %5
%14 = and i32 %13, 65535
store i32 %14, i32* %5
%15 = load i32, i32* %7
%16 = icmp eq i32 %15, 1
br i1 %16, label %17, label %49
17: ; preds = %3
%18 = load i8*, i8** %6
%19 = getelementptr inbounds i8, i8* %18, i64 0
%20 = load i8, i8* %19
%21 = zext i8 %20 to i32
%22 = load i32, i32* %5
%23 = add i32 %22, %21
store i32 %23, i32* %5
%24 = load i32, i32* %5
%25 = zext i32 %24 to i64
%26 = icmp uge i64 %25, 65521
br i1 %26, label %27, label %32
27: ; preds = %17
%28 = load i32, i32* %5
%29 = zext i32 %28 to i64
%30 = sub i64 %29, 65521
%31 = trunc i64 %30 to i32
store i32 %31, i32* %5
br label %32
32: ; preds = %27, %17
%33 = load i32, i32* %5
%34 = load i32, i32* %8
%35 = add i32 %34, %33
store i32 %35, i32* %8
%36 = load i32, i32* %8
%37 = zext i32 %36 to i64
%38 = icmp uge i64 %37, 65521
br i1 %38, label %39, label %44
39: ; preds = %32
%40 = load i32, i32* %8
%41 = zext i32 %40 to i64
%42 = sub i64 %41, 65521
%43 = trunc i64 %42 to i32
store i32 %43, i32* %8
br label %44
44: ; preds = %39, %32
%45 = load i32, i32* %5
%46 = load i32, i32* %8
%47 = shl i32 %46, 16
%48 = or i32 %45, %47
store i32 %48, i32* %4
br label %441
49: ; preds = %3
%50 = load i8*, i8** %6
%51 = icmp eq i8* %50, null
br i1 %51, label %52, label %53
52: ; preds = %49
store i32 1, i32* %4
br label %441
53: ; preds = %49
%54 = load i32, i32* %7
%55 = icmp ult i32 %54, 16
br i1 %55, label %56, label %89
56: ; preds = %53
br label %57
57: ; preds = %61, %56
%58 = load i32, i32* %7
%59 = add i32 %58, -1
store i32 %59, i32* %7
%60 = icmp ne i32 %58, 0
br i1 %60, label %61, label %71
61: ; preds = %57
%62 = load i8*, i8** %6
%63 = getelementptr inbounds i8, i8* %62, i32 1
store i8* %63, i8** %6
%64 = load i8, i8* %62
%65 = zext i8 %64 to i32
%66 = load i32, i32* %5
%67 = add i32 %66, %65
store i32 %67, i32* %5
%68 = load i32, i32* %5
%69 = load i32, i32* %8
%70 = add i32 %69, %68
store i32 %70, i32* %8
br label %57
71: ; preds = %57
%72 = load i32, i32* %5
%73 = zext i32 %72 to i64
%74 = icmp uge i64 %73, 65521
br i1 %74, label %75, label %80
75: ; preds = %71
%76 = load i32, i32* %5
%77 = zext i32 %76 to i64
%78 = sub i64 %77, 65521
%79 = trunc i64 %78 to i32
store i32 %79, i32* %5
br label %80
80: ; preds = %75, %71
%81 = load i32, i32* %8
%82 = zext i32 %81 to i64
%83 = urem i64 %82, 65521
%84 = trunc i64 %83 to i32
store i32 %84, i32* %8
%85 = load i32, i32* %5
%86 = load i32, i32* %8
%87 = shl i32 %86, 16
%88 = or i32 %85, %87
store i32 %88, i32* %4
br label %441
89: ; preds = %53
br label %90
90: ; preds = %247, %89
%91 = load i32, i32* %7
%92 = icmp uge i32 %91, 5552
br i1 %92, label %93, label %256
93: ; preds = %90
%94 = load i32, i32* %7
%95 = sub i32 %94, 5552
store i32 %95, i32* %7
store i32 347, i32* %9
br label %96
96: ; preds = %243, %93
%97 = load i8*, i8** %6
%98 = getelementptr inbounds i8, i8* %97, i64 0
%99 = load i8, i8* %98
%100 = zext i8 %99 to i32
%101 = load i32, i32* %5
%102 = add i32 %101, %100
store i32 %102, i32* %5
%103 = load i32, i32* %5
%104 = load i32, i32* %8
%105 = add i32 %104, %103
store i32 %105, i32* %8
%106 = load i8*, i8** %6
%107 = getelementptr inbounds i8, i8* %106, i64 1
%108 = load i8, i8* %107
%109 = zext i8 %108 to i32
%110 = load i32, i32* %5
%111 = add i32 %110, %109
store i32 %111, i32* %5
%112 = load i32, i32* %5
%113 = load i32, i32* %8
%114 = add i32 %113, %112
store i32 %114, i32* %8
%115 = load i8*, i8** %6
%116 = getelementptr inbounds i8, i8* %115, i64 2
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = load i32, i32* %5
%120 = add i32 %119, %118
store i32 %120, i32* %5
%121 = load i32, i32* %5
%122 = load i32, i32* %8
%123 = add i32 %122, %121
store i32 %123, i32* %8
%124 = load i8*, i8** %6
%125 = getelementptr inbounds i8, i8* %124, i64 3
%126 = load i8, i8* %125
%127 = zext i8 %126 to i32
%128 = load i32, i32* %5
%129 = add i32 %128, %127
store i32 %129, i32* %5
%130 = load i32, i32* %5
%131 = load i32, i32* %8
%132 = add i32 %131, %130
store i32 %132, i32* %8
%133 = load i8*, i8** %6
%134 = getelementptr inbounds i8, i8* %133, i64 4
%135 = load i8, i8* %134
%136 = zext i8 %135 to i32
%137 = load i32, i32* %5
%138 = add i32 %137, %136
store i32 %138, i32* %5
%139 = load i32, i32* %5
%140 = load i32, i32* %8
%141 = add i32 %140, %139
store i32 %141, i32* %8
%142 = load i8*, i8** %6
%143 = getelementptr inbounds i8, i8* %142, i64 5
%144 = load i8, i8* %143
%145 = zext i8 %144 to i32
%146 = load i32, i32* %5
%147 = add i32 %146, %145
store i32 %147, i32* %5
%148 = load i32, i32* %5
%149 = load i32, i32* %8
%150 = add i32 %149, %148
store i32 %150, i32* %8
%151 = load i8*, i8** %6
%152 = getelementptr inbounds i8, i8* %151, i64 6
%153 = load i8, i8* %152
%154 = zext i8 %153 to i32
%155 = load i32, i32* %5
%156 = add i32 %155, %154
store i32 %156, i32* %5
%157 = load i32, i32* %5
%158 = load i32, i32* %8
%159 = add i32 %158, %157
store i32 %159, i32* %8
%160 = load i8*, i8** %6
%161 = getelementptr inbounds i8, i8* %160, i64 7
%162 = load i8, i8* %161
%163 = zext i8 %162 to i32
%164 = load i32, i32* %5
%165 = add i32 %164, %163
store i32 %165, i32* %5
%166 = load i32, i32* %5
%167 = load i32, i32* %8
%168 = add i32 %167, %166
store i32 %168, i32* %8
%169 = load i8*, i8** %6
%170 = getelementptr inbounds i8, i8* %169, i64 8
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = load i32, i32* %5
%174 = add i32 %173, %172
store i32 %174, i32* %5
%175 = load i32, i32* %5
%176 = load i32, i32* %8
%177 = add i32 %176, %175
store i32 %177, i32* %8
%178 = load i8*, i8** %6
%179 = getelementptr inbounds i8, i8* %178, i64 9
%180 = load i8, i8* %179
%181 = zext i8 %180 to i32
%182 = load i32, i32* %5
%183 = add i32 %182, %181
store i32 %183, i32* %5
%184 = load i32, i32* %5
%185 = load i32, i32* %8
%186 = add i32 %185, %184
store i32 %186, i32* %8
%187 = load i8*, i8** %6
%188 = getelementptr inbounds i8, i8* %187, i64 10
%189 = load i8, i8* %188
%190 = zext i8 %189 to i32
%191 = load i32, i32* %5
%192 = add i32 %191, %190
store i32 %192, i32* %5
%193 = load i32, i32* %5
%194 = load i32, i32* %8
%195 = add i32 %194, %193
store i32 %195, i32* %8
%196 = load i8*, i8** %6
%197 = getelementptr inbounds i8, i8* %196, i64 11
%198 = load i8, i8* %197
%199 = zext i8 %198 to i32
%200 = load i32, i32* %5
%201 = add i32 %200, %199
store i32 %201, i32* %5
%202 = load i32, i32* %5
%203 = load i32, i32* %8
%204 = add i32 %203, %202
store i32 %204, i32* %8
%205 = load i8*, i8** %6
%206 = getelementptr inbounds i8, i8* %205, i64 12
%207 = load i8, i8* %206
%208 = zext i8 %207 to i32
%209 = load i32, i32* %5
%210 = add i32 %209, %208
store i32 %210, i32* %5
%211 = load i32, i32* %5
%212 = load i32, i32* %8
%213 = add i32 %212, %211
store i32 %213, i32* %8
%214 = load i8*, i8** %6
%215 = getelementptr inbounds i8, i8* %214, i64 13
%216 = load i8, i8* %215
%217 = zext i8 %216 to i32
%218 = load i32, i32* %5
%219 = add i32 %218, %217
store i32 %219, i32* %5
%220 = load i32, i32* %5
%221 = load i32, i32* %8
%222 = add i32 %221, %220
store i32 %222, i32* %8
%223 = load i8*, i8** %6
%224 = getelementptr inbounds i8, i8* %223, i64 14
%225 = load i8, i8* %224
%226 = zext i8 %225 to i32
%227 = load i32, i32* %5
%228 = add i32 %227, %226
store i32 %228, i32* %5
%229 = load i32, i32* %5
%230 = load i32, i32* %8
%231 = add i32 %230, %229
store i32 %231, i32* %8
%232 = load i8*, i8** %6
%233 = getelementptr inbounds i8, i8* %232, i64 15
%234 = load i8, i8* %233
%235 = zext i8 %234 to i32
%236 = load i32, i32* %5
%237 = add i32 %236, %235
store i32 %237, i32* %5
%238 = load i32, i32* %5
%239 = load i32, i32* %8
%240 = add i32 %239, %238
store i32 %240, i32* %8
%241 = load i8*, i8** %6
%242 = getelementptr inbounds i8, i8* %241, i64 16
store i8* %242, i8** %6
br label %243
243: ; preds = %96
%244 = load i32, i32* %9
%245 = add i32 %244, -1
store i32 %245, i32* %9
%246 = icmp ne i32 %245, 0
br i1 %246, label %96, label %247
247: ; preds = %243
%248 = load i32, i32* %5
%249 = zext i32 %248 to i64
%250 = urem i64 %249, 65521
%251 = trunc i64 %250 to i32
store i32 %251, i32* %5
%252 = load i32, i32* %8
%253 = zext i32 %252 to i64
%254 = urem i64 %253, 65521
%255 = trunc i64 %254 to i32
store i32 %255, i32* %8
br label %90
256: ; preds = %90
%257 = load i32, i32* %7
%258 = icmp ne i32 %257, 0
br i1 %258, label %259, label %436
259: ; preds = %256
br label %260
260: ; preds = %263, %259
%261 = load i32, i32* %7
%262 = icmp uge i32 %261, 16
br i1 %262, label %263, label %412
263: ; preds = %260
%264 = load i32, i32* %7
%265 = sub i32 %264, 16
store i32 %265, i32* %7
%266 = load i8*, i8** %6
%267 = getelementptr inbounds i8, i8* %266, i64 0
%268 = load i8, i8* %267
%269 = zext i8 %268 to i32
%270 = load i32, i32* %5
%271 = add i32 %270, %269
store i32 %271, i32* %5
%272 = load i32, i32* %5
%273 = load i32, i32* %8
%274 = add i32 %273, %272
store i32 %274, i32* %8
%275 = load i8*, i8** %6
%276 = getelementptr inbounds i8, i8* %275, i64 1
%277 = load i8, i8* %276
%278 = zext i8 %277 to i32
%279 = load i32, i32* %5
%280 = add i32 %279, %278
store i32 %280, i32* %5
%281 = load i32, i32* %5
%282 = load i32, i32* %8
%283 = add i32 %282, %281
store i32 %283, i32* %8
%284 = load i8*, i8** %6
%285 = getelementptr inbounds i8, i8* %284, i64 2
%286 = load i8, i8* %285
%287 = zext i8 %286 to i32
%288 = load i32, i32* %5
%289 = add i32 %288, %287
store i32 %289, i32* %5
%290 = load i32, i32* %5
%291 = load i32, i32* %8
%292 = add i32 %291, %290
store i32 %292, i32* %8
%293 = load i8*, i8** %6
%294 = getelementptr inbounds i8, i8* %293, i64 3
%295 = load i8, i8* %294
%296 = zext i8 %295 to i32
%297 = load i32, i32* %5
%298 = add i32 %297, %296
store i32 %298, i32* %5
%299 = load i32, i32* %5
%300 = load i32, i32* %8
%301 = add i32 %300, %299
store i32 %301, i32* %8
%302 = load i8*, i8** %6
%303 = getelementptr inbounds i8, i8* %302, i64 4
%304 = load i8, i8* %303
%305 = zext i8 %304 to i32
%306 = load i32, i32* %5
%307 = add i32 %306, %305
store i32 %307, i32* %5
%308 = load i32, i32* %5
%309 = load i32, i32* %8
%310 = add i32 %309, %308
store i32 %310, i32* %8
%311 = load i8*, i8** %6
%312 = getelementptr inbounds i8, i8* %311, i64 5
%313 = load i8, i8* %312
%314 = zext i8 %313 to i32
%315 = load i32, i32* %5
%316 = add i32 %315, %314
store i32 %316, i32* %5
%317 = load i32, i32* %5
%318 = load i32, i32* %8
%319 = add i32 %318, %317
store i32 %319, i32* %8
%320 = load i8*, i8** %6
%321 = getelementptr inbounds i8, i8* %320, i64 6
%322 = load i8, i8* %321
%323 = zext i8 %322 to i32
%324 = load i32, i32* %5
%325 = add i32 %324, %323
store i32 %325, i32* %5
%326 = load i32, i32* %5
%327 = load i32, i32* %8
%328 = add i32 %327, %326
store i32 %328, i32* %8
%329 = load i8*, i8** %6
%330 = getelementptr inbounds i8, i8* %329, i64 7
%331 = load i8, i8* %330
%332 = zext i8 %331 to i32
%333 = load i32, i32* %5
%334 = add i32 %333, %332
store i32 %334, i32* %5
%335 = load i32, i32* %5
%336 = load i32, i32* %8
%337 = add i32 %336, %335
store i32 %337, i32* %8
%338 = load i8*, i8** %6
%339 = getelementptr inbounds i8, i8* %338, i64 8
%340 = load i8, i8* %339
%341 = zext i8 %340 to i32
%342 = load i32, i32* %5
%343 = add i32 %342, %341
store i32 %343, i32* %5
%344 = load i32, i32* %5
%345 = load i32, i32* %8
%346 = add i32 %345, %344
store i32 %346, i32* %8
%347 = load i8*, i8** %6
%348 = getelementptr inbounds i8, i8* %347, i64 9
%349 = load i8, i8* %348
%350 = zext i8 %349 to i32
%351 = load i32, i32* %5
%352 = add i32 %351, %350
store i32 %352, i32* %5
%353 = load i32, i32* %5
%354 = load i32, i32* %8
%355 = add i32 %354, %353
store i32 %355, i32* %8
%356 = load i8*, i8** %6
%357 = getelementptr inbounds i8, i8* %356, i64 10
%358 = load i8, i8* %357
%359 = zext i8 %358 to i32
%360 = load i32, i32* %5
%361 = add i32 %360, %359
store i32 %361, i32* %5
%362 = load i32, i32* %5
%363 = load i32, i32* %8
%364 = add i32 %363, %362
store i32 %364, i32* %8
%365 = load i8*, i8** %6
%366 = getelementptr inbounds i8, i8* %365, i64 11
%367 = load i8, i8* %366
%368 = zext i8 %367 to i32
%369 = load i32, i32* %5
%370 = add i32 %369, %368
store i32 %370, i32* %5
%371 = load i32, i32* %5
%372 = load i32, i32* %8
%373 = add i32 %372, %371
store i32 %373, i32* %8
%374 = load i8*, i8** %6
%375 = getelementptr inbounds i8, i8* %374, i64 12
%376 = load i8, i8* %375
%377 = zext i8 %376 to i32
%378 = load i32, i32* %5
%379 = add i32 %378, %377
store i32 %379, i32* %5
%380 = load i32, i32* %5
%381 = load i32, i32* %8
%382 = add i32 %381, %380
store i32 %382, i32* %8
%383 = load i8*, i8** %6
%384 = getelementptr inbounds i8, i8* %383, i64 13
%385 = load i8, i8* %384
%386 = zext i8 %385 to i32
%387 = load i32, i32* %5
%388 = add i32 %387, %386
store i32 %388, i32* %5
%389 = load i32, i32* %5
%390 = load i32, i32* %8
%391 = add i32 %390, %389
store i32 %391, i32* %8
%392 = load i8*, i8** %6
%393 = getelementptr inbounds i8, i8* %392, i64 14
%394 = load i8, i8* %393
%395 = zext i8 %394 to i32
%396 = load i32, i32* %5
%397 = add i32 %396, %395
store i32 %397, i32* %5
%398 = load i32, i32* %5
%399 = load i32, i32* %8
%400 = add i32 %399, %398
store i32 %400, i32* %8
%401 = load i8*, i8** %6
%402 = getelementptr inbounds i8, i8* %401, i64 15
%403 = load i8, i8* %402
%404 = zext i8 %403 to i32
%405 = load i32, i32* %5
%406 = add i32 %405, %404
store i32 %406, i32* %5
%407 = load i32, i32* %5
%408 = load i32, i32* %8
%409 = add i32 %408, %407
store i32 %409, i32* %8
%410 = load i8*, i8** %6
%411 = getelementptr inbounds i8, i8* %410, i64 16
store i8* %411, i8** %6
br label %260
412: ; preds = %260
br label %413
413: ; preds = %417, %412
%414 = load i32, i32* %7
%415 = add i32 %414, -1
store i32 %415, i32* %7
%416 = icmp ne i32 %414, 0
br i1 %416, label %417, label %427
417: ; preds = %413
%418 = load i8*, i8** %6
%419 = getelementptr inbounds i8, i8* %418, i32 1
store i8* %419, i8** %6
%420 = load i8, i8* %418
%421 = zext i8 %420 to i32
%422 = load i32, i32* %5
%423 = add i32 %422, %421
store i32 %423, i32* %5
%424 = load i32, i32* %5
%425 = load i32, i32* %8
%426 = add i32 %425, %424
store i32 %426, i32* %8
br label %413
427: ; preds = %413
%428 = load i32, i32* %5
%429 = zext i32 %428 to i64
%430 = urem i64 %429, 65521
%431 = trunc i64 %430 to i32
store i32 %431, i32* %5
%432 = load i32, i32* %8
%433 = zext i32 %432 to i64
%434 = urem i64 %433, 65521
%435 = trunc i64 %434 to i32
store i32 %435, i32* %8
br label %436
436: ; preds = %427, %256
%437 = load i32, i32* %5
%438 = load i32, i32* %8
%439 = shl i32 %438, 16
%440 = or i32 %437, %439
store i32 %440, i32* %4
br label %441
441: ; preds = %436, %80, %52, %44
%442 = load i32, i32* %4
ret i32 %442
}

LLVM IR (-O2):
define i32 @adler32(i32 %0, i8* %1, i32 %2) {
%4 = lshr i32 %0, 16
%5 = and i32 %0, 65535
%6 = icmp eq i32 %2, 1
br i1 %6, label %7, label %20
7: ; preds = %3
%8 = load i8, i8* %1
%9 = zext i8 %8 to i32
%10 = add nuw nsw i32 %5, %9
%11 = icmp ugt i32 %10, 65520
%12 = add nsw i32 %10, -65521
%13 = select i1 %11, i32 %12, i32 %10
%14 = add nuw nsw i32 %13, %4
%15 = icmp ugt i32 %14, 65520
%16 = shl i32 %14, 16
%17 = add i32 %16, 983040
%18 = select i1 %15, i32 %17, i32 %16
%19 = or i32 %18, %13
br label %353
20: ; preds = %3
%21 = icmp eq i8* %1, null
br i1 %21, label %353, label %22
22: ; preds = %20
%23 = icmp ult i32 %2, 16
br i1 %23, label %26, label %24
24: ; preds = %22
%25 = icmp ugt i32 %2, 5551
br i1 %25, label %90, label %192
26: ; preds = %22
%27 = icmp eq i32 %2, 0
br i1 %27, label %81, label %28
28: ; preds = %26
%29 = add i32 %2, -1
%30 = and i32 %2, 3
%31 = icmp eq i32 %30, 0
br i1 %31, label %46, label %32
32: ; preds = %28, %32
%33 = phi i32 [ %43, %32 ], [ %4, %28 ]
%34 = phi i32 [ %38, %32 ], [ %2, %28 ]
%35 = phi i8* [ %39, %32 ], [ %1, %28 ]
%36 = phi i32 [ %42, %32 ], [ %5, %28 ]
%37 = phi i32 [ %44, %32 ], [ 0, %28 ]
%38 = add i32 %34, -1
%39 = getelementptr inbounds i8, i8* %35, i64 1
%40 = load i8, i8* %35
%41 = zext i8 %40 to i32
%42 = add i32 %36, %41
%43 = add i32 %42, %33
%44 = add i32 %37, 1
%45 = icmp eq i32 %44, %30
br i1 %45, label %46, label %32
46: ; preds = %32, %28
%47 = phi i32 [ undef, %28 ], [ %42, %32 ]
%48 = phi i32 [ undef, %28 ], [ %43, %32 ]
%49 = phi i32 [ %4, %28 ], [ %43, %32 ]
%50 = phi i32 [ %2, %28 ], [ %38, %32 ]
%51 = phi i8* [ %1, %28 ], [ %39, %32 ]
%52 = phi i32 [ %5, %28 ], [ %42, %32 ]
%53 = icmp ult i32 %29, 3
br i1 %53, label %81, label %54
54: ; preds = %46, %54
%55 = phi i32 [ %79, %54 ], [ %49, %46 ]
%56 = phi i32 [ %74, %54 ], [ %50, %46 ]
%57 = phi i8* [ %75, %54 ], [ %51, %46 ]
%58 = phi i32 [ %78, %54 ], [ %52, %46 ]
%59 = getelementptr inbounds i8, i8* %57, i64 1
%60 = load i8, i8* %57
%61 = zext i8 %60 to i32
%62 = add i32 %58, %61
%63 = add i32 %62, %55
%64 = getelementptr inbounds i8, i8* %57, i64 2
%65 = load i8, i8* %59
%66 = zext i8 %65 to i32
%67 = add i32 %62, %66
%68 = add i32 %67, %63
%69 = getelementptr inbounds i8, i8* %57, i64 3
%70 = load i8, i8* %64
%71 = zext i8 %70 to i32
%72 = add i32 %67, %71
%73 = add i32 %72, %68
%74 = add i32 %56, -4
%75 = getelementptr inbounds i8, i8* %57, i64 4
%76 = load i8, i8* %69
%77 = zext i8 %76 to i32
%78 = add i32 %72, %77
%79 = add i32 %78, %73
%80 = icmp eq i32 %74, 0
br i1 %80, label %81, label %54
81: ; preds = %46, %54, %26
%82 = phi i32 [ %5, %26 ], [ %47, %46 ], [ %78, %54 ]
%83 = phi i32 [ %4, %26 ], [ %48, %46 ], [ %79, %54 ]
%84 = icmp ugt i32 %82, 65520
%85 = add i32 %82, -65521
%86 = select i1 %84, i32 %85, i32 %82
%87 = urem i32 %83, 65521
%88 = shl nuw i32 %87, 16
%89 = or i32 %88, %86
br label %353
90: ; preds = %24, %183
%91 = phi i32 [ %186, %183 ], [ %4, %24 ]
%92 = phi i32 [ %95, %183 ], [ %2, %24 ]
%93 = phi i8* [ %184, %183 ], [ %1, %24 ]
%94 = phi i32 [ %185, %183 ], [ %5, %24 ]
%95 = add i32 %92, -5552
br label %96
96: ; preds = %96, %90
%97 = phi i32 [ %94, %90 ], [ %178, %96 ]
%98 = phi i8* [ %93, %90 ], [ %180, %96 ]
%99 = phi i32 [ %91, %90 ], [ %179, %96 ]
%100 = phi i32 [ 347, %90 ], [ %181, %96 ]
%101 = load i8, i8* %98
%102 = zext i8 %101 to i32
%103 = add i32 %97, %102
%104 = add i32 %103, %99
%105 = getelementptr inbounds i8, i8* %98, i64 1
%106 = load i8, i8* %105
%107 = zext i8 %106 to i32
%108 = add i32 %103, %107
%109 = add i32 %104, %108
%110 = getelementptr inbounds i8, i8* %98, i64 2
%111 = load i8, i8* %110
%112 = zext i8 %111 to i32
%113 = add i32 %108, %112
%114 = add i32 %109, %113
%115 = getelementptr inbounds i8, i8* %98, i64 3
%116 = load i8, i8* %115
%117 = zext i8 %116 to i32
%118 = add i32 %113, %117
%119 = add i32 %114, %118
%120 = getelementptr inbounds i8, i8* %98, i64 4
%121 = load i8, i8* %120
%122 = zext i8 %121 to i32
%123 = add i32 %118, %122
%124 = add i32 %119, %123
%125 = getelementptr inbounds i8, i8* %98, i64 5
%126 = load i8, i8* %125
%127 = zext i8 %126 to i32
%128 = add i32 %123, %127
%129 = add i32 %124, %128
%130 = getelementptr inbounds i8, i8* %98, i64 6
%131 = load i8, i8* %130
%132 = zext i8 %131 to i32
%133 = add i32 %128, %132
%134 = add i32 %129, %133
%135 = getelementptr inbounds i8, i8* %98, i64 7
%136 = load i8, i8* %135
%137 = zext i8 %136 to i32
%138 = add i32 %133, %137
%139 = add i32 %134, %138
%140 = getelementptr inbounds i8, i8* %98, i64 8
%141 = load i8, i8* %140
%142 = zext i8 %141 to i32
%143 = add i32 %138, %142
%144 = add i32 %139, %143
%145 = getelementptr inbounds i8, i8* %98, i64 9
%146 = load i8, i8* %145
%147 = zext i8 %146 to i32
%148 = add i32 %143, %147
%149 = add i32 %144, %148
%150 = getelementptr inbounds i8, i8* %98, i64 10
%151 = load i8, i8* %150
%152 = zext i8 %151 to i32
%153 = add i32 %148, %152
%154 = add i32 %149, %153
%155 = getelementptr inbounds i8, i8* %98, i64 11
%156 = load i8, i8* %155
%157 = zext i8 %156 to i32
%158 = add i32 %153, %157
%159 = add i32 %154, %158
%160 = getelementptr inbounds i8, i8* %98, i64 12
%161 = load i8, i8* %160
%162 = zext i8 %161 to i32
%163 = add i32 %158, %162
%164 = add i32 %159, %163
%165 = getelementptr inbounds i8, i8* %98, i64 13
%166 = load i8, i8* %165
%167 = zext i8 %166 to i32
%168 = add i32 %163, %167
%169 = add i32 %164, %168
%170 = getelementptr inbounds i8, i8* %98, i64 14
%171 = load i8, i8* %170
%172 = zext i8 %171 to i32
%173 = add i32 %168, %172
%174 = add i32 %169, %173
%175 = getelementptr inbounds i8, i8* %98, i64 15
%176 = load i8, i8* %175
%177 = zext i8 %176 to i32
%178 = add i32 %173, %177
%179 = add i32 %174, %178
%180 = getelementptr inbounds i8, i8* %98, i64 16
%181 = add nsw i32 %100, -1
%182 = icmp eq i32 %181, 0
br i1 %182, label %183, label %96
183: ; preds = %96
%184 = getelementptr i8, i8* %93, i64 5552
%185 = urem i32 %178, 65521
%186 = urem i32 %179, 65521
%187 = icmp ugt i32 %95, 5551
br i1 %187, label %90, label %188
188: ; preds = %183
%189 = icmp eq i32 %95, 0
br i1 %189, label %348, label %190
190: ; preds = %188
%191 = icmp ugt i32 %95, 15
br i1 %191, label %192, label %199
192: ; preds = %24, %190
%193 = phi i32 [ %4, %24 ], [ %186, %190 ]
%194 = phi i32 [ %2, %24 ], [ %95, %190 ]
%195 = phi i8* [ %1, %24 ], [ %184, %190 ]
%196 = phi i32 [ %5, %24 ], [ %185, %190 ]
br label %229
197: ; preds = %229
%198 = icmp eq i32 %234, 0
br i1 %198, label %343, label %199
199: ; preds = %190, %197
%200 = phi i32 [ %186, %190 ], [ %313, %197 ]
%201 = phi i32 [ %95, %190 ], [ %234, %197 ]
%202 = phi i8* [ %184, %190 ], [ %314, %197 ]
%203 = phi i32 [ %185, %190 ], [ %312, %197 ]
%204 = add i32 %201, -1
%205 = and i32 %201, 3
%206 = icmp eq i32 %205, 0
br i1 %206, label %221, label %207
207: ; preds = %199, %207
%208 = phi i32 [ %218, %207 ], [ %200, %199 ]
%209 = phi i32 [ %213, %207 ], [ %201, %199 ]
%210 = phi i8* [ %214, %207 ], [ %202, %199 ]
%211 = phi i32 [ %217, %207 ], [ %203, %199 ]
%212 = phi i32 [ %219, %207 ], [ 0, %199 ]
%213 = add i32 %209, -1
%214 = getelementptr inbounds i8, i8* %210, i64 1
%215 = load i8, i8* %210
%216 = zext i8 %215 to i32
%217 = add i32 %211, %216
%218 = add i32 %217, %208
%219 = add i32 %212, 1
%220 = icmp eq i32 %219, %205
br i1 %220, label %221, label %207
221: ; preds = %207, %199
%222 = phi i32 [ undef, %199 ], [ %217, %207 ]
%223 = phi i32 [ undef, %199 ], [ %218, %207 ]
%224 = phi i32 [ %200, %199 ], [ %218, %207 ]
%225 = phi i32 [ %201, %199 ], [ %213, %207 ]
%226 = phi i8* [ %202, %199 ], [ %214, %207 ]
%227 = phi i32 [ %203, %199 ], [ %217, %207 ]
%228 = icmp ult i32 %204, 3
br i1 %228, label %343, label %316
229: ; preds = %192, %229
%230 = phi i32 [ %313, %229 ], [ %193, %192 ]
%231 = phi i32 [ %234, %229 ], [ %194, %192 ]
%232 = phi i8* [ %314, %229 ], [ %195, %192 ]
%233 = phi i32 [ %312, %229 ], [ %196, %192 ]
%234 = add i32 %231, -16
%235 = load i8, i8* %232
%236 = zext i8 %235 to i32
%237 = add i32 %233, %236
%238 = add i32 %237, %230
%239 = getelementptr inbounds i8, i8* %232, i64 1
%240 = load i8, i8* %239
%241 = zext i8 %240 to i32
%242 = add i32 %237, %241
%243 = add i32 %238, %242
%244 = getelementptr inbounds i8, i8* %232, i64 2
%245 = load i8, i8* %244
%246 = zext i8 %245 to i32
%247 = add i32 %242, %246
%248 = add i32 %243, %247
%249 = getelementptr inbounds i8, i8* %232, i64 3
%250 = load i8, i8* %249
%251 = zext i8 %250 to i32
%252 = add i32 %247, %251
%253 = add i32 %248, %252
%254 = getelementptr inbounds i8, i8* %232, i64 4
%255 = load i8, i8* %254
%256 = zext i8 %255 to i32
%257 = add i32 %252, %256
%258 = add i32 %253, %257
%259 = getelementptr inbounds i8, i8* %232, i64 5
%260 = load i8, i8* %259
%261 = zext i8 %260 to i32
%262 = add i32 %257, %261
%263 = add i32 %258, %262
%264 = getelementptr inbounds i8, i8* %232, i64 6
%265 = load i8, i8* %264
%266 = zext i8 %265 to i32
%267 = add i32 %262, %266
%268 = add i32 %263, %267
%269 = getelementptr inbounds i8, i8* %232, i64 7
%270 = load i8, i8* %269
%271 = zext i8 %270 to i32
%272 = add i32 %267, %271
%273 = add i32 %268, %272
%274 = getelementptr inbounds i8, i8* %232, i64 8
%275 = load i8, i8* %274
%276 = zext i8 %275 to i32
%277 = add i32 %272, %276
%278 = add i32 %273, %277
%279 = getelementptr inbounds i8, i8* %232, i64 9
%280 = load i8, i8* %279
%281 = zext i8 %280 to i32
%282 = add i32 %277, %281
%283 = add i32 %278, %282
%284 = getelementptr inbounds i8, i8* %232, i64 10
%285 = load i8, i8* %284
%286 = zext i8 %285 to i32
%287 = add i32 %282, %286
%288 = add i32 %283, %287
%289 = getelementptr inbounds i8, i8* %232, i64 11
%290 = load i8, i8* %289
%291 = zext i8 %290 to i32
%292 = add i32 %287, %291
%293 = add i32 %288, %292
%294 = getelementptr inbounds i8, i8* %232, i64 12
%295 = load i8, i8* %294
%296 = zext i8 %295 to i32
%297 = add i32 %292, %296
%298 = add i32 %293, %297
%299 = getelementptr inbounds i8, i8* %232, i64 13
%300 = load i8, i8* %299
%301 = zext i8 %300 to i32
%302 = add i32 %297, %301
%303 = add i32 %298, %302
%304 = getelementptr inbounds i8, i8* %232, i64 14
%305 = load i8, i8* %304
%306 = zext i8 %305 to i32
%307 = add i32 %302, %306
%308 = add i32 %303, %307
%309 = getelementptr inbounds i8, i8* %232, i64 15
%310 = load i8, i8* %309
%311 = zext i8 %310 to i32
%312 = add i32 %307, %311
%313 = add i32 %308, %312
%314 = getelementptr inbounds i8, i8* %232, i64 16
%315 = icmp ugt i32 %234, 15
br i1 %315, label %229, label %197
316: ; preds = %221, %316
%317 = phi i32 [ %341, %316 ], [ %224, %221 ]
%318 = phi i32 [ %336, %316 ], [ %225, %221 ]
%319 = phi i8* [ %337, %316 ], [ %226, %221 ]
%320 = phi i32 [ %340, %316 ], [ %227, %221 ]
%321 = getelementptr inbounds i8, i8* %319, i64 1
%322 = load i8, i8* %319
%323 = zext i8 %322 to i32
%324 = add i32 %320, %323
%325 = add i32 %324, %317
%326 = getelementptr inbounds i8, i8* %319, i64 2
%327 = load i8, i8* %321
%328 = zext i8 %327 to i32
%329 = add i32 %324, %328
%330 = add i32 %329, %325
%331 = getelementptr inbounds i8, i8* %319, i64 3
%332 = load i8, i8* %326
%333 = zext i8 %332 to i32
%334 = add i32 %329, %333
%335 = add i32 %334, %330
%336 = add i32 %318, -4
%337 = getelementptr inbounds i8, i8* %319, i64 4
%338 = load i8, i8* %331
%339 = zext i8 %338 to i32
%340 = add i32 %334, %339
%341 = add i32 %340, %335
%342 = icmp eq i32 %336, 0
br i1 %342, label %343, label %316
343: ; preds = %221, %316, %197
%344 = phi i32 [ %312, %197 ], [ %222, %221 ], [ %340, %316 ]
%345 = phi i32 [ %313, %197 ], [ %223, %221 ], [ %341, %316 ]
%346 = urem i32 %344, 65521
%347 = urem i32 %345, 65521
br label %348
348: ; preds = %343, %188
%349 = phi i32 [ %346, %343 ], [ %185, %188 ]
%350 = phi i32 [ %347, %343 ], [ %186, %188 ]
%351 = shl nuw i32 %350, 16
%352 = or i32 %351, %349
br label %353
353: ; preds = %20, %348, %81, %7
%354 = phi i32 [ %19, %7 ], [ %89, %81 ], [ %352, %348 ], [ 1, %20 ]
ret i32 %354
}