#define NULL ((void *)0)
typedef unsigned long size_t; // Customize by platform.
typedef long intptr_t;
typedef unsigned long uintptr_t;
typedef long scalar_t__; // Either arithmetic or pointer type.
/* By default, we understand bool (as a convenience). */
typedef int bool;
#define false 0
#define true 1

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
int /*<<< orphan*/ exit(int);
int /*<<< orphan*/ fprintf(int /*<<< orphan*/, char *);
int /*<<< orphan*/ stderr;
void ForwardDNAAllOccCountNoLimit(const unsigned int *dna,
                                  const unsigned int index,
                                  unsigned int *__restrict occCount,
                                  const unsigned int *dnaDecodeTable) {
  static const unsigned int truncateRightMask[16] = {
      0x00000000, 0xC0000000, 0xF0000000, 0xFC000000, 0xFF000000, 0xFFC00000,
      0xFFF00000, 0xFFFC0000, 0xFFFF0000, 0xFFFFC000, 0xFFFFF000, 0xFFFFFC00,
      0xFFFFFF00, 0xFFFFFFC0, 0xFFFFFFF0, 0xFFFFFFFC};
  unsigned int iteration, wordToCount, charToCount;
  unsigned int i, j, c;
  unsigned int sum;
  occCount[0] = 0;
  occCount[1] = 0;
  occCount[2] = 0;
  occCount[3] = 0;
  iteration = index / 256;
  wordToCount = (index - iteration * 256) / 16;
  charToCount = index - iteration * 256 - wordToCount * 16;
  for (i = 0; i < iteration; i++) {
    sum = 0;
    for (j = 0; j < 16; j++) {
      sum += dnaDecodeTable[*dna >> 16];
      sum += dnaDecodeTable[*dna & 0x0000FFFF];
      dna++;
    }
    if (!((sum & 0xfefefeff) == 0)) {
      occCount[0] += sum & 0x000000FF;
      sum >>= 8;
      occCount[1] += sum & 0x000000FF;
      sum >>= 8;
      occCount[2] += sum & 0x000000FF;
      sum >>= 8;
      occCount[3] += sum;
    } else {
      if (sum == 0x00000100) {
        occCount[0] += 256;
      } else if (sum == 0x00010000) {
        occCount[1] += 256;
      } else if (sum == 0x01000000) {
        occCount[2] += 256;
      } else if (sum == 0x00000000) {
        occCount[3] += 256;
      } else {
        fprintf(stderr,
                "ForwardDNAAllOccCountNoLimit(): DNA occ sum exception!\n");
        exit(1);
      }
    }
  }
  sum = 0;
  for (j = 0; j < wordToCount; j++) {
    sum += dnaDecodeTable[*dna >> 16];
    sum += dnaDecodeTable[*dna & 0x0000FFFF];
    dna++;
  }
  if (charToCount > 0) {
    c = *dna & truncateRightMask[charToCount];
    sum += dnaDecodeTable[c >> 16];
    sum += dnaDecodeTable[c & 0xFFFF];
    sum += charToCount - 16;
  }
  occCount[0] += sum & 0x000000FF;
  sum >>= 8;
  occCount[1] += sum & 0x000000FF;
  sum >>= 8;
  occCount[2] += sum & 0x000000FF;
  sum >>= 8;
  occCount[3] += sum;
}


