void cost_matrix(double *Dmat, double *error, double *vals, int *actionindices,
                 double *state_weights, int *actions, int *actionsMax, int *M,
                 int *N, int *weighted_mean, int *mode, double *theta,
                 double *weight_best_action) {
  int u;
  for (u = 0; u < *M; u++) {
    int v;
    for (v = 0; v < *M; v++) {
      Dmat[v + u * *M] = 0;
    }
  }
  int i;
  int lastInd = 0;
  for (i = 0; i < *N; i++) {
    int nActions = actions[i];
    if (*actionsMax > 0) {
      if (nActions > *actionsMax)
        nActions = *actionsMax;
    }
    int j;
    double weights[*M][nActions];
    for (u = 0; u < *M; u++) {
      double sum1 = 0;
      if (*mode == 0) {
        for (j = 0; j < nActions; j++) {
          weights[u][j] = 1.0 / (double)nActions;
        }
      } else if (*mode == 1) {
        if (nActions == 1) {
          weights[u][0] = 1.0;
        } else {
          double bestVal2 = -999999;
          int bestJ2 = 0;
          for (j = 0; j < nActions; j++) {
            if (vals[u + *M * (j + lastInd)] > bestVal2) {
              bestVal2 = vals[u + *M * (j + lastInd)];
              bestJ2 = j;
            }
          }
          for (j = 0; j < nActions; j++) {
            if (j == bestJ2)
              weights[u][j] = *weight_best_action;
            else
              weights[u][j] =
                  1.0 / ((double)nActions - 1.0) * (1.0 - *weight_best_action);
          }
        }
      } else if (*mode == 2) {
        int rank[*M][nActions];
        int rankNew[*M][nActions];
        for (j = 0; j < nActions; j++) {
          rank[u][j] = j;
        }
        int swapped;
        do {
          swapped = 0;
          for (j = 1; j < nActions; j++) {
            if (vals[u + *M * (rank[u][j] + lastInd)] <
                vals[u + *M * (rank[u][j - 1] + lastInd)]) {
              int tmp = rank[u][j];
              rank[u][j] = rank[u][j - 1];
              rank[u][j - 1] = tmp;
              swapped = 1;
            }
          }
        } while (swapped);
        for (j = 0; j < nActions; j++) {
          rankNew[u][rank[u][j]] = j + 1;
        }
        if (*theta < 0) {
          for (j = 0; j < nActions; j++) {
            rank[u][j] = rankNew[u][j];
            sum1 += rank[u][j];
          }
        } else {
          for (j = 0; j < nActions; j++) {
            rank[u][j] = exp(rankNew[u][j] / (double)nActions * *theta);
            sum1 += rank[u][j];
          }
        }
        for (j = 0; j < nActions; j++) {
          weights[u][j] = rank[u][j] / sum1;
        }
      }
      sum1 = 0;
      for (j = 0; j < nActions; j++) {
        sum1 += weights[u][j];
        if (weights[u][j] < 0)
          printf("### Wrong weights #3 (%lf)\n", weights[u][j]);
      }
      if ((sum1 < 0.99999) || (sum1 > 1.00001))
        printf("### Wrong weights #1 (%lf)\n", sum1);
    }
    for (u = 0; u < *M; u++) {
      int v;
      for (v = 0; v < *M; v++) {
        if (*weighted_mean) {
          double mean1 = 0, mean2 = 0;
          for (j = 0; j < nActions; j++) {
            mean1 += weights[v][j] * error[v + *M * (j + lastInd)];
            mean2 += weights[u][j] * error[u + *M * (j + lastInd)];
          }
          Dmat[v + u * *M] += state_weights[i] * mean1 * mean2;
        } else {
          double sum = 0;
          for (j = 0; j < nActions; j++) {
            int k = actionindices[u + *M * (j + lastInd)];
            int found = 0, j2;
            for (j2 = 0; j2 < nActions; j2++) {
              int k2 = actionindices[v + *M * (j2 + lastInd)];
              if (k2 == k) {
                found = 1;
                break;
              }
            }
            if (found)
              sum += weights[v][j2] * weights[u][j] *
                     error[v + *M * (j2 + lastInd)] *
                     error[u + *M * (j + lastInd)];
          }
          Dmat[v + u * *M] += state_weights[i] * sum;
        }
      }
    }
    lastInd += actions[i];
  }
}


