#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 UINT64_C(int);
int /*<<< orphan*/ assert(int);
int siphash(const void *in, const size_t inlen, const void *k, uint8_t *out,
            const size_t outlen) {
  const unsigned char *ni = (const unsigned char *)in;
  const unsigned char *kk = (const unsigned char *)k;
  assert((outlen == 8) || (outlen == 16));
  uint64_t v0 = UINT64_C(0x736f6d6570736575);
  uint64_t v1 = UINT64_C(0x646f72616e646f6d);
  uint64_t v2 = UINT64_C(0x6c7967656e657261);
  uint64_t v3 = UINT64_C(0x7465646279746573);
  uint64_t k0 = (((uint64_t)((kk)[0])) | ((uint64_t)((kk)[1]) << 8) |
                 ((uint64_t)((kk)[2]) << 16) | ((uint64_t)((kk)[3]) << 24) |
                 ((uint64_t)((kk)[4]) << 32) | ((uint64_t)((kk)[5]) << 40) |
                 ((uint64_t)((kk)[6]) << 48) | ((uint64_t)((kk)[7]) << 56));
  uint64_t k1 =
      (((uint64_t)((kk + 8)[0])) | ((uint64_t)((kk + 8)[1]) << 8) |
       ((uint64_t)((kk + 8)[2]) << 16) | ((uint64_t)((kk + 8)[3]) << 24) |
       ((uint64_t)((kk + 8)[4]) << 32) | ((uint64_t)((kk + 8)[5]) << 40) |
       ((uint64_t)((kk + 8)[6]) << 48) | ((uint64_t)((kk + 8)[7]) << 56));
  uint64_t m;
  int i;
  const unsigned char *end = ni + 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;
  if (outlen == 16)
    v1 ^= 0xee;
  for (; ni != end; ni += 8) {
    m = (((uint64_t)((ni)[0])) | ((uint64_t)((ni)[1]) << 8) |
         ((uint64_t)((ni)[2]) << 16) | ((uint64_t)((ni)[3]) << 24) |
         ((uint64_t)((ni)[4]) << 32) | ((uint64_t)((ni)[5]) << 40) |
         ((uint64_t)((ni)[6]) << 48) | ((uint64_t)((ni)[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)ni[6]) << 48;
  case 6:
    b |= ((uint64_t)ni[5]) << 40;
  case 5:
    b |= ((uint64_t)ni[4]) << 32;
  case 4:
    b |= ((uint64_t)ni[3]) << 24;
  case 3:
    b |= ((uint64_t)ni[2]) << 16;
  case 2:
    b |= ((uint64_t)ni[1]) << 8;
  case 1:
    b |= ((uint64_t)ni[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;
  if (outlen == 16)
    v2 ^= 0xee;
  else
    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);
  ;
  ;
  if (outlen == 8)
    return 0;
  v1 ^= 0xdd;
  ;
  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 + 8))[0] = (uint8_t)(((uint32_t)((b))));
  ((out + 8))[1] = (uint8_t)(((uint32_t)((b))) >> 8);
  ((out + 8))[2] = (uint8_t)(((uint32_t)((b))) >> 16);
  ((out + 8))[3] = (uint8_t)(((uint32_t)((b))) >> 24);
  ;
  ((out + 8) + 4)[0] = (uint8_t)(((uint32_t)((b) >> 32)));
  ((out + 8) + 4)[1] = (uint8_t)(((uint32_t)((b) >> 32)) >> 8);
  ((out + 8) + 4)[2] = (uint8_t)(((uint32_t)((b) >> 32)) >> 16);
  ((out + 8) + 4)[3] = (uint8_t)(((uint32_t)((b) >> 32)) >> 24);
  ;
  ;
  return 0;
}


x86 assembly (clang, -O0):
<siphash>:
push   %rbp
mov    %rsp,%rbp
sub    $0x80,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %rdx,-0x20(%rbp)
mov    %rcx,-0x28(%rbp)
mov    %r8,-0x30(%rbp)
mov    -0x10(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    %rax,-0x40(%rbp)
mov    $0x1,%al
cmpq   $0x8,-0x30(%rbp)
mov    %al,-0x71(%rbp)
je     116a <siphash+0x4a>
cmpq   $0x10,-0x30(%rbp)
sete   %al
mov    %al,-0x71(%rbp)
mov    -0x71(%rbp),%al
and    $0x1,%al
movzbl %al,%edi
call   1040 <assert@plt>
mov    $0x70736575,%edi
call   1030 <UINT64_C@plt>
mov    %eax,-0x44(%rbp)
mov    $0x6e646f6d,%edi
call   1030 <UINT64_C@plt>
mov    %eax,-0x48(%rbp)
mov    $0x6e657261,%edi
call   1030 <UINT64_C@plt>
mov    %eax,-0x4c(%rbp)
mov    $0x79746573,%edi
call   1030 <UINT64_C@plt>
mov    %eax,-0x50(%rbp)
mov    -0x40(%rbp),%rax
movzbl (%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x4(%rcx),%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x5(%rcx),%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x6(%rcx),%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0x7(%rcx),%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x40(%rbp),%rax
movzbl 0x8(%rax),%eax
mov    -0x40(%rbp),%rcx
movzbl 0x9(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0xa(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0xb(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0xc(%rcx),%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0xd(%rcx),%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0xe(%rcx),%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x40(%rbp),%rcx
movzbl 0xf(%rcx),%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x38(%rbp),%rax
add    -0x18(%rbp),%rax
mov    -0x18(%rbp),%rdx
and    $0x3,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
add    %rcx,%rax
mov    %rax,-0x68(%rbp)
mov    -0x18(%rbp),%rax
and    $0x7,%rax
mov    %eax,-0x6c(%rbp)
mov    -0x18(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
mov    %eax,-0x70(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x58(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x54(%rbp),%eax
xor    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpq   $0x10,-0x30(%rbp)
jne    1315 <siphash+0x1f5>
mov    -0x48(%rbp),%eax
xor    $0xee,%eax
mov    %eax,-0x48(%rbp)
jmp    131a <siphash+0x1fa>
mov    -0x38(%rbp),%rax
cmp    -0x68(%rbp),%rax
je     14cb <siphash+0x3ab>
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
mov    -0x38(%rbp),%rcx
movzbl 0x1(%rcx),%ecx
shl    $0x8,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x2(%rcx),%ecx
shl    $0x10,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x3(%rcx),%ecx
shl    $0x18,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x4(%rcx),%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x5(%rcx),%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x6(%rcx),%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    -0x38(%rbp),%rcx
movzbl 0x7(%rcx),%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x5c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x2,-0x60(%rbp)
jge    14b1 <siphash+0x391>
jmp    13c4 <siphash+0x2a4>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
shl    $0xd,%eax
mov    -0x48(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x44(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x10,%eax
mov    -0x50(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x15,%eax
mov    -0x50(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x11,%eax
mov    -0x48(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x4c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
jmp    14a3 <siphash+0x383>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    13b5 <siphash+0x295>
mov    -0x5c(%rbp),%eax
xor    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x38(%rbp),%rax
add    $0x8,%rax
mov    %rax,-0x38(%rbp)
jmp    131a <siphash+0x1fa>
mov    -0x6c(%rbp),%eax
mov    %rax,-0x80(%rbp)
sub    $0x7,%rax
ja     1579 <siphash+0x459>
mov    -0x80(%rbp),%rax
lea    0xb19(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x38(%rbp),%rax
movzbl 0x6(%rax),%eax
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movzbl 0x5(%rax),%eax
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movzbl 0x4(%rax),%eax
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movzbl 0x3(%rax),%eax
shl    $0x18,%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movzbl 0x2(%rax),%eax
shl    $0x10,%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movzbl 0x1(%rax),%eax
shl    $0x8,%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x38(%rbp),%rax
movzbl (%rax),%eax
or     -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
jmp    1579 <siphash+0x459>
jmp    1579 <siphash+0x459>
mov    -0x70(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x2,-0x60(%rbp)
jge    1685 <siphash+0x565>
jmp    1598 <siphash+0x478>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
shl    $0xd,%eax
mov    -0x48(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x44(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x10,%eax
mov    -0x50(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x15,%eax
mov    -0x50(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x11,%eax
mov    -0x48(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x4c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
jmp    1677 <siphash+0x557>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    1589 <siphash+0x469>
mov    -0x70(%rbp),%eax
xor    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
cmpq   $0x10,-0x30(%rbp)
jne    16a9 <siphash+0x589>
mov    -0x4c(%rbp),%eax
xor    $0xee,%eax
mov    %eax,-0x4c(%rbp)
jmp    16b4 <siphash+0x594>
mov    -0x4c(%rbp),%eax
xor    $0xff,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    17b7 <siphash+0x697>
jmp    16ca <siphash+0x5aa>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
shl    $0xd,%eax
mov    -0x48(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x44(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x10,%eax
mov    -0x50(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x15,%eax
mov    -0x50(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x11,%eax
mov    -0x48(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x4c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
jmp    17a9 <siphash+0x689>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    16bb <siphash+0x59b>
mov    -0x44(%rbp),%eax
xor    -0x48(%rbp),%eax
xor    -0x4c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x70(%rbp)
movslq -0x70(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x70(%rbp),%eax
sar    $0x8,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x8(%rax)
mov    -0x70(%rbp),%eax
sar    $0x10,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x10(%rax)
mov    -0x70(%rbp),%eax
sar    $0x18,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x18(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x20(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x8,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x28(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x10,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x30(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x18,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x38(%rax)
cmpq   $0x8,-0x30(%rbp)
jne    1878 <siphash+0x758>
movl   $0x0,-0x4(%rbp)
jmp    1a38 <siphash+0x918>
mov    -0x48(%rbp),%eax
xor    $0xdd,%eax
mov    %eax,-0x48(%rbp)
movl   $0x0,-0x60(%rbp)
cmpl   $0x4,-0x60(%rbp)
jge    1986 <siphash+0x866>
jmp    1899 <siphash+0x779>
mov    -0x48(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x48(%rbp),%eax
shl    $0xd,%eax
mov    -0x48(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x44(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x44(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x10,%eax
mov    -0x50(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x50(%rbp),%eax
add    -0x44(%rbp),%eax
mov    %eax,-0x44(%rbp)
mov    -0x50(%rbp),%eax
shl    $0x15,%eax
mov    -0x50(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x50(%rbp)
mov    -0x48(%rbp),%eax
add    -0x4c(%rbp),%eax
mov    %eax,-0x4c(%rbp)
mov    -0x48(%rbp),%eax
shl    $0x11,%eax
mov    -0x48(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
xor    -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x4c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x4c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
jmp    1978 <siphash+0x858>
mov    -0x60(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x60(%rbp)
jmp    188a <siphash+0x76a>
mov    -0x44(%rbp),%eax
xor    -0x48(%rbp),%eax
xor    -0x4c(%rbp),%eax
xor    -0x50(%rbp),%eax
mov    %eax,-0x70(%rbp)
movslq -0x70(%rbp),%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x40(%rax)
mov    -0x70(%rbp),%eax
sar    $0x8,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x48(%rax)
mov    -0x70(%rbp),%eax
sar    $0x10,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x50(%rax)
mov    -0x70(%rbp),%eax
sar    $0x18,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x58(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x60(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x8,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x68(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x10,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x70(%rax)
mov    -0x70(%rbp),%eax
mov    $0x20,%ecx
sar    %cl,%eax
sar    $0x18,%eax
movslq %eax,%rcx
mov    -0x28(%rbp),%rax
mov    %rcx,0x78(%rax)
movl   $0x0,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x80,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<siphash>:
push   %r14
push   %rbx
push   %rax
mov    %r8,%rbx
mov    %rcx,%r14
cmp    $0x8,%r8
sete   %al
cmp    $0x10,%r8
sete   %cl
or     %al,%cl
movzbl %cl,%edi
call   1040 <assert@plt>
mov    $0x70736575,%edi
call   1030 <UINT64_C@plt>
mov    $0x6e646f6d,%edi
call   1030 <UINT64_C@plt>
mov    $0x6e657261,%edi
call   1030 <UINT64_C@plt>
mov    $0x79746573,%edi
call   1030 <UINT64_C@plt>
xorps  %xmm0,%xmm0
movups %xmm0,(%r14)
movups %xmm0,0x10(%r14)
cmp    $0x8,%rbx
je     1186 <siphash+0x66>
movups %xmm0,0x50(%r14)
movups %xmm0,0x40(%r14)
xor    %eax,%eax
add    $0x8,%rsp
pop    %rbx
pop    %r14
ret

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

LLVM IR (-O2):
define i32 @siphash(i8* readnone %0, i64 %1, i8* nocapture readnone %2, i64* nocapture writeonly %3, i64 %4) {
%6 = icmp eq i64 %4, 8
%7 = icmp eq i64 %4, 16
%8 = or i1 %6, %7
%9 = zext i1 %8 to i32
%10 = tail call i32 @assert(i32 %9)
%11 = tail call i32 @UINT64_C(i32 1886610805)
%12 = tail call i32 @UINT64_C(i32 1852075885)
%13 = tail call i32 @UINT64_C(i32 1852142177)
%14 = tail call i32 @UINT64_C(i32 2037671283)
%15 = bitcast i64* %3 to i8*
br i1 %6, label %19, label %16
16: ; preds = %5
%17 = getelementptr inbounds i64, i64* %3, i64 8
%18 = bitcast i64* %17 to i8*
br label %19
19: ; preds = %5, %16
ret i32 0
}