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