unsigned int jenkins_hash(const char *key) {
  unsigned char *data = (unsigned char *)key;
  unsigned int len = strlen(key);
  unsigned int a = 0x9e3779b9;
  unsigned int b = a;
  unsigned int c = 0;
  unsigned int i = 0;
  while (i + 12 <= len) {
    a += (unsigned int)data[i] | ((unsigned int)data[i + 1] << 8) |
         ((unsigned int)data[i + 2] << 16) | ((unsigned int)data[i + 3] << 24);
    i += 4;
    b += (unsigned int)data[i] | ((unsigned int)data[i + 1] << 8) |
         ((unsigned int)data[i + 2] << 16) | ((unsigned int)data[i + 2] << 24);
    i += 4;
    c += (unsigned int)data[i] | ((unsigned int)data[i + 1] << 8) |
         ((unsigned int)data[i + 2] << 16) | ((unsigned int)data[i + 3] << 24);
    i += 4;
    a -= b;
    a -= c;
    a ^= (c >> 13);
    b -= c;
    b -= a;
    b ^= (a << 8);
    c -= a;
    c -= b;
    c ^= (b >> 13);
    a -= b;
    a -= c;
    a ^= (c >> 12);
    b -= c;
    b -= a;
    b ^= (a << 16);
    c -= a;
    c -= b;
    c ^= (b >> 5);
    a -= b;
    a -= c;
    a ^= (c >> 3);
    b -= c;
    b -= a;
    b ^= (a << 10);
    c -= a;
    c -= b;
    c ^= (b >> 15);
  }
  c += (unsigned int)len;
  if (i < len)
    a += data[i++];
  if (i < len)
    a += (unsigned int)data[i++] << 8;
  if (i < len)
    a += (unsigned int)data[i++] << 16;
  if (i < len)
    a += (unsigned int)data[i++] << 24;
  if (i < len)
    b += (unsigned int)data[i++];
  if (i < len)
    b += (unsigned int)data[i++] << 8;
  if (i < len)
    b += (unsigned int)data[i++] << 16;
  if (i < len)
    b += (unsigned int)data[i++] << 24;
  if (i < len)
    c += (unsigned int)data[i++] << 8;
  if (i < len)
    c += (unsigned int)data[i++] << 16;
  if (i < len)
    c += (unsigned int)data[i++] << 24;
  a -= b;
  a -= c;
  a ^= (c >> 13);
  b -= c;
  b -= a;
  b ^= (a << 8);
  c -= a;
  c -= b;
  c ^= (b >> 13);
  a -= b;
  a -= c;
  a ^= (c >> 12);
  b -= c;
  b -= a;
  b ^= (a << 16);
  c -= a;
  c -= b;
  c ^= (b >> 5);
  a -= b;
  a -= c;
  a ^= (c >> 3);
  b -= c;
  b -= a;
  b ^= (a << 10);
  c -= a;
  c -= b;
  c ^= (b >> 15);
  return c;
}


