unsigned short gf64_mul(unsigned short a, unsigned short b) {
  unsigned short tmp1, tmp2, tmp3, tmp4, tmp5;
  unsigned short c_bit0, c_bit1, c_bit2, c_bit3, c_bit4, c_bit5, c;
  tmp1 = ((a) ^ (a >> 5));
  tmp2 = ((a >> 4) ^ (a >> 5));
  tmp3 = ((a >> 3) ^ (a >> 4));
  tmp4 = ((a >> 2) ^ (a >> 3));
  tmp5 = ((a >> 1) ^ (a >> 2));
  c_bit0 =
      ((a & b) ^ ((a >> 5) & (b >> 1)) ^ ((a >> 4) & (b >> 2)) ^
       ((a >> 3) & (b >> 3)) ^ ((a >> 2) & (b >> 4)) ^ ((a >> 1) & (b >> 5))) &
      0x1;
  c_bit1 = (((a >> 1) & b) ^ (tmp1 & (b >> 1)) ^ (tmp2 & (b >> 2)) ^
            (tmp3 & (b >> 3)) ^ (tmp4 & (b >> 4)) ^ (tmp5 & (b >> 5))) &
           0x1;
  c_bit2 = (((a >> 2) & b) ^ ((a >> 1) & (b >> 1)) ^ (tmp1 & (b >> 2)) ^
            (tmp2 & (b >> 3)) ^ (tmp3 & (b >> 4)) ^ (tmp4 & (b >> 5))) &
           0x1;
  c_bit3 = (((a >> 3) & b) ^ ((a >> 2) & (b >> 1)) ^ ((a >> 1) & (b >> 2)) ^
            (tmp1 & (b >> 3)) ^ (tmp2 & (b >> 4)) ^ (tmp3 & (b >> 5))) &
           0x1;
  c_bit4 = (((a >> 4) & b) ^ ((a >> 3) & (b >> 1)) ^ ((a >> 2) & (b >> 2)) ^
            ((a >> 1) & (b >> 3)) ^ (tmp1 & (b >> 4)) ^ (tmp2 & (b >> 5))) &
           0x1;
  c_bit5 = (((a >> 5) & b) ^ ((a >> 4) & (b >> 1)) ^ ((a >> 3) & (b >> 2)) ^
            ((a >> 2) & (b >> 3)) ^ ((a >> 1) & (b >> 4)) ^ (tmp1 & (b >> 5))) &
           0x1;
  c = c_bit0 | (c_bit1 << 1) | (c_bit2 << 2) | (c_bit3 << 3) | (c_bit4 << 4) |
      (c_bit5 << 5);
  return c;
}


