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

/* Forward declarations */

/* Type definitions */

/* Variables and functions */
scalar_t__ calloc(int, int);
int /*<<< orphan*/ free(unsigned long long *);
int /*<<< orphan*/ printf(char *, char, ...);
int Edit_Distance_multiple_word_NoEndPenaltySeq1(char *stringN, char *stringM,
                                                 int N, int M) {
  int i, j;
  unsigned long long int *matchA;
  unsigned long long int *matchC;
  unsigned long long int *matchG;
  unsigned long long int *matchT;
  unsigned long long int *matchN;
  unsigned long long int *matchVector;
  unsigned long long int bitmask;
  unsigned long long int matchString;
  unsigned long long int *P_D;
  unsigned long long int *P_S_or_P_D;
  unsigned long long int M_m;
  unsigned long long int R_IS;
  unsigned long long int not_M_I;
  unsigned long long int not_M_I_xor_P_D;
  unsigned long long int VC_0;
  unsigned long long int VC_plus_1;
  unsigned long long int VC_0_shift;
  unsigned long long int VC_plus_1_shift;
  unsigned long long int sum;
  unsigned long long int sum_and_R_IS;
  unsigned long long int highBitMask64 = 0x8000000000000000;
  unsigned long long int carryBitSum;
  unsigned long long int carryBitVC_plus_1_shift;
  unsigned long long int carryBitVC_0_shift;
  unsigned long long int oldCarryBitVC_plus_1_shift;
  unsigned long long int oldCarryBitVC_0_shift;
  unsigned long long int P_DErase;
  unsigned long long int P_IErase;
  unsigned long long int mask;
  int Score;
  int bestFinalRowScore;
  int nWords;
  int integerPart;
  int NWords;
  int junkBits;
  unsigned long long int junkBitsMask;
  int bestFinalColumn;
  if (M == 0)
    return (0);
  if (N > 64 - 1) {
    integerPart = (N - 64 + 1) / 64;
    nWords =
        (N - 64 + 1 - 64 * integerPart) > 0 ? integerPart + 2 : integerPart + 1;
  } else
    nWords = 1;
  junkBits = 64 - 1 + (nWords - 1) * 64 - N;
  junkBitsMask = 0xFFFFFFFFFFFFFFFF >> junkBits;
  NWords = nWords;
  matchA =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  matchC =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  matchG =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  matchT =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  matchN =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  P_D =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  P_S_or_P_D =
      (unsigned long long int *)calloc(NWords, sizeof(unsigned long long int));
  for (j = 0; j < NWords; j++) {
    bitmask = 0x0000000000000001;
    matchA[j] = 0x0000000000000000;
    matchC[j] = 0x0000000000000000;
    matchG[j] = 0x0000000000000000;
    matchT[j] = 0x0000000000000000;
    matchN[j] = 0x0000000000000000;
    for (i = j * 64; i < (j + 1) * 64; i++) {
      if (i <= N) {
        if (i || j) {
          switch (stringN[i - 1]) {
          case 'A':
            matchA[j] |= bitmask;
            break;
          case 'C':
            matchC[j] |= bitmask;
            break;
          case 'G':
            matchG[j] |= bitmask;
            break;
          case 'T':
            matchT[j] |= bitmask;
            break;
          case 'N':
            matchN[j] |= bitmask;
            break;
          default:
            printf("\nError, non-ACGTN character read at position "
                   "%d in string:%c",
                   i, stringN[i]);
            free(matchA);
            free(matchC);
            free(matchG);
            free(matchT);
            free(matchN);
            free(P_D);
            free(P_S_or_P_D);
            ;
            return (-1);
            break;
          }
        }
        bitmask <<= 1;
      }
    }
  }
  P_D[0] = 1;
  P_S_or_P_D[0] = 1;
  for (i = 0; i < M; i++) {
    carryBitSum = 0x0000000000000000;
    carryBitVC_plus_1_shift = 0x0000000000000001;
    carryBitVC_0_shift = 0x0000000000000000;
    switch (stringM[i]) {
    case 'A':
      matchVector = matchA;
      break;
    case 'C':
      matchVector = matchC;
      break;
    case 'G':
      matchVector = matchG;
      break;
    case 'T':
      matchVector = matchT;
      break;
    case 'N':
      matchVector = matchN;
      break;
    default:
      printf("\nError, non-ACGTN character read in string:%c", stringM[i]);
      free(matchA);
      free(matchC);
      free(matchG);
      free(matchT);
      free(matchN);
      free(P_D);
      free(P_S_or_P_D);
      ;
      return (-1);
      break;
    }
    for (j = 0; j < NWords; j++) {
      oldCarryBitVC_plus_1_shift = carryBitVC_plus_1_shift;
      oldCarryBitVC_0_shift = carryBitVC_0_shift;
      matchString = matchVector[j];
      M_m = matchString | P_D[j];
      R_IS = ~M_m;
      not_M_I = R_IS | P_S_or_P_D[j];
      not_M_I_xor_P_D = not_M_I ^ P_D[j];
      sum = not_M_I + carryBitSum;
      carryBitSum = (sum < not_M_I) ? 1 : 0;
      sum += P_S_or_P_D[j];
      carryBitSum |= (sum < P_S_or_P_D[j]) ? 1 : 0;
      sum_and_R_IS = sum & R_IS;
      VC_0 = sum_and_R_IS ^ not_M_I_xor_P_D;
      VC_plus_1 = P_D[j] | (sum_and_R_IS & P_S_or_P_D[j]);
      carryBitVC_0_shift = (VC_0 & highBitMask64) >> 63;
      carryBitVC_plus_1_shift = (VC_plus_1 & highBitMask64) >> 63;
      VC_0_shift = (VC_0 << 1) + oldCarryBitVC_0_shift;
      VC_plus_1_shift = (VC_plus_1 << 1) + oldCarryBitVC_plus_1_shift;
      P_D[j] = M_m & VC_plus_1_shift;
      P_S_or_P_D[j] = VC_plus_1_shift | (M_m & VC_0_shift);
    }
  }
  mask = 0x0000000000000001;
  bestFinalRowScore = M;
  bestFinalColumn = 0;
  Score = M;
  for (j = 0; j < NWords; j++) {
    P_DErase = P_D[j];
    P_IErase = ~P_S_or_P_D[j];
    if (j == NWords - 1) {
      P_DErase &= junkBitsMask;
      P_IErase &= junkBitsMask;
    }
    for (i = 0; i < 64; i++) {
      if (i | j) {
        Score -= (int)P_DErase & mask;
        Score += (int)P_IErase & mask;
        if (Score < bestFinalRowScore) {
          bestFinalRowScore = Score;
          bestFinalColumn = j * 64 + i;
        }
      }
      P_DErase >>= 1;
      P_IErase >>= 1;
    }
  }
  free(matchA);
  free(matchC);
  free(matchG);
  free(matchT);
  free(matchN);
  free(P_D);
  free(P_S_or_P_D);
  ;
  return (bestFinalRowScore);
}


