int hmm(char **seqs, int S, double *est_ini, double **est_emi,
        double *est_trans, double **f, int *Dmin, int *Dmax, int *T, int nseq,
        char **headers, int prevRead, int *prevHits, int *prevHitsRev,
        int reverse, char output[]) {
  int **resPaths, status, i;
  double **resLogV;
  char **revSeqs;
  int minLength = 0;
  for (int s = 0; s < S; s++) {
    minLength += Dmin[s];
  }
  if (reverse == 0) {
    resPaths = malloc(nseq * sizeof(int *));
    resLogV = malloc(nseq * sizeof(double *));
#pragma omp parallel for private(i)                                            \
    shared(nseq, T, seqs, resPaths, resLogV, S, est_ini, est_emi, est_trans,   \
           f, Dmin, Dmax)
    for (i = 0; i < nseq; i++) {
      resPaths[i] = malloc((T[i] + 1) * sizeof(int));
      resLogV[i] = malloc((T[i] + 1) * S * sizeof(double));
      if (T[i] >= minLength - 1) {
        viterbi(resPaths[i], resLogV[i], seqs[i], S, est_ini, est_emi,
                est_trans, f, Dmin, Dmax, T[i]);
      } else {
        for (int t = 0; t < T[i]; t++) {
          resPaths[i][t] = 7;
        }
      }
    }
  } else {
    revSeqs = malloc(nseq * sizeof(char *));
    resPaths = malloc(2 * nseq * sizeof(int *));
    resLogV = malloc(2 * nseq * sizeof(double *));
#pragma omp parallel for private(i)                                            \
    shared(nseq, T, seqs, resPaths, resLogV, S, est_ini, est_emi, est_trans,   \
           f, Dmin, Dmax)
    for (i = 0; i < nseq; i++) {
      resPaths[2 * i] = malloc((T[i] + 1) * sizeof(int));
      resLogV[2 * i] = malloc((T[i] + 1) * S * sizeof(double));
      resPaths[2 * i + 1] = malloc((T[i] + 1) * sizeof(int));
      resLogV[2 * i + 1] = malloc((T[i] + 1) * S * sizeof(double));
      revSeqs[i] = malloc(T[i] * sizeof(char));
      if (T[i] >= minLength - 1) {
        viterbi(resPaths[2 * i], resLogV[2 * i], seqs[i], S, est_ini, est_emi,
                est_trans, f, Dmin, Dmax, T[i]);
        for (int t = 0; t < T[i]; t++) {
          if (seqs[i][T[i] - t - 1] == 'A' || seqs[i][T[i] - t - 1] == 'a') {
            revSeqs[i][t] = 'T';
          } else if (seqs[i][T[i] - t - 1] == 'C' ||
                     seqs[i][T[i] - t - 1] == 'c') {
            revSeqs[i][t] = 'G';
          } else if (seqs[i][T[i] - t - 1] == 'G' ||
                     seqs[i][T[i] - t - 1] == 'g') {
            revSeqs[i][t] = 'C';
          } else {
            revSeqs[i][t] = 'A';
          }
        }
        viterbi(resPaths[2 * i + 1], resLogV[2 * i + 1], revSeqs[i], S, est_ini,
                est_emi, est_trans, f, Dmin, Dmax, T[i]);
      } else {
        for (int t = 0; t < T[i]; t++) {
          resPaths[2 * i][t] = 7;
          resPaths[2 * i + 1][t] = 7;
        }
      }
    }
  }
  if ((status = calcResults(resPaths, resLogV, seqs, revSeqs, nseq, T, S,
                            headers, prevRead, prevHits, prevHitsRev, reverse,
                            output, est_emi, est_trans, est_ini)) != 0) {
    printf("Error in calcResults!\n");
    return -1;
  }
  if (reverse == 1) {
    for (i = 0; i < nseq; i++) {
      free(revSeqs[i]);
    }
    free(revSeqs);
  }
  for (i = 0; i < (1 + reverse) * nseq; i++) {
    free(resPaths[i]);
    free(resLogV[i]);
  }
  free(resPaths);
  free(resLogV);
  return 0;
}


