unsigned long nibble_sort_word(unsigned long arg) {
  static const unsigned long tab[17] = {
      0x0000000000000000UL, 0x0000000000000001UL, 0x0000000000000011UL,
      0x0000000000000111UL, 0x0000000000001111UL, 0x0000000000011111UL,
      0x0000000000111111UL, 0x0000000001111111UL, 0x0000000011111111UL,
      0x0000000111111111UL, 0x0000001111111111UL, 0x0000011111111111UL,
      0x0000111111111111UL, 0x0001111111111111UL, 0x0011111111111111UL,
      0x0111111111111111UL, 0x1111111111111111UL,
  };
  char counts[16] = {};
  for (int i = 0; i < 16; ++i) {
    counts[arg & 15]++;
    arg >>= 4;
  }
  unsigned long result = 0;
  for (int i = 15; i >= 0; --i) {
    int c = counts[i];
    result <<= 4 * c;
    result |= i * tab[c];
  }
  return result;
}


x86 assembly (clang, -O0):
<nibble_sort_word>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
lea    -0x20(%rbp),%rdi
xor    %esi,%esi
mov    $0x10,%edx
call   1030 <memset@plt>
movl   $0x0,-0x24(%rbp)
cmpl   $0x10,-0x24(%rbp)
jge    116a <nibble_sort_word+0x5a>
mov    -0x8(%rbp),%rax
and    $0xf,%rax
mov    -0x20(%rbp,%rax,1),%cl
add    $0x1,%cl
mov    %cl,-0x20(%rbp,%rax,1)
mov    -0x8(%rbp),%rax
shr    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    1133 <nibble_sort_word+0x23>
movq   $0x0,-0x30(%rbp)
movl   $0xf,-0x34(%rbp)
cmpl   $0x0,-0x34(%rbp)
jl     11cc <nibble_sort_word+0xbc>
movslq -0x34(%rbp),%rax
movsbl -0x20(%rbp,%rax,1),%eax
mov    %eax,-0x38(%rbp)
mov    -0x38(%rbp),%ecx
shl    $0x2,%ecx
mov    -0x30(%rbp),%rax
mov    %ecx,%ecx
shl    %cl,%rax
mov    %rax,-0x30(%rbp)
movslq -0x34(%rbp),%rax
movslq -0x38(%rbp),%rdx
lea    0xe4f(%rip),%rcx
imul   (%rcx,%rdx,8),%rax
or     -0x30(%rbp),%rax
mov    %rax,-0x30(%rbp)
mov    -0x34(%rbp),%eax
add    $0xffffffff,%eax
mov    %eax,-0x34(%rbp)
jmp    1179 <nibble_sort_word+0x69>
mov    -0x30(%rbp),%rax
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<nibble_sort_word>:
xorps  %xmm0,%xmm0
movaps %xmm0,-0x18(%rsp)
mov    %edi,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0x4,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0x8,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0xc,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0x10,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0x14,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0x18,%eax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %edi,%eax
shr    $0x1c,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x20,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x24,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x28,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x2c,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x30,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x34,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
mov    %rdi,%rax
shr    $0x38,%rax
and    $0xf,%eax
addb   $0x1,-0x18(%rsp,%rax,1)
shr    $0x3c,%rdi
addb   $0x1,-0x18(%rsp,%rdi,1)
movsbq -0x9(%rsp),%rax
lea    0xe17(%rip),%rdx
mov    (%rdx,%rax,8),%rax
lea    (%rax,%rax,4),%rax
lea    (%rax,%rax,2),%rax
movsbl -0xa(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
mov    (%rdx,%rsi,8),%rcx
mov    %rcx,%rsi
shl    $0x4,%rsi
sub    %rcx,%rsi
sub    %rcx,%rsi
or     %rax,%rsi
movsbl -0xb(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rsi
mov    (%rdx,%rax,8),%rax
lea    (%rax,%rax,2),%rcx
lea    (%rax,%rcx,4),%rax
or     %rsi,%rax
movsbl -0xc(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
mov    (%rdx,%rsi,8),%rcx
shl    $0x2,%rcx
lea    (%rcx,%rcx,2),%rsi
or     %rax,%rsi
movsbl -0xd(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rsi
mov    (%rdx,%rax,8),%rax
lea    (%rax,%rax,4),%rcx
lea    (%rax,%rcx,2),%rax
or     %rsi,%rax
movsbl -0xe(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
mov    (%rdx,%rsi,8),%rcx
add    %rcx,%rcx
lea    (%rcx,%rcx,4),%rsi
or     %rax,%rsi
movsbl -0xf(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rsi
mov    (%rdx,%rax,8),%rax
lea    (%rax,%rax,8),%rax
or     %rsi,%rax
movsbl -0x10(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
mov    (%rdx,%rsi,8),%rsi
shl    $0x3,%rsi
or     %rax,%rsi
movsbl -0x11(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rsi
mov    (%rdx,%rax,8),%rax
lea    0x0(,%rax,8),%rdi
sub    %rax,%rdi
or     %rsi,%rdi
movsbl -0x12(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rdi
mov    (%rdx,%rax,8),%rax
add    %rax,%rax
lea    (%rax,%rax,2),%rax
or     %rdi,%rax
movsbl -0x13(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
mov    (%rdx,%rsi,8),%rcx
lea    (%rcx,%rcx,4),%rsi
or     %rax,%rsi
movsbl -0x14(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rsi
mov    (%rdx,%rax,8),%rax
shl    $0x2,%rax
or     %rsi,%rax
movsbl -0x15(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
mov    (%rdx,%rsi,8),%rcx
lea    (%rcx,%rcx,2),%rsi
or     %rax,%rsi
movsbl -0x16(%rsp),%eax
cltq
lea    0x0(,%rax,4),%ecx
shl    %cl,%rsi
mov    (%rdx,%rax,8),%rax
add    %rax,%rax
or     %rsi,%rax
movsbl -0x17(%rsp),%ecx
movslq %ecx,%rsi
lea    0x0(,%rsi,4),%ecx
shl    %cl,%rax
or     (%rdx,%rsi,8),%rax
mov    -0x18(%rsp),%cl
shl    $0x2,%cl
shl    %cl,%rax
ret

LLVM IR (-O0):
@nibble_sort_word.tab = internal constant [17 x i64] [i64 0, i64 1, i64 17, i64 273, i64 4369, i64 69905, i64 1118481, i64 17895697, i64 286331153, i64 4581298449, i64 73300775185, i64 1172812402961, i64 18764998447377, i64 300239975158033, i64 4803839602528529, i64 76861433640456465, i64 1229782938247303441]
define i64 @nibble_sort_word(i64 %0) {
%2 = alloca i64
%3 = alloca [16 x i8]
%4 = alloca i32
%5 = alloca i64
%6 = alloca i32
%7 = alloca i32
store i64 %0, i64* %2
%8 = bitcast [16 x i8]* %3 to i8*
store i32 0, i32* %4
br label %9
9: ; preds = %20, %1
%10 = load i32, i32* %4
%11 = icmp slt i32 %10, 16
br i1 %11, label %12, label %23
12: ; preds = %9
%13 = load i64, i64* %2
%14 = and i64 %13, 15
%15 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 %14
%16 = load i8, i8* %15
%17 = add i8 %16, 1
store i8 %17, i8* %15
%18 = load i64, i64* %2
%19 = lshr i64 %18, 4
store i64 %19, i64* %2
br label %20
20: ; preds = %12
%21 = load i32, i32* %4
%22 = add nsw i32 %21, 1
store i32 %22, i32* %4
br label %9
23: ; preds = %9
store i64 0, i64* %5
store i32 15, i32* %6
br label %24
24: ; preds = %47, %23
%25 = load i32, i32* %6
%26 = icmp sge i32 %25, 0
br i1 %26, label %27, label %50
27: ; preds = %24
%28 = load i32, i32* %6
%29 = sext i32 %28 to i64
%30 = getelementptr inbounds [16 x i8], [16 x i8]* %3, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = sext i8 %31 to i32
store i32 %32, i32* %7
%33 = load i32, i32* %7
%34 = mul nsw i32 4, %33
%35 = load i64, i64* %5
%36 = zext i32 %34 to i64
%37 = shl i64 %35, %36
store i64 %37, i64* %5
%38 = load i32, i32* %6
%39 = sext i32 %38 to i64
%40 = load i32, i32* %7
%41 = sext i32 %40 to i64
%42 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %41
%43 = load i64, i64* %42
%44 = mul i64 %39, %43
%45 = load i64, i64* %5
%46 = or i64 %45, %44
store i64 %46, i64* %5
br label %47
47: ; preds = %27
%48 = load i32, i32* %6
%49 = add nsw i32 %48, -1
store i32 %49, i32* %6
br label %24
50: ; preds = %24
%51 = load i64, i64* %5
ret i64 %51
}

LLVM IR (-O2):
@nibble_sort_word.tab = internal unnamed_addr constant [17 x i64] [i64 0, i64 1, i64 17, i64 273, i64 4369, i64 69905, i64 1118481, i64 17895697, i64 286331153, i64 4581298449, i64 73300775185, i64 1172812402961, i64 18764998447377, i64 300239975158033, i64 4803839602528529, i64 76861433640456465, i64 1229782938247303441]
define i64 @nibble_sort_word(i64 %0) {
%2 = alloca [16 x i8]
%3 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 0
%4 = and i64 %0, 15
%5 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %4
%6 = load i8, i8* %5
%7 = add i8 %6, 1
store i8 %7, i8* %5
%8 = lshr i64 %0, 4
%9 = and i64 %8, 15
%10 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %9
%11 = load i8, i8* %10
%12 = add i8 %11, 1
store i8 %12, i8* %10
%13 = lshr i64 %0, 8
%14 = and i64 %13, 15
%15 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %14
%16 = load i8, i8* %15
%17 = add i8 %16, 1
store i8 %17, i8* %15
%18 = lshr i64 %0, 12
%19 = and i64 %18, 15
%20 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %19
%21 = load i8, i8* %20
%22 = add i8 %21, 1
store i8 %22, i8* %20
%23 = lshr i64 %0, 16
%24 = and i64 %23, 15
%25 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %24
%26 = load i8, i8* %25
%27 = add i8 %26, 1
store i8 %27, i8* %25
%28 = lshr i64 %0, 20
%29 = and i64 %28, 15
%30 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %29
%31 = load i8, i8* %30
%32 = add i8 %31, 1
store i8 %32, i8* %30
%33 = lshr i64 %0, 24
%34 = and i64 %33, 15
%35 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %34
%36 = load i8, i8* %35
%37 = add i8 %36, 1
store i8 %37, i8* %35
%38 = lshr i64 %0, 28
%39 = and i64 %38, 15
%40 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %39
%41 = load i8, i8* %40
%42 = add i8 %41, 1
store i8 %42, i8* %40
%43 = lshr i64 %0, 32
%44 = and i64 %43, 15
%45 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %44
%46 = load i8, i8* %45
%47 = add i8 %46, 1
store i8 %47, i8* %45
%48 = lshr i64 %0, 36
%49 = and i64 %48, 15
%50 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %49
%51 = load i8, i8* %50
%52 = add i8 %51, 1
store i8 %52, i8* %50
%53 = lshr i64 %0, 40
%54 = and i64 %53, 15
%55 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %54
%56 = load i8, i8* %55
%57 = add i8 %56, 1
store i8 %57, i8* %55
%58 = lshr i64 %0, 44
%59 = and i64 %58, 15
%60 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %59
%61 = load i8, i8* %60
%62 = add i8 %61, 1
store i8 %62, i8* %60
%63 = lshr i64 %0, 48
%64 = and i64 %63, 15
%65 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %64
%66 = load i8, i8* %65
%67 = add i8 %66, 1
store i8 %67, i8* %65
%68 = lshr i64 %0, 52
%69 = and i64 %68, 15
%70 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %69
%71 = load i8, i8* %70
%72 = add i8 %71, 1
store i8 %72, i8* %70
%73 = lshr i64 %0, 56
%74 = and i64 %73, 15
%75 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %74
%76 = load i8, i8* %75
%77 = add i8 %76, 1
store i8 %77, i8* %75
%78 = lshr i64 %0, 60
%79 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 %78
%80 = load i8, i8* %79
%81 = add i8 %80, 1
store i8 %81, i8* %79
%82 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 15
%83 = load i8, i8* %82
%84 = sext i8 %83 to i64
%85 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %84
%86 = load i64, i64* %85
%87 = mul i64 %86, 15
%88 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 14
%89 = load i8, i8* %88
%90 = sext i8 %89 to i64
%91 = shl nsw i64 %90, 2
%92 = and i64 %91, 4294967292
%93 = shl i64 %87, %92
%94 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %90
%95 = load i64, i64* %94
%96 = mul i64 %95, 14
%97 = or i64 %93, %96
%98 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 13
%99 = load i8, i8* %98
%100 = sext i8 %99 to i64
%101 = shl nsw i64 %100, 2
%102 = and i64 %101, 4294967292
%103 = shl i64 %97, %102
%104 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %100
%105 = load i64, i64* %104
%106 = mul i64 %105, 13
%107 = or i64 %103, %106
%108 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 12
%109 = load i8, i8* %108
%110 = sext i8 %109 to i64
%111 = shl nsw i64 %110, 2
%112 = and i64 %111, 4294967292
%113 = shl i64 %107, %112
%114 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %110
%115 = load i64, i64* %114
%116 = mul i64 %115, 12
%117 = or i64 %113, %116
%118 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 11
%119 = load i8, i8* %118
%120 = sext i8 %119 to i64
%121 = shl nsw i64 %120, 2
%122 = and i64 %121, 4294967292
%123 = shl i64 %117, %122
%124 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %120
%125 = load i64, i64* %124
%126 = mul i64 %125, 11
%127 = or i64 %123, %126
%128 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 10
%129 = load i8, i8* %128
%130 = sext i8 %129 to i64
%131 = shl nsw i64 %130, 2
%132 = and i64 %131, 4294967292
%133 = shl i64 %127, %132
%134 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %130
%135 = load i64, i64* %134
%136 = mul i64 %135, 10
%137 = or i64 %133, %136
%138 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 9
%139 = load i8, i8* %138
%140 = sext i8 %139 to i64
%141 = shl nsw i64 %140, 2
%142 = and i64 %141, 4294967292
%143 = shl i64 %137, %142
%144 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %140
%145 = load i64, i64* %144
%146 = mul i64 %145, 9
%147 = or i64 %143, %146
%148 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 8
%149 = load i8, i8* %148
%150 = sext i8 %149 to i64
%151 = shl nsw i64 %150, 2
%152 = and i64 %151, 4294967292
%153 = shl i64 %147, %152
%154 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %150
%155 = load i64, i64* %154
%156 = shl i64 %155, 3
%157 = or i64 %153, %156
%158 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 7
%159 = load i8, i8* %158
%160 = sext i8 %159 to i64
%161 = shl nsw i64 %160, 2
%162 = and i64 %161, 4294967292
%163 = shl i64 %157, %162
%164 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %160
%165 = load i64, i64* %164
%166 = mul i64 %165, 7
%167 = or i64 %163, %166
%168 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 6
%169 = load i8, i8* %168
%170 = sext i8 %169 to i64
%171 = shl nsw i64 %170, 2
%172 = and i64 %171, 4294967292
%173 = shl i64 %167, %172
%174 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %170
%175 = load i64, i64* %174
%176 = mul i64 %175, 6
%177 = or i64 %173, %176
%178 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 5
%179 = load i8, i8* %178
%180 = sext i8 %179 to i64
%181 = shl nsw i64 %180, 2
%182 = and i64 %181, 4294967292
%183 = shl i64 %177, %182
%184 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %180
%185 = load i64, i64* %184
%186 = mul i64 %185, 5
%187 = or i64 %183, %186
%188 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 4
%189 = load i8, i8* %188
%190 = sext i8 %189 to i64
%191 = shl nsw i64 %190, 2
%192 = and i64 %191, 4294967292
%193 = shl i64 %187, %192
%194 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %190
%195 = load i64, i64* %194
%196 = shl i64 %195, 2
%197 = or i64 %193, %196
%198 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 3
%199 = load i8, i8* %198
%200 = sext i8 %199 to i64
%201 = shl nsw i64 %200, 2
%202 = and i64 %201, 4294967292
%203 = shl i64 %197, %202
%204 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %200
%205 = load i64, i64* %204
%206 = mul i64 %205, 3
%207 = or i64 %203, %206
%208 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 2
%209 = load i8, i8* %208
%210 = sext i8 %209 to i64
%211 = shl nsw i64 %210, 2
%212 = and i64 %211, 4294967292
%213 = shl i64 %207, %212
%214 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %210
%215 = load i64, i64* %214
%216 = shl i64 %215, 1
%217 = or i64 %213, %216
%218 = getelementptr inbounds [16 x i8], [16 x i8]* %2, i64 0, i64 1
%219 = load i8, i8* %218
%220 = sext i8 %219 to i64
%221 = shl nsw i64 %220, 2
%222 = and i64 %221, 4294967292
%223 = shl i64 %217, %222
%224 = getelementptr inbounds [17 x i64], [17 x i64]* @nibble_sort_word.tab, i64 0, i64 %220
%225 = load i64, i64* %224
%226 = or i64 %223, %225
%227 = load i8, i8* %3
%228 = sext i8 %227 to i64
%229 = shl nsw i64 %228, 2
%230 = and i64 %229, 4294967292
%231 = shl i64 %226, %230
ret i64 %231
}