x86 assembly (clang, -O0):
<jenkins_hash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x30,%rsp
mov    %rdi,-0x8(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x10(%rbp)
mov    -0x8(%rbp),%rdi
call   1030 <strlen@plt>
mov    %eax,-0x14(%rbp)
movl   $0x9e3779b9,-0x18(%rbp)
mov    -0x18(%rbp),%eax
mov    %eax,-0x1c(%rbp)
movl   $0x0,-0x20(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
add    $0xc,%eax
cmp    -0x14(%rbp),%eax
ja     139c <jenkins_hash+0x28c>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x3,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
movzbl (%rax,%rcx,1),%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x1,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x2,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    -0x24(%rbp),%edx
add    $0x3,%edx
mov    %edx,%edx
movzbl (%rcx,%rdx,1),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
add    $0x4,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shr    $0xd,%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x8,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0xd,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shr    $0xc,%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x10,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0x5,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shr    $0x3,%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0xa,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0xf,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
jmp    114b <jenkins_hash+0x3b>
mov    -0x14(%rbp),%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    13cc <jenkins_hash+0x2bc>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    13f6 <jenkins_hash+0x2e6>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1420 <jenkins_hash+0x310>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    144a <jenkins_hash+0x33a>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
add    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1471 <jenkins_hash+0x361>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    149b <jenkins_hash+0x38b>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    14c5 <jenkins_hash+0x3b5>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    14ef <jenkins_hash+0x3df>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1519 <jenkins_hash+0x409>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x8,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    1543 <jenkins_hash+0x433>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x10,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x14(%rbp),%eax
jae    156d <jenkins_hash+0x45d>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
mov    %ecx,%edx
add    $0x1,%edx
mov    %edx,-0x24(%rbp)
mov    %ecx,%ecx
movzbl (%rax,%rcx,1),%eax
shl    $0x18,%eax
add    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shr    $0xd,%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x8,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0xd,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shr    $0xc,%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0x10,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0x5,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x18(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%eax
shr    $0x3,%eax
xor    -0x18(%rbp),%eax
mov    %eax,-0x18(%rbp)
mov    -0x20(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x1c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%eax
shl    $0xa,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x18(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
mov    -0x20(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
shr    $0xf,%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
add    $0x30,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<jenkins_hash>:
push   %r14
push   %rbx
push   %rax
mov    %rdi,%r14
call   1030 <strlen@plt>
cmp    $0xc,%eax
jae    1137 <jenkins_hash+0x27>
xor    %r9d,%r9d
mov    $0x9e3779b9,%esi
mov    $0x9e3779b9,%r10d
xor    %r8d,%r8d
jmp    125a <jenkins_hash+0x14a>
mov    $0x9e3779b9,%r10d
xor    %edi,%edi
xor    %r9d,%r9d
mov    $0x9e3779b9,%esi
nopw   0x0(%rax,%rax,1)
mov    %edi,%ebx
movzbl (%r14,%rbx,1),%ebx
lea    0x1(%rdi),%ecx
movzbl (%r14,%rcx,1),%ecx
shl    $0x8,%ecx
or     %ebx,%ecx
lea    0x2(%rdi),%ebx
movzbl (%r14,%rbx,1),%edx
shl    $0x10,%edx
or     %ecx,%edx
lea    0x3(%rdi),%ecx
movzbl (%r14,%rcx,1),%ebx
shl    $0x18,%ebx
or     %edx,%ebx
add    %esi,%ebx
lea    0x4(%rdi),%ecx
movzbl (%r14,%rcx,1),%ecx
lea    0x5(%rdi),%edx
movzbl (%r14,%rdx,1),%edx
shl    $0x8,%edx
or     %ecx,%edx
lea    0x6(%rdi),%ecx
movzbl (%r14,%rcx,1),%esi
mov    %esi,%ecx
shl    $0x10,%ecx
or     %edx,%ecx
shl    $0x18,%esi
or     %ecx,%esi
add    %r10d,%esi
lea    0x8(%rdi),%ecx
movzbl (%r14,%rcx,1),%ecx
lea    0x9(%rdi),%edx
movzbl (%r14,%rdx,1),%edx
shl    $0x8,%edx
or     %ecx,%edx
lea    0xa(%rdi),%ecx
movzbl (%r14,%rcx,1),%ecx
shl    $0x10,%ecx
or     %edx,%ecx
lea    0xb(%rdi),%edx
movzbl (%r14,%rdx,1),%edx
shl    $0x18,%edx
or     %ecx,%edx
add    %r9d,%edx
sub    %esi,%ebx
sub    %edx,%ebx
mov    %edx,%ecx
shr    $0xd,%ecx
xor    %ebx,%ecx
sub    %edx,%esi
sub    %ecx,%esi
mov    %ecx,%ebx
shl    $0x8,%ebx
xor    %esi,%ebx
sub    %ecx,%edx
sub    %ebx,%edx
mov    %ebx,%esi
shr    $0xd,%esi
xor    %edx,%esi
sub    %ebx,%ecx
sub    %esi,%ecx
mov    %esi,%edx
shr    $0xc,%edx
xor    %ecx,%edx
sub    %esi,%ebx
sub    %edx,%ebx
mov    %edx,%ecx
shl    $0x10,%ecx
xor    %ebx,%ecx
sub    %edx,%esi
sub    %ecx,%esi
mov    %ecx,%ebx
shr    $0x5,%ebx
xor    %esi,%ebx
sub    %ecx,%edx
sub    %ebx,%edx
mov    %ebx,%esi
shr    $0x3,%esi
xor    %edx,%esi
sub    %ebx,%ecx
sub    %esi,%ecx
mov    %esi,%r10d
shl    $0xa,%r10d
xor    %ecx,%r10d
sub    %esi,%ebx
sub    %r10d,%ebx
mov    %r10d,%r9d
shr    $0xf,%r9d
xor    %ebx,%r9d
lea    0xc(%rdi),%r8d
add    $0x18,%edi
cmp    %eax,%edi
mov    %r8d,%edi
jbe    1150 <jenkins_hash+0x40>
cmp    %eax,%r8d
jb     134d <jenkins_hash+0x23d>
cmp    %eax,%r8d
jb     1364 <jenkins_hash+0x254>
cmp    %eax,%r8d
jb     1380 <jenkins_hash+0x270>
cmp    %eax,%r8d
jb     139c <jenkins_hash+0x28c>
cmp    %eax,%r8d
jb     13b8 <jenkins_hash+0x2a8>
cmp    %eax,%r8d
jb     13d0 <jenkins_hash+0x2c0>
cmp    %eax,%r8d
jb     13ee <jenkins_hash+0x2de>
cmp    %eax,%r8d
jae    12b3 <jenkins_hash+0x1a3>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x18,%ecx
add    %r10d,%ecx
mov    %ecx,%r10d
add    %eax,%r9d
cmp    %eax,%r8d
jb     1411 <jenkins_hash+0x301>
cmp    %eax,%r8d
jb     142c <jenkins_hash+0x31c>
cmp    %eax,%r8d
jae    12db <jenkins_hash+0x1cb>
mov    %r8d,%eax
movzbl (%r14,%rax,1),%eax
shl    $0x18,%eax
add    %eax,%r9d
sub    %r10d,%esi
sub    %r9d,%esi
mov    %r9d,%eax
shr    $0xd,%eax
xor    %esi,%eax
sub    %r9d,%r10d
sub    %eax,%r10d
mov    %eax,%ecx
shl    $0x8,%ecx
xor    %r10d,%ecx
sub    %eax,%r9d
sub    %ecx,%r9d
mov    %ecx,%edx
shr    $0xd,%edx
xor    %r9d,%edx
sub    %ecx,%eax
sub    %edx,%eax
mov    %edx,%esi
shr    $0xc,%esi
xor    %eax,%esi
sub    %edx,%ecx
sub    %esi,%ecx
mov    %esi,%edi
shl    $0x10,%edi
xor    %ecx,%edi
sub    %esi,%edx
sub    %edi,%edx
mov    %edi,%ecx
shr    $0x5,%ecx
xor    %edx,%ecx
sub    %edi,%esi
sub    %ecx,%esi
mov    %ecx,%edx
shr    $0x3,%edx
xor    %esi,%edx
sub    %ecx,%edi
sub    %edx,%edi
mov    %edx,%eax
shl    $0xa,%eax
xor    %edi,%eax
add    %eax,%edx
sub    %edx,%ecx
shr    $0xf,%eax
xor    %ecx,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret
mov    %r8d,%ecx
or     $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
add    %ecx,%esi
cmp    %eax,%r8d
jae    126c <jenkins_hash+0x15c>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x8,%ecx
add    %esi,%ecx
mov    %ecx,%esi
cmp    %eax,%r8d
jae    1275 <jenkins_hash+0x165>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x10,%ecx
add    %esi,%ecx
mov    %ecx,%esi
cmp    %eax,%r8d
jae    127e <jenkins_hash+0x16e>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x18,%ecx
add    %esi,%ecx
mov    %ecx,%esi
cmp    %eax,%r8d
jae    1287 <jenkins_hash+0x177>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
add    %ecx,%r10d
cmp    %eax,%r8d
jae    1290 <jenkins_hash+0x180>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x8,%ecx
add    %r10d,%ecx
mov    %ecx,%r10d
cmp    %eax,%r8d
jae    1299 <jenkins_hash+0x189>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x10,%ecx
add    %r10d,%ecx
mov    %ecx,%r10d
cmp    %eax,%r8d
jb     129e <jenkins_hash+0x18e>
jmp    12b3 <jenkins_hash+0x1a3>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x8,%ecx
add    %ecx,%r9d
cmp    %eax,%r8d
jae    12c8 <jenkins_hash+0x1b8>
mov    %r8d,%ecx
add    $0x1,%r8d
movzbl (%r14,%rcx,1),%ecx
shl    $0x10,%ecx
add    %ecx,%r9d
cmp    %eax,%r8d
jb     12cd <jenkins_hash+0x1bd>
jmp    12db <jenkins_hash+0x1cb>

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

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