#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 uint32_t;

/* Variables and functions */
unsigned short gethashvalue(unsigned int const *data, size_t len) {
  uint32_t const m = 0x000AD3E7;
  uint32_t const seed = 0x811C9DC5;
  uint32_t h, k, i;
  for (h = seed; len >= 2 * sizeof *data; len -= 2 * sizeof *data) {
    k = *data++;
    k = ((k << 5) | (k >> 27)) ^ *data++;
    h = (h ^ k) * m;
  }
  for (i = 0; i < len; ++i)
    h ^= ((unsigned char *)data)[i] << (i * 8);
  h *= m;
  return (h ^ (h >> 16)) & 0xFFFF;
}


x86 assembly (clang, -O0):
<gethashvalue>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
movl   $0xad3e7,-0x14(%rbp)
movl   $0x811c9dc5,-0x18(%rbp)
movl   $0x811c9dc5,-0x1c(%rbp)
cmpq   $0x8,-0x10(%rbp)
jb     1182 <gethashvalue+0x82>
mov    -0x8(%rbp),%rax
mov    %rax,%rcx
add    $0x4,%rcx
mov    %rcx,-0x8(%rbp)
mov    (%rax),%eax
mov    %eax,-0x20(%rbp)
mov    -0x20(%rbp),%eax
shl    $0x5,%eax
mov    -0x20(%rbp),%ecx
sar    $0x1b,%ecx
or     %ecx,%eax
mov    -0x8(%rbp),%rcx
mov    %rcx,%rdx
add    $0x4,%rdx
mov    %rdx,-0x8(%rbp)
xor    (%rcx),%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%eax
xor    -0x20(%rbp),%eax
imul   $0xad3e7,%eax,%eax
mov    %eax,-0x1c(%rbp)
mov    -0x10(%rbp),%rax
sub    $0x8,%rax
mov    %rax,-0x10(%rbp)
jmp    1121 <gethashvalue+0x21>
movl   $0x0,-0x24(%rbp)
movslq -0x24(%rbp),%rax
cmp    -0x10(%rbp),%rax
jae    11bf <gethashvalue+0xbf>
mov    -0x8(%rbp),%rax
movslq -0x24(%rbp),%rcx
movzbl (%rax,%rcx,1),%eax
mov    -0x24(%rbp),%ecx
shl    $0x3,%ecx
shl    %cl,%eax
xor    -0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1189 <gethashvalue+0x89>
imul   $0xad3e7,-0x1c(%rbp),%eax
mov    %eax,-0x1c(%rbp)
mov    -0x1c(%rbp),%eax
mov    -0x1c(%rbp),%ecx
sar    $0x10,%ecx
xor    %ecx,%eax
and    $0xffff,%eax
movzwl %ax,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<gethashvalue>:
push   %rbx
mov    $0x811c9dc5,%edx
cmp    $0x8,%rsi
jb     11a5 <gethashvalue+0xa5>
lea    -0x8(%rsi),%rcx
mov    %rcx,%r8
shr    $0x3,%r8
add    $0x1,%r8
cmp    $0x8,%rcx
jae    112c <gethashvalue+0x2c>
mov    $0x811c9dc5,%edx
jmp    1180 <gethashvalue+0x80>
mov    %r8,%r9
and    $0xfffffffffffffffe,%r9
mov    $0x811c9dc5,%edx
nopl   0x0(%rax,%rax,1)
mov    (%rdi),%eax
mov    0x8(%rdi),%ecx
mov    %eax,%r10d
shl    $0x5,%r10d
sar    $0x1b,%eax
or     %r10d,%eax
xor    0x4(%rdi),%edx
xor    %eax,%edx
imul   $0xad3e7,%edx,%eax
mov    %ecx,%edx
shl    $0x5,%edx
sar    $0x1b,%ecx
or     %edx,%ecx
xor    0xc(%rdi),%eax
add    $0x10,%rdi
xor    %ecx,%eax
imul   $0xad3e7,%eax,%edx
add    $0xfffffffffffffff0,%rsi
add    $0xfffffffffffffffe,%r9
jne    1140 <gethashvalue+0x40>
test   $0x1,%r8b
je     11a5 <gethashvalue+0xa5>
mov    (%rdi),%eax
mov    %eax,%ecx
shl    $0x5,%ecx
sar    $0x1b,%eax
or     %ecx,%eax
xor    0x4(%rdi),%edx
add    $0x8,%rdi
xor    %eax,%edx
imul   $0xad3e7,%edx,%edx
add    $0xfffffffffffffff8,%rsi
test   %rsi,%rsi
je     1254 <gethashvalue+0x154>
lea    -0x1(%rsi),%rax
mov    %esi,%r8d
and    $0x3,%r8d
cmp    $0x3,%rax
jae    11c4 <gethashvalue+0xc4>
xor    %r9d,%r9d
jmp    121f <gethashvalue+0x11f>
and    $0xfffffffffffffffc,%rsi
mov    $0x10,%r11d
xor    %r9d,%r9d
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%r9,1),%r10d
movzbl 0x1(%rdi,%r9,1),%eax
lea    -0x8(%r11),%ecx
shl    %cl,%eax
movzbl 0x2(%rdi,%r9,1),%ebx
mov    %r11d,%ecx
shl    %cl,%ebx
xor    %edx,%r10d
xor    %r10d,%eax
movzbl 0x3(%rdi,%r9,1),%edx
lea    0x8(%r11),%ecx
shl    %cl,%edx
xor    %ebx,%edx
xor    %eax,%edx
add    $0x4,%r9
add    $0x20,%r11d
cmp    %r9,%rsi
jne    11e0 <gethashvalue+0xe0>
test   %r8,%r8
je     1254 <gethashvalue+0x154>
lea    0x0(,%r9,8),%ecx
add    %r9,%rdi
xor    %eax,%eax
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movzbl (%rdi,%rax,1),%esi
shl    %cl,%esi
xor    %esi,%edx
add    $0x1,%rax
add    $0x8,%ecx
cmp    %rax,%r8
jne    1240 <gethashvalue+0x140>
imul   $0xad3e7,%edx,%ecx
mov    %ecx,%eax
shr    $0x10,%eax
xor    %ecx,%eax
pop    %rbx
ret

