unsigned int BackwardDNAOccCount(const unsigned int *dna,
                                 const unsigned int index,
                                 const unsigned int character,
                                 const unsigned int *dnaDecodeTable) {
  static const unsigned int truncateLeftMask[16] = {
      0x00000000, 0x00000003, 0x0000000F, 0x0000003F, 0x000000FF, 0x000003FF,
      0x00000FFF, 0x00003FFF, 0x0000FFFF, 0x0003FFFF, 0x000FFFFF, 0x003FFFFF,
      0x00FFFFFF, 0x03FFFFFF, 0x0FFFFFFF, 0x3FFFFFFF};
  unsigned int wordToCount, charToCount;
  unsigned int i, c;
  unsigned int sum = 0;
  wordToCount = index / 16;
  charToCount = index - wordToCount * 16;
  dna -= wordToCount + 1;
  if (charToCount > 0) {
    c = *dna & truncateLeftMask[charToCount];
    sum += dnaDecodeTable[c >> 16];
    sum += dnaDecodeTable[c & 0xFFFF];
    sum += charToCount - 16;
  }
  for (i = 0; i < wordToCount; i++) {
    dna++;
    sum += dnaDecodeTable[*dna >> 16];
    sum += dnaDecodeTable[*dna & 0x0000FFFF];
  }
  return (sum >> (character * 8)) & 0x000000FF;
}


