#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 */
typedef int uint8_t;
typedef int uint32_t;
typedef scalar_t__ uint16_t;

/* Variables and functions */
uint32_t nhash_(const void *key, int *length0, uint32_t *initval0) {
  uint32_t a, b, c;
  size_t length;
  uint32_t initval;
  union {
    const void *ptr;
    size_t i;
  } u;
  length = *length0;
  initval = *initval0;
  a = b = c = 0xdeadbeef + ((uint32_t)length) + initval;
  u.ptr = key;
  if (1 && ((u.i & 0x3) == 0)) {
    const uint32_t *k = (const uint32_t *)key;
    const uint8_t *k8;
    k8 = 0;
    while (length > 12) {
      a += k[0];
      b += k[1];
      c += k[2];
      {
        a -= c;
        a ^= (((c) << (4)) | ((c) >> (32 - (4))));
        c += b;
        b -= a;
        b ^= (((a) << (6)) | ((a) >> (32 - (6))));
        a += c;
        c -= b;
        c ^= (((b) << (8)) | ((b) >> (32 - (8))));
        b += a;
        a -= c;
        a ^= (((c) << (16)) | ((c) >> (32 - (16))));
        c += b;
        b -= a;
        b ^= (((a) << (19)) | ((a) >> (32 - (19))));
        a += c;
        c -= b;
        c ^= (((b) << (4)) | ((b) >> (32 - (4))));
        b += a;
      };
      length -= 12;
      k += 3;
    }
    switch (length) {
    case 12:
      c += k[2];
      b += k[1];
      a += k[0];
      break;
    case 11:
      c += k[2] & 0xffffff;
      b += k[1];
      a += k[0];
      break;
    case 10:
      c += k[2] & 0xffff;
      b += k[1];
      a += k[0];
      break;
    case 9:
      c += k[2] & 0xff;
      b += k[1];
      a += k[0];
      break;
    case 8:
      b += k[1];
      a += k[0];
      break;
    case 7:
      b += k[1] & 0xffffff;
      a += k[0];
      break;
    case 6:
      b += k[1] & 0xffff;
      a += k[0];
      break;
    case 5:
      b += k[1] & 0xff;
      a += k[0];
      break;
    case 4:
      a += k[0];
      break;
    case 3:
      a += k[0] & 0xffffff;
      break;
    case 2:
      a += k[0] & 0xffff;
      break;
    case 1:
      a += k[0] & 0xff;
      break;
    case 0:
      return c;
    }
  } else if (1 && ((u.i & 0x1) == 0)) {
    const uint16_t *k = (const uint16_t *)key;
    const uint8_t *k8;
    while (length > 12) {
      a += k[0] + (((uint32_t)k[1]) << 16);
      b += k[2] + (((uint32_t)k[3]) << 16);
      c += k[4] + (((uint32_t)k[5]) << 16);
      {
        a -= c;
        a ^= (((c) << (4)) | ((c) >> (32 - (4))));
        c += b;
        b -= a;
        b ^= (((a) << (6)) | ((a) >> (32 - (6))));
        a += c;
        c -= b;
        c ^= (((b) << (8)) | ((b) >> (32 - (8))));
        b += a;
        a -= c;
        a ^= (((c) << (16)) | ((c) >> (32 - (16))));
        c += b;
        b -= a;
        b ^= (((a) << (19)) | ((a) >> (32 - (19))));
        a += c;
        c -= b;
        c ^= (((b) << (4)) | ((b) >> (32 - (4))));
        b += a;
      };
      length -= 12;
      k += 6;
    }
    k8 = (const uint8_t *)k;
    switch (length) {
    case 12:
      c += k[4] + (((uint32_t)k[5]) << 16);
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 11:
      c += ((uint32_t)k8[10]) << 16;
    case 10:
      c += k[4];
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 9:
      c += k8[8];
    case 8:
      b += k[2] + (((uint32_t)k[3]) << 16);
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 7:
      b += ((uint32_t)k8[6]) << 16;
    case 6:
      b += k[2];
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 5:
      b += k8[4];
    case 4:
      a += k[0] + (((uint32_t)k[1]) << 16);
      break;
    case 3:
      a += ((uint32_t)k8[2]) << 16;
    case 2:
      a += k[0];
      break;
    case 1:
      a += k8[0];
      break;
    case 0:
      return c;
    }
  } else {
    const uint8_t *k = (const uint8_t *)key;
    while (length > 12) {
      a += k[0];
      a += ((uint32_t)k[1]) << 8;
      a += ((uint32_t)k[2]) << 16;
      a += ((uint32_t)k[3]) << 24;
      b += k[4];
      b += ((uint32_t)k[5]) << 8;
      b += ((uint32_t)k[6]) << 16;
      b += ((uint32_t)k[7]) << 24;
      c += k[8];
      c += ((uint32_t)k[9]) << 8;
      c += ((uint32_t)k[10]) << 16;
      c += ((uint32_t)k[11]) << 24;
      {
        a -= c;
        a ^= (((c) << (4)) | ((c) >> (32 - (4))));
        c += b;
        b -= a;
        b ^= (((a) << (6)) | ((a) >> (32 - (6))));
        a += c;
        c -= b;
        c ^= (((b) << (8)) | ((b) >> (32 - (8))));
        b += a;
        a -= c;
        a ^= (((c) << (16)) | ((c) >> (32 - (16))));
        c += b;
        b -= a;
        b ^= (((a) << (19)) | ((a) >> (32 - (19))));
        a += c;
        c -= b;
        c ^= (((b) << (4)) | ((b) >> (32 - (4))));
        b += a;
      };
      length -= 12;
      k += 12;
    }
    switch (length) {
    case 12:
      c += ((uint32_t)k[11]) << 24;
    case 11:
      c += ((uint32_t)k[10]) << 16;
    case 10:
      c += ((uint32_t)k[9]) << 8;
    case 9:
      c += k[8];
    case 8:
      b += ((uint32_t)k[7]) << 24;
    case 7:
      b += ((uint32_t)k[6]) << 16;
    case 6:
      b += ((uint32_t)k[5]) << 8;
    case 5:
      b += k[4];
    case 4:
      a += ((uint32_t)k[3]) << 24;
    case 3:
      a += ((uint32_t)k[2]) << 16;
    case 2:
      a += ((uint32_t)k[1]) << 8;
    case 1:
      a += k[0];
      break;
    case 0:
      return c;
    }
  }
  {
    c ^= b;
    c -= (((b) << (14)) | ((b) >> (32 - (14))));
    a ^= c;
    a -= (((c) << (11)) | ((c) >> (32 - (11))));
    b ^= a;
    b -= (((a) << (25)) | ((a) >> (32 - (25))));
    c ^= b;
    c -= (((b) << (16)) | ((b) >> (32 - (16))));
    a ^= c;
    a -= (((c) << (4)) | ((c) >> (32 - (4))));
    b ^= a;
    b -= (((a) << (14)) | ((a) >> (32 - (14))));
    c ^= b;
    c -= (((b) << (24)) | ((b) >> (32 - (24))));
  };
  return c;
}


