#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 */
size_t strlen(char *);
unsigned long newhash32(unsigned char *str) {
  size_t n, len;
  unsigned long a, b, c;
  n = len = strlen((char *)str);
  a = 0x9e3779b9;
  b = 0x9e3779b9;
  c = str[0];
  while (len >= 12) {
    a = a + (str[0] + ((unsigned long)str[1] << 8) +
             ((unsigned long)str[2] << 16) + ((unsigned long)str[3] << 24));
    b = b + (str[4] + ((unsigned long)str[5] << 8) +
             ((unsigned long)str[6] << 16) + ((unsigned long)str[7] << 24));
    c = c + (str[8] + ((unsigned long)str[9] << 8) +
             ((unsigned long)str[10] << 16) + ((unsigned long)str[11] << 24));
    {
      a = a - b;
      a = a - c;
      a = a ^ (c >> 13);
      b = b - c;
      b = b - a;
      b = b ^ (a << 8);
      c = c - a;
      c = c - b;
      c = c ^ (b >> 13);
      a = a - b;
      a = a - c;
      a = a ^ (c >> 12);
      b = b - c;
      b = b - a;
      b = b ^ (a << 16);
      c = c - a;
      c = c - b;
      c = c ^ (b >> 5);
      a = a - b;
      a = a - c;
      a = a ^ (c >> 3);
      b = b - c;
      b = b - a;
      b = b ^ (a << 10);
      c = c - a;
      c = c - b;
      c = c ^ (b >> 15);
    };
    str = str + 12;
    len = len - 12;
  }
  c += n;
  switch (len) {
  case 11:
    c = c + ((unsigned long)str[10] << 24);
  case 10:
    c = c + ((unsigned long)str[9] << 16);
  case 9:
    c = c + ((unsigned long)str[8] << 8);
  case 8:
    b = b + ((unsigned long)str[7] << 24);
  case 7:
    b = b + ((unsigned long)str[6] << 16);
  case 6:
    b = b + ((unsigned long)str[5] << 8);
  case 5:
    b = b + str[4];
  case 4:
    a = a + ((unsigned long)str[3] << 24);
  case 3:
    a = a + ((unsigned long)str[2] << 16);
  case 2:
    a = a + ((unsigned long)str[1] << 8);
  case 1:
    a = a + str[0];
  }
  {
    a = a - b;
    a = a - c;
    a = a ^ (c >> 13);
    b = b - c;
    b = b - a;
    b = b ^ (a << 8);
    c = c - a;
    c = c - b;
    c = c ^ (b >> 13);
    a = a - b;
    a = a - c;
    a = a ^ (c >> 12);
    b = b - c;
    b = b - a;
    b = b ^ (a << 16);
    c = c - a;
    c = c - b;
    c = c ^ (b >> 5);
    a = a - b;
    a = a - c;
    a = a ^ (c >> 3);
    b = b - c;
    b = b - a;
    b = b ^ (a << 10);
    c = c - a;
    c = c - b;
    c = c ^ (b >> 15);
  };
  return c;
}


