#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;
typedef int uint32_t;
typedef scalar_t__ *out;

/* Variables and functions */
int siphash(uint8_t *out, const uint8_t *in, uint64_t inlen, const uint8_t *k) {
  uint64_t v0 = 0x736f6d6570736575ULL;
  uint64_t v1 = 0x646f72616e646f6dULL;
  uint64_t v2 = 0x6c7967656e657261ULL;
  uint64_t v3 = 0x7465646279746573ULL;
  uint64_t b;
  uint64_t k0 = (((uint64_t)((k)[0])) | ((uint64_t)((k)[1]) << 8) |
                 ((uint64_t)((k)[2]) << 16) | ((uint64_t)((k)[3]) << 24) |
                 ((uint64_t)((k)[4]) << 32) | ((uint64_t)((k)[5]) << 40) |
                 ((uint64_t)((k)[6]) << 48) | ((uint64_t)((k)[7]) << 56));
  uint64_t k1 =
      (((uint64_t)((k + 8)[0])) | ((uint64_t)((k + 8)[1]) << 8) |
       ((uint64_t)((k + 8)[2]) << 16) | ((uint64_t)((k + 8)[3]) << 24) |
       ((uint64_t)((k + 8)[4]) << 32) | ((uint64_t)((k + 8)[5]) << 40) |
       ((uint64_t)((k + 8)[6]) << 48) | ((uint64_t)((k + 8)[7]) << 56));
  uint64_t m;
  int i;
  const uint8_t *end = in + inlen - (inlen % sizeof(uint64_t));
  const int left = inlen & 7;
  b = ((uint64_t)inlen) << 56;
  v3 ^= k1;
  v2 ^= k0;
  v1 ^= k1;
  v0 ^= k0;
  for (; in != end; in += 8) {
    m = (((uint64_t)((in)[0])) | ((uint64_t)((in)[1]) << 8) |
         ((uint64_t)((in)[2]) << 16) | ((uint64_t)((in)[3]) << 24) |
         ((uint64_t)((in)[4]) << 32) | ((uint64_t)((in)[5]) << 40) |
         ((uint64_t)((in)[6]) << 48) | ((uint64_t)((in)[7]) << 56));
    v3 ^= m;
    ;
    for (i = 0; i < 2; ++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 ^= 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;
  ;
  for (i = 0; i < 2; ++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 < 4; ++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;
  ((out))[0] = (uint8_t)(((uint32_t)((b))));
  ((out))[1] = (uint8_t)(((uint32_t)((b))) >> 8);
  ((out))[2] = (uint8_t)(((uint32_t)((b))) >> 16);
  ((out))[3] = (uint8_t)(((uint32_t)((b))) >> 24);
  ;
  ((out) + 4)[0] = (uint8_t)(((uint32_t)((b) >> 32)));
  ((out) + 4)[1] = (uint8_t)(((uint32_t)((b) >> 32)) >> 8);
  ((out) + 4)[2] = (uint8_t)(((uint32_t)((b) >> 32)) >> 16);
  ((out) + 4)[3] = (uint8_t)(((uint32_t)((b) >> 32)) >> 24);
  ;
  ;
  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)
movl   $0x70736575,-0x24(%rbp)
movl   $0x6e646f6d,-0x28(%rbp)
movl   $0x6e657261,-0x2c(%rbp)
movl   $0x79746573,-0x30(%rbp)
mov    -0x20(%rbp),%rax
mov    (%rax),%rax
mov    -0x20(%rbp),%rcx
mov    0x8(%rcx),%rcx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x10(%rcx),%rcx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x18(%rcx),%rcx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x20(%rcx),%rcx
mov    %ecx,%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x28(%rcx),%rcx
mov    %ecx,%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x30(%rcx),%rcx
mov    %ecx,%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x38(%rcx),%rcx
mov    %ecx,%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    0x40(%rax),%rax
mov    -0x20(%rbp),%rcx
mov    0x48(%rcx),%rcx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x50(%rcx),%rcx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x58(%rcx),%rcx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x60(%rcx),%rcx
mov    %ecx,%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x68(%rcx),%rcx
mov    %ecx,%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x70(%rcx),%rcx
mov    %ecx,%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x20(%rbp),%rcx
mov    0x78(%rcx),%rcx
mov    %ecx,%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x3c(%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    -0x14(%rbp),%eax
mov    $0x38,%ecx
shl    %cl,%eax
mov    %eax,-0x34(%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     1454 <siphash+0x354>
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
mov    -0x10(%rbp),%rcx
mov    0x8(%rcx),%rcx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x10(%rcx),%rcx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x18(%rcx),%rcx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x20(%rcx),%rcx
mov    %ecx,%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x28(%rcx),%rcx
mov    %ecx,%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x30(%rcx),%rcx
mov    %ecx,%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x10(%rbp),%rcx
mov    0x38(%rcx),%rcx
mov    %ecx,%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x40(%rbp)
mov    -0x40(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    143a <siphash+0x33a>
jmp    134d <siphash+0x24d>
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    142c <siphash+0x32c>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    133e <siphash+0x23e>
mov    -0x40(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x10(%rbp),%rax
add    $0x40,%rax
mov    %rax,-0x10(%rbp)
jmp    129b <siphash+0x19b>
mov    -0x54(%rbp),%eax
mov    %rax,-0x60(%rbp)
sub    $0x7,%rax
ja     1502 <siphash+0x402>
mov    -0x60(%rbp),%rax
lea    0xb90(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x10(%rbp),%rax
mov    0x30(%rax),%rax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    0x28(%rax),%rax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    0x20(%rax),%rax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    0x18(%rax),%rax
shl    $0x18,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    0x10(%rax),%rax
shl    $0x10,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    0x8(%rax),%rax
shl    $0x8,%eax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
mov    -0x10(%rbp),%rax
mov    (%rax),%rax
or     -0x34(%rbp),%eax
mov    %eax,-0x34(%rbp)
jmp    1502 <siphash+0x402>
jmp    1502 <siphash+0x402>
mov    -0x34(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x30(%rbp)
movl   $0x0,-0x44(%rbp)
cmpl   $0x2,-0x44(%rbp)
jge    160e <siphash+0x50e>
jmp    1521 <siphash+0x421>
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    1600 <siphash+0x500>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1512 <siphash+0x412>
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,-0x44(%rbp)
cmpl   $0x4,-0x44(%rbp)
jge    1725 <siphash+0x625>
jmp    1638 <siphash+0x538>
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    1717 <siphash+0x617>
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1629 <siphash+0x529>
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
xor    -0x2c(%rbp),%eax
xor    -0x30(%rbp),%eax
mov    %eax,-0x34(%rbp)
movslq -0x34(%rbp),%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x34(%rbp),%eax
sar    $0x8,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x34(%rbp),%eax
sar    $0x10,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x34(%rbp),%eax
sar    $0x18,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x34(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x34(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x8,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x34(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x10,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x34(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x18,%eax
movslq %eax,%rcx
mov    -0x8(%rbp),%rax
mov    %rcx,0x38(%rax)
xor    %eax,%eax
pop    %rbp
ret

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

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