x86 assembly (clang, -O0):
<hmm>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0xd8,%rsp
mov    0x58(%rbp),%rax
mov    0x50(%rbp),%eax
mov    0x48(%rbp),%rax
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%eax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%eax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x38(%rbp)
mov    %esi,-0x3c(%rbp)
mov    %rdx,-0x48(%rbp)
mov    %rcx,-0x50(%rbp)
mov    %r8,-0x58(%rbp)
mov    %r9,-0x60(%rbp)
movl   $0x0,-0x84(%rbp)
movl   $0x0,-0x88(%rbp)
mov    -0x88(%rbp),%eax
cmp    -0x3c(%rbp),%eax
jge    11f1 <hmm+0xa1>
mov    0x10(%rbp),%rax
movslq -0x88(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x84(%rbp),%eax
mov    %eax,-0x84(%rbp)
mov    -0x88(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x88(%rbp)
jmp    11b4 <hmm+0x64>
cmpl   $0x0,0x50(%rbp)
jne    137c <hmm+0x22c>
movslq 0x28(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
movslq 0x28(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1377 <hmm+0x227>
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
imul   -0x3c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     1310 <hmm+0x1c0>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x78(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x3c(%rbp),%ecx
mov    -0x48(%rbp),%r8
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%rbx
mov    0x10(%rbp),%r11
mov    0x18(%rbp),%r10
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%r15
mov    (%rax,%r15,4),%eax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %eax,0x20(%rsp)
mov    $0x0,%al
call   1060 <viterbi@plt>
jmp    1364 <hmm+0x214>
movl   $0x0,-0x8c(%rbp)
mov    -0x8c(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    135f <hmm+0x20f>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x8c(%rbp),%rcx
movl   $0x7,(%rax,%rcx,4)
mov    -0x8c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x8c(%rbp)
jmp    131a <hmm+0x1ca>
jmp    1364 <hmm+0x214>
jmp    1369 <hmm+0x219>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1224 <hmm+0xd4>
jmp    1825 <hmm+0x6d5>
movslq 0x28(%rbp),%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x80(%rbp)
mov    0x28(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x68(%rbp)
mov    0x28(%rbp),%eax
shl    $0x1,%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,-0x78(%rbp)
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1820 <hmm+0x6d0>
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
imul   -0x3c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
movslq %eax,%rdi
shl    $0x2,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    $0x1,%eax
imul   -0x3c(%rbp),%eax
movslq %eax,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
movslq (%rax,%rcx,4),%rdi
shl    $0x0,%rdi
call   1050 <malloc@plt>
mov    %rax,%rdx
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    %rdx,(%rax,%rcx,8)
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    -0x84(%rbp),%ecx
sub    $0x1,%ecx
cmp    %ecx,%eax
jl     1792 <hmm+0x642>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x3c(%rbp),%ecx
mov    -0x48(%rbp),%r8
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%rbx
mov    0x10(%rbp),%r11
mov    0x18(%rbp),%r10
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%r15
mov    (%rax,%r15,4),%eax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %eax,0x20(%rsp)
mov    $0x0,%al
call   1060 <viterbi@plt>
movl   $0x0,-0x90(%rbp)
mov    -0x90(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1714 <hmm+0x5c4>
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x41,%eax
je     15c6 <hmm+0x476>
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x61,%eax
jne    15e2 <hmm+0x492>
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movb   $0x54,(%rax,%rcx,1)
jmp    16fb <hmm+0x5ab>
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x43,%eax
je     1642 <hmm+0x4f2>
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x63,%eax
jne    165e <hmm+0x50e>
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movb   $0x47,(%rax,%rcx,1)
jmp    16f6 <hmm+0x5a6>
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x47,%eax
je     16be <hmm+0x56e>
mov    -0x38(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
sub    -0x90(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
movsbl (%rax,%rcx,1),%eax
cmp    $0x67,%eax
jne    16da <hmm+0x58a>
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movb   $0x43,(%rax,%rcx,1)
jmp    16f1 <hmm+0x5a1>
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x90(%rbp),%rcx
movb   $0x41,(%rax,%rcx,1)
jmp    16f6 <hmm+0x5a6>
jmp    16fb <hmm+0x5ab>
jmp    1700 <hmm+0x5b0>
mov    -0x90(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x90(%rbp)
jmp    154f <hmm+0x3ff>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rdi
mov    -0x78(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rsi
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdx
mov    -0x3c(%rbp),%ecx
mov    -0x48(%rbp),%r8
mov    -0x50(%rbp),%r9
mov    -0x58(%rbp),%r14
mov    -0x60(%rbp),%rbx
mov    0x10(%rbp),%r11
mov    0x18(%rbp),%r10
mov    0x20(%rbp),%rax
movslq -0x70(%rbp),%r15
mov    (%rax,%r15,4),%eax
mov    %r14,(%rsp)
mov    %rbx,0x8(%rsp)
mov    %r11,0x10(%rsp)
mov    %r10,0x18(%rsp)
mov    %eax,0x20(%rsp)
mov    $0x0,%al
call   1060 <viterbi@plt>
jmp    180d <hmm+0x6bd>
movl   $0x0,-0x94(%rbp)
mov    -0x94(%rbp),%eax
mov    0x20(%rbp),%rcx
movslq -0x70(%rbp),%rdx
cmp    (%rcx,%rdx,4),%eax
jge    1808 <hmm+0x6b8>
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movl   $0x7,(%rax,%rcx,4)
mov    -0x68(%rbp),%rax
mov    -0x70(%rbp),%ecx
shl    $0x1,%ecx
add    $0x1,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,8),%rax
movslq -0x94(%rbp),%rcx
movl   $0x7,(%rax,%rcx,4)
mov    -0x94(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x94(%rbp)
jmp    179c <hmm+0x64c>
jmp    180d <hmm+0x6bd>
jmp    1812 <hmm+0x6c2>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    13c0 <hmm+0x270>
jmp    1825 <hmm+0x6d5>
mov    -0x68(%rbp),%rdi
mov    -0x78(%rbp),%rsi
mov    -0x38(%rbp),%rdx
mov    -0x80(%rbp),%rcx
mov    0x28(%rbp),%r8d
mov    0x20(%rbp),%r9
mov    -0x3c(%rbp),%eax
mov    %eax,-0xac(%rbp)
mov    0x30(%rbp),%rax
mov    %rax,-0xa8(%rbp)
mov    0x38(%rbp),%r13d
mov    0x40(%rbp),%r12
mov    0x48(%rbp),%r15
mov    0x50(%rbp),%r14d
mov    0x58(%rbp),%rbx
mov    -0x50(%rbp),%r11
mov    -0x58(%rbp),%r10
mov    -0x48(%rbp),%rax
mov    %rax,-0xa0(%rbp)
mov    -0xac(%rbp),%eax
mov    %eax,(%rsp)
mov    -0xa8(%rbp),%rax
mov    %rax,0x8(%rsp)
mov    -0xa0(%rbp),%rax
mov    %r13d,0x10(%rsp)
mov    %r12,0x18(%rsp)
mov    %r15,0x20(%rsp)
mov    %r14d,0x28(%rsp)
mov    %rbx,0x30(%rsp)
mov    %r11,0x38(%rsp)
mov    %r10,0x40(%rsp)
mov    %rax,0x48(%rsp)
mov    $0x0,%al
call   1070 <calcResults@plt>
mov    %eax,-0x6c(%rbp)
cmp    $0x0,%eax
je     18e9 <hmm+0x799>
lea    0x72a(%rip),%rdi
mov    $0x0,%al
call   1040 <printf@plt>
movl   $0xffffffff,-0x2c(%rbp)
jmp    1993 <hmm+0x843>
cmpl   $0x1,0x50(%rbp)
jne    192e <hmm+0x7de>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
cmp    0x28(%rbp),%eax
jge    1925 <hmm+0x7d5>
mov    -0x80(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    18fa <hmm+0x7aa>
mov    -0x80(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x70(%rbp)
mov    -0x70(%rbp),%eax
mov    0x50(%rbp),%ecx
add    $0x1,%ecx
imul   0x28(%rbp),%ecx
cmp    %ecx,%eax
jge    197a <hmm+0x82a>
mov    -0x68(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rax
movslq -0x70(%rbp),%rcx
mov    (%rax,%rcx,8),%rdi
call   1030 <free@plt>
mov    -0x70(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x70(%rbp)
jmp    1935 <hmm+0x7e5>
mov    -0x68(%rbp),%rdi
call   1030 <free@plt>
mov    -0x78(%rbp),%rdi
call   1030 <free@plt>
movl   $0x0,-0x2c(%rbp)
mov    -0x2c(%rbp),%eax
add    $0xd8,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

x86 assembly (clang, -O2):
<hmm>:
push   %rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x78,%rsp
mov    %r9,0x48(%rsp)
mov    %r8,0x28(%rsp)
mov    %rcx,0x30(%rsp)
mov    %rdx,0x20(%rsp)
mov    %esi,%r13d
mov    %rdi,%r14
mov    0xf0(%rsp),%r15d
mov    0xc8(%rsp),%r12d
mov    0xb0(%rsp),%rbp
test   %esi,%esi
jle    11a6 <hmm+0x56>
mov    %r13d,%eax
cmp    $0x8,%r13d
jae    11b3 <hmm+0x63>
xor    %ecx,%ecx
xor    %edx,%edx
jmp    12a0 <hmm+0x150>
movl   $0xffffffff,0x14(%rsp)
ff
jmp    12b4 <hmm+0x164>
mov    %eax,%ecx
and    $0xfffffff8,%ecx
lea    -0x8(%rcx),%rsi
mov    %rsi,%rdi
shr    $0x3,%rdi
add    $0x1,%rdi
mov    %edi,%edx
and    $0x3,%edx
cmp    $0x18,%rsi
jae    11de <hmm+0x8e>
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
jmp    124a <hmm+0xfa>
and    $0xfffffffffffffffc,%rdi
pxor   %xmm0,%xmm0
xor    %esi,%esi
pxor   %xmm1,%xmm1
nopl   0x0(%rax)
movdqu 0x0(%rbp,%rsi,4),%xmm2
paddd  %xmm0,%xmm2
movdqu 0x10(%rbp,%rsi,4),%xmm0
paddd  %xmm1,%xmm0
movdqu 0x20(%rbp,%rsi,4),%xmm1
movdqu 0x30(%rbp,%rsi,4),%xmm3
movdqu 0x40(%rbp,%rsi,4),%xmm4
paddd  %xmm1,%xmm4
paddd  %xmm2,%xmm4
movdqu 0x50(%rbp,%rsi,4),%xmm2
paddd  %xmm3,%xmm2
paddd  %xmm0,%xmm2
movdqu 0x60(%rbp,%rsi,4),%xmm0
paddd  %xmm4,%xmm0
movdqu 0x70(%rbp,%rsi,4),%xmm1
paddd  %xmm2,%xmm1
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdi
jne    11f0 <hmm+0xa0>
test   %rdx,%rdx
je     127c <hmm+0x12c>
lea    0x10(,%rsi,4),%rsi
add    %rbp,%rsi
shl    $0x5,%rdx
xor    %edi,%edi
movdqu -0x10(%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm0
movdqu (%rsi,%rdi,1),%xmm2
paddd  %xmm2,%xmm1
add    $0x20,%rdi
cmp    %rdi,%rdx
jne    1260 <hmm+0x110>
paddd  %xmm1,%xmm0
pshufd $0xee,%xmm0,%xmm1
paddd  %xmm0,%xmm1
pshufd $0x55,%xmm1,%xmm0
paddd  %xmm1,%xmm0
movd   %xmm0,%edx
cmp    %rax,%rcx
je     12ad <hmm+0x15d>
nopl   0x0(%rax,%rax,1)
add    0x0(%rbp,%rcx,4),%edx
add    $0x1,%rcx
cmp    %rcx,%rax
jne    12a0 <hmm+0x150>
add    $0xffffffff,%edx
mov    %edx,0x14(%rsp)
movslq %r12d,%rbx
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,(%rsp)
test   %r15d,%r15d
mov    %r13,0x38(%rsp)
mov    %r14,0x40(%rsp)
je     16a1 <hmm+0x551>
lea    (%r12,%r12,1),%eax
movslq %eax,%rbx
shl    $0x3,%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbp
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,0x8(%rsp)
test   %r12d,%r12d
jle    18b5 <hmm+0x765>
mov    %rbp,0x18(%rsp)
mov    %r12d,%eax
mov    %rax,0x60(%rsp)
xor    %r15d,%r15d
mov    0xc0(%rsp),%r9
jmp    137b <hmm+0x22b>
mov    0x18(%rsp),%rax
mov    (%rax,%r8,8),%rbx
mov    0x8(%rsp),%rax
mov    (%rax,%r8,8),%rsi
mov    (%r9,%r15,8),%rdx
sub    $0x8,%rsp
mov    %rbx,%rdi
mov    0x28(%rsp),%r8
mov    0x38(%rsp),%r9
xor    %eax,%eax
push   %rbp
push   0xc8(%rsp)
push   %r12
push   0x68(%rsp)
push   0x50(%rsp)
call   1060 <viterbi@plt>
add    $0x30,%rsp
mov    0xc0(%rsp),%r9
add    $0x1,%r15
cmp    0x60(%rsp),%r15
je     167e <hmm+0x52e>
movslq (%r9,%r15,4),%rax
mov    %rax,0x70(%rsp)
lea    0x1(%rax),%rbp
lea    0x4(,%rax,4),%rbx
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%r13
lea    (%r15,%r15,1),%rax
mov    %rax,0x50(%rsp)
mov    %r15,%r14
shl    $0x4,%r14
mov    0x18(%rsp),%rax
mov    %r13,(%rax,%r14,1)
imul   0x38(%rsp),%ebp
movslq %ebp,%rbp
shl    $0x3,%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    0x8(%rsp),%r12
mov    %rax,0x68(%rsp)
mov    %rax,(%r12,%r14,1)
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    0x50(%rsp),%r14
mov    0x18(%rsp),%rax
mov    %rbx,0x8(%rax,%r14,8)
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,0x8(%r12,%r14,8)
mov    %rax,%r14
mov    0x70(%rsp),%rbp
mov    %rbp,%rdi
call   1050 <malloc@plt>
mov    %rax,%rcx
mov    (%rsp),%rax
mov    %rcx,(%rax,%r15,8)
cmp    0x14(%rsp),%ebp
jge    1450 <hmm+0x300>
test   %ebp,%ebp
mov    0xc0(%rsp),%r9
movdqa 0xbd0(%rip),%xmm0
jle    136c <hmm+0x21c>
cmp    $0x8,%ebp
jae    1567 <hmm+0x417>
xor    %eax,%eax
jmp    1660 <hmm+0x510>
cs nopw 0x0(%rax,%rax,1)
mov    %rcx,0x58(%rsp)
mov    %r14,0x50(%rsp)
mov    0x40(%rsp),%r14
mov    (%r14,%r15,8),%rdx
sub    $0x8,%rsp
mov    %r13,%rdi
mov    0x70(%rsp),%rsi
mov    0x40(%rsp),%r13
mov    %r13d,%ecx
mov    0x28(%rsp),%r8
mov    0x38(%rsp),%r9
xor    %eax,%eax
push   %rbp
push   0xc8(%rsp)
mov    0xc8(%rsp),%r12
push   %r12
push   0x68(%rsp)
push   0x50(%rsp)
call   1060 <viterbi@plt>
add    $0x30,%rsp
mov    0xc0(%rsp),%r10
mov    (%r10,%r15,4),%ebp
test   %ebp,%ebp
mov    %r13,%rcx
jle    1558 <hmm+0x408>
lea    (%r15,%r15,1),%r8
add    $0x1,%r8
mov    $0xffffffff,%eax
xor    %edx,%edx
mov    (%rsp),%r9
movabs $0x100000001,%r11
movabs $0x400000004,%r13
jmp    150d <hmm+0x3bd>
cs nopw 0x0(%rax,%rax,1)
mov    $0x47,%bl
mov    (%r9,%r15,8),%rsi
mov    %bl,(%rsi,%rdx,1)
add    $0x1,%rdx
movslq (%r10,%r15,4),%rbp
add    $0xffffffff,%eax
cmp    %rbp,%rdx
jge    1320 <hmm+0x1d0>
mov    (%r14,%r15,8),%rsi
add    %eax,%ebp
movslq %ebp,%rdi
movzbl (%rsi,%rdi,1),%ebx
add    $0xbf,%bl
cmp    $0x26,%bl
ja     1554 <hmm+0x404>
movzbl %bl,%esi
bt     %rsi,%r11
jb     1550 <hmm+0x400>
bt     %rsi,%r13
jb     14f0 <hmm+0x3a0>
movabs $0x4000000040,%rdi
bt     %rsi,%rdi
jae    1554 <hmm+0x404>
mov    $0x43,%bl
jmp    14f2 <hmm+0x3a2>
cs nopw 0x0(%rax,%rax,1)
nop
mov    $0x54,%bl
jmp    14f2 <hmm+0x3a2>
mov    $0x41,%bl
jmp    14f2 <hmm+0x3a2>
mov    0x50(%rsp),%rsi
mov    0x58(%rsp),%rdx
jmp    1336 <hmm+0x1e6>
mov    %rbp,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x3,%ecx
cmp    $0x18,%rsi
jae    158f <hmm+0x43f>
xor    %esi,%esi
jmp    1611 <hmm+0x4c1>
movabs $0x3ffffffffffffffc,%rsi
ff ff 3f
and    %rsi,%rdx
xor    %esi,%esi
xchg   %ax,%ax
movdqu %xmm0,0x0(%r13,%rsi,4)
movdqu %xmm0,0x10(%r13,%rsi,4)
movdqu %xmm0,(%rbx,%rsi,4)
movdqu %xmm0,0x10(%rbx,%rsi,4)
movdqu %xmm0,0x20(%r13,%rsi,4)
movdqu %xmm0,0x30(%r13,%rsi,4)
movdqu %xmm0,0x20(%rbx,%rsi,4)
movdqu %xmm0,0x30(%rbx,%rsi,4)
movdqu %xmm0,0x40(%r13,%rsi,4)
movdqu %xmm0,0x50(%r13,%rsi,4)
movdqu %xmm0,0x40(%rbx,%rsi,4)
movdqu %xmm0,0x50(%rbx,%rsi,4)
movdqu %xmm0,0x60(%r13,%rsi,4)
movdqu %xmm0,0x70(%r13,%rsi,4)
movdqu %xmm0,0x60(%rbx,%rsi,4)
movdqu %xmm0,0x70(%rbx,%rsi,4)
add    $0x20,%rsi
add    $0xfffffffffffffffc,%rdx
jne    15a0 <hmm+0x450>
test   %rcx,%rcx
je     164f <hmm+0x4ff>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
lea    0x10(,%rsi,4),%rsi
add    %r13,%rsi
shl    $0x5,%rcx
xor    %edi,%edi
nop
movdqu %xmm0,-0x10(%rsi,%rdi,1)
movdqu %xmm0,(%rsi,%rdi,1)
movdqu %xmm0,-0x10(%rdx,%rdi,1)
movdqu %xmm0,(%rdx,%rdi,1)
add    $0x20,%rdi
cmp    %rdi,%rcx
jne    1630 <hmm+0x4e0>
cmp    %rbp,%rax
je     136c <hmm+0x21c>
nopl   0x0(%rax,%rax,1)
movl   $0x7,0x0(%r13,%rax,4)
movl   $0x7,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %rbp,%rax
jl     1660 <hmm+0x510>
jmp    136c <hmm+0x21c>
mov    (%rsp),%r14
mov    0x18(%rsp),%rbx
mov    0xf0(%rsp),%r15d
mov    0xc8(%rsp),%r12d
mov    0x38(%rsp),%r13
jmp    18df <hmm+0x78f>
mov    %rbx,%rdi
call   1050 <malloc@plt>
mov    %rax,%rbp
test   %r12d,%r12d
jle    198c <hmm+0x83c>
mov    %rbp,0x8(%rsp)
movabs $0x3ffffffffffffffc,%rax
ff ff 3f
mov    %r12d,%r15d
add    $0xfffffffffffffffc,%rax
mov    %rax,0x18(%rsp)
xor    %r12d,%r12d
mov    0xc0(%rsp),%r9
mov    0x38(%rsp),%r14
jmp    1748 <hmm+0x5f8>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    0x40(%rsp),%rcx
mov    (%rcx,%r12,8),%rdx
sub    $0x8,%rsp
mov    %rbx,%rdi
mov    %rax,%rsi
mov    %r14d,%ecx
mov    0x28(%rsp),%r8
mov    0x38(%rsp),%r9
xor    %eax,%eax
push   %r13
push   0xc8(%rsp)
push   0xc8(%rsp)
push   0x68(%rsp)
push   0x50(%rsp)
call   1060 <viterbi@plt>
add    $0x30,%rsp
mov    0xc0(%rsp),%r9
add    $0x1,%r12
cmp    %r15,%r12
je     18c6 <hmm+0x776>
movslq (%r9,%r12,4),%r13
lea    0x1(%r13),%rbp
lea    0x4(,%r13,4),%rdi
call   1050 <malloc@plt>
mov    %rax,%rbx
mov    (%rsp),%rax
mov    %rbx,(%rax,%r12,8)
imul   %r14d,%ebp
movslq %ebp,%rdi
shl    $0x3,%rdi
call   1050 <malloc@plt>
mov    0x8(%rsp),%rcx
mov    %rax,(%rcx,%r12,8)
cmp    0x14(%rsp),%r13d
jge    16f0 <hmm+0x5a0>
test   %r13d,%r13d
mov    0xc0(%rsp),%r9
movdqa 0x861(%rip),%xmm0
jle    173b <hmm+0x5eb>
cmp    $0x8,%r13d
jae    17ae <hmm+0x65e>
xor    %eax,%eax
jmp    18a0 <hmm+0x750>
mov    %r13,%rax
and    $0xfffffffffffffff8,%rax
lea    -0x8(%rax),%rsi
mov    %rsi,%rdx
shr    $0x3,%rdx
add    $0x1,%rdx
mov    %edx,%ecx
and    $0x7,%ecx
cmp    $0x38,%rsi
jae    17d6 <hmm+0x686>
xor    %esi,%esi
jmp    1865 <hmm+0x715>
and    0x18(%rsp),%rdx
xor    %esi,%esi
nopl   (%rax)
movdqu %xmm0,(%rbx,%rsi,4)
movdqu %xmm0,0x10(%rbx,%rsi,4)
movdqu %xmm0,0x20(%rbx,%rsi,4)
movdqu %xmm0,0x30(%rbx,%rsi,4)
movdqu %xmm0,0x40(%rbx,%rsi,4)
movdqu %xmm0,0x50(%rbx,%rsi,4)
movdqu %xmm0,0x60(%rbx,%rsi,4)
movdqu %xmm0,0x70(%rbx,%rsi,4)
movdqu %xmm0,0x80(%rbx,%rsi,4)
movdqu %xmm0,0x90(%rbx,%rsi,4)
movdqu %xmm0,0xa0(%rbx,%rsi,4)
movdqu %xmm0,0xb0(%rbx,%rsi,4)
movdqu %xmm0,0xc0(%rbx,%rsi,4)
movdqu %xmm0,0xd0(%rbx,%rsi,4)
movdqu %xmm0,0xe0(%rbx,%rsi,4)
movdqu %xmm0,0xf0(%rbx,%rsi,4)
add    $0x40,%rsi
add    $0xfffffffffffffff8,%rdx
jne    17e0 <hmm+0x690>
test   %rcx,%rcx
je     1894 <hmm+0x744>
lea    (%rbx,%rsi,4),%rdx
add    $0x10,%rdx
shl    $0x5,%rcx
xor    %esi,%esi
nopl   0x0(%rax,%rax,1)
movdqu %xmm0,-0x10(%rdx,%rsi,1)
movdqu %xmm0,(%rdx,%rsi,1)
add    $0x20,%rsi
cmp    %rsi,%rcx
jne    1880 <hmm+0x730>
cmp    %r13,%rax
je     173b <hmm+0x5eb>
nopl   (%rax)
movl   $0x7,(%rbx,%rax,4)
add    $0x1,%rax
cmp    %r13,%rax
jl     18a0 <hmm+0x750>
jmp    173b <hmm+0x5eb>
mov    (%rsp),%r14
mov    %rbp,%rbx
mov    0xc0(%rsp),%r9
jmp    18df <hmm+0x78f>
mov    0xf0(%rsp),%r15d
mov    0xc8(%rsp),%r12d
mov    0x38(%rsp),%r13
mov    (%rsp),%rbx
mov    %rbx,%rdi
mov    0x8(%rsp),%rsi
mov    0x40(%rsp),%rdx
mov    %r14,%rcx
mov    %r12d,%r8d
xor    %eax,%eax
push   0x20(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   0x110(%rsp)
push   %r15
push   0x110(%rsp)
push   0x110(%rsp)
mov    0x110(%rsp),%ebp
push   %rbp
push   0x110(%rsp)
push   %r13
call   1070 <calcResults@plt>
add    $0x50,%rsp
test   %eax,%eax
je     194b <hmm+0x7fb>
lea    0x6d4(%rip),%rdi
call   1040 <puts@plt>
mov    $0xffffffff,%eax
jmp    1a3e <hmm+0x8ee>
cmp    $0x1,%r15d
jne    19f0 <hmm+0x8a0>
test   %r12d,%r12d
mov    %rbx,%r13
jle    1982 <hmm+0x832>
mov    %r12d,%ebp
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax)
mov    (%r14,%rbx,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbx
cmp    %rbx,%rbp
jne    1970 <hmm+0x820>
mov    %r14,%rdi
call   1030 <free@plt>
jmp    19f3 <hmm+0x8a3>
mov    (%rsp),%rbx
mov    %rbx,%rdi
mov    %rbp,%rsi
mov    %r14,%rdx
mov    %r12d,%r8d
mov    0xc0(%rsp),%r9
xor    %eax,%eax
push   0x20(%rsp)
push   0x30(%rsp)
push   0x40(%rsp)
push   0x110(%rsp)
push   %r15
push   0x110(%rsp)
push   0x110(%rsp)
mov    0x110(%rsp),%ecx
push   %rcx
push   0x110(%rsp)
push   %r13
call   1070 <calcResults@plt>
add    $0x50,%rsp
test   %eax,%eax
jne    1935 <hmm+0x7e5>
mov    %rbp,0x8(%rsp)
mov    %rbx,%r13
add    $0x1,%r15d
imul   %r12d,%r15d
test   %r15d,%r15d
mov    0x8(%rsp),%r14
jle    1a2c <hmm+0x8dc>
mov    %r15d,%ebx
xor    %ebp,%ebp
nopw   0x0(%rax,%rax,1)
mov    0x0(%r13,%rbp,8),%rdi
call   1030 <free@plt>
mov    (%r14,%rbp,8),%rdi
call   1030 <free@plt>
add    $0x1,%rbp
cmp    %rbp,%rbx
jne    1a10 <hmm+0x8c0>
mov    %r13,%rdi
call   1030 <free@plt>
mov    %r14,%rdi
call   1030 <free@plt>
xor    %eax,%eax
add    $0x78,%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

LLVM IR (-O0):
@.str = [23 x i8] c"Error in calcResults!\0A\00"
define i32 @hmm(i8** %0, i32 %1, double* %2, double** %3, double* %4, double** %5, i32* %6, i32* %7, i32* %8, i32 %9, i8** %10, i32 %11, i32* %12, i32* %13, i32 %14, i8* %15) {
%17 = alloca i32
%18 = alloca i8**
%19 = alloca i32
%20 = alloca double*
%21 = alloca double**
%22 = alloca double*
%23 = alloca double**
%24 = alloca i32*
%25 = alloca i32*
%26 = alloca i32*
%27 = alloca i32
%28 = alloca i8**
%29 = alloca i32
%30 = alloca i32*
%31 = alloca i32*
%32 = alloca i32
%33 = alloca i8*
%34 = alloca i32**
%35 = alloca i32
%36 = alloca i32
%37 = alloca double**
%38 = alloca i8**
%39 = alloca i32
%40 = alloca i32
%41 = alloca i32
%42 = alloca i32
%43 = alloca i32
store i8** %0, i8*** %18
store i32 %1, i32* %19
store double* %2, double** %20
store double** %3, double*** %21
store double* %4, double** %22
store double** %5, double*** %23
store i32* %6, i32** %24
store i32* %7, i32** %25
store i32* %8, i32** %26
store i32 %9, i32* %27
store i8** %10, i8*** %28
store i32 %11, i32* %29
store i32* %12, i32** %30
store i32* %13, i32** %31
store i32 %14, i32* %32
store i8* %15, i8** %33
store i32 0, i32* %39
store i32 0, i32* %40
br label %44
44: ; preds = %56, %16
%45 = load i32, i32* %40
%46 = load i32, i32* %19
%47 = icmp slt i32 %45, %46
br i1 %47, label %48, label %59
48: ; preds = %44
%49 = load i32*, i32** %24
%50 = load i32, i32* %40
%51 = sext i32 %50 to i64
%52 = getelementptr inbounds i32, i32* %49, i64 %51
%53 = load i32, i32* %52
%54 = load i32, i32* %39
%55 = add nsw i32 %54, %53
store i32 %55, i32* %39
br label %56
56: ; preds = %48
%57 = load i32, i32* %40
%58 = add nsw i32 %57, 1
store i32 %58, i32* %40
br label %44
59: ; preds = %44
%60 = load i32, i32* %32
%61 = icmp eq i32 %60, 0
br i1 %61, label %62, label %172
62: ; preds = %59
%63 = load i32, i32* %27
%64 = sext i32 %63 to i64
%65 = mul i64 %64, 8
%66 = call i8* @malloc(i64 %65)
%67 = bitcast i8* %66 to i32**
store i32** %67, i32*** %34
%68 = load i32, i32* %27
%69 = sext i32 %68 to i64
%70 = mul i64 %69, 8
%71 = call i8* @malloc(i64 %70)
%72 = bitcast i8* %71 to double**
store double** %72, double*** %37
store i32 0, i32* %36
br label %73
73: ; preds = %168, %62
%74 = load i32, i32* %36
%75 = load i32, i32* %27
%76 = icmp slt i32 %74, %75
br i1 %76, label %77, label %171
77: ; preds = %73
%78 = load i32*, i32** %26
%79 = load i32, i32* %36
%80 = sext i32 %79 to i64
%81 = getelementptr inbounds i32, i32* %78, i64 %80
%82 = load i32, i32* %81
%83 = add nsw i32 %82, 1
%84 = sext i32 %83 to i64
%85 = mul i64 %84, 4
%86 = call i8* @malloc(i64 %85)
%87 = bitcast i8* %86 to i32*
%88 = load i32**, i32*** %34
%89 = load i32, i32* %36
%90 = sext i32 %89 to i64
%91 = getelementptr inbounds i32*, i32** %88, i64 %90
store i32* %87, i32** %91
%92 = load i32*, i32** %26
%93 = load i32, i32* %36
%94 = sext i32 %93 to i64
%95 = getelementptr inbounds i32, i32* %92, i64 %94
%96 = load i32, i32* %95
%97 = add nsw i32 %96, 1
%98 = load i32, i32* %19
%99 = mul nsw i32 %97, %98
%100 = sext i32 %99 to i64
%101 = mul i64 %100, 8
%102 = call i8* @malloc(i64 %101)
%103 = bitcast i8* %102 to double*
%104 = load double**, double*** %37
%105 = load i32, i32* %36
%106 = sext i32 %105 to i64
%107 = getelementptr inbounds double*, double** %104, i64 %106
store double* %103, double** %107
%108 = load i32*, i32** %26
%109 = load i32, i32* %36
%110 = sext i32 %109 to i64
%111 = getelementptr inbounds i32, i32* %108, i64 %110
%112 = load i32, i32* %111
%113 = load i32, i32* %39
%114 = sub nsw i32 %113, 1
%115 = icmp sge i32 %112, %114
br i1 %115, label %116, label %145
116: ; preds = %77
%117 = load i32**, i32*** %34
%118 = load i32, i32* %36
%119 = sext i32 %118 to i64
%120 = getelementptr inbounds i32*, i32** %117, i64 %119
%121 = load i32*, i32** %120
%122 = load double**, double*** %37
%123 = load i32, i32* %36
%124 = sext i32 %123 to i64
%125 = getelementptr inbounds double*, double** %122, i64 %124
%126 = load double*, double** %125
%127 = load i8**, i8*** %18
%128 = load i32, i32* %36
%129 = sext i32 %128 to i64
%130 = getelementptr inbounds i8*, i8** %127, i64 %129
%131 = load i8*, i8** %130
%132 = load i32, i32* %19
%133 = load double*, double** %20
%134 = load double**, double*** %21
%135 = load double*, double** %22
%136 = load double**, double*** %23
%137 = load i32*, i32** %24
%138 = load i32*, i32** %25
%139 = load i32*, i32** %26
%140 = load i32, i32* %36
%141 = sext i32 %140 to i64
%142 = getelementptr inbounds i32, i32* %139, i64 %141
%143 = load i32, i32* %142
%144 = call i32 (i32*, double*, i8*, i32, double*, double**, double*, double**, i32*, i32*, i32, ...) bitcast (i32 (...)* @viterbi to i32 (i32*, double*, i8*, i32, double*, double**, double*, double**, i32*, i32*, i32, ...)*)(i32* %121, double* %126, i8* %131, i32 %132, double* %133, double** %134, double* %135, double** %136, i32* %137, i32* %138, i32 %143)
br label %167
145: ; preds = %77
store i32 0, i32* %41
br label %146
146: ; preds = %163, %145
%147 = load i32, i32* %41
%148 = load i32*, i32** %26
%149 = load i32, i32* %36
%150 = sext i32 %149 to i64
%151 = getelementptr inbounds i32, i32* %148, i64 %150
%152 = load i32, i32* %151
%153 = icmp slt i32 %147, %152
br i1 %153, label %154, label %166
154: ; preds = %146
%155 = load i32**, i32*** %34
%156 = load i32, i32* %36
%157 = sext i32 %156 to i64
%158 = getelementptr inbounds i32*, i32** %155, i64 %157
%159 = load i32*, i32** %158
%160 = load i32, i32* %41
%161 = sext i32 %160 to i64
%162 = getelementptr inbounds i32, i32* %159, i64 %161
store i32 7, i32* %162
br label %163
163: ; preds = %154
%164 = load i32, i32* %41
%165 = add nsw i32 %164, 1
store i32 %165, i32* %41
br label %146
166: ; preds = %146
br label %167
167: ; preds = %166, %116
br label %168
168: ; preds = %167
%169 = load i32, i32* %36
%170 = add nsw i32 %169, 1
store i32 %170, i32* %36
br label %73
171: ; preds = %73
br label %547
172: ; preds = %59
%173 = load i32, i32* %27
%174 = sext i32 %173 to i64
%175 = mul i64 %174, 8
%176 = call i8* @malloc(i64 %175)
%177 = bitcast i8* %176 to i8**
store i8** %177, i8*** %38
%178 = load i32, i32* %27
%179 = mul nsw i32 2, %178
%180 = sext i32 %179 to i64
%181 = mul i64 %180, 8
%182 = call i8* @malloc(i64 %181)
%183 = bitcast i8* %182 to i32**
store i32** %183, i32*** %34
%184 = load i32, i32* %27
%185 = mul nsw i32 2, %184
%186 = sext i32 %185 to i64
%187 = mul i64 %186, 8
%188 = call i8* @malloc(i64 %187)
%189 = bitcast i8* %188 to double**
store double** %189, double*** %37
store i32 0, i32* %36
br label %190
190: ; preds = %543, %172
%191 = load i32, i32* %36
%192 = load i32, i32* %27
%193 = icmp slt i32 %191, %192
br i1 %193, label %194, label %546
194: ; preds = %190
%195 = load i32*, i32** %26
%196 = load i32, i32* %36
%197 = sext i32 %196 to i64
%198 = getelementptr inbounds i32, i32* %195, i64 %197
%199 = load i32, i32* %198
%200 = add nsw i32 %199, 1
%201 = sext i32 %200 to i64
%202 = mul i64 %201, 4
%203 = call i8* @malloc(i64 %202)
%204 = bitcast i8* %203 to i32*
%205 = load i32**, i32*** %34
%206 = load i32, i32* %36
%207 = mul nsw i32 2, %206
%208 = sext i32 %207 to i64
%209 = getelementptr inbounds i32*, i32** %205, i64 %208
store i32* %204, i32** %209
%210 = load i32*, i32** %26
%211 = load i32, i32* %36
%212 = sext i32 %211 to i64
%213 = getelementptr inbounds i32, i32* %210, i64 %212
%214 = load i32, i32* %213
%215 = add nsw i32 %214, 1
%216 = load i32, i32* %19
%217 = mul nsw i32 %215, %216
%218 = sext i32 %217 to i64
%219 = mul i64 %218, 8
%220 = call i8* @malloc(i64 %219)
%221 = bitcast i8* %220 to double*
%222 = load double**, double*** %37
%223 = load i32, i32* %36
%224 = mul nsw i32 2, %223
%225 = sext i32 %224 to i64
%226 = getelementptr inbounds double*, double** %222, i64 %225
store double* %221, double** %226
%227 = load i32*, i32** %26
%228 = load i32, i32* %36
%229 = sext i32 %228 to i64
%230 = getelementptr inbounds i32, i32* %227, i64 %229
%231 = load i32, i32* %230
%232 = add nsw i32 %231, 1
%233 = sext i32 %232 to i64
%234 = mul i64 %233, 4
%235 = call i8* @malloc(i64 %234)
%236 = bitcast i8* %235 to i32*
%237 = load i32**, i32*** %34
%238 = load i32, i32* %36
%239 = mul nsw i32 2, %238
%240 = add nsw i32 %239, 1
%241 = sext i32 %240 to i64
%242 = getelementptr inbounds i32*, i32** %237, i64 %241
store i32* %236, i32** %242
%243 = load i32*, i32** %26
%244 = load i32, i32* %36
%245 = sext i32 %244 to i64
%246 = getelementptr inbounds i32, i32* %243, i64 %245
%247 = load i32, i32* %246
%248 = add nsw i32 %247, 1
%249 = load i32, i32* %19
%250 = mul nsw i32 %248, %249
%251 = sext i32 %250 to i64
%252 = mul i64 %251, 8
%253 = call i8* @malloc(i64 %252)
%254 = bitcast i8* %253 to double*
%255 = load double**, double*** %37
%256 = load i32, i32* %36
%257 = mul nsw i32 2, %256
%258 = add nsw i32 %257, 1
%259 = sext i32 %258 to i64
%260 = getelementptr inbounds double*, double** %255, i64 %259
store double* %254, double** %260
%261 = load i32*, i32** %26
%262 = load i32, i32* %36
%263 = sext i32 %262 to i64
%264 = getelementptr inbounds i32, i32* %261, i64 %263
%265 = load i32, i32* %264
%266 = sext i32 %265 to i64
%267 = mul i64 %266, 1
%268 = call i8* @malloc(i64 %267)
%269 = load i8**, i8*** %38
%270 = load i32, i32* %36
%271 = sext i32 %270 to i64
%272 = getelementptr inbounds i8*, i8** %269, i64 %271
store i8* %268, i8** %272
%273 = load i32*, i32** %26
%274 = load i32, i32* %36
%275 = sext i32 %274 to i64
%276 = getelementptr inbounds i32, i32* %273, i64 %275
%277 = load i32, i32* %276
%278 = load i32, i32* %39
%279 = sub nsw i32 %278, 1
%280 = icmp sge i32 %277, %279
br i1 %280, label %281, label %509
281: ; preds = %194
%282 = load i32**, i32*** %34
%283 = load i32, i32* %36
%284 = mul nsw i32 2, %283
%285 = sext i32 %284 to i64
%286 = getelementptr inbounds i32*, i32** %282, i64 %285
%287 = load i32*, i32** %286
%288 = load double**, double*** %37
%289 = load i32, i32* %36
%290 = mul nsw i32 2, %289
%291 = sext i32 %290 to i64
%292 = getelementptr inbounds double*, double** %288, i64 %291
%293 = load double*, double** %292
%294 = load i8**, i8*** %18
%295 = load i32, i32* %36
%296 = sext i32 %295 to i64
%297 = getelementptr inbounds i8*, i8** %294, i64 %296
%298 = load i8*, i8** %297
%299 = load i32, i32* %19
%300 = load double*, double** %20
%301 = load double**, double*** %21
%302 = load double*, double** %22
%303 = load double**, double*** %23
%304 = load i32*, i32** %24
%305 = load i32*, i32** %25
%306 = load i32*, i32** %26
%307 = load i32, i32* %36
%308 = sext i32 %307 to i64
%309 = getelementptr inbounds i32, i32* %306, i64 %308
%310 = load i32, i32* %309
%311 = call i32 (i32*, double*, i8*, i32, double*, double**, double*, double**, i32*, i32*, i32, ...) bitcast (i32 (...)* @viterbi to i32 (i32*, double*, i8*, i32, double*, double**, double*, double**, i32*, i32*, i32, ...)*)(i32* %287, double* %293, i8* %298, i32 %299, double* %300, double** %301, double* %302, double** %303, i32* %304, i32* %305, i32 %310)
store i32 0, i32* %42
br label %312
312: ; preds = %473, %281
%313 = load i32, i32* %42
%314 = load i32*, i32** %26
%315 = load i32, i32* %36
%316 = sext i32 %315 to i64
%317 = getelementptr inbounds i32, i32* %314, i64 %316
%318 = load i32, i32* %317
%319 = icmp slt i32 %313, %318
br i1 %319, label %320, label %476
320: ; preds = %312
%321 = load i8**, i8*** %18
%322 = load i32, i32* %36
%323 = sext i32 %322 to i64
%324 = getelementptr inbounds i8*, i8** %321, i64 %323
%325 = load i8*, i8** %324
%326 = load i32*, i32** %26
%327 = load i32, i32* %36
%328 = sext i32 %327 to i64
%329 = getelementptr inbounds i32, i32* %326, i64 %328
%330 = load i32, i32* %329
%331 = load i32, i32* %42
%332 = sub nsw i32 %330, %331
%333 = sub nsw i32 %332, 1
%334 = sext i32 %333 to i64
%335 = getelementptr inbounds i8, i8* %325, i64 %334
%336 = load i8, i8* %335
%337 = sext i8 %336 to i32
%338 = icmp eq i32 %337, 65
br i1 %338, label %358, label %339
339: ; preds = %320
%340 = load i8**, i8*** %18
%341 = load i32, i32* %36
%342 = sext i32 %341 to i64
%343 = getelementptr inbounds i8*, i8** %340, i64 %342
%344 = load i8*, i8** %343
%345 = load i32*, i32** %26
%346 = load i32, i32* %36
%347 = sext i32 %346 to i64
%348 = getelementptr inbounds i32, i32* %345, i64 %347
%349 = load i32, i32* %348
%350 = load i32, i32* %42
%351 = sub nsw i32 %349, %350
%352 = sub nsw i32 %351, 1
%353 = sext i32 %352 to i64
%354 = getelementptr inbounds i8, i8* %344, i64 %353
%355 = load i8, i8* %354
%356 = sext i8 %355 to i32
%357 = icmp eq i32 %356, 97
br i1 %357, label %358, label %367
358: ; preds = %339, %320
%359 = load i8**, i8*** %38
%360 = load i32, i32* %36
%361 = sext i32 %360 to i64
%362 = getelementptr inbounds i8*, i8** %359, i64 %361
%363 = load i8*, i8** %362
%364 = load i32, i32* %42
%365 = sext i32 %364 to i64
%366 = getelementptr inbounds i8, i8* %363, i64 %365
store i8 84, i8* %366
br label %472
367: ; preds = %339
%368 = load i8**, i8*** %18
%369 = load i32, i32* %36
%370 = sext i32 %369 to i64
%371 = getelementptr inbounds i8*, i8** %368, i64 %370
%372 = load i8*, i8** %371
%373 = load i32*, i32** %26
%374 = load i32, i32* %36
%375 = sext i32 %374 to i64
%376 = getelementptr inbounds i32, i32* %373, i64 %375
%377 = load i32, i32* %376
%378 = load i32, i32* %42
%379 = sub nsw i32 %377, %378
%380 = sub nsw i32 %379, 1
%381 = sext i32 %380 to i64
%382 = getelementptr inbounds i8, i8* %372, i64 %381
%383 = load i8, i8* %382
%384 = sext i8 %383 to i32
%385 = icmp eq i32 %384, 67
br i1 %385, label %405, label %386
386: ; preds = %367
%387 = load i8**, i8*** %18
%388 = load i32, i32* %36
%389 = sext i32 %388 to i64
%390 = getelementptr inbounds i8*, i8** %387, i64 %389
%391 = load i8*, i8** %390
%392 = load i32*, i32** %26
%393 = load i32, i32* %36
%394 = sext i32 %393 to i64
%395 = getelementptr inbounds i32, i32* %392, i64 %394
%396 = load i32, i32* %395
%397 = load i32, i32* %42
%398 = sub nsw i32 %396, %397
%399 = sub nsw i32 %398, 1
%400 = sext i32 %399 to i64
%401 = getelementptr inbounds i8, i8* %391, i64 %400
%402 = load i8, i8* %401
%403 = sext i8 %402 to i32
%404 = icmp eq i32 %403, 99
br i1 %404, label %405, label %414
405: ; preds = %386, %367
%406 = load i8**, i8*** %38
%407 = load i32, i32* %36
%408 = sext i32 %407 to i64
%409 = getelementptr inbounds i8*, i8** %406, i64 %408
%410 = load i8*, i8** %409
%411 = load i32, i32* %42
%412 = sext i32 %411 to i64
%413 = getelementptr inbounds i8, i8* %410, i64 %412
store i8 71, i8* %413
br label %471
414: ; preds = %386
%415 = load i8**, i8*** %18
%416 = load i32, i32* %36
%417 = sext i32 %416 to i64
%418 = getelementptr inbounds i8*, i8** %415, i64 %417
%419 = load i8*, i8** %418
%420 = load i32*, i32** %26
%421 = load i32, i32* %36
%422 = sext i32 %421 to i64
%423 = getelementptr inbounds i32, i32* %420, i64 %422
%424 = load i32, i32* %423
%425 = load i32, i32* %42
%426 = sub nsw i32 %424, %425
%427 = sub nsw i32 %426, 1
%428 = sext i32 %427 to i64
%429 = getelementptr inbounds i8, i8* %419, i64 %428
%430 = load i8, i8* %429
%431 = sext i8 %430 to i32
%432 = icmp eq i32 %431, 71
br i1 %432, label %452, label %433
433: ; preds = %414
%434 = load i8**, i8*** %18
%435 = load i32, i32* %36
%436 = sext i32 %435 to i64
%437 = getelementptr inbounds i8*, i8** %434, i64 %436
%438 = load i8*, i8** %437
%439 = load i32*, i32** %26
%440 = load i32, i32* %36
%441 = sext i32 %440 to i64
%442 = getelementptr inbounds i32, i32* %439, i64 %441
%443 = load i32, i32* %442
%444 = load i32, i32* %42
%445 = sub nsw i32 %443, %444
%446 = sub nsw i32 %445, 1
%447 = sext i32 %446 to i64
%448 = getelementptr inbounds i8, i8* %438, i64 %447
%449 = load i8, i8* %448
%450 = sext i8 %449 to i32
%451 = icmp eq i32 %450, 103
br i1 %451, label %452, label %461
452: ; preds = %433, %414
%453 = load i8**, i8*** %38
%454 = load i32, i32* %36
%455 = sext i32 %454 to i64
%456 = getelementptr inbounds i8*, i8** %453, i64 %455
%457 = load i8*, i8** %456
%458 = load i32, i32* %42
%459 = sext i32 %458 to i64
%460 = getelementptr inbounds i8, i8* %457, i64 %459
store i8 67, i8* %460
br label %470
461: ; preds = %433
%462 = load i8**, i8*** %38
%463 = load i32, i32* %36
%464 = sext i32 %463 to i64
%465 = getelementptr inbounds i8*, i8** %462, i64 %464
%466 = load i8*, i8** %465
%467 = load i32, i32* %42
%468 = sext i32 %467 to i64
%469 = getelementptr inbounds i8, i8* %466, i64 %468
store i8 65, i8* %469
br label %470
470: ; preds = %461, %452
br label %471
471: ; preds = %470, %405
br label %472
472: ; preds = %471, %358
br label %473
473: ; preds = %472
%474 = load i32, i32* %42
%475 = add nsw i32 %474, 1
store i32 %475, i32* %42
br label %312
476: ; preds = %312
%477 = load i32**, i32*** %34
%478 = load i32, i32* %36
%479 = mul nsw i32 2, %478
%480 = add nsw i32 %479, 1
%481 = sext i32 %480 to i64
%482 = getelementptr inbounds i32*, i32** %477, i64 %481
%483 = load i32*, i32** %482
%484 = load double**, double*** %37
%485 = load i32, i32* %36
%486 = mul nsw i32 2, %485
%487 = add nsw i32 %486, 1
%488 = sext i32 %487 to i64
%489 = getelementptr inbounds double*, double** %484, i64 %488
%490 = load double*, double** %489
%491 = load i8**, i8*** %38
%492 = load i32, i32* %36
%493 = sext i32 %492 to i64
%494 = getelementptr inbounds i8*, i8** %491, i64 %493
%495 = load i8*, i8** %494
%496 = load i32, i32* %19
%497 = load double*, double** %20
%498 = load double**, double*** %21
%499 = load double*, double** %22
%500 = load double**, double*** %23
%501 = load i32*, i32** %24
%502 = load i32*, i32** %25
%503 = load i32*, i32** %26
%504 = load i32, i32* %36
%505 = sext i32 %504 to i64
%506 = getelementptr inbounds i32, i32* %503, i64 %505
%507 = load i32, i32* %506
%508 = call i32 (i32*, double*, i8*, i32, double*, double**, double*, double**, i32*, i32*, i32, ...) bitcast (i32 (...)* @viterbi to i32 (i32*, double*, i8*, i32, double*, double**, double*, double**, i32*, i32*, i32, ...)*)(i32* %483, double* %490, i8* %495, i32 %496, double* %497, double** %498, double* %499, double** %500, i32* %501, i32* %502, i32 %507)
br label %542
509: ; preds = %194
store i32 0, i32* %43
br label %510
510: ; preds = %538, %509
%511 = load i32, i32* %43
%512 = load i32*, i32** %26
%513 = load i32, i32* %36
%514 = sext i32 %513 to i64
%515 = getelementptr inbounds i32, i32* %512, i64 %514
%516 = load i32, i32* %515
%517 = icmp slt i32 %511, %516
br i1 %517, label %518, label %541
518: ; preds = %510
%519 = load i32**, i32*** %34
%520 = load i32, i32* %36
%521 = mul nsw i32 2, %520
%522 = sext i32 %521 to i64
%523 = getelementptr inbounds i32*, i32** %519, i64 %522
%524 = load i32*, i32** %523
%525 = load i32, i32* %43
%526 = sext i32 %525 to i64
%527 = getelementptr inbounds i32, i32* %524, i64 %526
store i32 7, i32* %527
%528 = load i32**, i32*** %34
%529 = load i32, i32* %36
%530 = mul nsw i32 2, %529
%531 = add nsw i32 %530, 1
%532 = sext i32 %531 to i64
%533 = getelementptr inbounds i32*, i32** %528, i64 %532
%534 = load i32*, i32** %533
%535 = load i32, i32* %43
%536 = sext i32 %535 to i64
%537 = getelementptr inbounds i32, i32* %534, i64 %536
store i32 7, i32* %537
br label %538
538: ; preds = %518
%539 = load i32, i32* %43
%540 = add nsw i32 %539, 1
store i32 %540, i32* %43
br label %510
541: ; preds = %510
br label %542
542: ; preds = %541, %476
br label %543
543: ; preds = %542
%544 = load i32, i32* %36
%545 = add nsw i32 %544, 1
store i32 %545, i32* %36
br label %190
546: ; preds = %190
br label %547
547: ; preds = %546, %171
%548 = load i32**, i32*** %34
%549 = load double**, double*** %37
%550 = load i8**, i8*** %18
%551 = load i8**, i8*** %38
%552 = load i32, i32* %27
%553 = load i32*, i32** %26
%554 = load i32, i32* %19
%555 = load i8**, i8*** %28
%556 = load i32, i32* %29
%557 = load i32*, i32** %30
%558 = load i32*, i32** %31
%559 = load i32, i32* %32
%560 = load i8*, i8** %33
%561 = load double**, double*** %21
%562 = load double*, double** %22
%563 = load double*, double** %20
%564 = call i32 (i32**, double**, i8**, i8**, i32, i32*, i32, i8**, i32, i32*, i32*, i32, i8*, double**, double*, double*, ...) bitcast (i32 (...)* @calcResults to i32 (i32**, double**, i8**, i8**, i32, i32*, i32, i8**, i32, i32*, i32*, i32, i8*, double**, double*, double*, ...)*)(i32** %548, double** %549, i8** %550, i8** %551, i32 %552, i32* %553, i32 %554, i8** %555, i32 %556, i32* %557, i32* %558, i32 %559, i8* %560, double** %561, double* %562, double* %563)
store i32 %564, i32* %35
%565 = icmp ne i32 %564, 0
br i1 %565, label %566, label %568
566: ; preds = %547
%567 = call i32 (i8*, ...) @printf(i8* getelementptr inbounds ([23 x i8], [23 x i8]* @.str, i64 0, i64 0))
store i32 -1, i32* %17
br label %617
568: ; preds = %547
%569 = load i32, i32* %32
%570 = icmp eq i32 %569, 1
br i1 %570, label %571, label %588
571: ; preds = %568
store i32 0, i32* %36
br label %572
572: ; preds = %582, %571
%573 = load i32, i32* %36
%574 = load i32, i32* %27
%575 = icmp slt i32 %573, %574
br i1 %575, label %576, label %585
576: ; preds = %572
%577 = load i8**, i8*** %38
%578 = load i32, i32* %36
%579 = sext i32 %578 to i64
%580 = getelementptr inbounds i8*, i8** %577, i64 %579
%581 = load i8*, i8** %580
br label %582
582: ; preds = %576
%583 = load i32, i32* %36
%584 = add nsw i32 %583, 1
store i32 %584, i32* %36
br label %572
585: ; preds = %572
%586 = load i8**, i8*** %38
%587 = bitcast i8** %586 to i8*
br label %588
588: ; preds = %585, %568
store i32 0, i32* %36
br label %589
589: ; preds = %609, %588
%590 = load i32, i32* %36
%591 = load i32, i32* %32
%592 = add nsw i32 1, %591
%593 = load i32, i32* %27
%594 = mul nsw i32 %592, %593
%595 = icmp slt i32 %590, %594
br i1 %595, label %596, label %612
596: ; preds = %589
%597 = load i32**, i32*** %34
%598 = load i32, i32* %36
%599 = sext i32 %598 to i64
%600 = getelementptr inbounds i32*, i32** %597, i64 %599
%601 = load i32*, i32** %600
%602 = bitcast i32* %601 to i8*
%603 = load double**, double*** %37
%604 = load i32, i32* %36
%605 = sext i32 %604 to i64
%606 = getelementptr inbounds double*, double** %603, i64 %605
%607 = load double*, double** %606
%608 = bitcast double* %607 to i8*
br label %609
609: ; preds = %596
%610 = load i32, i32* %36
%611 = add nsw i32 %610, 1
store i32 %611, i32* %36
br label %589
612: ; preds = %589
%613 = load i32**, i32*** %34
%614 = bitcast i32** %613 to i8*
%615 = load double**, double*** %37
%616 = bitcast double** %615 to i8*
store i32 0, i32* %17
br label %617
617: ; preds = %612, %566
%618 = load i32, i32* %17
ret i32 %618
}

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