x86 assembly (clang, -O0):
<Edit_Distance_multiple_word_NoEndPenaltySeq1>:
push   %rbp
mov    %rsp,%rbp
sub    $0x150,%rsp
mov    %rdi,-0x10(%rbp)
mov    %rsi,-0x18(%rbp)
mov    %edx,-0x1c(%rbp)
mov    %ecx,-0x20(%rbp)
movabs $0x8000000000000000,%rax
mov    %rax,-0xd0(%rbp)
cmpl   $0x0,-0x20(%rbp)
jne    1170 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x40>
movl   $0x0,-0x4(%rbp)
jmp    19d6 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x8a6>
cmpl   $0x3f,-0x1c(%rbp)
jle    11e2 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0xb2>
mov    -0x1c(%rbp),%eax
sub    $0x40,%eax
add    $0x1,%eax
mov    $0x40,%ecx
cltd
idiv   %ecx
mov    %eax,-0x120(%rbp)
mov    -0x1c(%rbp),%eax
sub    $0x40,%eax
add    $0x1,%eax
mov    -0x120(%rbp),%ecx
shl    $0x6,%ecx
sub    %ecx,%eax
cmp    $0x0,%eax
jle    11c2 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x92>
mov    -0x120(%rbp),%eax
add    $0x2,%eax
mov    %eax,-0x138(%rbp)
jmp    11d1 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0xa1>
mov    -0x120(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x138(%rbp)
mov    -0x138(%rbp),%eax
mov    %eax,-0x11c(%rbp)
jmp    11ec <Edit_Distance_multiple_word_NoEndPenaltySeq1+0xbc>
movl   $0x1,-0x11c(%rbp)
mov    -0x11c(%rbp),%eax
sub    $0x1,%eax
shl    $0x6,%eax
add    $0x3f,%eax
sub    -0x1c(%rbp),%eax
mov    %eax,-0x128(%rbp)
mov    -0x128(%rbp),%eax
mov    %eax,%ecx
mov    $0xffffffffffffffff,%rax
shr    %cl,%rax
mov    %rax,-0x130(%rbp)
mov    -0x11c(%rbp),%eax
mov    %eax,-0x124(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x30(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x38(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x40(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x48(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x50(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x70(%rbp)
mov    -0x124(%rbp),%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x124(%rbp),%eax
jge    14bc <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x38c>
movq   $0x1,-0x60(%rbp)
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
movq   $0x0,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
shl    $0x6,%eax
mov    %eax,-0x24(%rbp)
mov    -0x24(%rbp),%eax
mov    -0x28(%rbp),%ecx
add    $0x1,%ecx
shl    $0x6,%ecx
cmp    %ecx,%eax
jge    14a9 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x379>
mov    -0x24(%rbp),%eax
cmp    -0x1c(%rbp),%eax
jg     1496 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x366>
cmpl   $0x0,-0x24(%rbp)
jne    1360 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x230>
cmpl   $0x0,-0x28(%rbp)
je     148a <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x35a>
mov    -0x10(%rbp),%rax
mov    -0x24(%rbp),%ecx
add    $0xffffffff,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x140(%rbp)
sub    $0x13,%eax
ja     141a <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x2ea>
mov    -0x140(%rbp),%rax
lea    0xcbc(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x60(%rbp),%rdx
mov    -0x30(%rbp),%rax
movslq -0x28(%rbp),%rcx
or     (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1485 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x355>
mov    -0x60(%rbp),%rdx
mov    -0x38(%rbp),%rax
movslq -0x28(%rbp),%rcx
or     (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1485 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x355>
mov    -0x60(%rbp),%rdx
mov    -0x40(%rbp),%rax
movslq -0x28(%rbp),%rcx
or     (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1485 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x355>
mov    -0x60(%rbp),%rdx
mov    -0x48(%rbp),%rax
movslq -0x28(%rbp),%rcx
or     (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1485 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x355>
mov    -0x60(%rbp),%rdx
mov    -0x50(%rbp),%rax
movslq -0x28(%rbp),%rcx
or     (%rax,%rcx,8),%rdx
mov    %rdx,(%rax,%rcx,8)
jmp    1485 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x355>
mov    -0x24(%rbp),%eax
mov    -0x10(%rbp),%rcx
movslq -0x24(%rbp),%rdx
movsbl (%rcx,%rdx,1),%edx
lea    0xc70(%rip),%rdi
movsbl %al,%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    19d6 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x8a6>
jmp    148a <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x35a>
mov    -0x60(%rbp),%rax
shl    $0x1,%rax
mov    %rax,-0x60(%rbp)
jmp    149b <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x36b>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    132c <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1fc>
jmp    14ae <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x37e>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    12bc <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x18c>
mov    -0x70(%rbp),%rax
movq   $0x1,(%rax)
mov    -0x78(%rbp),%rax
movq   $0x1,(%rax)
movl   $0x0,-0x24(%rbp)
mov    -0x24(%rbp),%eax
cmp    -0x20(%rbp),%eax
jge    1810 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x6e0>
movq   $0x0,-0xd8(%rbp)
movq   $0x1,-0xe0(%rbp)
movq   $0x0,-0xe8(%rbp)
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
movsbl (%rax,%rcx,1),%eax
add    $0xffffffbf,%eax
mov    %eax,%ecx
mov    %rcx,-0x148(%rbp)
sub    $0x13,%eax
ja     157f <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x44f>
mov    -0x148(%rbp),%rax
lea    0xacb(%rip),%rcx
movslq (%rcx,%rax,4),%rax
add    %rcx,%rax
jmp    *%rax
mov    -0x30(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    15e4 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4b4>
mov    -0x38(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    15e4 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4b4>
mov    -0x40(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    15e4 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4b4>
mov    -0x48(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    15e4 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4b4>
mov    -0x50(%rbp),%rax
mov    %rax,-0x58(%rbp)
jmp    15e4 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4b4>
mov    -0x18(%rbp),%rax
movslq -0x24(%rbp),%rcx
lea    0xb4f(%rip),%rdi
movsbl (%rax,%rcx,1),%esi
mov    $0x0,%al
call   1040 <printf@plt>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
movl   $0xffffffff,-0x4(%rbp)
jmp    19d6 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x8a6>
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x124(%rbp),%eax
jge    17fd <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x6cd>
mov    -0xe0(%rbp),%rax
mov    %rax,-0xf0(%rbp)
mov    -0xe8(%rbp),%rax
mov    %rax,-0xf8(%rbp)
mov    -0x58(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x68(%rbp)
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq -0x28(%rbp),%rdx
or     (%rcx,%rdx,8),%rax
mov    %rax,-0x80(%rbp)
mov    -0x80(%rbp),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x88(%rbp)
mov    -0x88(%rbp),%rax
mov    -0x78(%rbp),%rcx
movslq -0x28(%rbp),%rdx
or     (%rcx,%rdx,8),%rax
mov    %rax,-0x90(%rbp)
mov    -0x90(%rbp),%rax
mov    -0x70(%rbp),%rcx
movslq -0x28(%rbp),%rdx
xor    (%rcx,%rdx,8),%rax
mov    %rax,-0x98(%rbp)
mov    -0x90(%rbp),%rax
add    -0xd8(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rdx
mov    -0x90(%rbp),%rsi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %rsi,%rdx
cmovb  %ecx,%eax
cltq
mov    %rax,-0xd8(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
add    -0xc0(%rbp),%rax
mov    %rax,-0xc0(%rbp)
mov    -0xc0(%rbp),%rdx
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
xor    %eax,%eax
mov    $0x1,%ecx
cmp    %rsi,%rdx
cmovb  %ecx,%eax
cltq
or     -0xd8(%rbp),%rax
mov    %rax,-0xd8(%rbp)
mov    -0xc0(%rbp),%rax
and    -0x88(%rbp),%rax
mov    %rax,-0xc8(%rbp)
mov    -0xc8(%rbp),%rax
xor    -0x98(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    -0xc8(%rbp),%rcx
mov    -0x78(%rbp),%rdx
movslq -0x28(%rbp),%rsi
and    (%rdx,%rsi,8),%rcx
or     %rcx,%rax
mov    %rax,-0xa8(%rbp)
mov    -0xa0(%rbp),%rax
and    -0xd0(%rbp),%rax
shr    $0x3f,%rax
mov    %rax,-0xe8(%rbp)
mov    -0xa8(%rbp),%rax
and    -0xd0(%rbp),%rax
shr    $0x3f,%rax
mov    %rax,-0xe0(%rbp)
mov    -0xa0(%rbp),%rax
shl    $0x1,%rax
add    -0xf8(%rbp),%rax
mov    %rax,-0xb0(%rbp)
mov    -0xa8(%rbp),%rax
shl    $0x1,%rax
add    -0xf0(%rbp),%rax
mov    %rax,-0xb8(%rbp)
mov    -0x80(%rbp),%rdx
and    -0xb8(%rbp),%rdx
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0xb8(%rbp),%rdx
mov    -0x80(%rbp),%rax
and    -0xb0(%rbp),%rax
or     %rax,%rdx
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    15eb <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4bb>
jmp    1802 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x6d2>
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    14d9 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x3a9>
movq   $0x1,-0x110(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x118(%rbp)
movl   $0x0,-0x134(%rbp)
mov    -0x20(%rbp),%eax
mov    %eax,-0x114(%rbp)
movl   $0x0,-0x28(%rbp)
mov    -0x28(%rbp),%eax
cmp    -0x124(%rbp),%eax
jge    198e <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x85e>
mov    -0x70(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    %rax,-0x100(%rbp)
mov    -0x78(%rbp),%rax
movslq -0x28(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
xor    $0xffffffffffffffff,%rax
mov    %rax,-0x108(%rbp)
mov    -0x28(%rbp),%eax
mov    -0x124(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jne    18b5 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x785>
mov    -0x130(%rbp),%rax
and    -0x100(%rbp),%rax
mov    %rax,-0x100(%rbp)
mov    -0x130(%rbp),%rax
and    -0x108(%rbp),%rax
mov    %rax,-0x108(%rbp)
movl   $0x0,-0x24(%rbp)
cmpl   $0x40,-0x24(%rbp)
jge    197b <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x84b>
mov    -0x24(%rbp),%eax
or     -0x28(%rbp),%eax
cmp    $0x0,%eax
je     1949 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x819>
mov    -0x100(%rbp),%rax
movslq %eax,%rcx
and    -0x110(%rbp),%rcx
movslq -0x114(%rbp),%rax
sub    %rcx,%rax
mov    %eax,-0x114(%rbp)
mov    -0x108(%rbp),%rax
movslq %eax,%rcx
and    -0x110(%rbp),%rcx
movslq -0x114(%rbp),%rax
add    %rcx,%rax
mov    %eax,-0x114(%rbp)
mov    -0x114(%rbp),%eax
cmp    -0x118(%rbp),%eax
jge    1944 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x814>
mov    -0x114(%rbp),%eax
mov    %eax,-0x118(%rbp)
mov    -0x28(%rbp),%eax
shl    $0x6,%eax
add    -0x24(%rbp),%eax
mov    %eax,-0x134(%rbp)
jmp    1949 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x819>
mov    -0x100(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x100(%rbp)
mov    -0x108(%rbp),%rax
shr    $0x1,%rax
mov    %rax,-0x108(%rbp)
mov    -0x24(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x24(%rbp)
jmp    18bc <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x78c>
jmp    1980 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x850>
mov    -0x28(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x28(%rbp)
jmp    183e <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x70e>
mov    -0x30(%rbp),%rdi
call   1030 <free@plt>
mov    -0x38(%rbp),%rdi
call   1030 <free@plt>
mov    -0x40(%rbp),%rdi
call   1030 <free@plt>
mov    -0x48(%rbp),%rdi
call   1030 <free@plt>
mov    -0x50(%rbp),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
mov    -0x118(%rbp),%eax
mov    %eax,-0x4(%rbp)
mov    -0x4(%rbp),%eax
add    $0x150,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<Edit_Distance_multiple_word_NoEndPenaltySeq1>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x88,%rsp
mov    %rsi,0x68(%rsp)
mov    %rdi,0x28(%rsp)
test   %ecx,%ecx
je     13a3 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x273>
mov    %ecx,%r13d
mov    %edx,%ebx
mov    $0x1,%r12d
cmp    $0x40,%edx
jl     1183 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x53>
lea    -0x3f(%rbx),%eax
mov    %eax,%ecx
shr    $0x6,%ecx
mov    %ecx,%edx
shl    $0x6,%edx
sub    %edx,%eax
xor    %edx,%edx
test   %eax,%eax
setle  %dl
neg    %edx
lea    (%rcx,%rdx,1),%r12d
add    $0x2,%r12d
lea    -0x1(%r12),%ecx
mov    %ecx,0x4c(%rsp)
shl    $0x6,%ecx
sub    %ebx,%ecx
add    $0x3f,%cl
mov    $0xffffffffffffffff,%rax
shr    %cl,%rax
mov    %rax,0x50(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x20(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x10(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x18(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%r15
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,%r14
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x38(%rsp)
mov    %r12d,%edi
mov    $0x8,%esi
call   1050 <calloc@plt>
mov    %rax,0x8(%rsp)
movslq %ebx,%rcx
mov    %r12d,%eax
mov    %rax,0x40(%rsp)
xor    %r9d,%r9d
lea    0xdce(%rip),%rdx
xor    %r12d,%r12d
jmp    124f <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x11f>
nopw   0x0(%rax,%rax,1)
add    $0x40,%r12d
cmp    0x40(%rsp),%r9
je     13ab <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x27b>
mov    %r12d,%eax
mov    %r9,%rdi
movslq %r12d,%rbp
mov    %r12d,%r12d
mov    0x20(%rsp),%rax
lea    (%rax,%r9,8),%rbx
movq   $0x0,(%rax,%r9,8)
mov    0x10(%rsp),%rax
lea    (%rax,%r9,8),%rsi
mov    %rsi,0x30(%rsp)
movq   $0x0,(%rax,%r9,8)
mov    0x18(%rsp),%rax
lea    (%rax,%r9,8),%rsi
mov    %rsi,0x80(%rsp)
movq   $0x0,(%rax,%r9,8)
lea    (%r15,%r9,8),%rax
mov    %rax,0x78(%rsp)
movq   $0x0,(%r15,%r9,8)
lea    (%r14,%r9,8),%rax
mov    %rax,0x70(%rsp)
movq   $0x0,(%r14,%r9,8)
lea    0x1(%r9),%rax
mov    %rax,%r9
mov    %eax,%r11d
shl    $0x6,%r11d
mov    $0x1,%r10d
mov    %r12,%rsi
jmp    12f7 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1c7>
mov    0x30(%rsp),%rax
nopl   0x0(%rax,%rax,1)
or     %r10,(%rax)
add    %r10,%r10
add    $0x1,%rbp
add    $0x1,%rsi
cmp    %esi,%r11d
jbe    1240 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x110>
cmp    %rcx,%rbp
jg     12e6 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1b6>
mov    %rbp,%rax
or     %rdi,%rax
je     12e3 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1b3>
mov    0x28(%rsp),%rax
movsbl -0x1(%rax,%rbp,1),%eax
add    $0xffffffbf,%eax
cmp    $0x13,%eax
ja     133b <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x20b>
movslq (%rdx,%rax,4),%r8
add    %rdx,%r8
mov    %rbx,%rax
jmp    *%r8
mov    0x80(%rsp),%rax
jmp    12e0 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1b0>
mov    0x70(%rsp),%rax
jmp    12e0 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1b0>
mov    0x78(%rsp),%rax
jmp    12e0 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x1b0>
mov    0x28(%rsp),%rax
movsbl (%rax,%rsi,1),%edx
movsbl %bpl,%esi
lea    0xd51(%rip),%rdi
xor    %eax,%eax
call   1040 <printf@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    0x38(%rsp),%rdi
call   1030 <free@plt>
mov    0x8(%rsp),%rdi
call   1030 <free@plt>
mov    $0xffffffff,%r13d
jmp    15bc <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x48c>
xor    %r13d,%r13d
jmp    15bc <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x48c>
mov    0x38(%rsp),%r10
movq   $0x1,(%r10)
mov    0x8(%rsp),%rax
movq   $0x1,(%rax)
test   %r13d,%r13d
jle    14dd <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x3ad>
mov    %r13d,%eax
mov    %rax,0x30(%rsp)
xor    %edx,%edx
mov    %r14,0x60(%rsp)
mov    %r15,0x58(%rsp)
mov    0x68(%rsp),%rax
movsbl (%rax,%rdx,1),%eax
lea    -0x41(%rax),%ecx
cmp    $0x13,%ecx
ja     15d1 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x4a1>
lea    0xc54(%rip),%rsi
movslq (%rsi,%rcx,4),%rcx
add    %rsi,%rcx
mov    0x20(%rsp),%r12
jmp    *%rcx
mov    0x10(%rsp),%r12
jmp    1420 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x2f0>
mov    0x18(%rsp),%r12
jmp    1420 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x2f0>
mov    %r14,%r12
jmp    1420 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x2f0>
mov    %r15,%r12
mov    %rdx,0x28(%rsp)
mov    $0x1,%r9d
xor    %eax,%eax
xor    %ebp,%ebp
xor    %r14d,%r14d
mov    0x8(%rsp),%r15
nopw   0x0(%rax,%rax,1)
mov    (%r10,%rax,8),%r8
mov    (%r12,%rax,8),%r10
or     %r8,%r10
mov    %r10,%rsi
not    %rsi
mov    (%r15,%rax,8),%r11
mov    %r11,%rdi
or     %rsi,%rdi
mov    %rdi,%rbx
xor    %r8,%rbx
add    %rbp,%rdi
setb   %cl
add    %r11,%rdi
setb   %dl
or     %cl,%dl
movzbl %dl,%ebp
and    %rsi,%rdi
xor    %rdi,%rbx
and    %r11,%rdi
or     %r8,%rdi
mov    %rbx,%rcx
shr    $0x3f,%rcx
mov    %rdi,%rdx
shr    $0x3f,%rdx
add    %rbx,%rbx
or     %r14,%rbx
add    %rdi,%rdi
or     %r9,%rdi
and    %r10,%rbx
or     %rdi,%rbx
and    %r10,%rdi
mov    0x38(%rsp),%r10
mov    %rdi,(%r10,%rax,8)
mov    %rbx,(%r15,%rax,8)
add    $0x1,%rax
mov    %rdx,%r9
mov    %rcx,%r14
cmp    %rax,0x40(%rsp)
jne    1440 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x310>
mov    0x28(%rsp),%rdx
add    $0x1,%rdx
cmp    0x30(%rsp),%rdx
mov    0x60(%rsp),%r14
mov    0x58(%rsp),%r15
jne    13e0 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x2b0>
mov    0x4c(%rsp),%r8d
xor    %edx,%edx
mov    %r13d,%esi
mov    0x8(%rsp),%r9
mov    0x50(%rsp),%r11
mov    0x40(%rsp),%r12
jmp    1509 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x3d9>
nopl   0x0(%rax,%rax,1)
add    $0x1,%rdx
cmp    %r12,%rdx
je     1578 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x448>
mov    (%r9,%rdx,8),%rbp
not    %rbp
cmp    %r8,%rdx
mov    $0xffffffffffffffff,%rax
cmove  %r11,%rax
mov    (%r10,%rdx,8),%rdi
and    %rax,%rdi
and    %rbp,%rax
xor    %ebx,%ebx
jmp    155b <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x42b>
nopl   0x0(%rax)
mov    %edi,%ebp
shr    %ebp
and    $0x1,%ebp
mov    %esi,%ecx
sub    %ebp,%ecx
mov    %eax,%esi
shr    %esi
and    $0x1,%esi
add    %ecx,%esi
cmp    %r13d,%esi
cmovl  %esi,%r13d
shr    $0x2,%rdi
shr    $0x2,%rax
add    $0x2,%ebx
cmp    $0x40,%ebx
je     1500 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x3d0>
mov    %ebx,%ebp
or     %edx,%ebp
je     1530 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x400>
mov    %edi,%ebp
and    $0x1,%ebp
sub    %ebp,%esi
mov    %eax,%ebp
and    $0x1,%ebp
add    %ebp,%esi
cmp    %r13d,%esi
cmovl  %esi,%r13d
jmp    1530 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x400>
mov    0x20(%rsp),%rdi
mov    %r9,%rbx
mov    %r10,%rbp
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbp,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
call   1030 <free@plt>
mov    %r13d,%eax
add    $0x88,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret
movsbl %al,%esi
lea    0xb02(%rip),%rdi
xor    %eax,%eax
mov    %r10,%rbx
call   1040 <printf@plt>
mov    0x20(%rsp),%rdi
call   1030 <free@plt>
mov    0x10(%rsp),%rdi
call   1030 <free@plt>
mov    0x18(%rsp),%rdi
call   1030 <free@plt>
mov    %r15,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
mov    %rbx,%rdi
jmp    1389 <Edit_Distance_multiple_word_NoEndPenaltySeq1+0x259>

LLVM IR (-O0):
@.str = [61 x i8] c"\0AError, non-ACGTN character read at position %d in string:%c\00"
@.str.1 = [46 x i8] c"\0AError, non-ACGTN character read in string:%c\00"
define i32 @Edit_Distance_multiple_word_NoEndPenaltySeq1(i8* %0, i8* %1, i32 %2, i32 %3) {
%5 = alloca i32
%6 = alloca i8*
%7 = alloca i8*
%8 = alloca i32
%9 = alloca i32
%10 = alloca i32
%11 = alloca i32
%12 = alloca i64*
%13 = alloca i64*
%14 = alloca i64*
%15 = alloca i64*
%16 = alloca i64*
%17 = alloca i64*
%18 = alloca i64
%19 = alloca i64
%20 = alloca i64*
%21 = alloca i64*
%22 = alloca i64
%23 = alloca i64
%24 = alloca i64
%25 = alloca i64
%26 = alloca i64
%27 = alloca i64
%28 = alloca i64
%29 = alloca i64
%30 = alloca i64
%31 = alloca i64
%32 = alloca i64
%33 = alloca i64
%34 = alloca i64
%35 = alloca i64
%36 = alloca i64
%37 = alloca i64
%38 = alloca i64
%39 = alloca i64
%40 = alloca i64
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
%44 = alloca i32
%45 = alloca i32
%46 = alloca i32
%47 = alloca i64
%48 = alloca i32
store i8* %0, i8** %6
store i8* %1, i8** %7
store i32 %2, i32* %8
store i32 %3, i32* %9
store i64 -9223372036854775808, i64* %32
%49 = load i32, i32* %9
%50 = icmp eq i32 %49, 0
br i1 %50, label %51, label %52
51: ; preds = %4
store i32 0, i32* %5
br label %500
52: ; preds = %4
%53 = load i32, i32* %8
%54 = icmp sgt i32 %53, 63
br i1 %54, label %55, label %75
55: ; preds = %52
%56 = load i32, i32* %8
%57 = sub nsw i32 %56, 64
%58 = add nsw i32 %57, 1
%59 = sdiv i32 %58, 64
store i32 %59, i32* %44
%60 = load i32, i32* %8
%61 = sub nsw i32 %60, 64
%62 = add nsw i32 %61, 1
%63 = load i32, i32* %44
%64 = mul nsw i32 64, %63
%65 = sub nsw i32 %62, %64
%66 = icmp sgt i32 %65, 0
br i1 %66, label %67, label %70
67: ; preds = %55
%68 = load i32, i32* %44
%69 = add nsw i32 %68, 2
br label %73
70: ; preds = %55
%71 = load i32, i32* %44
%72 = add nsw i32 %71, 1
br label %73
73: ; preds = %70, %67
%74 = phi i32 [ %69, %67 ], [ %72, %70 ]
store i32 %74, i32* %43
br label %76
75: ; preds = %52
store i32 1, i32* %43
br label %76
76: ; preds = %75, %73
%77 = load i32, i32* %43
%78 = sub nsw i32 %77, 1
%79 = mul nsw i32 %78, 64
%80 = add nsw i32 63, %79
%81 = load i32, i32* %8
%82 = sub nsw i32 %80, %81
store i32 %82, i32* %46
%83 = load i32, i32* %46
%84 = zext i32 %83 to i64
%85 = lshr i64 -1, %84
store i64 %85, i64* %47
%86 = load i32, i32* %43
store i32 %86, i32* %45
%87 = load i32, i32* %45
%88 = call i64 @calloc(i32 %87, i32 8)
%89 = inttoptr i64 %88 to i64*
store i64* %89, i64** %12
%90 = load i32, i32* %45
%91 = call i64 @calloc(i32 %90, i32 8)
%92 = inttoptr i64 %91 to i64*
store i64* %92, i64** %13
%93 = load i32, i32* %45
%94 = call i64 @calloc(i32 %93, i32 8)
%95 = inttoptr i64 %94 to i64*
store i64* %95, i64** %14
%96 = load i32, i32* %45
%97 = call i64 @calloc(i32 %96, i32 8)
%98 = inttoptr i64 %97 to i64*
store i64* %98, i64** %15
%99 = load i32, i32* %45
%100 = call i64 @calloc(i32 %99, i32 8)
%101 = inttoptr i64 %100 to i64*
store i64* %101, i64** %16
%102 = load i32, i32* %45
%103 = call i64 @calloc(i32 %102, i32 8)
%104 = inttoptr i64 %103 to i64*
store i64* %104, i64** %20
%105 = load i32, i32* %45
%106 = call i64 @calloc(i32 %105, i32 8)
%107 = inttoptr i64 %106 to i64*
store i64* %107, i64** %21
store i32 0, i32* %11
br label %108
108: ; preds = %232, %76
%109 = load i32, i32* %11
%110 = load i32, i32* %45
%111 = icmp slt i32 %109, %110
br i1 %111, label %112, label %235
112: ; preds = %108
store i64 1, i64* %18
%113 = load i64*, i64** %12
%114 = load i32, i32* %11
%115 = sext i32 %114 to i64
%116 = getelementptr inbounds i64, i64* %113, i64 %115
store i64 0, i64* %116
%117 = load i64*, i64** %13
%118 = load i32, i32* %11
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i64, i64* %117, i64 %119
store i64 0, i64* %120
%121 = load i64*, i64** %14
%122 = load i32, i32* %11
%123 = sext i32 %122 to i64
%124 = getelementptr inbounds i64, i64* %121, i64 %123
store i64 0, i64* %124
%125 = load i64*, i64** %15
%126 = load i32, i32* %11
%127 = sext i32 %126 to i64
%128 = getelementptr inbounds i64, i64* %125, i64 %127
store i64 0, i64* %128
%129 = load i64*, i64** %16
%130 = load i32, i32* %11
%131 = sext i32 %130 to i64
%132 = getelementptr inbounds i64, i64* %129, i64 %131
store i64 0, i64* %132
%133 = load i32, i32* %11
%134 = mul nsw i32 %133, 64
store i32 %134, i32* %10
br label %135
135: ; preds = %228, %112
%136 = load i32, i32* %10
%137 = load i32, i32* %11
%138 = add nsw i32 %137, 1
%139 = mul nsw i32 %138, 64
%140 = icmp slt i32 %136, %139
br i1 %140, label %141, label %231
141: ; preds = %135
%142 = load i32, i32* %10
%143 = load i32, i32* %8
%144 = icmp sle i32 %142, %143
br i1 %144, label %145, label %227
145: ; preds = %141
%146 = load i32, i32* %10
%147 = icmp ne i32 %146, 0
br i1 %147, label %151, label %148
148: ; preds = %145
%149 = load i32, i32* %11
%150 = icmp ne i32 %149, 0
br i1 %150, label %151, label %224
151: ; preds = %148, %145
%152 = load i8*, i8** %6
%153 = load i32, i32* %10
%154 = sub nsw i32 %153, 1
%155 = sext i32 %154 to i64
%156 = getelementptr inbounds i8, i8* %152, i64 %155
%157 = load i8, i8* %156
%158 = sext i8 %157 to i32
switch i32 %158, label %199 [
i32 65, label %159
i32 67, label %167
i32 71, label %175
i32 84, label %183
i32 78, label %191
]
159: ; preds = %151
%160 = load i64, i64* %18
%161 = load i64*, i64** %12
%162 = load i32, i32* %11
%163 = sext i32 %162 to i64
%164 = getelementptr inbounds i64, i64* %161, i64 %163
%165 = load i64, i64* %164
%166 = or i64 %165, %160
store i64 %166, i64* %164
br label %223
167: ; preds = %151
%168 = load i64, i64* %18
%169 = load i64*, i64** %13
%170 = load i32, i32* %11
%171 = sext i32 %170 to i64
%172 = getelementptr inbounds i64, i64* %169, i64 %171
%173 = load i64, i64* %172
%174 = or i64 %173, %168
store i64 %174, i64* %172
br label %223
175: ; preds = %151
%176 = load i64, i64* %18
%177 = load i64*, i64** %14
%178 = load i32, i32* %11
%179 = sext i32 %178 to i64
%180 = getelementptr inbounds i64, i64* %177, i64 %179
%181 = load i64, i64* %180
%182 = or i64 %181, %176
store i64 %182, i64* %180
br label %223
183: ; preds = %151
%184 = load i64, i64* %18
%185 = load i64*, i64** %15
%186 = load i32, i32* %11
%187 = sext i32 %186 to i64
%188 = getelementptr inbounds i64, i64* %185, i64 %187
%189 = load i64, i64* %188
%190 = or i64 %189, %184
store i64 %190, i64* %188
br label %223
191: ; preds = %151
%192 = load i64, i64* %18
%193 = load i64*, i64** %16
%194 = load i32, i32* %11
%195 = sext i32 %194 to i64
%196 = getelementptr inbounds i64, i64* %193, i64 %195
%197 = load i64, i64* %196
%198 = or i64 %197, %192
store i64 %198, i64* %196
br label %223
199: ; preds = %151
%200 = load i32, i32* %10
%201 = trunc i32 %200 to i8
%202 = load i8*, i8** %6
%203 = load i32, i32* %10
%204 = sext i32 %203 to i64
%205 = getelementptr inbounds i8, i8* %202, i64 %204
%206 = load i8, i8* %205
%207 = sext i8 %206 to i32
%208 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i8 signext %201, i32 %207)
%209 = load i64*, i64** %12
%210 = call i32 @free(i64* %209)
%211 = load i64*, i64** %13
%212 = call i32 @free(i64* %211)
%213 = load i64*, i64** %14
%214 = call i32 @free(i64* %213)
%215 = load i64*, i64** %15
%216 = call i32 @free(i64* %215)
%217 = load i64*, i64** %16
%218 = call i32 @free(i64* %217)
%219 = load i64*, i64** %20
%220 = call i32 @free(i64* %219)
%221 = load i64*, i64** %21
%222 = call i32 @free(i64* %221)
store i32 -1, i32* %5
br label %500
223: ; preds = %191, %183, %175, %167, %159
br label %224
224: ; preds = %223, %148
%225 = load i64, i64* %18
%226 = shl i64 %225, 1
store i64 %226, i64* %18
br label %227
227: ; preds = %224, %141
br label %228
228: ; preds = %227
%229 = load i32, i32* %10
%230 = add nsw i32 %229, 1
store i32 %230, i32* %10
br label %135
231: ; preds = %135
br label %232
232: ; preds = %231
%233 = load i32, i32* %11
%234 = add nsw i32 %233, 1
store i32 %234, i32* %11
br label %108
235: ; preds = %108
%236 = load i64*, i64** %20
%237 = getelementptr inbounds i64, i64* %236, i64 0
store i64 1, i64* %237
%238 = load i64*, i64** %21
%239 = getelementptr inbounds i64, i64* %238, i64 0
store i64 1, i64* %239
store i32 0, i32* %10
br label %240
240: ; preds = %401, %235
%241 = load i32, i32* %10
%242 = load i32, i32* %9
%243 = icmp slt i32 %241, %242
br i1 %243, label %244, label %404
244: ; preds = %240
store i64 0, i64* %33
store i64 1, i64* %34
store i64 0, i64* %35
%245 = load i8*, i8** %7
%246 = load i32, i32* %10
%247 = sext i32 %246 to i64
%248 = getelementptr inbounds i8, i8* %245, i64 %247
%249 = load i8, i8* %248
%250 = sext i8 %249 to i32
switch i32 %250, label %261 [
i32 65, label %251
i32 67, label %253
i32 71, label %255
i32 84, label %257
i32 78, label %259
]
251: ; preds = %244
%252 = load i64*, i64** %12
store i64* %252, i64** %17
br label %282
253: ; preds = %244
%254 = load i64*, i64** %13
store i64* %254, i64** %17
br label %282
255: ; preds = %244
%256 = load i64*, i64** %14
store i64* %256, i64** %17
br label %282
257: ; preds = %244
%258 = load i64*, i64** %15
store i64* %258, i64** %17
br label %282
259: ; preds = %244
%260 = load i64*, i64** %16
store i64* %260, i64** %17
br label %282
261: ; preds = %244
%262 = load i8*, i8** %7
%263 = load i32, i32* %10
%264 = sext i32 %263 to i64
%265 = getelementptr inbounds i8, i8* %262, i64 %264
%266 = load i8, i8* %265
%267 = call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8 signext %266)
%268 = load i64*, i64** %12
%269 = call i32 @free(i64* %268)
%270 = load i64*, i64** %13
%271 = call i32 @free(i64* %270)
%272 = load i64*, i64** %14
%273 = call i32 @free(i64* %272)
%274 = load i64*, i64** %15
%275 = call i32 @free(i64* %274)
%276 = load i64*, i64** %16
%277 = call i32 @free(i64* %276)
%278 = load i64*, i64** %20
%279 = call i32 @free(i64* %278)
%280 = load i64*, i64** %21
%281 = call i32 @free(i64* %280)
store i32 -1, i32* %5
br label %500
282: ; preds = %259, %257, %255, %253, %251
store i32 0, i32* %11
br label %283
283: ; preds = %397, %282
%284 = load i32, i32* %11
%285 = load i32, i32* %45
%286 = icmp slt i32 %284, %285
br i1 %286, label %287, label %400
287: ; preds = %283
%288 = load i64, i64* %34
store i64 %288, i64* %36
%289 = load i64, i64* %35
store i64 %289, i64* %37
%290 = load i64*, i64** %17
%291 = load i32, i32* %11
%292 = sext i32 %291 to i64
%293 = getelementptr inbounds i64, i64* %290, i64 %292
%294 = load i64, i64* %293
store i64 %294, i64* %19
%295 = load i64, i64* %19
%296 = load i64*, i64** %20
%297 = load i32, i32* %11
%298 = sext i32 %297 to i64
%299 = getelementptr inbounds i64, i64* %296, i64 %298
%300 = load i64, i64* %299
%301 = or i64 %295, %300
store i64 %301, i64* %22
%302 = load i64, i64* %22
%303 = xor i64 %302, -1
store i64 %303, i64* %23
%304 = load i64, i64* %23
%305 = load i64*, i64** %21
%306 = load i32, i32* %11
%307 = sext i32 %306 to i64
%308 = getelementptr inbounds i64, i64* %305, i64 %307
%309 = load i64, i64* %308
%310 = or i64 %304, %309
store i64 %310, i64* %24
%311 = load i64, i64* %24
%312 = load i64*, i64** %20
%313 = load i32, i32* %11
%314 = sext i32 %313 to i64
%315 = getelementptr inbounds i64, i64* %312, i64 %314
%316 = load i64, i64* %315
%317 = xor i64 %311, %316
store i64 %317, i64* %25
%318 = load i64, i64* %24
%319 = load i64, i64* %33
%320 = add i64 %318, %319
store i64 %320, i64* %30
%321 = load i64, i64* %30
%322 = load i64, i64* %24
%323 = icmp ult i64 %321, %322
%324 = zext i1 %323 to i64
%325 = select i1 %323, i32 1, i32 0
%326 = sext i32 %325 to i64
store i64 %326, i64* %33
%327 = load i64*, i64** %21
%328 = load i32, i32* %11
%329 = sext i32 %328 to i64
%330 = getelementptr inbounds i64, i64* %327, i64 %329
%331 = load i64, i64* %330
%332 = load i64, i64* %30
%333 = add i64 %332, %331
store i64 %333, i64* %30
%334 = load i64, i64* %30
%335 = load i64*, i64** %21
%336 = load i32, i32* %11
%337 = sext i32 %336 to i64
%338 = getelementptr inbounds i64, i64* %335, i64 %337
%339 = load i64, i64* %338
%340 = icmp ult i64 %334, %339
%341 = zext i1 %340 to i64
%342 = select i1 %340, i32 1, i32 0
%343 = sext i32 %342 to i64
%344 = load i64, i64* %33
%345 = or i64 %344, %343
store i64 %345, i64* %33
%346 = load i64, i64* %30
%347 = load i64, i64* %23
%348 = and i64 %346, %347
store i64 %348, i64* %31
%349 = load i64, i64* %31
%350 = load i64, i64* %25
%351 = xor i64 %349, %350
store i64 %351, i64* %26
%352 = load i64*, i64** %20
%353 = load i32, i32* %11
%354 = sext i32 %353 to i64
%355 = getelementptr inbounds i64, i64* %352, i64 %354
%356 = load i64, i64* %355
%357 = load i64, i64* %31
%358 = load i64*, i64** %21
%359 = load i32, i32* %11
%360 = sext i32 %359 to i64
%361 = getelementptr inbounds i64, i64* %358, i64 %360
%362 = load i64, i64* %361
%363 = and i64 %357, %362
%364 = or i64 %356, %363
store i64 %364, i64* %27
%365 = load i64, i64* %26
%366 = load i64, i64* %32
%367 = and i64 %365, %366
%368 = lshr i64 %367, 63
store i64 %368, i64* %35
%369 = load i64, i64* %27
%370 = load i64, i64* %32
%371 = and i64 %369, %370
%372 = lshr i64 %371, 63
store i64 %372, i64* %34
%373 = load i64, i64* %26
%374 = shl i64 %373, 1
%375 = load i64, i64* %37
%376 = add i64 %374, %375
store i64 %376, i64* %28
%377 = load i64, i64* %27
%378 = shl i64 %377, 1
%379 = load i64, i64* %36
%380 = add i64 %378, %379
store i64 %380, i64* %29
%381 = load i64, i64* %22
%382 = load i64, i64* %29
%383 = and i64 %381, %382
%384 = load i64*, i64** %20
%385 = load i32, i32* %11
%386 = sext i32 %385 to i64
%387 = getelementptr inbounds i64, i64* %384, i64 %386
store i64 %383, i64* %387
%388 = load i64, i64* %29
%389 = load i64, i64* %22
%390 = load i64, i64* %28
%391 = and i64 %389, %390
%392 = or i64 %388, %391
%393 = load i64*, i64** %21
%394 = load i32, i32* %11
%395 = sext i32 %394 to i64
%396 = getelementptr inbounds i64, i64* %393, i64 %395
store i64 %392, i64* %396
br label %397
397: ; preds = %287
%398 = load i32, i32* %11
%399 = add nsw i32 %398, 1
store i32 %399, i32* %11
br label %283
400: ; preds = %283
br label %401
401: ; preds = %400
%402 = load i32, i32* %10
%403 = add nsw i32 %402, 1
store i32 %403, i32* %10
br label %240
404: ; preds = %240
store i64 1, i64* %40
%405 = load i32, i32* %9
store i32 %405, i32* %42
store i32 0, i32* %48
%406 = load i32, i32* %9
store i32 %406, i32* %41
store i32 0, i32* %11
br label %407
407: ; preds = %481, %404
%408 = load i32, i32* %11
%409 = load i32, i32* %45
%410 = icmp slt i32 %408, %409
br i1 %410, label %411, label %484
411: ; preds = %407
%412 = load i64*, i64** %20
%413 = load i32, i32* %11
%414 = sext i32 %413 to i64
%415 = getelementptr inbounds i64, i64* %412, i64 %414
%416 = load i64, i64* %415
store i64 %416, i64* %38
%417 = load i64*, i64** %21
%418 = load i32, i32* %11
%419 = sext i32 %418 to i64
%420 = getelementptr inbounds i64, i64* %417, i64 %419
%421 = load i64, i64* %420
%422 = xor i64 %421, -1
store i64 %422, i64* %39
%423 = load i32, i32* %11
%424 = load i32, i32* %45
%425 = sub nsw i32 %424, 1
%426 = icmp eq i32 %423, %425
br i1 %426, label %427, label %434
427: ; preds = %411
%428 = load i64, i64* %47
%429 = load i64, i64* %38
%430 = and i64 %429, %428
store i64 %430, i64* %38
%431 = load i64, i64* %47
%432 = load i64, i64* %39
%433 = and i64 %432, %431
store i64 %433, i64* %39
br label %434
434: ; preds = %427, %411
store i32 0, i32* %10
br label %435
435: ; preds = %477, %434
%436 = load i32, i32* %10
%437 = icmp slt i32 %436, 64
br i1 %437, label %438, label %480
438: ; preds = %435
%439 = load i32, i32* %10
%440 = load i32, i32* %11
%441 = or i32 %439, %440
%442 = icmp ne i32 %441, 0
br i1 %442, label %443, label %472
443: ; preds = %438
%444 = load i64, i64* %38
%445 = trunc i64 %444 to i32
%446 = sext i32 %445 to i64
%447 = load i64, i64* %40
%448 = and i64 %446, %447
%449 = load i32, i32* %41
%450 = sext i32 %449 to i64
%451 = sub i64 %450, %448
%452 = trunc i64 %451 to i32
store i32 %452, i32* %41
%453 = load i64, i64* %39
%454 = trunc i64 %453 to i32
%455 = sext i32 %454 to i64
%456 = load i64, i64* %40
%457 = and i64 %455, %456
%458 = load i32, i32* %41
%459 = sext i32 %458 to i64
%460 = add i64 %459, %457
%461 = trunc i64 %460 to i32
store i32 %461, i32* %41
%462 = load i32, i32* %41
%463 = load i32, i32* %42
%464 = icmp slt i32 %462, %463
br i1 %464, label %465, label %471
465: ; preds = %443
%466 = load i32, i32* %41
store i32 %466, i32* %42
%467 = load i32, i32* %11
%468 = mul nsw i32 %467, 64
%469 = load i32, i32* %10
%470 = add nsw i32 %468, %469
store i32 %470, i32* %48
br label %471
471: ; preds = %465, %443
br label %472
472: ; preds = %471, %438
%473 = load i64, i64* %38
%474 = lshr i64 %473, 1
store i64 %474, i64* %38
%475 = load i64, i64* %39
%476 = lshr i64 %475, 1
store i64 %476, i64* %39
br label %477
477: ; preds = %472
%478 = load i32, i32* %10
%479 = add nsw i32 %478, 1
store i32 %479, i32* %10
br label %435
480: ; preds = %435
br label %481
481: ; preds = %480
%482 = load i32, i32* %11
%483 = add nsw i32 %482, 1
store i32 %483, i32* %11
br label %407
484: ; preds = %407
%485 = load i64*, i64** %12
%486 = call i32 @free(i64* %485)
%487 = load i64*, i64** %13
%488 = call i32 @free(i64* %487)
%489 = load i64*, i64** %14
%490 = call i32 @free(i64* %489)
%491 = load i64*, i64** %15
%492 = call i32 @free(i64* %491)
%493 = load i64*, i64** %16
%494 = call i32 @free(i64* %493)
%495 = load i64*, i64** %20
%496 = call i32 @free(i64* %495)
%497 = load i64*, i64** %21
%498 = call i32 @free(i64* %497)
%499 = load i32, i32* %42
store i32 %499, i32* %5
br label %500
500: ; preds = %484, %261, %199, %51
%501 = load i32, i32* %5
ret i32 %501
}

LLVM IR (-O2):
@.str = [61 x i8] c"\0AError, non-ACGTN character read at position %d in string:%c\00"
@.str.1 = [46 x i8] c"\0AError, non-ACGTN character read in string:%c\00"
define i32 @Edit_Distance_multiple_word_NoEndPenaltySeq1(i8* nocapture %0, i8* nocapture %1, i32 %2, i32 %3) {
%5 = icmp eq i32 %3, 0
br i1 %5, label %221, label %6
6: ; preds = %4
%7 = icmp sgt i32 %2, 63
br i1 %7, label %8, label %16
8: ; preds = %6
%9 = add nsw i32 %2, -63
%10 = lshr i32 %9, 6
%11 = mul nsw i32 %10, -64
%12 = add nsw i32 %11, %9
%13 = icmp slt i32 %12, 1
%14 = select i1 %13, i32 1, i32 2
%15 = add nuw nsw i32 %14, %10
br label %16
16: ; preds = %6, %8
%17 = phi i32 [ %15, %8 ], [ 1, %6 ]
%18 = add nsw i32 %17, -1
%19 = shl nuw nsw i32 %18, 6
%20 = sub i32 63, %2
%21 = add i32 %20, %19
%22 = zext i32 %21 to i64
%23 = lshr i64 -1, %22
%24 = tail call i64 @calloc(i32 %17, i32 8)
%25 = inttoptr i64 %24 to i64*
%26 = tail call i64 @calloc(i32 %17, i32 8)
%27 = inttoptr i64 %26 to i64*
%28 = tail call i64 @calloc(i32 %17, i32 8)
%29 = inttoptr i64 %28 to i64*
%30 = tail call i64 @calloc(i32 %17, i32 8)
%31 = inttoptr i64 %30 to i64*
%32 = tail call i64 @calloc(i32 %17, i32 8)
%33 = inttoptr i64 %32 to i64*
%34 = tail call i64 @calloc(i32 %17, i32 8)
%35 = inttoptr i64 %34 to i64*
%36 = tail call i64 @calloc(i32 %17, i32 8)
%37 = inttoptr i64 %36 to i64*
%38 = sext i32 %2 to i64
%39 = zext i32 %17 to i64
br label %43
40: ; preds = %92
%41 = add i32 %45, 64
%42 = icmp eq i64 %52, %39
br i1 %42, label %97, label %43
43: ; preds = %16, %40
%44 = phi i64 [ 0, %16 ], [ %52, %40 ]
%45 = phi i32 [ 0, %16 ], [ %41, %40 ]
%46 = sext i32 %45 to i64
%47 = getelementptr inbounds i64, i64* %25, i64 %44
store i64 0, i64* %47
%48 = getelementptr inbounds i64, i64* %27, i64 %44
store i64 0, i64* %48
%49 = getelementptr inbounds i64, i64* %29, i64 %44
store i64 0, i64* %49
%50 = getelementptr inbounds i64, i64* %31, i64 %44
store i64 0, i64* %50
%51 = getelementptr inbounds i64, i64* %33, i64 %44
store i64 0, i64* %51
%52 = add nuw nsw i64 %44, 1
%53 = trunc i64 %52 to i32
%54 = shl nsw i32 %53, 6
%55 = icmp ne i64 %44, 0
br label %56
56: ; preds = %43, %92
%57 = phi i64 [ %46, %43 ], [ %94, %92 ]
%58 = phi i64 [ 1, %43 ], [ %93, %92 ]
%59 = icmp sgt i64 %57, %38
br i1 %59, label %92, label %60
60: ; preds = %56
%61 = icmp ne i64 %57, 0
%62 = select i1 %61, i1 true, i1 %55
br i1 %62, label %63, label %90
63: ; preds = %60
%64 = add nsw i64 %57, -1
%65 = getelementptr inbounds i8, i8* %0, i64 %64
%66 = load i8, i8* %65
%67 = sext i8 %66 to i32
switch i32 %67, label %72 [
i32 65, label %86
i32 67, label %68
i32 71, label %69
i32 84, label %70
i32 78, label %71
]
68: ; preds = %63
br label %86
69: ; preds = %63
br label %86
70: ; preds = %63
br label %86
71: ; preds = %63
br label %86
72: ; preds = %63
%73 = trunc i64 %57 to i8
%74 = and i64 %57, 4294967295
%75 = getelementptr inbounds i8, i8* %0, i64 %74
%76 = load i8, i8* %75
%77 = sext i8 %76 to i32
%78 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([61 x i8], [61 x i8]* @.str, i64 0, i64 0), i8 signext %73, i32 %77)
%79 = tail call i32 @free(i64* %25)
%80 = tail call i32 @free(i64* %27)
%81 = tail call i32 @free(i64* %29)
%82 = tail call i32 @free(i64* %31)
%83 = tail call i32 @free(i64* %33)
%84 = tail call i32 @free(i64* %35)
%85 = tail call i32 @free(i64* %37)
br label %221
86: ; preds = %63, %71, %70, %69, %68
%87 = phi i64* [ %48, %68 ], [ %49, %69 ], [ %50, %70 ], [ %51, %71 ], [ %47, %63 ]
%88 = load i64, i64* %87
%89 = or i64 %88, %58
store i64 %89, i64* %87
br label %90
90: ; preds = %86, %60
%91 = shl i64 %58, 1
br label %92
92: ; preds = %56, %90
%93 = phi i64 [ %91, %90 ], [ %58, %56 ]
%94 = add nsw i64 %57, 1
%95 = trunc i64 %94 to i32
%96 = icmp ugt i32 %54, %95
br i1 %96, label %56, label %40
97: ; preds = %40
store i64 1, i64* %35
store i64 1, i64* %37
%98 = icmp sgt i32 %3, 0
br i1 %98, label %99, label %101
99: ; preds = %97
%100 = zext i32 %3 to i64
br label %103
101: ; preds = %159, %97
%102 = zext i32 %18 to i64
br label %162
103: ; preds = %99, %159
%104 = phi i64 [ 0, %99 ], [ %160, %159 ]
%105 = getelementptr inbounds i8, i8* %1, i64 %104
%106 = load i8, i8* %105
%107 = sext i8 %106 to i32
switch i32 %107, label %112 [
i32 65, label %121
i32 67, label %108
i32 71, label %109
i32 84, label %110
i32 78, label %111
]
108: ; preds = %103
br label %121
109: ; preds = %103
br label %121
110: ; preds = %103
br label %121
111: ; preds = %103
br label %121
112: ; preds = %103
%113 = tail call i32 (i8*, i8, ...) @printf(i8* getelementptr inbounds ([46 x i8], [46 x i8]* @.str.1, i64 0, i64 0), i8 signext %106)
%114 = tail call i32 @free(i64* %25)
%115 = tail call i32 @free(i64* %27)
%116 = tail call i32 @free(i64* %29)
%117 = tail call i32 @free(i64* %31)
%118 = tail call i32 @free(i64* %33)
%119 = tail call i32 @free(i64* %35)
%120 = tail call i32 @free(i64* %37)
br label %221
121: ; preds = %103, %111, %110, %109, %108
%122 = phi i64* [ %33, %111 ], [ %31, %110 ], [ %29, %109 ], [ %27, %108 ], [ %25, %103 ]
br label %123
123: ; preds = %121, %123
%124 = phi i64 [ 0, %121 ], [ %157, %123 ]
%125 = phi i64 [ 0, %121 ], [ %143, %123 ]
%126 = phi i64 [ 1, %121 ], [ %149, %123 ]
%127 = phi i64 [ 0, %121 ], [ %148, %123 ]
%128 = getelementptr inbounds i64, i64* %122, i64 %124
%129 = load i64, i64* %128
%130 = getelementptr inbounds i64, i64* %35, i64 %124
%131 = load i64, i64* %130
%132 = or i64 %131, %129
%133 = xor i64 %132, -1
%134 = getelementptr inbounds i64, i64* %37, i64 %124
%135 = load i64, i64* %134
%136 = or i64 %135, %133
%137 = xor i64 %136, %131
%138 = add i64 %136, %125
%139 = icmp ult i64 %138, %136
%140 = add i64 %138, %135
%141 = icmp ult i64 %140, %135
%142 = or i1 %139, %141
%143 = zext i1 %142 to i64
%144 = and i64 %140, %133
%145 = xor i64 %137, %144
%146 = and i64 %144, %135
%147 = or i64 %146, %131
%148 = lshr i64 %145, 63
%149 = lshr i64 %147, 63
%150 = shl i64 %145, 1
%151 = or i64 %150, %127
%152 = shl i64 %147, 1
%153 = or i64 %152, %126
%154 = and i64 %153, %132
store i64 %154, i64* %130
%155 = and i64 %151, %132
%156 = or i64 %153, %155
store i64 %156, i64* %134
%157 = add nuw nsw i64 %124, 1
%158 = icmp eq i64 %157, %39
br i1 %158, label %159, label %123
159: ; preds = %123
%160 = add nuw nsw i64 %104, 1
%161 = icmp eq i64 %160, %100
br i1 %161, label %101, label %103
162: ; preds = %101, %210
%163 = phi i64 [ 0, %101 ], [ %211, %210 ]
%164 = phi i32 [ %3, %101 ], [ %205, %210 ]
%165 = phi i32 [ %3, %101 ], [ %203, %210 ]
%166 = getelementptr inbounds i64, i64* %35, i64 %163
%167 = load i64, i64* %166
%168 = getelementptr inbounds i64, i64* %37, i64 %163
%169 = load i64, i64* %168
%170 = xor i64 %169, -1
%171 = icmp eq i64 %163, %102
%172 = select i1 %171, i64 %23, i64 -1
%173 = and i64 %167, %172
%174 = and i64 %172, %170
%175 = trunc i64 %163 to i32
br label %176
176: ; preds = %193, %162
%177 = phi i32 [ 0, %162 ], [ %208, %193 ]
%178 = phi i32 [ %164, %162 ], [ %205, %193 ]
%179 = phi i32 [ %165, %162 ], [ %203, %193 ]
%180 = phi i64 [ %174, %162 ], [ %207, %193 ]
%181 = phi i64 [ %173, %162 ], [ %206, %193 ]
%182 = or i32 %177, %175
%183 = icmp eq i32 %182, 0
br i1 %183, label %193, label %184
184: ; preds = %176
%185 = trunc i64 %181 to i32
%186 = and i32 %185, 1
%187 = sub i32 %179, %186
%188 = trunc i64 %180 to i32
%189 = and i32 %188, 1
%190 = add i32 %189, %187
%191 = icmp slt i32 %190, %178
%192 = select i1 %191, i32 %190, i32 %178
br label %193
193: ; preds = %176, %184
%194 = phi i32 [ %179, %176 ], [ %190, %184 ]
%195 = phi i32 [ %178, %176 ], [ %192, %184 ]
%196 = trunc i64 %181 to i32
%197 = lshr i32 %196, 1
%198 = and i32 %197, 1
%199 = sub i32 %194, %198
%200 = trunc i64 %180 to i32
%201 = lshr i32 %200, 1
%202 = and i32 %201, 1
%203 = add i32 %202, %199
%204 = icmp slt i32 %203, %195
%205 = select i1 %204, i32 %203, i32 %195
%206 = lshr i64 %181, 2
%207 = lshr i64 %180, 2
%208 = add nuw nsw i32 %177, 2
%209 = icmp eq i32 %208, 64
br i1 %209, label %210, label %176
210: ; preds = %193
%211 = add nuw nsw i64 %163, 1
%212 = icmp eq i64 %211, %39
br i1 %212, label %213, label %162
213: ; preds = %210
%214 = tail call i32 @free(i64* %25)
%215 = tail call i32 @free(i64* %27)
%216 = tail call i32 @free(i64* %29)
%217 = tail call i32 @free(i64* %31)
%218 = tail call i32 @free(i64* %33)
%219 = tail call i32 @free(i64* %35)
%220 = tail call i32 @free(i64* %37)
br label %221
221: ; preds = %4, %213, %112, %72
%222 = phi i32 [ -1, %72 ], [ -1, %112 ], [ %205, %213 ], [ 0, %4 ]
ret i32 %222
}