x86 assembly (clang, -O0):
<nhash_>:
push   %rbp
mov    %rsp,%rbp
push   %rax
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movslq (%rax),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x38(%rbp),%rax
add    $0xdeadbeef,%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    %eax,-0x28(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x48(%rbp)
mov    -0x48(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
jne    146d <nhash_+0x36d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x50(%rbp)
movq   $0x0,-0x58(%rbp)
cmpq   $0xc,-0x38(%rbp)
jbe    12a2 <nhash_+0x1a2>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    0x8(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x4,%eax
mov    -0x2c(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x6,%eax
mov    -0x24(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x8,%eax
mov    -0x28(%rbp),%ecx
sar    $0x18,%ecx
or     %ecx,%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x10,%eax
mov    -0x2c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x13,%eax
mov    -0x24(%rbp),%ecx
sar    $0xd,%ecx
or     %ecx,%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x4,%eax
mov    -0x28(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x50(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x50(%rbp)
jmp    1164 <nhash_+0x64>
mov    -0x38(%rbp),%rax
mov    %rax,-0x78(%rbp)
sub    $0xc,%rax
ja     1468 <nhash_+0x368>
mov    -0x78(%rbp),%rax
lea    0xda9(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x50(%rbp),%rax
mov    0x8(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x8(%rax),%eax
and    $0xffffff,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x8(%rax),%eax
and    $0xffff,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x8(%rax),%eax
and    $0xff,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xffffff,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xffff,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xff,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
and    $0xffffff,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
and    $0xffff,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
and    $0xff,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1468 <nhash_+0x368>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1bce <nhash_+0xace>
jmp    1aef <nhash_+0x9ef>
mov    -0x48(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    181d <nhash_+0x71d>
mov    -0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
cmpq   $0xc,-0x38(%rbp)
jbe    1604 <nhash_+0x504>
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
mov    -0x60(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x18(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x28(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x2c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x4,%eax
mov    -0x2c(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x6,%eax
mov    -0x24(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x8,%eax
mov    -0x28(%rbp),%ecx
sar    $0x18,%ecx
or     %ecx,%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x10,%eax
mov    -0x2c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x13,%eax
mov    -0x24(%rbp),%ecx
sar    $0xd,%ecx
or     %ecx,%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x4,%eax
mov    -0x28(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x60(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x60(%rbp)
jmp    1487 <nhash_+0x387>
mov    -0x60(%rbp),%rax
mov    %rax,-0x68(%rbp)
mov    -0x38(%rbp),%rax
mov    %rax,-0x80(%rbp)
sub    $0xc,%rax
ja     1818 <nhash_+0x718>
mov    -0x80(%rbp),%rax
lea    0xa0b(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x60(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x28(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x2c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x60(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x18(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x68(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x60(%rbp),%rax
mov    0x20(%rax),%rcx
movslq -0x2c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x60(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x18(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x68(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x60(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x18(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x68(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    0x10(%rax),%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x68(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
mov    -0x60(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x10,%eax
cltq
add    %rax,%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x68(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x60(%rbp),%rax
mov    (%rax),%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x68(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1818 <nhash_+0x718>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1bce <nhash_+0xace>
jmp    1aea <nhash_+0x9ea>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
cmpq   $0xc,-0x38(%rbp)
jbe    19f3 <nhash_+0x8f3>
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x14(%rax),%eax
shl    $0x8,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x1c(%rax),%eax
shl    $0x18,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x24(%rax),%eax
shl    $0x8,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x2c(%rax),%eax
shl    $0x18,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x4,%eax
mov    -0x2c(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x6,%eax
mov    -0x24(%rbp),%ecx
sar    $0x1a,%ecx
or     %ecx,%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x8,%eax
mov    -0x28(%rbp),%ecx
sar    $0x18,%ecx
or     %ecx,%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
shl    $0x10,%eax
mov    -0x2c(%rbp),%ecx
sar    $0x10,%ecx
or     %ecx,%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
shl    $0x13,%eax
mov    -0x24(%rbp),%ecx
sar    $0xd,%ecx
or     %ecx,%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x4,%eax
mov    -0x28(%rbp),%ecx
sar    $0x1c,%ecx
or     %ecx,%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x38(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x38(%rbp)
mov    -0x70(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x70(%rbp)
jmp    1825 <nhash_+0x725>
mov    -0x38(%rbp),%rax
mov    %rax,-0x88(%rbp)
sub    $0xc,%rax
ja     1ae5 <nhash_+0x9e5>
mov    -0x88(%rbp),%rax
lea    0x5ea(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x70(%rbp),%rax
mov    0x2c(%rax),%eax
shl    $0x18,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x24(%rax),%eax
shl    $0x8,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x70(%rbp),%rax
mov    0x1c(%rax),%eax
shl    $0x18,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x14(%rax),%eax
shl    $0x8,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x70(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x70(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1ae5 <nhash_+0x9e5>
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
jmp    1bce <nhash_+0xace>
jmp    1aea <nhash_+0x9ea>
jmp    1aef <nhash_+0x9ef>
mov    -0x28(%rbp),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0xe,%ecx
mov    -0x28(%rbp),%eax
sar    $0x12,%eax
or     %eax,%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%ecx
shl    $0xb,%ecx
mov    -0x2c(%rbp),%eax
sar    $0x15,%eax
or     %eax,%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%ecx
shl    $0x19,%ecx
mov    -0x24(%rbp),%eax
sar    $0x7,%eax
or     %eax,%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0x10,%ecx
mov    -0x28(%rbp),%eax
sar    $0x10,%eax
or     %eax,%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%ecx
shl    $0x4,%ecx
mov    -0x2c(%rbp),%eax
sar    $0x1c,%eax
or     %eax,%ecx
mov    -0x24(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%ecx
shl    $0xe,%ecx
mov    -0x24(%rbp),%eax
sar    $0x12,%eax
or     %eax,%ecx
mov    -0x28(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%ecx
shl    $0x18,%ecx
mov    -0x28(%rbp),%eax
sar    $0x8,%eax
or     %eax,%ecx
mov    -0x2c(%rbp),%eax
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x8,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nhash_>:
movslq (%rsi),%r8
mov    (%rdx),%eax
lea    (%r8,%rax,1),%r9d
add    $0xdeadbeef,%r9d
test   $0x3,%dil
je     1207 <nhash_+0x107>
test   $0x1,%dil
jne    12ce <nhash_+0x1ce>
cmp    $0xd,%r8d
jb     1402 <nhash_+0x302>
mov    %r9d,%r10d
mov    %r9d,%eax
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    0x8(%rdi),%esi
mov    0x18(%rdi),%ecx
shl    $0x10,%esi
add    (%rdi),%esi
add    %r9d,%esi
shl    $0x10,%ecx
add    0x10(%rdi),%ecx
add    %r10d,%ecx
mov    0x28(%rdi),%edx
shl    $0x10,%edx
add    0x20(%rdi),%edx
add    %eax,%edx
sub    %edx,%esi
mov    %edx,%r9d
shl    $0x4,%r9d
mov    %edx,%eax
sar    $0x1c,%eax
or     %r9d,%eax
xor    %esi,%eax
add    %ecx,%edx
sub    %eax,%ecx
mov    %eax,%r9d
shl    $0x6,%r9d
mov    %eax,%esi
sar    $0x1a,%esi
or     %r9d,%esi
xor    %ecx,%esi
add    %edx,%eax
sub    %esi,%edx
mov    %esi,%r9d
shl    $0x8,%r9d
mov    %esi,%ecx
sar    $0x18,%ecx
or     %r9d,%ecx
xor    %edx,%ecx
add    %eax,%esi
sub    %ecx,%eax
mov    %ecx,%edx
shl    $0x10,%edx
mov    %ecx,%r9d
sar    $0x10,%r9d
or     %edx,%r9d
xor    %eax,%r9d
add    %esi,%ecx
sub    %r9d,%esi
mov    %r9d,%eax
shl    $0x13,%eax
mov    %r9d,%r10d
sar    $0xd,%r10d
or     %eax,%r10d
xor    %esi,%r10d
add    %ecx,%r9d
sub    %r10d,%ecx
mov    %r10d,%edx
shl    $0x4,%edx
mov    %r10d,%eax
sar    $0x1c,%eax
or     %edx,%eax
xor    %ecx,%eax
add    %r9d,%r10d
add    $0xfffffffffffffff4,%r8
add    $0x30,%rdi
cmp    $0xc,%r8
ja     1140 <nhash_+0x40>
cmp    $0xc,%r8
jbe    1412 <nhash_+0x312>
jmp    153d <nhash_+0x43d>
cmp    $0xd,%r8d
jb     13da <nhash_+0x2da>
mov    %r9d,%r10d
mov    %r9d,%eax
nopw   0x0(%rax,%rax,1)
add    (%rdi),%r9d
add    0x4(%rdi),%r10d
add    0x8(%rdi),%eax
sub    %eax,%r9d
mov    %eax,%edx
shl    $0x4,%edx
mov    %eax,%ecx
sar    $0x1c,%ecx
or     %edx,%ecx
xor    %r9d,%ecx
add    %r10d,%eax
sub    %ecx,%r10d
mov    %ecx,%edx
shl    $0x6,%edx
mov    %ecx,%esi
sar    $0x1a,%esi
or     %edx,%esi
xor    %r10d,%esi
add    %eax,%ecx
sub    %esi,%eax
mov    %esi,%r9d
shl    $0x8,%r9d
mov    %esi,%edx
sar    $0x18,%edx
or     %r9d,%edx
xor    %eax,%edx
add    %ecx,%esi
sub    %edx,%ecx
mov    %edx,%eax
shl    $0x10,%eax
mov    %edx,%r9d
sar    $0x10,%r9d
or     %eax,%r9d
xor    %ecx,%r9d
add    %esi,%edx
sub    %r9d,%esi
mov    %r9d,%eax
shl    $0x13,%eax
mov    %r9d,%r10d
sar    $0xd,%r10d
or     %eax,%r10d
xor    %esi,%r10d
add    %edx,%r9d
sub    %r10d,%edx
mov    %r10d,%ecx
shl    $0x4,%ecx
mov    %r10d,%eax
sar    $0x1c,%eax
or     %ecx,%eax
xor    %edx,%eax
add    %r9d,%r10d
add    $0xfffffffffffffff4,%r8
add    $0xc,%rdi
cmp    $0xc,%r8
ja     1220 <nhash_+0x120>
cmp    $0xc,%r8
jbe    13ea <nhash_+0x2ea>
jmp    153d <nhash_+0x43d>
cmp    $0xd,%r8d
jb     142a <nhash_+0x32a>
mov    %r9d,%r10d
mov    %r9d,%eax
xchg   %ax,%ax
add    (%rdi),%r9d
mov    0x4(%rdi),%ecx
mov    0x8(%rdi),%edx
shl    $0x8,%ecx
add    %r9d,%ecx
shl    $0x10,%edx
add    %ecx,%edx
mov    0xc(%rdi),%r9d
shl    $0x18,%r9d
add    0x10(%rdi),%r10d
add    %edx,%r9d
mov    0x14(%rdi),%ecx
shl    $0x8,%ecx
add    %r10d,%ecx
mov    0x18(%rdi),%edx
shl    $0x10,%edx
add    %ecx,%edx
mov    0x1c(%rdi),%r10d
shl    $0x18,%r10d
add    %edx,%r10d
add    0x20(%rdi),%eax
mov    0x24(%rdi),%edx
shl    $0x8,%edx
add    %eax,%edx
mov    0x28(%rdi),%eax
shl    $0x10,%eax
add    %edx,%eax
mov    0x2c(%rdi),%edx
shl    $0x18,%edx
add    %eax,%edx
sub    %edx,%r9d
mov    %edx,%esi
shl    $0x4,%esi
mov    %edx,%eax
sar    $0x1c,%eax
or     %esi,%eax
xor    %r9d,%eax
add    %r10d,%edx
sub    %eax,%r10d
mov    %eax,%ecx
shl    $0x6,%ecx
mov    %eax,%esi
sar    $0x1a,%esi
or     %ecx,%esi
xor    %r10d,%esi
add    %edx,%eax
sub    %esi,%edx
mov    %esi,%r9d
shl    $0x8,%r9d
mov    %esi,%ecx
sar    $0x18,%ecx
or     %r9d,%ecx
xor    %edx,%ecx
add    %eax,%esi
sub    %ecx,%eax
mov    %ecx,%edx
shl    $0x10,%edx
mov    %ecx,%r9d
sar    $0x10,%r9d
or     %edx,%r9d
xor    %eax,%r9d
add    %esi,%ecx
sub    %r9d,%esi
mov    %r9d,%eax
shl    $0x13,%eax
mov    %r9d,%r10d
sar    $0xd,%r10d
or     %eax,%r10d
xor    %esi,%r10d
add    %ecx,%r9d
sub    %r10d,%ecx
mov    %r10d,%edx
shl    $0x4,%edx
mov    %r10d,%eax
sar    $0x1c,%eax
or     %edx,%eax
xor    %ecx,%eax
add    %r9d,%r10d
add    $0xfffffffffffffff4,%r8
add    $0x30,%rdi
cmp    $0xc,%r8
ja     12e0 <nhash_+0x1e0>
cmp    $0xc,%r8
jbe    143a <nhash_+0x33a>
jmp    153d <nhash_+0x43d>
mov    %r9d,%eax
mov    %r9d,%r10d
cmp    $0xc,%r8
ja     153d <nhash_+0x43d>
lea    0xc77(%rip),%rcx
movslq (%rcx,%r8,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
movzbl (%rdi),%ecx
jmp    153a <nhash_+0x43a>
mov    %r9d,%eax
mov    %r9d,%r10d
cmp    $0xc,%r8
ja     153d <nhash_+0x43d>
lea    0xc1b(%rip),%rcx
movslq (%rcx,%r8,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
jmp    149c <nhash_+0x39c>
mov    %r9d,%eax
mov    %r9d,%r10d
cmp    $0xc,%r8
ja     153d <nhash_+0x43d>
lea    0xbbf(%rip),%rcx
movslq (%rcx,%r8,4),%rdx
add    %rcx,%rdx
jmp    *%rdx
mov    0x2c(%rdi),%ecx
shl    $0x18,%ecx
add    %ecx,%eax
mov    0x28(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
mov    0x24(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%eax
add    0x20(%rdi),%eax
mov    0x1c(%rdi),%ecx
shl    $0x18,%ecx
add    %ecx,%r10d
mov    0x18(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%r10d
mov    0x14(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%r10d
add    0x10(%rdi),%r10d
mov    0xc(%rdi),%ecx
shl    $0x18,%ecx
add    %ecx,%r9d
mov    0x8(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%r9d
mov    0x4(%rdi),%ecx
shl    $0x8,%ecx
add    %ecx,%r9d
jmp    14f7 <nhash_+0x3f7>
movzwl (%rdi),%ecx
jmp    153a <nhash_+0x43a>
mov    $0xffffff,%ecx
and    (%rdi),%ecx
jmp    153a <nhash_+0x43a>
movzbl 0x4(%rdi),%ecx
add    %ecx,%r10d
jmp    14f7 <nhash_+0x3f7>
movzwl 0x4(%rdi),%ecx
add    %ecx,%r10d
jmp    14f7 <nhash_+0x3f7>
mov    $0xffffff,%ecx
and    0x4(%rdi),%ecx
add    %ecx,%r10d
jmp    14f7 <nhash_+0x3f7>
movzbl 0x8(%rdi),%ecx
jmp    14e8 <nhash_+0x3e8>
movzwl 0x8(%rdi),%ecx
jmp    14e8 <nhash_+0x3e8>
mov    $0xffffff,%ecx
and    0x8(%rdi),%ecx
add    %ecx,%eax
add    0x4(%rdi),%r10d
jmp    14f7 <nhash_+0x3f7>
add    0x8(%rdi),%eax
add    0x4(%rdi),%r10d
add    (%rdi),%r9d
jmp    153d <nhash_+0x43d>
mov    0x18(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%r10d
add    0x10(%rdi),%r10d
mov    0x8(%rdi),%ecx
jmp    1535 <nhash_+0x435>
mov    0x28(%rdi),%ecx
shl    $0x10,%ecx
add    %ecx,%eax
add    0x20(%rdi),%eax
jmp    1526 <nhash_+0x426>
mov    0x28(%rdi),%ecx
shl    $0x10,%ecx
add    0x20(%rdi),%ecx
add    %ecx,%eax
mov    0x8(%rdi),%ecx
mov    0x18(%rdi),%edx
shl    $0x10,%edx
add    0x10(%rdi),%edx
add    %edx,%r10d
shl    $0x10,%ecx
add    (%rdi),%ecx
add    %ecx,%r9d
xor    %r10d,%eax
mov    %r10d,%ecx
shl    $0xe,%ecx
mov    %r10d,%edx
sar    $0x12,%edx
or     %ecx,%edx
sub    %edx,%eax
xor    %eax,%r9d
mov    %eax,%ecx
shl    $0xb,%ecx
mov    %eax,%edx
sar    $0x15,%edx
or     %ecx,%edx
sub    %edx,%r9d
xor    %r9d,%r10d
mov    %r9d,%ecx
shl    $0x19,%ecx
mov    %r9d,%edx
sar    $0x7,%edx
or     %ecx,%edx
sub    %edx,%r10d
xor    %r10d,%eax
mov    %r10d,%ecx
shl    $0x10,%ecx
mov    %r10d,%edx
sar    $0x10,%edx
or     %ecx,%edx
sub    %edx,%eax
xor    %eax,%r9d
mov    %eax,%ecx
shl    $0x4,%ecx
mov    %eax,%edx
sar    $0x1c,%edx
or     %ecx,%edx
sub    %edx,%r9d
xor    %r9d,%r10d
mov    %r9d,%ecx
shl    $0xe,%ecx
sar    $0x12,%r9d
or     %ecx,%r9d
sub    %r9d,%r10d
xor    %r10d,%eax
mov    %r10d,%ecx
shl    $0x18,%ecx
sar    $0x8,%r10d
or     %ecx,%r10d
sub    %r10d,%eax
ret

LLVM IR (-O0):
%union.anon = type { i8* }
define i32 @nhash_(i8* %0, i32* %1, i32* %2) {
%4 = alloca i32
%5 = alloca i8*
%6 = alloca i32*
%7 = alloca i32*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i64
%12 = alloca i32
%13 = alloca %union.anon
%14 = alloca i32*
%15 = alloca i32*
%16 = alloca i64*
%17 = alloca i32*
%18 = alloca i32*
store i8* %0, i8** %5
store i32* %1, i32** %6
store i32* %2, i32** %7
%19 = load i32*, i32** %6
%20 = load i32, i32* %19
%21 = sext i32 %20 to i64
store i64 %21, i64* %11
%22 = load i32*, i32** %7
%23 = load i32, i32* %22
store i32 %23, i32* %12
%24 = load i64, i64* %11
%25 = trunc i64 %24 to i32
%26 = add i32 -559038737, %25
%27 = load i32, i32* %12
%28 = add i32 %26, %27
store i32 %28, i32* %10
store i32 %28, i32* %9
store i32 %28, i32* %8
%29 = load i8*, i8** %5
%30 = bitcast %union.anon* %13 to i8**
store i8* %29, i8** %30
%31 = bitcast %union.anon* %13 to i64*
%32 = load i64, i64* %31
%33 = and i64 %32, 3
%34 = icmp eq i64 %33, 0
br i1 %34, label %35, label %285
35: ; preds = %3
%36 = load i8*, i8** %5
%37 = bitcast i8* %36 to i32*
store i32* %37, i32** %14
store i32* null, i32** %15
br label %38
38: ; preds = %41, %35
%39 = load i64, i64* %11
%40 = icmp ugt i64 %39, 12
br i1 %40, label %41, label %139
41: ; preds = %38
%42 = load i32*, i32** %14
%43 = getelementptr inbounds i32, i32* %42, i64 0
%44 = load i32, i32* %43
%45 = load i32, i32* %8
%46 = add nsw i32 %45, %44
store i32 %46, i32* %8
%47 = load i32*, i32** %14
%48 = getelementptr inbounds i32, i32* %47, i64 1
%49 = load i32, i32* %48
%50 = load i32, i32* %9
%51 = add nsw i32 %50, %49
store i32 %51, i32* %9
%52 = load i32*, i32** %14
%53 = getelementptr inbounds i32, i32* %52, i64 2
%54 = load i32, i32* %53
%55 = load i32, i32* %10
%56 = add nsw i32 %55, %54
store i32 %56, i32* %10
%57 = load i32, i32* %10
%58 = load i32, i32* %8
%59 = sub nsw i32 %58, %57
store i32 %59, i32* %8
%60 = load i32, i32* %10
%61 = shl i32 %60, 4
%62 = load i32, i32* %10
%63 = ashr i32 %62, 28
%64 = or i32 %61, %63
%65 = load i32, i32* %8
%66 = xor i32 %65, %64
store i32 %66, i32* %8
%67 = load i32, i32* %9
%68 = load i32, i32* %10
%69 = add nsw i32 %68, %67
store i32 %69, i32* %10
%70 = load i32, i32* %8
%71 = load i32, i32* %9
%72 = sub nsw i32 %71, %70
store i32 %72, i32* %9
%73 = load i32, i32* %8
%74 = shl i32 %73, 6
%75 = load i32, i32* %8
%76 = ashr i32 %75, 26
%77 = or i32 %74, %76
%78 = load i32, i32* %9
%79 = xor i32 %78, %77
store i32 %79, i32* %9
%80 = load i32, i32* %10
%81 = load i32, i32* %8
%82 = add nsw i32 %81, %80
store i32 %82, i32* %8
%83 = load i32, i32* %9
%84 = load i32, i32* %10
%85 = sub nsw i32 %84, %83
store i32 %85, i32* %10
%86 = load i32, i32* %9
%87 = shl i32 %86, 8
%88 = load i32, i32* %9
%89 = ashr i32 %88, 24
%90 = or i32 %87, %89
%91 = load i32, i32* %10
%92 = xor i32 %91, %90
store i32 %92, i32* %10
%93 = load i32, i32* %8
%94 = load i32, i32* %9
%95 = add nsw i32 %94, %93
store i32 %95, i32* %9
%96 = load i32, i32* %10
%97 = load i32, i32* %8
%98 = sub nsw i32 %97, %96
store i32 %98, i32* %8
%99 = load i32, i32* %10
%100 = shl i32 %99, 16
%101 = load i32, i32* %10
%102 = ashr i32 %101, 16
%103 = or i32 %100, %102
%104 = load i32, i32* %8
%105 = xor i32 %104, %103
store i32 %105, i32* %8
%106 = load i32, i32* %9
%107 = load i32, i32* %10
%108 = add nsw i32 %107, %106
store i32 %108, i32* %10
%109 = load i32, i32* %8
%110 = load i32, i32* %9
%111 = sub nsw i32 %110, %109
store i32 %111, i32* %9
%112 = load i32, i32* %8
%113 = shl i32 %112, 19
%114 = load i32, i32* %8
%115 = ashr i32 %114, 13
%116 = or i32 %113, %115
%117 = load i32, i32* %9
%118 = xor i32 %117, %116
store i32 %118, i32* %9
%119 = load i32, i32* %10
%120 = load i32, i32* %8
%121 = add nsw i32 %120, %119
store i32 %121, i32* %8
%122 = load i32, i32* %9
%123 = load i32, i32* %10
%124 = sub nsw i32 %123, %122
store i32 %124, i32* %10
%125 = load i32, i32* %9
%126 = shl i32 %125, 4
%127 = load i32, i32* %9
%128 = ashr i32 %127, 28
%129 = or i32 %126, %128
%130 = load i32, i32* %10
%131 = xor i32 %130, %129
store i32 %131, i32* %10
%132 = load i32, i32* %8
%133 = load i32, i32* %9
%134 = add nsw i32 %133, %132
store i32 %134, i32* %9
%135 = load i64, i64* %11
%136 = sub i64 %135, 12
store i64 %136, i64* %11
%137 = load i32*, i32** %14
%138 = getelementptr inbounds i32, i32* %137, i64 3
store i32* %138, i32** %14
br label %38
139: ; preds = %38
%140 = load i64, i64* %11
switch i64 %140, label %284 [
i64 12, label %141
i64 11, label %157
i64 10, label %174
i64 9, label %191
i64 8, label %208
i64 7, label %219
i64 6, label %231
i64 5, label %243
i64 4, label %255
i64 3, label %261
i64 2, label %268
i64 1, label %275
i64 0, label %282
]
141: ; preds = %139
%142 = load i32*, i32** %14
%143 = getelementptr inbounds i32, i32* %142, i64 2
%144 = load i32, i32* %143
%145 = load i32, i32* %10
%146 = add nsw i32 %145, %144
store i32 %146, i32* %10
%147 = load i32*, i32** %14
%148 = getelementptr inbounds i32, i32* %147, i64 1
%149 = load i32, i32* %148
%150 = load i32, i32* %9
%151 = add nsw i32 %150, %149
store i32 %151, i32* %9
%152 = load i32*, i32** %14
%153 = getelementptr inbounds i32, i32* %152, i64 0
%154 = load i32, i32* %153
%155 = load i32, i32* %8
%156 = add nsw i32 %155, %154
store i32 %156, i32* %8
br label %284
157: ; preds = %139
%158 = load i32*, i32** %14
%159 = getelementptr inbounds i32, i32* %158, i64 2
%160 = load i32, i32* %159
%161 = and i32 %160, 16777215
%162 = load i32, i32* %10
%163 = add nsw i32 %162, %161
store i32 %163, i32* %10
%164 = load i32*, i32** %14
%165 = getelementptr inbounds i32, i32* %164, i64 1
%166 = load i32, i32* %165
%167 = load i32, i32* %9
%168 = add nsw i32 %167, %166
store i32 %168, i32* %9
%169 = load i32*, i32** %14
%170 = getelementptr inbounds i32, i32* %169, i64 0
%171 = load i32, i32* %170
%172 = load i32, i32* %8
%173 = add nsw i32 %172, %171
store i32 %173, i32* %8
br label %284
174: ; preds = %139
%175 = load i32*, i32** %14
%176 = getelementptr inbounds i32, i32* %175, i64 2
%177 = load i32, i32* %176
%178 = and i32 %177, 65535
%179 = load i32, i32* %10
%180 = add nsw i32 %179, %178
store i32 %180, i32* %10
%181 = load i32*, i32** %14
%182 = getelementptr inbounds i32, i32* %181, i64 1
%183 = load i32, i32* %182
%184 = load i32, i32* %9
%185 = add nsw i32 %184, %183
store i32 %185, i32* %9
%186 = load i32*, i32** %14
%187 = getelementptr inbounds i32, i32* %186, i64 0
%188 = load i32, i32* %187
%189 = load i32, i32* %8
%190 = add nsw i32 %189, %188
store i32 %190, i32* %8
br label %284
191: ; preds = %139
%192 = load i32*, i32** %14
%193 = getelementptr inbounds i32, i32* %192, i64 2
%194 = load i32, i32* %193
%195 = and i32 %194, 255
%196 = load i32, i32* %10
%197 = add nsw i32 %196, %195
store i32 %197, i32* %10
%198 = load i32*, i32** %14
%199 = getelementptr inbounds i32, i32* %198, i64 1
%200 = load i32, i32* %199
%201 = load i32, i32* %9
%202 = add nsw i32 %201, %200
store i32 %202, i32* %9
%203 = load i32*, i32** %14
%204 = getelementptr inbounds i32, i32* %203, i64 0
%205 = load i32, i32* %204
%206 = load i32, i32* %8
%207 = add nsw i32 %206, %205
store i32 %207, i32* %8
br label %284
208: ; preds = %139
%209 = load i32*, i32** %14
%210 = getelementptr inbounds i32, i32* %209, i64 1
%211 = load i32, i32* %210
%212 = load i32, i32* %9
%213 = add nsw i32 %212, %211
store i32 %213, i32* %9
%214 = load i32*, i32** %14
%215 = getelementptr inbounds i32, i32* %214, i64 0
%216 = load i32, i32* %215
%217 = load i32, i32* %8
%218 = add nsw i32 %217, %216
store i32 %218, i32* %8
br label %284
219: ; preds = %139
%220 = load i32*, i32** %14
%221 = getelementptr inbounds i32, i32* %220, i64 1
%222 = load i32, i32* %221
%223 = and i32 %222, 16777215
%224 = load i32, i32* %9
%225 = add nsw i32 %224, %223
store i32 %225, i32* %9
%226 = load i32*, i32** %14
%227 = getelementptr inbounds i32, i32* %226, i64 0
%228 = load i32, i32* %227
%229 = load i32, i32* %8
%230 = add nsw i32 %229, %228
store i32 %230, i32* %8
br label %284
231: ; preds = %139
%232 = load i32*, i32** %14
%233 = getelementptr inbounds i32, i32* %232, i64 1
%234 = load i32, i32* %233
%235 = and i32 %234, 65535
%236 = load i32, i32* %9
%237 = add nsw i32 %236, %235
store i32 %237, i32* %9
%238 = load i32*, i32** %14
%239 = getelementptr inbounds i32, i32* %238, i64 0
%240 = load i32, i32* %239
%241 = load i32, i32* %8
%242 = add nsw i32 %241, %240
store i32 %242, i32* %8
br label %284
243: ; preds = %139
%244 = load i32*, i32** %14
%245 = getelementptr inbounds i32, i32* %244, i64 1
%246 = load i32, i32* %245
%247 = and i32 %246, 255
%248 = load i32, i32* %9
%249 = add nsw i32 %248, %247
store i32 %249, i32* %9
%250 = load i32*, i32** %14
%251 = getelementptr inbounds i32, i32* %250, i64 0
%252 = load i32, i32* %251
%253 = load i32, i32* %8
%254 = add nsw i32 %253, %252
store i32 %254, i32* %8
br label %284
255: ; preds = %139
%256 = load i32*, i32** %14
%257 = getelementptr inbounds i32, i32* %256, i64 0
%258 = load i32, i32* %257
%259 = load i32, i32* %8
%260 = add nsw i32 %259, %258
store i32 %260, i32* %8
br label %284
261: ; preds = %139
%262 = load i32*, i32** %14
%263 = getelementptr inbounds i32, i32* %262, i64 0
%264 = load i32, i32* %263
%265 = and i32 %264, 16777215
%266 = load i32, i32* %8
%267 = add nsw i32 %266, %265
store i32 %267, i32* %8
br label %284
268: ; preds = %139
%269 = load i32*, i32** %14
%270 = getelementptr inbounds i32, i32* %269, i64 0
%271 = load i32, i32* %270
%272 = and i32 %271, 65535
%273 = load i32, i32* %8
%274 = add nsw i32 %273, %272
store i32 %274, i32* %8
br label %284
275: ; preds = %139
%276 = load i32*, i32** %14
%277 = getelementptr inbounds i32, i32* %276, i64 0
%278 = load i32, i32* %277
%279 = and i32 %278, 255
%280 = load i32, i32* %8
%281 = add nsw i32 %280, %279
store i32 %281, i32* %8
br label %284
282: ; preds = %139
%283 = load i32, i32* %10
store i32 %283, i32* %4
br label %937
284: ; preds = %139, %275, %268, %261, %255, %243, %231, %219, %208, %191, %174, %157, %141
br label %865
285: ; preds = %3
%286 = bitcast %union.anon* %13 to i64*
%287 = load i64, i64* %286
%288 = and i64 %287, 1
%289 = icmp eq i64 %288, 0
br i1 %289, label %290, label %620
290: ; preds = %285
%291 = load i8*, i8** %5
%292 = bitcast i8* %291 to i64*
store i64* %292, i64** %16
br label %293
293: ; preds = %296, %290
%294 = load i64, i64* %11
%295 = icmp ugt i64 %294, 12
br i1 %295, label %296, label %421
296: ; preds = %293
%297 = load i64*, i64** %16
%298 = getelementptr inbounds i64, i64* %297, i64 0
%299 = load i64, i64* %298
%300 = load i64*, i64** %16
%301 = getelementptr inbounds i64, i64* %300, i64 1
%302 = load i64, i64* %301
%303 = trunc i64 %302 to i32
%304 = shl i32 %303, 16
%305 = sext i32 %304 to i64
%306 = add nsw i64 %299, %305
%307 = load i32, i32* %8
%308 = sext i32 %307 to i64
%309 = add nsw i64 %308, %306
%310 = trunc i64 %309 to i32
store i32 %310, i32* %8
%311 = load i64*, i64** %16
%312 = getelementptr inbounds i64, i64* %311, i64 2
%313 = load i64, i64* %312
%314 = load i64*, i64** %16
%315 = getelementptr inbounds i64, i64* %314, i64 3
%316 = load i64, i64* %315
%317 = trunc i64 %316 to i32
%318 = shl i32 %317, 16
%319 = sext i32 %318 to i64
%320 = add nsw i64 %313, %319
%321 = load i32, i32* %9
%322 = sext i32 %321 to i64
%323 = add nsw i64 %322, %320
%324 = trunc i64 %323 to i32
store i32 %324, i32* %9
%325 = load i64*, i64** %16
%326 = getelementptr inbounds i64, i64* %325, i64 4
%327 = load i64, i64* %326
%328 = load i64*, i64** %16
%329 = getelementptr inbounds i64, i64* %328, i64 5
%330 = load i64, i64* %329
%331 = trunc i64 %330 to i32
%332 = shl i32 %331, 16
%333 = sext i32 %332 to i64
%334 = add nsw i64 %327, %333
%335 = load i32, i32* %10
%336 = sext i32 %335 to i64
%337 = add nsw i64 %336, %334
%338 = trunc i64 %337 to i32
store i32 %338, i32* %10
%339 = load i32, i32* %10
%340 = load i32, i32* %8
%341 = sub nsw i32 %340, %339
store i32 %341, i32* %8
%342 = load i32, i32* %10
%343 = shl i32 %342, 4
%344 = load i32, i32* %10
%345 = ashr i32 %344, 28
%346 = or i32 %343, %345
%347 = load i32, i32* %8
%348 = xor i32 %347, %346
store i32 %348, i32* %8
%349 = load i32, i32* %9
%350 = load i32, i32* %10
%351 = add nsw i32 %350, %349
store i32 %351, i32* %10
%352 = load i32, i32* %8
%353 = load i32, i32* %9
%354 = sub nsw i32 %353, %352
store i32 %354, i32* %9
%355 = load i32, i32* %8
%356 = shl i32 %355, 6
%357 = load i32, i32* %8
%358 = ashr i32 %357, 26
%359 = or i32 %356, %358
%360 = load i32, i32* %9
%361 = xor i32 %360, %359
store i32 %361, i32* %9
%362 = load i32, i32* %10
%363 = load i32, i32* %8
%364 = add nsw i32 %363, %362
store i32 %364, i32* %8
%365 = load i32, i32* %9
%366 = load i32, i32* %10
%367 = sub nsw i32 %366, %365
store i32 %367, i32* %10
%368 = load i32, i32* %9
%369 = shl i32 %368, 8
%370 = load i32, i32* %9
%371 = ashr i32 %370, 24
%372 = or i32 %369, %371
%373 = load i32, i32* %10
%374 = xor i32 %373, %372
store i32 %374, i32* %10
%375 = load i32, i32* %8
%376 = load i32, i32* %9
%377 = add nsw i32 %376, %375
store i32 %377, i32* %9
%378 = load i32, i32* %10
%379 = load i32, i32* %8
%380 = sub nsw i32 %379, %378
store i32 %380, i32* %8
%381 = load i32, i32* %10
%382 = shl i32 %381, 16
%383 = load i32, i32* %10
%384 = ashr i32 %383, 16
%385 = or i32 %382, %384
%386 = load i32, i32* %8
%387 = xor i32 %386, %385
store i32 %387, i32* %8
%388 = load i32, i32* %9
%389 = load i32, i32* %10
%390 = add nsw i32 %389, %388
store i32 %390, i32* %10
%391 = load i32, i32* %8
%392 = load i32, i32* %9
%393 = sub nsw i32 %392, %391
store i32 %393, i32* %9
%394 = load i32, i32* %8
%395 = shl i32 %394, 19
%396 = load i32, i32* %8
%397 = ashr i32 %396, 13
%398 = or i32 %395, %397
%399 = load i32, i32* %9
%400 = xor i32 %399, %398
store i32 %400, i32* %9
%401 = load i32, i32* %10
%402 = load i32, i32* %8
%403 = add nsw i32 %402, %401
store i32 %403, i32* %8
%404 = load i32, i32* %9
%405 = load i32, i32* %10
%406 = sub nsw i32 %405, %404
store i32 %406, i32* %10
%407 = load i32, i32* %9
%408 = shl i32 %407, 4
%409 = load i32, i32* %9
%410 = ashr i32 %409, 28
%411 = or i32 %408, %410
%412 = load i32, i32* %10
%413 = xor i32 %412, %411
store i32 %413, i32* %10
%414 = load i32, i32* %8
%415 = load i32, i32* %9
%416 = add nsw i32 %415, %414
store i32 %416, i32* %9
%417 = load i64, i64* %11
%418 = sub i64 %417, 12
store i64 %418, i64* %11
%419 = load i64*, i64** %16
%420 = getelementptr inbounds i64, i64* %419, i64 6
store i64* %420, i64** %16
br label %293
421: ; preds = %293
%422 = load i64*, i64** %16
%423 = bitcast i64* %422 to i32*
store i32* %423, i32** %17
%424 = load i64, i64* %11
switch i64 %424, label %619 [
i64 12, label %425
i64 11, label %468
i64 10, label %475
i64 9, label %511
i64 8, label %517
i64 7, label %546
i64 6, label %553
i64 5, label %575
i64 4, label %581
i64 3, label %596
i64 2, label %603
i64 1, label %611
i64 0, label %617
]
425: ; preds = %421
%426 = load i64*, i64** %16
%427 = getelementptr inbounds i64, i64* %426, i64 4
%428 = load i64, i64* %427
%429 = load i64*, i64** %16
%430 = getelementptr inbounds i64, i64* %429, i64 5
%431 = load i64, i64* %430
%432 = trunc i64 %431 to i32
%433 = shl i32 %432, 16
%434 = sext i32 %433 to i64
%435 = add nsw i64 %428, %434
%436 = load i32, i32* %10
%437 = sext i32 %436 to i64
%438 = add nsw i64 %437, %435
%439 = trunc i64 %438 to i32
store i32 %439, i32* %10
%440 = load i64*, i64** %16
%441 = getelementptr inbounds i64, i64* %440, i64 2
%442 = load i64, i64* %441
%443 = load i64*, i64** %16
%444 = getelementptr inbounds i64, i64* %443, i64 3
%445 = load i64, i64* %444
%446 = trunc i64 %445 to i32
%447 = shl i32 %446, 16
%448 = sext i32 %447 to i64
%449 = add nsw i64 %442, %448
%450 = load i32, i32* %9
%451 = sext i32 %450 to i64
%452 = add nsw i64 %451, %449
%453 = trunc i64 %452 to i32
store i32 %453, i32* %9
%454 = load i64*, i64** %16
%455 = getelementptr inbounds i64, i64* %454, i64 0
%456 = load i64, i64* %455
%457 = load i64*, i64** %16
%458 = getelementptr inbounds i64, i64* %457, i64 1
%459 = load i64, i64* %458
%460 = trunc i64 %459 to i32
%461 = shl i32 %460, 16
%462 = sext i32 %461 to i64
%463 = add nsw i64 %456, %462
%464 = load i32, i32* %8
%465 = sext i32 %464 to i64
%466 = add nsw i64 %465, %463
%467 = trunc i64 %466 to i32
store i32 %467, i32* %8
br label %619
468: ; preds = %421
%469 = load i32*, i32** %17
%470 = getelementptr inbounds i32, i32* %469, i64 10
%471 = load i32, i32* %470
%472 = shl i32 %471, 16
%473 = load i32, i32* %10
%474 = add nsw i32 %473, %472
store i32 %474, i32* %10
br label %475
475: ; preds = %421, %468
%476 = load i64*, i64** %16
%477 = getelementptr inbounds i64, i64* %476, i64 4
%478 = load i64, i64* %477
%479 = load i32, i32* %10
%480 = sext i32 %479 to i64
%481 = add nsw i64 %480, %478
%482 = trunc i64 %481 to i32
store i32 %482, i32* %10
%483 = load i64*, i64** %16
%484 = getelementptr inbounds i64, i64* %483, i64 2
%485 = load i64, i64* %484
%486 = load i64*, i64** %16
%487 = getelementptr inbounds i64, i64* %486, i64 3
%488 = load i64, i64* %487
%489 = trunc i64 %488 to i32
%490 = shl i32 %489, 16
%491 = sext i32 %490 to i64
%492 = add nsw i64 %485, %491
%493 = load i32, i32* %9
%494 = sext i32 %493 to i64
%495 = add nsw i64 %494, %492
%496 = trunc i64 %495 to i32
store i32 %496, i32* %9
%497 = load i64*, i64** %16
%498 = getelementptr inbounds i64, i64* %497, i64 0
%499 = load i64, i64* %498
%500 = load i64*, i64** %16
%501 = getelementptr inbounds i64, i64* %500, i64 1
%502 = load i64, i64* %501
%503 = trunc i64 %502 to i32
%504 = shl i32 %503, 16
%505 = sext i32 %504 to i64
%506 = add nsw i64 %499, %505
%507 = load i32, i32* %8
%508 = sext i32 %507 to i64
%509 = add nsw i64 %508, %506
%510 = trunc i64 %509 to i32
store i32 %510, i32* %8
br label %619
511: ; preds = %421
%512 = load i32*, i32** %17
%513 = getelementptr inbounds i32, i32* %512, i64 8
%514 = load i32, i32* %513
%515 = load i32, i32* %10
%516 = add nsw i32 %515, %514
store i32 %516, i32* %10
br label %517
517: ; preds = %421, %511
%518 = load i64*, i64** %16
%519 = getelementptr inbounds i64, i64* %518, i64 2
%520 = load i64, i64* %519
%521 = load i64*, i64** %16
%522 = getelementptr inbounds i64, i64* %521, i64 3
%523 = load i64, i64* %522
%524 = trunc i64 %523 to i32
%525 = shl i32 %524, 16
%526 = sext i32 %525 to i64
%527 = add nsw i64 %520, %526
%528 = load i32, i32* %9
%529 = sext i32 %528 to i64
%530 = add nsw i64 %529, %527
%531 = trunc i64 %530 to i32
store i32 %531, i32* %9
%532 = load i64*, i64** %16
%533 = getelementptr inbounds i64, i64* %532, i64 0
%534 = load i64, i64* %533
%535 = load i64*, i64** %16
%536 = getelementptr inbounds i64, i64* %535, i64 1
%537 = load i64, i64* %536
%538 = trunc i64 %537 to i32
%539 = shl i32 %538, 16
%540 = sext i32 %539 to i64
%541 = add nsw i64 %534, %540
%542 = load i32, i32* %8
%543 = sext i32 %542 to i64
%544 = add nsw i64 %543, %541
%545 = trunc i64 %544 to i32
store i32 %545, i32* %8
br label %619
546: ; preds = %421
%547 = load i32*, i32** %17
%548 = getelementptr inbounds i32, i32* %547, i64 6
%549 = load i32, i32* %548
%550 = shl i32 %549, 16
%551 = load i32, i32* %9
%552 = add nsw i32 %551, %550
store i32 %552, i32* %9
br label %553
553: ; preds = %421, %546
%554 = load i64*, i64** %16
%555 = getelementptr inbounds i64, i64* %554, i64 2
%556 = load i64, i64* %555
%557 = load i32, i32* %9
%558 = sext i32 %557 to i64
%559 = add nsw i64 %558, %556
%560 = trunc i64 %559 to i32
store i32 %560, i32* %9
%561 = load i64*, i64** %16
%562 = getelementptr inbounds i64, i64* %561, i64 0
%563 = load i64, i64* %562
%564 = load i64*, i64** %16
%565 = getelementptr inbounds i64, i64* %564, i64 1
%566 = load i64, i64* %565
%567 = trunc i64 %566 to i32
%568 = shl i32 %567, 16
%569 = sext i32 %568 to i64
%570 = add nsw i64 %563, %569
%571 = load i32, i32* %8
%572 = sext i32 %571 to i64
%573 = add nsw i64 %572, %570
%574 = trunc i64 %573 to i32
store i32 %574, i32* %8
br label %619
575: ; preds = %421
%576 = load i32*, i32** %17
%577 = getelementptr inbounds i32, i32* %576, i64 4
%578 = load i32, i32* %577
%579 = load i32, i32* %9
%580 = add nsw i32 %579, %578
store i32 %580, i32* %9
br label %581
581: ; preds = %421, %575
%582 = load i64*, i64** %16
%583 = getelementptr inbounds i64, i64* %582, i64 0
%584 = load i64, i64* %583
%585 = load i64*, i64** %16
%586 = getelementptr inbounds i64, i64* %585, i64 1
%587 = load i64, i64* %586
%588 = trunc i64 %587 to i32
%589 = shl i32 %588, 16
%590 = sext i32 %589 to i64
%591 = add nsw i64 %584, %590
%592 = load i32, i32* %8
%593 = sext i32 %592 to i64
%594 = add nsw i64 %593, %591
%595 = trunc i64 %594 to i32
store i32 %595, i32* %8
br label %619
596: ; preds = %421
%597 = load i32*, i32** %17
%598 = getelementptr inbounds i32, i32* %597, i64 2
%599 = load i32, i32* %598
%600 = shl i32 %599, 16
%601 = load i32, i32* %8
%602 = add nsw i32 %601, %600
store i32 %602, i32* %8
br label %603
603: ; preds = %421, %596
%604 = load i64*, i64** %16
%605 = getelementptr inbounds i64, i64* %604, i64 0
%606 = load i64, i64* %605
%607 = load i32, i32* %8
%608 = sext i32 %607 to i64
%609 = add nsw i64 %608, %606
%610 = trunc i64 %609 to i32
store i32 %610, i32* %8
br label %619
611: ; preds = %421
%612 = load i32*, i32** %17
%613 = getelementptr inbounds i32, i32* %612, i64 0
%614 = load i32, i32* %613
%615 = load i32, i32* %8
%616 = add nsw i32 %615, %614
store i32 %616, i32* %8
br label %619
617: ; preds = %421
%618 = load i32, i32* %10
store i32 %618, i32* %4
br label %937
619: ; preds = %421, %611, %603, %581, %553, %517, %475, %425
br label %864
620: ; preds = %285
%621 = load i8*, i8** %5
%622 = bitcast i8* %621 to i32*
store i32* %622, i32** %18
br label %623
623: ; preds = %626, %620
%624 = load i64, i64* %11
%625 = icmp ugt i64 %624, 12
br i1 %625, label %626, label %778
626: ; preds = %623
%627 = load i32*, i32** %18
%628 = getelementptr inbounds i32, i32* %627, i64 0
%629 = load i32, i32* %628
%630 = load i32, i32* %8
%631 = add nsw i32 %630, %629
store i32 %631, i32* %8
%632 = load i32*, i32** %18
%633 = getelementptr inbounds i32, i32* %632, i64 1
%634 = load i32, i32* %633
%635 = shl i32 %634, 8
%636 = load i32, i32* %8
%637 = add nsw i32 %636, %635
store i32 %637, i32* %8
%638 = load i32*, i32** %18
%639 = getelementptr inbounds i32, i32* %638, i64 2
%640 = load i32, i32* %639
%641 = shl i32 %640, 16
%642 = load i32, i32* %8
%643 = add nsw i32 %642, %641
store i32 %643, i32* %8
%644 = load i32*, i32** %18
%645 = getelementptr inbounds i32, i32* %644, i64 3
%646 = load i32, i32* %645
%647 = shl i32 %646, 24
%648 = load i32, i32* %8
%649 = add nsw i32 %648, %647
store i32 %649, i32* %8
%650 = load i32*, i32** %18
%651 = getelementptr inbounds i32, i32* %650, i64 4
%652 = load i32, i32* %651
%653 = load i32, i32* %9
%654 = add nsw i32 %653, %652
store i32 %654, i32* %9
%655 = load i32*, i32** %18
%656 = getelementptr inbounds i32, i32* %655, i64 5
%657 = load i32, i32* %656
%658 = shl i32 %657, 8
%659 = load i32, i32* %9
%660 = add nsw i32 %659, %658
store i32 %660, i32* %9
%661 = load i32*, i32** %18
%662 = getelementptr inbounds i32, i32* %661, i64 6
%663 = load i32, i32* %662
%664 = shl i32 %663, 16
%665 = load i32, i32* %9
%666 = add nsw i32 %665, %664
store i32 %666, i32* %9
%667 = load i32*, i32** %18
%668 = getelementptr inbounds i32, i32* %667, i64 7
%669 = load i32, i32* %668
%670 = shl i32 %669, 24
%671 = load i32, i32* %9
%672 = add nsw i32 %671, %670
store i32 %672, i32* %9
%673 = load i32*, i32** %18
%674 = getelementptr inbounds i32, i32* %673, i64 8
%675 = load i32, i32* %674
%676 = load i32, i32* %10
%677 = add nsw i32 %676, %675
store i32 %677, i32* %10
%678 = load i32*, i32** %18
%679 = getelementptr inbounds i32, i32* %678, i64 9
%680 = load i32, i32* %679
%681 = shl i32 %680, 8
%682 = load i32, i32* %10
%683 = add nsw i32 %682, %681
store i32 %683, i32* %10
%684 = load i32*, i32** %18
%685 = getelementptr inbounds i32, i32* %684, i64 10
%686 = load i32, i32* %685
%687 = shl i32 %686, 16
%688 = load i32, i32* %10
%689 = add nsw i32 %688, %687
store i32 %689, i32* %10
%690 = load i32*, i32** %18
%691 = getelementptr inbounds i32, i32* %690, i64 11
%692 = load i32, i32* %691
%693 = shl i32 %692, 24
%694 = load i32, i32* %10
%695 = add nsw i32 %694, %693
store i32 %695, i32* %10
%696 = load i32, i32* %10
%697 = load i32, i32* %8
%698 = sub nsw i32 %697, %696
store i32 %698, i32* %8
%699 = load i32, i32* %10
%700 = shl i32 %699, 4
%701 = load i32, i32* %10
%702 = ashr i32 %701, 28
%703 = or i32 %700, %702
%704 = load i32, i32* %8
%705 = xor i32 %704, %703
store i32 %705, i32* %8
%706 = load i32, i32* %9
%707 = load i32, i32* %10
%708 = add nsw i32 %707, %706
store i32 %708, i32* %10
%709 = load i32, i32* %8
%710 = load i32, i32* %9
%711 = sub nsw i32 %710, %709
store i32 %711, i32* %9
%712 = load i32, i32* %8
%713 = shl i32 %712, 6
%714 = load i32, i32* %8
%715 = ashr i32 %714, 26
%716 = or i32 %713, %715
%717 = load i32, i32* %9
%718 = xor i32 %717, %716
store i32 %718, i32* %9
%719 = load i32, i32* %10
%720 = load i32, i32* %8
%721 = add nsw i32 %720, %719
store i32 %721, i32* %8
%722 = load i32, i32* %9
%723 = load i32, i32* %10
%724 = sub nsw i32 %723, %722
store i32 %724, i32* %10
%725 = load i32, i32* %9
%726 = shl i32 %725, 8
%727 = load i32, i32* %9
%728 = ashr i32 %727, 24
%729 = or i32 %726, %728
%730 = load i32, i32* %10
%731 = xor i32 %730, %729
store i32 %731, i32* %10
%732 = load i32, i32* %8
%733 = load i32, i32* %9
%734 = add nsw i32 %733, %732
store i32 %734, i32* %9
%735 = load i32, i32* %10
%736 = load i32, i32* %8
%737 = sub nsw i32 %736, %735
store i32 %737, i32* %8
%738 = load i32, i32* %10
%739 = shl i32 %738, 16
%740 = load i32, i32* %10
%741 = ashr i32 %740, 16
%742 = or i32 %739, %741
%743 = load i32, i32* %8
%744 = xor i32 %743, %742
store i32 %744, i32* %8
%745 = load i32, i32* %9
%746 = load i32, i32* %10
%747 = add nsw i32 %746, %745
store i32 %747, i32* %10
%748 = load i32, i32* %8
%749 = load i32, i32* %9
%750 = sub nsw i32 %749, %748
store i32 %750, i32* %9
%751 = load i32, i32* %8
%752 = shl i32 %751, 19
%753 = load i32, i32* %8
%754 = ashr i32 %753, 13
%755 = or i32 %752, %754
%756 = load i32, i32* %9
%757 = xor i32 %756, %755
store i32 %757, i32* %9
%758 = load i32, i32* %10
%759 = load i32, i32* %8
%760 = add nsw i32 %759, %758
store i32 %760, i32* %8
%761 = load i32, i32* %9
%762 = load i32, i32* %10
%763 = sub nsw i32 %762, %761
store i32 %763, i32* %10
%764 = load i32, i32* %9
%765 = shl i32 %764, 4
%766 = load i32, i32* %9
%767 = ashr i32 %766, 28
%768 = or i32 %765, %767
%769 = load i32, i32* %10
%770 = xor i32 %769, %768
store i32 %770, i32* %10
%771 = load i32, i32* %8
%772 = load i32, i32* %9
%773 = add nsw i32 %772, %771
store i32 %773, i32* %9
%774 = load i64, i64* %11
%775 = sub i64 %774, 12
store i64 %775, i64* %11
%776 = load i32*, i32** %18
%777 = getelementptr inbounds i32, i32* %776, i64 12
store i32* %777, i32** %18
br label %623
778: ; preds = %623
%779 = load i64, i64* %11
switch i64 %779, label %863 [
i64 12, label %780
i64 11, label %787
i64 10, label %794
i64 9, label %801
i64 8, label %807
i64 7, label %814
i64 6, label %821
i64 5, label %828
i64 4, label %834
i64 3, label %841
i64 2, label %848
i64 1, label %855
i64 0, label %861
]
780: ; preds = %778
%781 = load i32*, i32** %18
%782 = getelementptr inbounds i32, i32* %781, i64 11
%783 = load i32, i32* %782
%784 = shl i32 %783, 24
%785 = load i32, i32* %10
%786 = add nsw i32 %785, %784
store i32 %786, i32* %10
br label %787
787: ; preds = %778, %780
%788 = load i32*, i32** %18
%789 = getelementptr inbounds i32, i32* %788, i64 10
%790 = load i32, i32* %789
%791 = shl i32 %790, 16
%792 = load i32, i32* %10
%793 = add nsw i32 %792, %791
store i32 %793, i32* %10
br label %794
794: ; preds = %778, %787
%795 = load i32*, i32** %18
%796 = getelementptr inbounds i32, i32* %795, i64 9
%797 = load i32, i32* %796
%798 = shl i32 %797, 8
%799 = load i32, i32* %10
%800 = add nsw i32 %799, %798
store i32 %800, i32* %10
br label %801
801: ; preds = %778, %794
%802 = load i32*, i32** %18
%803 = getelementptr inbounds i32, i32* %802, i64 8
%804 = load i32, i32* %803
%805 = load i32, i32* %10
%806 = add nsw i32 %805, %804
store i32 %806, i32* %10
br label %807
807: ; preds = %778, %801
%808 = load i32*, i32** %18
%809 = getelementptr inbounds i32, i32* %808, i64 7
%810 = load i32, i32* %809
%811 = shl i32 %810, 24
%812 = load i32, i32* %9
%813 = add nsw i32 %812, %811
store i32 %813, i32* %9
br label %814
814: ; preds = %778, %807
%815 = load i32*, i32** %18
%816 = getelementptr inbounds i32, i32* %815, i64 6
%817 = load i32, i32* %816
%818 = shl i32 %817, 16
%819 = load i32, i32* %9
%820 = add nsw i32 %819, %818
store i32 %820, i32* %9
br label %821
821: ; preds = %778, %814
%822 = load i32*, i32** %18
%823 = getelementptr inbounds i32, i32* %822, i64 5
%824 = load i32, i32* %823
%825 = shl i32 %824, 8
%826 = load i32, i32* %9
%827 = add nsw i32 %826, %825
store i32 %827, i32* %9
br label %828
828: ; preds = %778, %821
%829 = load i32*, i32** %18
%830 = getelementptr inbounds i32, i32* %829, i64 4
%831 = load i32, i32* %830
%832 = load i32, i32* %9
%833 = add nsw i32 %832, %831
store i32 %833, i32* %9
br label %834
834: ; preds = %778, %828
%835 = load i32*, i32** %18
%836 = getelementptr inbounds i32, i32* %835, i64 3
%837 = load i32, i32* %836
%838 = shl i32 %837, 24
%839 = load i32, i32* %8
%840 = add nsw i32 %839, %838
store i32 %840, i32* %8
br label %841
841: ; preds = %778, %834
%842 = load i32*, i32** %18
%843 = getelementptr inbounds i32, i32* %842, i64 2
%844 = load i32, i32* %843
%845 = shl i32 %844, 16
%846 = load i32, i32* %8
%847 = add nsw i32 %846, %845
store i32 %847, i32* %8
br label %848
848: ; preds = %778, %841
%849 = load i32*, i32** %18
%850 = getelementptr inbounds i32, i32* %849, i64 1
%851 = load i32, i32* %850
%852 = shl i32 %851, 8
%853 = load i32, i32* %8
%854 = add nsw i32 %853, %852
store i32 %854, i32* %8
br label %855
855: ; preds = %778, %848
%856 = load i32*, i32** %18
%857 = getelementptr inbounds i32, i32* %856, i64 0
%858 = load i32, i32* %857
%859 = load i32, i32* %8
%860 = add nsw i32 %859, %858
store i32 %860, i32* %8
br label %863
861: ; preds = %778
%862 = load i32, i32* %10
store i32 %862, i32* %4
br label %937
863: ; preds = %778, %855
br label %864
864: ; preds = %863, %619
br label %865
865: ; preds = %864, %284
%866 = load i32, i32* %9
%867 = load i32, i32* %10
%868 = xor i32 %867, %866
store i32 %868, i32* %10
%869 = load i32, i32* %9
%870 = shl i32 %869, 14
%871 = load i32, i32* %9
%872 = ashr i32 %871, 18
%873 = or i32 %870, %872
%874 = load i32, i32* %10
%875 = sub nsw i32 %874, %873
store i32 %875, i32* %10
%876 = load i32, i32* %10
%877 = load i32, i32* %8
%878 = xor i32 %877, %876
store i32 %878, i32* %8
%879 = load i32, i32* %10
%880 = shl i32 %879, 11
%881 = load i32, i32* %10
%882 = ashr i32 %881, 21
%883 = or i32 %880, %882
%884 = load i32, i32* %8
%885 = sub nsw i32 %884, %883
store i32 %885, i32* %8
%886 = load i32, i32* %8
%887 = load i32, i32* %9
%888 = xor i32 %887, %886
store i32 %888, i32* %9
%889 = load i32, i32* %8
%890 = shl i32 %889, 25
%891 = load i32, i32* %8
%892 = ashr i32 %891, 7
%893 = or i32 %890, %892
%894 = load i32, i32* %9
%895 = sub nsw i32 %894, %893
store i32 %895, i32* %9
%896 = load i32, i32* %9
%897 = load i32, i32* %10
%898 = xor i32 %897, %896
store i32 %898, i32* %10
%899 = load i32, i32* %9
%900 = shl i32 %899, 16
%901 = load i32, i32* %9
%902 = ashr i32 %901, 16
%903 = or i32 %900, %902
%904 = load i32, i32* %10
%905 = sub nsw i32 %904, %903
store i32 %905, i32* %10
%906 = load i32, i32* %10
%907 = load i32, i32* %8
%908 = xor i32 %907, %906
store i32 %908, i32* %8
%909 = load i32, i32* %10
%910 = shl i32 %909, 4
%911 = load i32, i32* %10
%912 = ashr i32 %911, 28
%913 = or i32 %910, %912
%914 = load i32, i32* %8
%915 = sub nsw i32 %914, %913
store i32 %915, i32* %8
%916 = load i32, i32* %8
%917 = load i32, i32* %9
%918 = xor i32 %917, %916
store i32 %918, i32* %9
%919 = load i32, i32* %8
%920 = shl i32 %919, 14
%921 = load i32, i32* %8
%922 = ashr i32 %921, 18
%923 = or i32 %920, %922
%924 = load i32, i32* %9
%925 = sub nsw i32 %924, %923
store i32 %925, i32* %9
%926 = load i32, i32* %9
%927 = load i32, i32* %10
%928 = xor i32 %927, %926
store i32 %928, i32* %10
%929 = load i32, i32* %9
%930 = shl i32 %929, 24
%931 = load i32, i32* %9
%932 = ashr i32 %931, 8
%933 = or i32 %930, %932
%934 = load i32, i32* %10
%935 = sub nsw i32 %934, %933
store i32 %935, i32* %10
%936 = load i32, i32* %10
store i32 %936, i32* %4
br label %937
937: ; preds = %865, %861, %617, %282
%938 = load i32, i32* %4
ret i32 %938
}

LLVM IR (-O2):
define i32 @nhash_(i8* %0, i32* nocapture %1, i32* nocapture %2) {
%4 = load i32, i32* %1
%5 = sext i32 %4 to i64
%6 = load i32, i32* %2
%7 = add i32 %4, -559038737
%8 = add i32 %7, %6
%9 = ptrtoint i8* %0 to i64
%10 = and i64 %9, 3
%11 = icmp eq i64 %10, 0
br i1 %11, label %12, label %155
12: ; preds = %3
%13 = bitcast i8* %0 to i32*
%14 = icmp ugt i32 %4, 12
br i1 %14, label %15, label %68
15: ; preds = %12, %15
%16 = phi i32 [ %58, %15 ], [ %8, %12 ]
%17 = phi i32* [ %66, %15 ], [ %13, %12 ]
%18 = phi i32 [ %64, %15 ], [ %8, %12 ]
%19 = phi i32 [ %63, %15 ], [ %8, %12 ]
%20 = phi i64 [ %65, %15 ], [ %5, %12 ]
%21 = load i32, i32* %17
%22 = add nsw i32 %21, %16
%23 = getelementptr inbounds i32, i32* %17, i64 1
%24 = load i32, i32* %23
%25 = add nsw i32 %24, %18
%26 = getelementptr inbounds i32, i32* %17, i64 2
%27 = load i32, i32* %26
%28 = add nsw i32 %27, %19
%29 = sub i32 %22, %28
%30 = shl i32 %28, 4
%31 = ashr i32 %28, 28
%32 = or i32 %30, %31
%33 = xor i32 %32, %29
%34 = add nsw i32 %28, %25
%35 = sub nsw i32 %25, %33
%36 = shl i32 %33, 6
%37 = ashr i32 %33, 26
%38 = or i32 %36, %37
%39 = xor i32 %38, %35
%40 = add nsw i32 %33, %34
%41 = sub nsw i32 %34, %39
%42 = shl i32 %39, 8
%43 = ashr i32 %39, 24
%44 = or i32 %42, %43
%45 = xor i32 %44, %41
%46 = add nsw i32 %39, %40
%47 = sub nsw i32 %40, %45
%48 = shl i32 %45, 16
%49 = ashr i32 %45, 16
%50 = or i32 %48, %49
%51 = xor i32 %50, %47
%52 = add nsw i32 %45, %46
%53 = sub nsw i32 %46, %51
%54 = shl i32 %51, 19
%55 = ashr i32 %51, 13
%56 = or i32 %54, %55
%57 = xor i32 %56, %53
%58 = add nsw i32 %51, %52
%59 = sub nsw i32 %52, %57
%60 = shl i32 %57, 4
%61 = ashr i32 %57, 28
%62 = or i32 %60, %61
%63 = xor i32 %62, %59
%64 = add nsw i32 %57, %58
%65 = add i64 %20, -12
%66 = getelementptr inbounds i32, i32* %17, i64 3
%67 = icmp ugt i64 %65, 12
br i1 %67, label %15, label %68
68: ; preds = %15, %12
%69 = phi i64 [ %5, %12 ], [ %65, %15 ]
%70 = phi i32 [ %8, %12 ], [ %63, %15 ]
%71 = phi i32 [ %8, %12 ], [ %64, %15 ]
%72 = phi i32* [ %13, %12 ], [ %66, %15 ]
%73 = phi i32 [ %8, %12 ], [ %58, %15 ]
switch i64 %69, label %531 [
i64 12, label %74
i64 11, label %83
i64 10, label %93
i64 9, label %103
i64 8, label %113
i64 7, label %119
i64 6, label %126
i64 5, label %133
i64 4, label %140
i64 3, label %143
i64 2, label %147
i64 1, label %151
i64 0, label %570
]
74: ; preds = %68
%75 = getelementptr inbounds i32, i32* %72, i64 2
%76 = load i32, i32* %75
%77 = add nsw i32 %76, %70
%78 = getelementptr inbounds i32, i32* %72, i64 1
%79 = load i32, i32* %78
%80 = add nsw i32 %79, %71
%81 = load i32, i32* %72
%82 = add nsw i32 %81, %73
br label %531
83: ; preds = %68
%84 = getelementptr inbounds i32, i32* %72, i64 2
%85 = load i32, i32* %84
%86 = and i32 %85, 16777215
%87 = add nsw i32 %86, %70
%88 = getelementptr inbounds i32, i32* %72, i64 1
%89 = load i32, i32* %88
%90 = add nsw i32 %89, %71
%91 = load i32, i32* %72
%92 = add nsw i32 %91, %73
br label %531
93: ; preds = %68
%94 = getelementptr inbounds i32, i32* %72, i64 2
%95 = load i32, i32* %94
%96 = and i32 %95, 65535
%97 = add nsw i32 %96, %70
%98 = getelementptr inbounds i32, i32* %72, i64 1
%99 = load i32, i32* %98
%100 = add nsw i32 %99, %71
%101 = load i32, i32* %72
%102 = add nsw i32 %101, %73
br label %531
103: ; preds = %68
%104 = getelementptr inbounds i32, i32* %72, i64 2
%105 = load i32, i32* %104
%106 = and i32 %105, 255
%107 = add nsw i32 %106, %70
%108 = getelementptr inbounds i32, i32* %72, i64 1
%109 = load i32, i32* %108
%110 = add nsw i32 %109, %71
%111 = load i32, i32* %72
%112 = add nsw i32 %111, %73
br label %531
113: ; preds = %68
%114 = getelementptr inbounds i32, i32* %72, i64 1
%115 = load i32, i32* %114
%116 = add nsw i32 %115, %71
%117 = load i32, i32* %72
%118 = add nsw i32 %117, %73
br label %531
119: ; preds = %68
%120 = getelementptr inbounds i32, i32* %72, i64 1
%121 = load i32, i32* %120
%122 = and i32 %121, 16777215
%123 = add nsw i32 %122, %71
%124 = load i32, i32* %72
%125 = add nsw i32 %124, %73
br label %531
126: ; preds = %68
%127 = getelementptr inbounds i32, i32* %72, i64 1
%128 = load i32, i32* %127
%129 = and i32 %128, 65535
%130 = add nsw i32 %129, %71
%131 = load i32, i32* %72
%132 = add nsw i32 %131, %73
br label %531
133: ; preds = %68
%134 = getelementptr inbounds i32, i32* %72, i64 1
%135 = load i32, i32* %134
%136 = and i32 %135, 255
%137 = add nsw i32 %136, %71
%138 = load i32, i32* %72
%139 = add nsw i32 %138, %73
br label %531
140: ; preds = %68
%141 = load i32, i32* %72
%142 = add nsw i32 %141, %73
br label %531
143: ; preds = %68
%144 = load i32, i32* %72
%145 = and i32 %144, 16777215
%146 = add nsw i32 %145, %73
br label %531
147: ; preds = %68
%148 = load i32, i32* %72
%149 = and i32 %148, 65535
%150 = add nsw i32 %149, %73
br label %531
151: ; preds = %68
%152 = load i32, i32* %72
%153 = and i32 %152, 255
%154 = add nsw i32 %153, %73
br label %531
155: ; preds = %3
%156 = and i64 %9, 1
%157 = icmp eq i64 %156, 0
br i1 %157, label %158, label %356
158: ; preds = %155
%159 = bitcast i8* %0 to i64*
%160 = icmp ugt i32 %4, 12
br i1 %160, label %161, label %229
161: ; preds = %158, %161
%162 = phi i64* [ %227, %161 ], [ %159, %158 ]
%163 = phi i32 [ %219, %161 ], [ %8, %158 ]
%164 = phi i32 [ %225, %161 ], [ %8, %158 ]
%165 = phi i32 [ %224, %161 ], [ %8, %158 ]
%166 = phi i64 [ %226, %161 ], [ %5, %158 ]
%167 = load i64, i64* %162
%168 = getelementptr inbounds i64, i64* %162, i64 1
%169 = load i64, i64* %168
%170 = shl i64 %169, 16
%171 = add i64 %170, %167
%172 = trunc i64 %171 to i32
%173 = add i32 %163, %172
%174 = getelementptr inbounds i64, i64* %162, i64 2
%175 = load i64, i64* %174
%176 = getelementptr inbounds i64, i64* %162, i64 3
%177 = load i64, i64* %176
%178 = shl i64 %177, 16
%179 = add i64 %178, %175
%180 = trunc i64 %179 to i32
%181 = add i32 %164, %180
%182 = getelementptr inbounds i64, i64* %162, i64 4
%183 = load i64, i64* %182
%184 = getelementptr inbounds i64, i64* %162, i64 5
%185 = load i64, i64* %184
%186 = shl i64 %185, 16
%187 = add i64 %186, %183
%188 = trunc i64 %187 to i32
%189 = add i32 %165, %188
%190 = sub i32 %173, %189
%191 = shl i32 %189, 4
%192 = ashr i32 %189, 28
%193 = or i32 %191, %192
%194 = xor i32 %193, %190
%195 = add nsw i32 %189, %181
%196 = sub nsw i32 %181, %194
%197 = shl i32 %194, 6
%198 = ashr i32 %194, 26
%199 = or i32 %197, %198
%200 = xor i32 %199, %196
%201 = add nsw i32 %194, %195
%202 = sub nsw i32 %195, %200
%203 = shl i32 %200, 8
%204 = ashr i32 %200, 24
%205 = or i32 %203, %204
%206 = xor i32 %205, %202
%207 = add nsw i32 %200, %201
%208 = sub nsw i32 %201, %206
%209 = shl i32 %206, 16
%210 = ashr i32 %206, 16
%211 = or i32 %209, %210
%212 = xor i32 %211, %208
%213 = add nsw i32 %206, %207
%214 = sub nsw i32 %207, %212
%215 = shl i32 %212, 19
%216 = ashr i32 %212, 13
%217 = or i32 %215, %216
%218 = xor i32 %217, %214
%219 = add nsw i32 %212, %213
%220 = sub nsw i32 %213, %218
%221 = shl i32 %218, 4
%222 = ashr i32 %218, 28
%223 = or i32 %221, %222
%224 = xor i32 %223, %220
%225 = add nsw i32 %218, %219
%226 = add i64 %166, -12
%227 = getelementptr inbounds i64, i64* %162, i64 6
%228 = icmp ugt i64 %226, 12
br i1 %228, label %161, label %229
229: ; preds = %161, %158
%230 = phi i64 [ %5, %158 ], [ %226, %161 ]
%231 = phi i32 [ %8, %158 ], [ %224, %161 ]
%232 = phi i32 [ %8, %158 ], [ %225, %161 ]
%233 = phi i32 [ %8, %158 ], [ %219, %161 ]
%234 = phi i64* [ %159, %158 ], [ %227, %161 ]
switch i64 %230, label %531 [
i64 12, label %235
i64 11, label %259
i64 10, label %265
i64 9, label %286
i64 8, label %291
i64 7, label %308
i64 6, label %314
i64 5, label %327
i64 4, label %332
i64 3, label %341
i64 2, label %347
i64 1, label %352
i64 0, label %570
]
235: ; preds = %229
%236 = getelementptr inbounds i64, i64* %234, i64 4
%237 = load i64, i64* %236
%238 = getelementptr inbounds i64, i64* %234, i64 5
%239 = load i64, i64* %238
%240 = shl i64 %239, 16
%241 = add i64 %240, %237
%242 = trunc i64 %241 to i32
%243 = add i32 %231, %242
%244 = getelementptr inbounds i64, i64* %234, i64 2
%245 = load i64, i64* %244
%246 = getelementptr inbounds i64, i64* %234, i64 3
%247 = load i64, i64* %246
%248 = shl i64 %247, 16
%249 = add i64 %248, %245
%250 = trunc i64 %249 to i32
%251 = add i32 %232, %250
%252 = load i64, i64* %234
%253 = getelementptr inbounds i64, i64* %234, i64 1
%254 = load i64, i64* %253
%255 = shl i64 %254, 16
%256 = add i64 %255, %252
%257 = trunc i64 %256 to i32
%258 = add i32 %233, %257
br label %531
259: ; preds = %229
%260 = getelementptr inbounds i64, i64* %234, i64 5
%261 = bitcast i64* %260 to i32*
%262 = load i32, i32* %261
%263 = shl i32 %262, 16
%264 = add nsw i32 %263, %231
br label %265
265: ; preds = %229, %259
%266 = phi i32 [ %231, %229 ], [ %264, %259 ]
%267 = getelementptr inbounds i64, i64* %234, i64 4
%268 = load i64, i64* %267
%269 = trunc i64 %268 to i32
%270 = add i32 %266, %269
%271 = getelementptr inbounds i64, i64* %234, i64 2
%272 = load i64, i64* %271
%273 = getelementptr inbounds i64, i64* %234, i64 3
%274 = load i64, i64* %273
%275 = shl i64 %274, 16
%276 = add i64 %275, %272
%277 = trunc i64 %276 to i32
%278 = add i32 %232, %277
%279 = load i64, i64* %234
%280 = getelementptr inbounds i64, i64* %234, i64 1
%281 = load i64, i64* %280
%282 = shl i64 %281, 16
%283 = add i64 %282, %279
%284 = trunc i64 %283 to i32
%285 = add i32 %233, %284
br label %531
286: ; preds = %229
%287 = getelementptr inbounds i64, i64* %234, i64 4
%288 = bitcast i64* %287 to i32*
%289 = load i32, i32* %288
%290 = add nsw i32 %289, %231
br label %291
291: ; preds = %229, %286
%292 = phi i32 [ %231, %229 ], [ %290, %286 ]
%293 = getelementptr inbounds i64, i64* %234, i64 2
%294 = load i64, i64* %293
%295 = getelementptr inbounds i64, i64* %234, i64 3
%296 = load i64, i64* %295
%297 = shl i64 %296, 16
%298 = add i64 %297, %294
%299 = trunc i64 %298 to i32
%300 = add i32 %232, %299
%301 = load i64, i64* %234
%302 = getelementptr inbounds i64, i64* %234, i64 1
%303 = load i64, i64* %302
%304 = shl i64 %303, 16
%305 = add i64 %304, %301
%306 = trunc i64 %305 to i32
%307 = add i32 %233, %306
br label %531
308: ; preds = %229
%309 = getelementptr inbounds i64, i64* %234, i64 3
%310 = bitcast i64* %309 to i32*
%311 = load i32, i32* %310
%312 = shl i32 %311, 16
%313 = add nsw i32 %312, %232
br label %314
314: ; preds = %229, %308
%315 = phi i32 [ %232, %229 ], [ %313, %308 ]
%316 = getelementptr inbounds i64, i64* %234, i64 2
%317 = load i64, i64* %316
%318 = trunc i64 %317 to i32
%319 = add i32 %315, %318
%320 = load i64, i64* %234
%321 = getelementptr inbounds i64, i64* %234, i64 1
%322 = load i64, i64* %321
%323 = shl i64 %322, 16
%324 = add i64 %323, %320
%325 = trunc i64 %324 to i32
%326 = add i32 %233, %325
br label %531
327: ; preds = %229
%328 = getelementptr inbounds i64, i64* %234, i64 2
%329 = bitcast i64* %328 to i32*
%330 = load i32, i32* %329
%331 = add nsw i32 %330, %232
br label %332
332: ; preds = %229, %327
%333 = phi i32 [ %232, %229 ], [ %331, %327 ]
%334 = load i64, i64* %234
%335 = getelementptr inbounds i64, i64* %234, i64 1
%336 = load i64, i64* %335
%337 = shl i64 %336, 16
%338 = add i64 %337, %334
%339 = trunc i64 %338 to i32
%340 = add i32 %233, %339
br label %531
341: ; preds = %229
%342 = getelementptr inbounds i64, i64* %234, i64 1
%343 = bitcast i64* %342 to i32*
%344 = load i32, i32* %343
%345 = shl i32 %344, 16
%346 = add nsw i32 %345, %233
br label %347
347: ; preds = %229, %341
%348 = phi i32 [ %233, %229 ], [ %346, %341 ]
%349 = load i64, i64* %234
%350 = trunc i64 %349 to i32
%351 = add i32 %348, %350
br label %531
352: ; preds = %229
%353 = bitcast i64* %234 to i32*
%354 = load i32, i32* %353
%355 = add nsw i32 %354, %233
br label %531
356: ; preds = %155
%357 = bitcast i8* %0 to i32*
%358 = icmp ugt i32 %4, 12
br i1 %358, label %359, label %448
359: ; preds = %356, %359
%360 = phi i32* [ %446, %359 ], [ %357, %356 ]
%361 = phi i32 [ %438, %359 ], [ %8, %356 ]
%362 = phi i32 [ %444, %359 ], [ %8, %356 ]
%363 = phi i32 [ %443, %359 ], [ %8, %356 ]
%364 = phi i64 [ %445, %359 ], [ %5, %356 ]
%365 = load i32, i32* %360
%366 = add nsw i32 %365, %361
%367 = getelementptr inbounds i32, i32* %360, i64 1
%368 = load i32, i32* %367
%369 = shl i32 %368, 8
%370 = add nsw i32 %366, %369
%371 = getelementptr inbounds i32, i32* %360, i64 2
%372 = load i32, i32* %371
%373 = shl i32 %372, 16
%374 = add nsw i32 %370, %373
%375 = getelementptr inbounds i32, i32* %360, i64 3
%376 = load i32, i32* %375
%377 = shl i32 %376, 24
%378 = add nsw i32 %374, %377
%379 = getelementptr inbounds i32, i32* %360, i64 4
%380 = load i32, i32* %379
%381 = add nsw i32 %380, %362
%382 = getelementptr inbounds i32, i32* %360, i64 5
%383 = load i32, i32* %382
%384 = shl i32 %383, 8
%385 = add nsw i32 %381, %384
%386 = getelementptr inbounds i32, i32* %360, i64 6
%387 = load i32, i32* %386
%388 = shl i32 %387, 16
%389 = add nsw i32 %385, %388
%390 = getelementptr inbounds i32, i32* %360, i64 7
%391 = load i32, i32* %390
%392 = shl i32 %391, 24
%393 = add nsw i32 %389, %392
%394 = getelementptr inbounds i32, i32* %360, i64 8
%395 = load i32, i32* %394
%396 = add nsw i32 %395, %363
%397 = getelementptr inbounds i32, i32* %360, i64 9
%398 = load i32, i32* %397
%399 = shl i32 %398, 8
%400 = add nsw i32 %396, %399
%401 = getelementptr inbounds i32, i32* %360, i64 10
%402 = load i32, i32* %401
%403 = shl i32 %402, 16
%404 = add nsw i32 %400, %403
%405 = getelementptr inbounds i32, i32* %360, i64 11
%406 = load i32, i32* %405
%407 = shl i32 %406, 24
%408 = add nsw i32 %404, %407
%409 = sub i32 %378, %408
%410 = shl i32 %408, 4
%411 = ashr i32 %408, 28
%412 = or i32 %410, %411
%413 = xor i32 %412, %409
%414 = add nsw i32 %408, %393
%415 = sub nsw i32 %393, %413
%416 = shl i32 %413, 6
%417 = ashr i32 %413, 26
%418 = or i32 %416, %417
%419 = xor i32 %418, %415
%420 = add nsw i32 %413, %414
%421 = sub nsw i32 %414, %419
%422 = shl i32 %419, 8
%423 = ashr i32 %419, 24
%424 = or i32 %422, %423
%425 = xor i32 %424, %421
%426 = add nsw i32 %419, %420
%427 = sub nsw i32 %420, %425
%428 = shl i32 %425, 16
%429 = ashr i32 %425, 16
%430 = or i32 %428, %429
%431 = xor i32 %430, %427
%432 = add nsw i32 %425, %426
%433 = sub nsw i32 %426, %431
%434 = shl i32 %431, 19
%435 = ashr i32 %431, 13
%436 = or i32 %434, %435
%437 = xor i32 %436, %433
%438 = add nsw i32 %431, %432
%439 = sub nsw i32 %432, %437
%440 = shl i32 %437, 4
%441 = ashr i32 %437, 28
%442 = or i32 %440, %441
%443 = xor i32 %442, %439
%444 = add nsw i32 %437, %438
%445 = add i64 %364, -12
%446 = getelementptr inbounds i32, i32* %360, i64 12
%447 = icmp ugt i64 %445, 12
br i1 %447, label %359, label %448
448: ; preds = %359, %356
%449 = phi i64 [ %5, %356 ], [ %445, %359 ]
%450 = phi i32 [ %8, %356 ], [ %443, %359 ]
%451 = phi i32 [ %8, %356 ], [ %444, %359 ]
%452 = phi i32 [ %8, %356 ], [ %438, %359 ]
%453 = phi i32* [ %357, %356 ], [ %446, %359 ]
switch i64 %449, label %531 [
i64 12, label %454
i64 11, label %459
i64 10, label %465
i64 9, label %471
i64 8, label %476
i64 7, label %482
i64 6, label %489
i64 5, label %496
i64 4, label %502
i64 3, label %509
i64 2, label %517
i64 1, label %525
i64 0, label %570
]
454: ; preds = %448
%455 = getelementptr inbounds i32, i32* %453, i64 11
%456 = load i32, i32* %455
%457 = shl i32 %456, 24
%458 = add nsw i32 %457, %450
br label %459
459: ; preds = %448, %454
%460 = phi i32 [ %450, %448 ], [ %458, %454 ]
%461 = getelementptr inbounds i32, i32* %453, i64 10
%462 = load i32, i32* %461
%463 = shl i32 %462, 16
%464 = add nsw i32 %463, %460
br label %465
465: ; preds = %448, %459
%466 = phi i32 [ %450, %448 ], [ %464, %459 ]
%467 = getelementptr inbounds i32, i32* %453, i64 9
%468 = load i32, i32* %467
%469 = shl i32 %468, 8
%470 = add nsw i32 %469, %466
br label %471
471: ; preds = %448, %465
%472 = phi i32 [ %450, %448 ], [ %470, %465 ]
%473 = getelementptr inbounds i32, i32* %453, i64 8
%474 = load i32, i32* %473
%475 = add nsw i32 %474, %472
br label %476
476: ; preds = %448, %471
%477 = phi i32 [ %450, %448 ], [ %475, %471 ]
%478 = getelementptr inbounds i32, i32* %453, i64 7
%479 = load i32, i32* %478
%480 = shl i32 %479, 24
%481 = add nsw i32 %480, %451
br label %482
482: ; preds = %448, %476
%483 = phi i32 [ %450, %448 ], [ %477, %476 ]
%484 = phi i32 [ %451, %448 ], [ %481, %476 ]
%485 = getelementptr inbounds i32, i32* %453, i64 6
%486 = load i32, i32* %485
%487 = shl i32 %486, 16
%488 = add nsw i32 %487, %484
br label %489
489: ; preds = %448, %482
%490 = phi i32 [ %450, %448 ], [ %483, %482 ]
%491 = phi i32 [ %451, %448 ], [ %488, %482 ]
%492 = getelementptr inbounds i32, i32* %453, i64 5
%493 = load i32, i32* %492
%494 = shl i32 %493, 8
%495 = add nsw i32 %494, %491
br label %496
496: ; preds = %448, %489
%497 = phi i32 [ %450, %448 ], [ %490, %489 ]
%498 = phi i32 [ %451, %448 ], [ %495, %489 ]
%499 = getelementptr inbounds i32, i32* %453, i64 4
%500 = load i32, i32* %499
%501 = add nsw i32 %500, %498
br label %502
502: ; preds = %448, %496
%503 = phi i32 [ %450, %448 ], [ %497, %496 ]
%504 = phi i32 [ %451, %448 ], [ %501, %496 ]
%505 = getelementptr inbounds i32, i32* %453, i64 3
%506 = load i32, i32* %505
%507 = shl i32 %506, 24
%508 = add nsw i32 %507, %452
br label %509
509: ; preds = %448, %502
%510 = phi i32 [ %450, %448 ], [ %503, %502 ]
%511 = phi i32 [ %451, %448 ], [ %504, %502 ]
%512 = phi i32 [ %452, %448 ], [ %508, %502 ]
%513 = getelementptr inbounds i32, i32* %453, i64 2
%514 = load i32, i32* %513
%515 = shl i32 %514, 16
%516 = add nsw i32 %515, %512
br label %517
517: ; preds = %448, %509
%518 = phi i32 [ %450, %448 ], [ %510, %509 ]
%519 = phi i32 [ %451, %448 ], [ %511, %509 ]
%520 = phi i32 [ %452, %448 ], [ %516, %509 ]
%521 = getelementptr inbounds i32, i32* %453, i64 1
%522 = load i32, i32* %521
%523 = shl i32 %522, 8
%524 = add nsw i32 %523, %520
br label %525
525: ; preds = %448, %517
%526 = phi i32 [ %450, %448 ], [ %518, %517 ]
%527 = phi i32 [ %451, %448 ], [ %519, %517 ]
%528 = phi i32 [ %452, %448 ], [ %524, %517 ]
%529 = load i32, i32* %453
%530 = add nsw i32 %529, %528
br label %531
531: ; preds = %448, %525, %229, %352, %347, %332, %314, %291, %265, %235, %68, %151, %147, %143, %140, %133, %126, %119, %113, %103, %93, %83, %74
%532 = phi i32 [ %70, %68 ], [ %70, %151 ], [ %70, %147 ], [ %70, %143 ], [ %70, %140 ], [ %70, %133 ], [ %70, %126 ], [ %70, %119 ], [ %70, %113 ], [ %107, %103 ], [ %97, %93 ], [ %87, %83 ], [ %77, %74 ], [ %231, %229 ], [ %231, %352 ], [ %231, %347 ], [ %231, %332 ], [ %231, %314 ], [ %292, %291 ], [ %270, %265 ], [ %243, %235 ], [ %450, %448 ], [ %526, %525 ]
%533 = phi i32 [ %71, %68 ], [ %71, %151 ], [ %71, %147 ], [ %71, %143 ], [ %71, %140 ], [ %137, %133 ], [ %130, %126 ], [ %123, %119 ], [ %116, %113 ], [ %110, %103 ], [ %100, %93 ], [ %90, %83 ], [ %80, %74 ], [ %232, %229 ], [ %232, %352 ], [ %232, %347 ], [ %333, %332 ], [ %319, %314 ], [ %300, %291 ], [ %278, %265 ], [ %251, %235 ], [ %451, %448 ], [ %527, %525 ]
%534 = phi i32 [ %73, %68 ], [ %154, %151 ], [ %150, %147 ], [ %146, %143 ], [ %142, %140 ], [ %139, %133 ], [ %132, %126 ], [ %125, %119 ], [ %118, %113 ], [ %112, %103 ], [ %102, %93 ], [ %92, %83 ], [ %82, %74 ], [ %233, %229 ], [ %355, %352 ], [ %351, %347 ], [ %340, %332 ], [ %326, %314 ], [ %307, %291 ], [ %285, %265 ], [ %258, %235 ], [ %452, %448 ], [ %530, %525 ]
%535 = xor i32 %533, %532
%536 = shl i32 %533, 14
%537 = ashr i32 %533, 18
%538 = or i32 %536, %537
%539 = sub nsw i32 %535, %538
%540 = xor i32 %539, %534
%541 = shl i32 %539, 11
%542 = ashr i32 %539, 21
%543 = or i32 %541, %542
%544 = sub nsw i32 %540, %543
%545 = xor i32 %544, %533
%546 = shl i32 %544, 25
%547 = ashr i32 %544, 7
%548 = or i32 %546, %547
%549 = sub nsw i32 %545, %548
%550 = xor i32 %549, %539
%551 = shl i32 %549, 16
%552 = ashr i32 %549, 16
%553 = or i32 %551, %552
%554 = sub nsw i32 %550, %553
%555 = xor i32 %554, %544
%556 = shl i32 %554, 4
%557 = ashr i32 %554, 28
%558 = or i32 %556, %557
%559 = sub nsw i32 %555, %558
%560 = xor i32 %559, %549
%561 = shl i32 %559, 14
%562 = ashr i32 %559, 18
%563 = or i32 %561, %562
%564 = sub nsw i32 %560, %563
%565 = xor i32 %564, %554
%566 = shl i32 %564, 24
%567 = ashr i32 %564, 8
%568 = or i32 %566, %567
%569 = sub nsw i32 %565, %568
br label %570
570: ; preds = %448, %229, %68, %531
%571 = phi i32 [ %569, %531 ], [ %70, %68 ], [ %231, %229 ], [ %450, %448 ]
ret i32 %571
}