#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 scalar_t__ uint8_t;
typedef int uint64_t;

/* Variables and functions */
uint64_t siphash(const uint8_t *in, const size_t inlen, const uint8_t *k) {
  uint64_t v0 = 0x736f6d6570736575ULL;
  uint64_t v1 = 0x646f72616e646f6dULL;
  uint64_t v2 = 0x6c7967656e657261ULL;
  uint64_t v3 = 0x7465646279746573ULL;
  uint64_t k0 = (*((uint64_t *)(k)));
  uint64_t k1 = (*((uint64_t *)(k + 8)));
  uint64_t m;
  const uint8_t *end = in + inlen - (inlen % sizeof(uint64_t));
  const int left = inlen & 7;
  uint64_t b = ((uint64_t)inlen) << 56;
  v3 ^= k1;
  v2 ^= k0;
  v1 ^= k1;
  v0 ^= k0;
  for (; in != end; in += 8) {
    m = (*((uint64_t *)(in)));
    v3 ^= m;
    do {
      v0 += v1;
      v1 = (uint64_t)(((v1) << (13)) | ((v1) >> (64 - (13))));
      v1 ^= v0;
      v0 = (uint64_t)(((v0) << (32)) | ((v0) >> (64 - (32))));
      v2 += v3;
      v3 = (uint64_t)(((v3) << (16)) | ((v3) >> (64 - (16))));
      v3 ^= v2;
      v0 += v3;
      v3 = (uint64_t)(((v3) << (21)) | ((v3) >> (64 - (21))));
      v3 ^= v0;
      v2 += v1;
      v1 = (uint64_t)(((v1) << (17)) | ((v1) >> (64 - (17))));
      v1 ^= v2;
      v2 = (uint64_t)(((v2) << (32)) | ((v2) >> (64 - (32))));
    } while (0);
    v0 ^= m;
  }
  switch (left) {
  case 7:
    b |= ((uint64_t)in[6]) << 48;
  case 6:
    b |= ((uint64_t)in[5]) << 40;
  case 5:
    b |= ((uint64_t)in[4]) << 32;
  case 4:
    b |= ((uint64_t)in[3]) << 24;
  case 3:
    b |= ((uint64_t)in[2]) << 16;
  case 2:
    b |= ((uint64_t)in[1]) << 8;
  case 1:
    b |= ((uint64_t)in[0]);
    break;
  case 0:
    break;
  }
  v3 ^= b;
  do {
    v0 += v1;
    v1 = (uint64_t)(((v1) << (13)) | ((v1) >> (64 - (13))));
    v1 ^= v0;
    v0 = (uint64_t)(((v0) << (32)) | ((v0) >> (64 - (32))));
    v2 += v3;
    v3 = (uint64_t)(((v3) << (16)) | ((v3) >> (64 - (16))));
    v3 ^= v2;
    v0 += v3;
    v3 = (uint64_t)(((v3) << (21)) | ((v3) >> (64 - (21))));
    v3 ^= v0;
    v2 += v1;
    v1 = (uint64_t)(((v1) << (17)) | ((v1) >> (64 - (17))));
    v1 ^= v2;
    v2 = (uint64_t)(((v2) << (32)) | ((v2) >> (64 - (32))));
  } while (0);
  v0 ^= b;
  v2 ^= 0xff;
  do {
    v0 += v1;
    v1 = (uint64_t)(((v1) << (13)) | ((v1) >> (64 - (13))));
    v1 ^= v0;
    v0 = (uint64_t)(((v0) << (32)) | ((v0) >> (64 - (32))));
    v2 += v3;
    v3 = (uint64_t)(((v3) << (16)) | ((v3) >> (64 - (16))));
    v3 ^= v2;
    v0 += v3;
    v3 = (uint64_t)(((v3) << (21)) | ((v3) >> (64 - (21))));
    v3 ^= v0;
    v2 += v1;
    v1 = (uint64_t)(((v1) << (17)) | ((v1) >> (64 - (17))));
    v1 ^= v2;
    v2 = (uint64_t)(((v2) << (32)) | ((v2) >> (64 - (32))));
  } while (0);
  do {
    v0 += v1;
    v1 = (uint64_t)(((v1) << (13)) | ((v1) >> (64 - (13))));
    v1 ^= v0;
    v0 = (uint64_t)(((v0) << (32)) | ((v0) >> (64 - (32))));
    v2 += v3;
    v3 = (uint64_t)(((v3) << (16)) | ((v3) >> (64 - (16))));
    v3 ^= v2;
    v0 += v3;
    v3 = (uint64_t)(((v3) << (21)) | ((v3) >> (64 - (21))));
    v3 ^= v0;
    v2 += v1;
    v1 = (uint64_t)(((v1) << (17)) | ((v1) >> (64 - (17))));
    v1 ^= v2;
    v2 = (uint64_t)(((v2) << (32)) | ((v2) >> (64 - (32))));
  } while (0);
  b = v0 ^ v1 ^ v2 ^ v3;
  return b;
}


x86 assembly (clang, -O0):
<siphash>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x70736575,-0x1c(%rbp)
movl   $0x6e646f6d,-0x20(%rbp)
movl   $0x6e657261,-0x24(%rbp)
movl   $0x79746573,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x40(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rdx
and    $0x3,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
and    $0x7,%rax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x40(%rbp),%rax
je     12b7 <siphash+0x1b7>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x34(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x8(%rbp)
jmp    11a3 <siphash+0xa3>
mov    -0x44(%rbp),%eax
mov    %rax,-0x50(%rbp)
sub    $0x7,%rax
ja     1365 <siphash+0x265>
mov    -0x50(%rbp),%rax
lea    0xd2d(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    0x30(%rax),%rax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x28(%rax),%rax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x20(%rax),%rax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%rax
shl    $0x18,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%rax
shl    $0x10,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x8,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%rax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1365 <siphash+0x265>
jmp    1365 <siphash+0x265>
mov    -0x48(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
xor    $0xff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    153b <siphash+0x43b>
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<siphash>:
ret

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

LLVM IR (-O2):
define i32 @siphash(i64* readnone %0, i64 %1, i64* nocapture readnone %2) {
ret i32 poison
}