LLVM IR (-O0):
define zeroext i16 @gethashvalue(i32* %0, i64 %1) {
%3 = alloca i32*
%4 = alloca i64
%5 = alloca i32
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32
%9 = alloca i32
store i32* %0, i32** %3
store i64 %1, i64* %4
store i32 709607, i32* %5
store i32 -2128831035, i32* %6
store i32 -2128831035, i32* %7
br label %10
10: ; preds = %30, %2
%11 = load i64, i64* %4
%12 = icmp uge i64 %11, 8
br i1 %12, label %13, label %33
13: ; preds = %10
%14 = load i32*, i32** %3
%15 = getelementptr inbounds i32, i32* %14, i32 1
store i32* %15, i32** %3
%16 = load i32, i32* %14
store i32 %16, i32* %8
%17 = load i32, i32* %8
%18 = shl i32 %17, 5
%19 = load i32, i32* %8
%20 = ashr i32 %19, 27
%21 = or i32 %18, %20
%22 = load i32*, i32** %3
%23 = getelementptr inbounds i32, i32* %22, i32 1
store i32* %23, i32** %3
%24 = load i32, i32* %22
%25 = xor i32 %21, %24
store i32 %25, i32* %8
%26 = load i32, i32* %7
%27 = load i32, i32* %8
%28 = xor i32 %26, %27
%29 = mul nsw i32 %28, 709607
store i32 %29, i32* %7
br label %30
30: ; preds = %13
%31 = load i64, i64* %4
%32 = sub i64 %31, 8
store i64 %32, i64* %4
br label %10
33: ; preds = %10
store i32 0, i32* %9
br label %34
34: ; preds = %52, %33
%35 = load i32, i32* %9
%36 = sext i32 %35 to i64
%37 = load i64, i64* %4
%38 = icmp ult i64 %36, %37
br i1 %38, label %39, label %55
39: ; preds = %34
%40 = load i32*, i32** %3
%41 = bitcast i32* %40 to i8*
%42 = load i32, i32* %9
%43 = sext i32 %42 to i64
%44 = getelementptr inbounds i8, i8* %41, i64 %43
%45 = load i8, i8* %44
%46 = zext i8 %45 to i32
%47 = load i32, i32* %9
%48 = mul nsw i32 %47, 8
%49 = shl i32 %46, %48
%50 = load i32, i32* %7
%51 = xor i32 %50, %49
store i32 %51, i32* %7
br label %52
52: ; preds = %39
%53 = load i32, i32* %9
%54 = add nsw i32 %53, 1
store i32 %54, i32* %9
br label %34
55: ; preds = %34
%56 = load i32, i32* %7
%57 = mul nsw i32 %56, 709607
store i32 %57, i32* %7
%58 = load i32, i32* %7
%59 = load i32, i32* %7
%60 = ashr i32 %59, 16
%61 = xor i32 %58, %60
%62 = and i32 %61, 65535
%63 = trunc i32 %62 to i16
ret i16 %63
}

