void BWTGenerateOccValueFromBwt(const unsigned int *bwt,
                                unsigned int *__restrict occValue,
                                unsigned int *__restrict occValueMajor,
                                const unsigned int textLength,
                                const unsigned int *decodeTable) {
  unsigned int numberOfOccValueMajor, numberOfOccValue;
  unsigned int wordBetweenOccValue;
  unsigned int numberOfOccIntervalPerMajor;
  unsigned int c;
  unsigned int i, j;
  unsigned int occMajorIndex;
  unsigned int occIndex, bwtIndex;
  unsigned int sum;
  unsigned int tempOccValue0[4], tempOccValue1[4];
  wordBetweenOccValue = 256 / 16;
  numberOfOccValue = (textLength + 256 - 1) / 256 + 1;
  numberOfOccIntervalPerMajor = 65536 / 256;
  numberOfOccValueMajor = (numberOfOccValue + numberOfOccIntervalPerMajor - 1) /
                          numberOfOccIntervalPerMajor;
  tempOccValue0[0] = 0;
  tempOccValue0[1] = 0;
  tempOccValue0[2] = 0;
  tempOccValue0[3] = 0;
  occValueMajor[0] = 0;
  occValueMajor[1] = 0;
  occValueMajor[2] = 0;
  occValueMajor[3] = 0;
  occIndex = 0;
  bwtIndex = 0;
  for (occMajorIndex = 1; occMajorIndex < numberOfOccValueMajor;
       occMajorIndex++) {
    for (i = 0; i < numberOfOccIntervalPerMajor / 2; i++) {
      sum = 0;
      tempOccValue1[0] = tempOccValue0[0];
      tempOccValue1[1] = tempOccValue0[1];
      tempOccValue1[2] = tempOccValue0[2];
      tempOccValue1[3] = tempOccValue0[3];
      for (j = 0; j < wordBetweenOccValue; j++) {
        c = bwt[bwtIndex];
        sum += decodeTable[c >> 16];
        sum += decodeTable[c & 0x0000FFFF];
        bwtIndex++;
      }
      if (!((sum & 0xfefefeff) == 0)) {
        tempOccValue1[0] += (sum & 0x000000FF);
        sum >>= 8;
        tempOccValue1[1] += (sum & 0x000000FF);
        sum >>= 8;
        tempOccValue1[2] += (sum & 0x000000FF);
        sum >>= 8;
        tempOccValue1[3] += sum;
      } else {
        if (sum == 0x00000100) {
          tempOccValue1[0] += 256;
        } else if (sum == 0x00010000) {
          tempOccValue1[1] += 256;
        } else if (sum == 0x01000000) {
          tempOccValue1[2] += 256;
        } else {
          tempOccValue1[3] += 256;
        }
      }
      occValue[occIndex * 4 + 0] = (tempOccValue0[0] << 16) | tempOccValue1[0];
      occValue[occIndex * 4 + 1] = (tempOccValue0[1] << 16) | tempOccValue1[1];
      occValue[occIndex * 4 + 2] = (tempOccValue0[2] << 16) | tempOccValue1[2];
      occValue[occIndex * 4 + 3] = (tempOccValue0[3] << 16) | tempOccValue1[3];
      tempOccValue0[0] = tempOccValue1[0];
      tempOccValue0[1] = tempOccValue1[1];
      tempOccValue0[2] = tempOccValue1[2];
      tempOccValue0[3] = tempOccValue1[3];
      sum = 0;
      occIndex++;
      for (j = 0; j < wordBetweenOccValue; j++) {
        c = bwt[bwtIndex];
        sum += decodeTable[c >> 16];
        sum += decodeTable[c & 0x0000FFFF];
        bwtIndex++;
      }
      if (!((sum & 0xfefefeff) == 0)) {
        tempOccValue0[0] += (sum & 0x000000FF);
        sum >>= 8;
        tempOccValue0[1] += (sum & 0x000000FF);
        sum >>= 8;
        tempOccValue0[2] += (sum & 0x000000FF);
        sum >>= 8;
        tempOccValue0[3] += sum;
      } else {
        if (sum == 0x00000100) {
          tempOccValue0[0] += 256;
        } else if (sum == 0x00010000) {
          tempOccValue0[1] += 256;
        } else if (sum == 0x01000000) {
          tempOccValue0[2] += 256;
        } else {
          tempOccValue0[3] += 256;
        }
      }
    }
    occValueMajor[occMajorIndex * 4 + 0] =
        occValueMajor[(occMajorIndex - 1) * 4 + 0] + tempOccValue0[0];
    occValueMajor[occMajorIndex * 4 + 1] =
        occValueMajor[(occMajorIndex - 1) * 4 + 1] + tempOccValue0[1];
    occValueMajor[occMajorIndex * 4 + 2] =
        occValueMajor[(occMajorIndex - 1) * 4 + 2] + tempOccValue0[2];
    occValueMajor[occMajorIndex * 4 + 3] =
        occValueMajor[(occMajorIndex - 1) * 4 + 3] + tempOccValue0[3];
    tempOccValue0[0] = 0;
    tempOccValue0[1] = 0;
    tempOccValue0[2] = 0;
    tempOccValue0[3] = 0;
  }
  while (occIndex < (numberOfOccValue - 1) / 2) {
    sum = 0;
    tempOccValue1[0] = tempOccValue0[0];
    tempOccValue1[1] = tempOccValue0[1];
    tempOccValue1[2] = tempOccValue0[2];
    tempOccValue1[3] = tempOccValue0[3];
    for (j = 0; j < wordBetweenOccValue; j++) {
      c = bwt[bwtIndex];
      sum += decodeTable[c >> 16];
      sum += decodeTable[c & 0x0000FFFF];
      bwtIndex++;
    }
    if (!((sum & 0xfefefeff) == 0)) {
      tempOccValue1[0] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue1[1] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue1[2] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue1[3] += sum;
    } else {
      if (sum == 0x00000100) {
        tempOccValue1[0] += 256;
      } else if (sum == 0x00010000) {
        tempOccValue1[1] += 256;
      } else if (sum == 0x01000000) {
        tempOccValue1[2] += 256;
      } else {
        tempOccValue1[3] += 256;
      }
    }
    occValue[occIndex * 4 + 0] = (tempOccValue0[0] << 16) | tempOccValue1[0];
    occValue[occIndex * 4 + 1] = (tempOccValue0[1] << 16) | tempOccValue1[1];
    occValue[occIndex * 4 + 2] = (tempOccValue0[2] << 16) | tempOccValue1[2];
    occValue[occIndex * 4 + 3] = (tempOccValue0[3] << 16) | tempOccValue1[3];
    tempOccValue0[0] = tempOccValue1[0];
    tempOccValue0[1] = tempOccValue1[1];
    tempOccValue0[2] = tempOccValue1[2];
    tempOccValue0[3] = tempOccValue1[3];
    sum = 0;
    occIndex++;
    for (j = 0; j < wordBetweenOccValue; j++) {
      c = bwt[bwtIndex];
      sum += decodeTable[c >> 16];
      sum += decodeTable[c & 0x0000FFFF];
      bwtIndex++;
    }
    if (!((sum & 0xfefefeff) == 0)) {
      tempOccValue0[0] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue0[1] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue0[2] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue0[3] += sum;
    } else {
      if (sum == 0x00000100) {
        tempOccValue0[0] += 256;
      } else if (sum == 0x00010000) {
        tempOccValue0[1] += 256;
      } else if (sum == 0x01000000) {
        tempOccValue0[2] += 256;
      } else {
        tempOccValue0[3] += 256;
      }
    }
  }
  sum = 0;
  tempOccValue1[0] = tempOccValue0[0];
  tempOccValue1[1] = tempOccValue0[1];
  tempOccValue1[2] = tempOccValue0[2];
  tempOccValue1[3] = tempOccValue0[3];
  if (occIndex * 2 < numberOfOccValue - 1) {
    for (j = 0; j < wordBetweenOccValue; j++) {
      c = bwt[bwtIndex];
      sum += decodeTable[c >> 16];
      sum += decodeTable[c & 0x0000FFFF];
      bwtIndex++;
    }
    if (!((sum & 0xfefefeff) == 0)) {
      tempOccValue1[0] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue1[1] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue1[2] += (sum & 0x000000FF);
      sum >>= 8;
      tempOccValue1[3] += sum;
    } else {
      if (sum == 0x00000100) {
        tempOccValue1[0] += 256;
      } else if (sum == 0x00010000) {
        tempOccValue1[1] += 256;
      } else if (sum == 0x01000000) {
        tempOccValue1[2] += 256;
      } else {
        tempOccValue1[3] += 256;
      }
    }
  }
  occValue[occIndex * 4 + 0] = (tempOccValue0[0] << 16) | tempOccValue1[0];
  occValue[occIndex * 4 + 1] = (tempOccValue0[1] << 16) | tempOccValue1[1];
  occValue[occIndex * 4 + 2] = (tempOccValue0[2] << 16) | tempOccValue1[2];
  occValue[occIndex * 4 + 3] = (tempOccValue0[3] << 16) | tempOccValue1[3];
}


