#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */
typedef int /*<<< orphan*/ uint8_t;
typedef int uint64_t;

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


x86 assembly (clang, -O0):
<siphash_nocase>:
push   %rbp
mov    %rsp,%rbp
sub    $0x70,%rsp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
movl   $0x70736575,-0x1c(%rbp)
movl   $0x6e646f6d,-0x20(%rbp)
movl   $0x6e657261,-0x24(%rbp)
movl   $0x79746573,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    0x20(%rax),%eax
mov    %eax,-0x30(%rbp)
mov    -0x8(%rbp),%rax
mov    -0x10(%rbp),%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x10(%rbp),%rdx
and    $0x3,%rdx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x40(%rbp)
mov    -0x10(%rbp),%rax
and    $0x7,%rax
mov    %eax,-0x44(%rbp)
mov    -0x10(%rbp),%rax
mov    $0x38,%ecx
shl    %cl,%eax
mov    %eax,-0x48(%rbp)
mov    -0x30(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x30(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x2c(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
cmp    -0x40(%rbp),%rax
je     13a6 <siphash_nocase+0x296>
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
call   1030 <siptlw@plt>
mov    %eax,-0x64(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x64(%rbp),%eax
shl    $0x8,%ecx
or     %ecx,%eax
mov    %eax,-0x60(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x60(%rbp),%eax
shl    $0x10,%ecx
or     %ecx,%eax
mov    %eax,-0x5c(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x5c(%rbp),%eax
shl    $0x18,%ecx
or     %ecx,%eax
mov    %eax,-0x58(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x58(%rbp),%eax
mov    %ecx,%edx
mov    $0x20,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x54(%rbp)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x54(%rbp),%eax
mov    %ecx,%edx
mov    $0x28,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x50(%rbp)
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x50(%rbp),%eax
mov    %ecx,%edx
mov    $0x30,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x4c(%rbp)
mov    -0x8(%rbp),%rax
mov    0x1c(%rax),%edi
call   1030 <siptlw@plt>
mov    %rax,%rcx
mov    -0x4c(%rbp),%eax
mov    %ecx,%edx
mov    $0x38,%ecx
shl    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x34(%rbp)
mov    -0x34(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x34(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x20,%rax
mov    %rax,-0x8(%rbp)
jmp    11b7 <siphash_nocase+0xa7>
mov    -0x44(%rbp),%eax
mov    %rax,-0x70(%rbp)
sub    $0x7,%rax
ja     1470 <siphash_nocase+0x360>
mov    -0x70(%rbp),%rax
lea    0xc3e(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x8(%rbp),%rax
mov    0x18(%rax),%edi
call   1030 <siptlw@plt>
mov    $0x30,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x14(%rax),%edi
call   1030 <siptlw@plt>
mov    $0x28,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x10(%rax),%edi
call   1030 <siptlw@plt>
mov    $0x20,%ecx
shl    %cl,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0xc(%rax),%edi
call   1030 <siptlw@plt>
shl    $0x18,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x8(%rax),%edi
call   1030 <siptlw@plt>
shl    $0x10,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    0x4(%rax),%edi
call   1030 <siptlw@plt>
shl    $0x8,%eax
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x8(%rbp),%rax
mov    (%rax),%edi
call   1030 <siptlw@plt>
or     -0x48(%rbp),%eax
mov    %eax,-0x48(%rbp)
jmp    1470 <siphash_nocase+0x360>
jmp    1470 <siphash_nocase+0x360>
mov    -0x48(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x48(%rbp),%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
xor    $0xff,%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
jmp    1646 <siphash_nocase+0x536>
mov    -0x20(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x20(%rbp),%eax
shl    $0xd,%eax
mov    -0x20(%rbp),%edx
mov    $0x33,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x1c(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x10,%eax
mov    -0x28(%rbp),%edx
mov    $0x30,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x28(%rbp),%eax
add    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x15,%eax
mov    -0x28(%rbp),%edx
mov    $0x2b,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x28(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x28(%rbp)
mov    -0x20(%rbp),%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x24(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x11,%eax
mov    -0x20(%rbp),%edx
mov    $0x2f,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
xor    -0x20(%rbp),%eax
mov    %eax,-0x20(%rbp)
mov    -0x24(%rbp),%eax
mov    $0x20,%ecx
shl    %cl,%eax
mov    -0x24(%rbp),%edx
mov    $0x20,%ecx
sar    %cl,%edx
mov    %edx,%ecx
or     %ecx,%eax
mov    %eax,-0x24(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
xor    -0x24(%rbp),%eax
xor    -0x28(%rbp),%eax
mov    %eax,-0x48(%rbp)
mov    -0x48(%rbp),%eax
add    $0x70,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<siphash_nocase>:
push   %r15
push   %r14
push   %rbx
mov    %rsi,%r14
mov    %rdi,%rbx
lea    (%rdi,%rsi,4),%r15
mov    %r14d,%eax
and    $0x3,%eax
shl    $0x2,%rax
sub    %rax,%r15
and    $0x7,%r14d
cmp    %rdi,%r15
je     118b <siphash_nocase+0x7b>
cs nopw 0x0(%rax,%rax,1)
nop
mov    (%rbx),%edi
call   1030 <siptlw@plt>
mov    0x4(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x8(%rbx),%edi
call   1030 <siptlw@plt>
mov    0xc(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x10(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x14(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x18(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x1c(%rbx),%edi
call   1030 <siptlw@plt>
add    $0x20,%rbx
cmp    %r15,%rbx
jne    1140 <siphash_nocase+0x30>
mov    %r15,%rbx
add    $0xffffffff,%r14d
cmp    $0x6,%r14d
ja     11dc <siphash_nocase+0xcc>
lea    0xe64(%rip),%rax
movslq (%rax,%r14,4),%rcx
add    %rax,%rcx
jmp    *%rcx
mov    0x18(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x14(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x10(%rbx),%edi
call   1030 <siptlw@plt>
mov    0xc(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x8(%rbx),%edi
call   1030 <siptlw@plt>
mov    0x4(%rbx),%edi
call   1030 <siptlw@plt>
mov    (%rbx),%edi
call   1030 <siptlw@plt>
pop    %rbx
pop    %r14
pop    %r15
ret

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

LLVM IR (-O2):
define i32 @siphash_nocase(i32* %0, i64 %1, i32* nocapture readnone %2) {
%4 = getelementptr inbounds i32, i32* %0, i64 %1
%5 = and i64 %1, 3
%6 = sub nsw i64 0, %5
%7 = getelementptr inbounds i32, i32* %4, i64 %6
%8 = trunc i64 %1 to i32
%9 = and i32 %8, 7
%10 = icmp eq i32* %7, %0
br i1 %10, label %38, label %11
11: ; preds = %3, %11
%12 = phi i32* [ %36, %11 ], [ %0, %3 ]
%13 = load i32, i32* %12
%14 = tail call i64 @siptlw(i32 %13)
%15 = getelementptr inbounds i32, i32* %12, i64 1
%16 = load i32, i32* %15
%17 = tail call i64 @siptlw(i32 %16)
%18 = getelementptr inbounds i32, i32* %12, i64 2
%19 = load i32, i32* %18
%20 = tail call i64 @siptlw(i32 %19)
%21 = getelementptr inbounds i32, i32* %12, i64 3
%22 = load i32, i32* %21
%23 = tail call i64 @siptlw(i32 %22)
%24 = getelementptr inbounds i32, i32* %12, i64 4
%25 = load i32, i32* %24
%26 = tail call i64 @siptlw(i32 %25)
%27 = getelementptr inbounds i32, i32* %12, i64 5
%28 = load i32, i32* %27
%29 = tail call i64 @siptlw(i32 %28)
%30 = getelementptr inbounds i32, i32* %12, i64 6
%31 = load i32, i32* %30
%32 = tail call i64 @siptlw(i32 %31)
%33 = getelementptr inbounds i32, i32* %12, i64 7
%34 = load i32, i32* %33
%35 = tail call i64 @siptlw(i32 %34)
%36 = getelementptr inbounds i32, i32* %12, i64 8
%37 = icmp eq i32* %36, %7
br i1 %37, label %38, label %11
38: ; preds = %11, %3
%39 = phi i32* [ %0, %3 ], [ %7, %11 ]
switch i32 %9, label %67 [
i32 7, label %40
i32 6, label %44
i32 5, label %48
i32 4, label %52
i32 3, label %56
i32 2, label %60
i32 1, label %64
]
40: ; preds = %38
%41 = getelementptr inbounds i32, i32* %39, i64 6
%42 = load i32, i32* %41
%43 = tail call i64 @siptlw(i32 %42)
br label %44
44: ; preds = %38, %40
%45 = getelementptr inbounds i32, i32* %39, i64 5
%46 = load i32, i32* %45
%47 = tail call i64 @siptlw(i32 %46)
br label %48
48: ; preds = %38, %44
%49 = getelementptr inbounds i32, i32* %39, i64 4
%50 = load i32, i32* %49
%51 = tail call i64 @siptlw(i32 %50)
br label %52
52: ; preds = %38, %48
%53 = getelementptr inbounds i32, i32* %39, i64 3
%54 = load i32, i32* %53
%55 = tail call i64 @siptlw(i32 %54)
br label %56
56: ; preds = %38, %52
%57 = getelementptr inbounds i32, i32* %39, i64 2
%58 = load i32, i32* %57
%59 = tail call i64 @siptlw(i32 %58)
br label %60
60: ; preds = %38, %56
%61 = getelementptr inbounds i32, i32* %39, i64 1
%62 = load i32, i32* %61
%63 = tail call i64 @siptlw(i32 %62)
br label %64
64: ; preds = %38, %60
%65 = load i32, i32* %39
%66 = tail call i64 @siptlw(i32 %65)
br label %67
67: ; preds = %38, %64
ret i32 poison
}