x86 assembly (clang, -O0):
<cost_matrix>:
push   %rbp
mov    %rsp,%rbp
sub    $0x110,%rsp
mov    0x40(%rbp),%rax
mov    0x38(%rbp),%rax
mov    0x30(%rbp),%rax
mov    0x28(%rbp),%rax
mov    0x20(%rbp),%rax
mov    0x18(%rbp),%rax
mov    0x10(%rbp),%rax
mov    %rdi,-0x8(%rbp)
mov    %rsi,-0x10(%rbp)
mov    %rdx,-0x18(%rbp)
mov    %rcx,-0x20(%rbp)
mov    %r8,-0x28(%rbp)
mov    %r9,-0x30(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    11ca <cost_matrix+0xaa>
movl   $0x0,-0x38(%rbp)
mov    -0x38(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    11b7 <cost_matrix+0x97>
mov    -0x8(%rbp),%rax
mov    -0x38(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    0x18(%rbp),%rsi
imul   (%rsi),%edx
add    %edx,%ecx
movslq %ecx,%rcx
xorps  %xmm0,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x38(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x38(%rbp)
jmp    117c <cost_matrix+0x5c>
jmp    11bc <cost_matrix+0x9c>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1166 <cost_matrix+0x46>
movl   $0x0,-0x40(%rbp)
movl   $0x0,-0x3c(%rbp)
mov    -0x3c(%rbp),%eax
mov    0x20(%rbp),%rcx
cmp    (%rcx),%eax
jge    1da4 <cost_matrix+0xc84>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0x44(%rbp)
mov    0x10(%rbp),%rax
cmpl   $0x0,(%rax)
jle    121f <cost_matrix+0xff>
mov    -0x44(%rbp),%eax
mov    0x10(%rbp),%rcx
cmp    (%rcx),%eax
jle    121a <cost_matrix+0xfa>
mov    0x10(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0x44(%rbp)
jmp    121f <cost_matrix+0xff>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
mov    %rax,-0xe8(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x50(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,8),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xe0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x58(%rbp)
mov    %rax,-0x60(%rbp)
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1a07 <cost_matrix+0x8e7>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    0x30(%rbp),%rax
cmpl   $0x0,(%rax)
jne    12eb <cost_matrix+0x1cb>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    12e6 <cost_matrix+0x1c6>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
cvtsi2sdl -0x44(%rbp),%xmm1
movsd  0xd4c(%rip),%xmm0
divsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1295 <cost_matrix+0x175>
jmp    1901 <cost_matrix+0x7e1>
mov    0x30(%rbp),%rax
cmpl   $0x1,(%rax)
jne    1480 <cost_matrix+0x360>
cmpl   $0x1,-0x44(%rbp)
jne    132a <cost_matrix+0x20a>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
movsd  0xce8(%rip),%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    147b <cost_matrix+0x35b>
movsd  0xcce(%rip),%xmm0
movsd  %xmm0,-0x70(%rbp)
movl   $0x0,-0x74(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    13ba <cost_matrix+0x29a>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x48(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd -0x70(%rbp),%xmm0
jbe    13a7 <cost_matrix+0x287>
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x48(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  %xmm0,-0x70(%rbp)
mov    -0x48(%rbp),%eax
mov    %eax,-0x74(%rbp)
jmp    13ac <cost_matrix+0x28c>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1345 <cost_matrix+0x225>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1476 <cost_matrix+0x356>
mov    -0x48(%rbp),%eax
cmp    -0x74(%rbp),%eax
jne    140c <cost_matrix+0x2ec>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
mov    0x40(%rbp),%rcx
movsd  (%rcx),%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1463 <cost_matrix+0x343>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
cvtsi2sdl -0x44(%rbp),%xmm1
movsd  0xbe1(%rip),%xmm0
subsd  %xmm0,%xmm1
movsd  0xbd5(%rip),%xmm0
divsd  %xmm1,%xmm0
mov    0x40(%rbp),%rcx
movsd  0xbc5(%rip),%xmm1
subsd  (%rcx),%xmm1
mulsd  %xmm1,%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
jmp    1468 <cost_matrix+0x348>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    13c1 <cost_matrix+0x2a1>
jmp    147b <cost_matrix+0x35b>
jmp    18fc <cost_matrix+0x7dc>
mov    0x30(%rbp),%rax
cmpl   $0x2,(%rax)
jne    18f7 <cost_matrix+0x7d7>
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
mov    %rax,-0x108(%rbp)
mov    %rsp,%rdx
mov    %rdx,-0x80(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0x100(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x88(%rbp)
mov    %rax,-0x90(%rbp)
mov    0x18(%rbp),%rax
mov    (%rax),%eax
mov    %eax,%ecx
mov    -0x44(%rbp),%eax
mov    %rax,-0xf8(%rbp)
mov    %rcx,%rdx
imul   %rax,%rdx
lea    0xf(,%rdx,4),%rsi
and    $0xfffffffffffffff0,%rsi
mov    %rsp,%rdx
sub    %rsi,%rdx
mov    %rdx,-0xf0(%rbp)
mov    %rdx,%rsp
mov    %rcx,-0x98(%rbp)
mov    %rax,-0xa0(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1562 <cost_matrix+0x442>
mov    -0x100(%rbp),%rax
mov    -0x108(%rbp),%rsi
mov    -0x48(%rbp),%edx
movslq -0x34(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1521 <cost_matrix+0x401>
jmp    1567 <cost_matrix+0x447>
movl   $0x0,-0xa4(%rbp)
movl   $0x1,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    16ad <cost_matrix+0x58d>
mov    -0x100(%rbp),%rsi
mov    -0x108(%rbp),%r8
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
movslq -0x34(%rbp),%r9
imul   %r8,%r9
shl    $0x2,%r9
mov    %rsi,%rdi
add    %r9,%rdi
movslq -0x48(%rbp),%r9
mov    (%rdi,%r9,4),%edi
add    -0x40(%rbp),%edi
imul   %edi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mov    -0x18(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
movslq -0x34(%rbp),%rdi
imul   %r8,%rdi
shl    $0x2,%rdi
add    %rdi,%rsi
mov    -0x48(%rbp),%edi
sub    $0x1,%edi
movslq %edi,%rdi
mov    (%rsi,%rdi,4),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm0
ucomisd %xmm1,%xmm0
jbe    169a <cost_matrix+0x57a>
mov    -0x100(%rbp),%rax
mov    -0x108(%rbp),%rsi
movslq -0x34(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
mov    (%rcx,%rdx,4),%ecx
mov    %ecx,-0xa8(%rbp)
movslq -0x34(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
mov    -0x48(%rbp),%edx
sub    $0x1,%edx
movslq %edx,%rdx
mov    (%rcx,%rdx,4),%edi
movslq -0x34(%rbp),%rdx
imul   %rsi,%rdx
shl    $0x2,%rdx
mov    %rax,%rcx
add    %rdx,%rcx
movslq -0x48(%rbp),%rdx
mov    %edi,(%rcx,%rdx,4)
mov    -0xa8(%rbp),%edx
movslq -0x34(%rbp),%rcx
imul   %rsi,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
mov    -0x48(%rbp),%ecx
sub    $0x1,%ecx
movslq %ecx,%rcx
mov    %edx,(%rax,%rcx,4)
movl   $0x1,-0xa4(%rbp)
jmp    169f <cost_matrix+0x57f>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1578 <cost_matrix+0x458>
jmp    16b2 <cost_matrix+0x592>
cmpl   $0x0,-0xa4(%rbp)
jne    1567 <cost_matrix+0x447>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    172b <cost_matrix+0x60b>
mov    -0x100(%rbp),%rcx
mov    -0x108(%rbp),%rdi
mov    -0xf0(%rbp),%rax
mov    -0xf8(%rbp),%r8
mov    -0x48(%rbp),%edx
add    $0x1,%edx
movslq -0x34(%rbp),%rsi
imul   %r8,%rsi
shl    $0x2,%rsi
add    %rsi,%rax
movslq -0x34(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
movslq (%rcx,%rsi,4),%rcx
mov    %edx,(%rax,%rcx,4)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    16c6 <cost_matrix+0x5a6>
mov    0x38(%rbp),%rax
xorps  %xmm0,%xmm0
ucomisd (%rax),%xmm0
jbe    17cf <cost_matrix+0x6af>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    17ca <cost_matrix+0x6aa>
mov    -0x100(%rbp),%rax
mov    -0x108(%rbp),%rdx
mov    -0xf0(%rbp),%rcx
mov    -0xf8(%rbp),%rdi
movslq -0x34(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
mov    (%rcx,%rsi,4),%edi
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
mov    %edi,(%rcx,%rsi,4)
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1743 <cost_matrix+0x623>
jmp    187e <cost_matrix+0x75e>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1879 <cost_matrix+0x759>
mov    -0xf0(%rbp),%rax
mov    -0xf8(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
cvtsi2sdl -0x44(%rbp),%xmm1
divsd  %xmm1,%xmm0
mov    0x38(%rbp),%rax
mulsd  (%rax),%xmm0
call   1040 <exp@plt>
mov    -0x108(%rbp),%rdx
mov    -0x100(%rbp),%rax
cvttsd2si %xmm0,%edi
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x2,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
mov    %edi,(%rcx,%rsi,4)
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x2,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
cvtsi2sdl (%rax,%rcx,4),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    17d6 <cost_matrix+0x6b6>
jmp    187e <cost_matrix+0x75e>
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    18f0 <cost_matrix+0x7d0>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
mov    -0x100(%rbp),%rcx
mov    -0x108(%rbp),%rdi
movslq -0x34(%rbp),%rsi
imul   %rdi,%rsi
shl    $0x2,%rsi
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
cvtsi2sdl (%rcx,%rsi,4),%xmm0
divsd  -0x68(%rbp),%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movsd  %xmm0,(%rax,%rcx,8)
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1885 <cost_matrix+0x765>
mov    -0x80(%rbp),%rax
mov    %rax,%rsp
jmp    18fc <cost_matrix+0x7dc>
jmp    1901 <cost_matrix+0x7e1>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0x68(%rbp)
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    19b7 <cost_matrix+0x897>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
movslq -0x34(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
addsd  -0x68(%rbp),%xmm0
movsd  %xmm0,-0x68(%rbp)
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
xorps  %xmm0,%xmm0
ucomisd (%rax,%rcx,8),%xmm0
jbe    19a4 <cost_matrix+0x884>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
lea    0x683(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    19a9 <cost_matrix+0x889>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1910 <cost_matrix+0x7f0>
movsd  0x651(%rip),%xmm0
ucomisd -0x68(%rbp),%xmm0
ja     19e1 <cost_matrix+0x8c1>
movsd  -0x68(%rbp),%xmm0
movsd  0x641(%rip),%xmm1
ucomisd %xmm1,%xmm0
jbe    19f4 <cost_matrix+0x8d4>
movsd  -0x68(%rbp),%xmm0
lea    0x64f(%rip),%rdi
mov    $0x1,%al
call   1030 <printf@plt>
jmp    19f9 <cost_matrix+0x8d9>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    126a <cost_matrix+0x14a>
movl   $0x0,-0x34(%rbp)
mov    -0x34(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1d7e <cost_matrix+0xc5e>
movl   $0x0,-0xac(%rbp)
mov    -0xac(%rbp),%eax
mov    0x18(%rbp),%rcx
cmp    (%rcx),%eax
jge    1d6b <cost_matrix+0xc4b>
mov    0x28(%rbp),%rax
cmpl   $0x0,(%rax)
je     1b84 <cost_matrix+0xa64>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1b37 <cost_matrix+0xa17>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
movslq -0xac(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0x48(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
mov    -0x10(%rbp),%rcx
mov    -0xac(%rbp),%esi
mov    0x18(%rbp),%rdi
mov    (%rdi),%edi
mov    -0x48(%rbp),%r8d
add    -0x40(%rbp),%r8d
imul   %r8d,%edi
add    %edi,%esi
movslq %esi,%rsi
movsd  (%rcx,%rsi,8),%xmm2
movsd  -0xb8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xb8(%rbp)
ff
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x48(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc0(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc0(%rbp)
ff
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1a63 <cost_matrix+0x943>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
mulsd  -0xb8(%rbp),%xmm0
ff
movsd  -0xc0(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    0x18(%rbp),%rsi
imul   (%rsi),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d52 <cost_matrix+0xc32>
xorps  %xmm0,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
movl   $0x0,-0x48(%rbp)
mov    -0x48(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1d12 <cost_matrix+0xbf2>
mov    -0x20(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x48(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xcc(%rbp)
movl   $0x0,-0xd0(%rbp)
movl   $0x0,-0xd4(%rbp)
mov    -0xd4(%rbp),%eax
cmp    -0x44(%rbp),%eax
jge    1c4d <cost_matrix+0xb2d>
mov    -0x20(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0xd4(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mov    (%rax,%rcx,4),%eax
mov    %eax,-0xd8(%rbp)
mov    -0xd8(%rbp),%eax
cmp    -0xcc(%rbp),%eax
jne    1c34 <cost_matrix+0xb14>
movl   $0x1,-0xd0(%rbp)
jmp    1c4d <cost_matrix+0xb2d>
jmp    1c39 <cost_matrix+0xb19>
mov    -0xd4(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xd4(%rbp)
jmp    1bda <cost_matrix+0xaba>
cmpl   $0x0,-0xd0(%rbp)
je     1cff <cost_matrix+0xbdf>
mov    -0xe0(%rbp),%rax
mov    -0xe8(%rbp),%rdx
movslq -0xac(%rbp),%rsi
imul   %rdx,%rsi
shl    $0x3,%rsi
mov    %rax,%rcx
add    %rsi,%rcx
movslq -0xd4(%rbp),%rsi
movsd  (%rcx,%rsi,8),%xmm0
movslq -0x34(%rbp),%rcx
imul   %rdx,%rcx
shl    $0x3,%rcx
add    %rcx,%rax
movslq -0x48(%rbp),%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0xd4(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
mulsd  (%rax,%rcx,8),%xmm0
mov    -0x10(%rbp),%rax
mov    -0x34(%rbp),%ecx
mov    0x18(%rbp),%rdx
mov    (%rdx),%edx
mov    -0x48(%rbp),%esi
add    -0x40(%rbp),%esi
imul   %esi,%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm2
movsd  -0xc8(%rbp),%xmm1
ff
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,-0xc8(%rbp)
ff
jmp    1d04 <cost_matrix+0xbe4>
mov    -0x48(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x48(%rbp)
jmp    1b96 <cost_matrix+0xa76>
mov    -0x28(%rbp),%rax
movslq -0x3c(%rbp),%rcx
movsd  (%rax,%rcx,8),%xmm0
movsd  -0xc8(%rbp),%xmm2
ff
mov    -0x8(%rbp),%rax
mov    -0xac(%rbp),%ecx
mov    -0x34(%rbp),%edx
mov    0x18(%rbp),%rsi
imul   (%rsi),%edx
add    %edx,%ecx
movslq %ecx,%rcx
movsd  (%rax,%rcx,8),%xmm1
mulsd  %xmm2,%xmm0
addsd  %xmm1,%xmm0
movsd  %xmm0,(%rax,%rcx,8)
jmp    1d57 <cost_matrix+0xc37>
mov    -0xac(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0xac(%rbp)
jmp    1a27 <cost_matrix+0x907>
jmp    1d70 <cost_matrix+0xc50>
mov    -0x34(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x34(%rbp)
jmp    1a0e <cost_matrix+0x8ee>
mov    -0x30(%rbp),%rax
movslq -0x3c(%rbp),%rcx
mov    (%rax,%rcx,4),%eax
add    -0x40(%rbp),%eax
mov    %eax,-0x40(%rbp)
mov    -0x50(%rbp),%rax
mov    %rax,%rsp
mov    -0x3c(%rbp),%eax
add    $0x1,%eax
mov    %eax,-0x3c(%rbp)
jmp    11d8 <cost_matrix+0xb8>
mov    %rbp,%rsp
pop    %rbp
ret

x86 assembly (clang, -O2):
<cost_matrix>:
push   %rbp
mov    %rsp,%rbp
push   %r15
push   %r14
push   %r13
push   %r12
push   %rbx
sub    $0x198,%rsp
mov    %r9,-0xf8(%rbp)
mov    %r8,%r15
mov    %rcx,-0xf0(%rbp)
mov    %rdx,-0xd0(%rbp)
mov    %rsi,-0x128(%rbp)
mov    0x18(%rbp),%r13
mov    0x0(%r13),%edx
test   %edx,%edx
mov    %r8,-0xc8(%rbp)
mov    %rdi,-0x50(%rbp)
jle    1294 <cost_matrix+0x154>
lea    0x0(,%rdx,8),%rax
mov    %rax,-0x30(%rbp)
lea    -0x1(%rdx),%rax
mov    %edx,%r14d
and    $0x3,%r14d
xor    %r15d,%r15d
cmp    $0x3,%rax
mov    %rdx,-0x38(%rbp)
jae    11b9 <cost_matrix+0x79>
xor    %ebx,%ebx
jmp    1254 <cost_matrix+0x114>
mov    %edx,%r12d
and    $0xfffffffc,%r12d
lea    (%rdx,%rdx,1),%eax
mov    %rax,-0x68(%rbp)
lea    0x0(,%rdx,4),%eax
mov    %eax,-0x58(%rbp)
lea    (%rdx,%rdx,2),%r13d
xor    %ebx,%ebx
nopw   0x0(%rax,%rax,1)
movslq %r15d,%r15
lea    (%rdi,%r15,8),%rdi
xor    %esi,%esi
mov    -0x30(%rbp),%rdx
call   1040 <memset@plt>
mov    -0x38(%rbp),%rax
add    %r15d,%eax
cltq
mov    -0x50(%rbp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    -0x30(%rbp),%rdx
call   1040 <memset@plt>
mov    -0x68(%rbp),%rax
add    %r15d,%eax
cltq
mov    -0x50(%rbp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    -0x30(%rbp),%rdx
call   1040 <memset@plt>
lea    (%r15,%r13,1),%eax
cltq
mov    -0x50(%rbp),%rcx
lea    (%rcx,%rax,8),%rdi
xor    %esi,%esi
mov    -0x30(%rbp),%rdx
call   1040 <memset@plt>
mov    -0x50(%rbp),%rdi
add    $0x4,%rbx
add    -0x58(%rbp),%r15d
cmp    %rbx,%r12
jne    11e0 <cost_matrix+0xa0>
test   %r14,%r14
mov    -0xc8(%rbp),%r15
mov    0x18(%rbp),%r13
mov    -0x38(%rbp),%rdx
je     1294 <cost_matrix+0x154>
imul   %edx,%ebx
nopl   0x0(%rax,%rax,1)
movslq %ebx,%rbx
lea    (%rdi,%rbx,8),%rdi
xor    %esi,%esi
mov    %rdx,%r12
mov    -0x30(%rbp),%rdx
call   1040 <memset@plt>
mov    %r12,%rdx
mov    -0x50(%rbp),%rdi
add    %edx,%ebx
add    $0xffffffffffffffff,%r14
jne    1270 <cost_matrix+0x130>
mov    0x20(%rbp),%rax
cmpl   $0x0,(%rax)
mov    -0xd0(%rbp),%r14
jle    234a <cost_matrix+0x120a>
xor    %r8d,%r8d
movdqa 0x1d8d(%rip),%xmm3
movdqa 0x1d95(%rip),%xmm4
movdqa 0x1d9d(%rip),%xmm5
movdqa 0x1da5(%rip),%xmm6
movdqa 0x1dad(%rip),%xmm7
movdqa 0x1db4(%rip),%xmm8
movdqa 0x1dbb(%rip),%xmm9
movdqa 0x1dc2(%rip),%xmm10
xor    %eax,%eax
mov    %rax,-0x58(%rbp)
mov    -0xf8(%rbp),%rcx
nopl   0x0(%rax,%rax,1)
mov    (%rcx,%r8,4),%eax
mov    0x10(%rbp),%rcx
mov    (%rcx),%ecx
cmp    %ecx,%eax
mov    %eax,%r11d
cmovg  %ecx,%r11d
mov    %rsp,-0x178(%rbp)
test   %ecx,%ecx
cmovle %eax,%r11d
mov    %edx,%eax
imul   %r11,%rax
lea    0xf(,%rax,8),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rcx
sub    %rax,%rcx
mov    %rcx,-0x70(%rbp)
mov    %rcx,%rsp
mov    0x0(%r13),%eax
mov    %rax,-0x40(%rbp)
test   %eax,%eax
jle    2310 <cost_matrix+0x11d0>
cmp    $0x2,%r11d
cvtsi2sd %r11d,%xmm11
setl   -0xe8(%rbp)
movapd %xmm11,%xmm0
addsd  0x1c94(%rip),%xmm0
movsd  0x1c94(%rip),%xmm1
movapd %xmm1,%xmm2
divsd  %xmm0,%xmm2
movsd  %xmm2,-0x100(%rbp)
ff
movsd  %xmm11,-0xe0(%rbp)
ff ff
divsd  %xmm11,%xmm1
mov    %r11d,%eax
and    $0xfffffff8,%eax
mov    %rax,-0x1a0(%rbp)
add    $0xfffffffffffffff8,%rax
mov    %rax,-0x198(%rbp)
shr    $0x3,%rax
add    $0x1,%rax
mov    %r11d,%ebx
and    $0xfffffffe,%ebx
lea    -0x2(%rbx),%rcx
mov    %rcx,-0x158(%rbp)
shr    %rcx
add    $0x1,%rcx
mov    %r11d,%edx
and    $0xfffffffc,%edx
mov    %rdx,-0xc0(%rbp)
add    $0xfffffffffffffffc,%rdx
mov    %rdx,-0x190(%rbp)
shr    $0x2,%rdx
add    $0x1,%rdx
mov    %eax,%esi
and    $0x3,%esi
and    $0xfffffffffffffffc,%rax
mov    %rax,-0x168(%rbp)
mov    %r11d,%eax
and    $0x3,%eax
mov    %rax,-0xb8(%rbp)
mov    %rcx,%rax
mov    %rcx,-0x150(%rbp)
and    $0xfffffffffffffffe,%rcx
mov    %rcx,-0x148(%rbp)
movapd %xmm1,%xmm0
unpcklpd %xmm1,%xmm0
mov    %edx,%eax
and    $0x7,%eax
and    $0xfffffffffffffff8,%rdx
mov    %rdx,-0x160(%rbp)
mov    %rsi,-0x188(%rbp)
shl    $0x5,%rsi
mov    %rsi,-0x118(%rbp)
mov    %rax,-0x180(%rbp)
shl    $0x5,%rax
mov    %rax,-0x110(%rbp)
lea    0x0(,%r11,4),%rax
mov    %rax,-0x170(%rbp)
mov    -0x58(%rbp),%r10
movslq %r10d,%rdx
lea    -0x1(%r11),%r12
mov    -0x70(%rbp),%rax
lea    0x10(%rax),%rcx
mov    %rcx,-0xa0(%rbp)
lea    0x0(,%r11,8),%rcx
mov    %rcx,-0xd8(%rbp)
mov    %rdx,%rcx
mov    %rdx,-0xa8(%rbp)
lea    0x1(%rdx),%rcx
mov    %rcx,-0x108(%rbp)
mov    $0x1c,%ecx
mov    %rcx,-0x88(%rbp)
mov    $0x3,%ecx
mov    %rcx,-0x78(%rbp)
mov    $0x2,%ecx
mov    %rcx,-0x98(%rbp)
mov    %r14,-0xb0(%rbp)
mov    %rax,%r9
xor    %eax,%eax
mov    %rax,-0x48(%rbp)
xor    %r13d,%r13d
mov    %r8,-0x90(%rbp)
mov    %r11,-0x68(%rbp)
movapd %xmm1,-0x140(%rbp)
ff
mov    %rbx,-0x80(%rbp)
movapd %xmm0,-0x1c0(%rbp)
ff
jmp    15d6 <cost_matrix+0x496>
xorpd  %xmm2,%xmm2
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
lea    0x1bc5(%rip),%rdi
movapd %xmm2,%xmm0
mov    $0x1,%al
call   1030 <printf@plt>
mov    -0x60(%rbp),%r9
mov    -0x68(%rbp),%r11
mov    -0x58(%rbp),%r10
movdqa 0x1b79(%rip),%xmm10
movdqa 0x1b60(%rip),%xmm9
movdqa 0x1b47(%rip),%xmm8
movdqa 0x1b2f(%rip),%xmm7
movdqa 0x1b17(%rip),%xmm6
movdqa 0x1aff(%rip),%xmm5
movdqa 0x1ae7(%rip),%xmm4
movdqa 0x1acf(%rip),%xmm3
mov    -0x90(%rbp),%r8
mov    -0x50(%rbp),%rdi
add    $0x1,%r13
mov    0x18(%rbp),%rax
movslq (%rax),%rcx
add    %r11,-0x88(%rbp)
add    %r11,-0x48(%rbp)
add    %r11,-0x78(%rbp)
add    %r11,-0x98(%rbp)
mov    -0xd8(%rbp),%rax
add    %rax,-0xa0(%rbp)
add    %rax,%r9
addq   $0x8,-0xb0(%rbp)
08
mov    %rcx,%rax
mov    %rcx,-0x40(%rbp)
cmp    %rcx,%r13
movapd -0x140(%rbp),%xmm1
ff
movapd -0x1c0(%rbp),%xmm0
ff
jge    2010 <cost_matrix+0xed0>
mov    0x30(%rbp),%rax
mov    (%rax),%eax
cmp    $0x2,%eax
mov    %r9,-0x60(%rbp)
je     1640 <cost_matrix+0x500>
cmp    $0x1,%eax
je     1610 <cost_matrix+0x4d0>
test   %eax,%eax
jne    1ec2 <cost_matrix+0xd82>
test   %r11d,%r11d
jle    14fd <cost_matrix+0x3bd>
cmp    $0x4,%r11d
jae    1808 <cost_matrix+0x6c8>
xor    %eax,%eax
jmp    1940 <cost_matrix+0x800>
nopl   0x0(%rax)
cmp    $0x1,%r11d
jne    16ab <cost_matrix+0x56b>
mov    %r13,%rax
imul   %r11,%rax
movabs $0x3ff0000000000000,%rcx
mov    -0x70(%rbp),%rdx
mov    %rcx,(%rdx,%rax,8)
jmp    1ec2 <cost_matrix+0xd82>
nopl   0x0(%rax,%rax,1)
mov    %rsp,-0x1a8(%rbp)
mov    -0x40(%rbp),%eax
imul   %r11,%rax
lea    0xf(,%rax,4),%rax
and    $0xfffffffffffffff0,%rax
mov    %rsp,%rdi
sub    %rax,%rdi
mov    %rdi,%rsp
mov    0x18(%rbp),%rax
mov    (%rax),%r9d
mov    %r9,%rcx
imul   %r11,%rcx
lea    0xf(,%rcx,4),%rcx
and    $0xfffffffffffffff0,%rcx
mov    %rsp,%rax
sub    %rcx,%rax
mov    %rax,-0x38(%rbp)
mov    %rax,%rsp
mov    %r13,%rbx
imul   %r11,%rbx
test   %r11d,%r11d
jle    1a5c <cost_matrix+0x91c>
cmp    $0x8,%r11d
jae    1820 <cost_matrix+0x6e0>
xor    %ecx,%ecx
jmp    1a3f <cost_matrix+0x8ff>
xorpd  %xmm2,%xmm2
test   %r11d,%r11d
jle    1510 <cost_matrix+0x3d0>
movslq -0x40(%rbp),%rdx
test   %r12,%r12
je     1cf0 <cost_matrix+0xbb0>
mov    -0x108(%rbp),%rax
imul   %rdx,%rax
mov    -0xb0(%rbp),%rcx
lea    (%rcx,%rax,8),%r9
mov    %rdx,%rdi
shl    $0x4,%rdi
mov    -0xa8(%rbp),%rax
mov    %rdx,-0x30(%rbp)
imul   %rdx,%rax
mov    %rbx,%r8
lea    (%rcx,%rax,8),%rbx
xor    %eax,%eax
xor    %ecx,%ecx
movsd  0x190c(%rip),%xmm0
xor    %esi,%esi
cs nopw 0x0(%rax,%rax,1)
movsd  (%rbx,%rax,1),%xmm1
ucomisd %xmm0,%xmm1
mov    %esi,%edx
cmova  %ecx,%edx
maxsd  %xmm0,%xmm1
movsd  (%r9,%rax,1),%xmm0
ucomisd %xmm1,%xmm0
lea    0x1(%rcx),%esi
cmovbe %edx,%esi
maxsd  %xmm1,%xmm0
add    $0x2,%rcx
add    %rdi,%rax
cmp    %r8,%rcx
jne    1710 <cost_matrix+0x5d0>
mov    %r8,%rbx
mov    -0x60(%rbp),%r9
mov    -0x30(%rbp),%rdx
test   $0x1,%r11b
je     1771 <cost_matrix+0x631>
mov    -0xa8(%rbp),%rax
add    %rcx,%rax
imul   %rdx,%rax
add    %r13,%rax
movsd  (%r14,%rax,8),%xmm1
ucomisd %xmm0,%xmm1
cmova  %ecx,%esi
test   %r11d,%r11d
mov    -0x50(%rbp),%rdi
mov    -0x90(%rbp),%r8
jle    1510 <cost_matrix+0x3d0>
mov    %r13,%rax
imul   %r11,%rax
mov    -0x70(%rbp),%rcx
lea    (%rcx,%rax,8),%rax
mov    %esi,%ecx
test   %r12,%r12
je     1fb9 <cost_matrix+0xe79>
mov    0x40(%rbp),%rdx
movsd  (%rdx),%xmm0
movsd  0x1859(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
xor    %esi,%esi
jmp    17d2 <cost_matrix+0x692>
nop
movsd  %xmm0,(%rax,%rcx,8)
add    $0x1,%rsi
cmp    %rbx,%rsi
je     1cdd <cost_matrix+0xb9d>
mov    %rsi,%rdx
cmp    %rsi,%rcx
jne    17f0 <cost_matrix+0x6b0>
movsd  %xmm0,(%rax,%rcx,8)
jmp    17f6 <cost_matrix+0x6b6>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
movsd  %xmm1,(%r9,%rdx,8)
lea    0x1(%rdx),%rsi
cmp    %rcx,%rsi
je     17c0 <cost_matrix+0x680>
movsd  %xmm1,0x8(%r9,%rdx,8)
jmp    17c5 <cost_matrix+0x685>
cmpq   $0x1c,-0x190(%rbp)
1c
jae    1844 <cost_matrix+0x704>
xor    %eax,%eax
mov    -0x110(%rbp),%rdx
jmp    18f5 <cost_matrix+0x7b5>
cmpq   $0x18,-0x198(%rbp)
18
jae    1954 <cost_matrix+0x814>
xor    %ecx,%ecx
movdqa 0x17f8(%rip),%xmm0
mov    -0x118(%rbp),%rax
jmp    19f8 <cost_matrix+0x8b8>
mov    -0x160(%rbp),%rcx
xor    %eax,%eax
mov    -0x110(%rbp),%rdx
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
movupd %xmm0,(%r9,%rax,8)
movupd %xmm0,0x10(%r9,%rax,8)
movupd %xmm0,0x20(%r9,%rax,8)
movupd %xmm0,0x30(%r9,%rax,8)
movupd %xmm0,0x40(%r9,%rax,8)
movupd %xmm0,0x50(%r9,%rax,8)
movupd %xmm0,0x60(%r9,%rax,8)
movupd %xmm0,0x70(%r9,%rax,8)
movupd %xmm0,0x80(%r9,%rax,8)
movupd %xmm0,0x90(%r9,%rax,8)
movupd %xmm0,0xa0(%r9,%rax,8)
movupd %xmm0,0xb0(%r9,%rax,8)
movupd %xmm0,0xc0(%r9,%rax,8)
movupd %xmm0,0xd0(%r9,%rax,8)
movupd %xmm0,0xe0(%r9,%rax,8)
movupd %xmm0,0xf0(%r9,%rax,8)
add    $0x20,%rax
add    $0xfffffffffffffff8,%rcx
jne    1860 <cost_matrix+0x720>
cmpq   $0x0,-0x180(%rbp)
je     1924 <cost_matrix+0x7e4>
lea    (%r9,%rax,8),%rax
xor    %ecx,%ecx
cs nopw 0x0(%rax,%rax,1)
nop
movupd %xmm0,(%rax,%rcx,1)
movupd %xmm0,0x10(%rax,%rcx,1)
add    $0x20,%rcx
cmp    %rcx,%rdx
jne    1910 <cost_matrix+0x7d0>
mov    -0xc0(%rbp),%rcx
mov    %rcx,%rax
cmp    %r11,%rcx
je     1ec2 <cost_matrix+0xd82>
nopw   0x0(%rax,%rax,1)
movsd  %xmm1,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1940 <cost_matrix+0x800>
jmp    1ec2 <cost_matrix+0xd82>
mov    -0x88(%rbp),%rax
lea    (%rdi,%rax,4),%rdx
mov    -0x168(%rbp),%rsi
xor    %ecx,%ecx
movdqa 0x16c0(%rip),%xmm0
mov    -0x118(%rbp),%rax
nopw   0x0(%rax,%rax,1)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,-0x70(%rdx,%rcx,4)
movdqu %xmm1,-0x60(%rdx,%rcx,4)
movdqa %xmm0,%xmm1
paddd  %xmm4,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm5,%xmm2
movdqu %xmm1,-0x50(%rdx,%rcx,4)
movdqu %xmm2,-0x40(%rdx,%rcx,4)
movdqa %xmm0,%xmm1
paddd  %xmm6,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm7,%xmm2
movdqu %xmm1,-0x30(%rdx,%rcx,4)
movdqu %xmm2,-0x20(%rdx,%rcx,4)
movdqa %xmm0,%xmm1
paddd  %xmm8,%xmm1
movdqa %xmm0,%xmm2
paddd  %xmm9,%xmm2
movdqu %xmm1,-0x10(%rdx,%rcx,4)
movdqu %xmm2,(%rdx,%rcx,4)
add    $0x20,%rcx
paddd  %xmm10,%xmm0
add    $0xfffffffffffffffc,%rsi
jne    1980 <cost_matrix+0x840>
cmpq   $0x0,-0x188(%rbp)
je     1a30 <cost_matrix+0x8f0>
add    -0x48(%rbp),%rcx
lea    (%rdi,%rcx,4),%rcx
xor    %edx,%edx
nopl   0x0(%rax)
movdqa %xmm0,%xmm1
paddd  %xmm3,%xmm1
movdqu %xmm0,(%rcx,%rdx,1)
movdqu %xmm1,0x10(%rcx,%rdx,1)
paddd  %xmm4,%xmm0
add    $0x20,%rdx
cmp    %rdx,%rax
jne    1a10 <cost_matrix+0x8d0>
mov    -0x1a0(%rbp),%rax
mov    %rax,%rcx
cmp    %r11,%rax
je     1a5c <cost_matrix+0x91c>
mov    -0x48(%rbp),%rax
lea    (%rdi,%rax,4),%rdx
nopw   0x0(%rax,%rax,1)
mov    %ecx,(%rdx,%rcx,4)
add    $0x1,%rcx
cmp    %rcx,%r11
jne    1a50 <cost_matrix+0x910>
mov    %rdi,-0x40(%rbp)
mov    %rbx,-0x120(%rbp)
lea    (%rdi,%rbx,4),%rax
mov    %rax,-0x30(%rbp)
cmp    $0x2,%r11d
jl     1b00 <cost_matrix+0x9c0>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
lea    (%rcx,%rax,4),%rcx
jmp    1aa0 <cost_matrix+0x960>
nopw   0x0(%rax,%rax,1)
test   %r8d,%r8d
sete   %al
or     -0xe8(%rbp),%al
cmp    $0x1,%al
je     1b00 <cost_matrix+0x9c0>
mov    -0x30(%rbp),%rax
mov    (%rax),%ebx
xor    %r8d,%r8d
mov    $0x1,%esi
jmp    1ac6 <cost_matrix+0x986>
mov    %ebx,(%rcx,%rsi,4)
mov    %edx,-0x4(%rcx,%rsi,4)
mov    $0x1,%r8d
add    $0x1,%rsi
cmp    %rsi,%r11
je     1a90 <cost_matrix+0x950>
mov    (%rcx,%rsi,4),%edx
lea    (%rdx,%r10,1),%edi
imul   %r9d,%edi
movslq %edi,%rdi
add    %r13,%rdi
lea    (%rbx,%r10,1),%eax
imul   %r9d,%eax
cltq
add    %r13,%rax
movsd  (%r14,%rax,8),%xmm0
ucomisd (%r14,%rdi,8),%xmm0
ja     1ab0 <cost_matrix+0x970>
mov    %edx,%ebx
jmp    1abd <cost_matrix+0x97d>
cs nopw 0x0(%rax,%rax,1)
test   %r11d,%r11d
mov    -0x80(%rbp),%rbx
mov    -0x60(%rbp),%r9
jle    1eb0 <cost_matrix+0xd70>
mov    -0x120(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rsi
cmp    $0x3,%r12
jae    1b31 <cost_matrix+0x9f1>
xor    %eax,%eax
mov    -0xb8(%rbp),%r8
jmp    1b81 <cost_matrix+0xa41>
mov    -0x78(%rbp),%rax
mov    -0x40(%rbp),%rcx
lea    (%rcx,%rax,4),%rcx
xor    %eax,%eax
mov    -0xc0(%rbp),%rbx
mov    -0xb8(%rbp),%r8
nopl   (%rax)
movslq -0xc(%rcx,%rax,4),%rdx
lea    0x1(%rax),%edi
mov    %edi,(%rsi,%rdx,4)
movslq -0x8(%rcx,%rax,4),%rdx
lea    0x2(%rax),%edi
mov    %edi,(%rsi,%rdx,4)
movslq -0x4(%rcx,%rax,4),%rdx
lea    0x3(%rax),%edi
mov    %edi,(%rsi,%rdx,4)
movslq (%rcx,%rax,4),%rdx
add    $0x4,%rax
mov    %eax,(%rsi,%rdx,4)
cmp    %rax,%rbx
jne    1b50 <cost_matrix+0xa10>
test   %r8,%r8
je     1bb3 <cost_matrix+0xa73>
mov    -0x48(%rbp),%rcx
add    %rax,%rcx
mov    -0x40(%rbp),%rdx
lea    (%rdx,%rcx,4),%rcx
add    $0x1,%eax
xor    %edx,%edx
nopw   0x0(%rax,%rax,1)
movslq (%rcx,%rdx,4),%rdi
lea    (%rax,%rdx,1),%ebx
mov    %ebx,(%rsi,%rdi,4)
add    $0x1,%rdx
cmp    %rdx,%r8
jne    1ba0 <cost_matrix+0xa60>
mov    0x38(%rbp),%rax
movsd  (%rax),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1c09 <cost_matrix+0xac9>
test   %r11d,%r11d
mov    -0x80(%rbp),%rbx
jle    1eb0 <cost_matrix+0xd70>
mov    -0x30(%rbp),%rdi
mov    -0x170(%rbp),%rdx
call   1050 <memcpy@plt>
mov    -0x68(%rbp),%r11
cmp    $0x3,%r12
mov    -0xc0(%rbp),%rdx
mov    -0xb8(%rbp),%rsi
jae    1d0b <cost_matrix+0xbcb>
xorpd  %xmm0,%xmm0
xor    %eax,%eax
jmp    1d5c <cost_matrix+0xc1c>
test   %r11d,%r11d
mov    -0x80(%rbp),%rbx
jle    1eb0 <cost_matrix+0xd70>
mov    -0x48(%rbp),%rax
mov    -0x40(%rbp),%rcx
lea    (%rcx,%rax,4),%r14
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%r15
xorpd  %xmm0,%xmm0
xor    %ebx,%ebx
movsd  %xmm0,-0x38(%rbp)
xorps  %xmm0,%xmm0
cvtsi2sdl (%r15,%rbx,4),%xmm0
divsd  -0xe0(%rbp),%xmm0
ff
mulsd  %xmm1,%xmm0
call   1060 <exp@plt>
cvttsd2si %xmm0,%eax
mov    %eax,(%r14,%rbx,4)
cvttpd2dq %xmm0,%xmm0
cvtdq2pd %xmm0,%xmm0
addsd  -0x38(%rbp),%xmm0
cmp    %rbx,%r12
je     1c77 <cost_matrix+0xb37>
mov    0x38(%rbp),%rax
movsd  (%rax),%xmm1
add    $0x1,%rbx
jmp    1c30 <cost_matrix+0xaf0>
mov    -0xc8(%rbp),%r15
mov    -0xd0(%rbp),%r14
movdqa 0x13b3(%rip),%xmm3
movdqa 0x13bb(%rip),%xmm4
movdqa 0x13c3(%rip),%xmm5
movdqa 0x13cb(%rip),%xmm6
movdqa 0x13d3(%rip),%xmm7
movdqa 0x13da(%rip),%xmm8
movdqa 0x13e1(%rip),%xmm9
movdqa 0x13e8(%rip),%xmm10
mov    -0x58(%rbp),%r10
mov    -0x68(%rbp),%r11
mov    -0x80(%rbp),%rbx
mov    -0x60(%rbp),%r9
jmp    1dd5 <cost_matrix+0xc95>
add    $0x2,%rdx
test   $0x1,%r11b
je     1ec2 <cost_matrix+0xd82>
jmp    1fc5 <cost_matrix+0xe85>
xor    %ecx,%ecx
movsd  0x1316(%rip),%xmm0
xor    %esi,%esi
test   $0x1,%r11b
jne    1753 <cost_matrix+0x613>
jmp    1771 <cost_matrix+0x631>
mov    -0x78(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rcx
xorpd  %xmm0,%xmm0
xor    %eax,%eax
nopl   (%rax)
xorps  %xmm1,%xmm1
cvtsi2sdl -0xc(%rcx,%rax,4),%xmm1
addsd  %xmm0,%xmm1
xorps  %xmm2,%xmm2
cvtsi2sdl -0x8(%rcx,%rax,4),%xmm2
addsd  %xmm1,%xmm2
xorps  %xmm1,%xmm1
cvtsi2sdl -0x4(%rcx,%rax,4),%xmm1
xorps  %xmm0,%xmm0
cvtsi2sdl (%rcx,%rax,4),%xmm0
addsd  %xmm2,%xmm1
addsd  %xmm1,%xmm0
add    $0x4,%rax
cmp    %rax,%rdx
jne    1d20 <cost_matrix+0xbe0>
test   $0x3,%r11b
movdqa 0x12d8(%rip),%xmm3
movdqa 0x12e0(%rip),%xmm4
movdqa 0x12e8(%rip),%xmm5
movdqa 0x12f0(%rip),%xmm6
movdqa 0x12f8(%rip),%xmm7
movdqa 0x12ff(%rip),%xmm8
movdqa 0x1306(%rip),%xmm9
movdqa 0x130d(%rip),%xmm10
mov    -0x58(%rbp),%r10
mov    -0x60(%rbp),%r9
je     1dd5 <cost_matrix+0xc95>
add    -0x48(%rbp),%rax
mov    -0x38(%rbp),%rcx
lea    (%rcx,%rax,4),%rax
xor    %ecx,%ecx
nopl   0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rax,%rcx,4),%xmm1
addsd  %xmm1,%xmm0
add    $0x1,%rcx
cmp    %rcx,%rsi
jne    1dc0 <cost_matrix+0xc80>
test   %r11d,%r11d
jle    1eb0 <cost_matrix+0xd70>
cmp    $0x1,%r11d
jne    1deb <cost_matrix+0xcab>
xor    %eax,%eax
jmp    1e7a <cost_matrix+0xd3a>
movapd %xmm0,%xmm1
unpcklpd %xmm0,%xmm1
cmpq   $0x0,-0x158(%rbp)
je     1ffa <cost_matrix+0xeba>
mov    -0x98(%rbp),%rax
mov    -0x40(%rbp),%rcx
lea    (%rcx,%rax,4),%rcx
mov    -0x148(%rbp),%rdx
xor    %eax,%eax
mov    -0xa0(%rbp),%rsi
cvtdq2pd -0x8(%rcx,%rax,4),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,-0x10(%rsi,%rax,8)
cvtdq2pd (%rcx,%rax,4),%xmm2
divpd  %xmm1,%xmm2
movupd %xmm2,(%rsi,%rax,8)
add    $0x4,%rax
add    $0xfffffffffffffffe,%rdx
jne    1e20 <cost_matrix+0xce0>
testb  $0x1,-0x150(%rbp)
je     1e72 <cost_matrix+0xd32>
mov    -0x30(%rbp),%rcx
cvtdq2pd (%rcx,%rax,4),%xmm2
mov    -0x70(%rbp),%rcx
mov    -0x120(%rbp),%rdx
lea    (%rcx,%rdx,8),%rcx
divpd  %xmm1,%xmm2
movupd %xmm2,(%rcx,%rax,8)
mov    %rbx,%rax
cmp    %r11,%rbx
je     1eb0 <cost_matrix+0xd70>
mov    -0x48(%rbp),%rcx
mov    -0x40(%rbp),%rdx
lea    (%rdx,%rcx,4),%rcx
cs nopw 0x0(%rax,%rax,1)
xorps  %xmm1,%xmm1
cvtsi2sdl (%rcx,%rax,4),%xmm1
divsd  %xmm0,%xmm1
movsd  %xmm1,(%r9,%rax,8)
add    $0x1,%rax
cmp    %rax,%r11
jne    1e90 <cost_matrix+0xd50>
nopl   0x0(%rax,%rax,1)
mov    -0x1a8(%rbp),%rsp
mov    -0x50(%rbp),%rdi
mov    -0x90(%rbp),%r8
xorpd  %xmm2,%xmm2
test   %r11d,%r11d
jle    1510 <cost_matrix+0x3d0>
xor    %ebx,%ebx
jmp    1ef1 <cost_matrix+0xdb1>
cs nopw 0x0(%rax,%rax,1)
nopl   (%rax)
addsd  %xmm1,%xmm2
add    $0x1,%rbx
cmp    %rbx,%r11
je     1f90 <cost_matrix+0xe50>
movsd  (%r9,%rbx,8),%xmm1
xorpd  %xmm0,%xmm0
ucomisd %xmm1,%xmm0
jbe    1ee0 <cost_matrix+0xda0>
lea    0x11b8(%rip),%rdi
movapd %xmm1,%xmm0
mov    $0x1,%al
movsd  %xmm2,-0x30(%rbp)
movsd  %xmm1,-0x38(%rbp)
call   1030 <printf@plt>
movsd  -0x38(%rbp),%xmm1
movsd  -0x30(%rbp),%xmm2
mov    -0x60(%rbp),%r9
mov    -0x68(%rbp),%r11
mov    -0x58(%rbp),%r10
movdqa 0x1174(%rip),%xmm10
movdqa 0x115b(%rip),%xmm9
movdqa 0x1142(%rip),%xmm8
movdqa 0x112a(%rip),%xmm7
movdqa 0x1112(%rip),%xmm6
movdqa 0x10fa(%rip),%xmm5
movdqa 0x10e2(%rip),%xmm4
movdqa 0x10ca(%rip),%xmm3
mov    -0x90(%rbp),%r8
mov    -0x50(%rbp),%rdi
jmp    1ee0 <cost_matrix+0xda0>
cs nopw 0x0(%rax,%rax,1)
movsd  0x1080(%rip),%xmm0
ucomisd %xmm2,%xmm0
mov    -0x80(%rbp),%rbx
ja     1510 <cost_matrix+0x3d0>
ucomisd 0x1072(%rip),%xmm2
jbe    157c <cost_matrix+0x43c>
jmp    1510 <cost_matrix+0x3d0>
xor    %edx,%edx
test   $0x1,%r11b
je     1ec2 <cost_matrix+0xd82>
mov    0x40(%rbp),%rsi
movsd  (%rsi),%xmm0
cmp    %rcx,%rdx
jne    1fdc <cost_matrix+0xe9c>
movsd  %xmm0,(%rax,%rcx,8)
jmp    1ec2 <cost_matrix+0xd82>
movsd  0x1024(%rip),%xmm1
subsd  %xmm0,%xmm1
mulsd  -0x100(%rbp),%xmm1
ff
movsd  %xmm1,(%rax,%rdx,8)
jmp    1ec2 <cost_matrix+0xd82>
xor    %eax,%eax
testb  $0x1,-0x150(%rbp)
jne    1e51 <cost_matrix+0xd11>
jmp    1e72 <cost_matrix+0xd32>
xchg   %ax,%ax
cmpl   $0x0,-0x40(%rbp)
jle    2310 <cost_matrix+0x11d0>
mov    -0x40(%rbp),%ecx
movslq %r11d,%rax
mov    %rax,-0xe0(%rbp)
mov    0x28(%rbp),%rax
mov    (%rax),%eax
mov    %eax,-0xb0(%rbp)
mov    -0xa8(%rbp),%rdx
imul   %rcx,%rdx
mov    -0x128(%rbp),%rax
mov    %rdx,-0xa0(%rbp)
lea    (%rax,%rdx,8),%rsi
mov    -0x108(%rbp),%rdx
imul   %rcx,%rdx
mov    -0xf0(%rbp),%rax
lea    (%rax,%rdx,4),%rax
mov    %rax,-0x140(%rbp)
lea    0x0(,%rcx,4),%r9
mov    -0x70(%rbp),%rdx
mov    %rsi,-0x98(%rbp)
xor    %ebx,%ebx
jmp    20b3 <cost_matrix+0xf73>
cs nopw 0x0(%rax,%rax,1)
xchg   %ax,%ax
mov    -0x30(%rbp),%rbx
add    $0x1,%rbx
mov    -0x88(%rbp),%rsi
add    $0x8,%rsi
add    -0xd8(%rbp),%rdx
cmp    %rcx,%rbx
je     2310 <cost_matrix+0x11d0>
mov    %rsi,-0x88(%rbp)
mov    %rbx,%rax
imul   %r11,%rax
mov    -0x70(%rbp),%r10
lea    (%r10,%rax,8),%rax
mov    %rax,-0xe8(%rbp)
mov    %rbx,-0x30(%rbp)
imul   %rcx,%rbx
mov    %rbx,-0x78(%rbp)
mov    -0x140(%rbp),%rax
mov    %rax,-0x38(%rbp)
mov    -0x98(%rbp),%r13
xor    %eax,%eax
mov    %rdx,-0x48(%rbp)
jmp    214b <cost_matrix+0x100b>
xorpd  %xmm0,%xmm0
mov    -0xc8(%rbp),%r15
mov    -0x90(%rbp),%r8
mulsd  (%r15,%r8,8),%xmm0
mov    -0x78(%rbp),%rdx
add    %rax,%rdx
mov    -0x50(%rbp),%rdi
addsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
mov    -0xd0(%rbp),%r14
mov    -0x48(%rbp),%rdx
add    $0x1,%rax
add    $0x8,%r13
add    -0xd8(%rbp),%r10
addq   $0x4,-0x38(%rbp)
cmp    %rcx,%rax
je     2090 <cost_matrix+0xf50>
cmpl   $0x0,-0xb0(%rbp)
je     21d0 <cost_matrix+0x1090>
test   %r11d,%r11d
jle    22e0 <cost_matrix+0x11a0>
mov    %r14,%rdi
mov    %r8,%r14
mov    %r15,%r8
xorpd  %xmm2,%xmm2
xor    %ebx,%ebx
xor    %esi,%esi
mov    -0x88(%rbp),%r15
cs nopw 0x0(%rax,%rax,1)
nop
movapd %xmm2,%xmm1
movsd  (%r10,%rsi,8),%xmm2
movhpd (%rdx,%rsi,8),%xmm2
movsd  0x0(%r13,%rbx,8),%xmm0
movhpd (%r15,%rbx,8),%xmm0
mulpd  %xmm2,%xmm0
movapd %xmm0,%xmm2
addpd  %xmm1,%xmm2
add    $0x1,%rsi
add    %rcx,%rbx
cmp    %rsi,%r11
jne    2180 <cost_matrix+0x1040>
addpd  %xmm1,%xmm0
mov    %r8,%r15
mov    %r14,%r8
mov    %rdi,%r14
mov    -0x50(%rbp),%rdi
jmp    22e4 <cost_matrix+0x11a4>
nopw   0x0(%rax,%rax,1)
test   %r11d,%r11d
jle    20f6 <cost_matrix+0xfb6>
mov    %rax,%rdx
imul   %r11,%rdx
mov    -0x70(%rbp),%rsi
lea    (%rsi,%rdx,8),%rdx
mov    %rdx,-0x60(%rbp)
mov    -0xa0(%rbp),%rdx
add    %rax,%rdx
mov    -0xf0(%rbp),%rsi
mov    (%rsi,%rdx,4),%r15d
xorpd  %xmm0,%xmm0
xor    %r8d,%r8d
mov    -0xa8(%rbp),%rdi
jmp    2231 <cost_matrix+0x10f1>
cs nopw 0x0(%rax,%rax,1)
nopl   0x0(%rax,%rax,1)
mov    -0x68(%rbp),%r11
add    $0x1,%r8
cmp    %r11,%r8
je     20fa <cost_matrix+0xfba>
lea    (%r8,%rdi,1),%r14
imul   %rcx,%r14
add    -0x30(%rbp),%r14
mov    -0xf0(%rbp),%rdx
mov    (%rdx,%r14,4),%esi
cmp    %esi,%r15d
jne    2260 <cost_matrix+0x1120>
mov    $0x1,%dl
xor    %ebx,%ebx
test   %dl,%dl
je     2224 <cost_matrix+0x10e4>
jmp    2297 <cost_matrix+0x1157>
nopw   0x0(%rax,%rax,1)
mov    -0x38(%rbp),%r11
xor    %ebx,%ebx
cs nopw 0x0(%rax,%rax,1)
cmp    %rbx,%r12
je     2220 <cost_matrix+0x10e0>
lea    (%r11,%r9,1),%rdx
add    $0x1,%rbx
cmp    %esi,(%r11)
mov    %rdx,%r11
jne    2270 <cost_matrix+0x1130>
cmp    -0xe0(%rbp),%rbx
setl   %dl
mov    -0x68(%rbp),%r11
test   %dl,%dl
je     2224 <cost_matrix+0x10e4>
mov    %ebx,%edx
mov    -0x60(%rbp),%rsi
movsd  (%rsi,%rdx,8),%xmm1
mov    -0xe8(%rbp),%rdx
mulsd  (%rdx,%r8,8),%xmm1
add    -0x58(%rbp),%ebx
imul   -0x40(%rbp),%ebx
movslq %ebx,%rdx
add    %rax,%rdx
mov    -0x128(%rbp),%rsi
mulsd  (%rsi,%rdx,8),%xmm1
mulsd  (%rsi,%r14,8),%xmm1
addsd  %xmm1,%xmm0
jmp    2224 <cost_matrix+0x10e4>
nopw   0x0(%rax,%rax,1)
xorpd  %xmm0,%xmm0
movsd  (%r15,%r8,8),%xmm1
mulsd  %xmm0,%xmm1
mov    -0x78(%rbp),%rdx
add    %rax,%rdx
unpckhpd %xmm0,%xmm0
mulsd  %xmm1,%xmm0
addsd  (%rdi,%rdx,8),%xmm0
movsd  %xmm0,(%rdi,%rdx,8)
jmp    212a <cost_matrix+0xfea>
nopl   0x0(%rax)
mov    -0x178(%rbp),%rsp
lea    0x1(%r8),%rax
mov    0x20(%rbp),%rcx
movslq (%rcx),%rcx
cmp    %rcx,%rax
mov    0x18(%rbp),%r13
jge    234a <cost_matrix+0x120a>
mov    -0xf8(%rbp),%rcx
mov    -0x58(%rbp),%rdx
add    (%rcx,%r8,4),%edx
mov    %rdx,-0x58(%rbp)
mov    0x0(%r13),%edx
mov    %rax,%r8
jmp    1300 <cost_matrix+0x1c0>
lea    -0x28(%rbp),%rsp
pop    %rbx
pop    %r12
pop    %r13
pop    %r14
pop    %r15
pop    %rbp
ret

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

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