#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 */
void hashlittle2(const void *key, size_t length, uint32_t *pc, uint32_t *pb) {
  uint32_t a, b, c;
  union {
    const void *ptr;
    size_t i;
  } u;
  a = b = c = 0xdeadbeef + ((uint32_t)length) + *pc;
  c += *pb;
  u.ptr = key;
  if (1 && ((u.i & 0x3) == 0)) {
    const uint32_t *k = (const uint32_t *)key;
    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:
      *pc = c;
      *pb = b;
      return;
    }
  } 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:
      *pc = c;
      *pb = b;
      return;
    }
  } 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:
      *pc = c;
      *pb = b;
      return;
    }
  }
  {
    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))));
  };
  *pc = c;
  *pb = b;
}


x86 assembly (clang, -O0):
<hashlittle2>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x10(%rbp),%rax
add    $0xdeadbeef,%eax
mov    -0x18(%rbp),%rcx
add    (%rcx),%eax
mov    %eax,-0x2c(%rbp)
mov    %eax,-0x28(%rbp)
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x38(%rbp),%rax
and    $0x3,%rax
cmp    $0x0,%rax
jne    146f <hashlittle2+0x36f>
mov    -0x8(%rbp),%rax
mov    %rax,-0x40(%rbp)
cmpq   $0xc,-0x10(%rbp)
jbe    1298 <hashlittle2+0x198>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%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    -0x10(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x40(%rbp),%rax
add    $0xc,%rax
mov    %rax,-0x40(%rbp)
jmp    115a <hashlittle2+0x5a>
mov    -0x10(%rbp),%rax
mov    %rax,-0x60(%rbp)
sub    $0xc,%rax
ja     146a <hashlittle2+0x36a>
mov    -0x60(%rbp),%rax
lea    0xdb3(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%eax
and    $0xffffff,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%eax
and    $0xffff,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x8(%rax),%eax
and    $0xff,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xffffff,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xffff,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    0x4(%rax),%eax
and    $0xff,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
and    $0xffffff,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
and    $0xffff,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x40(%rbp),%rax
mov    (%rax),%eax
and    $0xff,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    146a <hashlittle2+0x36a>
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1bee <hashlittle2+0xaee>
jmp    1b03 <hashlittle2+0xa03>
mov    -0x38(%rbp),%rax
and    $0x1,%rax
cmp    $0x0,%rax
jne    182b <hashlittle2+0x72b>
mov    -0x8(%rbp),%rax
mov    %rax,-0x48(%rbp)
cmpq   $0xc,-0x10(%rbp)
jbe    1606 <hashlittle2+0x506>
mov    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%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    -0x48(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x48(%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    -0x48(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x48(%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    -0x10(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x48(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x48(%rbp)
jmp    1489 <hashlittle2+0x389>
mov    -0x48(%rbp),%rax
mov    %rax,-0x50(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x68(%rbp)
sub    $0xc,%rax
ja     1826 <hashlittle2+0x726>
mov    -0x68(%rbp),%rax
lea    0xa09(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x48(%rbp),%rax
mov    0x20(%rax),%rcx
mov    -0x48(%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    -0x48(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x48(%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    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%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    1826 <hashlittle2+0x726>
mov    -0x50(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x48(%rbp),%rax
mov    0x20(%rax),%rcx
movslq -0x2c(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x2c(%rbp)
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x48(%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    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%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    1826 <hashlittle2+0x726>
mov    -0x50(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rcx
mov    -0x48(%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    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%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    1826 <hashlittle2+0x726>
mov    -0x50(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    0x10(%rax),%rcx
movslq -0x28(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%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    1826 <hashlittle2+0x726>
mov    -0x50(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%rcx
mov    -0x48(%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    1826 <hashlittle2+0x726>
mov    -0x50(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%rax
mov    (%rax),%rcx
movslq -0x24(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x24(%rbp)
jmp    1826 <hashlittle2+0x726>
mov    -0x50(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1826 <hashlittle2+0x726>
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1bee <hashlittle2+0xaee>
jmp    1afe <hashlittle2+0x9fe>
mov    -0x8(%rbp),%rax
mov    %rax,-0x58(%rbp)
cmpq   $0xc,-0x10(%rbp)
jbe    1a01 <hashlittle2+0x901>
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x14(%rax),%eax
shl    $0x8,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x1c(%rax),%eax
shl    $0x18,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
mov    0x24(%rax),%eax
shl    $0x8,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%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    -0x10(%rbp),%rax
sub    $0xc,%rax
mov    %rax,-0x10(%rbp)
mov    -0x58(%rbp),%rax
add    $0x30,%rax
mov    %rax,-0x58(%rbp)
jmp    1833 <hashlittle2+0x733>
mov    -0x10(%rbp),%rax
mov    %rax,-0x70(%rbp)
sub    $0xc,%rax
ja     1af9 <hashlittle2+0x9f9>
mov    -0x70(%rbp),%rax
lea    0x5e2(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x58(%rbp),%rax
mov    0x2c(%rax),%eax
shl    $0x18,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
mov    0x28(%rax),%eax
shl    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
mov    0x24(%rax),%eax
shl    $0x8,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
mov    0x20(%rax),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x58(%rbp),%rax
mov    0x1c(%rax),%eax
shl    $0x18,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x18(%rax),%eax
shl    $0x10,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x14(%rax),%eax
shl    $0x8,%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0x10(%rax),%eax
add    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x58(%rbp),%rax
mov    0xc(%rax),%eax
shl    $0x18,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    0x8(%rax),%eax
shl    $0x10,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    0x4(%rax),%eax
shl    $0x8,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x58(%rbp),%rax
mov    (%rax),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
jmp    1af9 <hashlittle2+0x9f9>
mov    -0x2c(%rbp),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
jmp    1bee <hashlittle2+0xaee>
jmp    1afe <hashlittle2+0x9fe>
jmp    1b03 <hashlittle2+0xa03>
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),%ecx
mov    -0x18(%rbp),%rax
mov    %ecx,(%rax)
mov    -0x28(%rbp),%ecx
mov    -0x20(%rbp),%rax
mov    %ecx,(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<hashlittle2>:
push   %rbp
push   %rbx
mov    (%rdx),%eax
lea    (%rsi,%rax,1),%r9d
add    $0xdeadbeef,%r9d
mov    (%rcx),%r8d
add    %r9d,%r8d
mov    %r9d,%r11d
test   $0x3,%dil
je     122e <hashlittle2+0x12e>
test   $0x1,%dil
jne    1312 <hashlittle2+0x212>
cmp    $0xd,%rsi
jb     1209 <hashlittle2+0x109>
cs nopw 0x0(%rax,%rax,1)
mov    0x8(%rdi),%ebp
mov    0x18(%rdi),%r10d
shl    $0x10,%ebp
add    (%rdi),%ebp
add    %r9d,%ebp
shl    $0x10,%r10d
add    0x10(%rdi),%r10d
add    %r11d,%r10d
mov    0x28(%rdi),%eax
shl    $0x10,%eax
add    0x20(%rdi),%eax
add    %r8d,%eax
sub    %eax,%ebp
mov    %eax,%r8d
shl    $0x4,%r8d
mov    %eax,%ebx
sar    $0x1c,%ebx
or     %r8d,%ebx
xor    %ebp,%ebx
add    %r10d,%eax
sub    %ebx,%r10d
mov    %ebx,%ebp
shl    $0x6,%ebp
mov    %ebx,%r8d
sar    $0x1a,%r8d
or     %ebp,%r8d
xor    %r10d,%r8d
add    %eax,%ebx
sub    %r8d,%eax
mov    %r8d,%ebp
shl    $0x8,%ebp
mov    %r8d,%r10d
sar    $0x18,%r10d
or     %ebp,%r10d
xor    %eax,%r10d
add    %ebx,%r8d
sub    %r10d,%ebx
mov    %r10d,%eax
shl    $0x10,%eax
mov    %r10d,%r9d
sar    $0x10,%r9d
or     %eax,%r9d
xor    %ebx,%r9d
add    %r8d,%r10d
sub    %r9d,%r8d
mov    %r9d,%eax
shl    $0x13,%eax
mov    %r9d,%r11d
sar    $0xd,%r11d
or     %eax,%r11d
xor    %r8d,%r11d
add    %r10d,%r9d
sub    %r11d,%r10d
mov    %r11d,%eax
shl    $0x4,%eax
mov    %r11d,%r8d
sar    $0x1c,%r8d
or     %eax,%r8d
xor    %r10d,%r8d
add    %r9d,%r11d
add    $0xfffffffffffffff4,%rsi
add    $0x30,%rdi
cmp    $0xc,%rsi
ja     1140 <hashlittle2+0x40>
cmp    $0xc,%rsi
ja     1534 <hashlittle2+0x434>
lea    0xe1a(%rip),%rax
movslq (%rax,%rsi,4),%rsi
add    %rax,%rsi
jmp    *%rsi
mov    0x8(%rdi),%eax
shl    $0x10,%eax
jmp    148e <hashlittle2+0x38e>
cmp    $0xd,%rsi
jb     12f0 <hashlittle2+0x1f0>
nopl   0x0(%rax,%rax,1)
add    (%rdi),%r9d
add    0x4(%rdi),%r11d
add    0x8(%rdi),%r8d
sub    %r8d,%r9d
mov    %r8d,%ebx
shl    $0x4,%ebx
mov    %r8d,%eax
sar    $0x1c,%eax
or     %ebx,%eax
xor    %r9d,%eax
add    %r11d,%r8d
sub    %eax,%r11d
mov    %eax,%ebx
shl    $0x6,%ebx
mov    %eax,%r10d
sar    $0x1a,%r10d
or     %ebx,%r10d
xor    %r11d,%r10d
add    %r8d,%eax
sub    %r10d,%r8d
mov    %r10d,%r9d
shl    $0x8,%r9d
mov    %r10d,%ebx
sar    $0x18,%ebx
or     %r9d,%ebx
xor    %r8d,%ebx
add    %eax,%r10d
sub    %ebx,%eax
mov    %ebx,%r8d
shl    $0x10,%r8d
mov    %ebx,%r9d
sar    $0x10,%r9d
or     %r8d,%r9d
xor    %eax,%r9d
add    %r10d,%ebx
sub    %r9d,%r10d
mov    %r9d,%eax
shl    $0x13,%eax
mov    %r9d,%r11d
sar    $0xd,%r11d
or     %eax,%r11d
xor    %r10d,%r11d
add    %ebx,%r9d
sub    %r11d,%ebx
mov    %r11d,%eax
shl    $0x4,%eax
mov    %r11d,%r8d
sar    $0x1c,%r8d
or     %eax,%r8d
xor    %ebx,%r8d
add    %r9d,%r11d
add    $0xfffffffffffffff4,%rsi
add    $0xc,%rdi
cmp    $0xc,%rsi
ja     1240 <hashlittle2+0x140>
cmp    $0xc,%rsi
ja     1534 <hashlittle2+0x434>
lea    0xd67(%rip),%rax
movslq (%rax,%rsi,4),%rsi
add    %rax,%rsi
jmp    *%rsi
movzbl (%rdi),%eax
jmp    1531 <hashlittle2+0x431>
cmp    $0xd,%rsi
jb     141e <hashlittle2+0x31e>
nopl   0x0(%rax)
add    (%rdi),%r9d
mov    0x4(%rdi),%eax
mov    0x8(%rdi),%ebp
shl    $0x8,%eax
add    %r9d,%eax
shl    $0x10,%ebp
add    %eax,%ebp
mov    0xc(%rdi),%r9d
shl    $0x18,%r9d
add    0x10(%rdi),%r11d
add    %ebp,%r9d
mov    0x14(%rdi),%eax
shl    $0x8,%eax
add    %r11d,%eax
mov    0x18(%rdi),%ebp
shl    $0x10,%ebp
add    %eax,%ebp
mov    0x1c(%rdi),%r10d
shl    $0x18,%r10d
add    %ebp,%r10d
add    0x20(%rdi),%r8d
mov    0x24(%rdi),%eax
shl    $0x8,%eax
add    %r8d,%eax
mov    0x28(%rdi),%ebp
shl    $0x10,%ebp
add    %eax,%ebp
mov    0x2c(%rdi),%ebx
shl    $0x18,%ebx
add    %ebp,%ebx
sub    %ebx,%r9d
mov    %ebx,%ebp
shl    $0x4,%ebp
mov    %ebx,%eax
sar    $0x1c,%eax
or     %ebp,%eax
xor    %r9d,%eax
add    %r10d,%ebx
sub    %eax,%r10d
mov    %eax,%ebp
shl    $0x6,%ebp
mov    %eax,%r8d
sar    $0x1a,%r8d
or     %ebp,%r8d
xor    %r10d,%r8d
add    %ebx,%eax
sub    %r8d,%ebx
mov    %r8d,%ebp
shl    $0x8,%ebp
mov    %r8d,%r10d
sar    $0x18,%r10d
or     %ebp,%r10d
xor    %ebx,%r10d
add    %eax,%r8d
sub    %r10d,%eax
mov    %r10d,%ebp
shl    $0x10,%ebp
mov    %r10d,%r9d
sar    $0x10,%r9d
or     %ebp,%r9d
xor    %eax,%r9d
add    %r8d,%r10d
sub    %r9d,%r8d
mov    %r9d,%eax
shl    $0x13,%eax
mov    %r9d,%r11d
sar    $0xd,%r11d
or     %eax,%r11d
xor    %r8d,%r11d
add    %r10d,%r9d
sub    %r11d,%r10d
mov    %r11d,%eax
shl    $0x4,%eax
mov    %r11d,%r8d
sar    $0x1c,%r8d
or     %eax,%r8d
xor    %r10d,%r8d
add    %r9d,%r11d
add    $0xfffffffffffffff4,%rsi
add    $0x30,%rdi
cmp    $0xc,%rsi
ja     1320 <hashlittle2+0x220>
cmp    $0xc,%rsi
ja     1534 <hashlittle2+0x434>
lea    0xbd1(%rip),%rax
movslq (%rax,%rsi,4),%rsi
add    %rax,%rsi
jmp    *%rsi
mov    0x2c(%rdi),%eax
shl    $0x18,%eax
add    %eax,%r8d
mov    0x28(%rdi),%eax
shl    $0x10,%eax
add    %eax,%r8d
mov    0x24(%rdi),%eax
shl    $0x8,%eax
add    %eax,%r8d
add    0x20(%rdi),%r8d
mov    0x1c(%rdi),%eax
shl    $0x18,%eax
add    %eax,%r11d
mov    0x18(%rdi),%eax
shl    $0x10,%eax
add    %eax,%r11d
mov    0x14(%rdi),%eax
shl    $0x8,%eax
add    %eax,%r11d
add    0x10(%rdi),%r11d
mov    0xc(%rdi),%eax
shl    $0x18,%eax
add    %eax,%r9d
mov    0x8(%rdi),%eax
shl    $0x10,%eax
add    %eax,%r9d
mov    0x4(%rdi),%eax
shl    $0x8,%eax
add    %eax,%r9d
jmp    14eb <hashlittle2+0x3eb>
movzwl (%rdi),%eax
jmp    1531 <hashlittle2+0x431>
mov    $0xffffff,%eax
and    (%rdi),%eax
jmp    1531 <hashlittle2+0x431>
movzbl 0x4(%rdi),%eax
add    %eax,%r11d
jmp    14eb <hashlittle2+0x3eb>
movzwl 0x4(%rdi),%eax
add    %eax,%r11d
jmp    14eb <hashlittle2+0x3eb>
mov    $0xffffff,%eax
and    0x4(%rdi),%eax
add    %eax,%r11d
jmp    14eb <hashlittle2+0x3eb>
movzbl 0x8(%rdi),%eax
jmp    14da <hashlittle2+0x3da>
movzwl 0x8(%rdi),%eax
jmp    14da <hashlittle2+0x3da>
mov    $0xffffff,%eax
and    0x8(%rdi),%eax
add    %eax,%r8d
add    0x4(%rdi),%r11d
jmp    14eb <hashlittle2+0x3eb>
add    0x8(%rdi),%r8d
add    0x4(%rdi),%r11d
add    (%rdi),%r9d
jmp    1534 <hashlittle2+0x434>
mov    0x18(%rdi),%eax
shl    $0x10,%eax
add    %eax,%r11d
add    0x10(%rdi),%r11d
mov    0x8(%rdi),%eax
jmp    152c <hashlittle2+0x42c>
mov    0x28(%rdi),%eax
shl    $0x10,%eax
add    %eax,%r8d
add    0x20(%rdi),%r8d
jmp    151d <hashlittle2+0x41d>
mov    0x28(%rdi),%eax
shl    $0x10,%eax
add    0x20(%rdi),%eax
add    %eax,%r8d
mov    0x8(%rdi),%eax
mov    0x18(%rdi),%esi
shl    $0x10,%esi
add    0x10(%rdi),%esi
add    %esi,%r11d
shl    $0x10,%eax
add    (%rdi),%eax
add    %eax,%r9d
xor    %r11d,%r8d
mov    %r11d,%eax
shl    $0xe,%eax
mov    %r11d,%esi
sar    $0x12,%esi
or     %eax,%esi
sub    %esi,%r8d
xor    %r8d,%r9d
mov    %r8d,%eax
shl    $0xb,%eax
mov    %r8d,%esi
sar    $0x15,%esi
or     %eax,%esi
sub    %esi,%r9d
xor    %r9d,%r11d
mov    %r9d,%eax
shl    $0x19,%eax
mov    %r9d,%esi
sar    $0x7,%esi
or     %eax,%esi
sub    %esi,%r11d
xor    %r11d,%r8d
mov    %r11d,%eax
shl    $0x10,%eax
mov    %r11d,%esi
sar    $0x10,%esi
or     %eax,%esi
sub    %esi,%r8d
xor    %r8d,%r9d
mov    %r8d,%eax
shl    $0x4,%eax
mov    %r8d,%esi
sar    $0x1c,%esi
or     %eax,%esi
sub    %esi,%r9d
xor    %r9d,%r11d
mov    %r9d,%eax
shl    $0xe,%eax
sar    $0x12,%r9d
or     %eax,%r9d
sub    %r9d,%r11d
xor    %r11d,%r8d
mov    %r11d,%eax
shl    $0x18,%eax
mov    %r11d,%esi
sar    $0x8,%esi
or     %eax,%esi
sub    %esi,%r8d
mov    %r8d,(%rdx)
mov    %r11d,(%rcx)
pop    %rbx
pop    %rbp
ret

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

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