LLVM IR (-O2):
define zeroext i16 @gethashvalue(i32* nocapture %0, i64 %1) {
%3 = icmp ugt i64 %1, 7
br i1 %3, label %4, label %32
4: ; preds = %2
%5 = add i64 %1, -8
%6 = lshr i64 %5, 3
%7 = add nuw nsw i64 %6, 1
%8 = and i64 %7, 1
%9 = icmp ult i64 %5, 8
br i1 %9, label %12, label %10
10: ; preds = %4
%11 = and i64 %7, 4611686018427387902
br label %44
12: ; preds = %44, %4
%13 = phi i32* [ undef, %4 ], [ %64, %44 ]
%14 = phi i32 [ undef, %4 ], [ %68, %44 ]
%15 = phi i64 [ undef, %4 ], [ %69, %44 ]
%16 = phi i32* [ %0, %4 ], [ %64, %44 ]
%17 = phi i32 [ -2128831035, %4 ], [ %68, %44 ]
%18 = phi i64 [ %1, %4 ], [ %69, %44 ]
%19 = icmp eq i64 %8, 0
br i1 %19, label %32, label %20
20: ; preds = %12
%21 = getelementptr inbounds i32, i32* %16, i64 1
%22 = load i32, i32* %16
%23 = shl i32 %22, 5
%24 = ashr i32 %22, 27
%25 = or i32 %23, %24
%26 = getelementptr inbounds i32, i32* %16, i64 2
%27 = load i32, i32* %21
%28 = xor i32 %27, %17
%29 = xor i32 %28, %25
%30 = mul nsw i32 %29, 709607
%31 = add i64 %18, -8
br label %32
32: ; preds = %20, %12, %2
%33 = phi i64 [ %1, %2 ], [ %15, %12 ], [ %31, %20 ]
%34 = phi i32 [ -2128831035, %2 ], [ %14, %12 ], [ %30, %20 ]
%35 = phi i32* [ %0, %2 ], [ %13, %12 ], [ %26, %20 ]
%36 = icmp eq i64 %33, 0
br i1 %36, label %126, label %37
37: ; preds = %32
%38 = bitcast i32* %35 to i8*
%39 = add i64 %33, -1
%40 = and i64 %33, 3
%41 = icmp ult i64 %39, 3
br i1 %41, label %107, label %42
42: ; preds = %37
%43 = and i64 %33, -4
br label %72
44: ; preds = %44, %10
%45 = phi i32* [ %0, %10 ], [ %64, %44 ]
%46 = phi i32 [ -2128831035, %10 ], [ %68, %44 ]
%47 = phi i64 [ %1, %10 ], [ %69, %44 ]
%48 = phi i64 [ 0, %10 ], [ %70, %44 ]
%49 = getelementptr inbounds i32, i32* %45, i64 1
%50 = load i32, i32* %45
%51 = shl i32 %50, 5
%52 = ashr i32 %50, 27
%53 = or i32 %51, %52
%54 = getelementptr inbounds i32, i32* %45, i64 2
%55 = load i32, i32* %49
%56 = xor i32 %55, %46
%57 = xor i32 %56, %53
%58 = mul nsw i32 %57, 709607
%59 = getelementptr inbounds i32, i32* %45, i64 3
%60 = load i32, i32* %54
%61 = shl i32 %60, 5
%62 = ashr i32 %60, 27
%63 = or i32 %61, %62
%64 = getelementptr inbounds i32, i32* %45, i64 4
%65 = load i32, i32* %59
%66 = xor i32 %65, %58
%67 = xor i32 %66, %63
%68 = mul nsw i32 %67, 709607
%69 = add i64 %47, -16
%70 = add i64 %48, 2
%71 = icmp eq i64 %70, %11
br i1 %71, label %12, label %44
72: ; preds = %72, %42
%73 = phi i64 [ 0, %42 ], [ %104, %72 ]
%74 = phi i32 [ %34, %42 ], [ %103, %72 ]
%75 = phi i64 [ 0, %42 ], [ %105, %72 ]
%76 = getelementptr inbounds i8, i8* %38, i64 %73
%77 = load i8, i8* %76
%78 = zext i8 %77 to i32
%79 = xor i32 %74, %78
%80 = or i64 %73, 1
%81 = getelementptr inbounds i8, i8* %38, i64 %80
%82 = load i8, i8* %81
%83 = zext i8 %82 to i32
%84 = trunc i64 %80 to i32
%85 = shl nsw i32 %84, 3
%86 = shl i32 %83, %85
%87 = xor i32 %86, %79
%88 = or i64 %73, 2
%89 = getelementptr inbounds i8, i8* %38, i64 %88
%90 = load i8, i8* %89
%91 = zext i8 %90 to i32
%92 = trunc i64 %88 to i32
%93 = shl nsw i32 %92, 3
%94 = shl i32 %91, %93
%95 = xor i32 %94, %87
%96 = or i64 %73, 3
%97 = getelementptr inbounds i8, i8* %38, i64 %96
%98 = load i8, i8* %97
%99 = zext i8 %98 to i32
%100 = trunc i64 %96 to i32
%101 = shl nsw i32 %100, 3
%102 = shl i32 %99, %101
%103 = xor i32 %102, %95
%104 = add nuw nsw i64 %73, 4
%105 = add i64 %75, 4
%106 = icmp eq i64 %105, %43
br i1 %106, label %107, label %72
107: ; preds = %72, %37
%108 = phi i32 [ undef, %37 ], [ %103, %72 ]
%109 = phi i64 [ 0, %37 ], [ %104, %72 ]
%110 = phi i32 [ %34, %37 ], [ %103, %72 ]
%111 = icmp eq i64 %40, 0
br i1 %111, label %126, label %112
112: ; preds = %107, %112
%113 = phi i64 [ %123, %112 ], [ %109, %107 ]
%114 = phi i32 [ %122, %112 ], [ %110, %107 ]
%115 = phi i64 [ %124, %112 ], [ 0, %107 ]
%116 = getelementptr inbounds i8, i8* %38, i64 %113
%117 = load i8, i8* %116
%118 = zext i8 %117 to i32
%119 = trunc i64 %113 to i32
%120 = shl nsw i32 %119, 3
%121 = shl i32 %118, %120
%122 = xor i32 %121, %114
%123 = add nuw nsw i64 %113, 1
%124 = add i64 %115, 1
%125 = icmp eq i64 %124, %40
br i1 %125, label %126, label %112
126: ; preds = %107, %112, %32
%127 = phi i32 [ %34, %32 ], [ %108, %107 ], [ %122, %112 ]
%128 = mul nsw i32 %127, 709607
%129 = lshr i32 %128, 16
%130 = xor i32 %129, %128
%131 = trunc i32 %130 to i16
ret i16 %131
}