x86 assembly (clang, -O0):
<newhash32>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %rax,-0x18(%rbp)
mov    %rax,-0x10(%rbp)
mov    $0x9e3779b9,%eax
mov    %rax,-0x20(%rbp)
mov    $0x9e3779b9,%eax
mov    %rax,-0x28(%rbp)
mov    -0x8(%rbp),%rax
movzbl (%rax),%eax
mov    %rax,-0x30(%rbp)
cmpq   $0xc,-0x18(%rbp)
jb     13b4 <newhash32+0x2a4>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
mov    -0x8(%rbp),%rdx
movzbl 0x1(%rdx),%edx
shl    $0x8,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%rdx
movzbl 0x2(%rdx),%edx
shl    $0x10,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%rdx
movzbl 0x3(%rdx),%edx
shl    $0x18,%rdx
add    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
mov    -0x8(%rbp),%rdx
movzbl 0x5(%rdx),%edx
shl    $0x8,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%rdx
movzbl 0x6(%rdx),%edx
shl    $0x10,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%rdx
movzbl 0x7(%rdx),%edx
shl    $0x18,%rdx
add    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
mov    -0x8(%rbp),%rdx
movzbl 0x9(%rdx),%edx
shl    $0x8,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%rdx
movzbl 0xa(%rdx),%edx
shl    $0x10,%rdx
add    %rdx,%rcx
mov    -0x8(%rbp),%rdx
movzbl 0xb(%rdx),%edx
shl    $0x18,%rdx
add    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shr    $0xd,%rcx
xor    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x8,%rcx
xor    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0xd,%rcx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shr    $0xc,%rcx
xor    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x10,%rcx
xor    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0x5,%rcx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shr    $0x3,%rcx
xor    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0xa,%rcx
xor    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0xf,%rcx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x18(%rbp)
jmp    114a <newhash32+0x3a>
mov    -0x10(%rbp),%rcx
mov    -0x30(%rbp),%rax
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
add    $0xffffffffffffffff,%rax
mov    %rax,-0x38(%rbp)
sub    $0xa,%rax
ja     14e1 <newhash32+0x3d1>
mov    -0x38(%rbp),%rax
lea    0xc1c(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
shl    $0x18,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
shl    $0x10,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x8(%rcx),%ecx
shl    $0x8,%rcx
add    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x7(%rcx),%ecx
shl    $0x18,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x6(%rcx),%ecx
shl    $0x10,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x5(%rcx),%ecx
shl    $0x8,%rcx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x4(%rcx),%ecx
add    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
shl    $0x18,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x10,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x8,%rcx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
movzbl (%rcx),%ecx
add    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shr    $0xd,%rcx
xor    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x8,%rcx
xor    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0xd,%rcx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shr    $0xc,%rcx
xor    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0x10,%rcx
xor    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0x5,%rcx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x20(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x30(%rbp),%rcx
shr    $0x3,%rcx
xor    %rcx,%rax
mov    %rax,-0x20(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x30(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x28(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x20(%rbp),%rcx
shl    $0xa,%rcx
xor    %rcx,%rax
mov    %rax,-0x28(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x20(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
sub    -0x28(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
mov    -0x28(%rbp),%rcx
shr    $0xf,%rcx
xor    %rcx,%rax
mov    %rax,-0x30(%rbp)
mov    -0x30(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<newhash32>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
mov    $0x9e3779b9,%ebx
call   1030 <strlen@plt>
mov    (%r14),%dil
movzbl %dil,%ecx
cmp    $0xc,%rax
jb     1220 <newhash32+0x110>
lea    -0xc(%rax),%r8
add    $0xc,%r14
mov    $0x9e3779b9,%edx
nop
movzbl %dil,%edi
movzbl -0xb(%r14),%esi
shl    $0x8,%rsi
or     %rdi,%rsi
movzbl -0xa(%r14),%edi
shl    $0x10,%rdi
or     %rsi,%rdi
movzbl -0x9(%r14),%esi
shl    $0x18,%rsi
or     %rdi,%rsi
add    %rdx,%rsi
mov    -0x8(%r14),%edx
mov    -0x4(%r14),%edi
add    %rbx,%rdx
add    %rcx,%rdi
sub    %rdx,%rsi
sub    %rdi,%rsi
mov    %rdi,%rcx
shr    $0xd,%rcx
xor    %rsi,%rcx
sub    %rdi,%rdx
sub    %rcx,%rdx
mov    %rcx,%rsi
shl    $0x8,%rsi
xor    %rdx,%rsi
sub    %rcx,%rdi
sub    %rsi,%rdi
mov    %rsi,%rdx
shr    $0xd,%rdx
xor    %rdi,%rdx
sub    %rsi,%rcx
sub    %rdx,%rcx
mov    %rdx,%rdi
shr    $0xc,%rdi
xor    %rcx,%rdi
sub    %rdx,%rsi
sub    %rdi,%rsi
mov    %rdi,%rcx
shl    $0x10,%rcx
xor    %rsi,%rcx
sub    %rdi,%rdx
sub    %rcx,%rdx
mov    %rcx,%rsi
shr    $0x5,%rsi
xor    %rdx,%rsi
sub    %rcx,%rdi
sub    %rsi,%rdi
mov    %rsi,%rdx
shr    $0x3,%rdx
xor    %rdi,%rdx
sub    %rsi,%rcx
sub    %rdx,%rcx
mov    %rdx,%rbx
shl    $0xa,%rbx
xor    %rcx,%rbx
sub    %rdx,%rsi
sub    %rbx,%rsi
mov    %rbx,%rcx
shr    $0xf,%rcx
xor    %rsi,%rcx
cmp    $0xc,%r8
jb     1228 <newhash32+0x118>
movzbl (%r14),%edi
add    $0xfffffffffffffff4,%r8
add    $0xc,%r14
jmp    1140 <newhash32+0x30>
mov    %rax,%r8
mov    $0x9e3779b9,%edx
add    %rax,%rcx
add    $0xffffffffffffffff,%r8
cmp    $0xa,%r8
ja     12c4 <newhash32+0x1b4>
lea    0xdc0(%rip),%rax
movslq (%rax,%r8,4),%rsi
add    %rax,%rsi
jmp    *%rsi
movzbl 0xa(%r14),%eax
shl    $0x18,%rax
add    %rax,%rcx
movzbl 0x9(%r14),%eax
shl    $0x10,%rax
add    %rax,%rcx
movzbl 0x8(%r14),%eax
shl    $0x8,%rax
add    %rax,%rcx
movzbl 0x7(%r14),%eax
shl    $0x18,%rax
add    %rax,%rbx
movzbl 0x6(%r14),%eax
shl    $0x10,%rax
add    %rax,%rbx
movzbl 0x5(%r14),%eax
shl    $0x8,%rax
add    %rax,%rbx
movzbl 0x4(%r14),%eax
add    %rax,%rbx
movzbl 0x3(%r14),%eax
shl    $0x18,%rax
add    %rax,%rdx
movzbl 0x2(%r14),%eax
shl    $0x10,%rax
add    %rax,%rdx
movzbl 0x1(%r14),%eax
shl    $0x8,%rax
add    %rax,%rdx
movzbl (%r14),%eax
add    %rax,%rdx
sub    %rbx,%rdx
sub    %rcx,%rdx
mov    %rcx,%rax
shr    $0xd,%rax
xor    %rdx,%rax
sub    %rcx,%rbx
sub    %rax,%rbx
mov    %rax,%rdx
shl    $0x8,%rdx
xor    %rbx,%rdx
sub    %rax,%rcx
sub    %rdx,%rcx
mov    %rdx,%rsi
shr    $0xd,%rsi
xor    %rcx,%rsi
sub    %rdx,%rax
sub    %rsi,%rax
mov    %rsi,%rcx
shr    $0xc,%rcx
xor    %rax,%rcx
sub    %rsi,%rdx
sub    %rcx,%rdx
mov    %rcx,%rdi
shl    $0x10,%rdi
xor    %rdx,%rdi
sub    %rcx,%rsi
sub    %rdi,%rsi
mov    %rdi,%rdx
shr    $0x5,%rdx
xor    %rsi,%rdx
sub    %rdi,%rcx
sub    %rdx,%rcx
mov    %rdx,%rsi
shr    $0x3,%rsi
xor    %rcx,%rsi
sub    %rdx,%rdi
sub    %rsi,%rdi
mov    %rsi,%rax
shl    $0xa,%rax
xor    %rdi,%rax
add    %rax,%rsi
sub    %rsi,%rdx
shr    $0xf,%rax
xor    %rdx,%rax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

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