unsigned short hash(unsigned short v) {
  unsigned short h = v;
  for (unsigned int i = 0; i < 16; i++) {
    char v10 = (h >> 10) & 0x1;
    char v12 = (h >> 12) & 0x1;
    char v13 = (h >> 13) & 0x1;
    char v15 = (h >> 15) & 0x1;
    h = (h << 1) | ((((v15 ^ v13) ^ v12) ^ v10) & 0x1);
  }
  return h;
}


x86 assembly (clang, -O0):
<hash>:
push   %rbp
mov    %rsp,%rbp
mov    %di,%ax
mov    %ax,-0x2(%rbp)
mov    -0x2(%rbp),%ax
mov    %ax,-0x4(%rbp)
movl   $0x0,-0x8(%rbp)
cmpl   $0x10,-0x8(%rbp)
jae    118c <hash+0x8c>
movzwl -0x4(%rbp),%eax
sar    $0xa,%eax
and    $0x1,%eax
mov    %al,-0x9(%rbp)
movzwl -0x4(%rbp),%eax
sar    $0xc,%eax
and    $0x1,%eax
mov    %al,-0xa(%rbp)
movzwl -0x4(%rbp),%eax
sar    $0xd,%eax
and    $0x1,%eax
mov    %al,-0xb(%rbp)
movzwl -0x4(%rbp),%eax
sar    $0xf,%eax
and    $0x1,%eax
mov    %al,-0xc(%rbp)
movzwl -0x4(%rbp),%eax
shl    $0x1,%eax
movsbl -0xc(%rbp),%ecx
movsbl -0xb(%rbp),%edx
xor    %edx,%ecx
movsbl -0xa(%rbp),%edx
xor    %edx,%ecx
movsbl -0x9(%rbp),%edx
xor    %edx,%ecx
and    $0x1,%ecx
or     %ecx,%eax
mov    %ax,-0x4(%rbp)
mov    -0x8(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8(%rbp)
jmp    111a <hash+0x1a>
movzwl -0x4(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<hash>:
mov    %edi,%eax
mov    $0x10,%r8d
nopl   0x0(%rax,%rax,1)
movzwl %ax,%edx
mov    %edx,%esi
shr    $0xa,%esi
mov    %edx,%r9d
shr    $0xc,%r9d
mov    %edx,%ecx
shr    $0xd,%ecx
mov    %edx,%edi
shr    $0xf,%edi
xor    %ecx,%edi
xor    %r9d,%esi
xor    %edi,%esi
and    $0x1,%esi
mov    %edx,%ecx
shr    $0x9,%ecx
mov    %edx,%edi
shr    $0xb,%edi
xor    %ecx,%edi
shr    $0xe,%edx
add    %esi,%esi
lea    (%rsi,%rax,4),%eax
xor    %r9d,%edx
xor    %edi,%edx
and    $0x1,%edx
or     %eax,%edx
mov    %edx,%eax
add    $0xfffffffe,%r8d
jne    1110 <hash+0x10>
ret

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

LLVM IR (-O2):
define zeroext i16 @hash(i16 zeroext %0) {
br label %3
2: ; preds = %3
ret i16 %25
3: ; preds = %3, %1
%4 = phi i16 [ %0, %1 ], [ %25, %3 ]
%5 = phi i32 [ 0, %1 ], [ %26, %3 ]
%6 = lshr i16 %4, 10
%7 = lshr i16 %4, 12
%8 = lshr i16 %4, 13
%9 = lshr i16 %4, 15
%10 = shl i16 %4, 1
%11 = xor i16 %9, %8
%12 = xor i16 %11, %7
%13 = xor i16 %12, %6
%14 = and i16 %13, 1
%15 = or i16 %14, %10
%16 = lshr i16 %10, 10
%17 = lshr i16 %10, 12
%18 = lshr i16 %10, 13
%19 = lshr i16 %10, 15
%20 = shl i16 %15, 1
%21 = xor i16 %19, %18
%22 = xor i16 %21, %17
%23 = xor i16 %22, %16
%24 = and i16 %23, 1
%25 = or i16 %24, %20
%26 = add nuw nsw i32 %5, 2
%27 = icmp eq i32 %26, 16
br i1 %27, label %2, label %3
}