#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 long adler32(unsigned long adler, const unsigned char *buf,
                      unsigned int len) {
  unsigned long 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 == NULL)
    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    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
shr    $0x10,%rax
and    $0xffff,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
and    $0xffff,%rax
mov    %rax,-0x10(%rbp)
cmpl   $0x1,-0x1c(%rbp)
jne    11a4 <adler32+0xa4>
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
cmpq   $0xfff1,-0x10(%rbp)
jb     1164 <adler32+0x64>
mov    -0x10(%rbp),%rax
sub    $0xfff1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
cmpq   $0xfff1,-0x28(%rbp)
jb     118c <adler32+0x8c>
mov    -0x28(%rbp),%rax
sub    $0xfff1,%rax
mov    %rax,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
or     %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    16e7 <adler32+0x5e7>
cmpq   $0x0,-0x18(%rbp)
jne    11bc <adler32+0xbc>
movq   $0x1,-0x8(%rbp)
jmp    16e7 <adler32+0x5e7>
cmpl   $0x10,-0x1c(%rbp)
jae    1250 <adler32+0x150>
jmp    11cb <adler32+0xcb>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     120a <adler32+0x10a>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movzbl (%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    11cb <adler32+0xcb>
cmpq   $0xfff1,-0x10(%rbp)
jb     1226 <adler32+0x126>
mov    -0x10(%rbp),%rax
sub    $0xfff1,%rax
mov    %rax,-0x10(%rbp)
mov    -0x28(%rbp),%rax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %rdx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
or     %rcx,%rax
mov    %rax,-0x8(%rbp)
jmp    16e7 <adler32+0x5e7>
jmp    1255 <adler32+0x155>
cmpl   $0x15b0,-0x1c(%rbp)
jb     147a <adler32+0x37a>
mov    -0x1c(%rbp),%eax
sub    $0x15b0,%eax
mov    %eax,-0x1c(%rbp)
movl   $0x15b,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x4(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x5(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x6(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x7(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x9(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xa(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xb(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xc(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xd(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xe(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xf(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x2c(%rbp)
cmp    $0x0,%eax
jne    1274 <adler32+0x174>
mov    -0x10(%rbp),%rax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %rdx,-0x10(%rbp)
mov    -0x28(%rbp),%rax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %rdx,-0x28(%rbp)
jmp    1255 <adler32+0x155>
cmpl   $0x0,-0x1c(%rbp)
je     16d4 <adler32+0x5d4>
jmp    1489 <adler32+0x389>
cmpl   $0x10,-0x1c(%rbp)
jb     166c <adler32+0x56c>
mov    -0x1c(%rbp),%eax
sub    $0x10,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%rax
movzbl (%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x1(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x2(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x3(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x4(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x5(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x6(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x7(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x8(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0x9(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xa(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xb(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xc(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xd(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xe(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
movzbl 0xf(%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
add    $0x10,%rax
mov    %rax,-0x18(%rbp)
jmp    1489 <adler32+0x389>
jmp    1671 <adler32+0x571>
mov    -0x1c(%rbp),%eax
mov    %eax,%ecx
add    $0xffffffff,%ecx
mov    %ecx,-0x1c(%rbp)
cmp    $0x0,%eax
je     16b0 <adler32+0x5b0>
mov    -0x18(%rbp),%rax
mov    %rax,%rcx
add    $0x1,%rcx
mov    %rcx,-0x18(%rbp)
movzbl (%rax),%eax
add    -0x10(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x10(%rbp),%rax
add    -0x28(%rbp),%rax
mov    %rax,-0x28(%rbp)
jmp    1671 <adler32+0x571>
mov    -0x10(%rbp),%rax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %rdx,-0x10(%rbp)
mov    -0x28(%rbp),%rax
mov    $0xfff1,%ecx
xor    %edx,%edx
div    %rcx
mov    %rdx,-0x28(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x28(%rbp),%rcx
shl    $0x10,%rcx
or     %rcx,%rax
mov    %rax,-0x8(%rbp)
mov    -0x8(%rbp),%rax
pop    %rbp
ret

x86 assembly (clang, -O2):
<adler32>:
mov    %rdi,%rcx
movzwl %cx,%edi
shr    $0x10,%ecx
cmp    $0x1,%edx
jne    1151 <adler32+0x51>
movzbl (%rsi),%eax
lea    (%rdi,%rax,1),%rdx
cmp    $0xfff1,%rdx
lea    -0xfff1(%rdi,%rax,1),%rax
ff
cmovb  %rdx,%rax
add    %rax,%rcx
mov    %rcx,%rdx
shl    $0x10,%rdx
movabs $0xffffffff000f0000,%rsi
ff ff ff
add    %rdx,%rsi
cmp    $0xfff1,%rcx
cmovb  %rdx,%rsi
or     %rax,%rsi
mov    %rsi,%rax
ret
test   %rsi,%rsi
je     123b <adler32+0x13b>
mov    %edx,%r8d
cmp    $0x10,%edx
jae    1241 <adler32+0x141>
test   %r8d,%r8d
je     11f4 <adler32+0xf4>
lea    -0x1(%r8),%r9d
test   $0x3,%r8b
je     11a9 <adler32+0xa9>
mov    %r8d,%r10d
and    $0x3,%r10d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
movzbl (%rsi,%rdx,1),%eax
add    %rax,%rdi
add    %rdi,%rcx
add    $0x1,%rdx
cmp    %edx,%r10d
jne    1190 <adler32+0x90>
sub    %edx,%r8d
add    %rdx,%rsi
cmp    $0x3,%r9d
jb     11f4 <adler32+0xf4>
mov    %r8d,%r8d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsi,%rdx,1),%eax
add    %rdi,%rax
add    %rax,%rcx
movzbl 0x1(%rsi,%rdx,1),%edi
add    %rax,%rdi
add    %rdi,%rcx
movzbl 0x2(%rsi,%rdx,1),%eax
add    %rdi,%rax
add    %rax,%rcx
movzbl 0x3(%rsi,%rdx,1),%edi
add    %rax,%rdi
add    %rdi,%rcx
add    $0x4,%rdx
cmp    %edx,%r8d
jne    11c0 <adler32+0xc0>
lea    -0xfff1(%rdi),%rsi
cmp    $0xfff1,%rdi
cmovb  %rdi,%rsi
movabs $0xf00e10d2fc5cd,%rdx
mov    %rcx,%rax
mul    %rdx
mov    %rcx,%rax
sub    %rdx,%rax
shr    %rax
add    %rdx,%rax
shr    $0xf,%rax
imul   $0xfff1,%rax,%rax
sub    %rax,%rcx
shl    $0x10,%rcx
or     %rsi,%rcx
mov    %rcx,%rax
ret
mov    $0x1,%eax
ret
cmp    $0x15b0,%r8d
jb     13a0 <adler32+0x2a0>
movabs $0xf00e10d2fc5cd,%r9
nopl   0x0(%rax,%rax,1)
add    $0xffffea50,%r8d
xor    %eax,%eax
nopl   0x0(%rax)
movzbl (%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0x1(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0x2(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0x3(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0x4(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0x5(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0x6(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0x7(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0x8(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0x9(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0xa(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0xb(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0xc(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0xd(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
movzbl 0xe(%rsi,%rax,1),%edx
add    %rdi,%rdx
add    %rdx,%rcx
movzbl 0xf(%rsi,%rax,1),%edi
add    %rdx,%rdi
add    %rdi,%rcx
add    $0x10,%rax
cmp    $0x15b0,%eax
jne    1270 <adler32+0x170>
mov    %rdi,%rax
mul    %r9
add    $0x15b0,%rsi
mov    %rdi,%rax
sub    %rdx,%rax
shr    %rax
add    %rdx,%rax
shr    $0xf,%rax
imul   $0xfff1,%rax,%r10
mov    %rcx,%rax
mul    %r9
sub    %r10,%rdi
mov    %rcx,%rax
sub    %rdx,%rax
shr    %rax
add    %rdx,%rax
shr    $0xf,%rax
imul   $0xfff1,%rax,%rax
sub    %rax,%rcx
cmp    $0x15af,%r8d
ja     1260 <adler32+0x160>
test   %r8d,%r8d
je     151e <adler32+0x41e>
cmp    $0x10,%r8d
jb     145a <adler32+0x35a>
cs nopw 0x0(%rax,%rax,1)
nop
add    $0xfffffff0,%r8d
movzbl (%rsi),%eax
add    %rdi,%rax
add    %rax,%rcx
movzbl 0x1(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0x2(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0x3(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0x4(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0x5(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0x6(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0x7(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0x8(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0x9(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0xa(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0xb(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0xc(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0xd(%rsi),%edx
add    %rax,%rdx
add    %rdx,%rcx
movzbl 0xe(%rsi),%eax
add    %rdx,%rax
add    %rax,%rcx
movzbl 0xf(%rsi),%edi
add    %rax,%rdi
add    %rdi,%rcx
add    $0x10,%rsi
cmp    $0xf,%r8d
ja     13a0 <adler32+0x2a0>
test   %r8d,%r8d
je     14d4 <adler32+0x3d4>
lea    -0x1(%r8),%r9d
test   $0x3,%r8b
je     1489 <adler32+0x389>
mov    %r8d,%r10d
and    $0x3,%r10d
xor    %edx,%edx
nopl   (%rax)
movzbl (%rsi,%rdx,1),%eax
add    %rax,%rdi
add    %rdi,%rcx
add    $0x1,%rdx
cmp    %edx,%r10d
jne    1470 <adler32+0x370>
sub    %edx,%r8d
add    %rdx,%rsi
cmp    $0x3,%r9d
jb     14d4 <adler32+0x3d4>
mov    %r8d,%r8d
xor    %edx,%edx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movzbl (%rsi,%rdx,1),%eax
add    %rdi,%rax
add    %rax,%rcx
movzbl 0x1(%rsi,%rdx,1),%edi
add    %rax,%rdi
add    %rdi,%rcx
movzbl 0x2(%rsi,%rdx,1),%eax
add    %rdi,%rax
add    %rax,%rcx
movzbl 0x3(%rsi,%rdx,1),%edi
add    %rax,%rdi
add    %rdi,%rcx
add    $0x4,%rdx
cmp    %edx,%r8d
jne    14a0 <adler32+0x3a0>
movabs $0xf00e10d2fc5cd,%rsi
mov    %rdi,%rax
mul    %rsi
mov    %rdi,%rax
sub    %rdx,%rax
shr    %rax
add    %rdx,%rax
shr    $0xf,%rax
imul   $0xfff1,%rax,%rax
sub    %rax,%rdi
mov    %rcx,%rax
mul    %rsi
mov    %rcx,%rax
sub    %rdx,%rax
shr    %rax
add    %rdx,%rax
shr    $0xf,%rax
imul   $0xfff1,%rax,%rax
sub    %rax,%rcx
shl    $0x10,%rcx
or     %rdi,%rcx
mov    %rcx,%rax
ret

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

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