x86 assembly (clang, -O0):
<ForwardDNAAllOccCountNoLimit>:
push   %rbp
mov    %rsp,%rbp
sub    $0x40,%rsp
mov    %rdi,-0x8(%rbp)
mov    %esi,-0xc(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    -0x18(%rbp),%rax
movl   $0x0,(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0x4(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0x8(%rax)
mov    -0x18(%rbp),%rax
movl   $0x0,0xc(%rax)
mov    -0xc(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x24(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x8,%ecx
sub    %ecx,%eax
shr    $0x4,%eax
mov    %eax,-0x28(%rbp)
mov    -0xc(%rbp),%eax
mov    -0x24(%rbp),%ecx
shl    $0x8,%ecx
sub    %ecx,%eax
mov    -0x28(%rbp),%ecx
shl    $0x4,%ecx
sub    %ecx,%eax
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x30(%rbp)
mov    -0x30(%rbp),%eax
cmp    -0x24(%rbp),%eax
jae    1348 <ForwardDNAAllOccCountNoLimit+0x228>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
cmpl   $0x10,-0x34(%rbp)
jae    120a <ForwardDNAAllOccCountNoLimit+0xea>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    11b3 <ForwardDNAAllOccCountNoLimit+0x93>
mov    -0x3c(%rbp),%eax
and    $0xfefefeff,%eax
cmp    $0x0,%eax
je     127f <ForwardDNAAllOccCountNoLimit+0x15f>
mov    -0x3c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0x18(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
jmp    1335 <ForwardDNAAllOccCountNoLimit+0x215>
cmpl   $0x100,-0x3c(%rbp)
jne    129f <ForwardDNAAllOccCountNoLimit+0x17f>
mov    -0x18(%rbp),%rax
mov    (%rax),%ecx
add    $0x100,%ecx
mov    %ecx,(%rax)
jmp    1330 <ForwardDNAAllOccCountNoLimit+0x210>
cmpl   $0x10000,-0x3c(%rbp)
jne    12c1 <ForwardDNAAllOccCountNoLimit+0x1a1>
mov    -0x18(%rbp),%rax
mov    0x4(%rax),%ecx
add    $0x100,%ecx
mov    %ecx,0x4(%rax)
jmp    132b <ForwardDNAAllOccCountNoLimit+0x20b>
cmpl   $0x1000000,-0x3c(%rbp)
jne    12e3 <ForwardDNAAllOccCountNoLimit+0x1c3>
mov    -0x18(%rbp),%rax
mov    0x8(%rax),%ecx
add    $0x100,%ecx
mov    %ecx,0x8(%rax)
jmp    1326 <ForwardDNAAllOccCountNoLimit+0x206>
cmpl   $0x0,-0x3c(%rbp)
jne    1302 <ForwardDNAAllOccCountNoLimit+0x1e2>
mov    -0x18(%rbp),%rax
mov    0xc(%rax),%ecx
add    $0x100,%ecx
mov    %ecx,0xc(%rax)
jmp    1321 <ForwardDNAAllOccCountNoLimit+0x201>
mov    0x2cd7(%rip),%rax
mov    (%rax),%edi
lea    0xd2e(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>
jmp    1326 <ForwardDNAAllOccCountNoLimit+0x206>
jmp    132b <ForwardDNAAllOccCountNoLimit+0x20b>
jmp    1330 <ForwardDNAAllOccCountNoLimit+0x210>
jmp    1335 <ForwardDNAAllOccCountNoLimit+0x215>
jmp    133a <ForwardDNAAllOccCountNoLimit+0x21a>
mov    -0x30(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
jmp    1199 <ForwardDNAAllOccCountNoLimit+0x79>
movl   $0x0,-0x3c(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
cmp    -0x28(%rbp),%eax
jae    13af <ForwardDNAAllOccCountNoLimit+0x28f>
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x8(%rbp),%rcx
mov    (%rcx),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x8(%rbp),%rax
add    $0x4,%rax
mov    %rax,-0x8(%rbp)
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1356 <ForwardDNAAllOccCountNoLimit+0x236>
cmpl   $0x0,-0x2c(%rbp)
jbe    140a <ForwardDNAAllOccCountNoLimit+0x2ea>
mov    -0x8(%rbp),%rax
mov    (%rax),%eax
mov    -0x2c(%rbp),%ecx
mov    %ecx,%edx
lea    0xc35(%rip),%rcx
and    (%rcx,%rdx,4),%eax
mov    %eax,-0x38(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x20(%rbp),%rax
mov    -0x38(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x2c(%rbp),%eax
sub    $0x10,%eax
add    -0x3c(%rbp),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%rax
add    (%rax),%ecx
mov    %ecx,(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%rax
add    0x4(%rax),%ecx
mov    %ecx,0x4(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
and    $0xff,%ecx
mov    -0x18(%rbp),%rax
add    0x8(%rax),%ecx
mov    %ecx,0x8(%rax)
mov    -0x3c(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x3c(%rbp)
mov    -0x3c(%rbp),%ecx
mov    -0x18(%rbp),%rax
add    0xc(%rax),%ecx
mov    %ecx,0xc(%rax)
add    $0x40,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<ForwardDNAAllOccCountNoLimit>:
push   %r15
push   %r14
push   %rbx
xorps  %xmm0,%xmm0
movups %xmm0,(%rdx)
cmp    $0x100,%esi
jb     12fd <ForwardDNAAllOccCountNoLimit+0x1dd>
lea    0x4(%rdx),%r8
lea    0x8(%rdx),%r9
lea    0xc(%rdx),%r10
mov    %esi,%r11d
shr    $0x8,%r11d
jmp    117c <ForwardDNAAllOccCountNoLimit+0x5c>
nopl   0x0(%rax)
movzbl %bl,%eax
add    %eax,(%rdx)
movzbl %bh,%eax
add    %eax,0x4(%rdx)
mov    %ebx,%eax
shr    $0x10,%eax
movzbl %al,%eax
add    %eax,0x8(%rdx)
shr    $0x18,%ebx
mov    %r10,%rdi
add    %ebx,(%rdi)
lea    0x40(%r14),%rdi
add    $0xffffffff,%r11d
je     12f6 <ForwardDNAAllOccCountNoLimit+0x1d6>
mov    %rdi,%r14
mov    (%rdi),%edi
mov    0x4(%r14),%eax
movzwl %di,%r15d
shr    $0x10,%rdi
mov    (%rcx,%rdi,4),%ebx
add    (%rcx,%r15,4),%ebx
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x8(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0xc(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x10(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x14(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x18(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x1c(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x20(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x24(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x28(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x2c(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x30(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x34(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x38(%r14),%eax
movzwl %ax,%edi
shr    $0x10,%rax
add    (%rcx,%rax,4),%ebx
add    (%rcx,%rdi,4),%ebx
mov    0x3c(%r14),%eax
mov    %rax,%rdi
shr    $0x10,%rdi
add    (%rcx,%rdi,4),%ebx
movzwl %ax,%eax
add    (%rcx,%rax,4),%ebx
test   $0xfefefeff,%ebx
jne    1150 <ForwardDNAAllOccCountNoLimit+0x30>
cmp    $0xffff,%ebx
jg     12be <ForwardDNAAllOccCountNoLimit+0x19e>
test   %ebx,%ebx
je     12df <ForwardDNAAllOccCountNoLimit+0x1bf>
mov    %rdx,%rdi
cmp    $0x100,%ebx
je     116c <ForwardDNAAllOccCountNoLimit+0x4c>
jmp    13d6 <ForwardDNAAllOccCountNoLimit+0x2b6>
cmp    $0x1000000,%ebx
je     12e9 <ForwardDNAAllOccCountNoLimit+0x1c9>
cmp    $0x10000,%ebx
jne    13d6 <ForwardDNAAllOccCountNoLimit+0x2b6>
mov    $0x100,%ebx
mov    %r8,%rdi
jmp    116c <ForwardDNAAllOccCountNoLimit+0x4c>
mov    $0x100,%ebx
jmp    1169 <ForwardDNAAllOccCountNoLimit+0x49>
mov    $0x100,%ebx
mov    %r9,%rdi
jmp    116c <ForwardDNAAllOccCountNoLimit+0x4c>
add    $0x40,%r14
mov    %r14,%rdi
movzbl %sil,%ebx
and    $0xf0,%esi
mov    %ebx,%r9d
sub    %esi,%r9d
xor    %eax,%eax
cmp    $0x10,%ebx
jb     1389 <ForwardDNAAllOccCountNoLimit+0x269>
mov    %ebx,%eax
shr    $0x4,%eax
cmp    $0x2,%eax
mov    $0x1,%r8d
cmovae %eax,%r8d
cmp    $0x20,%ebx
jae    132f <ForwardDNAAllOccCountNoLimit+0x20f>
xor    %eax,%eax
jmp    136d <ForwardDNAAllOccCountNoLimit+0x24d>
mov    %r8d,%esi
and    $0xfffffffe,%esi
xor    %eax,%eax
nopw   0x0(%rax,%rax,1)
mov    (%rdi),%ebx
mov    0x4(%rdi),%r10d
movzwl %bx,%r11d
shr    $0x10,%rbx
add    (%rcx,%rbx,4),%eax
add    (%rcx,%r11,4),%eax
movzwl %r10w,%ebx
shr    $0x10,%r10
add    (%rcx,%r10,4),%eax
add    (%rcx,%rbx,4),%eax
add    $0x8,%rdi
add    $0xfffffffe,%esi
jne    1340 <ForwardDNAAllOccCountNoLimit+0x220>
test   $0x1,%r8b
je     1389 <ForwardDNAAllOccCountNoLimit+0x269>
mov    (%rdi),%ebx
mov    %rbx,%rsi
shr    $0x10,%rsi
add    (%rcx,%rsi,4),%eax
movzwl %bx,%esi
add    (%rcx,%rsi,4),%eax
add    $0x4,%rdi
test   %r9d,%r9d
je     13b4 <ForwardDNAAllOccCountNoLimit+0x294>
mov    %r9d,%esi
lea    0xc68(%rip),%rbx
mov    (%rbx,%rsi,4),%esi
and    (%rdi),%esi
movzwl %si,%edi
shr    $0xe,%esi
and    $0xfffffffc,%esi
mov    (%rcx,%rdi,4),%edi
add    %r9d,%eax
add    (%rcx,%rsi,1),%eax
add    %edi,%eax
add    $0xfffffff0,%eax
movzbl %al,%ecx
add    %ecx,(%rdx)
movzbl %ah,%ecx
add    %ecx,0x4(%rdx)
mov    %eax,%ecx
shr    $0x10,%ecx
movzbl %cl,%ecx
add    %ecx,0x8(%rdx)
shr    $0x18,%eax
add    %eax,0xc(%rdx)
pop    %rbx
pop    %r14
pop    %r15
ret
mov    0x2c03(%rip),%rax
mov    (%rax),%edi
lea    0xc5a(%rip),%rsi
call   1030 <fprintf@plt>
mov    $0x1,%edi
call   1040 <exit@plt>

LLVM IR (-O0):
@ForwardDNAAllOccCountNoLimit.truncateRightMask = internal constant [16 x i32] [i32 0, i32 -1073741824, i32 -268435456, i32 -67108864, i32 -16777216, i32 -4194304, i32 -1048576, i32 -262144, i32 -65536, i32 -16384, i32 -4096, i32 -1024, i32 -256, i32 -64, i32 -16, i32 -4]
@stderr = global i32 0
@.str = [56 x i8] c"ForwardDNAAllOccCountNoLimit(): DNA occ sum exception!\0A\00"
define void @ForwardDNAAllOccCountNoLimit(i32* %0, i32 %1, i32* noalias %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
%14 = alloca i32
%15 = alloca i32
store i32* %0, i32** %5
store i32 %1, i32* %6
store i32* %2, i32** %7
store i32* %3, i32** %8
%16 = load i32*, i32** %7
%17 = getelementptr inbounds i32, i32* %16, i64 0
store i32 0, i32* %17
%18 = load i32*, i32** %7
%19 = getelementptr inbounds i32, i32* %18, i64 1
store i32 0, i32* %19
%20 = load i32*, i32** %7
%21 = getelementptr inbounds i32, i32* %20, i64 2
store i32 0, i32* %21
%22 = load i32*, i32** %7
%23 = getelementptr inbounds i32, i32* %22, i64 3
store i32 0, i32* %23
%24 = load i32, i32* %6
%25 = udiv i32 %24, 256
store i32 %25, i32* %9
%26 = load i32, i32* %6
%27 = load i32, i32* %9
%28 = mul i32 %27, 256
%29 = sub i32 %26, %28
%30 = udiv i32 %29, 16
store i32 %30, i32* %10
%31 = load i32, i32* %6
%32 = load i32, i32* %9
%33 = mul i32 %32, 256
%34 = sub i32 %31, %33
%35 = load i32, i32* %10
%36 = mul i32 %35, 16
%37 = sub i32 %34, %36
store i32 %37, i32* %11
store i32 0, i32* %12
br label %38
38: ; preds = %145, %4
%39 = load i32, i32* %12
%40 = load i32, i32* %9
%41 = icmp ult i32 %39, %40
br i1 %41, label %42, label %148
42: ; preds = %38
store i32 0, i32* %15
store i32 0, i32* %13
br label %43
43: ; preds = %67, %42
%44 = load i32, i32* %13
%45 = icmp ult i32 %44, 16
br i1 %45, label %46, label %70
46: ; preds = %43
%47 = load i32*, i32** %8
%48 = load i32*, i32** %5
%49 = load i32, i32* %48
%50 = lshr i32 %49, 16
%51 = zext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %47, i64 %51
%53 = load i32, i32* %52
%54 = load i32, i32* %15
%55 = add i32 %54, %53
store i32 %55, i32* %15
%56 = load i32*, i32** %8
%57 = load i32*, i32** %5
%58 = load i32, i32* %57
%59 = and i32 %58, 65535
%60 = zext i32 %59 to i64
%61 = getelementptr inbounds i32, i32* %56, i64 %60
%62 = load i32, i32* %61
%63 = load i32, i32* %15
%64 = add i32 %63, %62
store i32 %64, i32* %15
%65 = load i32*, i32** %5
%66 = getelementptr inbounds i32, i32* %65, i32 1
store i32* %66, i32** %5
br label %67
67: ; preds = %46
%68 = load i32, i32* %13
%69 = add i32 %68, 1
store i32 %69, i32* %13
br label %43
70: ; preds = %43
%71 = load i32, i32* %15
%72 = and i32 %71, -16843009
%73 = icmp eq i32 %72, 0
br i1 %73, label %104, label %74
74: ; preds = %70
%75 = load i32, i32* %15
%76 = and i32 %75, 255
%77 = load i32*, i32** %7
%78 = getelementptr inbounds i32, i32* %77, i64 0
%79 = load i32, i32* %78
%80 = add i32 %79, %76
store i32 %80, i32* %78
%81 = load i32, i32* %15
%82 = lshr i32 %81, 8
store i32 %82, i32* %15
%83 = load i32, i32* %15
%84 = and i32 %83, 255
%85 = load i32*, i32** %7
%86 = getelementptr inbounds i32, i32* %85, i64 1
%87 = load i32, i32* %86
%88 = add i32 %87, %84
store i32 %88, i32* %86
%89 = load i32, i32* %15
%90 = lshr i32 %89, 8
store i32 %90, i32* %15
%91 = load i32, i32* %15
%92 = and i32 %91, 255
%93 = load i32*, i32** %7
%94 = getelementptr inbounds i32, i32* %93, i64 2
%95 = load i32, i32* %94
%96 = add i32 %95, %92
store i32 %96, i32* %94
%97 = load i32, i32* %15
%98 = lshr i32 %97, 8
store i32 %98, i32* %15
%99 = load i32, i32* %15
%100 = load i32*, i32** %7
%101 = getelementptr inbounds i32, i32* %100, i64 3
%102 = load i32, i32* %101
%103 = add i32 %102, %99
store i32 %103, i32* %101
br label %144
104: ; preds = %70
%105 = load i32, i32* %15
%106 = icmp eq i32 %105, 256
br i1 %106, label %107, label %112
107: ; preds = %104
%108 = load i32*, i32** %7
%109 = getelementptr inbounds i32, i32* %108, i64 0
%110 = load i32, i32* %109
%111 = add i32 %110, 256
store i32 %111, i32* %109
br label %143
112: ; preds = %104
%113 = load i32, i32* %15
%114 = icmp eq i32 %113, 65536
br i1 %114, label %115, label %120
115: ; preds = %112
%116 = load i32*, i32** %7
%117 = getelementptr inbounds i32, i32* %116, i64 1
%118 = load i32, i32* %117
%119 = add i32 %118, 256
store i32 %119, i32* %117
br label %142
120: ; preds = %112
%121 = load i32, i32* %15
%122 = icmp eq i32 %121, 16777216
br i1 %122, label %123, label %128
123: ; preds = %120
%124 = load i32*, i32** %7
%125 = getelementptr inbounds i32, i32* %124, i64 2
%126 = load i32, i32* %125
%127 = add i32 %126, 256
store i32 %127, i32* %125
br label %141
128: ; preds = %120
%129 = load i32, i32* %15
%130 = icmp eq i32 %129, 0
br i1 %130, label %131, label %136
131: ; preds = %128
%132 = load i32*, i32** %7
%133 = getelementptr inbounds i32, i32* %132, i64 3
%134 = load i32, i32* %133
%135 = add i32 %134, 256
store i32 %135, i32* %133
br label %140
136: ; preds = %128
%137 = load i32, i32* @stderr
%138 = call i32 @fprintf(i32 %137, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0))
%139 = call i32 @exit(i32 1)
unreachable
140: ; preds = %131
br label %141
141: ; preds = %140, %123
br label %142
142: ; preds = %141, %115
br label %143
143: ; preds = %142, %107
br label %144
144: ; preds = %143, %74
br label %145
145: ; preds = %144
%146 = load i32, i32* %12
%147 = add i32 %146, 1
store i32 %147, i32* %12
br label %38
148: ; preds = %38
store i32 0, i32* %15
store i32 0, i32* %13
br label %149
149: ; preds = %174, %148
%150 = load i32, i32* %13
%151 = load i32, i32* %10
%152 = icmp ult i32 %150, %151
br i1 %152, label %153, label %177
153: ; preds = %149
%154 = load i32*, i32** %8
%155 = load i32*, i32** %5
%156 = load i32, i32* %155
%157 = lshr i32 %156, 16
%158 = zext i32 %157 to i64
%159 = getelementptr inbounds i32, i32* %154, i64 %158
%160 = load i32, i32* %159
%161 = load i32, i32* %15
%162 = add i32 %161, %160
store i32 %162, i32* %15
%163 = load i32*, i32** %8
%164 = load i32*, i32** %5
%165 = load i32, i32* %164
%166 = and i32 %165, 65535
%167 = zext i32 %166 to i64
%168 = getelementptr inbounds i32, i32* %163, i64 %167
%169 = load i32, i32* %168
%170 = load i32, i32* %15
%171 = add i32 %170, %169
store i32 %171, i32* %15
%172 = load i32*, i32** %5
%173 = getelementptr inbounds i32, i32* %172, i32 1
store i32* %173, i32** %5
br label %174
174: ; preds = %153
%175 = load i32, i32* %13
%176 = add i32 %175, 1
store i32 %176, i32* %13
br label %149
177: ; preds = %149
%178 = load i32, i32* %11
%179 = icmp ugt i32 %178, 0
br i1 %179, label %180, label %208
180: ; preds = %177
%181 = load i32*, i32** %5
%182 = load i32, i32* %181
%183 = load i32, i32* %11
%184 = zext i32 %183 to i64
%185 = getelementptr inbounds [16 x i32], [16 x i32]* @ForwardDNAAllOccCountNoLimit.truncateRightMask, i64 0, i64 %184
%186 = load i32, i32* %185
%187 = and i32 %182, %186
store i32 %187, i32* %14
%188 = load i32*, i32** %8
%189 = load i32, i32* %14
%190 = lshr i32 %189, 16
%191 = zext i32 %190 to i64
%192 = getelementptr inbounds i32, i32* %188, i64 %191
%193 = load i32, i32* %192
%194 = load i32, i32* %15
%195 = add i32 %194, %193
store i32 %195, i32* %15
%196 = load i32*, i32** %8
%197 = load i32, i32* %14
%198 = and i32 %197, 65535
%199 = zext i32 %198 to i64
%200 = getelementptr inbounds i32, i32* %196, i64 %199
%201 = load i32, i32* %200
%202 = load i32, i32* %15
%203 = add i32 %202, %201
store i32 %203, i32* %15
%204 = load i32, i32* %11
%205 = sub i32 %204, 16
%206 = load i32, i32* %15
%207 = add i32 %206, %205
store i32 %207, i32* %15
br label %208
208: ; preds = %180, %177
%209 = load i32, i32* %15
%210 = and i32 %209, 255
%211 = load i32*, i32** %7
%212 = getelementptr inbounds i32, i32* %211, i64 0
%213 = load i32, i32* %212
%214 = add i32 %213, %210
store i32 %214, i32* %212
%215 = load i32, i32* %15
%216 = lshr i32 %215, 8
store i32 %216, i32* %15
%217 = load i32, i32* %15
%218 = and i32 %217, 255
%219 = load i32*, i32** %7
%220 = getelementptr inbounds i32, i32* %219, i64 1
%221 = load i32, i32* %220
%222 = add i32 %221, %218
store i32 %222, i32* %220
%223 = load i32, i32* %15
%224 = lshr i32 %223, 8
store i32 %224, i32* %15
%225 = load i32, i32* %15
%226 = and i32 %225, 255
%227 = load i32*, i32** %7
%228 = getelementptr inbounds i32, i32* %227, i64 2
%229 = load i32, i32* %228
%230 = add i32 %229, %226
store i32 %230, i32* %228
%231 = load i32, i32* %15
%232 = lshr i32 %231, 8
store i32 %232, i32* %15
%233 = load i32, i32* %15
%234 = load i32*, i32** %7
%235 = getelementptr inbounds i32, i32* %234, i64 3
%236 = load i32, i32* %235
%237 = add i32 %236, %233
store i32 %237, i32* %235
ret void
}

LLVM IR (-O2):
@ForwardDNAAllOccCountNoLimit.truncateRightMask = internal unnamed_addr constant [16 x i32] [i32 0, i32 -1073741824, i32 -268435456, i32 -67108864, i32 -16777216, i32 -4194304, i32 -1048576, i32 -262144, i32 -65536, i32 -16384, i32 -4096, i32 -1024, i32 -256, i32 -64, i32 -16, i32 -4]
@stderr = global i32 0
@.str = [56 x i8] c"ForwardDNAAllOccCountNoLimit(): DNA occ sum exception!\0A\00"
define void @ForwardDNAAllOccCountNoLimit(i32* nocapture %0, i32 %1, i32* noalias nocapture %2, i32* nocapture %3) {
%5 = getelementptr inbounds i32, i32* %2, i64 1
%6 = getelementptr inbounds i32, i32* %2, i64 2
%7 = getelementptr inbounds i32, i32* %2, i64 3
%8 = and i32 %1, 255
%9 = lshr i32 %8, 4
%10 = and i32 %1, 240
%11 = sub nsw i32 %8, %10
%12 = icmp ult i32 %1, 256
%13 = bitcast i32* %2 to i8*
br i1 %12, label %212, label %14
14: ; preds = %4
%15 = lshr i32 %1, 8
br label %16
16: ; preds = %14, %242
%17 = phi i32* [ %209, %242 ], [ %0, %14 ]
%18 = phi i32 [ %247, %242 ], [ 0, %14 ]
%19 = load i32, i32* %17
%20 = lshr i32 %19, 16
%21 = zext i32 %20 to i64
%22 = getelementptr inbounds i32, i32* %3, i64 %21
%23 = load i32, i32* %22
%24 = and i32 %19, 65535
%25 = zext i32 %24 to i64
%26 = getelementptr inbounds i32, i32* %3, i64 %25
%27 = load i32, i32* %26
%28 = add i32 %23, %27
%29 = getelementptr inbounds i32, i32* %17, i64 1
%30 = load i32, i32* %29
%31 = lshr i32 %30, 16
%32 = zext i32 %31 to i64
%33 = getelementptr inbounds i32, i32* %3, i64 %32
%34 = load i32, i32* %33
%35 = add i32 %34, %28
%36 = and i32 %30, 65535
%37 = zext i32 %36 to i64
%38 = getelementptr inbounds i32, i32* %3, i64 %37
%39 = load i32, i32* %38
%40 = add i32 %35, %39
%41 = getelementptr inbounds i32, i32* %17, i64 2
%42 = load i32, i32* %41
%43 = lshr i32 %42, 16
%44 = zext i32 %43 to i64
%45 = getelementptr inbounds i32, i32* %3, i64 %44
%46 = load i32, i32* %45
%47 = add i32 %46, %40
%48 = and i32 %42, 65535
%49 = zext i32 %48 to i64
%50 = getelementptr inbounds i32, i32* %3, i64 %49
%51 = load i32, i32* %50
%52 = add i32 %47, %51
%53 = getelementptr inbounds i32, i32* %17, i64 3
%54 = load i32, i32* %53
%55 = lshr i32 %54, 16
%56 = zext i32 %55 to i64
%57 = getelementptr inbounds i32, i32* %3, i64 %56
%58 = load i32, i32* %57
%59 = add i32 %58, %52
%60 = and i32 %54, 65535
%61 = zext i32 %60 to i64
%62 = getelementptr inbounds i32, i32* %3, i64 %61
%63 = load i32, i32* %62
%64 = add i32 %59, %63
%65 = getelementptr inbounds i32, i32* %17, i64 4
%66 = load i32, i32* %65
%67 = lshr i32 %66, 16
%68 = zext i32 %67 to i64
%69 = getelementptr inbounds i32, i32* %3, i64 %68
%70 = load i32, i32* %69
%71 = add i32 %70, %64
%72 = and i32 %66, 65535
%73 = zext i32 %72 to i64
%74 = getelementptr inbounds i32, i32* %3, i64 %73
%75 = load i32, i32* %74
%76 = add i32 %71, %75
%77 = getelementptr inbounds i32, i32* %17, i64 5
%78 = load i32, i32* %77
%79 = lshr i32 %78, 16
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %3, i64 %80
%82 = load i32, i32* %81
%83 = add i32 %82, %76
%84 = and i32 %78, 65535
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %3, i64 %85
%87 = load i32, i32* %86
%88 = add i32 %83, %87
%89 = getelementptr inbounds i32, i32* %17, i64 6
%90 = load i32, i32* %89
%91 = lshr i32 %90, 16
%92 = zext i32 %91 to i64
%93 = getelementptr inbounds i32, i32* %3, i64 %92
%94 = load i32, i32* %93
%95 = add i32 %94, %88
%96 = and i32 %90, 65535
%97 = zext i32 %96 to i64
%98 = getelementptr inbounds i32, i32* %3, i64 %97
%99 = load i32, i32* %98
%100 = add i32 %95, %99
%101 = getelementptr inbounds i32, i32* %17, i64 7
%102 = load i32, i32* %101
%103 = lshr i32 %102, 16
%104 = zext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %3, i64 %104
%106 = load i32, i32* %105
%107 = add i32 %106, %100
%108 = and i32 %102, 65535
%109 = zext i32 %108 to i64
%110 = getelementptr inbounds i32, i32* %3, i64 %109
%111 = load i32, i32* %110
%112 = add i32 %107, %111
%113 = getelementptr inbounds i32, i32* %17, i64 8
%114 = load i32, i32* %113
%115 = lshr i32 %114, 16
%116 = zext i32 %115 to i64
%117 = getelementptr inbounds i32, i32* %3, i64 %116
%118 = load i32, i32* %117
%119 = add i32 %118, %112
%120 = and i32 %114, 65535
%121 = zext i32 %120 to i64
%122 = getelementptr inbounds i32, i32* %3, i64 %121
%123 = load i32, i32* %122
%124 = add i32 %119, %123
%125 = getelementptr inbounds i32, i32* %17, i64 9
%126 = load i32, i32* %125
%127 = lshr i32 %126, 16
%128 = zext i32 %127 to i64
%129 = getelementptr inbounds i32, i32* %3, i64 %128
%130 = load i32, i32* %129
%131 = add i32 %130, %124
%132 = and i32 %126, 65535
%133 = zext i32 %132 to i64
%134 = getelementptr inbounds i32, i32* %3, i64 %133
%135 = load i32, i32* %134
%136 = add i32 %131, %135
%137 = getelementptr inbounds i32, i32* %17, i64 10
%138 = load i32, i32* %137
%139 = lshr i32 %138, 16
%140 = zext i32 %139 to i64
%141 = getelementptr inbounds i32, i32* %3, i64 %140
%142 = load i32, i32* %141
%143 = add i32 %142, %136
%144 = and i32 %138, 65535
%145 = zext i32 %144 to i64
%146 = getelementptr inbounds i32, i32* %3, i64 %145
%147 = load i32, i32* %146
%148 = add i32 %143, %147
%149 = getelementptr inbounds i32, i32* %17, i64 11
%150 = load i32, i32* %149
%151 = lshr i32 %150, 16
%152 = zext i32 %151 to i64
%153 = getelementptr inbounds i32, i32* %3, i64 %152
%154 = load i32, i32* %153
%155 = add i32 %154, %148
%156 = and i32 %150, 65535
%157 = zext i32 %156 to i64
%158 = getelementptr inbounds i32, i32* %3, i64 %157
%159 = load i32, i32* %158
%160 = add i32 %155, %159
%161 = getelementptr inbounds i32, i32* %17, i64 12
%162 = load i32, i32* %161
%163 = lshr i32 %162, 16
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %3, i64 %164
%166 = load i32, i32* %165
%167 = add i32 %166, %160
%168 = and i32 %162, 65535
%169 = zext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %3, i64 %169
%171 = load i32, i32* %170
%172 = add i32 %167, %171
%173 = getelementptr inbounds i32, i32* %17, i64 13
%174 = load i32, i32* %173
%175 = lshr i32 %174, 16
%176 = zext i32 %175 to i64
%177 = getelementptr inbounds i32, i32* %3, i64 %176
%178 = load i32, i32* %177
%179 = add i32 %178, %172
%180 = and i32 %174, 65535
%181 = zext i32 %180 to i64
%182 = getelementptr inbounds i32, i32* %3, i64 %181
%183 = load i32, i32* %182
%184 = add i32 %179, %183
%185 = getelementptr inbounds i32, i32* %17, i64 14
%186 = load i32, i32* %185
%187 = lshr i32 %186, 16
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %3, i64 %188
%190 = load i32, i32* %189
%191 = add i32 %190, %184
%192 = and i32 %186, 65535
%193 = zext i32 %192 to i64
%194 = getelementptr inbounds i32, i32* %3, i64 %193
%195 = load i32, i32* %194
%196 = add i32 %191, %195
%197 = getelementptr inbounds i32, i32* %17, i64 15
%198 = load i32, i32* %197
%199 = lshr i32 %198, 16
%200 = zext i32 %199 to i64
%201 = getelementptr inbounds i32, i32* %3, i64 %200
%202 = load i32, i32* %201
%203 = add i32 %202, %196
%204 = and i32 %198, 65535
%205 = zext i32 %204 to i64
%206 = getelementptr inbounds i32, i32* %3, i64 %205
%207 = load i32, i32* %206
%208 = add i32 %203, %207
%209 = getelementptr i32, i32* %17, i64 16
%210 = and i32 %208, -16843009
%211 = icmp eq i32 %210, 0
br i1 %211, label %234, label %221
212: ; preds = %242, %4
%213 = phi i32* [ %0, %4 ], [ %209, %242 ]
%214 = icmp ult i32 %8, 16
br i1 %214, label %298, label %215
215: ; preds = %212
%216 = call i32 @llvm.umax.i32(i32 %9, i32 1)
%217 = and i32 %216, 1
%218 = icmp ult i32 %8, 32
br i1 %218, label %279, label %219
219: ; preds = %215
%220 = and i32 %216, 14
br label %249
221: ; preds = %16
%222 = and i32 %208, 255
%223 = load i32, i32* %2
%224 = add i32 %223, %222
store i32 %224, i32* %2
%225 = lshr i32 %208, 8
%226 = and i32 %225, 255
%227 = load i32, i32* %5
%228 = add i32 %227, %226
store i32 %228, i32* %5
%229 = lshr i32 %208, 16
%230 = and i32 %229, 255
%231 = load i32, i32* %6
%232 = add i32 %231, %230
store i32 %232, i32* %6
%233 = lshr i32 %208, 24
br label %242
234: ; preds = %16
switch i32 %208, label %238 [
i32 256, label %242
i32 65536, label %235
i32 16777216, label %236
i32 0, label %237
]
235: ; preds = %234
br label %242
236: ; preds = %234
br label %242
237: ; preds = %234
br label %242
238: ; preds = %234
%239 = load i32, i32* @stderr
%240 = tail call i32 @fprintf(i32 %239, i8* getelementptr inbounds ([56 x i8], [56 x i8]* @.str, i64 0, i64 0))
%241 = tail call i32 @exit(i32 1)
unreachable
242: ; preds = %234, %221, %235, %237, %236
%243 = phi i32* [ %7, %221 ], [ %5, %235 ], [ %7, %237 ], [ %6, %236 ], [ %2, %234 ]
%244 = phi i32 [ %233, %221 ], [ 256, %235 ], [ 256, %237 ], [ 256, %236 ], [ %208, %234 ]
%245 = load i32, i32* %243
%246 = add i32 %245, %244
store i32 %246, i32* %243
%247 = add nuw nsw i32 %18, 1
%248 = icmp eq i32 %247, %15
br i1 %248, label %212, label %16
249: ; preds = %249, %219
%250 = phi i32 [ 0, %219 ], [ %275, %249 ]
%251 = phi i32* [ %213, %219 ], [ %276, %249 ]
%252 = phi i32 [ 0, %219 ], [ %277, %249 ]
%253 = load i32, i32* %251
%254 = lshr i32 %253, 16
%255 = zext i32 %254 to i64
%256 = getelementptr inbounds i32, i32* %3, i64 %255
%257 = load i32, i32* %256
%258 = add i32 %257, %250
%259 = and i32 %253, 65535
%260 = zext i32 %259 to i64
%261 = getelementptr inbounds i32, i32* %3, i64 %260
%262 = load i32, i32* %261
%263 = add i32 %258, %262
%264 = getelementptr inbounds i32, i32* %251, i64 1
%265 = load i32, i32* %264
%266 = lshr i32 %265, 16
%267 = zext i32 %266 to i64
%268 = getelementptr inbounds i32, i32* %3, i64 %267
%269 = load i32, i32* %268
%270 = add i32 %269, %263
%271 = and i32 %265, 65535
%272 = zext i32 %271 to i64
%273 = getelementptr inbounds i32, i32* %3, i64 %272
%274 = load i32, i32* %273
%275 = add i32 %270, %274
%276 = getelementptr inbounds i32, i32* %251, i64 2
%277 = add i32 %252, 2
%278 = icmp eq i32 %277, %220
br i1 %278, label %279, label %249
279: ; preds = %249, %215
%280 = phi i32 [ undef, %215 ], [ %275, %249 ]
%281 = phi i32* [ undef, %215 ], [ %276, %249 ]
%282 = phi i32 [ 0, %215 ], [ %275, %249 ]
%283 = phi i32* [ %213, %215 ], [ %276, %249 ]
%284 = icmp eq i32 %217, 0
br i1 %284, label %298, label %285
285: ; preds = %279
%286 = load i32, i32* %283
%287 = lshr i32 %286, 16
%288 = zext i32 %287 to i64
%289 = getelementptr inbounds i32, i32* %3, i64 %288
%290 = load i32, i32* %289
%291 = add i32 %290, %282
%292 = and i32 %286, 65535
%293 = zext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %3, i64 %293
%295 = load i32, i32* %294
%296 = add i32 %291, %295
%297 = getelementptr inbounds i32, i32* %283, i64 1
br label %298
298: ; preds = %285, %279, %212
%299 = phi i32* [ %213, %212 ], [ %281, %279 ], [ %297, %285 ]
%300 = phi i32 [ 0, %212 ], [ %280, %279 ], [ %296, %285 ]
%301 = icmp eq i32 %11, 0
br i1 %301, label %320, label %302
302: ; preds = %298
%303 = load i32, i32* %299
%304 = zext i32 %11 to i64
%305 = getelementptr inbounds [16 x i32], [16 x i32]* @ForwardDNAAllOccCountNoLimit.truncateRightMask, i64 0, i64 %304
%306 = load i32, i32* %305
%307 = and i32 %306, %303
%308 = lshr i32 %307, 16
%309 = zext i32 %308 to i64
%310 = getelementptr inbounds i32, i32* %3, i64 %309
%311 = load i32, i32* %310
%312 = and i32 %307, 65535
%313 = zext i32 %312 to i64
%314 = getelementptr inbounds i32, i32* %3, i64 %313
%315 = load i32, i32* %314
%316 = add nsw i32 %11, -16
%317 = add i32 %316, %300
%318 = add i32 %317, %311
%319 = add i32 %318, %315
br label %320
320: ; preds = %302, %298
%321 = phi i32 [ %319, %302 ], [ %300, %298 ]
%322 = and i32 %321, 255
%323 = load i32, i32* %2
%324 = add i32 %323, %322
store i32 %324, i32* %2
%325 = lshr i32 %321, 8
%326 = and i32 %325, 255
%327 = load i32, i32* %5
%328 = add i32 %327, %326
store i32 %328, i32* %5
%329 = lshr i32 %321, 16
%330 = and i32 %329, 255
%331 = load i32, i32* %6
%332 = add i32 %331, %330
store i32 %332, i32* %6
%333 = lshr i32 %321, 24
%334 = load i32, i32* %7
%335 = add i32 %334, %333
store i32 %335, i32* %7
ret void
}