x86 assembly (clang, -O0):
<BackwardDNAOccCount>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %edx,-0x10(%rbp)
mov    %rcx,-0x18(%rbp)
movl   $0x0,-0x2c(%rbp)
mov    -0xc(%rbp),%eax
shr    $0x4,%eax
mov    %eax,-0x1c(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x1c(%rbp),%ecx
shl    $0x4,%ecx
sub    %ecx,%eax
mov    %eax,-0x20(%rbp)
mov    -0x1c(%rbp),%ecx
add    $0x1,%ecx
mov    -0x8(%rbp),%rax
mov    %ecx,%ecx
mov    %ecx,%edx
xor    %ecx,%ecx
sub    %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    %rax,-0x8(%rbp)
cmpl   $0x0,-0x20(%rbp)
jbe    11a9 <BackwardDNAOccCount+0xa9>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x20(%rbp),%ecx
mov    %ecx,%edx
lea    0xe96(%rip),%rcx
and    (%rcx,%rdx,4),%eax
mov    %eax,-0x28(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x28(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x20(%rbp),%eax
sub    $0x10,%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jae    1209 <BackwardDNAOccCount+0x109>
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x18(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x2c(%rbp),%eax
mov    %eax,-0x2c(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    11b0 <BackwardDNAOccCount+0xb0>
mov    -0x2c(%rbp),%eax
mov    -0x10(%rbp),%ecx
shl    $0x3,%ecx
shr    %cl,%eax
and    $0xff,%eax
pop    %rbp
ret

x86 assembly (clang, -O2):
<BackwardDNAOccCount>:
mov    %rcx,%r11
mov    %edx,%ecx
mov    %esi,%r9d
shr    $0x4,%r9d
lea    0x0(,%r9,4),%rdx
sub    %rdx,%rdi
add    $0xfffffffffffffffc,%rdi
mov    %esi,%edx
and    $0xf,%edx
je     1155 <BackwardDNAOccCount+0x55>
mov    %edx,%r8d
lea    0xed4(%rip),%rdx
mov    (%rdx,%r8,4),%edx
and    (%rdi),%edx
movzwl %dx,%r8d
mov    %edx,%r10d
shr    $0xe,%r10d
and    $0xfffffffc,%r10d
mov    %esi,%edx
or     $0xfffffff0,%edx
add    (%r11,%r10,1),%edx
add    (%r11,%r8,4),%edx
cmp    $0x10,%esi
jae    115c <BackwardDNAOccCount+0x5c>
jmp    11c8 <BackwardDNAOccCount+0xc8>
xor    %edx,%edx
cmp    $0x10,%esi
jb     11c8 <BackwardDNAOccCount+0xc8>
cmp    $0x2,%r9d
mov    $0x1,%r8d
cmovae %r9d,%r8d
cmp    $0x20,%esi
jb     11b0 <BackwardDNAOccCount+0xb0>
mov    %r8d,%esi
and    $0xfffffffe,%esi
cs nopw 0x0(%rax,%rax,1)
nop
mov    0x4(%rdi),%eax
mov    0x8(%rdi),%r9d
movzwl %ax,%r10d
shr    $0x10,%rax
add    (%r11,%rax,4),%edx
add    (%r11,%r10,4),%edx
movzwl %r9w,%eax
shr    $0x10,%r9
add    (%r11,%r9,4),%edx
add    $0x8,%rdi
add    (%r11,%rax,4),%edx
add    $0xfffffffe,%esi
jne    1180 <BackwardDNAOccCount+0x80>
test   $0x1,%r8b
je     11c8 <BackwardDNAOccCount+0xc8>
mov    0x4(%rdi),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r11,%rax,4),%edx
add    (%r11,%rsi,4),%edx
shl    $0x3,%ecx
shr    %cl,%edx
movzbl %dl,%eax
ret

LLVM IR (-O0):
@BackwardDNAOccCount.truncateLeftMask = internal constant [16 x i32] [i32 0, i32 3, i32 15, i32 63, i32 255, i32 1023, i32 4095, i32 16383, i32 65535, i32 262143, i32 1048575, i32 4194303, i32 16777215, i32 67108863, i32 268435455, i32 1073741823]
define i32 @BackwardDNAOccCount(i32* %0, i32 %1, i32 %2, i32* %3) {
%5 = alloca i32*
%6 = alloca i32
%7 = alloca i32
%8 = alloca i32*
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i32
%13 = alloca i32
store i32* %0, i32** %5
store i32 %1, i32* %6
store i32 %2, i32* %7
store i32* %3, i32** %8
store i32 0, i32* %13
%14 = load i32, i32* %6
%15 = udiv i32 %14, 16
store i32 %15, i32* %9
%16 = load i32, i32* %6
%17 = load i32, i32* %9
%18 = mul i32 %17, 16
%19 = sub i32 %16, %18
store i32 %19, i32* %10
%20 = load i32, i32* %9
%21 = add i32 %20, 1
%22 = load i32*, i32** %5
%23 = zext i32 %21 to i64
%24 = sub i64 0, %23
%25 = getelementptr inbounds i32, i32* %22, i64 %24
store i32* %25, i32** %5
%26 = load i32, i32* %10
%27 = icmp ugt i32 %26, 0
br i1 %27, label %28, label %56
28: ; preds = %4
%29 = load i32*, i32** %5
%30 = load i32, i32* %29
%31 = load i32, i32* %10
%32 = zext i32 %31 to i64
%33 = getelementptr inbounds [16 x i32], [16 x i32]* @BackwardDNAOccCount.truncateLeftMask, i64 0, i64 %32
%34 = load i32, i32* %33
%35 = and i32 %30, %34
store i32 %35, i32* %12
%36 = load i32*, i32** %8
%37 = load i32, i32* %12
%38 = lshr i32 %37, 16
%39 = zext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %36, i64 %39
%41 = load i32, i32* %40
%42 = load i32, i32* %13
%43 = add i32 %42, %41
store i32 %43, i32* %13
%44 = load i32*, i32** %8
%45 = load i32, i32* %12
%46 = and i32 %45, 65535
%47 = zext i32 %46 to i64
%48 = getelementptr inbounds i32, i32* %44, i64 %47
%49 = load i32, i32* %48
%50 = load i32, i32* %13
%51 = add i32 %50, %49
store i32 %51, i32* %13
%52 = load i32, i32* %10
%53 = sub i32 %52, 16
%54 = load i32, i32* %13
%55 = add i32 %54, %53
store i32 %55, i32* %13
br label %56
56: ; preds = %28, %4
store i32 0, i32* %11
br label %57
57: ; preds = %82, %56
%58 = load i32, i32* %11
%59 = load i32, i32* %9
%60 = icmp ult i32 %58, %59
br i1 %60, label %61, label %85
61: ; preds = %57
%62 = load i32*, i32** %5
%63 = getelementptr inbounds i32, i32* %62, i32 1
store i32* %63, i32** %5
%64 = load i32*, i32** %8
%65 = load i32*, i32** %5
%66 = load i32, i32* %65
%67 = lshr i32 %66, 16
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %64, i64 %68
%70 = load i32, i32* %69
%71 = load i32, i32* %13
%72 = add i32 %71, %70
store i32 %72, i32* %13
%73 = load i32*, i32** %8
%74 = load i32*, i32** %5
%75 = load i32, i32* %74
%76 = and i32 %75, 65535
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %73, i64 %77
%79 = load i32, i32* %78
%80 = load i32, i32* %13
%81 = add i32 %80, %79
store i32 %81, i32* %13
br label %82
82: ; preds = %61
%83 = load i32, i32* %11
%84 = add i32 %83, 1
store i32 %84, i32* %11
br label %57
85: ; preds = %57
%86 = load i32, i32* %13
%87 = load i32, i32* %7
%88 = mul i32 %87, 8
%89 = lshr i32 %86, %88
%90 = and i32 %89, 255
ret i32 %90
}

LLVM IR (-O2):
@BackwardDNAOccCount.truncateLeftMask = internal unnamed_addr constant [16 x i32] [i32 0, i32 3, i32 15, i32 63, i32 255, i32 1023, i32 4095, i32 16383, i32 65535, i32 262143, i32 1048575, i32 4194303, i32 16777215, i32 67108863, i32 268435455, i32 1073741823]
define i32 @BackwardDNAOccCount(i32* nocapture %0, i32 %1, i32 %2, i32* nocapture %3) {
%5 = lshr i32 %1, 4
%6 = and i32 %1, 15
%7 = add nuw nsw i32 %5, 1
%8 = zext i32 %7 to i64
%9 = sub nsw i64 0, %8
%10 = getelementptr inbounds i32, i32* %0, i64 %9
%11 = icmp eq i32 %6, 0
br i1 %11, label %29, label %12
12: ; preds = %4
%13 = load i32, i32* %10
%14 = zext i32 %6 to i64
%15 = getelementptr inbounds [16 x i32], [16 x i32]* @BackwardDNAOccCount.truncateLeftMask, i64 0, i64 %14
%16 = load i32, i32* %15
%17 = and i32 %16, %13
%18 = lshr i32 %17, 16
%19 = zext i32 %18 to i64
%20 = getelementptr inbounds i32, i32* %3, i64 %19
%21 = load i32, i32* %20
%22 = and i32 %17, 65535
%23 = zext i32 %22 to i64
%24 = getelementptr inbounds i32, i32* %3, i64 %23
%25 = load i32, i32* %24
%26 = or i32 %1, -16
%27 = add i32 %21, %26
%28 = add i32 %27, %25
br label %29
29: ; preds = %12, %4
%30 = phi i32 [ %28, %12 ], [ 0, %4 ]
%31 = icmp ult i32 %1, 16
br i1 %31, label %86, label %32
32: ; preds = %29
%33 = call i32 @llvm.umax.i32(i32 %5, i32 1)
%34 = and i32 %33, 1
%35 = icmp ult i32 %1, 32
br i1 %35, label %68, label %36
36: ; preds = %32
%37 = and i32 %33, 268435454
br label %38
38: ; preds = %38, %36
%39 = phi i32 [ %30, %36 ], [ %65, %38 ]
%40 = phi i32* [ %10, %36 ], [ %54, %38 ]
%41 = phi i32 [ 0, %36 ], [ %66, %38 ]
%42 = getelementptr inbounds i32, i32* %40, i64 1
%43 = load i32, i32* %42
%44 = lshr i32 %43, 16
%45 = zext i32 %44 to i64
%46 = getelementptr inbounds i32, i32* %3, i64 %45
%47 = load i32, i32* %46
%48 = add i32 %47, %39
%49 = and i32 %43, 65535
%50 = zext i32 %49 to i64
%51 = getelementptr inbounds i32, i32* %3, i64 %50
%52 = load i32, i32* %51
%53 = add i32 %48, %52
%54 = getelementptr inbounds i32, i32* %40, i64 2
%55 = load i32, i32* %54
%56 = lshr i32 %55, 16
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %3, i64 %57
%59 = load i32, i32* %58
%60 = add i32 %59, %53
%61 = and i32 %55, 65535
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %3, i64 %62
%64 = load i32, i32* %63
%65 = add i32 %60, %64
%66 = add i32 %41, 2
%67 = icmp eq i32 %66, %37
br i1 %67, label %68, label %38
68: ; preds = %38, %32
%69 = phi i32 [ undef, %32 ], [ %65, %38 ]
%70 = phi i32 [ %30, %32 ], [ %65, %38 ]
%71 = phi i32* [ %10, %32 ], [ %54, %38 ]
%72 = icmp eq i32 %34, 0
br i1 %72, label %86, label %73
73: ; preds = %68
%74 = getelementptr inbounds i32, i32* %71, i64 1
%75 = load i32, i32* %74
%76 = lshr i32 %75, 16
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %3, i64 %77
%79 = load i32, i32* %78
%80 = add i32 %79, %70
%81 = and i32 %75, 65535
%82 = zext i32 %81 to i64
%83 = getelementptr inbounds i32, i32* %3, i64 %82
%84 = load i32, i32* %83
%85 = add i32 %80, %84
br label %86
86: ; preds = %73, %68, %29
%87 = phi i32 [ %30, %29 ], [ %69, %68 ], [ %85, %73 ]
%88 = shl i32 %2, 3
%89 = lshr i32 %87, %88
%90 = and i32 %89, 255
ret i32 %90
}