x86 assembly (clang, -O0):
<BWTGenerateOccValueFromBwt>:
push   %rbp
mov    %rsp,%rbp
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %ecx,-0x1c(%rbp)
mov    %r8,-0x28(%rbp)
movl   $0x10,-0x34(%rbp)
mov    -0x1c(%rbp),%eax
add    $0x100,%eax
sub    $0x1,%eax
shr    $0x8,%eax
add    $0x1,%eax
mov    %eax,-0x30(%rbp)
movl   $0x100,-0x38(%rbp)
mov    -0x30(%rbp),%eax
add    -0x38(%rbp),%eax
sub    $0x1,%eax
xor    %edx,%edx
divl   -0x38(%rbp)
mov    %eax,-0x2c(%rbp)
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x64(%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)
movl   $0x0,-0x4c(%rbp)
movl   $0x0,-0x50(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x2c(%rbp),%eax
jae    15d4 <BWTGenerateOccValueFromBwt+0x4d4>
movl   $0x0,-0x40(%rbp)
mov    -0x40(%rbp),%eax
mov    -0x38(%rbp),%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    1502 <BWTGenerateOccValueFromBwt+0x402>
movl   $0x0,-0x54(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    124d <BWTGenerateOccValueFromBwt+0x14d>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    11f0 <BWTGenerateOccValueFromBwt+0xf0>
mov    -0x54(%rbp),%eax
and    $0xfefefeff,%eax
cmp    $0x0,%eax
je     12b1 <BWTGenerateOccValueFromBwt+0x1b1>
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    1322 <BWTGenerateOccValueFromBwt+0x222>
cmpl   $0x100,-0x54(%rbp)
jne    12ce <BWTGenerateOccValueFromBwt+0x1ce>
mov    -0x80(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x80(%rbp)
jmp    131d <BWTGenerateOccValueFromBwt+0x21d>
cmpl   $0x10000,-0x54(%rbp)
jne    12eb <BWTGenerateOccValueFromBwt+0x1eb>
mov    -0x7c(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x7c(%rbp)
jmp    1318 <BWTGenerateOccValueFromBwt+0x218>
cmpl   $0x1000000,-0x54(%rbp)
jne    1308 <BWTGenerateOccValueFromBwt+0x208>
mov    -0x78(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x78(%rbp)
jmp    1313 <BWTGenerateOccValueFromBwt+0x213>
mov    -0x74(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x74(%rbp)
jmp    1318 <BWTGenerateOccValueFromBwt+0x218>
jmp    131d <BWTGenerateOccValueFromBwt+0x21d>
jmp    1322 <BWTGenerateOccValueFromBwt+0x222>
mov    -0x70(%rbp),%edx
shl    $0x10,%edx
or     -0x80(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%edx
shl    $0x10,%edx
or     -0x7c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
shl    $0x10,%edx
or     -0x78(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
shl    $0x10,%edx
or     -0x74(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    141a <BWTGenerateOccValueFromBwt+0x31a>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    13bd <BWTGenerateOccValueFromBwt+0x2bd>
mov    -0x54(%rbp),%eax
and    $0xfefefeff,%eax
cmp    $0x0,%eax
je     147e <BWTGenerateOccValueFromBwt+0x37e>
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    14ef <BWTGenerateOccValueFromBwt+0x3ef>
cmpl   $0x100,-0x54(%rbp)
jne    149b <BWTGenerateOccValueFromBwt+0x39b>
mov    -0x70(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x70(%rbp)
jmp    14ea <BWTGenerateOccValueFromBwt+0x3ea>
cmpl   $0x10000,-0x54(%rbp)
jne    14b8 <BWTGenerateOccValueFromBwt+0x3b8>
mov    -0x6c(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x6c(%rbp)
jmp    14e5 <BWTGenerateOccValueFromBwt+0x3e5>
cmpl   $0x1000000,-0x54(%rbp)
jne    14d5 <BWTGenerateOccValueFromBwt+0x3d5>
mov    -0x68(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x68(%rbp)
jmp    14e0 <BWTGenerateOccValueFromBwt+0x3e0>
mov    -0x64(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x64(%rbp)
jmp    14e5 <BWTGenerateOccValueFromBwt+0x3e5>
jmp    14ea <BWTGenerateOccValueFromBwt+0x3ea>
jmp    14ef <BWTGenerateOccValueFromBwt+0x3ef>
jmp    14f4 <BWTGenerateOccValueFromBwt+0x3f4>
mov    -0x40(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x40(%rbp)
jmp    11b9 <BWTGenerateOccValueFromBwt+0xb9>
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%edx
add    -0x70(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%edx
add    -0x6c(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%edx
add    -0x68(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%edx
add    -0x64(%rbp),%edx
mov    -0x18(%rbp),%rax
mov    -0x48(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
movl   $0x0,-0x70(%rbp)
movl   $0x0,-0x6c(%rbp)
movl   $0x0,-0x68(%rbp)
movl   $0x0,-0x64(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    11a6 <BWTGenerateOccValueFromBwt+0xa6>
jmp    15d9 <BWTGenerateOccValueFromBwt+0x4d9>
mov    -0x4c(%rbp),%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
shr    $0x1,%ecx
cmp    %ecx,%eax
jae    1917 <BWTGenerateOccValueFromBwt+0x817>
movl   $0x0,-0x54(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x74(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    1670 <BWTGenerateOccValueFromBwt+0x570>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1613 <BWTGenerateOccValueFromBwt+0x513>
mov    -0x54(%rbp),%eax
and    $0xfefefeff,%eax
cmp    $0x0,%eax
je     16d4 <BWTGenerateOccValueFromBwt+0x5d4>
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    1745 <BWTGenerateOccValueFromBwt+0x645>
cmpl   $0x100,-0x54(%rbp)
jne    16f1 <BWTGenerateOccValueFromBwt+0x5f1>
mov    -0x80(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x80(%rbp)
jmp    1740 <BWTGenerateOccValueFromBwt+0x640>
cmpl   $0x10000,-0x54(%rbp)
jne    170e <BWTGenerateOccValueFromBwt+0x60e>
mov    -0x7c(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x7c(%rbp)
jmp    173b <BWTGenerateOccValueFromBwt+0x63b>
cmpl   $0x1000000,-0x54(%rbp)
jne    172b <BWTGenerateOccValueFromBwt+0x62b>
mov    -0x78(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x78(%rbp)
jmp    1736 <BWTGenerateOccValueFromBwt+0x636>
mov    -0x74(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x74(%rbp)
jmp    173b <BWTGenerateOccValueFromBwt+0x63b>
jmp    1740 <BWTGenerateOccValueFromBwt+0x640>
jmp    1745 <BWTGenerateOccValueFromBwt+0x645>
mov    -0x70(%rbp),%edx
shl    $0x10,%edx
or     -0x80(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%edx
shl    $0x10,%edx
or     -0x7c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
shl    $0x10,%edx
or     -0x78(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
shl    $0x10,%edx
or     -0x74(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x80(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x7c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x78(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x74(%rbp),%eax
mov    %eax,-0x64(%rbp)
movl   $0x0,-0x54(%rbp)
mov    -0x4c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x4c(%rbp)
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    183d <BWTGenerateOccValueFromBwt+0x73d>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    17e0 <BWTGenerateOccValueFromBwt+0x6e0>
mov    -0x54(%rbp),%eax
and    $0xfefefeff,%eax
cmp    $0x0,%eax
je     18a1 <BWTGenerateOccValueFromBwt+0x7a1>
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x70(%rbp),%eax
mov    %eax,-0x70(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x6c(%rbp),%eax
mov    %eax,-0x6c(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x68(%rbp),%eax
mov    %eax,-0x68(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x64(%rbp),%eax
mov    %eax,-0x64(%rbp)
jmp    1912 <BWTGenerateOccValueFromBwt+0x812>
cmpl   $0x100,-0x54(%rbp)
jne    18be <BWTGenerateOccValueFromBwt+0x7be>
mov    -0x70(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x70(%rbp)
jmp    190d <BWTGenerateOccValueFromBwt+0x80d>
cmpl   $0x10000,-0x54(%rbp)
jne    18db <BWTGenerateOccValueFromBwt+0x7db>
mov    -0x6c(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x6c(%rbp)
jmp    1908 <BWTGenerateOccValueFromBwt+0x808>
cmpl   $0x1000000,-0x54(%rbp)
jne    18f8 <BWTGenerateOccValueFromBwt+0x7f8>
mov    -0x68(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x68(%rbp)
jmp    1903 <BWTGenerateOccValueFromBwt+0x803>
mov    -0x64(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x64(%rbp)
jmp    1908 <BWTGenerateOccValueFromBwt+0x808>
jmp    190d <BWTGenerateOccValueFromBwt+0x80d>
jmp    1912 <BWTGenerateOccValueFromBwt+0x812>
jmp    15d9 <BWTGenerateOccValueFromBwt+0x4d9>
movl   $0x0,-0x54(%rbp)
mov    -0x70(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x6c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x68(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x64(%rbp),%eax
mov    %eax,-0x74(%rbp)
mov    -0x4c(%rbp),%eax
shl    $0x1,%eax
mov    -0x30(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jae    1a88 <BWTGenerateOccValueFromBwt+0x988>
movl   $0x0,-0x44(%rbp)
mov    -0x44(%rbp),%eax
cmp    -0x34(%rbp),%eax
jae    19ae <BWTGenerateOccValueFromBwt+0x8ae>
mov    -0x8(%rbp),%rax
mov    -0x50(%rbp),%ecx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x3c(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
shr    $0x10,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x28(%rbp),%rax
mov    -0x3c(%rbp),%ecx
and    $0xffff,%ecx
mov    %ecx,%ecx
mov    (%rax,%rcx,4),%eax
add    -0x54(%rbp),%eax
mov    %eax,-0x54(%rbp)
mov    -0x50(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x50(%rbp)
mov    -0x44(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x44(%rbp)
jmp    1951 <BWTGenerateOccValueFromBwt+0x851>
mov    -0x54(%rbp),%eax
and    $0xfefefeff,%eax
cmp    $0x0,%eax
je     1a12 <BWTGenerateOccValueFromBwt+0x912>
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x80(%rbp),%eax
mov    %eax,-0x80(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x7c(%rbp),%eax
mov    %eax,-0x7c(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
and    $0xff,%eax
add    -0x78(%rbp),%eax
mov    %eax,-0x78(%rbp)
mov    -0x54(%rbp),%eax
shr    $0x8,%eax
mov    %eax,-0x54(%rbp)
mov    -0x54(%rbp),%eax
add    -0x74(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    1a83 <BWTGenerateOccValueFromBwt+0x983>
cmpl   $0x100,-0x54(%rbp)
jne    1a2f <BWTGenerateOccValueFromBwt+0x92f>
mov    -0x80(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x80(%rbp)
jmp    1a7e <BWTGenerateOccValueFromBwt+0x97e>
cmpl   $0x10000,-0x54(%rbp)
jne    1a4c <BWTGenerateOccValueFromBwt+0x94c>
mov    -0x7c(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x7c(%rbp)
jmp    1a79 <BWTGenerateOccValueFromBwt+0x979>
cmpl   $0x1000000,-0x54(%rbp)
jne    1a69 <BWTGenerateOccValueFromBwt+0x969>
mov    -0x78(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x78(%rbp)
jmp    1a74 <BWTGenerateOccValueFromBwt+0x974>
mov    -0x74(%rbp),%eax
add    $0x100,%eax
mov    %eax,-0x74(%rbp)
jmp    1a79 <BWTGenerateOccValueFromBwt+0x979>
jmp    1a7e <BWTGenerateOccValueFromBwt+0x97e>
jmp    1a83 <BWTGenerateOccValueFromBwt+0x983>
jmp    1a88 <BWTGenerateOccValueFromBwt+0x988>
mov    -0x70(%rbp),%edx
shl    $0x10,%edx
or     -0x80(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x0,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x6c(%rbp),%edx
shl    $0x10,%edx
or     -0x7c(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x1,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x68(%rbp),%edx
shl    $0x10,%edx
or     -0x78(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x2,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
mov    -0x64(%rbp),%edx
shl    $0x10,%edx
or     -0x74(%rbp),%edx
mov    -0x10(%rbp),%rax
mov    -0x4c(%rbp),%ecx
shl    $0x2,%ecx
add    $0x3,%ecx
mov    %ecx,%ecx
mov    %edx,(%rax,%rcx,4)
pop    %rbp
ret

x86 assembly (clang, -O2):
<BWTGenerateOccValueFromBwt>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
mov    %ecx,%ebx
mov    %rsi,-0x28(%rsp)
add    $0xff,%ebx
mov    %ebx,%esi
shr    $0x8,%esi
xor    %ecx,%ecx
xorps  %xmm0,%xmm0
mov    %rdx,-0x10(%rsp)
movups %xmm0,(%rdx)
mov    $0x0,%ebp
mov    $0x0,%r15d
cmp    $0x10000,%ebx
mov    %rsi,-0x20(%rsp)
jb     1695 <BWTGenerateOccValueFromBwt+0x595>
mov    %rbx,-0x30(%rsp)
lea    0x100(%rsi),%eax
shr    $0x8,%eax
cmp    $0x3,%eax
mov    $0x2,%ecx
cmovae %eax,%ecx
mov    %rcx,-0x18(%rsp)
mov    -0x28(%rsp),%rax
lea    0xc(%rax),%r14
xor    %ecx,%ecx
mov    $0x1,%eax
mov    %rax,-0x40(%rsp)
xor    %eax,%eax
mov    %rax,-0x38(%rsp)
jmp    11e8 <BWTGenerateOccValueFromBwt+0xe8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x40(%rsp),%rsi
mov    %rsi,%rax
shl    $0x4,%rax
mov    -0x10(%rsp),%rdx
add    -0x10(%rdx,%rax,1),%r11d
mov    %r11d,(%rdx,%rax,1)
add    -0xc(%rdx,%rax,1),%ebx
mov    %ebx,0x4(%rdx,%rax,1)
add    -0x8(%rdx,%rax,1),%r9d
mov    %r9d,0x8(%rdx,%rax,1)
add    -0x4(%rdx,%rax,1),%ecx
mov    %ecx,0xc(%rdx,%rax,1)
add    $0x1,%rsi
lea    (%r15,%rbp,1),%ecx
mov    -0x8(%rsp),%r14
add    $0x800,%r14
mov    %rsi,-0x40(%rsp)
cmp    -0x18(%rsp),%rsi
je     1681 <BWTGenerateOccValueFromBwt+0x581>
mov    %ecx,%r15d
mov    -0x38(%rsp),%rax
sub    $0xffffff80,%eax
mov    %rax,-0x38(%rsp)
mov    %r14,-0x8(%rsp)
xor    %ebp,%ebp
xor    %r11d,%r11d
xor    %ebx,%ebx
xor    %r9d,%r9d
xor    %ecx,%ecx
jmp    1240 <BWTGenerateOccValueFromBwt+0x140>
nopl   0x0(%rax,%rax,1)
movzbl %cl,%r11d
add    %r10d,%r11d
movzbl %ch,%ebx
add    %esi,%ebx
mov    %ecx,%eax
shr    $0x10,%eax
movzbl %al,%r9d
add    %r12d,%r9d
shr    $0x18,%ecx
add    %edx,%ecx
add    $0x20,%ebp
add    $0x10,%r14
cmp    $0x1000,%ebp
je     1190 <BWTGenerateOccValueFromBwt+0x90>
lea    (%r15,%rbp,1),%edx
mov    (%rdi,%rdx,4),%edx
movzwl %dx,%esi
shr    $0x10,%rdx
mov    (%r8,%rdx,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%esi
add    $0x1,%esi
mov    (%rdi,%rsi,4),%esi
movzwl %si,%eax
shr    $0x10,%rsi
add    (%r8,%rsi,4),%edx
add    (%r8,%rax,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x2,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x3,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x4,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x5,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x6,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x7,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x8,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0x9,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0xa,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0xb,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0xc,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0xd,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0xe,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%eax
add    $0xf,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%esi
shr    $0x10,%rax
add    (%r8,%rax,4),%edx
add    (%r8,%rsi,4),%edx
lea    (%r15,%rbp,1),%r13d
add    $0x10,%r13d
test   $0xfefefeff,%edx
je     1400 <BWTGenerateOccValueFromBwt+0x300>
movzbl %dl,%r10d
add    %r11d,%r10d
movzbl %dh,%esi
add    %ebx,%esi
mov    %edx,%eax
shr    $0x10,%eax
movzbl %al,%r12d
add    %r9d,%r12d
shr    $0x18,%edx
add    %ecx,%edx
jmp    144e <BWTGenerateOccValueFromBwt+0x34e>
nopl   0x0(%rax)
cmp    $0x1000000,%edx
je     1428 <BWTGenerateOccValueFromBwt+0x328>
cmp    $0x10000,%edx
je     1433 <BWTGenerateOccValueFromBwt+0x333>
cmp    $0x100,%edx
jne    1440 <BWTGenerateOccValueFromBwt+0x340>
lea    0x100(%r11),%r10d
mov    %ecx,%edx
mov    %r9d,%r12d
mov    %ebx,%esi
jmp    144e <BWTGenerateOccValueFromBwt+0x34e>
lea    0x100(%r9),%r12d
mov    %ecx,%edx
jmp    1449 <BWTGenerateOccValueFromBwt+0x349>
lea    0x100(%rbx),%esi
mov    %ecx,%edx
mov    %r9d,%r12d
jmp    144b <BWTGenerateOccValueFromBwt+0x34b>
lea    0x100(%rcx),%edx
mov    %r9d,%r12d
mov    %ebx,%esi
mov    %r11d,%r10d
shl    $0x10,%r11d
or     %r10d,%r11d
mov    %r11d,-0xc(%r14)
shl    $0x10,%ebx
or     %esi,%ebx
mov    %ebx,-0x8(%r14)
shl    $0x10,%r9d
or     %r12d,%r9d
mov    %r9d,-0x4(%r14)
shl    $0x10,%ecx
or     %edx,%ecx
mov    %ecx,(%r14)
mov    %r13d,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ebx
shr    $0x10,%rax
mov    (%r8,%rax,4),%ecx
add    (%r8,%rbx,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x11,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x12,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x13,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x14,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x15,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x16,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x17,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x18,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x19,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x1a,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x1b,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x1c,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x1d,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x1e,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
lea    (%r15,%rbp,1),%eax
add    $0x1f,%eax
mov    (%rdi,%rax,4),%ebx
mov    %rbx,%rax
shr    $0x10,%rax
add    (%r8,%rax,4),%ecx
movzwl %bx,%eax
add    (%r8,%rax,4),%ecx
test   $0xfefefeff,%ecx
jne    1210 <BWTGenerateOccValueFromBwt+0x110>
cmp    $0x1000000,%ecx
je     165b <BWTGenerateOccValueFromBwt+0x55b>
cmp    $0x10000,%ecx
je     1664 <BWTGenerateOccValueFromBwt+0x564>
cmp    $0x100,%ecx
jne    166c <BWTGenerateOccValueFromBwt+0x56c>
add    $0x100,%r10d
jmp    1672 <BWTGenerateOccValueFromBwt+0x572>
add    $0x100,%r12d
jmp    1672 <BWTGenerateOccValueFromBwt+0x572>
add    $0x100,%esi
jmp    1672 <BWTGenerateOccValueFromBwt+0x572>
add    $0x100,%edx
mov    %edx,%ecx
mov    %r12d,%r9d
mov    %esi,%ebx
mov    %r10d,%r11d
jmp    122d <BWTGenerateOccValueFromBwt+0x12d>
add    %ebp,%r15d
mov    -0x30(%rsp),%rbx
xor    %ecx,%ecx
mov    -0x20(%rsp),%rsi
mov    -0x38(%rsp),%rbp
shr    $0x9,%ebx
cmp    %ebx,%ebp
jae    1b2c <BWTGenerateOccValueFromBwt+0xa2c>
mov    %ebp,%eax
mov    %rbx,-0x30(%rsp)
mov    %ebx,%esi
sub    %rax,%rsi
shl    $0x2,%ebp
add    $0x1f,%r15d
xor    %r9d,%r9d
xor    %r12d,%r12d
xor    %r11d,%r11d
xor    %ecx,%ecx
jmp    16e7 <BWTGenerateOccValueFromBwt+0x5e7>
add    $0x100,%esi
mov    %ebx,%ecx
mov    %r14d,%r11d
mov    %esi,%r12d
mov    %r10d,%r9d
mov    -0x40(%rsp),%rsi
add    $0x4,%ebp
add    $0x20,%r15d
add    $0xffffffffffffffff,%rsi
je     1b3a <BWTGenerateOccValueFromBwt+0xa3a>
mov    %rcx,%r13
lea    -0x1f(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
mov    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x1e(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x1d(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x1c(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x1b(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x1a(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x19(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x18(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x17(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x16(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x15(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x14(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x13(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x12(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x11(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0x10(%r15),%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
add    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    -0xf(%r15),%ecx
test   $0xfefefeff,%ebx
mov    %rsi,-0x40(%rsp)
je     1880 <BWTGenerateOccValueFromBwt+0x780>
movzbl %bl,%r10d
add    %r9d,%r10d
movzbl %bh,%esi
mov    %r12,%rdx
add    %edx,%esi
mov    %ebx,%eax
shr    $0x10,%eax
movzbl %al,%r14d
add    %r11d,%r14d
shr    $0x18,%ebx
add    %r13d,%ebx
jmp    18d5 <BWTGenerateOccValueFromBwt+0x7d5>
xchg   %ax,%ax
cmp    $0x1000000,%ebx
mov    %r12,%rdx
je     18ac <BWTGenerateOccValueFromBwt+0x7ac>
cmp    $0x10000,%ebx
je     18b8 <BWTGenerateOccValueFromBwt+0x7b8>
cmp    $0x100,%ebx
jne    18c6 <BWTGenerateOccValueFromBwt+0x7c6>
lea    0x100(%r9),%r10d
mov    %r13d,%ebx
mov    %r11d,%r14d
mov    %edx,%esi
jmp    18d5 <BWTGenerateOccValueFromBwt+0x7d5>
lea    0x100(%r11),%r14d
mov    %r13d,%ebx
jmp    18d0 <BWTGenerateOccValueFromBwt+0x7d0>
lea    0x100(%rdx),%esi
mov    %r13d,%ebx
mov    %r11d,%r14d
jmp    18d2 <BWTGenerateOccValueFromBwt+0x7d2>
lea    0x100(%r13),%ebx
mov    %r11d,%r14d
mov    %edx,%esi
mov    %r9d,%r10d
shl    $0x10,%r9d
or     %r10d,%r9d
mov    %ebp,%eax
mov    -0x28(%rsp),%r12
mov    %r9d,(%r12,%rax,4)
shl    $0x10,%edx
or     %esi,%edx
lea    0x1(%rbp),%eax
mov    %edx,(%r12,%rax,4)
shl    $0x10,%r11d
or     %r14d,%r11d
lea    0x2(%rbp),%eax
mov    %r11d,(%r12,%rax,4)
shl    $0x10,%r13d
or     %ebx,%r13d
mov    %rbp,-0x38(%rsp)
lea    0x3(%rbp),%eax
mov    %r13d,(%r12,%rax,4)
mov    %ecx,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
mov    (%r8,%rax,4),%ebp
add    (%r8,%rcx,4),%ebp
lea    -0xe(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0xd(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0xc(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0xb(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0xa(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x9(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x8(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x7(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x6(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x5(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x4(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x3(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x2(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
lea    -0x1(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
movzwl %ax,%eax
add    (%r8,%rax,4),%ebp
mov    %r15d,%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebp
mov    %rbp,%rcx
movzwl %ax,%eax
add    (%r8,%rax,4),%ecx
test   $0xfefefeff,%ecx
je     1ae0 <BWTGenerateOccValueFromBwt+0x9e0>
movzbl %cl,%r9d
add    %r10d,%r9d
movzbl %ch,%eax
add    %esi,%eax
mov    %rax,%r12
mov    %ecx,%eax
shr    $0x10,%eax
movzbl %al,%r11d
add    %r14d,%r11d
shr    $0x18,%ecx
add    %ebx,%ecx
mov    -0x38(%rsp),%rbp
jmp    16d1 <BWTGenerateOccValueFromBwt+0x5d1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
cmp    $0x1000000,%ecx
je     1b0d <BWTGenerateOccValueFromBwt+0xa0d>
cmp    $0x10000,%ecx
mov    -0x38(%rsp),%rbp
je     16c0 <BWTGenerateOccValueFromBwt+0x5c0>
cmp    $0x100,%ecx
jne    1b21 <BWTGenerateOccValueFromBwt+0xa21>
add    $0x100,%r10d
jmp    16c6 <BWTGenerateOccValueFromBwt+0x5c6>
add    $0x100,%r14d
mov    %ebx,%ecx
mov    %r14d,%r11d
mov    %esi,%r12d
mov    %r10d,%r9d
jmp    1ac9 <BWTGenerateOccValueFromBwt+0x9c9>
add    $0x100,%ebx
jmp    16c6 <BWTGenerateOccValueFromBwt+0x5c6>
mov    %ebp,%r14d
xor    %r11d,%r11d
xor    %r12d,%r12d
xor    %r9d,%r9d
jmp    1b48 <BWTGenerateOccValueFromBwt+0xa48>
add    $0xffffffe1,%r15d
mov    -0x20(%rsp),%rsi
mov    -0x30(%rsp),%r14
lea    (%r14,%r14,1),%eax
mov    %ecx,%ebx
mov    %rcx,%r10
mov    %r11d,%ecx
mov    %r12d,%edx
mov    %r9d,%ebp
cmp    %esi,%eax
jae    1d78 <BWTGenerateOccValueFromBwt+0xc78>
mov    %r12,%rsi
mov    %r15d,%eax
mov    (%rdi,%rax,4),%eax
movzwl %ax,%ecx
shr    $0x10,%rax
mov    (%r8,%rax,4),%ebx
add    (%r8,%rcx,4),%ebx
lea    0x1(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x2(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x3(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x4(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x5(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x6(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x7(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x8(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0x9(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0xa(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0xb(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0xc(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0xd(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
lea    0xe(%r15),%eax
mov    (%rdi,%rax,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
add    $0xf,%r15d
mov    (%rdi,%r15,4),%eax
mov    %rax,%rcx
shr    $0x10,%rcx
add    (%r8,%rcx,4),%ebx
movzwl %ax,%eax
add    (%r8,%rax,4),%ebx
test   $0xfefefeff,%ebx
je     1d1c <BWTGenerateOccValueFromBwt+0xc1c>
movzbl %bl,%ebp
add    %r9d,%ebp
movzbl %bh,%edx
mov    %rsi,%r12
add    %r12d,%edx
mov    %ebx,%eax
shr    $0x10,%eax
movzbl %al,%ecx
add    %r11d,%ecx
shr    $0x18,%ebx
add    %r10d,%ebx
jmp    1d78 <BWTGenerateOccValueFromBwt+0xc78>
cmp    $0x1000000,%ebx
je     1d49 <BWTGenerateOccValueFromBwt+0xc49>
cmp    $0x10000,%ebx
mov    %rsi,%r12
je     1d58 <BWTGenerateOccValueFromBwt+0xc58>
cmp    $0x100,%ebx
jne    1d68 <BWTGenerateOccValueFromBwt+0xc68>
lea    0x100(%r9),%ebp
mov    %r10d,%ebx
mov    %r11d,%ecx
mov    %r12d,%edx
jmp    1d78 <BWTGenerateOccValueFromBwt+0xc78>
lea    0x100(%r11),%ecx
mov    %r10d,%ebx
mov    %rsi,%r12
jmp    1d72 <BWTGenerateOccValueFromBwt+0xc72>
lea    0x100(%r12),%edx
mov    %r10d,%ebx
mov    %r11d,%ecx
jmp    1d75 <BWTGenerateOccValueFromBwt+0xc75>
lea    0x100(%r10),%ebx
mov    %r11d,%ecx
mov    %r12d,%edx
mov    %r9d,%ebp
shl    $0x10,%r9d
or     %ebp,%r9d
lea    0x0(,%r14,4),%eax
mov    -0x28(%rsp),%rsi
mov    %r9d,(%rsi,%rax,4)
shl    $0x10,%r12d
or     %edx,%r12d
lea    0x1(,%r14,4),%eax
mov    %r12d,(%rsi,%rax,4)
shl    $0x10,%r11d
or     %ecx,%r11d
lea    0x2(,%r14,4),%eax
mov    %r11d,(%rsi,%rax,4)
shl    $0x10,%r10d
or     %ebx,%r10d
lea    0x3(,%r14,4),%eax
mov    %r10d,(%rsi,%rax,4)
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
define void @BWTGenerateOccValueFromBwt(i32* %0, i32* noalias %1, i32* noalias %2, i32 %3, i32* %4) {
%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
%16 = alloca i32
%17 = alloca i32
%18 = alloca i32
%19 = alloca i32
%20 = alloca i32
%21 = alloca i32
%22 = alloca [4 x i32]
%23 = alloca [4 x i32]
store i32* %0, i32** %6
store i32* %1, i32** %7
store i32* %2, i32** %8
store i32 %3, i32* %9
store i32* %4, i32** %10
store i32 16, i32* %13
%24 = load i32, i32* %9
%25 = add i32 %24, 256
%26 = sub i32 %25, 1
%27 = udiv i32 %26, 256
%28 = add i32 %27, 1
store i32 %28, i32* %12
store i32 256, i32* %14
%29 = load i32, i32* %12
%30 = load i32, i32* %14
%31 = add i32 %29, %30
%32 = sub i32 %31, 1
%33 = load i32, i32* %14
%34 = udiv i32 %32, %33
store i32 %34, i32* %11
%35 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
store i32 0, i32* %35
%36 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
store i32 0, i32* %36
%37 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
store i32 0, i32* %37
%38 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
store i32 0, i32* %38
%39 = load i32*, i32** %8
%40 = getelementptr inbounds i32, i32* %39, i64 0
store i32 0, i32* %40
%41 = load i32*, i32** %8
%42 = getelementptr inbounds i32, i32* %41, i64 1
store i32 0, i32* %42
%43 = load i32*, i32** %8
%44 = getelementptr inbounds i32, i32* %43, i64 2
store i32 0, i32* %44
%45 = load i32*, i32** %8
%46 = getelementptr inbounds i32, i32* %45, i64 3
store i32 0, i32* %46
store i32 0, i32* %19
store i32 0, i32* %20
store i32 1, i32* %18
br label %47
47: ; preds = %388, %5
%48 = load i32, i32* %18
%49 = load i32, i32* %11
%50 = icmp ult i32 %48, %49
br i1 %50, label %51, label %391
51: ; preds = %47
store i32 0, i32* %16
br label %52
52: ; preds = %312, %51
%53 = load i32, i32* %16
%54 = load i32, i32* %14
%55 = udiv i32 %54, 2
%56 = icmp ult i32 %53, %55
br i1 %56, label %57, label %315
57: ; preds = %52
store i32 0, i32* %21
%58 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%59 = load i32, i32* %58
%60 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
store i32 %59, i32* %60
%61 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%62 = load i32, i32* %61
%63 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
store i32 %62, i32* %63
%64 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%65 = load i32, i32* %64
%66 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
store i32 %65, i32* %66
%67 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%68 = load i32, i32* %67
%69 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
store i32 %68, i32* %69
store i32 0, i32* %17
br label %70
70: ; preds = %98, %57
%71 = load i32, i32* %17
%72 = load i32, i32* %13
%73 = icmp ult i32 %71, %72
br i1 %73, label %74, label %101
74: ; preds = %70
%75 = load i32*, i32** %6
%76 = load i32, i32* %20
%77 = zext i32 %76 to i64
%78 = getelementptr inbounds i32, i32* %75, i64 %77
%79 = load i32, i32* %78
store i32 %79, i32* %15
%80 = load i32*, i32** %10
%81 = load i32, i32* %15
%82 = lshr i32 %81, 16
%83 = zext i32 %82 to i64
%84 = getelementptr inbounds i32, i32* %80, i64 %83
%85 = load i32, i32* %84
%86 = load i32, i32* %21
%87 = add i32 %86, %85
store i32 %87, i32* %21
%88 = load i32*, i32** %10
%89 = load i32, i32* %15
%90 = and i32 %89, 65535
%91 = zext i32 %90 to i64
%92 = getelementptr inbounds i32, i32* %88, i64 %91
%93 = load i32, i32* %92
%94 = load i32, i32* %21
%95 = add i32 %94, %93
store i32 %95, i32* %21
%96 = load i32, i32* %20
%97 = add i32 %96, 1
store i32 %97, i32* %20
br label %98
98: ; preds = %74
%99 = load i32, i32* %17
%100 = add i32 %99, 1
store i32 %100, i32* %17
br label %70
101: ; preds = %70
%102 = load i32, i32* %21
%103 = and i32 %102, -16843009
%104 = icmp eq i32 %103, 0
br i1 %104, label %131, label %105
105: ; preds = %101
%106 = load i32, i32* %21
%107 = and i32 %106, 255
%108 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%109 = load i32, i32* %108
%110 = add i32 %109, %107
store i32 %110, i32* %108
%111 = load i32, i32* %21
%112 = lshr i32 %111, 8
store i32 %112, i32* %21
%113 = load i32, i32* %21
%114 = and i32 %113, 255
%115 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%116 = load i32, i32* %115
%117 = add i32 %116, %114
store i32 %117, i32* %115
%118 = load i32, i32* %21
%119 = lshr i32 %118, 8
store i32 %119, i32* %21
%120 = load i32, i32* %21
%121 = and i32 %120, 255
%122 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%123 = load i32, i32* %122
%124 = add i32 %123, %121
store i32 %124, i32* %122
%125 = load i32, i32* %21
%126 = lshr i32 %125, 8
store i32 %126, i32* %21
%127 = load i32, i32* %21
%128 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%129 = load i32, i32* %128
%130 = add i32 %129, %127
store i32 %130, i32* %128
br label %159
131: ; preds = %101
%132 = load i32, i32* %21
%133 = icmp eq i32 %132, 256
br i1 %133, label %134, label %138
134: ; preds = %131
%135 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%136 = load i32, i32* %135
%137 = add i32 %136, 256
store i32 %137, i32* %135
br label %158
138: ; preds = %131
%139 = load i32, i32* %21
%140 = icmp eq i32 %139, 65536
br i1 %140, label %141, label %145
141: ; preds = %138
%142 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%143 = load i32, i32* %142
%144 = add i32 %143, 256
store i32 %144, i32* %142
br label %157
145: ; preds = %138
%146 = load i32, i32* %21
%147 = icmp eq i32 %146, 16777216
br i1 %147, label %148, label %152
148: ; preds = %145
%149 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%150 = load i32, i32* %149
%151 = add i32 %150, 256
store i32 %151, i32* %149
br label %156
152: ; preds = %145
%153 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%154 = load i32, i32* %153
%155 = add i32 %154, 256
store i32 %155, i32* %153
br label %156
156: ; preds = %152, %148
br label %157
157: ; preds = %156, %141
br label %158
158: ; preds = %157, %134
br label %159
159: ; preds = %158, %105
%160 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%161 = load i32, i32* %160
%162 = shl i32 %161, 16
%163 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%164 = load i32, i32* %163
%165 = or i32 %162, %164
%166 = load i32*, i32** %7
%167 = load i32, i32* %19
%168 = mul i32 %167, 4
%169 = add i32 %168, 0
%170 = zext i32 %169 to i64
%171 = getelementptr inbounds i32, i32* %166, i64 %170
store i32 %165, i32* %171
%172 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%173 = load i32, i32* %172
%174 = shl i32 %173, 16
%175 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%176 = load i32, i32* %175
%177 = or i32 %174, %176
%178 = load i32*, i32** %7
%179 = load i32, i32* %19
%180 = mul i32 %179, 4
%181 = add i32 %180, 1
%182 = zext i32 %181 to i64
%183 = getelementptr inbounds i32, i32* %178, i64 %182
store i32 %177, i32* %183
%184 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%185 = load i32, i32* %184
%186 = shl i32 %185, 16
%187 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%188 = load i32, i32* %187
%189 = or i32 %186, %188
%190 = load i32*, i32** %7
%191 = load i32, i32* %19
%192 = mul i32 %191, 4
%193 = add i32 %192, 2
%194 = zext i32 %193 to i64
%195 = getelementptr inbounds i32, i32* %190, i64 %194
store i32 %189, i32* %195
%196 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%197 = load i32, i32* %196
%198 = shl i32 %197, 16
%199 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%200 = load i32, i32* %199
%201 = or i32 %198, %200
%202 = load i32*, i32** %7
%203 = load i32, i32* %19
%204 = mul i32 %203, 4
%205 = add i32 %204, 3
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %202, i64 %206
store i32 %201, i32* %207
%208 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%209 = load i32, i32* %208
%210 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
store i32 %209, i32* %210
%211 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%212 = load i32, i32* %211
%213 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
store i32 %212, i32* %213
%214 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%215 = load i32, i32* %214
%216 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
store i32 %215, i32* %216
%217 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%218 = load i32, i32* %217
%219 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
store i32 %218, i32* %219
store i32 0, i32* %21
%220 = load i32, i32* %19
%221 = add i32 %220, 1
store i32 %221, i32* %19
store i32 0, i32* %17
br label %222
222: ; preds = %250, %159
%223 = load i32, i32* %17
%224 = load i32, i32* %13
%225 = icmp ult i32 %223, %224
br i1 %225, label %226, label %253
226: ; preds = %222
%227 = load i32*, i32** %6
%228 = load i32, i32* %20
%229 = zext i32 %228 to i64
%230 = getelementptr inbounds i32, i32* %227, i64 %229
%231 = load i32, i32* %230
store i32 %231, i32* %15
%232 = load i32*, i32** %10
%233 = load i32, i32* %15
%234 = lshr i32 %233, 16
%235 = zext i32 %234 to i64
%236 = getelementptr inbounds i32, i32* %232, i64 %235
%237 = load i32, i32* %236
%238 = load i32, i32* %21
%239 = add i32 %238, %237
store i32 %239, i32* %21
%240 = load i32*, i32** %10
%241 = load i32, i32* %15
%242 = and i32 %241, 65535
%243 = zext i32 %242 to i64
%244 = getelementptr inbounds i32, i32* %240, i64 %243
%245 = load i32, i32* %244
%246 = load i32, i32* %21
%247 = add i32 %246, %245
store i32 %247, i32* %21
%248 = load i32, i32* %20
%249 = add i32 %248, 1
store i32 %249, i32* %20
br label %250
250: ; preds = %226
%251 = load i32, i32* %17
%252 = add i32 %251, 1
store i32 %252, i32* %17
br label %222
253: ; preds = %222
%254 = load i32, i32* %21
%255 = and i32 %254, -16843009
%256 = icmp eq i32 %255, 0
br i1 %256, label %283, label %257
257: ; preds = %253
%258 = load i32, i32* %21
%259 = and i32 %258, 255
%260 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%261 = load i32, i32* %260
%262 = add i32 %261, %259
store i32 %262, i32* %260
%263 = load i32, i32* %21
%264 = lshr i32 %263, 8
store i32 %264, i32* %21
%265 = load i32, i32* %21
%266 = and i32 %265, 255
%267 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%268 = load i32, i32* %267
%269 = add i32 %268, %266
store i32 %269, i32* %267
%270 = load i32, i32* %21
%271 = lshr i32 %270, 8
store i32 %271, i32* %21
%272 = load i32, i32* %21
%273 = and i32 %272, 255
%274 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%275 = load i32, i32* %274
%276 = add i32 %275, %273
store i32 %276, i32* %274
%277 = load i32, i32* %21
%278 = lshr i32 %277, 8
store i32 %278, i32* %21
%279 = load i32, i32* %21
%280 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%281 = load i32, i32* %280
%282 = add i32 %281, %279
store i32 %282, i32* %280
br label %311
283: ; preds = %253
%284 = load i32, i32* %21
%285 = icmp eq i32 %284, 256
br i1 %285, label %286, label %290
286: ; preds = %283
%287 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%288 = load i32, i32* %287
%289 = add i32 %288, 256
store i32 %289, i32* %287
br label %310
290: ; preds = %283
%291 = load i32, i32* %21
%292 = icmp eq i32 %291, 65536
br i1 %292, label %293, label %297
293: ; preds = %290
%294 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%295 = load i32, i32* %294
%296 = add i32 %295, 256
store i32 %296, i32* %294
br label %309
297: ; preds = %290
%298 = load i32, i32* %21
%299 = icmp eq i32 %298, 16777216
br i1 %299, label %300, label %304
300: ; preds = %297
%301 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%302 = load i32, i32* %301
%303 = add i32 %302, 256
store i32 %303, i32* %301
br label %308
304: ; preds = %297
%305 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%306 = load i32, i32* %305
%307 = add i32 %306, 256
store i32 %307, i32* %305
br label %308
308: ; preds = %304, %300
br label %309
309: ; preds = %308, %293
br label %310
310: ; preds = %309, %286
br label %311
311: ; preds = %310, %257
br label %312
312: ; preds = %311
%313 = load i32, i32* %16
%314 = add i32 %313, 1
store i32 %314, i32* %16
br label %52
315: ; preds = %52
%316 = load i32*, i32** %8
%317 = load i32, i32* %18
%318 = sub i32 %317, 1
%319 = mul i32 %318, 4
%320 = add i32 %319, 0
%321 = zext i32 %320 to i64
%322 = getelementptr inbounds i32, i32* %316, i64 %321
%323 = load i32, i32* %322
%324 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%325 = load i32, i32* %324
%326 = add i32 %323, %325
%327 = load i32*, i32** %8
%328 = load i32, i32* %18
%329 = mul i32 %328, 4
%330 = add i32 %329, 0
%331 = zext i32 %330 to i64
%332 = getelementptr inbounds i32, i32* %327, i64 %331
store i32 %326, i32* %332
%333 = load i32*, i32** %8
%334 = load i32, i32* %18
%335 = sub i32 %334, 1
%336 = mul i32 %335, 4
%337 = add i32 %336, 1
%338 = zext i32 %337 to i64
%339 = getelementptr inbounds i32, i32* %333, i64 %338
%340 = load i32, i32* %339
%341 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%342 = load i32, i32* %341
%343 = add i32 %340, %342
%344 = load i32*, i32** %8
%345 = load i32, i32* %18
%346 = mul i32 %345, 4
%347 = add i32 %346, 1
%348 = zext i32 %347 to i64
%349 = getelementptr inbounds i32, i32* %344, i64 %348
store i32 %343, i32* %349
%350 = load i32*, i32** %8
%351 = load i32, i32* %18
%352 = sub i32 %351, 1
%353 = mul i32 %352, 4
%354 = add i32 %353, 2
%355 = zext i32 %354 to i64
%356 = getelementptr inbounds i32, i32* %350, i64 %355
%357 = load i32, i32* %356
%358 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%359 = load i32, i32* %358
%360 = add i32 %357, %359
%361 = load i32*, i32** %8
%362 = load i32, i32* %18
%363 = mul i32 %362, 4
%364 = add i32 %363, 2
%365 = zext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %361, i64 %365
store i32 %360, i32* %366
%367 = load i32*, i32** %8
%368 = load i32, i32* %18
%369 = sub i32 %368, 1
%370 = mul i32 %369, 4
%371 = add i32 %370, 3
%372 = zext i32 %371 to i64
%373 = getelementptr inbounds i32, i32* %367, i64 %372
%374 = load i32, i32* %373
%375 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%376 = load i32, i32* %375
%377 = add i32 %374, %376
%378 = load i32*, i32** %8
%379 = load i32, i32* %18
%380 = mul i32 %379, 4
%381 = add i32 %380, 3
%382 = zext i32 %381 to i64
%383 = getelementptr inbounds i32, i32* %378, i64 %382
store i32 %377, i32* %383
%384 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
store i32 0, i32* %384
%385 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
store i32 0, i32* %385
%386 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
store i32 0, i32* %386
%387 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
store i32 0, i32* %387
br label %388
388: ; preds = %315
%389 = load i32, i32* %18
%390 = add i32 %389, 1
store i32 %390, i32* %18
br label %47
391: ; preds = %47
br label %392
392: ; preds = %652, %391
%393 = load i32, i32* %19
%394 = load i32, i32* %12
%395 = sub i32 %394, 1
%396 = udiv i32 %395, 2
%397 = icmp ult i32 %393, %396
br i1 %397, label %398, label %653
398: ; preds = %392
store i32 0, i32* %21
%399 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%400 = load i32, i32* %399
%401 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
store i32 %400, i32* %401
%402 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%403 = load i32, i32* %402
%404 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
store i32 %403, i32* %404
%405 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%406 = load i32, i32* %405
%407 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
store i32 %406, i32* %407
%408 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%409 = load i32, i32* %408
%410 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
store i32 %409, i32* %410
store i32 0, i32* %17
br label %411
411: ; preds = %439, %398
%412 = load i32, i32* %17
%413 = load i32, i32* %13
%414 = icmp ult i32 %412, %413
br i1 %414, label %415, label %442
415: ; preds = %411
%416 = load i32*, i32** %6
%417 = load i32, i32* %20
%418 = zext i32 %417 to i64
%419 = getelementptr inbounds i32, i32* %416, i64 %418
%420 = load i32, i32* %419
store i32 %420, i32* %15
%421 = load i32*, i32** %10
%422 = load i32, i32* %15
%423 = lshr i32 %422, 16
%424 = zext i32 %423 to i64
%425 = getelementptr inbounds i32, i32* %421, i64 %424
%426 = load i32, i32* %425
%427 = load i32, i32* %21
%428 = add i32 %427, %426
store i32 %428, i32* %21
%429 = load i32*, i32** %10
%430 = load i32, i32* %15
%431 = and i32 %430, 65535
%432 = zext i32 %431 to i64
%433 = getelementptr inbounds i32, i32* %429, i64 %432
%434 = load i32, i32* %433
%435 = load i32, i32* %21
%436 = add i32 %435, %434
store i32 %436, i32* %21
%437 = load i32, i32* %20
%438 = add i32 %437, 1
store i32 %438, i32* %20
br label %439
439: ; preds = %415
%440 = load i32, i32* %17
%441 = add i32 %440, 1
store i32 %441, i32* %17
br label %411
442: ; preds = %411
%443 = load i32, i32* %21
%444 = and i32 %443, -16843009
%445 = icmp eq i32 %444, 0
br i1 %445, label %472, label %446
446: ; preds = %442
%447 = load i32, i32* %21
%448 = and i32 %447, 255
%449 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%450 = load i32, i32* %449
%451 = add i32 %450, %448
store i32 %451, i32* %449
%452 = load i32, i32* %21
%453 = lshr i32 %452, 8
store i32 %453, i32* %21
%454 = load i32, i32* %21
%455 = and i32 %454, 255
%456 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%457 = load i32, i32* %456
%458 = add i32 %457, %455
store i32 %458, i32* %456
%459 = load i32, i32* %21
%460 = lshr i32 %459, 8
store i32 %460, i32* %21
%461 = load i32, i32* %21
%462 = and i32 %461, 255
%463 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%464 = load i32, i32* %463
%465 = add i32 %464, %462
store i32 %465, i32* %463
%466 = load i32, i32* %21
%467 = lshr i32 %466, 8
store i32 %467, i32* %21
%468 = load i32, i32* %21
%469 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%470 = load i32, i32* %469
%471 = add i32 %470, %468
store i32 %471, i32* %469
br label %500
472: ; preds = %442
%473 = load i32, i32* %21
%474 = icmp eq i32 %473, 256
br i1 %474, label %475, label %479
475: ; preds = %472
%476 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%477 = load i32, i32* %476
%478 = add i32 %477, 256
store i32 %478, i32* %476
br label %499
479: ; preds = %472
%480 = load i32, i32* %21
%481 = icmp eq i32 %480, 65536
br i1 %481, label %482, label %486
482: ; preds = %479
%483 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%484 = load i32, i32* %483
%485 = add i32 %484, 256
store i32 %485, i32* %483
br label %498
486: ; preds = %479
%487 = load i32, i32* %21
%488 = icmp eq i32 %487, 16777216
br i1 %488, label %489, label %493
489: ; preds = %486
%490 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%491 = load i32, i32* %490
%492 = add i32 %491, 256
store i32 %492, i32* %490
br label %497
493: ; preds = %486
%494 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%495 = load i32, i32* %494
%496 = add i32 %495, 256
store i32 %496, i32* %494
br label %497
497: ; preds = %493, %489
br label %498
498: ; preds = %497, %482
br label %499
499: ; preds = %498, %475
br label %500
500: ; preds = %499, %446
%501 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%502 = load i32, i32* %501
%503 = shl i32 %502, 16
%504 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%505 = load i32, i32* %504
%506 = or i32 %503, %505
%507 = load i32*, i32** %7
%508 = load i32, i32* %19
%509 = mul i32 %508, 4
%510 = add i32 %509, 0
%511 = zext i32 %510 to i64
%512 = getelementptr inbounds i32, i32* %507, i64 %511
store i32 %506, i32* %512
%513 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%514 = load i32, i32* %513
%515 = shl i32 %514, 16
%516 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%517 = load i32, i32* %516
%518 = or i32 %515, %517
%519 = load i32*, i32** %7
%520 = load i32, i32* %19
%521 = mul i32 %520, 4
%522 = add i32 %521, 1
%523 = zext i32 %522 to i64
%524 = getelementptr inbounds i32, i32* %519, i64 %523
store i32 %518, i32* %524
%525 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%526 = load i32, i32* %525
%527 = shl i32 %526, 16
%528 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%529 = load i32, i32* %528
%530 = or i32 %527, %529
%531 = load i32*, i32** %7
%532 = load i32, i32* %19
%533 = mul i32 %532, 4
%534 = add i32 %533, 2
%535 = zext i32 %534 to i64
%536 = getelementptr inbounds i32, i32* %531, i64 %535
store i32 %530, i32* %536
%537 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%538 = load i32, i32* %537
%539 = shl i32 %538, 16
%540 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%541 = load i32, i32* %540
%542 = or i32 %539, %541
%543 = load i32*, i32** %7
%544 = load i32, i32* %19
%545 = mul i32 %544, 4
%546 = add i32 %545, 3
%547 = zext i32 %546 to i64
%548 = getelementptr inbounds i32, i32* %543, i64 %547
store i32 %542, i32* %548
%549 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%550 = load i32, i32* %549
%551 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
store i32 %550, i32* %551
%552 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%553 = load i32, i32* %552
%554 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
store i32 %553, i32* %554
%555 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%556 = load i32, i32* %555
%557 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
store i32 %556, i32* %557
%558 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%559 = load i32, i32* %558
%560 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
store i32 %559, i32* %560
store i32 0, i32* %21
%561 = load i32, i32* %19
%562 = add i32 %561, 1
store i32 %562, i32* %19
store i32 0, i32* %17
br label %563
563: ; preds = %591, %500
%564 = load i32, i32* %17
%565 = load i32, i32* %13
%566 = icmp ult i32 %564, %565
br i1 %566, label %567, label %594
567: ; preds = %563
%568 = load i32*, i32** %6
%569 = load i32, i32* %20
%570 = zext i32 %569 to i64
%571 = getelementptr inbounds i32, i32* %568, i64 %570
%572 = load i32, i32* %571
store i32 %572, i32* %15
%573 = load i32*, i32** %10
%574 = load i32, i32* %15
%575 = lshr i32 %574, 16
%576 = zext i32 %575 to i64
%577 = getelementptr inbounds i32, i32* %573, i64 %576
%578 = load i32, i32* %577
%579 = load i32, i32* %21
%580 = add i32 %579, %578
store i32 %580, i32* %21
%581 = load i32*, i32** %10
%582 = load i32, i32* %15
%583 = and i32 %582, 65535
%584 = zext i32 %583 to i64
%585 = getelementptr inbounds i32, i32* %581, i64 %584
%586 = load i32, i32* %585
%587 = load i32, i32* %21
%588 = add i32 %587, %586
store i32 %588, i32* %21
%589 = load i32, i32* %20
%590 = add i32 %589, 1
store i32 %590, i32* %20
br label %591
591: ; preds = %567
%592 = load i32, i32* %17
%593 = add i32 %592, 1
store i32 %593, i32* %17
br label %563
594: ; preds = %563
%595 = load i32, i32* %21
%596 = and i32 %595, -16843009
%597 = icmp eq i32 %596, 0
br i1 %597, label %624, label %598
598: ; preds = %594
%599 = load i32, i32* %21
%600 = and i32 %599, 255
%601 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%602 = load i32, i32* %601
%603 = add i32 %602, %600
store i32 %603, i32* %601
%604 = load i32, i32* %21
%605 = lshr i32 %604, 8
store i32 %605, i32* %21
%606 = load i32, i32* %21
%607 = and i32 %606, 255
%608 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%609 = load i32, i32* %608
%610 = add i32 %609, %607
store i32 %610, i32* %608
%611 = load i32, i32* %21
%612 = lshr i32 %611, 8
store i32 %612, i32* %21
%613 = load i32, i32* %21
%614 = and i32 %613, 255
%615 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%616 = load i32, i32* %615
%617 = add i32 %616, %614
store i32 %617, i32* %615
%618 = load i32, i32* %21
%619 = lshr i32 %618, 8
store i32 %619, i32* %21
%620 = load i32, i32* %21
%621 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%622 = load i32, i32* %621
%623 = add i32 %622, %620
store i32 %623, i32* %621
br label %652
624: ; preds = %594
%625 = load i32, i32* %21
%626 = icmp eq i32 %625, 256
br i1 %626, label %627, label %631
627: ; preds = %624
%628 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%629 = load i32, i32* %628
%630 = add i32 %629, 256
store i32 %630, i32* %628
br label %651
631: ; preds = %624
%632 = load i32, i32* %21
%633 = icmp eq i32 %632, 65536
br i1 %633, label %634, label %638
634: ; preds = %631
%635 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%636 = load i32, i32* %635
%637 = add i32 %636, 256
store i32 %637, i32* %635
br label %650
638: ; preds = %631
%639 = load i32, i32* %21
%640 = icmp eq i32 %639, 16777216
br i1 %640, label %641, label %645
641: ; preds = %638
%642 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%643 = load i32, i32* %642
%644 = add i32 %643, 256
store i32 %644, i32* %642
br label %649
645: ; preds = %638
%646 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%647 = load i32, i32* %646
%648 = add i32 %647, 256
store i32 %648, i32* %646
br label %649
649: ; preds = %645, %641
br label %650
650: ; preds = %649, %634
br label %651
651: ; preds = %650, %627
br label %652
652: ; preds = %651, %598
br label %392
653: ; preds = %392
store i32 0, i32* %21
%654 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%655 = load i32, i32* %654
%656 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
store i32 %655, i32* %656
%657 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%658 = load i32, i32* %657
%659 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
store i32 %658, i32* %659
%660 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%661 = load i32, i32* %660
%662 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
store i32 %661, i32* %662
%663 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%664 = load i32, i32* %663
%665 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
store i32 %664, i32* %665
%666 = load i32, i32* %19
%667 = mul i32 %666, 2
%668 = load i32, i32* %12
%669 = sub i32 %668, 1
%670 = icmp ult i32 %667, %669
br i1 %670, label %671, label %762
671: ; preds = %653
store i32 0, i32* %17
br label %672
672: ; preds = %700, %671
%673 = load i32, i32* %17
%674 = load i32, i32* %13
%675 = icmp ult i32 %673, %674
br i1 %675, label %676, label %703
676: ; preds = %672
%677 = load i32*, i32** %6
%678 = load i32, i32* %20
%679 = zext i32 %678 to i64
%680 = getelementptr inbounds i32, i32* %677, i64 %679
%681 = load i32, i32* %680
store i32 %681, i32* %15
%682 = load i32*, i32** %10
%683 = load i32, i32* %15
%684 = lshr i32 %683, 16
%685 = zext i32 %684 to i64
%686 = getelementptr inbounds i32, i32* %682, i64 %685
%687 = load i32, i32* %686
%688 = load i32, i32* %21
%689 = add i32 %688, %687
store i32 %689, i32* %21
%690 = load i32*, i32** %10
%691 = load i32, i32* %15
%692 = and i32 %691, 65535
%693 = zext i32 %692 to i64
%694 = getelementptr inbounds i32, i32* %690, i64 %693
%695 = load i32, i32* %694
%696 = load i32, i32* %21
%697 = add i32 %696, %695
store i32 %697, i32* %21
%698 = load i32, i32* %20
%699 = add i32 %698, 1
store i32 %699, i32* %20
br label %700
700: ; preds = %676
%701 = load i32, i32* %17
%702 = add i32 %701, 1
store i32 %702, i32* %17
br label %672
703: ; preds = %672
%704 = load i32, i32* %21
%705 = and i32 %704, -16843009
%706 = icmp eq i32 %705, 0
br i1 %706, label %733, label %707
707: ; preds = %703
%708 = load i32, i32* %21
%709 = and i32 %708, 255
%710 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%711 = load i32, i32* %710
%712 = add i32 %711, %709
store i32 %712, i32* %710
%713 = load i32, i32* %21
%714 = lshr i32 %713, 8
store i32 %714, i32* %21
%715 = load i32, i32* %21
%716 = and i32 %715, 255
%717 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%718 = load i32, i32* %717
%719 = add i32 %718, %716
store i32 %719, i32* %717
%720 = load i32, i32* %21
%721 = lshr i32 %720, 8
store i32 %721, i32* %21
%722 = load i32, i32* %21
%723 = and i32 %722, 255
%724 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%725 = load i32, i32* %724
%726 = add i32 %725, %723
store i32 %726, i32* %724
%727 = load i32, i32* %21
%728 = lshr i32 %727, 8
store i32 %728, i32* %21
%729 = load i32, i32* %21
%730 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%731 = load i32, i32* %730
%732 = add i32 %731, %729
store i32 %732, i32* %730
br label %761
733: ; preds = %703
%734 = load i32, i32* %21
%735 = icmp eq i32 %734, 256
br i1 %735, label %736, label %740
736: ; preds = %733
%737 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%738 = load i32, i32* %737
%739 = add i32 %738, 256
store i32 %739, i32* %737
br label %760
740: ; preds = %733
%741 = load i32, i32* %21
%742 = icmp eq i32 %741, 65536
br i1 %742, label %743, label %747
743: ; preds = %740
%744 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%745 = load i32, i32* %744
%746 = add i32 %745, 256
store i32 %746, i32* %744
br label %759
747: ; preds = %740
%748 = load i32, i32* %21
%749 = icmp eq i32 %748, 16777216
br i1 %749, label %750, label %754
750: ; preds = %747
%751 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%752 = load i32, i32* %751
%753 = add i32 %752, 256
store i32 %753, i32* %751
br label %758
754: ; preds = %747
%755 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%756 = load i32, i32* %755
%757 = add i32 %756, 256
store i32 %757, i32* %755
br label %758
758: ; preds = %754, %750
br label %759
759: ; preds = %758, %743
br label %760
760: ; preds = %759, %736
br label %761
761: ; preds = %760, %707
br label %762
762: ; preds = %761, %653
%763 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 0
%764 = load i32, i32* %763
%765 = shl i32 %764, 16
%766 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 0
%767 = load i32, i32* %766
%768 = or i32 %765, %767
%769 = load i32*, i32** %7
%770 = load i32, i32* %19
%771 = mul i32 %770, 4
%772 = add i32 %771, 0
%773 = zext i32 %772 to i64
%774 = getelementptr inbounds i32, i32* %769, i64 %773
store i32 %768, i32* %774
%775 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 1
%776 = load i32, i32* %775
%777 = shl i32 %776, 16
%778 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 1
%779 = load i32, i32* %778
%780 = or i32 %777, %779
%781 = load i32*, i32** %7
%782 = load i32, i32* %19
%783 = mul i32 %782, 4
%784 = add i32 %783, 1
%785 = zext i32 %784 to i64
%786 = getelementptr inbounds i32, i32* %781, i64 %785
store i32 %780, i32* %786
%787 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 2
%788 = load i32, i32* %787
%789 = shl i32 %788, 16
%790 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 2
%791 = load i32, i32* %790
%792 = or i32 %789, %791
%793 = load i32*, i32** %7
%794 = load i32, i32* %19
%795 = mul i32 %794, 4
%796 = add i32 %795, 2
%797 = zext i32 %796 to i64
%798 = getelementptr inbounds i32, i32* %793, i64 %797
store i32 %792, i32* %798
%799 = getelementptr inbounds [4 x i32], [4 x i32]* %22, i64 0, i64 3
%800 = load i32, i32* %799
%801 = shl i32 %800, 16
%802 = getelementptr inbounds [4 x i32], [4 x i32]* %23, i64 0, i64 3
%803 = load i32, i32* %802
%804 = or i32 %801, %803
%805 = load i32*, i32** %7
%806 = load i32, i32* %19
%807 = mul i32 %806, 4
%808 = add i32 %807, 3
%809 = zext i32 %808 to i64
%810 = getelementptr inbounds i32, i32* %805, i64 %809
store i32 %804, i32* %810
ret void
}

LLVM IR (-O2):
define void @BWTGenerateOccValueFromBwt(i32* nocapture %0, i32* noalias nocapture writeonly %1, i32* noalias nocapture %2, i32 %3, i32* nocapture %4) {
%6 = add i32 %3, 255
%7 = lshr i32 %6, 8
%8 = icmp ugt i32 %6, 65535
%9 = bitcast i32* %2 to i8*
br i1 %8, label %10, label %20
10: ; preds = %5
%11 = add nuw nsw i32 %7, 256
%12 = lshr i32 %11, 8
%13 = call i32 @llvm.umax.i32(i32 %12, i32 2)
%14 = zext i32 %13 to i64
br label %15
15: ; preds = %10, %557
%16 = phi i64 [ 1, %10 ], [ %582, %557 ]
%17 = phi i32 [ 0, %10 ], [ %528, %557 ]
%18 = phi i32 [ 0, %10 ], [ %19, %557 ]
%19 = add i32 %18, 128
br label %28
20: ; preds = %557, %5
%21 = phi i32 [ 0, %5 ], [ %19, %557 ]
%22 = phi i32 [ 0, %5 ], [ %528, %557 ]
%23 = lshr i32 %6, 9
%24 = icmp ult i32 %21, %23
br i1 %24, label %25, label %1114
25: ; preds = %20
%26 = zext i32 %21 to i64
%27 = zext i32 %23 to i64
br label %584
28: ; preds = %15, %551
%29 = phi i32 [ 0, %15 ], [ %555, %551 ]
%30 = phi i32 [ 0, %15 ], [ %554, %551 ]
%31 = phi i32 [ 0, %15 ], [ %553, %551 ]
%32 = phi i32 [ 0, %15 ], [ %552, %551 ]
%33 = phi i32 [ %17, %15 ], [ %528, %551 ]
%34 = phi i32 [ %18, %15 ], [ %305, %551 ]
%35 = zext i32 %33 to i64
%36 = getelementptr inbounds i32, i32* %0, i64 %35
%37 = load i32, i32* %36
%38 = lshr i32 %37, 16
%39 = zext i32 %38 to i64
%40 = getelementptr inbounds i32, i32* %4, i64 %39
%41 = load i32, i32* %40
%42 = and i32 %37, 65535
%43 = zext i32 %42 to i64
%44 = getelementptr inbounds i32, i32* %4, i64 %43
%45 = load i32, i32* %44
%46 = add i32 %41, %45
%47 = add i32 %33, 1
%48 = zext i32 %47 to i64
%49 = getelementptr inbounds i32, i32* %0, i64 %48
%50 = load i32, i32* %49
%51 = lshr i32 %50, 16
%52 = zext i32 %51 to i64
%53 = getelementptr inbounds i32, i32* %4, i64 %52
%54 = load i32, i32* %53
%55 = add i32 %54, %46
%56 = and i32 %50, 65535
%57 = zext i32 %56 to i64
%58 = getelementptr inbounds i32, i32* %4, i64 %57
%59 = load i32, i32* %58
%60 = add i32 %55, %59
%61 = add i32 %33, 2
%62 = zext i32 %61 to i64
%63 = getelementptr inbounds i32, i32* %0, i64 %62
%64 = load i32, i32* %63
%65 = lshr i32 %64, 16
%66 = zext i32 %65 to i64
%67 = getelementptr inbounds i32, i32* %4, i64 %66
%68 = load i32, i32* %67
%69 = add i32 %68, %60
%70 = and i32 %64, 65535
%71 = zext i32 %70 to i64
%72 = getelementptr inbounds i32, i32* %4, i64 %71
%73 = load i32, i32* %72
%74 = add i32 %69, %73
%75 = add i32 %33, 3
%76 = zext i32 %75 to i64
%77 = getelementptr inbounds i32, i32* %0, i64 %76
%78 = load i32, i32* %77
%79 = lshr i32 %78, 16
%80 = zext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %4, i64 %80
%82 = load i32, i32* %81
%83 = add i32 %82, %74
%84 = and i32 %78, 65535
%85 = zext i32 %84 to i64
%86 = getelementptr inbounds i32, i32* %4, i64 %85
%87 = load i32, i32* %86
%88 = add i32 %83, %87
%89 = add i32 %33, 4
%90 = zext i32 %89 to i64
%91 = getelementptr inbounds i32, i32* %0, i64 %90
%92 = load i32, i32* %91
%93 = lshr i32 %92, 16
%94 = zext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %4, i64 %94
%96 = load i32, i32* %95
%97 = add i32 %96, %88
%98 = and i32 %92, 65535
%99 = zext i32 %98 to i64
%100 = getelementptr inbounds i32, i32* %4, i64 %99
%101 = load i32, i32* %100
%102 = add i32 %97, %101
%103 = add i32 %33, 5
%104 = zext i32 %103 to i64
%105 = getelementptr inbounds i32, i32* %0, i64 %104
%106 = load i32, i32* %105
%107 = lshr i32 %106, 16
%108 = zext i32 %107 to i64
%109 = getelementptr inbounds i32, i32* %4, i64 %108
%110 = load i32, i32* %109
%111 = add i32 %110, %102
%112 = and i32 %106, 65535
%113 = zext i32 %112 to i64
%114 = getelementptr inbounds i32, i32* %4, i64 %113
%115 = load i32, i32* %114
%116 = add i32 %111, %115
%117 = add i32 %33, 6
%118 = zext i32 %117 to i64
%119 = getelementptr inbounds i32, i32* %0, i64 %118
%120 = load i32, i32* %119
%121 = lshr i32 %120, 16
%122 = zext i32 %121 to i64
%123 = getelementptr inbounds i32, i32* %4, i64 %122
%124 = load i32, i32* %123
%125 = add i32 %124, %116
%126 = and i32 %120, 65535
%127 = zext i32 %126 to i64
%128 = getelementptr inbounds i32, i32* %4, i64 %127
%129 = load i32, i32* %128
%130 = add i32 %125, %129
%131 = add i32 %33, 7
%132 = zext i32 %131 to i64
%133 = getelementptr inbounds i32, i32* %0, i64 %132
%134 = load i32, i32* %133
%135 = lshr i32 %134, 16
%136 = zext i32 %135 to i64
%137 = getelementptr inbounds i32, i32* %4, i64 %136
%138 = load i32, i32* %137
%139 = add i32 %138, %130
%140 = and i32 %134, 65535
%141 = zext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %4, i64 %141
%143 = load i32, i32* %142
%144 = add i32 %139, %143
%145 = add i32 %33, 8
%146 = zext i32 %145 to i64
%147 = getelementptr inbounds i32, i32* %0, i64 %146
%148 = load i32, i32* %147
%149 = lshr i32 %148, 16
%150 = zext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %4, i64 %150
%152 = load i32, i32* %151
%153 = add i32 %152, %144
%154 = and i32 %148, 65535
%155 = zext i32 %154 to i64
%156 = getelementptr inbounds i32, i32* %4, i64 %155
%157 = load i32, i32* %156
%158 = add i32 %153, %157
%159 = add i32 %33, 9
%160 = zext i32 %159 to i64
%161 = getelementptr inbounds i32, i32* %0, i64 %160
%162 = load i32, i32* %161
%163 = lshr i32 %162, 16
%164 = zext i32 %163 to i64
%165 = getelementptr inbounds i32, i32* %4, i64 %164
%166 = load i32, i32* %165
%167 = add i32 %166, %158
%168 = and i32 %162, 65535
%169 = zext i32 %168 to i64
%170 = getelementptr inbounds i32, i32* %4, i64 %169
%171 = load i32, i32* %170
%172 = add i32 %167, %171
%173 = add i32 %33, 10
%174 = zext i32 %173 to i64
%175 = getelementptr inbounds i32, i32* %0, i64 %174
%176 = load i32, i32* %175
%177 = lshr i32 %176, 16
%178 = zext i32 %177 to i64
%179 = getelementptr inbounds i32, i32* %4, i64 %178
%180 = load i32, i32* %179
%181 = add i32 %180, %172
%182 = and i32 %176, 65535
%183 = zext i32 %182 to i64
%184 = getelementptr inbounds i32, i32* %4, i64 %183
%185 = load i32, i32* %184
%186 = add i32 %181, %185
%187 = add i32 %33, 11
%188 = zext i32 %187 to i64
%189 = getelementptr inbounds i32, i32* %0, i64 %188
%190 = load i32, i32* %189
%191 = lshr i32 %190, 16
%192 = zext i32 %191 to i64
%193 = getelementptr inbounds i32, i32* %4, i64 %192
%194 = load i32, i32* %193
%195 = add i32 %194, %186
%196 = and i32 %190, 65535
%197 = zext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %4, i64 %197
%199 = load i32, i32* %198
%200 = add i32 %195, %199
%201 = add i32 %33, 12
%202 = zext i32 %201 to i64
%203 = getelementptr inbounds i32, i32* %0, i64 %202
%204 = load i32, i32* %203
%205 = lshr i32 %204, 16
%206 = zext i32 %205 to i64
%207 = getelementptr inbounds i32, i32* %4, i64 %206
%208 = load i32, i32* %207
%209 = add i32 %208, %200
%210 = and i32 %204, 65535
%211 = zext i32 %210 to i64
%212 = getelementptr inbounds i32, i32* %4, i64 %211
%213 = load i32, i32* %212
%214 = add i32 %209, %213
%215 = add i32 %33, 13
%216 = zext i32 %215 to i64
%217 = getelementptr inbounds i32, i32* %0, i64 %216
%218 = load i32, i32* %217
%219 = lshr i32 %218, 16
%220 = zext i32 %219 to i64
%221 = getelementptr inbounds i32, i32* %4, i64 %220
%222 = load i32, i32* %221
%223 = add i32 %222, %214
%224 = and i32 %218, 65535
%225 = zext i32 %224 to i64
%226 = getelementptr inbounds i32, i32* %4, i64 %225
%227 = load i32, i32* %226
%228 = add i32 %223, %227
%229 = add i32 %33, 14
%230 = zext i32 %229 to i64
%231 = getelementptr inbounds i32, i32* %0, i64 %230
%232 = load i32, i32* %231
%233 = lshr i32 %232, 16
%234 = zext i32 %233 to i64
%235 = getelementptr inbounds i32, i32* %4, i64 %234
%236 = load i32, i32* %235
%237 = add i32 %236, %228
%238 = and i32 %232, 65535
%239 = zext i32 %238 to i64
%240 = getelementptr inbounds i32, i32* %4, i64 %239
%241 = load i32, i32* %240
%242 = add i32 %237, %241
%243 = add i32 %33, 15
%244 = zext i32 %243 to i64
%245 = getelementptr inbounds i32, i32* %0, i64 %244
%246 = load i32, i32* %245
%247 = lshr i32 %246, 16
%248 = zext i32 %247 to i64
%249 = getelementptr inbounds i32, i32* %4, i64 %248
%250 = load i32, i32* %249
%251 = add i32 %250, %242
%252 = and i32 %246, 65535
%253 = zext i32 %252 to i64
%254 = getelementptr inbounds i32, i32* %4, i64 %253
%255 = load i32, i32* %254
%256 = add i32 %251, %255
%257 = add i32 %33, 16
%258 = and i32 %256, -16843009
%259 = icmp eq i32 %258, 0
br i1 %259, label %271, label %260
260: ; preds = %28
%261 = and i32 %256, 255
%262 = add i32 %261, %29
%263 = lshr i32 %256, 8
%264 = and i32 %263, 255
%265 = add i32 %264, %30
%266 = lshr i32 %256, 16
%267 = and i32 %266, 255
%268 = add i32 %267, %31
%269 = lshr i32 %256, 24
%270 = add i32 %269, %32
br label %280
271: ; preds = %28
switch i32 %256, label %278 [
i32 256, label %272
i32 65536, label %274
i32 16777216, label %276
]
272: ; preds = %271
%273 = add i32 %29, 256
br label %280
274: ; preds = %271
%275 = add i32 %30, 256
br label %280
276: ; preds = %271
%277 = add i32 %31, 256
br label %280
278: ; preds = %271
%279 = add i32 %32, 256
br label %280
280: ; preds = %272, %276, %278, %274, %260
%281 = phi i32 [ %32, %272 ], [ %32, %274 ], [ %32, %276 ], [ %279, %278 ], [ %270, %260 ]
%282 = phi i32 [ %31, %272 ], [ %31, %274 ], [ %277, %276 ], [ %31, %278 ], [ %268, %260 ]
%283 = phi i32 [ %30, %272 ], [ %275, %274 ], [ %30, %276 ], [ %30, %278 ], [ %265, %260 ]
%284 = phi i32 [ %273, %272 ], [ %29, %274 ], [ %29, %276 ], [ %29, %278 ], [ %262, %260 ]
%285 = shl i32 %29, 16
%286 = or i32 %284, %285
%287 = shl i32 %34, 2
%288 = zext i32 %287 to i64
%289 = getelementptr inbounds i32, i32* %1, i64 %288
store i32 %286, i32* %289
%290 = shl i32 %30, 16
%291 = or i32 %283, %290
%292 = or i32 %287, 1
%293 = zext i32 %292 to i64
%294 = getelementptr inbounds i32, i32* %1, i64 %293
store i32 %291, i32* %294
%295 = shl i32 %31, 16
%296 = or i32 %282, %295
%297 = or i32 %287, 2
%298 = zext i32 %297 to i64
%299 = getelementptr inbounds i32, i32* %1, i64 %298
store i32 %296, i32* %299
%300 = shl i32 %32, 16
%301 = or i32 %281, %300
%302 = or i32 %287, 3
%303 = zext i32 %302 to i64
%304 = getelementptr inbounds i32, i32* %1, i64 %303
store i32 %301, i32* %304
%305 = add i32 %34, 1
%306 = zext i32 %257 to i64
%307 = getelementptr inbounds i32, i32* %0, i64 %306
%308 = load i32, i32* %307
%309 = lshr i32 %308, 16
%310 = zext i32 %309 to i64
%311 = getelementptr inbounds i32, i32* %4, i64 %310
%312 = load i32, i32* %311
%313 = and i32 %308, 65535
%314 = zext i32 %313 to i64
%315 = getelementptr inbounds i32, i32* %4, i64 %314
%316 = load i32, i32* %315
%317 = add i32 %312, %316
%318 = add i32 %33, 17
%319 = zext i32 %318 to i64
%320 = getelementptr inbounds i32, i32* %0, i64 %319
%321 = load i32, i32* %320
%322 = lshr i32 %321, 16
%323 = zext i32 %322 to i64
%324 = getelementptr inbounds i32, i32* %4, i64 %323
%325 = load i32, i32* %324
%326 = add i32 %325, %317
%327 = and i32 %321, 65535
%328 = zext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %4, i64 %328
%330 = load i32, i32* %329
%331 = add i32 %326, %330
%332 = add i32 %33, 18
%333 = zext i32 %332 to i64
%334 = getelementptr inbounds i32, i32* %0, i64 %333
%335 = load i32, i32* %334
%336 = lshr i32 %335, 16
%337 = zext i32 %336 to i64
%338 = getelementptr inbounds i32, i32* %4, i64 %337
%339 = load i32, i32* %338
%340 = add i32 %339, %331
%341 = and i32 %335, 65535
%342 = zext i32 %341 to i64
%343 = getelementptr inbounds i32, i32* %4, i64 %342
%344 = load i32, i32* %343
%345 = add i32 %340, %344
%346 = add i32 %33, 19
%347 = zext i32 %346 to i64
%348 = getelementptr inbounds i32, i32* %0, i64 %347
%349 = load i32, i32* %348
%350 = lshr i32 %349, 16
%351 = zext i32 %350 to i64
%352 = getelementptr inbounds i32, i32* %4, i64 %351
%353 = load i32, i32* %352
%354 = add i32 %353, %345
%355 = and i32 %349, 65535
%356 = zext i32 %355 to i64
%357 = getelementptr inbounds i32, i32* %4, i64 %356
%358 = load i32, i32* %357
%359 = add i32 %354, %358
%360 = add i32 %33, 20
%361 = zext i32 %360 to i64
%362 = getelementptr inbounds i32, i32* %0, i64 %361
%363 = load i32, i32* %362
%364 = lshr i32 %363, 16
%365 = zext i32 %364 to i64
%366 = getelementptr inbounds i32, i32* %4, i64 %365
%367 = load i32, i32* %366
%368 = add i32 %367, %359
%369 = and i32 %363, 65535
%370 = zext i32 %369 to i64
%371 = getelementptr inbounds i32, i32* %4, i64 %370
%372 = load i32, i32* %371
%373 = add i32 %368, %372
%374 = add i32 %33, 21
%375 = zext i32 %374 to i64
%376 = getelementptr inbounds i32, i32* %0, i64 %375
%377 = load i32, i32* %376
%378 = lshr i32 %377, 16
%379 = zext i32 %378 to i64
%380 = getelementptr inbounds i32, i32* %4, i64 %379
%381 = load i32, i32* %380
%382 = add i32 %381, %373
%383 = and i32 %377, 65535
%384 = zext i32 %383 to i64
%385 = getelementptr inbounds i32, i32* %4, i64 %384
%386 = load i32, i32* %385
%387 = add i32 %382, %386
%388 = add i32 %33, 22
%389 = zext i32 %388 to i64
%390 = getelementptr inbounds i32, i32* %0, i64 %389
%391 = load i32, i32* %390
%392 = lshr i32 %391, 16
%393 = zext i32 %392 to i64
%394 = getelementptr inbounds i32, i32* %4, i64 %393
%395 = load i32, i32* %394
%396 = add i32 %395, %387
%397 = and i32 %391, 65535
%398 = zext i32 %397 to i64
%399 = getelementptr inbounds i32, i32* %4, i64 %398
%400 = load i32, i32* %399
%401 = add i32 %396, %400
%402 = add i32 %33, 23
%403 = zext i32 %402 to i64
%404 = getelementptr inbounds i32, i32* %0, i64 %403
%405 = load i32, i32* %404
%406 = lshr i32 %405, 16
%407 = zext i32 %406 to i64
%408 = getelementptr inbounds i32, i32* %4, i64 %407
%409 = load i32, i32* %408
%410 = add i32 %409, %401
%411 = and i32 %405, 65535
%412 = zext i32 %411 to i64
%413 = getelementptr inbounds i32, i32* %4, i64 %412
%414 = load i32, i32* %413
%415 = add i32 %410, %414
%416 = add i32 %33, 24
%417 = zext i32 %416 to i64
%418 = getelementptr inbounds i32, i32* %0, i64 %417
%419 = load i32, i32* %418
%420 = lshr i32 %419, 16
%421 = zext i32 %420 to i64
%422 = getelementptr inbounds i32, i32* %4, i64 %421
%423 = load i32, i32* %422
%424 = add i32 %423, %415
%425 = and i32 %419, 65535
%426 = zext i32 %425 to i64
%427 = getelementptr inbounds i32, i32* %4, i64 %426
%428 = load i32, i32* %427
%429 = add i32 %424, %428
%430 = add i32 %33, 25
%431 = zext i32 %430 to i64
%432 = getelementptr inbounds i32, i32* %0, i64 %431
%433 = load i32, i32* %432
%434 = lshr i32 %433, 16
%435 = zext i32 %434 to i64
%436 = getelementptr inbounds i32, i32* %4, i64 %435
%437 = load i32, i32* %436
%438 = add i32 %437, %429
%439 = and i32 %433, 65535
%440 = zext i32 %439 to i64
%441 = getelementptr inbounds i32, i32* %4, i64 %440
%442 = load i32, i32* %441
%443 = add i32 %438, %442
%444 = add i32 %33, 26
%445 = zext i32 %444 to i64
%446 = getelementptr inbounds i32, i32* %0, i64 %445
%447 = load i32, i32* %446
%448 = lshr i32 %447, 16
%449 = zext i32 %448 to i64
%450 = getelementptr inbounds i32, i32* %4, i64 %449
%451 = load i32, i32* %450
%452 = add i32 %451, %443
%453 = and i32 %447, 65535
%454 = zext i32 %453 to i64
%455 = getelementptr inbounds i32, i32* %4, i64 %454
%456 = load i32, i32* %455
%457 = add i32 %452, %456
%458 = add i32 %33, 27
%459 = zext i32 %458 to i64
%460 = getelementptr inbounds i32, i32* %0, i64 %459
%461 = load i32, i32* %460
%462 = lshr i32 %461, 16
%463 = zext i32 %462 to i64
%464 = getelementptr inbounds i32, i32* %4, i64 %463
%465 = load i32, i32* %464
%466 = add i32 %465, %457
%467 = and i32 %461, 65535
%468 = zext i32 %467 to i64
%469 = getelementptr inbounds i32, i32* %4, i64 %468
%470 = load i32, i32* %469
%471 = add i32 %466, %470
%472 = add i32 %33, 28
%473 = zext i32 %472 to i64
%474 = getelementptr inbounds i32, i32* %0, i64 %473
%475 = load i32, i32* %474
%476 = lshr i32 %475, 16
%477 = zext i32 %476 to i64
%478 = getelementptr inbounds i32, i32* %4, i64 %477
%479 = load i32, i32* %478
%480 = add i32 %479, %471
%481 = and i32 %475, 65535
%482 = zext i32 %481 to i64
%483 = getelementptr inbounds i32, i32* %4, i64 %482
%484 = load i32, i32* %483
%485 = add i32 %480, %484
%486 = add i32 %33, 29
%487 = zext i32 %486 to i64
%488 = getelementptr inbounds i32, i32* %0, i64 %487
%489 = load i32, i32* %488
%490 = lshr i32 %489, 16
%491 = zext i32 %490 to i64
%492 = getelementptr inbounds i32, i32* %4, i64 %491
%493 = load i32, i32* %492
%494 = add i32 %493, %485
%495 = and i32 %489, 65535
%496 = zext i32 %495 to i64
%497 = getelementptr inbounds i32, i32* %4, i64 %496
%498 = load i32, i32* %497
%499 = add i32 %494, %498
%500 = add i32 %33, 30
%501 = zext i32 %500 to i64
%502 = getelementptr inbounds i32, i32* %0, i64 %501
%503 = load i32, i32* %502
%504 = lshr i32 %503, 16
%505 = zext i32 %504 to i64
%506 = getelementptr inbounds i32, i32* %4, i64 %505
%507 = load i32, i32* %506
%508 = add i32 %507, %499
%509 = and i32 %503, 65535
%510 = zext i32 %509 to i64
%511 = getelementptr inbounds i32, i32* %4, i64 %510
%512 = load i32, i32* %511
%513 = add i32 %508, %512
%514 = add i32 %33, 31
%515 = zext i32 %514 to i64
%516 = getelementptr inbounds i32, i32* %0, i64 %515
%517 = load i32, i32* %516
%518 = lshr i32 %517, 16
%519 = zext i32 %518 to i64
%520 = getelementptr inbounds i32, i32* %4, i64 %519
%521 = load i32, i32* %520
%522 = add i32 %521, %513
%523 = and i32 %517, 65535
%524 = zext i32 %523 to i64
%525 = getelementptr inbounds i32, i32* %4, i64 %524
%526 = load i32, i32* %525
%527 = add i32 %522, %526
%528 = add i32 %33, 32
%529 = and i32 %527, -16843009
%530 = icmp eq i32 %529, 0
br i1 %530, label %542, label %531
531: ; preds = %280
%532 = and i32 %527, 255
%533 = add i32 %532, %284
%534 = lshr i32 %527, 8
%535 = and i32 %534, 255
%536 = add i32 %535, %283
%537 = lshr i32 %527, 16
%538 = and i32 %537, 255
%539 = add i32 %538, %282
%540 = lshr i32 %527, 24
%541 = add i32 %540, %281
br label %551
542: ; preds = %280
switch i32 %527, label %549 [
i32 256, label %543
i32 65536, label %545
i32 16777216, label %547
]
543: ; preds = %542
%544 = add i32 %284, 256
br label %551
545: ; preds = %542
%546 = add i32 %283, 256
br label %551
547: ; preds = %542
%548 = add i32 %282, 256
br label %551
549: ; preds = %542
%550 = add i32 %281, 256
br label %551
551: ; preds = %531, %545, %549, %547, %543
%552 = phi i32 [ %281, %543 ], [ %281, %545 ], [ %281, %547 ], [ %550, %549 ], [ %541, %531 ]
%553 = phi i32 [ %282, %543 ], [ %282, %545 ], [ %548, %547 ], [ %282, %549 ], [ %539, %531 ]
%554 = phi i32 [ %283, %543 ], [ %546, %545 ], [ %283, %547 ], [ %283, %549 ], [ %536, %531 ]
%555 = phi i32 [ %544, %543 ], [ %284, %545 ], [ %284, %547 ], [ %284, %549 ], [ %533, %531 ]
%556 = icmp eq i32 %305, %19
br i1 %556, label %557, label %28
557: ; preds = %551
%558 = shl i64 %16, 2
%559 = add nsw i64 %558, -4
%560 = getelementptr inbounds i32, i32* %2, i64 %559
%561 = load i32, i32* %560
%562 = add i32 %561, %555
%563 = getelementptr inbounds i32, i32* %2, i64 %558
store i32 %562, i32* %563
%564 = add nsw i64 %558, -3
%565 = getelementptr inbounds i32, i32* %2, i64 %564
%566 = load i32, i32* %565
%567 = add i32 %566, %554
%568 = or i64 %558, 1
%569 = getelementptr inbounds i32, i32* %2, i64 %568
store i32 %567, i32* %569
%570 = add nsw i64 %558, -2
%571 = getelementptr inbounds i32, i32* %2, i64 %570
%572 = load i32, i32* %571
%573 = add i32 %572, %553
%574 = or i64 %558, 2
%575 = getelementptr inbounds i32, i32* %2, i64 %574
store i32 %573, i32* %575
%576 = add nsw i64 %558, -1
%577 = getelementptr inbounds i32, i32* %2, i64 %576
%578 = load i32, i32* %577
%579 = add i32 %578, %552
%580 = or i64 %558, 3
%581 = getelementptr inbounds i32, i32* %2, i64 %580
store i32 %579, i32* %581
%582 = add nuw nsw i64 %16, 1
%583 = icmp eq i64 %582, %14
br i1 %583, label %20, label %15
584: ; preds = %25, %1108
%585 = phi i64 [ %26, %25 ], [ %862, %1108 ]
%586 = phi i32 [ 0, %25 ], [ %1112, %1108 ]
%587 = phi i32 [ 0, %25 ], [ %1111, %1108 ]
%588 = phi i32 [ 0, %25 ], [ %1110, %1108 ]
%589 = phi i32 [ 0, %25 ], [ %1109, %1108 ]
%590 = phi i32 [ %22, %25 ], [ %1085, %1108 ]
%591 = zext i32 %590 to i64
%592 = getelementptr inbounds i32, i32* %0, i64 %591
%593 = load i32, i32* %592
%594 = lshr i32 %593, 16
%595 = zext i32 %594 to i64
%596 = getelementptr inbounds i32, i32* %4, i64 %595
%597 = load i32, i32* %596
%598 = and i32 %593, 65535
%599 = zext i32 %598 to i64
%600 = getelementptr inbounds i32, i32* %4, i64 %599
%601 = load i32, i32* %600
%602 = add i32 %597, %601
%603 = add i32 %590, 1
%604 = zext i32 %603 to i64
%605 = getelementptr inbounds i32, i32* %0, i64 %604
%606 = load i32, i32* %605
%607 = lshr i32 %606, 16
%608 = zext i32 %607 to i64
%609 = getelementptr inbounds i32, i32* %4, i64 %608
%610 = load i32, i32* %609
%611 = add i32 %610, %602
%612 = and i32 %606, 65535
%613 = zext i32 %612 to i64
%614 = getelementptr inbounds i32, i32* %4, i64 %613
%615 = load i32, i32* %614
%616 = add i32 %611, %615
%617 = add i32 %590, 2
%618 = zext i32 %617 to i64
%619 = getelementptr inbounds i32, i32* %0, i64 %618
%620 = load i32, i32* %619
%621 = lshr i32 %620, 16
%622 = zext i32 %621 to i64
%623 = getelementptr inbounds i32, i32* %4, i64 %622
%624 = load i32, i32* %623
%625 = add i32 %624, %616
%626 = and i32 %620, 65535
%627 = zext i32 %626 to i64
%628 = getelementptr inbounds i32, i32* %4, i64 %627
%629 = load i32, i32* %628
%630 = add i32 %625, %629
%631 = add i32 %590, 3
%632 = zext i32 %631 to i64
%633 = getelementptr inbounds i32, i32* %0, i64 %632
%634 = load i32, i32* %633
%635 = lshr i32 %634, 16
%636 = zext i32 %635 to i64
%637 = getelementptr inbounds i32, i32* %4, i64 %636
%638 = load i32, i32* %637
%639 = add i32 %638, %630
%640 = and i32 %634, 65535
%641 = zext i32 %640 to i64
%642 = getelementptr inbounds i32, i32* %4, i64 %641
%643 = load i32, i32* %642
%644 = add i32 %639, %643
%645 = add i32 %590, 4
%646 = zext i32 %645 to i64
%647 = getelementptr inbounds i32, i32* %0, i64 %646
%648 = load i32, i32* %647
%649 = lshr i32 %648, 16
%650 = zext i32 %649 to i64
%651 = getelementptr inbounds i32, i32* %4, i64 %650
%652 = load i32, i32* %651
%653 = add i32 %652, %644
%654 = and i32 %648, 65535
%655 = zext i32 %654 to i64
%656 = getelementptr inbounds i32, i32* %4, i64 %655
%657 = load i32, i32* %656
%658 = add i32 %653, %657
%659 = add i32 %590, 5
%660 = zext i32 %659 to i64
%661 = getelementptr inbounds i32, i32* %0, i64 %660
%662 = load i32, i32* %661
%663 = lshr i32 %662, 16
%664 = zext i32 %663 to i64
%665 = getelementptr inbounds i32, i32* %4, i64 %664
%666 = load i32, i32* %665
%667 = add i32 %666, %658
%668 = and i32 %662, 65535
%669 = zext i32 %668 to i64
%670 = getelementptr inbounds i32, i32* %4, i64 %669
%671 = load i32, i32* %670
%672 = add i32 %667, %671
%673 = add i32 %590, 6
%674 = zext i32 %673 to i64
%675 = getelementptr inbounds i32, i32* %0, i64 %674
%676 = load i32, i32* %675
%677 = lshr i32 %676, 16
%678 = zext i32 %677 to i64
%679 = getelementptr inbounds i32, i32* %4, i64 %678
%680 = load i32, i32* %679
%681 = add i32 %680, %672
%682 = and i32 %676, 65535
%683 = zext i32 %682 to i64
%684 = getelementptr inbounds i32, i32* %4, i64 %683
%685 = load i32, i32* %684
%686 = add i32 %681, %685
%687 = add i32 %590, 7
%688 = zext i32 %687 to i64
%689 = getelementptr inbounds i32, i32* %0, i64 %688
%690 = load i32, i32* %689
%691 = lshr i32 %690, 16
%692 = zext i32 %691 to i64
%693 = getelementptr inbounds i32, i32* %4, i64 %692
%694 = load i32, i32* %693
%695 = add i32 %694, %686
%696 = and i32 %690, 65535
%697 = zext i32 %696 to i64
%698 = getelementptr inbounds i32, i32* %4, i64 %697
%699 = load i32, i32* %698
%700 = add i32 %695, %699
%701 = add i32 %590, 8
%702 = zext i32 %701 to i64
%703 = getelementptr inbounds i32, i32* %0, i64 %702
%704 = load i32, i32* %703
%705 = lshr i32 %704, 16
%706 = zext i32 %705 to i64
%707 = getelementptr inbounds i32, i32* %4, i64 %706
%708 = load i32, i32* %707
%709 = add i32 %708, %700
%710 = and i32 %704, 65535
%711 = zext i32 %710 to i64
%712 = getelementptr inbounds i32, i32* %4, i64 %711
%713 = load i32, i32* %712
%714 = add i32 %709, %713
%715 = add i32 %590, 9
%716 = zext i32 %715 to i64
%717 = getelementptr inbounds i32, i32* %0, i64 %716
%718 = load i32, i32* %717
%719 = lshr i32 %718, 16
%720 = zext i32 %719 to i64
%721 = getelementptr inbounds i32, i32* %4, i64 %720
%722 = load i32, i32* %721
%723 = add i32 %722, %714
%724 = and i32 %718, 65535
%725 = zext i32 %724 to i64
%726 = getelementptr inbounds i32, i32* %4, i64 %725
%727 = load i32, i32* %726
%728 = add i32 %723, %727
%729 = add i32 %590, 10
%730 = zext i32 %729 to i64
%731 = getelementptr inbounds i32, i32* %0, i64 %730
%732 = load i32, i32* %731
%733 = lshr i32 %732, 16
%734 = zext i32 %733 to i64
%735 = getelementptr inbounds i32, i32* %4, i64 %734
%736 = load i32, i32* %735
%737 = add i32 %736, %728
%738 = and i32 %732, 65535
%739 = zext i32 %738 to i64
%740 = getelementptr inbounds i32, i32* %4, i64 %739
%741 = load i32, i32* %740
%742 = add i32 %737, %741
%743 = add i32 %590, 11
%744 = zext i32 %743 to i64
%745 = getelementptr inbounds i32, i32* %0, i64 %744
%746 = load i32, i32* %745
%747 = lshr i32 %746, 16
%748 = zext i32 %747 to i64
%749 = getelementptr inbounds i32, i32* %4, i64 %748
%750 = load i32, i32* %749
%751 = add i32 %750, %742
%752 = and i32 %746, 65535
%753 = zext i32 %752 to i64
%754 = getelementptr inbounds i32, i32* %4, i64 %753
%755 = load i32, i32* %754
%756 = add i32 %751, %755
%757 = add i32 %590, 12
%758 = zext i32 %757 to i64
%759 = getelementptr inbounds i32, i32* %0, i64 %758
%760 = load i32, i32* %759
%761 = lshr i32 %760, 16
%762 = zext i32 %761 to i64
%763 = getelementptr inbounds i32, i32* %4, i64 %762
%764 = load i32, i32* %763
%765 = add i32 %764, %756
%766 = and i32 %760, 65535
%767 = zext i32 %766 to i64
%768 = getelementptr inbounds i32, i32* %4, i64 %767
%769 = load i32, i32* %768
%770 = add i32 %765, %769
%771 = add i32 %590, 13
%772 = zext i32 %771 to i64
%773 = getelementptr inbounds i32, i32* %0, i64 %772
%774 = load i32, i32* %773
%775 = lshr i32 %774, 16
%776 = zext i32 %775 to i64
%777 = getelementptr inbounds i32, i32* %4, i64 %776
%778 = load i32, i32* %777
%779 = add i32 %778, %770
%780 = and i32 %774, 65535
%781 = zext i32 %780 to i64
%782 = getelementptr inbounds i32, i32* %4, i64 %781
%783 = load i32, i32* %782
%784 = add i32 %779, %783
%785 = add i32 %590, 14
%786 = zext i32 %785 to i64
%787 = getelementptr inbounds i32, i32* %0, i64 %786
%788 = load i32, i32* %787
%789 = lshr i32 %788, 16
%790 = zext i32 %789 to i64
%791 = getelementptr inbounds i32, i32* %4, i64 %790
%792 = load i32, i32* %791
%793 = add i32 %792, %784
%794 = and i32 %788, 65535
%795 = zext i32 %794 to i64
%796 = getelementptr inbounds i32, i32* %4, i64 %795
%797 = load i32, i32* %796
%798 = add i32 %793, %797
%799 = add i32 %590, 15
%800 = zext i32 %799 to i64
%801 = getelementptr inbounds i32, i32* %0, i64 %800
%802 = load i32, i32* %801
%803 = lshr i32 %802, 16
%804 = zext i32 %803 to i64
%805 = getelementptr inbounds i32, i32* %4, i64 %804
%806 = load i32, i32* %805
%807 = add i32 %806, %798
%808 = and i32 %802, 65535
%809 = zext i32 %808 to i64
%810 = getelementptr inbounds i32, i32* %4, i64 %809
%811 = load i32, i32* %810
%812 = add i32 %807, %811
%813 = add i32 %590, 16
%814 = and i32 %812, -16843009
%815 = icmp eq i32 %814, 0
br i1 %815, label %827, label %816
816: ; preds = %584
%817 = and i32 %812, 255
%818 = add i32 %817, %586
%819 = lshr i32 %812, 8
%820 = and i32 %819, 255
%821 = add i32 %820, %587
%822 = lshr i32 %812, 16
%823 = and i32 %822, 255
%824 = add i32 %823, %588
%825 = lshr i32 %812, 24
%826 = add i32 %825, %589
br label %836
827: ; preds = %584
switch i32 %812, label %834 [
i32 256, label %828
i32 65536, label %830
i32 16777216, label %832
]
828: ; preds = %827
%829 = add i32 %586, 256
br label %836
830: ; preds = %827
%831 = add i32 %587, 256
br label %836
832: ; preds = %827
%833 = add i32 %588, 256
br label %836
834: ; preds = %827
%835 = add i32 %589, 256
br label %836
836: ; preds = %828, %832, %834, %830, %816
%837 = phi i32 [ %589, %828 ], [ %589, %830 ], [ %589, %832 ], [ %835, %834 ], [ %826, %816 ]
%838 = phi i32 [ %588, %828 ], [ %588, %830 ], [ %833, %832 ], [ %588, %834 ], [ %824, %816 ]
%839 = phi i32 [ %587, %828 ], [ %831, %830 ], [ %587, %832 ], [ %587, %834 ], [ %821, %816 ]
%840 = phi i32 [ %829, %828 ], [ %586, %830 ], [ %586, %832 ], [ %586, %834 ], [ %818, %816 ]
%841 = shl i32 %586, 16
%842 = or i32 %840, %841
%843 = trunc i64 %585 to i32
%844 = shl i32 %843, 2
%845 = zext i32 %844 to i64
%846 = getelementptr inbounds i32, i32* %1, i64 %845
store i32 %842, i32* %846
%847 = shl i32 %587, 16
%848 = or i32 %839, %847
%849 = or i32 %844, 1
%850 = zext i32 %849 to i64
%851 = getelementptr inbounds i32, i32* %1, i64 %850
store i32 %848, i32* %851
%852 = shl i32 %588, 16
%853 = or i32 %838, %852
%854 = or i32 %844, 2
%855 = zext i32 %854 to i64
%856 = getelementptr inbounds i32, i32* %1, i64 %855
store i32 %853, i32* %856
%857 = shl i32 %589, 16
%858 = or i32 %837, %857
%859 = or i32 %844, 3
%860 = zext i32 %859 to i64
%861 = getelementptr inbounds i32, i32* %1, i64 %860
store i32 %858, i32* %861
%862 = add nuw nsw i64 %585, 1
%863 = zext i32 %813 to i64
%864 = getelementptr inbounds i32, i32* %0, i64 %863
%865 = load i32, i32* %864
%866 = lshr i32 %865, 16
%867 = zext i32 %866 to i64
%868 = getelementptr inbounds i32, i32* %4, i64 %867
%869 = load i32, i32* %868
%870 = and i32 %865, 65535
%871 = zext i32 %870 to i64
%872 = getelementptr inbounds i32, i32* %4, i64 %871
%873 = load i32, i32* %872
%874 = add i32 %869, %873
%875 = add i32 %590, 17
%876 = zext i32 %875 to i64
%877 = getelementptr inbounds i32, i32* %0, i64 %876
%878 = load i32, i32* %877
%879 = lshr i32 %878, 16
%880 = zext i32 %879 to i64
%881 = getelementptr inbounds i32, i32* %4, i64 %880
%882 = load i32, i32* %881
%883 = add i32 %882, %874
%884 = and i32 %878, 65535
%885 = zext i32 %884 to i64
%886 = getelementptr inbounds i32, i32* %4, i64 %885
%887 = load i32, i32* %886
%888 = add i32 %883, %887
%889 = add i32 %590, 18
%890 = zext i32 %889 to i64
%891 = getelementptr inbounds i32, i32* %0, i64 %890
%892 = load i32, i32* %891
%893 = lshr i32 %892, 16
%894 = zext i32 %893 to i64
%895 = getelementptr inbounds i32, i32* %4, i64 %894
%896 = load i32, i32* %895
%897 = add i32 %896, %888
%898 = and i32 %892, 65535
%899 = zext i32 %898 to i64
%900 = getelementptr inbounds i32, i32* %4, i64 %899
%901 = load i32, i32* %900
%902 = add i32 %897, %901
%903 = add i32 %590, 19
%904 = zext i32 %903 to i64
%905 = getelementptr inbounds i32, i32* %0, i64 %904
%906 = load i32, i32* %905
%907 = lshr i32 %906, 16
%908 = zext i32 %907 to i64
%909 = getelementptr inbounds i32, i32* %4, i64 %908
%910 = load i32, i32* %909
%911 = add i32 %910, %902
%912 = and i32 %906, 65535
%913 = zext i32 %912 to i64
%914 = getelementptr inbounds i32, i32* %4, i64 %913
%915 = load i32, i32* %914
%916 = add i32 %911, %915
%917 = add i32 %590, 20
%918 = zext i32 %917 to i64
%919 = getelementptr inbounds i32, i32* %0, i64 %918
%920 = load i32, i32* %919
%921 = lshr i32 %920, 16
%922 = zext i32 %921 to i64
%923 = getelementptr inbounds i32, i32* %4, i64 %922
%924 = load i32, i32* %923
%925 = add i32 %924, %916
%926 = and i32 %920, 65535
%927 = zext i32 %926 to i64
%928 = getelementptr inbounds i32, i32* %4, i64 %927
%929 = load i32, i32* %928
%930 = add i32 %925, %929
%931 = add i32 %590, 21
%932 = zext i32 %931 to i64
%933 = getelementptr inbounds i32, i32* %0, i64 %932
%934 = load i32, i32* %933
%935 = lshr i32 %934, 16
%936 = zext i32 %935 to i64
%937 = getelementptr inbounds i32, i32* %4, i64 %936
%938 = load i32, i32* %937
%939 = add i32 %938, %930
%940 = and i32 %934, 65535
%941 = zext i32 %940 to i64
%942 = getelementptr inbounds i32, i32* %4, i64 %941
%943 = load i32, i32* %942
%944 = add i32 %939, %943
%945 = add i32 %590, 22
%946 = zext i32 %945 to i64
%947 = getelementptr inbounds i32, i32* %0, i64 %946
%948 = load i32, i32* %947
%949 = lshr i32 %948, 16
%950 = zext i32 %949 to i64
%951 = getelementptr inbounds i32, i32* %4, i64 %950
%952 = load i32, i32* %951
%953 = add i32 %952, %944
%954 = and i32 %948, 65535
%955 = zext i32 %954 to i64
%956 = getelementptr inbounds i32, i32* %4, i64 %955
%957 = load i32, i32* %956
%958 = add i32 %953, %957
%959 = add i32 %590, 23
%960 = zext i32 %959 to i64
%961 = getelementptr inbounds i32, i32* %0, i64 %960
%962 = load i32, i32* %961
%963 = lshr i32 %962, 16
%964 = zext i32 %963 to i64
%965 = getelementptr inbounds i32, i32* %4, i64 %964
%966 = load i32, i32* %965
%967 = add i32 %966, %958
%968 = and i32 %962, 65535
%969 = zext i32 %968 to i64
%970 = getelementptr inbounds i32, i32* %4, i64 %969
%971 = load i32, i32* %970
%972 = add i32 %967, %971
%973 = add i32 %590, 24
%974 = zext i32 %973 to i64
%975 = getelementptr inbounds i32, i32* %0, i64 %974
%976 = load i32, i32* %975
%977 = lshr i32 %976, 16
%978 = zext i32 %977 to i64
%979 = getelementptr inbounds i32, i32* %4, i64 %978
%980 = load i32, i32* %979
%981 = add i32 %980, %972
%982 = and i32 %976, 65535
%983 = zext i32 %982 to i64
%984 = getelementptr inbounds i32, i32* %4, i64 %983
%985 = load i32, i32* %984
%986 = add i32 %981, %985
%987 = add i32 %590, 25
%988 = zext i32 %987 to i64
%989 = getelementptr inbounds i32, i32* %0, i64 %988
%990 = load i32, i32* %989
%991 = lshr i32 %990, 16
%992 = zext i32 %991 to i64
%993 = getelementptr inbounds i32, i32* %4, i64 %992
%994 = load i32, i32* %993
%995 = add i32 %994, %986
%996 = and i32 %990, 65535
%997 = zext i32 %996 to i64
%998 = getelementptr inbounds i32, i32* %4, i64 %997
%999 = load i32, i32* %998
%1000 = add i32 %995, %999
%1001 = add i32 %590, 26
%1002 = zext i32 %1001 to i64
%1003 = getelementptr inbounds i32, i32* %0, i64 %1002
%1004 = load i32, i32* %1003
%1005 = lshr i32 %1004, 16
%1006 = zext i32 %1005 to i64
%1007 = getelementptr inbounds i32, i32* %4, i64 %1006
%1008 = load i32, i32* %1007
%1009 = add i32 %1008, %1000
%1010 = and i32 %1004, 65535
%1011 = zext i32 %1010 to i64
%1012 = getelementptr inbounds i32, i32* %4, i64 %1011
%1013 = load i32, i32* %1012
%1014 = add i32 %1009, %1013
%1015 = add i32 %590, 27
%1016 = zext i32 %1015 to i64
%1017 = getelementptr inbounds i32, i32* %0, i64 %1016
%1018 = load i32, i32* %1017
%1019 = lshr i32 %1018, 16
%1020 = zext i32 %1019 to i64
%1021 = getelementptr inbounds i32, i32* %4, i64 %1020
%1022 = load i32, i32* %1021
%1023 = add i32 %1022, %1014
%1024 = and i32 %1018, 65535
%1025 = zext i32 %1024 to i64
%1026 = getelementptr inbounds i32, i32* %4, i64 %1025
%1027 = load i32, i32* %1026
%1028 = add i32 %1023, %1027
%1029 = add i32 %590, 28
%1030 = zext i32 %1029 to i64
%1031 = getelementptr inbounds i32, i32* %0, i64 %1030
%1032 = load i32, i32* %1031
%1033 = lshr i32 %1032, 16
%1034 = zext i32 %1033 to i64
%1035 = getelementptr inbounds i32, i32* %4, i64 %1034
%1036 = load i32, i32* %1035
%1037 = add i32 %1036, %1028
%1038 = and i32 %1032, 65535
%1039 = zext i32 %1038 to i64
%1040 = getelementptr inbounds i32, i32* %4, i64 %1039
%1041 = load i32, i32* %1040
%1042 = add i32 %1037, %1041
%1043 = add i32 %590, 29
%1044 = zext i32 %1043 to i64
%1045 = getelementptr inbounds i32, i32* %0, i64 %1044
%1046 = load i32, i32* %1045
%1047 = lshr i32 %1046, 16
%1048 = zext i32 %1047 to i64
%1049 = getelementptr inbounds i32, i32* %4, i64 %1048
%1050 = load i32, i32* %1049
%1051 = add i32 %1050, %1042
%1052 = and i32 %1046, 65535
%1053 = zext i32 %1052 to i64
%1054 = getelementptr inbounds i32, i32* %4, i64 %1053
%1055 = load i32, i32* %1054
%1056 = add i32 %1051, %1055
%1057 = add i32 %590, 30
%1058 = zext i32 %1057 to i64
%1059 = getelementptr inbounds i32, i32* %0, i64 %1058
%1060 = load i32, i32* %1059
%1061 = lshr i32 %1060, 16
%1062 = zext i32 %1061 to i64
%1063 = getelementptr inbounds i32, i32* %4, i64 %1062
%1064 = load i32, i32* %1063
%1065 = add i32 %1064, %1056
%1066 = and i32 %1060, 65535
%1067 = zext i32 %1066 to i64
%1068 = getelementptr inbounds i32, i32* %4, i64 %1067
%1069 = load i32, i32* %1068
%1070 = add i32 %1065, %1069
%1071 = add i32 %590, 31
%1072 = zext i32 %1071 to i64
%1073 = getelementptr inbounds i32, i32* %0, i64 %1072
%1074 = load i32, i32* %1073
%1075 = lshr i32 %1074, 16
%1076 = zext i32 %1075 to i64
%1077 = getelementptr inbounds i32, i32* %4, i64 %1076
%1078 = load i32, i32* %1077
%1079 = add i32 %1078, %1070
%1080 = and i32 %1074, 65535
%1081 = zext i32 %1080 to i64
%1082 = getelementptr inbounds i32, i32* %4, i64 %1081
%1083 = load i32, i32* %1082
%1084 = add i32 %1079, %1083
%1085 = add i32 %590, 32
%1086 = and i32 %1084, -16843009
%1087 = icmp eq i32 %1086, 0
br i1 %1087, label %1099, label %1088
1088: ; preds = %836
%1089 = and i32 %1084, 255
%1090 = add i32 %1089, %840
%1091 = lshr i32 %1084, 8
%1092 = and i32 %1091, 255
%1093 = add i32 %1092, %839
%1094 = lshr i32 %1084, 16
%1095 = and i32 %1094, 255
%1096 = add i32 %1095, %838
%1097 = lshr i32 %1084, 24
%1098 = add i32 %1097, %837
br label %1108
1099: ; preds = %836
switch i32 %1084, label %1106 [
i32 256, label %1100
i32 65536, label %1102
i32 16777216, label %1104
]
1100: ; preds = %1099
%1101 = add i32 %840, 256
br label %1108
1102: ; preds = %1099
%1103 = add i32 %839, 256
br label %1108
1104: ; preds = %1099
%1105 = add i32 %838, 256
br label %1108
1106: ; preds = %1099
%1107 = add i32 %837, 256
br label %1108
1108: ; preds = %1100, %1104, %1106, %1102, %1088
%1109 = phi i32 [ %837, %1100 ], [ %837, %1102 ], [ %837, %1104 ], [ %1107, %1106 ], [ %1098, %1088 ]
%1110 = phi i32 [ %838, %1100 ], [ %838, %1102 ], [ %1105, %1104 ], [ %838, %1106 ], [ %1096, %1088 ]
%1111 = phi i32 [ %839, %1100 ], [ %1103, %1102 ], [ %839, %1104 ], [ %839, %1106 ], [ %1093, %1088 ]
%1112 = phi i32 [ %1101, %1100 ], [ %840, %1102 ], [ %840, %1104 ], [ %840, %1106 ], [ %1090, %1088 ]
%1113 = icmp eq i64 %862, %27
br i1 %1113, label %1114, label %584
1114: ; preds = %1108, %20
%1115 = phi i32 [ %21, %20 ], [ %23, %1108 ]
%1116 = phi i32 [ %22, %20 ], [ %1085, %1108 ]
%1117 = phi i32 [ 0, %20 ], [ %1109, %1108 ]
%1118 = phi i32 [ 0, %20 ], [ %1110, %1108 ]
%1119 = phi i32 [ 0, %20 ], [ %1111, %1108 ]
%1120 = phi i32 [ 0, %20 ], [ %1112, %1108 ]
%1121 = shl i32 %1115, 1
%1122 = icmp ult i32 %1121, %7
br i1 %1122, label %1123, label %1368
1123: ; preds = %1114
%1124 = zext i32 %1116 to i64
%1125 = getelementptr inbounds i32, i32* %0, i64 %1124
%1126 = load i32, i32* %1125
%1127 = lshr i32 %1126, 16
%1128 = zext i32 %1127 to i64
%1129 = getelementptr inbounds i32, i32* %4, i64 %1128
%1130 = load i32, i32* %1129
%1131 = and i32 %1126, 65535
%1132 = zext i32 %1131 to i64
%1133 = getelementptr inbounds i32, i32* %4, i64 %1132
%1134 = load i32, i32* %1133
%1135 = add i32 %1130, %1134
%1136 = add i32 %1116, 1
%1137 = zext i32 %1136 to i64
%1138 = getelementptr inbounds i32, i32* %0, i64 %1137
%1139 = load i32, i32* %1138
%1140 = lshr i32 %1139, 16
%1141 = zext i32 %1140 to i64
%1142 = getelementptr inbounds i32, i32* %4, i64 %1141
%1143 = load i32, i32* %1142
%1144 = add i32 %1143, %1135
%1145 = and i32 %1139, 65535
%1146 = zext i32 %1145 to i64
%1147 = getelementptr inbounds i32, i32* %4, i64 %1146
%1148 = load i32, i32* %1147
%1149 = add i32 %1144, %1148
%1150 = add i32 %1116, 2
%1151 = zext i32 %1150 to i64
%1152 = getelementptr inbounds i32, i32* %0, i64 %1151
%1153 = load i32, i32* %1152
%1154 = lshr i32 %1153, 16
%1155 = zext i32 %1154 to i64
%1156 = getelementptr inbounds i32, i32* %4, i64 %1155
%1157 = load i32, i32* %1156
%1158 = add i32 %1157, %1149
%1159 = and i32 %1153, 65535
%1160 = zext i32 %1159 to i64
%1161 = getelementptr inbounds i32, i32* %4, i64 %1160
%1162 = load i32, i32* %1161
%1163 = add i32 %1158, %1162
%1164 = add i32 %1116, 3
%1165 = zext i32 %1164 to i64
%1166 = getelementptr inbounds i32, i32* %0, i64 %1165
%1167 = load i32, i32* %1166
%1168 = lshr i32 %1167, 16
%1169 = zext i32 %1168 to i64
%1170 = getelementptr inbounds i32, i32* %4, i64 %1169
%1171 = load i32, i32* %1170
%1172 = add i32 %1171, %1163
%1173 = and i32 %1167, 65535
%1174 = zext i32 %1173 to i64
%1175 = getelementptr inbounds i32, i32* %4, i64 %1174
%1176 = load i32, i32* %1175
%1177 = add i32 %1172, %1176
%1178 = add i32 %1116, 4
%1179 = zext i32 %1178 to i64
%1180 = getelementptr inbounds i32, i32* %0, i64 %1179
%1181 = load i32, i32* %1180
%1182 = lshr i32 %1181, 16
%1183 = zext i32 %1182 to i64
%1184 = getelementptr inbounds i32, i32* %4, i64 %1183
%1185 = load i32, i32* %1184
%1186 = add i32 %1185, %1177
%1187 = and i32 %1181, 65535
%1188 = zext i32 %1187 to i64
%1189 = getelementptr inbounds i32, i32* %4, i64 %1188
%1190 = load i32, i32* %1189
%1191 = add i32 %1186, %1190
%1192 = add i32 %1116, 5
%1193 = zext i32 %1192 to i64
%1194 = getelementptr inbounds i32, i32* %0, i64 %1193
%1195 = load i32, i32* %1194
%1196 = lshr i32 %1195, 16
%1197 = zext i32 %1196 to i64
%1198 = getelementptr inbounds i32, i32* %4, i64 %1197
%1199 = load i32, i32* %1198
%1200 = add i32 %1199, %1191
%1201 = and i32 %1195, 65535
%1202 = zext i32 %1201 to i64
%1203 = getelementptr inbounds i32, i32* %4, i64 %1202
%1204 = load i32, i32* %1203
%1205 = add i32 %1200, %1204
%1206 = add i32 %1116, 6
%1207 = zext i32 %1206 to i64
%1208 = getelementptr inbounds i32, i32* %0, i64 %1207
%1209 = load i32, i32* %1208
%1210 = lshr i32 %1209, 16
%1211 = zext i32 %1210 to i64
%1212 = getelementptr inbounds i32, i32* %4, i64 %1211
%1213 = load i32, i32* %1212
%1214 = add i32 %1213, %1205
%1215 = and i32 %1209, 65535
%1216 = zext i32 %1215 to i64
%1217 = getelementptr inbounds i32, i32* %4, i64 %1216
%1218 = load i32, i32* %1217
%1219 = add i32 %1214, %1218
%1220 = add i32 %1116, 7
%1221 = zext i32 %1220 to i64
%1222 = getelementptr inbounds i32, i32* %0, i64 %1221
%1223 = load i32, i32* %1222
%1224 = lshr i32 %1223, 16
%1225 = zext i32 %1224 to i64
%1226 = getelementptr inbounds i32, i32* %4, i64 %1225
%1227 = load i32, i32* %1226
%1228 = add i32 %1227, %1219
%1229 = and i32 %1223, 65535
%1230 = zext i32 %1229 to i64
%1231 = getelementptr inbounds i32, i32* %4, i64 %1230
%1232 = load i32, i32* %1231
%1233 = add i32 %1228, %1232
%1234 = add i32 %1116, 8
%1235 = zext i32 %1234 to i64
%1236 = getelementptr inbounds i32, i32* %0, i64 %1235
%1237 = load i32, i32* %1236
%1238 = lshr i32 %1237, 16
%1239 = zext i32 %1238 to i64
%1240 = getelementptr inbounds i32, i32* %4, i64 %1239
%1241 = load i32, i32* %1240
%1242 = add i32 %1241, %1233
%1243 = and i32 %1237, 65535
%1244 = zext i32 %1243 to i64
%1245 = getelementptr inbounds i32, i32* %4, i64 %1244
%1246 = load i32, i32* %1245
%1247 = add i32 %1242, %1246
%1248 = add i32 %1116, 9
%1249 = zext i32 %1248 to i64
%1250 = getelementptr inbounds i32, i32* %0, i64 %1249
%1251 = load i32, i32* %1250
%1252 = lshr i32 %1251, 16
%1253 = zext i32 %1252 to i64
%1254 = getelementptr inbounds i32, i32* %4, i64 %1253
%1255 = load i32, i32* %1254
%1256 = add i32 %1255, %1247
%1257 = and i32 %1251, 65535
%1258 = zext i32 %1257 to i64
%1259 = getelementptr inbounds i32, i32* %4, i64 %1258
%1260 = load i32, i32* %1259
%1261 = add i32 %1256, %1260
%1262 = add i32 %1116, 10
%1263 = zext i32 %1262 to i64
%1264 = getelementptr inbounds i32, i32* %0, i64 %1263
%1265 = load i32, i32* %1264
%1266 = lshr i32 %1265, 16
%1267 = zext i32 %1266 to i64
%1268 = getelementptr inbounds i32, i32* %4, i64 %1267
%1269 = load i32, i32* %1268
%1270 = add i32 %1269, %1261
%1271 = and i32 %1265, 65535
%1272 = zext i32 %1271 to i64
%1273 = getelementptr inbounds i32, i32* %4, i64 %1272
%1274 = load i32, i32* %1273
%1275 = add i32 %1270, %1274
%1276 = add i32 %1116, 11
%1277 = zext i32 %1276 to i64
%1278 = getelementptr inbounds i32, i32* %0, i64 %1277
%1279 = load i32, i32* %1278
%1280 = lshr i32 %1279, 16
%1281 = zext i32 %1280 to i64
%1282 = getelementptr inbounds i32, i32* %4, i64 %1281
%1283 = load i32, i32* %1282
%1284 = add i32 %1283, %1275
%1285 = and i32 %1279, 65535
%1286 = zext i32 %1285 to i64
%1287 = getelementptr inbounds i32, i32* %4, i64 %1286
%1288 = load i32, i32* %1287
%1289 = add i32 %1284, %1288
%1290 = add i32 %1116, 12
%1291 = zext i32 %1290 to i64
%1292 = getelementptr inbounds i32, i32* %0, i64 %1291
%1293 = load i32, i32* %1292
%1294 = lshr i32 %1293, 16
%1295 = zext i32 %1294 to i64
%1296 = getelementptr inbounds i32, i32* %4, i64 %1295
%1297 = load i32, i32* %1296
%1298 = add i32 %1297, %1289
%1299 = and i32 %1293, 65535
%1300 = zext i32 %1299 to i64
%1301 = getelementptr inbounds i32, i32* %4, i64 %1300
%1302 = load i32, i32* %1301
%1303 = add i32 %1298, %1302
%1304 = add i32 %1116, 13
%1305 = zext i32 %1304 to i64
%1306 = getelementptr inbounds i32, i32* %0, i64 %1305
%1307 = load i32, i32* %1306
%1308 = lshr i32 %1307, 16
%1309 = zext i32 %1308 to i64
%1310 = getelementptr inbounds i32, i32* %4, i64 %1309
%1311 = load i32, i32* %1310
%1312 = add i32 %1311, %1303
%1313 = and i32 %1307, 65535
%1314 = zext i32 %1313 to i64
%1315 = getelementptr inbounds i32, i32* %4, i64 %1314
%1316 = load i32, i32* %1315
%1317 = add i32 %1312, %1316
%1318 = add i32 %1116, 14
%1319 = zext i32 %1318 to i64
%1320 = getelementptr inbounds i32, i32* %0, i64 %1319
%1321 = load i32, i32* %1320
%1322 = lshr i32 %1321, 16
%1323 = zext i32 %1322 to i64
%1324 = getelementptr inbounds i32, i32* %4, i64 %1323
%1325 = load i32, i32* %1324
%1326 = add i32 %1325, %1317
%1327 = and i32 %1321, 65535
%1328 = zext i32 %1327 to i64
%1329 = getelementptr inbounds i32, i32* %4, i64 %1328
%1330 = load i32, i32* %1329
%1331 = add i32 %1326, %1330
%1332 = add i32 %1116, 15
%1333 = zext i32 %1332 to i64
%1334 = getelementptr inbounds i32, i32* %0, i64 %1333
%1335 = load i32, i32* %1334
%1336 = lshr i32 %1335, 16
%1337 = zext i32 %1336 to i64
%1338 = getelementptr inbounds i32, i32* %4, i64 %1337
%1339 = load i32, i32* %1338
%1340 = add i32 %1339, %1331
%1341 = and i32 %1335, 65535
%1342 = zext i32 %1341 to i64
%1343 = getelementptr inbounds i32, i32* %4, i64 %1342
%1344 = load i32, i32* %1343
%1345 = add i32 %1340, %1344
%1346 = and i32 %1345, -16843009
%1347 = icmp eq i32 %1346, 0
br i1 %1347, label %1359, label %1348
1348: ; preds = %1123
%1349 = and i32 %1345, 255
%1350 = add i32 %1349, %1120
%1351 = lshr i32 %1345, 8
%1352 = and i32 %1351, 255
%1353 = add i32 %1352, %1119
%1354 = lshr i32 %1345, 16
%1355 = and i32 %1354, 255
%1356 = add i32 %1355, %1118
%1357 = lshr i32 %1345, 24
%1358 = add i32 %1357, %1117
br label %1368
1359: ; preds = %1123
switch i32 %1345, label %1366 [
i32 256, label %1360
i32 65536, label %1362
i32 16777216, label %1364
]
1360: ; preds = %1359
%1361 = add i32 %1120, 256
br label %1368
1362: ; preds = %1359
%1363 = add i32 %1119, 256
br label %1368
1364: ; preds = %1359
%1365 = add i32 %1118, 256
br label %1368
1366: ; preds = %1359
%1367 = add i32 %1117, 256
br label %1368
1368: ; preds = %1348, %1362, %1366, %1364, %1360, %1114
%1369 = phi i32 [ %1117, %1360 ], [ %1117, %1362 ], [ %1117, %1364 ], [ %1367, %1366 ], [ %1358, %1348 ], [ %1117, %1114 ]
%1370 = phi i32 [ %1118, %1360 ], [ %1118, %1362 ], [ %1365, %1364 ], [ %1118, %1366 ], [ %1356, %1348 ], [ %1118, %1114 ]
%1371 = phi i32 [ %1119, %1360 ], [ %1363, %1362 ], [ %1119, %1364 ], [ %1119, %1366 ], [ %1353, %1348 ], [ %1119, %1114 ]
%1372 = phi i32 [ %1361, %1360 ], [ %1120, %1362 ], [ %1120, %1364 ], [ %1120, %1366 ], [ %1350, %1348 ], [ %1120, %1114 ]
%1373 = shl i32 %1120, 16
%1374 = or i32 %1372, %1373
%1375 = shl i32 %1115, 2
%1376 = zext i32 %1375 to i64
%1377 = getelementptr inbounds i32, i32* %1, i64 %1376
store i32 %1374, i32* %1377
%1378 = shl i32 %1119, 16
%1379 = or i32 %1371, %1378
%1380 = or i32 %1375, 1
%1381 = zext i32 %1380 to i64
%1382 = getelementptr inbounds i32, i32* %1, i64 %1381
store i32 %1379, i32* %1382
%1383 = shl i32 %1118, 16
%1384 = or i32 %1370, %1383
%1385 = or i32 %1375, 2
%1386 = zext i32 %1385 to i64
%1387 = getelementptr inbounds i32, i32* %1, i64 %1386
store i32 %1384, i32* %1387
%1388 = shl i32 %1117, 16
%1389 = or i32 %1369, %1388
%1390 = or i32 %1375, 3
%1391 = zext i32 %1390 to i64
%1392 = getelementptr inbounds i32, i32* %1, i64 %1391
store i32 %1389, i32* %1392
ret void
}