x86 assembly (clang, -O0):
<gf64_mul>:
push   %rbp
mov    %rsp,%rbp
mov    %si,%ax
mov    %di,%cx
mov    %cx,-0x2(%rbp)
mov    %ax,-0x4(%rbp)
movzwl -0x2(%rbp),%eax
movzwl -0x2(%rbp),%ecx
sar    $0x5,%ecx
xor    %ecx,%eax
mov    %ax,-0x6(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x4,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x5,%ecx
xor    %ecx,%eax
mov    %ax,-0x8(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x3,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x4,%ecx
xor    %ecx,%eax
mov    %ax,-0xa(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x2,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x3,%ecx
xor    %ecx,%eax
mov    %ax,-0xc(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x1,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x2,%ecx
xor    %ecx,%eax
mov    %ax,-0xe(%rbp)
movzwl -0x2(%rbp),%eax
movzwl -0x4(%rbp),%ecx
and    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x5,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x1,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x4,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x2,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x3,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x3,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x2,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x4,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x1,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x5,%edx
and    %edx,%ecx
xor    %ecx,%eax
and    $0x1,%eax
mov    %ax,-0x10(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x1,%eax
movzwl -0x4(%rbp),%ecx
and    %ecx,%eax
movzwl -0x6(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x1,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x8(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x2,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0xa(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x3,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0xc(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x4,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0xe(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x5,%edx
and    %edx,%ecx
xor    %ecx,%eax
and    $0x1,%eax
mov    %ax,-0x12(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x2,%eax
movzwl -0x4(%rbp),%ecx
and    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x1,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x1,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x6(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x2,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x8(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x3,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0xa(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x4,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0xc(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x5,%edx
and    %edx,%ecx
xor    %ecx,%eax
and    $0x1,%eax
mov    %ax,-0x14(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x3,%eax
movzwl -0x4(%rbp),%ecx
and    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x2,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x1,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x1,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x2,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x6(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x3,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x8(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x4,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0xa(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x5,%edx
and    %edx,%ecx
xor    %ecx,%eax
and    $0x1,%eax
mov    %ax,-0x16(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x4,%eax
movzwl -0x4(%rbp),%ecx
and    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x3,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x1,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x2,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x2,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x1,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x3,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x6(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x4,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x8(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x5,%edx
and    %edx,%ecx
xor    %ecx,%eax
and    $0x1,%eax
mov    %ax,-0x18(%rbp)
movzwl -0x2(%rbp),%eax
sar    $0x5,%eax
movzwl -0x4(%rbp),%ecx
and    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x4,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x1,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x3,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x2,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x2,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x3,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x2(%rbp),%ecx
sar    $0x1,%ecx
movzwl -0x4(%rbp),%edx
sar    $0x4,%edx
and    %edx,%ecx
xor    %ecx,%eax
movzwl -0x6(%rbp),%ecx
movzwl -0x4(%rbp),%edx
sar    $0x5,%edx
and    %edx,%ecx
xor    %ecx,%eax
and    $0x1,%eax
mov    %ax,-0x1a(%rbp)
movzwl -0x10(%rbp),%eax
movzwl -0x12(%rbp),%ecx
shl    $0x1,%ecx
or     %ecx,%eax
movzwl -0x14(%rbp),%ecx
shl    $0x2,%ecx
or     %ecx,%eax
movzwl -0x16(%rbp),%ecx
shl    $0x3,%ecx
or     %ecx,%eax
movzwl -0x18(%rbp),%ecx
shl    $0x4,%ecx
or     %ecx,%eax
movzwl -0x1a(%rbp),%ecx
shl    $0x5,%ecx
or     %ecx,%eax
mov    %ax,-0x1c(%rbp)
movzwl -0x1c(%rbp),%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<gf64_mul>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %esi,%ecx
mov    %edi,%eax
shr    $0x5,%eax
mov    %eax,%esi
mov    %eax,%edx
xor    %edi,%esi
mov    %esi,-0x4(%rsp)
mov    %edi,%r11d
shr    $0x4,%r11d
mov    %edi,%eax
shr    $0x3,%eax
mov    %eax,%esi
mov    %edi,%r13d
shr    $0x2,%r13d
mov    %ecx,%eax
and    %edi,%eax
shr    %edi
mov    %edi,%r8d
mov    %ecx,%ebx
shr    %ebx
mov    %ebx,%ebp
and    %edx,%ebp
xor    %eax,%ebp
mov    %ecx,%eax
shr    $0x2,%eax
mov    %eax,-0x30(%rsp)
and    %r11d,%eax
mov    %edi,%r10d
and    %ecx,%r10d
mov    %r13d,%edi
and    %ecx,%edi
mov    %edi,-0x8(%rsp)
mov    %ecx,%r14d
shr    $0x3,%r14d
mov    %r14d,%edi
and    %esi,%edi
xor    %eax,%edi
mov    %esi,%eax
mov    %esi,-0x2c(%rsp)
and    %ecx,%eax
mov    %eax,-0xc(%rsp)
xor    %ebp,%edi
mov    %r11d,%eax
and    %ecx,%eax
mov    %eax,-0x10(%rsp)
mov    %esi,%ebp
xor    %r11d,%ebp
mov    %ebx,-0x18(%rsp)
mov    %ebx,%r12d
mov    %ebx,%r15d
mov    %ebx,-0x14(%rsp)
and    %r11d,%ebx
mov    %ebx,-0x1c(%rsp)
xor    %edx,%r11d
and    %ecx,%edx
mov    %edx,-0x20(%rsp)
mov    %ecx,%edx
shr    $0x4,%edx
mov    %edx,%eax
and    %r13d,%eax
shr    $0x5,%ecx
mov    %ecx,%r9d
mov    %r8d,-0x34(%rsp)
and    %r8d,%r9d
xor    %eax,%r9d
xor    %edi,%r9d
mov    %r11d,%edi
mov    -0x30(%rsp),%eax
and    %eax,%edi
xor    %r10d,%edi
mov    %r8d,%esi
xor    %r13d,%esi
mov    %ebp,%r10d
and    %r14d,%r10d
mov    %r11d,%r8d
and    %r14d,%r8d
and    %r13d,%r15d
mov    %eax,%ebx
and    %r13d,%ebx
mov    %ebx,-0x24(%rsp)
mov    %r14d,-0x28(%rsp)
mov    %r14d,%ebx
and    %r13d,%r14d
xor    -0x2c(%rsp),%r13d
mov    %r13d,%eax
and    %edx,%eax
xor    %r10d,%eax
xor    %edi,%eax
mov    -0x4(%rsp),%r10d
mov    -0x18(%rsp),%edi
and    %r10d,%edi
and    %ecx,%esi
xor    %edi,%esi
xor    %eax,%esi
and    -0x34(%rsp),%r12d
xor    -0x8(%rsp),%r12d
xor    %r12d,%r8d
mov    %ebp,%eax
and    %edx,%eax
and    %ecx,%r13d
xor    %eax,%r13d
xor    %r8d,%r13d
mov    -0x30(%rsp),%edi
mov    %edi,%eax
and    %r10d,%eax
xor    %eax,%r13d
xor    -0xc(%rsp),%r15d
mov    %edi,%eax
mov    %edi,%r12d
mov    -0x34(%rsp),%r8d
and    %r8d,%eax
xor    %r15d,%eax
mov    %r11d,%edi
and    %edx,%edi
and    %ecx,%ebp
xor    %edi,%ebp
xor    %eax,%ebp
mov    -0x28(%rsp),%eax
and    %r10d,%eax
xor    %eax,%ebp
mov    -0x2c(%rsp),%edi
mov    -0x14(%rsp),%eax
and    %edi,%eax
xor    -0x10(%rsp),%eax
and    %r8d,%ebx
xor    -0x24(%rsp),%ebx
xor    %eax,%ebx
mov    %edx,%eax
and    %r10d,%eax
and    %ecx,%r11d
xor    %eax,%r11d
xor    %ebx,%r11d
mov    -0x1c(%rsp),%eax
xor    -0x20(%rsp),%eax
and    %edi,%r12d
xor    %r12d,%r14d
xor    %eax,%r14d
and    %r8d,%edx
and    %r10d,%ecx
xor    %edx,%ecx
xor    %r14d,%ecx
and    $0x1,%r9d
and    $0x1,%ebp
lea    (%r9,%rbp,8),%eax
shl    $0x4,%r11d
and    $0x10,%r11d
or     %r11d,%eax
shl    $0x5,%ecx
and    $0x20,%ecx
or     %ecx,%eax
and    $0x1,%r13d
lea    (%rax,%r13,4),%eax
and    $0x1,%esi
lea    (%rax,%rsi,2),%eax
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define zeroext i16 @gf64_mul(i16 zeroext %0, i16 zeroext %1) {
%3 = alloca i16
%4 = alloca i16
%5 = alloca i16
%6 = alloca i16
%7 = alloca i16
%8 = alloca i16
%9 = alloca i16
%10 = alloca i16
%11 = alloca i16
%12 = alloca i16
%13 = alloca i16
%14 = alloca i16
%15 = alloca i16
%16 = alloca i16
store i16 %0, i16* %3
store i16 %1, i16* %4
%17 = load i16, i16* %3
%18 = zext i16 %17 to i32
%19 = load i16, i16* %3
%20 = zext i16 %19 to i32
%21 = ashr i32 %20, 5
%22 = xor i32 %18, %21
%23 = trunc i32 %22 to i16
store i16 %23, i16* %5
%24 = load i16, i16* %3
%25 = zext i16 %24 to i32
%26 = ashr i32 %25, 4
%27 = load i16, i16* %3
%28 = zext i16 %27 to i32
%29 = ashr i32 %28, 5
%30 = xor i32 %26, %29
%31 = trunc i32 %30 to i16
store i16 %31, i16* %6
%32 = load i16, i16* %3
%33 = zext i16 %32 to i32
%34 = ashr i32 %33, 3
%35 = load i16, i16* %3
%36 = zext i16 %35 to i32
%37 = ashr i32 %36, 4
%38 = xor i32 %34, %37
%39 = trunc i32 %38 to i16
store i16 %39, i16* %7
%40 = load i16, i16* %3
%41 = zext i16 %40 to i32
%42 = ashr i32 %41, 2
%43 = load i16, i16* %3
%44 = zext i16 %43 to i32
%45 = ashr i32 %44, 3
%46 = xor i32 %42, %45
%47 = trunc i32 %46 to i16
store i16 %47, i16* %8
%48 = load i16, i16* %3
%49 = zext i16 %48 to i32
%50 = ashr i32 %49, 1
%51 = load i16, i16* %3
%52 = zext i16 %51 to i32
%53 = ashr i32 %52, 2
%54 = xor i32 %50, %53
%55 = trunc i32 %54 to i16
store i16 %55, i16* %9
%56 = load i16, i16* %3
%57 = zext i16 %56 to i32
%58 = load i16, i16* %4
%59 = zext i16 %58 to i32
%60 = and i32 %57, %59
%61 = load i16, i16* %3
%62 = zext i16 %61 to i32
%63 = ashr i32 %62, 5
%64 = load i16, i16* %4
%65 = zext i16 %64 to i32
%66 = ashr i32 %65, 1
%67 = and i32 %63, %66
%68 = xor i32 %60, %67
%69 = load i16, i16* %3
%70 = zext i16 %69 to i32
%71 = ashr i32 %70, 4
%72 = load i16, i16* %4
%73 = zext i16 %72 to i32
%74 = ashr i32 %73, 2
%75 = and i32 %71, %74
%76 = xor i32 %68, %75
%77 = load i16, i16* %3
%78 = zext i16 %77 to i32
%79 = ashr i32 %78, 3
%80 = load i16, i16* %4
%81 = zext i16 %80 to i32
%82 = ashr i32 %81, 3
%83 = and i32 %79, %82
%84 = xor i32 %76, %83
%85 = load i16, i16* %3
%86 = zext i16 %85 to i32
%87 = ashr i32 %86, 2
%88 = load i16, i16* %4
%89 = zext i16 %88 to i32
%90 = ashr i32 %89, 4
%91 = and i32 %87, %90
%92 = xor i32 %84, %91
%93 = load i16, i16* %3
%94 = zext i16 %93 to i32
%95 = ashr i32 %94, 1
%96 = load i16, i16* %4
%97 = zext i16 %96 to i32
%98 = ashr i32 %97, 5
%99 = and i32 %95, %98
%100 = xor i32 %92, %99
%101 = and i32 %100, 1
%102 = trunc i32 %101 to i16
store i16 %102, i16* %10
%103 = load i16, i16* %3
%104 = zext i16 %103 to i32
%105 = ashr i32 %104, 1
%106 = load i16, i16* %4
%107 = zext i16 %106 to i32
%108 = and i32 %105, %107
%109 = load i16, i16* %5
%110 = zext i16 %109 to i32
%111 = load i16, i16* %4
%112 = zext i16 %111 to i32
%113 = ashr i32 %112, 1
%114 = and i32 %110, %113
%115 = xor i32 %108, %114
%116 = load i16, i16* %6
%117 = zext i16 %116 to i32
%118 = load i16, i16* %4
%119 = zext i16 %118 to i32
%120 = ashr i32 %119, 2
%121 = and i32 %117, %120
%122 = xor i32 %115, %121
%123 = load i16, i16* %7
%124 = zext i16 %123 to i32
%125 = load i16, i16* %4
%126 = zext i16 %125 to i32
%127 = ashr i32 %126, 3
%128 = and i32 %124, %127
%129 = xor i32 %122, %128
%130 = load i16, i16* %8
%131 = zext i16 %130 to i32
%132 = load i16, i16* %4
%133 = zext i16 %132 to i32
%134 = ashr i32 %133, 4
%135 = and i32 %131, %134
%136 = xor i32 %129, %135
%137 = load i16, i16* %9
%138 = zext i16 %137 to i32
%139 = load i16, i16* %4
%140 = zext i16 %139 to i32
%141 = ashr i32 %140, 5
%142 = and i32 %138, %141
%143 = xor i32 %136, %142
%144 = and i32 %143, 1
%145 = trunc i32 %144 to i16
store i16 %145, i16* %11
%146 = load i16, i16* %3
%147 = zext i16 %146 to i32
%148 = ashr i32 %147, 2
%149 = load i16, i16* %4
%150 = zext i16 %149 to i32
%151 = and i32 %148, %150
%152 = load i16, i16* %3
%153 = zext i16 %152 to i32
%154 = ashr i32 %153, 1
%155 = load i16, i16* %4
%156 = zext i16 %155 to i32
%157 = ashr i32 %156, 1
%158 = and i32 %154, %157
%159 = xor i32 %151, %158
%160 = load i16, i16* %5
%161 = zext i16 %160 to i32
%162 = load i16, i16* %4
%163 = zext i16 %162 to i32
%164 = ashr i32 %163, 2
%165 = and i32 %161, %164
%166 = xor i32 %159, %165
%167 = load i16, i16* %6
%168 = zext i16 %167 to i32
%169 = load i16, i16* %4
%170 = zext i16 %169 to i32
%171 = ashr i32 %170, 3
%172 = and i32 %168, %171
%173 = xor i32 %166, %172
%174 = load i16, i16* %7
%175 = zext i16 %174 to i32
%176 = load i16, i16* %4
%177 = zext i16 %176 to i32
%178 = ashr i32 %177, 4
%179 = and i32 %175, %178
%180 = xor i32 %173, %179
%181 = load i16, i16* %8
%182 = zext i16 %181 to i32
%183 = load i16, i16* %4
%184 = zext i16 %183 to i32
%185 = ashr i32 %184, 5
%186 = and i32 %182, %185
%187 = xor i32 %180, %186
%188 = and i32 %187, 1
%189 = trunc i32 %188 to i16
store i16 %189, i16* %12
%190 = load i16, i16* %3
%191 = zext i16 %190 to i32
%192 = ashr i32 %191, 3
%193 = load i16, i16* %4
%194 = zext i16 %193 to i32
%195 = and i32 %192, %194
%196 = load i16, i16* %3
%197 = zext i16 %196 to i32
%198 = ashr i32 %197, 2
%199 = load i16, i16* %4
%200 = zext i16 %199 to i32
%201 = ashr i32 %200, 1
%202 = and i32 %198, %201
%203 = xor i32 %195, %202
%204 = load i16, i16* %3
%205 = zext i16 %204 to i32
%206 = ashr i32 %205, 1
%207 = load i16, i16* %4
%208 = zext i16 %207 to i32
%209 = ashr i32 %208, 2
%210 = and i32 %206, %209
%211 = xor i32 %203, %210
%212 = load i16, i16* %5
%213 = zext i16 %212 to i32
%214 = load i16, i16* %4
%215 = zext i16 %214 to i32
%216 = ashr i32 %215, 3
%217 = and i32 %213, %216
%218 = xor i32 %211, %217
%219 = load i16, i16* %6
%220 = zext i16 %219 to i32
%221 = load i16, i16* %4
%222 = zext i16 %221 to i32
%223 = ashr i32 %222, 4
%224 = and i32 %220, %223
%225 = xor i32 %218, %224
%226 = load i16, i16* %7
%227 = zext i16 %226 to i32
%228 = load i16, i16* %4
%229 = zext i16 %228 to i32
%230 = ashr i32 %229, 5
%231 = and i32 %227, %230
%232 = xor i32 %225, %231
%233 = and i32 %232, 1
%234 = trunc i32 %233 to i16
store i16 %234, i16* %13
%235 = load i16, i16* %3
%236 = zext i16 %235 to i32
%237 = ashr i32 %236, 4
%238 = load i16, i16* %4
%239 = zext i16 %238 to i32
%240 = and i32 %237, %239
%241 = load i16, i16* %3
%242 = zext i16 %241 to i32
%243 = ashr i32 %242, 3
%244 = load i16, i16* %4
%245 = zext i16 %244 to i32
%246 = ashr i32 %245, 1
%247 = and i32 %243, %246
%248 = xor i32 %240, %247
%249 = load i16, i16* %3
%250 = zext i16 %249 to i32
%251 = ashr i32 %250, 2
%252 = load i16, i16* %4
%253 = zext i16 %252 to i32
%254 = ashr i32 %253, 2
%255 = and i32 %251, %254
%256 = xor i32 %248, %255
%257 = load i16, i16* %3
%258 = zext i16 %257 to i32
%259 = ashr i32 %258, 1
%260 = load i16, i16* %4
%261 = zext i16 %260 to i32
%262 = ashr i32 %261, 3
%263 = and i32 %259, %262
%264 = xor i32 %256, %263
%265 = load i16, i16* %5
%266 = zext i16 %265 to i32
%267 = load i16, i16* %4
%268 = zext i16 %267 to i32
%269 = ashr i32 %268, 4
%270 = and i32 %266, %269
%271 = xor i32 %264, %270
%272 = load i16, i16* %6
%273 = zext i16 %272 to i32
%274 = load i16, i16* %4
%275 = zext i16 %274 to i32
%276 = ashr i32 %275, 5
%277 = and i32 %273, %276
%278 = xor i32 %271, %277
%279 = and i32 %278, 1
%280 = trunc i32 %279 to i16
store i16 %280, i16* %14
%281 = load i16, i16* %3
%282 = zext i16 %281 to i32
%283 = ashr i32 %282, 5
%284 = load i16, i16* %4
%285 = zext i16 %284 to i32
%286 = and i32 %283, %285
%287 = load i16, i16* %3
%288 = zext i16 %287 to i32
%289 = ashr i32 %288, 4
%290 = load i16, i16* %4
%291 = zext i16 %290 to i32
%292 = ashr i32 %291, 1
%293 = and i32 %289, %292
%294 = xor i32 %286, %293
%295 = load i16, i16* %3
%296 = zext i16 %295 to i32
%297 = ashr i32 %296, 3
%298 = load i16, i16* %4
%299 = zext i16 %298 to i32
%300 = ashr i32 %299, 2
%301 = and i32 %297, %300
%302 = xor i32 %294, %301
%303 = load i16, i16* %3
%304 = zext i16 %303 to i32
%305 = ashr i32 %304, 2
%306 = load i16, i16* %4
%307 = zext i16 %306 to i32
%308 = ashr i32 %307, 3
%309 = and i32 %305, %308
%310 = xor i32 %302, %309
%311 = load i16, i16* %3
%312 = zext i16 %311 to i32
%313 = ashr i32 %312, 1
%314 = load i16, i16* %4
%315 = zext i16 %314 to i32
%316 = ashr i32 %315, 4
%317 = and i32 %313, %316
%318 = xor i32 %310, %317
%319 = load i16, i16* %5
%320 = zext i16 %319 to i32
%321 = load i16, i16* %4
%322 = zext i16 %321 to i32
%323 = ashr i32 %322, 5
%324 = and i32 %320, %323
%325 = xor i32 %318, %324
%326 = and i32 %325, 1
%327 = trunc i32 %326 to i16
store i16 %327, i16* %15
%328 = load i16, i16* %10
%329 = zext i16 %328 to i32
%330 = load i16, i16* %11
%331 = zext i16 %330 to i32
%332 = shl i32 %331, 1
%333 = or i32 %329, %332
%334 = load i16, i16* %12
%335 = zext i16 %334 to i32
%336 = shl i32 %335, 2
%337 = or i32 %333, %336
%338 = load i16, i16* %13
%339 = zext i16 %338 to i32
%340 = shl i32 %339, 3
%341 = or i32 %337, %340
%342 = load i16, i16* %14
%343 = zext i16 %342 to i32
%344 = shl i32 %343, 4
%345 = or i32 %341, %344
%346 = load i16, i16* %15
%347 = zext i16 %346 to i32
%348 = shl i32 %347, 5
%349 = or i32 %345, %348
%350 = trunc i32 %349 to i16
store i16 %350, i16* %16
%351 = load i16, i16* %16
ret i16 %351
}

LLVM IR (-O2):
define zeroext i16 @gf64_mul(i16 zeroext %0, i16 zeroext %1) {
%3 = zext i16 %0 to i32
%4 = lshr i32 %3, 5
%5 = trunc i32 %4 to i16
%6 = xor i16 %5, %0
%7 = lshr i32 %3, 4
%8 = xor i32 %7, %4
%9 = lshr i32 %3, 3
%10 = xor i32 %9, %7
%11 = lshr i32 %3, 2
%12 = xor i32 %11, %9
%13 = lshr i32 %3, 1
%14 = xor i32 %13, %11
%15 = zext i16 %1 to i32
%16 = and i16 %1, %0
%17 = zext i16 %16 to i32
%18 = lshr i32 %15, 1
%19 = and i32 %18, %4
%20 = xor i32 %19, %17
%21 = lshr i32 %15, 2
%22 = and i32 %21, %7
%23 = xor i32 %20, %22
%24 = lshr i32 %15, 3
%25 = and i32 %24, %9
%26 = xor i32 %23, %25
%27 = lshr i32 %15, 4
%28 = and i32 %27, %11
%29 = xor i32 %26, %28
%30 = lshr i32 %15, 5
%31 = and i32 %30, %13
%32 = xor i32 %29, %31
%33 = and i32 %32, 1
%34 = and i32 %13, %15
%35 = zext i16 %6 to i32
%36 = and i32 %18, %35
%37 = and i32 %8, %21
%38 = and i32 %10, %24
%39 = and i32 %12, %27
%40 = and i32 %14, %30
%41 = xor i32 %37, %34
%42 = xor i32 %41, %38
%43 = xor i32 %42, %39
%44 = xor i32 %43, %40
%45 = xor i32 %44, %36
%46 = and i32 %11, %15
%47 = and i32 %18, %13
%48 = xor i32 %47, %46
%49 = and i32 %21, %35
%50 = and i32 %8, %24
%51 = and i32 %10, %27
%52 = and i32 %12, %30
%53 = xor i32 %48, %50
%54 = xor i32 %53, %51
%55 = xor i32 %54, %52
%56 = xor i32 %55, %49
%57 = and i32 %9, %15
%58 = and i32 %18, %11
%59 = xor i32 %58, %57
%60 = and i32 %21, %13
%61 = xor i32 %59, %60
%62 = and i32 %24, %35
%63 = and i32 %8, %27
%64 = and i32 %10, %30
%65 = xor i32 %61, %63
%66 = xor i32 %65, %64
%67 = xor i32 %66, %62
%68 = and i32 %7, %15
%69 = and i32 %18, %9
%70 = xor i32 %69, %68
%71 = and i32 %21, %11
%72 = xor i32 %70, %71
%73 = and i32 %24, %13
%74 = xor i32 %72, %73
%75 = and i32 %27, %35
%76 = and i32 %8, %30
%77 = xor i32 %74, %76
%78 = xor i32 %77, %75
%79 = and i32 %4, %15
%80 = and i32 %18, %7
%81 = xor i32 %80, %79
%82 = and i32 %21, %9
%83 = xor i32 %81, %82
%84 = and i32 %24, %11
%85 = xor i32 %83, %84
%86 = and i32 %27, %13
%87 = xor i32 %85, %86
%88 = and i32 %30, %35
%89 = xor i32 %87, %88
%90 = shl i32 %45, 1
%91 = and i32 %90, 2
%92 = shl i32 %56, 2
%93 = and i32 %92, 4
%94 = shl i32 %67, 3
%95 = and i32 %94, 8
%96 = shl i32 %78, 4
%97 = and i32 %96, 16
%98 = shl i32 %89, 5
%99 = and i32 %98, 32
%100 = or i32 %95, %33
%101 = or i32 %100, %97
%102 = or i32 %101, %99
%103 = or i32 %102, %93
%104 = or i32 %103, %91
%105 = trunc i32 %104 to i16
ret i16 %105
}