#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 */
int siphash(uint8_t *out, const uint8_t *in, uint64_t inlen, const uint8_t *k) {
  uint64_t v0 = ((uint64_t)0x736f6d65UL << 32) | 0x70736575UL;
  uint64_t v1 = ((uint64_t)0x646f7261UL << 32) | 0x6e646f6dUL;
  uint64_t v2 = ((uint64_t)0x6c796765UL << 32) | 0x6e657261UL;
  uint64_t v3 = ((uint64_t)0x74656462UL << 32) | 0x79746573UL;
  uint64_t b;
  uint64_t k0 = ((uint64_t)0x07060504UL << 32) | 0x03020100UL;
  uint64_t k1 = ((uint64_t)0x0F0E0D0CUL << 32) | 0x0B0A0908UL;
  int i;
  const int cROUNDS = 2, dROUNDS = 4;
  const uint8_t *end = in + inlen - (inlen % sizeof(uint64_t));
  int left = inlen & 7;
  v3 ^= k1;
  v2 ^= k0;
  v1 ^= k1;
  v0 ^= k0;
  for (; in != end; in += 8) {
    b = 0;
    for (i = 0; i < 8; i++)
      b |= ((uint64_t)in[i]) << (8 * i);
    v3 ^= b;
    for (i = 0; i < cROUNDS; i++)
      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;
  }
  b = ((uint64_t)inlen) << 56;
  for (; left; left--)
    b |= ((uint64_t)in[left - 1]) << (8 * left - 8);
  v3 ^= b;
  for (i = 0; i < cROUNDS; i++)
    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;
  for (i = 0; i < dROUNDS; i++)
    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;
  for (i = 0; i < 8; i++) {
    out[i] = (uint8_t)b;
    b >>= 8;
  }
  return 0;
}


x86 assembly (clang, -O0):
<siphash>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %edx,-0x14(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %eax,-0x24(%rbp)
mov    %eax,-0x28(%rbp)
mov    %eax,-0x2c(%rbp)
mov    %eax,-0x30(%rbp)
mov    %eax,-0x38(%rbp)
mov    %eax,-0x3c(%rbp)
movl   $0x2,-0x44(%rbp)
movl   $0x4,-0x48(%rbp)
mov    -0x10(%rbp),%rax
movslq -0x14(%rbp),%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x14(%rbp),%rdx
and    $0x3,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
mov    %rax,-0x50(%rbp)
mov    -0x14(%rbp),%eax
and    $0x7,%eax
mov    %eax,-0x54(%rbp)
mov    -0x3c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x38(%rbp),%eax
xor    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x3c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x38(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
cmp    -0x50(%rbp),%rax
je     12fb <siphash+0x1fb>
movl   $0x0,-0x34(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x8,-0x40(%rbp)
jge    11d5 <siphash+0xd5>
mov    -0x10(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x40(%rbp),%ecx
shl    $0x3,%ecx
shl    %cl,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11a3 <siphash+0xa3>
mov    -0x34(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x2,-0x40(%rbp)
jge    12e1 <siphash+0x1e1>
jmp    11f4 <siphash+0xf4>
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0xd,%eax
mov    -0x28(%rbp),%edx
mov    $0x33,%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    -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    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x10,%eax
mov    -0x30(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x15,%eax
mov    -0x30(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x11,%eax
mov    -0x28(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x2c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    12d3 <siphash+0x1d3>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11e5 <siphash+0xe5>
mov    -0x34(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
jmp    1187 <siphash+0x87>
mov    -0x14(%rbp),%eax
mov    $0x38,%ecx
shl    %cl,%eax
mov    %eax,-0x34(%rbp)
cmpl   $0x0,-0x54(%rbp)
je     1342 <siphash+0x242>
mov    -0x10(%rbp),%rax
mov    -0x54(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
mov    -0x54(%rbp),%ecx
shl    $0x3,%ecx
sub    $0x8,%ecx
shl    %cl,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x54(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x54(%rbp)
jmp    1308 <siphash+0x208>
mov    -0x34(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x2,-0x40(%rbp)
jge    144e <siphash+0x34e>
jmp    1361 <siphash+0x261>
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0xd,%eax
mov    -0x28(%rbp),%edx
mov    $0x33,%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    -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    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x10,%eax
mov    -0x30(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x15,%eax
mov    -0x30(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x11,%eax
mov    -0x28(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x2c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    1440 <siphash+0x340>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1352 <siphash+0x252>
mov    -0x34(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x2c(%rbp),%eax
xor    $0xff,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x4,-0x40(%rbp)
jge    1565 <siphash+0x465>
jmp    1478 <siphash+0x378>
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0xd,%eax
mov    -0x28(%rbp),%edx
mov    $0x33,%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    -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    -0x30(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x10,%eax
mov    -0x30(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x30(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%eax
shl    $0x15,%eax
mov    -0x30(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x30(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
mov    -0x28(%rbp),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x11,%eax
mov    -0x28(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x2c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x2c(%rbp)
jmp    1557 <siphash+0x457>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    1469 <siphash+0x369>
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
xor    -0x2c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movl   $0x0,-0x40(%rbp)
cmpl   $0x8,-0x40(%rbp)
jge    15ac <siphash+0x4ac>
movslq -0x34(%rbp),%rdx
mov    -0x8(%rbp),%rax
movslq -0x40(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x34(%rbp),%eax
sar    $0x8,%eax
mov    %eax,-0x34(%rbp)
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    157b <siphash+0x47b>
xor    %eax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<siphash>:
xorps  %xmm0,%xmm0
movups %xmm0,0x30(%rdi)
movups %xmm0,0x20(%rdi)
movups %xmm0,0x10(%rdi)
movups %xmm0,(%rdi)
xor    %eax,%eax
ret

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

LLVM IR (-O2):
define i32 @siphash(i64* nocapture writeonly %0, i64* %1, i32 %2, i64* nocapture readnone %3) {
%5 = bitcast i64* %0 to i8*
ret i32 0
}