void generate_table_normal(unsigned long long tableID,
                           unsigned long long *color_table) {
  unsigned long long ID = tableID;
  unsigned long long b0 = ID & 63;
  unsigned long long b1 = (ID >> 6) & 63;
  unsigned long long b2 = (ID >> 12) & 63;
  unsigned long long b3 = (ID >> 18) & 63;
  unsigned long long b4 = (ID >> 24) & 63;
  color_table[0] = (b0 << (8 + 1)) | (b1 << (8 * 2 + 1)) | (b2 << (8 * 3 + 1)) |
                   (b3 << (8 * 4 + 1)) | (b4 << (8 * 5 + 1));
  ID = ~ID;
  b0 = ID & 63;
  b1 = (ID >> 6) & 63;
  b2 = (ID >> 12) & 63;
  b3 = (ID >> 18) & 63;
  b4 = (ID >> 24) & 63;
  color_table[1] = (b0 << (8 + 1)) | (b1 << (8 * 2 + 1)) | (b2 << (8 * 3 + 1)) |
                   (b3 << (8 * 4 + 1)) | (b4 << (8 * 5 + 1));
}


x86 assembly (clang, -O0):
<generate_table_normal>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    -0x8(%rbp),%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x3f,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x6,%rax
and    $0x3f,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
shr    $0xc,%rax
and    $0x3f,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x12,%rax
and    $0x3f,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x18,%rax
and    $0x3f,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rcx
shl    $0x9,%rcx
mov    -0x28(%rbp),%rax
shl    $0x11,%rax
or     %rax,%rcx
mov    -0x30(%rbp),%rax
shl    $0x19,%rax
or     %rax,%rcx
mov    -0x38(%rbp),%rax
shl    $0x21,%rax
or     %rax,%rcx
mov    -0x40(%rbp),%rax
shl    $0x29,%rax
or     %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,(%rax)
mov    -0x18(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x18(%rbp)
mov    -0x18(%rbp),%rax
and    $0x3f,%rax
mov    %rax,-0x20(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x6,%rax
and    $0x3f,%rax
mov    %rax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
shr    $0xc,%rax
and    $0x3f,%rax
mov    %rax,-0x30(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x12,%rax
and    $0x3f,%rax
mov    %rax,-0x38(%rbp)
mov    -0x18(%rbp),%rax
shr    $0x18,%rax
and    $0x3f,%rax
mov    %rax,-0x40(%rbp)
mov    -0x20(%rbp),%rcx
shl    $0x9,%rcx
mov    -0x28(%rbp),%rax
shl    $0x11,%rax
or     %rax,%rcx
mov    -0x30(%rbp),%rax
shl    $0x19,%rax
or     %rax,%rcx
mov    -0x38(%rbp),%rax
shl    $0x21,%rax
or     %rax,%rcx
mov    -0x40(%rbp),%rax
shl    $0x29,%rax
or     %rax,%rcx
mov    -0x10(%rbp),%rax
mov    %rcx,0x8(%rax)
pop    %rbp
ret

x86 assembly (clang, -O2):
<generate_table_normal>:
movq   %rdi,%xmm0
not    %rdi
movq   %rdi,%xmm1
punpcklqdq %xmm1,%xmm0
movdqa %xmm0,%xmm1
psllq  $0xb,%xmm1
movdqa %xmm0,%xmm2
psllq  $0x9,%xmm2
movdqa %xmm2,%xmm3
movsd  %xmm1,%xmm3
andpd  0xecd(%rip),%xmm3
shufpd $0x2,%xmm1,%xmm2
andpd  0xed0(%rip),%xmm2
movdqa %xmm0,%xmm1
psllq  $0xd,%xmm1
pand   0xecf(%rip),%xmm1
movdqa %xmm0,%xmm4
psllq  $0xf,%xmm4
pand   0xece(%rip),%xmm4
orpd   %xmm3,%xmm2
psllq  $0x11,%xmm0
pand   0xecd(%rip),%xmm0
por    %xmm1,%xmm4
por    %xmm4,%xmm0
por    %xmm2,%xmm0
movdqu %xmm0,(%rsi)
ret

LLVM IR (-O0):
define void @generate_table_normal(i64 %0, i64* %1) {
%3 = alloca i64
%4 = alloca i64*
%5 = alloca i64
%6 = alloca i64
%7 = alloca i64
%8 = alloca i64
%9 = alloca i64
%10 = alloca i64
store i64 %0, i64* %3
store i64* %1, i64** %4
%11 = load i64, i64* %3
store i64 %11, i64* %5
%12 = load i64, i64* %5
%13 = and i64 %12, 63
store i64 %13, i64* %6
%14 = load i64, i64* %5
%15 = lshr i64 %14, 6
%16 = and i64 %15, 63
store i64 %16, i64* %7
%17 = load i64, i64* %5
%18 = lshr i64 %17, 12
%19 = and i64 %18, 63
store i64 %19, i64* %8
%20 = load i64, i64* %5
%21 = lshr i64 %20, 18
%22 = and i64 %21, 63
store i64 %22, i64* %9
%23 = load i64, i64* %5
%24 = lshr i64 %23, 24
%25 = and i64 %24, 63
store i64 %25, i64* %10
%26 = load i64, i64* %6
%27 = shl i64 %26, 9
%28 = load i64, i64* %7
%29 = shl i64 %28, 17
%30 = or i64 %27, %29
%31 = load i64, i64* %8
%32 = shl i64 %31, 25
%33 = or i64 %30, %32
%34 = load i64, i64* %9
%35 = shl i64 %34, 33
%36 = or i64 %33, %35
%37 = load i64, i64* %10
%38 = shl i64 %37, 41
%39 = or i64 %36, %38
%40 = load i64*, i64** %4
%41 = getelementptr inbounds i64, i64* %40, i64 0
store i64 %39, i64* %41
%42 = load i64, i64* %5
%43 = xor i64 %42, -1
store i64 %43, i64* %5
%44 = load i64, i64* %5
%45 = and i64 %44, 63
store i64 %45, i64* %6
%46 = load i64, i64* %5
%47 = lshr i64 %46, 6
%48 = and i64 %47, 63
store i64 %48, i64* %7
%49 = load i64, i64* %5
%50 = lshr i64 %49, 12
%51 = and i64 %50, 63
store i64 %51, i64* %8
%52 = load i64, i64* %5
%53 = lshr i64 %52, 18
%54 = and i64 %53, 63
store i64 %54, i64* %9
%55 = load i64, i64* %5
%56 = lshr i64 %55, 24
%57 = and i64 %56, 63
store i64 %57, i64* %10
%58 = load i64, i64* %6
%59 = shl i64 %58, 9
%60 = load i64, i64* %7
%61 = shl i64 %60, 17
%62 = or i64 %59, %61
%63 = load i64, i64* %8
%64 = shl i64 %63, 25
%65 = or i64 %62, %64
%66 = load i64, i64* %9
%67 = shl i64 %66, 33
%68 = or i64 %65, %67
%69 = load i64, i64* %10
%70 = shl i64 %69, 41
%71 = or i64 %68, %70
%72 = load i64*, i64** %4
%73 = getelementptr inbounds i64, i64* %72, i64 1
store i64 %71, i64* %73
ret void
}

LLVM IR (-O2):
define void @generate_table_normal(i64 %0, i64* nocapture writeonly %1) {
%3 = xor i64 %0, -1
%4 = insertelement <2 x i64> poison, i64 %0, i64 0
%5 = insertelement <2 x i64> %4, i64 %3, i64 1
%6 = shl <2 x i64> %5, <i64 11, i64 9>
%7 = and <2 x i64> %6, <i64 8257536, i64 32256>
%8 = shl <2 x i64> %5, <i64 9, i64 11>
%9 = and <2 x i64> %8, <i64 32256, i64 8257536>
%10 = or <2 x i64> %7, %9
%11 = shl <2 x i64> %5, <i64 13, i64 13>
%12 = and <2 x i64> %11, <i64 2113929216, i64 2113929216>
%13 = or <2 x i64> %10, %12
%14 = shl <2 x i64> %5, <i64 15, i64 15>
%15 = and <2 x i64> %14, <i64 541165879296, i64 541165879296>
%16 = or <2 x i64> %13, %15
%17 = shl <2 x i64> %5, <i64 17, i64 17>
%18 = and <2 x i64> %17, <i64 138538465099776, i64 138538465099776>
%19 = or <2 x i64> %16, %18
%20 = bitcast i64* %1 to <2 x i64>*
store <2 x i64> %19, <2 x i64>* %20
ret void
}